Contents

module TlaParserS

  
  module LValue

    # default implmentation for 'recurse_lvalue' when no block: create expression
    #
    def default_lvalue( memo, node )
      case node.node_type
      when  "LValue"
      # when 'Identifier', "LValue"        
      memo = node.lvalue
      # when 'RecordField'
      #   memo = memo ? "#{memo}.#{node.lvalue}" : node.lvalue
      # when 'RecordFieldName'
      #   memo = memo ? "#{memo}[#{node.lvalue}]" : node.lvalue
      when 'UnitExpression'
      # no output - just recurs
      when 'FieldByName'
        memo = "#{memo}.#{node.lvalue}"
      when 'FieldByValue'
        memo = "#{memo}[#{node.lvalue}]"        
      else
        raise "Lvalue recursion, parser error unkown node_type #{node_type} #{node.inspect}" 
      end
      memo
    end # recurs

    # @return [String] lvalue
    def lvalue
      # n = recursive_select( SbuilderSexp::Root ).first
      # return nil unless n
      recursive_select( SbuilderSexp::Identifier ).first.node_value
    end
    

    # Recurse down 'RecordField' structure and create string for
    # lvalue or yield block with 'ret' and 'node'.
    # 
    # @param ret [Object|String] to create in recursion
    # @return [String] like A, A.b, A[c], A[d].e
    def recurse_lvalue( ret=nil, &blk )
      if ( blk )
        ret = yield( ret, self )
      else
        ret = default_lvalue( ret, self )
      end
      ret = lvalue_down.recurse_lvalue( ret, &blk ) if lvalue_down
      ret
      
    end

    # Eac lvalue should implement something like this:
    # # @return [nil|RecordField] down next level in hierarchy
    # def lvalue_down
    #   down = recursive_select( Sexp::RecordField ).first
    #   return nil unless down
    #   down.recursive_select( Sexp::RecordField ).first
    # end
    
    
  end
end

Version data entries

2 entries across 2 versions & 1 rubygems

Version	Path
tla-parser-s-0.2.5	lib/parser/lvalue.rb
tla-parser-s-0.2.2	lib/parser/lvalue.rb