sbuilder-ethereum 0.0.6

data/lib/sbuilder/sexp_processor_ethereum.rb

@@ -0,0 +1,127 @@
+module Sbuilder
+  module Ethereum
+
+# A class allowing sbuilder ethereum to extend 'SexpProcessor'
+# behaviour. (Possible candidate for extension env)
+
+class SexpProcessorEthereum < SexpProcessor
+
+  PROGNAME = nil                        # progname for logger default class name
+  include MyLogger     # mix logger
+
+  # @attr [Hash] options
+  # @option options [String] :log  e.g. "WARN"
+  # @option options [String|STDOUT] :logfile e.g. STDOUT
+  attr_reader :options
+
+  # @attr [Logger] logger
+  attr_reader :logger
+  
+  # ------------------------------------------------------------------
+  # @!group Contstruct and configure
+
+  def initialize( options={} )
+    super()
+
+    @options = options
+    @logger = getLogger( nil, options )
+    
+    # Override defaults in parent class
+    self.strict = false
+    
+    # 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
+    
+    # no warning needed when using default method
+    self.warn_on_default = false
+    
+  end
+
+  # @!endgroup      
+
+  # ------------------------------------------------------------------
+  # @!group Node rules
+
+  # @!endgroup    
+
+  # ------------------------------------------------------------------
+  # @!group Visitor helpers
+
+  ##
+  # Process each element of #exp in turn.
+  
+  # def process_until_empty exp
+  #   until exp.empty?
+  #     sexp = exp.shift
+  #     process sexp if Sexp === sexp
+  #   end
+  #   s()
+  # end
+
+
+  ##
+  # Process each element of +exp+ in turn
+
+  def process_rest exp
+    pos = 0
+    ret = s()
+    until pos >= exp.length
+      sexp = exp[pos]
+      pos += 1
+      psexps = process( sexp ) if Sexp === sexp
+      if !psexps.nil? && psexps.sexp_type == :dummy
+        # :dummy get flattened
+        psexps.rest.each do |psexp|
+          ret << psexp
+        end
+      else # non-dummy sexp || nil sexp
+        ret << psexps unless psexps.nil?
+      end
+    end
+    ret
+  end
+  
+
+  # Default operation: current node does not contribute to sexp,
+  # flatten it
+  def process_skip exp
+    ret = process_rest( exp )
+    return ret if ret.length == 0
+    return ret.first if ret.length == 1
+    raise <<-EOS
+    Expect child nodes to return s() or s( s(:any, ...)) -
+
+    When processing exp: #{exp}
+
+    process_rest returns: #{ret} 
+
+    EOS
+  end
+
+  # Default operation: do nothing
+  def process_none exp
+    s()
+  end
+
+
+  def process_abort exp
+    
+    raise <<-EOS
+    Implementation missing for #{exp}
+    EOS
+    
+  end
+  
+
+  
+  # @!endgroup
+  
+  
+end
+
+
+      end
+end

data/lib/sbuilder/sexp_processor_need_to_canonize.rb

@@ -0,0 +1,572 @@
+module Sbuilder
+  module Ethereum
+
+    ##
+    #
+    # Add
+    # - constructor - if missing
+    # - balance - if missing
+    # - getter methods - if missing
+    
+    class SexpProcessorNeedToCanonize < SexpProcessorEthereum
+
+      # ------------------------------------------------------------------
+      # @!group canonize operations
+
+      # @attr [Boolean] needConstructor
+      attr_reader :needConstructor
+
+      # @attr [String:Array] needVariableDeclarations, initialized
+      # with variable names, which will be added (unless they are defined)
+      attr_reader :needVariableDeclarations
+
+      # @attr [String:Array] neededGetters variable names missing
+      # getters, add entry each variable declation, and remove for
+      # each getter.
+      attr_reader :neededGetters
+
+      # @attr [Assignment:Array] assignmentOperatorSplits
+      attr_reader :assignmentOperatorSplits
+
+      
+      # @attr [SexpAst:Array] functionCallsToSplit s(Block, Statement, FunctionCall)
+      attr_reader :functionCallsToSplit
+
+
+      # @attr [s(FunctionDef, s(s(:parameter, name,domain), s(:parameter, name, domain)]), ... )]
+      attr_reader :missing_request_parameters
+
+      # @attr [VariableDeclaration:Array] variable_declarations_without_name
+      attr_reader :variable_declarations_without_name
+
+      # @attr [s(Sexp(Literal), value ):Array]
+      attr_reader :map_literalValue
+
+      # @!endgroup
+
+      # @attr [Hash] optionss
+      attr_reader :options
+
+      # @!endgroup      
+
+      # ------------------------------------------------------------------
+      # @!group Configs
+
+      # https://github.com/ethereum/wiki/wiki/Solidity-Features#contracts-inherit-all-members-from-address
+      #
+      # a contract type contains all members of the address type with
+      # the semantics applying to the contract's address, unless
+      # overwritten by the contract.
+      #
+      # Balance is hold in 'eth_accounts' not in eth_storageRoot
+      INHERITED_VARIABLE_DECLARATIONS = [
+        Constants::FIELD_NAME_ADDRESS,
+        # Constants::FIELD_NAME_BALANCE,
+      ]
+
+      ##
+      # Require 'expLiteral.type' to have TLA-value, if this is not the case
+      # check if 'expLiteral.value' is defined
+      LITERAL_MAPPINGS = {
+
+        # solc integer literals 'int_const 42', no rule to change
+        # value needed
+        /int_const/ => {
+          :rules => nil
+        },
+
+        # solc 'bool' is mapped to TLA-domain 'BOOLEAN' with values
+        # 'TRUE' and 'FALSE'
+        'bool' => {
+          :rules => {
+            # TLA-value => solc value
+            'TRUE' => 'true',
+            'FALSE' => 'false',
+          }
+        }
+      }
+
+      # @!endgroup      
+      
+      # ------------------------------------------------------------------
+      # @!group Construct & configure
+      
+      def initialize( options={} )
+        super( options )
+        logger.debug "#{__method__}: created" if logger.debug?
+        
+        @options = options
+
+        # reset state
+        initIt
+
+      end
+
+      def initIt()
+        ##
+        logger.info "#{__method__} called"
+        
+        # default - constructor should be added
+        @needConstructor = true
+        
+        # default - no getters need
+        @neededGetters = []
+
+        # default - inherited variables should be added.  NOTICE:
+        # clone here because later we are using
+        # needVariableDeclarations.delete opreation!!
+        @needVariableDeclarations = INHERITED_VARIABLE_DECLARATIONS.clone
+
+        # split assignment/conditional/.. with function calls
+        @functionCallsToSplit = []
+
+        # add: msg.value, msg.sender, etc. to FunctionDefinition
+        @missing_request_parameters = []
+
+        # invent a name: (function definition)
+        @variable_declarations_without_name =  []
+
+        # map literal.value to tlavalue
+        @map_literalValue = []
+
+        # split assigment operator += etc.
+        @assignmentOperatorSplits = []
+
+        # currentCall initially nil
+        @currentCall = nil
+
+      end
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group scope support
+
+      # @attr [Contract] currentContract which currently processing
+      attr_accessor :currentContract
+
+      # @attr [FunctionDefinition] currentFunction
+      attr_accessor :currentFunction
+
+      # @attr [IfStatement] currentIf
+      attr_accessor :currentIf
+
+      # @attr [Block] currentBlock
+      attr_accessor :currentBlock
+
+      # @attr [IfStatement] currentAssign
+      attr_accessor :currentAssign
+
+      # @attr [FunctionCall] currentCall
+      attr_accessor :currentCall
+
+      # @attr [Sexp] s(s(:parameter, name domain), ...)
+      attr_accessor :request
+      
+      # @attr [Sexp] s(s(:parameter, name domain), ...)
+      attr_accessor :response
+
+      def contracted( expContract )
+
+        self.currentContract = expContract
+        begin
+          yield
+        ensure
+          self.currentContract = nil
+        end
+      end
+
+      def functed( expFunctionDef )
+        self.currentFunction = expFunctionDef
+        begin
+          yield
+        ensure
+          self.currentFunction = nil
+        end
+
+      end
+
+      def funcCalled( exp )
+        self.currentCall = exp
+        begin
+          yield
+        ensure
+          self.currentCall = nil
+        end
+
+      end
+      
+
+      def iffed( expIf )
+        prevIf = currentIf
+        self.currentIf = expIf
+        begin
+          yield
+        ensure
+          self.currentIf = prevIf
+        end
+
+      end
+      
+      def blocked( expBlock )
+        prevBlock = currentBlock
+        self.currentBlock = expBlock
+        begin
+          yield
+        ensure
+          self.currentBlock = prevBlock
+        end
+
+      end
+      
+      def assigned( expAssign )
+        prevAssign = currentAssign
+        self.currentAssign = expAssign
+        begin
+          yield
+        ensure
+          self.currentAssign = prevAssign
+        end
+
+      end
+      
+
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group Rules triggering actions
+
+      # @return [Boolean] true if +expFunction+ is constructor for +currentContract+
+      def isConstructor( expFunction )
+        currentContract && expFunction.name == currentContract.name
+      end
+
+
+      # @!endgroup      
+      
+
+      # ------------------------------------------------------------------
+      # @!group Tree traversal
+
+      def process_GlobalScope( exp )
+        logger.debug "#{__method__}: exp=#{exp}" if logger.debug?
+
+        # wrap
+        contracted( exp ) do
+          process_rest( exp  )          
+        end
+        
+      end
+      
+
+      def process_ContractDefinition( exp )
+        logger.debug "#{__method__}: exp=#{exp}" if logger.debug?
+
+        # wrap
+        contracted( exp ) do
+
+          logger.debug "#{__method__}: start iterating FindVariableDeclarations for exp=#{exp}"  if logger.debug?
+          FindVariableDeclarations.new( self, options ).process( exp )
+          FindMissingSetters.new( self, options ).process( exp )          
+
+          process_rest( exp  )
+        end
+        s()
+      end
+
+      ## 
+      # see if it is a constructor - toggle if not
+      #
+      # - adds method #interfaceName
+      #
+      def process_FunctionDefinition( exp )
+        logger.debug "#{__method__}: exp=#{exp}" if logger.debug?
+        if isConstructor( exp )
+          logger.info "#{__method__}: consructor already defined #{exp}"
+          @needConstructor = false
+          interfaceName = "#{currentContract.name}()" 
+        else
+          interfaceName = "#{currentContract.name}(#{exp.name})"
+        end
+
+        if !exp.respond_to?( :interfaceName ) then
+          logger.info "#{__method__}: addeded method :interfaceName to return #{interfaceName}"
+          SexpUtils.defineInterfaceName( exp, interfaceName )
+          # exp.define_singleton_method( :interfaceName ) do
+          #   interfaceName
+          # end
+        end
+
+        # parameter lists
+        functed( exp ) do
+
+          logger.debug "#{__method__}: exp=#{exp}" if logger.debug?
+          formalParametersToFunction = exp.parameterList.parameters ? exp.parameterList.parameters.map { |varDecl| varDecl.name } : []
+
+          # should add parameters which are NOT found on current formal parameter list
+          parametersNeeds = TlaElementText.commonMsgProperties( 'request', isConstructor(exp)).
+            select { |par| !formalParametersToFunction.include?(par[1] )  }          
+
+          if parametersNeeds.any?
+            logger.info "#{__method__}: parametersNeeds=#{parametersNeeds} in #{exp.name}"
+            @missing_request_parameters << s(exp, parametersNeeds )
+          end
+
+          # process function stmts
+          process_rest( exp )
+        end
+        s()
+      end
+
+      def process_Block( exp )
+        logger.debug "#{__method__}: #{exp}" if logger.debug?
+
+        #wrap
+        blocked( exp ) do
+          process_rest( exp )
+        end
+        s()
+      end
+
+      ##
+      # Identify: 'if ( !msg.sender.send( msg.value ) )'
+      def process_IfStatement( exp )
+        logger.debug "#{__method__}: #{exp}" if logger.debug?
+
+        # if 
+        iffed( exp ) do
+          process( exp.condition )
+        end
+
+        # then
+        blocked( exp.then_branch )  do
+          process( exp.then_branch )
+        end
+
+        # else
+        if exp.else_branch
+          blocked( exp.else_branch ) do 
+            process( exp.else_branch )
+          end
+        end
+        s()
+      end
+
+      
+
+      ## 
+      # Identify 'var = func()'
+      def process_ExpressionStatement( exp )
+        logger.debug "#{__method__}: #{exp}" if logger.debug?
+        assigned( exp ) do
+          process_rest( exp )          
+        end
+        s()
+      end
+
+      def process_FunctionCallReadReturn( exp )
+        logger.debug "#{__method__}: #{exp}" if logger.debug?
+        # FunctionCallReadReturn indicates that canonzation has
+        # already taken place. no need to go down anymore
+        s()
+      end
+
+      def process_Assignment( exp )
+        logger.debug "#{__method__}: #{exp}" if logger.debug?
+        if exp.operator != '='
+          logger.info "#{__method__}: split assignment #{exp}"
+          assignmentOperatorSplits << exp 
+        end
+        process_rest( exp )
+      end
+      
+      def process_FunctionCall( exp )
+        logger.debug "#{__method__}: #{exp}" if logger.debug?
+
+        # split only fist level function in functionOnFunction -case
+        if currentAssign && currentCall.nil?
+          @functionCallsToSplit << s( currentBlock, currentAssign, exp )
+          logger.info "#{__method__}: function-call in assingment split #{currentAssign}"
+        elsif currentIf && currentCall.nil?
+          @functionCallsToSplit << s( currentBlock, currentIf, exp )
+          logger.info "#{__method__}: function-call in if split #{currentIf}"          
+        end
+          
+        funcCalled( exp ) do
+          process_rest( exp )
+        end
+      end
+
+      def process_Literal( exp )
+        logger.debug "#{__method__}: #{exp}" if logger.debug?
+        # should literal be remapped (e.g. true -> TRUE),
+        # no need to remap integers
+        tlaValue = checkLiteralMapping( exp )
+        if tlaValue
+          # add to task list
+          logger.info "#{__method__}: map-literal tlaValue=#{tlaValue} on #{exp}"          
+          
+          @map_literalValue << s(exp, tlaValue)
+        end
+        process_rest( exp )
+      end
+
+      # def match( parameter )
+      #   matchRule.is_a?( String ) ? parameter.name == matchRule  : (parameter.name =~ matchRule) != nil
+      # end
+
+
+      ##
+      # @return [Hash] mapper
+      # @option mapper [:Symbol] :rules defining mapping, nil if no mapping needed
+      private def findMapperHash( expLiteral )
+        mapperes = LITERAL_MAPPINGS
+        literalType = expLiteral.type.to_s
+        mapperes.each do |key,mapper|
+          # quit block && subroutine if found
+          return mapper if key.is_a?( String ) ?  literalType == key  : (literalType =~ key) != nil
+        end
+
+        nil
+      end
+
+      # @!endgroup      
+
+      # ------------------------------------------------------------------
+      # @!group utils
+
+      ##
+      # Check if literal should be remapped, and return mapper suggesion
+      # @return [Hash] tlaValue
+      # @option tlaValue [String] key as solcValue
+      # @option tlaValue [String] value in tla
+      private def checkLiteralMapping( expLiteral )
+        logger.debug "#{__method__}: check in solc type '#{expLiteral.type}' that value '#{expLiteral.value}' valid for tla " if logger.debug?        
+
+        #
+        mapperHash = findMapperHash( expLiteral )
+        logger.debug "#{__method__}: mapperHash=#{mapperHash}" if logger.debug?                
+        
+
+        # Must be known literal type
+        raise SbuilderEtherumException, "Unkown literal type '#{expLiteral.type}', supported types #{mapperHash.keys}" if mapperHash.nil? 
+        
+
+        # No need to map if no rules defined
+        return nil unless  mapperHash[:rules]
+        # Literal value valid TLA value in :rules
+        return nil if mapperHash[:rules][expLiteral.value]
+
+        # Invert mapper table for 'epx.type' i.e map solc=>tla
+        reverseMapper =  mapperHash[:rules].inject( {}){ |solc2tla,(tla,solc)| solc2tla[solc] = tla;  solc2tla }
+
+        # use inverted mapper to find TLA-name,
+        tlaValue = reverseMapper[expLiteral.value]
+        raise SbuilderEtherumException, "Could not map literal value '#{expLiteral.value}' for #{expLiteral} using #{reverseMapper}" unless tlaValue
+        logger.info "#{__method__}: map literal value '#{expLiteral.value}' to TLA value '#{tlaValue}' in  #{expLiteral}"
+        tlaValue
+        
+      end
+      
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group Specialized processeros
+
+      ##
+      # For each contract 'VariableDeclaration' remove in
+      # +needVariableDeclarations+, and add +neededGetters+.
+      #
+      
+      class  FindVariableDeclarations < SexpProcessorEthereum
+
+        # @attr [SexpProcessorNeedToCanonize] parent
+        attr_reader :parent
+
+        def initialize( parent, options={} )
+          super( options )
+          logger.debug "#{__method__}: created" if logger.debug?
+          @parent = parent
+        end
+
+
+        ##
+        # Actions: 1 ) add contract variables to
+        # +parent.neededGetters+, remove from
+        # +parent.needVariableDeclarations+ 2) if variable declation
+        # does not have a name
+        def process_VariableDeclaration( exp )
+          logger.debug "#{__method__}: exp=#{exp}, exp.parent=#{exp.parent}" if logger.debug?
+          # parent.gettersNeeded << exp
+
+          if !exp.name or exp.name.length == 0
+            logger.info "#{__method__}: variable declared without name #{exp}"            
+            parent.variable_declarations_without_name  << exp
+          end
+
+          if exp.parent && exp.parent.sexp_type == :ContractDefinition
+
+            logger.debug "#{__method__}: variable declaration for contract, exp=#{exp}" if logger.debug?
+          
+            # contract variable declared - remove it form the list 
+            deleted = parent.needVariableDeclarations.delete( exp.name )
+            logger.debug "#{__method__}: variable already declared #{deleted}" if logger.debug?
+            
+            # each contact varibale decl should have a getter
+            parent.neededGetters << exp.name
+          end
+          
+          s()
+        end
+        
+      end
+
+      class  FindMissingSetters < SexpProcessorEthereum
+
+        # @attr [SexpProcessorNeedToCanonize] parent
+        attr_reader :parent
+
+        def initialize( parent, options={} )
+          super( options )
+          logger.debug "#{__method__}: created" if logger.debug?
+          @parent = parent
+        end
+
+
+        ##
+        # remove from +parent.neededGetters+ if getter
+        def process_FunctionDefinition( exp )
+          logger.debug "#{__method__}: exp=#{exp}" if logger.debug?
+
+          # if getXaaB --> XaaB (or nil)
+          getterForVariable = exp.name[/get([A-Z]\w*)/, 1]
+          logger.debug "#{__method__}: exp.name=#{exp.name} --> extracted=#{getterForVariable}" if logger.debug?
+
+          # function name parses like getter 
+          if ! getterForVariable.nil?
+            # xaaB --> xaaB
+            getterForVariable = getterForVariable[0,1].downcase + getterForVariable[1..-1]
+            logger.debug "#{__method__}: variable to get =#{getterForVariable}" if logger.debug?
+
+            # Getter implemented -> remove it from +parent.neededGetters+
+            parent.neededGetters.delete( getterForVariable ) 
+          end
+          
+          s()
+        end
+
+        
+      end
+
+      
+
+
+      # @!endgroup      
+      
+      
+    end
+
+  end
+end