antlr3 1.8.0 → 1.8.2

data/samples/standard/C/output

@@ -0,0 +1,171 @@
+define type size_t
+define type wchar_t
+define type _Bool
+define type div_t
+define type ldiv_t
+define type __u_char
+define type __u_short
+define type __u_int
+define type __u_long
+define type __int8_t
+define type __uint8_t
+define type __int16_t
+define type __uint16_t
+define type __int32_t
+define type __uint32_t
+define type __int64_t
+define type __uint64_t
+define type __quad_t
+define type __u_quad_t
+define type __dev_t
+define type __uid_t
+define type __gid_t
+define type __ino_t
+define type __ino64_t
+define type __mode_t
+define type __nlink_t
+define type __off_t
+define type __off64_t
+define type __pid_t
+define type __fsid_t
+define type __clock_t
+define type __rlim_t
+define type __rlim64_t
+define type __id_t
+define type __time_t
+define type __useconds_t
+define type __suseconds_t
+define type __daddr_t
+define type __swblk_t
+define type __key_t
+define type __clockid_t
+define type __timer_t
+define type __blksize_t
+define type __blkcnt_t
+define type __blkcnt64_t
+define type __fsblkcnt_t
+define type __fsblkcnt64_t
+define type __fsfilcnt_t
+define type __fsfilcnt64_t
+define type __ssize_t
+define type __loff_t
+define type __qaddr_t
+define type __caddr_t
+define type __intptr_t
+define type __socklen_t
+define type u_char
+define type u_short
+define type u_int
+define type u_long
+define type quad_t
+define type u_quad_t
+define type fsid_t
+define type loff_t
+define type ino_t
+define type dev_t
+define type gid_t
+define type mode_t
+define type nlink_t
+define type uid_t
+define type off_t
+define type pid_t
+define type id_t
+define type ssize_t
+define type daddr_t
+define type caddr_t
+define type key_t
+define type time_t
+define type clockid_t
+define type timer_t
+define type ulong
+define type ushort
+define type uint
+define type int8_t
+define type int16_t
+define type int32_t
+define type int64_t
+define type u_int8_t
+define type u_int16_t
+define type u_int32_t
+define type u_int64_t
+define type register_t
+define type __sig_atomic_t
+define type __sigset_t
+define type sigset_t
+define type suseconds_t
+define type __fd_mask
+define type fd_set
+define type fd_mask
+define type blkcnt_t
+define type fsblkcnt_t
+define type fsfilcnt_t
+define type _pthread_descr
+define type pthread_attr_t
+define type __pthread_cond_align_t
+define type pthread_cond_t
+define type pthread_condattr_t
+define type pthread_key_t
+define type pthread_mutex_t
+define type pthread_mutexattr_t
+define type pthread_once_t
+define type pthread_t
+define type __compar_fn_t
+define type sig_atomic_t
+define type __sighandler_t
+define type sig_t
+define type sigval_t
+define type siginfo_t
+define type sigevent_t
+define type stack_t
+define type chtype
+define type FILE
+define type __FILE
+define type wint_t
+define type __mbstate_t
+define type _G_fpos_t
+define type _G_fpos64_t
+define type __gconv_fct
+define type __gconv_btowc_fct
+define type __gconv_init_fct
+define type __gconv_end_fct
+define type __gconv_trans_fct
+define type __gconv_trans_context_fct
+define type __gconv_trans_query_fct
+define type __gconv_trans_init_fct
+define type __gconv_trans_end_fct
+define type __gconv_t
+define type _G_iconv_t
+define type _G_int16_t
+define type _G_int32_t
+define type _G_uint16_t
+define type _G_uint32_t
+define type __gnuc_va_list
+define type _IO_lock_t
+define type _IO_FILE
+define type __io_read_fn
+define type __cookie
+define type __buf
+define type __nbytes
+define type __io_write_fn
+define type __cookie
+define type __buf
+define type __n
+define type __io_seek_fn
+define type __cookie
+define type __pos
+define type __w
+define type __io_close_fn
+define type __cookie
+define type fpos_t
+define type va_list
+define type NCURSES_BOOL
+define type SCREEN
+define type WINDOW
+define type attr_t
+define type mmask_t
+define type MEVENT
+define type cc_t
+define type speed_t
+define type tcflag_t
+define type TERMTYPE
+define type TERMINAL

data/samples/standard/LL-star/LLStar.g

@@ -0,0 +1,101 @@
+grammar LLStar;
+
+options { language = Ruby; }
+
+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 ';'
+  { puts( $functionHeader.name + " is a declaration") }
+    |   functionHeader block
+  { 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}
+    ;

data/samples/standard/LL-star/input

@@ -0,0 +1,12 @@
+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;
+  }
+}

data/samples/standard/LL-star/ll-star.rb

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

data/samples/standard/LL-star/output

@@ -0,0 +1,2 @@
+bar is a declaration
+foo is a definition

data/samples/standard/calc/Calculator.g

@@ -0,0 +1,47 @@
+grammar Calculator;
+options {
+  language = Ruby;
+}
+
+evaluate returns [result]
+  : r=expression { $result = $r.result }
+  ;
+
+expression returns [result]
+  : r=mult
+    ( '+' r2=mult { $r.result += $r2.result }
+    | '-' r2=mult { $r.result -= $r2.result }
+    )* { $result = $r.result }
+  ;
+
+mult returns [result]
+  : r=log
+    ( '*' r2=log { $r.result *= $r2.result }
+    | '/' r2=log { $r.result /= $r2.result }  //
+    )* { $result = $r.result };
+
+log returns [result]
+  : 'ln' r=exp { $result = Math.log( r ) }
+  | r=exp { $result = $r.result }
+  ;
+
+exp returns [result]
+  : r=atom ( '^' r2=atom { $r.result **= $r2.result } )? { $result = $r.result }
+  ;
+
+atom returns [result]
+  : n=INTEGER { $result = Integer( $n.text ) }
+  | n=DECIMAL { $result = $n.text.to_f }
+  | '(' 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 };

data/samples/standard/calc/Calculator.py

@@ -0,0 +1,16 @@
+import antlr3
+from CalculatorLexer import CalculatorLexer
+from CalculatorParser import CalculatorParser
+
+
+while True:
+    expr = raw_input('>>> ')
+    if expr == '':
+        break
+    
+    cStream = antlr3.StringStream(expr)
+    lexer = CalculatorLexer(cStream)
+    tStream = antlr3.CommonTokenStream(lexer)
+    parser = CalculatorParser(tStream)
+    result = parser.evaluate()
+    print result

data/samples/standard/calc/Calculator.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+$:.unshift( File.dirname( __FILE__ ) )
+require 'CalculatorLexer'
+require 'CalculatorParser'
+
+fetch = 
+  begin
+    require 'readline'
+    proc do
+      Readline.readline( ">>> ", true )
+    end
+  rescue LoadError
+    proc do
+      print( ">>> " )
+      l = $stdin.gets and l.chomp
+    end
+  end
+
+puts( "enter calculator expressions or `quit' to exit")
+loop do
+  case line = fetch.call
+  when /q(uit)?/i, /e(xit)?/i, nil then break
+  else
+    printf( "\t=> %s\n", Calculator::Parser.new( line ).evaluate )
+  end
+end

data/samples/standard/cminus/CMinus.g

@@ -0,0 +1,141 @@
+grammar CMinus;
+options {
+  language = Ruby;
+  output   = template;
+}
+
+scope slist {
+    locals;
+    stats;
+}
+
+@members {
+  load_templates( 'java.group' )
+}
+
+program
+scope {
+  globals;
+  functions;
+}
+@init {
+  $program::globals   = []
+  $program::functions = []
+}
+    :   declaration+
+        -> program(globals={$program::globals},functions={$program::functions})
+    ;
+
+declaration
+    :   variable   { $program::globals << $variable.st }
+    |   f=function { $program::functions << $f.st }
+    ;
+
+// ack is $function.st ambig?  It can mean the rule's dyn scope or
+// the ref in this rule.  Ack.
+
+variable
+    :   type declarator ';'
+        -> { $function.length > 0 and $function::name.nil? }?
+           globalVariable(type={$type.st},name={$declarator.st})
+        -> variable(type={$type.st},name={$declarator.st})
+    ;
+
+declarator
+    :   ID -> { $ID.text }
+    ;
+
+function
+scope {
+    name;
+}
+scope slist;
+@init {
+  $slist::locals = []
+  $slist::stats  = []
+}
+    :   type ID { $function::name = $ID.text }
+        '(' ( p+=formalParameter ( ',' p+=formalParameter )* )? ')'
+        block
+        -> function(type={$type.st}, name={$function::name},
+                    locals={$slist::locals},
+                    stats={$slist::stats},
+                    args={$p})
+    ;
+
+formalParameter
+    :   type declarator 
+        -> parameter(type={$type.st},name={$declarator.st})
+    ;
+
+type
+    : 'int'  -> type_int()
+    | 'char' -> type_char()
+    | ID     -> type_user_object(name={$ID.text})
+    ;
+
+block
+  : '{'
+    ( variable { $slist::locals << $variable.st } )*
+    ( stat { $slist::stats << $stat.st } )*
+    '}'
+  ;
+
+stat
+scope slist;
+@init {
+  $slist::locals = []
+  $slist::stats = []
+}
+  : forStat -> { $forStat.st }
+  | expr ';' -> statement( expr={$expr.st} )
+  | block -> statementList( locals={$slist::locals}, stats={$slist::stats} )
+  | assignStat ';' -> { $assignStat.st }
+  | ';' -> { ';' }
+  ;
+
+forStat
+scope slist;
+@init {
+  $slist::locals = []
+  $slist::stats = []
+}
+  : 'for' '(' e1=assignStat ';' e2=expr ';' e3=assignStat ')' block
+    -> forLoop(e1={$e1.st},e2={$e2.st},e3={$e3.st},locals={$slist::locals}, stats={$slist::stats})
+  ;
+
+assignStat
+  :   ID '=' expr -> assign(lhs={$ID.text}, rhs={$expr.st})
+  ;
+
+expr: condExpr -> {$condExpr.st}
+    ;
+
+condExpr
+    :   a=aexpr
+        (   (  '==' b=aexpr -> equals(left={$a.st},right={$b.st})
+            |  '<' b=aexpr   -> lessThan(left={$a.st},right={$b.st})
+            )
+        |   -> {$a.st} // else just aexpr
+        )
+    ;
+
+aexpr
+    :   (a=atom -> {$a.st})
+        ( '+' b=atom -> add(left={$aexpr.st}, right={$b.st}) )*
+    ;
+
+atom
+    : ID -> refVar(id={$ID.text})
+    | INT -> iconst(value={$INT.text})
+    | '(' expr ')' -> {$expr.st}
+    ; 
+
+ID  :   ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*
+    ;
+
+INT	:	('0'..'9')+
+	;
+
+WS  :   (' ' | '\t' | '\r' | '\n')+ {$channel=HIDDEN;}
+    ;