redparse 0.8.0

data/lib/redparse/node.rb

@@ -0,0 +1,3808 @@
+=begin           
+    redparse - a ruby parser written in ruby
+    Copyright (C) 2008  Caleb Clausen
+
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+=end
+
+require 'rubygems'
+require 'tempfile'
+require 'pp'
+require "rubylexer"
+require "reg"
+
+
+
+
+
+class RedParse
+#  module Nodes
+    #import token classes from rubylexer
+    RubyLexer::constants.each{|k| 
+      t=RubyLexer::const_get(k)
+      self::const_set k,t if Module===t and RubyLexer::Token>=t
+    }
+
+    module SimpleToLisp
+      def to_lisp; to_s end
+    end
+
+    [NumberToken, SymbolToken, VarNameToken, MethNameToken].each{|tokclass|
+      tokclass.send :include, SimpleToLisp
+    }
+
+    module FlattenedIvars
+      def flattened_ivars
+        result=[]
+        instance_variables.sort.each{|iv| 
+          break if iv=="@data"
+          result.push iv, instance_variable_get(iv)
+        }
+        return result
+      end
+
+      def flattened_ivars_equal?(other)
+        self.class == other.class and
+          flattened_ivars == other.flattened_ivars
+      end
+    end
+
+    class Token
+      def image; "#{inspect}" end
+ 
+      def to_parsetree(*options)
+        options.include? :newlines and Thread.current[:$RedParse_parsetree_newlines]=true
+        options.include? :quirks and Thread.current[:$RedParse_parsetree_quirks]=true        
+
+        result=[parsetree] 
+
+        Thread.current[:$RedParse_parsetree_newlines]=false
+        Thread.current[:$RedParse_parsetree_quirks]=false
+
+        result=[] if result==[[]]
+
+        return result
+      end
+      def lvalue?; nil end
+      def data; [self] end
+      def unary; false end
+      def rescue_parsetree; parsetree end
+      def begin_parsetree; parsetree end
+
+    end
+
+    class KeywordToken
+      def not_real!
+        @not_real=true
+      end
+ 
+      def not_real?
+        @not_real if defined? @not_real
+      end
+
+      alias image ident
+    end
+
+    class VarNameToken
+      include FlattenedIvars
+      alias image ident
+
+      alias == flattened_ivars_equal?
+
+      def parsetree 
+        type=case ident[0]
+         when ?$: 
+           case ident[1]
+           when ?1..?9: return [:nth_ref,ident[1..-1].to_i]
+           when ?&,?+,?`,?': return [:back_ref,ident[1].chr.to_sym] #`
+           else :gvar
+           end
+         when ?@: 
+           if ident[1]==?@
+             :cvar
+           else
+             :ivar
+           end
+         when ?A..?Z: :const
+         else 
+           case lvar_type
+           when :local; :lvar
+           when :block; :dvar
+           when :current; :dvar#_curr
+           else fail
+           end
+         end
+         return [type,ident.to_sym]
+      end
+
+      def varname2assigntype
+          case ident[0]
+            when ?$: :gasgn
+            when ?@: 
+              if ident[1]!=?@:  :iasgn
+              elsif in_def:     :cvasgn
+              else              :cvdecl
+              end
+            when ?A..?Z: :cdecl
+            else :lasgn
+              case lvar_type
+              when :local; :lasgn
+              when :block; :dasgn
+              when :current; :dasgn_curr
+              else fail
+              end
+          end
+      end
+
+      def lvalue_parsetree
+        [varname2assigntype, ident.to_sym]
+      end
+
+      def lvalue?
+        return @lvalue if defined? @lvalue
+        @lvalue=true
+      end
+
+      def all_current_lvars
+        lvar_type==:current ? [ident] : []
+      end
+
+      attr_accessor :line,:lvalue
+
+      def dup
+        result=super
+        result.ident=@ident.dup
+        return result
+      end
+
+      public :remove_instance_variable
+
+      def unparse o; ident end
+      alias lhs_unparse unparse
+
+      def delete_extraneous_ivars!
+        huh
+      end
+
+      def walk
+         yield nil,nil,nil,self
+      end
+    end   
+
+    class StringToken
+      attr :char
+    end
+  
+    class HerePlaceholderToken
+      attr_accessor :node
+      attr :string
+    end
+
+    class Node<Array
+      include FlattenedIvars
+      def initialize(*data)
+        replace data
+      end
+
+      def flattened_ivars
+        result=super
+        result.each_with_index{|x,i|
+          if i&1==0 and x!="@data"
+            result[i,2]=[]
+          end
+        }
+        result
+      end
+
+
+      def ==(other)
+        super and flattened_ivars_equal?(other)
+      end
+
+      def image; "(#{inspect})" end
+
+      @@data_warned=nil
+      def data
+        unless @@data_warned
+          warn "using obsolete Node#data from #{caller.first}"
+          @@data_warned=true
+        end
+        Array.new(self)
+      end
+      alias unwrap data
+
+      attr_accessor :line
+      attr_accessor :errors
+
+      def self.[](*data)
+        options=data.pop if Hash===data.last
+        result=allocate
+        result.instance_eval{
+          replace data
+          options.each_pair{|name,val|
+            instance_variable_set name,val
+          } if options
+        }
+        return result
+      end
+
+      def inspect
+        ivarnames=instance_variables-["@data"]
+        ivars=ivarnames.map{|ivarname| 
+          ":"+ivarname+"=>"+instance_variable_get(ivarname).inspect 
+        }.join(', ')
+        bare=super
+        bare.gsub!(/\]\Z/, ", {"+ivars+"}]") unless ivarnames.empty?
+        return self.class.name+bare
+      end
+ 
+      def pretty_print(q)
+        ivarnames=instance_variables-["@data"]
+        ivars={}
+        ivarnames.each{|ivarname| 
+          ivars[ivarname.to_sym]=instance_variable_get(ivarname)
+        }
+        q.group(1, self.class.name+'[', ']') {
+          displaylist= ivars.empty? ? self : self+[ivars]
+          q.seplist(displaylist) {|v|
+            q.pp v
+          }
+#          q.text ', '
+#          q.pp_hash ivars          
+        }
+      end
+
+      def self.param_names(*names)
+        accessors=[]
+        namelist=[]
+        namelist2=[]
+        names.each{|name| 
+          name=name.to_s
+          last=name[-1]
+          name.chomp! '!' and name << ?_
+          namelist2 << name
+          unless last==?_
+            accessors << "def #{name.chomp('_')}; self[#{namelist.size}] end\n"
+            accessors << "def #{name.chomp('_')}=(newval); self[#{namelist.size}]=newval end\n"
+            namelist << name
+          end
+        }
+        init="
+          def initialize(#{namelist2.join(', ')})
+            replace [#{namelist.size==1 ? 
+                      namelist.first : 
+                      namelist.join(', ')
+                  }]
+          end
+          alias init_data initialize
+             "
+
+        code= "class ::#{self}\n"+init+accessors.to_s+"\nend\n"
+        if defined? DEBUGGER__ or defined? Debugger
+          Tempfile.open("param_name_defs"){|f|
+            f.write code
+            f.flush
+            load f.path
+          }
+        else
+          eval code
+        end
+      end
+
+      def lhs_unparse o; unparse(o) end
+
+      def to_parsetree(*options)
+        options.include? :newlines and Thread.current[:$RedParse_parsetree_newlines]=true
+        options.include? :quirks and Thread.current[:$RedParse_parsetree_quirks]=true        
+
+        result=[parsetree] 
+
+        Thread.current[:$RedParse_parsetree_newlines]=false
+        Thread.current[:$RedParse_parsetree_quirks]=false
+
+        result=[] if result==[[]]
+
+        return result
+      end
+      def parsetree
+        "wrong(#{inspect})"
+      end
+
+      def rescue_parsetree; parsetree end
+      def begin_parsetree; parsetree end
+
+      def parsetrees list
+        !list.empty? and list.map{|node| node.parsetree}
+      end
+
+      def negate(condition,offset=nil)
+          if UnOpNode===condition and condition.op.ident[/^(!|not)$/]
+            condition.val
+          else
+            UnOpNode.new(KeywordToken.new("not",offset),condition)
+          end
+      end
+
+      #callback takes four parameters:
+      #parent of node currently being walked, index and subindex within 
+      #that parent, and finally the actual node being walked.
+      def walk(parent=nil,index=nil,subindex=nil,&callback)
+        callback[ parent,index,subindex,self ] and
+        each_with_index{|datum,i|
+          case datum
+          when Node: datum.walk(self,i,&callback)
+          when Array:
+            datum.each_with_index{|x,j| 
+              Node===x ? x.walk(self,i,j,&callback) : callback[self,i,j,x]
+            }
+          else callback[self,i,nil,datum]
+          end
+        }
+      end
+
+      def linerange
+        min=9999999999999999999999999999999999999999999999999999
+        max=0
+        walk{|parent,i,subi,node|
+          if node.respond_to? :line and line=node.line
+            min=[min,line].min
+            max=[max,line].max
+          end
+        }
+        return min..max
+      end
+
+      def fixup_multiple_assignments!
+       result=self
+       walk{|parent,i,subi,node|
+        if CommaOpNode===node
+          #there should be an assignnode within this node... find it
+          j=nil
+          list=Array.new(node)
+          assignnode=nil
+          list.each_with_index{|assignnode,jj|
+            AssignNode===assignnode and break(j=jj)
+          }
+          fail "CommaOpNode without any assignment in final parse tree" unless j
+
+          #re-hang the current node with = at the top
+          lhs=list[0...j]<<list[j].left
+          rhs=list[j+1..-1].unshift list[j].right
+          if lhs.size==1 and MultiAssign===lhs.first
+            lhs=lhs.first
+          else
+            lhs=MultiAssign.new(lhs)
+          end
+          node=AssignNode.new(lhs, assignnode.op, rhs)
+
+          #graft the new node back onto the old tree
+          if parent
+            if subi
+              parent[i][subi]=node
+            else
+              parent[i]=node
+            end
+          else #replacement at top level
+            result=node
+          end
+
+          #re-scan newly made node, since we tell caller not to scan our children
+          node.fixup_multiple_assignments!
+
+          false #skip (your old view of) my children, please
+        else
+          true
+        end
+       }
+ 
+       return result
+
+      end
+
+      def prohibit_fixup x
+        case x
+        when UnaryStarNode: true
+#        when ParenedNode: x.size>1
+        when CallSiteNode: x.params and !x.real_parens
+        else false
+        end
+      end
+
+      def fixup_rescue_assignments!
+        result=self
+        walk{|parent,i,subi,node|
+          #if a rescue op with a single assignment on the lhs
+          if ParenedNode===node and node.op? and assign=node.first and #ick
+               AssignNode===assign and assign.op.ident=="=" and 
+               !(assign.multi? or 
+                 prohibit_fixup assign.right)
+
+
+            #re-hang the node with = at the top instead of rescue
+            node=AssignNode.new(assign.left, assign.op,
+              ParenedNode.new(assign.right,nil,node[1][0].action)
+            )
+            
+            #graft the new node back onto the old tree
+            if parent
+              if subi
+                parent[i][subi]=node
+              else
+                parent[i]=node
+              end
+            else #replacement at top level
+              result=node
+            end
+
+            #re-scan newly made node, since we tell caller not to scan our children
+            node.fixup_rescue_assignments!
+
+            false #skip (your old view of) my children, please
+          else
+            true
+          end
+        }
+        return result
+      end
+ 
+      def lvars_defined_in
+        result=[]
+        walk {|parent,i,subi,node|
+          case node
+          when MethodNode,ClassNode,ModuleNode,MetaClassNode: false
+          when CallSiteNode
+            Node===node.receiver and
+              result.concat node.receiver.lvars_defined_in 
+            node.args.each{|arg| 
+              result.concat arg.lvars_defined_in if Node===arg
+            } if node.args
+            false
+          when AssignNode
+            lvalue=node.left
+            lvalue.respond_to? :all_current_lvars and
+              result.concat lvalue.all_current_lvars 
+            true
+          when ForNode: 
+            lvalue=node.for
+            lvalue.respond_to? :all_current_lvars and
+              result.concat lvalue.all_current_lvars 
+            true
+          when ParenedNode: 
+            if node.size>1
+              rescues=node[1]
+              rescues.each{|resc|
+                name=resc.varname
+                name and result.push name.ident
+              }
+            end
+            true
+          else true
+          end
+        }
+
+        result.uniq!
+        return result
+      end
+
+      def unary; false end
+      def lvalue?; false end
+
+      def deep_copy transform={},&override
+        handler=proc{|child|
+          if transform.has_key? child.__id__ 
+            transform[child.__id__]
+          else
+            case child
+            when Node: 
+                override&&override[child] or 
+                  child.deep_copy(transform,&override)
+            when Array: 
+                child.map(&handler)
+            when Integer,Symbol,Float,nil,false,true,Module:
+                child
+            else 
+                child.dup
+            end
+          end
+        }
+
+        newdata=map(&handler)
+
+        h={}
+        result_module=nil
+        instance_variables.each{|iv| 
+          unless iv=="@data"
+            val=instance_variable_get(iv)
+            h[iv]=handler[val]
+            result_module=val if iv=="@module" #hacky
+          end
+        }
+        result= self.class[*newdata << h]
+        result.extend result_module if result_module
+        return result
+      end
+
+      def delete_extraneous_ivars!
+        walk{|parent,i,subi,node|
+          case node
+          when Node,VarNameToken
+            node.remove_instance_variable :@offset rescue nil
+            node.remove_instance_variable :@loopword_offset rescue nil
+            node.remove_instance_variable :@line rescue nil
+            if node.respond_to? :lvalue 
+              node.lvalue or
+                node.remove_instance_variable :@lvalue rescue nil 
+            end
+          when Token
+            print "#{node.inspect} in "; pp parent
+            fail "no tokens should be present in final parse tree (maybe except VarNameToken, ick)"
+          end
+          true
+        }
+        return self
+      end
+
+      public :remove_instance_variable
+
+      #convert to a Reg::Array expression. subnodes are also converted.
+      #if any matchers are present in the tree, they will be included
+      #directly into the enclosing Node's matcher.
+      #this can be a nice way to turn a (possibly deeply nested) node
+      #tree into a matcher.
+      #note: anything stored in instance variables is ignored in the 
+      #matcher.
+      def +@
+        node2matcher=proc{|n|
+          case n
+          when Node: +n
+          when Array: +[*n.map(&node2matcher)]
+          else n
+          end
+        }
+        return +[*map(&node2matcher)] & self.class
+      end
+
+    private
+      def quirks
+        Thread.current[:$RedParse_parsetree_quirks]
+      end
+
+      #turn a list (array) of arrays into a linked list, in which each array
+      #has a reference to the next in turn as its last element.
+      def linked_list(arrays)
+        0.upto(arrays.size-2){|i| arrays[i]<<arrays[i+1] }
+        return arrays.first
+      end
+
+      def param_list_walk(param_list)
+        param_list or return
+        limit=param_list.size
+        i=0
+        normals=[]
+        lownormal=nil
+        handle_normals=proc{
+          yield '',normals,lownormal..i-1 if lownormal
+          lownormal=nil
+          normals.slice! 0..-1
+        }
+        while i<limit
+          case param=param_list[i]
+          when ArrowOpNode
+            handle_normals[]
+            low=i
+            i+=1 while ArrowOpNode===param_list[i]
+            high=i-1
+            yield '=>',param_list[low..high],low..high
+          when UnaryStarNode
+            handle_normals[]
+            yield '*',param,i
+          when UnOpNode&-{:op=>"&@"}
+            handle_normals[]
+            yield '&',param,i
+          else
+            lownormal=i unless lownormal
+            normals << param
+          end
+          i+=1
+        end
+        handle_normals[]
+      end
+
+      def param_list_parse(param_list)
+        output=[]
+        star=amp=nil
+        param_list_walk(param_list){|type,val,i|
+          case type
+          when '':
+            output.concat val.map{|param| param.rescue_parsetree}
+          when '=>':
+            output.push HashLiteralNode.new(nil,val,nil).parsetree
+          when '*': star=val.parsetree
+          when '&': amp=val.parsetree
+          end
+        }
+        return output,star,amp
+      end
+    end
+
+    class ValueNode<Node
+      def lvalue?; nil end
+    end
+
+    #forward decls
+    module ArrowOpNode; end
+    module RangeNode; end
+    module LogicalNode; end
+    module WhileOpNode; end
+    module UntilOpNode; end
+    module IfOpNode; end
+    module UnlessOpNode; end
+    module OpNode; end
+    module NotEqualNode; end
+    module MatchNode; end
+    module NotMatchNode; end
+
+    OP2MIXIN={
+      "=>"=>ArrowOpNode,
+      ".."=>RangeNode,
+      "..."=>RangeNode,
+      "&&"=>LogicalNode,
+      "||"=>LogicalNode,
+      "and"=>LogicalNode,
+      "or"=>LogicalNode,
+      "while"=>WhileOpNode,
+      "until"=>UntilOpNode,
+      "if"=>IfOpNode,
+      "unless"=>UnlessOpNode,
+      "!="=>NotEqualNode,
+      "!~"=>NotMatchNode,
+      "=~"=>MatchNode,
+    }
+
+    class RawOpNode<ValueNode
+      param_names(:left,:op,:right)
+      def initialize(left,op,right)
+        @offset=op.offset
+        op=op.ident
+        super(left,op,right)
+        Array((OP2MIXIN[op]||OpNode)).each{|mod|
+          extend(mod)        
+          mod.instance_method(:initialize).bind(self).call(left,op,right)
+        }
+      end
+      def self.[](*args)
+        result=super
+        @module and extend @module
+        return result
+      end
+      def image; "(#{op})" end
+      def raw_unparse o
+        l=left.unparse(o)
+        l[/(~| \Z)/] and maybesp=" "
+        [l,op,maybesp,right.unparse(o)].to_s
+      end
+    end
+
+    module OpNode
+      def initialize(left,op,right)
+        #@negative_of="="+$1 if /^!([=~])$/===op
+        @module=OpNode
+      end
+      def to_lisp
+        "(#{op} #{left.to_lisp} #{right.to_lisp})"
+      end
+
+      def parsetree
+        [:call, 
+           left.rescue_parsetree, 
+           op.to_sym, 
+           [:array, right.rescue_parsetree]
+        ]
+      end
+      alias opnode_parsetree parsetree
+
+      def unparse o
+        result=l=left.unparse(o)
+        result+=" " if /a-z_/i===op
+        result+=op
+        result+=" " if /a-z_/i===op or / \Z/===l
+        result+=right.unparse(o)      
+      end
+
+      def unparse o; raw_unparse o end
+    end
+
+    module MatchNode
+      include OpNode
+
+      def parsetree
+        if StringNode===left and left.char=='/'
+          [:match2, left.parsetree, right.parsetree]
+        elsif StringNode===right and right.char=='/'
+          [:match3, right.parsetree, left.parsetree]
+        else
+          super 
+        end
+      end
+      def op; "=~"; end
+    end
+
+    module NotEqualNode
+      include OpNode
+
+      def parsetree
+        result=opnode_parsetree
+        result[2]="=#{op[1..1]}".to_sym
+        result=[:not, result]
+        return result
+      end
+      def op; "!="; end
+    end
+
+    module NotMatchNode
+      include NotEqualNode
+
+      def parsetree
+        if StringNode===left and left.char=="/"
+          [:not, [:match2, left.parsetree, right.parsetree]]
+        elsif StringNode===right and right.char=="/"
+          [:not, [:match3, right.parsetree, left.parsetree]]
+        else
+          super
+        end
+      end
+
+      def op; "!~"; end
+    end
+
+    class ListOpNode<ValueNode #abstract
+      def initialize(val1,op,val2)
+        list=if self.class===val1
+               Array.new(val1)
+             else
+               [val1]
+             end
+        if self.class===val2
+          list.push *val2
+        elsif val2
+          list.push val2
+        end 
+        super *list
+      end
+    end
+
+    class CommaOpNode<ListOpNode #not to appear in final tree
+      def image; '(,)' end
+      def to_lisp
+        "(#{map{|x| x.to_lisp}.join(" ")})"
+      end
+      def lvalue?
+        return @lvalue if defined? @lvalue
+        @lvalue=true
+      end
+      attr_accessor :lvalue
+    end
+
+    class LiteralNode<ValueNode; end
+    class StringNode<ValueNode; end
+    class StringCatNode < ValueNode; end
+    class NopNode<ValueNode; end
+    class VarLikeNode<ValueNode; end  #nil,false,true,__FILE__,__LINE__,self
+
+    class SequenceNode<ListOpNode
+      def image; '(;)' end
+      def to_lisp
+        "#{map{|x| x.to_lisp}.join("\n")}"
+      end
+
+      def to_lisp_with_parens
+        "(#{to_lisp})"
+      end
+
+      LITFIX=LiteralNode&-{:val=>Fixnum}
+      LITRANGE=RangeNode&-{:left=>LITFIX,:right=>LITFIX}
+      LITSTR=StringNode&-{:size=>1,:char=>/^[^`\[{]$/}
+      #LITCAT=proc{|item| item.grep(~LITSTR).empty?}
+      #class<<LITCAT; alias === call; end
+      LITCAT=StringCatNode& item_that.grep(~LITSTR).empty? #+[LITSTR.+]
+      LITNODE=LiteralNode|NopNode|LITSTR|LITCAT|LITRANGE|(VarLikeNode&-{:name=>/^__/})
+            #VarNameToken|  #why not this too?
+      def parsetree
+        data=compact
+        data.empty? and return
+        items=Array.new(data[0...-1])
+        if quirks
+          items.shift while LITNODE===items.first
+        else
+          items.reject!{|expr| LITNODE===expr }
+        end
+        items.map!{|expr| expr.rescue_parsetree}.push last.parsetree
+#        items=map{|expr| expr.parsetree}
+        items.reject!{|expr| []==expr }
+        if quirks
+          header=items.first
+          (items[0,1] = *header[1..-1]) if header and header.first==:block
+        else
+          items.size.pred.downto(0){|i|
+            header=items[i]
+            (items[i,1] = *header[1..-1]) if header and header.first==:block
+          }     
+        end
+        if items.size>1
+          items.unshift :block
+        elsif items.size==1
+          items.first
+        else
+          items
+        end
+      end
+
+      def unparse o
+        map{|expr| expr.unparse(o)}.join("\n")      
+      end
+    end
+
+    class StringCatNode < ValueNode
+      def initialize(strs,str1,str2)
+        if HereDocNode===strs
+          hd,strs,str=strs,str1,str2
+          strs.push str
+        else
+          strs.push str1,str2
+        end
+        strs.map!{|str| StringNode.new(str)}
+        strs.unshift hd if hd
+        super *strs
+      end
+      def parsetree
+        result=map{|str| str.parsetree}
+        sum=''
+        type=:str
+        tree=i=nil
+        result.each_with_index{|tree,i| 
+          sum+=tree[1]
+          tree.first==:str or break(type=:dstr)
+        }
+        [type,sum,*tree[2..-1]+result[i+1..-1].inject([]){|cat,x|
+          if x.first==:dstr
+            x.shift
+            x0=x[0] 
+            if x0=='' and x.size==2
+              x.shift
+            else
+              x[0]=[:str,x0]
+            end
+            cat+x
+          else
+            cat+[x]
+          end
+          }
+        ]
+      end
+
+      def unparse o
+        map{|ss| ss.unparse(o)}.join ' '      
+      end
+    end
+
+#    class ArrowOpNode<ValueNode
+#      param_names(:left,:arrow_,:right)
+#    end
+     module ArrowOpNode #not to appear in final tree?
+       def initialize(*args) 
+         @module=ArrowOpNode
+       end
+     end
+
+#    class RangeNode<ValueNode
+    module RangeNode
+#      param_names(:first,:op_,:last)
+      def initialize(left,op_,right)
+        @exclude_end=!!op_[2]
+        @module=RangeNode
+        @as_flow_control=false
+#        super(left,right)
+      end
+      def begin; left end
+      def end; right end
+      def first; left end
+      def last; right end
+      def exclude_end?; @exclude_end end
+
+      def parsetree
+        first=first().parsetree
+        last=last().parsetree
+        if :lit==first.first and :lit==last.first and
+           Fixnum===first.last and Fixnum===last.last
+          return [:lit, Range.new(first.last,last.last,@exclude_end)]
+        end
+        tag= @as_flow_control ? "flip" : "dot"
+        count= @exclude_end ? ?3 : ?2
+        tag << count
+        [tag.to_sym, first, last]
+      end
+
+      def special_conditions!
+        @as_flow_control=true
+      end
+
+      def unparse(o)
+        result=left.unparse(o)+'..'
+        result+='.' if exclude_end?
+        result << right.unparse(o)
+        return result      
+      end
+    end
+
+    class UnOpNode<ValueNode
+      param_names(:op,:val)
+      def initialize(op,val)
+#        /^[&*+-]$/===op.ident and op.ident+="@"
+        op=op.ident
+        /^(!|not)$/===op and 
+          val.respond_to? :special_conditions! and 
+            val.special_conditions!
+        super(op,val)
+      end
+   
+      alias ident op
+
+      def image; "(#{op})" end
+
+      def lvalue?
+#        return nil unless op=="*@"
+
+        return @lvalue if defined? @lvalue
+        @lvalue=true
+      end
+      attr_accessor :lvalue
+
+      def to_lisp
+        "(#{op} #{val.to_lisp})"
+      end
+
+      def parsetree
+        node=self
+        node=node.val while UnOpNode===node and node.op=="+@"
+        return node.parsetree if LiteralNode&-{:val=>Integer|Float|Symbol}===node
+        return node.parsetree if StringNode&-{:char=>'/', :size=>1}===node
+
+        case op
+        when /^&/: [:block_arg, val.ident.to_sym]
+        when "!","not": [:not, val.rescue_parsetree]
+        when "defined?": [:defined, val.parsetree]
+        else
+          [:call, val.rescue_parsetree, op.to_sym]
+        end
+      end
+
+      def lvalue_parsetree
+        parsetree
+      end
+
+      def unparse o
+        op=op()
+        op=op.chomp "@"
+        result=op
+        result+=" " if /[a-z_]/i===op
+        result+=val.unparse(o)
+      end
+    end
+
+    class UnaryStarNode<UnOpNode
+      def parsetree
+        [:splat, val.rescue_parsetree]
+      end
+
+      def all_current_lvars
+        val.respond_to?(:all_current_lvars) ?
+          val.all_current_lvars : []
+      end
+      attr_accessor :after_comma
+
+      def lvalue_parsetree
+        val.lvalue_parsetree
+      end
+
+      def unparse o
+        "*"+val.unparse(o)      
+      end
+    end
+
+    class DanglingStarNode<UnaryStarNode
+      #param_names :op,:val
+      def initialize(star)
+        @offset= star.offset
+        replace ['*@',VarNameToken.new('',offset)]
+      end
+      attr :offset
+      def lvars_defined_in; [] end
+      def parsetree; [:splat] end
+      alias lvalue_parsetree parsetree
+
+      def unparse(o); "* "; end
+    end
+
+    class DanglingCommaNode<DanglingStarNode
+      def initialize
+        
+      end
+      attr_accessor :offset
+
+      def lvalue_parsetree
+        :dangle_comma
+      end
+      alias parsetree lvalue_parsetree
+
+      def unparse o;  "";   end
+    end
+
+    class ConstantNode<ListOpNode
+      def initialize(*args)
+        args.unshift nil if args.size==2
+        args.map!{|node| 
+          if VarNameToken===node and (?A..?Z)===node.ident[0]
+          then node.ident 
+          else node
+          end
+        }
+        super(*args)  
+      end
+      def unparse(o)
+        if Node===first
+          result=dup
+          result[0]= first.unparse(o)#.gsub(/\s+\Z/,'')
+          result.join('::')
+        else join('::')
+        end
+      end
+      alias image unparse
+      def lvalue_parsetree
+        [:cdecl,parsetree]
+      end
+      def parsetree
+        if !first
+          result=[:colon3, self[1].to_sym]
+          i=2
+        else
+          result=first.respond_to?(:parsetree) ? 
+                   first.parsetree :
+                   [:const,first.to_sym]
+          i=1
+        end
+        (i...size).inject(result){|r,j| 
+          [:colon2, r, self[j].to_sym]
+        }
+      end
+
+      def lvalue?
+        return @lvalue if defined? @lvalue
+        @lvalue=true
+      end
+      attr_accessor :lvalue
+    end
+    LookupNode=ConstantNode
+
+    class DoubleColonNode<ValueNode #dunno about this name...     maybe ConstantNode?
+      #not used anymore
+      param_names :namespace, :constant
+      alias left namespace
+      alias right constant
+      def initialize(val1,op,val2=nil)
+        val1,op,val2=nil,val1,op unless val2
+        val1=val1.ident if VarNameToken===val1 and /\A[A-Z]/===val1.ident
+        val2=val2.ident if VarNameToken===val2 and /\A[A-Z]/===val2.ident
+        replace [val1,val2]
+      end
+
+      def image; '(::)' end
+ 
+
+      def parsetree
+        if namespace
+          ns= (String===namespace) ? [:const,namespace.to_sym] : namespace.parsetree
+          [:colon2, ns, constant.to_sym]
+        else
+          [:colon3, constant.to_sym]
+        end
+      end
+      def lvalue_parsetree
+        [:cdecl,parsetree]
+      end
+
+      def lvalue?
+        return @lvalue if defined? @lvalue
+        @lvalue=true
+      end
+      attr_accessor :lvalue
+    end
+
+    class DotCallNode<ValueNode #obsolete
+      param_names :receiver,:dot_,:callsite
+
+      def image; '(.)' end
+
+      def to_lisp
+        "(#{receiver.to_lisp} #{@data.last.to_lisp[1...-1]})"
+      end
+
+      def parsetree
+        cs=self[1]
+        cs &&= cs.parsetree
+        cs.shift if cs.first==:vcall or cs.first==:fcall
+        [:call, @data.first.parsetree, *cs]
+      end
+      def lvalue?
+        return @lvalue if defined? @lvalue
+        @lvalue=true
+      end
+      attr_accessor :lvalue
+    end
+
+    class ParenedNode<ValueNode
+      param_names :body, :rescues, :else!, :ensure!
+      def initialize(*args)
+        @empty_ensure=@op_rescue=nil
+        replace(
+        if args.size==3  #()
+          if (KeywordToken===args.first and args.first.ident=='(')
+            [args[1]] 
+          else
+            expr,rescueword,backup=*args
+            @op_rescue=true
+            [expr,[RescueNode[[],nil,backup]],nil,nil]    
+          end
+        else
+          body,rescues,else_,ensure_=*args[1...-1]
+          if else_
+            else_=else_.val or @empty_else=true
+          end
+          if ensure_
+            ensure_=ensure_.val or @empty_ensure=true
+          end
+          [body,rescues,else_,ensure_]
+        end
+        )
+      end
+
+      alias ensure_ ensure
+      alias else_ else
+
+      attr_reader :empty_ensure, :empty_else
+      attr_accessor :after_comma, :after_equals
+      def op?; @op_rescue; end
+
+      def image; '(begin)' end
+
+      def special_conditions!
+        if size==1
+          node=body
+          node.special_conditions! if node.respond_to? :special_conditions!
+        end
+      end
+
+      def to_lisp
+        huh #what about rescues, else, ensure?
+        body.to_lisp
+      end
+ 
+      def parsetree
+        if size==1
+          body.parsetree
+        else
+          body=body()
+          target=result=[]   #was: [:begin, ]
+
+          #body,rescues,else_,ensure_=*self
+          target.push target=[:ensure, ] if ensure_ or @empty_ensure
+
+          rescues=rescues().map{|resc| resc.parsetree}
+          if rescues.empty? 
+            else_ and
+              body=SequenceNode.new(body,nil,else_)
+            else_=nil
+          else 
+            target.push newtarget=[:rescue, ]
+            else_=else_()
+          end
+          if body 
+              needbegin=  (ParenedNode===body and body.after_equals)
+              body=body.parsetree 
+              body=[:begin, body] if needbegin and body.first!=:begin
+              (newtarget||target).push body if body
+          end
+          target.push ensure_.parsetree if ensure_
+          target.push [:nil] if @empty_ensure
+          target=newtarget if newtarget
+          
+          unless rescues.empty?
+            target.push linked_list(rescues)
+          end
+          target.push else_.parsetree if  else_ #and !body
+          result.size==0 and result=[[:nil]]
+          result=result.last #if @op_rescue
+          result
+        end
+      end
+
+#      def rescue_parsetree
+#        result=parsetree
+#        result.first==:begin and result=result.last
+#        result
+#      end
+
+      def begin_parsetree
+        body,rescues,else_,ensure_=*self
+        needbegin=(rescues&&!rescues.empty?) || ensure_ || @empty_ensure
+        result=parsetree
+        needbegin and result=[:begin, result]
+        result
+      end
+
+      def lvalue?
+        return nil unless size==1 
+#        case first
+#        when CommaOpNode,UnaryStarNode: #do nothing
+#        when ParenedNode: return first.lvalue?
+#        else return nil
+#        end
+
+        return @lvalue if defined? @lvalue
+        @lvalue=true
+      end
+      attr_accessor :lvalue
+
+      def unparse(o)
+        if size==1
+          "("+(body&&body.unparse(o))+")"
+        else
+          result="begin "
+          body&&result+= body.unparse(o)
+          result+="\n"
+          rescues.each{|resc| result+=resc.unparse(o) }
+          result+="\nensure "+ensure_.unparse(o) if ensure_
+          result+="\nelse "+else_.unparse(o) if else_
+          result+="\nend"
+        end
+      end
+    end
+
+    class AssignmentRhsNode < Node #not to appear in final parse tree
+      param_names :open_, :val, :close_
+      def initialize(*args)
+        if args.size==1: super args.first
+        else super args[1]
+        end
+      end
+    end
+
+    class AssignNode<ValueNode
+      param_names :left,:op,:right
+      alias lhs left
+      alias rhs right
+      def initialize(*args)
+
+        if args.size==5
+          if args[3].ident=="rescue3"
+            lhs,op,rescuee,op2,rescuer=*args
+            rhs=ParenedNode.new(rescuee.val,op2,rescuer)
+          else
+            lhs,op,bogus1,rhs,bogus2=*args
+          end
+        else
+          lhs,op,rhs=*args
+          rhs=rhs.val if AssignmentRhsNode===rhs
+        end
+        case lhs
+        when UnaryStarNode         #look for star on lhs
+          lhs=MultiAssign.new([lhs]) unless lhs.after_comma
+        when ParenedNode
+        if lhs.size==1 and !lhs.after_comma      #look for () around lhs
+          if CommaOpNode===lhs.first
+            lhs=MultiAssign.new(Array.new(lhs.first))
+          else
+            lhs=MultiAssign.new([lhs.first])
+          end
+          @lhs_parens=true
+        end
+        when CommaOpNode: 
+          lhs=MultiAssign.new lhs
+          #rhs=Array.new(rhs) if CommaOpNode===rhs
+        end 
+
+        if CommaOpNode===rhs
+          rhs=Array.new(rhs)
+          lhs=MultiAssign.new([lhs]) unless MultiAssign===lhs
+        end
+
+        op=op.ident
+
+        return super(lhs,op,rhs)  
+        #punting, i hope the next layer can handle += and the like
+
+=begin
+        #in theory, we should do something more sophisticated, like this:
+        #(but the presence of side effects in lhs will screw it up)
+        if op=='='
+          super
+        else
+          super(lhs,OpNode.new(lhs,OperatorToken.new(op.chomp('=')),rhs))
+        end
+=end
+      end
+
+      def multi?
+        MultiAssign===left
+      end
+
+      def image; '(=)' end
+
+      def to_lisp
+        case left
+        when ParenedNode: huh
+        when ConstantNode: huh
+        when BracketsGetNode: huh
+        when VarNameToken
+          "(set #{left.to_lisp} (#{op.chomp('=')} #{left.to_lisp} #{right.to_lisp}))"
+        when CallSiteNode
+        if op=='='
+          "(#{left.receiver.to_lisp} #{left.name}= #{right.to_lisp})"
+        else
+          op_=op.chomp('=')
+          varname=nil
+          "(let #{varname=huh} #{left.receiver.to_lisp} "+
+            "(#{varname} #{left.name}= "+
+              "(#{op_} (#{varname} #{op}) #{right.to_lisp})))"
+        end
+        else  huh
+        end
+      end
+
+      def all_current_lvars
+        left.respond_to?(:all_current_lvars) ?
+          left.all_current_lvars : []
+      end
+
+      def parsetree
+        case left
+        when ParenedNode: huh
+        when ConstantNode: 
+        left.lvalue_parsetree << right.parsetree
+
+        when MultiAssign: 
+        lhs=left.lvalue_parsetree
+        rhs= right.class==Array ? right : [right]
+        star=rhs.pop if UnaryStarNode===rhs.last
+        rhs=rhs.map{|x| x.rescue_parsetree}
+        if rhs.size==0
+          star or fail
+          rhs= star.parsetree
+        elsif rhs.size==1 and !star and !(UnaryStarNode===left.first)
+          rhs.unshift :to_ary
+        else
+          rhs.unshift(:array) 
+          if star
+            splat=star.val.rescue_parsetree
+            #if splat.first==:call #I don't see how this can be right....
+            #  splat[0]=:attrasgn
+            #  splat[2]="#{splat[2]}=".to_sym
+            #end
+            rhs=[:argscat, rhs, splat] 
+          end
+          if left.size==1 and !(UnaryStarNode===left.first) and !(NestedAssign===left.first)
+            rhs=[:svalue, rhs]
+          end
+        end
+        lhs<< rhs
+
+        when CallSiteNode
+        op=op().chomp('=')
+        rcvr=left.receiver.parsetree
+        prop=left.name.+('=').to_sym
+        args=right.rescue_parsetree
+        UnaryStarNode===right and args=[:svalue, args]
+        if op.empty?
+          [:attrasgn, rcvr, prop, [:array, args] ]
+        else
+          [:op_asgn2, rcvr,prop,  op.to_sym, args]
+        end
+
+        when BracketsGetNode
+        args=left.params
+        if op()=='='
+          result=left.lvalue_parsetree #[:attrasgn, left[0].parsetree, :[]=]
+          result.size==3 and result.push [:array]
+          rhs=right.rescue_parsetree
+          UnaryStarNode===right and rhs=[:svalue, rhs]
+          if args 
+            result[-1]=[:argspush,result[-1]] if UnaryStarNode===args.last
+          #else result[-1]=[:zarray]
+          end
+          result.last << rhs
+          result            
+          
+        else
+=begin
+          args&&=args.map{|x| x.parsetree}.unshift(:array)
+          splat=args.pop if :splat==args.last.first
+          if splat and left.params.size==1
+            args=splat
+          elsif splat
+            args=[:argscat, args, splat.last]
+          end
+=end
+          lhs=left.parsetree
+          if lhs.first==:fcall
+            rcvr=[:self]
+            args=lhs[2]
+          else
+            rcvr=lhs[1]
+            args=lhs[3]
+          end
+          args||=[:zarray]
+          result=[
+            :op_asgn1, rcvr, args,
+            op().chomp('=').to_sym, 
+            right.rescue_parsetree
+          ]
+        end
+
+        when VarNameToken
+        node_type=left.varname2assigntype
+        if /^(&&|\|\|)=$/===op()
+          
+          return ["op_asgn_#{$1[0]==?& ? "and" : "or"}".to_sym, 
+                  left.parsetree,
+                  [node_type, left.ident.to_sym, 
+                   right.rescue_parsetree]
+                 ]
+        end
+
+        if op()=='='
+          rhs=right.rescue_parsetree
+          UnaryStarNode===right and rhs=[:svalue, rhs]
+          
+#          case left
+#          when VarNameToken: 
+               [node_type, left.ident.to_sym, rhs]
+#          else [node_type, left.data[0].parsetree, left.data[1].data[0].ident.+('=').to_sym  ,[:array, rhs]]
+#          end
+
+=begin these branches shouldn't be necessary now
+        elsif node_type==:op_asgn2
+          [node_type, @data[0].data[0].parsetree, 
+            @data[0].data[1].data[0].ident.+('=').to_sym,
+            op().ident.chomp('=').to_sym,
+             @data[2].parsetree
+          ]
+        elsif node_type==:attrasgn
+          [node_type]
+=end
+        else
+          [node_type, left.ident.to_sym,
+            [:call,
+             left.parsetree, 
+               op().chomp('=').to_sym, 
+             [:array, right.rescue_parsetree]
+            ]
+          ]
+        end
+        else 
+          huh
+        end
+      end
+
+      def unparse(o)
+        lhs.lhs_unparse(o)+op+
+          (rhs.class==Array ? 
+            rhs.map{|rv| rv.unparse o}.join(',') :
+            rhs.unparse(o) 
+          )
+      end
+    end
+
+    class MultiAssignNode < ValueNode #obsolete
+      param_names :left,:right
+
+      #not called from parse table
+
+      def parsetree
+        lhs=left.dup
+        if UnaryStarNode===lhs.last
+          lstar=lhs.pop
+        end
+        lhs.map!{|x| 
+          res=x.parsetree
+          res[0]=x.varname2assigntype if VarNameToken===x
+          res
+        }
+        lhs.unshift(:array) if lhs.size>1 or lstar
+        rhs=right.map{|x| x.parsetree}
+        if rhs.size==1
+          if rhs.first.first==:splat 
+            rhs=rhs.first
+          else
+            rhs.unshift :to_ary
+          end
+        else
+          rhs.unshift(:array) 
+          if rhs[-1][0]==:splat
+            splat=rhs.pop[1]
+            if splat.first==:call 
+              splat[0]=:attrasgn
+              splat[2]="#{splat[2]}=".to_sym
+            end
+            rhs=[:argscat, rhs, splat] 
+          end
+        end
+        result=[:masgn, lhs, rhs]
+        result.insert(2,lstar.data.last.parsetree) if lstar
+        result
+
+      end
+    end
+
+    class AssigneeList< ValueNode #abstract
+      def initialize(data)
+        data.each_with_index{|datum,i|
+          if ParenedNode&-{:size=>1}===datum
+            first=datum.first
+            list=case first
+            when CommaOpNode: Array.new(first)
+            when UnaryStarNode,ParenedNode: [first]
+            end 
+            data[i]=NestedAssign.new(list) if list
+          end
+        }
+        replace data
+      end
+
+      def  unparse o
+        map{|lval| lval.lhs_unparse o}.join(', ')      
+      end
+
+      def old_parsetree
+        lhs=data.dup
+        if UnaryStarNode===lhs.last
+          lstar=lhs.pop.val
+        end
+        lhs.map!{|x| 
+          res=x.parsetree
+          res[0]=x.varname2assigntype if VarNameToken===x
+          res
+        }
+        lhs.unshift(:array) if lhs.size>1 or lstar
+        result=[lhs]
+        if lstar.respond_to? :varname2assigntype
+          result << lstar.varname2assigntype 
+        elsif lstar #[]=, attrib=, or A::B=
+          huh  
+        else #do nothing
+        end
+        result
+
+      end
+
+      def parsetree 
+        data=self
+        data.empty? and return nil 
+#        data=data.first if data.size==1 and ParenedNode===data.first and data.first.size==1
+        data=Array.new(data)
+        star=data.pop if UnaryStarNode===data.last
+        result=data.map{|x| x.lvalue_parsetree }
+=begin
+        {
+          if VarNameToken===x 
+            ident=x.ident
+            ty=x.varname2assigntype
+#            ty==:lasgn and ty=:dasgn_curr
+            [ty, ident.to_sym] 
+          else
+            x=x.parsetree
+            if x[0]==:call
+              x[0]=:attrasgn
+              x[2]="#{x[2]}=".to_sym
+            end
+            x
+          end
+        }
+=end
+        if result.size==0
+          star or fail
+          result=[:masgn, star.lvalue_parsetree]
+        elsif result.size==1 and !star and !(NestedAssign===data.first)
+          result=result.first
+        else
+          result=[:masgn, [:array, *result]]
+          result.push star.lvalue_parsetree if star and not DanglingCommaNode===star
+        end
+        result
+      end
+
+
+
+      def all_current_lvars
+        result=[]
+        each{|lvar|
+          lvar.respond_to?(:all_current_lvars) and
+            result.concat lvar.all_current_lvars 
+        }
+        return result
+      end
+
+      def lvalue_parsetree; parsetree end
+    end
+    class NestedAssign<AssigneeList
+#      def parsetree
+#        [:masgn, *super]
+#      end
+      def unparse o
+        "("+super+")"
+      
+      end
+    end
+
+
+    class MultiAssign<AssigneeList; end
+    class BlockParams<AssigneeList; 
+      def initialize(data)
+        item=data.first if data.size==1
+        #elide 1 layer of parens if present
+        if ParenedNode===item and item.size==1
+          item=item.first
+          data=CommaOpNode===item ? Array.new(item) : [item]
+          @had_parens=true
+        end
+
+        super(data)
+      end
+
+      def unparse o
+        unless @had_parens
+          "|"+super+"|" 
+        else
+          "|("+super+")|" 
+        end
+      end
+    end
+
+    class AccessorAssignNode < ValueNode #obsolete
+      param_names :left,:dot_,:property,:op,:right
+
+      def to_lisp
+        if op.ident=='='
+          "(#{left.to_lisp} #{property.ident}= #{right.to_lisp})"
+        else
+          op=op().ident.chomp('=')
+          varname=nil
+          "(let #{varname=huh} #{left.to_lisp} "+
+            "(#{varname} #{property.ident}= "+
+              "(#{op} (#{varname} #{property.ident}) #{right.to_lisp})))"
+        end
+      end
+
+      def parsetree
+        op=op().ident.chomp('=')
+        rcvr=left.parsetree
+        prop=property.ident.<<(?=).to_sym
+        rhs=right.parsetree
+        if op.empty?
+          [:attrasgn, rcvr, prop, [:array, args] ]
+        else
+          [:op_asgn2, rcvr,prop,  op.to_sym, args]
+        end
+      end
+    end
+ 
+    module KeywordOpNode
+      def unparse o
+        [left.unparse(o),' ',op,' ',right.unparse(o)].to_s
+      end
+    end
+
+    module LogicalNode
+      include KeywordOpNode
+      def initialize(left,op,right)
+        @opmap=op[0,1]
+        case op
+        when "&&": op="and"
+        when "||": op="or"
+        end
+        #@reverse= op=="or"
+        #@op=op
+        @module=LogicalNode
+        replace [left,right]
+        (size-1).downto(0){|i|
+          expr=self[i]
+          if LogicalNode===expr and expr.op==op 
+            self[i,1]=Array.new expr
+            opmap[i,0]=expr.opmap
+          end
+        }
+      end
+      attr_reader :opmap
+
+      OP_EXPAND={?o=>"or", ?a=>"and", ?&=>"&&", ?|=>"||", nil=>""}
+      OP_EQUIV={?o=>"or", ?a=>"and", ?&=>"and", ?|=>"or"}
+
+      def reverse
+        /\A[o|]/===@opmap      
+      end
+      def op
+        OP_EQUIV[@opmap[0]]
+      end
+
+      #these 3 methods are defined in RawOpNode too, hence these
+      #definitions are ignored. grrrrrrr.
+      def unparse o
+        result=''
+      
+        each_with_index{|expr,i|
+          result.concat expr.unparse(o)
+          result.concat ?\s
+          result.concat OP_EXPAND[@opmap[i]]
+          result.concat ?\s
+        }
+        return result
+      end
+      def left(*args,&block)
+        method_missing(:left,*args,&block)  
+      end
+      def right(*args,&block)
+        method_missing(:right,*args,&block)
+      end
+
+      def parsetree
+        result=[].replace(self).reverse
+        last=result.shift.begin_parsetree
+        first=result.pop
+        result=result.inject(last){|sum,x| 
+          [op.to_sym, x.begin_parsetree, sum]
+        }
+        [op.to_sym, first.rescue_parsetree, result]
+      end
+
+      def special_conditions!
+        each{|x| 
+          if x.respond_to? :special_conditions! and !(ParenedNode===x)
+            x.special_conditions! 
+          end
+        }
+      end
+    end
+
+    module WhileOpNode
+      include KeywordOpNode
+      def condition; right end
+      def consequent; left end
+      def initialize(val1,op,val2)
+        self[1]=op
+        @reverse=false
+        @module=WhileOpNode
+        @loop=true
+        @test_first= !( ParenedNode===val1 and val1.size != 1  )
+        condition.special_conditions! if condition.respond_to? :special_conditions!
+      end
+
+      def while; condition end
+      def do; consequent end
+
+      def parsetree
+        cond=condition.rescue_parsetree
+        body=consequent.parsetree
+        !@test_first and
+          body.size == 2 and
+            body.first == :begin and
+              body=body.last
+        if cond.first==:not
+          kw=:until
+          cond=cond.last
+        else
+          kw=:while
+        end
+        [kw, cond, body, (@test_first or body==[:nil])]
+      end
+
+      
+    end
+
+    module UntilOpNode
+      include KeywordOpNode
+      def condition; right end
+      def consequent; left end
+      def initialize(val1,op,val2)
+        self[1]=op
+        @reverse=true
+        @loop=true
+        @test_first= !( ParenedNode===val1 and (val1.size != 1 )) 
+        @module=UntilOpNode
+        condition.special_conditions! if condition.respond_to? :special_conditions!
+      end
+
+      def while; negate condition end
+      def do; consequent end
+
+      def parsetree
+        cond=condition.rescue_parsetree
+        body=consequent.parsetree
+        !@test_first and
+          body.size == 2 and
+            body.first == :begin and
+              body=body.last
+        if cond.first==:not
+          kw=:while
+          cond=cond.last
+        else
+          kw=:until
+        end
+        tf=@test_first
+        tf||= (!consequent.body and !consequent.else and !consequent.empty_else and
+               !consequent.ensure and !consequent.empty_ensure and consequent.rescues.empty?
+              ) if ParenedNode===consequent
+        [kw, cond, body, tf]
+      end
+    end
+
+    module UnlessOpNode
+      include KeywordOpNode
+      def condition; right end
+      def consequent; left end
+      def initialize(val1,op,val2)
+        self[1]=op
+        @reverse=true
+        @loop=false
+        @module=UnlessOpNode
+        condition.special_conditions! if condition.respond_to? :special_conditions!
+      end
+
+      def if; condition end
+      def then; nil end
+      def else; consequent end
+      def elsifs; [] end
+
+      def parsetree
+        cond=condition.rescue_parsetree
+        actions=[nil, consequent.parsetree]
+        if cond.first==:not
+          actions.reverse!
+          cond=cond.last
+        end
+        [:if, cond, *actions]
+      end
+    end
+
+    module IfOpNode
+      include KeywordOpNode
+      def condition; right end
+      def consequent; left end
+      def initialize(left,op,right)
+        self[1]=op
+        @reverse=false
+        @loop=false
+        @module=IfOpNode
+        condition.special_conditions! if condition.respond_to? :special_conditions!
+      end
+
+      def if; condition end
+      def then; consequent end
+      def else; nil end
+      def elsifs; [] end
+
+      def parsetree
+        cond=condition.rescue_parsetree
+        actions=[consequent.parsetree, nil]
+        if cond.first==:not
+          actions.reverse!
+          cond=cond.last
+        end
+        [:if, cond, *actions]
+      end
+    end
+
+    class CallSiteNode<ValueNode
+      param_names :receiver, :name, :params, :blockparams, :block
+      alias blockargs blockparams
+      alias block_args blockargs
+      alias block_params blockparams
+
+      def initialize(method,open_paren,param_list,close_paren,block)
+        @not_real_parens=!open_paren || open_paren.not_real?
+
+        case param_list
+        when CommaOpNode
+          #handle inlined hash pairs in param list (if any)
+#          compr=Object.new
+#          def compr.==(other) ArrowOpNode===other end
+          param_list=Array.new(param_list)
+          first=last=nil
+          param_list.each_with_index{|param,i| 
+            break first=i if ArrowOpNode===param
+          }
+          (1..param_list.size).each{|i| param=param_list[-i]
+            break last=-i if ArrowOpNode===param
+          }
+          if first
+            arrowrange=first..last
+            arrows=param_list[arrowrange]
+            param_list[arrowrange]=[HashLiteralNode.new(nil,arrows,nil)]
+          end
+        
+        when ArrowOpNode:  
+          param_list=[HashLiteralNode.new(nil,param_list,nil)]
+#        when KeywordOpNode
+#          fail "didn't expect '#{param_list.inspect}' inside actual parameter list"
+        when nil
+        else
+          param_list=[param_list]
+        end
+
+        if block
+          @do_end=block.do_end
+          blockparams=block.params
+          block=SequenceNode[*block.body] #||[]
+        end
+        @offset=method.offset
+        method=method.ident
+        fail unless String===method
+        super(nil,method,param_list,blockparams,block)
+        #receiver, if any, is tacked on later
+      end
+
+      def real_parens; !@not_real_parens end
+
+      def unparse o
+        fail if block==false
+        result=[
+         receiver&&receiver.unparse(o)+'.',name,      
+         real_parens ? '(' : (' ' if params),
+         params&&params.map{|param| param.unparse(o)}.join(', '),
+         real_parens ? ')' : nil,
+        
+         block&&[
+           @do_end ? " do " : "{", 
+             block_params&&block_params.unparse(o),
+             " ",
+             block.unparse(o),
+           @do_end ? " end" : "}"
+         ]
+        ]
+        return result.to_s
+      end
+
+      def image
+        result="(#{receiver.image if receiver}.#{name})"
+      end
+
+      def lvalue_parsetree
+        result=parsetree
+        result[0]=:attrasgn
+        result[2]="#{result[2]}=".to_sym
+        result
+      end
+
+      def lvalue?
+        return @lvalue if defined? @lvalue
+        @lvalue=true
+      end
+      attr_accessor :lvalue
+
+      def to_lisp
+        "(#{receiver.to_lisp} #{self[1..-1].map{|x| x.to_lisp}.join(' ')})"
+      end
+
+      alias args params
+      alias rcvr receiver
+
+      def set_receiver!(expr)
+        self[0]=expr
+      end
+
+      def parsetree_with_params
+        args=args()||[]
+        if (UnOpNode===args.last and args.last.ident=="&@")
+          lasti=args.size-2
+          unamp_expr=args.last.val
+        else
+          lasti=args.size-1
+        end
+        methodname= name
+        methodsym=methodname.to_sym
+        is_kw= RubyLexer::FUNCLIKE_KEYWORDS&~/^(BEGIN|END|raise)$/===methodname
+
+        result=
+        if lasti==-1
+          [(@not_real_parens and /[!?]$/!~methodname and !unamp_expr) ? 
+             :vcall : :fcall, methodsym
+          ]
+        elsif (UnaryStarNode===args[lasti])
+          if lasti.zero?
+            [:fcall, methodsym, args.first.rescue_parsetree]
+          else
+            [:fcall, methodsym, 
+             [:argscat, 
+               [:array, *args[0...lasti].map{|x| x.rescue_parsetree } ], 
+                  args[lasti].val.rescue_parsetree 
+             ]
+            ]
+          end         
+        else
+          singlearg= lasti.zero?&&args.first
+          [:fcall, methodsym, 
+           [:array, *args[0..lasti].map{|x| x.rescue_parsetree } ]
+          ]
+        end
+
+        result[0]=:vcall if block #and /\Af?call\Z/===result[0].to_s
+
+        if is_kw and !receiver
+          return [methodsym, singlearg.parsetree] if singlearg and "super"!=methodname
+          breaklike=  /^(break|next|return)$/===methodname
+          if @not_real_parens
+              return [:zsuper] if "super"==methodname and !args()
+          else
+              return [methodsym, [:nil]] if breaklike and args.size.zero?
+          end
+          result.shift 
+          arg=result[1]
+          result[1]=[:svalue,arg] if arg and arg[0]==:splat and breaklike
+        end
+
+        if receiver
+          result.shift if result.first==:vcall or result.first==:fcall #if not kw
+          result=[:call, receiver.rescue_parsetree, *result]
+        end
+
+        if unamp_expr
+#          result[0]=:fcall if lasti.zero?
+          result=[:block_pass, unamp_expr.rescue_parsetree, result]
+        end
+
+        return result
+      end
+
+      def parsetree
+        callsite=parsetree_with_params
+        return callsite unless blockparams or block
+        call=name
+        callsite[0]=:fcall  if callsite[0]==:call or callsite[0]==:vcall
+        unless receiver
+          case call
+          when "BEGIN": 
+            if quirks
+              return []
+            else
+              callsite=[:preexe] 
+            end
+          when "END": callsite=[:postexe]
+          end
+        else
+          callsite[0]=:call if callsite[0]==:fcall
+        end
+
+        if blockparams
+          bparams=blockparams.dup
+          lastparam=bparams.last
+          amped=bparams.pop.val if UnOpNode===lastparam and lastparam.op=="&@"
+          bparams=bparams.parsetree||0
+          if amped
+            bparams=[:masgn, [:array, bparams]] unless bparams==0 or bparams.first==:masgn
+            bparams=[:block_pass, amped.lvalue_parsetree, bparams]
+          end
+        else
+          bparams=nil
+        end
+        result=[:iter, callsite, bparams]
+        unless block.empty?
+          body=block.parsetree
+          if curr_vars=block.lvars_defined_in
+            curr_vars-=blockparams.all_current_lvars if blockparams
+            if curr_vars.empty?
+              result.push body
+            else
+              curr_vars.map!{|cv| [:dasgn_curr, cv.to_sym] }
+              (0...curr_vars.size-1).each{|i| curr_vars[i]<<curr_vars[i+1] }
+              #body.first==:block ? body.shift : body=[body]
+              result.push((body)) #.unshift curr_vars[0]))
+            end
+          else
+            result.push body
+          end
+        end 
+        result
+      end
+
+      def blockformals_parsetree data
+        data.empty? and return nil 
+        data=data.dup
+        star=data.pop if UnaryStarNode===data.last
+        result=data.map{|x| x.parsetree }
+=begin
+ {          if VarNameToken===x 
+            ident=x.ident
+            ty=x.varname2assigntype
+#            ty==:lasgn and ty=:dasgn_curr
+            [ty, ident.to_sym] 
+          else
+            x=x.parsetree
+            if x[0]==:call
+              x[0]=:attrasgn
+              x[2]="#{x[2]}=".to_sym
+            end
+            x
+          end
+        }
+=end
+        if result.size==0
+          star or fail
+          result=[:masgn, star.parsetree.last]
+        elsif result.size==1 and !star
+          result=result.first
+        else
+          result=[:masgn, [:array, *result]]
+          if star 
+            old=star= star.val
+            star=star.parsetree
+            if star[0]==:call
+              star[0]=:attrasgn
+              star[2]="#{star[2]}=".to_sym
+            end
+
+            if VarNameToken===old
+              ty=old.varname2assigntype
+#              ty==:lasgn and ty=:dasgn_curr
+              star[0]=ty
+            end
+            result.push star
+          end
+        end
+        result
+      end
+    end
+
+    class CallNode<CallSiteNode #normal method calls
+      def initialize(method,open_paren,param_list,close_paren,block)
+        MethNameToken===method or fail
+        super
+      end
+    end
+    class KWCallNode<CallSiteNode #keywords that look (more or less) like methods
+      def initialize(method,open_paren,param_list,close_paren,block)
+        KeywordToken===method or fail
+        super
+      end
+    end
+
+    class BlockFormalsNode<Node #obsolete
+      def initialize(goalpost1,param_list,goalpost2)
+        param_list or return super()
+        CommaOpNode===param_list and return super(*Array.new(param_list))
+        super(param_list)
+      end
+
+      def to_lisp
+        "(#{data.join' '})"
+      end
+
+      def parsetree
+        empty? ? nil :
+          [:dasgn_curr, 
+            *map{|x| 
+              VarNameToken===x ? x.ident.to_sym : x.parsetree
+            }
+          ]
+      end
+    end
+
+    class BlockNode<ValueNode #not to appear in final parse tree
+      param_names :params,:body
+      def initialize(open_brace,formals,stmts,close_brace)
+        case stmts
+        when SequenceNode: stmts=Array.new(stmts)
+        when nil: stmts=[]
+        else stmts=[stmts]
+        end
+        
+        formals&&=BlockParams.new(Array.new(formals))
+        @do_end=true unless open_brace.not_real?
+        super(formals,stmts)
+      end
+
+      attr_reader :do_end
+
+      def to_lisp
+        "(#{params.to_lisp} #{body.to_lisp})"
+      end
+
+      def parsetree #obsolete
+        callsite=@data[0].parsetree
+        call=@data[0].data[0]
+        callsite[0]=:fcall  if call.respond_to? :ident
+        if call.respond_to? :ident
+          case call.ident
+          when "BEGIN": 
+            if quirks
+              return []
+            else
+              callsite=[:preexe] 
+            end
+          when "END": callsite=[:postexe]
+          end
+        end
+        result=[:iter, callsite, @data[1].parsetree]
+        result.push @data[2].parsetree if @data[2]
+        result
+      end
+    end
+
+    class NopNode<ValueNode
+      def initialize(*args)
+        super()
+      end
+
+      def unparse o
+        ''      
+      end
+
+      def to_lisp
+        "()"
+      end
+
+      alias image to_lisp
+
+      def to_parsetree(*options)
+        []
+      end
+    end
+
+=begin
+    class ObjectNode<ValueNode
+      def initialize
+        super
+      end
+      def to_lisp
+        "Object"
+      end
+
+      def parsetree
+        :Object
+      end
+    end
+=end 
+
+    class CallWithBlockNode<ValueNode #obsolete
+      param_names :call,:block
+      def initialize(call,block)
+        KeywordCall===call and extend KeywordCall
+        super
+      end
+
+      def to_lisp
+        @data.first.to_lisp.chomp!(")")+" #{@data.last.to_lisp})"
+      end
+    end
+
+    class StringNode<ValueNode
+      def initialize(token)
+        if HerePlaceholderToken===token 
+          str=token.string
+          @char=token.quote
+        else
+          str=token
+          @char=str.char
+        end
+        @modifiers=str.modifiers #if str.modifiers
+        super *with_string_data(str)
+
+        if /[\[{]/===@char
+          @parses_like=split_into_words(str)
+        end
+
+        first=shift
+        delete_if{|x| ''==x }
+        unshift(first)
+        map!{|strfrag|
+          if String===strfrag
+            str.translate_escapes strfrag
+          else
+            strfrag
+          end
+        }
+        @open=token.open
+        @close=token.close
+      end
+
+      def old_cat_initialize(*tokens) #not needed anymore?
+        token=tokens.shift
+  
+        tokens.size==1 or fail "string node must be made from a single string token"
+
+        newdata=with_string_data(*tokens)
+
+        case token
+        when HereDocNode: 
+          token.list_to_append=newdata
+        when StringNode: #do nothing
+        else fail "non-string token class used to construct string node"
+        end
+        replace token.data
+
+#        size%2==1 and last<<newdata.shift
+        if size==1 and String===first and String===newdata.first
+          first << newdata.shift
+        end
+        concat newdata
+        
+        @implicit_match=false
+      end
+
+      ESCAPABLES={}
+      EVEN_NUM_BSLASHES=/(^|[^\\])((?:\\\\)*)/
+      def unparse o
+      
+        [@open,unparse_interior(o),@close,@modifiers].to_s  
+      end
+
+      def escapable open=@open,close=@close
+        unless escapable=ESCAPABLES[open]
+          maybe_crunch='#' if %r{\A["`/\{]\Z} === @char #"
+          #crunch (#) might need to be escaped too, depending on what @char is
+          escapable=ESCAPABLES[open]=
+            /[#{open[-1,1]+close}#{maybe_crunch}]/
+        end
+        escapable             
+      end
+
+      def unparse_interior o,open=@open,close=@close
+        escapable=escapable(open,close)
+        map{|substr|
+          if String===substr
+            substr.gsub! /\\+/ do 
+              result=$&*2 
+              result.chomp! '\\' if $&.size&1==1
+              result
+            end
+            substr.gsub! escapable do '\\'+$& end
+            substr
+          else
+            ['#{',substr.unparse(o),'}']
+          end
+        }
+      end
+
+      def image; '(#@char)' end
+
+      def delete_extraneous_ivars!
+        @parses_like.delete_extraneous_ivars! if @parses_like
+        return super
+      end
+
+      def special_conditions!
+        @implicit_match= @char=="/"
+      end
+
+      attr_reader :modifiers,:char#,:data
+      alias type char
+
+      def with_string_data(token)
+#        token=tokens.first
+
+#        data=tokens.inject([]){|sum,token|
+#          data=elems=token.string.elems
+          data=elems=
+            case token
+            when StringToken: token.elems
+            when HerePlaceholderToken: token.string.elems
+            else raise "unknown string token type: #{token}:#{token.class}"
+            end
+#          sum.size%2==1 and sum.last<<elems.shift
+#          sum+elems
+#        } 
+        1.step(data.length-1,2){|i|
+          tokens=data[i].ident.dup
+          (tokens.size-1).downto(0){|j| 
+             tok=tokens[j]
+             break(tokens[j..-1]=[EoiToken.new('',nil,tokens[j].offset)]) if tok.ident=='}' 
+          }
+          tokens.each_with_index{|tok,j| break(tokens.delete_at j) if tok.ident=='{' }
+          if tokens.size==1 and VarNameToken===tokens.first
+            data[i]=tokens.first
+          else
+            klass=Thread.current[:$RedParse_parser].class
+            data[i]=klass.new(tokens, "(string inclusion)").parse
+          end
+        } #if data
+#        was_nul_header= (String===data.first and data.first.empty?) #and quirks
+        last=data.size-1
+        last.downto(1){|frag_i| 
+          frag=data[frag_i]
+          String===frag or next
+          delete= frag.empty? 
+          next if frag_i==last #and quirks
+          next if data[frag_i-1].line != data[frag_i+1].line #and quirks
+                  #prev and next inclusions on different lines
+          data.slice!(frag_i) if delete
+        }
+#        data.unshift '' if was_nul_header
+        return data
+      end
+
+      def line= line
+        each{|frag| 
+          frag.line||=line if frag.respond_to? :line
+        }
+
+        super
+      end
+
+      def to_lisp
+        return %{"#{first}"} if size<=1 and @char=='"'
+        huh
+      end
+
+      def split_into_words strtok
+        return unless /[{\[]/===@char
+        result=ArrayLiteralNode[]
+        result << StringNode['',{:@char=>'"'}]
+        first[/\A(?:\s|\v)+/]='' if /\A(?:\s|\v)/===first
+        each{|x|
+          if String===x
+            double_chunks=x.split(/((?:(?:[^\\]|\A)(?:\\\\)+)|(?:[^\\\s\v]|\A))(?:\s|\v)+/,-1)
+            chunks=[]
+            (0..double_chunks.size).step(2){|i| 
+              chunks << strtok.translate_escapes(double_chunks[i,2].to_s)#.gsub(/\\([\s\v\\])/){$1}
+            }
+
+            chunk1= chunks.shift          
+            if chunk1.empty?
+              #do nothing more
+            elsif String===result.last.last
+              result.last.last << chunk1
+            else
+              result.last.push chunk1
+            end
+#            result.last.last.empty? and result.last.pop
+            result.concat chunks.map{|chunk| StringNode[chunk,{:@char=>'"'}]}
+          else
+            result.last << x
+          end
+        } 
+        result.shift if StringNode&-{:size=>1, :first=>''}===result.first
+        result.pop if StringNode&-{:size=>1, :first=>''}===result.last
+
+        return result
+      end
+
+      CHAROPT2NUM={
+        ?x=>Regexp::EXTENDED,
+        ?m=>Regexp::MULTILINE,
+        ?i=>Regexp::IGNORECASE,
+        ?o=>8,
+      }
+      CHARSETFLAG2NUM={
+        ?n=>0x10,
+        ?e=>0x20,
+        ?s=>0x30,
+        ?u=>0x40
+      }
+      CHAROPT2NUM.default=0
+      CHARSETFLAG2NUM.default=0
+      DOWNSHIFT_STRING_TYPE={
+        :dregx=>:lit,
+        :dregx_once=>:lit,
+        :dstr=>:str,
+        :dxstr=>:xstr,
+      }
+      def parsetree
+        if size==1
+          val=first
+          type=case @char
+               when '"',"'"; :str
+               when '/'
+                 numopts=0
+                 charset=0
+                 @modifiers.each_byte{|ch| 
+                   if ch==?o
+                     type=:dregx_once
+                   elsif numopt=CHAROPT2NUM[ch].nonzero?
+                     numopts|=numopt
+                   elsif set=CHARSETFLAG2NUM[ch].nonzero?
+                     charset=set
+                   else fail
+                   end
+                 }
+                 val=Regexp.new val,numopts|charset
+                 :lit
+               when '[','{'
+                 return @parses_like.parsetree
+
+                 double_chunks=val.split(/([^\\]|\A)(?:\s|\v)/,-1)
+                 chunks=[]
+                 (0..double_chunks.size).step(2){|i| 
+                   chunks << double_chunks[i,2].to_s.gsub(/\\(\s|\v)/){$1}
+                 }
+#                 last=chunks
+#                 last.last.empty? and last.pop if last and !last.empty?
+
+                 words=chunks#.flatten
+                 words.shift if words.first.empty? unless words.empty?
+                 words.pop if words.last.empty? unless words.empty?
+                 return [:zarray] if words.empty? 
+                 return words.map{|word| [:str,word]}.unshift(:array)
+               when '`'; :xstr
+               else raise "dunno what to do with #@char<StringToken"
+               end
+          result=[type,val]
+        else
+          saw_string=false
+          vals=[]
+          each{|elem| 
+            case elem
+            when String: 
+              if saw_string
+                result=[:str, elem]
+              else
+                saw_string=true
+                result=elem
+              end
+              vals.push result
+            when NopNode:
+              vals.push [:evstr]
+            when Node,VarNameToken:
+              res=elem.parsetree
+              if res.first==:str and @char != '{'
+                vals.push res
+              elsif res.first==:dstr and @char != '{'
+                vals.push [:str, res[1]], *res[2..-1]
+              else
+                vals.push [:evstr, res]
+              end
+            else fail "#{elem.class} not expected here"
+            end
+          }
+          while vals.size>1 and vals[1].first==:str
+            vals[0]<<vals.delete_at(1).last
+          end
+          #vals.pop if vals.last==[:str, ""]
+
+          type=case @char
+               when '"'; :dstr
+               when '/'
+                 type=:dregx
+                 numopts=charset=0
+                 @modifiers.each_byte{|ch| 
+                   if ch==?o
+                     type=:dregx_once
+                   elsif numopt=CHAROPT2NUM[ch].nonzero?
+                     numopts|=numopt
+                   elsif set=CHARSETFLAG2NUM[ch].nonzero?
+                     charset=set
+                   end
+                 }
+                 vals.push numopts|charset unless numopts|charset==0
+                 val=/#{val}/
+                 type
+               when '{': 
+                 return @parses_like.parsetree
+                 vals[0]=vals[0].sub(/\A(\s|\v)+/,'') if /\A(\s|\v)/===vals.first
+                 merged=Array.new(vals)
+                 result=[]
+                 merged.each{|i|
+                   if String===i
+                     next if /\A(?:\s|\v)+\Z/===i 
+                     double_chunks=i.split(/([^\\]|\A)(?:\s|\v)/,-1)
+                     chunks=[]
+                     (0..double_chunks.size).step(2){|ii| 
+                       chunks << double_chunks[ii,2].to_s.gsub(/\\(\s|\v)/){$1}
+                     }
+                     words=chunks.map{|word| [:str,word]}
+                     if !result.empty? and frag=words.shift and !frag.last.empty?
+                       result[-1]+=frag
+                     end
+                     result.push *words
+                   else
+                     result.push [:str,""] if result.empty?
+                     if i.first==:evstr and i.size>1 and i.last.first==:str
+                       if String===result.last[-1]
+                         result.last[-1]+=i.last.last
+                       else
+                         result.last[0]=:dstr
+                         result.last.push(i.last)
+                       end
+                     else
+                       result.last[0]=:dstr
+                       result.last.push(i)
+                     end
+                   end
+                 }
+                 return result.unshift(:array)
+               when '`'; :dxstr
+               else raise "dunno what to do with #@char<StringToken"
+               end
+
+          if vals.size==1
+            vals=[/#{vals[0]}/] if :dregx==type or :dregx_once==type
+            type=DOWNSHIFT_STRING_TYPE[type]
+          end
+          result= vals.unshift(type)
+        end
+        result=[:match, result] if defined? @implicit_match and @implicit_match
+        return result
+      end
+    end
+
+    class HereDocNode<StringNode
+      param_names :token
+      def initialize(token)
+        token.node=self
+        super(token)
+      end
+      attr_accessor :list_to_append
+#      attr :token
+
+      def saw_body!     #not used
+        replace with_string_data(token)
+        @char=token.quote
+        if @list_to_append
+          size%2==1 and token << @list_to_append.shift
+          push *@list_to_append
+          remove_instance_variable :@list_to_append
+        end
+      end
+
+
+      def flattened_ivars_equal?(other)
+        StringNode===other
+      end
+
+      def unparse o
+        [@char,(unparse_interior o,@char,@char),@char].to_s
+      end
+    end
+
+    class LiteralNode<ValueNode
+      param_names :val
+      attr_accessor :offset
+      def initialize(old_val)
+        @offset=old_val.offset
+        val=old_val.ident
+        case old_val
+        when SymbolToken: 
+          case val[1]
+          when ?': #'
+            assert !old_val.raw.has_str_inc?
+            val=old_val.raw.translate_escapes(old_val.raw.elems.first).to_sym
+            #val=eval(val[1..-1]).to_sym
+            #eval here is cheating!!!!
+            #too lazy to do it right just now
+          when ?": #"
+            if old_val.raw.has_str_inc?
+              val=StringNode.new(old_val.raw) #ugly hack: this isn't literal
+            else
+              val=old_val.raw.translate_escapes(old_val.raw.elems.first).to_sym
+              #val=eval(val[1..-1]).to_sym
+              #eval here is cheating!!!!
+              #too lazy to do it right just now
+            end
+          else #val=val[1..-1].to_sym
+            if StringToken===old_val.raw
+              val=old_val.raw.translate_escapes(old_val.raw.elems.first).to_sym
+            else
+              val=old_val.raw.to_sym
+            end
+          end
+        when NumberToken: 
+          case val
+          when /\A-?0([^.]|\Z)/: val=val.oct
+          when /[.e]/i: val=val.to_f
+          else val=val.to_i
+          end
+        end
+        super(val)
+      end
+
+      def image; "(#{':' if Symbol===val}#{val})" end
+
+      def to_lisp
+        return val.to_s
+      end
+
+      Inf="999999999999999999999999999999999.9e999999999999999999999999999999999999"
+      Nan="****shouldnt ever happen****"
+
+      def unparse o
+        val=val()
+        case val 
+        when StringNode #ugly hack
+          ":"+
+            val.unparse(o)
+        when Float
+          s= "%#{Float::DIG}.#{Float::DIG}f"%val
+          case s
+          when /-inf/i: s="-"+Inf
+          when /inf/i:  s=    Inf
+          when /nan/i:  s=    Nan
+          else
+            fail unless [s.to_f].pack("d")==[val].pack("d")
+          end
+          s
+        else val.inspect
+        end
+      end
+
+      def parsetree
+        val=val()
+        case val 
+        when StringNode #ugly hack
+          result= val.parsetree
+          result[0]=:dsym
+          return result
+=begin
+        when String 
+          #float or real string? or keyword?
+          val=
+          case val
+          when Numeric: val
+          when Symbol: val
+          when String: val
+          when "true": true
+          when "false": false
+          when "nil": nil
+          when "self": return :self
+          when "__FILE__": "wrong-o"
+          when "__LINE__": "wrong-o"
+          else fail "unknown token type in LiteralNode: #{val.class}"
+          end
+=end
+        end
+        return [:lit,val]
+      end
+    end
+
+    class VarLikeNode<ValueNode #nil,false,true,__FILE__,__LINE__,self
+      param_names :name
+      def initialize(name,*more)
+        if name.ident=='(' 
+          #simulate nil
+          replace ['nil']
+        else
+          replace [name.ident]
+          @value=name.respond_to?(:value) && name.value
+        end
+      end
+
+      alias ident name
+      
+      def image; "(#{name})" end
+ 
+      def to_lisp
+        name
+      end
+
+      def unparse o
+        name      
+      end
+
+      def parsetree
+        if @value
+          type=:lit
+          val=@value
+          if name=="__FILE__"
+            type=:str
+            val="(string)" if val=="-"
+          end
+          [type,val]
+        else
+          [name.to_sym]
+        end
+      end
+    end
+
+    class ArrayLiteralNode<ValueNode
+      def initialize(lbrack,contents,rbrack)
+        contents or return super()
+        if CommaOpNode===contents
+          super *contents
+        else
+          super contents
+        end
+      end
+
+      def image; "([])" end
+
+      def unparse o
+        "["+map{|item| item.unparse o}.join(', ')+"]"
+      end
+
+      def parsetree
+        size.zero? and return [:zarray]
+        normals,star,amp=param_list_parse(self)
+        result=normals.unshift :array
+        if star
+          if size==1
+            result=star
+          else
+            result=[:argscat, result, star.last] 
+          end
+        end
+        result
+      end
+
+    end
+    #ArrayNode=ValueNode
+
+    class BracketsSetNode < ValueNode #obsolete
+      param_names :left,:assign_,:right
+      def parsetree
+        [:attrasgn, left.data[0].parsetree, :[]=, 
+         [:array]+Array(left.data[1]).map{|x| x.parsetree}<< right.parsetree
+        ]
+      end
+    end
+
+    class BracketsModifyNode < ValueNode #obsolete
+      param_names :left,:assignop,:right
+      def initialize(left,assignop,right)
+        super
+      end
+
+      def parsetree
+        bracketargs=@data[0].data[1]
+        bracketargs=bracketargs ? bracketargs.map{|x| x.parsetree}.unshift(:array) : [:zarray]
+        [:op_asgn1, @data[0].data[0].parsetree, bracketargs, 
+         data[1].ident.chomp('=').to_sym, data[2].parsetree]
+      end
+    end
+
+    class IfNode < ValueNode
+      param_names :condition,:consequent,:elsifs,:otherwise
+      def initialize(iftok,condition,thentok,consequent,elsifs,else_,endtok)
+        if else_ 
+          else_=else_.val or @empty_else=true
+        end
+        condition.special_conditions! if condition.respond_to? :special_conditions!
+        super(condition,consequent,elsifs,else_)
+        @reverse=  iftok.ident=="unless"
+        if @reverse
+          @iftok_offset=iftok.offset
+          fail "elsif not allowed with unless" unless elsifs.empty?
+        end
+      end
+      alias if condition
+      alias then consequent
+      alias else otherwise
+      alias else_ else
+      alias if_ if
+      alias then_ then
+
+      attr_reader :empty_else
+
+      def unparse o
+        result=@reverse ? "unless " : "if "
+        result+="#{condition.unparse o}\n"
+        result+="#{consequent.unparse(o)}\n" if consequent
+        result+=elsifs.map{|n| n.unparse(o)}.to_s if elsifs
+        result+="else "+else_.unparse(o)+"\n" if else_
+        result+="end"
+        return result
+      end
+
+      def image; "(if)" end
+
+      def if
+        if @reverse
+          negate condition, @iftok_offset
+        else
+          condition
+        end
+      end
+
+      def then
+        @reverse ? otherwise : consequent
+      end
+
+      def else
+        @reverse ? consequent : otherwise
+      end
+
+      def to_lisp
+        if elsifs.empty? 
+          "(#{@reverse ? :unless : :if} #{condition.to_lisp}\n"+
+          "(then #{consequent.to_lisp})\n(else #{otherwise.to_lisp}))"
+        else
+          "(cond (#{condition.to_lisp} #{consequent.to_lisp})\n"+
+                elsifs.map{|x| x.to_lisp}.join("\n")+
+                "\n(else #{otherwise.to_lisp})"+
+          "\n)"
+        end
+      end
+ 
+      def parsetree
+        elsepart=otherwise.parsetree if otherwise
+        elsifs.reverse_each{|elsifnode|
+          elsepart=elsifnode.parsetree << elsepart
+        }
+        cond=condition.rescue_parsetree
+        actions=[
+              consequent&&consequent.parsetree, 
+              elsepart
+        ]
+        if cond.first==:not
+          cond=cond.last
+          reverse=!@reverse
+        else
+          reverse=@reverse
+        end
+        actions.reverse! if reverse
+        result=[:if, cond, *actions]
+        return result
+      end
+    end
+
+    class ElseNode<Node #not to appear in final tree
+      param_names :elseword_,:val
+      alias body val
+
+      def image; "(else)" end
+
+      def to_lisp
+        "(else #{body.to_lisp})"
+      end
+    end
+
+    class EnsureNode<Node #not to appear in final tree
+      param_names :ensureword_, :val
+      alias body val
+      def image; "(ensure)" end
+      def parsetree #obsolete?
+        (body=body()) ? body.parsetree : [:nil]
+      end
+    end
+
+    class ElsifNode<Node
+      param_names(:elsifword_,:condition,:thenword_,:consequent)
+      def initialize(elsifword,condition,thenword,consequent)
+        condition.special_conditions! if condition.respond_to? :special_conditions!
+        super(condition,consequent)
+      end
+
+      alias if condition
+      alias elsif if
+      alias then consequent
+
+      def image; "(elsif)" end
+
+      def unparse o
+        "elsif #{condition.unparse o}\n#{consequent.unparse o}\n"
+      end
+
+      def to_lisp
+        "("+condition.to_lisp+" "+consequent.to_lisp+")"
+      end
+
+      def parsetree #obsolete?
+        [:if, condition.rescue_parsetree, consequent&&consequent.parsetree, ]
+      end
+    end
+
+    class LoopNode<ValueNode
+      #this class should be abstract and have 2 concrete descendants for while and until
+      param_names :condition, :body
+      def initialize(loopword,condition,thenword,body,endtok)
+        condition.special_conditions! if condition.respond_to? :special_conditions!
+        super(condition,body)
+        @reverse=  loopword.ident=="until"
+        @loopword_offset=loopword.offset
+      end
+
+      alias do body
+
+      def image; "(#{loopword})" end
+
+      def unparse o
+        [@reverse? "until " : "while ",
+         condition.unparse(o), "\n",
+         body&&body.unparse(o),
+         "\nend"
+        ].to_s
+      end
+
+      def while
+        @reverse ? negate(condition, @loopword_offset) : condition
+      end
+
+      def until
+        @reverse ? condition : negate(condition, @loopword_offset)
+      end
+
+      def to_lisp
+        body=body()
+        "(#{@reverse ? :until : :while} #{condition.to_lisp}\n#{body.to_lisp})"
+      end
+
+      def parsetree
+        cond=condition.rescue_parsetree
+        if cond.first==:not
+          reverse=!@reverse
+          cond=cond.last
+        else
+          reverse=@reverse
+        end 
+        [reverse ? :until : :while, cond, body&&body.parsetree, true]
+      end
+    end
+
+    class CaseNode<ValueNode
+      param_names(:case!,:whens,:else!)
+      alias condition case
+      alias otherwise else
+
+      def initialize(caseword, condition, semi, whens, otherwise, endword)
+        if otherwise
+          otherwise=otherwise.val or @empty_else=true
+        end
+        super(condition,whens,otherwise)
+      end
+
+      attr_reader :empty_else
+
+      def unparse o
+        result="case #{condition&&condition.unparse(o)}\n"+
+               whens.map{|wh| wh.unparse o}.to_s
+
+        result += "else "+otherwise.unparse(o)+"\n" if otherwise
+        result += "end"
+
+        return result
+      end
+
+      def image; "(case)" end
+
+      def to_lisp
+        "(case #{case_.to_lisp}\n"+
+          whens.map{|x| x.to_lisp}.join("\n")+"\n"+
+          "(else #{else_.to_lisp}"+
+        "\n)"
+      end
+  
+      def parsetree
+        [:case, condition&&condition.parsetree]+ 
+           whens.map{|whennode| whennode.parsetree}+
+        [otherwise&&otherwise.parsetree]
+      end
+    end
+
+    class WhenNode<Node #not to appear in final tree?
+      param_names(:whenword_,:when!,:thenword_,:then!)
+      def initialize(whenword,when_,thenword,then_)
+        when_=Array.new(when_) if CommaOpNode===when_
+        super(when_,then_)
+      end
+      alias body then
+      alias consequent then
+      alias condition when
+
+      def image; "(when)" end
+
+      def unparse o
+        result="when "
+        result+=condition.class==Array ? 
+                  condition.map{|cond| cond.unparse(o)}.join(',') : 
+                  condition.unparse(o) 
+        result+="\n"
+        result+=consequent.unparse(o)+"\n" if consequent
+        result
+      end
+
+      def to_lisp
+        unless Node|Token===condition
+          "(when (#{condition.map{|cond| cond.to_lisp}.join(" ")}) #{
+            consequent&&consequent.to_lisp
+          })"
+        else
+          "(#{when_.to_lisp} #{then_.to_lisp})"
+        end
+        
+
+      end
+
+      def parsetree
+        conds=
+          if Node|Token===condition
+            [condition.rescue_parsetree]
+          else
+            condition.map{|cond| cond.rescue_parsetree}
+          end
+        if conds.last[0]==:splat
+          conds.last[0]=:when
+          conds.last.push nil
+        end
+        [:when, [:array, *conds],
+          consequent&&consequent.parsetree
+        ]
+      end
+    end
+
+    class ForNode<ValueNode
+      param_names(:forword_,:for!,:inword_,:in!,:doword_,:do!,:endword_)
+      def initialize(forword,for_,inword,in_,doword,do_,endword)
+        #elide 1 layer of parens if present
+        for_=for_.first if ParenedNode===for_ and for_.size==1
+        for_=CommaOpNode===for_ ? Array.new(for_) : [for_]
+        super(BlockParams.new(for_),in_,do_)
+      end
+
+      alias body do
+      alias enumerable in
+      alias iterator for
+
+      def image; "(for)" end
+
+      def unparse o
+        "
+         for #{iterator.lhs_unparse(o)[1...-1]} in #{enumerable.unparse o}
+           #{body&&body.unparse(o)}
+         end"
+      end
+
+      def parsetree
+=begin
+        case vars=@data[0]
+        when Node: 
+          vars=vars.parsetree
+          if vars.first==:call
+            vars[0]=:attrasgn
+            vars[2]="#{vars[2]}=".to_sym
+          end
+          vars
+        when Array: 
+          vars=[:masgn, [:array, 
+                  *vars.map{|lval| 
+                     res=lval.parsetree
+                     res[0]=lval.varname2assigntype if VarNameToken===lval
+                     res
+                   } 
+               ]]
+        when VarNameToken: 
+          ident=vars.ident
+          vars=vars.parsetree
+          (vars[0]=vars.varname2assigntype) rescue nil
+        else fail
+        end
+=end
+
+        vars=self.for.lvalue_parsetree
+        result=[:for, self.in.begin_parsetree, vars]
+        result.push self.do.parsetree if self.do
+        result
+      end
+
+    end
+
+
+    class HashLiteralNode<ValueNode
+      def initialize(open,contents,close)
+        case contents
+        when nil: super()
+        when ArrowOpNode: super(contents.first,contents.last)
+        when CommaOpNode,Array
+          if ArrowOpNode===contents.first
+            data=[]
+            contents.each{|pair|
+              ArrowOpNode===pair or fail
+              data.push pair.first,pair.last
+            }
+          else
+            data=Array[*contents]
+          end
+          super(*data)
+        end
+        @no_braces=true unless open
+      end
+
+      def image; "({})" end
+
+      def unparse o
+        result=''
+        result << "{" unless @no_braces
+        (0...size).step(2){|i| 
+          result<<
+            self[i].unparse(o)+' => '+
+            self[i+1].unparse(o)+', '
+        }
+        result.chomp! ', '
+        result << "}" unless @no_braces
+        return result
+      end
+
+      def parsetree
+        map{|elem| elem.rescue_parsetree}.unshift :hash
+      end
+    end
+
+    class TernaryNode<ValueNode
+      param_names :if!,:qm_,:then!,:colon_,:else!
+      alias condition if
+      alias consequent then
+      alias otherwise else
+      def initialize(if_,qm,then_,colon,else_)
+        super(if_,then_,else_)
+        condition.special_conditions! if condition.respond_to? :special_conditions!
+      end
+
+      def image; "(?:)" end
+
+      def unparse o
+        "#{condition.unparse o} ? #{consequent.unparse o} : #{otherwise.unparse o}"      
+      end
+
+      def elsifs; [] end
+
+      def parsetree
+        cond=condition.rescue_parsetree
+        cond[0]=:fcall if cond[0]==:vcall and cond[1].to_s[/[?!]$/]
+        [:if, cond, consequent.begin_parsetree, otherwise.begin_parsetree]
+      end
+    end
+
+    class MethodNode<ValueNode
+      param_names(:defword_,:receiver,:name,:maybe_eq_,:args,:semi_,:body,:rescues,:elses,:ensures,:endword_)
+      alias ensure_ ensures
+      alias else_ elses
+      alias ensure ensures
+      alias else elses
+      alias params args
+      
+      def initialize(defword_,header,maybe_eq_,semi_,
+                     body,rescues,else_,ensure_,endword_)
+        @empty_ensure=nil
+#        if DotCallNode===header
+#          header=header.data[1]
+#        end
+        if CallSiteNode===header
+          receiver=header.receiver
+          args=header.args
+          header=header.name
+        end
+        if MethNameToken===header
+          header=header.ident 
+        end
+        unless String===header
+          fail "unrecognized method header: #{header}"
+        end
+        if else_
+          else_=else_.val  or @empty_else=true
+        end
+        if ensure_
+          ensure_=ensure_.val or @empty_ensure=true
+        end
+        replace [receiver,header,args,body,rescues,else_,ensure_]
+      end
+
+      attr_reader :empty_ensure, :empty_else
+
+      def receiver= x
+        self[0]=x      
+      end
+
+      def body= x
+        self[3]=x      
+      end
+
+      def ensure_= x
+        self[5]=x      
+      end
+
+      def else_= x
+        self[6]=x      
+      end
+
+      def image
+        "(def #{receiver.image.+('.') if receiver}#{name})"
+      end
+
+      def unparse o
+        result="
+         def #{receiver&&receiver.unparse(o)+'.'}#{name}#{
+           args&&'('+args.map{|arg| arg.unparse o}.join(',')+')'
+        }
+           #{body&&body.unparse(o)}
+        "
+        result+=rescues.map{|resc| resc.unparse o}.to_s 
+        result+="else #{else_.unparse o}\n"  if else_
+        result+="ensure #{ensure_.unparse o}\n"  if ensure_
+        result+="end"
+      end
+
+      def to_lisp
+        "(imethod #{name} is\n#{body.to_lisp}\n)\n"
+        #no receiver, args, rescues, else_ or ensure_...
+      end
+
+      def parsetree
+        name=name().to_sym
+
+        result=[name, target=[:scope, [:block, ]] ]
+        if receiver
+          result.unshift :defs, receiver.rescue_parsetree
+        else
+          result.unshift :defn
+        end
+
+        goodies= (body or !rescues.empty? or elses or ensures or @empty_ensure) # or args())
+
+        if unamp=args() and unamp=unamp.last and UnOpNode===unamp and unamp.op=="&@"
+          receiver and goodies=true
+        else 
+          unamp=false
+        end
+
+        if receiver and !goodies
+          target.delete_at 1 #omit :block
+        else
+          target=target[1]
+        end
+
+        target.push args=[:args,]
+        target.push unamp.parsetree if unamp
+
+        if args()
+          initvals=[]
+          args().each{|arg| 
+              case arg
+                  when VarNameToken:
+                    args.push arg.ident.to_sym
+                  when UnaryStarNode:
+                    args.push "*#{arg.val.ident}".to_sym
+                  when UnOpNode:
+                    nil
+                  when AssignNode:
+                    initvals << arg.parsetree
+                    initvals[-1][-1]=arg.right.rescue_parsetree #ugly
+                    args.push arg[0].ident.to_sym
+                  else 
+                    fail "unsupported node type in method param list: #{arg}"
+              end
+          }
+          unless initvals.empty?
+            initvals.unshift(:block) 
+            args << initvals
+            args[-2][0]==:block_arg and target.push args.delete_at(-2)
+          end
+        end
+        target.push [:nil] if !goodies && !receiver
+        target.push ensuretarget=target=[:ensure, ] if ensures or @empty_ensure
+        #simple dup won't work... won't copy extend'd modules
+        body=Marshal.load(Marshal.dump(body())) if body()
+        elses=elses()
+        if rescues.empty?
+          case body
+          when SequenceNode: body << elses;elses=nil 
+          when nil: body=elses;elses=nil
+          else nil
+          end if elses
+        else
+          target.push target=[:rescue, ] 
+          elses=elses()
+        end
+        if body
+          if ParenedNode===body and body.size>1 and 
+            body.rescues.empty? and !body.ensure and !body.empty_ensure and body.body and body.body.size>1
+              wantblock=true
+          end
+          body=body.parsetree
+          if body.first==:block and rescues.empty? and not ensures||@empty_ensure
+            if wantblock
+              target.push body
+            else
+              body.shift 
+              target.concat body
+            end
+          else
+            body=[:block, *body] if wantblock
+            target.push body
+          end
+        end
+        target.push linked_list(rescues.map{|rescue_| rescue_.parsetree }) unless rescues.empty?
+        target.push elses.parsetree if elses
+        ensuretarget.push ensures.parsetree if ensures
+        ensuretarget.push [:nil] if @empty_ensure
+
+        return result
+      end
+    end
+
+    module BareSymbolUtils
+      def baresym2str(node)
+        case node
+        when MethNameToken:  node.ident
+        when VarNameToken: node
+        when LiteralNode: 
+          case node.val
+          when Symbol: 
+            node.val.to_s
+          when StringNode: node.val
+#          when StringToken: StringNode.new(node.val)
+          else fail
+          end
+        end
+      end
+
+      def str_unparse(str,o)
+       case str
+       when VarNameToken: str.ident
+       when String: 
+         str.to_sym.inspect
+         #what if str isn't a valid method or operator name? should be quoted
+       when StringNode: 
+         ":"+str.unparse(o)
+       else fail
+       end
+      end
+
+      def str2parsetree(str)
+       if String===str then [:lit, str.to_sym] 
+       else 
+         result=str.parsetree
+         result[0]=:dsym
+         result
+       end
+      end
+    end
+
+    class AliasNode < ValueNode
+      include BareSymbolUtils
+      param_names(:aliasword_,:to,:from)
+      def initialize(aliasword,to,from)
+        to=baresym2str(to)
+        from=baresym2str(from)
+        super(to,from)
+      end
+
+      def unparse o
+        "alias #{str_unparse to,o} #{str_unparse from,o}"      
+      end
+
+      def image; "(alias)" end
+      def parsetree
+        if VarNameToken===to and to.ident[0]==?$
+          [:valias, to.ident.to_sym, from.ident.to_sym]
+        else
+          [:alias, str2parsetree(to), str2parsetree(from)]
+        end
+      end
+    end
+
+    class UndefNode < ValueNode
+      include BareSymbolUtils
+      def initialize(first,middle,last=nil)
+        if last
+          node,newsym=first,last
+          super(*node << baresym2str(newsym))
+        else
+          super(baresym2str(middle))
+        end
+      end
+
+      def image; "(undef)" end
+
+      def unparse o
+        "undef #{map{|name| str_unparse name,o}.join(', ')}"
+      end
+
+      def parsetree
+        result=map{|name| [:undef, str2parsetree(name)] }
+        if result.size==1
+          result.first
+        else
+          result.unshift :block 
+        end
+      end
+    end
+
+    class NamespaceNode<ValueNode
+    end
+ 
+    class ModuleNode<NamespaceNode
+      param_names(:moduleword_,:name,:semi_,:body,:endword_)
+
+      def image; "(module #{name})" end
+
+      def unparse o
+        "module #{name.unparse o}\n#{body&&body.unparse(o)}\nend"
+      end
+
+      def parent; nil end
+      def to_lisp
+        result="(#{name.ident} #{body.to_lisp} "
+        #parent=@data[2]
+        #result+="is #{parent.to_lisp} " if parent
+       
+        result+="\n"+body.to_lisp+")"
+        return result
+      end
+
+      def parsetree
+        name=name()
+        if VarNameToken===name
+          name=name.ident.to_sym
+        elsif name.nil? #do nothing
+#        elsif quirks
+#          name=name.constant.ident.to_sym
+        else 
+          name=name.parsetree
+        end
+        result=[:module, name, scope=[:scope, ]]
+        body&&scope << body.parsetree
+        return result
+      end
+    end
+
+    class ClassNode<NamespaceNode
+      param_names(:name,:parent,:body)
+      def initialize(classword,name,semi,body,endword)
+        if OpNode===name
+          name,op,parent=*name
+          op=="<" or fail "invalid superclass expression: #{name}"
+        end
+        super(name,parent,body)
+      end
+
+      def image; "(class #{name})" end
+
+      def unparse o
+        result="class #{name.unparse o}"
+        result+=" < #{parent.unparse o}" if parent
+        result+="\n#{body&&body.unparse(o)}\nend"
+        return result
+      end
+
+      def to_lisp
+        result="(class #{name.to_lisp} "
+        result+="is #{parent.to_lisp} " if parent
+       
+        result+="\n"+body.to_lisp+")"
+        return result
+      end
+
+      def parsetree
+        name=name()
+        if VarNameToken===name
+          name=name.ident.to_sym
+        elsif name.nil? #do nothing
+#        elsif quirks
+#          name=name.constant.ident.to_sym
+        else 
+          name=name.parsetree
+        end
+        result=[:class, name, parent&&parent.parsetree, scope=[:scope,]]
+        body&&scope << body.parsetree
+        return result
+      end
+    end
+
+    class MetaClassNode<NamespaceNode
+      param_names :classword_, :leftleft_, :val, :semi_, :body, :endword_
+      alias expr val
+      alias object val
+      alias obj val
+      alias receiver val
+      alias name val
+
+      def image; "(class<<)" end
+
+      def unparse o
+        "class << #{obj.unparse o}\n#{body&&body.unparse(o)}\nend"
+      end
+
+      def parsetree
+        result=[:sclass, expr.parsetree, scope=[:scope]]
+        body&&scope << body.parsetree
+        return result
+      end
+    end
+
+    class RescueHeaderNode<Node  #not to appear in final tree
+      param_names :exceptions,:varname
+      def initialize(rescueword,arrowword,exceptions,thenword)
+        case exceptions
+        when nil
+        when VarNameToken:
+          if arrowword
+            exvarname=exceptions
+            exceptions=nil
+            arrowword=nil
+          end
+        when ArrowOpNode: 
+          exvarname=exceptions.last
+          exceptions=exceptions.first
+        when CommaOpNode
+          lastexpr=exceptions.last
+          if ArrowOpNode===lastexpr
+            exceptions[-1]=lastexpr.left
+            exvarname=lastexpr.right
+          end
+          exceptions=Array.new(exceptions)
+        end
+        fail if arrowword
+#        fail unless VarNameToken===exvarname || exvarname.nil?
+        super(exceptions,exvarname)
+      end
+
+      def image; "(rescue=>)" end
+    end
+
+    class RescueNode<Node
+      param_names :exceptions,:varname,:action
+      def initialize(rescuehdr,action,semi)
+        exlist=rescuehdr.exceptions||[]
+        exlist=[exlist] unless exlist.class==Array
+        fail unless exlist.class==Array
+        super(exlist,rescuehdr.varname,action)
+      end
+
+      def unparse o
+        xx=exceptions.map{|exc| exc.unparse o}.join(',')
+        "rescue #{xx} #{varname&&'=> '+varname.lhs_unparse(o)}\n#{action&&action.unparse(o)}\n"
+      end
+
+      def parsetree
+        result=[:resbody, nil]
+        fail unless exceptions.class==Array
+        ex=#if Node===exceptions; [exceptions.rescue_parsetree] 
+           #elsif exceptions
+             exceptions.map{|exc| exc.rescue_parsetree} 
+           #end
+        if !ex or ex.empty? #do nothing
+        elsif ex.last.first!=:splat
+          result[1]= [:array, *ex]
+        elsif ex.size==1
+          result[1]= ex.first
+        else
+          result[1]= [:argscat, ex[0...-1].unshift(:array), ex.last[1]]
+        end
+        VarNameToken===varname and offset=varname.offset
+        action=if varname
+          SequenceNode.new(
+            AssignNode.new( 
+              varname, 
+              KeywordToken.new("=",offset),
+              VarNameToken.new("$!",offset)
+            ),nil,action()
+          )
+        else
+          action()
+        end
+        result.push action.parsetree if action
+        result
+      end
+
+      def image; "(rescue)" end
+    end
+
+    class BracketsGetNode<ValueNode
+      param_names(:receiver,:lbrack_,:params,:rbrack_)
+      def initialize(receiver,lbrack,params,rbrack)
+        params=case params
+        when CommaOpNode: Array.new params
+        when nil:
+        else [params]
+        end
+        super(receiver,params)
+      end
+
+      def image; "(#{receiver.image}.[])" end
+
+      def unparse o
+        [ receiver.unparse(o).sub(/\s+\Z/,''),
+          '[',
+          params&&params.map{|param| param.unparse o}.join(','),
+          ']'
+        ].to_s
+      end
+
+      def parsetree
+        result=parsetree_no_fcall
+        quirks and VarLikeNode===receiver and receiver.name=='self' and
+          result[0..2]=[:fcall,:[]] 
+        return result
+      end
+
+      def parsetree_no_fcall
+        params=params()
+        output,star,amp=param_list_parse(params)
+#        receiver=receiver.parsetree
+        result=[:call, receiver.parsetree, :[], output]
+        if params
+          if star and params.size==1
+            output.concat star
+          else
+            output.unshift :array 
+            result[-1]=[:argscat, output, star.last] if star
+          end
+        else
+          result.pop
+        end
+        return result
+      end
+      def lvalue_parsetree
+        result=parsetree_no_fcall
+        result[0]=:attrasgn
+        result[2]=:[]=
+        result
+      end
+
+      def lvalue?
+        return @lvalue if defined? @lvalue
+        @lvalue=true
+      end
+      attr_accessor :lvalue
+    end
+
+
+    class StartNode<Node  #not to appear in final tree
+      def initialize; end
+
+      def image; "(START)" end
+    end #beginning of input marker
+
+    class GoalPostNode<Node  #not to appear in final tree
+      def initialize(offset); @offset=offset end
+      def ident; "|" end
+      attr :offset
+
+      def image; "|" end
+    end
+
+    module ErrorNode
+      #pass the buck to child ErrorNodes until there's no one else
+      def blame
+        middle.each{|node| 
+          node.respond_to? :blame and return node.blame 
+        }
+        return self
+      end
+ 
+
+      #def msg; ... end
+    end
+
+
+    class MisparsedNode<ValueNode
+      include ErrorNode
+      param_names :open,:middle,:close_
+      alias begin open
+      alias what open
+
+      def image; "misparsed #{what}" end
+
+      def msg
+        "#@line: misparsed #{what}: #{middle.map{|node| node&&node.image}.join(' ')}" 
+      end
+    end
+
+#  end
+
+end
+=begin a (formal?) description
+  NodeMatcher=
+    Recursive(nodematcher={},
+      Node&-{:subnodes=>NodeList = 
+               Recursive(nodelist={},
+                 +[(nodematcher|nodelist|nil).*])
+            }
+
+  #Nodes can also have attributes which don't appear in subnodes
+  #this is where ordinary values (symbols, strings, numbers, true/false/nil) are kept
+=end