opal 0.2.2 → 0.3.0

data/lib/opal/builders/ruby/ruby_parser.rb.y

@@ -1,1451 +0,0 @@
-# 
-# ruby_parser.rb.y
-# vienna
-# 
-# Created by Adam Beynon.
-# Copyright 2009 Adam Beynon.
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-# 
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-
-class Vienna::RubyParser
-
-  #   prechigh
-  #     nonassoc tLOWEST
-  #     nonassoc tLBRACE_ARG
-  #     
-  #     left  tLSHFT tRSHFT
-  #     nonassoc  kIF_MOD kUNLESS_MOD kWHILE_MOD kUNTIL_MOD
-  #     left  kOR kAND
-  #     right kNOT
-  #     nonassoc kDEFined
-  #     right '=' tOP_ASGN
-  #     left kRESCUE_MOD
-  #     right '?' ':'
-  #     nonassoc tDOT2 tDOT3
-  #     left  tOROP
-  #     left  tANDOP
-  #     nonassoc  tCMP tEQ tEQQ tNEQ tMATCH tNMATCH
-  #     left  '>' tGEQ '<' tLEQ
-  #     left  '|' '^'
-  #     left  '&'
-  #     left  '+' '-'
-  #     left  '*' '/' '%'
-  #     right tUMINUS_NUM tUMINUS
-  #     right tPOW
-  #     right '!' '~' tUPLUS
-  # preclow
-  
-  prechigh
-    right    '!' tTILDE tUPLUS
-    right    tPOW
-    right    tUMINUS_NUM tUMINUS
-    left     tSTAR2 tDIVIDE tPERCENT
-    left     tPLUS tMINUS
-    left     tLSHFT tRSHFT
-    left     tAMPER2
-    left     tPIPE tCARET
-    left     '>' tGEQ '<' tLEQ
-    nonassoc tCMP tEQ tEQQ tNEQ tMATCH tNMATCH
-    left     tANDOP
-    left     tOROP
-    nonassoc tDOT2 tDOT3
-    right    '?' ':'
-    left     kRESCUE_MOD
-    right    '=' tOP_ASGN
-    # left     tANDOP
-    # left     tOROP
-    nonassoc kDEFINED
-    right    kNOT
-    left     kOR kAND
-    nonassoc kIF_MOD kUNLESS_MOD kWHILE_MOD kUNTIL_MOD
-    nonassoc tLBRACE_ARG
-    nonassoc tLOWEST
-  preclow
-	  
-  token kCLASS kMODULE kDEF kUNDEF kBEGIN kRESCUE kENSURE kEND kIF kUNLESS
-  token kTHEN kELSIF kELSE kCASE kWHEN kWHILE kUNTIL kFOR kBREAK kNEXT
-  token kREDO kRETRY kIN kDO kDO_COND kDO_BLOCK kDO_LAMBDA kRETURN kYIELD
-  token kSUPER kSELF kNIL kTRUE kFALSE kAND kOR kNOT kIF_MOD kUNLESS_MOD
-  token kWHILE_MOD kUNTIL_MOD kRESCUE_MOD kALIAS kDEFINED klBEGIN klEND
-  token k__LINE__ k__FILE__ k__ENCODING__ 
-  token kDEFined kBLOCK_GIVEN
-
-  token tIDENTIFIER tFID tGVAR tIVAR tCONSTANT tCVAR tLABEL tINTEGER tFLOAT
-  token tSTRING_CONTENT tCHAR tNTH_REF tBACK_REF tREGEXP_END tUPLUS tUMINUS
-  token tPOW tCMP tEQ tEQQ tNEQ tGEQ tLEQ tANDOP tOROP tMATCH tNMATCH	tDOT2
-  token tDOT3 tAREF tASET tLSHFT tRSHFT tCOLON2 tCOLON3 tOP_ASGN tASSOC
-  token tLPAREN	tLPAREN_ARG	tRPAREN tLBRACK tLBRACE tLBRACE_ARG tSTAR tAMPER
-  token tLAMBDA tSYMBEG tSTRING_BEG tXSTRING_BEG tREGEXP_BEG tWORDS_BEG
-  token tQWORDS_BEG tSTRING_DBEG tSTRING_DVAR tSTRING_END tLAMBEG tUMINUS_NUM
-  token tSTRING tXSTRING_END
-	
-
-rule
-
-          target: program
-                  {
-                    # puts 'well, we got here..'
-                    # puts val[0]
-                    @parser_result = val[0]
-                    result = val[0]
-                  }
-			
-         program:
-                  {
-                    self.lex_state = :EXPR_BEG
-                  }
-                  top_compstmt
-                  {
-                    # puts 'program'
-                    # puts val[1]
-                    result = val[1]
-                  }
-
-    top_compstmt: top_stmts opt_terms
-                  {
-                    # puts 'top_compstmt'
-                    # puts val[0]
-                    # puts val[1]
-                    result = val[0]
-                  }
-
-       top_stmts: none
-                  {
-                    result = []
-                  }
-                | top_stmt
-                  {
-                    result = [val[0]]
-                  }
-                | top_stmts terms top_stmt
-                  {
-                    result = val[0] + [val[2]]
-                  }
-                | error top_stmt
-                  {
-                    result = val[1]
-                  }
-
-        top_stmt: stmt
-                  {
-                    result = val[0]
-                  }
-  	            | kBEGIN
-
-        bodystmt: compstmt opt_rescue opt_else opt_ensure
-                  {
-                    # puts "erm wtf?!"
-                    # puts val[1]
-                    result = self.node_bodystmt(val[0], val[1], val[2], val[3])
-                    # if val[1]
-                      # pp result
-                    # end
-                  }
-
-        compstmt: stmts opt_terms
-                  {
-                    result = val[0]
-                  }
-
-           stmts: none
-                  {
-                    result = []
-                  }
-                | stmt
-                  {
-                    result = [val[0]]
-                  }
-		            | stmts terms stmt
-		              {
-                    result = val[0] + [val[2]]
-		              }
-		            | error stmt
-
-            stmt: kALIAS fitem
-                  {
-                    self.lex_state = :EXPR_FNAME
-                  }
-                  fitem
-                  {
-                    result = node :alias, :lhs => val[1], :rhs => val[3] 
-                  }
-            		| kALIAS tGVAR tGVAR
-            		| kALIAS tGVAR tBACK_REF
-            		| kALIAS tGVAR tNTH_REF
-            		| kUNDEF undef_list
-            		| stmt kIF_MOD expr_value
-            		  {
-                    result = node :if, :expr => val[2], :stmt => [val[0]], :tail => []
-            		  }
-            		| stmt kUNLESS_MOD expr_value
-            		  {
-            		    result = node :unless, :expr => val[2], :stmt => [val[0]], :tail => []
-            		  }
-            		| stmt kWHILE_MOD expr_value
-            		  {
-            		    result = node :while, :expr => val[2], :stmt => [val[0]]
-            		  }
-            		| stmt kUNTIL_MOD expr_value
-            		  {
-            		    result = node :until, :expr => val[2], :stmt => [val[0]]
-            		  }
-            		| stmt kRESCUE_MOD stmt
-                | klEND '{' compstmt '}'
-            		| lhs '=' command_call
-            		  {
-            		    result = node :assign, :lhs => val[0], :rhs => val[2]
-            		  }
-            		| mlhs '=' command_call
-            		| var_lhs tOP_ASGN command_call
-            		  {
-            		    result = node :op_asgn, :lhs => val[0], :op => val[1], :rhs => val[2]
-            		  }
-            		| primary_value '[' opt_call_args rbracket tOP_ASGN command_call
-            		  {
-            		    puts "in here for #{val[0]}"
-            		  }
-            		| primary_value '.' tIDENTIFIER tOP_ASGN command_call
-            		| primary_value '.' tCONSTANT tOP_ASGN command_call
-            		| primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_call
-            		| backref tOP_ASGN command_call
-            		| lhs '=' mrhs
-            		| mlhs '=' arg_value
-            		| mlhs '=' mrhs
-            		| expr
-
-            expr: command_call
-              	| expr kAND expr
-              	  {
-              	    result = node :andop, :lhs => val[0], :rhs => val[2]
-              	  }
-              	| expr kOR expr
-              	  {
-              	    result = node :orop, :lhs => val[0], :rhs => val[2]
-              	  }
-              	| kNOT opt_nl expr
-              	  {
-              	    result = node :not, :expr => val[2]
-              	  }
-              	| '!' command_call
-              	| arg
-
-      expr_value: expr
-
-    command_call: command
-              	| block_command
-              	| kRETURN call_args
-              	  {
-              	    result = node :return, :call_args => val[1]
-              	  }
-            	  | kBREAK call_args
-            	    {
-            	      result = node :break, :call_args => val[1]
-            	    }
-            	  | kNEXT call_args
-            	    {
-            	      result = node :next, :call_args => val[1]
-            	    }
-
-   block_command: block_call
-             	  | block_call '.' operation2 command_args
-                | block_call tCOLON2 operation2 command_args
-
- cmd_brace_block: tLBRACE_ARG opt_block_param compstmt '}'
-
-         command: operation command_args =tLOWEST
-                  {
-                    # command call - no brackets/recv
-          		      result = node :call, :recv => nil, :meth => val[0], :call_args => val[1]
-                  }
-        	      | operation command_args cmd_brace_block
-        	      | primary_value '.' operation2 command_args =tLOWEST
-        	        {
-          		      result = node :call, :recv => val[0], :meth => val[2], :call_args => val[3]
-                  }
-        	      | primary_value '.' operation2 command_args cmd_brace_block
-        	      | primary_value tCOLON2 operation2 command_args =tLOWEST
-      		      | primary_value tCOLON2 operation2 command_args cmd_brace_block
-      		      | kSUPER command_args
-      		        {
-      		          result = node :super, :call_args => val[1]
-      		        }
-        	      | kYIELD command_args
-        	        {
-        	          result = node :yield, :call_args => val[1]
-        	        }
-
-            mlhs: mlhs_basic
-  	            | tLPAREN mlhs_inner rparen
-
-      mlhs_inner: mlhs_basic
-  	            | tLPAREN mlhs_inner rparen
-
-      mlhs_basic: mlhs_head
-    		        | mlhs_head mlhs_item
-      	        | mlhs_head tSTAR mlhs_node
-      	        | mlhs_head tSTAR mlhs_node ',' mlhs_post
-      	        | mlhs_head tSTAR
-      	        | mlhs_head tSTAR ',' mlhs_post
-      	        | tSTAR mlhs_node
-      	        | tSTAR mlhs_node ',' mlhs_post
-      	        | tSTAR
-      	        | tSTAR ',' mlhs_post
-
-       mlhs_item: mlhs_node
-  	            | tLPAREN mlhs_inner rparen
-
-       mlhs_head: mlhs_item ','
-  	            | mlhs_head mlhs_item ','
-
-       mlhs_post: mlhs_item
-  	            | mlhs_post ',' mlhs_item
-
-       mlhs_node: variable
-              	| primary_value '[' opt_call_args rbracket
-              	| primary_value '.' tIDENTIFIER
-              	| primary_value tCOLON2 tIDENTIFIER
-              	| primary_value '.' tCONSTANT
-              	| primary_value tCOLON2 tCONSTANT
-              	| tCOLON3 tCONSTANT
-              	| backref
-
-             lhs: variable
-		            | primary_value '[' opt_call_args rbracket
-		              {
-		                result = node :call, :recv => val[0], :meth => '[]', :args => val[2]
-		              }
-            		| primary_value '.' tIDENTIFIER
-            		  {
-          		      result = node :call, :recv => val[0], :meth => val[2], :call_args => {}
-                  }
-            		| primary_value tCOLON2 tIDENTIFIER
-            		| primary_value '.' tCONSTANT
-            		| primary_value tCOLON2 tCONSTANT
-            		| tCOLON3 tCONSTANT
-            		  {
-            		    result = node :colon3, :name => val[1]
-            		  }
-            		| backref
-
-           cname: tIDENTIFIER
-                  {
-                    puts 'ERROR: cant use identifier for class/mod name'
-                  }
-            		| tCONSTANT
-            		  {
-            		    result = val[0]
-            		  }
-
-           cpath: tCOLON3 cname
-                  {
-                    
-                  }
-  	            | cname
-  	              {
-  	                result = node :path, :cname => val[0]
-  	              }
-              	| primary_value tCOLON2 cname
-
-           fname: tIDENTIFIER
-		            | tCONSTANT
-		            | tFID
-		            | op
-		              {
-		                self.lex_state = :EXPR_END
-		                result = val[0]
-		              }
-		            | reswords
-		              {
-		                self.lex_state = :EXPR_END
-		                result = val[0]
-		              }
-
-            fsym: fname
-              	| symbol
-
-           fitem: fsym
-  	            | dsym
-
-      undef_list: fitem
-		            | undef_list ',' fitem
-
-              op: '|'      | '^'      | '&'      | tCMP     | tEQ      | tEQQ
-                | tMATCH   | tNMATCH  | '>'      | tGEQ     | '<'      | tLEQ
-                | tNEQ     | tLSHFT   | tRSHFT   | '+'      | '-'      | '*'
-		            | tSTAR	   | '/'      | '%'      | tPOW     | '!'      | '~'
-		            | tUPLUS   | tUMINUS  | tAREF    | tASET    | '`'
-
-        reswords: k__LINE__          | k__FILE__          | k__ENCODING__
-		            | kBEGIN             | kEND               | kALIAS 
-		            | kAND               | kBEGIN             | kBREAK 
-            		| kCASE              | kCLASS             | kDEF
-            		| kDEFined           | kDO                | kELSE 
-            		| kELSIF             | kEND               | kENSURE 
-            		| kFALSE             | kFOR               | kIN 
-            		| kMODULE            | kNEXT              | kNIL 
-            		| kNOT               | kOR                | kREDO
-            		| kRESCUE            | kRETRY             | kRETURN
-            		| kSELF              | kSUPER             | kTHEN 
-            		| kTRUE    	         | kUNDEF             | kWHEN 
-            		| kYIELD 	           | kIF                | kUNLESS
-            		| kWHILE             | kUNTIL             | kBLOCK_GIVEN
-
-             arg: lhs '=' arg
-                  {
-                    result = node :assign, :lhs => val[0], :rhs => val[2]
-                  }
-            		| lhs '=' arg kRESCUE_MOD arg
-            		| var_lhs tOP_ASGN arg
-            		  {
-            		    result = node :op_asgn, :lhs => val[0], :op => val[1], :rhs => val[2]
-            		  }
-            		| var_lhs tOP_ASGN arg kRESCUE_MOD arg
-            		| primary_value '[' opt_call_args rbracket tOP_ASGN arg
-            		  {
-            		    result = node :aset_op_asgn, :recv => val[0], :call_args => val[2], :op => val[4], :arg => val[5]
-            		  }
-            		| primary_value '.' tIDENTIFIER tOP_ASGN arg
-            		  {
-            		    result = node :op_asgn, :lhs => node(:call, :recv => val[0], :meth => val[2], :call_args => {}), :op => val[3], :rhs => val[4]
-                    # result = node :dot_identifier_op_asgn, :lhs => node(:call, :recv => val[0], :meth => val[2]), :op => val[3], :rhs => val[4]
-            		  }
-            		| primary_value '.' tCONSTANT tOP_ASGN arg
-            		| primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg
-            		| primary_value tCOLON2 tCONSTANT tOP_ASGN arg
-            		| tCOLON3 tCONSTANT tOP_ASGN arg
-            		| backref tOP_ASGN arg
-            		| arg tDOT2 arg
-            		  {
-            		    result = node :dot2, :start => val[0], :ending => val[2]
-            		  }
-            		| arg tDOT3 arg
-            		  {
-            		    result = node :dot3, :start => val[0], :ending => val[2]
-            		  }
-            		| arg '+' arg
-            		  {
-            		    result = node :opt_plus, :recv => val[0], :meth => '+', :call_args => { :args => [val[2]]}
-            		  }
-            		| arg '-' arg
-            		  {
-            		    result = node :opt_minus, :recv => val[0], :meth => '-', :call_args => { :args => [val[2]]}
-            		  }
-            		| arg '*' arg
-            		  {
-            		    result = node :opt_mult, :recv => val[0], :meth => '*', :call_args => { :args => [val[2]]}
-            		  }
-            		| arg '/' arg
-            		  {
-            		    result = node :opt_div, :recv => val[0], :meth => '/', :call_args => { :args => [val[2]]}
-            		  }
-            		| arg '%' arg
-            		  {
-            		    result = node :call, :recv => val[0], :meth => '%', :call_args => { :args => [val[2]]}
-            		  }
-            		| arg tPOW arg
-            		  {
-            		    result = node :call, :recv => val[0], :meth => '**', :call_args => { :args => [val[2]]}
-            		  }
-            		| tUMINUS_NUM tINTEGER tPOW arg
-            		| tUMINUS_NUM tFLOAT tPOW arg
-            		| tUPLUS arg
-            		  {
-            		    result = node :call, :recv => val[1], :meth => '+@', :call_args => { :args => []}
-            		  }
-            		| tUMINUS arg
-            		  {
-            		    result = node :call, :recv => val[1], :meth => '-@', :call_args => { :args => []}
-            		  }
-            		| arg '|' arg
-            		  {
-            		    result = node :call, :recv => val[0], :meth => '|', :call_args => { :args => [val[2]]}
-            		  }
-            		| arg '^' arg
-            		  {
-            		    result = node :call, :recv => val[0], :meth => '^', :call_args => { :args => [val[2]]}
-            		  }
-            		| arg '&' arg
-            		  {
-            		    result = node :call, :recv => val[0], :meth => '&', :call_args => { :args => [val[2]]}
-            		  }
-            		| arg tCMP arg
-            		  {
-            		    result = node :call, :recv => val[0], :meth => '<=>', :call_args => { :args => [val[2]]}
-            		  }
-            		| arg '>' arg
-            		  {
-            		    result = node :call, :recv => val[0], :meth => '>', :call_args => { :args => [val[2]]}
-            		  }
-            		| arg tGEQ arg
-            		  {
-            		    result = node :call, :recv => val[0], :meth => '>=', :call_args => { :args => [val[2]]}
-            		  }
-            		| arg '<' arg
-            		  {
-            		    result = node :call, :recv => val[0], :meth => '<', :call_args => { :args => [val[2]]}
-            		  }
-            		| arg tLEQ arg
-            		  {
-            		    result = node :call, :recv => val[0], :meth => '<=', :call_args => { :args => [val[2]]}
-            		  }
-            		| arg tEQ arg
-            		  {
-            		    result = node :call, :recv => val[0], :meth => '==', :call_args => { :args => [val[2]]}
-            		  }
-            		| arg tEQQ arg
-            		  {
-            		    result = node :call, :recv => val[0], :meth => '===', :call_args => { :args => [val[2]]}
-            		  }
-            		| arg tNEQ arg
-            		  {
-            		    result = node :call, :recv => val[0], :meth => '!=', :call_args => { :args => [val[2]]}
-            		  }
-            		| arg tMATCH arg
-            		  {
-            		    result = node :call, :recv => val[0], :meth => '=~', :call_args => { :args => [val[2]]}
-            		  }
-            		| arg tNMATCH arg
-            		  {
-            		    result = node :call, :recv => val[0], :meth => '!~', :call_args => { :args => [val[2]]}
-            		  }
-            		| '!' arg
-              	  {
-              	    result = node :not, :expr => val[1]
-              	  }
-            		| '~' arg
-            		  {
-            		    result = node :call, :recv => val[1], :meth => '~', :call_args => { :args => []}
-            		  }
-            		| arg tLSHFT arg
-            		  {
-            		    result = node :call, :recv => val[0], :meth => '<<', :call_args => { :args => [val[2]]}
-            		  }
-            		| arg tRSHFT arg
-            		  {
-            		    result = node :call, :recv => val[0], :meth => '>>', :call_args => { :args => [val[2]]}
-            		  }
-          		  | arg tANDOP arg
-            		  {
-            		    result = node :andop, :lhs => val[0], :rhs => val[2]
-            		  }
-            		| arg tOROP arg
-            		  {
-            		    result = node :orop, :lhs => val[0], :rhs => val[2]
-            		  }
-            		| kDEFined opt_nl arg
-            		| arg '?' arg opt_nl ':' arg
-            		  {
-            		    result = node :tertiary, :expr => val[0], :true => val[2], :false => val[5]
-            		  }
-            		| primary
-
-       arg_value: arg
-
-       aref_args: none
-              	| args trailer
-            		| args ',' assocs trailer
-            		| assocs trailer
-
-      paren_args: '(' opt_call_args rparen
-                  {
-                    result = val[1]
-                  }
-
-  opt_paren_args: none
-                  {
-                    result = node :call_args, :args => nil
-                  }
-  	            | paren_args
-
-   opt_call_args: none
-                  {
-                    result = node :call_args, :args => nil
-                  }
-  	            | call_args
-
-       call_args: command
-                  {
-            		    result = node :call_args, :args => [val[0]]
-            		  }
-            		| args opt_block_arg
-            		  {
-            		    result = node :call_args, :args => val[0], :block_arg => val[1]
-            		  }
-		            | assocs opt_block_arg
-		              {
-            		    result = node :call_args, :assocs => val[0], :block_arg => val[1]
-            		  }
-		            | args ',' assocs opt_block_arg
-		              {
-            		    result = node :call_args, :args => val[0], :assocs => val[2], :block_arg => val[3]
-            		  }
-		            | block_arg
-		              {
-            		    result = node :call_args, :block_arg => val[0]
-            		  }
-
-    command_args: call_args
-
-       block_arg: tAMPER arg_value
-                  {
-                    # puts "here for #{val[1]}"
-                    # puts val[1]
-                    result = self.node :block_arg, :arg => val[1]
-                  }
-                | '&' arg_value
-                  {
-                    # puts val[1]
-                    result = self.node :block_arg, :arg => val[1]
-                  }
-
-   opt_block_arg: ',' block_arg
-                  {
-                    result = val[1]
-                  }
-		            | ','
-		            | none
-
-            args: arg_value
-                  {
-                    result = [val[0]]
-                  }
-		            | tSTAR arg_value
-		              {
-		                result = [node(:splat, :val => val[1])]
-		              }
-		            | args ',' arg_value
-		              {
-		                result = val[0] + [val[2]]
-		              }
-		            | args ',' tSTAR arg_value
-		              {
-		                result = val[0] + [node(:splat, :val => val[3])]
-		              }
-
-            mrhs: args ',' arg_value
-		            | args ',' tSTAR arg_value
-		            | tSTAR arg_value
-
-         primary: literal
-  	            | strings
-  	            | xstring
-  	            | regexp
-  	            | words
-  	            | qwords
-                | tIDENTIFIER do_block
-                  {
-                    # if val[0].node == :self
-                      # result = val[0]
-                    # else
-                      # HACK: this rule shouldnt even exist. But for now it must for "identifier do .. end"
-                      result = node :call, :recv => nil, :meth => val[0], :brace_block => val[1]
-                    # end
-                  }
-  	            | var_ref
-  	            | backref
-  	            | tFID
-              	| k_begin bodystmt k_end
-              	  {
-              	    result = node :begin, :stmt => val[1]
-              	  }
-            		| tLPAREN_ARG expr rparen
-            		| tLPAREN compstmt ')'
-            		  {
-            		    result = node :lparen, :stmt => val[1]
-            		  }
-            		| primary_value tCOLON2 tCONSTANT
-            		  {
-            		    result = node :colon2, :lhs => val[0], :rhs => val[2]
-            		  }
-            		| tCOLON3 tCONSTANT
-            		  {
-            		    result = node :colon3, :name => val[1]
-            		  }
-            		| tLBRACK aref_args ']'
-            		  {
-            		    result = node :array, :args => val[1]
-            		  }
-            		| tLBRACE assoc_list '}'
-            		  {
-            		    result = node :assoc_list, :list => val[1]
-            		  }
-            		| kRETURN
-            		  {
-            		    result = node :return
-            		  }
-            		| kYIELD '(' call_args rparen
-            		  {
-        	          result = node :yield, :call_args => val[2]
-        	        }
-            		| kYIELD '(' rparen
-            		  {
-        	          result = node :yield
-        	        }
-            		| kYIELD
-            		  {
-        	          result = node :yield
-        	        }
-            		| kDEFined opt_nl '(' expr rparen
-            		| kNOT '(' expr rparen
-            		| kNOT '(' rparen
-            		| operation brace_block
-            		  {
-            		    result = node :call, :recv => nil, :meth => val[0], :brace_block => val[1]
-            		  }
-            		| method_call
-            		  {
-            		    # puts 2
-            		  }
-            		| method_call brace_block
-            		  {
-            		    val[0][:brace_block] = val[1]
-            		    result = val[0]
-            		  }
-            		| tLAMBDA lambda
-            		  {
-            		    result = node :lambda, :args => val[1][:args], :body => val[1][:body]
-            		  }
-            		| k_if expr_value then compstmt if_tail k_end
-            		  {
-            		    result = self.node :if, :expr => val[1], :stmt => val[3], :tail => val[4]
-            		  }
-            		| k_unless expr_value then compstmt opt_else k_end
-            		  {
-            		    result = self.node :unless, :expr => val[1], :stmt => val[3], :tail => val[4]
-            		  }
-            		| k_while expr_value do compstmt k_end
-            		  {
-                    # puts "in node while"
-            		    result = node :while, :expr => val[1], :stmt => val[3]
-            		  }
-            		| k_until expr_value do compstmt k_end
-            		  {
-            		    result = node :until, :expr => val[1], :stmt => val[3]
-            		  }
-            		| k_case expr_value opt_terms case_body k_end
-            		  {
-            		    result = node :case, :expr => val[1], :body => val[3]
-            		  }
-            		| k_case opt_terms case_body k_end
-            		  {
-            		    result = node :case, :expr => nil, :body => val[2]
-            		  }
-            		| k_for for_var kIN expr_value do compstmt k_end
-            		| k_class cpath superclass bodystmt k_end
-            		  {
-            		    result = self.node_class(:cpath => val[1], :superclass => val[2], :bodystmt => val[3])
-            		  }
-            		| k_class tLSHFT expr term bodystmt k_end
-            		  {
-            		    result = node :class_shift, :expr => val[2], :bodystmt => val[4]
-            		  }
-            		| k_module cpath bodystmt k_end
-            		  {
-            		    result = self.node_module(:cpath => val[1], :body => val[2])
-            		  }
-            		| k_def fname f_arglist bodystmt k_end
-            		  {
-            		    result = self.node :def, :fname => val[1], :arglist => val[2], :bodystmt => val[3], :line_number => @current_def_linenumber
-            		  }
-            		| k_def singleton dot_or_colon fname f_arglist bodystmt k_end
-            		  {
-            		    result = self.node :def, :singleton => val[1], :fname => val[3], :arglist => val[4], :bodystmt => val[5], :line_number => @current_def_linenumber
-            		  }
-            		| kBREAK
-            		  {
-            		    result = node :break, :call_args => nil
-            		  }
-            		| kNEXT
-            		  {
-            		    result = node :next, :call_args => nil
-            		  }
-            		| kREDO
-            		  {
-            		    result = node :redo
-            		  }
-            		| kRETRY
-
-   primary_value: primary
-
-         k_begin: kBEGIN
-
-            k_if: kIF
-
-        k_unless: kUNLESS
-
-         k_while: kWHILE
-    
-         k_until: kUNTIL
-    
-          k_case: kCASE
-  
-           k_for: kFOR
-    
-         k_class: kCLASS
-    
-        k_module: kMODULE
-  
-           k_def: kDEF
-  
-           k_end: kEND
-  
-            then: term
-		            | kTHEN
-		            | term kTHEN
-
-              do: term
-		            | kDO_COND
-		            | kDO
-
-         if_tail: opt_else
-                  {
-                    result = val[0]
-                  }
-              	| kELSIF expr_value then compstmt if_tail
-              	  {
-              	    result = [self.node(:elsif, :expr => val[1], :stmt => val[3])] + val[4]
-              	  }
-
-        opt_else: none
-                  {
-                    result = []
-                  }
-              	| kELSE compstmt
-              	  {
-              	    result = [self.node(:else, :stmt => val[1])]
-              	  }
-
-         for_var: lhs
-              	| mlhs
-
-          f_marg: f_norm_arg
-              	| tLPAREN f_margs rparen
-
-     f_marg_list: f_marg
-  	            | f_marg_list ',' f_marg
-
-         f_margs: f_marg_list
-            		| f_marg_list ',' tSTAR f_norm_arg
-            		| f_marg_list ',' tSTAR f_norm_arg ',' f_marg_list
-            		| f_marg_list ',' tSTAR
-            		| f_marg_list ',' tSTAR ',' f_marg_list
-            		| tSTAR f_norm_arg
-            		| tSTAR f_norm_arg ',' f_marg_list
-            		| tSTAR
-            		| tSTAR ',' f_marg_list
-
-     block_param: f_arg ',' f_block_optarg ',' f_rest_arg opt_f_block_arg
-  	            | f_arg ',' f_block_optarg ',' f_rest_arg ',' f_arg opt_f_block_arg
-              	| f_arg ',' f_block_optarg opt_f_block_arg
-              	| f_arg ',' f_block_optarg ',' f_arg opt_f_block_arg
-              	| f_arg ',' f_rest_arg opt_f_block_arg
-              	| f_arg ','
-            		| f_arg ',' f_rest_arg ',' f_arg opt_f_block_arg
-            		| f_arg opt_f_block_arg
-            		| f_block_optarg ',' f_rest_arg opt_f_block_arg
-            		| f_block_optarg ',' f_rest_arg ',' f_arg opt_f_block_arg
-            		| f_block_optarg opt_f_block_arg
-            		| f_block_optarg ',' f_arg opt_f_block_arg
-            		| f_rest_arg opt_f_block_arg
-            		| f_rest_arg ',' f_arg opt_f_block_arg
-            		| f_block_arg
-
- opt_block_param: none
-                  {
-                    result = nil
-                  }
-              	| block_param_def
-
- block_param_def: '|' opt_bv_decl '|'
-            		| tOROP
-            		| '|' block_param opt_bv_decl '|'
-            		  {
-            		    result = val[1]
-            		  }
-
-     opt_bv_decl: none
-              	| ';' bv_decls
-
-        bv_decls: bvar
-                | bv_decls ',' bvar
-
-            bvar: tIDENTIFIER
-            		| f_bad_arg
-
-          lambda: f_larglist lambda_body
-                  {
-                    result = {:args => val[0], :body => val[1]}
-                  }
-
-      f_larglist: '(' f_args opt_bv_decl rparen
-		            | f_args
-
-     lambda_body: tLBRACE compstmt '}'
-                  {
-                    result = val[1]
-                  }
-            		| kDO_LAMBDA compstmt kEND
-            		  {
-            		    result = val[1]
-            		  }
-
-        do_block: kDO_BLOCK opt_block_param compstmt kEND
-                | kDO opt_block_param compstmt kEND
-                  {
-                    result = node :brace_block, :params => val[1], :stmt => val[2]
-                  }
-
-      block_call: command do_block
-                  {
-                    val[0][:brace_block] = val[1]
-                    result = val[0]
-                  }
-            		| block_call '.' operation2 opt_paren_args
-            		| block_call tCOLON2 operation2 opt_paren_args
-
-     method_call: operation paren_args
-                  {
-                    result = node :call, :recv => nil, :meth => val[0], :call_args => val[1]
-                  }
-              	| primary_value '.' operation2 opt_paren_args
-              	  {
-                    result = node :call, :recv => val[0], :meth => val[2], :call_args => val[3]
-                  }
-              	| primary_value tCOLON2 operation2 paren_args
-              	  {
-              	    result = node :tCOLON2call, :recv => val[0], :meth => val[2], :args => val[3]
-              	    puts "tCOLON2call"
-              	  }
-            		| primary_value tCOLON2 operation3
-            		  {
-              	    result = node :tCOLON2call, :recv => val[0], :meth => val[2]
-              	    puts "tCOLON2call.noargs."
-              	  }
-            		| primary_value '.' paren_args
-            		| primary_value tCOLON2 paren_args
-            		| kSUPER paren_args
-            		  {
-            		    result = node :super, :call_args => val[1], :paren => true
-            		  }
-            		| kSUPER
-            		  {
-            		    result = node :super, :call_args => nil, :inherit => true
-            		  }
-            		| primary_value '[' opt_call_args rbracket
-            		  {
-                    result = node :call, :recv => val[0], :meth => '[]', :call_args => val[2]
-                  }
-
-
-     brace_block: '{' opt_block_param compstmt '}'
-                  {
-            		    result = node :brace_block, :params => val[1], :stmt => val[2]
-            		  }
-            		| kDO opt_block_param compstmt kEND
-            		  {
-            		    result = node :brace_block, :params => val[1], :stmt => val[2]
-            		  }
-
-       case_body: kWHEN args then compstmt cases
-                  {
-                    result = [node(:when, :args => val[1], :stmt => val[3])] + val[4]
-                  }
-
-           cases: opt_else
-                  {
-                    result = val[0]
-                  }
-              	| case_body
-
-      opt_rescue: kRESCUE exc_list exc_var then compstmt opt_rescue
-                  {
-                    result = node :rescue, :list => val[1], :var => val[2], :stmt => val[4], :opt_rescue => val[5]
-                    # puts result
-                  }
-            		| none
-            		  {
-            		    result = nil
-            		  }
-
-        exc_list: arg_value
-                  {
-                    result = val[0]
-                  }
-            		| mrhs
-            		  {
-            		    result = val[0]
-            		  }
-            		| none
-            		  {
-            		    result = nil
-            		  }
-
-         exc_var: tASSOC lhs
-                  {
-                    result = val[1]
-                  }
-            		| none
-            		  {
-            		    result = nil
-            		  }
-
-      opt_ensure: kENSURE compstmt
-                  {
-                    result = val[1]
-                  }
-            		| none
-            		  {
-            		    result = nil
-            		  }
-
-         literal: numeric
-              	| symbol
-            		| dsym
-
-         strings: string
-
-          string: tCHAR
-  	            | string1
-              	| string string1
-
-         string1: tSTRING_BEG string_contents tSTRING_END
-                  {
-                    result = node :string, :value => val[1], :beg => val[0]
-                  }  
-
-         xstring: tXSTRING_BEG xstring_contents tXSTRING_END
-                  {
-                    result = node :xstring, :value => val[1]
-                  }
-
-          regexp: tREGEXP_BEG xstring_contents tREGEXP_END
-                  {
-                    result = node :regexp, :value => val[1]
-                  }
-
-           words: tWORDS_BEG ' ' tSTRING_END
-            		| tWORDS_BEG word_list tSTRING_END
-            		  {
-            		    result = node :words, :list => val[1]
-            		  }
-
-       word_list: /* none */
-                  {
-                    result = []
-                  }
-            		| word_list word
-            		  {
-            		    result = val[0] + [val[1]]
-            		  }
-
-            word: string_content
-                  {
-                    result = [val[0]]
-                  }
-            		| word string_content
-                  {
-                    result = val[0] + [val[1]]
-                  }
-                  
-          qwords: tQWORDS_BEG ' ' tSTRING_END
-            		| tQWORDS_BEG qword_list tSTRING_END
-
-      qword_list:
-                  {
-                    # none..
-                    result = []
-                  }
-              	| qword_list tSTRING_CONTENT ' '
-
- string_contents: 
-                  {
-                    # none..
-                    result = []
-                  }
-            		| string_contents string_content
-            		  {
-            		    result = val[0] + [val[1]]
-            		  }
-
-xstring_contents: 
-                  {
-                    # none..
-                    result = []
-                  }
-              	| xstring_contents string_content
-              	  {
-            		    result = val[0] + [val[1]]
-            		  }
-
-  string_content: tSTRING_CONTENT
-                  {
-                    result = node :string_content, :value => val[0]
-                  }
-              	| tSTRING_DVAR string_dvar
-              	  {
-                    result = node :string_dvar, :value => val[1]
-                  }
-              	| tSTRING_DBEG compstmt '}'
-              	  {
-                    result = node :string_dbeg, :value => val[1]
-                  }
-
-     string_dvar: tGVAR
-            		| tIVAR
-            		| tCVAR
-            		| backref
-
-          symbol: tSYMBEG sym
-                  {
-                    result = node :symbol, :name => val[1]
-                  }
-
-             sym: fname
-              	| tIVAR
-              	| tGVAR
-              	| tCVAR
-
-            dsym: tSYMBEG xstring_contents tSTRING_END
-                  {
-                    result = node :dsym, :contents => val[1]
-                  }
-
-         numeric: tINTEGER
-                  {
-                    result = node :numeric, :value => val[0], :float => false
-                  }
-              	| tFLOAT
-              	  {
-                    result = node :numeric, :value => val[0], :float => true
-                  }
-              	| tUMINUS_NUM tINTEGER
-            		| tUMINUS_NUM tFLOAT
-
-        variable: tIDENTIFIER
-                  {
-                    
-                    result = node :identifier, :name => val[0]
-                  }
-            		| tIVAR
-            		  {
-                    result = node :ivar, :name => val[0]
-                  }
-            		| tGVAR
-            		  {
-                    result = node :gvar, :name => val[0]
-                  }
-            		| tCONSTANT
-            		  {
-                    result = node :constant, :name => val[0]
-                  }
-            		| tCVAR
-            		  {
-                    result = node :cvar, :name => val[0]
-                  }
-            		| kNIL
-            		  {
-                    result = node :nil, :name => val[0]
-                  }
-            		| kSELF
-            		  {
-                    result = node :self, :name => val[0]
-                  }
-            		| kTRUE
-            		  {
-                    result = node :true, :name => val[0]
-                  }
-            		| kFALSE
-            		  {
-                    result = node :false, :name => val[0]
-                  }
-            		| k__FILE__
-            		  {
-                    result = node :__FILE__, :name => val[0]
-                  }
-            		| k__LINE__
-            		  {
-                    result = node :__LINE__, :name => val[0]
-                  }
-            		| k__ENCODING__
-            		  {
-                    result = node :__ENCODING__, :name => val[0]
-                  }
-                | kBLOCK_GIVEN
-                  {
-                    # added for block_given? support.. :D
-                    result = node :block_given, :name => val[0]
-                  }
-
-         var_ref: variable
-
-         var_lhs: variable
-
-         backref: tNTH_REF
-  	            | tBACK_REF
-
-      superclass: term
-                  {
-                    result = nil
-                  }
-            		| '<' expr_value term
-            		  {
-            		    result = node :superclass, :expr => val[1]
-            		  }
-            		| error term { puts 'OMFG' }
-
-       f_arglist: '(' f_args rparen
-                  {
-                    result = val[1]
-                    self.lex_state = :EXPR_BEG
-                  }
-              	| f_args term
-              	  {
-                    result = val[0]
-                    self.lex_state = :EXPR_BEG
-                  }
-
-          f_args: f_arg ',' f_optarg ',' f_rest_arg opt_f_block_arg
-                  {
-                    result = node_args(val[0], val[2], val[4], nil, val[5])
-             		  }
-              	| f_arg ',' f_optarg ',' f_rest_arg ',' f_arg opt_f_block_arg
-              	  {
-             		    result = node_args(val[0], val[2], val[4], val[6], val[7])
-             		  }
-              	| f_arg ',' f_optarg opt_f_block_arg
-              	  {
-              	    result = node_args(val[0], val[2], nil, nil, val[3])
-              	  }
-            		| f_arg ',' f_optarg ',' f_arg opt_f_block_arg
-            		  {
-            		    result = node_args(val[0], val[2], nil, val[4], val[5])
-              	  }
-            		| f_arg ',' f_rest_arg opt_f_block_arg
-            		  {
-            		    result = node_args(val[0], nil, val[2], nil, val[3])
-            		  }
-             		| f_arg ',' f_rest_arg ',' f_arg opt_f_block_arg
-             		  {
-            		    result = node_args(val[0], nil, val[2], val[4], val[5])
-            		  }
-             		| f_arg opt_f_block_arg
-             		  {
-             		    result = node_args(val[0], nil, nil, nil, val[1])
-             		  }
-            		| f_optarg ',' f_rest_arg opt_f_block_arg
-            		  {
-            		    result = node_args(nil, val[0], val[2], nil, val[3])
-            		  }
-            		| f_optarg ',' f_rest_arg ',' f_arg opt_f_block_arg
-            		  {
-            		    result = node_args(nil, val[0], val[2], val[4], val[5])
-            		  }
-             		| f_optarg opt_f_block_arg
-             		  {
-             		    result = node_args(nil, val[0], nil, nil, val[1])
-             		  }
-            		| f_optarg ',' f_arg opt_f_block_arg
-            		  {
-             		    result = node_args(nil, val[0], nil, val[2], val[3])
-             		  }
-              	| f_rest_arg opt_f_block_arg
-            	    {
-             		    result = node_args(nil, nil, val[0], nil, val[1])
-             		  }
-            		| f_rest_arg ',' f_arg opt_f_block_arg
-            		  {
-             		    result = node_args(nil, nil, val[0], val[2], val[3])
-             		  }
-            		| f_block_arg
-            		  {
-             		    result = node_args(nil, nil, nil, nil, val[0])
-             		  }
-              	| # none ..
-              	  {
-              	    result = node_args(nil, nil, nil, nil, nil)
-              	  }
-
-       f_bad_arg: tCONSTANT
-              	| tIVAR
-              	| tGVAR
-              	| tCVAR
-
-      f_norm_arg: f_bad_arg
-              	| tIDENTIFIER
-              	  {
-                    # result = val[0]
-              	    result = node :norm_arg, :value => val[0]
-              	  }
-              	| tIDENTIFIER tASSOC tIDENTIFIER
-                  {
-                  
-                  }
-                | tLABEL tIDENTIFIER
-                  {
-                    result = node :label_arg, :name => val[0], :value => val[1]
-                  }
-
-      f_arg_item: f_norm_arg
-                  {
-                    result = val[0]
-                  }
-            		| tLPAREN f_margs rparen
-
-           f_arg: f_arg_item
-                  {
-                    result = [val[0]]
-                  }
-            		| f_arg ',' f_arg_item
-            		  {
-                    # val[0] + val[2]
-                    result = val[0] + [val[2]]
-            		  }
-
-           f_opt: tIDENTIFIER '=' arg_value
-                  {
-                    result = [val[0], val[2]]
-                  }
-
-     f_block_opt: tIDENTIFIER '=' primary_value
-
-  f_block_optarg: f_block_opt
-            		| f_block_optarg ',' f_block_opt
-
-        f_optarg: f_opt
-                  {
-                    result = [val[0]]
-                  }
-            		| f_optarg ',' f_opt
-            		  {
-            		    result = val[0] + [val[2]]
-            		  }
-
-    restarg_mark: '*'
-  	            | tSTAR
-
-      f_rest_arg: restarg_mark tIDENTIFIER
-                  {
-                    result = val[1]
-                  }
-              	| restarg_mark
-
-     blkarg_mark: '&'
-              	| tAMPER
-
-     f_block_arg: blkarg_mark tIDENTIFIER
-                  {
-                    result = val[1]
-                  }
-                | tLABEL blkarg_mark tIDENTIFIER
-                  {
-                    result = node :label_arg, :name => val[0], :value => val[1]
-                  }
-
- opt_f_block_arg: ',' f_block_arg
-                  {
-                    result = val[1]
-                  }
-            		| none
-
-       singleton: var_ref
-            		| '(' expr rparen
-
-      assoc_list: none
-                  {
-                    result = []
-                  }
-              	| assocs trailer
-              	  {
-              	    result = val[0]
-              	  }
-
-          assocs: assoc
-                  {
-                    result = [val[0]]
-                  }
-            		| assocs ',' assoc
-            		  {
-            		    result = val[0] + [val[2]]
-            		  }
-
-           assoc: arg_value tASSOC arg_value
-                  {
-                    result = node :assoc, :key => val[0], :value => val[2]
-                  }
-                | tLABEL arg_value
-                  {
-                    result = node :label_assoc, :key => val[0], :value => val[1]
-                  }
-
-       operation: tIDENTIFIER
-              	| tCONSTANT
-              	| tFID
-
-      operation2: tIDENTIFIER
-                  {
-                    
-                  }
-              	| tCONSTANT
-              	| tFID
-              	| op
-
-      operation3: tIDENTIFIER
-                  {
-                    puts 4
-                  }
-              	| tFID
-              	| op
-
-    dot_or_colon: '.'
-            		| tCOLON2
-
-       opt_terms: 
-              	| terms
-
-          opt_nl: /* none */
-              	| '\n'
-
-          rparen: opt_nl ')'
-
-        rbracket: opt_nl ']'
-
-         trailer: /* none */
-              	| '\n'
-              	| ','
-
-            term: ';'
-              	| '\n'
-
-           terms: term
-              	| terms ';'
-
-            none:
-            
-end
-
----- header ----
-
-# require 'ctokenizer'
-require 'strscan'
-
----- inner ----
-
-
----- footer ----