antlr3 1.2.3

data/test/functional/parser/calc.rb

@@ -0,0 +1,98 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+require 'antlr3/test/functional'
+
+class TestCalcParser < ANTLR3::Test::Functional
+  inline_grammar(<<-'END')
+    grammar TestCalc;
+    options { language = Ruby; }
+    
+    @parser::init {
+      @reported_errors = []
+    }
+    
+    @parser::members {
+      attr_reader :reported_errors
+      
+      def emit_error_message(msg)
+        @reported_errors << msg
+      end
+    }
+    
+    evaluate returns [result]: r=expression { $result = $r.result };
+    
+    expression returns [result]:
+               r=mult { $result = $r.result }
+        (
+          '+' r2=mult { $result += $r2.result }
+        | '-' r2=mult { $result -= $r2.result }
+        )*
+        ;
+    
+    mult returns [result]:
+               r=log { $result = $r.result }
+        (
+          '*' r2=log {$result *= $r2.result}
+        | '/' r2=log {$result /= $r2.result}
+        | '%' r2=log {$result \%= $r2.result}
+        )*
+        ;
+    
+    log returns [result]: 'ln' r=exp {$result = Math.log($r.result)}
+        | r=exp {$result = $r.result}
+        ;
+    
+    exp returns [result]: r=atom { $result = $r.result } ('^' r2=atom { $result **= $r2.result } )?
+        ;
+    
+    atom returns [result]:
+        n=INTEGER {$result = Integer($n.text)}
+      | n=DECIMAL {$result = Float($n.text)} 
+      | '(' r=expression {$result = $r.result} ')'
+      | 'PI' {$result = Math::PI}
+      | 'E' {$result = Math::E}
+      ;
+    
+    INTEGER: DIGIT+;
+    
+    DECIMAL: DIGIT+ '.' DIGIT+;
+    
+    fragment
+    DIGIT: '0'..'9';
+    
+    WS: (' ' | '\n' | '\t')+ {$channel = HIDDEN};
+  END
+  
+  def evaluate(expression)
+    lexer  = TestCalc::Lexer.new( expression )
+    parser = TestCalc::Parser.new lexer
+    value = parser.evaluate
+    errors = parser.reported_errors
+    return [value, errors]
+  end
+  
+  tests = %[
+    1 + 2            = 3
+    1 + 2 * 3        = 7
+    10 / 2           = 5
+    6 + 2*(3+1) - 4  = 10
+  ].strip!.split(/\n/).map { |line| 
+    expr, val = line.strip.split(/\s+=\s+/, 2)
+    [expr, Integer(val)]
+  }
+  
+  tests.each do |expression, true_value|
+    example "should parse '#{expression}'" do
+      parser_value, errors = evaluate(expression)
+      parser_value.should == true_value
+    end
+  end
+  
+  example "badly formed input" do
+    val, errors = evaluate "6 - (2*1"
+    
+    errors.should have(1).thing
+    errors.first.should =~ /mismatched/
+  end
+end

data/test/functional/parser/ll-star.rb

@@ -0,0 +1,143 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+require 'antlr3/test/functional'
+
+class TestLLStarParser < ANTLR3::Test::Functional
+  inline_grammar(<<-'END')
+    grammar LLStar;
+    
+    options { language = Ruby; }
+    @header {  require 'stringio' }
+    @init { @output = StringIO.new() }
+    @members {
+      def output
+        @output.string
+      end
+    }
+    
+    program
+        :   declaration+
+        ;
+    
+    /** In this rule, the functionHeader left prefix on the last two
+     *  alternatives is not LL(k) for a fixed k.  However, it is
+     *  LL(*).  The LL(*) algorithm simply scans ahead until it sees
+     *  either the ';' or the '{' of the block and then it picks
+     *  the appropriate alternative.  Lookhead can be arbitrarily
+     *  long in theory, but is <=10 in most cases.  Works great.
+     *  Use ANTLRWorks to see the look use (step by Location)
+     *  and look for blue tokens in the input window pane. :)
+     */
+    declaration
+        :   variable
+        |   functionHeader ';'
+      { @output.puts( $functionHeader.name + " is a declaration") }
+        |   functionHeader block
+      { @output.puts( $functionHeader.name + " is a definition") }
+        ;
+    
+    variable
+        :   type declarator ';'
+        ;
+    
+    declarator
+        :   ID 
+        ;
+    
+    functionHeader returns [name]
+        :   type ID '(' ( formalParameter ( ',' formalParameter )* )? ')'
+      {$name = $ID.text}
+        ;
+    
+    formalParameter
+        :   type declarator        
+        ;
+    
+    type
+        :   'int'   
+        |   'char'  
+        |   'void'
+        |   ID        
+        ;
+    
+    block
+        :   '{'
+                variable*
+                stat*
+            '}'
+        ;
+    
+    stat: forStat
+        | expr ';'      
+        | block
+        | assignStat ';'
+        | ';'
+        ;
+    
+    forStat
+        :   'for' '(' assignStat ';' expr ';' assignStat ')' block        
+        ;
+    
+    assignStat
+        :   ID '=' expr        
+        ;
+    
+    expr:   condExpr
+        ;
+    
+    condExpr
+        :   aexpr ( ('==' | '<') aexpr )?
+        ;
+    
+    aexpr
+        :   atom ( '+' atom )*
+        ;
+    
+    atom
+        : ID      
+        | INT      
+        | '(' expr ')'
+        ; 
+    
+    ID  :   ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*
+        ;
+    
+    INT :	('0'..'9')+
+        ;
+    
+    WS  :   (   ' '
+            |   '\t'
+            |   '\r'
+            |   '\n'
+            )+
+            {$channel=HIDDEN}
+        ;
+  END
+  
+  
+  example "parsing with a LL(*) grammar" do
+    lexer = LLStar::Lexer.new(<<-'END'.fixed_indent(0))
+      char c;
+      int x;
+      
+      void bar(int x);
+      
+      int foo(int y, char d) {
+        int i;
+        for (i=0; i<3; i=i+1) {
+          x=3;
+          y=5;
+        }
+      }
+    END
+    parser = LLStar::Parser.new lexer
+    
+    parser.program
+    parser.output.should == <<-'END'.fixed_indent(0)
+      bar is a declaration
+      foo is a definition
+    END
+  end
+  
+end

data/test/functional/parser/nuances.rb

@@ -0,0 +1,165 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+require 'antlr3/test/functional'
+
+class TestEmptyAlternative < ANTLR3::Test::Functional
+
+  inline_grammar(<<-'END')
+    grammar EmptyAlt;
+    options {
+      language = Ruby;
+    }
+    
+    r
+      : NAME 
+        ( WS+ NAME
+        | 
+        )
+        EOF
+      ;
+    
+    NAME: ('a'..'z') ('a'..'z' | '0'..'9')+;
+    NUMBER: ('0'..'9')+;
+    WS: ' '+;
+  END
+  
+  example "rule with empty alternative" do
+    lexer = EmptyAlt::Lexer.new( 'foo' )
+    parser = EmptyAlt::Parser.new lexer
+    events = parser.r
+  end
+
+end
+
+class TestSubrulePrediction < ANTLR3::Test::Functional
+
+  inline_grammar(<<-'END')
+    grammar Subrule;
+    options {
+      language = Ruby;
+    }
+    
+    @parser::members {
+      def emit_error_message(msg)
+        # do nothing
+      end
+      def report_error(error)
+        raise error
+      end
+    }
+    
+    a: 'BEGIN' b WS+ 'END';
+    b: ( WS+ 'A' )+;
+    WS: ' ';
+  END
+  
+  example "make correct predictions involving subrules" do
+    lexer = Subrule::Lexer.new( 'BEGIN A END' )
+    parser = Subrule::Parser.new lexer
+    events = parser.a
+  end
+
+end
+
+
+class TestSpecialStates < ANTLR3::Test::Functional
+
+  inline_grammar(<<-'END')
+    grammar SpecialStates;
+    options { language = Ruby; }
+    
+    @init { @cond = true }
+    
+    @members {
+      attr_accessor :cond
+      def recover(re)
+        raise re
+      end
+    }
+    
+    r
+      : ( { @cond }? NAME
+        | {!@cond }? NAME WS+ NAME
+        )
+        ( WS+ NAME )?
+        EOF
+      ;
+    
+    NAME: ('a'..'z') ('a'..'z' | '0'..'9')+;
+    NUMBER: ('0'..'9')+;
+    WS: ' '+;
+  END
+
+  example "parsing 'foo'" do
+    lexer  = SpecialStates::Lexer.new 'foo'
+    parser = SpecialStates::Parser.new lexer
+    parser.r
+  end
+
+  example "parsing 'foo name1'"  do
+    lexer = SpecialStates::Lexer.new 'foo name1'
+    parser = SpecialStates::Parser.new lexer
+    parser.r
+  end
+
+  example "parsing 'bar name1'"  do
+    lexer = SpecialStates::Lexer.new 'bar name1'
+    parser = SpecialStates::Parser.new lexer
+    parser.cond = false
+    parser.r
+  end
+
+  example "parsing 'bar name1 name2'" do
+    lexer = SpecialStates::Lexer.new 'bar name1 name2'
+    parser = SpecialStates::Parser.new lexer
+    parser.cond = false
+    parser.r
+  end
+end
+
+
+class TestDFABug < ANTLR3::Test::Functional
+
+  inline_grammar(<<-'END')
+    grammar DFABug;
+    options {
+        language = Ruby;
+        output = AST;
+    }
+    
+    
+    // this rule used to generate an infinite loop in DFA.predict
+    r
+    options { backtrack=true; }
+        : (modifier+ INT)=> modifier+ expression
+        | modifier+ statement
+        ;
+    
+    expression
+        : INT '+' INT
+        ;
+    
+    statement
+        : 'fooze'
+        | 'fooze2'
+        ;
+    
+    modifier
+        : 'public'
+        | 'private'
+        ;
+    
+    ID : 'a'..'z' + ;
+    INT : '0'..'9' +;
+    WS: (' ' | '\n' | '\t')+ {$channel = HIDDEN;};
+  END
+
+  example "testing for DFA-based decision bug" do
+    lexer = DFABug::Lexer.new 'public fooze'
+    parser = DFABug::Parser.new lexer
+    parser.r
+  end
+  
+end
+

data/test/functional/parser/predicates.rb

@@ -0,0 +1,103 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+require 'antlr3/test/functional'
+
+class TestPredicateHoist < ANTLR3::Test::Functional
+
+  inline_grammar(<<-'END')
+    grammar TestHoist;
+    options {
+        language = Ruby;
+    }
+    
+    /* With this true, enum is seen as a keyword.  False, it's an identifier */
+    @parser::init {
+      @enable_enum = false
+    }
+    @members {
+      attr_accessor :enable_enum
+    }
+    
+    stat returns [enumIs]
+        : identifier    {$enumIs = "ID"}
+        | enumAsKeyword {$enumIs = "keyword"}
+        ;
+    
+    identifier
+        : ID
+        | enumAsID
+        ;
+    
+    enumAsKeyword : {@enable_enum}? 'enum' ;
+    
+    enumAsID : {!@enable_enum}? 'enum' ;
+    
+    ID  :   ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*
+        ;
+    
+    INT :	('0'..'9')+
+        ;
+    
+    WS  :   (   ' '
+            |   '\t'
+            |   '\r'
+            |   '\n'
+            )+
+            {$channel=HIDDEN}
+        ;
+  END
+  
+  
+  example "'enum' is a keyword" do
+    lexer = TestHoist::Lexer.new 'enum'
+    parser = TestHoist::Parser.new lexer
+    parser.enable_enum = true
+    parser.stat.should == 'keyword'
+  end
+  
+  example "'enum' is an ID" do
+    lexer = TestHoist::Lexer.new 'enum'
+    parser = TestHoist::Parser.new lexer
+    parser.enable_enum = false
+    parser.stat.should == 'ID'
+  end
+  
+end
+
+
+class TestSyntacticPredicate < ANTLR3::Test::Functional
+
+  inline_grammar(<<-'END')
+    grammar SyntacticPredicate;
+    options {
+      language = Ruby;
+    }
+    
+    @parser::members {
+      def emit_error_message(msg)
+        # do nothing
+      end
+      def report_error(error)
+        raise error
+      end
+    }
+    
+    a: ((s+ P)=> s+ b)? E;
+    b: P 'foo';
+    
+    s: S;
+    
+    
+    S: ' ';
+    P: '+';
+    E: '>';
+  END
+  
+  example "rule with syntactic predicate" do
+    lexer = SyntacticPredicate::Lexer.new('   +foo>')
+    parser = SyntacticPredicate::Parser.new lexer
+    events = parser.a
+  end
+end
+