antlr3 1.8.0 → 1.8.2

data/samples/standard/cminus/bytecode.group

@@ -0,0 +1,80 @@
+group Bytecode
+
+program(globals,functions) ::=
+<<<
+.class public Wrapper
+.super java/lang/Object
+<%= @globals.join( "\n" ) %>
+<%= @functions.join( "\n" ) %>
+>>>
+
+variable(type,name) ::= ".var is <%= @name %> <%= @type %>"
+
+globalVariable(type,name) ::= ".field <%= @name %> <%= @type %>"
+
+function(type,name,args,locals,stats) ::=
+<<<
+.method <%= @name %>(<%= @args.map { | i | i.type } %>)<%= @type %>
+    <%= @locals %>
+% for stat in @stats
+    <%= stat %>
+% end
+    return
+.end method
+>>>
+
+type_int() ::= "I"
+
+type_char() ::= "C"
+
+type_user_object( name ) ::= "L<%= @name %>;"
+
+parameter(type,name) ::= "<%= @type %> <%= @name %>"
+
+statement(expr) ::= "<%= @expr %>"
+
+statementList(locals,stats) ::= <<
+<%= @locals %>
+<%= stats.join( "\n" ) %>
+>>
+
+forLoop(e1,e2,e3,locals,stats) ::= <<
+<%= @e1 %>
+start:
+<%= @e2 %>
+bf exit
+<%= @locals %>
+% for stat in @stats
+<%= stat %>
+% end
+<%= e3 %>
+goto start
+exit:
+>>
+
+assign(lhs,rhs) ::= <<
+<%= @rhs %>
+store <%= @lhs %>
+>>
+
+equals(left,right) ::= <<
+<%= @left %>
+<%= @right %>
+equals
+>>
+
+lessThan(left,right) ::= <<
+<%= @left %>
+<%= @right %>
+lt
+>>
+
+add(left,right) ::= <<
+<%= @left %>
+<%= @right %>
+add
+>>
+
+refVar(id) ::= "push <%= @id %>"
+
+iconst(value) ::= "iconst <%= @value %>"

data/samples/standard/cminus/cminus.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+$LOAD_PATH.unshift( File.dirname( __FILE__ ) )
+require 'CMinusLexer'
+require 'CMinusParser'
+
+input = ARGV.shift or fail( "please provide an input file path" )
+options = {}
+if template_file = ARGV.shift
+  options[ :templates ] = ANTLR3::Template::Group.load( template_file )
+end
+
+input = ANTLR3::FileStream.new( input )
+lexer = CMinus::Lexer.new( input )
+puts( CMinus::Parser.new( lexer, options ).program.template )

data/samples/standard/cminus/input

@@ -0,0 +1,9 @@
+char c;
+int x;
+int foo(int y, char d) {
+  int i;
+  for (i=0; i<3; i=i+1) {
+    x=3;
+    y=5;
+  }
+}

data/samples/standard/cminus/java.group

@@ -0,0 +1,91 @@
+group CMinus::Java
+
+indent( text, level ) ::=
+<<<
+% @text.to_s.each_line do | line |
+<%= '    ' * @level %><%= line.chomp %>
+% end
+>>>
+
+program(globals,functions) ::=
+<<<
+class Wrapper {
+% for global in @globals
+    <%= global %>
+% end
+% for function in @functions
+% for line in function.to_s.lines
+    <%= line.chomp %>
+% end
+% end
+}
+>>>
+
+variable(type,name) ::= "<%= @type %> <%= @name %>;"
+
+globalVariable ::= variable
+
+function(type,name,args,locals,stats) ::=
+<<<
+<%= @type %> <%= @name %>( <%= @args.join( ', ' ) %> ) {
+% for local in @locals
+    <%= local %>
+% end
+% for stat in @stats
+% for line in stat.to_s.lines
+    <%= line.chomp %>
+% end
+% end
+}
+>>>
+
+type_int() ::= "int"
+
+type_char() ::= "char"
+
+type_user_object(name) ::= "<%= @name %>"
+
+parameter(type,name) ::= "<%= @type %> <%= @name %>"
+
+statement(expr) ::= "<%= @expr %>;"
+
+statementList(locals,stats) ::=
+<<<
+{
+% for local in @locals
+    <%= local %>
+% end
+% for stat in @stats
+% for line in stat.to_s.lines
+    <%= line.chomp %>
+% end
+% end
+}
+
+>>>
+
+forLoop(e1,e2,e3,locals,stats) ::=
+<<<
+for (<%= @e1 %> <%= @e2 %>; <%= @e3 %>) {
+% for local in @locals
+    <%= local %>
+% end
+% for stat in @stats
+% for line in stat.to_s.lines
+    <%= line.chomp %>
+% end
+% end
+}
+>>>
+
+assign(lhs,rhs) ::= "<%= @lhs %> = <%= @rhs %>;"
+
+equals(left,right) ::= "<%= @left %> == <%= @right %>"
+
+lessThan(left,right) ::= "<%= @left %> < <%= @right %>"
+
+add(left,right) ::= "<%= @left %> + <%= @right %>"
+
+refVar(id) ::= "<%= @id %>"
+
+iconst(value) ::= "<%= @value %>"

data/samples/standard/cminus/output

@@ -0,0 +1,11 @@
+class Wrapper {
+    char c;
+    int x;
+    int foo(int y, char d) {
+        int i;
+        for (i = 0; i < 3; i = i + 1;) {
+            x = 3;
+            y = 5;
+        }
+    }
+}

data/samples/standard/cminus/python.group

@@ -0,0 +1,48 @@
+group Python;
+
+program(globals,functions) ::= <<
+<functions; separator="\n">
+>>
+
+variable(type,name) ::= " "
+
+globalVariable ::= variable
+
+function(type,name,args,locals,stats) ::= <<
+def <name>(<args; separator=", ">):
+    <stats>
+>>
+
+type_int() ::= "int"
+
+type_char() ::= "char"
+
+type_user_object(name) ::= "<name>"
+
+parameter(type,name) ::= "<name>"
+
+statement(expr) ::= "<expr>"
+
+statementList(locals,stats) ::= <<
+    <stats; separator="\n">
+>>
+
+// python has a weird FOR, use a WHILE. :)
+forLoop(e1,e2,e3,locals,stats) ::= <<
+<e1>
+while ( <e2> ):
+	<stats; separator="\n">
+	<e3>
+>>
+
+assign(lhs,rhs) ::= "<lhs> = <rhs>"
+
+equals(left,right) ::= "<left> == <right>"
+
+lessThan(left,right) ::= "<left> \< <right>"
+
+add(left,right) ::= "<left> + <right>"
+
+refVar(id) ::= "<id>"
+
+iconst(value) ::= "<value>"

data/samples/standard/dynamic-scope/DynamicScopes.g

@@ -0,0 +1,50 @@
+grammar DynamicScopes;
+
+options {
+  language = Ruby;
+}
+
+program : method ;
+
+method
+/* name is visible to any rule called by method directly or indirectly.
+ *  There is also a stack of these names, one slot for each nested
+ *  invocation of method.  If you have a method nested within another
+ *  method then you have name strings on the stack.  Referencing
+ *  $method.name access the topmost always.  I have no way at the moment
+ *  to access earlier elements on the stack.
+ */
+scope {
+  name;
+}
+    :   'method' ID '(' ')' { $method::name = $ID.text } body
+    ; 
+
+body:   '{' stat* '}'
+    ;
+
+stat:   ID '=' expr ';'
+    |   method // allow nested methods to demo stack nature of dynamic attributes
+    ;
+
+expr:   mul ('+' mul)* 
+    ;
+
+mul :   atom ('*' atom)*
+    ;
+
+/** Demonstrate that 'name' is a dynamically-scoped attribute defined
+ *  within rule method.  With lexical-scoping (variables go away at
+ *  the end of the '}'), you'd have to pass the current method name
+ *  down through all rules as a parameter.  Ick.  This is much much better.
+ */
+atom:   ID  { puts( "ref #{ $ID.text } from method #{ $method::name }" ) }
+    |   INT { puts( "int #{ $INT.text } in method #{ $method::name }" ) }
+    ;
+
+ID  :   ('a'..'z'|'A'..'Z')+ ;
+
+INT :   '0'..'9'+ ;
+
+WS  :   (' '|'\t'|'\n')+ {$channel=HIDDEN}
+    ;

data/samples/standard/dynamic-scope/dynamic-scopes.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+$:.unshift( File.dirname( __FILE__ ) )
+require 'DynamicScopesLexer'
+require 'DynamicScopesParser'
+
+for file in ARGV
+  input = ANTLR3::FileStream.new( file )
+  lexer = DynamicScopes::Lexer.new( input )
+  parser = DynamicScopes::Parser.new( lexer )
+  parser.program
+end

data/samples/standard/dynamic-scope/input

@@ -0,0 +1,7 @@
+method foo() {
+  i = 3;
+  method bar() {
+    j = i*2;
+  }
+  k = i;
+}

data/samples/standard/dynamic-scope/output

@@ -0,0 +1,4 @@
+int 3 in method foo
+ref i from method bar
+int 2 in method bar
+ref i from method foo

data/samples/standard/fuzzy/FuzzyJava.g

@@ -0,0 +1,89 @@
+lexer grammar FuzzyJava;
+options {
+  language=Ruby;
+  filter=true;
+}
+
+IMPORT
+	:	'import' WS name=QIDStar WS? ';'
+	;
+	
+/** Avoids having "return foo;" match as a field */
+RETURN
+	:	'return' .* ';'
+	;
+
+CLASS
+	:	'class' WS name=ID WS? ('extends' WS QID WS?)?
+		('implements' WS QID WS? (',' WS? QID WS?)*)? '{'
+        { puts( "found class #{ $name.text }" ) }
+	;
+	
+METHOD
+    :   TYPE WS name=ID WS? '(' ( ARG WS? (',' WS? ARG WS?)* )? ')' WS? 
+       ('throws' WS QID WS? (',' WS? QID WS?)*)? '{'
+        { puts( "found method #{ $name.text }" ) }
+    ;
+
+FIELD
+    :   TYPE WS name=ID '[]'? WS? (';'|'=')
+        { puts( "found var #{ $name.text }" ) }
+    ;
+
+STAT:	('if'|'while'|'switch'|'for') WS? '(' ;
+	
+CALL
+    :   name=QID WS? '('
+        { puts( "found call #{ $name.text }" ) }
+    ;
+
+COMMENT
+    :   '/*' (options {greedy=false;} : . )* '*/'
+        { puts( "found comment #{ $text }" ) }
+    ;
+
+SL_COMMENT
+    :   '//' (options {greedy=false;} : . )* '\n'
+        { puts( "found // comment #{ $text }" ) }
+    ;
+	
+STRING
+	:	'"' (options {greedy=false;}: ESC | .)* '"'
+	;
+
+CHAR
+	:	'\'' (options {greedy=false;}: ESC | .)* '\''
+	;
+
+WS  :   (' '|'\t'|'\n')+
+    ;
+
+fragment
+QID :	ID ('.' ID)*
+	;
+	
+/** QID cannot see beyond end of token so using QID '.*'? somewhere won't
+ *  ever match since k=1 lookahead in the QID loop of '.' will make it loop.
+ *  I made this rule to compensate.
+ */
+fragment
+QIDStar
+	:	ID ('.' ID)* '.*'?
+	;
+
+fragment
+TYPE:   QID '[]'?
+    ;
+    
+fragment
+ARG :   TYPE WS ID
+    ;
+
+fragment
+ID  :   ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*
+    ;
+
+fragment
+ESC	:	'\\' ('"'|'\''|'\\')
+
+	;

data/samples/standard/fuzzy/fuzzy.py

@@ -0,0 +1,11 @@
+import sys
+import antlr3
+from FuzzyJava import FuzzyJava
+
+stream = antlr3.StringStream(open(sys.argv[1]).read())
+lexer = FuzzyJava(stream)
+
+while True:
+    token = lexer.nextToken()
+    if token.type == antlr3.EOF:
+        break

data/samples/standard/fuzzy/fuzzy.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+$:.unshift( File.dirname( __FILE__ ) )
+require 'FuzzyJava'
+
+for file in ARGV
+  input = ANTLR3::FileStream.new( file )
+  FuzzyJava::Lexer.new( input ).exhaust
+end