Hello community,
here is the log from the commit of package perl-Parse-RecDescent for
openSUSE:Factory checked in at 2015-09-24 06:13:11
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/perl-Parse-RecDescent (Old)
and /work/SRC/openSUSE:Factory/.perl-Parse-RecDescent.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "perl-Parse-RecDescent"
Changes:
--------
---
/work/SRC/openSUSE:Factory/perl-Parse-RecDescent/perl-Parse-RecDescent.changes
2012-06-01 22:32:33.000000000 +0200
+++
/work/SRC/openSUSE:Factory/.perl-Parse-RecDescent.new/perl-Parse-RecDescent.changes
2015-09-24 06:13:13.000000000 +0200
@@ -1,0 +2,6 @@
+Mon Sep 14 08:51:35 UTC 2015 - [email protected]
+
+- updated to 1.967012
+ see /usr/share/doc/packages/perl-Parse-RecDescent/Changes
+
+-------------------------------------------------------------------
Old:
----
Parse-RecDescent-1.967009.tar.gz
New:
----
Parse-RecDescent-1.967012.tar.gz
cpanspec.yml
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ perl-Parse-RecDescent.spec ++++++
--- /var/tmp/diff_new_pack.8cXTJm/_old 2015-09-24 06:13:14.000000000 +0200
+++ /var/tmp/diff_new_pack.8cXTJm/_new 2015-09-24 06:13:14.000000000 +0200
@@ -1,7 +1,7 @@
#
# spec file for package perl-Parse-RecDescent
#
-# Copyright (c) 2012 SUSE LINUX Products GmbH, Nuernberg, Germany.
+# Copyright (c) 2015 SUSE LINUX GmbH, Nuernberg, Germany.
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
@@ -17,24 +17,19 @@
Name: perl-Parse-RecDescent
-Version: 1.967009
+Version: 1.967012
Release: 0
%define cpan_name Parse-RecDescent
Summary: Generate Recursive-Descent Parsers
License: GPL-1.0+ or Artistic-1.0
Group: Development/Libraries/Perl
Url: http://search.cpan.org/dist/Parse-RecDescent/
-Source:
http://www.cpan.org/authors/id/J/JT/JTBRAUN/%{cpan_name}-%{version}.tar.gz
+Source0:
http://www.cpan.org/authors/id/J/JT/JTBRAUN/%{cpan_name}-%{version}.tar.gz
+Source1: cpanspec.yml
BuildRoot: %{_tmppath}/%{name}-%{version}-build
BuildRequires: perl
BuildRequires: perl-macros
-BuildRequires: perl(ExtUtils::MakeMaker) >= 6.57
BuildRequires: perl(Module::Build)
-#BuildRequires: perl(AutoDump)
-#BuildRequires: perl(Calc)
-#BuildRequires: perl(CGrammar)
-#BuildRequires: perl(DecommentGrammar)
-#BuildRequires: perl(Parse::RecDescent)
%{perl_requires}
%description
++++++ Parse-RecDescent-1.967009.tar.gz -> Parse-RecDescent-1.967012.tar.gz
++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Parse-RecDescent-1.967009/Changes
new/Parse-RecDescent-1.967012/Changes
--- old/Parse-RecDescent-1.967009/Changes 2012-03-16 15:25:51.000000000
+0100
+++ new/Parse-RecDescent-1.967012/Changes 2015-09-13 17:00:59.000000000
+0200
@@ -753,45 +753,82 @@
1.967_005 Wed Feb 8 18:46:35 2012
- - Added [email protected] as author in Build.PL.
+ - Added [email protected] as author in Build.PL.
- - Added ExtUtils::MakeMaker build/configure version
- requirements. (RT.cpan.org #74787, Thanks POPEL!)
+ - Added ExtUtils::MakeMaker build/configure version
+ requirements. (RT.cpan.org #74787, Thanks POPEL!)
1.967006 Fri Feb 10 20:48:48 2012
- - Bumped version to 1.967006 for non-development release.
+ - Bumped version to 1.967006 for non-development release.
1.967_007 Thu Feb 23 07:26:03 2012
- - Revised ExtUtils::MakeMaker build/configure version
- requirements. (RT.cpan.org #74787, Thanks Paul!)
+ - Revised ExtUtils::MakeMaker build/configure version
+ requirements. (RT.cpan.org #74787, Thanks Paul!)
- - Revised Text::Balanced prereq to require version 1.95,
- necessary for t/skip.t to pass.
- (RT.cpan.org #74787, Thanks Paul!)
-
- - Removed unused version.pm prereq.
-
- - Fix a circular reference memory leak caused by the use of
- $AUTOLOAD in sub AUTOLOAD{} in the generated parser's
- namespace. Workaround documented in perl5 RT #110248.
- Workaround a circular reference memory leak in ISA documented
- by perl5 RT #92708. A parser's DESTROY() method redefines all
- subs before deleting the stash, to avoid circular references
- between subrules. (RT #53710, thanks Andreas!)
-
- - Parse::RecDescent::AUTOLOAD did not correctly handle
- initializing the line counting mechanism when a reference to a
- scalar was passed to the parser. (RT.cpan.org #27705, thanks
- Justin!)
+ - Revised Text::Balanced prereq to require version 1.95, necessary
+ for t/skip.t to pass. (RT.cpan.org #74787, Thanks Paul!)
+
+ - Removed unused version.pm prereq.
+
+ - Fix a circular reference memory leak caused by the use of
+ $AUTOLOAD in sub AUTOLOAD{} in the generated parser's namespace.
+ Workaround documented in perl5 RT #110248. Workaround a
+ circular reference memory leak in ISA documented by perl5 RT
+ #92708. A parser's DESTROY() method redefines all subs before
+ deleting the stash, to avoid circular references between
+ subrules. (RT #53710, thanks Andreas!)
+
+ - Parse::RecDescent::AUTOLOAD did not correctly handle
+ initializing the line counting mechanism when a reference to a
+ scalar was passed to the parser. (RT.cpan.org #27705, thanks
+ Justin!)
1.967_008 Tue Mar 13 22:28:00 2012
- - Restore old _parserepeat calling convention. Change a
- parser's DESTROY method to check for $self->{_not_precompiled}
- instead of $self->{_precompiled}. (Fix for RT #74593).
+ - Restore old _parserepeat calling convention. Change a parser's
+ DESTROY method to check for $self->{_not_precompiled} instead of
+ $self->{_precompiled}. (Fix for RT #74593).
1.967009 Fri Mar 16 07:25:09 2012
- - Bumped version to 1.967009 for non-development release.
+ - Bumped version to 1.967009 for non-development release.
+
+1.967_010 Sun Jul 7 11:23:53 2013
+
+ - Base the standalone precompiled parser's runtime name on the
+ parser's class, rather than use the fixed
+ "Parse::RecDescent::_Runtime". This prevents "already defined"
+ warnings when two standalone precompiled parsers are used.
+
+ - Add support for allowing precompiled parsers to share a common
+ runtime via the Precompile({-runtime_class}) option and the
+ PrecompiledRuntime() function.
+
+ - Warn on creation of Precompiled parsers that depend on
+ Parse::RecDescent.
+
+ - *** NON-BACKWARDS COMPATIBLE CHANGE! *** Change global the
+ <skip:> directive to eval similar to other <skip:> directives,
+ rather than being single-quoted in the resulting parser.
+
+1.967011 Sat Sep 12 16:42:01 2015
+
+ - Correct some typos in the documentation. (RT.cpan.org #87185,
+ thanks dsteinbrunner!)
+
+ - Sort hash keys and rulenames when generating code. This keeps
+ the output text for a given input text the same, reducing
+ differences in automated builds. (RT.cpan.org #102160, thanks
+ Reiner!)
+
+ - Precompiled parsers now document which
+ $Parse::RecDescent::VERSION was used to generate
+ them. (RT.cpan.org #77001)
+
+1.967012 Sun Sep 13 07:59:00 2015
+
+ - Reference Data::Dumper::Sortkeys, not SortKeys. Actually
+ produces reproducible precompiled parsers now. (RT.cpan.org
+ #107061, thanks Slaven!)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Parse-RecDescent-1.967009/MANIFEST
new/Parse-RecDescent-1.967012/MANIFEST
--- old/Parse-RecDescent-1.967009/MANIFEST 2012-03-16 15:27:02.000000000
+0100
+++ new/Parse-RecDescent-1.967012/MANIFEST 2015-09-13 02:44:06.000000000
+0200
@@ -78,6 +78,7 @@
t/precompile.t
t/re_capture_return.t
t/reentry.t
+t/reproducible.t
t/separated_repetition.t
t/skip.t
t/skip_dynamic.t
@@ -88,5 +89,3 @@
tutorial/TPJ_maze.gif
tutorial/TPJ_tree.gif
tutorial/tutorial.html
-META.yml Module YAML meta-data (added by
MakeMaker)
-META.json Module JSON meta-data (added by
MakeMaker)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Parse-RecDescent-1.967009/META.json
new/Parse-RecDescent-1.967012/META.json
--- old/Parse-RecDescent-1.967009/META.json 2012-03-16 15:27:02.000000000
+0100
+++ new/Parse-RecDescent-1.967012/META.json 1970-01-01 01:00:00.000000000
+0100
@@ -1,43 +0,0 @@
-{
- "abstract" : "Generate Recursive-Descent Parsers",
- "author" : [
- "Damian Conway <[email protected]>",
- "Jeremy T. Braun <[email protected]>"
- ],
- "dynamic_config" : 1,
- "generated_by" : "ExtUtils::MakeMaker version 6.62, CPAN::Meta::Converter
version 2.113640",
- "license" : [
- "unknown"
- ],
- "meta-spec" : {
- "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec";,
- "version" : "2"
- },
- "name" : "Parse-RecDescent",
- "no_index" : {
- "directory" : [
- "t",
- "inc"
- ]
- },
- "prereqs" : {
- "build" : {
- "requires" : {
- "ExtUtils::MakeMaker" : "6.5702"
- }
- },
- "configure" : {
- "requires" : {
- "ExtUtils::MakeMaker" : "6.5702"
- }
- },
- "runtime" : {
- "requires" : {
- "Test::More" : 0,
- "Text::Balanced" : "1.95"
- }
- }
- },
- "release_status" : "stable",
- "version" : "1.967009"
-}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Parse-RecDescent-1.967009/META.yml
new/Parse-RecDescent-1.967012/META.yml
--- old/Parse-RecDescent-1.967009/META.yml 2012-03-16 15:27:02.000000000
+0100
+++ new/Parse-RecDescent-1.967012/META.yml 1970-01-01 01:00:00.000000000
+0100
@@ -1,24 +0,0 @@
----
-abstract: 'Generate Recursive-Descent Parsers'
-author:
- - 'Damian Conway <[email protected]>'
- - 'Jeremy T. Braun <[email protected]>'
-build_requires:
- ExtUtils::MakeMaker: 6.5702
-configure_requires:
- ExtUtils::MakeMaker: 6.5702
-dynamic_config: 1
-generated_by: 'ExtUtils::MakeMaker version 6.62, CPAN::Meta::Converter version
2.113640'
-license: unknown
-meta-spec:
- url: http://module-build.sourceforge.net/META-spec-v1.4.html
- version: 1.4
-name: Parse-RecDescent
-no_index:
- directory:
- - t
- - inc
-requires:
- Test::More: 0
- Text::Balanced: 1.95
-version: 1.967009
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Parse-RecDescent-1.967009/README
new/Parse-RecDescent-1.967012/README
--- old/Parse-RecDescent-1.967009/README 2012-03-16 15:26:10.000000000
+0100
+++ new/Parse-RecDescent-1.967012/README 2015-09-13 17:01:10.000000000
+0200
@@ -1,4 +1,4 @@
-Parse::RecDescent version 1.967009
+Parse::RecDescent version 1.967012
NAME
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Parse-RecDescent-1.967009/lib/Parse/RecDescent.pm
new/Parse-RecDescent-1.967012/lib/Parse/RecDescent.pm
--- old/Parse-RecDescent-1.967009/lib/Parse/RecDescent.pm 2012-03-16
15:26:26.000000000 +0100
+++ new/Parse-RecDescent-1.967012/lib/Parse/RecDescent.pm 2015-09-13
17:01:33.000000000 +0200
@@ -16,7 +16,7 @@
#ifndef RUNTIME
sub import # IMPLEMENT PRECOMPILER BEHAVIOUR UNDER:
- # perl -MParse::RecDescent - <grammarfile> <classname>
+ # perl -MParse::RecDescent - <grammarfile> <classname>
[runtimeclassname]
{
local *_die = sub { print @_, "\n"; exit };
@@ -25,9 +25,9 @@
if ($file eq '-' && $line == 0)
{
_die("Usage: perl -MLocalTest - <grammarfile> <classname>")
- unless @ARGV == 2;
+ unless @ARGV >= 2 and $ARGV <= 3;
- my ($sourcefile, $class) = @ARGV;
+ my ($sourcefile, $class, $runtime_class) = @ARGV;
local *IN;
open IN, $sourcefile
@@ -36,7 +36,8 @@
my $grammar = <IN>;
close IN;
- Parse::RecDescent->Precompile($grammar, $class, $sourcefile);
+ Parse::RecDescent->Precompile({ -runtime_class => $runtime_class },
+ $grammar, $class, $sourcefile);
exit;
}
}
@@ -55,10 +56,21 @@
$self->{saving} = 0;
}
+sub PrecompiledRuntime
+{
+ my ($self, $class) = @_;
+ my $opt = {
+ -standalone => 1,
+ -runtime_class => $class,
+ };
+ $self->Precompile($opt, '', $class);
+}
+
sub Precompile
{
my $self = shift;
- my %opt = ( -standalone => 0 );
+ my %opt = ( -standalone => 0,
+ );
if ('HASH' eq ref $_[0]) {
%opt = (%opt, %{$_[0]});
shift;
@@ -71,21 +83,75 @@
$modulefile =~ s/.*:://;
$modulefile .= ".pm";
- my $runtime_package = 'Parse::RecDescent::_Runtime';
- my $code;
+ my $code = '';
local *OUT;
open OUT, ">", $modulefile
or croak("Can't write to new module file '$modulefile'");
+ print OUT "#\n",
+ "# This parser was generated with\n",
+ "# Parse::RecDescent version $Parse::RecDescent::VERSION\n",
+ "#\n\n";
+
print STDERR "precompiling grammar from file '$sourcefile'\n",
"to class $class in module file '$modulefile'\n"
if $grammar && $sourcefile;
- # Make the resulting pre-compiled parser stand-alone by
- # including the contents of Parse::RecDescent as
- # Parse::RecDescent::Runtime in the resulting precompiled
- # parser.
+ if ($grammar) {
+ $self = Parse::RecDescent->new($grammar, # $grammar
+ 1, # $compiling
+ $class # $namespace
+ )
+ || croak("Can't compile bad grammar")
+ if $grammar;
+
+ # Do not allow &DESTROY to remove the precompiled namespace
+ delete $self->{_not_precompiled};
+
+ foreach ( keys %{$self->{rules}} ) {
+ $self->{rules}{$_}{changed} = 1;
+ }
+
+ $code = $self->_code();
+ }
+
+ # If a name for the runtime package was not provided,
+ # generate one based on the module output name and the generated
+ # code
+ if (not defined($opt{-runtime_class})) {
+ if ($opt{-standalone}) {
+ my $basename = $class . '::_Runtime';
+
+ my $name = $basename;
+
+ for (my $i = 0; $code =~ /$basename/; ++$i) {
+ $name = sprintf("%s%06d", $basename, $i);
+ }
+
+ $opt{-runtime_class} = $name;
+ } else {
+ my $package = ref $self;
+ local $::RD_HINT = defined $::RD_HINT ? $::RD_HINT : 1;
+ _hint(<<EOWARNING);
+The precompiled grammar did not specify the -runtime_class
+option. The resulting parser will "use $package". Future changes to
+$package may cause $class to stop working.
+
+Consider building a -standalone parser, or providing the
+-runtime_class option as described in Parse::RecDescent's POD.
+
+Use \$::RD_HINT = 0 to disable this message.
+EOWARNING
+ $opt{-runtime_class} = $package;
+ }
+ }
+
+ $code =~ s/Parse::RecDescent/$opt{-runtime_class}/gs;
+
+ # Make the resulting pre-compiled parser stand-alone by including
+ # the contents of Parse::RecDescent as -runtime_class in the
+ # resulting precompiled parser.
if ($opt{-standalone}) {
local *IN;
open IN, '<', $Parse::RecDescent::_FILENAME
@@ -104,7 +170,8 @@
if ($_ =~ m/^__END__/) {
last;
}
- s/Parse::RecDescent/$runtime_package/gs;
+
+ s/Parse::RecDescent/$opt{-runtime_class}/gs;
print OUT $_;
}
}
@@ -112,45 +179,32 @@
print OUT "}\n";
}
- $self = Parse::RecDescent->new($grammar, # $grammar
- 1, # $compiling
- $class # $namespace
- )
- || croak("Can't compile bad grammar")
- if $grammar;
-
- # Do not allow &DESTROY to remove the precompiled namespace
- delete $self->{_not_precompiled};
-
- foreach ( keys %{$self->{rules}} ) {
- $self->{rules}{$_}{changed} = 1;
+ if ($grammar) {
+ print OUT "package $class;\n";
}
-
- print OUT "package $class;\n";
if (not $opt{-standalone}) {
- print OUT "use Parse::RecDescent;\n";
+ print OUT "use $opt{-runtime_class};\n";
}
- print OUT "{ my \$ERRORS;\n\n";
+ if ($grammar) {
+ print OUT "{ my \$ERRORS;\n\n";
- $code = $self->_code();
- if ($opt{-standalone}) {
- $code =~ s/Parse::RecDescent/$runtime_package/gs;
- }
- print OUT $code;
+ print OUT $code;
- print OUT "}\npackage $class; sub new { ";
- print OUT "my ";
+ print OUT "}\npackage $class; sub new { ";
+ print OUT "my ";
- require Data::Dumper;
- $code = Data::Dumper->Dump([$self], [qw(self)]);
- if ($opt{-standalone}) {
- $code =~ s/Parse::RecDescent/$runtime_package/gs;
- }
- print OUT $code;
+ require Data::Dumper;
+ # Sort the keys to ensure the output is reproducible
+ local $Data::Dumper::Sortkeys = 1;
+ $code = Data::Dumper->Dump([$self], [qw(self)]);
+ $code =~ s/Parse::RecDescent/$opt{-runtime_class}/gs;
- print OUT "}";
+ print OUT $code;
+
+ print OUT "}";
+ }
close OUT
or croak("Can't write to new module file '$modulefile'");
@@ -1896,7 +1950,7 @@
my $ERRORS = 0;
-our $VERSION = '1.967009';
+our $VERSION = '1.967012';
$VERSION = eval $VERSION;
$_FILENAME=__FILE__;
@@ -2018,61 +2072,61 @@
to be part of.");
}
-my $NEGLOOKAHEAD = '\G(\s*\.\.\.\!)';
-my $POSLOOKAHEAD = '\G(\s*\.\.\.)';
-my $RULE = '\G\s*(\w+)[ \t]*:';
-my $PROD = '\G\s*([|])';
-my $TOKEN = q{\G\s*/((\\\\/|\\\\\\\\|[^/])*)/([cgimsox]*)};
-my $MTOKEN = q{\G\s*(m\s*[^\w\s])};
-my $LITERAL = q{\G\s*'((\\\\['\\\\]|[^'])*)'};
+my $NEGLOOKAHEAD = '\G(\s*\.\.\.\!)';
+my $POSLOOKAHEAD = '\G(\s*\.\.\.)';
+my $RULE = '\G\s*(\w+)[ \t]*:';
+my $PROD = '\G\s*([|])';
+my $TOKEN = q{\G\s*/((\\\\/|\\\\\\\\|[^/])*)/([cgimsox]*)};
+my $MTOKEN = q{\G\s*(m\s*[^\w\s])};
+my $LITERAL = q{\G\s*'((\\\\['\\\\]|[^'])*)'};
my $INTERPLIT = q{\G\s*"((\\\\["\\\\]|[^"])*)"};
-my $SUBRULE = '\G\s*(\w+)';
-my $MATCHRULE = '\G(\s*<matchrule:)';
-my $SIMPLEPAT = '((\\s+/[^/\\\\]*(?:\\\\.[^/\\\\]*)*/)?)';
-my $OPTIONAL = '\G\((\?)'.$SIMPLEPAT.'\)';
-my $ANY = '\G\((s\?)'.$SIMPLEPAT.'\)';
-my $MANY = '\G\((s|\.\.)'.$SIMPLEPAT.'\)';
-my $EXACTLY = '\G\(([1-9]\d*)'.$SIMPLEPAT.'\)';
-my $BETWEEN = '\G\((\d+)\.\.([1-9]\d*)'.$SIMPLEPAT.'\)';
-my $ATLEAST = '\G\((\d+)\.\.'.$SIMPLEPAT.'\)';
-my $ATMOST = '\G\(\.\.([1-9]\d*)'.$SIMPLEPAT.'\)';
-my $BADREP = '\G\((-?\d+)?\.\.(-?\d+)?'.$SIMPLEPAT.'\)';
-my $ACTION = '\G\s*\{';
-my $IMPLICITSUBRULE = '\G\s*\(';
-my $COMMENT = '\G\s*(#.*)';
-my $COMMITMK = '\G\s*<commit>';
-my $UNCOMMITMK = '\G\s*<uncommit>';
-my $QUOTELIKEMK = '\G\s*<perl_quotelike>';
-my $CODEBLOCKMK = '\G\s*<perl_codeblock(?:\s+([][()<>{}]+))?>';
-my $VARIABLEMK = '\G\s*<perl_variable>';
-my $NOCHECKMK = '\G\s*<nocheck>';
-my $AUTOACTIONPATMK = '\G\s*<autoaction:';
-my $AUTOTREEMK = '\G\s*<autotree(?::\s*([\w:]+)\s*)?>';
-my $AUTOSTUBMK = '\G\s*<autostub>';
-my $AUTORULEMK = '\G\s*<autorule:(.*?)>';
-my $REJECTMK = '\G\s*<reject>';
-my $CONDREJECTMK = '\G\s*<reject:';
-my $SCOREMK = '\G\s*<score:';
-my $AUTOSCOREMK = '\G\s*<autoscore:';
-my $SKIPMK = '\G\s*<skip:';
-my $OPMK = '\G\s*<(left|right)op(?:=(\'.*?\'))?:';
-my $ENDDIRECTIVEMK = '\G\s*>';
-my $RESYNCMK = '\G\s*<resync>';
-my $RESYNCPATMK = '\G\s*<resync:';
-my $RULEVARPATMK = '\G\s*<rulevar:';
-my $DEFERPATMK = '\G\s*<defer:';
-my $TOKENPATMK = '\G\s*<token:';
-my $AUTOERRORMK = '\G\s*<error(\??)>';
-my $MSGERRORMK = '\G\s*<error(\??):';
-my $NOCHECK = '\G\s*<nocheck>';
-my $WARNMK = '\G\s*<warn((?::\s*(\d+)\s*)?)>';
-my $HINTMK = '\G\s*<hint>';
-my $TRACEBUILDMK = '\G\s*<trace_build((?::\s*(\d+)\s*)?)>';
-my $TRACEPARSEMK = '\G\s*<trace_parse((?::\s*(\d+)\s*)?)>';
+my $SUBRULE = '\G\s*(\w+)';
+my $MATCHRULE = '\G(\s*<matchrule:)';
+my $SIMPLEPAT = '((\\s+/[^/\\\\]*(?:\\\\.[^/\\\\]*)*/)?)';
+my $OPTIONAL = '\G\((\?)'.$SIMPLEPAT.'\)';
+my $ANY = '\G\((s\?)'.$SIMPLEPAT.'\)';
+my $MANY = '\G\((s|\.\.)'.$SIMPLEPAT.'\)';
+my $EXACTLY = '\G\(([1-9]\d*)'.$SIMPLEPAT.'\)';
+my $BETWEEN = '\G\((\d+)\.\.([1-9]\d*)'.$SIMPLEPAT.'\)';
+my $ATLEAST = '\G\((\d+)\.\.'.$SIMPLEPAT.'\)';
+my $ATMOST = '\G\(\.\.([1-9]\d*)'.$SIMPLEPAT.'\)';
+my $BADREP = '\G\((-?\d+)?\.\.(-?\d+)?'.$SIMPLEPAT.'\)';
+my $ACTION = '\G\s*\{';
+my $IMPLICITSUBRULE = '\G\s*\(';
+my $COMMENT = '\G\s*(#.*)';
+my $COMMITMK = '\G\s*<commit>';
+my $UNCOMMITMK = '\G\s*<uncommit>';
+my $QUOTELIKEMK = '\G\s*<perl_quotelike>';
+my $CODEBLOCKMK = '\G\s*<perl_codeblock(?:\s+([][()<>{}]+))?>';
+my $VARIABLEMK = '\G\s*<perl_variable>';
+my $NOCHECKMK = '\G\s*<nocheck>';
+my $AUTOACTIONPATMK = '\G\s*<autoaction:';
+my $AUTOTREEMK = '\G\s*<autotree(?::\s*([\w:]+)\s*)?>';
+my $AUTOSTUBMK = '\G\s*<autostub>';
+my $AUTORULEMK = '\G\s*<autorule:(.*?)>';
+my $REJECTMK = '\G\s*<reject>';
+my $CONDREJECTMK = '\G\s*<reject:';
+my $SCOREMK = '\G\s*<score:';
+my $AUTOSCOREMK = '\G\s*<autoscore:';
+my $SKIPMK = '\G\s*<skip:';
+my $OPMK = '\G\s*<(left|right)op(?:=(\'.*?\'))?:';
+my $ENDDIRECTIVEMK = '\G\s*>';
+my $RESYNCMK = '\G\s*<resync>';
+my $RESYNCPATMK = '\G\s*<resync:';
+my $RULEVARPATMK = '\G\s*<rulevar:';
+my $DEFERPATMK = '\G\s*<defer:';
+my $TOKENPATMK = '\G\s*<token:';
+my $AUTOERRORMK = '\G\s*<error(\??)>';
+my $MSGERRORMK = '\G\s*<error(\??):';
+my $NOCHECK = '\G\s*<nocheck>';
+my $WARNMK = '\G\s*<warn((?::\s*(\d+)\s*)?)>';
+my $HINTMK = '\G\s*<hint>';
+my $TRACEBUILDMK = '\G\s*<trace_build((?::\s*(\d+)\s*)?)>';
+my $TRACEPARSEMK = '\G\s*<trace_parse((?::\s*(\d+)\s*)?)>';
my $UNCOMMITPROD = $PROD.'\s*<uncommit';
my $ERRORPROD = $PROD.'\s*<error';
-my $LONECOLON = '\G\s*:';
-my $OTHER = '\G\s*([^\s]+)';
+my $LONECOLON = '\G\s*:';
+my $OTHER = '\G\s*([^\s]+)';
my @lines = 0;
@@ -2532,7 +2586,7 @@
_parseunneg("a rule declaration", 0,
$lookahead,$line, substr($grammar, $-[0], $+[0] - $-[0]) )
or next;
my $rulename = $1;
- if ($rulename =~ /Replace|Extend|Precompile|Save/ )
+ if ($rulename =~
/Replace|Extend|Precompile|PrecompiledRuntime|Save/ )
{
_warn(2,"Rule \"$rulename\" hidden by method
Parse::RecDescent::$rulename",$line)
@@ -3049,14 +3103,17 @@
sub _code($)
{
my $self = shift;
- my $initial_skip = defined($self->{skip}) ? $self->{skip} : $skip;
+ require Data::Dumper;
+ my $initial_skip = defined($self->{skip}) ?
+ '$skip = ' . $self->{skip} . ';' :
+ Data::Dumper->Dump([$skip],[qw(skip)]);
my $code = qq!
package $self->{namespace};
use strict;
use vars qw(\$skip \$AUTOLOAD $self->{localvars} );
\@$self->{namespace}\::ISA = ();
-\$skip = '$initial_skip';
+$initial_skip
$self->{startcode}
{
@@ -3082,7 +3139,9 @@
$self->{"startcode"} = '';
my $rule;
- foreach $rule ( values %{$self->{"rules"}} )
+ # sort the rules to ensure the output is reproducible
+ foreach $rule ( sort { $a->{name} cmp $b->{name} }
+ values %{$self->{"rules"}} )
{
if ($rule->{"changed"})
{
@@ -3427,8 +3486,8 @@
=head1 VERSION
-This document describes version 1.967009 of Parse::RecDescent
-released March 16th, 2012.
+This document describes version 1.967012 of Parse::RecDescent
+released September 13th, 2015.
=head1 SYNOPSIS
@@ -3881,7 +3940,7 @@
The results of named subrules are stored in the hash under each
subrule's name (including the repetition specifier, if any),
whilst all other items are stored under a "named
-positional" key that indictates their ordinal position within their item
+positional" key that indicates their ordinal position within their item
type: __STRINGI<n>__, __PATTERNI<n>__, __DIRECTIVEI<n>__, __ACTIONI<n>__:
stuff: /various/ bits 'and' pieces "then" data 'end' { save }
@@ -4407,7 +4466,7 @@
Normally, if a subrule appears in some production, but no rule of that
name is ever defined in the grammar, the production which refers to the
non-existent subrule fails immediately. This typically occurs as a
-result of misspellings, and is a sufficiently common occurance that a
+result of misspellings, and is a sufficiently common occurrence that a
warning is generated for such situations.
However, when prototyping a grammar it is sometimes useful to be
@@ -4493,7 +4552,7 @@
inner_word: word ...!......!word
-is exactly equivalent the the original example above (a warning is issued in
+is exactly equivalent to the original example above (a warning is issued in
cases like these, since they often indicate something left out, or
misunderstood).
@@ -4660,19 +4719,20 @@
OneLiner: Command <skip:'[ \t]*'> Arg(s) /;/
-causes only blanks and tabs to be skipped before terminals in the C<Arg>
-subrule (and any of I<its> subrules>, and also before the final C</;/>
terminal.
-Once the production is complete, the previous terminal prefix is
-reinstated. Note that this implies that distinct productions of a rule
-must reset their terminal prefixes individually.
+causes only blanks and tabs to be skipped before terminals in the
+C<Arg> subrule (and any of I<its> subrules>, and also before the final
+C</;/> terminal. Once the production is complete, the previous
+terminal prefix is reinstated. Note that this implies that distinct
+productions of a rule must reset their terminal prefixes individually.
-The C<E<lt>skipE<gt>> directive evaluates to the I<previous> terminal prefix,
-so it's easy to reinstate a prefix later in a production:
+The C<E<lt>skipE<gt>> directive evaluates to the I<previous> terminal
+prefix, so it's easy to reinstate a prefix later in a production:
Command: <skip:","> CSV(s) <skip:$item[1]> Modifier
-The value specified after the colon is interpolated into a pattern, so all of
-the following are equivalent (though their efficiency increases down the list):
+The value specified after the colon is interpolated into a pattern, so
+all of the following are equivalent (though their efficiency increases
+down the list):
<skip: "$colon|$comma"> # ASSUMING THE VARS HOLD THE OBVIOUS VALUES
@@ -4716,10 +4776,15 @@
C<Rule_with_dynamic_skip> and have it skip whatever you specified.
B<Note: Up to release 1.51 of Parse::RecDescent, an entirely different
-mechanism was used for specifying terminal prefixes. The current method
-is not backwards-compatible with that early approach. The current approach
-is stable and will not to change again.>
-
+mechanism was used for specifying terminal prefixes. The current
+method is not backwards-compatible with that early approach. The
+current approach is stable and will not change again.>
+
+B<Note: the global C<E<lt>skipE<gt>> directive added in 1.967_004 did
+not interpolate the pattern argument, instead the pattern was placed
+inside of single quotes and then interpolated. This behavior was
+changed in 1.967_010 so that all C<E<lt>skipE<gt>> directives behavior
+similarly.>
=item Resynchronization
@@ -4953,7 +5018,7 @@
grammar: C<< <warn> >>. It takes an optional argument, which specifies
the warning level: C<< <warn: 2> >>.
-See F<"DIAGNOSTICS"> for a list of the varous error and warning messages
+See F<"DIAGNOSTICS"> for a list of the various error and warning messages
that Parse::RecDescent generates when these two variables are defined.
Defining any of the remaining variables (which are not defined by
@@ -5273,7 +5338,7 @@
In this case, even though the first production of C<sentence> caused
the subrules C<noun> and C<trans> to match, that production ultimately
failed and so the deferred actions queued by those subrules were subsequently
-disgarded. The second production then succeeded, causing the entire
+discarded. The second production then succeeded, causing the entire
parse to succeed, and so the deferred actions queued by the (second) match of
the C<noun> subrule and the subsequent match of C<intrans> I<are> preserved and
eventually executed.
@@ -5618,7 +5683,7 @@
"fruit flies like a banana", then the second production is probably
the right match.
-To cater for such situtations, the C<E<lt>score:...E<gt>> can be used.
+To cater for such situations, the C<E<lt>score:...E<gt>> can be used.
The directive is equivalent to an unconditional C<E<lt>rejectE<gt>>,
except that it allows you to specify a "score" for the current
production. If that score is numerically greater than the best
@@ -5921,7 +5986,7 @@
$add = "name: 'Jimmy-Bob' | 'Bobby-Jim'\ndesc: colour /necks?/";
parser->Replace($add);
-are are I<only> valid "name"s and the one possible description.
+there are I<only> valid "name"s and the one possible description.
A more interesting use of the C<Extend> and C<Replace> methods is to call them
inside the action of an executing parser. For example:
@@ -5986,7 +6051,7 @@
use Parse::RecDescent;
- Parse::RecDescent->Precompile([$options_hashref], $grammar, "PreGrammar");
+ Parse::RecDescent->Precompile([$options_hashref], $grammar, "PreGrammar",
["RuntimeClass"]);
The first required argument is the grammar string, the second is the
name of the class to be built. The name of the module file is
@@ -5997,10 +6062,14 @@
would produce a module file named Parser.pm.
+After the class name, you may specify the name of the runtime_class
+called by the Precompiled parser. See L</"Precompiled runtimes"> for
+more details.
+
An optional hash reference may be supplied as the first argument to
C<Precompile>. This argument is currently EXPERIMENTAL, and may change
in a future release of Parse::RecDescent. The only supported option
-is currently C<-standalone>, see L</"Standalone Precompiled Parsers">.
+is currently C<-standalone>, see L</"Standalone precompiled parsers">.
It is somewhat tedious to have to write a small Perl program just to
generate a precompiled grammar class, so Parse::RecDescent has some special
@@ -6009,7 +6078,7 @@
If your grammar is specified in a file named F<grammar>, you can generate
a class named Yet::Another::Grammar like so:
- > perl -MParse::RecDescent - grammar Yet::Another::Grammar
+ > perl -MParse::RecDescent - grammar Yet::Another::Grammar [Runtime::Class]
This would produce a file named F<Grammar.pm> containing the full
definition of a class called Yet::Another::Grammar. Of course, to use
@@ -6040,7 +6109,7 @@
it has no effect on I<parsing> speed. RecDescent 2.0 will address that
problem.
-=head3 Standalone Precompiled Parsers
+=head3 Standalone precompiled parsers
Until version 1.967003 of Parse::RecDescent, parser modules built with
C<Precompile> were dependent on Parse::RecDescent. Future
@@ -6051,19 +6120,59 @@
itself in the resulting .pm file if you pass the boolean option
C<-standalone> to C<Precompile>:
- Parse::RecDescent->Precompile({ -standalone = 1, },
+ Parse::RecDescent->Precompile({ -standalone => 1, },
$grammar, "My::New::Parser");
-Parse::RecDescent is included as Parse::RecDescent::_Runtime in order
-to avoid conflicts between an installed version of Parse::RecDescent
-and a precompiled, standalone parser made with another version of
-Parse::RecDescent. This renaming is experimental, and is subject to
-change in future versions.
+Parse::RecDescent is included as C<$class::_Runtime> in order to avoid
+conflicts between an installed version of Parse::RecDescent and other
+precompiled, standalone parser made with Parse::RecDescent. The name
+of this class may be changed with the C<-runtime_class> option to
+Precompile. This renaming is experimental, and is subject to change
+in future versions.
Precompiled parsers remain dependent on Parse::RecDescent by default,
as this feature is still considered experimental. In the future,
standalone parsers will become the default.
+=head3 Precompiled runtimes
+
+Standalone precompiled parsers each include a copy of
+Parse::RecDescent. For users who have a family of related precompiled
+parsers, this is very inefficient. C<Precompile> now supports an
+experimental C<-runtime_class> option. To build a precompiled parser
+with a different runtime name, call:
+
+ Parse::RecDescent->Precompile({
+ -standalone => 1,
+ -runtime_class => "My::Runtime",
+ },
+ $grammar, "My::New::Parser");
+
+The resulting standalone parser will contain a copy of
+Parse::RecDescent, renamed to "My::Runtime".
+
+To build a set of parsers that C<use> a custom-named runtime, without
+including that runtime in the output, simply build those parsers with
+C<-runtime_class> and without C<-standalone>:
+
+ Parse::RecDescent->Precompile({
+ -runtime_class => "My::Runtime",
+ },
+ $grammar, "My::New::Parser");
+
+The runtime itself must be generated as well, so that it may be
+C<use>d by My::New::Parser. To generate the runtime file, use one of
+the two folling calls:
+
+ Parse::RecDescent->PrecompiledRuntime("My::Runtime");
+
+ Parse::RecDescent->Precompile({
+ -standalone => 1,
+ -runtime_class => "My::Runtime",
+ },
+ '', # empty grammar
+ "My::Runtime");
+
=head1 GOTCHAS
This section describes common mistakes that grammar writers seem to
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Parse-RecDescent-1.967009/t/precompile.t
new/Parse-RecDescent-1.967012/t/precompile.t
--- old/Parse-RecDescent-1.967009/t/precompile.t 2012-02-09
04:10:52.000000000 +0100
+++ new/Parse-RecDescent-1.967012/t/precompile.t 2015-09-13
02:44:06.000000000 +0200
@@ -3,6 +3,9 @@
use Parse::RecDescent;
use Test::More tests => 14;
+# Turn off the "build a -standalone parser" precompile warning
+our $RD_HINT = 0;
+
# mask "subroutine element redefined" warnings
local $^W;
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Parse-RecDescent-1.967009/t/reproducible.t
new/Parse-RecDescent-1.967012/t/reproducible.t
--- old/Parse-RecDescent-1.967009/t/reproducible.t 1970-01-01
01:00:00.000000000 +0100
+++ new/Parse-RecDescent-1.967012/t/reproducible.t 2015-09-13
16:57:36.000000000 +0200
@@ -0,0 +1,421 @@
+# Ensure that the output of Parse::RecDescent is the same, time after
+# time. This prevents automated builds with precompiled parsers from
+# registering changes, with no change input.
+
+use strict;
+use warnings;
+use Parse::RecDescent;
+use Test::More tests => 41;
+
+# Turn off the "build a -standalone parser" precompile warning
+our $RD_HINT = 0;
+
+# mask "subroutine element redefined" warnings
+local $^W;
+
+my $grammar = <<'EOGRAMMAR';
+
+
+ translation_unit:
+ external_declaration(s)
+ | <error>
+
+ external_declaration:
+ function_definition
+ | declaration
+ | <resync>
+ {
+ if ($::opt_SKIPPEDLINES || (defined $::opt_VERBOSE and
$::opt_VERBOSE >= 1 ))
+ {
+ print "Skipping line $thisline\n" # Try next line if
possible...
+ }
+ }
+
+ function_definition:
+ declaration_specifiers(?) declarator declaration_list(?)
compound_statement
+ {
+ if($::opt_FUNCTIONS)
+ {
+ $::functions_output .= ::flatten_list($item[1]);
+ $::functions_output .= ::flatten_list($item[2]);
+ $::functions_output .= ::flatten_list($item[3]) . ";\n";
+ }
+ }
+
+ declaration:
+ declaration_specifiers init_declarator_list(?) ';'
+ {
+ if($::opt_DECLARATIONS)
+ {
+ $::declarations_output .= ::flatten_list($item[1]);
+ $::declarations_output .= ::flatten_list($item[2]);
+ $::declarations_output .= ::flatten_list($item[3]) . "\n";
+ }
+ }
+
+ declaration_list:
+ declaration(s)
+
+ declaration_specifiers:
+ type_qualifier declaration_specifiers(?)
+ | storage_class_specifier declaration_specifiers(?)
+ | type_specifier declaration_specifiers(?)
+
+ storage_class_specifier:
+ 'auto'
+ | 'register'
+ | 'static'
+ | 'extern'
+ | 'typedef'
+
+ type_specifier:
+ 'int'
+ | 'double'
+ | 'void'
+ | 'char'
+ | 'long'
+ | 'float'
+ | 'signed'
+ | 'unsigned'
+ | 'short'
+ | struct_or_union_specifier
+ | enum_specifier
+ | typedef_name ...typedef_name_lookahead { [$item[1] ] }
+
+ typedef_name_lookahead:
+ declarator
+# | pointer
+# | ',' ...parameter_type_list
+# | ')'
+
+ type_qualifier:
+ 'const'
+ | 'volatile'
+
+ struct_or_union_specifier:
+ struct_or_union IDENTIFIER(?) '{' struct_declaration_list(?) '}'
+ {
+ if($::opt_STRUCTS){
+ $::structs_output .= ::flatten_list($item[1]) . " ";
+ $::structs_output .= ::flatten_list($item[2]);
+ $::structs_output .= ::flatten_list($item[3]) . "\n";
+ $::structs_output .= ::flatten_list_beautified($item[4]);
+ $::structs_output .= ::flatten_list($item[5]) . ";\n\n";
+ }
+ }
+ | struct_or_union IDENTIFIER
+
+ struct_or_union:
+ 'struct'
+ | 'union'
+
+
+ struct_declaration_list:
+ struct_declaration(s)
+
+ init_declarator_list:
+ init_declarator(s /(,)/)
+
+ init_declarator:
+ declarator '=' initializer
+ | declarator
+
+ struct_declaration:
+ specifier_qualifier_list struct_declarator_list ';'
+
+ specifier_qualifier_list:
+ type_specifier specifier_qualifier_list(?)
+ | type_qualifier specifier_qualifier_list(?)
+
+ struct_declarator_list:
+ struct_declarator(s /(,)/)
+
+ struct_declarator:
+ declarator(?) ':' constant_expression
+ | declarator
+
+ enum_specifier:
+ 'enum' IDENTIFIER(?) '{' enumerator_list '}'
+ {
+ if($::opt_STRUCTS){
+ $::structs_output .= ::flatten_list($item[1]) . " ";
+ $::structs_output .= ::flatten_list($item[2]);
+ $::structs_output .= ::flatten_list($item[3]) . "\n";
+ $::structs_output .= ::flatten_list_beautified($item[4]);
+ $::structs_output .= ::flatten_list($item[5]) . ";\n\n";
+ }
+ }
+ | 'enum' IDENTIFIER
+
+ enumerator_list:
+ enumerator(s /(,)/)
+
+ enumerator:
+ IDENTIFIER ('=' constant_expression)(?)
+
+ declarator:
+ pointer(?) direct_declarator
+
+ function_signature:
+ '[' constant_expression(?) ']'
+ | '(' parameter_type_list ')'
+ | '(' identifier_list(?) ')'
+
+ direct_declarator:
+ IDENTIFIER function_signature(s?)
+ | '(' declarator ')' function_signature(s?)
+
+
+ pointer:
+ '*' type_qualifier_list(?) pointer(?)
+
+ type_qualifier_list:
+ type_qualifier(s)
+
+ parameter_type_list:
+ parameter_list (',' '...')(?)
+
+ parameter_list:
+ parameter_declaration(s /(,)/)
+
+ parameter_declaration:
+ declaration_specifiers declarator
+ | declaration_specifiers abstract_declarator(?)
+
+ identifier_list:
+ IDENTIFIER(s /(,)/)
+
+ initializer:
+ assignment_expression
+ | '{' initializer_list (',')(?) '}'
+
+ initializer_list:
+ initializer(s /(,)/)
+
+ type_name:
+ specifier_qualifier_list abstract_declarator(?)
+
+ abstract_declarator:
+ pointer(?) direct_abstract_declarator
+ | pointer
+
+ abstract_type:
+ '[' constant_expression(?) ']'
+ | '(' parameter_type_list(?) ')'
+
+ direct_abstract_declarator:
+ '(' abstract_declarator ')' abstract_type(s?)
+ | abstract_type(s)
+
+ typedef_name:
+ IDENTIFIER
+
+ statement:
+ selection_statement
+ | expression_statement
+ | iteration_statement
+ | compound_statement
+ | jump_statement
+ | labeled_statement
+
+
+ labeled_statement:
+ 'case' constant_expression ':' statement
+ | IDENTIFIER ':' statement
+ | 'default' ':' statement
+
+ expression_statement:
+ expression(?) ';'
+
+ compound_statement:
+ '{' declaration_list(?) statement_list(?) '}'
+
+ statement_list:
+ statement(s)
+
+ selection_statement:
+ 'if' '(' expression ')' statement ('else' statement)(?)
+ | 'switch' '(' expression ')' statement
+
+ iteration_statement:
+ 'for' '(' expression(?) ';' expression(?) ';' expression(?) ')'
statement
+ | 'while' '(' expression ')' statement
+ | 'do' statement 'while' '(' expression ')'
+
+ jump_statement:
+ 'return' expression(?) ';'
+ | 'break' ';'
+ | 'continue' ';'
+ | 'goto' IDENTIFIER ';'
+
+ expression:
+ assignment_expression(s /(,)/)
+
+ assignment_expression:
+ unary_expression ASSIGNMENT_OPERATOR assignment_expression
+ | conditional_expression
+
+
+ conditional_expression:
+ logical_OR_expression ('?' expression ':' conditional_expression)(?)
+
+ constant_expression:
+ conditional_expression
+
+ logical_OR_expression:
+ logical_AND_expression(s /(\|\|)/)
+
+ logical_AND_expression:
+ inclusive_OR_expression(s /(&&)/)
+
+ inclusive_OR_expression:
+ exclusive_OR_expression(s /(\|)/)
+
+ exclusive_OR_expression:
+ AND_expression(s /(\^)/)
+
+ AND_expression:
+ equality_expression(s /(&)/)
+
+ equality_expression:
+ relational_expression(s /(==|!=)/)
+
+ relational_expression:
+ shift_expression(s /(<=|>=|<|>)/)
+
+ shift_expression:
+ additive_expression(s /(<<|>>)/)
+
+ additive_expression:
+ multiplicative_expression(s /(\+|-)/)
+
+ multiplicative_expression:
+ cast_expression(s /(\*|\/|%)/)
+
+ cast_expression:
+ unary_expression
+ | '(' type_name ')' cast_expression
+
+ unary_expression:
+ postfix_expression
+ | '++' unary_expression
+ | '--' unary_expression
+ | 'sizeof' '(' type_name ')'
+ | UNARY_OPERATOR cast_expression
+ | 'sizeof' unary_expression
+
+
+ postfix_expression:
+ primary_expression postfix_expression_token(s?)
+
+
+ postfix_expression_token:
+ '[' expression ']'
+ | '(' argument_expression_list(?)')'
+ | '.' IDENTIFIER
+ | '->' IDENTIFIER
+ | '++'
+ | '--'
+
+
+ primary_expression:
+ IDENTIFIER
+ | constant
+ | STRING
+ | '(' expression ')'
+
+ argument_expression_list:
+ assignment_expression(s /(,)/)
+
+ constant:
+ CHARACTER_CONSTANT
+ | FLOATING_CONSTANT
+ | INTEGER_CONSTANT
+ | ENUMERATION_CONSTANT
+
+
+### TERMINALS
+
+
+ INTEGER_CONSTANT:
+ /(?:0[xX][\da-fA-F]+) # Hexadecimal
+ |(?:0[0-7]*) # Octal or Zero
+ |(?:[1-9]\d*) # Decimal
+ [uUlL]? # Suffix
+ /x
+
+ CHARACTER_CONSTANT:
+ /'([^\\'"] # None of these
+ |\\['\\ntvbrfa'"] # or a backslash followed by one
of those
+ |\\[0-7]{1,3}|\\x\d+)' # or an octal or hex constant
+ /x
+
+ FLOATING_CONSTANT:
+ /(?:\d+|(?=\.\d+)) # No leading digits only if
'.moreDigits' follows
+ (?:\.|(?=[eE])) # There may be no floating
point only if an exponent is present
+ \d* # Zero or more floating digits
+ ([eE][+-]?\d+)? # expontent
+ [lLfF]? # Suffix
+ /x
+
+ ENUMERATION_CONSTANT:
+ INTEGER_CONSTANT
+
+ STRING:
+ /"(([^\\'"]) # None of these
+ |(\\[\\ntvbrfa'"]) # or a backslash followed by one
of those
+ |(\\[0-7]{1,3})|(\\x\d+))*"/x # or an octal or hex
+
+ IDENTIFIER:
+
/(?!(auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto
# LOOKAHEAD FOR KEYWORDS
+
|if|int|long|register|return|signed|sizeof|short|static|struct|switch|typedef
# NONE OF THE KEYWORDS
+ |union|unsigned|void|volatile|while)[^a-zA-Z_])
# SHOULD FULLY MATCH!
+ (([a-zA-Z]\w*)|(_\w+))/x
# Check for valid identifier
+
+ ASSIGNMENT_OPERATOR:
+ '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '&=' | '^=' |
'|='
+
+ UNARY_OPERATOR:
+ '&' | '*' | '+' | '-' | '~' | '!'
+
+EOGRAMMAR
+
+
+# Create the reference output
+my $class = "TestParser";
+
+sub CompileParser {
+ my $pm_filename = $class . '.pm';
+
+ eval {
+ Parse::RecDescent->Precompile({-standalone => 1,},
+ $grammar,
+ $class);
+ };
+ ok(!$@, qq{created a precompiled parser: } . $@);
+ ok(-e $pm_filename, "found the precompiled parser file");
+
+ my $fh;
+ ok((open $fh, '<', $pm_filename), "opened the precompiled parser");
+ my $parser_text;
+
+ local $/;
+ $parser_text = <$fh>;
+ close $fh;
+
+ ok((defined($parser_text) and length($parser_text)),
+ "parser contains data");
+
+ unlink $pm_filename;
+ ok(!-e $pm_filename, "deleted precompiled parser");
+
+ return $parser_text;
+}
+
+my $reference_parser = CompileParser();
+
+for (0..5) {
+ my $new_parser = CompileParser($_);
+
+ ok($new_parser eq $reference_parser, "parsers match");
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Parse-RecDescent-1.967009/t/skip.t
new/Parse-RecDescent-1.967012/t/skip.t
--- old/Parse-RecDescent-1.967009/t/skip.t 2012-02-19 20:53:32.000000000
+0100
+++ new/Parse-RecDescent-1.967012/t/skip.t 2015-09-13 02:44:06.000000000
+0200
@@ -24,7 +24,7 @@
# Test setting the initial skip via the <skip:> global directive
RunTests(q{
-<skip:(?mxs: \s+ |\# .*?$)*>
+<skip:'(?mxs: \s+ |\# .*?$)*'>
});
# Test setting the initial skip via $Parse::RecDescent::skip global
++++++ cpanspec.yml ++++++
---
#description_paragraphs: 3
#no_testing: broken upstream
#sources:
# - source1
# - source2
#patches:
# foo.patch: -p1
# bar.patch:
#preamble: |-
# BuildRequires: gcc-c++
#post_prep: |-
# hunspell=`pkg-config --libs hunspell | sed -e 's,-l,,; s, *,,g'`
# sed -i -e "s,hunspell-X,$hunspell," t/00-prereq.t Makefile.PL
#post_install: |-
# sed on %{name}.files
#license: SUSE-NonFree
#skip_noarch: 1
#custom_build: |-
#./Build build flags=%{?_smp_mflags} --myflag
#custom_test: |-
#startserver && make test
#ignore_requires: Bizarre::Module
