#!/usr/bin/ruby
# encoding: utf-8

require 'antlr3/test/functional'

class TestParser001 < ANTLR3::Test::Functional
  inline_grammar( <<-'END' )
    grammar Identifiers;
    options { language = Ruby; }
    
    @parser::init {
      @identifiers = []
      @reported_errors = []
    }
    
    @parser::members {
      attr_reader :reported_errors, :identifiers
      
      def found_identifier(name)
          @identifiers << name
      end
      
      def emit_error_message(msg)
        @reported_errors << msg
      end
    }
    
    document:
            t=IDENTIFIER {found_identifier($t.text)}
            ;
    
    IDENTIFIER: ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*;
  END
  
  example "parsing 'blah_de_blah'" do
    # to build a parser, this is the standard chain of calls to prepare the input
    input = ANTLR3::StringStream.new( 'blah_de_blah', :file => 'blah.txt' )
    lexer  = Identifiers::Lexer.new( input )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = Identifiers::Parser.new( tokens )
    
    parser.document
    
    parser.reported_errors.should be_empty
    parser.identifiers.should == %w(blah_de_blah)
  end
  
  example "error from empty input" do
    # if you don't need to use a customized stream, lexers and parsers will
    # automatically wrap input in the standard stream classes
    lexer = Identifiers::Lexer.new( '' )
    parser = Identifiers::Parser.new( lexer )
    parser.document
    
    parser.reported_errors.should have( 1 ).thing
  end
  
  example 'automatic input wrapping' do
    # if the parser is able to figure out what lexer class
    # to use (typically when it comes from a combined grammar),
    # and you don't need to do any special token processing
    # before making a parser, this is an extra shortcut for
    # parser construction
    parser = Identifiers::Parser.new( 'blah_de_blah', :file => 'blah.txt' )
    
    parser.document
    
    parser.reported_errors.should be_empty
    parser.identifiers.should == %w(blah_de_blah)
  end
end

class TestParser002 < ANTLR3::Test::Functional
  inline_grammar( <<-'END' )
    grammar SimpleLanguage;
    options {
      language = Ruby;
    }
    
    @parser::init {
      @events = []
      @reported_errors = []
    }
    
    @parser::members {
      attr_reader :reported_errors, :events
      
      def emit_error_message(msg)
        @reported_errors << msg
      end
    }
    
    document:
            ( declaration
            | call
            )*
            EOF
        ;
    
    declaration:
            'var' t=IDENTIFIER ';'
            {@events << ['decl', $t.text]}
        ;
    
    call:
            t=IDENTIFIER '(' ')' ';'
            {@events << ['call', $t.text]}
        ;
    
    IDENTIFIER: ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*;
    WS:  (' '|'\r'|'\t'|'\n') {$channel=HIDDEN;};
  END
  
  
  example "parsing decls and calls" do
    lexer  = SimpleLanguage::Lexer.new( "var foobar; gnarz(); var blupp; flupp ( ) ;" )
    parser = SimpleLanguage::Parser.new( lexer )
    
    parser.document
    
    parser.reported_errors.should be_empty
    parser.events.should == [ 
      %w(decl foobar),
      %w(call gnarz),
      %w(decl blupp),
      %w(call flupp)
    ]
  end
  
  example "bad declaration" do
    lexer  = SimpleLanguage::Lexer.new( 'var; foo()' )
    parser = SimpleLanguage::Parser.new( lexer )
    
    parser.document
    
    parser.reported_errors.should have( 1 ).thing
    parser.events.should be_empty
  end
  
  example "error recovery via token insertion" do
    lexer  = SimpleLanguage::Lexer.new( 'gnarz(; flupp();' )
    parser = SimpleLanguage::Parser.new( lexer )
    
    parser.document
    
    parser.reported_errors.should have( 1 ).thing
    parser.events.should == [ 
      %w(call gnarz),
      %w(call flupp)
    ]
  end
  
end

class TestParser003 < ANTLR3::Test::Functional
  inline_grammar( <<-'END' )
    grammar MoreComplicated;
    
    options { language = Ruby; }
    
    @init {
      @reported_errors = []
    }
    
    @members {
      attr_reader :reported_errors
      
      def emit_error_message(msg)
        @reported_errors << msg
      end
    }
    
    program
        :   declaration+
        ;
    
    declaration
        :   variable
        |   functionHeader ';'
        |   functionHeader block
        ;
    
    variable
        :   type declarator ';'
        ;
    
    declarator
        :   ID 
        ;
    
    functionHeader
        :   type ID '(' ( formalParameter ( ',' formalParameter )* )? ')'
        ;
    
    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 'int foo;'" do
    lexer = MoreComplicated::Lexer.new "int foo;"
    parser = MoreComplicated::Parser.new lexer
    parser.program
    parser.reported_errors.should be_empty
  end
  
  
  example "catching badly formed input" do
    lexer = MoreComplicated::Lexer.new "int foo() { 1+2 }"
    parser = MoreComplicated::Parser.new lexer
    parser.program
    parser.reported_errors.should have( 1 ).thing
  end
  
  example "two instances of badly formed input" do
    lexer = MoreComplicated::Lexer.new "int foo() { 1+; 1+2 }"
    parser = MoreComplicated::Parser.new lexer
    parser.program
    parser.reported_errors.should have( 2 ).things
  end
  
end