From: Nito Martinez Date: Fri, 16 Apr 2010 06:14:39 +0000 (+0100) Subject: Added new version of libextutils-parsexs-perl X-Git-Url: http://vcs.maemo.org/git/?a=commitdiff_plain;h=e82dc6ce300a8a50b3c699da4eac0474e003dc15;hp=e24c21bc0063c9faa720396245fb7af5e5ff0b26;p=pkg-perl Added new version of libextutils-parsexs-perl --- diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/Build.PL b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/Build.PL new file mode 100644 index 0000000..c28966e --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/Build.PL @@ -0,0 +1,45 @@ +use Module::Build; +use Config; + +my $class = Module::Build->subclass(code => <<'EOF'); + sub do_create_makefile_pl { + my $self = shift; + $self->SUPER::do_create_makefile_pl(fh => $fh); + $self->do_system(qw(perl -pi -e), q{s/'INSTALLDIRS' => '\w+'/'INSTALLDIRS' => (\$] < 5.008009 ? 'site' : 'perl')/}, 'Makefile.PL'); + } +EOF + +my $build = $class->new +( + module_name => 'ExtUtils::ParseXS', + license => 'perl', + installdirs => ($] < 5.008009 ? 'site' : 'core'), + auto_configure_requires => 0, + requires => { + 'Cwd' => 0, + 'Exporter' => 0, + 'File::Basename' => 0, + 'File::Spec' => 0, + 'Symbol' => 0, + }, + build_requires => { + 'Carp' => 0, + 'DynaLoader' => 0, + 'ExtUtils::CBuilder' => 0, + 'Test::More' => 0.47, + }, + add_to_cleanup => ["t/XSTest.c", "t/XSTest$Config{obj_ext}", "t/XSTest.$Config{dlext}"], + create_makefile_pl => 'traditional', + create_readme => 1, + meta_merge => { + resources => { + bugtracker => + 'http://rt.cpan.org/Dist/Display.html?Queue=ExtUtils-ParseXS', + MailingList => 'mailto:perl5-porters@perl.org', + repository => 'git://github.com/dagolden/extutils-parsexs.git' + } + }, +); + +$build->create_build_script; + diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/Changes b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/Changes new file mode 100644 index 0000000..6f13d50 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/Changes @@ -0,0 +1,334 @@ +Revision history for Perl extension ExtUtils::ParseXS. + +2.2202 - Wed Jan 27 15:04:59 EST 2010 + + Bug fixes: + + - The fix to IN/OUT/OUTLIST was itself broken and is now fixed. + [Reported by Serdar Dalgic; fix suggested by Rafael Garcia-Suarez] + + We apologize for the fault in the regex. Those responsible + have been sacked. + +2.2201 Mon Jan 25 16:12:05 EST 2010 + + Bug fixes: + + - IN/OUT/OUTLIST, etc. were broken due to a bad regexp. [Simon Cozens] + +2.22 - Mon Jan 11 15:00:07 EST 2010 + + No changes from 2.21_02 + +2.21_02 - Sat Dec 19 10:55:41 EST 2009 + + Bug fixes: + + - fixed bugs and added tests for INCLUDE_COMMAND [Steffen Mueller] + +2.21_01 - Sat Dec 19 07:22:44 EST 2009 + + Enhancements: + + - New 'INCLUDE_COMMAND' directive [Steffen Mueller] + + Bug fixes: + + - Workaround for empty newXS macro found in P5NCI [Goro Fuji] + +2.21 - Mon Oct 5 11:17:53 EDT 2009 + + Bug fixes: + - Adds full path in INCLUDE #line directives (RT#50198) [patch by "spb"] + + Other: + - Updated copyright and maintainer list + +2.20_07 - Sat Oct 3 11:26:55 EDT 2009 + + Bug fixes: + - Use "char* file" for perl < 5.9, not "char[] file"; fixes mod_perl + breakage due to prior attempts to fix RT#48104 [David Golden] + +2.20_06 - Fri Oct 2 23:45:45 EDT 2009 + + Bug fixes: + - Added t/typemap to fix broken test on perl 5.6.2 [David Golden] + - More prototype fixes for older perls [Goro Fuji] + - Avoid "const char *" in test files as it breaks on 5.6.2 [Goro Fuji] + + Other: + - Merged changes from 2.2004 maintenance branch (see 2.200401 to 2.200403) + [David Golden] + +2.20_05 - Sat Aug 22 21:46:56 EDT 2009 + + Bug fixes: + - Fix prototype related bugs [Goro Fuji] + - Fix the SCOPE keyword [Goro Fuji] + +2.200403 - Fri Oct 2 02:01:58 EDT 2009 + + Other: + - Removed PERL_CORE specific @INC manipulation (no longer needed) + [Nicholas Clark] + - Changed hard-coded $^H manipulation in favor of "use re 'eval'" + [Nicholas Clark] + +2.200402 - Fri Oct 2 01:26:40 EDT 2009 + + Bug fixes: + - UNITCHECK subroutines were not being called (detected in ext/XS-APItest + in Perl blead) [reported by Jesse Vincent, patched by David Golden] + +2.200401 - Mon Sep 14 22:26:03 EDT 2009 + + - No changes from 2.20_04. + + +2.20_04 - Mon Aug 10 11:18:47 EDT 2009 + + Bug fixes: + - Changed install_dirs to 'core' for 5.8.9 as well (RT#48474) + - Removed t/bugs.t until there is better C++ support in ExtUtils::CBuilder + + Other: + - Updated repository URL in META file + +2.20_03 - Thu Jul 23 23:14:50 EDT 2009 + + Bug fixes: + - Fixed "const char *" errors for 5.8.8 (and older) (RT#48104) + [Vincent Pit] + - Added newline before a preprocessor directive (RT#30673) + [patch by hjp] + +2.2002 - Sat Jul 18 17:22:27 EDT 2009 + + Bug fixes: + - Fix Makefile.PL installdirs for older perls + +2.20_01 - Wed Jul 8 12:12:47 EDT 2009 + + - Fix XSUsage prototypes for testing [Jan Dubois] + +2.20 - Wed Jul 1 13:42:11 EDT 2009 + + - No changes from 2.19_04 + +2.19_04 - Mon Jun 29 11:49:12 EDT 2009 + + - Changed tests to use Test::More and added it to prereqs + + - Some tests skip if no compiler or if no dynamic loading + + - INTERFACE keyword tests skipped for perl < 5.8 + +2.19_03 - Sat Jun 27 22:51:18 EDT 2009 + + - Released to see updated results from smoke testers + + - Fix minor doc typo pulled from blead + +2.19_02 - Wed Aug 6 22:18:33 2008 + + - Fix the usage reports to consistently report package name as well + as sub name across ALIAS, INTERFACE and regular XSUBS. [Robert May] + + - Cleaned up a warning with -Wwrite-strings that gets passed into + every parsed XS file. [Steve Peters] + + - Allow (pedantically correct) C pre-processor comments in the code + snippets of typemap files. [Nicholas Clark] + +2.19 - Sun Feb 17 14:27:40 2008 + + - Fixed the treatment of the OVERLOAD: keyword, which was causing a C + compile error. [Toshiyuki Yamato] + +2.18 - Mon Jan 29 20:56:36 2007 + + - Added some UNITCHECK stuff, which (I think) makes XS code able to + do UNITCHECK blocks. [Nicholas Clark] + + - Changed 'use re "eval";' to 'BEGIN { $^H |= 0x00200000 };' so we + can compile re.xs in bleadperl. [Yves Orton] + + - Fix an undefined-variable warning related to 'inout' parameter + processing. + +2.17 - Mon Nov 20 17:07:27 2006 + + - Stacked $filepathname to make #line directives in #INCLUDEs work. + [Nicholas Clark] + + - Sprinked dVAR in with dXSARGS, for God-(Jarkko)-knows-what + reason. [Jarkko Hietaniemi] + + - Use printf-style formats in Perl_croak() for some significant + savings in number of distinct constant strings in the linked + binaries we create. [Alexey Tourbin] + + - Don't use 'class' as a variable name in the t/XSTest.xs module, + since that's a keyword in C++. [Jarkko Hietaniemi] + +2.16 Fri Sep 15 22:33:24 CDT 2006 + + - Fix a problem with PREFIX not working inside INTERFACE + sections. [Salvador Fandin~o] + +2.15 Mon Oct 10 11:02:13 EDT 2005 + + - I accidentally left out a README from the distribution. Now it's + auto-created from the main documentation in ExtUtils/ParseXS.pm. + +2.14 Sat Oct 8 21:49:15 EDT 2005 + + - The filehandle for the .xs file was never being properly closed, + and now it is. This was causing some Win32 problems with + Module::Build's tests, which create a .xs file, process it with + ParseXS, and then try to remove it. [Spotted by Randy Sims] + +2.13 Mon Oct 3 21:59:06 CDT 2005 + + - Integrate a cleanup-related change from bleadperl that somehow + never got into this copy. [Steve Hay] + +2.12 Wed Aug 24 20:03:09 CDT 2005 + + - On Win32, there was a DLL file we create during testing that we + couldn't delete unless we closed it first, so testing failed when + the deletiong was attempted. This should now work (provided the + version of perl is high enough to have DynaLoader::dl_unload_file() + - I'm not sure what will happen otherwise). [Steve Hay] + + - Fix a spurious warning during testing about a variable that's used + before it's initialized. [Steve Hay] + +2.11 Mon Jun 13 23:00:23 CDT 2005 + + - Make some variables global, to avoid some "will not stay shared" + warnings at compile time. [Rafael Garcia-Suarez] + +2.10 Mon May 30 21:29:44 CDT 2005 + + - This module is being integrated into the perl core; the regression + tests will now work properly when run as part of the core build. + [Yitzchak Scott-Thoennes] + + - Added the ability to create output files with a suffix other than + ".c", via the new "csuffix" option. This gets the module working + on Symbian. [Jarkko Hietaniemi] + + - Added the ability to put 'extern "C"' declarations in front of + prototypes. [Jarkko Hietaniemi] + +2.09 Sun Mar 27 11:11:49 CST 2005 + + - Integrated change #18270 from the perl core, which fixed a problem + in which xsubpp can make nested comments in C code (which is + bad). [Nicholas Clark] + + - When no "MODULE ... PACKAGE ... PREFIX" line is found, it's now + still a fatal error for ParseXS, but we exit with status 0, which + is what the old xsubpp did and seems to work best with some modules + like Win32::NetAdmin. See RT ticket 11472. [Steve Hay] + +2.08 Fri Feb 20 21:41:22 CST 2004 + + - Fixed a problem with backslashes in file paths (e.g. C:\Foo\Bar.xs) + disappearing in error messages. [Randy Sims, Steve Hay] + + - Did a little minor internal code cleanup in the + ExtUtils::ParseXS::CountLines class, now other classes don't poke + around in its package variables. + +2.07 Sun Jan 25 17:01:52 CST 2004 + + - We now use ExtUtils::CBuilder for testing the compile/build phase + in the regression tests. It's not necessary to have it for runtime + usage, though. + + - Fixed a minor documentation error (look in 'Changes' for revision + history, not 'changes.pod'). [Scott R. Godin] + +2.06 Fri Dec 26 09:00:47 CST 2003 + + - Some fixes in the regression tests for the AIX platform. + +2.05 Mon Sep 29 10:33:39 CDT 2003 + + - We no longer trim the directory portions from the "#line " comments + in the generated C code. This helps cooperation with many editors' + auto-jump-to-error stuff. [Ross McFarland] + + - In some cases the PERL_UNUSED_VAR macro is needed to get rid of C + compile-time warnings in generated code. Since this eliminates so + many warnings, turning on "-Wall -W" (or your platform's + equivalent) can once again be helpful. [Ross McFarland] + + - Did a huge amount of variable-scoping cleanup, and it *still* + doesn't compile under 'use strict;'. Much progress was made + though, and many scoping issues were fixed. + +2.04 Thu Sep 4 13:10:59 CDT 2003 + + - Added a COPYRIGHT section to the documentation. [Spotted by Ville + Skytta] + +2.03 Sat Aug 16 17:49:03 CST 2003 + + - Fixed a warning that occurs if a regular expression (buried deep + within the bowels of the code here) fails. [Spotted by Michael + Schwern] + + - Fixed a testing error on Cygwin. [Reini Urban] + +2.02 Sun Mar 30 18:20:12 CST 2003 + + - Now that we know this module doesn't work (yet?) with perl 5.005, + put a couple 'use 5.006' statements in the module & Makefile.PL so + we're explicit about the dependency. [Richard Clamp] + +2.01 Thu Mar 20 08:22:36 CST 2003 + + - Allow -C++ flag for backward compatibility. It's a no-op, and has + been since perl5.003_07. [PodMaster] + +2.00 Sun Feb 23 16:40:17 CST 2003 + + - Tests now function under all three of the supported compilers on + Windows environments. [Randy W. Sims] + + - Will now install to the 'core' perl module directory instead of to + 'site_perl' or the like, because this is the only place MakeMaker + will look for the xsubpp script. + + - Explicitly untie and close the output file handle because ParseXS was + holding the file handle open, preventing the compiler from opening + it on Win32. [Randy W. Sims] + + - Added an '--output FILENAME' flag to xsubpp and changed ParseXS to use + the named file in the #line directives when the output file has an + extension other than '.c' (i.e. '.cpp'). [Randy W. Sims] + + - Added conditional definition of the PERL_UNUSED_VAR macro to the + output file in case it's not already defined for backwards + compatibility with pre-5.8 versions of perl. (Not sure if this is the + best solution.) [Randy W. Sims] + + +1.99 Wed Feb 5 10:07:47 PST 2003 + + - Version bump to 1.99 so it doesn't look like a 'beta release' to + CPAN.pm. No code changes, since I haven't had any bug reports. + + - Fixed a minor problem in the regression tests that was creating an + XSTest..o file instead of XSTest.o + + +1.98_01 Mon Dec 9 11:50:41 EST 2002 + + - Converted from ExtUtils::xsubpp in bleadperl + + - Basic set of regression tests written diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/INSTALL b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/INSTALL new file mode 100644 index 0000000..b0fb4e5 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/INSTALL @@ -0,0 +1,14 @@ + Installation instructions for ExtUtils::ParseXS + +To install this module, follow the standard steps for installing most +Perl modules: + + perl Makefile.PL + make + make test + make install + +Or you may use the CPAN.pm module, which will automatically execute +these steps for you. + + -Ken diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/MANIFEST b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/MANIFEST new file mode 100644 index 0000000..3fb93a2 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/MANIFEST @@ -0,0 +1,24 @@ +Build.PL +Changes +INSTALL +lib/ExtUtils/ParseXS.pm +lib/ExtUtils/xsubpp +Makefile.PL +MANIFEST +META.yml Module meta-data (added by MakeMaker) +README +t/basic.t +t/bugs/RT48104.xs +t/bugs/typemap +t/include/nscore.h +t/include/nsUniversalDetector.h +t/lib/IncludeTester.pm +t/more.t +t/typemap +t/usage.t +t/XSInclude.xsh +t/XSMore.xs +t/XSTest.pm +t/XSTest.xs +t/XSUsage.pm +t/XSUsage.xs diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/META.yml b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/META.yml new file mode 100644 index 0000000..cfcc905 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/META.yml @@ -0,0 +1,32 @@ +--- +abstract: 'converts Perl XS code into C code' +author: + - 'Ken Williams, ' + - 'David Golden, ' +build_requires: + Carp: 0 + DynaLoader: 0 + ExtUtils::CBuilder: 0 + Test::More: 0.47 +generated_by: 'Module::Build version 0.3603' +license: perl +meta-spec: + url: http://module-build.sourceforge.net/META-spec-v1.4.html + version: 1.4 +name: ExtUtils-ParseXS +provides: + ExtUtils::ParseXS: + file: lib/ExtUtils/ParseXS.pm + version: 2.2202 +requires: + Cwd: 0 + Exporter: 0 + File::Basename: 0 + File::Spec: 0 + Symbol: 0 +resources: + MailingList: mailto:perl5-porters@perl.org + bugtracker: http://rt.cpan.org/Dist/Display.html?Queue=ExtUtils-ParseXS + license: http://dev.perl.org/licenses/ + repository: git://github.com/dagolden/extutils-parsexs.git +version: 2.2202 diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/Makefile.PL b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/Makefile.PL new file mode 100644 index 0000000..405fb66 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/Makefile.PL @@ -0,0 +1,22 @@ +# Note: this file was auto-generated by Module::Build::Compat version 0.3603 +use ExtUtils::MakeMaker; +WriteMakefile +( + 'NAME' => 'ExtUtils::ParseXS', + 'VERSION_FROM' => 'lib/ExtUtils/ParseXS.pm', + 'PREREQ_PM' => { + 'Carp' => 0, + 'Cwd' => 0, + 'DynaLoader' => 0, + 'Exporter' => 0, + 'ExtUtils::CBuilder' => 0, + 'File::Basename' => 0, + 'File::Spec' => 0, + 'Symbol' => 0, + 'Test::More' => '0.47' + }, + 'INSTALLDIRS' => ($] < 5.008009 ? 'site' : 'perl'), + 'EXE_FILES' => [], + 'PL_FILES' => {} + ) +; diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/README b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/README new file mode 100644 index 0000000..8cfd0b4 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/README @@ -0,0 +1,113 @@ +NAME + ExtUtils::ParseXS - converts Perl XS code into C code + +SYNOPSIS + use ExtUtils::ParseXS qw(process_file); + + process_file( filename => 'foo.xs' ); + + process_file( filename => 'foo.xs', + output => 'bar.c', + 'C++' => 1, + typemap => 'path/to/typemap', + hiertype => 1, + except => 1, + prototypes => 1, + versioncheck => 1, + linenumbers => 1, + optimize => 1, + prototypes => 1, + ); + =head1 DESCRIPTION + + `ExtUtils::ParseXS' will compile XS code into C code by embedding the + constructs necessary to let C functions manipulate Perl values and + creates the glue necessary to let Perl access those functions. The + compiler uses typemaps to determine how to map C function parameters and + variables to Perl values. + + The compiler will search for typemap files called *typemap*. It will use + the following search path to find default typemaps, with the rightmost + typemap taking precedence. + + ../../../typemap:../../typemap:../typemap:typemap + +EXPORT + None by default. `process_file()' may be exported upon request. + +FUNCTIONS + process_xs() + This function processes an XS file and sends output to a C file. + Named parameters control how the processing is done. The following + parameters are accepted: + + C++ Adds `extern "C"' to the C code. Default is false. + + hiertype + Retains `::' in type names so that C++ hierachical types can be + mapped. Default is false. + + except + Adds exception handling stubs to the C code. Default is false. + + typemap + Indicates that a user-supplied typemap should take precedence + over the default typemaps. A single typemap may be specified as + a string, or multiple typemaps can be specified in an array + reference, with the last typemap having the highest precedence. + + prototypes + Generates prototype code for all xsubs. Default is false. + + versioncheck + Makes sure at run time that the object file (derived from the + `.xs' file) and the `.pm' files have the same version number. + Default is true. + + linenumbers + Adds `#line' directives to the C output so error messages will + look like they came from the original XS file. Default is true. + + optimize + Enables certain optimizations. The only optimization that is + currently affected is the use of *target*s by the output C code + (see perlguts). Not optimizing may significantly slow down the + generated code, but this is the way xsubpp of 5.005 and earlier + operated. Default is to optimize. + + inout + Enable recognition of `IN', `OUT_LIST' and `INOUT_LIST' + declarations. Default is true. + + argtypes + Enable recognition of ANSI-like descriptions of function + signature. Default is true. + + s I have no clue what this does. Strips function prefixes? + + errors() + This function returns the number of [a certain kind of] errors + encountered during processing of the XS file. + +AUTHOR + Based on xsubpp code, written by Larry Wall. + + Maintained by: + + * Ken Williams, + + * David Golden, + +COPYRIGHT + Copyright 2002-2009 by Ken Williams, David Golden and other + contributors. All rights reserved. + + This library is free software; you can redistribute it and/or modify it + under the same terms as Perl itself. + + Based on the ExtUtils::xsubpp code by Larry Wall and the Perl 5 Porters, + which was released under the same license terms. + +SEE ALSO + perl, ExtUtils::xsubpp, ExtUtils::MakeMaker, perlxs, perlxstut. + diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/debian/changelog b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/debian/changelog new file mode 100644 index 0000000..f540f7d --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/debian/changelog @@ -0,0 +1,192 @@ +libextutils-parsexs-perl (2.220200-1maemo1) fremantle; urgency=low + + * New Maemo packaging + + -- Nito Martinez Fri, 16 Apr 2010 07:12:39 +0100 + + +libextutils-parsexs-perl (2.220200-1) unstable; urgency=low + + * New upstream release + * Standards-Version 3.8.4 (no changes) + + -- Jonathan Yu Fri, 29 Jan 2010 21:35:03 -0500 + +libextutils-parsexs-perl (2.220100-1) unstable; urgency=low + + * New upstream release + * Update copyright to new DEP5 format + + -- Jonathan Yu Tue, 26 Jan 2010 21:28:55 -0500 + +libextutils-parsexs-perl (2.220000-1) unstable; urgency=low + + * New upstream release + + -- Jonathan Yu Tue, 12 Jan 2010 10:13:33 -0500 + +libextutils-parsexs-perl (2.210000-1) unstable; urgency=low + + [ Jonathan Yu ] + * New upstream release + + [ gregor herrmann ] + * debian/copyright: update upstream copyright. + + -- Jonathan Yu Sun, 18 Oct 2009 15:07:41 -0400 + +libextutils-parsexs-perl (2.200403-1) unstable; urgency=low + + [ Jonathan Yu ] + * New upstream release + + [ Ryan Niebur ] + * Update jawnsy's email address + + -- Jonathan Yu Fri, 02 Oct 2009 09:28:35 -0400 + +libextutils-parsexs-perl (2.2002-1) unstable; urgency=low + + [ Jonathan Yu ] + * New upstream release + + Fix XSUsage prototypes -- xsusage_{five,six} take an int parameter + + [ Damyan Ivanov ] + * add uversionmangle to force four digits after the dot + Closes: #542019 -- version numbering + * Standards-Version: 3.8.3 + - drop the version from the perl build-dependency (already covered by + oldstable) + * add myself to Uploaders + + -- Damyan Ivanov Fri, 21 Aug 2009 10:42:21 +0300 + +libextutils-parsexs-perl (2.20-1) unstable; urgency=low + + * New upstream release + + Various bug fixes + + Added test for using an XS library + + Now depends on Test::More 0.47, oldstable has 0.62 + * Standards-Version 3.8.2 + * Added /me to Uploaders and Copyright + * Updated copyright statements + * No longer needs Module::Build, Makefile.PL is traditional + * Rewrote control description + * Bumped debhelper dependency to 7; use the short rules style + + [ gregor herrmann ] + * debian/control: Changed: Switched Vcs-Browser field to ViewSVN + (source stanza). + * Remove Florian Ragwitz from Uploaders (closes: #523285). + + [ Nathan Handler ] + * debian/watch: Update to ignore development releases. + + [ gregor herrmann ] + * debian/copyright: list contributors instead of group for debian/*. + + -- Jonathan Yu Fri, 03 Jul 2009 16:18:13 -0400 + +libextutils-parsexs-perl (2.19-1) unstable; urgency=low + + [ gregor herrmann ] + * Take over for the Debian Perl Group with maintainer's permission + (http://lists.debian.org/debian-perl/2008/06/msg00039.html) + * debian/control: Added: Vcs-Svn field (source stanza); Vcs-Browser + field (source stanza); Homepage field (source stanza). Changed: + Maintainer set to Debian Perl Group (was: Florian Ragwitz + ); Florian Ragwitz moved to + Uploaders. + * Add debian/watch. + + [ AGOSTINI Yves ] + * upgrade to new upstream 2.19 (Closes: #485441, #485419) + * add me to uploaders + * Standards-Version: 3.8.0 (no changes) + * refresh rules with architecture independent rules + * debian/control: add libmodule-build-perl in Build-Depends + * debian/copyright: Proposals/CopyrightFormat rev=102, add Perl Group + + -- AGOSTINI Yves Sun, 15 Jun 2008 21:05:53 +0200 + +libextutils-parsexs-perl (2.15-2) unstable; urgency=low + + * Use Makefile.PL instead of Build.PL. + * Remove libmodule-build-perl dependency (Closes: #385354). + * Bump-up Standards-Version to 3.7.2 (no changes). + * Use DH_COMPAT 5. + + -- Florian Ragwitz Sat, 2 Sep 2006 15:21:03 +0200 + +libextutils-parsexs-perl (2.15-1) unstable; urgency=low + + * New upstream release (Closes: #329536). + * New Maintainer with the acknowledgement from the former one. + * Cleaned up debian/rules. + * Bumped up Standards-Version. + + -- Florian Ragwitz Fri, 27 Jan 2006 03:23:19 +0100 + +libextutils-parsexs-perl (2.09-2) unstable; urgency=low + + * Change to "Architecture: all". (dh-make-perl was fooled by an xs file + that's used only for testing.) + + -- Chip Salzenberg Thu, 7 Apr 2005 19:19:12 -0400 + +libextutils-parsexs-perl (2.09-1) unstable; urgency=low + + * New upstream release. + > Apparently fixes FTBTS on amd64. (closes: #277591) + + -- Chip Salzenberg Tue, 5 Apr 2005 08:25:04 -0400 + +libextutils-parsexs-perl (2.05-2) unstable; urgency=high + + * Fix Build-Depends by deleting my hacked dpkg-source. + + -- Chip Salzenberg Sun, 5 Oct 2003 21:42:32 -0400 + +libextutils-parsexs-perl (2.05-1) unstable; urgency=low + + * New upstream release. + * Expand package description. (closes: #209710) + + -- Chip Salzenberg Fri, 3 Oct 2003 19:11:49 -0400 + +libextutils-parsexs-perl (2.02-3) unstable; urgency=medium + + * Link test program with $Config{perllibs} instead of $Config{libs}, + so build no longer needs libdb-dev and libgdbm-dev. Adjust control + accordingly. + + -- Chip Salzenberg Sun, 27 Jul 2003 11:27:52 -0400 + +libextutils-parsexs-perl (2.02-2) unstable; urgency=low + + * Changed section from interpreters to perl. + * Changed Build-Depends to be Build-Depends-Indep, fixes lintian warning. + * Changed perl depends from hard number to ${perl:Depends}. + * Expanded Description field from upstream docs. + * Upped Standards-Version to 3.6.0. + * Use debhelper v4 (Depends in control, DH_COMPAT in rules). + * Remove unused directories from package. + * Use module test when building (requires libgdbm-dev as build dep). + (All above from Jay Bonci , thanks much) + * Install xsubpp substitute in examples, not where the libs are. + + -- Chip Salzenberg Fri, 25 Jul 2003 14:54:19 -0400 + +libextutils-parsexs-perl (2.02-1) unstable; urgency=low + + * New upstream release. + + -- Chip Salzenberg Thu, 24 Jul 2003 17:58:06 -0400 + +libextutils-parsexs-perl (1.99-1) unstable; urgency=low + + * Initial Release. + + -- Chip Salzenberg Sat, 15 Feb 2003 16:06:56 -0500 + diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/debian/compat b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/debian/compat new file mode 100644 index 0000000..7f8f011 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/debian/compat @@ -0,0 +1 @@ +7 diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/debian/control b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/debian/control new file mode 100644 index 0000000..7006f56 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/debian/control @@ -0,0 +1,22 @@ +Source: libextutils-parsexs-perl +Section: perl +Priority: optional +Build-Depends: debhelper7 +Build-Depends-Indep: perl, libextutils-cbuilder-perl +Maintainer: Debian Perl Group +Uploaders: AGOSTINI Yves , + Jonathan Yu , Damyan Ivanov +Standards-Version: 3.8.4 +Homepage: http://search.cpan.org/dist/ExtUtils-ParseXS/ +Vcs-Svn: svn://svn.debian.org/pkg-perl/trunk/libextutils-parsexs-perl/ +Vcs-Browser: http://svn.debian.org/viewsvn/pkg-perl/trunk/libextutils-parsexs-perl/ + +Package: libextutils-parsexs-perl +Architecture: all +Depends: ${perl:Depends}, ${misc:Depends}, libextutils-cbuilder-perl +Description: Perl utility to process Perl XS code into C code + ExtUtils::ParseXS provides a modular way of compiling Perl XS code into the + appropriate C code by embedding the constructs necessary to let C functions + manipulate Perl values and creating the glue necessary to let Perl access + those functions. It is functionally similar to the "xsubpp" program included + with perl and in fact provides a drop-in replacement for it. diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/debian/copyright b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/debian/copyright new file mode 100644 index 0000000..71ce6b5 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/debian/copyright @@ -0,0 +1,33 @@ +Format-Specification: http://svn.debian.org/wsvn/dep/web/deps/dep5.mdwn?op=file&rev=135 +Maintainer: David Golden +Source: http://search.cpan.org/dist/ExtUtils-ParseXS/ +Name: ExtUtils-ParseXS + +Files: * +Copyright: 2002-2009, David Golden + 2002-2009, Ken Williams +License: Artistic or GPL-1+ + +Files: debian/* +Copyright: 2009-2010, Jonathan Yu + 2009, Damyan Ivanov + 2008, AGOSTINI Yves + 2006, Florian Ragwitz + 2003-2005, Chip Salzenberg +License: Artistic or GPL-1+ + +License: Artistic + This program is free software; you can redistribute it and/or modify + it under the terms of the Artistic License, which comes with Perl. + . + On Debian GNU/Linux systems, the complete text of the Artistic License + can be found in `/usr/share/common-licenses/Artistic' + +License: GPL-1+ + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 1, or (at your option) + any later version. + . + On Debian GNU/Linux systems, the complete text of the GNU General + Public License can be found in `/usr/share/common-licenses/GPL' diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/debian/rules b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/debian/rules new file mode 100755 index 0000000..2d33f6a --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/debian/rules @@ -0,0 +1,4 @@ +#!/usr/bin/make -f + +%: + dh $@ diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/debian/watch b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/debian/watch new file mode 100644 index 0000000..ebd3e4c --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/debian/watch @@ -0,0 +1,5 @@ +version=3 + +opts="uversionmangle=s/\.\d\d$/$&0000/;s/\.\d\d\d\d$/$&00/" \ + http://search.cpan.org/dist/ExtUtils-ParseXS/ \ + .*/ExtUtils-ParseXS-v?(\d[\d.-]+)\.(?:tar(?:\.gz|\.bz2)?|tgz|zip)$ diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/lib/ExtUtils/ParseXS.pm b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/lib/ExtUtils/ParseXS.pm new file mode 100644 index 0000000..1bc3f22 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/lib/ExtUtils/ParseXS.pm @@ -0,0 +1,2170 @@ +package ExtUtils::ParseXS; + +use 5.006; # We use /??{}/ in regexes +use Cwd; +use Config; +use File::Basename; +use File::Spec; +use Symbol; + +require Exporter; + +@ISA = qw(Exporter); +@EXPORT_OK = qw(process_file); + +# use strict; # One of these days... + +my(@XSStack); # Stack of conditionals and INCLUDEs +my($XSS_work_idx, $cpp_next_tmp); + +use vars qw($VERSION); +$VERSION = '2.2202'; +$VERSION = eval $VERSION if $VERSION =~ /_/; + +use vars qw(%input_expr %output_expr $ProtoUsed @InitFileCode $FH $proto_re $Overload $errors $Fallback + $cplusplus $hiertype $WantPrototypes $WantVersionChk $except $WantLineNumbers + $WantOptimize $process_inout $process_argtypes @tm + $dir $filename $filepathname %IncludedFiles + %type_kind %proto_letter + %targetable $BLOCK_re $lastline $lastline_no + $Package $Prefix @line @BootCode %args_match %defaults %var_types %arg_list @proto_arg + $processing_arg_with_types %argtype_seen @outlist %in_out %lengthof + $proto_in_this_xsub $scope_in_this_xsub $interface $prepush_done $interface_macro $interface_macro_set + $ProtoThisXSUB $ScopeThisXSUB $xsreturn + @line_no $ret_type $func_header $orig_args + ); # Add these just to get compilation to happen. + + +sub process_file { + + # Allow for $package->process_file(%hash) in the future + my ($pkg, %args) = @_ % 2 ? @_ : (__PACKAGE__, @_); + + $ProtoUsed = exists $args{prototypes}; + + # Set defaults. + %args = ( + # 'C++' => 0, # Doesn't seem to *do* anything... + hiertype => 0, + except => 0, + prototypes => 0, + versioncheck => 1, + linenumbers => 1, + optimize => 1, + prototypes => 0, + inout => 1, + argtypes => 1, + typemap => [], + output => \*STDOUT, + csuffix => '.c', + %args, + ); + + # Global Constants + + my ($Is_VMS, $SymSet); + if ($^O eq 'VMS') { + $Is_VMS = 1; + # Establish set of global symbols with max length 28, since xsubpp + # will later add the 'XS_' prefix. + require ExtUtils::XSSymSet; + $SymSet = new ExtUtils::XSSymSet 28; + } + @XSStack = ({type => 'none'}); + ($XSS_work_idx, $cpp_next_tmp) = (0, "XSubPPtmpAAAA"); + @InitFileCode = (); + $FH = Symbol::gensym(); + $proto_re = "[" . quotemeta('\$%&*@;[]') . "]" ; + $Overload = 0; + $errors = 0; + $Fallback = '&PL_sv_undef'; + + # Most of the 1500 lines below uses these globals. We'll have to + # clean this up sometime, probably. For now, we just pull them out + # of %args. -Ken + + $cplusplus = $args{'C++'}; + $hiertype = $args{hiertype}; + $WantPrototypes = $args{prototypes}; + $WantVersionChk = $args{versioncheck}; + $except = $args{except} ? ' TRY' : ''; + $WantLineNumbers = $args{linenumbers}; + $WantOptimize = $args{optimize}; + $process_inout = $args{inout}; + $process_argtypes = $args{argtypes}; + @tm = ref $args{typemap} ? @{$args{typemap}} : ($args{typemap}); + + for ($args{filename}) { + die "Missing required parameter 'filename'" unless $_; + $filepathname = $_; + ($dir, $filename) = (dirname($_), basename($_)); + $filepathname =~ s/\\/\\\\/g; + $IncludedFiles{$_}++; + } + + # Open the input file + open($FH, $args{filename}) or die "cannot open $args{filename}: $!\n"; + + # Open the output file if given as a string. If they provide some + # other kind of reference, trust them that we can print to it. + if (not ref $args{output}) { + open my($fh), "> $args{output}" or die "Can't create $args{output}: $!"; + $args{outfile} = $args{output}; + $args{output} = $fh; + } + + # Really, we shouldn't have to chdir() or select() in the first + # place. For now, just save & restore. + my $orig_cwd = cwd(); + my $orig_fh = select(); + + chdir($dir); + my $pwd = cwd(); + my $csuffix = $args{csuffix}; + + if ($WantLineNumbers) { + my $cfile; + if ( $args{outfile} ) { + $cfile = $args{outfile}; + } else { + $cfile = $args{filename}; + $cfile =~ s/\.xs$/$csuffix/i or $cfile .= $csuffix; + } + tie(*PSEUDO_STDOUT, 'ExtUtils::ParseXS::CountLines', $cfile, $args{output}); + select PSEUDO_STDOUT; + } else { + select $args{output}; + } + + foreach my $typemap (@tm) { + die "Can't find $typemap in $pwd\n" unless -r $typemap; + } + + push @tm, standard_typemap_locations(); + + foreach my $typemap (@tm) { + next unless -f $typemap ; + # skip directories, binary files etc. + warn("Warning: ignoring non-text typemap file '$typemap'\n"), next + unless -T $typemap ; + open(TYPEMAP, $typemap) + or warn ("Warning: could not open typemap file '$typemap': $!\n"), next; + my $mode = 'Typemap'; + my $junk = "" ; + my $current = \$junk; + while () { + next if /^\s* #/; + my $line_no = $. + 1; + if (/^INPUT\s*$/) { + $mode = 'Input'; $current = \$junk; next; + } + if (/^OUTPUT\s*$/) { + $mode = 'Output'; $current = \$junk; next; + } + if (/^TYPEMAP\s*$/) { + $mode = 'Typemap'; $current = \$junk; next; + } + if ($mode eq 'Typemap') { + chomp; + my $line = $_ ; + TrimWhitespace($_) ; + # skip blank lines and comment lines + next if /^$/ or /^#/ ; + my($type,$kind, $proto) = /^\s*(.*?\S)\s+(\S+)\s*($proto_re*)\s*$/ or + warn("Warning: File '$typemap' Line $. '$line' TYPEMAP entry needs 2 or 3 columns\n"), next; + $type = TidyType($type) ; + $type_kind{$type} = $kind ; + # prototype defaults to '$' + $proto = "\$" unless $proto ; + warn("Warning: File '$typemap' Line $. '$line' Invalid prototype '$proto'\n") + unless ValidProtoString($proto) ; + $proto_letter{$type} = C_string($proto) ; + } elsif (/^\s/) { + $$current .= $_; + } elsif ($mode eq 'Input') { + s/\s+$//; + $input_expr{$_} = ''; + $current = \$input_expr{$_}; + } else { + s/\s+$//; + $output_expr{$_} = ''; + $current = \$output_expr{$_}; + } + } + close(TYPEMAP); + } + + foreach my $value (values %input_expr) { + $value =~ s/;*\s+\z//; + # Move C pre-processor instructions to column 1 to be strictly ANSI + # conformant. Some pre-processors are fussy about this. + $value =~ s/^\s+#/#/mg; + } + foreach my $value (values %output_expr) { + # And again. + $value =~ s/^\s+#/#/mg; + } + + my ($cast, $size); + our $bal = qr[(?:(?>[^()]+)|\((??{ $bal })\))*]; # ()-balanced + $cast = qr[(?:\(\s*SV\s*\*\s*\)\s*)?]; # Optional (SV*) cast + $size = qr[,\s* (??{ $bal }) ]x; # Third arg (to setpvn) + + foreach my $key (keys %output_expr) { + # We can still bootstrap compile 're', because in code re.pm is + # available to miniperl, and does not attempt to load the XS code. + use re 'eval'; + + my ($t, $with_size, $arg, $sarg) = + ($output_expr{$key} =~ + m[^ \s+ sv_set ( [iunp] ) v (n)? # Type, is_setpvn + \s* \( \s* $cast \$arg \s* , + \s* ( (??{ $bal }) ) # Set from + ( (??{ $size }) )? # Possible sizeof set-from + \) \s* ; \s* $ + ]x); + $targetable{$key} = [$t, $with_size, $arg, $sarg] if $t; + } + + my $END = "!End!\n\n"; # "impossible" keyword (multiple newline) + + # Match an XS keyword + $BLOCK_re= '\s*(' . join('|', qw( + REQUIRE BOOT CASE PREINIT INPUT INIT CODE PPCODE + OUTPUT CLEANUP ALIAS ATTRS PROTOTYPES PROTOTYPE + VERSIONCHECK INCLUDE INCLUDE_COMMAND SCOPE INTERFACE + INTERFACE_MACRO C_ARGS POSTCALL OVERLOAD FALLBACK + )) . "|$END)\\s*:"; + + + our ($C_group_rex, $C_arg); + # Group in C (no support for comments or literals) + $C_group_rex = qr/ [({\[] + (?: (?> [^()\[\]{}]+ ) | (??{ $C_group_rex }) )* + [)}\]] /x ; + # Chunk in C without comma at toplevel (no comments): + $C_arg = qr/ (?: (?> [^()\[\]{},"']+ ) + | (??{ $C_group_rex }) + | " (?: (?> [^\\"]+ ) + | \\. + )* " # String literal + | ' (?: (?> [^\\']+ ) | \\. )* ' # Char literal + )* /xs; + + # Identify the version of xsubpp used + print <) { + if (/^=/) { + my $podstartline = $.; + do { + if (/^=cut\s*$/) { + # We can't just write out a /* */ comment, as our embedded + # POD might itself be in a comment. We can't put a /**/ + # comment inside #if 0, as the C standard says that the source + # file is decomposed into preprocessing characters in the stage + # before preprocessing commands are executed. + # I don't want to leave the text as barewords, because the spec + # isn't clear whether macros are expanded before or after + # preprocessing commands are executed, and someone pathological + # may just have defined one of the 3 words as a macro that does + # something strange. Multiline strings are illegal in C, so + # the "" we write must be a string literal. And they aren't + # concatenated until 2 steps later, so we are safe. + # - Nicholas Clark + print("#if 0\n \"Skipped embedded POD.\"\n#endif\n"); + printf("#line %d \"$filepathname\"\n", $. + 1) + if $WantLineNumbers; + next firstmodule + } + + } while (<$FH>); + # At this point $. is at end of file so die won't state the start + # of the problem, and as we haven't yet read any lines &death won't + # show the correct line in the message either. + die ("Error: Unterminated pod in $filename, line $podstartline\n") + unless $lastline; + } + last if ($Package, $Prefix) = + /^MODULE\s*=\s*[\w:]+(?:\s+PACKAGE\s*=\s*([\w:]+))?(?:\s+PREFIX\s*=\s*(\S+))?\s*$/; + + print $_; + } + unless (defined $_) { + warn "Didn't find a 'MODULE ... PACKAGE ... PREFIX' line\n"; + exit 0; # Not a fatal error for the caller process + } + + print 'ExtUtils::ParseXS::CountLines'->end_marker, "\n" if $WantLineNumbers; + + print <<"EOF"; +#ifndef PERL_UNUSED_VAR +# define PERL_UNUSED_VAR(var) if (0) var = var +#endif + +EOF + + print <<"EOF"; +#ifndef PERL_ARGS_ASSERT_CROAK_XS_USAGE +#define PERL_ARGS_ASSERT_CROAK_XS_USAGE assert(cv); assert(params) + +/* prototype to pass -Wmissing-prototypes */ +STATIC void +S_croak_xs_usage(pTHX_ const CV *const cv, const char *const params); + +STATIC void +S_croak_xs_usage(pTHX_ const CV *const cv, const char *const params) +{ + const GV *const gv = CvGV(cv); + + PERL_ARGS_ASSERT_CROAK_XS_USAGE; + + if (gv) { + const char *const gvname = GvNAME(gv); + const HV *const stash = GvSTASH(gv); + const char *const hvname = stash ? HvNAME(stash) : NULL; + + if (hvname) + Perl_croak(aTHX_ "Usage: %s::%s(%s)", hvname, gvname, params); + else + Perl_croak(aTHX_ "Usage: %s(%s)", gvname, params); + } else { + /* Pants. I don't think that it should be possible to get here. */ + Perl_croak(aTHX_ "Usage: CODE(0x%"UVxf")(%s)", PTR2UV(cv), params); + } +} +#undef PERL_ARGS_ASSERT_CROAK_XS_USAGE + +#ifdef PERL_IMPLICIT_CONTEXT +#define croak_xs_usage(a,b) S_croak_xs_usage(aTHX_ a,b) +#else +#define croak_xs_usage S_croak_xs_usage +#endif + +#endif + +/* NOTE: the prototype of newXSproto() is different in versions of perls, + * so we define a portable version of newXSproto() + */ +#ifdef newXS_flags +#define newXSproto_portable(name, c_impl, file, proto) newXS_flags(name, c_impl, file, proto, 0) +#else +#define newXSproto_portable(name, c_impl, file, proto) (PL_Sv=(SV*)newXS(name, c_impl, file), sv_setpv(PL_Sv, proto), (CV*)PL_Sv) +#endif /* !defined(newXS_flags) */ + +EOF + + print 'ExtUtils::ParseXS::CountLines'->end_marker, "\n" if $WantLineNumbers; + + $lastline = $_; + $lastline_no = $.; + + PARAGRAPH: + while (fetch_para()) { + # Print initial preprocessor statements and blank lines + while (@line && $line[0] !~ /^[^\#]/) { + my $line = shift(@line); + print $line, "\n"; + next unless $line =~ /^\#\s*((if)(?:n?def)?|elsif|else|endif)\b/; + my $statement = $+; + if ($statement eq 'if') { + $XSS_work_idx = @XSStack; + push(@XSStack, {type => 'if'}); + } else { + death ("Error: `$statement' with no matching `if'") + if $XSStack[-1]{type} ne 'if'; + if ($XSStack[-1]{varname}) { + push(@InitFileCode, "#endif\n"); + push(@BootCode, "#endif"); + } + + my(@fns) = keys %{$XSStack[-1]{functions}}; + if ($statement ne 'endif') { + # Hide the functions defined in other #if branches, and reset. + @{$XSStack[-1]{other_functions}}{@fns} = (1) x @fns; + @{$XSStack[-1]}{qw(varname functions)} = ('', {}); + } else { + my($tmp) = pop(@XSStack); + 0 while (--$XSS_work_idx + && $XSStack[$XSS_work_idx]{type} ne 'if'); + # Keep all new defined functions + push(@fns, keys %{$tmp->{other_functions}}); + @{$XSStack[$XSS_work_idx]{functions}}{@fns} = (1) x @fns; + } + } + } + + next PARAGRAPH unless @line; + + if ($XSS_work_idx && !$XSStack[$XSS_work_idx]{varname}) { + # We are inside an #if, but have not yet #defined its xsubpp variable. + print "#define $cpp_next_tmp 1\n\n"; + push(@InitFileCode, "#if $cpp_next_tmp\n"); + push(@BootCode, "#if $cpp_next_tmp"); + $XSStack[$XSS_work_idx]{varname} = $cpp_next_tmp++; + } + + death ("Code is not inside a function" + ." (maybe last function was ended by a blank line " + ." followed by a statement on column one?)") + if $line[0] =~ /^\s/; + + my ($class, $externC, $static, $ellipsis, $wantRETVAL, $RETVAL_no_return); + my (@fake_INPUT_pre); # For length(s) generated variables + my (@fake_INPUT); + + # initialize info arrays + undef(%args_match); + undef(%var_types); + undef(%defaults); + undef(%arg_list) ; + undef(@proto_arg) ; + undef($processing_arg_with_types) ; + undef(%argtype_seen) ; + undef(@outlist) ; + undef(%in_out) ; + undef(%lengthof) ; + undef($proto_in_this_xsub) ; + undef($scope_in_this_xsub) ; + undef($interface); + undef($prepush_done); + $interface_macro = 'XSINTERFACE_FUNC' ; + $interface_macro_set = 'XSINTERFACE_FUNC_SET' ; + $ProtoThisXSUB = $WantPrototypes ; + $ScopeThisXSUB = 0; + $xsreturn = 0; + + $_ = shift(@line); + while (my $kwd = check_keyword("REQUIRE|PROTOTYPES|FALLBACK|VERSIONCHECK|INCLUDE(?:_COMMAND)?|SCOPE")) { + &{"${kwd}_handler"}() ; + next PARAGRAPH unless @line ; + $_ = shift(@line); + } + + if (check_keyword("BOOT")) { + &check_cpp; + push (@BootCode, "#line $line_no[@line_no - @line] \"$filepathname\"") + if $WantLineNumbers && $line[0] !~ /^\s*#\s*line\b/; + push (@BootCode, @line, "") ; + next PARAGRAPH ; + } + + + # extract return type, function name and arguments + ($ret_type) = TidyType($_); + $RETVAL_no_return = 1 if $ret_type =~ s/^NO_OUTPUT\s+//; + + # Allow one-line ANSI-like declaration + unshift @line, $2 + if $process_argtypes + and $ret_type =~ s/^(.*?\w.*?)\s*\b(\w+\s*\(.*)/$1/s; + + # a function definition needs at least 2 lines + blurt ("Error: Function definition too short '$ret_type'"), next PARAGRAPH + unless @line ; + + $externC = 1 if $ret_type =~ s/^extern "C"\s+//; + $static = 1 if $ret_type =~ s/^static\s+//; + + $func_header = shift(@line); + blurt ("Error: Cannot parse function definition from '$func_header'"), next PARAGRAPH + unless $func_header =~ /^(?:([\w:]*)::)?(\w+)\s*\(\s*(.*?)\s*\)\s*(const)?\s*(;\s*)?$/s; + + ($class, $func_name, $orig_args) = ($1, $2, $3) ; + $class = "$4 $class" if $4; + ($pname = $func_name) =~ s/^($Prefix)?/$Packprefix/; + ($clean_func_name = $func_name) =~ s/^$Prefix//; + $Full_func_name = "${Packid}_$clean_func_name"; + if ($Is_VMS) { + $Full_func_name = $SymSet->addsym($Full_func_name); + } + + # Check for duplicate function definition + for my $tmp (@XSStack) { + next unless defined $tmp->{functions}{$Full_func_name}; + Warn("Warning: duplicate function definition '$clean_func_name' detected"); + last; + } + $XSStack[$XSS_work_idx]{functions}{$Full_func_name} ++ ; + %XsubAliases = %XsubAliasValues = %Interfaces = @Attributes = (); + $DoSetMagic = 1; + + $orig_args =~ s/\\\s*/ /g; # process line continuations + my @args; + + my %only_C_inlist; # Not in the signature of Perl function + if ($process_argtypes and $orig_args =~ /\S/) { + my $args = "$orig_args ,"; + if ($args =~ /^( (??{ $C_arg }) , )* $ /x) { + @args = ($args =~ /\G ( (??{ $C_arg }) ) , /xg); + for ( @args ) { + s/^\s+//; + s/\s+$//; + my ($arg, $default) = / ( [^=]* ) ( (?: = .* )? ) /x; + my ($pre, $name) = ($arg =~ /(.*?) \s* + \b ( \w+ | length\( \s*\w+\s* \) ) + \s* $ /x); + next unless defined($pre) && length($pre); + my $out_type = ''; + my $inout_var; + if ($process_inout and s/^(IN|IN_OUTLIST|OUTLIST|OUT|IN_OUT)\b\s*//) { + my $type = $1; + $out_type = $type if $type ne 'IN'; + $arg =~ s/^(IN|IN_OUTLIST|OUTLIST|OUT|IN_OUT)\b\s*//; + $pre =~ s/^(IN|IN_OUTLIST|OUTLIST|OUT|IN_OUT)\b\s*//; + } + my $islength; + if ($name =~ /^length\( \s* (\w+) \s* \)\z/x) { + $name = "XSauto_length_of_$1"; + $islength = 1; + die "Default value on length() argument: `$_'" + if length $default; + } + if (length $pre or $islength) { # Has a type + if ($islength) { + push @fake_INPUT_pre, $arg; + } else { + push @fake_INPUT, $arg; + } + # warn "pushing '$arg'\n"; + $argtype_seen{$name}++; + $_ = "$name$default"; # Assigns to @args + } + $only_C_inlist{$_} = 1 if $out_type eq "OUTLIST" or $islength; + push @outlist, $name if $out_type =~ /OUTLIST$/; + $in_out{$name} = $out_type if $out_type; + } + } else { + @args = split(/\s*,\s*/, $orig_args); + Warn("Warning: cannot parse argument list '$orig_args', fallback to split"); + } + } else { + @args = split(/\s*,\s*/, $orig_args); + for (@args) { + if ($process_inout and s/^(IN|IN_OUTLIST|OUTLIST|IN_OUT|OUT)\b\s*//) { + my $out_type = $1; + next if $out_type eq 'IN'; + $only_C_inlist{$_} = 1 if $out_type eq "OUTLIST"; + push @outlist, $name if $out_type =~ /OUTLIST$/; + $in_out{$_} = $out_type; + } + } + } + if (defined($class)) { + my $arg0 = ((defined($static) or $func_name eq 'new') + ? "CLASS" : "THIS"); + unshift(@args, $arg0); + } + my $extra_args = 0; + @args_num = (); + $num_args = 0; + my $report_args = ''; + foreach my $i (0 .. $#args) { + if ($args[$i] =~ s/\.\.\.//) { + $ellipsis = 1; + if ($args[$i] eq '' && $i == $#args) { + $report_args .= ", ..."; + pop(@args); + last; + } + } + if ($only_C_inlist{$args[$i]}) { + push @args_num, undef; + } else { + push @args_num, ++$num_args; + $report_args .= ", $args[$i]"; + } + if ($args[$i] =~ /^([^=]*[^\s=])\s*=\s*(.*)/s) { + $extra_args++; + $args[$i] = $1; + $defaults{$args[$i]} = $2; + $defaults{$args[$i]} =~ s/"/\\"/g; + } + $proto_arg[$i+1] = '$' ; + } + $min_args = $num_args - $extra_args; + $report_args =~ s/"/\\"/g; + $report_args =~ s/^,\s+//; + my @func_args = @args; + shift @func_args if defined($class); + + for (@func_args) { + s/^/&/ if $in_out{$_}; + } + $func_args = join(", ", @func_args); + @args_match{@args} = @args_num; + + $PPCODE = grep(/^\s*PPCODE\s*:/, @line); + $CODE = grep(/^\s*CODE\s*:/, @line); + # Detect CODE: blocks which use ST(n)= or XST_m*(n,v) + # to set explicit return values. + $EXPLICIT_RETURN = ($CODE && + ("@line" =~ /(\bST\s*\([^;]*=) | (\bXST_m\w+\s*\()/x )); + $ALIAS = grep(/^\s*ALIAS\s*:/, @line); + $INTERFACE = grep(/^\s*INTERFACE\s*:/, @line); + + $xsreturn = 1 if $EXPLICIT_RETURN; + + $externC = $externC ? qq[extern "C"] : ""; + + # print function header + print Q(<<"EOF"); +#$externC +#XS(XS_${Full_func_name}); /* prototype to pass -Wmissing-prototypes */ +#XS(XS_${Full_func_name}) +#[[ +##ifdef dVAR +# dVAR; dXSARGS; +##else +# dXSARGS; +##endif +EOF + print Q(<<"EOF") if $ALIAS ; +# dXSI32; +EOF + print Q(<<"EOF") if $INTERFACE ; +# dXSFUNCTION($ret_type); +EOF + if ($ellipsis) { + $cond = ($min_args ? qq(items < $min_args) : 0); + } elsif ($min_args == $num_args) { + $cond = qq(items != $min_args); + } else { + $cond = qq(items < $min_args || items > $num_args); + } + + print Q(<<"EOF") if $except; +# char errbuf[1024]; +# *errbuf = '\0'; +EOF + + if($cond) { + print Q(<<"EOF"); +# if ($cond) +# croak_xs_usage(cv, "$report_args"); +EOF + } else { + # cv likely to be unused + print Q(<<"EOF"); +# PERL_UNUSED_VAR(cv); /* -W */ +EOF + } + + #gcc -Wall: if an xsub has PPCODE is used + #it is possible none of ST, XSRETURN or XSprePUSH macros are used + #hence `ax' (setup by dXSARGS) is unused + #XXX: could breakup the dXSARGS; into dSP;dMARK;dITEMS + #but such a move could break third-party extensions + print Q(<<"EOF") if $PPCODE; +# PERL_UNUSED_VAR(ax); /* -Wall */ +EOF + + print Q(<<"EOF") if $PPCODE; +# SP -= items; +EOF + + # Now do a block of some sort. + + $condnum = 0; + $cond = ''; # last CASE: condidional + push(@line, "$END:"); + push(@line_no, $line_no[-1]); + $_ = ''; + &check_cpp; + while (@line) { + &CASE_handler if check_keyword("CASE"); + print Q(<<"EOF"); +# $except [[ +EOF + + # do initialization of input variables + $thisdone = 0; + $retvaldone = 0; + $deferred = ""; + %arg_list = () ; + $gotRETVAL = 0; + + INPUT_handler() ; + process_keyword("INPUT|PREINIT|INTERFACE_MACRO|C_ARGS|ALIAS|ATTRS|PROTOTYPE|SCOPE|OVERLOAD") ; + + print Q(<<"EOF") if $ScopeThisXSUB; +# ENTER; +# [[ +EOF + + if (!$thisdone && defined($class)) { + if (defined($static) or $func_name eq 'new') { + print "\tchar *"; + $var_types{"CLASS"} = "char *"; + &generate_init("char *", 1, "CLASS"); + } + else { + print "\t$class *"; + $var_types{"THIS"} = "$class *"; + &generate_init("$class *", 1, "THIS"); + } + } + + # do code + if (/^\s*NOT_IMPLEMENTED_YET/) { + print "\n\tPerl_croak(aTHX_ \"$pname: not implemented yet\");\n"; + $_ = '' ; + } else { + if ($ret_type ne "void") { + print "\t" . &map_type($ret_type, 'RETVAL') . ";\n" + if !$retvaldone; + $args_match{"RETVAL"} = 0; + $var_types{"RETVAL"} = $ret_type; + print "\tdXSTARG;\n" + if $WantOptimize and $targetable{$type_kind{$ret_type}}; + } + + if (@fake_INPUT or @fake_INPUT_pre) { + unshift @line, @fake_INPUT_pre, @fake_INPUT, $_; + $_ = ""; + $processing_arg_with_types = 1; + INPUT_handler() ; + } + print $deferred; + + process_keyword("INIT|ALIAS|ATTRS|PROTOTYPE|INTERFACE_MACRO|INTERFACE|C_ARGS|OVERLOAD") ; + + if (check_keyword("PPCODE")) { + print_section(); + death ("PPCODE must be last thing") if @line; + print "\tLEAVE;\n" if $ScopeThisXSUB; + print "\tPUTBACK;\n\treturn;\n"; + } elsif (check_keyword("CODE")) { + print_section() ; + } elsif (defined($class) and $func_name eq "DESTROY") { + print "\n\t"; + print "delete THIS;\n"; + } else { + print "\n\t"; + if ($ret_type ne "void") { + print "RETVAL = "; + $wantRETVAL = 1; + } + if (defined($static)) { + if ($func_name eq 'new') { + $func_name = "$class"; + } else { + print "${class}::"; + } + } elsif (defined($class)) { + if ($func_name eq 'new') { + $func_name .= " $class"; + } else { + print "THIS->"; + } + } + $func_name =~ s/^\Q$args{'s'}// + if exists $args{'s'}; + $func_name = 'XSFUNCTION' if $interface; + print "$func_name($func_args);\n"; + } + } + + # do output variables + $gotRETVAL = 0; # 1 if RETVAL seen in OUTPUT section; + undef $RETVAL_code ; # code to set RETVAL (from OUTPUT section); + # $wantRETVAL set if 'RETVAL =' autogenerated + ($wantRETVAL, $ret_type) = (0, 'void') if $RETVAL_no_return; + undef %outargs ; + process_keyword("POSTCALL|OUTPUT|ALIAS|ATTRS|PROTOTYPE|OVERLOAD"); + + &generate_output($var_types{$_}, $args_match{$_}, $_, $DoSetMagic) + for grep $in_out{$_} =~ /OUT$/, keys %in_out; + + # all OUTPUT done, so now push the return value on the stack + if ($gotRETVAL && $RETVAL_code) { + print "\t$RETVAL_code\n"; + } elsif ($gotRETVAL || $wantRETVAL) { + my $t = $WantOptimize && $targetable{$type_kind{$ret_type}}; + my $var = 'RETVAL'; + my $type = $ret_type; + + # 0: type, 1: with_size, 2: how, 3: how_size + if ($t and not $t->[1] and $t->[0] eq 'p') { + # PUSHp corresponds to setpvn. Treate setpv directly + my $what = eval qq("$t->[2]"); + warn $@ if $@; + + print "\tsv_setpv(TARG, $what); XSprePUSH; PUSHTARG;\n"; + $prepush_done = 1; + } + elsif ($t) { + my $what = eval qq("$t->[2]"); + warn $@ if $@; + + my $size = $t->[3]; + $size = '' unless defined $size; + $size = eval qq("$size"); + warn $@ if $@; + print "\tXSprePUSH; PUSH$t->[0]($what$size);\n"; + $prepush_done = 1; + } + else { + # RETVAL almost never needs SvSETMAGIC() + &generate_output($ret_type, 0, 'RETVAL', 0); + } + } + + $xsreturn = 1 if $ret_type ne "void"; + my $num = $xsreturn; + my $c = @outlist; + print "\tXSprePUSH;" if $c and not $prepush_done; + print "\tEXTEND(SP,$c);\n" if $c; + $xsreturn += $c; + generate_output($var_types{$_}, $num++, $_, 0, 1) for @outlist; + + # do cleanup + process_keyword("CLEANUP|ALIAS|ATTRS|PROTOTYPE|OVERLOAD") ; + + print Q(<<"EOF") if $ScopeThisXSUB; +# ]] +EOF + print Q(<<"EOF") if $ScopeThisXSUB and not $PPCODE; +# LEAVE; +EOF + + # print function trailer + print Q(<<"EOF"); +# ]] +EOF + print Q(<<"EOF") if $except; +# BEGHANDLERS +# CATCHALL +# sprintf(errbuf, "%s: %s\\tpropagated", Xname, Xreason); +# ENDHANDLERS +EOF + if (check_keyword("CASE")) { + blurt ("Error: No `CASE:' at top of function") + unless $condnum; + $_ = "CASE: $_"; # Restore CASE: label + next; + } + last if $_ eq "$END:"; + death(/^$BLOCK_re/o ? "Misplaced `$1:'" : "Junk at end of function ($_)"); + } + + print Q(<<"EOF") if $except; +# if (errbuf[0]) +# Perl_croak(aTHX_ errbuf); +EOF + + if ($xsreturn) { + print Q(<<"EOF") unless $PPCODE; +# XSRETURN($xsreturn); +EOF + } else { + print Q(<<"EOF") unless $PPCODE; +# XSRETURN_EMPTY; +EOF + } + + print Q(<<"EOF"); +#]] +# +EOF + + our $newXS = "newXS" ; + our $proto = "" ; + + # Build the prototype string for the xsub + if ($ProtoThisXSUB) { + $newXS = "newXSproto_portable"; + + if ($ProtoThisXSUB eq 2) { + # User has specified empty prototype + } + elsif ($ProtoThisXSUB eq 1) { + my $s = ';'; + if ($min_args < $num_args) { + $s = ''; + $proto_arg[$min_args] .= ";" ; + } + push @proto_arg, "$s\@" + if $ellipsis ; + + $proto = join ("", grep defined, @proto_arg); + } + else { + # User has specified a prototype + $proto = $ProtoThisXSUB; + } + $proto = qq{, "$proto"}; + } + + if (%XsubAliases) { + $XsubAliases{$pname} = 0 + unless defined $XsubAliases{$pname} ; + while ( ($name, $value) = each %XsubAliases) { + push(@InitFileCode, Q(<<"EOF")); +# cv = ${newXS}(\"$name\", XS_$Full_func_name, file$proto); +# XSANY.any_i32 = $value ; +EOF + } + } + elsif (@Attributes) { + push(@InitFileCode, Q(<<"EOF")); +# cv = ${newXS}(\"$pname\", XS_$Full_func_name, file$proto); +# apply_attrs_string("$Package", cv, "@Attributes", 0); +EOF + } + elsif ($interface) { + while ( ($name, $value) = each %Interfaces) { + $name = "$Package\::$name" unless $name =~ /::/; + push(@InitFileCode, Q(<<"EOF")); +# cv = ${newXS}(\"$name\", XS_$Full_func_name, file$proto); +# $interface_macro_set(cv,$value) ; +EOF + } + } + elsif($newXS eq 'newXS'){ # work around P5NCI's empty newXS macro + push(@InitFileCode, + " ${newXS}(\"$pname\", XS_$Full_func_name, file$proto);\n"); + } + else { + push(@InitFileCode, + " (void)${newXS}(\"$pname\", XS_$Full_func_name, file$proto);\n"); + } + } + + if ($Overload) # make it findable with fetchmethod + { + print Q(<<"EOF"); +#XS(XS_${Packid}_nil); /* prototype to pass -Wmissing-prototypes */ +#XS(XS_${Packid}_nil) +#{ +# dXSARGS; +# XSRETURN_EMPTY; +#} +# +EOF + unshift(@InitFileCode, <<"MAKE_FETCHMETHOD_WORK"); + /* Making a sub named "${Package}::()" allows the package */ + /* to be findable via fetchmethod(), and causes */ + /* overload::Overloaded("${Package}") to return true. */ + (void)${newXS}("${Package}::()", XS_${Packid}_nil, file$proto); +MAKE_FETCHMETHOD_WORK + } + + # print initialization routine + + print Q(<<"EOF"); +##ifdef __cplusplus +#extern "C" +##endif +EOF + + print Q(<<"EOF"); +#XS(boot_$Module_cname); /* prototype to pass -Wmissing-prototypes */ +#XS(boot_$Module_cname) +EOF + + print Q(<<"EOF"); +#[[ +##ifdef dVAR +# dVAR; dXSARGS; +##else +# dXSARGS; +##endif +EOF + + #Under 5.8.x and lower, newXS is declared in proto.h as expecting a non-const + #file name argument. If the wrong qualifier is used, it causes breakage with + #C++ compilers and warnings with recent gcc. + #-Wall: if there is no $Full_func_name there are no xsubs in this .xs + #so `file' is unused + print Q(<<"EOF") if $Full_func_name; +##if (PERL_REVISION == 5 && PERL_VERSION < 9) +# char* file = __FILE__; +##else +# const char* file = __FILE__; +##endif +EOF + + print Q("#\n"); + + print Q(<<"EOF"); +# PERL_UNUSED_VAR(cv); /* -W */ +# PERL_UNUSED_VAR(items); /* -W */ +EOF + + print Q(<<"EOF") if $WantVersionChk ; +# XS_VERSION_BOOTCHECK ; +# +EOF + + print Q(<<"EOF") if defined $XsubAliases or defined $Interfaces ; +# { +# CV * cv ; +# +EOF + + print Q(<<"EOF") if ($Overload); +# /* register the overloading (type 'A') magic */ +# PL_amagic_generation++; +# /* The magic for overload gets a GV* via gv_fetchmeth as */ +# /* mentioned above, and looks in the SV* slot of it for */ +# /* the "fallback" status. */ +# sv_setsv( +# get_sv( "${Package}::()", TRUE ), +# $Fallback +# ); +EOF + + print @InitFileCode; + + print Q(<<"EOF") if defined $XsubAliases or defined $Interfaces ; +# } +EOF + + if (@BootCode) + { + print "\n /* Initialisation Section */\n\n" ; + @line = @BootCode; + print_section(); + print "\n /* End of Initialisation Section */\n\n" ; + } + + print Q(<<'EOF'); +##if (PERL_REVISION == 5 && PERL_VERSION >= 9) +# if (PL_unitcheckav) +# call_list(PL_scopestack_ix, PL_unitcheckav); +##endif +EOF + + print Q(<<"EOF"); +# XSRETURN_YES; +#]] +# +EOF + + warn("Please specify prototyping behavior for $filename (see perlxs manual)\n") + unless $ProtoUsed ; + + chdir($orig_cwd); + select($orig_fh); + untie *PSEUDO_STDOUT if tied *PSEUDO_STDOUT; + close $FH; + + return 1; +} + +sub errors { $errors } + +sub standard_typemap_locations { + # Add all the default typemap locations to the search path + my @tm = qw(typemap); + + my $updir = File::Spec->updir; + foreach my $dir (File::Spec->catdir(($updir) x 1), File::Spec->catdir(($updir) x 2), + File::Spec->catdir(($updir) x 3), File::Spec->catdir(($updir) x 4)) { + + unshift @tm, File::Spec->catfile($dir, 'typemap'); + unshift @tm, File::Spec->catfile($dir, lib => ExtUtils => 'typemap'); + } + foreach my $dir (@INC) { + my $file = File::Spec->catfile($dir, ExtUtils => 'typemap'); + unshift @tm, $file if -e $file; + } + return @tm; +} + +sub TrimWhitespace +{ + $_[0] =~ s/^\s+|\s+$//go ; +} + +sub TidyType + { + local ($_) = @_ ; + + # rationalise any '*' by joining them into bunches and removing whitespace + s#\s*(\*+)\s*#$1#g; + s#(\*+)# $1 #g ; + + # change multiple whitespace into a single space + s/\s+/ /g ; + + # trim leading & trailing whitespace + TrimWhitespace($_) ; + + $_ ; +} + +# Input: ($_, @line) == unparsed input. +# Output: ($_, @line) == (rest of line, following lines). +# Return: the matched keyword if found, otherwise 0 +sub check_keyword { + $_ = shift(@line) while !/\S/ && @line; + s/^(\s*)($_[0])\s*:\s*(?:#.*)?/$1/s && $2; +} + +sub print_section { + # the "do" is required for right semantics + do { $_ = shift(@line) } while !/\S/ && @line; + + print("#line ", $line_no[@line_no - @line -1], " \"$filepathname\"\n") + if $WantLineNumbers && !/^\s*#\s*line\b/ && !/^#if XSubPPtmp/; + for (; defined($_) && !/^$BLOCK_re/o; $_ = shift(@line)) { + print "$_\n"; + } + print 'ExtUtils::ParseXS::CountLines'->end_marker, "\n" if $WantLineNumbers; +} + +sub merge_section { + my $in = ''; + + while (!/\S/ && @line) { + $_ = shift(@line); + } + + for (; defined($_) && !/^$BLOCK_re/o; $_ = shift(@line)) { + $in .= "$_\n"; + } + chomp $in; + return $in; + } + +sub process_keyword($) + { + my($pattern) = @_ ; + my $kwd ; + + &{"${kwd}_handler"}() + while $kwd = check_keyword($pattern) ; + } + +sub CASE_handler { + blurt ("Error: `CASE:' after unconditional `CASE:'") + if $condnum && $cond eq ''; + $cond = $_; + TrimWhitespace($cond); + print " ", ($condnum++ ? " else" : ""), ($cond ? " if ($cond)\n" : "\n"); + $_ = '' ; +} + +sub INPUT_handler { + for (; !/^$BLOCK_re/o; $_ = shift(@line)) { + last if /^\s*NOT_IMPLEMENTED_YET/; + next unless /\S/; # skip blank lines + + TrimWhitespace($_) ; + my $line = $_ ; + + # remove trailing semicolon if no initialisation + s/\s*;$//g unless /[=;+].*\S/ ; + + # Process the length(foo) declarations + if (s/^([^=]*)\blength\(\s*(\w+)\s*\)\s*$/$1 XSauto_length_of_$2=NO_INIT/x) { + print "\tSTRLEN\tSTRLEN_length_of_$2;\n"; + $lengthof{$2} = $name; + # $islengthof{$name} = $1; + $deferred .= "\n\tXSauto_length_of_$2 = STRLEN_length_of_$2;\n"; + } + + # check for optional initialisation code + my $var_init = '' ; + $var_init = $1 if s/\s*([=;+].*)$//s ; + $var_init =~ s/"/\\"/g; + + s/\s+/ /g; + my ($var_type, $var_addr, $var_name) = /^(.*?[^&\s])\s*(\&?)\s*\b(\w+)$/s + or blurt("Error: invalid argument declaration '$line'"), next; + + # Check for duplicate definitions + blurt ("Error: duplicate definition of argument '$var_name' ignored"), next + if $arg_list{$var_name}++ + or defined $argtype_seen{$var_name} and not $processing_arg_with_types; + + $thisdone |= $var_name eq "THIS"; + $retvaldone |= $var_name eq "RETVAL"; + $var_types{$var_name} = $var_type; + # XXXX This check is a safeguard against the unfinished conversion of + # generate_init(). When generate_init() is fixed, + # one can use 2-args map_type() unconditionally. + if ($var_type =~ / \( \s* \* \s* \) /x) { + # Function pointers are not yet supported with &output_init! + print "\t" . &map_type($var_type, $var_name); + $name_printed = 1; + } else { + print "\t" . &map_type($var_type); + $name_printed = 0; + } + $var_num = $args_match{$var_name}; + + $proto_arg[$var_num] = ProtoString($var_type) + if $var_num ; + $func_args =~ s/\b($var_name)\b/&$1/ if $var_addr; + if ($var_init =~ /^[=;]\s*NO_INIT\s*;?\s*$/ + or $in_out{$var_name} and $in_out{$var_name} =~ /^OUT/ + and $var_init !~ /\S/) { + if ($name_printed) { + print ";\n"; + } else { + print "\t$var_name;\n"; + } + } elsif ($var_init =~ /\S/) { + &output_init($var_type, $var_num, $var_name, $var_init, $name_printed); + } elsif ($var_num) { + # generate initialization code + &generate_init($var_type, $var_num, $var_name, $name_printed); + } else { + print ";\n"; + } + } +} + +sub OUTPUT_handler { + for (; !/^$BLOCK_re/o; $_ = shift(@line)) { + next unless /\S/; + if (/^\s*SETMAGIC\s*:\s*(ENABLE|DISABLE)\s*/) { + $DoSetMagic = ($1 eq "ENABLE" ? 1 : 0); + next; + } + my ($outarg, $outcode) = /^\s*(\S+)\s*(.*?)\s*$/s ; + blurt ("Error: duplicate OUTPUT argument '$outarg' ignored"), next + if $outargs{$outarg} ++ ; + if (!$gotRETVAL and $outarg eq 'RETVAL') { + # deal with RETVAL last + $RETVAL_code = $outcode ; + $gotRETVAL = 1 ; + next ; + } + blurt ("Error: OUTPUT $outarg not an argument"), next + unless defined($args_match{$outarg}); + blurt("Error: No input definition for OUTPUT argument '$outarg' - ignored"), next + unless defined $var_types{$outarg} ; + $var_num = $args_match{$outarg}; + if ($outcode) { + print "\t$outcode\n"; + print "\tSvSETMAGIC(ST(" , $var_num-1 , "));\n" if $DoSetMagic; + } else { + &generate_output($var_types{$outarg}, $var_num, $outarg, $DoSetMagic); + } + delete $in_out{$outarg} # No need to auto-OUTPUT + if exists $in_out{$outarg} and $in_out{$outarg} =~ /OUT$/; + } +} + +sub C_ARGS_handler() { + my $in = merge_section(); + + TrimWhitespace($in); + $func_args = $in; +} + +sub INTERFACE_MACRO_handler() { + my $in = merge_section(); + + TrimWhitespace($in); + if ($in =~ /\s/) { # two + ($interface_macro, $interface_macro_set) = split ' ', $in; + } else { + $interface_macro = $in; + $interface_macro_set = 'UNKNOWN_CVT'; # catch later + } + $interface = 1; # local + $Interfaces = 1; # global +} + +sub INTERFACE_handler() { + my $in = merge_section(); + + TrimWhitespace($in); + + foreach (split /[\s,]+/, $in) { + my $name = $_; + $name =~ s/^$Prefix//; + $Interfaces{$name} = $_; + } + print Q(<<"EOF"); +# XSFUNCTION = $interface_macro($ret_type,cv,XSANY.any_dptr); +EOF + $interface = 1; # local + $Interfaces = 1; # global +} + +sub CLEANUP_handler() { print_section() } +sub PREINIT_handler() { print_section() } +sub POSTCALL_handler() { print_section() } +sub INIT_handler() { print_section() } + +sub GetAliases + { + my ($line) = @_ ; + my ($orig) = $line ; + my ($alias) ; + my ($value) ; + + # Parse alias definitions + # format is + # alias = value alias = value ... + + while ($line =~ s/^\s*([\w:]+)\s*=\s*(\w+)\s*//) { + $alias = $1 ; + $orig_alias = $alias ; + $value = $2 ; + + # check for optional package definition in the alias + $alias = $Packprefix . $alias if $alias !~ /::/ ; + + # check for duplicate alias name & duplicate value + Warn("Warning: Ignoring duplicate alias '$orig_alias'") + if defined $XsubAliases{$alias} ; + + Warn("Warning: Aliases '$orig_alias' and '$XsubAliasValues{$value}' have identical values") + if $XsubAliasValues{$value} ; + + $XsubAliases = 1; + $XsubAliases{$alias} = $value ; + $XsubAliasValues{$value} = $orig_alias ; + } + + blurt("Error: Cannot parse ALIAS definitions from '$orig'") + if $line ; + } + +sub ATTRS_handler () + { + for (; !/^$BLOCK_re/o; $_ = shift(@line)) { + next unless /\S/; + TrimWhitespace($_) ; + push @Attributes, $_; + } + } + +sub ALIAS_handler () + { + for (; !/^$BLOCK_re/o; $_ = shift(@line)) { + next unless /\S/; + TrimWhitespace($_) ; + GetAliases($_) if $_ ; + } + } + +sub OVERLOAD_handler() +{ + for (; !/^$BLOCK_re/o; $_ = shift(@line)) { + next unless /\S/; + TrimWhitespace($_) ; + while ( s/^\s*([\w:"\\)\+\-\*\/\%\<\>\.\&\|\^\!\~\{\}\=]+)\s*//) { + $Overload = 1 unless $Overload; + my $overload = "$Package\::(".$1 ; + push(@InitFileCode, + " (void)${newXS}(\"$overload\", XS_$Full_func_name, file$proto);\n"); + } + } +} + +sub FALLBACK_handler() +{ + # the rest of the current line should contain either TRUE, + # FALSE or UNDEF + + TrimWhitespace($_) ; + my %map = ( + TRUE => "&PL_sv_yes", 1 => "&PL_sv_yes", + FALSE => "&PL_sv_no", 0 => "&PL_sv_no", + UNDEF => "&PL_sv_undef", + ) ; + + # check for valid FALLBACK value + death ("Error: FALLBACK: TRUE/FALSE/UNDEF") unless exists $map{uc $_} ; + + $Fallback = $map{uc $_} ; +} + + +sub REQUIRE_handler () + { + # the rest of the current line should contain a version number + my ($Ver) = $_ ; + + TrimWhitespace($Ver) ; + + death ("Error: REQUIRE expects a version number") + unless $Ver ; + + # check that the version number is of the form n.n + death ("Error: REQUIRE: expected a number, got '$Ver'") + unless $Ver =~ /^\d+(\.\d*)?/ ; + + death ("Error: xsubpp $Ver (or better) required--this is only $VERSION.") + unless $VERSION >= $Ver ; + } + +sub VERSIONCHECK_handler () + { + # the rest of the current line should contain either ENABLE or + # DISABLE + + TrimWhitespace($_) ; + + # check for ENABLE/DISABLE + death ("Error: VERSIONCHECK: ENABLE/DISABLE") + unless /^(ENABLE|DISABLE)/i ; + + $WantVersionChk = 1 if $1 eq 'ENABLE' ; + $WantVersionChk = 0 if $1 eq 'DISABLE' ; + + } + +sub PROTOTYPE_handler () + { + my $specified ; + + death("Error: Only 1 PROTOTYPE definition allowed per xsub") + if $proto_in_this_xsub ++ ; + + for (; !/^$BLOCK_re/o; $_ = shift(@line)) { + next unless /\S/; + $specified = 1 ; + TrimWhitespace($_) ; + if ($_ eq 'DISABLE') { + $ProtoThisXSUB = 0 + } elsif ($_ eq 'ENABLE') { + $ProtoThisXSUB = 1 + } else { + # remove any whitespace + s/\s+//g ; + death("Error: Invalid prototype '$_'") + unless ValidProtoString($_) ; + $ProtoThisXSUB = C_string($_) ; + } + } + + # If no prototype specified, then assume empty prototype "" + $ProtoThisXSUB = 2 unless $specified ; + + $ProtoUsed = 1 ; + + } + +sub SCOPE_handler () + { + death("Error: Only 1 SCOPE declaration allowed per xsub") + if $scope_in_this_xsub ++ ; + + TrimWhitespace($_); + death ("Error: SCOPE: ENABLE/DISABLE") + unless /^(ENABLE|DISABLE)\b/i; + $ScopeThisXSUB = ( uc($1) eq 'ENABLE' ); + } + +sub PROTOTYPES_handler () + { + # the rest of the current line should contain either ENABLE or + # DISABLE + + TrimWhitespace($_) ; + + # check for ENABLE/DISABLE + death ("Error: PROTOTYPES: ENABLE/DISABLE") + unless /^(ENABLE|DISABLE)/i ; + + $WantPrototypes = 1 if $1 eq 'ENABLE' ; + $WantPrototypes = 0 if $1 eq 'DISABLE' ; + $ProtoUsed = 1 ; + + } + +sub PushXSStack + { + # Save the current file context. + push(@XSStack, { + type => 'file', + LastLine => $lastline, + LastLineNo => $lastline_no, + Line => \@line, + LineNo => \@line_no, + Filename => $filename, + Filepathname => $filepathname, + Handle => $FH, + }) ; + + } + +sub INCLUDE_handler () + { + # the rest of the current line should contain a valid filename + + TrimWhitespace($_) ; + + death("INCLUDE: filename missing") + unless $_ ; + + death("INCLUDE: output pipe is illegal") + if /^\s*\|/ ; + + # simple minded recursion detector + death("INCLUDE loop detected") + if $IncludedFiles{$_} ; + + ++ $IncludedFiles{$_} unless /\|\s*$/ ; + + Warn("The INCLUDE directive with a command is deprecated." . + " Use INCLUDE_COMMAND instead!") + if /\|\s*$/ ; + + PushXSStack(); + + $FH = Symbol::gensym(); + + # open the new file + open ($FH, "$_") or death("Cannot open '$_': $!") ; + + print Q(<<"EOF"); +# +#/* INCLUDE: Including '$_' from '$filename' */ +# +EOF + + $filename = $_ ; + $filepathname = "$dir/$filename"; + + # Prime the pump by reading the first + # non-blank line + + # skip leading blank lines + while (<$FH>) { + last unless /^\s*$/ ; + } + + $lastline = $_ ; + $lastline_no = $. ; + } + +sub INCLUDE_COMMAND_handler () + { + # the rest of the current line should contain a valid command + + TrimWhitespace($_) ; + + death("INCLUDE_COMMAND: command missing") + unless $_ ; + + death("INCLUDE_COMMAND: pipes are illegal") + if /^\s*\|/ or /\|\s*$/ ; + + PushXSStack(); + + $FH = Symbol::gensym(); + + # If $^X is used in INCLUDE_COMMAND, we know it's supposed to be + # the same perl interpreter as we're currently running + s/^\s*\$\^X/$^X/; + + # open the new file + open ($FH, "-|", "$_") + or death("Cannot run command '$_' to include its output: $!") ; + + print Q(<<"EOF"); +# +#/* INCLUDE_COMMAND: Including output of '$_' from '$filename' */ +# +EOF + + $filename = $_ ; + $filepathname = "$dir/$filename"; + + # Prime the pump by reading the first + # non-blank line + + # skip leading blank lines + while (<$FH>) { + last unless /^\s*$/ ; + } + + $lastline = $_ ; + $lastline_no = $. ; + } + +sub PopFile() + { + return 0 unless $XSStack[-1]{type} eq 'file' ; + + my $data = pop @XSStack ; + my $ThisFile = $filename ; + my $isPipe = ($filename =~ /\|\s*$/) ; + + -- $IncludedFiles{$filename} + unless $isPipe ; + + close $FH ; + + $FH = $data->{Handle} ; + # $filename is the leafname, which for some reason isused for diagnostic + # messages, whereas $filepathname is the full pathname, and is used for + # #line directives. + $filename = $data->{Filename} ; + $filepathname = $data->{Filepathname} ; + $lastline = $data->{LastLine} ; + $lastline_no = $data->{LastLineNo} ; + @line = @{ $data->{Line} } ; + @line_no = @{ $data->{LineNo} } ; + + if ($isPipe and $? ) { + -- $lastline_no ; + print STDERR "Error reading from pipe '$ThisFile': $! in $filename, line $lastline_no\n" ; + exit 1 ; + } + + print Q(<<"EOF"); +# +#/* INCLUDE: Returning to '$filename' from '$ThisFile' */ +# +EOF + + return 1 ; + } + +sub ValidProtoString ($) + { + my($string) = @_ ; + + if ( $string =~ /^$proto_re+$/ ) { + return $string ; + } + + return 0 ; + } + +sub C_string ($) + { + my($string) = @_ ; + + $string =~ s[\\][\\\\]g ; + $string ; + } + +sub ProtoString ($) + { + my ($type) = @_ ; + + $proto_letter{$type} or "\$" ; + } + +sub check_cpp { + my @cpp = grep(/^\#\s*(?:if|e\w+)/, @line); + if (@cpp) { + my ($cpp, $cpplevel); + for $cpp (@cpp) { + if ($cpp =~ /^\#\s*if/) { + $cpplevel++; + } elsif (!$cpplevel) { + Warn("Warning: #else/elif/endif without #if in this function"); + print STDERR " (precede it with a blank line if the matching #if is outside the function)\n" + if $XSStack[-1]{type} eq 'if'; + return; + } elsif ($cpp =~ /^\#\s*endif/) { + $cpplevel--; + } + } + Warn("Warning: #if without #endif in this function") if $cpplevel; + } +} + + +sub Q { + my($text) = @_; + $text =~ s/^#//gm; + $text =~ s/\[\[/{/g; + $text =~ s/\]\]/}/g; + $text; +} + +# Read next xsub into @line from ($lastline, <$FH>). +sub fetch_para { + # parse paragraph + death ("Error: Unterminated `#if/#ifdef/#ifndef'") + if !defined $lastline && $XSStack[-1]{type} eq 'if'; + @line = (); + @line_no = () ; + return PopFile() if !defined $lastline; + + if ($lastline =~ + /^MODULE\s*=\s*([\w:]+)(?:\s+PACKAGE\s*=\s*([\w:]+))?(?:\s+PREFIX\s*=\s*(\S+))?\s*$/) { + $Module = $1; + $Package = defined($2) ? $2 : ''; # keep -w happy + $Prefix = defined($3) ? $3 : ''; # keep -w happy + $Prefix = quotemeta $Prefix ; + ($Module_cname = $Module) =~ s/\W/_/g; + ($Packid = $Package) =~ tr/:/_/; + $Packprefix = $Package; + $Packprefix .= "::" if $Packprefix ne ""; + $lastline = ""; + } + + for (;;) { + # Skip embedded PODs + while ($lastline =~ /^=/) { + while ($lastline = <$FH>) { + last if ($lastline =~ /^=cut\s*$/); + } + death ("Error: Unterminated pod") unless $lastline; + $lastline = <$FH>; + chomp $lastline; + $lastline =~ s/^\s+$//; + } + if ($lastline !~ /^\s*#/ || + # CPP directives: + # ANSI: if ifdef ifndef elif else endif define undef + # line error pragma + # gcc: warning include_next + # obj-c: import + # others: ident (gcc notes that some cpps have this one) + $lastline =~ /^#[ \t]*(?:(?:if|ifn?def|elif|else|endif|define|undef|pragma|error|warning|line\s+\d+|ident)\b|(?:include(?:_next)?|import)\s*["<].*[>"])/) { + last if $lastline =~ /^\S/ && @line && $line[-1] eq ""; + push(@line, $lastline); + push(@line_no, $lastline_no) ; + } + + # Read next line and continuation lines + last unless defined($lastline = <$FH>); + $lastline_no = $.; + my $tmp_line; + $lastline .= $tmp_line + while ($lastline =~ /\\$/ && defined($tmp_line = <$FH>)); + + chomp $lastline; + $lastline =~ s/^\s+$//; + } + pop(@line), pop(@line_no) while @line && $line[-1] eq ""; + 1; +} + +sub output_init { + local($type, $num, $var, $init, $name_printed) = @_; + local($arg) = "ST(" . ($num - 1) . ")"; + + if ( $init =~ /^=/ ) { + if ($name_printed) { + eval qq/print " $init\\n"/; + } else { + eval qq/print "\\t$var $init\\n"/; + } + warn $@ if $@; + } else { + if ( $init =~ s/^\+// && $num ) { + &generate_init($type, $num, $var, $name_printed); + } elsif ($name_printed) { + print ";\n"; + $init =~ s/^;//; + } else { + eval qq/print "\\t$var;\\n"/; + warn $@ if $@; + $init =~ s/^;//; + } + $deferred .= eval qq/"\\n\\t$init\\n"/; + warn $@ if $@; + } +} + +sub Warn + { + # work out the line number + my $line_no = $line_no[@line_no - @line -1] ; + + print STDERR "@_ in $filename, line $line_no\n" ; + } + +sub blurt + { + Warn @_ ; + $errors ++ + } + +sub death + { + Warn @_ ; + exit 1 ; + } + +sub generate_init { + local($type, $num, $var) = @_; + local($arg) = "ST(" . ($num - 1) . ")"; + local($argoff) = $num - 1; + local($ntype); + local($tk); + + $type = TidyType($type) ; + blurt("Error: '$type' not in typemap"), return + unless defined($type_kind{$type}); + + ($ntype = $type) =~ s/\s*\*/Ptr/g; + ($subtype = $ntype) =~ s/(?:Array)?(?:Ptr)?$//; + $tk = $type_kind{$type}; + $tk =~ s/OBJ$/REF/ if $func_name =~ /DESTROY$/; + if ($tk eq 'T_PV' and exists $lengthof{$var}) { + print "\t$var" unless $name_printed; + print " = ($type)SvPV($arg, STRLEN_length_of_$var);\n"; + die "default value not supported with length(NAME) supplied" + if defined $defaults{$var}; + return; + } + $type =~ tr/:/_/ unless $hiertype; + blurt("Error: No INPUT definition for type '$type', typekind '$type_kind{$type}' found"), return + unless defined $input_expr{$tk} ; + $expr = $input_expr{$tk}; + if ($expr =~ /DO_ARRAY_ELEM/) { + blurt("Error: '$subtype' not in typemap"), return + unless defined($type_kind{$subtype}); + blurt("Error: No INPUT definition for type '$subtype', typekind '$type_kind{$subtype}' found"), return + unless defined $input_expr{$type_kind{$subtype}} ; + $subexpr = $input_expr{$type_kind{$subtype}}; + $subexpr =~ s/\$type/\$subtype/g; + $subexpr =~ s/ntype/subtype/g; + $subexpr =~ s/\$arg/ST(ix_$var)/g; + $subexpr =~ s/\n\t/\n\t\t/g; + $subexpr =~ s/is not of (.*\")/[arg %d] is not of $1, ix_$var + 1/g; + $subexpr =~ s/\$var/${var}[ix_$var - $argoff]/; + $expr =~ s/DO_ARRAY_ELEM/$subexpr/; + } + if ($expr =~ m#/\*.*scope.*\*/#i) { # "scope" in C comments + $ScopeThisXSUB = 1; + } + if (defined($defaults{$var})) { + $expr =~ s/(\t+)/$1 /g; + $expr =~ s/ /\t/g; + if ($name_printed) { + print ";\n"; + } else { + eval qq/print "\\t$var;\\n"/; + warn $@ if $@; + } + if ($defaults{$var} eq 'NO_INIT') { + $deferred .= eval qq/"\\n\\tif (items >= $num) {\\n$expr;\\n\\t}\\n"/; + } else { + $deferred .= eval qq/"\\n\\tif (items < $num)\\n\\t $var = $defaults{$var};\\n\\telse {\\n$expr;\\n\\t}\\n"/; + } + warn $@ if $@; + } elsif ($ScopeThisXSUB or $expr !~ /^\s*\$var =/) { + if ($name_printed) { + print ";\n"; + } else { + eval qq/print "\\t$var;\\n"/; + warn $@ if $@; + } + $deferred .= eval qq/"\\n$expr;\\n"/; + warn $@ if $@; + } else { + die "panic: do not know how to handle this branch for function pointers" + if $name_printed; + eval qq/print "$expr;\\n"/; + warn $@ if $@; + } +} + +sub generate_output { + local($type, $num, $var, $do_setmagic, $do_push) = @_; + local($arg) = "ST(" . ($num - ($num != 0)) . ")"; + local($argoff) = $num - 1; + local($ntype); + + $type = TidyType($type) ; + if ($type =~ /^array\(([^,]*),(.*)\)/) { + print "\t$arg = sv_newmortal();\n"; + print "\tsv_setpvn($arg, (char *)$var, $2 * sizeof($1));\n"; + print "\tSvSETMAGIC($arg);\n" if $do_setmagic; + } else { + blurt("Error: '$type' not in typemap"), return + unless defined($type_kind{$type}); + blurt("Error: No OUTPUT definition for type '$type', typekind '$type_kind{$type}' found"), return + unless defined $output_expr{$type_kind{$type}} ; + ($ntype = $type) =~ s/\s*\*/Ptr/g; + $ntype =~ s/\(\)//g; + ($subtype = $ntype) =~ s/(?:Array)?(?:Ptr)?$//; + $expr = $output_expr{$type_kind{$type}}; + if ($expr =~ /DO_ARRAY_ELEM/) { + blurt("Error: '$subtype' not in typemap"), return + unless defined($type_kind{$subtype}); + blurt("Error: No OUTPUT definition for type '$subtype', typekind '$type_kind{$subtype}' found"), return + unless defined $output_expr{$type_kind{$subtype}} ; + $subexpr = $output_expr{$type_kind{$subtype}}; + $subexpr =~ s/ntype/subtype/g; + $subexpr =~ s/\$arg/ST(ix_$var)/g; + $subexpr =~ s/\$var/${var}[ix_$var]/g; + $subexpr =~ s/\n\t/\n\t\t/g; + $expr =~ s/DO_ARRAY_ELEM\n/$subexpr/; + eval "print qq\a$expr\a"; + warn $@ if $@; + print "\t\tSvSETMAGIC(ST(ix_$var));\n" if $do_setmagic; + } elsif ($var eq 'RETVAL') { + if ($expr =~ /^\t\$arg = new/) { + # We expect that $arg has refcnt 1, so we need to + # mortalize it. + eval "print qq\a$expr\a"; + warn $@ if $@; + print "\tsv_2mortal(ST($num));\n"; + print "\tSvSETMAGIC(ST($num));\n" if $do_setmagic; + } elsif ($expr =~ /^\s*\$arg\s*=/) { + # We expect that $arg has refcnt >=1, so we need + # to mortalize it! + eval "print qq\a$expr\a"; + warn $@ if $@; + print "\tsv_2mortal(ST(0));\n"; + print "\tSvSETMAGIC(ST(0));\n" if $do_setmagic; + } else { + # Just hope that the entry would safely write it + # over an already mortalized value. By + # coincidence, something like $arg = &sv_undef + # works too. + print "\tST(0) = sv_newmortal();\n"; + eval "print qq\a$expr\a"; + warn $@ if $@; + # new mortals don't have set magic + } + } elsif ($do_push) { + print "\tPUSHs(sv_newmortal());\n"; + $arg = "ST($num)"; + eval "print qq\a$expr\a"; + warn $@ if $@; + print "\tSvSETMAGIC($arg);\n" if $do_setmagic; + } elsif ($arg =~ /^ST\(\d+\)$/) { + eval "print qq\a$expr\a"; + warn $@ if $@; + print "\tSvSETMAGIC($arg);\n" if $do_setmagic; + } + } +} + +sub map_type { + my($type, $varname) = @_; + + # C++ has :: in types too so skip this + $type =~ tr/:/_/ unless $hiertype; + $type =~ s/^array\(([^,]*),(.*)\).*/$1 */s; + if ($varname) { + if ($varname && $type =~ / \( \s* \* (?= \s* \) ) /xg) { + (substr $type, pos $type, 0) = " $varname "; + } else { + $type .= "\t$varname"; + } + } + $type; +} + + +######################################################### +package + ExtUtils::ParseXS::CountLines; +use strict; +use vars qw($SECTION_END_MARKER); + +sub TIEHANDLE { + my ($class, $cfile, $fh) = @_; + $cfile =~ s/\\/\\\\/g; + $SECTION_END_MARKER = qq{#line --- "$cfile"}; + + return bless {buffer => '', + fh => $fh, + line_no => 1, + }, $class; +} + +sub PRINT { + my $self = shift; + for (@_) { + $self->{buffer} .= $_; + while ($self->{buffer} =~ s/^([^\n]*\n)//) { + my $line = $1; + ++ $self->{line_no}; + $line =~ s|^\#line\s+---(?=\s)|#line $self->{line_no}|; + print {$self->{fh}} $line; + } + } +} + +sub PRINTF { + my $self = shift; + my $fmt = shift; + $self->PRINT(sprintf($fmt, @_)); +} + +sub DESTROY { + # Not necessary if we're careful to end with a "\n" + my $self = shift; + print {$self->{fh}} $self->{buffer}; +} + +sub UNTIE { + # This sub does nothing, but is neccessary for references to be released. +} + +sub end_marker { + return $SECTION_END_MARKER; +} + + +1; +__END__ + +=head1 NAME + +ExtUtils::ParseXS - converts Perl XS code into C code + +=head1 SYNOPSIS + + use ExtUtils::ParseXS qw(process_file); + + process_file( filename => 'foo.xs' ); + + process_file( filename => 'foo.xs', + output => 'bar.c', + 'C++' => 1, + typemap => 'path/to/typemap', + hiertype => 1, + except => 1, + prototypes => 1, + versioncheck => 1, + linenumbers => 1, + optimize => 1, + prototypes => 1, + ); +=head1 DESCRIPTION + +C will compile XS code into C code by embedding the constructs +necessary to let C functions manipulate Perl values and creates the glue +necessary to let Perl access those functions. The compiler uses typemaps to +determine how to map C function parameters and variables to Perl values. + +The compiler will search for typemap files called I. It will use +the following search path to find default typemaps, with the rightmost +typemap taking precedence. + + ../../../typemap:../../typemap:../typemap:typemap + +=head1 EXPORT + +None by default. C may be exported upon request. + + +=head1 FUNCTIONS + +=over 4 + +=item process_xs() + +This function processes an XS file and sends output to a C file. +Named parameters control how the processing is done. The following +parameters are accepted: + +=over 4 + +=item B + +Adds C to the C code. Default is false. + +=item B + +Retains C<::> in type names so that C++ hierachical types can be +mapped. Default is false. + +=item B + +Adds exception handling stubs to the C code. Default is false. + +=item B + +Indicates that a user-supplied typemap should take precedence over the +default typemaps. A single typemap may be specified as a string, or +multiple typemaps can be specified in an array reference, with the +last typemap having the highest precedence. + +=item B + +Generates prototype code for all xsubs. Default is false. + +=item B + +Makes sure at run time that the object file (derived from the C<.xs> +file) and the C<.pm> files have the same version number. Default is +true. + +=item B + +Adds C<#line> directives to the C output so error messages will look +like they came from the original XS file. Default is true. + +=item B + +Enables certain optimizations. The only optimization that is currently +affected is the use of Is by the output C code (see L). +Not optimizing may significantly slow down the generated code, but this is the way +B of 5.005 and earlier operated. Default is to optimize. + +=item B + +Enable recognition of C, C and C +declarations. Default is true. + +=item B + +Enable recognition of ANSI-like descriptions of function signature. +Default is true. + +=item B + +I have no clue what this does. Strips function prefixes? + +=back + +=item errors() + +This function returns the number of [a certain kind of] errors +encountered during processing of the XS file. + +=back + +=head1 AUTHOR + +Based on xsubpp code, written by Larry Wall. + +Maintained by: + +=over 4 + +=item * + +Ken Williams, + +=item * + +David Golden, + +=back + +=head1 COPYRIGHT + +Copyright 2002-2009 by Ken Williams, David Golden and other contributors. All +rights reserved. + +This library is free software; you can redistribute it and/or +modify it under the same terms as Perl itself. + +Based on the ExtUtils::xsubpp code by Larry Wall and the Perl 5 +Porters, which was released under the same license terms. + +=head1 SEE ALSO + +L, ExtUtils::xsubpp, ExtUtils::MakeMaker, L, L. + +=cut diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/lib/ExtUtils/xsubpp b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/lib/ExtUtils/xsubpp new file mode 100644 index 0000000..e4e5b77 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/lib/ExtUtils/xsubpp @@ -0,0 +1,156 @@ +#!./miniperl + +require 5.002; +use ExtUtils::ParseXS qw(process_file); +use Getopt::Long; + +my %args = (); + +my $usage = "Usage: xsubpp [-v] [-csuffix csuffix] [-except] [-prototypes] [-noversioncheck] [-nolinenumbers] [-nooptimize] [-noinout] [-noargtypes] [-s pattern] [-typemap typemap]... file.xs\n"; + +Getopt::Long::Configure qw(no_auto_abbrev no_ignore_case); + +@ARGV = grep {$_ ne '-C++'} @ARGV; # Allow -C++ for backward compatibility +GetOptions(\%args, qw(hiertype! + prototypes! + versioncheck! + linenumbers! + optimize! + inout! + argtypes! + object_capi! + except! + v + typemap=s@ + output=s + s=s + csuffix=s + )) + or die $usage; + +if ($args{v}) { + print "xsubpp version $ExtUtils::ParseXS::VERSION\n"; + exit; +} + +@ARGV == 1 or die $usage; + +$args{filename} = shift @ARGV; + +process_file(%args); +exit( ExtUtils::ParseXS::errors() ? 1 : 0 ); + +__END__ + +=head1 NAME + +xsubpp - compiler to convert Perl XS code into C code + +=head1 SYNOPSIS + +B [B<-v>] [B<-except>] [B<-s pattern>] [B<-prototypes>] [B<-noversioncheck>] [B<-nolinenumbers>] [B<-nooptimize>] [B<-typemap typemap>] [B<-output filename>]... file.xs + +=head1 DESCRIPTION + +This compiler is typically run by the makefiles created by L. + +I will compile XS code into C code by embedding the constructs +necessary to let C functions manipulate Perl values and creates the glue +necessary to let Perl access those functions. The compiler uses typemaps to +determine how to map C function parameters and variables to Perl values. + +The compiler will search for typemap files called I. It will use +the following search path to find default typemaps, with the rightmost +typemap taking precedence. + + ../../../typemap:../../typemap:../typemap:typemap + +It will also use a default typemap installed as C. + +=head1 OPTIONS + +Note that the C MakeMaker option may be used to add these options to +any makefiles generated by MakeMaker. + +=over 5 + +=item B<-hiertype> + +Retains '::' in type names so that C++ hierarchical types can be mapped. + +=item B<-except> + +Adds exception handling stubs to the C code. + +=item B<-typemap typemap> + +Indicates that a user-supplied typemap should take precedence over the +default typemaps. This option may be used multiple times, with the last +typemap having the highest precedence. + +=item B<-output filename> + +Specifies the name of the output file to generate. If no file is +specified, output will be written to standard output. + +=item B<-v> + +Prints the I version number to standard output, then exits. + +=item B<-prototypes> + +By default I will not automatically generate prototype code for +all xsubs. This flag will enable prototypes. + +=item B<-noversioncheck> + +Disables the run time test that determines if the object file (derived +from the C<.xs> file) and the C<.pm> files have the same version +number. + +=item B<-nolinenumbers> + +Prevents the inclusion of `#line' directives in the output. + +=item B<-nooptimize> + +Disables certain optimizations. The only optimization that is currently +affected is the use of Is by the output C code (see L). +This may significantly slow down the generated code, but this is the way +B of 5.005 and earlier operated. + +=item B<-noinout> + +Disable recognition of C, C and C declarations. + +=item B<-noargtypes> + +Disable recognition of ANSI-like descriptions of function signature. + +=item B<-C++> + +Currently doesn't do anything at all. This flag has been a no-op for +many versions of perl, at least as far back as perl5.003_07. It's +allowed here for backwards compatibility. + +=back + +=head1 ENVIRONMENT + +No environment variables are used. + +=head1 AUTHOR + +Originally by Larry Wall. Turned into the C module +by Ken Williams. + +=head1 MODIFICATION HISTORY + +See the file F. + +=head1 SEE ALSO + +perl(1), perlxs(1), perlxstut(1), ExtUtils::ParseXS + +=cut + diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/XSInclude.xsh b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/XSInclude.xsh new file mode 100644 index 0000000..e70ecde --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/XSInclude.xsh @@ -0,0 +1,10 @@ + +# Testing the INCLUDE keyword + +int +include_ok() +CODE: + RETVAL = 1; +OUTPUT: + RETVAL + diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/XSMore.xs b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/XSMore.xs new file mode 100644 index 0000000..f2fe902 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/XSMore.xs @@ -0,0 +1,119 @@ +#include "EXTERN.h" +#include "perl.h" +#include "XSUB.h" + +=for testing + +This parts are ignored. + +=cut + +STATIC void +outlist(int* a, int* b){ + *a = 'a'; + *b = 'b'; +} + +STATIC int +len(const char* const s, int const l){ + return l; +} + +MODULE = XSMore PACKAGE = XSMore + +=for testing + +This parts are also ignored. + +=cut + +PROTOTYPES: ENABLE + +VERSIONCHECK: DISABLE + +REQUIRE: 2.20 + +SCOPE: DISABLE + +FALLBACK: TRUE + +BOOT: + sv_setiv(get_sv("XSMore::boot_ok", TRUE), 100); + + +void +prototype_ssa() +PROTOTYPE: $$@ +CODE: + NOOP; + +void +attr_method(self, ...) +ATTRS: method +CODE: + NOOP; + +#define RET_1 1 +#define RET_2 2 + +int +return_1() +CASE: ix == 1 + ALIAS: + return_1 = RET_1 + return_2 = RET_2 + CODE: + RETVAL = ix; + OUTPUT: + RETVAL +CASE: ix == 2 + CODE: + RETVAL = ix; + OUTPUT: + RETVAL + +int +arg_init(x) + int x = SvIV($arg); +CODE: + RETVAL = x; +OUTPUT: + RETVAL + +int +myabs(...) +OVERLOAD: abs +CODE: + RETVAL = 42; +OUTPUT: + RETVAL + +void +hook(IN AV* av) +INIT: + av_push(av, newSVpv("INIT", 0)); +CODE: + av_push(av, newSVpv("CODE", 0)); +POSTCALL: + av_push(av, newSVpv("POSTCALL", 0)); +CLEANUP: + av_push(av, newSVpv("CLEANUP", 0)); + + +void +outlist(OUTLIST int a, OUTLIST int b) + +int +len(char* s, int length(s)) + +INCLUDE_COMMAND: $^X -Ilib -It/lib -MIncludeTester -e IncludeTester::print_xs + +#if 1 + +INCLUDE: XSInclude.xsh + +#else + +# for testing #else directive + +#endif diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/XSTest.pm b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/XSTest.pm new file mode 100644 index 0000000..988ef47 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/XSTest.pm @@ -0,0 +1,8 @@ +package XSTest; + +require DynaLoader; +@ISA = qw(Exporter DynaLoader); +$VERSION = '0.01'; +bootstrap XSTest $VERSION; + +1; diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/XSTest.xs b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/XSTest.xs new file mode 100644 index 0000000..699c734 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/XSTest.xs @@ -0,0 +1,67 @@ +#include "EXTERN.h" +#include "perl.h" +#include "XSUB.h" + +void +xstest_something (char * some_thing) +{ + some_thing = some_thing; +} + +void +xstest_something2 (char * some_thing) +{ + some_thing = some_thing; +} + + +MODULE = XSTest PACKAGE = XSTest PREFIX = xstest_ + +PROTOTYPES: DISABLE + +int +is_even(input) + int input + CODE: + RETVAL = (input % 2 == 0); + OUTPUT: + RETVAL + +void +xstest_something (myclass, some_thing) + char * some_thing + C_ARGS: + some_thing + +void +xstest_something2 (some_thing) + char * some_thing + +void +xstest_something3 (myclass, some_thing) + SV * myclass + char * some_thing + PREINIT: + int i = 0; + PPCODE: + /* it's up to us clear these warnings */ + myclass = myclass; + some_thing = some_thing; + i = i; + XSRETURN_UNDEF; + +int +consts (myclass) + SV * myclass + ALIAS: + const_one = 1 + const_two = 2 + const_three = 3 + CODE: + /* it's up to us clear these warnings */ + myclass = myclass; + ix = ix; + RETVAL = 1; + OUTPUT: + RETVAL + diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/XSUsage.pm b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/XSUsage.pm new file mode 100644 index 0000000..a375428 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/XSUsage.pm @@ -0,0 +1,6 @@ +package XSUsage; + +require DynaLoader; +@ISA = qw(Exporter DynaLoader); +$VERSION = '0.01'; +bootstrap XSUsage $VERSION; diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/XSUsage.xs b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/XSUsage.xs new file mode 100644 index 0000000..ec663f8 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/XSUsage.xs @@ -0,0 +1,37 @@ +#include "EXTERN.h" +#include "perl.h" +#include "XSUB.h" + +int xsusage_one() { return 1; } +int xsusage_two() { return 2; } +int xsusage_three() { return 3; } +int xsusage_four() { return 4; } +int xsusage_five(int i) { return 5; } +int xsusage_six(int i) { return 6; } + +MODULE = XSUsage PACKAGE = XSUsage PREFIX = xsusage_ + +PROTOTYPES: DISABLE + +int +xsusage_one() + +int +xsusage_two() + ALIAS: + two_x = 1 + FOO::two = 2 + +int +interface_v_i() + INTERFACE: + xsusage_three + +int +xsusage_four(...) + +int +xsusage_five(int i, ...) + +int +xsusage_six(int i = 0) diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/basic.t b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/basic.t new file mode 100644 index 0000000..39e1ca9 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/basic.t @@ -0,0 +1,80 @@ +#!/usr/bin/perl + +use strict; +use Test::More; +use Config; +use DynaLoader; +use ExtUtils::CBuilder; + +plan tests => 10; + +my ($source_file, $obj_file, $lib_file); + +require_ok( 'ExtUtils::ParseXS' ); +ExtUtils::ParseXS->import('process_file'); + +chdir 't' or die "Can't chdir to t/, $!"; + +use Carp; $SIG{__WARN__} = \&Carp::cluck; + +######################### + +# Try sending to filehandle +tie *FH, 'Foo'; +process_file( filename => 'XSTest.xs', output => \*FH, prototypes => 1 ); +like tied(*FH)->content, '/is_even/', "Test that output contains some text"; + +$source_file = 'XSTest.c'; + +# Try sending to file +process_file(filename => 'XSTest.xs', output => $source_file, prototypes => 0); +ok -e $source_file, "Create an output file"; + +my $quiet = $ENV{PERL_CORE} && !$ENV{HARNESS_ACTIVE}; +my $b = ExtUtils::CBuilder->new(quiet => $quiet); + +SKIP: { + skip "no compiler available", 2 + if ! $b->have_compiler; + $obj_file = $b->compile( source => $source_file ); + ok $obj_file; + ok -e $obj_file, "Make sure $obj_file exists"; +} + +SKIP: { + skip "no dynamic loading", 5 + if !$b->have_compiler || !$Config{usedl}; + my $module = 'XSTest'; + $lib_file = $b->link( objects => $obj_file, module_name => $module ); + ok $lib_file; + ok -e $lib_file, "Make sure $lib_file exists"; + + eval {require XSTest}; + is $@, ''; + ok XSTest::is_even(8); + ok !XSTest::is_even(9); + + # Win32 needs to close the DLL before it can unlink it, but unfortunately + # dl_unload_file was missing on Win32 prior to perl change #24679! + if ($^O eq 'MSWin32' and defined &DynaLoader::dl_unload_file) { + for (my $i = 0; $i < @DynaLoader::dl_modules; $i++) { + if ($DynaLoader::dl_modules[$i] eq $module) { + DynaLoader::dl_unload_file($DynaLoader::dl_librefs[$i]); + last; + } + } + } +} + +unless ($ENV{PERL_NO_CLEANUP}) { + for ( $obj_file, $lib_file, $source_file) { + next unless defined $_; + 1 while unlink $_; + } +} + +##################################################################### + +sub Foo::TIEHANDLE { bless {}, 'Foo' } +sub Foo::PRINT { shift->{buf} .= join '', @_ } +sub Foo::content { shift->{buf} } diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/bugs/RT48104.xs b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/bugs/RT48104.xs new file mode 100644 index 0000000..87fbc44 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/bugs/RT48104.xs @@ -0,0 +1,115 @@ +// ***** BEGIN LICENSE BLOCK ***** +// Version: MPL 1.1/GPL 2.0/LGPL 2.1 +// +// The contents of this file are subject to the Mozilla Public License Version +// 1.1 (the "License"); you may not use this file except in compliance with +// the License. You may obtain a copy of the License at +// http://www.mozilla.org/MPL/ +// +// Software distributed under the License is distributed on an "AS IS" basis, +// WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License +// for the specific language governing rights and limitations under the +// License. +// +// The Original Code is Encode::Detect wrapper +// +// The Initial Developer of the Original Code is +// Proofpoint, Inc. +// Portions created by the Initial Developer are Copyright (C) 2005 +// the Initial Developer. All Rights Reserved. +// +// Contributor(s): +// +// Alternatively, the contents of this file may be used under the terms of +// either the GNU General Public License Version 2 or later (the "GPL"), or +// the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), +// in which case the provisions of the GPL or the LGPL are applicable instead +// of those above. If you wish to allow use of your version of this file only +// under the terms of either the GPL or the LGPL, and not to allow others to +// use your version of this file under the terms of the MPL, indicate your +// decision by deleting the provisions above and replace them with the notice +// and other provisions required by the GPL or the LGPL. If you do not delete +// the provisions above, a recipient may use your version of this file under +// the terms of any one of the MPL, the GPL or the LGPL. +// +// ***** END LICENSE BLOCK ***** + +extern "C" { +#define PERL_NO_GET_CONTEXT /* we want efficiency */ +#include "EXTERN.h" +#include "perl.h" + +// work around perlbug #39634 +#if __GNUC__ == 3 && __GNUC_MINOR__ <= 3 +#undef HASATTRIBUTE_UNUSED +#endif + +#include "XSUB.h" +} + +#include "nscore.h" +#include "nsUniversalDetector.h" + +class Detector: public nsUniversalDetector { + public: + Detector() {}; + virtual ~Detector() {} + const char *getresult() { return mDetectedCharset; } + virtual void Reset() { this->nsUniversalDetector::Reset(); } + protected: + virtual void Report(const char* aCharset) { mDetectedCharset = aCharset; } +}; + + +MODULE = Encode::Detect::Detector PACKAGE = Encode::Detect::Detector +PROTOTYPES: ENABLE + + +Detector * +Detector::new() + +void +Detector::DESTROY() + +int +Detector::handle(SV *buf) + CODE: + STRLEN len; + char *ptr = SvPV(buf, len); + RETVAL = THIS->HandleData(ptr, len); + OUTPUT: + RETVAL + +void +Detector::eof() + CODE: + THIS->DataEnd(); + +void +Detector::reset() + CODE: + THIS->Reset(); + +const char * +Detector::getresult() + CODE: + RETVAL = THIS->getresult(); + OUTPUT: + RETVAL + + +const char * +detect(buf) + SV *buf + CODE: + STRLEN len; + char *ptr = SvPV(buf, len); + + Detector *det = new Detector; + det->HandleData(ptr, len); + det->DataEnd(); + RETVAL = det->getresult(); + delete det; + OUTPUT: + RETVAL + diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/bugs/typemap b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/bugs/typemap new file mode 100644 index 0000000..9e2ebb9 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/bugs/typemap @@ -0,0 +1,18 @@ +TYPEMAP +Detector * O_OBJECT + +INPUT +O_OBJECT + if (sv_isobject($arg) && (SvTYPE(SvRV($arg)) == SVt_PVMG)) { + $var = ($type)SvIV((SV*)SvRV( $arg )); + } else { + warn(\"${Package}::$func_name() -- $var is not a blessed SV reference\"); + XSRETURN_UNDEF; + } + +OUTPUT +# The Perl object is blessed into 'CLASS', which should be a +# char * having the name of the package for the blessing. +O_OBJECT + sv_setref_pv($arg, CLASS, (void*)$var); + diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/include/nsUniversalDetector.h b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/include/nsUniversalDetector.h new file mode 100644 index 0000000..36f3fa0 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/include/nsUniversalDetector.h @@ -0,0 +1,75 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Mozilla Communicator client code. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef nsUniversalDetector_h__ +#define nsUniversalDetector_h__ + +class nsCharSetProber; + +#define NUM_OF_CHARSET_PROBERS 3 + +typedef enum { + ePureAscii = 0, + eEscAscii = 1, + eHighbyte = 2 +} nsInputState; + +class nsUniversalDetector { +public: + nsUniversalDetector(); + virtual ~nsUniversalDetector(); + virtual nsresult HandleData(const char* aBuf, PRUint32 aLen); + virtual void DataEnd(void); + +protected: + virtual void Report(const char* aCharset) = 0; + virtual void Reset(); + nsInputState mInputState; + PRBool mDone; + PRBool mInTag; + PRBool mStart; + PRBool mGotData; + char mLastChar; + const char * mDetectedCharset; + PRInt32 mBestGuess; + + nsCharSetProber *mCharSetProbers[NUM_OF_CHARSET_PROBERS]; + nsCharSetProber *mEscCharSetProber; +}; + +#endif + diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/include/nscore.h b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/include/nscore.h new file mode 100644 index 0000000..e130608 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/include/nscore.h @@ -0,0 +1,20 @@ +#ifndef INCLUDED_NSCORE_H +#define INCLUDED_NSCORE_H + +typedef short PRInt16; +typedef unsigned short PRUint16; + +typedef int PRInt32; +typedef unsigned PRUint32; + +typedef int PRBool; +#define PR_TRUE 1 +#define PR_FALSE 0 + +#define nsnull 0 + +typedef PRUint32 nsresult; +#define NS_OK 0 +#define NS_ERROR_OUT_OF_MEMORY ((nsresult)(0x8007000eL)) + +#endif /* INCLUDED_NSCORE_H */ diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/lib/IncludeTester.pm b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/lib/IncludeTester.pm new file mode 100644 index 0000000..8d16254 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/lib/IncludeTester.pm @@ -0,0 +1,20 @@ +package IncludeTester; +use strict; + +sub print_xs { + print <<'HERE'; + +int +sum(a, b) + int a + int b + CODE: + RETVAL = a + b; + OUTPUT: + RETVAL + +HERE +} + +1; + diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/more.t b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/more.t new file mode 100644 index 0000000..2e55976 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/more.t @@ -0,0 +1,110 @@ +#!/usr/bin/perl + +use strict; +use Test::More; +use Config; +use DynaLoader; +use ExtUtils::CBuilder; +use attributes; +use overload; + +plan tests => 25; + +my ($source_file, $obj_file, $lib_file); + +require_ok( 'ExtUtils::ParseXS' ); +ExtUtils::ParseXS->import('process_file'); + +chdir 't' or die "Can't chdir to t/, $!"; + +use Carp; $SIG{__WARN__} = \&Carp::cluck; + +######################### + +$source_file = 'XSMore.c'; + +# Try sending to file +ExtUtils::ParseXS->process_file( + filename => 'XSMore.xs', + output => $source_file, +); +ok -e $source_file, "Create an output file"; + +my $quiet = $ENV{PERL_CORE} && !$ENV{HARNESS_ACTIVE}; +my $b = ExtUtils::CBuilder->new(quiet => $quiet); + +SKIP: { + skip "no compiler available", 2 + if ! $b->have_compiler; + $obj_file = $b->compile( source => $source_file ); + ok $obj_file; + ok -e $obj_file, "Make sure $obj_file exists"; +} + +SKIP: { + skip "no dynamic loading", 6 + if !$b->have_compiler || !$Config{usedl}; + my $module = 'XSMore'; + $lib_file = $b->link( objects => $obj_file, module_name => $module ); + ok $lib_file; + ok -e $lib_file, "Make sure $lib_file exists"; + + eval{ + package XSMore; + our $VERSION = 42; + our $boot_ok; + DynaLoader::bootstrap_inherit(__PACKAGE__, $VERSION); # VERSIONCHECK disabled + + sub new{ bless {}, shift } + }; + is $@, ''; + is ExtUtils::ParseXS::errors(), 0, 'ExtUtils::ParseXS::errors()'; + + is $XSMore::boot_ok, 100, 'the BOOT keyword'; + + ok XSMore::include_ok(), 'the INCLUDE keyword'; + is prototype(\&XSMore::include_ok), "", 'the PROTOTYPES keyword'; + + is prototype(\&XSMore::prototype_ssa), '$$@', 'the PROTOTYPE keyword'; + + is_deeply [attributes::get(\&XSMore::attr_method)], [qw(method)], 'the ATTRS keyword'; + is prototype(\&XSMore::attr_method), '$;@', 'ATTRS with prototype'; + + is XSMore::return_1(), 1, 'the CASE keyword (1)'; + is XSMore::return_2(), 2, 'the CASE keyword (2)'; + is prototype(\&XSMore::return_1), "", 'ALIAS with prototype (1)'; + is prototype(\&XSMore::return_2), "", 'ALIAS with prototype (2)'; + + is XSMore::arg_init(200), 200, 'argument init'; + + ok overload::Overloaded(XSMore->new), 'the FALLBACK keyword'; + is abs(XSMore->new), 42, 'the OVERLOAD keyword'; + + my @a; + XSMore::hook(\@a); + is_deeply \@a, [qw(INIT CODE POSTCALL CLEANUP)], 'the INIT & POSTCALL & CLEANUP keywords'; + + is_deeply [XSMore::outlist()], [ord('a'), ord('b')], 'the OUTLIST keyword'; + + is XSMore::len("foo"), 3, 'the length keyword'; + + is XSMore::sum(5, 9), 14, 'the INCLUDE_COMMAND directive'; + + # Win32 needs to close the DLL before it can unlink it, but unfortunately + # dl_unload_file was missing on Win32 prior to perl change #24679! + if ($^O eq 'MSWin32' and defined &DynaLoader::dl_unload_file) { + for (my $i = 0; $i < @DynaLoader::dl_modules; $i++) { + if ($DynaLoader::dl_modules[$i] eq $module) { + DynaLoader::dl_unload_file($DynaLoader::dl_librefs[$i]); + last; + } + } + } +} + +unless ($ENV{PERL_NO_CLEANUP}) { + for ( $obj_file, $lib_file, $source_file) { + next unless defined $_; + 1 while unlink $_; + } +} diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/typemap b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/typemap new file mode 100644 index 0000000..2c35437 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/typemap @@ -0,0 +1,336 @@ +# basic C types +int T_IV +unsigned T_UV +unsigned int T_UV +long T_IV +unsigned long T_UV +short T_IV +unsigned short T_UV +char T_CHAR +unsigned char T_U_CHAR +char * T_PV +unsigned char * T_PV +const char * T_PV +caddr_t T_PV +wchar_t * T_PV +wchar_t T_IV +# bool_t is defined in +bool_t T_IV +size_t T_UV +ssize_t T_IV +time_t T_NV +unsigned long * T_OPAQUEPTR +char ** T_PACKEDARRAY +void * T_PTR +Time_t * T_PV +SV * T_SV +SVREF T_SVREF +AV * T_AVREF +HV * T_HVREF +CV * T_CVREF + +IV T_IV +UV T_UV +NV T_NV +I32 T_IV +I16 T_IV +I8 T_IV +STRLEN T_UV +U32 T_U_LONG +U16 T_U_SHORT +U8 T_UV +Result T_U_CHAR +Boolean T_BOOL +float T_FLOAT +double T_DOUBLE +SysRet T_SYSRET +SysRetLong T_SYSRET +FILE * T_STDIO +PerlIO * T_INOUT +FileHandle T_PTROBJ +InputStream T_IN +InOutStream T_INOUT +OutputStream T_OUT +bool T_BOOL + +############################################################################# +INPUT +T_SV + $var = $arg +T_SVREF + if (SvROK($arg)) + $var = (SV*)SvRV($arg); + else + Perl_croak(aTHX_ \"%s: %s is not a reference\", + ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, + \"$var\") +T_AVREF + if (SvROK($arg) && SvTYPE(SvRV($arg))==SVt_PVAV) + $var = (AV*)SvRV($arg); + else + Perl_croak(aTHX_ \"%s: %s is not an array reference\", + ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, + \"$var\") +T_HVREF + if (SvROK($arg) && SvTYPE(SvRV($arg))==SVt_PVHV) + $var = (HV*)SvRV($arg); + else + Perl_croak(aTHX_ \"%s: %s is not a hash reference\", + ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, + \"$var\") +T_CVREF + if (SvROK($arg) && SvTYPE(SvRV($arg))==SVt_PVCV) + $var = (CV*)SvRV($arg); + else + Perl_croak(aTHX_ \"%s: %s is not a code reference\", + ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, + \"$var\") +T_SYSRET + $var NOT IMPLEMENTED +T_UV + $var = ($type)SvUV($arg) +T_IV + $var = ($type)SvIV($arg) +T_INT + $var = (int)SvIV($arg) +T_ENUM + $var = ($type)SvIV($arg) +T_BOOL + $var = (bool)SvTRUE($arg) +T_U_INT + $var = (unsigned int)SvUV($arg) +T_SHORT + $var = (short)SvIV($arg) +T_U_SHORT + $var = (unsigned short)SvUV($arg) +T_LONG + $var = (long)SvIV($arg) +T_U_LONG + $var = (unsigned long)SvUV($arg) +T_CHAR + $var = (char)*SvPV_nolen($arg) +T_U_CHAR + $var = (unsigned char)SvUV($arg) +T_FLOAT + $var = (float)SvNV($arg) +T_NV + $var = ($type)SvNV($arg) +T_DOUBLE + $var = (double)SvNV($arg) +T_PV + $var = ($type)SvPV_nolen($arg) +T_PTR + $var = INT2PTR($type,SvIV($arg)) +T_PTRREF + if (SvROK($arg)) { + IV tmp = SvIV((SV*)SvRV($arg)); + $var = INT2PTR($type,tmp); + } + else + Perl_croak(aTHX_ \"%s: %s is not a reference\", + ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, + \"$var\") +T_REF_IV_REF + if (sv_isa($arg, \"${ntype}\")) { + IV tmp = SvIV((SV*)SvRV($arg)); + $var = *INT2PTR($type *, tmp); + } + else + Perl_croak(aTHX_ \"%s: %s is not of type %s\", + ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, + \"$var\", \"$ntype\") +T_REF_IV_PTR + if (sv_isa($arg, \"${ntype}\")) { + IV tmp = SvIV((SV*)SvRV($arg)); + $var = INT2PTR($type, tmp); + } + else + Perl_croak(aTHX_ \"%s: %s is not of type %s\", + ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, + \"$var\", \"$ntype\") +T_PTROBJ + if (sv_derived_from($arg, \"${ntype}\")) { + IV tmp = SvIV((SV*)SvRV($arg)); + $var = INT2PTR($type,tmp); + } + else + Perl_croak(aTHX_ \"%s: %s is not of type %s\", + ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, + \"$var\", \"$ntype\") +T_PTRDESC + if (sv_isa($arg, \"${ntype}\")) { + IV tmp = SvIV((SV*)SvRV($arg)); + ${type}_desc = (\U${type}_DESC\E*) tmp; + $var = ${type}_desc->ptr; + } + else + Perl_croak(aTHX_ \"%s: %s is not of type %s\", + ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, + \"$var\", \"$ntype\") +T_REFREF + if (SvROK($arg)) { + IV tmp = SvIV((SV*)SvRV($arg)); + $var = *INT2PTR($type,tmp); + } + else + Perl_croak(aTHX_ \"%s: %s is not a reference\", + ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, + \"$var\") +T_REFOBJ + if (sv_isa($arg, \"${ntype}\")) { + IV tmp = SvIV((SV*)SvRV($arg)); + $var = *INT2PTR($type,tmp); + } + else + Perl_croak(aTHX_ \"%s: %s is not of type %s\", + ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, + \"$var\", \"$ntype\") +T_OPAQUE + $var = *($type *)SvPV_nolen($arg) +T_OPAQUEPTR + $var = ($type)SvPV_nolen($arg) +T_PACKED + $var = XS_unpack_$ntype($arg) +T_PACKEDARRAY + $var = XS_unpack_$ntype($arg) +T_CALLBACK + $var = make_perl_cb_$type($arg) +T_ARRAY + U32 ix_$var = $argoff; + $var = $ntype(items -= $argoff); + while (items--) { + DO_ARRAY_ELEM; + ix_$var++; + } + /* this is the number of elements in the array */ + ix_$var -= $argoff +T_STDIO + $var = PerlIO_findFILE(IoIFP(sv_2io($arg))) +T_IN + $var = IoIFP(sv_2io($arg)) +T_INOUT + $var = IoIFP(sv_2io($arg)) +T_OUT + $var = IoOFP(sv_2io($arg)) +############################################################################# +OUTPUT +T_SV + $arg = $var; +T_SVREF + $arg = newRV((SV*)$var); +T_AVREF + $arg = newRV((SV*)$var); +T_HVREF + $arg = newRV((SV*)$var); +T_CVREF + $arg = newRV((SV*)$var); +T_IV + sv_setiv($arg, (IV)$var); +T_UV + sv_setuv($arg, (UV)$var); +T_INT + sv_setiv($arg, (IV)$var); +T_SYSRET + if ($var != -1) { + if ($var == 0) + sv_setpvn($arg, "0 but true", 10); + else + sv_setiv($arg, (IV)$var); + } +T_ENUM + sv_setiv($arg, (IV)$var); +T_BOOL + $arg = boolSV($var); +T_U_INT + sv_setuv($arg, (UV)$var); +T_SHORT + sv_setiv($arg, (IV)$var); +T_U_SHORT + sv_setuv($arg, (UV)$var); +T_LONG + sv_setiv($arg, (IV)$var); +T_U_LONG + sv_setuv($arg, (UV)$var); +T_CHAR + sv_setpvn($arg, (char *)&$var, 1); +T_U_CHAR + sv_setuv($arg, (UV)$var); +T_FLOAT + sv_setnv($arg, (double)$var); +T_NV + sv_setnv($arg, (NV)$var); +T_DOUBLE + sv_setnv($arg, (double)$var); +T_PV + sv_setpv((SV*)$arg, $var); +T_PTR + sv_setiv($arg, PTR2IV($var)); +T_PTRREF + sv_setref_pv($arg, Nullch, (void*)$var); +T_REF_IV_REF + sv_setref_pv($arg, \"${ntype}\", (void*)new $ntype($var)); +T_REF_IV_PTR + sv_setref_pv($arg, \"${ntype}\", (void*)$var); +T_PTROBJ + sv_setref_pv($arg, \"${ntype}\", (void*)$var); +T_PTRDESC + sv_setref_pv($arg, \"${ntype}\", (void*)new\U${type}_DESC\E($var)); +T_REFREF + NOT_IMPLEMENTED +T_REFOBJ + NOT IMPLEMENTED +T_OPAQUE + sv_setpvn($arg, (char *)&$var, sizeof($var)); +T_OPAQUEPTR + sv_setpvn($arg, (char *)$var, sizeof(*$var)); +T_PACKED + XS_pack_$ntype($arg, $var); +T_PACKEDARRAY + XS_pack_$ntype($arg, $var, count_$ntype); +T_DATAUNIT + sv_setpvn($arg, $var.chp(), $var.size()); +T_CALLBACK + sv_setpvn($arg, $var.context.value().chp(), + $var.context.value().size()); +T_ARRAY + { + U32 ix_$var; + EXTEND(SP,size_$var); + for (ix_$var = 0; ix_$var < size_$var; ix_$var++) { + ST(ix_$var) = sv_newmortal(); + DO_ARRAY_ELEM + } + } +T_STDIO + { + GV *gv = newGVgen("$Package"); + PerlIO *fp = PerlIO_importFILE($var,0); + if ( fp && do_open(gv, "+<&", 3, FALSE, 0, 0, fp) ) + sv_setsv($arg, sv_bless(newRV((SV*)gv), gv_stashpv("$Package",1))); + else + $arg = &PL_sv_undef; + } +T_IN + { + GV *gv = newGVgen("$Package"); + if ( do_open(gv, "<&", 2, FALSE, 0, 0, $var) ) + sv_setsv($arg, sv_bless(newRV((SV*)gv), gv_stashpv("$Package",1))); + else + $arg = &PL_sv_undef; + } +T_INOUT + { + GV *gv = newGVgen("$Package"); + if ( do_open(gv, "+<&", 3, FALSE, 0, 0, $var) ) + sv_setsv($arg, sv_bless(newRV((SV*)gv), gv_stashpv("$Package",1))); + else + $arg = &PL_sv_undef; + } +T_OUT + { + GV *gv = newGVgen("$Package"); + if ( do_open(gv, "+>&", 3, FALSE, 0, 0, $var) ) + sv_setsv($arg, sv_bless(newRV((SV*)gv), gv_stashpv("$Package",1))); + else + $arg = &PL_sv_undef; + } diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/usage.t b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/usage.t new file mode 100644 index 0000000..3d6ed79 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl-2.220200/t/usage.t @@ -0,0 +1,117 @@ +#!/usr/bin/perl + +use strict; +use Test::More; +use Config; +use DynaLoader; +use ExtUtils::CBuilder; + +if ( $] < 5.008 ) { + plan skip_all => "INTERFACE keyword support broken before 5.8"; +} +else { + plan tests => 24; +} + +my ($source_file, $obj_file, $lib_file, $module); + +require_ok( 'ExtUtils::ParseXS' ); +ExtUtils::ParseXS->import('process_file'); + +chdir 't' or die "Can't chdir to t/, $!"; + +use Carp; $SIG{__WARN__} = \&Carp::cluck; + +######################### + +$source_file = 'XSUsage.c'; + +# Try sending to file +process_file(filename => 'XSUsage.xs', output => $source_file); +ok -e $source_file, "Create an output file"; + +# TEST doesn't like extraneous output +my $quiet = $ENV{PERL_CORE} && !$ENV{HARNESS_ACTIVE}; + +# Try to compile the file! Don't get too fancy, though. +my $b = ExtUtils::CBuilder->new(quiet => $quiet); + +SKIP: { + skip "no compiler available", 2 + if ! $b->have_compiler; + $module = 'XSUsage'; + + $obj_file = $b->compile( source => $source_file ); + ok $obj_file; + ok -e $obj_file, "Make sure $obj_file exists"; +} +SKIP: { + skip "no dynamic loading", 20 + if !$b->have_compiler || !$Config{usedl}; + + $lib_file = $b->link( objects => $obj_file, module_name => $module ); + ok $lib_file; + ok -e $lib_file, "Make sure $lib_file exists"; + + eval {require XSUsage}; + is $@, ''; + + # The real tests here - for each way of calling the functions, call with the + # wrong number of arguments and check the Usage line is what we expect + + eval { XSUsage::one(1) }; + ok $@; + ok $@ =~ /^Usage: XSUsage::one/; + + eval { XSUsage::two(1) }; + ok $@; + ok $@ =~ /^Usage: XSUsage::two/; + + eval { XSUsage::two_x(1) }; + ok $@; + ok $@ =~ /^Usage: XSUsage::two_x/; + + eval { FOO::two(1) }; + ok $@; + ok $@ =~ /^Usage: FOO::two/; + + eval { XSUsage::three(1) }; + ok $@; + ok $@ =~ /^Usage: XSUsage::three/; + + eval { XSUsage::four(1) }; + ok !$@; + + eval { XSUsage::five() }; + ok $@; + ok $@ =~ /^Usage: XSUsage::five/; + + eval { XSUsage::six() }; + ok !$@; + + eval { XSUsage::six(1) }; + ok !$@; + + eval { XSUsage::six(1,2) }; + ok $@; + ok $@ =~ /^Usage: XSUsage::six/; + + # Win32 needs to close the DLL before it can unlink it, but unfortunately + # dl_unload_file was missing on Win32 prior to perl change #24679! + if ($^O eq 'MSWin32' and defined &DynaLoader::dl_unload_file) { + for (my $i = 0; $i < @DynaLoader::dl_modules; $i++) { + if ($DynaLoader::dl_modules[$i] eq $module) { + DynaLoader::dl_unload_file($DynaLoader::dl_librefs[$i]); + last; + } + } + } +} + +unless ($ENV{PERL_NO_CLEANUP}) { + for ( $obj_file, $lib_file, $source_file) { + next unless defined $_; + 1 while unlink $_; + } +} + diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl_2.220200-1.diff.gz b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl_2.220200-1.diff.gz new file mode 100644 index 0000000..e152284 Binary files /dev/null and b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl_2.220200-1.diff.gz differ diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl_2.220200-1.dsc b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl_2.220200-1.dsc new file mode 100644 index 0000000..e1f1799 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl_2.220200-1.dsc @@ -0,0 +1,43 @@ +-----BEGIN PGP SIGNED MESSAGE----- +Hash: SHA256 + +Format: 1.0 +Source: libextutils-parsexs-perl +Binary: libextutils-parsexs-perl +Architecture: all +Version: 2.220200-1 +Maintainer: Debian Perl Group +Uploaders: AGOSTINI Yves , Jonathan Yu , Damyan Ivanov +Homepage: http://search.cpan.org/dist/ExtUtils-ParseXS/ +Standards-Version: 3.8.4 +Vcs-Browser: http://svn.debian.org/viewsvn/pkg-perl/trunk/libextutils-parsexs-perl/ +Vcs-Svn: svn://svn.debian.org/pkg-perl/trunk/libextutils-parsexs-perl/ +Build-Depends: debhelper (>= 7) +Build-Depends-Indep: perl, libextutils-cbuilder-perl +Checksums-Sha1: + a395d996ccec81813a1d2e51ef65f3242e57a7b8 40651 libextutils-parsexs-perl_2.220200.orig.tar.gz + a1386a2eef93a9838f8dec665ce92d815c3abcd2 3238 libextutils-parsexs-perl_2.220200-1.diff.gz +Checksums-Sha256: + b485d855a932e2d951247b51325d1aa6affcc190d0b97e8eec184c193581ccf9 40651 libextutils-parsexs-perl_2.220200.orig.tar.gz + 52eecc90d2159c7123f7c54a33b7aafb9601ccd81dc277a4b85f301b07b6a4b7 3238 libextutils-parsexs-perl_2.220200-1.diff.gz +Files: + 271b4413b1847568401393b7634b44ab 40651 libextutils-parsexs-perl_2.220200.orig.tar.gz + de61512b66d864085db0cd721d796db0 3238 libextutils-parsexs-perl_2.220200-1.diff.gz + +-----BEGIN PGP SIGNATURE----- +Version: GnuPG v1.4.10 (GNU/Linux) + +iQIcBAEBCAAGBQJLZECeAAoJELs6aAGGSaoGAW8P/06EnCB9k8eF3GF70gbMm1nW +WZ6xZVEDGmvCWnW4L6Jf+erW7Rdp3IH9sSuwDqProGJO/SfKlmUT4GsW3opb3zhr ++BlMXIxVNPHJXsGnTwOl7VNHcK2eoZ99KU/1L2FbDCdFgj6ieZdaT+6xua+Dg9Y6 +TKL7BkWfBHTiO0u8HFJ75cZ14v3bOS0cQexAfVg23XCEtKdEDZ4aGvkxOZjf0Qxb +cBH/X6Jux8PF9cfjI377K55vulwx74NWOfgmJogpr6vJo3GiMHzNemqfpgzV53bn +4w8J8z9/7iKjC5QrZpgC1WcBEknSy4E7OffIUwyaBxlCkVN+YBO6E5KC2WtXxrqT +Jmb2ansFDAAHJRj17w7U3/y1SI851AQq1ft6Q/3pcT8EtowWqXsP/SEM0zwHTh77 +hitDg9jllNrRpHA6e2uwkurbN0QqYXVfEqzH5EaOqRo+5287gEmfRUKfQS2IzTwY +JOjk+Pq5A7DnKIFU2ebU/wgu7iJSXpo044DQu5UACDMZM8EfMPC2dx5QEOj2lsJp +MND5BUKoUQqXutS07XUAq1LablH8FFrrqRdF+P9z952JhLfuCOrhxyVuKhaut0qA +P00rQKBzsdf6JNqm0+Hqsecz71zoB8NCoLnJ6+gwHPtDbyqoYbgFhkUGuxY4/pq2 +dkBlXpRcWQ41N76gPZBn +=5dQS +-----END PGP SIGNATURE----- diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl_2.220200-1maemo1.diff.gz b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl_2.220200-1maemo1.diff.gz new file mode 100644 index 0000000..5aeead9 Binary files /dev/null and b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl_2.220200-1maemo1.diff.gz differ diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl_2.220200-1maemo1.dsc b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl_2.220200-1maemo1.dsc new file mode 100644 index 0000000..b4a3188 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl_2.220200-1maemo1.dsc @@ -0,0 +1,13 @@ +Format: 1.0 +Source: libextutils-parsexs-perl +Version: 2.220200-1maemo1 +Binary: libextutils-parsexs-perl +Maintainer: Debian Perl Group +Architecture: all +Standards-Version: 3.8.4 +Build-Depends: debhelper7 +Build-Depends-Indep: perl, libextutils-cbuilder-perl +Uploaders: AGOSTINI Yves , Jonathan Yu , Damyan Ivanov +Files: + 271b4413b1847568401393b7634b44ab 40651 libextutils-parsexs-perl_2.220200.orig.tar.gz + 5752df2870cc0720082fa28d3e8116eb 3292 libextutils-parsexs-perl_2.220200-1maemo1.diff.gz diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl_2.220200-1maemo1_i386.changes b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl_2.220200-1maemo1_i386.changes new file mode 100644 index 0000000..1a9c227 --- /dev/null +++ b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl_2.220200-1maemo1_i386.changes @@ -0,0 +1,20 @@ +Format: 1.7 +Date: Fri, 16 Apr 2010 07:12:39 +0100 +Source: libextutils-parsexs-perl +Binary: libextutils-parsexs-perl +Architecture: source all +Version: 2.220200-1maemo1 +Distribution: fremantle +Urgency: low +Maintainer: Debian Perl Group +Changed-By: Nito Martinez +Description: + libextutils-parsexs-perl - Perl utility to process Perl XS code into C code +Changes: + libextutils-parsexs-perl (2.220200-1maemo1) fremantle; urgency=low + . + * New Maemo packaging +Files: + 9f705ab312a92783bbe129b64be32e73 598 perl optional libextutils-parsexs-perl_2.220200-1maemo1.dsc + 5752df2870cc0720082fa28d3e8116eb 3292 perl optional libextutils-parsexs-perl_2.220200-1maemo1.diff.gz + 782f0ec4984306c637d3e0b77408ea29 35032 perl optional libextutils-parsexs-perl_2.220200-1maemo1_all.deb diff --git a/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl_2.220200.orig.tar.gz b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl_2.220200.orig.tar.gz new file mode 100644 index 0000000..3b9eb0a Binary files /dev/null and b/deb-src/libextutils-parsexs-perl/libextutils-parsexs-perl_2.220200.orig.tar.gz differ diff --git a/deb/pool/main/libe/libextutils-parsexs-perl/libextutils-parsexs-perl_2.220200-1maemo1_all.deb b/deb/pool/main/libe/libextutils-parsexs-perl/libextutils-parsexs-perl_2.220200-1maemo1_all.deb new file mode 100644 index 0000000..fcc1344 Binary files /dev/null and b/deb/pool/main/libe/libextutils-parsexs-perl/libextutils-parsexs-perl_2.220200-1maemo1_all.deb differ