sbuilder-eth 0.0.4

data/lib/eth/sexp_processor_resolve.rb

@@ -0,0 +1,122 @@
+require 'sexp_processor'
+
+module Sbuilder
+  module Eth
+    class  SexpProcessorResolve < SexpProcessorEth
+      # ------------------------------------------------------------------
+      # @!group Constructor
+
+      def initialize( options={} )
+        super( options )
+        # Allow Sexp nodes to remain intact, see 'process_rest'
+        self.require_empty = false
+
+        # visitors just recurses - do not shift sexp (as sexp_processor default does)
+        self.default_method = :process_rest
+        
+      end
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group Resolvers for reference node types
+
+      # Resolve 'reference' on 'NewExpression' to point to constructor
+      # in contract pointed by 'classConstructed'
+      def process_NewExpression( sexp )
+
+        # resolve child particulary 'UserDefinedTypeName'
+        process_rest( sexp )
+
+        # Navigate to resolved contract
+        contract = sexp.classConstructed.reference
+
+        # resolve for constructor method
+        sexp.reference = contract.resolve( sexp.classConstructed["name"])
+
+        s()
+      end
+
+      def process_UserDefinedTypeName( sexp )
+        logger.debug "#{__method__}: sexp:#{sexp}" if logger.debug?
+
+        raise "Unscoped identifier '#{sexp['name']}' for #{sexp}" if sexp.enclosingScope.nil?
+        # Resolve user defined type name  in 'enclosingScope'
+        sexp.reference = sexp.enclosingScope.resolve(sexp['name'])
+
+        s()
+      end
+
+      def process_MemberAccess( sexp )
+        logger.debug "#{__method__}: sexp:#{sexp}" if logger.debug?
+
+        # resolve childs (ie. :Identifier, :MemberAccess) NB: can also
+        # be FunctionCall as is case for f.gas(1).value(2)(3,5,6)
+        process_rest( sexp )
+
+        # 'struct' should have been resolved by process_rest.
+        # No need to resolve function call modifiers
+
+        if sexp.struct.sexp_type == :FunctionCall
+
+        #   sexp.reference = scope.resolve( sexp["member_name"] ) unless sexp["member_name"] == Constants::FIELD_NAME_VALUE ||
+        # #                                                                sexp["member_name"] == Constants::FIELD_NAME_GAS          
+          
+        else
+          # scope is pointed by reference
+          scope = sexp.struct.reference
+          # Indirection for :VariableDeclaration: scope is actually the
+          # type of the :VariableDeclaration
+          scope = scope.variableType.reference if scope.sexp_type == :VariableDeclaration
+
+          if scope.sexp_type == :FunctionDefinition
+            #
+            # Case f.value(1).gas(1)(3,4) - value and gas modifiers of
+            # the function CALL are NOT defined in 'FunctionDefinition'
+            #
+            # Gas, value  - No need to resolve - raise exception for surprieses if
+            # 'member_name' is something else that 'value' or 'gas'.
+            #
+            # raise "Unexpected sexp #{sexp["member_name"]} of  in #{sexp}" unless sexp["member_name"] == Constants::FIELD_NAME_VALUE ||
+            #                                                                sexp["member_name"] == Constants::FIELD_NAME_GAS
+            # sexp.reference = sexp.functionCalled.reference
+            if sexp["member_name"] == Constants::FIELD_NAME_VALUE || sexp["member_name"] == Constants::FIELD_NAME_GAS
+              # point to called function
+              sexp.reference = sexp.struct.reference
+            else
+              sexp.reference = scope.resolve( sexp["member_name"] )
+            end
+                                                                         
+          else
+            # easy part
+            sexp.reference = scope.resolve( sexp["member_name"] )
+          end
+          
+        end
+
+        s()
+        
+      end
+
+      def process_Identifier( sexp )
+        logger.debug "#{__method__}: sexp:#{sexp}" if logger.debug?        
+
+        raise "Unscoped identifier '#{sexp['value']}' for #{sexp}" if sexp.enclosingScope.nil?
+        # Resolve identifier 'value' in 'enclosingScope' of 'sexp'
+        sexp.reference = sexp.enclosingScope.resolve(sexp['value'])
+
+        # continue with tree traversal
+        # process_rest( sexp  )
+        s()
+
+      end
+      
+
+      # @!endgroup
+
+      
+      
+    end
+  end
+end
+

data/lib/eth/sexp_processor_scope.rb

@@ -0,0 +1,355 @@
+# coding: utf-8
+require 'sexp_processor'
+
+module Sbuilder
+  module Eth
+
+    # Visit AstSexp, 1) create hierarchical symbol tables 2) define
+    # symbols, and 3) add pointer to encosing scope to expression
+    # needed to be resolved.
+    #
+    # Techinically:
+    # - 1) Scope#enclosingScope : build scope hierarchy
+    # - 2) Scope#define( name, sexp ): build symbol table defines
+    # - 3) Reference#enclosingScope : set scope for use for Scope#resolve
+    #
+    # Scope hierarchy built:
+    # - contract
+    #    - function
+    #      - input parameter = request message (key name "msg"), scope where expression
+    #        references are resolved
+    #      - return parameters = response message ( key name "return-")
+    #
+    # TODO:
+    #  - global scope
+    #  - structure types
+    #  - enums
+    #
+    #
+    #
+    
+    class  SexpProcessorScope < SexpProcessorEth
+
+      # ------------------------------------------------------------------
+      # @!group Object state
+
+      # @!attribute [Scope] currentScope which currently opened
+      attr_accessor :currentScope
+
+      # @!attribute [Hash] options  
+      attr_accessor :options
+
+      # @!endgroup
+
+
+      # ------------------------------------------------------------------
+      # @!group Constructor
+
+      def initialize( options={} )
+        super( options )
+
+        self.options = options
+        
+        initGlobalScope
+      end
+
+      def initGlobalScope
+        self.currentScope = GlobalScope.start( options )
+      end
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group Recursion helpers
+
+      def scoped( ethScope )
+        raise "Scope support missing in #{ethScope}" unless ethScope.respond_to?( :isScope ) && ethScope.isScope
+
+        # remember  'prevScope', update enclosing scope, switch '@currentScope', 
+        prevScope = currentScope
+        ethScope.enclosingScope = currentScope
+        self.currentScope = ethScope
+        
+        begin
+          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
+
+      def getScopeExpressionProcessor( scope )
+        proc = ScopeExpressionProcessor.new( options )
+        proc.currentScope = scope
+        proc
+
+      end
+
+      # @!endgroup
+
+
+      # ------------------------------------------------------------------
+      # @!group Node rules to recurse down
+
+      def process_ContractDefinition( sexp )
+
+        # add contract to global scope
+        currentScope.define( sexp['name'], sexp )
+                
+        scoped( sexp ) do
+          getScopeExpressionProcessor( currentScope ).process( sexp )          
+          process_rest( sexp )
+        end
+        s()
+      end
+
+      # Scope ModifierDefinitionReferences
+      # to 'msg' and :ParameterList parameters in
+      # :ModifierDefinition must be resolved dynamically during
+      # :ModifierInvocation. Global references can be resolved
+      # "normally" (=statically by sexp_processor_scope and
+      # sexp_processor_resolve), as well as :Idenfier references in
+      # sexp_processor_resolve.
+      # 
+      #
+      # Solution: we define 'msg' scope as :ParameterListWrapper
+      # encapsulating :ParameterList of :ModifierDefinition. Method
+      # 'scopeDefining', which would otherwise return :ParameterList
+      # or :ModifierDefinition, is changed to return :ParameterList of
+      # :FunctionDefintion from a value set dynamically into
+      # :ParameterListWrapper, when scope of modifier is known (=when
+      # processing :ModifierInvocation in :FunctionDefinition
+      # statements).
+      # 
+      def process_ModifierDefinition( sexp )
+        logger.debug "#{__method__}: sexp=#{sexp}" if logger.debug?
+
+        currentScope.define( sexp['name'], sexp )
+        
+        # Wrap :ModifierDefinition 'requestParameters' ParameterListWrapper
+        # sexp.wrapRequestParameters
+        
+        blockScope = sexp
+        scoped( sexp ) do
+          
+
+          # Define msg
+          currentScope.define( Constants::SOL_MSG, sexp.requestParameters)
+
+          # Add common params
+          addCommonRequestParameters( sexp.requestParameters, sexp)
+
+          # Scope 'normal' request paramers in () ModifierDefinition scope
+          sexp.requestParameters.parameters.each { |paramDecl| process( paramDecl ) }
+          scoped( sexp.requestParameters ) do
+            # scope request params within contract:func:input:output
+            process( sexp.requestParameters )
+          end
+          
+          
+          # currentScope.define( Constants::SYMBOL_RESPONSE_MSG, sexp.responseParameters )
+          # process( sexp.responseParameters )          
+          # local variables
+          process( sexp.block )
+        end
+        
+        # process expression on block with requestParameteres in scope context
+        getScopeExpressionProcessor( blockScope ).process( sexp.block )        
+        
+        s()
+        
+      end
+
+      # Create scope hierarchy for :FunctionDefintion, define symbols
+      # for declarations in a scope, and add pointers to scope for
+      # identfiers. 
+      #
+      # Implementation:
+      #
+      # - assumes preprocessing ensures return parameters have name
+      #
+      # - scope hieararchy: :FunctionDefintion, requestParameters,
+      #   responseParameters
+      #
+      # -symbol definitions:
+      #   - FunctionDefintion
+      #       - msg --> requestParameters
+      #       - local variables
+      #   - requestParameters
+      #       - request parameter name -> :VarDecl
+      #   - responseParameters
+      #       - response parameter name -> :VarDecl
+      #
+      # - scope identifiers
+      #   - requestParameters
+      #      -- modifierInvocations
+      #   - responseParameters
+      #      -- function body block
+      # 
+      #   
+      
+      def process_FunctionDefinition( sexp )
+        logger.debug "#{__method__}: sexp=#{sexp}" if logger.debug?
+
+        
+        currentScope.define( sexp['name'], sexp )
+        currentScope.define( Constants::SOL_THIS, sexp )        
+        
+        scoped( sexp ) do
+
+          # validate existing names for return value 
+          logger.debug "#{__method__}: sexp.responseParameters=#{sexp.responseParameters}" if logger.debug?
+          # assume preprocessing ensures return parameters have name
+          sexp.responseParameters.parameters.each { |parameter| raise "Unnamed return parameters are not supported yet #{parameter} in #{sexp}" if parameter["name"].empty? }
+
+          # Support msg.X, where X=sender, value, ...
+          currentScope.define( Constants::SOL_MSG, sexp.requestParameters )
+          
+          # TODO: remove, currently used to create response data types
+          # for this function
+          currentScope.define( Constants::SYMBOL_RESPONSE_MSG, sexp.responseParameters )
+
+          # add msg.sender, msg.recipient, msg.value
+          addCommonRequestParameters( sexp.requestParameters, sexp)
+          
+          scoped( sexp.requestParameters ) do
+
+            # scope request params within contract:func:input:output
+            process( sexp.requestParameters )
+            
+            # scope for modfifiers: contract:func:input
+            sexp.modifierInvocations.each do |modifier|
+              logger.debug "#{__method__}: scope-modifierInvocation:#{modifier}" if logger.debug?
+              # getScopeExpressionProcessor( sexp.requestParameters ).process( modifier )
+              getScopeExpressionProcessor( currentScope ).process( modifier )
+              
+            end
+
+            # declare return parametes within 'responseParameters' scope
+            scoped( sexp.responseParameters ) do
+              process( sexp.responseParameters )
+              # add scope for identifier references
+              getScopeExpressionProcessor( currentScope ).process( sexp.block )
+            end # scoped( sexp.responseParameters )
+            
+          end # request parameters
+
+          # local variables
+          process( sexp.block )
+          
+        end # scoped(sexp):  function
+        
+        s()
+      end
+      
+      # def process_ParameterList( sexp )
+      #   # logger.info "#{__method__}: #{sexp} entered"
+      #   scoped( sexp ) do
+      #     process_rest( sexp  )
+      #   end
+      # end
+      
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group Node rules for scoped ie. nodes using scope
+
+      def process_VariableDeclaration( sexp )
+        logger.debug "#{__method__}: sexp=#{sexp}" if logger.debug?
+        logger.info "#{__method__}: define variable name=#{sexp['name']}, type=#{sexp.sexp_type} within #{currentScope}"
+        
+        currentScope.define( sexp['name'], sexp )
+        process_rest( sexp  )
+      end
+
+      def process_VariableDeclarationWithDomain( sexp )
+        logger.debug "#{__method__}: sexp=#{sexp}" if logger.debug?
+        logger.info "#{__method__}: define variable name=#{sexp['name']}, type=#{sexp.sexp_type} within #{currentScope}"
+        
+        currentScope.define( sexp['name'], sexp )
+
+        # No need to go deeper
+        # process_rest( sexp  )
+
+        s()
+      end
+
+      
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group AST modifiers
+
+      # Add common request parameters (e.g. sender, value, recipient)
+      # to 'sexpRequestParameters' of a constructor or a normal
+      # contract function 'sexpFunctionDefinition'.
+      #
+      # @param sexpFuncOrModifier
+      #        [:FunctionDefinition,:ModifierDefinition] to add common
+      #        parametes rto
+      #      
+      #
+      def addCommonRequestParameters( sexpRequestParameters, sexpFuncOrModifier )
+        (sexpFuncOrModifier.sexp_type != :ModifierDefinition && sexpFuncOrModifier["isConstructor"] ?
+          Constants::COMMON_REQ_CONSTRUCTOR :
+           Constants::COMMON_REQ_MSG).each do |name_domain|
+          sexpRequestParameters.addChild( VariableDeclarationWithDomain.create( name_domain))
+        end
+        
+      end
+
+      # @!endgroup
+
+      
+    end
+
+    class ScopeExpressionProcessor < SexpProcessorEth
+
+      # @!attribute [Scope] currentScope which currently opened
+      attr_accessor :currentScope
+
+
+      def initialize( options={} )
+        super( options )
+
+        # self.options = options
+        
+      end
+
+      # ------------------------------------------------------------------
+      # @!group Individual expressions - set enclosingScope
+
+      def process_UserDefinedTypeName( sexp )
+        
+        logger.debug "#{__method__}: sexp==#{sexp}" if logger.debug?
+        raise "No current scope for #{sexp}" if currentScope.nil?
+
+        # save 'currentScope' to use in resolve declaration reference
+        sexp.enclosingScope = currentScope
+        
+        process_rest(sexp)
+        
+      end
+      
+
+      def process_Identifier( sexp )
+
+        logger.debug "#{__method__}: sexp==#{sexp}" if logger.debug?
+        logger.info "#{__method__}: sexp=#{sexp['value']}"
+
+        # save 'currentScope' to use in resolve declaration reference
+        sexp.enclosingScope = currentScope
+
+        process_rest(sexp)
+      end
+      
+      # @!endgroup
+
+      
+      
+    end
+  end
+
+end
+