sbuilder-ethereum 0.0.6

data/lib/sbuilder/load.rb

@@ -0,0 +1,119 @@
+require 'json'
+
+
+module Sbuilder
+  module Ethereum
+
+
+    class Load
+      
+      PROGNAME = nil       # progname for logger default class name
+      include MyLogger     # mix logger
+      
+
+      def initialize( options = {} )
+        
+        @options = options
+        @logger = getLogger( nil, options )
+        @logger.info "#{__method__}: initalized"
+
+
+      end
+      
+
+      # ------------------------------------------------------------------
+      # @!group Access solc AST for solidity source
+
+      # @param [String] solcAstPath path JSON file containing solc
+      # combined-AST
+      #
+      # @yield [SexpAst, compileUnit] ast process, string identifying
+      # ast (source+counter)
+      #
+      def processAllAsts( solcAstPath )
+        @logger.info "#{__method__}: solcAstPath=#{solcAstPath}"
+        solcHash = solc_input( solcAstPath )
+
+        solcHash['sourceList'].each do |solSource|
+          hashes = solcHash['sources'][solSource]['AST']
+          @logger.debug "#{__method__}: hash.keys=#{hashes.keys}" if @logger.debug?
+          hashes["children"].each_with_index do |ast,indx|
+            astName = "#{solSource}-#{indx}"
+            sourceUnit = SourceUnit.define( astName, SexpAst.build_sexp(ast) )
+            yield sourceUnit, astName
+          end
+        end
+      end
+      
+
+      # Read solidyty source in +solcAstPath+, and  
+      #
+      # @param [String] solcAstPath path JSON file containing solc
+      # combined-AST
+      #
+      # @param [Integer] index to contract to compile
+      #
+      # @return [SexpAst] sexp ast for solc json AST in {solc_hash},
+      # nil
+      def load_solc_ast_as_sexp( solcAstPath, index=0 )
+
+        @logger.info "#{__method__}: solcAstPath=#{solcAstPath}"
+        # read result of solc compiler
+        solcHash = solc_input( solcAstPath )
+        @logger.debug "#{__method__}: solcHash=#{solcHash.to_yaml}"  if @logger.debug?
+
+        # extract AST from the result of solc compiler
+        solcSexpAst = solc_ast( solcHash, index )
+
+        solcSexpAst
+        
+      end
+
+
+      #
+      # @param [String] solcAstPath path to solidity source file
+      #
+      # @return [hash] cached '@solcHash' parsed from JSON file in
+      # {solcAstPath} containing the AST from solc compilation
+      def solc_input( solcAstPath )
+        return @solcHash unless @solcHash.nil?
+        str = readSolc( solcAstPath )
+        @solcHash = JSON.parse( str )
+      end
+
+      # Read AST JSON string created by solc compiler for compiling
+      # solidity source in file {solcAstPath}.
+      #
+      # @param [String] solcAstPath path to solidity source
+      # 
+      # @return [String] solc AST JSON in a string
+      def readSolc( solcAstPath )
+        File.read( solcAstPath )
+      end
+
+      # Create Sexp AST tree for +index+-th compile unit in solc AST
+      # in +solc_hash+
+      #
+      # @param [Hash] solcHash JSON hash created by solc compiler
+      # 
+      # @option solcHash [sources.<file>.AST]
+      #
+      # @return [SexpAst] sexp ast for solc json AST in +solc_hash+,
+      # nil if +index+ exceeds number of sources in the +solcHash+.
+      def solc_ast( solcHash, index=0 )
+        return nil if solcHash['sourceList'].length <= index
+        solSource = solcHash['sourceList'][index]
+        @logger.info "#{__method__}: index:#{index}, solSource=#{solSource}"
+        # extract AST  part from solcHash for {solSource}
+        hash = solcHash['sources'][solSource]['AST']
+        # converst hash to sexp AST tree
+        SexpAst.build_sexp( hash )
+      end
+      
+      # @!endgroup      
+
+
+    end
+
+  end
+end

data/lib/sbuilder/mustache/renderer.rb

@@ -0,0 +1,152 @@
+require 'mustache'
+
+
+# ------------------------------------------------------------------
+# Hack mustache to allow change default otag '{{' ctag '}}'
+
+class Mustache
+
+
+  # Open mustache to define class accessors 'otag' and 'ctag'
+  def self.otag=( o )
+    @@otag = o
+  end
+  def self.ctag=( c )
+    @@ctag = c
+  end
+  def self.otag
+    @@otag ||= '{{'  
+  end
+  def self.ctag
+   @@ctag ||=  '}}'
+  end
+
+
+  class Template
+    
+    # Open template to set otag/ctag on parser.
+    #
+    # Returns an array of tokens for a given template.
+    #
+    # @return [Array] Array of tokens.
+    #
+    def tokens(src = @source)
+      p = Parser.new
+      p.otag = Mustache.otag
+      p.ctag = Mustache.ctag
+      p.compile(src)
+    end
+  end    
+
+end
+
+module Sbuilder
+  module Ethereum
+
+class Renderer < Mustache
+
+  # @attr [Logger] loger
+  attr_reader :logger
+  PROGNAME = nil                        # progname for logger default class name
+  include MyLogger                      # mix logger
+  
+
+  # @attr [String:Array] partials must be set before +to_str+
+  attr_accessor :partials
+
+  # @attr [Hash] preferences modify mustache rendering (debug?)
+  attr_reader :preferences
+
+  def initialize( options={} ) 
+    # exception raise if accessing unknown property
+    self.raise_on_context_miss = true
+
+    @options = options
+    @logger = getLogger( nil, options )
+    @logger.info "#{__method__}: starting options=#{options}"
+    
+  end
+
+  def setPreferences( preferences )
+    @preferences = preferences
+    @logger.info "#{__method__}:  preferences=#{preferences}"
+  end
+
+  # Use 'to_str' instead of 'render' to use non-default otag/ctag's
+  def to_str( template, data=nil )
+    Mustache.otag = '{|'
+    Mustache.ctag = '|}'    
+
+    begin 
+      ret = render( template, data )
+    ensure
+      # restore default otag/ctag
+      Mustache.otag = '{{'
+      Mustache.ctag = '}}'
+    end
+    ret
+  end
+
+  # Render conxtext.current[key].
+
+  # @param [String, '.'] key to render, '.' means current context,
+  # string lookup key in current context
+  def EVAL( key )
+
+    logger.info "#{__method__}: key='#{key}', context.current=#{context.current}" if logger.debug?
+    
+    # find generate sexp( :sym, data ) to render 
+    if key == '.'
+      sexp = context.current
+    else
+      #  to evaluate 
+      hash = context.current.is_a?( Array ) ? context.current[1] : context.current
+      sexp = hash[key] || hash[key.to_sym]
+      raise SbuilderEtherumMustacheException, "No such key #{key}:#{key.class} found in #{hash}"  if sexp.nil?      
+    end
+    
+    sexp_type = sexp[0]
+    data = sexp[1]
+    logger.debug "#{__method__}: key=#{key}, sexp_type=#{sexp_type}" if logger.debug?
+    
+
+    # find correct template 
+    template = partials[sexp_type]
+    raise SbuilderEtherumMustacheException, <<-EOS if template.nil?
+    Unknown partial for sexp_type '#{sexp_type}'
+
+    Known partials: #{partials.keys.join(',')}"  
+    Conxt = #{context.current}
+    EOS
+
+    logger.debug "#{__method__}: template=#{template}, data=#{data}" if logger.debug?    
+    return render( template, data )
+
+  end
+            
+
+  # # partials are constant strings, partial to use is defined in
+  # # SexpAst#sexp_type in context stack
+  # def partial( partial )
+
+
+  #   logger.debug "#{__method__}: partial=#{partial}, sex_type=#{context.current.respond_to?(:sexp_type)}, context.current=#{context.current}, context.current.class=#{context.current.class}"  if logger.debug?
+
+  #   raise "TOOD remove"
+    
+  #   partial = context.current.sexp_type if context.current.respond_to?( :sexp_type )
+  #   partial_str = partials[partial]
+  #   logger.debug "#{__method__}:  using partial =#{partial}"
+    
+
+  #   raise SbuilderEtherumMustacheException.new "Unknown partial '#{partial}'"  if partial_str.nil?
+    
+  #   return partial_str
+  # end
+
+
+  
+end
+
+      end
+end

data/lib/sbuilder/render.rb

@@ -0,0 +1,141 @@
+
+require 'json'
+
+module Sbuilder
+  module Ethereum
+
+class Render
+
+  
+  # SNIPPET_ROOT = <<-EOS
+  # {|>__partial_root__|}
+  # EOS
+
+
+  # @attr [Logger] logger
+  attr_reader :logger
+  PROGNAME = nil                        # progname for logger default class name
+  include MyLogger     # mix logger
+
+  # @attr [Hash] options
+  attr_reader :options
+
+  # @attr [Hash] partials mapping used to find starting point for Snippets
+  attr_reader :partials
+
+  # # @attr [Renderer] renderer mustache template generator
+  # attr_reader :renderer
+
+  # @attr [Hash] preferences passesed as PREFERENCES property to rendering
+  attr_reader :preferences
+
+  # ------------------------------------------------------------------
+  # @!group Construct && configure
+
+  def initialize( options={} )
+    @options = options
+    @logger = getLogger( PROGNAME, options )
+    setPreferences( Constants::DEFAULT_PREFERENCES )
+  end
+
+  ##
+  # Configure partials used to render snippets
+  def setPartials( partials )
+    # used later to find starting point for a snippet
+    @partials = partials
+  end
+
+  ##
+  # Configure 'PREFERENCES' property passed to rendering
+  def setPreferences(  preferences )
+    @preferences = Constants::DEFAULT_PREFERENCES.merge( preferences || {} )
+  end
+
+  def getRenderer
+    return @renderer unless @renderer.nil?
+    # create mustache renderer && configure it 
+    @renderer = Renderer.new( options )
+
+    # Pass a hash mapping TLA generate element sexp_type to mustache
+    # templates used to generate TLA code for TLA generate element
+    # sexp to the object responsible the generation.
+    @renderer.partials = partials
+    @renderer.setPreferences( preferences )
+    @renderer
+    
+  end
+
+  # @!endgroup      
+  
+  # ------------------------------------------------------------------
+  # @!group Iterater, render yield result
+
+  ##
+  # Uses +renderer+ to render +snippet+ to +body+ string in TLA language
+  # 
+  # @param [Snippet] snippet ie. TLA generate (data) element
+  #
+  # @yield [metatype,appName,body]
+  # @yieldparam [String] metatype of the snippet
+  # @yieldparam [String] appName in application domain
+  # @yieldparam [String] body snippet content
+  #
+
+  def renderSnippet( snippet, &blk )
+
+    # logger.info "#{__method__}: snippet=#{snippet[0]}-#{snippet[0]}" 
+    logger.debug "#{__method__}: snippet=#{snippet}" if logger.debug? 
+
+    # use +snippet.sext_type+ to look up template in +partials+
+    partial = snippet.sexp_type
+    template = getRenderer.partials[partial]
+    logger.debug "#{__method__}, partial=#{partial}, template #{template}" if logger.debug? 
+    
+    raise SbuilderEtherumMustacheException.new, "Unknown partial '#{partial}', known partials: #{getRenderer.partials.keys.join(',')}"  if template.nil?      
+
+    # Typicall snippet renders a body, however it is also possible to
+    # create a mapping from appName to specName in some matatype
+    # without defining body. (Which may be laoded later for that
+    # specName)
+    # 
+    snippet_str = getRenderer.to_str( template, snippet ) if snippet.snippet && snippet.snippet.any?
+    logger.debug "#{__method__}, metatype=#{snippet.metatype}, appName=#{snippet.appName}) snippet_str='#{snippet_str}'" if logger.debug?
+    
+    # yield result to block
+    logger.debug "#{__method__}, yield metatype=#{snippet.metatype}, appName=#{snippet.appName}) body=#{snippet_str ? snippet_str[1..20] : 'no body'}" if logger.debug?
+    yield snippet.metatype, snippet.appName, snippet_str if block_given?
+    
+  end
+
+  
+  # iterate, render, and yield result.
+  #
+  #
+  # @return [Integer] number of snippets rendered
+  
+  def render( snippets, &blk )
+    
+    logger.info "#{__method__}, start snippets=#{snippets}"
+    raise "Should have used #setPartials before #render" if partials.nil?
+
+
+    # init counter
+    rendered = 0
+    snippets.sexp_body.each do |snippet|
+      
+      renderSnippet( snippet, &blk )
+      
+      rendered += 1
+    end
+    rendered
+    
+  end
+  
+  # @!endgroup      
+
+  # Render +snippet+ to string
+
+end
+
+    end
+end

data/lib/sbuilder/s.rb

@@ -0,0 +1,21 @@
+module Sbuilder
+  module Ethereum
+
+# Helper method to build s-expressions
+
+# def s(type, *children)
+#   Ast.new(type, children)
+# end
+
+def self.s(*args)
+  Sbuilder::Ethereum::SexpAst.new(*args)
+end
+
+
+      end
+end
+
+# Override sexp_processos s
+def s( *args )
+  Sbuilder::Ethereum::s( *args )
+end

data/lib/sbuilder/sexp_ast.rb

@@ -0,0 +1,1378 @@
+# coding: utf-8
+
+require 'sexp_processor'
+
+module Sbuilder
+  module Ethereum
+
+
+# ------------------------------------------------------------------
+# @!group Common root for Sbuilder 
+
+# Common root
+
+class SexpSbuilder < Sexp
+
+  # Create a new Sexp containing +args+.
+  def initialize(*args)
+    super(*args)
+  end
+
+  # @return [Ast:Array] sexpAst nodes with +type+
+  # def return_nodes_with_type( type )
+  #   sexpAstArray = s() # []
+  #   deep_each { |n|
+  #     sexpAstArray << n  if n.sexp_type == type
+  #   }
+  #   sexpAstArray    
+  # end
+  def return_nodes_with_type( type )
+    return_nodes_with_match { |n|
+      n.sexp_type == type
+    }
+  end
+  
+
+  def return_nodes_with_match( &blk )
+    sexpAstArray = s() # []
+    deep_each { |n|
+      sexpAstArray << n  if blk[n]
+    }
+    sexpAstArray    
+  end
+  
+
+  # alias-method  to return nodes with type
+  def t( type )
+    return_nodes_with_type( type ).first[1..-1]
+  end
+
+  # Restore behaviour missing methods
+  def method_missing meth, delete = false
+    raise "Unknwon method '#{meth}' called on #{self}"
+  end
+  
+end
+# @!endgroup
+
+
+# ------------------------------------------------------------------
+# @!group Node in AST
+
+
+class SexpAst < SexpSbuilder
+
+  # @əttr [String] src source definition e.g. 0:106:1
+  attr_accessor :src
+
+  # @əttr [String] id as given by solc compiler
+  attr_accessor :id
+
+  # @attr [SexpAst] parent pointer to parent SexpAst
+  attr_accessor :parent
+
+
+  # Create a new Sexp containing +args+.
+  def initialize(*args)
+    super(*args)
+  end
+
+  def setParent( parent )
+    @parent = parent
+  end
+
+
+  # ------------------------------------------------------------------
+  # Build ast
+  
+  # Create ast sexp tree from {json}.
+  #
+  # @param [Json] json to load as sexp
+  #
+  # @param [Interger] id generate unique identifier for each AST node
+  #
+  def self.build_sexp( json )
+
+    raise SexpException.new "Nil input" if json.nil?
+    raise SexpException.new "Missing name property in '#{json}'" if json['name'].nil?    
+
+    # create sexp Node based on json['name']
+    result = new_node( json )
+
+    # add common content for all node types
+    result.src = json['src']
+    result.id = json['id']    
+
+    # add children & create back pointer
+    json['children'] && json['children'].each do |x|
+      chld = self.build_sexp(x )
+      chld.setParent( result )
+      result << chld
+    end
+
+    result
+    
+  end
+
+  def self.new_node( json )
+
+    # map solc node type to SexpClass. This guarantees that we know
+    # each node type. Sexp classes know also attributes, which solc
+    # json defines.
+    node2class = {
+      :Identifier => Sbuilder::Ethereum::Identifier,
+      :PragmaDirective => Sbuilder::Ethereum::PragmaDirective,
+      :BinaryOperation => Sbuilder::Ethereum::BinaryOperation,
+      :Literal => Sbuilder::Ethereum::Literal,
+      :SourceUnit => Sbuilder::Ethereum::SourceUnit,
+      :ContractDefinition => Sbuilder::Ethereum::ContractDefinition,
+      :FunctionDefinition => Sbuilder::Ethereum::FunctionDefinition,
+      :ParameterList => Sbuilder::Ethereum::ParameterList,
+      :VariableDeclaration => Sbuilder::Ethereum::VariableDeclaration,
+      :ElementaryTypeName => Sbuilder::Ethereum::ElementaryTypeName,
+      :Mapping => Sbuilder::Ethereum::Mapping,
+      :IndexAccess => Sbuilder::Ethereum::IndexAccess,
+      :VariableDefinitionStatement =>Sbuilder::Ethereum::VariableDefinitionStatement,
+      :Block => Sbuilder::Ethereum::Block,
+      :Return => Sbuilder::Ethereum::Return,
+      :ExpressionStatement => Sbuilder::Ethereum::ExpressionStatement,
+      :Assignment => Sbuilder::Ethereum::Assignment,
+      :MemberAccess => Sbuilder::Ethereum::MemberAccess,
+      :FunctionCall => Sbuilder::Ethereum::FunctionCall,
+      :NewExpression => Sbuilder::Ethereum::NewExpression,
+      :UserDefinedTypeName => Sbuilder::Ethereum::UserDefinedTypeName,
+      :Throw => Sbuilder::Ethereum::Throw,
+      :Domain => Sbuilder::Ethereum::Domain,
+      :IfStatement => Sbuilder::Ethereum::IfStatement,
+      :UnaryOperation => Sbuilder::Ethereum::UnaryOperation,
+    }
+
+    nodeType = json['name'].is_a?( String ) ? json['name'].to_sym : json['name']
+    klass = node2class[nodeType]
+    raise SexpException.new "Unknown node type  '#{json['name']}' in #{json.to_yaml}" if klass.nil?
+    
+    result = klass.json( json )    
+
+
+  end
+
+  
+
+end
+
+class Identifier < SexpAst
+
+  # reference to declaration
+  include Sbuilder::Ethereum::DeclRef
+
+  # pointer to domain of the declaration
+  include Sbuilder::Ethereum::DomainRef
+  
+
+  # Create a new Sexp containing +json+.
+  def self.json(json=nil)
+    ary = [
+      json['name'].to_sym,
+      json['attributes']['type'],
+      json['attributes']['value'],      
+    ] unless json.nil?
+    
+    Identifier.new(*ary)
+  end
+
+  def self.s( type, value )
+    Identifier.new( :Identifier, type, value )
+  end
+
+  def type
+    self[1]
+  end
+
+  # value for identifier as an expression
+  def value
+    self[2]
+  end
+
+  # semantic routine
+  
+  # name of identifier
+  def name
+    value
+  end
+  def resolvedReference
+    raise 'Identifier reference #{self} not resolved' if declationRef.nil?
+    declationRef
+  end
+  
+end
+
+class PragmaDirective < SexpAst
+  def self.json(json)
+    ary = [
+      json['name'].to_sym,
+    ]
+    PragmaDirective.new(*ary)
+  end
+end
+
+class SourceUnit < SexpAst
+  def self.json(json)
+    ary = [
+      json['name'].to_sym,
+    ]
+    SourceUnit.new(*ary)
+  end
+
+  def self.define( sourceUnit, ast )
+    SourceUnit.new( :SourceUnit, sourceUnit, ast )
+  end
+  
+end
+
+class ContractDefinition < SexpAst
+
+  # number of contracts is a domain
+  include Sbuilder::Ethereum::DomainRef
+  
+  include Scope
+
+  # type hierarcy
+  include TypeSymbol
+
+  # TypeSymbol uses 'typeName' to create unique names in type
+  # hierarchy
+  def typeName
+    name
+  end
+  
+  def self.json(json)
+    ary = [
+      json['name'].to_sym,
+      json['attributes']['name'],            
+    ]
+    ContractDefinition.new(*ary)
+  end
+  def name
+    self[1]    
+  end
+
+  ##
+  # Name of set to hold contract identifiers
+  def contractIdSet
+    "#{name}_ids"
+  end
+
+  ## 
+  # @return [VariableDeclaration:Array] symbols with 'sexp_type' ==
+  # :VariableDeclaration defined in contract scope
+  def contractVariables
+    return s() if symbols.nil?
+    symbols.values.select { |s| s.sexp_type ==  :VariableDeclaration }
+  end
+  
+end
+
+
+class ParameterList < SexpAst
+
+  # back pointer to scope where declared
+  include Scoped
+
+  # it acts also as a scope
+  include Scope
+  
+  def self.json(json)
+    ary = [
+      json['name'].to_sym,
+    ]
+    ParameterList.new(*ary)
+  end
+
+  # parameters SexpAst nodes starting form pos 1
+  def parameters
+    # return self[1..-1] if self.length > 1
+    return self[1..-1]
+  end
+
+  ##
+  # Name as function for function
+  def name
+    parent.name
+  end
+  
+end
+
+class ExpressionStatement < SexpAst
+  def self.json(json)
+    ary = [
+      json['name'].to_sym,
+    ]
+    ExpressionStatement.new(*ary)
+  end
+end
+
+class MemberAccess < SexpAst
+
+  # reference to declaration
+  include DeclRef
+
+  # pointer to domain of the declaration
+  include DomainRef
+  
+  
+  def self.json(json)
+    ary = [
+      json['name'].to_sym,
+      json['attributes']['member_name'],
+      # json['attributes']['type'], 
+    ]
+    MemberAccess.new(*ary)
+  end
+
+  # @return [String] member_name e.g. 'sender' in 'msg.sender'
+  def member_name
+    self[1]
+  end
+  
+
+  ## Children
+  # @return [Identifier|MemberAccesss] msg in 'msg.sender', sender
+  # in 'msg.sender.send'
+
+  def memberStruct
+    self[2]
+  end
+
+
+  # "calling a function on the function" e.g. f.gas(2).value(20)()
+  # calls the modified function f and thereby sending 20 Wei and
+  # limiting the gas to 2 we catch this later in code generation
+  # phase, and have no need for declationRef
+  #
+  # @return [Boolean] true if 'mmbStct.decLRef.sexp_type == :FucnDef'
+  def isFunctionOnFunction
+    memberStruct && memberStruct.declationRef && memberStruct.declationRef.sexp_type == :FunctionDefinition
+  end
+  
+  ##
+  # @return [Sexp] recipientSexp in s(:MemberAccess, "send",
+  # s(:MemberAccess, "sender", s(:Identifier, "msg", "msg"))) it
+  # returns s(:MemberAccess, "sender", s(:Identifier, "msg", "msg"))
+  # def recipientSexp
+  #   memberStruct
+  # end
+
+  
+end
+
+class Assignment < SexpAst
+  def self.json(json)
+    ary = [
+      json['name'].to_sym,
+      json['attributes']['operator'],
+      json['attributes']['type'],      
+    ]
+    Assignment.new(*ary)
+  end
+
+  def operator
+    self[1]
+  end
+  
+  def type
+    self[2]
+  end
+
+  # variable being assined to, 1.st child
+  def lval
+    self[3]
+  end
+
+  # expression being assined, 2nd child  
+  def rval
+    self[4]    
+  end
+
+  # Canonize
+  def setOperator( operator='=' )
+    self[1] = operator
+  end
+
+  def setRval( rval )
+    self[4] = rval
+  end
+  
+end
+
+
+class Block < SexpAst
+  def self.json(json)
+    ary = [
+      json['name'].to_sym,
+    ]
+    Block.new(*ary)
+  end
+
+  # ------------------------------------------------------------------
+  # semantic methods
+  def statements
+    self[1..-1]
+  end
+  
+end
+
+class Return < SexpAst
+  
+  # back pointer for the function scope where return variables are set
+  include Scoped
+
+  def self.json(json=nil)
+    ary = [
+      json['name'].to_sym,
+    ] unless json.nil?
+    Return.new(*ary)
+  end
+
+  # list of expressions returned start from pos 1
+  def expressions
+    self[1..-1]
+  end
+
+  # semantic methods
+
+  # alias a name with more semantics
+  alias_method :function, :scopeDefining
+
+  # '(uint retVal, ...)' in 'function get() constant returns (uint retVal, ...)'  
+  def functionReturnList
+    raise "function scope for #{self} not resolved" if function.nil?
+    function.returnList
+  end
+
+  def functionReturnParameter( i )
+    raise "function scope for #{self} not resolved" if function.nil?
+    function.returnParameter( i )
+  end
+  
+end
+
+
+class IndexAccess  < SexpAst
+
+  include DomainRef
+  
+  def self.json(json)
+    ary = [
+      json['name'].to_sym,
+    ]
+    IndexAccess.new(*ary)
+  end
+
+  # childs
+  def identifier
+    self[1]
+  end
+
+  def indexer
+    self[2]
+  end
+end
+
+class Mapping < SexpAst
+  
+  
+  def self.json(json)
+    ary = [
+      json['name'].to_sym,
+    ]
+    Mapping.new(*ary)
+  end
+
+  # childs
+  def mapFrom
+    self[1]
+  end
+  def mapTo
+    self[2]
+  end
+
+  #  @return [Array] mappings [from, to]
+  def maps
+    self[1..-1]
+  end
+  
+
+end
+
+
+class VariableDeclaration < SexpAst
+
+  # back pointer to scope where declared
+  include Scoped
+
+  # pointer to domain of the declaration
+  include DomainRef
+  
+  def self.json(json=nil)
+    ary = [
+      json['name'].to_sym,
+      json['attributes']['name'],      
+      json['attributes']['type'],
+      
+    ] unless json.nil?
+    VariableDeclaration.new(*ary)
+  end
+
+  def self.s( name, typeSexp=ElementaryTypeName.s )
+    VariableDeclaration.new( :VariableDeclaration, name, "domain", typeSexp )
+  end
+  
+  def name
+    self[1]
+  end
+  # function return parameters do not have a name,
+  # canonize process may update name
+  def setName( name )
+    self[1] = name
+  end
+  
+  
+  def type
+    self[2]
+  end
+
+  # childs
+  def typeSexp
+    self[3]    
+  end
+
+  def isMapping
+    typeSexp.sexp_type == :Mapping
+  end
+
+  # @return true iff +typeSexp? == :ElementaryTypeName
+  # def isElementary
+  #   typeSexp &&  typeSexp.sexp_type == :ElementaryTypeName
+  # end
+  
+  
+end
+
+
+# @see Assignment because 'VariableDefinitionStatement' is intepreted 
+# an assignment
+class VariableDefinitionStatement < SexpAst
+
+  # back pointer to scope where declared
+  include Scoped
+  
+  def self.json(json)
+    ary = [
+      json['name'].to_sym,
+    ]
+    VariableDefinitionStatement.new(*ary)
+  end
+
+  # variable being assined to, 1.st child
+  def lval
+    self[1]
+  end
+
+  # expression being assined, 2nd child  
+  def rval
+    self[2]    
+  end
+
+
+  
+end
+
+
+# @see UserDefinedTypeName implementing also typeName
+class ElementaryTypeName < SexpAst
+
+  # back pointer to scope where declared
+  include Scoped
+
+  # pointer to symbol type (i.e User defined/elementary type)
+  include SymbolRef
+
+  # pointer to domain of the declaration
+  include DomainRef
+  
+  def self.json(json)
+    ary = [
+      json['name'].to_sym,
+      json['attributes']['name'],                  
+    ]
+    ElementaryTypeName.new(*ary)
+  end
+
+  def self.s()
+    ElementaryTypeName.new( :ElementaryTypeName )
+  end
+
+  def typeName
+    self[1]
+  end
+  
+  
+end
+
+class IfStatement  < SexpAst
+  def self.json(json)
+    ary = [
+      json['name'].to_sym,
+    ]
+    IfStatement.new(*ary)
+  end
+
+  def condition
+    self[1]
+  end
+
+  # childs
+  def then_branch
+    self[2]
+  end
+  
+  def else_branch
+    self[3]
+  end
+  
+end
+
+class Throw  < SexpAst
+  def self.json(json)
+    ary = [
+      json['name'].to_sym,
+    ]
+    Throw.new(*ary)
+  end
+  
+end
+
+class UserDefinedTypeName  < SexpAst
+
+  # back pointer to scope where declared
+  include Scoped
+
+  # pointer to symbol type (i.e User defined/elementary type)
+  include SymbolRef
+
+  def self.json(json)
+    ary = [
+      json['name'].to_sym,
+      json['attributes']['name'],            
+    ]
+    UserDefinedTypeName.new(*ary)
+  end
+
+  def name
+    self[1]        
+  end
+
+  # common method for UserDefinedTypeName, ElementaryTypeName
+  def typeName
+    name
+  end
+  
+  
+end      
+
+class NewExpression < SexpAst
+
+  # reference to constructor declaration
+  include DeclRef
+
+  def self.json(json)
+    ary = [
+      json['name'].to_sym,
+      json['attributes']['type'],      
+    ]
+    NewExpression.new(*ary)
+  end
+
+  def type
+    self[1]        
+  end
+
+  ## 
+  # Semantic
+  def contractConstructed
+    self[2]
+  end
+
+  # def name
+  #   functionCalled.name
+  # end
+  
+  
+end
+
+##
+# Wrap function call to indicate that we should read result of
+# function, which was called previously. This sexp is created when
+# spllitting statement with function call e.g. in assignment or in
+# condiational
+class FunctionCallReadReturn < SexpAst
+
+  # function may assign to variable with domain of the declaration,
+  # this is handled in 'FunctionCallReadReturn'
+  include DomainRef
+  
+  def initialize( functionCall )
+    ary = [
+      :FunctionCallReadReturn,
+      functionCall,
+    ]
+    super(*ary)
+  end
+  def self.define( functionCall )
+    FunctionCallReadReturn.new( functionCall )
+  end
+
+  def functionCalled
+    self[1]
+  end
+  
+end
+
+class FunctionCall < SexpAst
+
+
+  def self.json(json=nil)
+    ary = [
+      json['name'].to_sym,
+      json['attributes']['type'],
+    ] unless json.nil?
+    FunctionCall.new(*ary)
+  end
+  
+  def type
+    self[1]        
+  end
+
+  ##
+  # childs
+  def functionExpression
+    self[2]
+  end
+
+  def actualParameters
+    self[3..-1]
+  end
+  
+end
+  
+class FunctionDefinition < SexpAst
+  # Function definition is also a scope
+  include Scope
+
+  # @əttr [ContractDefinition] contractDefinition
+  attr_accessor :contractDefinition
+
+  # pointer to domain of the declaration
+  include DomainRef
+  
+  def self.json(json=nil)
+    ary = [
+      json['name'].to_sym,
+      json['attributes']['name'],
+      json['attributes']['public'],
+      json['attributes']['constant'],                        
+    ] unless json.nil?
+    FunctionDefinition.new(*ary)
+  end
+
+  def name
+    self[1]        
+  end
+  
+  def isPublic
+    self[2]        
+  end
+  def isConstant
+    self[3]        
+  end
+  # child nodes in AST
+  # @return [ParameterList] parameterList
+  def parameterList
+    self[4]        
+  end
+  # child nodes in AST
+  # @return [ParameterList] returnList
+  def returnList
+    self[5]        
+  end
+  def block
+    self[6]     
+  end
+
+  # ------------------------------------------------------------------
+  # semantic
+  def statements
+    block.statements
+  end
+
+  def returnParameter( i )
+    returnList[i+1]
+  end
+
+  ##
+  # Method added dyncamially 
+  # def interfaceName
+  #   return "Demo()" or "Demo(set)
+  # end
+  
+end
+
+class UnaryOperation < SexpAst
+    # pointer to domain of the declaration
+  include DomainRef
+
+  # Create a new Sexp containing +args+.
+  def self.json(json)
+    ary = [
+      json['name'].to_sym,
+      json['attributes']['operator'],      
+    ]
+    
+    UnaryOperation.new(*ary)
+  end
+
+  def operator
+    self[1]    
+  end
+
+  # childs
+  def expr
+    self[2]    
+  end
+
+end
+
+
+class BinaryOperation < SexpAst
+
+  # pointer to domain of the declaration
+  include DomainRef
+  
+
+  # Create a new Sexp containing +args+.
+  def self.json(json)
+    ary = [
+      json['name'].to_sym,
+      json['attributes']['operator'],      
+    ]
+    
+    BinaryOperation.new(*ary)
+  end
+
+  def operator
+    self[1]    
+  end
+
+  # childs
+  def lhs
+    self[2]    
+  end
+  def rhs
+    self[3]    
+  end
+  
+
+  # value of operator expression
+  def value
+    "op_#{operator}"
+  end
+  
+end
+
+class Literal < SexpAst
+
+  # literals participate to  data flows
+  include DomainRef
+  
+  # Create a new Sexp containing +args+.
+  def self.json(json)
+    ary = [
+      json['name'].to_sym,
+      json['attributes']['type'],
+      json['attributes']['value'],      
+    ]
+    
+    Literal.new(*ary)
+  end
+
+  def type
+    self[1]
+  end
+
+  # value of the expression
+  def value
+    self[2]
+  end
+
+  ##
+  # canonize maps literal constant values in solc to TLA
+  def setValue( value )
+    self[2] = value
+  end
+  
+end
+# @!endgroup
+
+# ------------------------------------------------------------------
+# @!group Symbols
+
+class BuiltInSymbol < SexpSbuilder
+
+  # integer, boolean, etc
+  include TypeSymbol;
+
+
+  # TypeSymbol uses 'typeName' to create unique names in type
+  # hierarchy
+  def typeName
+    name
+  end
+  
+
+  # it may define names e.g. address knowns of 'send'
+  include Scope;
+
+  def initialize(name)
+    ary = [
+      :BuiltInSymbol,
+      name
+    ]
+    super(*ary)
+  end
+  
+  def name
+    self[1]
+  end
+  
+  # @return unique identifier like no other
+  def id
+    "#{self.class}-#{name}"
+  end
+  
+  
+end
+
+# @!endgroup
+# ------------------------------------------------------------------
+
+# ------------------------------------------------------------------
+# @!group Sexp cretad outside AST 
+
+# Symbol table main entry (like Sexp), not found in AST
+class GlobalScope < SexpSbuilder
+  include Scope
+
+  def initialize
+    ary = [
+      :GlobalScope,
+    ]
+
+    super(*ary)
+  end
+
+  def name
+    self[0].to_s
+  end
+
+  ##
+  # Use global scope like contract
+  def contractVariables
+    s()
+  end
+  
+end
+
+# @see  http://solidity.readthedocs.io/en/develop/units-and-global-variables.html
+class Msg < SexpSbuilder
+
+  # e.g. to hold 'sender', 'value', 'gas', ...
+  include Scope
+
+  def initialize( id )
+    ary = [
+      :Msg,
+      id,
+    ]
+    super(*ary)
+  end
+
+  ##
+  # @return unique identifier like no other
+  def id
+    self[1]
+  end
+
+  
+  
+end
+
+# @see  http://solidity.readthedocs.io/en/develop/units-and-global-variables.html
+class Now < SexpSbuilder
+
+  def initialize( id )
+    ary = [
+      :Now,
+      id,
+    ]
+    super(*ary)
+  end
+
+  # @return unique identifier like no other
+  def id
+    self[1]
+  end
+end
+
+
+# not <SexpSbuilder because we construct Domain nodes
+class Domain < SexpAst
+
+  # Using Domain to define types for common message properties
+  include Scoped
+
+  # pointer to symbol type (i.e User defined/elementary type)
+  include SymbolRef
+  
+  def initialize(name, solidityType=nil)
+    ary = [
+      :Domain,
+      name,
+      solidityType,
+    ]
+    
+    super(*ary)
+  end
+
+  def self.json(json)
+    ary = [
+      # json['name'].to_sym,
+      json['attributes']['name'],
+      json['attributes']['solidityType'],
+    ]
+    Domain.new(*ary)
+  end
+
+  def self.s( name, solidityType=nil )
+    Domain.new( name, solidityType )
+  end
+
+  def domainName
+    self[1]    
+  end
+
+  def solidityType
+    self[2]    
+  end
+  
+
+  ##
+  # values idenfied for domain e.g. contract names in 'eth_code_hash'.
+  # Possibly literals in ethereum contracts.
+  # 
+  def domainValues
+    self[3..-1]
+  end
+
+  def name
+    domainName
+  end
+  
+end
+
+class Domains < SexpSbuilder
+
+  # @param [Domain:array] domainArr array of Domain sexps
+  def initialize( domainArr )
+    ary = [
+      :Domains,
+      *domainArr
+    ]
+    
+    super(*ary)
+  end
+
+  def domains
+    self[1..-1]        
+  end
+  
+end
+
+
+
+# Snippets created 
+class Snippets < SexpSbuilder
+
+  # @param [Domain:array] domainArr array of Domain sexps
+  def initialize( snippets )
+    ary = [
+      :Snippets,
+      *snippets
+    ]
+    
+    super(*ary)
+  end
+
+end
+
+class Interfaces <  SexpSbuilder
+
+  # @param [Interface:Array] interfaces array of Interface instances
+  def initialize( interfaces )
+    ary = [
+      :Interfaces,
+      *interfaces
+    ]
+    super(*ary)
+  end
+
+  def interfaces
+    self[1..-1]
+  end
+
+end
+
+
+class Definitions <  SexpSbuilder
+
+  # @param [Definition:Array] interfaces array of Definition instances
+  def initialize( definitions )
+    ary = [
+      :Definitions,
+      *definitions
+    ]
+    super(*ary)
+  end
+
+  def definitions
+    self[1..-1]
+  end
+
+end
+
+
+class Definition <  SexpSbuilder
+
+  # 
+  # @param [:Symbol] definitionType :normal or :function
+  def initialize( definitionName, properties, definitionType  )
+    raise "Unknown type #{definitionType}" unless [:normal, :function ].include? definitionType
+    ary = [
+      :Definition, 
+      definitionName,
+      properties,
+      definitionType
+    ]
+    super(*ary)
+  end
+
+  def self.define( definitionName, propertiesSexp, definitionType = :normal )
+    Definition.new(
+      definitionName, 
+      propertiesSexp.map do |prop|
+        # prop = s(name domain_name)
+        p =  {
+          :type => prop[0],
+          :name => prop[1],
+        }
+        p[:domain_name] = prop[2] if prop[0] == :parameter        
+        p[:reference] = prop[2] if prop[0] == :reference
+        p
+      end,
+      definitionType
+    )
+  end
+
+  def name
+    self[1]
+  end
+
+  # @return [Hash:Array] prop
+  # @option prop [:Symbol] :type values :parameter or :reference
+  # @option prop [:Symbol] :name
+  # @option prop [:Symbol] :domain_name if :type == :parameter
+  # @option prop [:Symbol] :reference if :type == :reference
+  def properties
+    self[2]
+  end
+
+  # @return [:Symbol] definitionType one of [:normal, :function]
+  def definitionType
+    self[3]
+  end
+  
+  
+end
+
+
+
+class Interface <  SexpSbuilder
+  
+  def initialize( interfaceDefinition, input=nil, output=nil )
+    ary = [
+      :Interface, 
+      interfaceDefinition,
+      input,
+      output,
+    ]
+    super(*ary)
+  end
+
+  def self.define( contractName, functionName, inputSexp, outputSexp )
+    Interface.new(    
+      {
+        :interface => contractName,
+        :method => functionName,
+        :input => inputSexp.map do |param|
+          # param s(:type name domain_name)
+          {
+            :name => param[1],
+            :domain_name => param[2]            
+          }
+        end,
+        :output => outputSexp.map do |param|
+          # param s(:type name domain_name)
+          {
+            :name => param[1],
+            :domain_name => param[2]            
+          }
+        end
+      })
+  end
+
+  # #
+  # # @param [ParameterList] input request parameters
+  # # 
+  # # @param [ParameterList] output response parameters
+  
+  # def self.create( contractName, functionName, input, output )
+  #   Interface.new(
+  #     {
+  #       :interface => functionName,
+  #       :input => input.parameters.map do |param|
+  #         # param [VariableDeclation]
+  #         raise "Domain reference not resolved on #{param}" unless param.domainReference
+  #         {
+  #           :name => param.name,
+  #           # :type => param.type,
+  #           :domain_name => param.domainReference.name,            
+  #         }
+  #       end,
+  #       :output => output.parameters.map do |param|
+  #         # param [VariableDeclation]
+  #         raise "Domain reference not resolved on #{param}" unless param.domainReference
+  #         {
+  #           :name => param.name,
+  #           # :type => param.type,
+  #           :domain_name => param.domainReference.name,            
+  #         }
+  #       end,
+        
+  #       # :output => functionName.parameters.map { |param| a },                
+  #     },
+  #     input, output,
+
+  #   )
+  # end
+
+  
+
+  def interfaceDefinition
+    self[1]
+  end
+  def inputParameters
+    raise "Not used"
+    self[2]
+  end
+  def outputParameters
+    raise "Not used"    
+    self[3]
+  end
+
+  # return +path+ parameter for ApiLoaderFacade#newInterce  
+  def path
+    interfaceDefinition[:interface]
+  end
+
+  # return +op+ parameter for ApiLoaderFacade#newInterce
+  def op
+    interfaceDefinition[:method]
+  end
+  
+  def input
+    raise "Not used"    
+    interfaceDefinition[:input]
+  end
+  
+end
+
+class Snippet < SexpSbuilder
+
+  def initialize( metatype, name, sexp, specName=nil, comment=false )
+    ary = [
+      :Snippet,
+      metatype,      
+      name,
+      sexp,
+      specName,
+      comment,
+    ]
+    super(*ary)
+  end
+
+  # ------
+  # sematics
+  
+  def metatype
+    self[1]    
+  end
+  def name
+    self[2]    
+  end
+  # Genarate body
+  def sexp
+    self[3]
+  end
+  # optional specName - if want override generation
+  def specName
+    self[4]    
+  end
+  def comment
+    self[5]    
+  end
+
+  # this stuff gets rendered as snippetBody
+  def snippet
+    # self[2..-1]
+    s(sexp)
+  end
+  
+
+  # metatype+appName combination is unique identifier in specification
+  # code domain.
+
+  # appName is unique identifier in application domain
+  def appName
+    name
+  end
+
+  # Unique name as identified by 'metatype':'appName'
+  def snippetId
+    "#{metatype}:#{appName}"
+  end
+
+end
+
+# @!endgroup
+
+  end
+end