You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucy.apache.org by ma...@apache.org on 2009/09/09 06:27:13 UTC
svn commit: r812766 - in /lucene/lucy/trunk/boilerplater:
lib/Boilerplater/Parser.pm t/600-parser.t
Author: marvin
Date: Wed Sep 9 04:27:13 2009
New Revision: 812766
URL: http://svn.apache.org/viewvc?rev=812766&view=rev
Log:
Commit LUCY-29. This patch to Parser fixes a backtracking inefficiency with
composite types, speeding up parsing by around 30%. In addition, numerous
tests have been added for sub-productions.
Modified:
lucene/lucy/trunk/boilerplater/lib/Boilerplater/Parser.pm
lucene/lucy/trunk/boilerplater/t/600-parser.t
Modified: lucene/lucy/trunk/boilerplater/lib/Boilerplater/Parser.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/boilerplater/lib/Boilerplater/Parser.pm?rev=812766&r1=812765&r2=812766&view=diff
==============================================================================
--- lucene/lucy/trunk/boilerplater/lib/Boilerplater/Parser.pm (original)
+++ lucene/lucy/trunk/boilerplater/lib/Boilerplater/Parser.pm Wed Sep 9 04:27:13 2009
@@ -79,12 +79,9 @@
{ $item[2] }
class_name:
- class_name_component ( "::" class_name_component )(s?)
+ object_type_specifier ( "::" object_type_specifier )(s?)
{ join('::', $item[1], @{ $item[2] } ) }
-class_name_component:
- /[A-Z]+[A-Z0-9]*[a-z]+[A-Za-z0-9]*(?!\w)/
-
cnick:
'cnick'
/([A-Z][A-Za-z0-9]+)(?!\w)/
@@ -143,9 +140,8 @@
{ $item[2] }
type:
- composite_type
- | simple_type
- { $item[1] }
+ simple_type type_postfix(s?)
+ { Boilerplater::Parser->simple_or_composite_type(\%item) }
simple_type:
object_type
@@ -155,9 +151,9 @@
| arbitrary_type
{ $item[1] }
-composite_type:
- simple_type type_postfix(s)
- { Boilerplater::Parser->new_composite_type(\%item) }
+object_type:
+ type_qualifier(s?) object_type_specifier '*'
+ { Boilerplater::Parser->new_object_type(\%item); }
primitive_type:
c_integer_type
@@ -189,10 +185,6 @@
arbitrary_type_specifier
{ Boilerplater::Parser->new_arbitrary_type(\%item); }
-object_type:
- type_qualifier(s?) object_type_specifier '*'
- { Boilerplater::Parser->new_object_type(\%item); }
-
type_qualifier:
'const'
| 'incremented'
@@ -215,6 +207,15 @@
'inert'
{ $item[1] }
+type_specifier:
+ ( object_type_specifier
+ | primitive_type_specifier
+ | void_type_specifier
+ | va_list_type_specifier
+ | arbitrary_type_specifier
+ )
+ { $item[1] }
+
primitive_type_specifier:
chy_integer_specifier
| c_integer_specifier
@@ -357,22 +358,30 @@
return Boilerplater::Type::Object->new(%args);
}
-sub new_composite_type {
+sub simple_or_composite_type {
my ( undef, $item ) = @_;
- my %args = (
- child => $item->{simple_type},
- indirection => 0,
- );
- for my $postfix ( @{ $item->{'type_postfix(s)'} } ) {
- if ( $postfix =~ /\[/ ) {
- $args{array} ||= '';
- $args{array} .= $postfix;
- }
- elsif ( $postfix eq '*' ) {
- $args{indirection}++;
+ my $simple_type = $item->{simple_type};
+ my $postfixes = $item->{'type_postfix(s?)'};
+
+ if ( !@$postfixes ) {
+ return $simple_type;
+ }
+ else {
+ my %args = (
+ child => $simple_type,
+ indirection => 0,
+ );
+ for my $postfix (@$postfixes) {
+ if ( $postfix =~ /\[/ ) {
+ $args{array} ||= '';
+ $args{array} .= $postfix;
+ }
+ elsif ( $postfix eq '*' ) {
+ $args{indirection}++;
+ }
}
+ return Boilerplater::Type::Composite->new(%args);
}
- return Boilerplater::Type::Composite->new(%args);
}
sub new_var {
Modified: lucene/lucy/trunk/boilerplater/t/600-parser.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/boilerplater/t/600-parser.t?rev=812766&r1=812765&r2=812766&view=diff
==============================================================================
--- lucene/lucy/trunk/boilerplater/t/600-parser.t (original)
+++ lucene/lucy/trunk/boilerplater/t/600-parser.t Wed Sep 9 04:27:13 2009
@@ -1,7 +1,7 @@
use strict;
use warnings;
-use Test::More tests => 30;
+use Test::More tests => 124;
BEGIN { use_ok('Boilerplater::Parser') }
@@ -19,10 +19,120 @@
is( $Boilerplater::Parser::parcel, $parcel,
"parcel_definition sets internal \$parcel var" );
-is( $parser->class_name_component($_), $_, "class_name_component: $_" )
+is( $parser->strip_plain_comments("/*x*/"),
+ " ", "comments replaced by spaces" );
+is( $parser->strip_plain_comments("/**x*/"),
+ "/**x*/", "docu-comment untouched" );
+is( $parser->strip_plain_comments("/*\n*/"), " \n ", "newline preserved" );
+
+for (qw( foo _foo foo_yoo FOO Foo fOO f00 )) {
+ is( $parser->identifier($_), $_, "identifier: $_" );
+}
+
+for (qw( void unsigned float u32_t i64_t u8_t bool_t )) {
+ ok( !$parser->identifier($_), "reserved word not an identifier: $_" );
+}
+
+is( $parser->chy_integer_specifier($_), $_, "Charmony integer specifier $_" )
+ for qw( u8_t u16_t u32_t u64_t i8_t i16_t i32_t i64_t bool_t );
+
+is( $parser->object_type_specifier($_), $_, "object_type_specifier $_" )
+ for qw( ByteBuf Obj ANDScorer );
+
+is( $parser->type_specifier($_), $_, "type_specifier $_" )
+ for qw( u32_t char int short long float double void ANDScorer );
+
+is( $parser->type_qualifier($_), $_, "type_qualifier $_" ) for qw( const );
+
+is( $parser->exposure_specifier($_), $_, "exposure_specifier $_" )
+ for qw( public private parcel );
+
+is( $parser->type_postfix($_), $_, "postfix: $_" )
+ for ( '[]', '[A_CONSTANT]', '*' );
+is( $parser->type_postfix('[ FOO ]'), '[FOO]', "type_postfix: [ FOO ]" );
+
+isa_ok( $parser->type($_), "Boilerplater::Type", "type $_" )
+ for ( 'const char *', 'Obj*', 'i32_t', 'char[]', 'long[1]',
+ 'i64_t[FOO]' );
+
+is( $parser->declarator($_), $_, "declarator: $_" )
+ for ( 'foo', 'bar_bar_bar' );
+
+isa_ok( $parser->param_variable($_),
+ "Boilerplater::Variable", "param_variable: $_" )
+ for ( 'u32_t baz;', 'CharBuf *stuff;', 'float **ptr;', );
+
+isa_ok( $parser->var_declaration_statement($_)->{declared},
+ "Boilerplater::Variable", "var_declaration_statement: $_" )
+ for (
+ 'parcel int foo;',
+ 'private Obj *obj;',
+ 'public inert i32_t **foo;',
+ 'Dog *fido;'
+ );
+
+is( $parser->hex_constant($_), $_, "hex_constant: $_" )
+ for (qw( 0x1 0x0a 0xFFFFFFFF ));
+
+is( $parser->integer_constant($_), $_, "integer_constant: $_" )
+ for (qw( 1 -9999 0 10000 ));
+
+is( $parser->float_constant($_), $_, "float_constant: $_" )
+ for (qw( 1.0 -9999.999 0.1 0.0 ));
+
+is( $parser->string_literal($_), $_, "string_literal: $_" )
+ for ( q|"blah"|, q|"blah blah"|, q|"\\"blah\\" \\"blah\\""| );
+
+is( $parser->scalar_constant($_), $_, "scalar_constant: $_" )
+ for ( q|"blah"|, 1, 1.2, "0xFC" );
+
+my @composites = ( 'int[]', "i32_t **", "Foo **", "Foo ***", "const void *" );
+for my $composite (@composites) {
+ my $parsed = $parser->type($composite);
+ isa_ok(
+ $parsed,
+ "Boilerplater::Type::Composite",
+ "composite_type: $composite"
+ );
+}
+
+my @object_types = ( 'Obj *', "incremented Foo*", "decremented CharBuf *" );
+for my $object_type (@object_types) {
+ my $parsed = $parser->object_type($object_type);
+ isa_ok( $parsed, "Boilerplater::Type::Object",
+ "object_type: $object_type" );
+}
+
+my %param_lists = (
+ '(int foo)' => 1,
+ '(Obj *foo, Foo **foo_ptr)' => 2,
+ '()' => 0,
+);
+while ( my ( $param_list, $num_params ) = each %param_lists ) {
+ my $parsed = $parser->param_list($param_list);
+ isa_ok( $parsed, "Boilerplater::ParamList", "param_list: $param_list" );
+}
+ok( $parser->param_list("(int foo, ...)")->variadic, "variadic param list" );
+my $param_list = $parser->param_list(q|(int foo = 0xFF, char *bar ="blah")|);
+is_deeply(
+ $param_list->get_initial_values,
+ [ '0xFF', '"blah"' ],
+ "initial values"
+);
+
+my %sub_args = ( class => 'Boil::Obj', cnick => 'Obj' );
+
+ok( $parser->declaration_statement( $_, 0, %sub_args, inert => 1 ),
+ "declaration_statment: $_" )
+ for (
+ 'public Foo* Spew_Foo(Obj *self, u32_t *how_many);',
+ 'private Hash *hash;',
+ );
+
+is( $parser->object_type_specifier($_), $_, "object_type_specifier: $_" )
for (qw( Foo FooJr FooIII Foo4th ));
-ok( !$parser->class_name_component($_), "illegal class_name_component: $_" )
+ok( !$parser->object_type_specifier($_), "illegal object_type_specifier: $_" )
for (qw( foo fooBar Foo_Bar FOOBAR 1Foo 1FOO ));
is( $parser->class_name($_), $_, "class_name: $_" )