antlr3 1.2.3

data/test/functional/main/main-scripts.rb

@@ -0,0 +1,245 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+require 'antlr3'
+require 'antlr3/test/functional'
+
+ENV.delete( 'RUBYOPT' )
+ENV['RUBYLIB'] = ANTLR3.library_path
+
+class TestMainUtility < ANTLR3::Test::Functional
+  
+  example 'overriding the built-in script action using the @main named-action' do
+    grammar = inline_grammar(<<-'END')
+      lexer grammar MainOverride;
+      options { language = Ruby; }
+      
+      @main {
+        raise( "the main block ran" )
+      }
+      
+      ID: ('a'..'z' | '\u00c0'..'\u00ff')+;
+      WS: ' '+ { $channel = HIDDEN; };
+    END
+    
+    # when this grammar is compiled and the resulting ruby files
+    # are loaded as a library, the custom @main block
+    # should not be executed
+    proc { compile_and_load( grammar ) }.should_not raise_error
+    
+    # this assertion verifies that the main region is executed
+    # when the parser script is run directly
+    lexer_script = grammar.target_files.first
+    out = `ruby #{lexer_script} 2>&1`.chomp
+    out.should =~ /the main block ran/
+  end
+  
+  example 'using Lexer.main() to run the built-in lexer utility script on a source file' do
+    input_path = local_path('input.txt')
+    open(input_path, 'w') { |f| f.write("yada yada") }
+    
+    compile_and_load inline_grammar(<<-'END')
+      lexer grammar LexerMainWithSourceFile;
+      options { language = Ruby; }
+      
+      ID: 'a'..'z'+;
+      WS: ' '+ { $channel = HIDDEN; };
+    END
+    
+    begin
+      output = StringIO.new
+      input = File.open(input_path)
+      LexerMainWithSourceFile::Lexer.main([], :input => input, :output => output)
+      
+      out_lines = output.string.split(/\n/)
+      out_lines.should have(3).things
+    ensure
+      File.delete(input_path)
+    end
+  end
+
+  example 'using Lexer.main to run the built-in lexer utility script on input from $stdin' do
+    input = StringIO.new("yada yada")    # <- used to simulate $stdin
+    output = StringIO.new
+    
+    compile_and_load inline_grammar(<<-'END')
+      lexer grammar LexerMainFromStdIO;
+      options { language = Ruby; }
+      
+      ID: 'a'..'z'+;
+      WS: ' '+ { $channel = HIDDEN; };
+    END
+    
+    LexerMainFromStdIO::Lexer.main([], :input => input, :output => output)
+    lines = output.string.split(/\n/)
+    lines.should have(3).things
+  end
+
+  example 'using Parser.main to run the built-in parser script utility with a combo grammar' do
+    compile_and_load inline_grammar(<<-'END')
+      grammar MainForCombined;
+      options { language = Ruby; }
+      r returns [res]: (ID)+ EOF { $res = $text; };
+      
+      ID: 'a'..'z'+;
+      WS: ' '+ { $channel = HIDDEN; };
+    END
+    
+    output = StringIO.new
+    input = StringIO.new('yada yada')
+    
+    MainForCombined::Parser.main(
+        %w(--rule r --lexer-name MainForCombined::Lexer),
+        :input => input, :output => output)
+    lines = output.string.split("\n")
+    lines.should have(4).things
+  end
+  
+  example 'using built-in main to inspect AST constructed by an AST-building parser' do
+    compile_and_load inline_grammar(<<-'END')
+      grammar ASTParserMain;
+      options {
+        language = Ruby;
+        output = AST;
+      }
+      r: ID OP^ ID EOF!;
+      
+      ID: 'a'..'z'+;
+      OP: '+';
+      WS: ' '+ { $channel = HIDDEN; };
+    END
+    
+    output = StringIO.new
+    input  = StringIO.new 'yada + yada'
+    ASTParserMain::Parser.main(
+      %w(--rule r --lexer-name ASTParserMain::Lexer),
+      :input => input, :output => output)
+    output = output.string.strip
+    output.should == "(+ yada yada)"
+  end
+  
+  example "using a tree parser's built-in main" do
+    compile_and_load inline_grammar(<<-'END')
+      grammar TreeMain;
+      options {
+        language = Ruby;
+        output = AST;
+      }
+      
+      r: ID OP^ ID EOF!;
+      
+      ID: 'a'..'z'+;
+      OP: '+';
+      WS: ' '+ { $channel = HIDDEN; };
+    END
+    compile_and_load inline_grammar(<<-'END')
+      tree grammar TreeMainWalker;
+      options {
+        language=Ruby;
+        ASTLabelType=CommonTree;
+        tokenVocab=TreeMain;
+      }
+      r returns [res]: ^(OP a=ID b=ID)
+        { $res = "\%s \%s \%s" \% [$a.text, $OP.text, $b.text] }
+        ;
+    END
+    
+    output = StringIO.new
+    input  = StringIO.new 'a+b'
+    
+    TreeMainWalker::TreeParser.main(
+      %w(--rule r --parser-name TreeMain::Parser
+         --parser-rule r --lexer-name TreeMain::Lexer),
+      :input => input, :output => output)
+    output = output.string.strip
+    output.should == '"a + b"'
+  end
+  
+  example "using a tree parser's built-in main to inspect AST rewrite output" do
+    compile_and_load inline_grammar(<<-'END')
+      grammar TreeRewriteMain;
+      options {
+        language = Ruby;
+        output = AST;
+      }
+      
+      r: ID OP^ ID EOF!;
+      
+      ID: 'a'..'z'+;
+      OP: '+';
+      WS: ' '+ { $channel = HIDDEN; };
+    END
+    compile_and_load inline_grammar(<<-'END')
+      tree grammar TreeRewriteMainWalker;
+      options {
+        language=Ruby;
+        ASTLabelType=CommonTree;
+        tokenVocab=TreeRewriteMain;
+        output=AST;
+      }
+      tokens { ARG; }
+      r: ^(OP a=ID b=ID) -> ^(OP ^(ARG ID) ^(ARG ID));
+    END
+    
+    output = StringIO.new
+    input  = StringIO.new 'a+b'
+    TreeRewriteMainWalker::TreeParser.main(
+      %w(--rule r --parser-name TreeRewriteMain::Parser
+         --parser-rule r --lexer-name TreeRewriteMain::Lexer),
+      :input => input, :output => output
+    )
+    
+    output = output.string.strip
+    output.should == '(+ (ARG a) (ARG b))'
+  end
+  
+  example 'using built-in main with a delegating grammar' do
+    inline_grammar(<<-'END')
+      parser grammar MainSlave;
+      options { language=Ruby; }
+      a : B;
+    END
+    master = inline_grammar(<<-'END')
+      grammar MainMaster;
+      options { language=Ruby; }
+      import MainSlave;
+      s returns [res]: a { $res = $a.text };
+      B : 'b' ; // defines B from inherited token space
+      WS : (' '|'\n') {skip} ;
+    END
+    master.compile
+    for file in master.target_files
+      require(file)
+    end
+    
+    output = StringIO.new
+    input = StringIO.new 'b'
+    
+    MainMaster::Parser.main(
+      %w(--rule s --lexer-name MainMaster::Lexer),
+      :input => input, :output => output)
+    output = output.string.strip
+    output.should == 'b'.inspect
+  end
+
+  #test :LexerEncoding do
+  #  broken!("Non-ASCII encodings have not been implemented yet")
+  #  grammar = inline_grammar(<<-'END')
+  #    lexer grammar T3;
+  #    options {
+  #      language = Ruby;
+  #      }
+  #
+  #    ID: ('a'..'z' | '\u00c0'..'\u00ff')+;
+  #    WS: ' '+ { $channel = HIDDEN; };
+  #  END
+  #  compile grammar
+  #  input = StringIO.new("föö bär")
+  #  output = StringIO.new('')
+  #  lexer_class.main(%w(--encoding utf-8), :input => input, :output => output)
+  #  puts output.string
+  #  lines = output.string.split(/\n/)
+  #  lines.should have(3).things
+  #end
+
+end

data/test/functional/parser/actions.rb

@@ -0,0 +1,224 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+require 'antlr3/test/functional'
+
+class TestActions1 < ANTLR3::Test::Functional
+  inline_grammar(<<-'END')
+    grammar ParserActions;
+    options { language = Ruby; }
+    
+    declaration returns [name]
+        :   functionHeader ';'
+            { $name = $functionHeader.name }
+        ;
+    
+    functionHeader returns [name]
+        : type id=ID
+          { $name = $id.text }
+        ;
+    
+    type
+        :   'int'
+        |   'char'
+        |   'void'
+        ;
+    
+    ID  :   ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*
+        ;
+    
+    WS  :   (   ' '
+            |   '\t'
+            |   '\r'
+            |   '\n'
+            )+
+            {$channel=HIDDEN}
+        ;    
+  END
+  
+  example "parser action execution" do
+    lexer = ParserActions::Lexer.new "int foo;"
+    parser = ParserActions::Parser.new lexer
+    
+    parser.declaration.should == 'foo'
+  end
+  
+end
+
+
+class TestActions2 < ANTLR3::Test::Functional
+
+  inline_grammar(<<-'END')
+    grammar AllKindsOfActions;
+    options { language = Ruby; }
+    
+    @parser::members {
+      include ANTLR3::Test::CaptureOutput
+    }
+    
+    @lexer::members {
+      include ANTLR3::Test::CaptureOutput
+    }
+    @lexer::init { @foobar = 'attribute' }
+    
+    prog
+    @init  { say('init')  }
+    @after { say('after') }
+      :   IDENTIFIER EOF
+      ;
+      catch [ RecognitionError => exc ] {
+        say('catch')
+        raise
+      }
+      finally { say('finally') }
+    
+    
+    IDENTIFIER
+        : ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*
+          {
+            # a comment
+            say('action')
+            say('\%p \%p \%p \%p \%p \%p \%p \%p' \% [$text, $type, $line, $pos, $index, $channel, $start, $stop])
+            say(@foobar)
+          }
+        ;
+    
+    WS: (' ' | '\n')+;
+  END
+
+
+  example "execution of special named actions" do
+    lexer = AllKindsOfActions::Lexer.new( "foobar _Ab98 \n A12sdf" )
+    parser = AllKindsOfActions::Parser.new lexer
+    parser.prog
+    
+    parser.output.should == <<-END.fixed_indent(0)
+      init
+      after
+      finally
+    END
+    
+    lexer.output.should == <<-END.fixed_indent(0)
+      action
+      "foobar" 4 1 0 -1 :default 0 5
+      attribute
+      action
+      "_Ab98" 4 1 7 -1 :default 7 11
+      attribute
+      action
+      "A12sdf" 4 2 1 -1 :default 15 20
+      attribute
+    END
+  end
+end
+
+class TestFinally < ANTLR3::Test::Functional
+
+  inline_grammar(<<-'END')
+    grammar Finally;
+    
+    options {
+        language = Ruby;
+    }
+    
+    prog returns [events]
+    @init {events = []}
+    @after {events << 'after'}
+        :   ID {raise RuntimeError}
+        ;
+        catch [RuntimeError] {events << 'catch'}
+        finally { events << 'finally'}
+    
+    ID  :   ('a'..'z')+
+        ;
+    
+    WS  :   (' '|'\n'|'\r')+ {$channel=HIDDEN}
+        ;
+  END
+
+  
+  example "order of catch and ensure clauses" do
+    lexer = Finally::Lexer.new( 'foobar' )
+    parser = Finally::Parser.new lexer
+    parser.prog.should == %w(catch finally)
+  end
+
+end
+
+
+class TestActionScopes < ANTLR3::Test::Functional
+
+  inline_grammar(<<-'END')
+    grammar SpecialActionScopes;
+    options { language=Ruby; }
+    
+    @header {
+      \$header_location = __LINE__
+      \$header_context = self
+    }
+    
+    @footer {
+      \$footer_location = __LINE__
+      \$footer_context = self
+    }
+    
+    
+    @module::head {
+      \$module_head_location = __LINE__
+      \$module_head_context = self
+      
+      class << self
+        attr_accessor :head_var
+      end
+    }
+    
+    @module::foot {
+      \$module_foot_location = __LINE__
+      \$module_foot_context  = self
+      
+      FOOT_CONST = 1
+    }
+    
+    @token::scheme {
+      \$token_scheme_location = __LINE__
+      \$token_scheme_context = self
+      
+      SCHEME_CONST = 1
+    }
+    
+    @token::members {
+      \$token_members_location = __LINE__
+      \$token_members_context  = self
+      
+      def value
+        text.to_i
+      end
+    }
+    
+    @members {
+      \$members_location = __LINE__
+    }
+    
+    nums returns [ds]: digs+=DIGIT+
+                       { $ds = $digs.map { |t| t.value } };
+    
+    DIGIT: ('0'..'9')+;
+    WS: (' ' | '\t' | '\n' | '\r' | '\f')+ { $channel=HIDDEN; };
+  END
+  
+  example 'verifying action scope behavior' do
+    lexer = SpecialActionScopes::Lexer.new("10 20 30 40 50")
+    parser = SpecialActionScopes::Parser.new lexer
+    parser.nums.should == [10, 20, 30, 40, 50]
+  end
+  
+  example 'special action scope locations' do
+    $header_location.should be < $module_head_location
+    $module_head_location.should be < $token_scheme_location
+    $token_scheme_location.should be < $token_members_location
+    $token_members_location.should be < $members_location
+    $members_location.should be < $module_foot_location
+    $module_foot_location.should be < $footer_location
+  end
+
+end