sbuilder-ethereum 0.0.6

data/lib/sbuilder/sexp_processor_snippet.rb

@@ -0,0 +1,154 @@
+module Sbuilder;
+  module Ethereum
+    ##
+    # Load Snippet information to sbuilder using facade
+
+    class SexpProcessorSnippet < SexpProcessorEthereum
+      
+      # ------------------------------------------------------------------
+      # Attributes
+
+      # @attr [SnippetLoaderFacade] snippetFacade, Must be set before
+      # using #process.
+      attr_reader :snippetFacade
+
+      # @attr [Render] renderer rendering TLA generate element to TLA
+      # language snippets. Must be set before using #process.
+      attr_reader :renderer
+
+      # @attr [Hash] metatypes map snippet metatype to metatype
+      # desciption. Must be set before using #process.
+      attr_reader :metatypes
+
+      # ------------------------------------------------------------------
+      # @!group Construct & configure
+      
+      def initialize( options={} )
+        super( options )
+      end
+
+      ##
+      # Configure +@renderer+ to render TLA generate elements to TLA language snippets
+      def setRenderer( renderer )
+        @renderer = renderer
+      end
+
+
+      ##
+      # Configure +snippetFacade+ used to communicate with sbuilder framework
+      def setSnippetFacade( snippetFacade )
+        @snippetFacade = snippetFacade
+
+        # before anythin else - configure
+        configureSnippetFacade
+
+      end
+
+      private def configureSnippetFacade
+        # set snippet wrappers with known text 
+        snippetFacade.setSnippetHeader( TlaElementText::SNIPPET_HEADER )
+        snippetFacade.setSnippetFooter( TlaElementText::SNIPPET_FOOTER ) 
+        
+      end
+
+      ##
+      # Configure +metatypes+ used in +partials+
+      def setMetatypes( metatypes )
+        @metatypes = metatypes
+      end
+      
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group render TLA snippet
+
+      ##
+      # Render body of snippit in TLA-language.
+      # 
+      # @param [Snippet] snippet SexpAst to render
+      def render( snippet, &blk )
+        raise SbuilderEtherumException, "Invalid call sequence, should have called '#setRenderer' before #process" unless metatypes
+        renderer.renderSnippet( snippet, &blk ) 
+      end
+      
+
+      # @!endgroup      
+
+      # ------------------------------------------------------------------
+      # @!group Sexp node actions
+
+      ##
+      # Register metatypes in Snippets Sexp tree.
+      #
+      
+      def process_Snippets( exp )
+        
+        logger.debug( "#{__method__}: exp=#{exp}") if logger.debug?
+
+        registerMetatypes
+
+        # exp.return_nodes_with_type( :Snippet ).each do |snippet|
+        #   metatypeDescription = metatypes[snippet.metatype]
+        #   if metatypeDescription.nil?
+        #     msg = <<-EOS
+        #     Unknown metatype '#{snippet.metatype}' in #{snippet}
+
+        #     Known metatypes #{metatypes.keys.join(',')}
+        #     EOS
+        #     logger.error "#{__method__}: #{msg}"
+        #     raise SbuilderEtherumException, msg
+        #     end
+          
+        #   # valid metatype found, register it before processing snippets
+        #   snippetFacade.registerMetatype( snippet.metatype.to_s, metatypeDescription )
+        # end
+
+        # continue with tree traversal
+        process_rest( exp )
+        
+      end
+
+      ##
+      # Register metatypes over snippet facade
+      def registerMetatypes
+        raise SbuilderEtherumException, "Invalid call sequence, should have called '#setMetatypes' before #process" unless metatypes
+        logger.debug "#{__method__}: #{metatypes}" if logger.debug?
+
+        metatypes.each do |metatype,metatypeDef|
+          metatypeDescription = metatypeDef[:name]
+          metatypePrefix = metatypeDef[:prefix]          
+          snippetFacade.registerMetatype( metatype.to_s, metatypeDescription, metatypePrefix )
+        end
+      end
+
+      ##
+      # Render +exp+ to create +snippetBody+, pass +snippetBody+
+      # together with +snippet.metatype+, and +snippet.appName+ to
+      # +snippetFacade+
+      def process_Snippet( exp )
+        logger.debug( "#{__method__}: exp=#{exp}") if logger.debug?
+        raise SbuilderEtherumException, "Invalid call sequence, should have called '#setSnippetFacade' before #process" unless snippetFacade
+
+        # create TLA language body && hand over to sbuilder facede
+        render( exp ) do |metatype,appName, snippetBody|
+          logger.info "#{__method__}: rendered metatype=#{metatype}, appName=#{appName}, specName=#{exp.specName}"
+          logger.debug "#{__method__}: rendered snippetBody=#{snippetBody}" if logger.debug?
+
+          # pass to sbuilder (using 'Strings' as metatype),
+          # 'specName', if given, overrides name generated in sbuilder
+          snippetFacade.handOver( metatype.to_s, appName, snippetBody, exp.specName )
+          
+        end
+        s()
+      end
+
+
+      # @!endgroup
+
+      
+    end # class
+    
+                   
+  end
+end

data/lib/sbuilder/sexp_processor_symboltable1.rb

@@ -0,0 +1,296 @@
+# coding: utf-8
+module Sbuilder
+  module Ethereum
+
+    ##
+    # Create scope hierarchy for symbol table
+    #
+    # Traverse sexp AST, and
+    # - initializes & returns GlobalScope (for process)
+    # - build scope hierarchy (mixer Scope) for SexpAst -nodes
+    #    -- GlobalScope
+    #    -- ContractDefinition
+    #    -- FunctionDefinition
+    # - add references to currentScope 
+    #    -- VariableDeclaration#scopeDefining (Scoped)
+    #    -- Return#scopeDefining (Scoped)
+    #    -- Identifier#enclosingScope (DeclRef)
+
+    class SexpProcessorSymbolTable1 < SexpProcessorEthereum
+      
+      # ------------------------------------------------------------------
+      # @!group Construct & configure
+      
+      def initialize( options={} )
+        super( options )
+      end
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group scope support
+
+      # @attr [GlobalScope] globalScope the one
+      attr_accessor :globalScope
+
+      # @attr [Scope] currentScope which currently opened
+      attr_accessor :currentScope
+
+      # @attr [Contract] currentContract which currently processing
+      attr_accessor :currentContract
+
+
+      def contracted( expContract )
+
+        self.currentContract = expContract
+        begin
+            yield
+        ensure
+          self.currentContract = nil
+        end
+      end
+
+
+      # Use +scoped+ allowing scope object passed as a parameter, instead
+      # of +SexpProcessor#scope+, which uses fixed hash to manage scope
+      # entries.
+      # 
+      # @param [Scope] ethScope to push to @env
+      #
+      # @param [String] prefix distinguish variable declaration in funtion return list 
+      #
+      def scoped( ethScope )
+
+        raise "Scope support missing in #{ethScope}" unless ethScope.respond_to?( :isScope ) && ethScope.isScope
+        logger.debug "#{__method__}: create scope for '#{ethScope.sexp_type}' over #{ currentScope ? currentScope.sexp_type : 'starting global scope' }" if logger.debug?
+
+        # remember  'prevScope', update enclosing scope, switch '@currentScope', 
+        prevScope = currentScope
+        ethScope.enclosing_scope = currentScope
+        self.currentScope = ethScope
+
+        
+        begin
+          # traverse the tree under the newly created scope
+          yield
+        ensure
+          logger.debug "#{__method__}: pop scope for '#{ethScope.sexp_type}' - resume #{prevScope ? prevScope.sexp_type : 'global scope'}"   if logger.debug?
+          self.currentScope = prevScope
+        end
+      end
+
+      # @return [Scope] gloabalScope with ethereum declarations
+      #
+      def startWithGlobalScope
+        # start with global scope with sexp_type :GlobalScope
+        warn "Global scope not initialized" if globalScope.nil?
+        self.currentScope = globalScope || GlobalScope.new
+      end
+
+      # ------------------------------------------------------------------
+      # @!group Access processors
+
+      def getSymbolTable1ExpressionsProcessor( scope )
+        proc = SymbolTable1Expressions.new( options )
+        proc.currentScope = scope
+        proc
+      end
+      
+      # @!endgroup
+      
+      # ------------------------------------------------------------------
+      # @!group starting point && return value
+      
+
+      # @return [GlobalScope] globalScope
+      def process_SourceUnit( exp )
+
+        # global declarations are always there
+        startWithGlobalScope
+        # tree traversal
+        process_rest( exp  )
+        
+        # returns sexp, which should be +GlobalScope+
+        currentScope
+        
+      end
+
+      # @!endgroup
+      
+      # ------------------------------------------------------------------
+      # @!group Node rules creating scopes
+      def process_GlobalScope( exp )
+        logger.debug "#{__method__}: exp=#{exp}" if logger.debug?
+
+        # address is top level type for functions in globalScope
+        contracted( exp.resolve(Constants::SOL_ADDRESS ) ) do 
+          scoped( exp ) do
+            process_rest( exp  )
+          end
+        end
+      end
+
+      def process_ContractDefinition( exp )
+        logger.debug "#{__method__}: name=#{exp.name}" if logger.debug?
+        # add name of contract (to top-level scope?)
+        currentScope.define( exp.name, exp )
+        contracted( exp ) do
+          scoped( exp ) do 
+            # contracted & scoped!!
+            process_rest( exp  )
+          end
+        end
+      end
+
+      def process_FunctionDefinition( exp )
+        logger.debug "#{__method__}: #{exp} entered" if logger.debug?
+
+        exp.contractDefinition = currentContract
+        currentScope.define( exp.name, exp )
+        # TODO - remove this
+        
+        # add interfacename to contract
+        if exp.respond_to?( :interfaceName )
+          logger.info "#{__method__}: scope-definition for interface #{exp.interfaceName}"          
+          currentScope.define( exp.interfaceName, exp )
+        else
+          warn "Exp #{exp} does not respond to :interfaceName - preprocessing problem??" 
+        end
+
+        scoped( exp ) do
+          
+          # add 'msg': pointing to function parameter list & process variable declaration
+          currentScope.define( Constants::SOL_MSG, exp.parameterList )
+          exp.parameterList.scopeDefining = currentScope
+          exp.parameterList.enclosing_scope = currentScope                  
+          process( exp.parameterList )
+
+          # add 'return-': pointing to return list
+          currentScope.define( Constants::SYMBOL_RETURN_PREFIX, exp.returnList )
+          exp.returnList.scopeDefining = currentScope
+          exp.returnList.enclosing_scope = currentScope
+          process( exp.returnList )          
+
+          # local variables
+          process( exp.block )
+        end
+
+        # expression resolved within parameterlist block
+        getSymbolTable1ExpressionsProcessor( exp.parameterList ).process( exp.block )
+        
+        
+        s()
+      end
+
+
+      ##
+      def process_ParameterList( exp )
+        logger.info "#{__method__}: #{exp} entered"
+
+        
+        scoped( exp ) do
+          process_rest( exp  )
+        end
+      end
+
+      
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group Node rules using scopes
+
+      def process_VariableDeclaration( exp )
+
+        logger.debug "#{__method__}: define variable name=#{exp.name}, type=#{exp.type}" if logger.debug?
+
+        # declaration defines
+        currentScope.define( exp.name, exp )
+        
+        # add back pointer to the scope where the variable is defined 
+        exp.scopeDefining = currentScope
+        
+        process_rest( exp )
+      end
+
+      def process_ElementaryTypeName( exp)
+        
+        # add back pointer to the scope where the variable is defined 
+        exp.scopeDefining = currentScope
+
+        s()
+      end
+
+      def process_UserDefinedTypeName( exp )
+        exp.scopeDefining = currentScope
+        s()        
+      end
+
+      
+      def process_Domain( exp )
+        exp.scopeDefining = currentScope
+        s()        
+      end
+      
+
+      
+    end # SexpProcessorSymbolTable1
+
+    # process expressions (within function body)
+    
+    class SymbolTable1Expressions < SexpProcessorEthereum
+
+      def initialize( options={} )
+        super( options )
+      end
+
+      # @attr [Scope] currentScope which currently opened
+      attr_accessor :currentScope
+
+      def process_NewExpression( exp )
+        logger.debug "#{__method__}: exp=#{exp}" if logger.debug?
+        exp.enclosingScope = currentScope
+        # No need to recurse furher
+        # process_rest( exp )
+      end
+
+      
+      def process_Return( exp )
+
+        # advance above parameter list
+        functionScope = currentScope.enclosing_scope
+        # functionScope = currentScope
+        functionScopeExpect = :FunctionDefinition
+        raise  SexpProcessorDataflowException.new "Incorrect sexp_type '#{functionScope.sexp_type}' in #{exp}, expecting '#{functionScopeExpect}'" if functionScopeExpect != functionScope.sexp_type
+
+        # back pointer to function scope where the return expression is set
+        exp.scopeDefining = functionScope
+        
+        process_rest( exp )
+        
+      end
+      def process_MemberAccess( exp )
+        
+        logger.debug "#{__method__}: exp=#{exp}" if logger.debug?
+        # register scope of reference
+        exp.enclosingScope = currentScope
+        
+        process_rest( exp )
+
+      end
+      def process_Identifier( exp )
+
+        logger.debug "#{__method__}: exp-value=#{exp.value}, type=#{exp.type}" if logger.debug?
+
+        # register scope of reference
+        exp.enclosingScope = currentScope
+
+        process_rest( exp )
+      end
+
+      # @!endgroup  
+      
+    end
+
+  end
+end

data/lib/sbuilder/sexp_processor_symboltable2.rb

@@ -0,0 +1,175 @@
+module Sbuilder
+  module Ethereum
+
+
+    # Assumes that
+    # - scope hierarchy has been created
+    # - declarations added to scopes
+    #
+    # Traverse AST and
+    # - resolve declarations
+
+    class SexpProcessorSymbolTable2 < SexpProcessorEthereum
+
+      # ------------------------------------------------------------------
+      # @!group Construct & configure
+      
+      def initialize( options={} )
+        super( options )
+      end
+      
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group Resolve references
+
+      def process_ContractDefinition( exp )
+        logger.debug "#{__method__}: #{exp}" if logger.debug?
+        
+        # all contract inherit from 'address'
+        exp.inherits( exp.globalScope.resolveOrReportError( Constants::SOL_ADDRESS ) )
+        process_rest( exp )
+      end
+
+
+      def process_MemberAccess( exp )
+        logger.debug "#{__method__}: #{exp}" if logger.debug?
+
+        # Cases:
+        #
+        # * s( :MemberAccess, s(:Identifier s(:ElementaryTypeName)))
+        #
+        # * msg.sender.send s( :MemberAccess, s( :MemberAccess,
+        #   s(:Idenfier, s(:UserDefinedTypeName)))
+        # 
+        # * s(:MemberAccess, "value", s(:TupleExpression,
+        # s(:NewExpression, "function () returns (contract Demo1)",
+        # s(:UserDefinedTypeName, "Demo1"))))
+        
+        # resolve 'declationRef' under 'memberStruct' before
+        # processing 'exp'
+        process_rest( exp )
+
+        logger.debug "#{__method__}: use exp.memberStruct=#{exp.memberStruct} with declationRef #{exp.memberStruct.declationRef} to resolve '#{exp.member_name}'" if logger.debug?
+
+        if exp.isFunctionOnFunction
+          # calling "function on a function"
+          # e.g. f.gas(2).value(20)(), which calls the modified
+          # function 'f' and thereby sending 20 Wei and limiting the
+          # gas to 2.
+          #
+          # we catch 'FunctionOnFunction' separately in code
+          # generation phase, and have no need for declationRef
+          decl = nil
+        # elsif exp.memberStruct.declationRef.respond_to?( :isTypeSymbol ) && exp.memberStruct.declationRef.isTypeSymbol
+        #   # points contract - resolve in type hierarchy
+        #   decl = exp.memberStruct.declationRef.resolveMemberOrReportError( exp.member_name )
+        elsif exp.memberStruct.declationRef.respond_to?( :isScope ) && exp.memberStruct.declationRef.isScope
+          # points to scope (parameterlist?) - resolve within scope 
+          decl = exp.memberStruct.declationRef.resolveOrReportError( exp.member_name )          
+        else
+          # it is variable declaration
+          logger.debug "#{__method__}: use exp.memberStruct.declationRef=#{exp.memberStruct.declationRef} to resolve '#{exp.member_name}'" if logger.debug?          
+          declarationType = exp.memberStruct.declationRef.typeSexp
+          decl = declarationType.symbolTypeReference.resolveOrReportError( exp.member_name )          
+        end
+        
+        # and finally set the result
+        exp.declationRef= decl
+        logger.info "#{__method__}: resolved declaration #{decl} on member access #{exp}"
+
+        s()
+      end
+
+      ##
+      # s( :NewExpression, s(:UserDefinedTypeName) -> resolve fist
+      # contract and then resolve constructor
+      def process_NewExpression( exp )
+        logger.debug "#{__method__}: #{exp}" if logger.debug?        
+
+        # name of constructor called
+        contructorCalled = exp.contractConstructed.name
+        
+        # TODO: use some DRY method to map contract to constructor interface
+        constructorInterface="#{contructorCalled}()"
+
+        # Find contract, and within it resolve construtor interface
+        contractResolved = exp.enclosingScope.resolveOrReportError( contructorCalled )
+        constructorResolved = contractResolved.resolveOrReportError( constructorInterface )
+        logger.info "#{__method__}: contractResolved=#{contractResolved}, constructorResolved=#{constructorResolved}"
+
+        # Resolve succsess
+        exp.declationRef = constructorResolved
+        s()
+      end
+
+      def process_Identifier( exp )
+        raise "Could not set declaration ref on #{exp}" unless exp.isDeclarationRef
+        logger.debug "#{__method__}: #{exp}" if logger.debug?        
+
+        # was set in SexpProcessorSymbolTable1
+        scope = exp.enclosingScope
+
+        # now resolve reference
+        decl = scope.resolveOrReportError( exp.value )
+        logger.info "#{__method__}, resolved #{exp.value} -> #{decl.inspect}"
+        exp.declationRef= decl
+
+        # continue with tree traversal
+        process_rest( exp  )
+
+      end
+
+      def process_Domain( exp)
+        logger.debug "#{__method__}: #{exp}" if logger.debug?
+        typeName = exp.solidityType
+
+        if typeName
+
+          # typeName defined, for example on address domain, resolve
+          # 'symbolTypeReference' to point to solidity elementary type
+          # defined on global scope.
+
+          typeSymbol = exp.scopeDefining.globalScope.resolveOrReportError(typeName)
+          logger.info "#{__method__}: type resolve --> typeName=#{typeName} resolved to typeSymbol=#{typeSymbol}"
+
+          exp.symbolTypeReference = typeSymbol
+        end
+        process_rest( exp );
+        
+      end
+      
+
+      def process_ElementaryTypeName( exp)
+        logger.debug "#{__method__}: #{exp}" if logger.debug?
+
+        typeName = exp.typeName
+        # elementary types defined in global scope 
+        typeSymbol = exp.scopeDefining.globalScope.resolveOrReportError( typeName )
+        logger.info "#{__method__}: type resolve --> typeName=#{typeName} resolved to typeSymbol=#{typeSymbol}"
+
+        exp.symbolTypeReference = typeSymbol
+        process_rest( exp )
+        
+      end
+
+      # 
+      # resolve type of variable declarion
+      def process_UserDefinedTypeName( exp )
+        logger.debug "#{__method__}: #{exp}" if logger.debug?
+
+        typeName = exp.name
+        typeSymbol = exp.scopeDefining.resolveOrReportError( typeName )
+        raise "typeSymbol #{typeSymbol} is not 'TypeSymbol'" unless typeSymbol.respond_to?(:isTypeSymbol) && typeSymbol.isTypeSymbol
+        logger.info "#{__method__}: type resolve --> typeName=#{typeName} resolved to typeSymbol=#{typeSymbol}"
+
+        exp.symbolTypeReference = typeSymbol
+        process_rest( exp )
+      end
+
+      # @!endgroup
+      
+    end
+
+  end
+end