From 470f642024f42dc141fee27be6e46f7f0c620714 Mon Sep 17 00:00:00 2001 From: Marius Gavrilescu Date: Sun, 10 Apr 2016 01:42:19 +0300 Subject: [PATCH] Initial commit --- COPYING | 661 +++ Changes | 4 + MANIFEST | 12 + Makefile.PL | 23 + OpenALPR.xs | 42 + README | 45 + lib/Image/OpenALPR.pm | 153 + lib/Image/OpenALPR/PlateResult.pm | 100 + ppport.h | 7748 +++++++++++++++++++++++++++++ t/Image-OpenALPR.t | 15 + t/ex.jpg | Bin 0 -> 76543 bytes typemap | 8 + 12 files changed, 8811 insertions(+) create mode 100644 COPYING create mode 100644 Changes create mode 100644 MANIFEST create mode 100644 Makefile.PL create mode 100644 OpenALPR.xs create mode 100644 README create mode 100644 lib/Image/OpenALPR.pm create mode 100644 lib/Image/OpenALPR/PlateResult.pm create mode 100644 ppport.h create mode 100644 t/Image-OpenALPR.t create mode 100644 t/ex.jpg create mode 100644 typemap diff --git a/COPYING b/COPYING new file mode 100644 index 0000000..dba13ed --- /dev/null +++ b/COPYING @@ -0,0 +1,661 @@ + GNU AFFERO GENERAL PUBLIC LICENSE + Version 3, 19 November 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU Affero General Public License is a free, copyleft license for +software and other kinds of works, specifically designed to ensure +cooperation with the community in the case of network server software. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +our General Public Licenses are intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + Developers that use our General Public Licenses protect your rights +with two steps: (1) assert copyright on the software, and (2) offer +you this License which gives you legal permission to copy, distribute +and/or modify the software. + + A secondary benefit of defending all users' freedom is that +improvements made in alternate versions of the program, if they +receive widespread use, become available for other developers to +incorporate. Many developers of free software are heartened and +encouraged by the resulting cooperation. However, in the case of +software used on network servers, this result may fail to come about. +The GNU General Public License permits making a modified version and +letting the public access it on a server without ever releasing its +source code to the public. + + The GNU Affero General Public License is designed specifically to +ensure that, in such cases, the modified source code becomes available +to the community. It requires the operator of a network server to +provide the source code of the modified version running there to the +users of that server. Therefore, public use of a modified version, on +a publicly accessible server, gives the public access to the source +code of the modified version. + + An older license, called the Affero General Public License and +published by Affero, was designed to accomplish similar goals. This is +a different license, not a version of the Affero GPL, but Affero has +released a new version of the Affero GPL which permits relicensing under +this license. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU Affero General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Remote Network Interaction; Use with the GNU General Public License. + + Notwithstanding any other provision of this License, if you modify the +Program, your modified version must prominently offer all users +interacting with it remotely through a computer network (if your version +supports such interaction) an opportunity to receive the Corresponding +Source of your version by providing access to the Corresponding Source +from a network server at no charge, through some standard or customary +means of facilitating copying of software. This Corresponding Source +shall include the Corresponding Source for any work covered by version 3 +of the GNU General Public License that is incorporated pursuant to the +following paragraph. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the work with which it is combined will remain governed by version +3 of the GNU General Public License. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU Affero General Public License from time to time. Such new versions +will be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU Affero General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU Affero General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU Affero General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If your software can interact with users remotely through a computer +network, you should also make sure that it provides a way for users to +get its source. For example, if your program is a web application, its +interface could display a "Source" link that leads users to an archive +of the code. There are many ways you could offer source, and different +solutions will be better for different programs; see section 13 for the +specific requirements. + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU AGPL, see +. diff --git a/Changes b/Changes new file mode 100644 index 0000000..da0d8fa --- /dev/null +++ b/Changes @@ -0,0 +1,4 @@ +Revision history for Perl extension Image::OpenALPR. + +0.001 2016-04-10T01:42+03:00 + - Initial release \ No newline at end of file diff --git a/MANIFEST b/MANIFEST new file mode 100644 index 0000000..e85d7ff --- /dev/null +++ b/MANIFEST @@ -0,0 +1,12 @@ +Changes +COPYING +lib/Image/OpenALPR.pm +lib/Image/OpenALPR/PlateResult.pm +Makefile.PL +MANIFEST +OpenALPR.xs +ppport.h +README +t/ex.jpg +t/Image-OpenALPR.t +typemap diff --git a/Makefile.PL b/Makefile.PL new file mode 100644 index 0000000..3abc42e --- /dev/null +++ b/Makefile.PL @@ -0,0 +1,23 @@ +use 5.014000; +use ExtUtils::MakeMaker; + +WriteMakefile( + NAME => 'Image::OpenALPR', + VERSION_FROM => 'lib/Image/OpenALPR.pm', + ABSTRACT_FROM => 'lib/Image/OpenALPR.pm', + AUTHOR => 'Marius Gavrilescu ', + MIN_PERL_VERSION => '5.14.0', + LICENSE => 'open_source', + SIGN => 1, + PREREQ_PM => { + qw/Class::Accessor::Fast 0 + JSON::MaybeXS 0/, + }, + LIBS => ['-lopenalprpy'], + META_ADD => { + dynamic_config => 0, + resources => { + repository => 'https://git.ieval.ro/?p=image-openalpr.git', + }, + } +); diff --git a/OpenALPR.xs b/OpenALPR.xs new file mode 100644 index 0000000..310ab30 --- /dev/null +++ b/OpenALPR.xs @@ -0,0 +1,42 @@ +#define PERL_NO_GET_CONTEXT +#include "EXTERN.h" +#include "perl.h" +#include "XSUB.h" + +#include "ppport.h" + +struct Alpr; +typedef struct Alpr Alpr; +typedef char fchar; + +extern Alpr* initialize(char*, char*, char*); +extern void dispose(Alpr*); +extern bool isLoaded(Alpr*); +extern char* recognizeFile(Alpr*, char*); +extern char* recognizeArray(Alpr*, char*, int); +extern void setCountry(Alpr*, char*); +extern void setPrewarp(Alpr*, char*); +extern void setDefaultRegion(Alpr*, char*); +extern void setTopN(Alpr*, int); +extern char* getVersion(Alpr*); +extern void freeJsonMem(char*); + +MODULE = Image::OpenALPR PACKAGE = Image::OpenALPR +PROTOTYPES: ENABLE + +Alpr* initialize(char* country, char* config_file = "", char* runtime_dir = "") + +void dispose(Alpr* alpr) + +bool isLoaded(Alpr* alpr) + +fchar* recognizeFile(Alpr* alpr, char* image_file) + +fchar* recognizeArray(Alpr* alpr, char* buf, int length(buf)) + +void setString(Alpr* alpr, char* value) + INTERFACE: setCountry setPrewarp setDefaultRegion + +void setTopN(Alpr* alpr, int top_n) + +fchar* getVersion(Alpr* alpr) diff --git a/README b/README new file mode 100644 index 0000000..b6ce4ff --- /dev/null +++ b/README @@ -0,0 +1,45 @@ +Image-OpenALPR version 0.001 +============================ + +OpenALPR is an automatic license plate recognition library that +extracts license plate numbers from images. + +Image-OpenALPR is a Perl binding to this library. + +INSTALLATION + +To install this module type the following: + + perl Makefile.PL + make + make test + make install + +DEPENDENCIES + +This module requires these other modules and libraries: + +* Class::Accessor::Fast +* JSON:::MaybeXS +* libopenalprpy.so from OpenALPR + +COPYRIGHT AND LICENCE + +Copyright (C) 2016 by Marius Gavrilescu + +This file is part of Image-OpenALPR. + +Image-OpenALPR is free software: you can redistribute it and/or modify +it under the terms of the GNU Affero General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +Image-OpenALPR is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Affero General Public License for more details. + +You should have received a copy of the GNU Affero General Public License +along with Image-OpenALPR. If not, see + + diff --git a/lib/Image/OpenALPR.pm b/lib/Image/OpenALPR.pm new file mode 100644 index 0000000..c75a365 --- /dev/null +++ b/lib/Image/OpenALPR.pm @@ -0,0 +1,153 @@ +package Image::OpenALPR; + +use 5.014000; +use strict; +use warnings; + +use Image::OpenALPR::PlateResult; +use JSON::MaybeXS qw/decode_json/; +use XSLoader; + +BEGIN { + our $VERSION = '0.001'; + XSLoader::load('Image::OpenALPR', $VERSION); + *initialise = \&initialize; + *is_loaded = \&isLoaded; + *get_version = \&getVersion; + *set_country = \&setCountry; + *set_prewarp = \&setPrewarp; + *set_default_region = \&setDefaultRegion; + *set_top_n = \&setTopN; +} + +sub new { + my $alpr = initialise (@_[1..$#_]); + die "Failed to load OpenALPR\n" unless $alpr->is_loaded; + $alpr +} + +sub recognise { + my ($alpr, $data) = @_; + my $json = ref $data eq 'SCALAR' ? $alpr->recognizeArray($$data) : $alpr->recognizeFile($data); + $json = decode_json $json; + my @plates = map { Image::OpenALPR::PlateResult->new($_) } @{$json->{results}}; + wantarray ? @plates : shift @plates +} + +sub DESTROY { shift->dispose } + +package AlprPtr; +our @ISA = qw/Image::OpenALPR/; + +1; +__END__ + +=encoding utf-8 + +=head1 NAME + +Image::OpenALPR - Perl binding for Automatic License Plate Recognition library + +=head1 SYNOPSIS + + use Image::OpenALPR; + my $alpr = Image::OpenALPR->new('eu'); + $alpr->get_version; # 2.2.4 + my (@plates) = $alpr->recognise('many_plates.jpg'); + say 'Plates found: ', join ' ', map { $_->plate } @plates; + + $alpr->set_top_n(2); + my $data = read_file 'one_plate.gif'; + my $a_plate = $alpr->recognise(\$data); + my @cnd = @{$a_plate->candidates}; + say $cnd[0]->plate, ' ', $cnd[0]->confidence; + say $cnd[1]->plate, ' ', $cnd[1]->confidence; + +=head1 DESCRIPTION + +OpenALPR is an automatic license plate recognition library that +extracts license plate numbers from images. + +The following methods are available: + +=over + +=item Image::OpenALPR->B(I<$country>, I<$config>, I<$runtime_data>) + +Takes one mandatory argument (the country rules to use, such as C +or C) and two optional arguments: a path to the configuration +file, and a path to the runtime_data directory. + +Returns a new Image::OpenALPR instance. If initialization fails (for +example, if the chosen country is not available) an exception is +thrown. + +=item $alpr->B(I<$file>) +=item $alpr->B(I<\$data>) + +Takes a path to an image file or a reference to the contents of an +image file and tries to find license plates in the image. In list +context, it returns a list of L objects, +one for each plate found. In scalar context it returns only one such +object (the first plate found), or undef if no plates were found. + +=item $alpr->B +=item $alpr->B + +Returns the version of the OpenALPR library. + +=item $alpr->B(I<$country>) +=item $alpr->B(I<$country>) + +Changes the country rules in use. + +=item $alpr->B(I<$prewarp>) +=item $alpr->B(I<$prewarp>) + +Sets the camera calibration values, as obtained from the +openalpr-utils-calibrate utility. Can also be set in the configuration +file. + +=item $alpr->B(I<$region>) +=item $alpr->B(I<$region>) + +Sets the expected region for pattern matching. This improves accuracy. +The B flag is set on plates that match this pattern. + +=item $alpr->B(I<$n>) +=item $alpr->B(I<$n>) + +Sets the maximum number of candidates to return for one plate. Default +is 10. + +=back + +=head1 SEE ALSO + +L, L + +=head1 AUTHOR + +Marius Gavrilescu, Emarius@ieval.roE + +=head1 COPYRIGHT AND LICENSE + +Copyright (C) 2016 by Marius Gavrilescu + +This file is part of Image-OpenALPR. + +Image-OpenALPR is free software: you can redistribute it and/or modify +it under the terms of the GNU Affero General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +Image-OpenALPR is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Affero General Public License for more details. + +You should have received a copy of the GNU Affero General Public License +along with Image-OpenALPR. If not, see + + +=cut diff --git a/lib/Image/OpenALPR/PlateResult.pm b/lib/Image/OpenALPR/PlateResult.pm new file mode 100644 index 0000000..6cf1651 --- /dev/null +++ b/lib/Image/OpenALPR/PlateResult.pm @@ -0,0 +1,100 @@ +package Image::OpenALPR::PlateResult; + +use 5.014000; +use strict; +use warnings; + +use parent qw/Class::Accessor::Fast/; + +our $VERSION = '0.001'; + +__PACKAGE__->mk_ro_accessors(qw/plate confidence matches_template/); + +sub coordinates { + my $coords = shift->{coordinates}; + return unless $coords; + my @result = map { [$_->{x}, $_->{y}] } @$coords; + wantarray ? @result : \@result +} + +sub candidates { + my $cands = shift->{candidates}; + return unless $cands; + my @result = map { __PACKAGE__->new($_) } @$cands; + wantarray ? @result : \@result +} + +1; +__END__ + +=encoding utf-8 + +=head1 NAME + +Image::OpenALPR::PlateResult - a license plate, as identified by OpenALPR + +=head1 SYNOPSIS + + my $plate = $alpr->recognise('t/example.jpg'); + say $plate->plate; # ZP36709 + say $plate->confidence; # 92.373634 + my @coords = $plate->coordinates; # [306, 351], [476, 351], [476, 384], [306, 384] + my @candidates = $plate->candidates; + say $candidates[1]->plate; # ZP367O9 + say $candidates[1]->confidence; # 89.812302 + +=head1 DESCRIPTION + +Image::OpenALPR::PlateResult is a class representing a plate identified by OpenALPR. It offers the following methods: + +=over + +=item B + +The plate number that has the highest confidence value (likelihood of being correct). + +=item B + +The confidence value of the plate number returned by B. + +=item B + +True if the plate matches the plate pattern chosen via the B in L, false otherwise (or if no region was chosen). +=item B + +In list context, returns a four element list representing the vertices of the license plate, numbered clock-wise from top-left. Each element is an arrayref with two elements: the X coordinate followed by the Y coordinate. + +In scalar context, returns an arrayref to an array containing the list described above. + + +=item B + +In list context, returns a list of candidate license numbers, in decreasing order of confidence. The first element coincides with the plate/confidence pair returned by the B and B methods. Each element is a partial Image::OpenALPR::PlateResult object -- only the B, B and B methods will return a meaningful value. + +=back + +=head1 AUTHOR + +Marius Gavrilescu, Emarius@ieval.roE + +=head1 COPYRIGHT AND LICENSE + +Copyright (C) 2016 by Marius Gavrilescu + +This file is part of Image-OpenALPR. + +Image-OpenALPR is free software: you can redistribute it and/or modify +it under the terms of the GNU Affero General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +Image-OpenALPR is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Affero General Public License for more details. + +You should have received a copy of the GNU Affero General Public License +along with Image-OpenALPR. If not, see + + +=cut diff --git a/ppport.h b/ppport.h new file mode 100644 index 0000000..17d0eea --- /dev/null +++ b/ppport.h @@ -0,0 +1,7748 @@ +#if 0 +<<'SKIP'; +#endif +/* +---------------------------------------------------------------------- + + ppport.h -- Perl/Pollution/Portability Version 3.31 + + Automatically created by Devel::PPPort running under perl 5.022001. + + Do NOT edit this file directly! -- Edit PPPort_pm.PL and the + includes in parts/inc/ instead. + + Use 'perldoc ppport.h' to view the documentation below. + +---------------------------------------------------------------------- + +SKIP + +=pod + +=head1 NAME + +ppport.h - Perl/Pollution/Portability version 3.31 + +=head1 SYNOPSIS + + perl ppport.h [options] [source files] + + Searches current directory for files if no [source files] are given + + --help show short help + + --version show version + + --patch=file write one patch file with changes + --copy=suffix write changed copies with suffix + --diff=program use diff program and options + + --compat-version=version provide compatibility with Perl version + --cplusplus accept C++ comments + + --quiet don't output anything except fatal errors + --nodiag don't show diagnostics + --nohints don't show hints + --nochanges don't suggest changes + --nofilter don't filter input files + + --strip strip all script and doc functionality from + ppport.h + + --list-provided list provided API + --list-unsupported list unsupported API + --api-info=name show Perl API portability information + +=head1 COMPATIBILITY + +This version of F is designed to support operation with Perl +installations back to 5.003, and has been tested up to 5.20. + +=head1 OPTIONS + +=head2 --help + +Display a brief usage summary. + +=head2 --version + +Display the version of F. + +=head2 --patch=I + +If this option is given, a single patch file will be created if +any changes are suggested. This requires a working diff program +to be installed on your system. + +=head2 --copy=I + +If this option is given, a copy of each file will be saved with +the given suffix that contains the suggested changes. This does +not require any external programs. Note that this does not +automagically add a dot between the original filename and the +suffix. If you want the dot, you have to include it in the option +argument. + +If neither C<--patch> or C<--copy> are given, the default is to +simply print the diffs for each file. This requires either +C or a C program to be installed. + +=head2 --diff=I + +Manually set the diff program and options to use. The default +is to use C, when installed, and output unified +context diffs. + +=head2 --compat-version=I + +Tell F to check for compatibility with the given +Perl version. The default is to check for compatibility with Perl +version 5.003. You can use this option to reduce the output +of F if you intend to be backward compatible only +down to a certain Perl version. + +=head2 --cplusplus + +Usually, F will detect C++ style comments and +replace them with C style comments for portability reasons. +Using this option instructs F to leave C++ +comments untouched. + +=head2 --quiet + +Be quiet. Don't print anything except fatal errors. + +=head2 --nodiag + +Don't output any diagnostic messages. Only portability +alerts will be printed. + +=head2 --nohints + +Don't output any hints. Hints often contain useful portability +notes. Warnings will still be displayed. + +=head2 --nochanges + +Don't suggest any changes. Only give diagnostic output and hints +unless these are also deactivated. + +=head2 --nofilter + +Don't filter the list of input files. By default, files not looking +like source code (i.e. not *.xs, *.c, *.cc, *.cpp or *.h) are skipped. + +=head2 --strip + +Strip all script and documentation functionality from F. +This reduces the size of F dramatically and may be useful +if you want to include F in smaller modules without +increasing their distribution size too much. + +The stripped F will have a C<--unstrip> option that allows +you to undo the stripping, but only if an appropriate C +module is installed. + +=head2 --list-provided + +Lists the API elements for which compatibility is provided by +F. Also lists if it must be explicitly requested, +if it has dependencies, and if there are hints or warnings for it. + +=head2 --list-unsupported + +Lists the API elements that are known not to be supported by +F and below which version of Perl they probably +won't be available or work. + +=head2 --api-info=I + +Show portability information for API elements matching I. +If I is surrounded by slashes, it is interpreted as a regular +expression. + +=head1 DESCRIPTION + +In order for a Perl extension (XS) module to be as portable as possible +across differing versions of Perl itself, certain steps need to be taken. + +=over 4 + +=item * + +Including this header is the first major one. This alone will give you +access to a large part of the Perl API that hasn't been available in +earlier Perl releases. Use + + perl ppport.h --list-provided + +to see which API elements are provided by ppport.h. + +=item * + +You should avoid using deprecated parts of the API. For example, using +global Perl variables without the C prefix is deprecated. Also, +some API functions used to have a C prefix. Using this form is +also deprecated. You can safely use the supported API, as F +will provide wrappers for older Perl versions. + +=item * + +If you use one of a few functions or variables that were not present in +earlier versions of Perl, and that can't be provided using a macro, you +have to explicitly request support for these functions by adding one or +more C<#define>s in your source code before the inclusion of F. + +These functions or variables will be marked C in the list shown +by C<--list-provided>. + +Depending on whether you module has a single or multiple files that +use such functions or variables, you want either C or global +variants. + +For a C function or variable (used only in a single source +file), use: + + #define NEED_function + #define NEED_variable + +For a global function or variable (used in multiple source files), +use: + + #define NEED_function_GLOBAL + #define NEED_variable_GLOBAL + +Note that you mustn't have more than one global request for the +same function or variable in your project. + + Function / Variable Static Request Global Request + ----------------------------------------------------------------------------------------- + PL_parser NEED_PL_parser NEED_PL_parser_GLOBAL + PL_signals NEED_PL_signals NEED_PL_signals_GLOBAL + caller_cx() NEED_caller_cx NEED_caller_cx_GLOBAL + eval_pv() NEED_eval_pv NEED_eval_pv_GLOBAL + grok_bin() NEED_grok_bin NEED_grok_bin_GLOBAL + grok_hex() NEED_grok_hex NEED_grok_hex_GLOBAL + grok_number() NEED_grok_number NEED_grok_number_GLOBAL + grok_numeric_radix() NEED_grok_numeric_radix NEED_grok_numeric_radix_GLOBAL + grok_oct() NEED_grok_oct NEED_grok_oct_GLOBAL + load_module() NEED_load_module NEED_load_module_GLOBAL + mg_findext() NEED_mg_findext NEED_mg_findext_GLOBAL + my_snprintf() NEED_my_snprintf NEED_my_snprintf_GLOBAL + my_sprintf() NEED_my_sprintf NEED_my_sprintf_GLOBAL + my_strlcat() NEED_my_strlcat NEED_my_strlcat_GLOBAL + my_strlcpy() NEED_my_strlcpy NEED_my_strlcpy_GLOBAL + newCONSTSUB() NEED_newCONSTSUB NEED_newCONSTSUB_GLOBAL + newRV_noinc() NEED_newRV_noinc NEED_newRV_noinc_GLOBAL + newSV_type() NEED_newSV_type NEED_newSV_type_GLOBAL + newSVpvn_flags() NEED_newSVpvn_flags NEED_newSVpvn_flags_GLOBAL + newSVpvn_share() NEED_newSVpvn_share NEED_newSVpvn_share_GLOBAL + pv_display() NEED_pv_display NEED_pv_display_GLOBAL + pv_escape() NEED_pv_escape NEED_pv_escape_GLOBAL + pv_pretty() NEED_pv_pretty NEED_pv_pretty_GLOBAL + sv_2pv_flags() NEED_sv_2pv_flags NEED_sv_2pv_flags_GLOBAL + sv_2pvbyte() NEED_sv_2pvbyte NEED_sv_2pvbyte_GLOBAL + sv_catpvf_mg() NEED_sv_catpvf_mg NEED_sv_catpvf_mg_GLOBAL + sv_catpvf_mg_nocontext() NEED_sv_catpvf_mg_nocontext NEED_sv_catpvf_mg_nocontext_GLOBAL + sv_pvn_force_flags() NEED_sv_pvn_force_flags NEED_sv_pvn_force_flags_GLOBAL + sv_setpvf_mg() NEED_sv_setpvf_mg NEED_sv_setpvf_mg_GLOBAL + sv_setpvf_mg_nocontext() NEED_sv_setpvf_mg_nocontext NEED_sv_setpvf_mg_nocontext_GLOBAL + sv_unmagicext() NEED_sv_unmagicext NEED_sv_unmagicext_GLOBAL + vload_module() NEED_vload_module NEED_vload_module_GLOBAL + vnewSVpvf() NEED_vnewSVpvf NEED_vnewSVpvf_GLOBAL + warner() NEED_warner NEED_warner_GLOBAL + +To avoid namespace conflicts, you can change the namespace of the +explicitly exported functions / variables using the C +macro. Just C<#define> the macro before including C: + + #define DPPP_NAMESPACE MyOwnNamespace_ + #include "ppport.h" + +The default namespace is C. + +=back + +The good thing is that most of the above can be checked by running +F on your source code. See the next section for +details. + +=head1 EXAMPLES + +To verify whether F is needed for your module, whether you +should make any changes to your code, and whether any special defines +should be used, F can be run as a Perl script to check your +source code. Simply say: + + perl ppport.h + +The result will usually be a list of patches suggesting changes +that should at least be acceptable, if not necessarily the most +efficient solution, or a fix for all possible problems. + +If you know that your XS module uses features only available in +newer Perl releases, if you're aware that it uses C++ comments, +and if you want all suggestions as a single patch file, you could +use something like this: + + perl ppport.h --compat-version=5.6.0 --cplusplus --patch=test.diff + +If you only want your code to be scanned without any suggestions +for changes, use: + + perl ppport.h --nochanges + +You can specify a different C program or options, using +the C<--diff> option: + + perl ppport.h --diff='diff -C 10' + +This would output context diffs with 10 lines of context. + +If you want to create patched copies of your files instead, use: + + perl ppport.h --copy=.new + +To display portability information for the C function, +use: + + perl ppport.h --api-info=newSVpvn + +Since the argument to C<--api-info> can be a regular expression, +you can use + + perl ppport.h --api-info=/_nomg$/ + +to display portability information for all C<_nomg> functions or + + perl ppport.h --api-info=/./ + +to display information for all known API elements. + +=head1 BUGS + +If this version of F is causing failure during +the compilation of this module, please check if newer versions +of either this module or C are available on CPAN +before sending a bug report. + +If F was generated using the latest version of +C and is causing failure of this module, please +file a bug report here: L + +Please include the following information: + +=over 4 + +=item 1. + +The complete output from running "perl -V" + +=item 2. + +This file. + +=item 3. + +The name and version of the module you were trying to build. + +=item 4. + +A full log of the build that failed. + +=item 5. + +Any other information that you think could be relevant. + +=back + +For the latest version of this code, please get the C +module from CPAN. + +=head1 COPYRIGHT + +Version 3.x, Copyright (c) 2004-2013, Marcus Holland-Moritz. + +Version 2.x, Copyright (C) 2001, Paul Marquess. + +Version 1.x, Copyright (C) 1999, Kenneth Albanowski. + +This program is free software; you can redistribute it and/or +modify it under the same terms as Perl itself. + +=head1 SEE ALSO + +See L. + +=cut + +use strict; + +# Disable broken TRIE-optimization +BEGIN { eval '${^RE_TRIE_MAXBUF} = -1' if $] >= 5.009004 && $] <= 5.009005 } + +my $VERSION = 3.31; + +my %opt = ( + quiet => 0, + diag => 1, + hints => 1, + changes => 1, + cplusplus => 0, + filter => 1, + strip => 0, + version => 0, +); + +my($ppport) = $0 =~ /([\w.]+)$/; +my $LF = '(?:\r\n|[\r\n])'; # line feed +my $HS = "[ \t]"; # horizontal whitespace + +# Never use C comments in this file! +my $ccs = '/'.'*'; +my $cce = '*'.'/'; +my $rccs = quotemeta $ccs; +my $rcce = quotemeta $cce; + +eval { + require Getopt::Long; + Getopt::Long::GetOptions(\%opt, qw( + help quiet diag! filter! hints! changes! cplusplus strip version + patch=s copy=s diff=s compat-version=s + list-provided list-unsupported api-info=s + )) or usage(); +}; + +if ($@ and grep /^-/, @ARGV) { + usage() if "@ARGV" =~ /^--?h(?:elp)?$/; + die "Getopt::Long not found. Please don't use any options.\n"; +} + +if ($opt{version}) { + print "This is $0 $VERSION.\n"; + exit 0; +} + +usage() if $opt{help}; +strip() if $opt{strip}; + +if (exists $opt{'compat-version'}) { + my($r,$v,$s) = eval { parse_version($opt{'compat-version'}) }; + if ($@) { + die "Invalid version number format: '$opt{'compat-version'}'\n"; + } + die "Only Perl 5 is supported\n" if $r != 5; + die "Invalid version number: $opt{'compat-version'}\n" if $v >= 1000 || $s >= 1000; + $opt{'compat-version'} = sprintf "%d.%03d%03d", $r, $v, $s; +} +else { + $opt{'compat-version'} = 5; +} + +my %API = map { /^(\w+)\|([^|]*)\|([^|]*)\|(\w*)$/ + ? ( $1 => { + ($2 ? ( base => $2 ) : ()), + ($3 ? ( todo => $3 ) : ()), + (index($4, 'v') >= 0 ? ( varargs => 1 ) : ()), + (index($4, 'p') >= 0 ? ( provided => 1 ) : ()), + (index($4, 'n') >= 0 ? ( nothxarg => 1 ) : ()), + } ) + : die "invalid spec: $_" } qw( +ASCII_TO_NEED||5.007001|n +AvFILLp|5.004050||p +AvFILL||| +BhkDISABLE||5.021008| +BhkENABLE||5.021008| +BhkENTRY_set||5.021008| +BhkENTRY||| +BhkFLAGS||| +CALL_BLOCK_HOOKS||| +CLASS|||n +CPERLscope|5.005000||p +CX_CURPAD_SAVE||| +CX_CURPAD_SV||| +CopFILEAV|5.006000||p +CopFILEGV_set|5.006000||p +CopFILEGV|5.006000||p +CopFILESV|5.006000||p +CopFILE_set|5.006000||p +CopFILE|5.006000||p +CopSTASHPV_set|5.006000||p +CopSTASHPV|5.006000||p +CopSTASH_eq|5.006000||p +CopSTASH_set|5.006000||p +CopSTASH|5.006000||p +CopyD|5.009002|5.004050|p +Copy||| +CvPADLIST||5.008001| +CvSTASH||| +CvWEAKOUTSIDE||| +DEFSV_set|5.010001||p +DEFSV|5.004050||p +END_EXTERN_C|5.005000||p +ENTER||| +ERRSV|5.004050||p +EXTEND||| +EXTERN_C|5.005000||p +F0convert|||n +FREETMPS||| +GIMME_V||5.004000|n +GIMME|||n +GROK_NUMERIC_RADIX|5.007002||p +G_ARRAY||| +G_DISCARD||| +G_EVAL||| +G_METHOD|5.006001||p +G_NOARGS||| +G_SCALAR||| +G_VOID||5.004000| +GetVars||| +GvAV||| +GvCV||| +GvHV||| +GvSVn|5.009003||p +GvSV||| +Gv_AMupdate||5.011000| +HEf_SVKEY|5.003070||p +HeHASH||5.003070| +HeKEY||5.003070| +HeKLEN||5.003070| +HePV||5.004000| +HeSVKEY_force||5.003070| +HeSVKEY_set||5.004000| +HeSVKEY||5.003070| +HeUTF8|5.010001|5.008000|p +HeVAL||5.003070| +HvENAMELEN||5.015004| +HvENAMEUTF8||5.015004| +HvENAME||5.013007| +HvNAMELEN_get|5.009003||p +HvNAMELEN||5.015004| +HvNAMEUTF8||5.015004| +HvNAME_get|5.009003||p +HvNAME||| +INT2PTR|5.006000||p +IN_LOCALE_COMPILETIME|5.007002||p +IN_LOCALE_RUNTIME|5.007002||p +IN_LOCALE|5.007002||p +IN_PERL_COMPILETIME|5.008001||p +IS_NUMBER_GREATER_THAN_UV_MAX|5.007002||p +IS_NUMBER_INFINITY|5.007002||p +IS_NUMBER_IN_UV|5.007002||p +IS_NUMBER_NAN|5.007003||p +IS_NUMBER_NEG|5.007002||p +IS_NUMBER_NOT_INT|5.007002||p +IVSIZE|5.006000||p +IVTYPE|5.006000||p +IVdf|5.006000||p +LEAVE||| +LINKLIST||5.013006| +LVRET||| +MARK||| +MULTICALL||5.021008| +MUTABLE_PTR|5.010001||p +MUTABLE_SV|5.010001||p +MY_CXT_CLONE|5.009002||p +MY_CXT_INIT|5.007003||p +MY_CXT|5.007003||p +MoveD|5.009002|5.004050|p +Move||| +NATIVE_TO_NEED||5.007001|n +NOOP|5.005000||p +NUM2PTR|5.006000||p +NVTYPE|5.006000||p +NVef|5.006001||p +NVff|5.006001||p +NVgf|5.006001||p +Newxc|5.009003||p +Newxz|5.009003||p +Newx|5.009003||p +Nullav||| +Nullch||| +Nullcv||| +Nullhv||| +Nullsv||| +OP_CLASS||5.013007| +OP_DESC||5.007003| +OP_NAME||5.007003| +OP_TYPE_IS_OR_WAS||5.019010| +OP_TYPE_IS||5.019007| +ORIGMARK||| +OpHAS_SIBLING||5.021007| +OpSIBLING_set||5.021007| +OpSIBLING||5.021007| +PAD_BASE_SV||| +PAD_CLONE_VARS||| +PAD_COMPNAME_FLAGS||| +PAD_COMPNAME_GEN_set||| +PAD_COMPNAME_GEN||| +PAD_COMPNAME_OURSTASH||| +PAD_COMPNAME_PV||| +PAD_COMPNAME_TYPE||| +PAD_RESTORE_LOCAL||| +PAD_SAVE_LOCAL||| +PAD_SAVE_SETNULLPAD||| +PAD_SETSV||| +PAD_SET_CUR_NOSAVE||| +PAD_SET_CUR||| +PAD_SVl||| +PAD_SV||| +PERLIO_FUNCS_CAST|5.009003||p +PERLIO_FUNCS_DECL|5.009003||p +PERL_ABS|5.008001||p +PERL_BCDVERSION|5.021008||p +PERL_GCC_BRACE_GROUPS_FORBIDDEN|5.008001||p +PERL_HASH|5.003070||p +PERL_INT_MAX|5.003070||p +PERL_INT_MIN|5.003070||p +PERL_LONG_MAX|5.003070||p +PERL_LONG_MIN|5.003070||p +PERL_MAGIC_arylen|5.007002||p +PERL_MAGIC_backref|5.007002||p +PERL_MAGIC_bm|5.007002||p +PERL_MAGIC_collxfrm|5.007002||p +PERL_MAGIC_dbfile|5.007002||p +PERL_MAGIC_dbline|5.007002||p +PERL_MAGIC_defelem|5.007002||p +PERL_MAGIC_envelem|5.007002||p +PERL_MAGIC_env|5.007002||p +PERL_MAGIC_ext|5.007002||p +PERL_MAGIC_fm|5.007002||p +PERL_MAGIC_glob|5.021008||p +PERL_MAGIC_isaelem|5.007002||p +PERL_MAGIC_isa|5.007002||p +PERL_MAGIC_mutex|5.021008||p +PERL_MAGIC_nkeys|5.007002||p +PERL_MAGIC_overload_elem|5.021008||p +PERL_MAGIC_overload_table|5.007002||p +PERL_MAGIC_overload|5.021008||p +PERL_MAGIC_pos|5.007002||p +PERL_MAGIC_qr|5.007002||p +PERL_MAGIC_regdata|5.007002||p +PERL_MAGIC_regdatum|5.007002||p +PERL_MAGIC_regex_global|5.007002||p +PERL_MAGIC_shared_scalar|5.007003||p +PERL_MAGIC_shared|5.007003||p +PERL_MAGIC_sigelem|5.007002||p +PERL_MAGIC_sig|5.007002||p +PERL_MAGIC_substr|5.007002||p +PERL_MAGIC_sv|5.007002||p +PERL_MAGIC_taint|5.007002||p +PERL_MAGIC_tiedelem|5.007002||p +PERL_MAGIC_tiedscalar|5.007002||p +PERL_MAGIC_tied|5.007002||p +PERL_MAGIC_utf8|5.008001||p +PERL_MAGIC_uvar_elem|5.007003||p +PERL_MAGIC_uvar|5.007002||p +PERL_MAGIC_vec|5.007002||p +PERL_MAGIC_vstring|5.008001||p +PERL_PV_ESCAPE_ALL|5.009004||p +PERL_PV_ESCAPE_FIRSTCHAR|5.009004||p +PERL_PV_ESCAPE_NOBACKSLASH|5.009004||p +PERL_PV_ESCAPE_NOCLEAR|5.009004||p +PERL_PV_ESCAPE_QUOTE|5.009004||p +PERL_PV_ESCAPE_RE|5.009005||p +PERL_PV_ESCAPE_UNI_DETECT|5.009004||p +PERL_PV_ESCAPE_UNI|5.009004||p +PERL_PV_PRETTY_DUMP|5.009004||p +PERL_PV_PRETTY_ELLIPSES|5.010000||p +PERL_PV_PRETTY_LTGT|5.009004||p +PERL_PV_PRETTY_NOCLEAR|5.010000||p +PERL_PV_PRETTY_QUOTE|5.009004||p +PERL_PV_PRETTY_REGPROP|5.009004||p +PERL_QUAD_MAX|5.003070||p +PERL_QUAD_MIN|5.003070||p +PERL_REVISION|5.006000||p +PERL_SCAN_ALLOW_UNDERSCORES|5.007003||p +PERL_SCAN_DISALLOW_PREFIX|5.007003||p +PERL_SCAN_GREATER_THAN_UV_MAX|5.007003||p +PERL_SCAN_SILENT_ILLDIGIT|5.008001||p +PERL_SHORT_MAX|5.003070||p +PERL_SHORT_MIN|5.003070||p +PERL_SIGNALS_UNSAFE_FLAG|5.008001||p +PERL_SUBVERSION|5.006000||p +PERL_SYS_INIT3||5.006000| +PERL_SYS_INIT||| +PERL_SYS_TERM||5.021008| +PERL_UCHAR_MAX|5.003070||p +PERL_UCHAR_MIN|5.003070||p +PERL_UINT_MAX|5.003070||p +PERL_UINT_MIN|5.003070||p +PERL_ULONG_MAX|5.003070||p +PERL_ULONG_MIN|5.003070||p +PERL_UNUSED_ARG|5.009003||p +PERL_UNUSED_CONTEXT|5.009004||p +PERL_UNUSED_DECL|5.007002||p +PERL_UNUSED_VAR|5.007002||p +PERL_UQUAD_MAX|5.003070||p +PERL_UQUAD_MIN|5.003070||p +PERL_USE_GCC_BRACE_GROUPS|5.009004||p +PERL_USHORT_MAX|5.003070||p +PERL_USHORT_MIN|5.003070||p +PERL_VERSION|5.006000||p +PL_DBsignal|5.005000||p +PL_DBsingle|||pn +PL_DBsub|||pn +PL_DBtrace|||pn +PL_Sv|5.005000||p +PL_bufend|5.021008||p +PL_bufptr|5.021008||p +PL_check||5.006000| +PL_compiling|5.004050||p +PL_comppad_name||5.017004| +PL_comppad||5.008001| +PL_copline|5.021008||p +PL_curcop|5.004050||p +PL_curpad||5.005000| +PL_curstash|5.004050||p +PL_debstash|5.004050||p +PL_defgv|5.004050||p +PL_diehook|5.004050||p +PL_dirty|5.004050||p +PL_dowarn|||pn +PL_errgv|5.004050||p +PL_error_count|5.021008||p +PL_expect|5.021008||p +PL_hexdigit|5.005000||p +PL_hints|5.005000||p +PL_in_my_stash|5.021008||p +PL_in_my|5.021008||p +PL_keyword_plugin||5.011002| +PL_last_in_gv|||n +PL_laststatval|5.005000||p +PL_lex_state|5.021008||p +PL_lex_stuff|5.021008||p +PL_linestr|5.021008||p +PL_modglobal||5.005000|n +PL_na|5.004050||pn +PL_no_modify|5.006000||p +PL_ofsgv|||n +PL_opfreehook||5.011000|n +PL_parser|5.009005||p +PL_peepp||5.007003|n +PL_perl_destruct_level|5.004050||p +PL_perldb|5.004050||p +PL_ppaddr|5.006000||p +PL_rpeepp||5.013005|n +PL_rsfp_filters|5.021008||p +PL_rsfp|5.021008||p +PL_rs|||n +PL_signals|5.008001||p +PL_stack_base|5.004050||p +PL_stack_sp|5.004050||p +PL_statcache|5.005000||p +PL_stdingv|5.004050||p +PL_sv_arenaroot|5.004050||p +PL_sv_no|5.004050||pn +PL_sv_undef|5.004050||pn +PL_sv_yes|5.004050||pn +PL_tainted|5.004050||p +PL_tainting|5.004050||p +PL_tokenbuf|5.021008||p +POP_MULTICALL||5.021008| +POPi|||n +POPl|||n +POPn|||n +POPpbytex||5.007001|n +POPpx||5.005030|n +POPp|||n +POPs|||n +PTR2IV|5.006000||p +PTR2NV|5.006000||p +PTR2UV|5.006000||p +PTR2nat|5.009003||p +PTR2ul|5.007001||p +PTRV|5.006000||p +PUSHMARK||| +PUSH_MULTICALL||5.021008| +PUSHi||| +PUSHmortal|5.009002||p +PUSHn||| +PUSHp||| +PUSHs||| +PUSHu|5.004000||p +PUTBACK||| +PadARRAY||5.021008| +PadMAX||5.021008| +PadlistARRAY||5.021008| +PadlistMAX||5.021008| +PadlistNAMESARRAY||5.021008| +PadlistNAMESMAX||5.021008| +PadlistNAMES||5.021008| +PadlistREFCNT||5.017004| +PadnameIsOUR||| +PadnameIsSTATE||| +PadnameLEN||5.021008| +PadnameOURSTASH||| +PadnameOUTER||| +PadnamePV||5.021008| +PadnameREFCNT_dec||5.021008| +PadnameREFCNT||5.021008| +PadnameSV||5.021008| +PadnameTYPE||| +PadnameUTF8||5.021007| +PadnamelistARRAY||5.021008| +PadnamelistMAX||5.021008| +PadnamelistREFCNT_dec||5.021008| +PadnamelistREFCNT||5.021008| +PerlIO_clearerr||5.007003| +PerlIO_close||5.007003| +PerlIO_context_layers||5.009004| +PerlIO_eof||5.007003| +PerlIO_error||5.007003| +PerlIO_fileno||5.007003| +PerlIO_fill||5.007003| +PerlIO_flush||5.007003| +PerlIO_get_base||5.007003| +PerlIO_get_bufsiz||5.007003| +PerlIO_get_cnt||5.007003| +PerlIO_get_ptr||5.007003| +PerlIO_read||5.007003| +PerlIO_restore_errno||| +PerlIO_save_errno||| +PerlIO_seek||5.007003| +PerlIO_set_cnt||5.007003| +PerlIO_set_ptrcnt||5.007003| +PerlIO_setlinebuf||5.007003| +PerlIO_stderr||5.007003| +PerlIO_stdin||5.007003| +PerlIO_stdout||5.007003| +PerlIO_tell||5.007003| +PerlIO_unread||5.007003| +PerlIO_write||5.007003| +Perl_signbit||5.009005|n +PoisonFree|5.009004||p +PoisonNew|5.009004||p +PoisonWith|5.009004||p +Poison|5.008000||p +READ_XDIGIT||5.017006| +RETVAL|||n +Renewc||| +Renew||| +SAVECLEARSV||| +SAVECOMPPAD||| +SAVEPADSV||| +SAVETMPS||| +SAVE_DEFSV|5.004050||p +SPAGAIN||| +SP||| +START_EXTERN_C|5.005000||p +START_MY_CXT|5.007003||p +STMT_END|||p +STMT_START|||p +STR_WITH_LEN|5.009003||p +ST||| +SV_CONST_RETURN|5.009003||p +SV_COW_DROP_PV|5.008001||p +SV_COW_SHARED_HASH_KEYS|5.009005||p +SV_GMAGIC|5.007002||p +SV_HAS_TRAILING_NUL|5.009004||p +SV_IMMEDIATE_UNREF|5.007001||p +SV_MUTABLE_RETURN|5.009003||p +SV_NOSTEAL|5.009002||p +SV_SMAGIC|5.009003||p +SV_UTF8_NO_ENCODING|5.008001||p +SVfARG|5.009005||p +SVf_UTF8|5.006000||p +SVf|5.006000||p +SVt_INVLIST||5.019002| +SVt_IV||| +SVt_NULL||| +SVt_NV||| +SVt_PVAV||| +SVt_PVCV||| +SVt_PVFM||| +SVt_PVGV||| +SVt_PVHV||| +SVt_PVIO||| +SVt_PVIV||| +SVt_PVLV||| +SVt_PVMG||| +SVt_PVNV||| +SVt_PV||| +SVt_REGEXP||5.011000| +Safefree||| +Slab_Alloc||| +Slab_Free||| +Slab_to_ro||| +Slab_to_rw||| +StructCopy||| +SvCUR_set||| +SvCUR||| +SvEND||| +SvGAMAGIC||5.006001| +SvGETMAGIC|5.004050||p +SvGROW||| +SvIOK_UV||5.006000| +SvIOK_notUV||5.006000| +SvIOK_off||| +SvIOK_only_UV||5.006000| +SvIOK_only||| +SvIOK_on||| +SvIOKp||| +SvIOK||| +SvIVX||| +SvIV_nomg|5.009001||p +SvIV_set||| +SvIVx||| +SvIV||| +SvIsCOW_shared_hash||5.008003| +SvIsCOW||5.008003| +SvLEN_set||| +SvLEN||| +SvLOCK||5.007003| +SvMAGIC_set|5.009003||p +SvNIOK_off||| +SvNIOKp||| +SvNIOK||| +SvNOK_off||| +SvNOK_only||| +SvNOK_on||| +SvNOKp||| +SvNOK||| +SvNVX||| +SvNV_nomg||5.013002| +SvNV_set||| +SvNVx||| +SvNV||| +SvOK||| +SvOOK_offset||5.011000| +SvOOK||| +SvPOK_off||| +SvPOK_only_UTF8||5.006000| +SvPOK_only||| +SvPOK_on||| +SvPOKp||| +SvPOK||| +SvPVX_const|5.009003||p +SvPVX_mutable|5.009003||p +SvPVX||| +SvPV_const|5.009003||p +SvPV_flags_const_nolen|5.009003||p +SvPV_flags_const|5.009003||p +SvPV_flags_mutable|5.009003||p +SvPV_flags|5.007002||p +SvPV_force_flags_mutable|5.009003||p +SvPV_force_flags_nolen|5.009003||p +SvPV_force_flags|5.007002||p +SvPV_force_mutable|5.009003||p +SvPV_force_nolen|5.009003||p +SvPV_force_nomg_nolen|5.009003||p +SvPV_force_nomg|5.007002||p +SvPV_force|||p +SvPV_mutable|5.009003||p +SvPV_nolen_const|5.009003||p +SvPV_nolen|5.006000||p +SvPV_nomg_const_nolen|5.009003||p +SvPV_nomg_const|5.009003||p +SvPV_nomg_nolen|5.013007||p +SvPV_nomg|5.007002||p +SvPV_renew|5.009003||p +SvPV_set||| +SvPVbyte_force||5.009002| +SvPVbyte_nolen||5.006000| +SvPVbytex_force||5.006000| +SvPVbytex||5.006000| +SvPVbyte|5.006000||p +SvPVutf8_force||5.006000| +SvPVutf8_nolen||5.006000| +SvPVutf8x_force||5.006000| +SvPVutf8x||5.006000| +SvPVutf8||5.006000| +SvPVx||| +SvPV||| +SvREFCNT_dec_NN||5.017007| +SvREFCNT_dec||| +SvREFCNT_inc_NN|5.009004||p +SvREFCNT_inc_simple_NN|5.009004||p +SvREFCNT_inc_simple_void_NN|5.009004||p +SvREFCNT_inc_simple_void|5.009004||p +SvREFCNT_inc_simple|5.009004||p +SvREFCNT_inc_void_NN|5.009004||p +SvREFCNT_inc_void|5.009004||p +SvREFCNT_inc|||p +SvREFCNT||| +SvROK_off||| +SvROK_on||| +SvROK||| +SvRV_set|5.009003||p +SvRV||| +SvRXOK||5.009005| +SvRX||5.009005| +SvSETMAGIC||| +SvSHARED_HASH|5.009003||p +SvSHARE||5.007003| +SvSTASH_set|5.009003||p +SvSTASH||| +SvSetMagicSV_nosteal||5.004000| +SvSetMagicSV||5.004000| +SvSetSV_nosteal||5.004000| +SvSetSV||| +SvTAINTED_off||5.004000| +SvTAINTED_on||5.004000| +SvTAINTED||5.004000| +SvTAINT||| +SvTHINKFIRST||| +SvTRUE_nomg||5.013006| +SvTRUE||| +SvTYPE||| +SvUNLOCK||5.007003| +SvUOK|5.007001|5.006000|p +SvUPGRADE||| +SvUTF8_off||5.006000| +SvUTF8_on||5.006000| +SvUTF8||5.006000| +SvUVXx|5.004000||p +SvUVX|5.004000||p +SvUV_nomg|5.009001||p +SvUV_set|5.009003||p +SvUVx|5.004000||p +SvUV|5.004000||p +SvVOK||5.008001| +SvVSTRING_mg|5.009004||p +THIS|||n +UNDERBAR|5.009002||p +UTF8_MAXBYTES|5.009002||p +UVSIZE|5.006000||p +UVTYPE|5.006000||p +UVXf|5.007001||p +UVof|5.006000||p +UVuf|5.006000||p +UVxf|5.006000||p +WARN_ALL|5.006000||p +WARN_AMBIGUOUS|5.006000||p +WARN_ASSERTIONS|5.021008||p +WARN_BAREWORD|5.006000||p +WARN_CLOSED|5.006000||p +WARN_CLOSURE|5.006000||p +WARN_DEBUGGING|5.006000||p +WARN_DEPRECATED|5.006000||p +WARN_DIGIT|5.006000||p +WARN_EXEC|5.006000||p +WARN_EXITING|5.006000||p +WARN_GLOB|5.006000||p +WARN_INPLACE|5.006000||p +WARN_INTERNAL|5.006000||p +WARN_IO|5.006000||p +WARN_LAYER|5.008000||p +WARN_MALLOC|5.006000||p +WARN_MISC|5.006000||p +WARN_NEWLINE|5.006000||p +WARN_NUMERIC|5.006000||p +WARN_ONCE|5.006000||p +WARN_OVERFLOW|5.006000||p +WARN_PACK|5.006000||p +WARN_PARENTHESIS|5.006000||p +WARN_PIPE|5.006000||p +WARN_PORTABLE|5.006000||p +WARN_PRECEDENCE|5.006000||p +WARN_PRINTF|5.006000||p +WARN_PROTOTYPE|5.006000||p +WARN_QW|5.006000||p +WARN_RECURSION|5.006000||p +WARN_REDEFINE|5.006000||p +WARN_REGEXP|5.006000||p +WARN_RESERVED|5.006000||p +WARN_SEMICOLON|5.006000||p +WARN_SEVERE|5.006000||p +WARN_SIGNAL|5.006000||p +WARN_SUBSTR|5.006000||p +WARN_SYNTAX|5.006000||p +WARN_TAINT|5.006000||p +WARN_THREADS|5.008000||p +WARN_UNINITIALIZED|5.006000||p +WARN_UNOPENED|5.006000||p +WARN_UNPACK|5.006000||p +WARN_UNTIE|5.006000||p +WARN_UTF8|5.006000||p +WARN_VOID|5.006000||p +WIDEST_UTYPE|5.015004||p +XCPT_CATCH|5.009002||p +XCPT_RETHROW|5.009002||p +XCPT_TRY_END|5.009002||p +XCPT_TRY_START|5.009002||p +XPUSHi||| +XPUSHmortal|5.009002||p +XPUSHn||| +XPUSHp||| +XPUSHs||| +XPUSHu|5.004000||p +XSPROTO|5.010000||p +XSRETURN_EMPTY||| +XSRETURN_IV||| +XSRETURN_NO||| +XSRETURN_NV||| +XSRETURN_PV||| +XSRETURN_UNDEF||| +XSRETURN_UV|5.008001||p +XSRETURN_YES||| +XSRETURN|||p +XST_mIV||| +XST_mNO||| +XST_mNV||| +XST_mPV||| +XST_mUNDEF||| +XST_mUV|5.008001||p +XST_mYES||| +XS_APIVERSION_BOOTCHECK||5.021008| +XS_EXTERNAL||5.021008| +XS_INTERNAL||5.021008| +XS_VERSION_BOOTCHECK||5.021008| +XS_VERSION||| +XSprePUSH|5.006000||p +XS||| +XopDISABLE||5.021008| +XopENABLE||5.021008| +XopENTRYCUSTOM||5.021008| +XopENTRY_set||5.021008| +XopENTRY||5.021008| +XopFLAGS||5.013007| +ZeroD|5.009002||p +Zero||| +_aMY_CXT|5.007003||p +_add_range_to_invlist||| +_append_range_to_invlist||| +_core_swash_init||| +_get_encoding||| +_get_regclass_nonbitmap_data||| +_get_swash_invlist||| +_invlist_array_init|||n +_invlist_contains_cp|||n +_invlist_contents||| +_invlist_dump||| +_invlist_intersection_maybe_complement_2nd||| +_invlist_intersection||| +_invlist_invert||| +_invlist_len|||n +_invlist_populate_swatch|||n +_invlist_search|||n +_invlist_subtract||| +_invlist_union_maybe_complement_2nd||| +_invlist_union||| +_is_cur_LC_category_utf8||| +_is_in_locale_category||5.021001| +_is_uni_FOO||5.017008| +_is_uni_perl_idcont||5.017008| +_is_uni_perl_idstart||5.017007| +_is_utf8_FOO||5.017008| +_is_utf8_char_slow||5.021001|n +_is_utf8_idcont||5.021001| +_is_utf8_idstart||5.021001| +_is_utf8_mark||5.017008| +_is_utf8_perl_idcont||5.017008| +_is_utf8_perl_idstart||5.017007| +_is_utf8_xidcont||5.021001| +_is_utf8_xidstart||5.021001| +_load_PL_utf8_foldclosures||| +_make_exactf_invlist||| +_new_invlist_C_array||| +_new_invlist||| +_pMY_CXT|5.007003||p +_setup_canned_invlist||| +_swash_inversion_hash||| +_swash_to_invlist||| +_to_fold_latin1||| +_to_uni_fold_flags||5.014000| +_to_upper_title_latin1||| +_to_utf8_fold_flags||5.019009| +_to_utf8_lower_flags||5.019009| +_to_utf8_title_flags||5.019009| +_to_utf8_upper_flags||5.019009| +_warn_problematic_locale|||n +aMY_CXT_|5.007003||p +aMY_CXT|5.007003||p +aTHXR_|5.021008||p +aTHXR|5.021008||p +aTHX_|5.006000||p +aTHX|5.006000||p +aassign_common_vars||| +add_above_Latin1_folds||| +add_cp_to_invlist||| +add_data|||n +add_multi_match||| +add_utf16_textfilter||| +adjust_size_and_find_bucket|||n +advance_one_SB||| +advance_one_WB||| +alloc_maybe_populate_EXACT||| +alloccopstash||| +allocmy||| +amagic_call||| +amagic_cmp_locale||| +amagic_cmp||| +amagic_deref_call||5.013007| +amagic_i_ncmp||| +amagic_is_enabled||| +amagic_ncmp||| +anonymise_cv_maybe||| +any_dup||| +ao||| +append_utf8_from_native_byte||5.019004|n +apply_attrs_my||| +apply_attrs_string||5.006001| +apply_attrs||| +apply||| +assert_uft8_cache_coherent||| +assignment_type||| +atfork_lock||5.007003|n +atfork_unlock||5.007003|n +av_arylen_p||5.009003| +av_clear||| +av_create_and_push||5.009005| +av_create_and_unshift_one||5.009005| +av_delete||5.006000| +av_exists||5.006000| +av_extend_guts||| +av_extend||| +av_fetch||| +av_fill||| +av_iter_p||5.011000| +av_len||| +av_make||| +av_pop||| +av_push||| +av_reify||| +av_shift||| +av_store||| +av_tindex||5.017009| +av_top_index||5.017009| +av_undef||| +av_unshift||| +ax|||n +backup_one_SB||| +backup_one_WB||| +bad_type_gv||| +bad_type_pv||| +bind_match||| +block_end||5.004000| +block_gimme||5.004000| +block_start||5.004000| +blockhook_register||5.013003| +boolSV|5.004000||p +boot_core_PerlIO||| +boot_core_UNIVERSAL||| +boot_core_mro||| +bytes_cmp_utf8||5.013007| +bytes_from_utf8||5.007001| +bytes_to_utf8||5.006001| +call_argv|5.006000||p +call_atexit||5.006000| +call_list||5.004000| +call_method|5.006000||p +call_pv|5.006000||p +call_sv|5.006000||p +caller_cx|5.013005|5.006000|p +calloc||5.007002|n +cando||| +cast_i32||5.006000|n +cast_iv||5.006000|n +cast_ulong||5.006000|n +cast_uv||5.006000|n +check_locale_boundary_crossing||| +check_type_and_open||| +check_uni||| +check_utf8_print||| +checkcomma||| +ckWARN|5.006000||p +ck_entersub_args_core||| +ck_entersub_args_list||5.013006| +ck_entersub_args_proto_or_list||5.013006| +ck_entersub_args_proto||5.013006| +ck_warner_d||5.011001|v +ck_warner||5.011001|v +ckwarn_common||| +ckwarn_d||5.009003| +ckwarn||5.009003| +clear_placeholders||| +clear_special_blocks||| +clone_params_del|||n +clone_params_new|||n +closest_cop||| +cntrl_to_mnemonic|||n +compute_EXACTish|||n +construct_ahocorasick_from_trie||| +cop_fetch_label||5.015001| +cop_free||| +cop_hints_2hv||5.013007| +cop_hints_fetch_pvn||5.013007| +cop_hints_fetch_pvs||5.013007| +cop_hints_fetch_pv||5.013007| +cop_hints_fetch_sv||5.013007| +cop_store_label||5.015001| +cophh_2hv||5.013007| +cophh_copy||5.013007| +cophh_delete_pvn||5.013007| +cophh_delete_pvs||5.013007| +cophh_delete_pv||5.013007| +cophh_delete_sv||5.013007| +cophh_fetch_pvn||5.013007| +cophh_fetch_pvs||5.013007| +cophh_fetch_pv||5.013007| +cophh_fetch_sv||5.013007| +cophh_free||5.013007| +cophh_new_empty||5.021008| +cophh_store_pvn||5.013007| +cophh_store_pvs||5.013007| +cophh_store_pv||5.013007| +cophh_store_sv||5.013007| +core_prototype||| +coresub_op||| +could_it_be_a_POSIX_class|||n +cr_textfilter||| +create_eval_scope||| +croak_memory_wrap||5.019003|n +croak_no_mem|||n +croak_no_modify||5.013003|n +croak_nocontext|||vn +croak_popstack|||n +croak_sv||5.013001| +croak_xs_usage||5.010001|n +croak|||v +csighandler||5.009003|n +current_re_engine||| +curse||| +custom_op_desc||5.007003| +custom_op_get_field||| +custom_op_name||5.007003| +custom_op_register||5.013007| +custom_op_xop||5.013007| +cv_ckproto_len_flags||| +cv_clone_into||| +cv_clone||| +cv_const_sv_or_av|||n +cv_const_sv||5.003070|n +cv_dump||| +cv_forget_slab||| +cv_get_call_checker||5.013006| +cv_name||5.021005| +cv_set_call_checker_flags||5.021004| +cv_set_call_checker||5.013006| +cv_undef_flags||| +cv_undef||| +cvgv_from_hek||| +cvgv_set||| +cvstash_set||| +cx_dump||5.005000| +cx_dup||| +cxinc||| +dAXMARK|5.009003||p +dAX|5.007002||p +dITEMS|5.007002||p +dMARK||| +dMULTICALL||5.009003| +dMY_CXT_SV|5.007003||p +dMY_CXT|5.007003||p +dNOOP|5.006000||p +dORIGMARK||| +dSP||| +dTHR|5.004050||p +dTHXR|5.021008||p +dTHXa|5.006000||p +dTHXoa|5.006000||p +dTHX|5.006000||p +dUNDERBAR|5.009002||p +dVAR|5.009003||p +dXCPT|5.009002||p +dXSARGS||| +dXSI32||| +dXSTARG|5.006000||p +deb_curcv||| +deb_nocontext|||vn +deb_stack_all||| +deb_stack_n||| +debop||5.005000| +debprofdump||5.005000| +debprof||| +debstackptrs||5.007003| +debstack||5.007003| +debug_start_match||| +deb||5.007003|v +defelem_target||| +del_sv||| +delete_eval_scope||| +delimcpy||5.004000|n +deprecate_commaless_var_list||| +despatch_signals||5.007001| +destroy_matcher||| +die_nocontext|||vn +die_sv||5.013001| +die_unwind||| +die|||v +dirp_dup||| +div128||| +djSP||| +do_aexec5||| +do_aexec||| +do_aspawn||| +do_binmode||5.004050| +do_chomp||| +do_close||| +do_delete_local||| +do_dump_pad||| +do_eof||| +do_exec3||| +do_execfree||| +do_exec||| +do_gv_dump||5.006000| +do_gvgv_dump||5.006000| +do_hv_dump||5.006000| +do_ipcctl||| +do_ipcget||| +do_join||| +do_magic_dump||5.006000| +do_msgrcv||| +do_msgsnd||| +do_ncmp||| +do_oddball||| +do_op_dump||5.006000| +do_open6||| +do_open9||5.006000| +do_open_raw||| +do_openn||5.007001| +do_open||5.003070| +do_pmop_dump||5.006000| +do_print||| +do_readline||| +do_seek||| +do_semop||| +do_shmio||| +do_smartmatch||| +do_spawn_nowait||| +do_spawn||| +do_sprintf||| +do_sv_dump||5.006000| +do_sysseek||| +do_tell||| +do_trans_complex_utf8||| +do_trans_complex||| +do_trans_count_utf8||| +do_trans_count||| +do_trans_simple_utf8||| +do_trans_simple||| +do_trans||| +do_vecget||| +do_vecset||| +do_vop||| +docatch||| +doeval||| +dofile||| +dofindlabel||| +doform||| +doing_taint||5.008001|n +dooneliner||| +doopen_pm||| +doparseform||| +dopoptoeval||| +dopoptogiven||| +dopoptolabel||| +dopoptoloop||| +dopoptosub_at||| +dopoptowhen||| +doref||5.009003| +dounwind||| +dowantarray||| +drand48_init_r|||n +drand48_r|||n +dump_all_perl||| +dump_all||5.006000| +dump_c_backtrace||| +dump_eval||5.006000| +dump_exec_pos||| +dump_form||5.006000| +dump_indent||5.006000|v +dump_mstats||| +dump_packsubs_perl||| +dump_packsubs||5.006000| +dump_sub_perl||| +dump_sub||5.006000| +dump_sv_child||| +dump_trie_interim_list||| +dump_trie_interim_table||| +dump_trie||| +dump_vindent||5.006000| +dumpuntil||| +dup_attrlist||| +emulate_cop_io||| +eval_pv|5.006000||p +eval_sv|5.006000||p +exec_failed||| +expect_number||| +fbm_compile||5.005000| +fbm_instr||5.005000| +feature_is_enabled||| +filter_add||| +filter_del||| +filter_gets||| +filter_read||| +finalize_optree||| +finalize_op||| +find_and_forget_pmops||| +find_array_subscript||| +find_beginning||| +find_byclass||| +find_default_stash||| +find_hash_subscript||| +find_in_my_stash||| +find_lexical_cv||| +find_runcv_where||| +find_runcv||5.008001| +find_rundefsv2||| +find_rundefsvoffset||5.009002| +find_rundefsv||5.013002| +find_script||| +find_uninit_var||| +first_symbol|||n +fixup_errno_string||| +foldEQ_latin1||5.013008|n +foldEQ_locale||5.013002|n +foldEQ_utf8_flags||5.013010| +foldEQ_utf8||5.013002| +foldEQ||5.013002|n +fold_constants||| +forbid_setid||| +force_ident_maybe_lex||| +force_ident||| +force_list||| +force_next||| +force_strict_version||| +force_version||| +force_word||| +forget_pmop||| +form_nocontext|||vn +form_short_octal_warning||| +form||5.004000|v +fp_dup||| +fprintf_nocontext|||vn +free_c_backtrace||| +free_global_struct||| +free_tied_hv_pool||| +free_tmps||| +gen_constant_list||| +get_ANYOF_cp_list_for_ssc||| +get_and_check_backslash_N_name||| +get_aux_mg||| +get_av|5.006000||p +get_c_backtrace_dump||| +get_c_backtrace||| +get_context||5.006000|n +get_cvn_flags|5.009005||p +get_cvs|5.011000||p +get_cv|5.006000||p +get_db_sub||| +get_debug_opts||| +get_hash_seed||| +get_hv|5.006000||p +get_invlist_iter_addr|||n +get_invlist_offset_addr|||n +get_invlist_previous_index_addr|||n +get_mstats||| +get_no_modify||| +get_num||| +get_op_descs||5.005000| +get_op_names||5.005000| +get_opargs||| +get_ppaddr||5.006000| +get_re_arg||| +get_sv|5.006000||p +get_vtbl||5.005030| +getcwd_sv||5.007002| +getenv_len||| +glob_2number||| +glob_assign_glob||| +gp_dup||| +gp_free||| +gp_ref||| +grok_atoUV|||n +grok_bin|5.007003||p +grok_bslash_N||| +grok_bslash_c||| +grok_bslash_o||| +grok_bslash_x||| +grok_hex|5.007003||p +grok_infnan||5.021004| +grok_number_flags||5.021002| +grok_number|5.007002||p +grok_numeric_radix|5.007002||p +grok_oct|5.007003||p +group_end||| +gv_AVadd||| +gv_HVadd||| +gv_IOadd||| +gv_SVadd||| +gv_add_by_type||5.011000| +gv_autoload4||5.004000| +gv_autoload_pvn||5.015004| +gv_autoload_pv||5.015004| +gv_autoload_sv||5.015004| +gv_check||| +gv_const_sv||5.009003| +gv_dump||5.006000| +gv_efullname3||5.003070| +gv_efullname4||5.006001| +gv_efullname||| +gv_fetchfile_flags||5.009005| +gv_fetchfile||| +gv_fetchmeth_autoload||5.007003| +gv_fetchmeth_internal||| +gv_fetchmeth_pv_autoload||5.015004| +gv_fetchmeth_pvn_autoload||5.015004| +gv_fetchmeth_pvn||5.015004| +gv_fetchmeth_pv||5.015004| +gv_fetchmeth_sv_autoload||5.015004| +gv_fetchmeth_sv||5.015004| +gv_fetchmethod_autoload||5.004000| +gv_fetchmethod_pv_flags||5.015004| +gv_fetchmethod_pvn_flags||5.015004| +gv_fetchmethod_sv_flags||5.015004| +gv_fetchmethod||| +gv_fetchmeth||| +gv_fetchpvn_flags|5.009002||p +gv_fetchpvs|5.009004||p +gv_fetchpv||| +gv_fetchsv|5.009002||p +gv_fullname3||5.003070| +gv_fullname4||5.006001| +gv_fullname||| +gv_handler||5.007001| +gv_init_pvn||5.015004| +gv_init_pv||5.015004| +gv_init_svtype||| +gv_init_sv||5.015004| +gv_init||| +gv_is_in_main||| +gv_magicalize_isa||| +gv_magicalize||| +gv_name_set||5.009004| +gv_override||| +gv_setref||| +gv_stashpvn_internal||| +gv_stashpvn|5.003070||p +gv_stashpvs|5.009003||p +gv_stashpv||| +gv_stashsvpvn_cached||| +gv_stashsv||| +gv_try_downgrade||| +handle_regex_sets||| +he_dup||| +hek_dup||| +hfree_next_entry||| +hfreeentries||| +hsplit||| +hv_assert||| +hv_auxinit_internal|||n +hv_auxinit||| +hv_backreferences_p||| +hv_clear_placeholders||5.009001| +hv_clear||| +hv_common_key_len||5.010000| +hv_common||5.010000| +hv_copy_hints_hv||5.009004| +hv_delayfree_ent||5.004000| +hv_delete_common||| +hv_delete_ent||5.003070| +hv_delete||| +hv_eiter_p||5.009003| +hv_eiter_set||5.009003| +hv_ename_add||| +hv_ename_delete||| +hv_exists_ent||5.003070| +hv_exists||| +hv_fetch_ent||5.003070| +hv_fetchs|5.009003||p +hv_fetch||| +hv_fill||5.013002| +hv_free_ent_ret||| +hv_free_ent||5.004000| +hv_iterinit||| +hv_iterkeysv||5.003070| +hv_iterkey||| +hv_iternext_flags||5.008000| +hv_iternextsv||| +hv_iternext||| +hv_iterval||| +hv_kill_backrefs||| +hv_ksplit||5.003070| +hv_magic_check|||n +hv_magic||| +hv_name_set||5.009003| +hv_notallowed||| +hv_placeholders_get||5.009003| +hv_placeholders_p||| +hv_placeholders_set||5.009003| +hv_rand_set||5.018000| +hv_riter_p||5.009003| +hv_riter_set||5.009003| +hv_scalar||5.009001| +hv_store_ent||5.003070| +hv_store_flags||5.008000| +hv_stores|5.009004||p +hv_store||| +hv_undef_flags||| +hv_undef||| +ibcmp_locale||5.004000| +ibcmp_utf8||5.007003| +ibcmp||| +incline||| +incpush_if_exists||| +incpush_use_sep||| +incpush||| +ingroup||| +init_argv_symbols||| +init_constants||| +init_dbargs||| +init_debugger||| +init_global_struct||| +init_i18nl10n||5.006000| +init_i18nl14n||5.006000| +init_ids||| +init_interp||| +init_main_stash||| +init_perllib||| +init_postdump_symbols||| +init_predump_symbols||| +init_stacks||5.005000| +init_tm||5.007002| +inplace_aassign||| +instr|||n +intro_my||5.004000| +intuit_method||| +intuit_more||| +invert||| +invlist_array|||n +invlist_clone||| +invlist_extend||| +invlist_highest|||n +invlist_is_iterating|||n +invlist_iterfinish|||n +invlist_iterinit|||n +invlist_iternext|||n +invlist_max|||n +invlist_previous_index|||n +invlist_set_len||| +invlist_set_previous_index|||n +invlist_trim|||n +invoke_exception_hook||| +io_close||| +isALNUMC|5.006000||p +isALNUM_lazy||5.021001| +isALPHANUMERIC||5.017008| +isALPHA||| +isASCII|5.006000||p +isBLANK|5.006001||p +isCNTRL|5.006000||p +isDIGIT||| +isFOO_lc||| +isFOO_utf8_lc||| +isGCB|||n +isGRAPH|5.006000||p +isGV_with_GP|5.009004||p +isIDCONT||5.017008| +isIDFIRST_lazy||5.021001| +isIDFIRST||| +isLOWER||| +isOCTAL||5.013005| +isPRINT|5.004000||p +isPSXSPC|5.006001||p +isPUNCT|5.006000||p +isSB||| +isSPACE||| +isUPPER||| +isUTF8_CHAR||5.021001| +isWB||| +isWORDCHAR||5.013006| +isXDIGIT|5.006000||p +is_an_int||| +is_ascii_string||5.011000| +is_handle_constructor|||n +is_invariant_string||5.021007|n +is_lvalue_sub||5.007001| +is_safe_syscall||5.019004| +is_ssc_worth_it|||n +is_uni_alnum_lc||5.006000| +is_uni_alnumc_lc||5.017007| +is_uni_alnumc||5.017007| +is_uni_alnum||5.006000| +is_uni_alpha_lc||5.006000| +is_uni_alpha||5.006000| +is_uni_ascii_lc||5.006000| +is_uni_ascii||5.006000| +is_uni_blank_lc||5.017002| +is_uni_blank||5.017002| +is_uni_cntrl_lc||5.006000| +is_uni_cntrl||5.006000| +is_uni_digit_lc||5.006000| +is_uni_digit||5.006000| +is_uni_graph_lc||5.006000| +is_uni_graph||5.006000| +is_uni_idfirst_lc||5.006000| +is_uni_idfirst||5.006000| +is_uni_lower_lc||5.006000| +is_uni_lower||5.006000| +is_uni_print_lc||5.006000| +is_uni_print||5.006000| +is_uni_punct_lc||5.006000| +is_uni_punct||5.006000| +is_uni_space_lc||5.006000| +is_uni_space||5.006000| +is_uni_upper_lc||5.006000| +is_uni_upper||5.006000| +is_uni_xdigit_lc||5.006000| +is_uni_xdigit||5.006000| +is_utf8_alnumc||5.017007| +is_utf8_alnum||5.006000| +is_utf8_alpha||5.006000| +is_utf8_ascii||5.006000| +is_utf8_blank||5.017002| +is_utf8_char_buf||5.015008|n +is_utf8_char||5.006000|n +is_utf8_cntrl||5.006000| +is_utf8_common||| +is_utf8_digit||5.006000| +is_utf8_graph||5.006000| +is_utf8_idcont||5.008000| +is_utf8_idfirst||5.006000| +is_utf8_lower||5.006000| +is_utf8_mark||5.006000| +is_utf8_perl_space||5.011001| +is_utf8_perl_word||5.011001| +is_utf8_posix_digit||5.011001| +is_utf8_print||5.006000| +is_utf8_punct||5.006000| +is_utf8_space||5.006000| +is_utf8_string_loclen||5.009003|n +is_utf8_string_loc||5.008001|n +is_utf8_string||5.006001|n +is_utf8_upper||5.006000| +is_utf8_xdigit||5.006000| +is_utf8_xidcont||5.013010| +is_utf8_xidfirst||5.013010| +isa_lookup||| +isinfnansv||| +isinfnan||5.021004|n +items|||n +ix|||n +jmaybe||| +join_exact||| +keyword_plugin_standard||| +keyword||| +leave_common||| +leave_scope||| +lex_bufutf8||5.011002| +lex_discard_to||5.011002| +lex_grow_linestr||5.011002| +lex_next_chunk||5.011002| +lex_peek_unichar||5.011002| +lex_read_space||5.011002| +lex_read_to||5.011002| +lex_read_unichar||5.011002| +lex_start||5.009005| +lex_stuff_pvn||5.011002| +lex_stuff_pvs||5.013005| +lex_stuff_pv||5.013006| +lex_stuff_sv||5.011002| +lex_unstuff||5.011002| +listkids||| +list||| +load_module_nocontext|||vn +load_module|5.006000||pv +localize||| +looks_like_bool||| +looks_like_number||| +lop||| +mPUSHi|5.009002||p +mPUSHn|5.009002||p +mPUSHp|5.009002||p +mPUSHs|5.010001||p +mPUSHu|5.009002||p +mXPUSHi|5.009002||p +mXPUSHn|5.009002||p +mXPUSHp|5.009002||p +mXPUSHs|5.010001||p +mXPUSHu|5.009002||p +magic_clear_all_env||| +magic_cleararylen_p||| +magic_clearenv||| +magic_clearhints||| +magic_clearhint||| +magic_clearisa||| +magic_clearpack||| +magic_clearsig||| +magic_copycallchecker||| +magic_dump||5.006000| +magic_existspack||| +magic_freearylen_p||| +magic_freeovrld||| +magic_getarylen||| +magic_getdebugvar||| +magic_getdefelem||| +magic_getnkeys||| +magic_getpack||| +magic_getpos||| +magic_getsig||| +magic_getsubstr||| +magic_gettaint||| +magic_getuvar||| +magic_getvec||| +magic_get||| +magic_killbackrefs||| +magic_methcall1||| +magic_methcall|||v +magic_methpack||| +magic_nextpack||| +magic_regdata_cnt||| +magic_regdatum_get||| +magic_regdatum_set||| +magic_scalarpack||| +magic_set_all_env||| +magic_setarylen||| +magic_setcollxfrm||| +magic_setdbline||| +magic_setdebugvar||| +magic_setdefelem||| +magic_setenv||| +magic_sethint||| +magic_setisa||| +magic_setlvref||| +magic_setmglob||| +magic_setnkeys||| +magic_setpack||| +magic_setpos||| +magic_setregexp||| +magic_setsig||| +magic_setsubstr||| +magic_settaint||| +magic_setutf8||| +magic_setuvar||| +magic_setvec||| +magic_set||| +magic_sizepack||| +magic_wipepack||| +make_matcher||| +make_trie||| +malloc_good_size|||n +malloced_size|||n +malloc||5.007002|n +markstack_grow||5.021001| +matcher_matches_sv||| +maybe_multimagic_gv||| +mayberelocate||| +measure_struct||| +memEQs|5.009005||p +memEQ|5.004000||p +memNEs|5.009005||p +memNE|5.004000||p +mem_collxfrm||| +mem_log_common|||n +mess_alloc||| +mess_nocontext|||vn +mess_sv||5.013001| +mess||5.006000|v +mfree||5.007002|n +mg_clear||| +mg_copy||| +mg_dup||| +mg_find_mglob||| +mg_findext|5.013008||pn +mg_find|||n +mg_free_type||5.013006| +mg_free||| +mg_get||| +mg_length||5.005000| +mg_localize||| +mg_magical|||n +mg_set||| +mg_size||5.005000| +mini_mktime||5.007002|n +minus_v||| +missingterm||| +mode_from_discipline||| +modkids||| +more_bodies||| +more_sv||| +moreswitches||| +move_proto_attr||| +mro_clean_isarev||| +mro_gather_and_rename||| +mro_get_from_name||5.010001| +mro_get_linear_isa_dfs||| +mro_get_linear_isa||5.009005| +mro_get_private_data||5.010001| +mro_isa_changed_in||| +mro_meta_dup||| +mro_meta_init||| +mro_method_changed_in||5.009005| +mro_package_moved||| +mro_register||5.010001| +mro_set_mro||5.010001| +mro_set_private_data||5.010001| +mul128||| +mulexp10|||n +multideref_stringify||| +my_atof2||5.007002| +my_atof||5.006000| +my_attrs||| +my_bcopy|||n +my_bytes_to_utf8|||n +my_bzero|||n +my_chsize||| +my_clearenv||| +my_cxt_index||| +my_cxt_init||| +my_dirfd||5.009005|n +my_exit_jump||| +my_exit||| +my_failure_exit||5.004000| +my_fflush_all||5.006000| +my_fork||5.007003|n +my_kid||| +my_lstat_flags||| +my_lstat||5.021008| +my_memcmp|||n +my_memset|||n +my_pclose||5.003070| +my_popen_list||5.007001| +my_popen||5.003070| +my_setenv||| +my_setlocale||| +my_snprintf|5.009004||pvn +my_socketpair||5.007003|n +my_sprintf|5.009003||pvn +my_stat_flags||| +my_stat||5.021008| +my_strerror||5.021001| +my_strftime||5.007002| +my_strlcat|5.009004||pn +my_strlcpy|5.009004||pn +my_unexec||| +my_vsnprintf||5.009004|n +need_utf8|||n +newANONATTRSUB||5.006000| +newANONHASH||| +newANONLIST||| +newANONSUB||| +newASSIGNOP||| +newATTRSUB_x||| +newATTRSUB||5.006000| +newAVREF||| +newAV||| +newBINOP||| +newCONDOP||| +newCONSTSUB_flags||5.015006| +newCONSTSUB|5.004050||p +newCVREF||| +newDEFSVOP||5.021006| +newFORM||| +newFOROP||5.013007| +newGIVENOP||5.009003| +newGIVWHENOP||| +newGP||| +newGVOP||| +newGVREF||| +newGVgen_flags||5.015004| +newGVgen||| +newHVREF||| +newHVhv||5.005000| +newHV||| +newIO||| +newLISTOP||| +newLOGOP||| +newLOOPEX||| +newLOOPOP||| +newMETHOP_internal||| +newMETHOP_named||5.021005| +newMETHOP||5.021005| +newMYSUB||5.017004| +newNULLLIST||| +newOP||| +newPADNAMELIST||5.021007|n +newPADNAMEouter||5.021007|n +newPADNAMEpvn||5.021007|n +newPADOP||| +newPMOP||| +newPROG||| +newPVOP||| +newRANGE||| +newRV_inc|5.004000||p +newRV_noinc|5.004000||p +newRV||| +newSLICEOP||| +newSTATEOP||| +newSTUB||| +newSUB||| +newSVOP||| +newSVREF||| +newSV_type|5.009005||p +newSVavdefelem||| +newSVhek||5.009003| +newSViv||| +newSVnv||| +newSVpadname||5.017004| +newSVpv_share||5.013006| +newSVpvf_nocontext|||vn +newSVpvf||5.004000|v +newSVpvn_flags|5.010001||p +newSVpvn_share|5.007001||p +newSVpvn_utf8|5.010001||p +newSVpvn|5.004050||p +newSVpvs_flags|5.010001||p +newSVpvs_share|5.009003||p +newSVpvs|5.009003||p +newSVpv||| +newSVrv||| +newSVsv||| +newSVuv|5.006000||p +newSV||| +newUNOP_AUX||5.021007| +newUNOP||| +newWHENOP||5.009003| +newWHILEOP||5.013007| +newXS_deffile||| +newXS_flags||5.009004| +newXS_len_flags||| +newXSproto||5.006000| +newXS||5.006000| +new_collate||5.006000| +new_constant||| +new_ctype||5.006000| +new_he||| +new_logop||| +new_numeric||5.006000| +new_stackinfo||5.005000| +new_version||5.009000| +new_warnings_bitfield||| +next_symbol||| +nextargv||| +nextchar||| +ninstr|||n +no_bareword_allowed||| +no_fh_allowed||| +no_op||| +noperl_die|||vn +not_a_number||| +not_incrementable||| +nothreadhook||5.008000| +nuke_stacks||| +num_overflow|||n +oopsAV||| +oopsHV||| +op_append_elem||5.013006| +op_append_list||5.013006| +op_clear||| +op_contextualize||5.013006| +op_convert_list||5.021006| +op_dump||5.006000| +op_free||| +op_integerize||| +op_linklist||5.013006| +op_lvalue_flags||| +op_lvalue||5.013007| +op_null||5.007002| +op_parent||5.021002|n +op_prepend_elem||5.013006| +op_refcnt_dec||| +op_refcnt_inc||| +op_refcnt_lock||5.009002| +op_refcnt_unlock||5.009002| +op_relocate_sv||| +op_scope||5.013007| +op_sibling_splice||5.021002|n +op_std_init||| +op_unscope||| +open_script||| +openn_cleanup||| +openn_setup||| +opmethod_stash||| +opslab_force_free||| +opslab_free_nopad||| +opslab_free||| +pMY_CXT_|5.007003||p +pMY_CXT|5.007003||p +pTHX_|5.006000||p +pTHX|5.006000||p +packWARN|5.007003||p +pack_cat||5.007003| +pack_rec||| +package_version||| +package||| +packlist||5.008001| +pad_add_anon||5.008001| +pad_add_name_pvn||5.015001| +pad_add_name_pvs||5.015001| +pad_add_name_pv||5.015001| +pad_add_name_sv||5.015001| +pad_add_weakref||| +pad_alloc_name||| +pad_alloc||| +pad_block_start||| +pad_check_dup||| +pad_compname_type||5.009003| +pad_findlex||| +pad_findmy_pvn||5.015001| +pad_findmy_pvs||5.015001| +pad_findmy_pv||5.015001| +pad_findmy_sv||5.015001| +pad_fixup_inner_anons||| +pad_free||| +pad_leavemy||| +pad_new||5.008001| +pad_push||| +pad_reset||| +pad_setsv||| +pad_sv||| +pad_swipe||| +pad_tidy||5.008001| +padlist_dup||| +padlist_store||| +padname_dup||| +padname_free||| +padnamelist_dup||| +padnamelist_fetch||5.021007|n +padnamelist_free||| +padnamelist_store||5.021007| +parse_arithexpr||5.013008| +parse_barestmt||5.013007| +parse_block||5.013007| +parse_body||| +parse_fullexpr||5.013008| +parse_fullstmt||5.013005| +parse_gv_stash_name||| +parse_ident||| +parse_label||5.013007| +parse_listexpr||5.013008| +parse_lparen_question_flags||| +parse_stmtseq||5.013006| +parse_subsignature||| +parse_termexpr||5.013008| +parse_unicode_opts||| +parser_dup||| +parser_free_nexttoke_ops||| +parser_free||| +path_is_searchable|||n +peep||| +pending_ident||| +perl_alloc_using|||n +perl_alloc|||n +perl_clone_using|||n +perl_clone|||n +perl_construct|||n +perl_destruct||5.007003|n +perl_free|||n +perl_parse||5.006000|n +perl_run|||n +pidgone||| +pm_description||| +pmop_dump||5.006000| +pmruntime||| +pmtrans||| +pop_scope||| +populate_ANYOF_from_invlist||| +populate_isa|||v +pregcomp||5.009005| +pregexec||| +pregfree2||5.011000| +pregfree||| +prescan_version||5.011004| +printbuf||| +printf_nocontext|||vn +process_special_blocks||| +ptr_hash|||n +ptr_table_clear||5.009005| +ptr_table_fetch||5.009005| +ptr_table_find|||n +ptr_table_free||5.009005| +ptr_table_new||5.009005| +ptr_table_split||5.009005| +ptr_table_store||5.009005| +push_scope||| +put_charclass_bitmap_innards||| +put_code_point||| +put_range||| +pv_display|5.006000||p +pv_escape|5.009004||p +pv_pretty|5.009004||p +pv_uni_display||5.007003| +qerror||| +qsortsvu||| +quadmath_format_needed|||n +quadmath_format_single|||n +re_compile||5.009005| +re_croak2||| +re_dup_guts||| +re_intuit_start||5.019001| +re_intuit_string||5.006000| +re_op_compile||| +realloc||5.007002|n +reentrant_free||5.021008| +reentrant_init||5.021008| +reentrant_retry||5.021008|vn +reentrant_size||5.021008| +ref_array_or_hash||| +refcounted_he_chain_2hv||| +refcounted_he_fetch_pvn||| +refcounted_he_fetch_pvs||| +refcounted_he_fetch_pv||| +refcounted_he_fetch_sv||| +refcounted_he_free||| +refcounted_he_inc||| +refcounted_he_new_pvn||| +refcounted_he_new_pvs||| +refcounted_he_new_pv||| +refcounted_he_new_sv||| +refcounted_he_value||| +refkids||| +refto||| +ref||5.021008| +reg2Lanode||| +reg_check_named_buff_matched|||n +reg_named_buff_all||5.009005| +reg_named_buff_exists||5.009005| +reg_named_buff_fetch||5.009005| +reg_named_buff_firstkey||5.009005| +reg_named_buff_iter||| +reg_named_buff_nextkey||5.009005| +reg_named_buff_scalar||5.009005| +reg_named_buff||| +reg_node||| +reg_numbered_buff_fetch||| +reg_numbered_buff_length||| +reg_numbered_buff_store||| +reg_qr_package||| +reg_recode||| +reg_scan_name||| +reg_skipcomment|||n +reg_temp_copy||| +reganode||| +regatom||| +regbranch||| +regclass_swash||5.009004| +regclass||| +regcppop||| +regcppush||| +regcurly|||n +regdump_extflags||| +regdump_intflags||| +regdump||5.005000| +regdupe_internal||| +regexec_flags||5.005000| +regfree_internal||5.009005| +reghop3|||n +reghop4|||n +reghopmaybe3|||n +reginclass||| +reginitcolors||5.006000| +reginsert||| +regmatch||| +regnext||5.005000| +regnode_guts||| +regpatws|||n +regpiece||| +regpposixcc||| +regprop||| +regrepeat||| +regtail_study||| +regtail||| +regtry||| +reg||| +repeatcpy|||n +report_evil_fh||| +report_redefined_cv||| +report_uninit||| +report_wrongway_fh||| +require_pv||5.006000| +require_tie_mod||| +restore_magic||| +rninstr|||n +rpeep||| +rsignal_restore||| +rsignal_save||| +rsignal_state||5.004000| +rsignal||5.004000| +run_body||| +run_user_filter||| +runops_debug||5.005000| +runops_standard||5.005000| +rv2cv_op_cv||5.013006| +rvpv_dup||| +rxres_free||| +rxres_restore||| +rxres_save||| +safesyscalloc||5.006000|n +safesysfree||5.006000|n +safesysmalloc||5.006000|n +safesysrealloc||5.006000|n +same_dirent||| +save_I16||5.004000| +save_I32||| +save_I8||5.006000| +save_adelete||5.011000| +save_aelem_flags||5.011000| +save_aelem||5.004050| +save_aliased_sv||| +save_alloc||5.006000| +save_aptr||| +save_ary||| +save_bool||5.008001| +save_clearsv||| +save_delete||| +save_destructor_x||5.006000| +save_destructor||5.006000| +save_freeop||| +save_freepv||| +save_freesv||| +save_generic_pvref||5.006001| +save_generic_svref||5.005030| +save_gp||5.004000| +save_hash||| +save_hdelete||5.011000| +save_hek_flags|||n +save_helem_flags||5.011000| +save_helem||5.004050| +save_hints||5.010001| +save_hptr||| +save_int||| +save_item||| +save_iv||5.005000| +save_lines||| +save_list||| +save_long||| +save_magic_flags||| +save_mortalizesv||5.007001| +save_nogv||| +save_op||5.005000| +save_padsv_and_mortalize||5.010001| +save_pptr||| +save_pushi32ptr||5.010001| +save_pushptri32ptr||| +save_pushptrptr||5.010001| +save_pushptr||5.010001| +save_re_context||5.006000| +save_scalar_at||| +save_scalar||| +save_set_svflags||5.009000| +save_shared_pvref||5.007003| +save_sptr||| +save_strlen||| +save_svref||| +save_vptr||5.006000| +savepvn||| +savepvs||5.009003| +savepv||| +savesharedpvn||5.009005| +savesharedpvs||5.013006| +savesharedpv||5.007003| +savesharedsvpv||5.013006| +savestack_grow_cnt||5.008001| +savestack_grow||| +savesvpv||5.009002| +sawparens||| +scalar_mod_type|||n +scalarboolean||| +scalarkids||| +scalarseq||| +scalarvoid||| +scalar||| +scan_bin||5.006000| +scan_commit||| +scan_const||| +scan_formline||| +scan_heredoc||| +scan_hex||| +scan_ident||| +scan_inputsymbol||| +scan_num||5.007001| +scan_oct||| +scan_pat||| +scan_str||| +scan_subst||| +scan_trans||| +scan_version||5.009001| +scan_vstring||5.009005| +scan_word||| +search_const||| +seed||5.008001| +sequence_num||| +set_ANYOF_arg||| +set_caret_X||| +set_context||5.006000|n +set_numeric_local||5.006000| +set_numeric_radix||5.006000| +set_numeric_standard||5.006000| +set_padlist|||n +setdefout||| +share_hek_flags||| +share_hek||5.004000| +should_warn_nl|||n +si_dup||| +sighandler|||n +simplify_sort||| +skipspace_flags||| +softref2xv||| +sortcv_stacked||| +sortcv_xsub||| +sortcv||| +sortsv_flags||5.009003| +sortsv||5.007003| +space_join_names_mortal||| +ss_dup||| +ssc_add_range||| +ssc_and||| +ssc_anything||| +ssc_clear_locale|||n +ssc_cp_and||| +ssc_finalize||| +ssc_init||| +ssc_intersection||| +ssc_is_anything|||n +ssc_is_cp_posixl_init|||n +ssc_or||| +ssc_union||| +stack_grow||| +start_glob||| +start_subparse||5.004000| +stdize_locale||| +strEQ||| +strGE||| +strGT||| +strLE||| +strLT||| +strNE||| +str_to_version||5.006000| +strip_return||| +strnEQ||| +strnNE||| +study_chunk||| +sub_crush_depth||| +sublex_done||| +sublex_push||| +sublex_start||| +sv_2bool_flags||5.013006| +sv_2bool||| +sv_2cv||| +sv_2io||| +sv_2iuv_common||| +sv_2iuv_non_preserve||| +sv_2iv_flags||5.009001| +sv_2iv||| +sv_2mortal||| +sv_2num||| +sv_2nv_flags||5.013001| +sv_2pv_flags|5.007002||p +sv_2pv_nolen|5.006000||p +sv_2pvbyte_nolen|5.006000||p +sv_2pvbyte|5.006000||p +sv_2pvutf8_nolen||5.006000| +sv_2pvutf8||5.006000| +sv_2pv||| +sv_2uv_flags||5.009001| +sv_2uv|5.004000||p +sv_add_arena||| +sv_add_backref||| +sv_backoff|||n +sv_bless||| +sv_buf_to_ro||| +sv_buf_to_rw||| +sv_cat_decode||5.008001| +sv_catpv_flags||5.013006| +sv_catpv_mg|5.004050||p +sv_catpv_nomg||5.013006| +sv_catpvf_mg_nocontext|||pvn +sv_catpvf_mg|5.006000|5.004000|pv +sv_catpvf_nocontext|||vn +sv_catpvf||5.004000|v +sv_catpvn_flags||5.007002| +sv_catpvn_mg|5.004050||p +sv_catpvn_nomg|5.007002||p +sv_catpvn||| +sv_catpvs_flags||5.013006| +sv_catpvs_mg||5.013006| +sv_catpvs_nomg||5.013006| +sv_catpvs|5.009003||p +sv_catpv||| +sv_catsv_flags||5.007002| +sv_catsv_mg|5.004050||p +sv_catsv_nomg|5.007002||p +sv_catsv||| +sv_chop||| +sv_clean_all||| +sv_clean_objs||| +sv_clear||| +sv_cmp_flags||5.013006| +sv_cmp_locale_flags||5.013006| +sv_cmp_locale||5.004000| +sv_cmp||| +sv_collxfrm_flags||5.013006| +sv_collxfrm||| +sv_copypv_flags||5.017002| +sv_copypv_nomg||5.017002| +sv_copypv||| +sv_dec_nomg||5.013002| +sv_dec||| +sv_del_backref||| +sv_derived_from_pvn||5.015004| +sv_derived_from_pv||5.015004| +sv_derived_from_sv||5.015004| +sv_derived_from||5.004000| +sv_destroyable||5.010000| +sv_display||| +sv_does_pvn||5.015004| +sv_does_pv||5.015004| +sv_does_sv||5.015004| +sv_does||5.009004| +sv_dump||| +sv_dup_common||| +sv_dup_inc_multiple||| +sv_dup_inc||| +sv_dup||| +sv_eq_flags||5.013006| +sv_eq||| +sv_exp_grow||| +sv_force_normal_flags||5.007001| +sv_force_normal||5.006000| +sv_free2||| +sv_free_arenas||| +sv_free||| +sv_get_backrefs||5.021008|n +sv_gets||5.003070| +sv_grow||| +sv_i_ncmp||| +sv_inc_nomg||5.013002| +sv_inc||| +sv_insert_flags||5.010001| +sv_insert||| +sv_isa||| +sv_isobject||| +sv_iv||5.005000| +sv_kill_backrefs||| +sv_len_utf8_nomg||| +sv_len_utf8||5.006000| +sv_len||| +sv_magic_portable|5.021008|5.004000|p +sv_magicext_mglob||| +sv_magicext||5.007003| +sv_magic||| +sv_mortalcopy_flags||| +sv_mortalcopy||| +sv_ncmp||| +sv_newmortal||| +sv_newref||| +sv_nolocking||5.007003| +sv_nosharing||5.007003| +sv_nounlocking||| +sv_nv||5.005000| +sv_only_taint_gmagic|||n +sv_or_pv_pos_u2b||| +sv_peek||5.005000| +sv_pos_b2u_flags||5.019003| +sv_pos_b2u_midway||| +sv_pos_b2u||5.006000| +sv_pos_u2b_cached||| +sv_pos_u2b_flags||5.011005| +sv_pos_u2b_forwards|||n +sv_pos_u2b_midway|||n +sv_pos_u2b||5.006000| +sv_pvbyten_force||5.006000| +sv_pvbyten||5.006000| +sv_pvbyte||5.006000| +sv_pvn_force_flags|5.007002||p +sv_pvn_force||| +sv_pvn_nomg|5.007003|5.005000|p +sv_pvn||5.005000| +sv_pvutf8n_force||5.006000| +sv_pvutf8n||5.006000| +sv_pvutf8||5.006000| +sv_pv||5.006000| +sv_recode_to_utf8||5.007003| +sv_reftype||| +sv_ref||| +sv_release_COW||| +sv_replace||| +sv_report_used||| +sv_resetpvn||| +sv_reset||| +sv_rvweaken||5.006000| +sv_sethek||| +sv_setiv_mg|5.004050||p +sv_setiv||| +sv_setnv_mg|5.006000||p +sv_setnv||| +sv_setpv_mg|5.004050||p +sv_setpvf_mg_nocontext|||pvn +sv_setpvf_mg|5.006000|5.004000|pv +sv_setpvf_nocontext|||vn +sv_setpvf||5.004000|v +sv_setpviv_mg||5.008001| +sv_setpviv||5.008001| +sv_setpvn_mg|5.004050||p +sv_setpvn||| +sv_setpvs_mg||5.013006| +sv_setpvs|5.009004||p +sv_setpv||| +sv_setref_iv||| +sv_setref_nv||| +sv_setref_pvn||| +sv_setref_pvs||5.021008| +sv_setref_pv||| +sv_setref_uv||5.007001| +sv_setsv_cow||| +sv_setsv_flags||5.007002| +sv_setsv_mg|5.004050||p +sv_setsv_nomg|5.007002||p +sv_setsv||| +sv_setuv_mg|5.004050||p +sv_setuv|5.004000||p +sv_tainted||5.004000| +sv_taint||5.004000| +sv_true||5.005000| +sv_unglob||| +sv_uni_display||5.007003| +sv_unmagicext|5.013008||p +sv_unmagic||| +sv_unref_flags||5.007001| +sv_unref||| +sv_untaint||5.004000| +sv_upgrade||| +sv_usepvn_flags||5.009004| +sv_usepvn_mg|5.004050||p +sv_usepvn||| +sv_utf8_decode||5.006000| +sv_utf8_downgrade||5.006000| +sv_utf8_encode||5.006000| +sv_utf8_upgrade_flags_grow||5.011000| +sv_utf8_upgrade_flags||5.007002| +sv_utf8_upgrade_nomg||5.007002| +sv_utf8_upgrade||5.007001| +sv_uv|5.005000||p +sv_vcatpvf_mg|5.006000|5.004000|p +sv_vcatpvfn_flags||5.017002| +sv_vcatpvfn||5.004000| +sv_vcatpvf|5.006000|5.004000|p +sv_vsetpvf_mg|5.006000|5.004000|p +sv_vsetpvfn||5.004000| +sv_vsetpvf|5.006000|5.004000|p +svtype||| +swallow_bom||| +swash_fetch||5.007002| +swash_init||5.006000| +swash_scan_list_line||| +swatch_get||| +sync_locale||5.021004| +sys_init3||5.010000|n +sys_init||5.010000|n +sys_intern_clear||| +sys_intern_dup||| +sys_intern_init||| +sys_term||5.010000|n +taint_env||| +taint_proper||| +tied_method|||v +tmps_grow_p||| +toFOLD_uni||5.007003| +toFOLD_utf8||5.019001| +toFOLD||5.019001| +toLOWER_L1||5.019001| +toLOWER_LC||5.004000| +toLOWER_uni||5.007003| +toLOWER_utf8||5.015007| +toLOWER||| +toTITLE_uni||5.007003| +toTITLE_utf8||5.015007| +toTITLE||5.019001| +toUPPER_uni||5.007003| +toUPPER_utf8||5.015007| +toUPPER||| +to_byte_substr||| +to_lower_latin1|||n +to_uni_fold||5.007003| +to_uni_lower_lc||5.006000| +to_uni_lower||5.007003| +to_uni_title_lc||5.006000| +to_uni_title||5.007003| +to_uni_upper_lc||5.006000| +to_uni_upper||5.007003| +to_utf8_case||5.007003| +to_utf8_fold||5.015007| +to_utf8_lower||5.015007| +to_utf8_substr||| +to_utf8_title||5.015007| +to_utf8_upper||5.015007| +tokenize_use||| +tokeq||| +tokereport||| +too_few_arguments_pv||| +too_many_arguments_pv||| +translate_substr_offsets|||n +try_amagic_bin||| +try_amagic_un||| +uiv_2buf|||n +unlnk||| +unpack_rec||| +unpack_str||5.007003| +unpackstring||5.008001| +unreferenced_to_tmp_stack||| +unshare_hek_or_pvn||| +unshare_hek||| +unsharepvn||5.003070| +unwind_handler_stack||| +update_debugger_info||| +upg_version||5.009005| +usage||| +utf16_textfilter||| +utf16_to_utf8_reversed||5.006001| +utf16_to_utf8||5.006001| +utf8_distance||5.006000| +utf8_hop||5.006000|n +utf8_length||5.007001| +utf8_mg_len_cache_update||| +utf8_mg_pos_cache_update||| +utf8_to_bytes||5.006001| +utf8_to_uvchr_buf||5.015009| +utf8_to_uvchr||5.007001| +utf8_to_uvuni_buf||5.015009| +utf8_to_uvuni||5.007001| +utf8n_to_uvchr||5.007001| +utf8n_to_uvuni||5.007001| +utilize||| +uvchr_to_utf8_flags||5.007003| +uvchr_to_utf8||5.007001| +uvoffuni_to_utf8_flags||5.019004| +uvuni_to_utf8_flags||5.007003| +uvuni_to_utf8||5.007001| +valid_utf8_to_uvchr||5.015009| +valid_utf8_to_uvuni||5.015009| +validate_proto||| +validate_suid||| +varname||| +vcmp||5.009000| +vcroak||5.006000| +vdeb||5.007003| +vform||5.006000| +visit||| +vivify_defelem||| +vivify_ref||| +vload_module|5.006000||p +vmess||5.006000| +vnewSVpvf|5.006000|5.004000|p +vnormal||5.009002| +vnumify||5.009000| +vstringify||5.009000| +vverify||5.009003| +vwarner||5.006000| +vwarn||5.006000| +wait4pid||| +warn_nocontext|||vn +warn_sv||5.013001| +warner_nocontext|||vn +warner|5.006000|5.004000|pv +warn|||v +was_lvalue_sub||| +watch||| +whichsig_pvn||5.015004| +whichsig_pv||5.015004| +whichsig_sv||5.015004| +whichsig||| +win32_croak_not_implemented|||n +with_queued_errors||| +wrap_op_checker||5.015008| +write_to_stderr||| +xs_boot_epilog||| +xs_handshake|||vn +xs_version_bootcheck||| +yyerror_pvn||| +yyerror_pv||| +yyerror||| +yylex||| +yyparse||| +yyunlex||| +yywarn||| +); + +if (exists $opt{'list-unsupported'}) { + my $f; + for $f (sort { lc $a cmp lc $b } keys %API) { + next unless $API{$f}{todo}; + print "$f ", '.'x(40-length($f)), " ", format_version($API{$f}{todo}), "\n"; + } + exit 0; +} + +# Scan for possible replacement candidates + +my(%replace, %need, %hints, %warnings, %depends); +my $replace = 0; +my($hint, $define, $function); + +sub find_api +{ + my $code = shift; + $code =~ s{ + / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]*) + | "[^"\\]*(?:\\.[^"\\]*)*" + | '[^'\\]*(?:\\.[^'\\]*)*' }{}egsx; + grep { exists $API{$_} } $code =~ /(\w+)/mg; +} + +while () { + if ($hint) { + my $h = $hint->[0] eq 'Hint' ? \%hints : \%warnings; + if (m{^\s*\*\s(.*?)\s*$}) { + for (@{$hint->[1]}) { + $h->{$_} ||= ''; # suppress warning with older perls + $h->{$_} .= "$1\n"; + } + } + else { undef $hint } + } + + $hint = [$1, [split /,?\s+/, $2]] + if m{^\s*$rccs\s+(Hint|Warning):\s+(\w+(?:,?\s+\w+)*)\s*$}; + + if ($define) { + if ($define->[1] =~ /\\$/) { + $define->[1] .= $_; + } + else { + if (exists $API{$define->[0]} && $define->[1] !~ /^DPPP_\(/) { + my @n = find_api($define->[1]); + push @{$depends{$define->[0]}}, @n if @n + } + undef $define; + } + } + + $define = [$1, $2] if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(.*)}; + + if ($function) { + if (/^}/) { + if (exists $API{$function->[0]}) { + my @n = find_api($function->[1]); + push @{$depends{$function->[0]}}, @n if @n + } + undef $function; + } + else { + $function->[1] .= $_; + } + } + + $function = [$1, ''] if m{^DPPP_\(my_(\w+)\)}; + + $replace = $1 if m{^\s*$rccs\s+Replace:\s+(\d+)\s+$rcce\s*$}; + $replace{$2} = $1 if $replace and m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+)}; + $replace{$2} = $1 if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+).*$rccs\s+Replace\s+$rcce}; + $replace{$1} = $2 if m{^\s*$rccs\s+Replace (\w+) with (\w+)\s+$rcce\s*$}; + + if (m{^\s*$rccs\s+(\w+(\s*,\s*\w+)*)\s+depends\s+on\s+(\w+(\s*,\s*\w+)*)\s+$rcce\s*$}) { + my @deps = map { s/\s+//g; $_ } split /,/, $3; + my $d; + for $d (map { s/\s+//g; $_ } split /,/, $1) { + push @{$depends{$d}}, @deps; + } + } + + $need{$1} = 1 if m{^#if\s+defined\(NEED_(\w+)(?:_GLOBAL)?\)}; +} + +for (values %depends) { + my %s; + $_ = [sort grep !$s{$_}++, @$_]; +} + +if (exists $opt{'api-info'}) { + my $f; + my $count = 0; + my $match = $opt{'api-info'} =~ m!^/(.*)/$! ? $1 : "^\Q$opt{'api-info'}\E\$"; + for $f (sort { lc $a cmp lc $b } keys %API) { + next unless $f =~ /$match/; + print "\n=== $f ===\n\n"; + my $info = 0; + if ($API{$f}{base} || $API{$f}{todo}) { + my $base = format_version($API{$f}{base} || $API{$f}{todo}); + print "Supported at least starting from perl-$base.\n"; + $info++; + } + if ($API{$f}{provided}) { + my $todo = $API{$f}{todo} ? format_version($API{$f}{todo}) : "5.003"; + print "Support by $ppport provided back to perl-$todo.\n"; + print "Support needs to be explicitly requested by NEED_$f.\n" if exists $need{$f}; + print "Depends on: ", join(', ', @{$depends{$f}}), ".\n" if exists $depends{$f}; + print "\n$hints{$f}" if exists $hints{$f}; + print "\nWARNING:\n$warnings{$f}" if exists $warnings{$f}; + $info++; + } + print "No portability information available.\n" unless $info; + $count++; + } + $count or print "Found no API matching '$opt{'api-info'}'."; + print "\n"; + exit 0; +} + +if (exists $opt{'list-provided'}) { + my $f; + for $f (sort { lc $a cmp lc $b } keys %API) { + next unless $API{$f}{provided}; + my @flags; + push @flags, 'explicit' if exists $need{$f}; + push @flags, 'depend' if exists $depends{$f}; + push @flags, 'hint' if exists $hints{$f}; + push @flags, 'warning' if exists $warnings{$f}; + my $flags = @flags ? ' ['.join(', ', @flags).']' : ''; + print "$f$flags\n"; + } + exit 0; +} + +my @files; +my @srcext = qw( .xs .c .h .cc .cpp -c.inc -xs.inc ); +my $srcext = join '|', map { quotemeta $_ } @srcext; + +if (@ARGV) { + my %seen; + for (@ARGV) { + if (-e) { + if (-f) { + push @files, $_ unless $seen{$_}++; + } + else { warn "'$_' is not a file.\n" } + } + else { + my @new = grep { -f } glob $_ + or warn "'$_' does not exist.\n"; + push @files, grep { !$seen{$_}++ } @new; + } + } +} +else { + eval { + require File::Find; + File::Find::find(sub { + $File::Find::name =~ /($srcext)$/i + and push @files, $File::Find::name; + }, '.'); + }; + if ($@) { + @files = map { glob "*$_" } @srcext; + } +} + +if (!@ARGV || $opt{filter}) { + my(@in, @out); + my %xsc = map { /(.*)\.xs$/ ? ("$1.c" => 1, "$1.cc" => 1) : () } @files; + for (@files) { + my $out = exists $xsc{$_} || /\b\Q$ppport\E$/i || !/($srcext)$/i; + push @{ $out ? \@out : \@in }, $_; + } + if (@ARGV && @out) { + warning("Skipping the following files (use --nofilter to avoid this):\n| ", join "\n| ", @out); + } + @files = @in; +} + +die "No input files given!\n" unless @files; + +my(%files, %global, %revreplace); +%revreplace = reverse %replace; +my $filename; +my $patch_opened = 0; + +for $filename (@files) { + unless (open IN, "<$filename") { + warn "Unable to read from $filename: $!\n"; + next; + } + + info("Scanning $filename ..."); + + my $c = do { local $/; }; + close IN; + + my %file = (orig => $c, changes => 0); + + # Temporarily remove C/XS comments and strings from the code + my @ccom; + + $c =~ s{ + ( ^$HS*\#$HS*include\b[^\r\n]+\b(?:\Q$ppport\E|XSUB\.h)\b[^\r\n]* + | ^$HS*\#$HS*(?:define|elif|if(?:def)?)\b[^\r\n]* ) + | ( ^$HS*\#[^\r\n]* + | "[^"\\]*(?:\\.[^"\\]*)*" + | '[^'\\]*(?:\\.[^'\\]*)*' + | / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]* ) ) + }{ defined $2 and push @ccom, $2; + defined $1 ? $1 : "$ccs$#ccom$cce" }mgsex; + + $file{ccom} = \@ccom; + $file{code} = $c; + $file{has_inc_ppport} = $c =~ /^$HS*#$HS*include[^\r\n]+\b\Q$ppport\E\b/m; + + my $func; + + for $func (keys %API) { + my $match = $func; + $match .= "|$revreplace{$func}" if exists $revreplace{$func}; + if ($c =~ /\b(?:Perl_)?($match)\b/) { + $file{uses_replace}{$1}++ if exists $revreplace{$func} && $1 eq $revreplace{$func}; + $file{uses_Perl}{$func}++ if $c =~ /\bPerl_$func\b/; + if (exists $API{$func}{provided}) { + $file{uses_provided}{$func}++; + if (!exists $API{$func}{base} || $API{$func}{base} > $opt{'compat-version'}) { + $file{uses}{$func}++; + my @deps = rec_depend($func); + if (@deps) { + $file{uses_deps}{$func} = \@deps; + for (@deps) { + $file{uses}{$_} = 0 unless exists $file{uses}{$_}; + } + } + for ($func, @deps) { + $file{needs}{$_} = 'static' if exists $need{$_}; + } + } + } + if (exists $API{$func}{todo} && $API{$func}{todo} > $opt{'compat-version'}) { + if ($c =~ /\b$func\b/) { + $file{uses_todo}{$func}++; + } + } + } + } + + while ($c =~ /^$HS*#$HS*define$HS+(NEED_(\w+?)(_GLOBAL)?)\b/mg) { + if (exists $need{$2}) { + $file{defined $3 ? 'needed_global' : 'needed_static'}{$2}++; + } + else { warning("Possibly wrong #define $1 in $filename") } + } + + for (qw(uses needs uses_todo needed_global needed_static)) { + for $func (keys %{$file{$_}}) { + push @{$global{$_}{$func}}, $filename; + } + } + + $files{$filename} = \%file; +} + +# Globally resolve NEED_'s +my $need; +for $need (keys %{$global{needs}}) { + if (@{$global{needs}{$need}} > 1) { + my @targets = @{$global{needs}{$need}}; + my @t = grep $files{$_}{needed_global}{$need}, @targets; + @targets = @t if @t; + @t = grep /\.xs$/i, @targets; + @targets = @t if @t; + my $target = shift @targets; + $files{$target}{needs}{$need} = 'global'; + for (@{$global{needs}{$need}}) { + $files{$_}{needs}{$need} = 'extern' if $_ ne $target; + } + } +} + +for $filename (@files) { + exists $files{$filename} or next; + + info("=== Analyzing $filename ==="); + + my %file = %{$files{$filename}}; + my $func; + my $c = $file{code}; + my $warnings = 0; + + for $func (sort keys %{$file{uses_Perl}}) { + if ($API{$func}{varargs}) { + unless ($API{$func}{nothxarg}) { + my $changes = ($c =~ s{\b(Perl_$func\s*\(\s*)(?!aTHX_?)(\)|[^\s)]*\))} + { $1 . ($2 eq ')' ? 'aTHX' : 'aTHX_ ') . $2 }ge); + if ($changes) { + warning("Doesn't pass interpreter argument aTHX to Perl_$func"); + $file{changes} += $changes; + } + } + } + else { + warning("Uses Perl_$func instead of $func"); + $file{changes} += ($c =~ s{\bPerl_$func(\s*)\((\s*aTHX_?)?\s*} + {$func$1(}g); + } + } + + for $func (sort keys %{$file{uses_replace}}) { + warning("Uses $func instead of $replace{$func}"); + $file{changes} += ($c =~ s/\b$func\b/$replace{$func}/g); + } + + for $func (sort keys %{$file{uses_provided}}) { + if ($file{uses}{$func}) { + if (exists $file{uses_deps}{$func}) { + diag("Uses $func, which depends on ", join(', ', @{$file{uses_deps}{$func}})); + } + else { + diag("Uses $func"); + } + } + $warnings += hint($func); + } + + unless ($opt{quiet}) { + for $func (sort keys %{$file{uses_todo}}) { + print "*** WARNING: Uses $func, which may not be portable below perl ", + format_version($API{$func}{todo}), ", even with '$ppport'\n"; + $warnings++; + } + } + + for $func (sort keys %{$file{needed_static}}) { + my $message = ''; + if (not exists $file{uses}{$func}) { + $message = "No need to define NEED_$func if $func is never used"; + } + elsif (exists $file{needs}{$func} && $file{needs}{$func} ne 'static') { + $message = "No need to define NEED_$func when already needed globally"; + } + if ($message) { + diag($message); + $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_$func\b.*$LF//mg); + } + } + + for $func (sort keys %{$file{needed_global}}) { + my $message = ''; + if (not exists $global{uses}{$func}) { + $message = "No need to define NEED_${func}_GLOBAL if $func is never used"; + } + elsif (exists $file{needs}{$func}) { + if ($file{needs}{$func} eq 'extern') { + $message = "No need to define NEED_${func}_GLOBAL when already needed globally"; + } + elsif ($file{needs}{$func} eq 'static') { + $message = "No need to define NEED_${func}_GLOBAL when only used in this file"; + } + } + if ($message) { + diag($message); + $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_${func}_GLOBAL\b.*$LF//mg); + } + } + + $file{needs_inc_ppport} = keys %{$file{uses}}; + + if ($file{needs_inc_ppport}) { + my $pp = ''; + + for $func (sort keys %{$file{needs}}) { + my $type = $file{needs}{$func}; + next if $type eq 'extern'; + my $suffix = $type eq 'global' ? '_GLOBAL' : ''; + unless (exists $file{"needed_$type"}{$func}) { + if ($type eq 'global') { + diag("Files [@{$global{needs}{$func}}] need $func, adding global request"); + } + else { + diag("File needs $func, adding static request"); + } + $pp .= "#define NEED_$func$suffix\n"; + } + } + + if ($pp && ($c =~ s/^(?=$HS*#$HS*define$HS+NEED_\w+)/$pp/m)) { + $pp = ''; + $file{changes}++; + } + + unless ($file{has_inc_ppport}) { + diag("Needs to include '$ppport'"); + $pp .= qq(#include "$ppport"\n) + } + + if ($pp) { + $file{changes} += ($c =~ s/^($HS*#$HS*define$HS+NEED_\w+.*?)^/$1$pp/ms) + || ($c =~ s/^(?=$HS*#$HS*include.*\Q$ppport\E)/$pp/m) + || ($c =~ s/^($HS*#$HS*include.*XSUB.*\s*?)^/$1$pp/m) + || ($c =~ s/^/$pp/); + } + } + else { + if ($file{has_inc_ppport}) { + diag("No need to include '$ppport'"); + $file{changes} += ($c =~ s/^$HS*?#$HS*include.*\Q$ppport\E.*?$LF//m); + } + } + + # put back in our C comments + my $ix; + my $cppc = 0; + my @ccom = @{$file{ccom}}; + for $ix (0 .. $#ccom) { + if (!$opt{cplusplus} && $ccom[$ix] =~ s!^//!!) { + $cppc++; + $file{changes} += $c =~ s/$rccs$ix$rcce/$ccs$ccom[$ix] $cce/; + } + else { + $c =~ s/$rccs$ix$rcce/$ccom[$ix]/; + } + } + + if ($cppc) { + my $s = $cppc != 1 ? 's' : ''; + warning("Uses $cppc C++ style comment$s, which is not portable"); + } + + my $s = $warnings != 1 ? 's' : ''; + my $warn = $warnings ? " ($warnings warning$s)" : ''; + info("Analysis completed$warn"); + + if ($file{changes}) { + if (exists $opt{copy}) { + my $newfile = "$filename$opt{copy}"; + if (-e $newfile) { + error("'$newfile' already exists, refusing to write copy of '$filename'"); + } + else { + local *F; + if (open F, ">$newfile") { + info("Writing copy of '$filename' with changes to '$newfile'"); + print F $c; + close F; + } + else { + error("Cannot open '$newfile' for writing: $!"); + } + } + } + elsif (exists $opt{patch} || $opt{changes}) { + if (exists $opt{patch}) { + unless ($patch_opened) { + if (open PATCH, ">$opt{patch}") { + $patch_opened = 1; + } + else { + error("Cannot open '$opt{patch}' for writing: $!"); + delete $opt{patch}; + $opt{changes} = 1; + goto fallback; + } + } + mydiff(\*PATCH, $filename, $c); + } + else { +fallback: + info("Suggested changes:"); + mydiff(\*STDOUT, $filename, $c); + } + } + else { + my $s = $file{changes} == 1 ? '' : 's'; + info("$file{changes} potentially required change$s detected"); + } + } + else { + info("Looks good"); + } +} + +close PATCH if $patch_opened; + +exit 0; + + +sub try_use { eval "use @_;"; return $@ eq '' } + +sub mydiff +{ + local *F = shift; + my($file, $str) = @_; + my $diff; + + if (exists $opt{diff}) { + $diff = run_diff($opt{diff}, $file, $str); + } + + if (!defined $diff and try_use('Text::Diff')) { + $diff = Text::Diff::diff($file, \$str, { STYLE => 'Unified' }); + $diff = <
$tmp") { + print F $str; + close F; + + if (open F, "$prog $file $tmp |") { + while () { + s/\Q$tmp\E/$file.patched/; + $diff .= $_; + } + close F; + unlink $tmp; + return $diff; + } + + unlink $tmp; + } + else { + error("Cannot open '$tmp' for writing: $!"); + } + + return undef; +} + +sub rec_depend +{ + my($func, $seen) = @_; + return () unless exists $depends{$func}; + $seen = {%{$seen||{}}}; + return () if $seen->{$func}++; + my %s; + grep !$s{$_}++, map { ($_, rec_depend($_, $seen)) } @{$depends{$func}}; +} + +sub parse_version +{ + my $ver = shift; + + if ($ver =~ /^(\d+)\.(\d+)\.(\d+)$/) { + return ($1, $2, $3); + } + elsif ($ver !~ /^\d+\.[\d_]+$/) { + die "cannot parse version '$ver'\n"; + } + + $ver =~ s/_//g; + $ver =~ s/$/000000/; + + my($r,$v,$s) = $ver =~ /(\d+)\.(\d{3})(\d{3})/; + + $v = int $v; + $s = int $s; + + if ($r < 5 || ($r == 5 && $v < 6)) { + if ($s % 10) { + die "cannot parse version '$ver'\n"; + } + } + + return ($r, $v, $s); +} + +sub format_version +{ + my $ver = shift; + + $ver =~ s/$/000000/; + my($r,$v,$s) = $ver =~ /(\d+)\.(\d{3})(\d{3})/; + + $v = int $v; + $s = int $s; + + if ($r < 5 || ($r == 5 && $v < 6)) { + if ($s % 10) { + die "invalid version '$ver'\n"; + } + $s /= 10; + + $ver = sprintf "%d.%03d", $r, $v; + $s > 0 and $ver .= sprintf "_%02d", $s; + + return $ver; + } + + return sprintf "%d.%d.%d", $r, $v, $s; +} + +sub info +{ + $opt{quiet} and return; + print @_, "\n"; +} + +sub diag +{ + $opt{quiet} and return; + $opt{diag} and print @_, "\n"; +} + +sub warning +{ + $opt{quiet} and return; + print "*** ", @_, "\n"; +} + +sub error +{ + print "*** ERROR: ", @_, "\n"; +} + +my %given_hints; +my %given_warnings; +sub hint +{ + $opt{quiet} and return; + my $func = shift; + my $rv = 0; + if (exists $warnings{$func} && !$given_warnings{$func}++) { + my $warn = $warnings{$func}; + $warn =~ s!^!*** !mg; + print "*** WARNING: $func\n", $warn; + $rv++; + } + if ($opt{hints} && exists $hints{$func} && !$given_hints{$func}++) { + my $hint = $hints{$func}; + $hint =~ s/^/ /mg; + print " --- hint for $func ---\n", $hint; + } + $rv; +} + +sub usage +{ + my($usage) = do { local(@ARGV,$/)=($0); <> } =~ /^=head\d$HS+SYNOPSIS\s*^(.*?)\s*^=/ms; + my %M = ( 'I' => '*' ); + $usage =~ s/^\s*perl\s+\S+/$^X $0/; + $usage =~ s/([A-Z])<([^>]+)>/$M{$1}$2$M{$1}/g; + + print < }; + my($copy) = $self =~ /^=head\d\s+COPYRIGHT\s*^(.*?)^=\w+/ms; + $copy =~ s/^(?=\S+)/ /gms; + $self =~ s/^$HS+Do NOT edit.*?(?=^-)/$copy/ms; + $self =~ s/^SKIP.*(?=^__DATA__)/SKIP +if (\@ARGV && \$ARGV[0] eq '--unstrip') { + eval { require Devel::PPPort }; + \$@ and die "Cannot require Devel::PPPort, please install.\\n"; + if (eval \$Devel::PPPort::VERSION < $VERSION) { + die "$0 was originally generated with Devel::PPPort $VERSION.\\n" + . "Your Devel::PPPort is only version \$Devel::PPPort::VERSION.\\n" + . "Please install a newer version, or --unstrip will not work.\\n"; + } + Devel::PPPort::WriteFile(\$0); + exit 0; +} +print <$0" or die "cannot strip $0: $!\n"; + print OUT "$pl$c\n"; + + exit 0; +} + +__DATA__ +*/ + +#ifndef _P_P_PORTABILITY_H_ +#define _P_P_PORTABILITY_H_ + +#ifndef DPPP_NAMESPACE +# define DPPP_NAMESPACE DPPP_ +#endif + +#define DPPP_CAT2(x,y) CAT2(x,y) +#define DPPP_(name) DPPP_CAT2(DPPP_NAMESPACE, name) + +#ifndef PERL_REVISION +# if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION)) +# define PERL_PATCHLEVEL_H_IMPLICIT +# include +# endif +# if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL))) +# include +# endif +# ifndef PERL_REVISION +# define PERL_REVISION (5) + /* Replace: 1 */ +# define PERL_VERSION PATCHLEVEL +# define PERL_SUBVERSION SUBVERSION + /* Replace PERL_PATCHLEVEL with PERL_VERSION */ + /* Replace: 0 */ +# endif +#endif + +#define _dpppDEC2BCD(dec) ((((dec)/100)<<8)|((((dec)%100)/10)<<4)|((dec)%10)) +#define PERL_BCDVERSION ((_dpppDEC2BCD(PERL_REVISION)<<24)|(_dpppDEC2BCD(PERL_VERSION)<<12)|_dpppDEC2BCD(PERL_SUBVERSION)) + +/* It is very unlikely that anyone will try to use this with Perl 6 + (or greater), but who knows. + */ +#if PERL_REVISION != 5 +# error ppport.h only works with Perl version 5 +#endif /* PERL_REVISION != 5 */ +#ifndef dTHR +# define dTHR dNOOP +#endif +#ifndef dTHX +# define dTHX dNOOP +#endif + +#ifndef dTHXa +# define dTHXa(x) dNOOP +#endif +#ifndef pTHX +# define pTHX void +#endif + +#ifndef pTHX_ +# define pTHX_ +#endif + +#ifndef aTHX +# define aTHX +#endif + +#ifndef aTHX_ +# define aTHX_ +#endif + +#if (PERL_BCDVERSION < 0x5006000) +# ifdef USE_THREADS +# define aTHXR thr +# define aTHXR_ thr, +# else +# define aTHXR +# define aTHXR_ +# endif +# define dTHXR dTHR +#else +# define aTHXR aTHX +# define aTHXR_ aTHX_ +# define dTHXR dTHX +#endif +#ifndef dTHXoa +# define dTHXoa(x) dTHXa(x) +#endif + +#ifdef I_LIMITS +# include +#endif + +#ifndef PERL_UCHAR_MIN +# define PERL_UCHAR_MIN ((unsigned char)0) +#endif + +#ifndef PERL_UCHAR_MAX +# ifdef UCHAR_MAX +# define PERL_UCHAR_MAX ((unsigned char)UCHAR_MAX) +# else +# ifdef MAXUCHAR +# define PERL_UCHAR_MAX ((unsigned char)MAXUCHAR) +# else +# define PERL_UCHAR_MAX ((unsigned char)~(unsigned)0) +# endif +# endif +#endif + +#ifndef PERL_USHORT_MIN +# define PERL_USHORT_MIN ((unsigned short)0) +#endif + +#ifndef PERL_USHORT_MAX +# ifdef USHORT_MAX +# define PERL_USHORT_MAX ((unsigned short)USHORT_MAX) +# else +# ifdef MAXUSHORT +# define PERL_USHORT_MAX ((unsigned short)MAXUSHORT) +# else +# ifdef USHRT_MAX +# define PERL_USHORT_MAX ((unsigned short)USHRT_MAX) +# else +# define PERL_USHORT_MAX ((unsigned short)~(unsigned)0) +# endif +# endif +# endif +#endif + +#ifndef PERL_SHORT_MAX +# ifdef SHORT_MAX +# define PERL_SHORT_MAX ((short)SHORT_MAX) +# else +# ifdef MAXSHORT /* Often used in */ +# define PERL_SHORT_MAX ((short)MAXSHORT) +# else +# ifdef SHRT_MAX +# define PERL_SHORT_MAX ((short)SHRT_MAX) +# else +# define PERL_SHORT_MAX ((short) (PERL_USHORT_MAX >> 1)) +# endif +# endif +# endif +#endif + +#ifndef PERL_SHORT_MIN +# ifdef SHORT_MIN +# define PERL_SHORT_MIN ((short)SHORT_MIN) +# else +# ifdef MINSHORT +# define PERL_SHORT_MIN ((short)MINSHORT) +# else +# ifdef SHRT_MIN +# define PERL_SHORT_MIN ((short)SHRT_MIN) +# else +# define PERL_SHORT_MIN (-PERL_SHORT_MAX - ((3 & -1) == 3)) +# endif +# endif +# endif +#endif + +#ifndef PERL_UINT_MAX +# ifdef UINT_MAX +# define PERL_UINT_MAX ((unsigned int)UINT_MAX) +# else +# ifdef MAXUINT +# define PERL_UINT_MAX ((unsigned int)MAXUINT) +# else +# define PERL_UINT_MAX (~(unsigned int)0) +# endif +# endif +#endif + +#ifndef PERL_UINT_MIN +# define PERL_UINT_MIN ((unsigned int)0) +#endif + +#ifndef PERL_INT_MAX +# ifdef INT_MAX +# define PERL_INT_MAX ((int)INT_MAX) +# else +# ifdef MAXINT /* Often used in */ +# define PERL_INT_MAX ((int)MAXINT) +# else +# define PERL_INT_MAX ((int)(PERL_UINT_MAX >> 1)) +# endif +# endif +#endif + +#ifndef PERL_INT_MIN +# ifdef INT_MIN +# define PERL_INT_MIN ((int)INT_MIN) +# else +# ifdef MININT +# define PERL_INT_MIN ((int)MININT) +# else +# define PERL_INT_MIN (-PERL_INT_MAX - ((3 & -1) == 3)) +# endif +# endif +#endif + +#ifndef PERL_ULONG_MAX +# ifdef ULONG_MAX +# define PERL_ULONG_MAX ((unsigned long)ULONG_MAX) +# else +# ifdef MAXULONG +# define PERL_ULONG_MAX ((unsigned long)MAXULONG) +# else +# define PERL_ULONG_MAX (~(unsigned long)0) +# endif +# endif +#endif + +#ifndef PERL_ULONG_MIN +# define PERL_ULONG_MIN ((unsigned long)0L) +#endif + +#ifndef PERL_LONG_MAX +# ifdef LONG_MAX +# define PERL_LONG_MAX ((long)LONG_MAX) +# else +# ifdef MAXLONG +# define PERL_LONG_MAX ((long)MAXLONG) +# else +# define PERL_LONG_MAX ((long) (PERL_ULONG_MAX >> 1)) +# endif +# endif +#endif + +#ifndef PERL_LONG_MIN +# ifdef LONG_MIN +# define PERL_LONG_MIN ((long)LONG_MIN) +# else +# ifdef MINLONG +# define PERL_LONG_MIN ((long)MINLONG) +# else +# define PERL_LONG_MIN (-PERL_LONG_MAX - ((3 & -1) == 3)) +# endif +# endif +#endif + +#if defined(HAS_QUAD) && (defined(convex) || defined(uts)) +# ifndef PERL_UQUAD_MAX +# ifdef ULONGLONG_MAX +# define PERL_UQUAD_MAX ((unsigned long long)ULONGLONG_MAX) +# else +# ifdef MAXULONGLONG +# define PERL_UQUAD_MAX ((unsigned long long)MAXULONGLONG) +# else +# define PERL_UQUAD_MAX (~(unsigned long long)0) +# endif +# endif +# endif + +# ifndef PERL_UQUAD_MIN +# define PERL_UQUAD_MIN ((unsigned long long)0L) +# endif + +# ifndef PERL_QUAD_MAX +# ifdef LONGLONG_MAX +# define PERL_QUAD_MAX ((long long)LONGLONG_MAX) +# else +# ifdef MAXLONGLONG +# define PERL_QUAD_MAX ((long long)MAXLONGLONG) +# else +# define PERL_QUAD_MAX ((long long) (PERL_UQUAD_MAX >> 1)) +# endif +# endif +# endif + +# ifndef PERL_QUAD_MIN +# ifdef LONGLONG_MIN +# define PERL_QUAD_MIN ((long long)LONGLONG_MIN) +# else +# ifdef MINLONGLONG +# define PERL_QUAD_MIN ((long long)MINLONGLONG) +# else +# define PERL_QUAD_MIN (-PERL_QUAD_MAX - ((3 & -1) == 3)) +# endif +# endif +# endif +#endif + +/* This is based on code from 5.003 perl.h */ +#ifdef HAS_QUAD +# ifdef cray +#ifndef IVTYPE +# define IVTYPE int +#endif + +#ifndef IV_MIN +# define IV_MIN PERL_INT_MIN +#endif + +#ifndef IV_MAX +# define IV_MAX PERL_INT_MAX +#endif + +#ifndef UV_MIN +# define UV_MIN PERL_UINT_MIN +#endif + +#ifndef UV_MAX +# define UV_MAX PERL_UINT_MAX +#endif + +# ifdef INTSIZE +#ifndef IVSIZE +# define IVSIZE INTSIZE +#endif + +# endif +# else +# if defined(convex) || defined(uts) +#ifndef IVTYPE +# define IVTYPE long long +#endif + +#ifndef IV_MIN +# define IV_MIN PERL_QUAD_MIN +#endif + +#ifndef IV_MAX +# define IV_MAX PERL_QUAD_MAX +#endif + +#ifndef UV_MIN +# define UV_MIN PERL_UQUAD_MIN +#endif + +#ifndef UV_MAX +# define UV_MAX PERL_UQUAD_MAX +#endif + +# ifdef LONGLONGSIZE +#ifndef IVSIZE +# define IVSIZE LONGLONGSIZE +#endif + +# endif +# else +#ifndef IVTYPE +# define IVTYPE long +#endif + +#ifndef IV_MIN +# define IV_MIN PERL_LONG_MIN +#endif + +#ifndef IV_MAX +# define IV_MAX PERL_LONG_MAX +#endif + +#ifndef UV_MIN +# define UV_MIN PERL_ULONG_MIN +#endif + +#ifndef UV_MAX +# define UV_MAX PERL_ULONG_MAX +#endif + +# ifdef LONGSIZE +#ifndef IVSIZE +# define IVSIZE LONGSIZE +#endif + +# endif +# endif +# endif +#ifndef IVSIZE +# define IVSIZE 8 +#endif + +#ifndef LONGSIZE +# define LONGSIZE 8 +#endif + +#ifndef PERL_QUAD_MIN +# define PERL_QUAD_MIN IV_MIN +#endif + +#ifndef PERL_QUAD_MAX +# define PERL_QUAD_MAX IV_MAX +#endif + +#ifndef PERL_UQUAD_MIN +# define PERL_UQUAD_MIN UV_MIN +#endif + +#ifndef PERL_UQUAD_MAX +# define PERL_UQUAD_MAX UV_MAX +#endif + +#else +#ifndef IVTYPE +# define IVTYPE long +#endif + +#ifndef LONGSIZE +# define LONGSIZE 4 +#endif + +#ifndef IV_MIN +# define IV_MIN PERL_LONG_MIN +#endif + +#ifndef IV_MAX +# define IV_MAX PERL_LONG_MAX +#endif + +#ifndef UV_MIN +# define UV_MIN PERL_ULONG_MIN +#endif + +#ifndef UV_MAX +# define UV_MAX PERL_ULONG_MAX +#endif + +#endif + +#ifndef IVSIZE +# ifdef LONGSIZE +# define IVSIZE LONGSIZE +# else +# define IVSIZE 4 /* A bold guess, but the best we can make. */ +# endif +#endif +#ifndef UVTYPE +# define UVTYPE unsigned IVTYPE +#endif + +#ifndef UVSIZE +# define UVSIZE IVSIZE +#endif +#ifndef sv_setuv +# define sv_setuv(sv, uv) \ + STMT_START { \ + UV TeMpUv = uv; \ + if (TeMpUv <= IV_MAX) \ + sv_setiv(sv, TeMpUv); \ + else \ + sv_setnv(sv, (double)TeMpUv); \ + } STMT_END +#endif +#ifndef newSVuv +# define newSVuv(uv) ((uv) <= IV_MAX ? newSViv((IV)uv) : newSVnv((NV)uv)) +#endif +#ifndef sv_2uv +# define sv_2uv(sv) ((PL_Sv = (sv)), (UV) (SvNOK(PL_Sv) ? SvNV(PL_Sv) : sv_2nv(PL_Sv))) +#endif + +#ifndef SvUVX +# define SvUVX(sv) ((UV)SvIVX(sv)) +#endif + +#ifndef SvUVXx +# define SvUVXx(sv) SvUVX(sv) +#endif + +#ifndef SvUV +# define SvUV(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv)) +#endif + +#ifndef SvUVx +# define SvUVx(sv) ((PL_Sv = (sv)), SvUV(PL_Sv)) +#endif + +/* Hint: sv_uv + * Always use the SvUVx() macro instead of sv_uv(). + */ +#ifndef sv_uv +# define sv_uv(sv) SvUVx(sv) +#endif + +#if !defined(SvUOK) && defined(SvIOK_UV) +# define SvUOK(sv) SvIOK_UV(sv) +#endif +#ifndef XST_mUV +# define XST_mUV(i,v) (ST(i) = sv_2mortal(newSVuv(v)) ) +#endif + +#ifndef XSRETURN_UV +# define XSRETURN_UV(v) STMT_START { XST_mUV(0,v); XSRETURN(1); } STMT_END +#endif +#ifndef PUSHu +# define PUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG; } STMT_END +#endif + +#ifndef XPUSHu +# define XPUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END +#endif + +#ifdef HAS_MEMCMP +#ifndef memNE +# define memNE(s1,s2,l) (memcmp(s1,s2,l)) +#endif + +#ifndef memEQ +# define memEQ(s1,s2,l) (!memcmp(s1,s2,l)) +#endif + +#else +#ifndef memNE +# define memNE(s1,s2,l) (bcmp(s1,s2,l)) +#endif + +#ifndef memEQ +# define memEQ(s1,s2,l) (!bcmp(s1,s2,l)) +#endif + +#endif +#ifndef memEQs +# define memEQs(s1, l, s2) \ + (sizeof(s2)-1 == l && memEQ(s1, (s2 ""), (sizeof(s2)-1))) +#endif + +#ifndef memNEs +# define memNEs(s1, l, s2) !memEQs(s1, l, s2) +#endif +#ifndef MoveD +# define MoveD(s,d,n,t) memmove((char*)(d),(char*)(s), (n) * sizeof(t)) +#endif + +#ifndef CopyD +# define CopyD(s,d,n,t) memcpy((char*)(d),(char*)(s), (n) * sizeof(t)) +#endif + +#ifdef HAS_MEMSET +#ifndef ZeroD +# define ZeroD(d,n,t) memzero((char*)(d), (n) * sizeof(t)) +#endif + +#else +#ifndef ZeroD +# define ZeroD(d,n,t) ((void)memzero((char*)(d), (n) * sizeof(t)), d) +#endif + +#endif +#ifndef PoisonWith +# define PoisonWith(d,n,t,b) (void)memset((char*)(d), (U8)(b), (n) * sizeof(t)) +#endif + +#ifndef PoisonNew +# define PoisonNew(d,n,t) PoisonWith(d,n,t,0xAB) +#endif + +#ifndef PoisonFree +# define PoisonFree(d,n,t) PoisonWith(d,n,t,0xEF) +#endif + +#ifndef Poison +# define Poison(d,n,t) PoisonFree(d,n,t) +#endif +#ifndef Newx +# define Newx(v,n,t) New(0,v,n,t) +#endif + +#ifndef Newxc +# define Newxc(v,n,t,c) Newc(0,v,n,t,c) +#endif + +#ifndef Newxz +# define Newxz(v,n,t) Newz(0,v,n,t) +#endif + +#ifndef PERL_UNUSED_DECL +# ifdef HASATTRIBUTE +# if (defined(__GNUC__) && defined(__cplusplus)) || defined(__INTEL_COMPILER) +# define PERL_UNUSED_DECL +# else +# define PERL_UNUSED_DECL __attribute__((unused)) +# endif +# else +# define PERL_UNUSED_DECL +# endif +#endif + +#ifndef PERL_UNUSED_ARG +# if defined(lint) && defined(S_SPLINT_S) /* www.splint.org */ +# include +# define PERL_UNUSED_ARG(x) NOTE(ARGUNUSED(x)) +# else +# define PERL_UNUSED_ARG(x) ((void)x) +# endif +#endif + +#ifndef PERL_UNUSED_VAR +# define PERL_UNUSED_VAR(x) ((void)x) +#endif + +#ifndef PERL_UNUSED_CONTEXT +# ifdef USE_ITHREADS +# define PERL_UNUSED_CONTEXT PERL_UNUSED_ARG(my_perl) +# else +# define PERL_UNUSED_CONTEXT +# endif +#endif +#ifndef NOOP +# define NOOP /*EMPTY*/(void)0 +#endif + +#ifndef dNOOP +# define dNOOP extern int /*@unused@*/ Perl___notused PERL_UNUSED_DECL +#endif + +#ifndef NVTYPE +# if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) +# define NVTYPE long double +# else +# define NVTYPE double +# endif +typedef NVTYPE NV; +#endif + +#ifndef INT2PTR +# if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE) +# define PTRV UV +# define INT2PTR(any,d) (any)(d) +# else +# if PTRSIZE == LONGSIZE +# define PTRV unsigned long +# else +# define PTRV unsigned +# endif +# define INT2PTR(any,d) (any)(PTRV)(d) +# endif +#endif + +#ifndef PTR2ul +# if PTRSIZE == LONGSIZE +# define PTR2ul(p) (unsigned long)(p) +# else +# define PTR2ul(p) INT2PTR(unsigned long,p) +# endif +#endif +#ifndef PTR2nat +# define PTR2nat(p) (PTRV)(p) +#endif + +#ifndef NUM2PTR +# define NUM2PTR(any,d) (any)PTR2nat(d) +#endif + +#ifndef PTR2IV +# define PTR2IV(p) INT2PTR(IV,p) +#endif + +#ifndef PTR2UV +# define PTR2UV(p) INT2PTR(UV,p) +#endif + +#ifndef PTR2NV +# define PTR2NV(p) NUM2PTR(NV,p) +#endif + +#undef START_EXTERN_C +#undef END_EXTERN_C +#undef EXTERN_C +#ifdef __cplusplus +# define START_EXTERN_C extern "C" { +# define END_EXTERN_C } +# define EXTERN_C extern "C" +#else +# define START_EXTERN_C +# define END_EXTERN_C +# define EXTERN_C extern +#endif + +#if defined(PERL_GCC_PEDANTIC) +# ifndef PERL_GCC_BRACE_GROUPS_FORBIDDEN +# define PERL_GCC_BRACE_GROUPS_FORBIDDEN +# endif +#endif + +#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) && !defined(__cplusplus) +# ifndef PERL_USE_GCC_BRACE_GROUPS +# define PERL_USE_GCC_BRACE_GROUPS +# endif +#endif + +#undef STMT_START +#undef STMT_END +#ifdef PERL_USE_GCC_BRACE_GROUPS +# define STMT_START (void)( /* gcc supports ``({ STATEMENTS; })'' */ +# define STMT_END ) +#else +# if defined(VOIDFLAGS) && (VOIDFLAGS) && (defined(sun) || defined(__sun__)) && !defined(__GNUC__) +# define STMT_START if (1) +# define STMT_END else (void)0 +# else +# define STMT_START do +# define STMT_END while (0) +# endif +#endif +#ifndef boolSV +# define boolSV(b) ((b) ? &PL_sv_yes : &PL_sv_no) +#endif + +/* DEFSV appears first in 5.004_56 */ +#ifndef DEFSV +# define DEFSV GvSV(PL_defgv) +#endif + +#ifndef SAVE_DEFSV +# define SAVE_DEFSV SAVESPTR(GvSV(PL_defgv)) +#endif + +#ifndef DEFSV_set +# define DEFSV_set(sv) (DEFSV = (sv)) +#endif + +/* Older perls (<=5.003) lack AvFILLp */ +#ifndef AvFILLp +# define AvFILLp AvFILL +#endif +#ifndef ERRSV +# define ERRSV get_sv("@",FALSE) +#endif + +/* Hint: gv_stashpvn + * This function's backport doesn't support the length parameter, but + * rather ignores it. Portability can only be ensured if the length + * parameter is used for speed reasons, but the length can always be + * correctly computed from the string argument. + */ +#ifndef gv_stashpvn +# define gv_stashpvn(str,len,create) gv_stashpv(str,create) +#endif + +/* Replace: 1 */ +#ifndef get_cv +# define get_cv perl_get_cv +#endif + +#ifndef get_sv +# define get_sv perl_get_sv +#endif + +#ifndef get_av +# define get_av perl_get_av +#endif + +#ifndef get_hv +# define get_hv perl_get_hv +#endif + +/* Replace: 0 */ +#ifndef dUNDERBAR +# define dUNDERBAR dNOOP +#endif + +#ifndef UNDERBAR +# define UNDERBAR DEFSV +#endif +#ifndef dAX +# define dAX I32 ax = MARK - PL_stack_base + 1 +#endif + +#ifndef dITEMS +# define dITEMS I32 items = SP - MARK +#endif +#ifndef dXSTARG +# define dXSTARG SV * targ = sv_newmortal() +#endif +#ifndef dAXMARK +# define dAXMARK I32 ax = POPMARK; \ + register SV ** const mark = PL_stack_base + ax++ +#endif +#ifndef XSprePUSH +# define XSprePUSH (sp = PL_stack_base + ax - 1) +#endif + +#if (PERL_BCDVERSION < 0x5005000) +# undef XSRETURN +# define XSRETURN(off) \ + STMT_START { \ + PL_stack_sp = PL_stack_base + ax + ((off) - 1); \ + return; \ + } STMT_END +#endif +#ifndef XSPROTO +# define XSPROTO(name) void name(pTHX_ CV* cv) +#endif + +#ifndef SVfARG +# define SVfARG(p) ((void*)(p)) +#endif +#ifndef PERL_ABS +# define PERL_ABS(x) ((x) < 0 ? -(x) : (x)) +#endif +#ifndef dVAR +# define dVAR dNOOP +#endif +#ifndef SVf +# define SVf "_" +#endif +#ifndef UTF8_MAXBYTES +# define UTF8_MAXBYTES UTF8_MAXLEN +#endif +#ifndef CPERLscope +# define CPERLscope(x) x +#endif +#ifndef PERL_HASH +# define PERL_HASH(hash,str,len) \ + STMT_START { \ + const char *s_PeRlHaSh = str; \ + I32 i_PeRlHaSh = len; \ + U32 hash_PeRlHaSh = 0; \ + while (i_PeRlHaSh--) \ + hash_PeRlHaSh = hash_PeRlHaSh * 33 + *s_PeRlHaSh++; \ + (hash) = hash_PeRlHaSh; \ + } STMT_END +#endif + +#ifndef PERLIO_FUNCS_DECL +# ifdef PERLIO_FUNCS_CONST +# define PERLIO_FUNCS_DECL(funcs) const PerlIO_funcs funcs +# define PERLIO_FUNCS_CAST(funcs) (PerlIO_funcs*)(funcs) +# else +# define PERLIO_FUNCS_DECL(funcs) PerlIO_funcs funcs +# define PERLIO_FUNCS_CAST(funcs) (funcs) +# endif +#endif + +/* provide these typedefs for older perls */ +#if (PERL_BCDVERSION < 0x5009003) + +# ifdef ARGSproto +typedef OP* (CPERLscope(*Perl_ppaddr_t))(ARGSproto); +# else +typedef OP* (CPERLscope(*Perl_ppaddr_t))(pTHX); +# endif + +typedef OP* (CPERLscope(*Perl_check_t)) (pTHX_ OP*); + +#endif +#ifndef isPSXSPC +# define isPSXSPC(c) (isSPACE(c) || (c) == '\v') +#endif + +#ifndef isBLANK +# define isBLANK(c) ((c) == ' ' || (c) == '\t') +#endif + +#ifdef EBCDIC +#ifndef isALNUMC +# define isALNUMC(c) isalnum(c) +#endif + +#ifndef isASCII +# define isASCII(c) isascii(c) +#endif + +#ifndef isCNTRL +# define isCNTRL(c) iscntrl(c) +#endif + +#ifndef isGRAPH +# define isGRAPH(c) isgraph(c) +#endif + +#ifndef isPRINT +# define isPRINT(c) isprint(c) +#endif + +#ifndef isPUNCT +# define isPUNCT(c) ispunct(c) +#endif + +#ifndef isXDIGIT +# define isXDIGIT(c) isxdigit(c) +#endif + +#else +# if (PERL_BCDVERSION < 0x5010000) +/* Hint: isPRINT + * The implementation in older perl versions includes all of the + * isSPACE() characters, which is wrong. The version provided by + * Devel::PPPort always overrides a present buggy version. + */ +# undef isPRINT +# endif + +#ifdef HAS_QUAD +# ifdef U64TYPE +# define WIDEST_UTYPE U64TYPE +# else +# define WIDEST_UTYPE Quad_t +# endif +#else +# define WIDEST_UTYPE U32 +#endif +#ifndef isALNUMC +# define isALNUMC(c) (isALPHA(c) || isDIGIT(c)) +#endif + +#ifndef isASCII +# define isASCII(c) ((WIDEST_UTYPE) (c) <= 127) +#endif + +#ifndef isCNTRL +# define isCNTRL(c) ((WIDEST_UTYPE) (c) < ' ' || (c) == 127) +#endif + +#ifndef isGRAPH +# define isGRAPH(c) (isALNUM(c) || isPUNCT(c)) +#endif + +#ifndef isPRINT +# define isPRINT(c) (((c) >= 32 && (c) < 127)) +#endif + +#ifndef isPUNCT +# define isPUNCT(c) (((c) >= 33 && (c) <= 47) || ((c) >= 58 && (c) <= 64) || ((c) >= 91 && (c) <= 96) || ((c) >= 123 && (c) <= 126)) +#endif + +#ifndef isXDIGIT +# define isXDIGIT(c) (isDIGIT(c) || ((c) >= 'a' && (c) <= 'f') || ((c) >= 'A' && (c) <= 'F')) +#endif + +#endif + +/* Until we figure out how to support this in older perls... */ +#if (PERL_BCDVERSION >= 0x5008000) +#ifndef HeUTF8 +# define HeUTF8(he) ((HeKLEN(he) == HEf_SVKEY) ? \ + SvUTF8(HeKEY_sv(he)) : \ + (U32)HeKUTF8(he)) +#endif + +#endif + +#ifndef PERL_SIGNALS_UNSAFE_FLAG + +#define PERL_SIGNALS_UNSAFE_FLAG 0x0001 + +#if (PERL_BCDVERSION < 0x5008000) +# define D_PPP_PERL_SIGNALS_INIT PERL_SIGNALS_UNSAFE_FLAG +#else +# define D_PPP_PERL_SIGNALS_INIT 0 +#endif + +#if defined(NEED_PL_signals) +static U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT; +#elif defined(NEED_PL_signals_GLOBAL) +U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT; +#else +extern U32 DPPP_(my_PL_signals); +#endif +#define PL_signals DPPP_(my_PL_signals) + +#endif + +/* Hint: PL_ppaddr + * Calling an op via PL_ppaddr requires passing a context argument + * for threaded builds. Since the context argument is different for + * 5.005 perls, you can use aTHXR (supplied by ppport.h), which will + * automatically be defined as the correct argument. + */ + +#if (PERL_BCDVERSION <= 0x5005005) +/* Replace: 1 */ +# define PL_ppaddr ppaddr +# define PL_no_modify no_modify +/* Replace: 0 */ +#endif + +#if (PERL_BCDVERSION <= 0x5004005) +/* Replace: 1 */ +# define PL_DBsignal DBsignal +# define PL_DBsingle DBsingle +# define PL_DBsub DBsub +# define PL_DBtrace DBtrace +# define PL_Sv Sv +# define PL_bufend bufend +# define PL_bufptr bufptr +# define PL_compiling compiling +# define PL_copline copline +# define PL_curcop curcop +# define PL_curstash curstash +# define PL_debstash debstash +# define PL_defgv defgv +# define PL_diehook diehook +# define PL_dirty dirty +# define PL_dowarn dowarn +# define PL_errgv errgv +# define PL_error_count error_count +# define PL_expect expect +# define PL_hexdigit hexdigit +# define PL_hints hints +# define PL_in_my in_my +# define PL_laststatval laststatval +# define PL_lex_state lex_state +# define PL_lex_stuff lex_stuff +# define PL_linestr linestr +# define PL_na na +# define PL_perl_destruct_level perl_destruct_level +# define PL_perldb perldb +# define PL_rsfp_filters rsfp_filters +# define PL_rsfp rsfp +# define PL_stack_base stack_base +# define PL_stack_sp stack_sp +# define PL_statcache statcache +# define PL_stdingv stdingv +# define PL_sv_arenaroot sv_arenaroot +# define PL_sv_no sv_no +# define PL_sv_undef sv_undef +# define PL_sv_yes sv_yes +# define PL_tainted tainted +# define PL_tainting tainting +# define PL_tokenbuf tokenbuf +/* Replace: 0 */ +#endif + +/* Warning: PL_parser + * For perl versions earlier than 5.9.5, this is an always + * non-NULL dummy. Also, it cannot be dereferenced. Don't + * use it if you can avoid is and unless you absolutely know + * what you're doing. + * If you always check that PL_parser is non-NULL, you can + * define DPPP_PL_parser_NO_DUMMY to avoid the creation of + * a dummy parser structure. + */ + +#if (PERL_BCDVERSION >= 0x5009005) +# ifdef DPPP_PL_parser_NO_DUMMY +# define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \ + (croak("panic: PL_parser == NULL in %s:%d", \ + __FILE__, __LINE__), (yy_parser *) NULL))->var) +# else +# ifdef DPPP_PL_parser_NO_DUMMY_WARNING +# define D_PPP_parser_dummy_warning(var) +# else +# define D_PPP_parser_dummy_warning(var) \ + warn("warning: dummy PL_" #var " used in %s:%d", __FILE__, __LINE__), +# endif +# define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \ + (D_PPP_parser_dummy_warning(var) &DPPP_(dummy_PL_parser)))->var) +#if defined(NEED_PL_parser) +static yy_parser DPPP_(dummy_PL_parser); +#elif defined(NEED_PL_parser_GLOBAL) +yy_parser DPPP_(dummy_PL_parser); +#else +extern yy_parser DPPP_(dummy_PL_parser); +#endif + +# endif + +/* PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters, PL_linestr, PL_bufptr, PL_bufend, PL_lex_state, PL_lex_stuff, PL_tokenbuf depends on PL_parser */ +/* Warning: PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters, PL_linestr, PL_bufptr, PL_bufend, PL_lex_state, PL_lex_stuff, PL_tokenbuf + * Do not use this variable unless you know exactly what you're + * doint. It is internal to the perl parser and may change or even + * be removed in the future. As of perl 5.9.5, you have to check + * for (PL_parser != NULL) for this variable to have any effect. + * An always non-NULL PL_parser dummy is provided for earlier + * perl versions. + * If PL_parser is NULL when you try to access this variable, a + * dummy is being accessed instead and a warning is issued unless + * you define DPPP_PL_parser_NO_DUMMY_WARNING. + * If DPPP_PL_parser_NO_DUMMY is defined, the code trying to access + * this variable will croak with a panic message. + */ + +# define PL_expect D_PPP_my_PL_parser_var(expect) +# define PL_copline D_PPP_my_PL_parser_var(copline) +# define PL_rsfp D_PPP_my_PL_parser_var(rsfp) +# define PL_rsfp_filters D_PPP_my_PL_parser_var(rsfp_filters) +# define PL_linestr D_PPP_my_PL_parser_var(linestr) +# define PL_bufptr D_PPP_my_PL_parser_var(bufptr) +# define PL_bufend D_PPP_my_PL_parser_var(bufend) +# define PL_lex_state D_PPP_my_PL_parser_var(lex_state) +# define PL_lex_stuff D_PPP_my_PL_parser_var(lex_stuff) +# define PL_tokenbuf D_PPP_my_PL_parser_var(tokenbuf) +# define PL_in_my D_PPP_my_PL_parser_var(in_my) +# define PL_in_my_stash D_PPP_my_PL_parser_var(in_my_stash) +# define PL_error_count D_PPP_my_PL_parser_var(error_count) + + +#else + +/* ensure that PL_parser != NULL and cannot be dereferenced */ +# define PL_parser ((void *) 1) + +#endif +#ifndef mPUSHs +# define mPUSHs(s) PUSHs(sv_2mortal(s)) +#endif + +#ifndef PUSHmortal +# define PUSHmortal PUSHs(sv_newmortal()) +#endif + +#ifndef mPUSHp +# define mPUSHp(p,l) sv_setpvn(PUSHmortal, (p), (l)) +#endif + +#ifndef mPUSHn +# define mPUSHn(n) sv_setnv(PUSHmortal, (NV)(n)) +#endif + +#ifndef mPUSHi +# define mPUSHi(i) sv_setiv(PUSHmortal, (IV)(i)) +#endif + +#ifndef mPUSHu +# define mPUSHu(u) sv_setuv(PUSHmortal, (UV)(u)) +#endif +#ifndef mXPUSHs +# define mXPUSHs(s) XPUSHs(sv_2mortal(s)) +#endif + +#ifndef XPUSHmortal +# define XPUSHmortal XPUSHs(sv_newmortal()) +#endif + +#ifndef mXPUSHp +# define mXPUSHp(p,l) STMT_START { EXTEND(sp,1); sv_setpvn(PUSHmortal, (p), (l)); } STMT_END +#endif + +#ifndef mXPUSHn +# define mXPUSHn(n) STMT_START { EXTEND(sp,1); sv_setnv(PUSHmortal, (NV)(n)); } STMT_END +#endif + +#ifndef mXPUSHi +# define mXPUSHi(i) STMT_START { EXTEND(sp,1); sv_setiv(PUSHmortal, (IV)(i)); } STMT_END +#endif + +#ifndef mXPUSHu +# define mXPUSHu(u) STMT_START { EXTEND(sp,1); sv_setuv(PUSHmortal, (UV)(u)); } STMT_END +#endif + +/* Replace: 1 */ +#ifndef call_sv +# define call_sv perl_call_sv +#endif + +#ifndef call_pv +# define call_pv perl_call_pv +#endif + +#ifndef call_argv +# define call_argv perl_call_argv +#endif + +#ifndef call_method +# define call_method perl_call_method +#endif +#ifndef eval_sv +# define eval_sv perl_eval_sv +#endif + +/* Replace: 0 */ +#ifndef PERL_LOADMOD_DENY +# define PERL_LOADMOD_DENY 0x1 +#endif + +#ifndef PERL_LOADMOD_NOIMPORT +# define PERL_LOADMOD_NOIMPORT 0x2 +#endif + +#ifndef PERL_LOADMOD_IMPORT_OPS +# define PERL_LOADMOD_IMPORT_OPS 0x4 +#endif + +#ifndef G_METHOD +# define G_METHOD 64 +# ifdef call_sv +# undef call_sv +# endif +# if (PERL_BCDVERSION < 0x5006000) +# define call_sv(sv, flags) ((flags) & G_METHOD ? perl_call_method((char *) SvPV_nolen_const(sv), \ + (flags) & ~G_METHOD) : perl_call_sv(sv, flags)) +# else +# define call_sv(sv, flags) ((flags) & G_METHOD ? Perl_call_method(aTHX_ (char *) SvPV_nolen_const(sv), \ + (flags) & ~G_METHOD) : Perl_call_sv(aTHX_ sv, flags)) +# endif +#endif + +/* Replace perl_eval_pv with eval_pv */ + +#ifndef eval_pv +#if defined(NEED_eval_pv) +static SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error); +static +#else +extern SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error); +#endif + +#ifdef eval_pv +# undef eval_pv +#endif +#define eval_pv(a,b) DPPP_(my_eval_pv)(aTHX_ a,b) +#define Perl_eval_pv DPPP_(my_eval_pv) + +#if defined(NEED_eval_pv) || defined(NEED_eval_pv_GLOBAL) + +SV* +DPPP_(my_eval_pv)(char *p, I32 croak_on_error) +{ + dSP; + SV* sv = newSVpv(p, 0); + + PUSHMARK(sp); + eval_sv(sv, G_SCALAR); + SvREFCNT_dec(sv); + + SPAGAIN; + sv = POPs; + PUTBACK; + + if (croak_on_error && SvTRUE(GvSV(errgv))) + croak(SvPVx(GvSV(errgv), na)); + + return sv; +} + +#endif +#endif + +#ifndef vload_module +#if defined(NEED_vload_module) +static void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args); +static +#else +extern void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args); +#endif + +#ifdef vload_module +# undef vload_module +#endif +#define vload_module(a,b,c,d) DPPP_(my_vload_module)(aTHX_ a,b,c,d) +#define Perl_vload_module DPPP_(my_vload_module) + +#if defined(NEED_vload_module) || defined(NEED_vload_module_GLOBAL) + +void +DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args) +{ + dTHR; + dVAR; + OP *veop, *imop; + + OP * const modname = newSVOP(OP_CONST, 0, name); + /* 5.005 has a somewhat hacky force_normal that doesn't croak on + SvREADONLY() if PL_compling is true. Current perls take care in + ck_require() to correctly turn off SvREADONLY before calling + force_normal_flags(). This seems a better fix than fudging PL_compling + */ + SvREADONLY_off(((SVOP*)modname)->op_sv); + modname->op_private |= OPpCONST_BARE; + if (ver) { + veop = newSVOP(OP_CONST, 0, ver); + } + else + veop = NULL; + if (flags & PERL_LOADMOD_NOIMPORT) { + imop = sawparens(newNULLLIST()); + } + else if (flags & PERL_LOADMOD_IMPORT_OPS) { + imop = va_arg(*args, OP*); + } + else { + SV *sv; + imop = NULL; + sv = va_arg(*args, SV*); + while (sv) { + imop = append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv)); + sv = va_arg(*args, SV*); + } + } + { + const line_t ocopline = PL_copline; + COP * const ocurcop = PL_curcop; + const int oexpect = PL_expect; + +#if (PERL_BCDVERSION >= 0x5004000) + utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(FALSE, 0), + veop, modname, imop); +#elif (PERL_BCDVERSION > 0x5003000) + utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(), + veop, modname, imop); +#else + utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(), + modname, imop); +#endif + PL_expect = oexpect; + PL_copline = ocopline; + PL_curcop = ocurcop; + } +} + +#endif +#endif + +#ifndef load_module +#if defined(NEED_load_module) +static void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...); +static +#else +extern void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...); +#endif + +#ifdef load_module +# undef load_module +#endif +#define load_module DPPP_(my_load_module) +#define Perl_load_module DPPP_(my_load_module) + +#if defined(NEED_load_module) || defined(NEED_load_module_GLOBAL) + +void +DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...) +{ + va_list args; + va_start(args, ver); + vload_module(flags, name, ver, &args); + va_end(args); +} + +#endif +#endif +#ifndef newRV_inc +# define newRV_inc(sv) newRV(sv) /* Replace */ +#endif + +#ifndef newRV_noinc +#if defined(NEED_newRV_noinc) +static SV * DPPP_(my_newRV_noinc)(SV *sv); +static +#else +extern SV * DPPP_(my_newRV_noinc)(SV *sv); +#endif + +#ifdef newRV_noinc +# undef newRV_noinc +#endif +#define newRV_noinc(a) DPPP_(my_newRV_noinc)(aTHX_ a) +#define Perl_newRV_noinc DPPP_(my_newRV_noinc) + +#if defined(NEED_newRV_noinc) || defined(NEED_newRV_noinc_GLOBAL) +SV * +DPPP_(my_newRV_noinc)(SV *sv) +{ + SV *rv = (SV *)newRV(sv); + SvREFCNT_dec(sv); + return rv; +} +#endif +#endif + +/* Hint: newCONSTSUB + * Returns a CV* as of perl-5.7.1. This return value is not supported + * by Devel::PPPort. + */ + +/* newCONSTSUB from IO.xs is in the core starting with 5.004_63 */ +#if (PERL_BCDVERSION < 0x5004063) && (PERL_BCDVERSION != 0x5004005) +#if defined(NEED_newCONSTSUB) +static void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv); +static +#else +extern void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv); +#endif + +#ifdef newCONSTSUB +# undef newCONSTSUB +#endif +#define newCONSTSUB(a,b,c) DPPP_(my_newCONSTSUB)(aTHX_ a,b,c) +#define Perl_newCONSTSUB DPPP_(my_newCONSTSUB) + +#if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL) + +/* This is just a trick to avoid a dependency of newCONSTSUB on PL_parser */ +/* (There's no PL_parser in perl < 5.005, so this is completely safe) */ +#define D_PPP_PL_copline PL_copline + +void +DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv) +{ + U32 oldhints = PL_hints; + HV *old_cop_stash = PL_curcop->cop_stash; + HV *old_curstash = PL_curstash; + line_t oldline = PL_curcop->cop_line; + PL_curcop->cop_line = D_PPP_PL_copline; + + PL_hints &= ~HINT_BLOCK_SCOPE; + if (stash) + PL_curstash = PL_curcop->cop_stash = stash; + + newSUB( + +#if (PERL_BCDVERSION < 0x5003022) + start_subparse(), +#elif (PERL_BCDVERSION == 0x5003022) + start_subparse(0), +#else /* 5.003_23 onwards */ + start_subparse(FALSE, 0), +#endif + + newSVOP(OP_CONST, 0, newSVpv((char *) name, 0)), + newSVOP(OP_CONST, 0, &PL_sv_no), /* SvPV(&PL_sv_no) == "" -- GMB */ + newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv)) + ); + + PL_hints = oldhints; + PL_curcop->cop_stash = old_cop_stash; + PL_curstash = old_curstash; + PL_curcop->cop_line = oldline; +} +#endif +#endif + +/* + * Boilerplate macros for initializing and accessing interpreter-local + * data from C. All statics in extensions should be reworked to use + * this, if you want to make the extension thread-safe. See ext/re/re.xs + * for an example of the use of these macros. + * + * Code that uses these macros is responsible for the following: + * 1. #define MY_CXT_KEY to a unique string, e.g. "DynaLoader_guts" + * 2. Declare a typedef named my_cxt_t that is a structure that contains + * all the data that needs to be interpreter-local. + * 3. Use the START_MY_CXT macro after the declaration of my_cxt_t. + * 4. Use the MY_CXT_INIT macro such that it is called exactly once + * (typically put in the BOOT: section). + * 5. Use the members of the my_cxt_t structure everywhere as + * MY_CXT.member. + * 6. Use the dMY_CXT macro (a declaration) in all the functions that + * access MY_CXT. + */ + +#if defined(MULTIPLICITY) || defined(PERL_OBJECT) || \ + defined(PERL_CAPI) || defined(PERL_IMPLICIT_CONTEXT) + +#ifndef START_MY_CXT + +/* This must appear in all extensions that define a my_cxt_t structure, + * right after the definition (i.e. at file scope). The non-threads + * case below uses it to declare the data as static. */ +#define START_MY_CXT + +#if (PERL_BCDVERSION < 0x5004068) +/* Fetches the SV that keeps the per-interpreter data. */ +#define dMY_CXT_SV \ + SV *my_cxt_sv = get_sv(MY_CXT_KEY, FALSE) +#else /* >= perl5.004_68 */ +#define dMY_CXT_SV \ + SV *my_cxt_sv = *hv_fetch(PL_modglobal, MY_CXT_KEY, \ + sizeof(MY_CXT_KEY)-1, TRUE) +#endif /* < perl5.004_68 */ + +/* This declaration should be used within all functions that use the + * interpreter-local data. */ +#define dMY_CXT \ + dMY_CXT_SV; \ + my_cxt_t *my_cxtp = INT2PTR(my_cxt_t*,SvUV(my_cxt_sv)) + +/* Creates and zeroes the per-interpreter data. + * (We allocate my_cxtp in a Perl SV so that it will be released when + * the interpreter goes away.) */ +#define MY_CXT_INIT \ + dMY_CXT_SV; \ + /* newSV() allocates one more than needed */ \ + my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\ + Zero(my_cxtp, 1, my_cxt_t); \ + sv_setuv(my_cxt_sv, PTR2UV(my_cxtp)) + +/* This macro must be used to access members of the my_cxt_t structure. + * e.g. MYCXT.some_data */ +#define MY_CXT (*my_cxtp) + +/* Judicious use of these macros can reduce the number of times dMY_CXT + * is used. Use is similar to pTHX, aTHX etc. */ +#define pMY_CXT my_cxt_t *my_cxtp +#define pMY_CXT_ pMY_CXT, +#define _pMY_CXT ,pMY_CXT +#define aMY_CXT my_cxtp +#define aMY_CXT_ aMY_CXT, +#define _aMY_CXT ,aMY_CXT + +#endif /* START_MY_CXT */ + +#ifndef MY_CXT_CLONE +/* Clones the per-interpreter data. */ +#define MY_CXT_CLONE \ + dMY_CXT_SV; \ + my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\ + Copy(INT2PTR(my_cxt_t*, SvUV(my_cxt_sv)), my_cxtp, 1, my_cxt_t);\ + sv_setuv(my_cxt_sv, PTR2UV(my_cxtp)) +#endif + +#else /* single interpreter */ + +#ifndef START_MY_CXT + +#define START_MY_CXT static my_cxt_t my_cxt; +#define dMY_CXT_SV dNOOP +#define dMY_CXT dNOOP +#define MY_CXT_INIT NOOP +#define MY_CXT my_cxt + +#define pMY_CXT void +#define pMY_CXT_ +#define _pMY_CXT +#define aMY_CXT +#define aMY_CXT_ +#define _aMY_CXT + +#endif /* START_MY_CXT */ + +#ifndef MY_CXT_CLONE +#define MY_CXT_CLONE NOOP +#endif + +#endif + +#ifndef IVdf +# if IVSIZE == LONGSIZE +# define IVdf "ld" +# define UVuf "lu" +# define UVof "lo" +# define UVxf "lx" +# define UVXf "lX" +# elif IVSIZE == INTSIZE +# define IVdf "d" +# define UVuf "u" +# define UVof "o" +# define UVxf "x" +# define UVXf "X" +# else +# error "cannot define IV/UV formats" +# endif +#endif + +#ifndef NVef +# if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) && \ + defined(PERL_PRIfldbl) && (PERL_BCDVERSION != 0x5006000) + /* Not very likely, but let's try anyway. */ +# define NVef PERL_PRIeldbl +# define NVff PERL_PRIfldbl +# define NVgf PERL_PRIgldbl +# else +# define NVef "e" +# define NVff "f" +# define NVgf "g" +# endif +#endif + +#ifndef SvREFCNT_inc +# ifdef PERL_USE_GCC_BRACE_GROUPS +# define SvREFCNT_inc(sv) \ + ({ \ + SV * const _sv = (SV*)(sv); \ + if (_sv) \ + (SvREFCNT(_sv))++; \ + _sv; \ + }) +# else +# define SvREFCNT_inc(sv) \ + ((PL_Sv=(SV*)(sv)) ? (++(SvREFCNT(PL_Sv)),PL_Sv) : NULL) +# endif +#endif + +#ifndef SvREFCNT_inc_simple +# ifdef PERL_USE_GCC_BRACE_GROUPS +# define SvREFCNT_inc_simple(sv) \ + ({ \ + if (sv) \ + (SvREFCNT(sv))++; \ + (SV *)(sv); \ + }) +# else +# define SvREFCNT_inc_simple(sv) \ + ((sv) ? (SvREFCNT(sv)++,(SV*)(sv)) : NULL) +# endif +#endif + +#ifndef SvREFCNT_inc_NN +# ifdef PERL_USE_GCC_BRACE_GROUPS +# define SvREFCNT_inc_NN(sv) \ + ({ \ + SV * const _sv = (SV*)(sv); \ + SvREFCNT(_sv)++; \ + _sv; \ + }) +# else +# define SvREFCNT_inc_NN(sv) \ + (PL_Sv=(SV*)(sv),++(SvREFCNT(PL_Sv)),PL_Sv) +# endif +#endif + +#ifndef SvREFCNT_inc_void +# ifdef PERL_USE_GCC_BRACE_GROUPS +# define SvREFCNT_inc_void(sv) \ + ({ \ + SV * const _sv = (SV*)(sv); \ + if (_sv) \ + (void)(SvREFCNT(_sv)++); \ + }) +# else +# define SvREFCNT_inc_void(sv) \ + (void)((PL_Sv=(SV*)(sv)) ? ++(SvREFCNT(PL_Sv)) : 0) +# endif +#endif +#ifndef SvREFCNT_inc_simple_void +# define SvREFCNT_inc_simple_void(sv) STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END +#endif + +#ifndef SvREFCNT_inc_simple_NN +# define SvREFCNT_inc_simple_NN(sv) (++SvREFCNT(sv), (SV*)(sv)) +#endif + +#ifndef SvREFCNT_inc_void_NN +# define SvREFCNT_inc_void_NN(sv) (void)(++SvREFCNT((SV*)(sv))) +#endif + +#ifndef SvREFCNT_inc_simple_void_NN +# define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT((SV*)(sv))) +#endif + +#ifndef newSV_type + +#if defined(NEED_newSV_type) +static SV* DPPP_(my_newSV_type)(pTHX_ svtype const t); +static +#else +extern SV* DPPP_(my_newSV_type)(pTHX_ svtype const t); +#endif + +#ifdef newSV_type +# undef newSV_type +#endif +#define newSV_type(a) DPPP_(my_newSV_type)(aTHX_ a) +#define Perl_newSV_type DPPP_(my_newSV_type) + +#if defined(NEED_newSV_type) || defined(NEED_newSV_type_GLOBAL) + +SV* +DPPP_(my_newSV_type)(pTHX_ svtype const t) +{ + SV* const sv = newSV(0); + sv_upgrade(sv, t); + return sv; +} + +#endif + +#endif + +#if (PERL_BCDVERSION < 0x5006000) +# define D_PPP_CONSTPV_ARG(x) ((char *) (x)) +#else +# define D_PPP_CONSTPV_ARG(x) (x) +#endif +#ifndef newSVpvn +# define newSVpvn(data,len) ((data) \ + ? ((len) ? newSVpv((data), (len)) : newSVpv("", 0)) \ + : newSV(0)) +#endif +#ifndef newSVpvn_utf8 +# define newSVpvn_utf8(s, len, u) newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0) +#endif +#ifndef SVf_UTF8 +# define SVf_UTF8 0 +#endif + +#ifndef newSVpvn_flags + +#if defined(NEED_newSVpvn_flags) +static SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags); +static +#else +extern SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags); +#endif + +#ifdef newSVpvn_flags +# undef newSVpvn_flags +#endif +#define newSVpvn_flags(a,b,c) DPPP_(my_newSVpvn_flags)(aTHX_ a,b,c) +#define Perl_newSVpvn_flags DPPP_(my_newSVpvn_flags) + +#if defined(NEED_newSVpvn_flags) || defined(NEED_newSVpvn_flags_GLOBAL) + +SV * +DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags) +{ + SV *sv = newSVpvn(D_PPP_CONSTPV_ARG(s), len); + SvFLAGS(sv) |= (flags & SVf_UTF8); + return (flags & SVs_TEMP) ? sv_2mortal(sv) : sv; +} + +#endif + +#endif + +/* Backwards compatibility stuff... :-( */ +#if !defined(NEED_sv_2pv_flags) && defined(NEED_sv_2pv_nolen) +# define NEED_sv_2pv_flags +#endif +#if !defined(NEED_sv_2pv_flags_GLOBAL) && defined(NEED_sv_2pv_nolen_GLOBAL) +# define NEED_sv_2pv_flags_GLOBAL +#endif + +/* Hint: sv_2pv_nolen + * Use the SvPV_nolen() or SvPV_nolen_const() macros instead of sv_2pv_nolen(). + */ +#ifndef sv_2pv_nolen +# define sv_2pv_nolen(sv) SvPV_nolen(sv) +#endif + +#ifdef SvPVbyte + +/* Hint: SvPVbyte + * Does not work in perl-5.6.1, ppport.h implements a version + * borrowed from perl-5.7.3. + */ + +#if (PERL_BCDVERSION < 0x5007000) + +#if defined(NEED_sv_2pvbyte) +static char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp); +static +#else +extern char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp); +#endif + +#ifdef sv_2pvbyte +# undef sv_2pvbyte +#endif +#define sv_2pvbyte(a,b) DPPP_(my_sv_2pvbyte)(aTHX_ a,b) +#define Perl_sv_2pvbyte DPPP_(my_sv_2pvbyte) + +#if defined(NEED_sv_2pvbyte) || defined(NEED_sv_2pvbyte_GLOBAL) + +char * +DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp) +{ + sv_utf8_downgrade(sv,0); + return SvPV(sv,*lp); +} + +#endif + +/* Hint: sv_2pvbyte + * Use the SvPVbyte() macro instead of sv_2pvbyte(). + */ + +#undef SvPVbyte + +#define SvPVbyte(sv, lp) \ + ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK) \ + ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp)) + +#endif + +#else + +# define SvPVbyte SvPV +# define sv_2pvbyte sv_2pv + +#endif +#ifndef sv_2pvbyte_nolen +# define sv_2pvbyte_nolen(sv) sv_2pv_nolen(sv) +#endif + +/* Hint: sv_pvn + * Always use the SvPV() macro instead of sv_pvn(). + */ + +/* Hint: sv_pvn_force + * Always use the SvPV_force() macro instead of sv_pvn_force(). + */ + +/* If these are undefined, they're not handled by the core anyway */ +#ifndef SV_IMMEDIATE_UNREF +# define SV_IMMEDIATE_UNREF 0 +#endif + +#ifndef SV_GMAGIC +# define SV_GMAGIC 0 +#endif + +#ifndef SV_COW_DROP_PV +# define SV_COW_DROP_PV 0 +#endif + +#ifndef SV_UTF8_NO_ENCODING +# define SV_UTF8_NO_ENCODING 0 +#endif + +#ifndef SV_NOSTEAL +# define SV_NOSTEAL 0 +#endif + +#ifndef SV_CONST_RETURN +# define SV_CONST_RETURN 0 +#endif + +#ifndef SV_MUTABLE_RETURN +# define SV_MUTABLE_RETURN 0 +#endif + +#ifndef SV_SMAGIC +# define SV_SMAGIC 0 +#endif + +#ifndef SV_HAS_TRAILING_NUL +# define SV_HAS_TRAILING_NUL 0 +#endif + +#ifndef SV_COW_SHARED_HASH_KEYS +# define SV_COW_SHARED_HASH_KEYS 0 +#endif + +#if (PERL_BCDVERSION < 0x5007002) + +#if defined(NEED_sv_2pv_flags) +static char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags); +static +#else +extern char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags); +#endif + +#ifdef sv_2pv_flags +# undef sv_2pv_flags +#endif +#define sv_2pv_flags(a,b,c) DPPP_(my_sv_2pv_flags)(aTHX_ a,b,c) +#define Perl_sv_2pv_flags DPPP_(my_sv_2pv_flags) + +#if defined(NEED_sv_2pv_flags) || defined(NEED_sv_2pv_flags_GLOBAL) + +char * +DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags) +{ + STRLEN n_a = (STRLEN) flags; + return sv_2pv(sv, lp ? lp : &n_a); +} + +#endif + +#if defined(NEED_sv_pvn_force_flags) +static char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags); +static +#else +extern char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags); +#endif + +#ifdef sv_pvn_force_flags +# undef sv_pvn_force_flags +#endif +#define sv_pvn_force_flags(a,b,c) DPPP_(my_sv_pvn_force_flags)(aTHX_ a,b,c) +#define Perl_sv_pvn_force_flags DPPP_(my_sv_pvn_force_flags) + +#if defined(NEED_sv_pvn_force_flags) || defined(NEED_sv_pvn_force_flags_GLOBAL) + +char * +DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags) +{ + STRLEN n_a = (STRLEN) flags; + return sv_pvn_force(sv, lp ? lp : &n_a); +} + +#endif + +#endif + +#if (PERL_BCDVERSION < 0x5008008) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5009003) ) +# define DPPP_SVPV_NOLEN_LP_ARG &PL_na +#else +# define DPPP_SVPV_NOLEN_LP_ARG 0 +#endif +#ifndef SvPV_const +# define SvPV_const(sv, lp) SvPV_flags_const(sv, lp, SV_GMAGIC) +#endif + +#ifndef SvPV_mutable +# define SvPV_mutable(sv, lp) SvPV_flags_mutable(sv, lp, SV_GMAGIC) +#endif +#ifndef SvPV_flags +# define SvPV_flags(sv, lp, flags) \ + ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags)) +#endif +#ifndef SvPV_flags_const +# define SvPV_flags_const(sv, lp, flags) \ + ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + ? ((lp = SvCUR(sv)), SvPVX_const(sv)) : \ + (const char*) sv_2pv_flags(sv, &lp, flags|SV_CONST_RETURN)) +#endif +#ifndef SvPV_flags_const_nolen +# define SvPV_flags_const_nolen(sv, flags) \ + ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + ? SvPVX_const(sv) : \ + (const char*) sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags|SV_CONST_RETURN)) +#endif +#ifndef SvPV_flags_mutable +# define SvPV_flags_mutable(sv, lp, flags) \ + ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) : \ + sv_2pv_flags(sv, &lp, flags|SV_MUTABLE_RETURN)) +#endif +#ifndef SvPV_force +# define SvPV_force(sv, lp) SvPV_force_flags(sv, lp, SV_GMAGIC) +#endif + +#ifndef SvPV_force_nolen +# define SvPV_force_nolen(sv) SvPV_force_flags_nolen(sv, SV_GMAGIC) +#endif + +#ifndef SvPV_force_mutable +# define SvPV_force_mutable(sv, lp) SvPV_force_flags_mutable(sv, lp, SV_GMAGIC) +#endif + +#ifndef SvPV_force_nomg +# define SvPV_force_nomg(sv, lp) SvPV_force_flags(sv, lp, 0) +#endif + +#ifndef SvPV_force_nomg_nolen +# define SvPV_force_nomg_nolen(sv) SvPV_force_flags_nolen(sv, 0) +#endif +#ifndef SvPV_force_flags +# define SvPV_force_flags(sv, lp, flags) \ + ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \ + ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags)) +#endif +#ifndef SvPV_force_flags_nolen +# define SvPV_force_flags_nolen(sv, flags) \ + ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \ + ? SvPVX(sv) : sv_pvn_force_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags)) +#endif +#ifndef SvPV_force_flags_mutable +# define SvPV_force_flags_mutable(sv, lp, flags) \ + ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \ + ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \ + : sv_pvn_force_flags(sv, &lp, flags|SV_MUTABLE_RETURN)) +#endif +#ifndef SvPV_nolen +# define SvPV_nolen(sv) \ + ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + ? SvPVX(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC)) +#endif +#ifndef SvPV_nolen_const +# define SvPV_nolen_const(sv) \ + ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + ? SvPVX_const(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC|SV_CONST_RETURN)) +#endif +#ifndef SvPV_nomg +# define SvPV_nomg(sv, lp) SvPV_flags(sv, lp, 0) +#endif + +#ifndef SvPV_nomg_const +# define SvPV_nomg_const(sv, lp) SvPV_flags_const(sv, lp, 0) +#endif + +#ifndef SvPV_nomg_const_nolen +# define SvPV_nomg_const_nolen(sv) SvPV_flags_const_nolen(sv, 0) +#endif + +#ifndef SvPV_nomg_nolen +# define SvPV_nomg_nolen(sv) ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + ? SvPVX(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, 0)) +#endif +#ifndef SvPV_renew +# define SvPV_renew(sv,n) STMT_START { SvLEN_set(sv, n); \ + SvPV_set((sv), (char *) saferealloc( \ + (Malloc_t)SvPVX(sv), (MEM_SIZE)((n)))); \ + } STMT_END +#endif +#ifndef SvMAGIC_set +# define SvMAGIC_set(sv, val) \ + STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \ + (((XPVMG*) SvANY(sv))->xmg_magic = (val)); } STMT_END +#endif + +#if (PERL_BCDVERSION < 0x5009003) +#ifndef SvPVX_const +# define SvPVX_const(sv) ((const char*) (0 + SvPVX(sv))) +#endif + +#ifndef SvPVX_mutable +# define SvPVX_mutable(sv) (0 + SvPVX(sv)) +#endif +#ifndef SvRV_set +# define SvRV_set(sv, val) \ + STMT_START { assert(SvTYPE(sv) >= SVt_RV); \ + (((XRV*) SvANY(sv))->xrv_rv = (val)); } STMT_END +#endif + +#else +#ifndef SvPVX_const +# define SvPVX_const(sv) ((const char*)((sv)->sv_u.svu_pv)) +#endif + +#ifndef SvPVX_mutable +# define SvPVX_mutable(sv) ((sv)->sv_u.svu_pv) +#endif +#ifndef SvRV_set +# define SvRV_set(sv, val) \ + STMT_START { assert(SvTYPE(sv) >= SVt_RV); \ + ((sv)->sv_u.svu_rv = (val)); } STMT_END +#endif + +#endif +#ifndef SvSTASH_set +# define SvSTASH_set(sv, val) \ + STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \ + (((XPVMG*) SvANY(sv))->xmg_stash = (val)); } STMT_END +#endif + +#if (PERL_BCDVERSION < 0x5004000) +#ifndef SvUV_set +# define SvUV_set(sv, val) \ + STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \ + (((XPVIV*) SvANY(sv))->xiv_iv = (IV) (val)); } STMT_END +#endif + +#else +#ifndef SvUV_set +# define SvUV_set(sv, val) \ + STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \ + (((XPVUV*) SvANY(sv))->xuv_uv = (val)); } STMT_END +#endif + +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(vnewSVpvf) +#if defined(NEED_vnewSVpvf) +static SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args); +static +#else +extern SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args); +#endif + +#ifdef vnewSVpvf +# undef vnewSVpvf +#endif +#define vnewSVpvf(a,b) DPPP_(my_vnewSVpvf)(aTHX_ a,b) +#define Perl_vnewSVpvf DPPP_(my_vnewSVpvf) + +#if defined(NEED_vnewSVpvf) || defined(NEED_vnewSVpvf_GLOBAL) + +SV * +DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args) +{ + register SV *sv = newSV(0); + sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); + return sv; +} + +#endif +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf) +# define sv_vcatpvf(sv, pat, args) sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)) +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf) +# define sv_vsetpvf(sv, pat, args) sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)) +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg) +#if defined(NEED_sv_catpvf_mg) +static void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...); +static +#else +extern void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...); +#endif + +#define Perl_sv_catpvf_mg DPPP_(my_sv_catpvf_mg) + +#if defined(NEED_sv_catpvf_mg) || defined(NEED_sv_catpvf_mg_GLOBAL) + +void +DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...) +{ + va_list args; + va_start(args, pat); + sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*)); + SvSETMAGIC(sv); + va_end(args); +} + +#endif +#endif + +#ifdef PERL_IMPLICIT_CONTEXT +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg_nocontext) +#if defined(NEED_sv_catpvf_mg_nocontext) +static void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...); +static +#else +extern void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...); +#endif + +#define sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext) +#define Perl_sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext) + +#if defined(NEED_sv_catpvf_mg_nocontext) || defined(NEED_sv_catpvf_mg_nocontext_GLOBAL) + +void +DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...) +{ + dTHX; + va_list args; + va_start(args, pat); + sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*)); + SvSETMAGIC(sv); + va_end(args); +} + +#endif +#endif +#endif + +/* sv_catpvf_mg depends on sv_catpvf_mg_nocontext */ +#ifndef sv_catpvf_mg +# ifdef PERL_IMPLICIT_CONTEXT +# define sv_catpvf_mg Perl_sv_catpvf_mg_nocontext +# else +# define sv_catpvf_mg Perl_sv_catpvf_mg +# endif +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf_mg) +# define sv_vcatpvf_mg(sv, pat, args) \ + STMT_START { \ + sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); \ + SvSETMAGIC(sv); \ + } STMT_END +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg) +#if defined(NEED_sv_setpvf_mg) +static void DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...); +static +#else +extern void DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...); +#endif + +#define Perl_sv_setpvf_mg DPPP_(my_sv_setpvf_mg) + +#if defined(NEED_sv_setpvf_mg) || defined(NEED_sv_setpvf_mg_GLOBAL) + +void +DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...) +{ + va_list args; + va_start(args, pat); + sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*)); + SvSETMAGIC(sv); + va_end(args); +} + +#endif +#endif + +#ifdef PERL_IMPLICIT_CONTEXT +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg_nocontext) +#if defined(NEED_sv_setpvf_mg_nocontext) +static void DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...); +static +#else +extern void DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...); +#endif + +#define sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext) +#define Perl_sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext) + +#if defined(NEED_sv_setpvf_mg_nocontext) || defined(NEED_sv_setpvf_mg_nocontext_GLOBAL) + +void +DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...) +{ + dTHX; + va_list args; + va_start(args, pat); + sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*)); + SvSETMAGIC(sv); + va_end(args); +} + +#endif +#endif +#endif + +/* sv_setpvf_mg depends on sv_setpvf_mg_nocontext */ +#ifndef sv_setpvf_mg +# ifdef PERL_IMPLICIT_CONTEXT +# define sv_setpvf_mg Perl_sv_setpvf_mg_nocontext +# else +# define sv_setpvf_mg Perl_sv_setpvf_mg +# endif +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf_mg) +# define sv_vsetpvf_mg(sv, pat, args) \ + STMT_START { \ + sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); \ + SvSETMAGIC(sv); \ + } STMT_END +#endif + +/* Hint: newSVpvn_share + * The SVs created by this function only mimic the behaviour of + * shared PVs without really being shared. Only use if you know + * what you're doing. + */ + +#ifndef newSVpvn_share + +#if defined(NEED_newSVpvn_share) +static SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash); +static +#else +extern SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash); +#endif + +#ifdef newSVpvn_share +# undef newSVpvn_share +#endif +#define newSVpvn_share(a,b,c) DPPP_(my_newSVpvn_share)(aTHX_ a,b,c) +#define Perl_newSVpvn_share DPPP_(my_newSVpvn_share) + +#if defined(NEED_newSVpvn_share) || defined(NEED_newSVpvn_share_GLOBAL) + +SV * +DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash) +{ + SV *sv; + if (len < 0) + len = -len; + if (!hash) + PERL_HASH(hash, (char*) src, len); + sv = newSVpvn((char *) src, len); + sv_upgrade(sv, SVt_PVIV); + SvIVX(sv) = hash; + SvREADONLY_on(sv); + SvPOK_on(sv); + return sv; +} + +#endif + +#endif +#ifndef SvSHARED_HASH +# define SvSHARED_HASH(sv) (0 + SvUVX(sv)) +#endif +#ifndef HvNAME_get +# define HvNAME_get(hv) HvNAME(hv) +#endif +#ifndef HvNAMELEN_get +# define HvNAMELEN_get(hv) (HvNAME_get(hv) ? (I32)strlen(HvNAME_get(hv)) : 0) +#endif +#ifndef GvSVn +# define GvSVn(gv) GvSV(gv) +#endif + +#ifndef isGV_with_GP +# define isGV_with_GP(gv) isGV(gv) +#endif + +#ifndef gv_fetchpvn_flags +# define gv_fetchpvn_flags(name, len, flags, svt) gv_fetchpv(name, flags, svt) +#endif + +#ifndef gv_fetchsv +# define gv_fetchsv(name, flags, svt) gv_fetchpv(SvPV_nolen_const(name), flags, svt) +#endif +#ifndef get_cvn_flags +# define get_cvn_flags(name, namelen, flags) get_cv(name, flags) +#endif +#ifndef WARN_ALL +# define WARN_ALL 0 +#endif + +#ifndef WARN_CLOSURE +# define WARN_CLOSURE 1 +#endif + +#ifndef WARN_DEPRECATED +# define WARN_DEPRECATED 2 +#endif + +#ifndef WARN_EXITING +# define WARN_EXITING 3 +#endif + +#ifndef WARN_GLOB +# define WARN_GLOB 4 +#endif + +#ifndef WARN_IO +# define WARN_IO 5 +#endif + +#ifndef WARN_CLOSED +# define WARN_CLOSED 6 +#endif + +#ifndef WARN_EXEC +# define WARN_EXEC 7 +#endif + +#ifndef WARN_LAYER +# define WARN_LAYER 8 +#endif + +#ifndef WARN_NEWLINE +# define WARN_NEWLINE 9 +#endif + +#ifndef WARN_PIPE +# define WARN_PIPE 10 +#endif + +#ifndef WARN_UNOPENED +# define WARN_UNOPENED 11 +#endif + +#ifndef WARN_MISC +# define WARN_MISC 12 +#endif + +#ifndef WARN_NUMERIC +# define WARN_NUMERIC 13 +#endif + +#ifndef WARN_ONCE +# define WARN_ONCE 14 +#endif + +#ifndef WARN_OVERFLOW +# define WARN_OVERFLOW 15 +#endif + +#ifndef WARN_PACK +# define WARN_PACK 16 +#endif + +#ifndef WARN_PORTABLE +# define WARN_PORTABLE 17 +#endif + +#ifndef WARN_RECURSION +# define WARN_RECURSION 18 +#endif + +#ifndef WARN_REDEFINE +# define WARN_REDEFINE 19 +#endif + +#ifndef WARN_REGEXP +# define WARN_REGEXP 20 +#endif + +#ifndef WARN_SEVERE +# define WARN_SEVERE 21 +#endif + +#ifndef WARN_DEBUGGING +# define WARN_DEBUGGING 22 +#endif + +#ifndef WARN_INPLACE +# define WARN_INPLACE 23 +#endif + +#ifndef WARN_INTERNAL +# define WARN_INTERNAL 24 +#endif + +#ifndef WARN_MALLOC +# define WARN_MALLOC 25 +#endif + +#ifndef WARN_SIGNAL +# define WARN_SIGNAL 26 +#endif + +#ifndef WARN_SUBSTR +# define WARN_SUBSTR 27 +#endif + +#ifndef WARN_SYNTAX +# define WARN_SYNTAX 28 +#endif + +#ifndef WARN_AMBIGUOUS +# define WARN_AMBIGUOUS 29 +#endif + +#ifndef WARN_BAREWORD +# define WARN_BAREWORD 30 +#endif + +#ifndef WARN_DIGIT +# define WARN_DIGIT 31 +#endif + +#ifndef WARN_PARENTHESIS +# define WARN_PARENTHESIS 32 +#endif + +#ifndef WARN_PRECEDENCE +# define WARN_PRECEDENCE 33 +#endif + +#ifndef WARN_PRINTF +# define WARN_PRINTF 34 +#endif + +#ifndef WARN_PROTOTYPE +# define WARN_PROTOTYPE 35 +#endif + +#ifndef WARN_QW +# define WARN_QW 36 +#endif + +#ifndef WARN_RESERVED +# define WARN_RESERVED 37 +#endif + +#ifndef WARN_SEMICOLON +# define WARN_SEMICOLON 38 +#endif + +#ifndef WARN_TAINT +# define WARN_TAINT 39 +#endif + +#ifndef WARN_THREADS +# define WARN_THREADS 40 +#endif + +#ifndef WARN_UNINITIALIZED +# define WARN_UNINITIALIZED 41 +#endif + +#ifndef WARN_UNPACK +# define WARN_UNPACK 42 +#endif + +#ifndef WARN_UNTIE +# define WARN_UNTIE 43 +#endif + +#ifndef WARN_UTF8 +# define WARN_UTF8 44 +#endif + +#ifndef WARN_VOID +# define WARN_VOID 45 +#endif + +#ifndef WARN_ASSERTIONS +# define WARN_ASSERTIONS 46 +#endif +#ifndef packWARN +# define packWARN(a) (a) +#endif + +#ifndef ckWARN +# ifdef G_WARN_ON +# define ckWARN(a) (PL_dowarn & G_WARN_ON) +# else +# define ckWARN(a) PL_dowarn +# endif +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(warner) +#if defined(NEED_warner) +static void DPPP_(my_warner)(U32 err, const char *pat, ...); +static +#else +extern void DPPP_(my_warner)(U32 err, const char *pat, ...); +#endif + +#define Perl_warner DPPP_(my_warner) + +#if defined(NEED_warner) || defined(NEED_warner_GLOBAL) + +void +DPPP_(my_warner)(U32 err, const char *pat, ...) +{ + SV *sv; + va_list args; + + PERL_UNUSED_ARG(err); + + va_start(args, pat); + sv = vnewSVpvf(pat, &args); + va_end(args); + sv_2mortal(sv); + warn("%s", SvPV_nolen(sv)); +} + +#define warner Perl_warner + +#define Perl_warner_nocontext Perl_warner + +#endif +#endif + +/* concatenating with "" ensures that only literal strings are accepted as argument + * note that STR_WITH_LEN() can't be used as argument to macros or functions that + * under some configurations might be macros + */ +#ifndef STR_WITH_LEN +# define STR_WITH_LEN(s) (s ""), (sizeof(s)-1) +#endif +#ifndef newSVpvs +# define newSVpvs(str) newSVpvn(str "", sizeof(str) - 1) +#endif + +#ifndef newSVpvs_flags +# define newSVpvs_flags(str, flags) newSVpvn_flags(str "", sizeof(str) - 1, flags) +#endif + +#ifndef newSVpvs_share +# define newSVpvs_share(str) newSVpvn_share(str "", sizeof(str) - 1, 0) +#endif + +#ifndef sv_catpvs +# define sv_catpvs(sv, str) sv_catpvn(sv, str "", sizeof(str) - 1) +#endif + +#ifndef sv_setpvs +# define sv_setpvs(sv, str) sv_setpvn(sv, str "", sizeof(str) - 1) +#endif + +#ifndef hv_fetchs +# define hv_fetchs(hv, key, lval) hv_fetch(hv, key "", sizeof(key) - 1, lval) +#endif + +#ifndef hv_stores +# define hv_stores(hv, key, val) hv_store(hv, key "", sizeof(key) - 1, val, 0) +#endif +#ifndef gv_fetchpvs +# define gv_fetchpvs(name, flags, svt) gv_fetchpvn_flags(name "", sizeof(name) - 1, flags, svt) +#endif + +#ifndef gv_stashpvs +# define gv_stashpvs(name, flags) gv_stashpvn(name "", sizeof(name) - 1, flags) +#endif +#ifndef get_cvs +# define get_cvs(name, flags) get_cvn_flags(name "", sizeof(name)-1, flags) +#endif +#ifndef SvGETMAGIC +# define SvGETMAGIC(x) STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END +#endif + +/* Some random bits for sv_unmagicext. These should probably be pulled in for + real and organized at some point */ +#ifndef HEf_SVKEY +# define HEf_SVKEY -2 +#endif + +#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) +# define MUTABLE_PTR(p) ({ void *_p = (p); _p; }) +#else +# define MUTABLE_PTR(p) ((void *) (p)) +#endif + +#define MUTABLE_SV(p) ((SV *)MUTABLE_PTR(p)) + +/* end of random bits */ +#ifndef PERL_MAGIC_sv +# define PERL_MAGIC_sv '\0' +#endif + +#ifndef PERL_MAGIC_overload +# define PERL_MAGIC_overload 'A' +#endif + +#ifndef PERL_MAGIC_overload_elem +# define PERL_MAGIC_overload_elem 'a' +#endif + +#ifndef PERL_MAGIC_overload_table +# define PERL_MAGIC_overload_table 'c' +#endif + +#ifndef PERL_MAGIC_bm +# define PERL_MAGIC_bm 'B' +#endif + +#ifndef PERL_MAGIC_regdata +# define PERL_MAGIC_regdata 'D' +#endif + +#ifndef PERL_MAGIC_regdatum +# define PERL_MAGIC_regdatum 'd' +#endif + +#ifndef PERL_MAGIC_env +# define PERL_MAGIC_env 'E' +#endif + +#ifndef PERL_MAGIC_envelem +# define PERL_MAGIC_envelem 'e' +#endif + +#ifndef PERL_MAGIC_fm +# define PERL_MAGIC_fm 'f' +#endif + +#ifndef PERL_MAGIC_regex_global +# define PERL_MAGIC_regex_global 'g' +#endif + +#ifndef PERL_MAGIC_isa +# define PERL_MAGIC_isa 'I' +#endif + +#ifndef PERL_MAGIC_isaelem +# define PERL_MAGIC_isaelem 'i' +#endif + +#ifndef PERL_MAGIC_nkeys +# define PERL_MAGIC_nkeys 'k' +#endif + +#ifndef PERL_MAGIC_dbfile +# define PERL_MAGIC_dbfile 'L' +#endif + +#ifndef PERL_MAGIC_dbline +# define PERL_MAGIC_dbline 'l' +#endif + +#ifndef PERL_MAGIC_mutex +# define PERL_MAGIC_mutex 'm' +#endif + +#ifndef PERL_MAGIC_shared +# define PERL_MAGIC_shared 'N' +#endif + +#ifndef PERL_MAGIC_shared_scalar +# define PERL_MAGIC_shared_scalar 'n' +#endif + +#ifndef PERL_MAGIC_collxfrm +# define PERL_MAGIC_collxfrm 'o' +#endif + +#ifndef PERL_MAGIC_tied +# define PERL_MAGIC_tied 'P' +#endif + +#ifndef PERL_MAGIC_tiedelem +# define PERL_MAGIC_tiedelem 'p' +#endif + +#ifndef PERL_MAGIC_tiedscalar +# define PERL_MAGIC_tiedscalar 'q' +#endif + +#ifndef PERL_MAGIC_qr +# define PERL_MAGIC_qr 'r' +#endif + +#ifndef PERL_MAGIC_sig +# define PERL_MAGIC_sig 'S' +#endif + +#ifndef PERL_MAGIC_sigelem +# define PERL_MAGIC_sigelem 's' +#endif + +#ifndef PERL_MAGIC_taint +# define PERL_MAGIC_taint 't' +#endif + +#ifndef PERL_MAGIC_uvar +# define PERL_MAGIC_uvar 'U' +#endif + +#ifndef PERL_MAGIC_uvar_elem +# define PERL_MAGIC_uvar_elem 'u' +#endif + +#ifndef PERL_MAGIC_vstring +# define PERL_MAGIC_vstring 'V' +#endif + +#ifndef PERL_MAGIC_vec +# define PERL_MAGIC_vec 'v' +#endif + +#ifndef PERL_MAGIC_utf8 +# define PERL_MAGIC_utf8 'w' +#endif + +#ifndef PERL_MAGIC_substr +# define PERL_MAGIC_substr 'x' +#endif + +#ifndef PERL_MAGIC_defelem +# define PERL_MAGIC_defelem 'y' +#endif + +#ifndef PERL_MAGIC_glob +# define PERL_MAGIC_glob '*' +#endif + +#ifndef PERL_MAGIC_arylen +# define PERL_MAGIC_arylen '#' +#endif + +#ifndef PERL_MAGIC_pos +# define PERL_MAGIC_pos '.' +#endif + +#ifndef PERL_MAGIC_backref +# define PERL_MAGIC_backref '<' +#endif + +#ifndef PERL_MAGIC_ext +# define PERL_MAGIC_ext '~' +#endif + +/* That's the best we can do... */ +#ifndef sv_catpvn_nomg +# define sv_catpvn_nomg sv_catpvn +#endif + +#ifndef sv_catsv_nomg +# define sv_catsv_nomg sv_catsv +#endif + +#ifndef sv_setsv_nomg +# define sv_setsv_nomg sv_setsv +#endif + +#ifndef sv_pvn_nomg +# define sv_pvn_nomg sv_pvn +#endif + +#ifndef SvIV_nomg +# define SvIV_nomg SvIV +#endif + +#ifndef SvUV_nomg +# define SvUV_nomg SvUV +#endif + +#ifndef sv_catpv_mg +# define sv_catpv_mg(sv, ptr) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_catpv(TeMpSv,ptr); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_catpvn_mg +# define sv_catpvn_mg(sv, ptr, len) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_catpvn(TeMpSv,ptr,len); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_catsv_mg +# define sv_catsv_mg(dsv, ssv) \ + STMT_START { \ + SV *TeMpSv = dsv; \ + sv_catsv(TeMpSv,ssv); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_setiv_mg +# define sv_setiv_mg(sv, i) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_setiv(TeMpSv,i); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_setnv_mg +# define sv_setnv_mg(sv, num) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_setnv(TeMpSv,num); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_setpv_mg +# define sv_setpv_mg(sv, ptr) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_setpv(TeMpSv,ptr); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_setpvn_mg +# define sv_setpvn_mg(sv, ptr, len) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_setpvn(TeMpSv,ptr,len); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_setsv_mg +# define sv_setsv_mg(dsv, ssv) \ + STMT_START { \ + SV *TeMpSv = dsv; \ + sv_setsv(TeMpSv,ssv); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_setuv_mg +# define sv_setuv_mg(sv, i) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_setuv(TeMpSv,i); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_usepvn_mg +# define sv_usepvn_mg(sv, ptr, len) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_usepvn(TeMpSv,ptr,len); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif +#ifndef SvVSTRING_mg +# define SvVSTRING_mg(sv) (SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_vstring) : NULL) +#endif + +/* Hint: sv_magic_portable + * This is a compatibility function that is only available with + * Devel::PPPort. It is NOT in the perl core. + * Its purpose is to mimic the 5.8.0 behaviour of sv_magic() when + * it is being passed a name pointer with namlen == 0. In that + * case, perl 5.8.0 and later store the pointer, not a copy of it. + * The compatibility can be provided back to perl 5.004. With + * earlier versions, the code will not compile. + */ + +#if (PERL_BCDVERSION < 0x5004000) + + /* code that uses sv_magic_portable will not compile */ + +#elif (PERL_BCDVERSION < 0x5008000) + +# define sv_magic_portable(sv, obj, how, name, namlen) \ + STMT_START { \ + SV *SvMp_sv = (sv); \ + char *SvMp_name = (char *) (name); \ + I32 SvMp_namlen = (namlen); \ + if (SvMp_name && SvMp_namlen == 0) \ + { \ + MAGIC *mg; \ + sv_magic(SvMp_sv, obj, how, 0, 0); \ + mg = SvMAGIC(SvMp_sv); \ + mg->mg_len = -42; /* XXX: this is the tricky part */ \ + mg->mg_ptr = SvMp_name; \ + } \ + else \ + { \ + sv_magic(SvMp_sv, obj, how, SvMp_name, SvMp_namlen); \ + } \ + } STMT_END + +#else + +# define sv_magic_portable(a, b, c, d, e) sv_magic(a, b, c, d, e) + +#endif + +#if !defined(mg_findext) +#if defined(NEED_mg_findext) +static MAGIC * DPPP_(my_mg_findext)(SV * sv, int type, const MGVTBL *vtbl); +static +#else +extern MAGIC * DPPP_(my_mg_findext)(SV * sv, int type, const MGVTBL *vtbl); +#endif + +#define mg_findext DPPP_(my_mg_findext) +#define Perl_mg_findext DPPP_(my_mg_findext) + +#if defined(NEED_mg_findext) || defined(NEED_mg_findext_GLOBAL) + +MAGIC * +DPPP_(my_mg_findext)(SV * sv, int type, const MGVTBL *vtbl) { + if (sv) { + MAGIC *mg; + +#ifdef AvPAD_NAMELIST + assert(!(SvTYPE(sv) == SVt_PVAV && AvPAD_NAMELIST(sv))); +#endif + + for (mg = SvMAGIC (sv); mg; mg = mg->mg_moremagic) { + if (mg->mg_type == type && mg->mg_virtual == vtbl) + return mg; + } + } + + return NULL; +} + +#endif +#endif + +#if !defined(sv_unmagicext) +#if defined(NEED_sv_unmagicext) +static int DPPP_(my_sv_unmagicext)(pTHX_ SV * const sv, const int type, MGVTBL * vtbl); +static +#else +extern int DPPP_(my_sv_unmagicext)(pTHX_ SV * const sv, const int type, MGVTBL * vtbl); +#endif + +#ifdef sv_unmagicext +# undef sv_unmagicext +#endif +#define sv_unmagicext(a,b,c) DPPP_(my_sv_unmagicext)(aTHX_ a,b,c) +#define Perl_sv_unmagicext DPPP_(my_sv_unmagicext) + +#if defined(NEED_sv_unmagicext) || defined(NEED_sv_unmagicext_GLOBAL) + +int +DPPP_(my_sv_unmagicext)(pTHX_ SV *const sv, const int type, MGVTBL *vtbl) +{ + MAGIC* mg; + MAGIC** mgp; + + if (SvTYPE(sv) < SVt_PVMG || !SvMAGIC(sv)) + return 0; + mgp = &(SvMAGIC(sv)); + for (mg = *mgp; mg; mg = *mgp) { + const MGVTBL* const virt = mg->mg_virtual; + if (mg->mg_type == type && virt == vtbl) { + *mgp = mg->mg_moremagic; + if (virt && virt->svt_free) + virt->svt_free(aTHX_ sv, mg); + if (mg->mg_ptr && mg->mg_type != PERL_MAGIC_regex_global) { + if (mg->mg_len > 0) + Safefree(mg->mg_ptr); + else if (mg->mg_len == HEf_SVKEY) /* Questionable on older perls... */ + SvREFCNT_dec(MUTABLE_SV(mg->mg_ptr)); + else if (mg->mg_type == PERL_MAGIC_utf8) + Safefree(mg->mg_ptr); + } + if (mg->mg_flags & MGf_REFCOUNTED) + SvREFCNT_dec(mg->mg_obj); + Safefree(mg); + } + else + mgp = &mg->mg_moremagic; + } + if (SvMAGIC(sv)) { + if (SvMAGICAL(sv)) /* if we're under save_magic, wait for restore_magic; */ + mg_magical(sv); /* else fix the flags now */ + } + else { + SvMAGICAL_off(sv); + SvFLAGS(sv) |= (SvFLAGS(sv) & (SVp_IOK|SVp_NOK|SVp_POK)) >> PRIVSHIFT; + } + return 0; +} + +#endif +#endif + +#ifdef USE_ITHREADS +#ifndef CopFILE +# define CopFILE(c) ((c)->cop_file) +#endif + +#ifndef CopFILEGV +# define CopFILEGV(c) (CopFILE(c) ? gv_fetchfile(CopFILE(c)) : Nullgv) +#endif + +#ifndef CopFILE_set +# define CopFILE_set(c,pv) ((c)->cop_file = savepv(pv)) +#endif + +#ifndef CopFILESV +# define CopFILESV(c) (CopFILE(c) ? GvSV(gv_fetchfile(CopFILE(c))) : Nullsv) +#endif + +#ifndef CopFILEAV +# define CopFILEAV(c) (CopFILE(c) ? GvAV(gv_fetchfile(CopFILE(c))) : Nullav) +#endif + +#ifndef CopSTASHPV +# define CopSTASHPV(c) ((c)->cop_stashpv) +#endif + +#ifndef CopSTASHPV_set +# define CopSTASHPV_set(c,pv) ((c)->cop_stashpv = ((pv) ? savepv(pv) : Nullch)) +#endif + +#ifndef CopSTASH +# define CopSTASH(c) (CopSTASHPV(c) ? gv_stashpv(CopSTASHPV(c),GV_ADD) : Nullhv) +#endif + +#ifndef CopSTASH_set +# define CopSTASH_set(c,hv) CopSTASHPV_set(c, (hv) ? HvNAME(hv) : Nullch) +#endif + +#ifndef CopSTASH_eq +# define CopSTASH_eq(c,hv) ((hv) && (CopSTASHPV(c) == HvNAME(hv) \ + || (CopSTASHPV(c) && HvNAME(hv) \ + && strEQ(CopSTASHPV(c), HvNAME(hv))))) +#endif + +#else +#ifndef CopFILEGV +# define CopFILEGV(c) ((c)->cop_filegv) +#endif + +#ifndef CopFILEGV_set +# define CopFILEGV_set(c,gv) ((c)->cop_filegv = (GV*)SvREFCNT_inc(gv)) +#endif + +#ifndef CopFILE_set +# define CopFILE_set(c,pv) CopFILEGV_set((c), gv_fetchfile(pv)) +#endif + +#ifndef CopFILESV +# define CopFILESV(c) (CopFILEGV(c) ? GvSV(CopFILEGV(c)) : Nullsv) +#endif + +#ifndef CopFILEAV +# define CopFILEAV(c) (CopFILEGV(c) ? GvAV(CopFILEGV(c)) : Nullav) +#endif + +#ifndef CopFILE +# define CopFILE(c) (CopFILESV(c) ? SvPVX(CopFILESV(c)) : Nullch) +#endif + +#ifndef CopSTASH +# define CopSTASH(c) ((c)->cop_stash) +#endif + +#ifndef CopSTASH_set +# define CopSTASH_set(c,hv) ((c)->cop_stash = (hv)) +#endif + +#ifndef CopSTASHPV +# define CopSTASHPV(c) (CopSTASH(c) ? HvNAME(CopSTASH(c)) : Nullch) +#endif + +#ifndef CopSTASHPV_set +# define CopSTASHPV_set(c,pv) CopSTASH_set((c), gv_stashpv(pv,GV_ADD)) +#endif + +#ifndef CopSTASH_eq +# define CopSTASH_eq(c,hv) (CopSTASH(c) == (hv)) +#endif + +#endif /* USE_ITHREADS */ + +#if (PERL_BCDVERSION >= 0x5006000) +#ifndef caller_cx + +# if defined(NEED_caller_cx) || defined(NEED_caller_cx_GLOBAL) +static I32 +DPPP_dopoptosub_at(const PERL_CONTEXT *cxstk, I32 startingblock) +{ + I32 i; + + for (i = startingblock; i >= 0; i--) { + register const PERL_CONTEXT * const cx = &cxstk[i]; + switch (CxTYPE(cx)) { + default: + continue; + case CXt_EVAL: + case CXt_SUB: + case CXt_FORMAT: + return i; + } + } + return i; +} +# endif + +# if defined(NEED_caller_cx) +static const PERL_CONTEXT * DPPP_(my_caller_cx)(pTHX_ I32 count, const PERL_CONTEXT **dbcxp); +static +#else +extern const PERL_CONTEXT * DPPP_(my_caller_cx)(pTHX_ I32 count, const PERL_CONTEXT **dbcxp); +#endif + +#ifdef caller_cx +# undef caller_cx +#endif +#define caller_cx(a,b) DPPP_(my_caller_cx)(aTHX_ a,b) +#define Perl_caller_cx DPPP_(my_caller_cx) + +#if defined(NEED_caller_cx) || defined(NEED_caller_cx_GLOBAL) + +const PERL_CONTEXT * +DPPP_(my_caller_cx)(pTHX_ I32 count, const PERL_CONTEXT **dbcxp) +{ + register I32 cxix = DPPP_dopoptosub_at(cxstack, cxstack_ix); + register const PERL_CONTEXT *cx; + register const PERL_CONTEXT *ccstack = cxstack; + const PERL_SI *top_si = PL_curstackinfo; + + for (;;) { + /* we may be in a higher stacklevel, so dig down deeper */ + while (cxix < 0 && top_si->si_type != PERLSI_MAIN) { + top_si = top_si->si_prev; + ccstack = top_si->si_cxstack; + cxix = DPPP_dopoptosub_at(ccstack, top_si->si_cxix); + } + if (cxix < 0) + return NULL; + /* caller() should not report the automatic calls to &DB::sub */ + if (PL_DBsub && GvCV(PL_DBsub) && cxix >= 0 && + ccstack[cxix].blk_sub.cv == GvCV(PL_DBsub)) + count++; + if (!count--) + break; + cxix = DPPP_dopoptosub_at(ccstack, cxix - 1); + } + + cx = &ccstack[cxix]; + if (dbcxp) *dbcxp = cx; + + if (CxTYPE(cx) == CXt_SUB || CxTYPE(cx) == CXt_FORMAT) { + const I32 dbcxix = DPPP_dopoptosub_at(ccstack, cxix - 1); + /* We expect that ccstack[dbcxix] is CXt_SUB, anyway, the + field below is defined for any cx. */ + /* caller() should not report the automatic calls to &DB::sub */ + if (PL_DBsub && GvCV(PL_DBsub) && dbcxix >= 0 && ccstack[dbcxix].blk_sub.cv == GvCV(PL_DBsub)) + cx = &ccstack[dbcxix]; + } + + return cx; +} + +# endif +#endif /* caller_cx */ +#endif /* 5.6.0 */ +#ifndef IN_PERL_COMPILETIME +# define IN_PERL_COMPILETIME (PL_curcop == &PL_compiling) +#endif + +#ifndef IN_LOCALE_RUNTIME +# define IN_LOCALE_RUNTIME (PL_curcop->op_private & HINT_LOCALE) +#endif + +#ifndef IN_LOCALE_COMPILETIME +# define IN_LOCALE_COMPILETIME (PL_hints & HINT_LOCALE) +#endif + +#ifndef IN_LOCALE +# define IN_LOCALE (IN_PERL_COMPILETIME ? IN_LOCALE_COMPILETIME : IN_LOCALE_RUNTIME) +#endif +#ifndef IS_NUMBER_IN_UV +# define IS_NUMBER_IN_UV 0x01 +#endif + +#ifndef IS_NUMBER_GREATER_THAN_UV_MAX +# define IS_NUMBER_GREATER_THAN_UV_MAX 0x02 +#endif + +#ifndef IS_NUMBER_NOT_INT +# define IS_NUMBER_NOT_INT 0x04 +#endif + +#ifndef IS_NUMBER_NEG +# define IS_NUMBER_NEG 0x08 +#endif + +#ifndef IS_NUMBER_INFINITY +# define IS_NUMBER_INFINITY 0x10 +#endif + +#ifndef IS_NUMBER_NAN +# define IS_NUMBER_NAN 0x20 +#endif +#ifndef GROK_NUMERIC_RADIX +# define GROK_NUMERIC_RADIX(sp, send) grok_numeric_radix(sp, send) +#endif +#ifndef PERL_SCAN_GREATER_THAN_UV_MAX +# define PERL_SCAN_GREATER_THAN_UV_MAX 0x02 +#endif + +#ifndef PERL_SCAN_SILENT_ILLDIGIT +# define PERL_SCAN_SILENT_ILLDIGIT 0x04 +#endif + +#ifndef PERL_SCAN_ALLOW_UNDERSCORES +# define PERL_SCAN_ALLOW_UNDERSCORES 0x01 +#endif + +#ifndef PERL_SCAN_DISALLOW_PREFIX +# define PERL_SCAN_DISALLOW_PREFIX 0x02 +#endif + +#ifndef grok_numeric_radix +#if defined(NEED_grok_numeric_radix) +static bool DPPP_(my_grok_numeric_radix)(pTHX_ const char ** sp, const char * send); +static +#else +extern bool DPPP_(my_grok_numeric_radix)(pTHX_ const char ** sp, const char * send); +#endif + +#ifdef grok_numeric_radix +# undef grok_numeric_radix +#endif +#define grok_numeric_radix(a,b) DPPP_(my_grok_numeric_radix)(aTHX_ a,b) +#define Perl_grok_numeric_radix DPPP_(my_grok_numeric_radix) + +#if defined(NEED_grok_numeric_radix) || defined(NEED_grok_numeric_radix_GLOBAL) +bool +DPPP_(my_grok_numeric_radix)(pTHX_ const char **sp, const char *send) +{ +#ifdef USE_LOCALE_NUMERIC +#ifdef PL_numeric_radix_sv + if (PL_numeric_radix_sv && IN_LOCALE) { + STRLEN len; + char* radix = SvPV(PL_numeric_radix_sv, len); + if (*sp + len <= send && memEQ(*sp, radix, len)) { + *sp += len; + return TRUE; + } + } +#else + /* older perls don't have PL_numeric_radix_sv so the radix + * must manually be requested from locale.h + */ +#include + dTHR; /* needed for older threaded perls */ + struct lconv *lc = localeconv(); + char *radix = lc->decimal_point; + if (radix && IN_LOCALE) { + STRLEN len = strlen(radix); + if (*sp + len <= send && memEQ(*sp, radix, len)) { + *sp += len; + return TRUE; + } + } +#endif +#endif /* USE_LOCALE_NUMERIC */ + /* always try "." if numeric radix didn't match because + * we may have data from different locales mixed */ + if (*sp < send && **sp == '.') { + ++*sp; + return TRUE; + } + return FALSE; +} +#endif +#endif + +#ifndef grok_number +#if defined(NEED_grok_number) +static int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep); +static +#else +extern int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep); +#endif + +#ifdef grok_number +# undef grok_number +#endif +#define grok_number(a,b,c) DPPP_(my_grok_number)(aTHX_ a,b,c) +#define Perl_grok_number DPPP_(my_grok_number) + +#if defined(NEED_grok_number) || defined(NEED_grok_number_GLOBAL) +int +DPPP_(my_grok_number)(pTHX_ const char *pv, STRLEN len, UV *valuep) +{ + const char *s = pv; + const char *send = pv + len; + const UV max_div_10 = UV_MAX / 10; + const char max_mod_10 = UV_MAX % 10; + int numtype = 0; + int sawinf = 0; + int sawnan = 0; + + while (s < send && isSPACE(*s)) + s++; + if (s == send) { + return 0; + } else if (*s == '-') { + s++; + numtype = IS_NUMBER_NEG; + } + else if (*s == '+') + s++; + + if (s == send) + return 0; + + /* next must be digit or the radix separator or beginning of infinity */ + if (isDIGIT(*s)) { + /* UVs are at least 32 bits, so the first 9 decimal digits cannot + overflow. */ + UV value = *s - '0'; + /* This construction seems to be more optimiser friendly. + (without it gcc does the isDIGIT test and the *s - '0' separately) + With it gcc on arm is managing 6 instructions (6 cycles) per digit. + In theory the optimiser could deduce how far to unroll the loop + before checking for overflow. */ + if (++s < send) { + int digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + /* Now got 9 digits, so need to check + each time for overflow. */ + digit = *s - '0'; + while (digit >= 0 && digit <= 9 + && (value < max_div_10 + || (value == max_div_10 + && digit <= max_mod_10))) { + value = value * 10 + digit; + if (++s < send) + digit = *s - '0'; + else + break; + } + if (digit >= 0 && digit <= 9 + && (s < send)) { + /* value overflowed. + skip the remaining digits, don't + worry about setting *valuep. */ + do { + s++; + } while (s < send && isDIGIT(*s)); + numtype |= + IS_NUMBER_GREATER_THAN_UV_MAX; + goto skip_value; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + numtype |= IS_NUMBER_IN_UV; + if (valuep) + *valuep = value; + + skip_value: + if (GROK_NUMERIC_RADIX(&s, send)) { + numtype |= IS_NUMBER_NOT_INT; + while (s < send && isDIGIT(*s)) /* optional digits after the radix */ + s++; + } + } + else if (GROK_NUMERIC_RADIX(&s, send)) { + numtype |= IS_NUMBER_NOT_INT | IS_NUMBER_IN_UV; /* valuep assigned below */ + /* no digits before the radix means we need digits after it */ + if (s < send && isDIGIT(*s)) { + do { + s++; + } while (s < send && isDIGIT(*s)); + if (valuep) { + /* integer approximation is valid - it's 0. */ + *valuep = 0; + } + } + else + return 0; + } else if (*s == 'I' || *s == 'i') { + s++; if (s == send || (*s != 'N' && *s != 'n')) return 0; + s++; if (s == send || (*s != 'F' && *s != 'f')) return 0; + s++; if (s < send && (*s == 'I' || *s == 'i')) { + s++; if (s == send || (*s != 'N' && *s != 'n')) return 0; + s++; if (s == send || (*s != 'I' && *s != 'i')) return 0; + s++; if (s == send || (*s != 'T' && *s != 't')) return 0; + s++; if (s == send || (*s != 'Y' && *s != 'y')) return 0; + s++; + } + sawinf = 1; + } else if (*s == 'N' || *s == 'n') { + /* XXX TODO: There are signaling NaNs and quiet NaNs. */ + s++; if (s == send || (*s != 'A' && *s != 'a')) return 0; + s++; if (s == send || (*s != 'N' && *s != 'n')) return 0; + s++; + sawnan = 1; + } else + return 0; + + if (sawinf) { + numtype &= IS_NUMBER_NEG; /* Keep track of sign */ + numtype |= IS_NUMBER_INFINITY | IS_NUMBER_NOT_INT; + } else if (sawnan) { + numtype &= IS_NUMBER_NEG; /* Keep track of sign */ + numtype |= IS_NUMBER_NAN | IS_NUMBER_NOT_INT; + } else if (s < send) { + /* we can have an optional exponent part */ + if (*s == 'e' || *s == 'E') { + /* The only flag we keep is sign. Blow away any "it's UV" */ + numtype &= IS_NUMBER_NEG; + numtype |= IS_NUMBER_NOT_INT; + s++; + if (s < send && (*s == '-' || *s == '+')) + s++; + if (s < send && isDIGIT(*s)) { + do { + s++; + } while (s < send && isDIGIT(*s)); + } + else + return 0; + } + } + while (s < send && isSPACE(*s)) + s++; + if (s >= send) + return numtype; + if (len == 10 && memEQ(pv, "0 but true", 10)) { + if (valuep) + *valuep = 0; + return IS_NUMBER_IN_UV; + } + return 0; +} +#endif +#endif + +/* + * The grok_* routines have been modified to use warn() instead of + * Perl_warner(). Also, 'hexdigit' was the former name of PL_hexdigit, + * which is why the stack variable has been renamed to 'xdigit'. + */ + +#ifndef grok_bin +#if defined(NEED_grok_bin) +static UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); +static +#else +extern UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); +#endif + +#ifdef grok_bin +# undef grok_bin +#endif +#define grok_bin(a,b,c,d) DPPP_(my_grok_bin)(aTHX_ a,b,c,d) +#define Perl_grok_bin DPPP_(my_grok_bin) + +#if defined(NEED_grok_bin) || defined(NEED_grok_bin_GLOBAL) +UV +DPPP_(my_grok_bin)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) +{ + const char *s = start; + STRLEN len = *len_p; + UV value = 0; + NV value_nv = 0; + + const UV max_div_2 = UV_MAX / 2; + bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES; + bool overflowed = FALSE; + + if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) { + /* strip off leading b or 0b. + for compatibility silently suffer "b" and "0b" as valid binary + numbers. */ + if (len >= 1) { + if (s[0] == 'b') { + s++; + len--; + } + else if (len >= 2 && s[0] == '0' && s[1] == 'b') { + s+=2; + len-=2; + } + } + } + + for (; len-- && *s; s++) { + char bit = *s; + if (bit == '0' || bit == '1') { + /* Write it in this wonky order with a goto to attempt to get the + compiler to make the common case integer-only loop pretty tight. + With gcc seems to be much straighter code than old scan_bin. */ + redo: + if (!overflowed) { + if (value <= max_div_2) { + value = (value << 1) | (bit - '0'); + continue; + } + /* Bah. We're just overflowed. */ + warn("Integer overflow in binary number"); + overflowed = TRUE; + value_nv = (NV) value; + } + value_nv *= 2.0; + /* If an NV has not enough bits in its mantissa to + * represent a UV this summing of small low-order numbers + * is a waste of time (because the NV cannot preserve + * the low-order bits anyway): we could just remember when + * did we overflow and in the end just multiply value_nv by the + * right amount. */ + value_nv += (NV)(bit - '0'); + continue; + } + if (bit == '_' && len && allow_underscores && (bit = s[1]) + && (bit == '0' || bit == '1')) + { + --len; + ++s; + goto redo; + } + if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT)) + warn("Illegal binary digit '%c' ignored", *s); + break; + } + + if ( ( overflowed && value_nv > 4294967295.0) +#if UVSIZE > 4 + || (!overflowed && value > 0xffffffff ) +#endif + ) { + warn("Binary number > 0b11111111111111111111111111111111 non-portable"); + } + *len_p = s - start; + if (!overflowed) { + *flags = 0; + return value; + } + *flags = PERL_SCAN_GREATER_THAN_UV_MAX; + if (result) + *result = value_nv; + return UV_MAX; +} +#endif +#endif + +#ifndef grok_hex +#if defined(NEED_grok_hex) +static UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); +static +#else +extern UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); +#endif + +#ifdef grok_hex +# undef grok_hex +#endif +#define grok_hex(a,b,c,d) DPPP_(my_grok_hex)(aTHX_ a,b,c,d) +#define Perl_grok_hex DPPP_(my_grok_hex) + +#if defined(NEED_grok_hex) || defined(NEED_grok_hex_GLOBAL) +UV +DPPP_(my_grok_hex)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) +{ + const char *s = start; + STRLEN len = *len_p; + UV value = 0; + NV value_nv = 0; + + const UV max_div_16 = UV_MAX / 16; + bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES; + bool overflowed = FALSE; + const char *xdigit; + + if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) { + /* strip off leading x or 0x. + for compatibility silently suffer "x" and "0x" as valid hex numbers. + */ + if (len >= 1) { + if (s[0] == 'x') { + s++; + len--; + } + else if (len >= 2 && s[0] == '0' && s[1] == 'x') { + s+=2; + len-=2; + } + } + } + + for (; len-- && *s; s++) { + xdigit = strchr((char *) PL_hexdigit, *s); + if (xdigit) { + /* Write it in this wonky order with a goto to attempt to get the + compiler to make the common case integer-only loop pretty tight. + With gcc seems to be much straighter code than old scan_hex. */ + redo: + if (!overflowed) { + if (value <= max_div_16) { + value = (value << 4) | ((xdigit - PL_hexdigit) & 15); + continue; + } + warn("Integer overflow in hexadecimal number"); + overflowed = TRUE; + value_nv = (NV) value; + } + value_nv *= 16.0; + /* If an NV has not enough bits in its mantissa to + * represent a UV this summing of small low-order numbers + * is a waste of time (because the NV cannot preserve + * the low-order bits anyway): we could just remember when + * did we overflow and in the end just multiply value_nv by the + * right amount of 16-tuples. */ + value_nv += (NV)((xdigit - PL_hexdigit) & 15); + continue; + } + if (*s == '_' && len && allow_underscores && s[1] + && (xdigit = strchr((char *) PL_hexdigit, s[1]))) + { + --len; + ++s; + goto redo; + } + if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT)) + warn("Illegal hexadecimal digit '%c' ignored", *s); + break; + } + + if ( ( overflowed && value_nv > 4294967295.0) +#if UVSIZE > 4 + || (!overflowed && value > 0xffffffff ) +#endif + ) { + warn("Hexadecimal number > 0xffffffff non-portable"); + } + *len_p = s - start; + if (!overflowed) { + *flags = 0; + return value; + } + *flags = PERL_SCAN_GREATER_THAN_UV_MAX; + if (result) + *result = value_nv; + return UV_MAX; +} +#endif +#endif + +#ifndef grok_oct +#if defined(NEED_grok_oct) +static UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); +static +#else +extern UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); +#endif + +#ifdef grok_oct +# undef grok_oct +#endif +#define grok_oct(a,b,c,d) DPPP_(my_grok_oct)(aTHX_ a,b,c,d) +#define Perl_grok_oct DPPP_(my_grok_oct) + +#if defined(NEED_grok_oct) || defined(NEED_grok_oct_GLOBAL) +UV +DPPP_(my_grok_oct)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) +{ + const char *s = start; + STRLEN len = *len_p; + UV value = 0; + NV value_nv = 0; + + const UV max_div_8 = UV_MAX / 8; + bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES; + bool overflowed = FALSE; + + for (; len-- && *s; s++) { + /* gcc 2.95 optimiser not smart enough to figure that this subtraction + out front allows slicker code. */ + int digit = *s - '0'; + if (digit >= 0 && digit <= 7) { + /* Write it in this wonky order with a goto to attempt to get the + compiler to make the common case integer-only loop pretty tight. + */ + redo: + if (!overflowed) { + if (value <= max_div_8) { + value = (value << 3) | digit; + continue; + } + /* Bah. We're just overflowed. */ + warn("Integer overflow in octal number"); + overflowed = TRUE; + value_nv = (NV) value; + } + value_nv *= 8.0; + /* If an NV has not enough bits in its mantissa to + * represent a UV this summing of small low-order numbers + * is a waste of time (because the NV cannot preserve + * the low-order bits anyway): we could just remember when + * did we overflow and in the end just multiply value_nv by the + * right amount of 8-tuples. */ + value_nv += (NV)digit; + continue; + } + if (digit == ('_' - '0') && len && allow_underscores + && (digit = s[1] - '0') && (digit >= 0 && digit <= 7)) + { + --len; + ++s; + goto redo; + } + /* Allow \octal to work the DWIM way (that is, stop scanning + * as soon as non-octal characters are seen, complain only iff + * someone seems to want to use the digits eight and nine). */ + if (digit == 8 || digit == 9) { + if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT)) + warn("Illegal octal digit '%c' ignored", *s); + } + break; + } + + if ( ( overflowed && value_nv > 4294967295.0) +#if UVSIZE > 4 + || (!overflowed && value > 0xffffffff ) +#endif + ) { + warn("Octal number > 037777777777 non-portable"); + } + *len_p = s - start; + if (!overflowed) { + *flags = 0; + return value; + } + *flags = PERL_SCAN_GREATER_THAN_UV_MAX; + if (result) + *result = value_nv; + return UV_MAX; +} +#endif +#endif + +#if !defined(my_snprintf) +#if defined(NEED_my_snprintf) +static int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...); +static +#else +extern int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...); +#endif + +#define my_snprintf DPPP_(my_my_snprintf) +#define Perl_my_snprintf DPPP_(my_my_snprintf) + +#if defined(NEED_my_snprintf) || defined(NEED_my_snprintf_GLOBAL) + +int +DPPP_(my_my_snprintf)(char *buffer, const Size_t len, const char *format, ...) +{ + dTHX; + int retval; + va_list ap; + va_start(ap, format); +#ifdef HAS_VSNPRINTF + retval = vsnprintf(buffer, len, format, ap); +#else + retval = vsprintf(buffer, format, ap); +#endif + va_end(ap); + if (retval < 0 || (len > 0 && (Size_t)retval >= len)) + Perl_croak(aTHX_ "panic: my_snprintf buffer overflow"); + return retval; +} + +#endif +#endif + +#if !defined(my_sprintf) +#if defined(NEED_my_sprintf) +static int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...); +static +#else +extern int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...); +#endif + +#define my_sprintf DPPP_(my_my_sprintf) +#define Perl_my_sprintf DPPP_(my_my_sprintf) + +#if defined(NEED_my_sprintf) || defined(NEED_my_sprintf_GLOBAL) + +int +DPPP_(my_my_sprintf)(char *buffer, const char* pat, ...) +{ + va_list args; + va_start(args, pat); + vsprintf(buffer, pat, args); + va_end(args); + return strlen(buffer); +} + +#endif +#endif + +#ifdef NO_XSLOCKS +# ifdef dJMPENV +# define dXCPT dJMPENV; int rEtV = 0 +# define XCPT_TRY_START JMPENV_PUSH(rEtV); if (rEtV == 0) +# define XCPT_TRY_END JMPENV_POP; +# define XCPT_CATCH if (rEtV != 0) +# define XCPT_RETHROW JMPENV_JUMP(rEtV) +# else +# define dXCPT Sigjmp_buf oldTOP; int rEtV = 0 +# define XCPT_TRY_START Copy(top_env, oldTOP, 1, Sigjmp_buf); rEtV = Sigsetjmp(top_env, 1); if (rEtV == 0) +# define XCPT_TRY_END Copy(oldTOP, top_env, 1, Sigjmp_buf); +# define XCPT_CATCH if (rEtV != 0) +# define XCPT_RETHROW Siglongjmp(top_env, rEtV) +# endif +#endif + +#if !defined(my_strlcat) +#if defined(NEED_my_strlcat) +static Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size); +static +#else +extern Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size); +#endif + +#define my_strlcat DPPP_(my_my_strlcat) +#define Perl_my_strlcat DPPP_(my_my_strlcat) + +#if defined(NEED_my_strlcat) || defined(NEED_my_strlcat_GLOBAL) + +Size_t +DPPP_(my_my_strlcat)(char *dst, const char *src, Size_t size) +{ + Size_t used, length, copy; + + used = strlen(dst); + length = strlen(src); + if (size > 0 && used < size - 1) { + copy = (length >= size - used) ? size - used - 1 : length; + memcpy(dst + used, src, copy); + dst[used + copy] = '\0'; + } + return used + length; +} +#endif +#endif + +#if !defined(my_strlcpy) +#if defined(NEED_my_strlcpy) +static Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size); +static +#else +extern Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size); +#endif + +#define my_strlcpy DPPP_(my_my_strlcpy) +#define Perl_my_strlcpy DPPP_(my_my_strlcpy) + +#if defined(NEED_my_strlcpy) || defined(NEED_my_strlcpy_GLOBAL) + +Size_t +DPPP_(my_my_strlcpy)(char *dst, const char *src, Size_t size) +{ + Size_t length, copy; + + length = strlen(src); + if (size > 0) { + copy = (length >= size) ? size - 1 : length; + memcpy(dst, src, copy); + dst[copy] = '\0'; + } + return length; +} + +#endif +#endif +#ifndef PERL_PV_ESCAPE_QUOTE +# define PERL_PV_ESCAPE_QUOTE 0x0001 +#endif + +#ifndef PERL_PV_PRETTY_QUOTE +# define PERL_PV_PRETTY_QUOTE PERL_PV_ESCAPE_QUOTE +#endif + +#ifndef PERL_PV_PRETTY_ELLIPSES +# define PERL_PV_PRETTY_ELLIPSES 0x0002 +#endif + +#ifndef PERL_PV_PRETTY_LTGT +# define PERL_PV_PRETTY_LTGT 0x0004 +#endif + +#ifndef PERL_PV_ESCAPE_FIRSTCHAR +# define PERL_PV_ESCAPE_FIRSTCHAR 0x0008 +#endif + +#ifndef PERL_PV_ESCAPE_UNI +# define PERL_PV_ESCAPE_UNI 0x0100 +#endif + +#ifndef PERL_PV_ESCAPE_UNI_DETECT +# define PERL_PV_ESCAPE_UNI_DETECT 0x0200 +#endif + +#ifndef PERL_PV_ESCAPE_ALL +# define PERL_PV_ESCAPE_ALL 0x1000 +#endif + +#ifndef PERL_PV_ESCAPE_NOBACKSLASH +# define PERL_PV_ESCAPE_NOBACKSLASH 0x2000 +#endif + +#ifndef PERL_PV_ESCAPE_NOCLEAR +# define PERL_PV_ESCAPE_NOCLEAR 0x4000 +#endif + +#ifndef PERL_PV_ESCAPE_RE +# define PERL_PV_ESCAPE_RE 0x8000 +#endif + +#ifndef PERL_PV_PRETTY_NOCLEAR +# define PERL_PV_PRETTY_NOCLEAR PERL_PV_ESCAPE_NOCLEAR +#endif +#ifndef PERL_PV_PRETTY_DUMP +# define PERL_PV_PRETTY_DUMP PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_QUOTE +#endif + +#ifndef PERL_PV_PRETTY_REGPROP +# define PERL_PV_PRETTY_REGPROP PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_LTGT|PERL_PV_ESCAPE_RE +#endif + +/* Hint: pv_escape + * Note that unicode functionality is only backported to + * those perl versions that support it. For older perl + * versions, the implementation will fall back to bytes. + */ + +#ifndef pv_escape +#if defined(NEED_pv_escape) +static char * DPPP_(my_pv_escape)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags); +static +#else +extern char * DPPP_(my_pv_escape)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags); +#endif + +#ifdef pv_escape +# undef pv_escape +#endif +#define pv_escape(a,b,c,d,e,f) DPPP_(my_pv_escape)(aTHX_ a,b,c,d,e,f) +#define Perl_pv_escape DPPP_(my_pv_escape) + +#if defined(NEED_pv_escape) || defined(NEED_pv_escape_GLOBAL) + +char * +DPPP_(my_pv_escape)(pTHX_ SV *dsv, char const * const str, + const STRLEN count, const STRLEN max, + STRLEN * const escaped, const U32 flags) +{ + const char esc = flags & PERL_PV_ESCAPE_RE ? '%' : '\\'; + const char dq = flags & PERL_PV_ESCAPE_QUOTE ? '"' : esc; + char octbuf[32] = "%123456789ABCDF"; + STRLEN wrote = 0; + STRLEN chsize = 0; + STRLEN readsize = 1; +#if defined(is_utf8_string) && defined(utf8_to_uvchr) + bool isuni = flags & PERL_PV_ESCAPE_UNI ? 1 : 0; +#endif + const char *pv = str; + const char * const end = pv + count; + octbuf[0] = esc; + + if (!(flags & PERL_PV_ESCAPE_NOCLEAR)) + sv_setpvs(dsv, ""); + +#if defined(is_utf8_string) && defined(utf8_to_uvchr) + if ((flags & PERL_PV_ESCAPE_UNI_DETECT) && is_utf8_string((U8*)pv, count)) + isuni = 1; +#endif + + for (; pv < end && (!max || wrote < max) ; pv += readsize) { + const UV u = +#if defined(is_utf8_string) && defined(utf8_to_uvchr) + isuni ? utf8_to_uvchr((U8*)pv, &readsize) : +#endif + (U8)*pv; + const U8 c = (U8)u & 0xFF; + + if (u > 255 || (flags & PERL_PV_ESCAPE_ALL)) { + if (flags & PERL_PV_ESCAPE_FIRSTCHAR) + chsize = my_snprintf(octbuf, sizeof octbuf, + "%" UVxf, u); + else + chsize = my_snprintf(octbuf, sizeof octbuf, + "%cx{%" UVxf "}", esc, u); + } else if (flags & PERL_PV_ESCAPE_NOBACKSLASH) { + chsize = 1; + } else { + if (c == dq || c == esc || !isPRINT(c)) { + chsize = 2; + switch (c) { + case '\\' : /* fallthrough */ + case '%' : if (c == esc) + octbuf[1] = esc; + else + chsize = 1; + break; + case '\v' : octbuf[1] = 'v'; break; + case '\t' : octbuf[1] = 't'; break; + case '\r' : octbuf[1] = 'r'; break; + case '\n' : octbuf[1] = 'n'; break; + case '\f' : octbuf[1] = 'f'; break; + case '"' : if (dq == '"') + octbuf[1] = '"'; + else + chsize = 1; + break; + default: chsize = my_snprintf(octbuf, sizeof octbuf, + pv < end && isDIGIT((U8)*(pv+readsize)) + ? "%c%03o" : "%c%o", esc, c); + } + } else { + chsize = 1; + } + } + if (max && wrote + chsize > max) { + break; + } else if (chsize > 1) { + sv_catpvn(dsv, octbuf, chsize); + wrote += chsize; + } else { + char tmp[2]; + my_snprintf(tmp, sizeof tmp, "%c", c); + sv_catpvn(dsv, tmp, 1); + wrote++; + } + if (flags & PERL_PV_ESCAPE_FIRSTCHAR) + break; + } + if (escaped != NULL) + *escaped= pv - str; + return SvPVX(dsv); +} + +#endif +#endif + +#ifndef pv_pretty +#if defined(NEED_pv_pretty) +static char * DPPP_(my_pv_pretty)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags); +static +#else +extern char * DPPP_(my_pv_pretty)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags); +#endif + +#ifdef pv_pretty +# undef pv_pretty +#endif +#define pv_pretty(a,b,c,d,e,f,g) DPPP_(my_pv_pretty)(aTHX_ a,b,c,d,e,f,g) +#define Perl_pv_pretty DPPP_(my_pv_pretty) + +#if defined(NEED_pv_pretty) || defined(NEED_pv_pretty_GLOBAL) + +char * +DPPP_(my_pv_pretty)(pTHX_ SV *dsv, char const * const str, const STRLEN count, + const STRLEN max, char const * const start_color, char const * const end_color, + const U32 flags) +{ + const U8 dq = (flags & PERL_PV_PRETTY_QUOTE) ? '"' : '%'; + STRLEN escaped; + + if (!(flags & PERL_PV_PRETTY_NOCLEAR)) + sv_setpvs(dsv, ""); + + if (dq == '"') + sv_catpvs(dsv, "\""); + else if (flags & PERL_PV_PRETTY_LTGT) + sv_catpvs(dsv, "<"); + + if (start_color != NULL) + sv_catpv(dsv, D_PPP_CONSTPV_ARG(start_color)); + + pv_escape(dsv, str, count, max, &escaped, flags | PERL_PV_ESCAPE_NOCLEAR); + + if (end_color != NULL) + sv_catpv(dsv, D_PPP_CONSTPV_ARG(end_color)); + + if (dq == '"') + sv_catpvs(dsv, "\""); + else if (flags & PERL_PV_PRETTY_LTGT) + sv_catpvs(dsv, ">"); + + if ((flags & PERL_PV_PRETTY_ELLIPSES) && escaped < count) + sv_catpvs(dsv, "..."); + + return SvPVX(dsv); +} + +#endif +#endif + +#ifndef pv_display +#if defined(NEED_pv_display) +static char * DPPP_(my_pv_display)(pTHX_ SV * dsv, const char * pv, STRLEN cur, STRLEN len, STRLEN pvlim); +static +#else +extern char * DPPP_(my_pv_display)(pTHX_ SV * dsv, const char * pv, STRLEN cur, STRLEN len, STRLEN pvlim); +#endif + +#ifdef pv_display +# undef pv_display +#endif +#define pv_display(a,b,c,d,e) DPPP_(my_pv_display)(aTHX_ a,b,c,d,e) +#define Perl_pv_display DPPP_(my_pv_display) + +#if defined(NEED_pv_display) || defined(NEED_pv_display_GLOBAL) + +char * +DPPP_(my_pv_display)(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim) +{ + pv_pretty(dsv, pv, cur, pvlim, NULL, NULL, PERL_PV_PRETTY_DUMP); + if (len > cur && pv[cur] == '\0') + sv_catpvs(dsv, "\\0"); + return SvPVX(dsv); +} + +#endif +#endif + +#endif /* _P_P_PORTABILITY_H_ */ + +/* End of File ppport.h */ diff --git a/t/Image-OpenALPR.t b/t/Image-OpenALPR.t new file mode 100644 index 0000000..1218eeb --- /dev/null +++ b/t/Image-OpenALPR.t @@ -0,0 +1,15 @@ +#!/usr/bin/perl +use strict; +use warnings; + +use Test::More tests => 5; +BEGIN { use_ok('Image::OpenALPR') }; + +my $alpr = Image::OpenALPR->new('eu'); +$alpr->set_top_n(3); +my @plates = $alpr->recognise('t/ex.jpg'); +is @plates, 1, 'Found only one plate'; +is $plates[0]->plate, 'ZP36709', 'plate number'; +cmp_ok $plates[0]->confidence, '>=', 80, 'high confidence'; +my @cands = $plates[0]->candidates; +is @cands, 3, 'number of candidates matches top_n'; diff --git a/t/ex.jpg b/t/ex.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3a9b6e71cfe871a35638b802608298bf228293fa GIT binary patch literal 76543 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

F-TuP??f0?SckXnghU!`q!y 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

?jkfjt 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