This is an automated email from the git hooks/post-receive script. js pushed a commit to tag PEVANS in repository libparser-mgc-perl.
commit 25f85062460be63f8ce5360ad74c960bdcffd737 Author: Paul Evans <leon...@leonerd.org.uk> Date: Sun Dec 12 17:37:46 2010 +0000 Import of PEVANS/Parser-MGC-0.03 from CPAN. gitpan-cpan-distribution: Parser-MGC gitpan-cpan-version: 0.03 gitpan-cpan-path: PEVANS/Parser-MGC-0.03.tar.gz gitpan-cpan-author: PEVANS gitpan-cpan-maturity: released --- Build.PL | 1 + Changes | 7 ++++++ META.yml | 6 +++-- Makefile.PL | 1 + README | 71 ++++++++++++++++++++++++++++++++++++++++++++++------ lib/Parser/MGC.pm | 74 ++++++++++++++++++++++++++++++++++++++++++++++++------- t/02expect.t | 6 ++++- 7 files changed, 147 insertions(+), 19 deletions(-) diff --git a/Build.PL b/Build.PL index f98f30d..45549a9 100644 --- a/Build.PL +++ b/Build.PL @@ -6,6 +6,7 @@ use Module::Build; my $build = Module::Build->new( module_name => 'Parser::MGC', requires => { + 'File::Slurp' => 0, }, build_requires => { 'Test::More' => 0, diff --git a/Changes b/Changes index 6b61864..58675b5 100644 --- a/Changes +++ b/Changes @@ -1,5 +1,12 @@ Revision history for Parser-MGC +0.03 CHANGES: + * Expanded documentation, more examples + + BUGFIXES: + * Regexp quoting fix for perl >= 5.13.6 + * Declare dependency on File::Slurp + 0.02 CHANGES: * ->expect now returns the consumed string * ->token_int recognises negative integers diff --git a/META.yml b/META.yml index f4262cd..cb085ae 100644 --- a/META.yml +++ b/META.yml @@ -15,7 +15,9 @@ name: Parser-MGC provides: Parser::MGC: file: lib/Parser/MGC.pm - version: 0.02 + version: 0.03 +requires: + File::Slurp: 0 resources: license: http://dev.perl.org/licenses/ -version: 0.02 +version: 0.03 diff --git a/Makefile.PL b/Makefile.PL index 1c06b3a..e9136a7 100644 --- a/Makefile.PL +++ b/Makefile.PL @@ -5,6 +5,7 @@ WriteMakefile 'NAME' => 'Parser::MGC', 'VERSION_FROM' => 'lib/Parser/MGC.pm', 'PREREQ_PM' => { + 'File::Slurp' => 0, 'Test::More' => 0 }, 'INSTALLDIRS' => 'site', diff --git a/README b/README index bfd056f..5130c07 100644 --- a/README +++ b/README @@ -91,7 +91,7 @@ METHODS $parser->fail( $message ) Aborts the current parse attempt with the given message string. The failure message will include the current line and column position, and - will include the line of input that failed. + the line of input that failed. $eos = $parser->at_eos Returns true if the input string is at the end of the string. @@ -103,14 +103,27 @@ STRUCTURE-FORMING METHODS argument. $ret = $parser->maybe( $code ) - Attempts to execute the given $code reference in scalar context, passing - in no arguments, and returning what it returned. If the code fails to - parse by calling the "fail" method then none of the input string will be - consumed; the current parsing position will be restored. "undef" will be - returned in this case. + Attempts to execute the given $code reference in scalar context, and + returns what it returned. If the code fails to parse by calling the + "fail" method then none of the input string will be consumed; the + current parsing position will be restored. "undef" will be returned in + this case. This may be considered to be similar to the "?" regexp qualifier. + sub parse_declaration + { + my $self = shift; + + [ $self->parse_type, + $self->token_ident, + $self->maybe( sub { + $self->expect( "=" ); + $self->parse_expression + } ), + ]; + } + $ret = $parser->scope_of( $start, $code, $stop ) Expects to find the $start pattern, then attempts to execute the given $code reference, then expects to find the $stop pattern. Returns @@ -120,6 +133,13 @@ STRUCTURE-FORMING METHODS token parsing methods as an end-of-scope marker; causing them to raise a failure if called at the end of a scope. + sub parse_block + { + my $self = shift; + + $self->scope_of( "{", sub { $self->parse_statements }, "}" ); + } + $ret = $parser->list_of( $sep, $code ) Expects to find a list of instances of something parsed by $code, separated by the $sep pattern. Returns an ARRAY ref containing a list of @@ -129,6 +149,13 @@ STRUCTURE-FORMING METHODS that is, that the scope ended before any item instances were parsed from it. + sub parse_numbers + { + my $self = shift; + + $self->list_of( ",", sub { $self->token_int } ); + } + $ret = $parser->sequence_of( $code ) A shortcut for calling "list_of" with an empty string as separator; expects to find at least one instance of something parsed by $code, @@ -137,6 +164,13 @@ STRUCTURE-FORMING METHODS This may be considered to be similar to the "+" or "*" regexp qualifiers. + sub parse_statements + { + my $self = shift; + + $self->sequence_of( sub { $self->parse_statement } ); + } + $ret = $parser->one_of( @codes ) Expects that one of the given code references can parse something from the input, returning what it returned. Each code reference may indicate @@ -145,6 +179,17 @@ STRUCTURE-FORMING METHODS This may be considered to be similar to the "|" regexp operator for forming alternations of possible parse trees. + sub parse_statement + { + my $self = shift; + + $self->one_of( + sub { $self->parse_declaration; $self->expect(";") }, + sub { $self->parse_expression; $self->expect(";") }, + sub { $self->parse_block }, + ); + } + $parser->commit Calling this method will cancel the backtracking behaviour of the innermost "maybe" or "one_of" structure forming method. That is, if @@ -155,7 +200,19 @@ STRUCTURE-FORMING METHODS alternation has been determined, ensuring that any further failures are raised as real exceptions, rather than by attempting other alternatives. - TODO: Code example with commit inside one_of + sub parse_statement + { + my $self = shift; + + $self->one_of( + ... + sub { + $self->scope_of( "{", + sub { $self->commit; $self->parse_statements; }, + "}" ), + }, + ); + } TOKEN PARSING METHODS The following methods attempt to consume some part of the input string, diff --git a/lib/Parser/MGC.pm b/lib/Parser/MGC.pm index 3b6675b..fc4039b 100644 --- a/lib/Parser/MGC.pm +++ b/lib/Parser/MGC.pm @@ -8,7 +8,7 @@ package Parser::MGC; use strict; use warnings; -our $VERSION = '0.02'; +our $VERSION = '0.03'; use Carp; @@ -217,8 +217,8 @@ sub where =head2 $parser->fail( $message ) Aborts the current parse attempt with the given message string. The failure -message will include the current line and column position, and will include -the line of input that failed. +message will include the current line and column position, and the line of +input that failed. =cut @@ -266,14 +266,26 @@ which will be passed the actual C<$parser> object as its first argument. =head2 $ret = $parser->maybe( $code ) -Attempts to execute the given C<$code> reference in scalar context, passing in -no arguments, and returning what it returned. If the code fails to parse by -calling the C<fail> method then none of the input string will be consumed; the -current parsing position will be restored. C<undef> will be returned in this -case. +Attempts to execute the given C<$code> reference in scalar context, and +returns what it returned. If the code fails to parse by calling the C<fail> +method then none of the input string will be consumed; the current parsing +position will be restored. C<undef> will be returned in this case. This may be considered to be similar to the C<?> regexp qualifier. + sub parse_declaration + { + my $self = shift; + + [ $self->parse_type, + $self->token_ident, + $self->maybe( sub { + $self->expect( "=" ); + $self->parse_expression + } ), + ]; + } + =cut sub maybe @@ -306,6 +318,13 @@ While the code is being executed, the C<$stop> pattern will be used by the token parsing methods as an end-of-scope marker; causing them to raise a failure if called at the end of a scope. + sub parse_block + { + my $self = shift; + + $self->scope_of( "{", sub { $self->parse_statements }, "}" ); + } + =cut sub scope_of @@ -334,6 +353,13 @@ the return values from the C<$code>. This method does not consider it an error if the returned list is empty; that is, that the scope ended before any item instances were parsed from it. + sub parse_numbers + { + my $self = shift; + + $self->list_of( ",", sub { $self->token_int } ); + } + =cut sub list_of @@ -363,6 +389,13 @@ by skipped whitespace. This may be considered to be similar to the C<+> or C<*> regexp qualifiers. + sub parse_statements + { + my $self = shift; + + $self->sequence_of( sub { $self->parse_statement } ); + } + =cut sub sequence_of @@ -382,6 +415,17 @@ to parse by calling the C<fail> method. This may be considered to be similar to the C<|> regexp operator for forming alternations of possible parse trees. + sub parse_statement + { + my $self = shift; + + $self->one_of( + sub { $self->parse_declaration; $self->expect(";") }, + sub { $self->parse_expression; $self->expect(";") }, + sub { $self->parse_block }, + ); + } + =cut sub one_of @@ -417,7 +461,19 @@ Typically this will be called once the grammatical structure of an alternation has been determined, ensuring that any further failures are raised as real exceptions, rather than by attempting other alternatives. - TODO: Code example with commit inside one_of + sub parse_statement + { + my $self = shift; + + $self->one_of( + ... + sub { + $self->scope_of( "{", + sub { $self->commit; $self->parse_statements; }, + "}" ), + }, + ); + } =cut diff --git a/t/02expect.t b/t/02expect.t index b5a8e35..a6382e2 100644 --- a/t/02expect.t +++ b/t/02expect.t @@ -22,9 +22,13 @@ is_deeply( $parser->from_string( "hello world" ), [ "hello", "world" ], '"hello world"' ); +# Perl 5.13.6 changed the regexp form +# Accept both old and new-style stringification +my $modifiers = (qr/foobar/ =~ /\Q(?^/) ? '^' : '-xism'; + ok( !eval { $parser->from_string( "goodbye world" ) }, '"goodbye world" fails' ); is( $@, - qq[Expected (?-xism:hello) on line 1 at:\n] . + qq[Expected (?$modifiers:hello) on line 1 at:\n] . qq[goodbye world\n] . qq[^\n], 'Exception from "goodbye world" failure' ); -- Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-perl/packages/libparser-mgc-perl.git _______________________________________________ Pkg-perl-cvs-commits mailing list Pkg-perl-cvs-commits@lists.alioth.debian.org http://lists.alioth.debian.org/cgi-bin/mailman/listinfo/pkg-perl-cvs-commits