diff options
Diffstat (limited to 'perl')
| -rw-r--r-- | perl/COPYING.LIB | 504 | ||||
| -rw-r--r-- | perl/Changes | 51 | ||||
| -rw-r--r-- | perl/MANIFEST | 26 | ||||
| -rw-r--r-- | perl/MANIFEST.SKIP | 4 | ||||
| -rw-r--r-- | perl/Makefile.PL | 64 | ||||
| -rw-r--r-- | perl/README | 38 | ||||
| -rw-r--r-- | perl/ZBar.pm | 216 | ||||
| -rw-r--r-- | perl/ZBar.xs | 869 | ||||
| -rw-r--r-- | perl/ZBar/Image.pod | 145 | ||||
| -rw-r--r-- | perl/ZBar/ImageScanner.pod | 103 | ||||
| -rw-r--r-- | perl/ZBar/Processor.pod | 157 | ||||
| -rw-r--r-- | perl/ZBar/Symbol.pod | 179 | ||||
| -rwxr-xr-x | perl/examples/paginate.pl | 71 | ||||
| -rwxr-xr-x | perl/examples/processor.pl | 35 | ||||
| -rwxr-xr-x | perl/examples/read_one.pl | 29 | ||||
| -rwxr-xr-x | perl/examples/scan_image.pl | 37 | ||||
| -rw-r--r-- | perl/inc/Devel/CheckLib.pm | 350 | ||||
| -rw-r--r-- | perl/ppport.h | 5097 | ||||
| -rwxr-xr-x | perl/t/Decoder.t | 111 | ||||
| -rwxr-xr-x | perl/t/Image.t | 186 | ||||
| -rwxr-xr-x | perl/t/Processor.t | 140 | ||||
| -rwxr-xr-x | perl/t/Scanner.t | 23 | ||||
| -rwxr-xr-x | perl/t/ZBar.t | 68 | ||||
| -rw-r--r-- | perl/t/barcode.png | bin | 0 -> 1182 bytes | |||
| -rw-r--r-- | perl/t/pod-coverage.t | 12 | ||||
| -rw-r--r-- | perl/t/pod.t | 12 | ||||
| -rw-r--r-- | perl/typemap | 66 |
27 files changed, 8593 insertions, 0 deletions
diff --git a/perl/COPYING.LIB b/perl/COPYING.LIB new file mode 100644 index 0000000..5ab7695 --- /dev/null +++ b/perl/COPYING.LIB @@ -0,0 +1,504 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +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 this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +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 +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser 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 Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "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 +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY 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 +LIBRARY (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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + <one line to give the library's name and a brief idea of what it does.> + Copyright (C) <year> <name of author> + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + <signature of Ty Coon>, 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! + + diff --git a/perl/Changes b/perl/Changes new file mode 100644 index 0000000..6707766 --- /dev/null +++ b/perl/Changes @@ -0,0 +1,51 @@ +Revision history for Perl extension Barcode::ZBar. + +0.10 2022-02-08 Official Release to CPAN + * Barcode::ZBar 0.10 update version + +0.09 2022-02-08 + * bdf1a10 Barcode::ZBar 0.09 update version and Changes + * 08ac997 Barcode::ZBar fix test + +0.08 2022-02-07 + * 0a2fa55 Barcode::ZBar update version for release + * 889cc66 perl skip more tests if DISPLAY not set and set prereqs in Makefile.PL + * c77594e Barcode::ZBar Update Changes and Increment Version + +0.07 2022-02-06 + * d0428ef Barcode::ZBar - Image::Magick not installed skip 3 more tests + * 576355e Fixes rt.cpan.org 122061 - test fails when DISPLAY not set + * e9a0cf2 Update Barcode::ZBar Changes + +0.06 2022-02-06 + * 93564a5 Add provides and min-perl version to meta files + * b01a86f perl module Increment version for cpan release and update changes + +0.05 2022-02-05 - Updates from mchehab/zbar + * 0d1d582 perl some packaging improvements + * 5b3c33d Enforce a coding style + * 2b841d5 Update ZBar's main URL location + * d1397ff Fix typos found by codespell. + * edcf08b Add support for using versions with major.minor.patch + * cd5b63e Update to the very latest version of zbar + +current spadix + * add Symbol orientation and Decoder direction interfaces + +0.04 2009-10-23 spadix + * add result query interfaces to ImageScanner and Processor + +0.03 2009-09-24 spadix + * add support for binary symbol data + * fix symbol leaks + * add symbol quality metric + * add support for QR Code + +0.02 2009-04-16 spadix + * project name change: package becomes Barcode::ZBar + +0.01 2009-02-28 spadix + * add Barcode:: namespace prefix + * add a few new/missing APIs + * add most documentation + * first draft: Processor, Scanner and Decoder basic function diff --git a/perl/MANIFEST b/perl/MANIFEST new file mode 100644 index 0000000..8be0421 --- /dev/null +++ b/perl/MANIFEST @@ -0,0 +1,26 @@ +Changes +COPYING.LIB +examples/paginate.pl +examples/processor.pl +examples/read_one.pl +examples/scan_image.pl +inc/Devel/CheckLib.pm +Makefile.PL +MANIFEST This list of files +ppport.h +README +t/barcode.png +t/Decoder.t +t/Image.t +t/pod-coverage.t +t/pod.t +t/Processor.t +t/Scanner.t +t/ZBar.t +typemap +ZBar.pm +ZBar.xs +ZBar/Image.pod +ZBar/ImageScanner.pod +ZBar/Processor.pod +ZBar/Symbol.pod diff --git a/perl/MANIFEST.SKIP b/perl/MANIFEST.SKIP new file mode 100644 index 0000000..a888bf9 --- /dev/null +++ b/perl/MANIFEST.SKIP @@ -0,0 +1,4 @@ +MANIFEST.bak +MANIFEST.SKIP +MYMETA.* +^Makefile$ diff --git a/perl/Makefile.PL b/perl/Makefile.PL new file mode 100644 index 0000000..3a4ddf0 --- /dev/null +++ b/perl/Makefile.PL @@ -0,0 +1,64 @@ +use 5.006; +use ExtUtils::MakeMaker; + +use lib qw(inc); +use Devel::CheckLib; + +check_lib_or_exit( + lib => 'zbar', + header => 'zbar.h', + LIBS => join(' ', map({ /^LIBS=(.*)/; $1 } grep(/^LIBS=/, @ARGV))), + INC => join(' ', map({ /^INC=(.*)/; $1 } grep(/^INC=/, @ARGV))), +); + +WriteMakefile( + NAME => 'Barcode::ZBar', + VERSION_FROM => "ZBar.pm", + ABSTRACT_FROM => "ZBar.pm", + AUTHOR => 'Jeff Brown <spadix@users.sourceforge.net>', + LICENSE => 'lgpl_2_1', + LIBS => ['-lzbar'], + MIN_PERL_VERSION => '5.006', + META_MERGE => { + "meta-spec" => { + version => '2', + url => 'https://metacpan.org/pod/CPAN::Meta::Spec', + }, + prereqs => { + build => { + requires => { + 'Test::More' => 0, + }, + }, + test => { + recommends => { + 'Image::Magick' => 0, + }, + }, + develop => { + recommends => { + 'Test::Pod::Coverage' => 0, + 'Test::Pod' => 0, + }, + } + }, + resources => { + homepage => 'https://metacpan.org/pod/Barcode::ZBar/', + repository => { + type => 'git', + url => 'https://github.com/mchehab/zbar.git', + web => 'https://github.com/mchehab/zbar', + } + }, + provides => { + 'Barcode::ZBar' => { + file => 'ZBar.pm', + version => '0.10', + }, + 'Barcode::ZBar::Error' => { + file => 'ZBar.pm', + version => '0.10', + }, + } + }, +); diff --git a/perl/README b/perl/README new file mode 100644 index 0000000..85758fd --- /dev/null +++ b/perl/README @@ -0,0 +1,38 @@ +Barcode::ZBar Perl module +========================= + +ZBar Bar Code Reader is an open source software suite for reading bar +codes from various sources, such as video streams, image files and raw +intensity sensors. It supports EAN-13/UPC-A, UPC-E, EAN-8, Code 128, +Code 93, Code 39, Codabar, Interleaved 2 of 5 and QR Code. These are +the Perl bindings for the library. + +Check the ZBar project home page for the latest release, mailing +lists, etc. + https://github.com/mchehab/zbar + + +INSTALLATION + +To install this module type the following: + + perl Makefile.PL + make + make test + make install + + +DEPENDENCIES + +This module requires the ZBar Bar Code Reader, which may be obtained +from: + + https://github.com/mchehab/zbar + + +COPYRIGHT AND LICENCE + +Licensed under the GNU Lesser General Public License, version 2.1. +http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt + +Copyright 2008-2010 (c) Jeff Brown <spadix@users.sourceforge.net> diff --git a/perl/ZBar.pm b/perl/ZBar.pm new file mode 100644 index 0000000..c9c474e --- /dev/null +++ b/perl/ZBar.pm @@ -0,0 +1,216 @@ +#------------------------------------------------------------------------ +# Copyright 2008-2010 (c) Jeff Brown <spadix@users.sourceforge.net> +# +# This file is part of the ZBar Bar Code Reader. +# +# The ZBar Bar Code Reader is free software; you can redistribute it +# and/or modify it under the terms of the GNU Lesser Public License as +# published by the Free Software Foundation; either version 2.1 of +# the License, or (at your option) any later version. +# +# The ZBar Bar Code Reader 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 Lesser Public License for more details. +# +# You should have received a copy of the GNU Lesser Public License +# along with the ZBar Bar Code Reader; if not, write to the Free +# Software Foundation, Inc., 51 Franklin St, Fifth Floor, +# Boston, MA 02110-1301 USA +# +# http://sourceforge.net/projects/zbar +#------------------------------------------------------------------------ +package Barcode::ZBar; + +use 5.006; +use strict; +use warnings; +use Carp; + +require Exporter; +our @ISA = qw(Exporter); +our @EXPORT_OK = qw(SPACE BAR + version increase_verbosity set_verbosity); + +our $VERSION = '0.10'; + +require XSLoader; +XSLoader::load('Barcode::ZBar', $VERSION); + +package Barcode::ZBar::Error; + +use overload '""' => sub { return($_[0]->error_string()) }; + +1; +__END__ + + +=head1 NAME + +Barcode::ZBar - Perl interface to the ZBar Barcode Reader + + +=head1 SYNOPSIS + +setup: + + use Barcode::ZBar; + + my $reader = Barcode::ZBar::Processor->new(); + $reader->init(); + $reader->set_data_handler(\&my_handler); + +scan an image: + + my $image = Barcode::ZBar::Image->new(); + $image->set_format('422P'); + $image->set_size(114, 80); + $image->set_data($raw_bits); + $reader->process_image($image); + +scan from video: + + $reader->set_visible(); + $reader->set_active(); + $reader->user_wait(); + +collect results: + + my @symbols = $image->get_symbols(); + foreach my $sym (@symbols) { + print("decoded: " . $sym->get_type() . ":" . $sym->get_data()); + } + + +=head1 DESCRIPTION + +The ZBar Bar Code Reader is a library for scanning and decoding bar +codes from various sources such as video streams, image files or raw +intensity sensors. It supports EAN-13/UPC-A, UPC-E, EAN-8, Code 128, +Code 93, Code 39, Codabar, Interleaved 2 of 5 and QR Code. + +These are the bindings for interacting directly with the library from +Perl. + + +=head1 REFERENCE + +=head2 Functions + +=over 4 + +=item version() + +Returns the version of the zbar library as "I<major>.I<minor>". + +=item increase_verbosity() + +Increases global library debug by one level. + +=item set_verbosity(I<level>) + +Sets global library debug to the indicated level. Higher numbers give +more verbosity. + +=item parse_config(I<configstr>) + +Parse a decoder configuration setting into a list containing the +symbology constant, config constant, and value to set. See the +documentation for C<zbarcam>/C<zbarimg> for available configuration +options. + +=back + +=head2 Constants + +Width stream "color" constants: + +=over 4 + +=item SPACE + +Light area or space between bars. + +=item BAR + +Dark area or colored bar segment. + +=back + +Decoder configuration constants: + +=over 4 + +=item Config::ENABLE + +=item Config::ADD_CHECK + +=item Config::EMIT_CHECK + +=item Config::ASCII + +=item Config::MIN_LEN + +=item Config::MAX_LEN + +=item Config::POSITION + +=item Config::X_DENSITY + +=item Config::Y_DENSITY + +=back + +Symbology modifier constants: + +=over 4 + +=item Modifier::GS1 + +=item Modifier::AIM + +=back + +Symbol orientation constants: + +=over 4 + +=item Orient::UNKNOWN + +=item Orient::UP + +=item Orient::RIGHT + +=item Orient::DOWN + +=item Orient::LEFT + +=back + + +=head1 SEE ALSO + +Barcode::ZBar::Processor, Barcode::ZBar::ImageScanner, +Barcode::ZBar::Image, Barcode::ZBar::Symbol, +Barcode::ZBar::Scanner, Barcode::ZBar::Decoder + +zbarimg(1), zbarcam(1) + +http://zbar.sf.net + + +=head1 AUTHOR + +Jeff Brown, E<lt>spadix@users.sourceforge.netE<gt> + + +=head1 COPYRIGHT AND LICENSE + +Copyright 2008-2010 (c) Jeff Brown E<lt>spadix@users.sourceforge.netE<gt> + +The ZBar Bar Code Reader is free software; you can redistribute it +and/or modify it under the terms of the GNU Lesser Public License as +published by the Free Software Foundation; either version 2.1 of +the License, or (at your option) any later version. + +=cut diff --git a/perl/ZBar.xs b/perl/ZBar.xs new file mode 100644 index 0000000..0e340f6 --- /dev/null +++ b/perl/ZBar.xs @@ -0,0 +1,869 @@ +//------------------------------------------------------------------------ +// Copyright 2008-2010 (c) Jeff Brown <spadix@users.sourceforge.net> +// +// This file is part of the ZBar Bar Code Reader. +// +// The ZBar Bar Code Reader is free software; you can redistribute it +// and/or modify it under the terms of the GNU Lesser Public License as +// published by the Free Software Foundation; either version 2.1 of +// the License, or (at your option) any later version. +// +// The ZBar Bar Code Reader 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 Lesser Public License for more details. +// +// You should have received a copy of the GNU Lesser Public License +// along with the ZBar Bar Code Reader; if not, write to the Free +// Software Foundation, Inc., 51 Franklin St, Fifth Floor, +// Boston, MA 02110-1301 USA +// +// http://sourceforge.net/projects/zbar +//------------------------------------------------------------------------ +#include "EXTERN.h" +#include "perl.h" +#include "XSUB.h" + +#include "ppport.h" + +#include <zbar.h> + +typedef zbar_symbol_t *Barcode__ZBar__Symbol; +typedef zbar_image_t *Barcode__ZBar__Image; +typedef zbar_processor_t *Barcode__ZBar__Processor; +typedef zbar_video_t *Barcode__ZBar__Video; +typedef zbar_window_t *Barcode__ZBar__Window; +typedef zbar_image_scanner_t *Barcode__ZBar__ImageScanner; +typedef zbar_decoder_t *Barcode__ZBar__Decoder; +typedef zbar_scanner_t *Barcode__ZBar__Scanner; +typedef void *Barcode__ZBar__Error; + +typedef unsigned long fourcc_t; +typedef int timeout_t; +typedef int config_error; + +typedef struct handler_wrapper_s { + SV *instance; + SV *handler; + SV *closure; +} handler_wrapper_t; + + +static AV *LOOKUP_zbar_color_t = NULL; +static AV *LOOKUP_zbar_symbol_type_t = NULL; +static AV *LOOKUP_zbar_error_t = NULL; +static AV *LOOKUP_zbar_config_t = NULL; +static AV *LOOKUP_zbar_modifier_t = NULL; +static AV *LOOKUP_zbar_orientation_t = NULL; + +#define CONSTANT(typ, prefix, sym, name) \ + do { \ + SV *c = newSViv(ZBAR_ ## prefix ## sym); \ + sv_setpv(c, name); \ + SvIOK_on(c); \ + newCONSTSUB(stash, #sym, c); \ + av_store(LOOKUP_zbar_ ## typ ## _t, \ + ZBAR_ ## prefix ## sym, \ + SvREFCNT_inc(c)); \ + } while(0) + +#define LOOKUP_ENUM(typ, val) \ + lookup_enum(LOOKUP_zbar_ ## typ ## _t, val) + +static inline SV *lookup_enum (AV *lookup, int val) +{ + SV **tmp = av_fetch(lookup, val, 0); + return((tmp) ? *tmp : sv_newmortal()); +} + +static inline void check_error (int rc, void *obj) +{ + if(rc < 0) { + sv_setref_pv(get_sv("@", TRUE), "Barcode::ZBar::Error", obj); + croak(NULL); + } +} + +#define PUSH_SYMS(x) \ + do { \ + const zbar_symbol_t *sym = (const zbar_symbol_t*)(x); \ + for(; sym; sym = zbar_symbol_next(sym)) { \ + zbar_symbol_t *s = (zbar_symbol_t*)sym; \ + zbar_symbol_ref(s, 1); \ + XPUSHs(sv_setref_pv(sv_newmortal(), "Barcode::ZBar::Symbol", \ + (void*)sym)); \ + } \ + } while(0); + +#define PUSH_ENUM_MASK(typ, TYP, val) \ + do { \ + unsigned mask = (val); \ + int i; \ + for(i = 0; i < ZBAR_ ## TYP ## _NUM; i++, mask >>= 1) \ + if(mask & 1) \ + XPUSHs(LOOKUP_ENUM(typ, i)); \ + } while(0); + +static void image_cleanup_handler (zbar_image_t *image) +{ + SV *data = zbar_image_get_userdata(image); + if(!data) + /* FIXME this is internal error */ + return; + + /* release reference to cleanup data */ + SvREFCNT_dec(data); +} + +static inline int set_handler (handler_wrapper_t **wrapp, + SV *instance, + SV *handler, + SV *closure) +{ + handler_wrapper_t *wrap = *wrapp; + if(!handler || !SvOK(handler)) { + if(wrap) { + if(wrap->instance) SvREFCNT_dec(wrap->instance); + if(wrap->handler) SvREFCNT_dec(wrap->handler); + if(wrap->closure) SvREFCNT_dec(wrap->closure); + wrap->instance = wrap->handler = wrap->closure = NULL; + } + return(0); + } + + if(!wrap) { + Newxz(wrap, 1, handler_wrapper_t); + wrap->instance = newSVsv(instance); + wrap->closure = newSV(0); + *wrapp = wrap; + } + + if(wrap->handler) + SvSetSV(wrap->handler, handler); + else + wrap->handler = newSVsv(handler); + + if(!closure || !SvOK(closure)) + SvSetSV(wrap->closure, &PL_sv_undef); + else + SvSetSV(wrap->closure, closure); + return(1); +} + +static inline void activate_handler (handler_wrapper_t *wrap, + SV *param) +{ + dSP; + if(!wrap) + /* FIXME this is internal error */ + return; + + ENTER; + SAVETMPS; + + PUSHMARK(SP); + EXTEND(SP, 3); + PUSHs(sv_mortalcopy(wrap->instance)); + if(param) + PUSHs(param); + PUSHs(sv_mortalcopy(wrap->closure)); + PUTBACK; + + call_sv(wrap->handler, G_DISCARD); + + FREETMPS; + LEAVE; +} + +static void processor_handler (zbar_image_t *image, + const void *userdata) +{ + SV *img; + zbar_image_ref(image, 1); + img = sv_setref_pv(newSV(0), "Barcode::ZBar::Image", image); + activate_handler((void*)userdata, img); + SvREFCNT_dec(img); +} + +static void decoder_handler (zbar_decoder_t *decoder) +{ + activate_handler(zbar_decoder_get_userdata(decoder), NULL); +} + + +MODULE = Barcode::ZBar PACKAGE = Barcode::ZBar PREFIX = zbar_ + +PROTOTYPES: ENABLE + +BOOT: + { + HV *stash = gv_stashpv("Barcode::ZBar", TRUE); + + LOOKUP_zbar_color_t = newAV(); + CONSTANT(color, , SPACE, "SPACE"); + CONSTANT(color, , BAR, "BAR"); + } + +SV * +zbar_version() + PREINIT: + unsigned major; + unsigned minor; + CODE: + zbar_version(&major, &minor, NULL); + RETVAL = newSVpvf("%u.%u", major, minor); + OUTPUT: + RETVAL + +void +zbar_increase_verbosity() + +void +zbar_set_verbosity(verbosity) + int verbosity + +SV * +parse_config(config_string) + const char * config_string + PREINIT: + zbar_symbol_type_t sym; + zbar_config_t cfg; + int val; + PPCODE: + if(zbar_parse_config(config_string, &sym, &cfg, &val)) + croak("invalid configuration setting: %s", config_string); + EXTEND(SP, 3); + PUSHs(LOOKUP_ENUM(symbol_type, sym)); + PUSHs(LOOKUP_ENUM(config, cfg)); + mPUSHi(val); + + +MODULE = Barcode::ZBar PACKAGE = Barcode::ZBar::Error PREFIX = zbar_ + +BOOT: + { + HV *stash = gv_stashpv("Barcode::ZBar::Error", TRUE); + + LOOKUP_zbar_error_t = newAV(); + CONSTANT(error, ERR_, NOMEM, "out of memory"); + CONSTANT(error, ERR_, INTERNAL, "internal library error"); + CONSTANT(error, ERR_, UNSUPPORTED, "unsupported request"); + CONSTANT(error, ERR_, INVALID, "invalid request"); + CONSTANT(error, ERR_, SYSTEM, "system error"); + CONSTANT(error, ERR_, LOCKING, "locking error"); + CONSTANT(error, ERR_, BUSY, "all resources busy"); + CONSTANT(error, ERR_, XDISPLAY, "X11 display error"); + CONSTANT(error, ERR_, XPROTO, "X11 protocol error"); + CONSTANT(error, ERR_, CLOSED, "output window is closed"); + CONSTANT(error, ERR_, WINAPI, "windows system error"); + } + +zbar_error_t +get_error_code(err) + Barcode::ZBar::Error err + CODE: + RETVAL = _zbar_get_error_code(err); + OUTPUT: + RETVAL + +const char * +error_string(err) + Barcode::ZBar::Error err + CODE: + RETVAL = _zbar_error_string(err, 1); + OUTPUT: + RETVAL + + +MODULE = Barcode::ZBar PACKAGE = Barcode::ZBar::Config PREFIX = zbar_config_ + +BOOT: + { + HV *stash = gv_stashpv("Barcode::ZBar::Config", TRUE); + + LOOKUP_zbar_config_t = newAV(); + CONSTANT(config, CFG_, ENABLE, "enable"); + CONSTANT(config, CFG_, ADD_CHECK, "add-check"); + CONSTANT(config, CFG_, EMIT_CHECK, "emit-check"); + CONSTANT(config, CFG_, ASCII, "ascii"); + CONSTANT(config, CFG_, MIN_LEN, "min-length"); + CONSTANT(config, CFG_, MAX_LEN, "max-length"); + CONSTANT(config, CFG_, UNCERTAINTY, "uncertainty"); + CONSTANT(config, CFG_, POSITION, "position"); + CONSTANT(config, CFG_, X_DENSITY, "x-density"); + CONSTANT(config, CFG_, Y_DENSITY, "y-density"); + } + +MODULE = Barcode::ZBar PACKAGE = Barcode::ZBar::Modifier PREFIX = zbar_mod_ + +BOOT: + { + HV *stash = gv_stashpv("Barcode::ZBar::Modifier", TRUE); + + LOOKUP_zbar_modifier_t = newAV(); + CONSTANT(modifier, MOD_, GS1, "GS1"); + CONSTANT(modifier, MOD_, AIM, "AIM"); + } + +MODULE = Barcode::ZBar PACKAGE = Barcode::ZBar::Orient PREFIX = zbar_orientation_ + +BOOT: + { + HV *stash = gv_stashpv("Barcode::ZBar::Orient", TRUE); + + LOOKUP_zbar_orientation_t = newAV(); + CONSTANT(orientation, ORIENT_, UNKNOWN, "UNKNOWN"); + CONSTANT(orientation, ORIENT_, UP, "UP"); + CONSTANT(orientation, ORIENT_, RIGHT, "RIGHT"); + CONSTANT(orientation, ORIENT_, DOWN, "DOWN"); + CONSTANT(orientation, ORIENT_, LEFT, "LEFT"); + } + + +MODULE = Barcode::ZBar PACKAGE = Barcode::ZBar::Symbol PREFIX = zbar_symbol_ + +BOOT: + { + HV *stash = gv_stashpv("Barcode::ZBar::Symbol", TRUE); + + LOOKUP_zbar_symbol_type_t = newAV(); + CONSTANT(symbol_type, , NONE, "None"); + CONSTANT(symbol_type, , PARTIAL, "Partial"); + CONSTANT(symbol_type, , EAN8, zbar_get_symbol_name(ZBAR_EAN8)); + CONSTANT(symbol_type, , UPCE, zbar_get_symbol_name(ZBAR_UPCE)); + CONSTANT(symbol_type, , ISBN10, zbar_get_symbol_name(ZBAR_ISBN10)); + CONSTANT(symbol_type, , UPCA, zbar_get_symbol_name(ZBAR_UPCA)); + CONSTANT(symbol_type, , EAN13, zbar_get_symbol_name(ZBAR_EAN13)); + CONSTANT(symbol_type, , ISBN13, zbar_get_symbol_name(ZBAR_ISBN13)); + CONSTANT(symbol_type, , DATABAR, zbar_get_symbol_name(ZBAR_DATABAR)); + CONSTANT(symbol_type, , DATABAR_EXP, + zbar_get_symbol_name(ZBAR_DATABAR_EXP)); + CONSTANT(symbol_type, , I25, zbar_get_symbol_name(ZBAR_I25)); + CONSTANT(symbol_type, , CODABAR, zbar_get_symbol_name(ZBAR_CODABAR)); + CONSTANT(symbol_type, , CODE39, zbar_get_symbol_name(ZBAR_CODE39)); + CONSTANT(symbol_type, , PDF417, zbar_get_symbol_name(ZBAR_PDF417)); + CONSTANT(symbol_type, , QRCODE, zbar_get_symbol_name(ZBAR_QRCODE)); + CONSTANT(symbol_type, , CODE93, zbar_get_symbol_name(ZBAR_CODE93)); + CONSTANT(symbol_type, , CODE128, zbar_get_symbol_name(ZBAR_CODE128)); + } + +void +DESTROY(symbol) + Barcode::ZBar::Symbol symbol + CODE: + zbar_symbol_ref(symbol, -1); + +zbar_symbol_type_t +zbar_symbol_get_type(symbol) + Barcode::ZBar::Symbol symbol + +SV * +zbar_symbol_get_configs(symbol) + Barcode::ZBar::Symbol symbol + PPCODE: + PUSH_ENUM_MASK(config, CFG, zbar_symbol_get_configs(symbol)); + +SV * +zbar_symbol_get_modifiers(symbol) + Barcode::ZBar::Symbol symbol + PPCODE: + PUSH_ENUM_MASK(modifier, MOD, zbar_symbol_get_modifiers(symbol)); + +SV * +zbar_symbol_get_data(symbol) + Barcode::ZBar::Symbol symbol + CODE: + RETVAL = newSVpvn(zbar_symbol_get_data(symbol), + zbar_symbol_get_data_length(symbol)); + OUTPUT: + RETVAL + +int +zbar_symbol_get_count(symbol) + Barcode::ZBar::Symbol symbol + +int +zbar_symbol_get_quality(symbol) + Barcode::ZBar::Symbol symbol + +SV * +zbar_symbol_get_loc(symbol) + Barcode::ZBar::Symbol symbol + PREINIT: + unsigned i, size; + PPCODE: + size = zbar_symbol_get_loc_size(symbol); + EXTEND(SP, size); + for(i = 0; i < size; i++) { + AV *pt = (AV*)sv_2mortal((SV*)newAV()); + PUSHs(newRV((SV*)pt)); + av_push(pt, newSVuv(zbar_symbol_get_loc_x(symbol, i))); + av_push(pt, newSVuv(zbar_symbol_get_loc_y(symbol, i))); + } + +zbar_orientation_t +zbar_symbol_get_orientation(symbol) + Barcode::ZBar::Symbol symbol + +SV * +get_components(symbol) + Barcode::ZBar::Symbol symbol + PPCODE: + PUSH_SYMS(zbar_symbol_first_component(symbol)); + + +MODULE = Barcode::ZBar PACKAGE = Barcode::ZBar::Image PREFIX = zbar_image_ + +Barcode::ZBar::Image +new(package) + char * package + CODE: + RETVAL = zbar_image_create(); + OUTPUT: + RETVAL + +void +DESTROY(image) + Barcode::ZBar::Image image + CODE: + zbar_image_destroy(image); + +Barcode::ZBar::Image +zbar_image_convert(image, format) + Barcode::ZBar::Image image + fourcc_t format + +Barcode::ZBar::Image +zbar_image_convert_resize(image, format, width, height) + Barcode::ZBar::Image image + fourcc_t format + unsigned width + unsigned height + +fourcc_t +zbar_image_get_format(image) + Barcode::ZBar::Image image + +unsigned +zbar_image_get_sequence(image) + Barcode::ZBar::Image image + +void +get_size(image) + Barcode::ZBar::Image image + PPCODE: + EXTEND(SP, 2); + mPUSHu(zbar_image_get_width(image)); + mPUSHu(zbar_image_get_height(image)); + +void +get_crop(image) + Barcode::ZBar::Image image + PREINIT: + unsigned x, y, w, h; + PPCODE: + zbar_image_get_crop(image, &x, &y, &w, &h); + EXTEND(SP, 4); + mPUSHu(x); + mPUSHu(y); + mPUSHu(w); + mPUSHu(h); + +SV * +zbar_image_get_data(image) + Barcode::ZBar::Image image + CODE: + RETVAL = newSVpvn(zbar_image_get_data(image), + zbar_image_get_data_length(image)); + OUTPUT: + RETVAL + +SV * +get_symbols(image) + Barcode::ZBar::Image image + PPCODE: + PUSH_SYMS(zbar_image_first_symbol(image)); + +void +zbar_image_set_format(image, format) + Barcode::ZBar::Image image + fourcc_t format + +void +zbar_image_set_sequence(image, seq_num) + Barcode::ZBar::Image image + unsigned seq_num + +void +zbar_image_set_size(image, width, height) + Barcode::ZBar::Image image + int width + if(width < 0) width = 0; + int height + if(height < 0) height = 0; + +void +zbar_image_set_crop(image, x, y, width, height) + Barcode::ZBar::Image image + int x + if(x < 0) { width += x; x = 0; } + int y + if(y < 0) { height += y; y = 0; } + int width + int height + +void +zbar_image_set_data(image, data) + Barcode::ZBar::Image image + SV * data + PREINIT: + SV *old; + CODE: + if(!data || !SvOK(data)) { + zbar_image_set_data(image, NULL, 0, NULL); + zbar_image_set_userdata(image, NULL); + } + else if(SvPOK(data)) { + /* FIXME is this copy of data or new ref to same data? + * not sure this is correct: + * need to retain a reference to image data, + * but do not really want to copy it...maybe an RV? + */ + SV *copy = newSVsv(data); + STRLEN len; + void *raw = SvPV(copy, len); + zbar_image_set_data(image, raw, len, image_cleanup_handler); + zbar_image_set_userdata(image, copy); + } + else + croak("image data must be binary string"); + + +MODULE = Barcode::ZBar PACKAGE = Barcode::ZBar::Processor PREFIX = zbar_processor_ + +Barcode::ZBar::Processor +new(package, threaded=0) + char * package + bool threaded + CODE: + RETVAL = zbar_processor_create(threaded); + OUTPUT: + RETVAL + +void +DESTROY(processor) + Barcode::ZBar::Processor processor + CODE: + zbar_processor_destroy(processor); + +void +zbar_processor_init(processor, video_device="", enable_display=1) + Barcode::ZBar::Processor processor + const char * video_device + bool enable_display + CODE: + check_error(zbar_processor_init(processor, video_device, enable_display), + processor); + +void +zbar_processor_request_size(processor, width, height) + Barcode::ZBar::Processor processor + unsigned width + unsigned height + CODE: + check_error(zbar_processor_request_size(processor, width, height), + processor); + +void +zbar_processor_force_format(processor, input_format=0, output_format=0) + Barcode::ZBar::Processor processor + fourcc_t input_format + fourcc_t output_format + CODE: + check_error(zbar_processor_force_format(processor, input_format, output_format), + processor); + +void +zbar_processor_set_config(processor, symbology, config, value=1) + Barcode::ZBar::Processor processor + zbar_symbol_type_t symbology + zbar_config_t config + int value + +config_error +zbar_processor_parse_config(processor, config_string) + Barcode::ZBar::Processor processor + const char *config_string + +bool +zbar_processor_is_visible(processor) + Barcode::ZBar::Processor processor + CODE: + check_error((RETVAL = zbar_processor_is_visible(processor)), + processor); + OUTPUT: + RETVAL + +void +zbar_processor_set_visible(processor, visible=1) + Barcode::ZBar::Processor processor + bool visible + CODE: + check_error(zbar_processor_set_visible(processor, visible), + processor); + +void +zbar_processor_set_active(processor, active=1) + Barcode::ZBar::Processor processor + bool active + CODE: + check_error(zbar_processor_set_active(processor, active), + processor); + +SV * +get_results(processor) + Barcode::ZBar::Processor processor + PREINIT: + const zbar_symbol_set_t *syms; + PPCODE: + syms = zbar_processor_get_results(processor); + PUSH_SYMS(zbar_symbol_set_first_symbol(syms)); + zbar_symbol_set_ref(syms, -1); + +int +zbar_processor_user_wait(processor, timeout=-1) + Barcode::ZBar::Processor processor + timeout_t timeout + CODE: + check_error((RETVAL = zbar_processor_user_wait(processor, timeout)), + processor); + OUTPUT: + RETVAL + +int +process_one(processor, timeout=-1) + Barcode::ZBar::Processor processor + timeout_t timeout + CODE: + check_error((RETVAL = zbar_process_one(processor, timeout)), + processor); + OUTPUT: + RETVAL + +int +process_image(processor, image) + Barcode::ZBar::Processor processor + Barcode::ZBar::Image image + CODE: + check_error((RETVAL = zbar_process_image(processor, image)), + processor); + OUTPUT: + RETVAL + +void +zbar_processor_set_data_handler(processor, handler = 0, closure = 0) + Barcode::ZBar::Processor processor + SV * handler + SV * closure + PREINIT: + handler_wrapper_t *wrap; + zbar_image_data_handler_t *callback = NULL; + CODE: + wrap = zbar_processor_get_userdata(processor); + if(set_handler(&wrap, ST(0), handler, closure)) + callback = processor_handler; + zbar_processor_set_data_handler(processor, callback, wrap); + + +MODULE = Barcode::ZBar PACKAGE = Barcode::ZBar::ImageScanner PREFIX = zbar_image_scanner_ + +Barcode::ZBar::ImageScanner +new(package) + char * package + CODE: + RETVAL = zbar_image_scanner_create(); + OUTPUT: + RETVAL + +void +DESTROY(scanner) + Barcode::ZBar::ImageScanner scanner + CODE: + zbar_image_scanner_destroy(scanner); + +void +zbar_image_scanner_set_config(scanner, symbology, config, value=1) + Barcode::ZBar::ImageScanner scanner + zbar_symbol_type_t symbology + zbar_config_t config + int value + +config_error +zbar_image_scanner_parse_config(scanner, config_string) + Barcode::ZBar::ImageScanner scanner + const char *config_string + +void +zbar_image_scanner_enable_cache(scanner, enable) + Barcode::ZBar::ImageScanner scanner + int enable + +void +zbar_image_scanner_recycle_image(scanner, image) + Barcode::ZBar::ImageScanner scanner + Barcode::ZBar::Image image + +SV * +get_results(scanner) + Barcode::ZBar::ImageScanner scanner + PREINIT: + const zbar_symbol_set_t *syms; + PPCODE: + syms = zbar_image_scanner_get_results(scanner); + PUSH_SYMS(zbar_symbol_set_first_symbol(syms)); + +int +scan_image(scanner, image) + Barcode::ZBar::ImageScanner scanner + Barcode::ZBar::Image image + CODE: + RETVAL = zbar_scan_image(scanner, image); + OUTPUT: + RETVAL + + +MODULE = Barcode::ZBar PACKAGE = Barcode::ZBar::Decoder PREFIX = zbar_decoder_ + +Barcode::ZBar::Decoder +new(package) + char * package + CODE: + RETVAL = zbar_decoder_create(); + OUTPUT: + RETVAL + +void +DESTROY(decoder) + Barcode::ZBar::Decoder decoder + CODE: + /* FIXME cleanup handler wrapper */ + zbar_decoder_destroy(decoder); + +void +zbar_decoder_set_config(decoder, symbology, config, value=1) + Barcode::ZBar::Decoder decoder + zbar_symbol_type_t symbology + zbar_config_t config + int value + +config_error +zbar_decoder_parse_config(decoder, config_string) + Barcode::ZBar::Decoder decoder + const char *config_string + +void +zbar_decoder_reset(decoder) + Barcode::ZBar::Decoder decoder + +void +zbar_decoder_new_scan(decoder) + Barcode::ZBar::Decoder decoder + +zbar_symbol_type_t +decode_width(decoder, width) + Barcode::ZBar::Decoder decoder + unsigned width + CODE: + RETVAL = zbar_decode_width(decoder, width); + OUTPUT: + RETVAL + +zbar_color_t +zbar_decoder_get_color(decoder) + Barcode::ZBar::Decoder decoder + +SV * +zbar_decoder_get_data(decoder) + Barcode::ZBar::Decoder decoder + CODE: + RETVAL = newSVpvn(zbar_decoder_get_data(decoder), + zbar_decoder_get_data_length(decoder)); + OUTPUT: + RETVAL + +zbar_symbol_type_t +zbar_decoder_get_type(decoder) + Barcode::ZBar::Decoder decoder + +SV * +zbar_decoder_get_configs(decoder, symbology) + Barcode::ZBar::Decoder decoder + zbar_symbol_type_t symbology + PPCODE: + if(symbology == ZBAR_NONE) + symbology = zbar_decoder_get_type(decoder); + PUSH_ENUM_MASK(config, CFG, zbar_decoder_get_configs(decoder, symbology)); + +SV * +zbar_decoder_get_modifiers(decoder) + Barcode::ZBar::Decoder decoder + PPCODE: + PUSH_ENUM_MASK(modifier, MOD, zbar_decoder_get_modifiers(decoder)); + +int +zbar_decoder_get_direction(decoder) + Barcode::ZBar::Decoder decoder + +void +zbar_decoder_set_handler(decoder, handler = 0, closure = 0) + Barcode::ZBar::Decoder decoder + SV * handler + SV * closure + PREINIT: + handler_wrapper_t *wrap; + CODE: + wrap = zbar_decoder_get_userdata(decoder); + zbar_decoder_set_handler(decoder, NULL); + if(set_handler(&wrap, ST(0), handler, closure)) { + zbar_decoder_set_userdata(decoder, wrap); + zbar_decoder_set_handler(decoder, decoder_handler); + } + + +MODULE = Barcode::ZBar PACKAGE = Barcode::ZBar::Scanner PREFIX = zbar_scanner_ + +Barcode::ZBar::Scanner +new(package, decoder = 0) + char * package + Barcode::ZBar::Decoder decoder + CODE: + RETVAL = zbar_scanner_create(decoder); + OUTPUT: + RETVAL + +void +DESTROY(scanner) + Barcode::ZBar::Scanner scanner + CODE: + zbar_scanner_destroy(scanner); + +zbar_symbol_type_t +zbar_scanner_reset(scanner) + Barcode::ZBar::Scanner scanner + +zbar_symbol_type_t +zbar_scanner_new_scan(scanner) + Barcode::ZBar::Scanner scanner + +zbar_color_t +zbar_scanner_get_color(scanner) + Barcode::ZBar::Scanner scanner + +unsigned +zbar_scanner_get_width(scanner) + Barcode::ZBar::Scanner scanner + +zbar_symbol_type_t +scan_y(scanner, y) + Barcode::ZBar::Scanner scanner + int y + CODE: + RETVAL = zbar_scan_y(scanner, y); + OUTPUT: + RETVAL diff --git a/perl/ZBar/Image.pod b/perl/ZBar/Image.pod new file mode 100644 index 0000000..6848bdd --- /dev/null +++ b/perl/ZBar/Image.pod @@ -0,0 +1,145 @@ +#------------------------------------------------------------------------ +# Copyright 2008-2009 (c) Jeff Brown <spadix@users.sourceforge.net> +# +# This file is part of the ZBar Bar Code Reader. +# +# The ZBar Bar Code Reader is free software; you can redistribute it +# and/or modify it under the terms of the GNU Lesser Public License as +# published by the Free Software Foundation; either version 2.1 of +# the License, or (at your option) any later version. +# +# The ZBar Bar Code Reader 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 Lesser Public License for more details. +# +# You should have received a copy of the GNU Lesser Public License +# along with the ZBar Bar Code Reader; if not, write to the Free +# Software Foundation, Inc., 51 Franklin St, Fifth Floor, +# Boston, MA 02110-1301 USA +# +# http://sourceforge.net/projects/zbar +#------------------------------------------------------------------------ + +=pod + +=head1 NAME + +Barcode::ZBar::Image - image object to scan for bar codes + +=head1 SYNOPSIS + + use Barcode::ZBar; + + my $image = Barcode::ZBar::Image->new(); + $image->set_format('422P'); + $image->set_size(114, 80); + $image->set_data($raw_bits); + + my @symbols = $image->get_symbols(); + +=head1 DESCRIPTION + +Barcode::ZBar::Image is used to pass images to the bar code scanner. +It wraps raw image data with the meta-data required to interpret it +(size, pixel format, etc) + +=head2 Image Formats + +Image data formats are represented by (relatively) standard "Four +Character Codes" (fourcc), represented by four character strings in +Perl. A list of supported formats is available on the project wiki. + +Examples: + +=over 2 + +=item * + +'GREY' - single 8bpp intensity plane + +=item * + +'BGR3' - 24bpp packed RGB component format + +=item * + +'YUYV' - 12bpp packed luminance/chrominance (YCbCr) format + +=back + +=head1 REFERENCE + +=head2 Methods + +=over 4 + +=item new() + +Create a new Barcode::ZBar::Image object. The size, pixel format and +data must be defined before the object may be used. + +=item get_format() + +=item set_format(I<format>) + +Return/specify the fourcc code corresponding to the image pixel format. + +=item get_sequence() + +=item set_sequence(I<seq_num>) + +Return/specify the video frame or page number associated with the image. + +=item get_size() + +=item set_size(I<width>, I<height>) + +Return/specify the (I<width>, I<height>) image size tuple. + +=item get_data() + +=item set_data(I<raw>) + +Return/specify the raw image data as a binary string. + +=item get_symbols() + +Return a list of scanned Barcode::ZBar::Symbol results attached to +this image. + +=item convert_resize(I<format>, I<width>, I<height>) + +=item convert(I<format>) + +Return a new Barcode::ZBar::Image object converted to the indicated +fourcc format. Returns C<undef> if the conversion is not supported. +Conversion complexity ranges from CPU intensive to trivial depending +on the formats involved. Note that only a few conversions retain +color information. convert actually calls convert_resize using the +source width and height. + +=back + +=head1 SEE ALSO + +Barcode::ZBar, Barcode::ZBar::Image, Barcode::ZBar::Symbol + +zbarimg(1), zbarcam(1) + +http://zbar.sf.net + +=head1 AUTHOR + +Jeff Brown, E<lt>spadix@users.sourceforge.netE<gt> + +=head1 COPYRIGHT AND LICENSE + +Copyright 2008-2010 (c) Jeff Brown E<lt>spadix@users.sourceforge.netE<gt> + +The ZBar Bar Code Reader is free software; you can redistribute it +and/or modify it under the terms of the GNU Lesser Public License as +published by the Free Software Foundation; either version 2.1 of +the License, or (at your option) any later version. + +=cut diff --git a/perl/ZBar/ImageScanner.pod b/perl/ZBar/ImageScanner.pod new file mode 100644 index 0000000..dcbc21c --- /dev/null +++ b/perl/ZBar/ImageScanner.pod @@ -0,0 +1,103 @@ +#------------------------------------------------------------------------ +# Copyright 2008-2009 (c) Jeff Brown <spadix@users.sourceforge.net> +# +# This file is part of the ZBar Bar Code Reader. +# +# The ZBar Bar Code Reader is free software; you can redistribute it +# and/or modify it under the terms of the GNU Lesser Public License as +# published by the Free Software Foundation; either version 2.1 of +# the License, or (at your option) any later version. +# +# The ZBar Bar Code Reader 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 Lesser Public License for more details. +# +# You should have received a copy of the GNU Lesser Public License +# along with the ZBar Bar Code Reader; if not, write to the Free +# Software Foundation, Inc., 51 Franklin St, Fifth Floor, +# Boston, MA 02110-1301 USA +# +# http://sourceforge.net/projects/zbar +#------------------------------------------------------------------------ + +=pod + +=head1 NAME + +Barcode::ZBar::ImageScanner - scan images for bar codes + +=head1 SYNOPSIS + + use Barcode::ZBar; + + my $scanner = Barcode::ZBar::ImageScanner->new(); + $scanner->parse_config('i25.disable'); + $scanner->scan_image($image); + +=head1 DESCRIPTION + +A Barcode::ZBar::ImageScanner is used to scan for bar codes in a +Barcode::ZBar::Image. + +=head1 REFERENCE + +=head2 Methods + +=over 4 + +=item new() + +Create a new bar code image scanner instance. + +=item get_results() + +Return a list of Barcode::ZBar::Symbol results from the last scanned +image. + +=item scan_image([I<image>]) + +Scan a Barcode::ZBar::Image for bar codes. The image must be in the +"Y800" format. If necessary, use C<< I<$image>->convert("Y800") >> to +convert from other supported formats to Y800 before scanning. + +=item enable_cache([I<enable>]) + +Enable the inter-image result consistency cache. + +=item set_config(I<symbology>, I<config>, I<value>) + +Set config for indicated symbology (0 for all) to specified value. + +=item parse_config(I<configstr>) + +Apply a decoder configuration setting. See the documentation for +C<zbarcam>/C<zbarimg> for available configuration options. + +=item recycle_image([I<image>]) + +Remove previously decoded results from a Barcode::ZBar::Image and +recycle the associated memory. + +=back + +=head1 SEE ALSO + +Barcode::ZBar, Barcode::ZBar::Image, zbarimg(1), zbarcam(1) + +http://zbar.sf.net + +=head1 AUTHOR + +Jeff Brown, E<lt>spadix@users.sourceforge.netE<gt> + +=head1 COPYRIGHT AND LICENSE + +Copyright 2008-2010 (c) Jeff Brown E<lt>spadix@users.sourceforge.netE<gt> + +The ZBar Bar Code Reader is free software; you can redistribute it +and/or modify it under the terms of the GNU Lesser Public License as +published by the Free Software Foundation; either version 2.1 of +the License, or (at your option) any later version. + +=cut diff --git a/perl/ZBar/Processor.pod b/perl/ZBar/Processor.pod new file mode 100644 index 0000000..96b1982 --- /dev/null +++ b/perl/ZBar/Processor.pod @@ -0,0 +1,157 @@ +#------------------------------------------------------------------------ +# Copyright 2008-2009 (c) Jeff Brown <spadix@users.sourceforge.net> +# +# This file is part of the ZBar Bar Code Reader. +# +# The ZBar Bar Code Reader is free software; you can redistribute it +# and/or modify it under the terms of the GNU Lesser Public License as +# published by the Free Software Foundation; either version 2.1 of +# the License, or (at your option) any later version. +# +# The ZBar Bar Code Reader 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 Lesser Public License for more details. +# +# You should have received a copy of the GNU Lesser Public License +# along with the ZBar Bar Code Reader; if not, write to the Free +# Software Foundation, Inc., 51 Franklin St, Fifth Floor, +# Boston, MA 02110-1301 USA +# +# http://sourceforge.net/projects/zbar +#------------------------------------------------------------------------ + +=pod + +=head1 NAME + +Barcode::ZBar::Processor - self-contained bar code reader + +=head1 SYNOPSIS + +setup: + + use Barcode::ZBar; + + my $reader = Barcode::ZBar::Processor->new(); + $reader->init("/dev/video1", 1); + $reader->parse_config('code39.disable'); + $reader->set_data_handler(\&my_handler); + +scan an image: + + $reader->process_image($image); + +scan from video: + + $reader->set_visible(); + $reader->set_active(); + $reader->user_wait(); + +=head1 DESCRIPTION + +A Barcode::ZBar::Processor may be used to quickly create stand-alone +bar code scanning applications. It has interfaces to scan images or +video and to optionally display a video/image preview to a window. + +This interface is not well suited for integration with an existing +GUI, as the library manages the optional preview window and any user +interaction. Use a Barcode::ZBar::ImageScanner or Investigate the +available widget interfaces for GUI applications. + +=head1 REFERENCE + +=head2 Methods + +=over 4 + +=item new() + +Create a new bar code reader instance. + +=item init([I<video_device>], [I<enable_display>]) + +Open a video input device and/or prepare to display output. + +=item set_data_handler([I<handler>], [I<closure>]) + +Setup a callback to process results whenever new results are available +from the video stream or a static image. The specified callable will +be invoked with the associated Barcode::ZBar::Processor object and +I<closure> as arguments. Closure may be achieved either using +standard Perl closure or by manually passing a scalar via I<closure>. + +=item is_visible() + +=item set_visible([I<visible>]) + +Test/set visibility of the output window. + +=item set_active([I<active>]) + +Enable/disable video streaming and scanning for bar codes. + +=item get_results() + +Return a list of Barcode::ZBar::Symbol results from the last scanned +image or video frame. + +=item user_wait([I<timeout>]) + +Wait for the user to press a key/button or close the window. Bar +codes will continue to be processed if video is active. + +=item process_one([I<timeout>]) + +Enable video and scan until at least one barcode is found. Note that +multiple results may still be returned. + +=item process_image([I<image>]) + +Scan a Barcode::ZBar::Image for bar codes. + +=item parse_config(I<configstr>) + +Apply a decoder configuration setting. See the documentation for +C<zbarcam>/C<zbarimg> for available configuration options. + +=item request_size(I<width>, I<height>) + +Request a preferred size for the video image from the device. The +request may be adjusted or completely ignored by the driver. Must be +called before C<init()> + +=item force_format(I<input>, I<output>) + +force specific input and output formats for debug/testing. + +=item set_config(I<symbology>, I<config>, I<value>) + +Set config for indicated symbology (0 for all) to specified value. +@returns 0 for success, non-0 for failure (config does not apply to +specified symbology, or value out of range) + +=back + +=head1 SEE ALSO + +Barcode::ZBar, Barcode::ZBar::Image, Barcode::ZBar::ImageScanner + +zbarimg(1), zbarcam(1) + +http://zbar.sf.net + +=head1 AUTHOR + +Jeff Brown, E<lt>spadix@users.sourceforge.netE<gt> + +=head1 COPYRIGHT AND LICENSE + +Copyright 2008-2010 (c) Jeff Brown E<lt>spadix@users.sourceforge.netE<gt> + +The ZBar Bar Code Reader is free software; you can redistribute it +and/or modify it under the terms of the GNU Lesser Public License as +published by the Free Software Foundation; either version 2.1 of +the License, or (at your option) any later version. + +=cut diff --git a/perl/ZBar/Symbol.pod b/perl/ZBar/Symbol.pod new file mode 100644 index 0000000..6a21b1e --- /dev/null +++ b/perl/ZBar/Symbol.pod @@ -0,0 +1,179 @@ +#------------------------------------------------------------------------ +# Copyright 2008-2010 (c) Jeff Brown <spadix@users.sourceforge.net> +# +# This file is part of the ZBar Bar Code Reader. +# +# The ZBar Bar Code Reader is free software; you can redistribute it +# and/or modify it under the terms of the GNU Lesser Public License as +# published by the Free Software Foundation; either version 2.1 of +# the License, or (at your option) any later version. +# +# The ZBar Bar Code Reader 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 Lesser Public License for more details. +# +# You should have received a copy of the GNU Lesser Public License +# along with the ZBar Bar Code Reader; if not, write to the Free +# Software Foundation, Inc., 51 Franklin St, Fifth Floor, +# Boston, MA 02110-1301 USA +# +# http://sourceforge.net/projects/zbar +#------------------------------------------------------------------------ + +=pod + +=head1 NAME + +Barcode::ZBar::Symbol - bar code scan result object + +=head1 SYNOPSIS + + my @symbols = $image->get_symbols(); + foreach my $sym (@symbols) { + print("decoded: " . $sym->get_type() . + ":" . $sym->get_data(). + "(" . $sym->get_count() . ")"); + } + +=head1 DESCRIPTION + +Barcode::ZBar::Symbol objects are constant results returned for each +bar code scanned from images or video. This object wraps the raw +symbol data with additional information about the decode (symbology, +confidence, location, etc) + +=head1 REFERENCE + +=head2 Methods + +=over 4 + +=item get_type() + +The type of bar code "symbology" from which the data was decoded. + +=item get_data() + +The decoded data string. Note that some symbologies can encode binary +data. + +=item get_quality() + +Confidence metric. An unscaled integer value that indicates something +(intentionally unspecified) about the reliability of this result +relative to another. Larger values are better than smaller values, +where "large" and "small" are application dependent. Expect this +definition to become more specific as the metric is enhanced. + +=item get_count() + +Current cache count of the symbol. This integer value provides +inter-scan reliability and redundancy information if enabled at the +Barcode::ZBar::ImageScanner. + +=item get_orientation() + +General orientation of decoded symbol. This returns one of the +Barcode::ZBar::Orient constants, which provide a coarse, axis-aligned +indication of symbol orientation. + +=item get_components() + +Components of a composite result. This yields an array of physical +component symbols that were combined to form a composite result. + +=item get_configs() + +Retrieve symbology boolean config settings. Returns a bitmask +indicating which configs were set for the detected +symbology during decoding. + +=item get_modifiers() + +Retrieve symbology modifier flag settings. Returns a bitmask +indicating which characteristics were detected during decoding. + +=item get_loc() + +Retrieve an array of symbol location points (x,y) + +=over 2 + +=item * + +A negative value indicates that this result is still uncertain + +=item * + +A zero value indicates the first occurrence of this result with high +confidence + +=item * + +A positive value indicates a duplicate scan + +=back + +=back + +=head2 Constants + +Bar code type "symbology" constants: + +=over 4 + +=item NONE + +=item PARTIAL + +=item EAN13 + +=item EAN8 + +=item UPCA + +=item UPCE + +=item ISBN10 + +=item ISBN13 + +=item I25 + +=item CODABAR + +=item CODE39 + +=item CODE93 + +=item CODE128 + +=item QRCODE + +=item PDF417 + +=back + +=head1 SEE ALSO + +Barcode::ZBar, Barcode::ZBar::Image + +zbarimg(1), zbarcam(1) + +http://zbar.sf.net + +=head1 AUTHOR + +Jeff Brown, E<lt>spadix@users.sourceforge.netE<gt> + +=head1 COPYRIGHT AND LICENSE + +Copyright 2008-2010 (c) Jeff Brown E<lt>spadix@users.sourceforge.netE<gt> + +The ZBar Bar Code Reader is free software; you can redistribute it +and/or modify it under the terms of the GNU Lesser Public License as +published by the Free Software Foundation; either version 2.1 of +the License, or (at your option) any later version. + +=cut diff --git a/perl/examples/paginate.pl b/perl/examples/paginate.pl new file mode 100755 index 0000000..68ffe50 --- /dev/null +++ b/perl/examples/paginate.pl @@ -0,0 +1,71 @@ +#!/usr/bin/perl +#------------------------------------------------------------------------ +# Copyright 2009 (c) Jeff Brown <spadix@users.sourceforge.net> +# +# This file is part of the ZBar Bar Code Reader. +# +# The ZBar Bar Code Reader is free software; you can redistribute it +# and/or modify it under the terms of the GNU Lesser Public License as +# published by the Free Software Foundation; either version 2.1 of +# the License, or (at your option) any later version. +# +# The ZBar Bar Code Reader 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 Lesser Public License for more details. +# +# You should have received a copy of the GNU Lesser Public License +# along with the ZBar Bar Code Reader; if not, write to the Free +# Software Foundation, Inc., 51 Franklin St, Fifth Floor, +# Boston, MA 02110-1301 USA +# +# http://sourceforge.net/projects/zbar +#------------------------------------------------------------------------ +use warnings; +use strict; + +use Barcode::ZBar; +use Image::Magick; + +warn("no input files specified?\n") if(!@ARGV); + +# running output document +my $out = undef; + +# barcode scanner +my $scanner = Barcode::ZBar::ImageScanner->new(); + +foreach my $file (@ARGV) { + print "scanning from \"$file\"\n"; + my $imseq = Image::Magick->new(); + my $err = $imseq->Read($file); + warn($err) if($err); + + foreach my $page (@$imseq) { + # convert ImageMagick page to ZBar image + my $zimg = Barcode::ZBar::Image->new(); + $zimg->set_format('Y800'); + $zimg->set_size($page->Get(qw(columns rows))); + $zimg->set_data($page->Clone()->ImageToBlob(magick => 'GRAY', depth => 8)); + + # scan for barcodes + if($scanner->scan_image($zimg)) { + # write out previous document + $out->write() if($out); + + # use first symbol found to name next image (FIXME sanitize) + my $data = ($zimg->get_symbols())[0]->get_data(); + my $idx = $page->Get('scene') + 1; + print "splitting $data from page $idx\n"; + + # create new output document + $out = Image::Magick->new(filename => $data); + } + + # append this page to current output + push(@$out, $page) if($out); + } + + # write out final document + $out->write() if($out); +} diff --git a/perl/examples/processor.pl b/perl/examples/processor.pl new file mode 100755 index 0000000..d2d1e91 --- /dev/null +++ b/perl/examples/processor.pl @@ -0,0 +1,35 @@ +#!/usr/bin/env perl +use warnings; +use strict; +require Barcode::ZBar; + +# create a Processor +my $proc = Barcode::ZBar::Processor->new(); + +# configure the Processor +$proc->parse_config("enable"); + +# initialize the Processor +$proc->init($ARGV[0] || '/dev/video0'); + +# setup a callback +sub my_handler { + my ($proc, $image, $closure) = @_; + + # extract results + foreach my $symbol ($proc->get_results()) { + # do something useful with results + print('decoded ' . $symbol->get_type() . + ' symbol "' . $symbol->get_data() . "\"\n"); + } +} +$proc->set_data_handler(\&my_handler); + +# enable the preview window +$proc->set_visible(); + +# initiate scanning +$proc->set_active(); + +# keep scanning until user provides key/mouse input +$proc->user_wait(); diff --git a/perl/examples/read_one.pl b/perl/examples/read_one.pl new file mode 100755 index 0000000..d64860c --- /dev/null +++ b/perl/examples/read_one.pl @@ -0,0 +1,29 @@ +#!/usr/bin/env perl +use warnings; +use strict; +require Barcode::ZBar; + +# create a Processor +my $proc = Barcode::ZBar::Processor->new(); + +# configure the Processor +$proc->parse_config("enable"); + +# initialize the Processor +$proc->init($ARGV[0] || '/dev/video0'); + +# enable the preview window +$proc->set_visible(); + +# read at least one barcode (or until window closed) +$proc->process_one(); + +# hide the preview window +$proc->set_visible(0); + +# extract results +foreach my $symbol ($proc->get_results()) { + # do something useful with results + print('decoded ' . $symbol->get_type() . + ' symbol "' . $symbol->get_data() . "\"\n"); +} diff --git a/perl/examples/scan_image.pl b/perl/examples/scan_image.pl new file mode 100755 index 0000000..39d460e --- /dev/null +++ b/perl/examples/scan_image.pl @@ -0,0 +1,37 @@ +#!/usr/bin/perl +use warnings; +use strict; +require Image::Magick; +require Barcode::ZBar; + +$ARGV[0] || die; + +# create a reader +my $scanner = Barcode::ZBar::ImageScanner->new(); + +# configure the reader +$scanner->parse_config("enable"); + +# obtain image data +my $magick = Image::Magick->new(); +$magick->Read($ARGV[0]) && die; +my $raw = $magick->ImageToBlob(magick => 'GRAY', depth => 8); + +# wrap image data +my $image = Barcode::ZBar::Image->new(); +$image->set_format('Y800'); +$image->set_size($magick->Get(qw(columns rows))); +$image->set_data($raw); + +# scan the image for barcodes +my $n = $scanner->scan_image($image); + +# extract results +foreach my $symbol ($image->get_symbols()) { + # do something useful with results + print('decoded ' . $symbol->get_type() . + ' symbol "' . $symbol->get_data() . "\"\n"); +} + +# clean up +undef($image); diff --git a/perl/inc/Devel/CheckLib.pm b/perl/inc/Devel/CheckLib.pm new file mode 100644 index 0000000..be40780 --- /dev/null +++ b/perl/inc/Devel/CheckLib.pm @@ -0,0 +1,350 @@ +# $Id: CheckLib.pm,v 1.22 2008/03/12 19:52:50 drhyde Exp $ + +package Devel::CheckLib; + +use strict; +use vars qw($VERSION @ISA @EXPORT); +$VERSION = '0.5'; +use Config; + +use File::Spec; +use File::Temp; + +require Exporter; +@ISA = qw(Exporter); +@EXPORT = qw(assert_lib check_lib_or_exit); + +# localising prevents the warningness leaking out of this module +local $^W = 1; # use warnings is a 5.6-ism + +_findcc(); # bomb out early if there's no compiler + +=head1 NAME + +Devel::CheckLib - check that a library is available + +=head1 DESCRIPTION + +Devel::CheckLib is a perl module that checks whether a particular C +library and its headers are available. + +=head1 SYNOPSIS + + # in a Makefile.PL or Build.PL + use lib qw(inc); + use Devel::CheckLib; + + check_lib_or_exit( lib => 'jpeg', header => 'jpeglib.h' ); + check_lib_or_exit( lib => [ 'iconv', 'jpeg' ] ); + + # or prompt for path to library and then do this: + check_lib_or_exit( lib => 'jpeg', libpath => $additional_path ); + +=head1 HOW IT WORKS + +You pass named parameters to a function, describing to it how to build +and link to the libraries. + +It works by trying to compile this: + + int main(void) { return 0; } + +and linking it to the specified libraries. If something pops out the end +which looks executable, then we know that it worked. That tiny program is +built once for each library that you specify, and (without linking) once +for each header file. + +=head1 FUNCTIONS + +All of these take the same named parameters and are exported by default. +To avoid exporting them, C<use Devel::CheckLib ()>. + +=head2 assert_lib + +This takes several named parameters, all of which are optional, and dies +with an error message if any of the libraries listed can +not be found. B<Note>: dying in a Makefile.PL or Build.PL may provoke +a 'FAIL' report from CPAN Testers' automated smoke testers. Use +C<check_lib_or_exit> instead. + +The named parameters are: + +=over + +=item lib + +Must be either a string with the name of a single +library or a reference to an array of strings of library names. Depending +on the compiler found, library names will be fed to the compiler either as +C<-l> arguments or as C<.lib> file names. (E.g. C<-ljpeg> or C<jpeg.lib>) + +=item libpath + +a string or an array of strings +representing additional paths to search for libraries. + +=item LIBS + +a C<ExtUtils::MakeMaker>-style space-seperated list of +libraries (each preceded by '-l') and directories (preceded by '-L'). + +=back + +And libraries are no use without header files, so ... + +=over + +=item header + +Must be either a string with the name of a single +header file or a reference to an array of strings of header file names. + +=item incpath + +a string or an array of strings +representing additional paths to search for headers. + +=item INC + +a C<ExtUtils::MakeMaker>-style space-seperated list of +incpaths, each preceded by '-I'. + +=back + +=head2 check_lib_or_exit + +This behaves exactly the same as C<assert_lib()> except that instead of +dying, it warns (with exactly the same error message) and exits. +This is intended for use in Makefile.PL / Build.PL +when you might want to prompt the user for various paths and +things before checking that what they've told you is sane. + +If any library or header is missing, it exits with an exit value of 0 to avoid +causing a CPAN Testers 'FAIL' report. CPAN Testers should ignore this +result -- which is what you want if an external library dependency is not +available. + +=cut + +sub check_lib_or_exit { + eval 'assert_lib(@_)'; + if($@) { + warn $@; + exit; + } +} + +sub assert_lib { + my %args = @_; + my (@libs, @libpaths, @headers, @incpaths); + + # FIXME: these four just SCREAM "refactor" at me + @libs = (ref($args{lib}) ? @{$args{lib}} : $args{lib}) + if $args{lib}; + @libpaths = (ref($args{libpath}) ? @{$args{libpath}} : $args{libpath}) + if $args{libpath}; + @headers = (ref($args{header}) ? @{$args{header}} : $args{header}) + if $args{header}; + @incpaths = (ref($args{incpath}) ? @{$args{incpath}} : $args{incpath}) + if $args{incpath}; + + # work-a-like for Makefile.PL's LIBS and INC arguments + if(defined($args{LIBS})) { + foreach my $arg (split(/\s+/, $args{LIBS})) { + die("LIBS argument badly-formed: $arg\n") unless($arg =~ /^-l/i); + push @{$arg =~ /^-l/ ? \@libs : \@libpaths}, substr($arg, 2); + } + } + if(defined($args{INC})) { + foreach my $arg (split(/\s+/, $args{INC})) { + die("INC argument badly-formed: $arg\n") unless($arg =~ /^-I/); + push @incpaths, substr($arg, 2); + } + } + + my @cc = _findcc(); + my @missing; + + # first figure out which headers we can't find ... + for my $header (@headers) { + my($ch, $cfile) = File::Temp::tempfile( + 'assertlibXXXXXXXX', SUFFIX => '.c' + ); + print $ch qq{#include <$header>\nint main(void) { return 0; }\n}; + close($ch); + my $exefile = File::Temp::mktemp( 'assertlibXXXXXXXX' ) . $Config{_exe}; + my @sys_cmd; + # FIXME: re-factor - almost identical code later when linking + if ( $Config{cc} eq 'cl' ) { # Microsoft compiler + require Win32; + @sys_cmd = (@cc, $cfile, "/Fe$exefile", (map { '/I'.Win32::GetShortPathName($_) } @incpaths)); + } elsif($Config{cc} =~ /bcc32(\.exe)?/) { # Borland + @sys_cmd = (@cc, (map { "-I$_" } @incpaths), "-o$exefile", $cfile); + } else { # Unix-ish + # gcc, Sun, AIX (gcc, cc) + @sys_cmd = (@cc, $cfile, (map { "-I$_" } @incpaths), "-o", "$exefile"); + } + warn "# @sys_cmd\n" if $args{debug}; + my $rv = $args{debug} ? system(@sys_cmd) : _quiet_system(@sys_cmd); + push @missing, $header if $rv != 0 || ! -x $exefile; + _cleanup_exe($exefile); + unlink $cfile; + } + + # now do each library in turn with no headers + my($ch, $cfile) = File::Temp::tempfile( + 'assertlibXXXXXXXX', SUFFIX => '.c' + ); + print $ch "int main(void) { return 0; }\n"; + close($ch); + for my $lib ( @libs ) { + my $exefile = File::Temp::mktemp( 'assertlibXXXXXXXX' ) . $Config{_exe}; + my @sys_cmd; + if ( $Config{cc} eq 'cl' ) { # Microsoft compiler + require Win32; + my @libpath = map { + q{/libpath:} . Win32::GetShortPathName($_) + } @libpaths; + @sys_cmd = (@cc, $cfile, "${lib}.lib", "/Fe$exefile", + "/link", @libpath + ); + } elsif($Config{cc} eq 'CC/DECC') { # VMS + } elsif($Config{cc} =~ /bcc32(\.exe)?/) { # Borland + my @libpath = map { "-L$_" } @libpaths; + @sys_cmd = (@cc, "-o$exefile", "-l$lib", @libpath, $cfile); + } else { # Unix-ish + # gcc, Sun, AIX (gcc, cc) + my @libpath = map { "-L$_" } @libpaths; + @sys_cmd = (@cc, $cfile, "-o", "$exefile", "-l$lib", @libpath); + } + warn "# @sys_cmd\n" if $args{debug}; + my $rv = $args{debug} ? system(@sys_cmd) : _quiet_system(@sys_cmd); + push @missing, $lib if $rv != 0 || ! -x $exefile; + _cleanup_exe($exefile); + } + unlink $cfile; + + my $miss_string = join( q{, }, map { qq{'$_'} } @missing ); + die("Can't link/include $miss_string\n") if @missing; +} + +sub _cleanup_exe { + my ($exefile) = @_; + my $ofile = $exefile; + $ofile =~ s/$Config{_exe}$/$Config{_o}/; + unlink $exefile if -f $exefile; + unlink $ofile if -f $ofile; + unlink "$exefile\.manifest" if -f "$exefile\.manifest"; + return +} + +sub _findcc { + my @paths = split(/$Config{path_sep}/, $ENV{PATH}); + my @cc = split(/\s+/, $Config{cc}); + return @cc if -x $cc[0]; + foreach my $path (@paths) { + my $compiler = File::Spec->catfile($path, $cc[0]) . $Config{_exe}; + return ($compiler, @cc[1 .. $#cc]) if -x $compiler; + } + die("Couldn't find your C compiler\n"); +} + +# code substantially borrowed from IPC::Run3 +sub _quiet_system { + my (@cmd) = @_; + + # save handles + local *STDOUT_SAVE; + local *STDERR_SAVE; + open STDOUT_SAVE, ">&STDOUT" or die "CheckLib: $! saving STDOUT"; + open STDERR_SAVE, ">&STDERR" or die "CheckLib: $! saving STDERR"; + + # redirect to nowhere + local *DEV_NULL; + open DEV_NULL, ">" . File::Spec->devnull + or die "CheckLib: $! opening handle to null device"; + open STDOUT, ">&" . fileno DEV_NULL + or die "CheckLib: $! redirecting STDOUT to null handle"; + open STDERR, ">&" . fileno DEV_NULL + or die "CheckLib: $! redirecting STDERR to null handle"; + + # run system command + my $rv = system(@cmd); + + # restore handles + open STDOUT, ">&" . fileno STDOUT_SAVE + or die "CheckLib: $! restoring STDOUT handle"; + open STDERR, ">&" . fileno STDERR_SAVE + or die "CheckLib: $! restoring STDERR handle"; + + return $rv; +} + +=head1 PLATFORMS SUPPORTED + +You must have a C compiler installed. We check for C<$Config{cc}>, +both literally as it is in Config.pm and also in the $PATH. + +It has been tested with varying degrees on rigourousness on: + +=over + +=item gcc (on Linux, *BSD, Mac OS X, Solaris, Cygwin) + +=item Sun's compiler tools on Solaris + +=item IBM's tools on AIX + +=item Microsoft's tools on Windows + +=item MinGW on Windows (with Strawberry Perl) + +=item Borland's tools on Windows + +=back + +=head1 WARNINGS, BUGS and FEEDBACK + +This is a very early release intended primarily for feedback from +people who have discussed it. The interface may change and it has +not been adequately tested. + +Feedback is most welcome, including constructive criticism. +Bug reports should be made using L<http://rt.cpan.org/> or by email. + +When submitting a bug report, please include the output from running: + + perl -V + perl -MDevel::CheckLib -e0 + +=head1 SEE ALSO + +L<Devel::CheckOS> + +L<Probe::Perl> + +=head1 AUTHORS + +David Cantrell E<lt>david@cantrell.org.ukE<gt> + +David Golden E<lt>dagolden@cpan.orgE<gt> + +Thanks to the cpan-testers-discuss mailing list for prompting us to write it +in the first place; + +to Chris Williams for help with Borland support. + +=head1 COPYRIGHT and LICENCE + +Copyright 2007 David Cantrell. Portions copyright 2007 David Golden. + +This module is free-as-in-speech software, and may be used, distributed, +and modified under the same conditions as perl itself. + +=head1 CONSPIRACY + +This module is also free-as-in-mason software. + +=cut + +1; diff --git a/perl/ppport.h b/perl/ppport.h new file mode 100644 index 0000000..63a8cb1 --- /dev/null +++ b/perl/ppport.h @@ -0,0 +1,5097 @@ +#if 0 +<<'SKIP'; +#endif +/* +---------------------------------------------------------------------- + + ppport.h -- Perl/Pollution/Portability Version 3.06_01 + + Automatically created by Devel::PPPort running under + perl 5.008008 on Fri Nov 14 08:58:38 2008. + + 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.06_01 + +=head1 SYNOPSIS + + perl ppport.h [options] [source files] + + Searches current directory for files if no [source files] are given + + --help show short help + + --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 + + --list-provided list provided API + --list-unsupported list unsupported API + --api-info=name show Perl API portability information + +=head1 COMPATIBILITY + +This version of F<ppport.h> is designed to support operation with Perl +installations back to 5.003, and has been tested up to 5.9.3. + +=head1 OPTIONS + +=head2 --help + +Display a brief usage summary. + +=head2 --patch=I<file> + +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<suffix> + +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. + +If neither C<--patch> or C<--copy> are given, the default is to +simply print the diffs for each file. This requires either +C<Text::Diff> or a C<diff> program to be installed. + +=head2 --diff=I<program> + +Manually set the diff program and options to use. The default +is to use C<Text::Diff>, when installed, and output unified +context diffs. + +=head2 --compat-version=I<version> + +Tell F<ppport.h> 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<ppport.h> if you intend to be backward compatible only +up to a certain Perl version. + +=head2 --cplusplus + +Usually, F<ppport.h> will detect C++ style comments and +replace them with C style comments for portability reasons. +Using this option instructs F<ppport.h> 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. + +=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 --list-provided + +Lists the API elements for which compatibility is provided by +F<ppport.h>. Also lists if it must be explicitly requested, +if it has dependencies, and if there are hints for it. + +=head2 --list-unsupported + +Lists the API elements that are known not to be supported by +F<ppport.h> and below which version of Perl they probably +won't be available or work. + +=head2 --api-info=I<name> + +Show portability information for API elements matching I<name>. +If I<name> 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<PL_> prefix is deprecated. Also, +some API functions used to have a C<perl_> prefix. Using this form is +also deprecated. You can safely use the supported API, as F<ppport.h> +will provide wrappers for older Perl versions. + +=item * + +If you use one of a few functions 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<ppport.h>. + +These functions will be marked C<explicit> in the list shown by +C<--list-provided>. + +Depending on whether you module has a single or multiple files that +use such functions, you want either C<static> or global variants. + +For a C<static> function, use: + + #define NEED_function + +For a global function, use: + + #define NEED_function_GLOBAL + +Note that you mustn't have more than one global request for one +function in your project. + + Function Static Request Global Request + ----------------------------------------------------------------------------------------- + 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 + newCONSTSUB() NEED_newCONSTSUB NEED_newCONSTSUB_GLOBAL + newRV_noinc() NEED_newRV_noinc NEED_newRV_noinc_GLOBAL + sv_2pv_nolen() NEED_sv_2pv_nolen NEED_sv_2pv_nolen_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_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 + vnewSVpvf() NEED_vnewSVpvf NEED_vnewSVpvf_GLOBAL + +To avoid namespace conflicts, you can change the namespace of the +explicitly exported functions using the C<DPPP_NAMESPACE> macro. +Just C<#define> the macro before including C<ppport.h>: + + #define DPPP_NAMESPACE MyOwnNamespace_ + #include "ppport.h" + +The default namespace is C<DPPP_>. + +=back + +The good thing is that most of the above can be checked by running +F<ppport.h> on your source code. See the next section for +details. + +=head1 EXAMPLES + +To verify whether F<ppport.h> is needed for your module, whether you +should make any changes to your code, and whether any special defines +should be used, F<ppport.h> 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<diff> 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. + +To display portability information for the C<newSVpvn> 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<ppport.h> is causing failure during +the compilation of this module, please check if newer versions +of either this module or C<Devel::PPPort> are available on CPAN +before sending a bug report. + +If F<ppport.h> was generated using the latest version of +C<Devel::PPPort> and is causing failure of this module, please +file a bug report using the CPAN Request Tracker at L<http://rt.cpan.org/>. + +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<Devel::PPPort> +module from CPAN. + +=head1 COPYRIGHT + +Version 3.x, Copyright (c) 2004-2005, 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<Devel::PPPort>. + +=cut + +use strict; + +my %opt = ( + quiet => 0, + diag => 1, + hints => 1, + changes => 1, + cplusplus => 0, + filter => 1, +); + +my($ppport) = $0 =~ /([\w.]+)$/; +my $LF = '(?:\r\n|[\r\n])'; # line feed +my $HS = "[ \t]"; # horizontal whitespace + +eval { + require Getopt::Long; + Getopt::Long::GetOptions(\%opt, qw( + help quiet diag! filter! hints! changes! cplusplus + 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"; +} + +usage() if $opt{help}; + +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; +} + +# Never use C comments in this file!!!!! +my $ccs = '/'.'*'; +my $cce = '*'.'/'; +my $rccs = quotemeta $ccs; +my $rcce = quotemeta $cce; + +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( +AvFILLp|5.004050||p +AvFILL||| +CLASS|||n +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||p +Copy||| +CvPADLIST||| +CvSTASH||| +CvWEAKOUTSIDE||| +DEFSV|5.004050||p +END_EXTERN_C|5.005000||p +ENTER||| +ERRSV|5.004050||p +EXTEND||| +EXTERN_C|5.005000||p +FREETMPS||| +GIMME_V||5.004000|n +GIMME|||n +GROK_NUMERIC_RADIX|5.007002||p +G_ARRAY||| +G_DISCARD||| +G_EVAL||| +G_NOARGS||| +G_SCALAR||| +G_VOID||5.004000| +GetVars||| +GvSV||| +Gv_AMupdate||| +HEf_SVKEY||5.004000| +HeHASH||5.004000| +HeKEY||5.004000| +HeKLEN||5.004000| +HePV||5.004000| +HeSVKEY_force||5.004000| +HeSVKEY_set||5.004000| +HeSVKEY||5.004000| +HeVAL||5.004000| +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||| +LVRET||| +MARK||| +MY_CXT_CLONE|5.009002||p +MY_CXT_INIT|5.007003||p +MY_CXT|5.007003||p +MoveD|5.009002||p +Move||| +NEWSV||| +NOOP|5.005000||p +NUM2PTR|5.006000||p +NVTYPE|5.006000||p +NVef|5.006001||p +NVff|5.006001||p +NVgf|5.006001||p +Newc||| +Newz||| +New||| +Nullav||| +Nullch||| +Nullcv||| +Nullhv||| +Nullsv||| +ORIGMARK||| +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||| +PERL_BCDVERSION|5.009003||p +PERL_GCC_BRACE_GROUPS_FORBIDDEN|5.008001||p +PERL_INT_MAX|5.004000||p +PERL_INT_MIN|5.004000||p +PERL_LONG_MAX|5.004000||p +PERL_LONG_MIN|5.004000||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.007002||p +PERL_MAGIC_isaelem|5.007002||p +PERL_MAGIC_isa|5.007002||p +PERL_MAGIC_mutex|5.007002||p +PERL_MAGIC_nkeys|5.007002||p +PERL_MAGIC_overload_elem|5.007002||p +PERL_MAGIC_overload_table|5.007002||p +PERL_MAGIC_overload|5.007002||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_QUAD_MAX|5.004000||p +PERL_QUAD_MIN|5.004000||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.004000||p +PERL_SHORT_MIN|5.004000||p +PERL_SUBVERSION|5.006000||p +PERL_UCHAR_MAX|5.004000||p +PERL_UCHAR_MIN|5.004000||p +PERL_UINT_MAX|5.004000||p +PERL_UINT_MIN|5.004000||p +PERL_ULONG_MAX|5.004000||p +PERL_ULONG_MIN|5.004000||p +PERL_UNUSED_DECL|5.007002||p +PERL_UQUAD_MAX|5.004000||p +PERL_UQUAD_MIN|5.004000||p +PERL_USHORT_MAX|5.004000||p +PERL_USHORT_MIN|5.004000||p +PERL_VERSION|5.006000||p +PL_DBsingle|||pn +PL_DBsub|||pn +PL_DBtrace|||n +PL_Sv|5.005000||p +PL_compiling|5.004050||p +PL_copline|5.005000||p +PL_curcop|5.004050||p +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_hexdigit|5.005000||p +PL_hints|5.005000||p +PL_last_in_gv|||n +PL_modglobal||5.005000|n +PL_na|5.004050||pn +PL_no_modify|5.006000||p +PL_ofs_sv|||n +PL_perl_destruct_level|5.004050||p +PL_perldb|5.004050||p +PL_ppaddr|5.006000||p +PL_rsfp_filters|5.004050||p +PL_rsfp|5.004050||p +PL_rs|||n +PL_stack_base|5.004050||p +PL_stack_sp|5.004050||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 +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 +PTR2ul|5.007001||p +PTRV|5.006000||p +PUSHMARK||| +PUSHi||| +PUSHmortal|5.009002||p +PUSHn||| +PUSHp||| +PUSHs||| +PUSHu|5.004000||p +PUTBACK||| +PerlIO_clearerr||5.007003| +PerlIO_close||5.007003| +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_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| +Poison|5.008000||p +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 +ST||| +SVt_IV||| +SVt_NV||| +SVt_PVAV||| +SVt_PVCV||| +SVt_PVHV||| +SVt_PVMG||| +SVt_PV||| +Safefree||| +Slab_Alloc||| +Slab_Free||| +StructCopy||| +SvCUR_set||| +SvCUR||| +SvEND||| +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| +SvNIOK_off||| +SvNIOKp||| +SvNIOK||| +SvNOK_off||| +SvNOK_only||| +SvNOK_on||| +SvNOKp||| +SvNOK||| +SvNVX||| +SvNV_set||| +SvNVx||| +SvNV||| +SvOK||| +SvOOK||| +SvPOK_off||| +SvPOK_only_UTF8||5.006000| +SvPOK_only||| +SvPOK_on||| +SvPOKp||| +SvPOK||| +SvPVX||| +SvPV_force_nomg|5.007002||p +SvPV_force||| +SvPV_nolen|5.006000||p +SvPV_nomg|5.007002||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||| +SvREFCNT_inc||| +SvREFCNT||| +SvROK_off||| +SvROK_on||| +SvROK||| +SvRV_set||5.009003| +SvRV||| +SvSETMAGIC||| +SvSHARE||5.007003| +SvSTASH_set||5.009003| +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||| +SvTRUE||| +SvTYPE||| +SvUNLOCK||5.007003| +SvUOK||5.007001| +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| +SvUVx|5.004000||p +SvUV|5.004000||p +SvVOK||5.008001| +THIS|||n +UNDERBAR|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 +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 +XSRETURN_EMPTY||| +XSRETURN_IV||| +XSRETURN_NO||| +XSRETURN_NV||| +XSRETURN_PV||| +XSRETURN_UNDEF||| +XSRETURN_UV|5.008001||p +XSRETURN_YES||| +XSRETURN||| +XST_mIV||| +XST_mNO||| +XST_mNV||| +XST_mPV||| +XST_mUNDEF||| +XST_mUV|5.008001||p +XST_mYES||| +XS_VERSION_BOOTCHECK||| +XS_VERSION||| +XS||| +ZeroD|5.009002||p +Zero||| +_aMY_CXT|5.007003||p +_pMY_CXT|5.007003||p +aMY_CXT_|5.007003||p +aMY_CXT|5.007003||p +aTHX_|5.006000||p +aTHX|5.006000||p +add_data||| +allocmy||| +amagic_call||| +any_dup||| +ao||| +append_elem||| +append_list||| +apply_attrs_my||| +apply_attrs_string||5.006001| +apply_attrs||| +apply||| +asIV||| +asUV||| +atfork_lock||5.007003|n +atfork_unlock||5.007003|n +av_arylen_p||5.009003| +av_clear||| +av_delete||5.006000| +av_exists||5.006000| +av_extend||| +av_fake||| +av_fetch||| +av_fill||| +av_len||| +av_make||| +av_pop||| +av_push||| +av_reify||| +av_shift||| +av_store||| +av_undef||| +av_unshift||| +ax|||n +bad_type||| +bind_match||| +block_end||| +block_gimme||5.004000| +block_start||| +boolSV|5.004000||p +boot_core_PerlIO||| +boot_core_UNIVERSAL||| +boot_core_xsutils||| +bytes_from_utf8||5.007001| +bytes_to_utf8||5.006001| +cache_re||| +call_argv|5.006000||p +call_atexit||5.006000| +call_body||| +call_list_body||| +call_list||5.004000| +call_method|5.006000||p +call_pv|5.006000||p +call_sv|5.006000||p +calloc||5.007002|n +cando||| +cast_i32||5.006000| +cast_iv||5.006000| +cast_ulong||5.006000| +cast_uv||5.006000| +check_uni||| +checkcomma||| +checkposixcc||| +ck_anoncode||| +ck_bitop||| +ck_concat||| +ck_defined||| +ck_delete||| +ck_die||| +ck_eof||| +ck_eval||| +ck_exec||| +ck_exists||| +ck_exit||| +ck_ftst||| +ck_fun||| +ck_glob||| +ck_grep||| +ck_index||| +ck_join||| +ck_lengthconst||| +ck_lfun||| +ck_listiob||| +ck_match||| +ck_method||| +ck_null||| +ck_open||| +ck_repeat||| +ck_require||| +ck_retarget||| +ck_return||| +ck_rfun||| +ck_rvconst||| +ck_sassign||| +ck_select||| +ck_shift||| +ck_sort||| +ck_spair||| +ck_split||| +ck_subr||| +ck_substr||| +ck_svconst||| +ck_trunc||| +ck_unpack||| +cl_and||| +cl_anything||| +cl_init_zero||| +cl_init||| +cl_is_anything||| +cl_or||| +closest_cop||| +convert||| +cop_free||| +cr_textfilter||| +croak_nocontext|||vn +croak|||v +csighandler||5.007001|n +custom_op_desc||5.007003| +custom_op_name||5.007003| +cv_ckproto||| +cv_clone||| +cv_const_sv||5.004000| +cv_dump||| +cv_undef||| +cx_dump||5.005000| +cx_dup||| +cxinc||| +dAXMARK||5.009003| +dAX|5.007002||p +dITEMS|5.007002||p +dMARK||| +dMY_CXT_SV|5.007003||p +dMY_CXT|5.007003||p +dNOOP|5.006000||p +dORIGMARK||| +dSP||| +dTHR|5.004050||p +dTHXa|5.006000||p +dTHXoa|5.006000||p +dTHX|5.006000||p +dUNDERBAR|5.009002||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| +deb||5.007003|v +del_he||| +del_sv||| +delimcpy||5.004000| +depcom||| +deprecate_old||| +deprecate||| +despatch_signals||5.007001| +die_nocontext|||vn +die_where||| +die|||v +dirp_dup||| +div128||| +djSP||| +do_aexec5||| +do_aexec||| +do_aspawn||| +do_binmode||5.004050| +do_chomp||| +do_chop||| +do_close||| +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_kv||| +do_magic_dump||5.006000| +do_msgrcv||| +do_msgsnd||| +do_oddball||| +do_op_dump||5.006000| +do_open9||5.006000| +do_openn||5.007001| +do_open||5.004000| +do_pipe||| +do_pmop_dump||5.006000| +do_print||| +do_readline||| +do_seek||| +do_semop||| +do_shmio||| +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_body||| +docatch||| +doeval||| +dofile||| +dofindlabel||| +doform||| +doing_taint||5.008001|n +dooneliner||| +doopen_pm||| +doparseform||| +dopoptoeval||| +dopoptolabel||| +dopoptoloop||| +dopoptosub_at||| +dopoptosub||| +dounwind||| +dowantarray||| +dump_all||5.006000| +dump_eval||5.006000| +dump_fds||| +dump_form||5.006000| +dump_indent||5.006000|v +dump_mstats||| +dump_packsubs||5.006000| +dump_sub||5.006000| +dump_vindent||5.006000| +dumpuntil||| +dup_attrlist||| +emulate_eaccess||| +eval_pv|5.006000||p +eval_sv|5.006000||p +expect_number||| +fbm_compile||5.005000| +fbm_instr||5.005000| +fd_on_nosuid_fs||| +filter_add||| +filter_del||| +filter_gets||| +filter_read||| +find_beginning||| +find_byclass||| +find_in_my_stash||| +find_runcv||| +find_rundefsvoffset||5.009002| +find_script||| +find_uninit_var||| +fold_constants||| +forbid_setid||| +force_ident||| +force_list||| +force_next||| +force_version||| +force_word||| +form_nocontext|||vn +form||5.004000|v +fp_dup||| +fprintf_nocontext|||vn +free_global_struct||| +free_tied_hv_pool||| +free_tmps||| +gen_constant_list||| +get_av|5.006000||p +get_context||5.006000|n +get_cv|5.006000||p +get_db_sub||| +get_debug_opts||| +get_hash_seed||| +get_hv|5.006000||p +get_mstats||| +get_no_modify||| +get_num||| +get_op_descs||5.005000| +get_op_names||5.005000| +get_opargs||| +get_ppaddr||5.006000| +get_sv|5.006000||p +get_vtbl||5.005030| +getcwd_sv||5.007002| +getenv_len||| +gp_dup||| +gp_free||| +gp_ref||| +grok_bin|5.007003||p +grok_hex|5.007003||p +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_autoload4||5.004000| +gv_check||| +gv_dump||5.006000| +gv_efullname3||5.004000| +gv_efullname4||5.006001| +gv_efullname||| +gv_ename||| +gv_fetchfile||| +gv_fetchmeth_autoload||5.007003| +gv_fetchmethod_autoload||5.004000| +gv_fetchmethod||| +gv_fetchmeth||| +gv_fetchpvn_flags||5.009002| +gv_fetchpv||| +gv_fetchsv||5.009002| +gv_fullname3||5.004000| +gv_fullname4||5.006001| +gv_fullname||| +gv_handler||5.007001| +gv_init_sv||| +gv_init||| +gv_share||| +gv_stashpvn|5.006000||p +gv_stashpv||| +gv_stashsv||| +he_dup||| +hek_dup||| +hfreeentries||| +hsplit||| +hv_assert||5.009001| +hv_auxinit||| +hv_clear_placeholders||5.009001| +hv_clear||| +hv_delayfree_ent||5.004000| +hv_delete_common||| +hv_delete_ent||5.004000| +hv_delete||| +hv_eiter_p||5.009003| +hv_eiter_set||5.009003| +hv_exists_ent||5.004000| +hv_exists||| +hv_fetch_common||| +hv_fetch_ent||5.004000| +hv_fetch||| +hv_free_ent||5.004000| +hv_iterinit||| +hv_iterkeysv||5.004000| +hv_iterkey||| +hv_iternext_flags||5.008000| +hv_iternextsv||| +hv_iternext||| +hv_iterval||| +hv_ksplit||5.004000| +hv_magic_check||| +hv_magic||| +hv_name_set||5.009003| +hv_notallowed||| +hv_placeholders_get||5.009003| +hv_placeholders_p||5.009003| +hv_placeholders_set||5.009003| +hv_riter_p||5.009003| +hv_riter_set||5.009003| +hv_scalar||5.009001| +hv_store_ent||5.004000| +hv_store_flags||5.008000| +hv_store||| +hv_undef||| +ibcmp_locale||5.004000| +ibcmp_utf8||5.007003| +ibcmp||| +incl_perldb||| +incline||| +incpush||| +ingroup||| +init_argv_symbols||| +init_debugger||| +init_global_struct||| +init_i18nl10n||5.006000| +init_i18nl14n||5.006000| +init_ids||| +init_interp||| +init_lexer||| +init_main_stash||| +init_perllib||| +init_postdump_symbols||| +init_predump_symbols||| +init_stacks||5.005000| +init_tm||5.007002| +instr||| +intro_my||| +intuit_method||| +intuit_more||| +invert||| +io_close||| +isALNUM||| +isALPHA||| +isDIGIT||| +isLOWER||| +isSPACE||| +isUPPER||| +is_an_int||| +is_gv_magical_sv||| +is_gv_magical||| +is_handle_constructor||| +is_list_assignment||| +is_lvalue_sub||5.007001| +is_uni_alnum_lc||5.006000| +is_uni_alnumc_lc||5.006000| +is_uni_alnumc||5.006000| +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_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.006000| +is_utf8_alnum||5.006000| +is_utf8_alpha||5.006000| +is_utf8_ascii||5.006000| +is_utf8_char_slow||| +is_utf8_char||5.006000| +is_utf8_cntrl||5.006000| +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_print||5.006000| +is_utf8_punct||5.006000| +is_utf8_space||5.006000| +is_utf8_string_loclen||5.009003| +is_utf8_string_loc||5.008001| +is_utf8_string||5.006001| +is_utf8_upper||5.006000| +is_utf8_xdigit||5.006000| +isa_lookup||| +items|||n +ix|||n +jmaybe||| +keyword||| +leave_scope||| +lex_end||| +lex_start||| +linklist||| +listkids||| +list||| +load_module_nocontext|||vn +load_module||5.006000|v +localize||| +looks_like_number||| +lop||| +mPUSHi|5.009002||p +mPUSHn|5.009002||p +mPUSHp|5.009002||p +mPUSHu|5.009002||p +mXPUSHi|5.009002||p +mXPUSHn|5.009002||p +mXPUSHp|5.009002||p +mXPUSHu|5.009002||p +magic_clear_all_env||| +magic_clearenv||| +magic_clearpack||| +magic_clearsig||| +magic_dump||5.006000| +magic_existspack||| +magic_freearylen_p||| +magic_freeovrld||| +magic_freeregexp||| +magic_getarylen||| +magic_getdefelem||| +magic_getglob||| +magic_getnkeys||| +magic_getpack||| +magic_getpos||| +magic_getsig||| +magic_getsubstr||| +magic_gettaint||| +magic_getuvar||| +magic_getvec||| +magic_get||| +magic_killbackrefs||| +magic_len||| +magic_methcall||| +magic_methpack||| +magic_nextpack||| +magic_regdata_cnt||| +magic_regdatum_get||| +magic_regdatum_set||| +magic_scalarpack||| +magic_set_all_env||| +magic_setamagic||| +magic_setarylen||| +magic_setbm||| +magic_setcollxfrm||| +magic_setdbline||| +magic_setdefelem||| +magic_setenv||| +magic_setfm||| +magic_setglob||| +magic_setisa||| +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||| +magicname||| +make_trie||| +malloced_size|||n +malloc||5.007002|n +markstack_grow||| +measure_struct||| +memEQ|5.004000||p +memNE|5.004000||p +mem_collxfrm||| +mess_alloc||| +mess_nocontext|||vn +mess||5.006000|v +method_common||| +mfree||5.007002|n +mg_clear||| +mg_copy||| +mg_dup||| +mg_find||| +mg_free||| +mg_get||| +mg_length||5.005000| +mg_localize||| +mg_magical||| +mg_set||| +mg_size||5.005000| +mini_mktime||5.007002| +missingterm||| +mode_from_discipline||| +modkids||| +mod||| +moreswitches||| +mul128||| +mulexp10|||n +my_atof2||5.007002| +my_atof||5.006000| +my_attrs||| +my_bcopy|||n +my_betoh16|||n +my_betoh32|||n +my_betoh64|||n +my_betohi|||n +my_betohl|||n +my_betohs|||n +my_bzero|||n +my_chsize||| +my_exit_jump||| +my_exit||| +my_failure_exit||5.004000| +my_fflush_all||5.006000| +my_fork||5.007003|n +my_htobe16|||n +my_htobe32|||n +my_htobe64|||n +my_htobei|||n +my_htobel|||n +my_htobes|||n +my_htole16|||n +my_htole32|||n +my_htole64|||n +my_htolei|||n +my_htolel|||n +my_htoles|||n +my_htonl||| +my_kid||| +my_letoh16|||n +my_letoh32|||n +my_letoh64|||n +my_letohi|||n +my_letohl|||n +my_letohs|||n +my_lstat||| +my_memcmp||5.004000|n +my_memset|||n +my_ntohl||| +my_pclose||5.004000| +my_popen_list||5.007001| +my_popen||5.004000| +my_setenv||| +my_socketpair||5.007003|n +my_stat||| +my_strftime||5.007002| +my_swabn|||n +my_swap||| +my_unexec||| +my||| +newANONATTRSUB||5.006000| +newANONHASH||| +newANONLIST||| +newANONSUB||| +newASSIGNOP||| +newATTRSUB||5.006000| +newAVREF||| +newAV||| +newBINOP||| +newCONDOP||| +newCONSTSUB|5.006000||p +newCVREF||| +newDEFSVOP||| +newFORM||| +newFOROP||| +newGVOP||| +newGVREF||| +newGVgen||| +newHVREF||| +newHVhv||5.005000| +newHV||| +newIO||| +newLISTOP||| +newLOGOP||| +newLOOPEX||| +newLOOPOP||| +newMYSUB||5.006000| +newNULLLIST||| +newOP||| +newPADOP||5.006000| +newPMOP||| +newPROG||| +newPVOP||| +newRANGE||| +newRV_inc|5.004000||p +newRV_noinc|5.006000||p +newRV||| +newSLICEOP||| +newSTATEOP||| +newSUB||| +newSVOP||| +newSVREF||| +newSVhek||5.009003| +newSViv||| +newSVnv||| +newSVpvf_nocontext|||vn +newSVpvf||5.004000|v +newSVpvn_share||5.007001| +newSVpvn|5.006000||p +newSVpv||| +newSVrv||| +newSVsv||| +newSVuv|5.006000||p +newSV||| +newUNOP||| +newWHILEOP||5.009003| +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| +next_symbol||| +nextargv||| +nextchar||| +ninstr||| +no_bareword_allowed||| +no_fh_allowed||| +no_op||| +not_a_number||| +nothreadhook||5.008000| +nuke_stacks||| +num_overflow|||n +oopsAV||| +oopsCV||| +oopsHV||| +op_clear||| +op_const_sv||| +op_dump||5.006000| +op_free||| +op_null||5.007002| +op_refcnt_lock||5.009002| +op_refcnt_unlock||5.009002| +open_script||| +pMY_CXT_|5.007003||p +pMY_CXT|5.007003||p +pTHX_|5.006000||p +pTHX|5.006000||p +pack_cat||5.007003| +pack_rec||| +package||| +packlist||5.008001| +pad_add_anon||| +pad_add_name||| +pad_alloc||| +pad_block_start||| +pad_check_dup||| +pad_compname_type||| +pad_findlex||| +pad_findmy||| +pad_fixup_inner_anons||| +pad_free||| +pad_leavemy||| +pad_new||| +pad_push||| +pad_reset||| +pad_setsv||| +pad_sv||| +pad_swipe||| +pad_tidy||| +pad_undef||| +parse_body||| +parse_unicode_opts||| +path_is_absolute||| +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||| +pmflag||| +pmop_dump||5.006000| +pmruntime||| +pmtrans||| +pop_scope||| +pregcomp||| +pregexec||| +pregfree||| +prepend_elem||| +printf_nocontext|||vn +ptr_table_clear||| +ptr_table_fetch||| +ptr_table_free||| +ptr_table_new||| +ptr_table_split||| +ptr_table_store||| +push_scope||| +put_byte||| +pv_display||5.006000| +pv_uni_display||5.007003| +qerror||| +re_croak2||| +re_dup||| +re_intuit_start||5.006000| +re_intuit_string||5.006000| +realloc||5.007002|n +reentrant_free||| +reentrant_init||| +reentrant_retry|||vn +reentrant_size||| +refkids||| +refto||| +ref||| +reg_node||| +reganode||| +regatom||| +regbranch||| +regclass_swash||5.007003| +regclass||| +regcp_set_to||| +regcppop||| +regcppush||| +regcurly||| +regdump||5.005000| +regexec_flags||5.005000| +reghop3||| +reghopmaybe3||| +reghopmaybe||| +reghop||| +reginclass||| +reginitcolors||5.006000| +reginsert||| +regmatch||| +regnext||5.005000| +regoptail||| +regpiece||| +regpposixcc||| +regprop||| +regrepeat_hard||| +regrepeat||| +regtail||| +regtry||| +reguni||| +regwhite||| +reg||| +repeatcpy||| +report_evil_fh||| +report_uninit||| +require_errno||| +require_pv||5.006000| +rninstr||| +rsignal_restore||| +rsignal_save||| +rsignal_state||5.004000| +rsignal||5.004000| +run_body||| +runops_debug||5.005000| +runops_standard||5.005000| +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_aelem||5.004050| +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_hek_flags||| +save_helem||5.004050| +save_hints||5.005000| +save_hptr||| +save_int||| +save_item||| +save_iv||5.005000| +save_lines||| +save_list||| +save_long||| +save_magic||| +save_mortalizesv||5.007001| +save_nogv||| +save_op||| +save_padsv||5.007001| +save_pptr||| +save_re_context||5.006000| +save_scalar_at||| +save_scalar||| +save_set_svflags||5.009000| +save_shared_pvref||5.007003| +save_sptr||| +save_svref||| +save_threadsv||5.005000| +save_vptr||5.006000| +savepvn||| +savepv||| +savesharedpv||5.007003| +savestack_grow_cnt||5.008001| +savestack_grow||| +savesvpv||5.009002| +sawparens||| +scalar_mod_type||| +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.008001| +scan_word||| +scope||| +screaminstr||5.005000| +seed||| +set_context||5.006000|n +set_csh||| +set_numeric_local||5.006000| +set_numeric_radix||5.006000| +set_numeric_standard||5.006000| +setdefout||| +setenv_getix||| +share_hek_flags||| +share_hek||| +si_dup||| +sighandler|||n +simplify_sort||| +skipspace||| +sortsv||5.007003| +ss_dup||| +stack_grow||| +start_glob||| +start_subparse||5.004000| +stashpv_hvname_match||5.009003| +stdize_locale||| +strEQ||| +strGE||| +strGT||| +strLE||| +strLT||| +strNE||| +str_to_version||5.006000| +strnEQ||| +strnNE||| +study_chunk||| +sub_crush_depth||| +sublex_done||| +sublex_push||| +sublex_start||| +sv_2bool||| +sv_2cv||| +sv_2io||| +sv_2iuv_non_preserve||| +sv_2iv_flags||5.009001| +sv_2iv||| +sv_2mortal||| +sv_2nv||| +sv_2pv_flags||5.007002| +sv_2pv_nolen|5.006000||p +sv_2pvbyte_nolen||| +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||| +sv_bless||| +sv_cat_decode||5.008001| +sv_catpv_mg|5.006000||p +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.006000||p +sv_catpvn_nomg|5.007002||p +sv_catpvn||| +sv_catpv||| +sv_catsv_flags||5.007002| +sv_catsv_mg|5.006000||p +sv_catsv_nomg|5.007002||p +sv_catsv||| +sv_chop||| +sv_clean_all||| +sv_clean_objs||| +sv_clear||| +sv_cmp_locale||5.004000| +sv_cmp||| +sv_collxfrm||| +sv_compile_2op||5.008001| +sv_copypv||5.007003| +sv_dec||| +sv_del_backref||| +sv_derived_from||5.004000| +sv_dump||| +sv_dup||| +sv_eq||| +sv_force_normal_flags||5.007001| +sv_force_normal||5.006000| +sv_free2||| +sv_free_arenas||| +sv_free||| +sv_gets||5.004000| +sv_grow||| +sv_inc||| +sv_insert||| +sv_isa||| +sv_isobject||| +sv_iv||5.005000| +sv_len_utf8||5.006000| +sv_len||| +sv_magicext||5.007003| +sv_magic||| +sv_mortalcopy||| +sv_newmortal||| +sv_newref||| +sv_nolocking||5.007003| +sv_nosharing||5.007003| +sv_nounlocking||5.007003| +sv_nv||5.005000| +sv_peek||5.005000| +sv_pos_b2u||5.006000| +sv_pos_u2b||5.006000| +sv_pvbyten_force||5.006000| +sv_pvbyten||5.006000| +sv_pvbyte||5.006000| +sv_pvn_force_flags||5.007002| +sv_pvn_force|||p +sv_pvn_nomg|5.007003||p +sv_pvn|5.006000||p +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_release_COW||| +sv_release_IVX||| +sv_replace||| +sv_report_used||| +sv_reset||| +sv_rvweaken||5.006000| +sv_setiv_mg|5.006000||p +sv_setiv||| +sv_setnv_mg|5.006000||p +sv_setnv||| +sv_setpv_mg|5.006000||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.006000||p +sv_setpvn||| +sv_setpv||| +sv_setref_iv||| +sv_setref_nv||| +sv_setref_pvn||| +sv_setref_pv||| +sv_setref_uv||5.007001| +sv_setsv_cow||| +sv_setsv_flags||5.007002| +sv_setsv_mg|5.006000||p +sv_setsv_nomg|5.007002||p +sv_setsv||| +sv_setuv_mg|5.006000||p +sv_setuv|5.006000||p +sv_tainted||5.004000| +sv_taint||5.004000| +sv_true||5.005000| +sv_unglob||| +sv_uni_display||5.007003| +sv_unmagic||| +sv_unref_flags||5.007001| +sv_unref||| +sv_untaint||5.004000| +sv_upgrade||| +sv_usepvn_mg|5.006000||p +sv_usepvn||| +sv_utf8_decode||5.006000| +sv_utf8_downgrade||5.006000| +sv_utf8_encode||5.006000| +sv_utf8_upgrade_flags||5.007002| +sv_utf8_upgrade||5.007001| +sv_uv|5.006000||p +sv_vcatpvf_mg|5.006000|5.004000|p +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| +sys_intern_clear||| +sys_intern_dup||| +sys_intern_init||| +taint_env||| +taint_proper||| +tmps_grow||5.006000| +toLOWER||| +toUPPER||| +to_byte_substr||| +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.007003| +to_utf8_lower||5.007003| +to_utf8_substr||| +to_utf8_title||5.007003| +to_utf8_upper||5.007003| +tokeq||| +tokereport||| +too_few_arguments||| +too_many_arguments||| +unlnk||| +unpack_rec||| +unpack_str||5.007003| +unpackstring||5.008001| +unshare_hek_or_pvn||| +unshare_hek||| +unsharepvn||5.004000| +upg_version||5.009000| +usage||| +utf16_textfilter||| +utf16_to_utf8_reversed||5.006001| +utf16_to_utf8||5.006001| +utf16rev_textfilter||| +utf8_distance||5.006000| +utf8_hop||5.006000| +utf8_length||5.007001| +utf8_mg_pos_init||| +utf8_mg_pos||| +utf8_to_bytes||5.006001| +utf8_to_uvchr||5.007001| +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| +uvuni_to_utf8_flags||5.007003| +uvuni_to_utf8||5.007001| +validate_suid||| +varname||| +vcmp||5.009000| +vcroak||5.006000| +vdeb||5.007003| +vdie||| +vform||5.006000| +visit||| +vivify_defelem||| +vivify_ref||| +vload_module||5.006000| +vmess||5.006000| +vnewSVpvf|5.006000|5.004000|p +vnormal||5.009002| +vnumify||5.009000| +vstringify||5.009000| +vwarner||5.006000| +vwarn||5.006000| +wait4pid||| +warn_nocontext|||vn +warner_nocontext|||vn +warner||5.006000|v +warn|||v +watch||| +whichsig||| +write_to_stderr||| +yyerror||| +yylex||| +yyparse||| +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, %depends); +my $replace = 0; +my $hint = ''; + +while (<DATA>) { + if ($hint) { + if (m{^\s*\*\s(.*?)\s*$}) { + $hints{$hint} ||= ''; # suppress warning with older perls + $hints{$hint} .= "$1\n"; + } + else { + $hint = ''; + } + } + $hint = $1 if m{^\s*$rccs\sHint:\s+(\w+)\s*$}; + + $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+depends\s+on\s+(\w+(\s*,\s*\w+)*)\s+$rcce\s*$}) { + push @{$depends{$1}}, map { s/\s+//g; $_ } split /,/, $2; + } + + $need{$1} = 1 if m{^#if\s+defined\(NEED_(\w+)(?:_GLOBAL)?\)}; +} + +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 "$hints{$f}" if exists $hints{$f}; + $info++; + } + unless ($info) { + print "No portability information available.\n"; + } + $count++; + } + if ($count > 0) { + print "\n"; + } + else { + print "Found no API matching '$opt{'api-info'}'.\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}; + my $flags = @flags ? ' ['.join(', ', @flags).']' : ''; + print "$f$flags\n"; + } + exit 0; +} + +my @files; +my @srcext = qw( xs c h cc cpp ); +my $srcext = join '|', @srcext; + +if (@ARGV) { + my %seen; + @files = grep { -f && !exists $seen{$_} } map { glob $_ } @ARGV; +} +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; +} + +unless (@files) { + die "No input files given!\n"; +} + +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 $/; <IN> }; + close IN; + + my %file = (orig => $c, changes => 0); + + # temporarily remove C comments from the code + my @ccom; + $c =~ s{ + ( + [^"'/]+ + | + (?:"[^"\\]*(?:\\.[^"\\]*)*" [^"'/]*)+ + | + (?:'[^'\\]*(?:\\.[^'\\]*)*' [^"'/]*)+ + ) + | + (/ (?: + \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / + | + /[^\r\n]* + )) + }{ + defined $2 and push @ccom, $2; + defined $1 ? $1 : "$ccs$#ccom$cce"; + }egsx; + + $file{ccom} = \@ccom; + $file{code} = $c; + $file{has_inc_ppport} = ($c =~ /#.*include.*\Q$ppport\E/); + + 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}) { + 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) { + if (exists $need{$_}) { + $file{needs}{$_} = 'static'; + } + } + } + } + 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}; + + for $func (sort keys %{$file{uses_Perl}}) { + if ($API{$func}{varargs}) { + 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}}) { + next unless $file{uses}{$func}; # if it's only a dependency + if (exists $file{uses_deps}{$func}) { + diag("Uses $func, which depends on ", join(', ', @{$file{uses_deps}{$func}})); + } + elsif (exists $replace{$func}) { + warning("Uses $func instead of $replace{$func}"); + $file{changes} += ($c =~ s/\b$func\b/$replace{$func}/g); + } + else { + diag("Uses $func"); + } + hint($func); + } + + for $func (sort keys %{$file{uses_todo}}) { + warning("Uses $func, which may not be portable below perl ", + format_version($API{$func}{todo})); + } + + 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"); + } + + 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 mydiff +{ + local *F = shift; + my($file, $str) = @_; + my $diff; + + if (exists $opt{diff}) { + $diff = run_diff($opt{diff}, $file, $str); + } + + if (!defined $diff and can_use('Text::Diff')) { + $diff = Text::Diff::diff($file, \$str, { STYLE => 'Unified' }); + $diff = <<HEADER . $diff; +--- $file ++++ $file.patched +HEADER + } + + if (!defined $diff) { + $diff = run_diff('diff -u', $file, $str); + } + + if (!defined $diff) { + $diff = run_diff('diff', $file, $str); + } + + if (!defined $diff) { + error("Cannot generate a diff. Please install Text::Diff or use --copy."); + return; + } + + print F $diff; + +} + +sub run_diff +{ + my($prog, $file, $str) = @_; + my $tmp = 'dppptemp'; + my $suf = 'aaa'; + my $diff = ''; + local *F; + + while (-e "$tmp.$suf") { $suf++ } + $tmp = "$tmp.$suf"; + + if (open F, ">$tmp") { + print F $str; + close F; + + if (open F, "$prog $file $tmp |") { + while (<F>) { + 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 can_use +{ + eval "use @_;"; + return $@ eq ''; +} + +sub rec_depend +{ + my $func = shift; + my %seen; + return () unless exists $depends{$func}; + grep !$seen{$_}++, map { ($_, rec_depend($_)) } @{$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; +sub hint +{ + $opt{quiet} and return; + $opt{hints} or return; + my $func = shift; + exists $hints{$func} or return; + $given_hints{$func}++ and return; + my $hint = $hints{$func}; + $hint =~ s/^/ /mg; + print " --- hint for $func ---\n", $hint; +} + +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 <<ENDUSAGE; + +Usage: $usage + +See perldoc $0 for details. + +ENDUSAGE + + exit 2; +} + +__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 <patchlevel.h> +#endif +#if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL))) +#include <could_not_find_Perl_patchlevel.h> +#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 PERL_BCDVERSION \ + ((PERL_REVISION * 0x1000000L) + (PERL_VERSION * 0x1000L) + 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 */ + +#ifdef I_LIMITS +#include <limits.h> +#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 <values.h> */ +#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 <values.h> */ +#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 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 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 +#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 + +#if (PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION <= 5)) +/* Replace: 1 */ +#define PL_DBsingle DBsingle +#define PL_DBsub DBsub +#define PL_Sv Sv +#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_hexdigit hexdigit +#define PL_hints hints +#define PL_na na +#define PL_no_modify no_modify +#define PL_perl_destruct_level perl_destruct_level +#define PL_perldb perldb +#define PL_ppaddr ppaddr +#define PL_rsfp_filters rsfp_filters +#define PL_rsfp rsfp +#define PL_stack_base stack_base +#define PL_stack_sp stack_sp +#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 +/* Replace: 0 */ +#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 NOOP +#define NOOP (void)0 +#endif + +#ifndef dNOOP +#define dNOOP extern int 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 + +#define NUM2PTR(any, d) (any)(PTRV)(d) +#define PTR2IV(p) INT2PTR(IV, p) +#define PTR2UV(p) INT2PTR(UV, p) +#define PTR2NV(p) NUM2PTR(NV, p) + +#if PTRSIZE == LONGSIZE +#define PTR2ul(p) (unsigned long)(p) +#else +#define PTR2ul(p) INT2PTR(unsigned long, p) +#endif + +#endif /* !INT2PTR */ + +#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 + +#ifndef PERL_GCC_BRACE_GROUPS_FORBIDDEN +#if defined(__STRICT_ANSI__) && defined(PERL_GCC_PEDANTIC) +#define PERL_GCC_BRACE_GROUPS_FORBIDDEN +#endif +#endif + +#undef STMT_START +#undef STMT_END +#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) && \ + !defined(__cplusplus) +#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 + +/* Older perls (<=5.003) lack AvFILLp */ +#ifndef AvFILLp +#define AvFILLp AvFILL +#endif +#ifndef ERRSV +#define ERRSV get_sv("@", FALSE) +#endif +#ifndef newSVpvn +#define newSVpvn(data, len) \ + ((data) ? ((len) ? newSVpv((data), (len)) : newSVpv("", 0)) : newSV(0)) +#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 */ + +#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 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 Poison +#define Poison(d, n, t) (void)memset((char *)(d), 0xAB, (n) * sizeof(t)) +#endif +#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 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 +#ifndef dTHXoa +#define dTHXoa(x) dTHXa(x) +#endif +#ifndef PUSHmortal +#define PUSHmortal PUSHs(sv_newmortal()) +#endif + +#ifndef mPUSHp +#define mPUSHp(p, l) sv_setpvn_mg(PUSHmortal, (p), (l)) +#endif + +#ifndef mPUSHn +#define mPUSHn(n) sv_setnv_mg(PUSHmortal, (NV)(n)) +#endif + +#ifndef mPUSHi +#define mPUSHi(i) sv_setiv_mg(PUSHmortal, (IV)(i)) +#endif + +#ifndef mPUSHu +#define mPUSHu(u) sv_setuv_mg(PUSHmortal, (UV)(u)) +#endif +#ifndef XPUSHmortal +#define XPUSHmortal XPUSHs(sv_newmortal()) +#endif + +#ifndef mXPUSHp +#define mXPUSHp(p, l) \ + STMT_START \ + { \ + EXTEND(sp, 1); \ + sv_setpvn_mg(PUSHmortal, (p), (l)); \ + } \ + STMT_END +#endif + +#ifndef mXPUSHn +#define mXPUSHn(n) \ + STMT_START \ + { \ + EXTEND(sp, 1); \ + sv_setnv_mg(PUSHmortal, (NV)(n)); \ + } \ + STMT_END +#endif + +#ifndef mXPUSHi +#define mXPUSHi(i) \ + STMT_START \ + { \ + EXTEND(sp, 1); \ + sv_setiv_mg(PUSHmortal, (IV)(i)); \ + } \ + STMT_END +#endif + +#ifndef mXPUSHu +#define mXPUSHu(u) \ + STMT_START \ + { \ + EXTEND(sp, 1); \ + sv_setuv_mg(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 */ + +/* Replace perl_eval_pv with eval_pv */ +/* eval_pv depends on eval_sv */ + +#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 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_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION < 63))) && \ + ((PERL_VERSION != 4) || (PERL_SUBVERSION != 5)) +#if defined(NEED_newCONSTSUB) +static void DPPP_(my_newCONSTSUB)(HV *stash, char *name, SV *sv); +static +#else +extern void DPPP_(my_newCONSTSUB)(HV *stash, 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) + + void DPPP_(my_newCONSTSUB)(HV *stash, 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 = PL_copline; + + PL_hints &= ~HINT_BLOCK_SCOPE; + if (stash) + PL_curstash = PL_curcop->cop_stash = stash; + + newSUB( + +#if ((PERL_VERSION < 3) || ((PERL_VERSION == 3) && (PERL_SUBVERSION < 22))) + start_subparse(), +#elif ((PERL_VERSION == 3) && (PERL_SUBVERSION == 22)) + start_subparse(0), +#else /* 5.003_23 onwards */ + start_subparse(FALSE, 0), +#endif + + newSVOP(OP_CONST, 0, newSVpv(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_VERSION < 4 || (PERL_VERSION == 4 && PERL_SUBVERSION < 68)) +/* 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" +#else +#if IVSIZE == INTSIZE +#define IVdf "d" +#define UVuf "u" +#define UVof "o" +#define UVxf "x" +#define UVXf "X" +#endif +#endif +#endif + +#ifndef NVef +#if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) && \ + defined(PERL_PRIfldbl) /* 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 SvPV_nolen + +#if defined(NEED_sv_2pv_nolen) +static char *DPPP_(my_sv_2pv_nolen)(pTHX_ register SV *sv); +static +#else +extern char *DPPP_(my_sv_2pv_nolen)(pTHX_ register SV *sv); +#endif + +#ifdef sv_2pv_nolen +#undef sv_2pv_nolen +#endif +#define sv_2pv_nolen(a) DPPP_(my_sv_2pv_nolen)(aTHX_ a) +#define Perl_sv_2pv_nolen DPPP_(my_sv_2pv_nolen) + +#if defined(NEED_sv_2pv_nolen) || defined(NEED_sv_2pv_nolen_GLOBAL) + + char *DPPP_(my_sv_2pv_nolen)(pTHX_ register SV *sv) +{ + STRLEN n_a; + return sv_2pv(sv, &n_a); +} + +#endif + +/* Hint: sv_2pv_nolen + * Use the SvPV_nolen() macro instead of sv_2pv_nolen(). + */ + +/* SvPV_nolen depends on sv_2pv_nolen */ +#define SvPV_nolen(sv) \ + ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK ? SvPVX(sv) : sv_2pv_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_VERSION < 7) || ((PERL_VERSION == 7) && (PERL_SUBVERSION < 0))) + +#if defined(NEED_sv_2pvbyte) +static char *DPPP_(my_sv_2pvbyte)(pTHX_ register SV *sv, STRLEN *lp); +static +#else +extern char *DPPP_(my_sv_2pvbyte)(pTHX_ register 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_ register 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 + +/* SvPVbyte depends on sv_2pvbyte */ +#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 + +/* sv_2pvbyte_nolen depends on sv_2pv_nolen */ +#ifndef sv_2pvbyte_nolen +#define sv_2pvbyte_nolen sv_2pv_nolen +#endif + +/* Hint: sv_pvn + * Always use the SvPV() macro instead of sv_pvn(). + */ +#ifndef sv_pvn +#define sv_pvn(sv, len) SvPV(sv, len) +#endif + +/* Hint: sv_pvn_force + * Always use the SvPV_force() macro instead of sv_pvn_force(). + */ +#ifndef sv_pvn_force +#define sv_pvn_force(sv, len) SvPV_force(sv, len) +#endif + +#if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && \ + !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 + +/* sv_vcatpvf depends on sv_vcatpvfn */ +#if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && \ + !defined(sv_vcatpvf) +#define sv_vcatpvf(sv, pat, args) \ + sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV **), 0, Null(bool *)) +#endif + +/* sv_vsetpvf depends on sv_vsetpvfn */ +#if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && \ + !defined(sv_vsetpvf) +#define sv_vsetpvf(sv, pat, args) \ + sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV **), 0, Null(bool *)) +#endif + +/* sv_catpvf_mg depends on sv_vcatpvfn, sv_catpvf_mg_nocontext */ +#if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && \ + !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 + +/* sv_catpvf_mg_nocontext depends on sv_vcatpvfn */ +#ifdef PERL_IMPLICIT_CONTEXT +#if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && \ + !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 + +#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 + +/* sv_vcatpvf_mg depends on sv_vcatpvfn */ +#if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && \ + !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 + +/* sv_setpvf_mg depends on sv_vsetpvfn, sv_setpvf_mg_nocontext */ +#if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && \ + !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 + +/* sv_setpvf_mg_nocontext depends on sv_vsetpvfn */ +#ifdef PERL_IMPLICIT_CONTEXT +#if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && \ + !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 + +#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 + +/* sv_vsetpvf_mg depends on sv_vsetpvfn */ +#if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && \ + !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 +#ifndef SvGETMAGIC +#define SvGETMAGIC(x) \ + STMT_START \ + { \ + if (SvGMAGICAL(x)) \ + mg_get(x); \ + } \ + STMT_END +#endif +#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 SvPV_force_nomg +#define SvPV_force_nomg SvPV_force +#endif + +#ifndef SvPV_nomg +#define SvPV_nomg SvPV +#endif + +#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 + +#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 */ +#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 + +/* GROK_NUMERIC_RADIX depends on grok_numeric_radix */ +#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 <locale.h> + 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 /* PERL_VERSION */ +#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 + +/* grok_number depends on grok_numeric_radix */ + +#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_ char *start, STRLEN *len_p, I32 *flags, + NV *result); +static +#else +extern UV DPPP_(my_grok_bin)(pTHX_ 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_ 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_ char *start, STRLEN *len_p, I32 *flags, + NV *result); +static +#else +extern UV DPPP_(my_grok_hex)(pTHX_ 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_ 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_ char *start, STRLEN *len_p, I32 *flags, + NV *result); +static +#else +extern UV DPPP_(my_grok_oct)(pTHX_ 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_ 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 + +#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 + +#endif /* _P_P_PORTABILITY_H_ */ + +/* End of File ppport.h */ diff --git a/perl/t/Decoder.t b/perl/t/Decoder.t new file mode 100755 index 0000000..12ba86f --- /dev/null +++ b/perl/t/Decoder.t @@ -0,0 +1,111 @@ +# Before `make install' is performed this script should be runnable with +# `make test'. After `make install' it should work as `perl Decoder.t' + +use warnings; +use strict; +use Test::More tests => 17; + +######################### + +BEGIN { use_ok('Barcode::ZBar') } + +######################### + +my $decoder = Barcode::ZBar::Decoder->new(); +isa_ok($decoder, 'Barcode::ZBar::Decoder', 'decoder'); + +$decoder->parse_config('enable'); + +######################### + +can_ok($decoder, qw(set_config parse_config reset new_scan decode_width + get_color get_configs get_direction get_data get_modifiers + get_type set_handler)); + +######################### + +my $sym = $decoder->decode_width(5); +is($sym, Barcode::ZBar::Symbol::NONE, 'enum/enum compare'); + +######################### + +ok($sym == 0, 'enum/numeric compare'); + +######################### + +is($sym, 'None', 'enum/string compare'); + +######################### + +my $handler_type = 0; +my $explicit_closure = 0; + +$decoder->set_handler(sub { + if(!$handler_type) { + is($_[0], $decoder, 'handler decoder'); + } + + my $type = $_[0]->get_type(); + $handler_type = $type + if(!$handler_type or $type > Barcode::ZBar::Symbol::PARTIAL); + + ${$_[1]} += 1 +}, \$explicit_closure); + +######################### + +$decoder->reset(); +is($decoder->get_color(), Barcode::ZBar::SPACE, 'reset color'); + +######################### + +is($decoder->get_direction(), 0, 'reset direction'); + +######################### + +$decoder->set_config(Barcode::ZBar::Symbol::QRCODE, + Barcode::ZBar::Config::ENABLE, 0); + +my $encoded = + '9 111 212241113121211311141132 11111 311213121312121332111132 111 9'; + +foreach my $width (split(/ */, $encoded)) { + my $tmp = $decoder->decode_width($width); + if($tmp > Barcode::ZBar::Symbol::PARTIAL) { + $sym = ($sym == Barcode::ZBar::Symbol::NONE) ? $tmp : -1; + } +} +is($sym, Barcode::ZBar::Symbol::EAN13, 'EAN-13 type'); + +######################### + +is_deeply([$decoder->get_configs($sym)], + [Barcode::ZBar::Config::ENABLE, + Barcode::ZBar::Config::EMIT_CHECK], + 'read configs'); + +######################### + +is_deeply([$decoder->get_modifiers()], [], 'read modifiers'); + +######################### + +is($decoder->get_data(), '6268964977804', 'EAN-13 data'); + +######################### + +is($decoder->get_color(), Barcode::ZBar::BAR, 'post-scan color'); + +######################### + +is($decoder->get_direction(), 1, 'decode direction'); + +######################### + +is($handler_type, Barcode::ZBar::Symbol::EAN13, 'handler type'); + +######################### + +is($explicit_closure, 2, 'handler explicit closure'); + +######################### diff --git a/perl/t/Image.t b/perl/t/Image.t new file mode 100755 index 0000000..a63b985 --- /dev/null +++ b/perl/t/Image.t @@ -0,0 +1,186 @@ +# Before `make install' is performed this script should be runnable with +# `make test'. After `make install' it should work as `perl Image.t' + +use warnings; +use strict; +use Test::More tests => 29; + +######################### + +BEGIN { use_ok('Barcode::ZBar') } + +Barcode::ZBar::set_verbosity(16); + +######################### + +my $image = Barcode::ZBar::Image->new(); +isa_ok($image, 'Barcode::ZBar::Image', 'image'); + +######################### + +my $scanner = Barcode::ZBar::ImageScanner->new(); +isa_ok($scanner, 'Barcode::ZBar::ImageScanner', 'image scanner'); + +######################### + +can_ok($image, qw(convert convert_resize + get_format get_size get_data + set_format set_size set_data)); + +######################### + +can_ok($scanner, qw(set_config parse_config enable_cache scan_image)); + +######################### + +$image->set_format('422P'); +my $fmt = $image->get_format(); +is($fmt, '422P', 'string format accessors'); + +######################### + +ok($fmt == 0x50323234, 'numeric format accessors'); + +######################### + +$image->set_size(114, 80); +is_deeply([$image->get_size()], [114, 80], 'size accessors'); + +######################### + +$image->set_crop(20, 20, 74, 40); +is_deeply([$image->get_crop()], [20, 20, 74, 40], 'crop accessors'); + +######################### + +$image->set_crop(-57, -40, 228, 160); +is_deeply([$image->get_crop()], [0, 0, 114, 80], 'crop clipping'); + +######################### + +$image->set_crop(10, 10, 94, 60); +is_deeply([$image->get_crop()], [10, 10, 94, 60], 'crop accessors'); + +######################### + +$image->set_size(114, 80); +is_deeply([$image->get_crop()], [0, 0, 114, 80], 'crop reset'); + +######################### + +# FIXME avoid skipping these (eg embed image vs ImageMagick) +SKIP: { + eval { require Image::Magick }; + skip "Image::Magick not installed", 16 if $@; + + my $im = Image::Magick->new(); + my $err = $im->Read('t/barcode.png'); + die($err) if($err); + + $image->set_size($im->Get(qw(columns rows))); + + { + my $data = $im->ImageToBlob( + magick => 'YUV', + 'sampling-factor' => '4:2:2', + interlace => 'Plane'); + $image->set_data($data); + } + + $image = $image->convert('Y800'); + isa_ok($image, 'Barcode::ZBar::Image', 'image'); + + ######################### + + is($image->get_format(), 'Y800', 'converted image format'); + + ######################### + + is_deeply([$image->get_size()], [114, 80], 'converted image size'); + + ######################### + + is($scanner->scan_image($image), 1, 'scan result'); + + ######################### + + my @symbols = $image->get_symbols(); + is(scalar(@symbols), 1, 'result size'); + + ######################### + + my $sym = $symbols[0]; + isa_ok($sym, 'Barcode::ZBar::Symbol', 'symbol'); + + ######################### + + can_ok($sym, qw(get_type get_configs get_modifiers get_data get_quality + get_count get_loc get_orientation)); + + ######################### + + is($sym->get_type(), Barcode::ZBar::Symbol::EAN13, 'result type'); + + ######################### + + is_deeply([$sym->get_configs()], + [Barcode::ZBar::Config::ENABLE, + Barcode::ZBar::Config::EMIT_CHECK], + 'result configs'); + + ######################### + + is_deeply([$sym->get_modifiers()], [], 'result modifiers'); + + ######################### + + is($sym->get_data(), '9876543210128', 'result data'); + + ######################### + + ok($sym->get_quality() > 0, 'quality'); + + ######################### + + my @loc = $sym->get_loc(); + ok(scalar(@loc) >= 4, 'location size'); + + ######################### + + my $failure = undef; + foreach my $pt (@loc) { + if(ref($pt) ne 'ARRAY') { + $failure = ("location entry is wrong type:" . + " expecting ARRAY ref, got " . ref($pt)); + last; + } + if(scalar(@{$pt}) != 2) { + $failure = ("location coordinate has too many entries:" . + " expecting 2, got " . scalar(@{$pt})); + last; + } + } + ok(!defined($failure), 'location structure') or + diag($failure); + + ######################### + + is($sym->get_orientation(), Barcode::ZBar::Orient::UP, 'orientation'); + + ######################### + + my @comps = $sym->get_components(); + is(scalar(@comps), 0, 'components size'); + + ######################### +} + +$scanner->recycle_image($image); + +my @symbols = $image->get_symbols(); +is(scalar(@symbols), 0, 'recycled result size'); + +######################### + + +# FIXME more image tests diff --git a/perl/t/Processor.t b/perl/t/Processor.t new file mode 100755 index 0000000..92bf6fe --- /dev/null +++ b/perl/t/Processor.t @@ -0,0 +1,140 @@ +# Before `make install' is performed this script should be runnable with +# `make test'. After `make install' it should work as `perl Processor.t' + +use warnings; +use strict; +use Test::More tests => 20; + +######################### + +BEGIN { use_ok('Barcode::ZBar') } + +Barcode::ZBar::set_verbosity(32); + +######################### + +my $proc = Barcode::ZBar::Processor->new(); +isa_ok($proc, 'Barcode::ZBar::Processor', 'processor'); + +######################### + +can_ok($proc, qw(init set_config parse_config)); + +######################### + +ok(!$proc->parse_config('enable'), 'configuration'); + +######################### + +my $cnt = 0; +my $explicit_closure = 0; + +$proc->set_data_handler(sub { + + ok(!$cnt, 'handler invocations'); + $cnt += 1; + + ######################### + + is($_[0], $proc, 'handler processor'); + + ######################### + + my $image = $_[1]; + isa_ok($image, 'Barcode::ZBar::Image', 'image'); + + ######################### + + my @symbols = $image->get_symbols(); + is(scalar(@symbols), 1, 'result size'); + + ######################### + + my $sym = $symbols[0]; + isa_ok($sym, 'Barcode::ZBar::Symbol', 'symbol'); + + ######################### + + is($sym->get_type(), Barcode::ZBar::Symbol::EAN13, 'result type'); + + ######################### + + is($sym->get_data(), '9876543210128', 'result data'); + + ######################### + + ok($sym->get_quality() > 0, 'quality'); + + ######################### + + my @loc = $sym->get_loc(); + ok(scalar(@loc) >= 4, 'location size'); + + # structure checked by Image.t + + ${$_[2]} += 1 +}, \$explicit_closure); + +######################### + +SKIP: { + skip "no display", 3 unless defined $ENV{'DISPLAY'}; + + $proc->init($ENV{VIDEO_DEVICE}); + ok(!$proc->is_visible(), 'initial visibility'); + + ######################### + + $proc->set_visible(); + ok($proc->is_visible(), 'enabled visiblity'); + + ######################### + + ok($proc->user_wait(1.1) >= 0, 'wait w/timeout'); + + ######################### +} + +SKIP: { + # FIXME factor out image read utility + eval { require Image::Magick }; + skip "Image::Magick not installed", 11 if $@; + my $im = Image::Magick->new(); + my $err = $im->Read('t/barcode.png'); + die($err) if($err); + my $image = Barcode::ZBar::Image->new(); + $image->set_format('422P'); + $image->set_size($im->Get(qw(columns rows))); + $image->set_data($im->ImageToBlob( + magick => 'YUV', + 'sampling-factor' => '4:2:2', + interlace => 'Plane') + ); + +SKIP: { + skip "no display", 11 unless defined $ENV{'DISPLAY'}; + + my $rc = $proc->process_image($image); + ok(!$rc, 'process result'); + + $proc->user_wait(.9); + + ######################### + + is($explicit_closure, 1, 'handler explicit closure'); + } +} + +######################### + +$proc->set_data_handler(); +pass('unset handler'); + +######################### + +# FIXME more processor tests + +$proc = undef; +pass('cleanup'); + +######################### diff --git a/perl/t/Scanner.t b/perl/t/Scanner.t new file mode 100755 index 0000000..99b8942 --- /dev/null +++ b/perl/t/Scanner.t @@ -0,0 +1,23 @@ +# Before `make install' is performed this script should be runnable with +# `make test'. After `make install' it should work as `perl Scanner.t' + +use warnings; +use strict; +use Test::More tests => 3; + +######################### + +BEGIN { use_ok('Barcode::ZBar') } + +######################### + +my $scanner = Barcode::ZBar::Scanner->new(); +isa_ok($scanner, 'Barcode::ZBar::Scanner', 'scanner'); + +######################### + +can_ok($scanner, qw(reset new_scan scan_y get_width get_color)); + +######################### + +# FIXME more scanner tests diff --git a/perl/t/ZBar.t b/perl/t/ZBar.t new file mode 100755 index 0000000..0e3a867 --- /dev/null +++ b/perl/t/ZBar.t @@ -0,0 +1,68 @@ +# Before `make install' is performed this script should be runnable with +# `make test'. After `make install' it should work as `perl ZBar.t' + +use warnings; +use strict; +use Test::More tests => 37; + +######################### + +BEGIN { use_ok('Barcode::ZBar') } + +######################### + +like(Barcode::ZBar::version(), qr<\d.\d>, 'version'); + +######################### + +Barcode::ZBar::set_verbosity(16); +Barcode::ZBar::increase_verbosity(); +pass('verbosity'); + +######################### + +# performs (2 * n) tests +sub test_enum { + my $name = shift; + foreach my $test (@_) { + my $enum = $test->[0]; + + is($enum, $test->[1], "$name enum/string compare"); + + ######################### + + ok($enum == $test->[2], "$name enum/numeric compare"); + } +} + +test_enum('config', + [Barcode::ZBar::Config::ENABLE, 'enable', 0], + [Barcode::ZBar::Config::ADD_CHECK, 'add-check', 1], + [Barcode::ZBar::Config::EMIT_CHECK, 'emit-check', 2], + [Barcode::ZBar::Config::ASCII, 'ascii', 3], + [Barcode::ZBar::Config::MIN_LEN, 'min-length', 32], + [Barcode::ZBar::Config::MAX_LEN, 'max-length', 33], + [Barcode::ZBar::Config::UNCERTAINTY, 'uncertainty', 64], + [Barcode::ZBar::Config::POSITION, 'position', 128], + [Barcode::ZBar::Config::X_DENSITY, 'x-density', 256], + [Barcode::ZBar::Config::Y_DENSITY, 'y-density', 257], +); + +######################### + +test_enum('modifier', + [Barcode::ZBar::Modifier::GS1, 'GS1', 0], + [Barcode::ZBar::Modifier::AIM, 'AIM', 1], +); + +######################### + +test_enum('orientation', + [Barcode::ZBar::Orient::UNKNOWN, 'UNKNOWN', -1], + [Barcode::ZBar::Orient::UP, 'UP', 0], + [Barcode::ZBar::Orient::RIGHT, 'RIGHT', 1], + [Barcode::ZBar::Orient::DOWN, 'DOWN', 2], + [Barcode::ZBar::Orient::LEFT, 'LEFT', 3], +); + +######################### diff --git a/perl/t/barcode.png b/perl/t/barcode.png Binary files differnew file mode 100644 index 0000000..72846ce --- /dev/null +++ b/perl/t/barcode.png diff --git a/perl/t/pod-coverage.t b/perl/t/pod-coverage.t new file mode 100644 index 0000000..97c2df8 --- /dev/null +++ b/perl/t/pod-coverage.t @@ -0,0 +1,12 @@ +# Before `make install' is performed this script should be runnable with +# `make test'. After `make install' it should work as `perl pod.t' + +use warnings; +use strict; +use Test::More; + +eval "use Test::Pod::Coverage"; +plan skip_all => "Test::Pod::Coverage required for testing pod coverage" + if $@; + +all_pod_coverage_ok(); diff --git a/perl/t/pod.t b/perl/t/pod.t new file mode 100644 index 0000000..bc0af34 --- /dev/null +++ b/perl/t/pod.t @@ -0,0 +1,12 @@ +# Before `make install' is performed this script should be runnable with +# `make test'. After `make install' it should work as `perl pod.t' + +use warnings; +use strict; +use Test::More; + +eval "use Test::Pod 1.00"; +plan skip_all => "Test::Pod 1.00 required for testing POD" + if $@; + +all_pod_files_ok(); diff --git a/perl/typemap b/perl/typemap new file mode 100644 index 0000000..dda1979 --- /dev/null +++ b/perl/typemap @@ -0,0 +1,66 @@ +# objects +Barcode::ZBar::Error T_PTROBJ +Barcode::ZBar::Symbol T_PTROBJ +Barcode::ZBar::Image T_PTROBJ +Barcode::ZBar::Processor T_PTROBJ +Barcode::ZBar::Video T_PTROBJ +Barcode::ZBar::Window T_PTROBJ +Barcode::ZBar::ImageScanner T_PTROBJ +Barcode::ZBar::Decoder T_PTROBJ +Barcode::ZBar::Scanner T_PTROBJ + +# enums +zbar_color_t T_ENUM +zbar_error_t T_ENUM +zbar_symbol_type_t T_ENUM +zbar_config_t T_ENUM +zbar_modifier_t T_ENUM +zbar_orientation_t T_ENUM + +# special scalars +fourcc_t T_FOURCC +timeout_t T_TIMEOUT + +# error handling +config_error T_CONFIG_ERROR + + +INPUT + +T_ENUM + $var = ($type)SvIV($arg) +T_FOURCC + { + if(SvPOK($arg)) { + char *str = SvPV_nolen($arg); + $var = zbar_fourcc_parse(str); + } + else + $var = SvUV($arg); + } +T_TIMEOUT + if(($var = ($type)(SvNV($arg) * 1000.)) < 0) + $var = -1; +T_PV + $var = SvOK($arg) ? SvPV_nolen($arg) : NULL; + +OUTPUT + +T_ENUM + $arg = SvREFCNT_inc(lookup_enum(LOOKUP_$ntype, (int)$var)); +T_FOURCC + { + char str[4] = { + $var & 0xff, + ($var >> 8) & 0xff, + ($var >> 16) & 0xff, + ($var >> 24) & 0xff, + }; + sv_setuv($arg, $var); + sv_setpvn($arg, str, 4); + SvIOK_on($arg); + } + +T_CONFIG_ERROR + if($var) + croak("invalid configuration setting: %s", config_string); |
