antlr3 1.2.3

data/test/functional/parser/properties.rb

@@ -0,0 +1,242 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+require 'antlr3/test/functional'
+
+class TestRulePropertyReference < ANTLR3::Test::Functional
+
+  inline_grammar(<<-'END')
+    grammar RuleProperties;
+    options { language = Ruby; }
+    
+    @parser::members {
+      def emit_error_message(msg)
+        # do nothing
+      end
+      def report_error(error)
+        raise error
+      end
+    }
+    
+    @lexer::members {
+      def emit_error_message(msg)
+        # do nothing
+      end
+      def report_error(error)
+        raise error
+      end
+    }
+    
+    a returns [bla]
+    @after { $bla = [$start, $stop, $text] }
+        : A+
+        ;
+    
+    A: 'a'..'z';
+    
+    WS: ' '+  { $channel = HIDDEN };
+  END
+  
+  example "accessing rule properties" do
+    lexer = RuleProperties::Lexer.new( '   a a a a  ' )
+    parser = RuleProperties::Parser.new lexer
+    start, stop, text = parser.a.bla
+    
+    start.index.should == 1
+    stop.index.should == 7
+    text.should == 'a a a a'
+  end
+
+
+end
+
+class TestLabels < ANTLR3::Test::Functional
+
+  inline_grammar(<<-'END')
+    grammar Labels;
+    options { language = Ruby; }
+    
+    @parser::members {
+      def recover(e)
+        raise e
+      end
+    }
+    
+    @lexer::members {
+      def recover(e)
+        raise e
+      end
+    }
+    
+    a returns [l]
+        : ids+=A ( ',' ids+=(A|B) )* C D w=. ids+=. F EOF
+            { $l = [$ids, $w] }
+        ;
+    
+    A: 'a'..'z';
+    B: '0'..'9';
+    C: a='A' { $a };
+    D: a='FOOBAR' { $a };
+    E: 'GNU' a=. { $a };
+    F: 'BLARZ' a=EOF { $a };
+    
+    WS: ' '+  { $channel = HIDDEN };
+  END
+  
+  example "parsing 'a, b, c, 1, 2 A FOOBAR GNU1 A BLARZ'" do
+    lexer = Labels::Lexer.new 'a, b, c, 1, 2 A FOOBAR GNU1 A BLARZ'
+    parser = Labels::Parser.new lexer
+    ids, w = parser.a
+    
+    ids.should have(6).things
+    ids[0].text.should == 'a'
+    ids[1].text.should == 'b'
+    ids[2].text.should == 'c'
+    ids[3].text.should == '1'
+    ids[4].text.should == '2'
+    ids[5].text.should == 'A'
+    
+    w.text.should == 'GNU1'
+  end
+
+
+end
+
+
+class TestTokenLabelReference < ANTLR3::Test::Functional
+
+  inline_grammar(<<-'END')
+    grammar TokenLabels;
+    options {
+      language = Ruby;
+    }
+    
+    @parser::members {
+      def emit_error_message(msg)
+        # do nothing
+      end
+      def report_error(error)
+        raise error
+      end
+    }
+    
+    @lexer::members {
+      def emit_error_message(msg)
+        # do nothing
+      end
+      def report_error(error)
+        raise error
+      end
+    }
+    
+    a returns [$tk]
+      : t=A
+          {
+            $tk = [
+              $t.text,
+              $t.type,
+              $t.name,
+              $t.line,
+              $t.pos,
+              $t.index,
+              $t.channel
+            ]
+          }
+      ;
+    
+    A: 'a'..'z';
+    
+    WS  :
+            (   ' '
+            |   '\t'
+            |  ( '\n'
+                |	'\r\n'
+                |	'\r'
+                )
+            )+
+            { $channel = HIDDEN }
+        ;
+  END
+  
+  example "accessing tokens with labels" do
+    lexer = TokenLabels::Lexer.new( '   a' )
+    parser = TokenLabels::Parser.new lexer
+    tk = parser.a
+    tk.should == [
+      'a', TokenLabels::TokenData::A, 'A',
+      1, 3, 1, :default
+    ]
+  end
+
+
+end
+
+class TestRuleLabelReference < ANTLR3::Test::Functional
+
+  inline_grammar(<<-'END')
+    grammar RuleLabelReference;
+    options {language = Ruby;}
+    
+    @parser::members {
+      def emit_error_message(msg)
+        # do nothing
+      end
+      def report_error(error)
+        raise error
+      end
+    }
+    
+    @lexer::members {
+      def emit_error_message(msg)
+        # do nothing
+      end
+      def report_error(error)
+        raise error
+      end
+    }
+    
+    a returns [bla]: t=b
+            {
+                $bla = [$t.start, $t.stop, $t.text]
+            }
+        ;
+    
+    b: A+;
+    
+    A: 'a'..'z';
+    
+    WS: ' '+  { $channel = HIDDEN };
+  END
+  
+  example "referencing rule properties using rule labels" do
+    lexer = RuleLabelReference::Lexer.new( '   a a a a  ' )
+    parser = RuleLabelReference::Parser.new lexer
+    start, stop, text = parser.a
+    
+    start.index.should == 1
+    stop.index.should == 7
+    text.should == 'a a a a'
+  end
+
+end
+
+
+
+class TestReferenceDoesntSetChannel < ANTLR3::Test::Functional
+
+  inline_grammar(<<-'END')
+    grammar ReferenceSetChannel;
+    options {language=Ruby;}
+    a returns [foo]: A EOF { $foo = '\%s, channel=\%p' \% [$A.text, $A.channel]; } ;
+    A : '-' WS I ;
+    I : '0'..'9'+ ;
+    WS: ' ' | '\t';
+  END
+
+  example 'verifying that a token reference does not set its channel' do
+    lexer = ReferenceSetChannel::Lexer.new("- 34")
+    parser = ReferenceSetChannel::Parser.new lexer
+    parser.a.should == "- 34, channel=:default"
+  end
+
+end

data/test/functional/parser/rule-methods.rb

@@ -0,0 +1,132 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+require 'antlr3/test/functional'
+
+class TestParameters < ANTLR3::Test::Functional
+
+  inline_grammar(<<-'END')
+    grammar Parameters;
+    options {
+      language = Ruby;
+    }
+    
+    @parser::members {
+      def emit_error_message(msg)
+        # do nothing
+      end
+      def report_error(error)
+        raise error
+      end
+    }
+    
+    @lexer::members {
+      def emit_error_message(msg)
+        # do nothing
+      end
+      def report_error(error)
+        raise error
+      end
+    }
+    
+    a[arg1, arg2] returns [l]
+        : A+ EOF
+            { 
+                l = [$arg1, $arg2]
+                $arg1 = "gnarz"
+            }
+        ;
+    
+    A: 'a'..'z';
+    
+    WS: ' '+  { $channel = HIDDEN };
+  END
+  
+  example "rules with method parameters" do
+    lexer = Parameters::Lexer.new( 'a a a' )
+    parser = Parameters::Parser.new lexer
+    r = parser.a( 'foo', 'bar' )
+    r.should == %w(foo bar)
+  end
+
+end
+
+
+class TestMultipleReturnValues < ANTLR3::Test::Functional
+
+  inline_grammar(<<-'END')
+    grammar MultipleReturnValues;
+    options { language = Ruby; }
+    @parser::members {
+      def emit_error_message(msg)
+        # do nothing
+      end
+      def report_error(error)
+        raise error
+      end
+    }
+    
+    @lexer::members {
+      def emit_error_message(msg)
+        # do nothing
+      end
+      def report_error(error)
+        raise error
+      end
+    }
+    
+    a returns [foo, bar]: A
+            {
+                $foo = "foo";
+                $bar = "bar";
+            }
+        ;
+    
+    A: 'a'..'z';
+    
+    WS  :
+            (   ' '
+            |   '\t'
+            |  ( '\n'
+                |	'\r\n'
+                |	'\r'
+                )
+            )+
+            { $channel = HIDDEN }
+        ;
+  END
+  
+  example "multi-valued rule return structures" do
+    lexer = MultipleReturnValues::Lexer.new( '   a' )
+    parser = MultipleReturnValues::Parser.new lexer
+    ret = parser.a
+    
+    ret.foo.should == 'foo'
+    ret.bar.should == 'bar'
+  end
+  
+end
+
+
+class TestRuleVisibility < ANTLR3::Test::Functional
+  inline_grammar(<<-'END')
+    grammar RuleVisibility;
+    options { language=Ruby; }
+    
+    public a: ID;
+    private b: DIGIT;
+    protected c: ID DIGIT;
+    
+    DIGIT: ('0'..'9')+;
+    ID: ('a'..'z' | 'A'..'Z')+;
+    WS: (' ' | '\t' | '\n' | '\r' | '\f')+ { $channel=HIDDEN; };
+  END
+  
+  example 'using visibility modifiers on rules' do
+    RuleVisibility::Parser.public_instance_methods.should include('a')
+    RuleVisibility::Parser.protected_instance_methods.should include('c')
+    RuleVisibility::Parser.private_instance_methods.should include('b')
+  end
+
+end
+

data/test/functional/parser/scopes.rb

@@ -0,0 +1,274 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+require 'antlr3/test/functional'
+
+class TestScopes1 < ANTLR3::Test::Functional
+
+  inline_grammar(<<-'END')
+    grammar SimpleScope;
+    
+    options {
+        language = Ruby;
+    }
+    
+    prog
+    scope {
+    name
+    }
+        :   ID {$prog::name=$ID.text;}
+        ;
+    
+    ID  :   ('a'..'z')+
+        ;
+    
+    WS  :   (' '|'\n'|'\r')+ {$channel=HIDDEN}
+        ;
+  END
+  
+  example "parsing 'foobar'" do
+    lexer = SimpleScope::Lexer.new( 'foobar' )
+    parser = SimpleScope::Parser.new lexer
+    parser.prog
+  end
+end
+
+class TestScopes2 < ANTLR3::Test::Functional
+  inline_grammar(<<-'END')
+    grammar LotsaScopes;
+    
+    options {
+        language = Ruby;
+    }
+    
+    /* global scopes */
+    
+    scope aScope {
+      names;
+    }
+    
+    @members {
+      def emit_error_message(msg)
+        # do nothing
+      end
+      
+      def report_error(error)
+        raise error
+      end
+    }
+    
+    a
+    scope aScope;
+        :   {$aScope::names = []} ID*
+        ;
+    
+    
+    /* rule scopes, from the book, final beta, p.147 */
+    
+    b[v]
+    scope {x}
+        : {$b::x = v;} b2
+        ;
+    
+    b2
+        : b3
+        ;
+    
+    b3 
+        : {$b::x}?=> ID // only visible, if b was called with True
+        | NUM
+        ;
+    
+    
+    /* rule scopes, from the book, final beta, p.148 */
+    
+    c returns [res]
+    scope {
+        symbols
+    }
+    @init {
+        $c::symbols = Set.new;
+    }
+        : '{' c1* c2+ '}'
+            { $res = $c::symbols; }
+        ;
+    
+    c1
+        : 'int' ID {$c::symbols.add($ID.text)} ';'
+        ;
+    
+    c2
+        : ID '=' NUM ';'
+            {
+                $c::symbols.include?($ID.text) or raise RuntimeError, $ID.text
+             }
+        ;
+    
+    /* recursive rule scopes, from the book, final beta, p.150 */
+    
+    d returns [res]
+    scope {
+        symbols
+    }
+    @init {
+        $d::symbols = Set.new
+    }
+        : '{' d1* d2* '}'
+            { $res = $d::symbols; }
+        ;
+    
+    d1
+        : 'int' ID {$d::symbols.add($ID.text)} ';'
+        ;
+    
+    d2
+        : ID '=' NUM ';'
+            {
+              catch(:found) do
+                level = ($d.length - 1).downto(0) do |s|
+                  $d[s].symbols.include?($ID.text) and throw(:found)
+                end
+                raise $ID.text
+              end
+            }
+        | d
+        ;
+    
+    /* recursive rule scopes, access bottom-most scope */
+    
+    e returns [res]
+    scope {
+        a
+    }
+    @after {
+        $res = $e::a;
+    }
+        : NUM { $e[0]::a = Integer($NUM.text); }
+        | '{' e '}'
+        ;
+    
+    
+    /* recursive rule scopes, access with negative index */
+    
+    f returns [res]
+    scope {
+        a
+    }
+    @after {
+        $res = $f::a;
+    }
+        : NUM { $f[-2]::a = Integer($NUM.text); }
+        | '{' f '}'
+        ;
+    
+    
+    /* tokens */
+    
+    ID  :   ('a'..'z')+
+        ;
+    
+    NUM :   ('0'..'9')+
+        ;
+    
+    WS  :   (' '|'\n'|'\r')+ {$channel=HIDDEN}
+        ;
+  END
+
+  example "parsing 'foobar' with rule a" do
+    lexer = LotsaScopes::Lexer.new("foobar")
+    parser = LotsaScopes::Parser.new lexer
+    parser.a
+  end
+  
+  example "failing to parse 'foobar' with rule b[false]" do
+    lexer = LotsaScopes::Lexer.new("foobar")
+    parser = LotsaScopes::Parser.new lexer
+    proc { parser.b(false) }.should raise_error(ANTLR3::RecognitionError)
+  end
+  
+  example "parsing 'foobar' with rule b[true]" do
+    lexer = LotsaScopes::Lexer.new("foobar")
+    parser = LotsaScopes::Parser.new lexer
+    parser.b(true)
+  end
+  
+  example "parsing a decl block with rule c" do
+    lexer = LotsaScopes::Lexer.new(<<-END.here_indent!)
+    | {
+    |     int i;
+    |     int j;
+    |     i = 0;
+    | }
+    END
+    parser = LotsaScopes::Parser.new lexer
+
+    symbols = parser.c
+    symbols.should have(2).things
+    symbols.should include 'i'
+    symbols.should include 'j'
+  end
+  
+  example "failing to parse undeclared symbols with rule c" do
+    lexer = LotsaScopes::Lexer.new(<<-END.here_indent!)
+    | {
+    |     int i;
+    |     int j;
+    |     i = 0;
+    |     x = 4;
+    | }
+    END
+    parser = LotsaScopes::Parser.new lexer
+
+    proc { parser.c }.should raise_error RuntimeError, 'x'
+  end
+  
+  example "parsing nested declaration blocks" do
+    lexer = LotsaScopes::Lexer.new(<<-END.here_indent!)
+    | {
+    |     int i;
+    |     int j;
+    |     i = 0;
+    |     {
+    |        int i;
+    |        int x;
+    |        x = 5;
+    |     }
+    | }
+    END
+    parser = LotsaScopes::Parser.new lexer
+
+    symbols = parser.d 
+    symbols.should have(2).things
+    symbols.should include 'i'
+    symbols.should include 'j'
+  end
+  
+  example "parsing a deeply nested set of blocks with rule e" do
+    lexer = LotsaScopes::Lexer.new(<<-END.here_indent!)
+    | { { { { 12 } } } }
+    END
+
+    parser = LotsaScopes::Parser.new lexer
+    parser.e.should == 12
+  end
+  
+  example "parsing a deeply nested set of blocks with rule f" do
+    lexer = LotsaScopes::Lexer.new(<<-END.here_indent!)
+    | { { { { 12 } } } }
+    END
+
+    parser = LotsaScopes::Parser.new lexer
+    parser.f.should == nil
+  end
+  
+  example "parsing a 2-level nested set of blocks with rule f" do
+    lexer = LotsaScopes::Lexer.new(<<-END.here_indent!)
+    | { { 12 } }
+    END
+    parser = LotsaScopes::Parser.new lexer
+
+    parser.f.should == nil
+  end
+
+end
+