sbuilder-ethereum 0.0.6

data/lib/sbuilder/sexp_processor_api.rb

@@ -0,0 +1,184 @@
+module Sbuilder;
+  module Ethereum
+    ##
+    # Load Api information to sbuilder using facade
+
+    class SexpProcessorApi < SexpProcessorEthereum
+      
+      # ------------------------------------------------------------------
+      # Attributes
+
+      # @attr [ApiLoaderFacade] apiFacade
+      attr_accessor :apiFacade
+
+      # ------------------------------------------------------------------
+      # Maintain state in tree tarversal
+
+
+      # @attr [ParamSet_If] currentInterface
+      attr_accessor :currentInterface
+
+      # @attr [ParamSetDef_If] currentDefinition 
+      attr_accessor :currentDefinition
+
+      # @attr [ParamSetRoot:Stack] paramSetStack
+      attr_reader :paramSetStack
+
+      # ------------------------------------------------------------------
+      # @!group Construct & configure
+      
+      def initialize( options={} )
+        super( options )
+        @paramSetStack = []
+      end
+      
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group wrap interfaces
+      
+
+      # @param [Interface] expInterface
+      def encloseInterface( expInterface )
+        logger.info "#{__method__}: #{expInterface}"
+
+        raise "Invalid call sequence, should have callde #apiFacade= before #process" unless apiFacade
+
+        # create new interface
+        self.currentInterface = apiFacade.newInterface( expInterface.path, expInterface.op )
+        
+        begin
+          # build new interface
+          yield
+        ensure
+          # pass interface object built to sbuilder
+          apiFacade.modelInterface( currentInterface )
+          self.currentInterface = nil
+        end
+      end
+
+      def encloseDefinition( expDefinition )
+        logger.info "#{__method__}: #{expDefinition}"
+
+        raise "Invalid call sequence, should have callde #apiFacade= before #process" unless apiFacade
+
+        # create new definition based on 'expDefinition.definitionType'
+        case expDefinition.definitionType
+        when :normal
+          self.currentDefinition = apiFacade.newDefinition( expDefinition.name )
+        when :function
+          self.currentDefinition = apiFacade.newFunctionDefinition( expDefinition.name )          
+        else
+          raise "Unknown definitionType #{expDefinition.definitionType}"
+        end
+        
+        begin
+          # build new interface
+          yield currentDefinition
+        ensure
+          # pass definition object built to sbuilder
+          apiFacade.modelDefinition( currentDefinition )
+          self.currentDefinition = nil
+        end
+      end
+      
+
+      def encloseParameterList( expParameterList )
+        logger.info "#{__method__}: currentInterface=#{currentInterface}"
+        paramSetStack.push( currentInterface  )
+        begin
+          # traverse the tree under the newly created scope
+          yield
+        ensure
+          paramSetStack.pop
+        end
+      end
+      
+      # ------------------------------------------------------------------
+      # @!group Sexp node actions
+
+      def process_Definition( exp )
+        logger.info "#{__method__}: #{exp}"
+
+        encloseDefinition( exp ) do |paramSet| 
+
+          exp.properties.each do |prop|
+            if prop[:type] == :parameter
+              sbuilderParameter = apiFacade.newParameter( prop[:name] )
+              domainName = prop[:domain_name]
+              logger.debug "#{__method__}: add definition parameter=#{sbuilderParameter} with domain '#{domainName}' for prop=#{prop}" if logger.debug?               
+              apiFacade.addParameter( paramSet, sbuilderParameter, domainName )
+            elsif prop[:type] == :reference
+              isArray = false
+              sbuilderParameter = apiFacade.newParameterReference( prop[:name], prop[:reference], isArray )
+              logger.debug "#{__method__}: add definition parameter=#{sbuilderParameter} for prop=#{prop}" if logger.debug? 
+              apiFacade.addParameter( paramSet, sbuilderParameter )              
+            else
+              raise "Unknown :type #{prop[:type]} in #{prop}, knwon types ':parameter', ':reference'" 
+            end
+            # add it to the parameter list on top of the stack
+          end
+          
+        end
+
+        s()
+      end
+
+      def process_Interface( exp )
+        logger.info "#{__method__}: #{exp}"
+        
+        encloseInterface( exp ) do
+          
+          encloseParameterList( exp ) do
+            
+            # processing arameter set on top of the stack
+            paramSet = paramSetStack.last
+            
+            exp.interfaceDefinition[:input].each do |param|
+              sbuilderParameter = apiFacade.newParameter( param[:name] )
+              logger.info "#{__method__}: add input parameter=#{sbuilderParameter}"
+              # add it to the parameter list on top of the stack
+              apiFacade.addParameter( paramSet, sbuilderParameter, param[:domain_name] )
+            end
+
+            exp.interfaceDefinition[:output].each do |param|
+              sbuilderParameter = apiFacade.newParameter( param[:name] )
+              logger.info "#{__method__}: add outpu parameter=#{sbuilderParameter}"
+              apiFacade.addResponseParameter( paramSet, sbuilderParameter, param[:domain_name] )
+            end
+            
+            # process_rest( exp.inputParameters )
+          end
+        end
+        s()
+      end
+
+      # def process_ParameterList( exp )
+      #   raise "no support for recursive  ParameterList"
+      #   # logger.info "#{__method__}"
+      #   # encloseParameterList( exp ) do
+      #   #   process_rest( exp )          
+      #   # end
+      # end
+      
+      # def process_VariableDeclaration( exp )
+      #   logger.info "#{__method__}: #{exp}}"
+      #   raise "Support only elementary types" unless exp.isElementary
+
+      #   # create elementary parameter
+      #   sbuilderParameter = apiFacade.newParameter( exp.name )
+        
+      #   # add it to the parameter list on top of the stack
+      #   paramSetStack.last.addParameter( sbuilderParameter )
+      #   s()
+      # end
+
+
+      # @!endgroup
+
+      
+    end # class
+    
+                   
+  end
+end

data/lib/sbuilder/sexp_processor_canonize.rb

@@ -0,0 +1,326 @@
+module Sbuilder
+  module Ethereum
+
+    require 'yaml'
+    require 'json'
+    
+    ##
+    # SexpProcessorCanonize know how to canonize SexpAst. It expect
+    # +SexpProcessorNeedToCanonize+ object in +needs+ attribute to
+    # know, what needs to be canonized. After canonization, this
+    # method returns +somethingCanonized+
+    #
+    # - constructor - if missing
+    # - balance - if missing
+    # - getter methods - if missing
+    #
+    # Generates unique identifiers using static variable +idGenerator+
+    #
+    # 
+    #
+    
+    class SexpProcessorCanonize < SexpProcessorEthereum
+
+
+
+      # @attr [SexpProcessorNeedToCanonize] needs SexpProcessor, which
+      # knows what needs to be added to SexpAst -tree.
+      attr_reader :needs
+
+
+      # @attr [Hash] optionss
+      attr_reader :options
+
+      # @attr [Boolean] somethingCanonized true if any chg in SexpTree
+      attr_reader :somethingCanonized
+
+      # @attr [String] compileUnit for better log message
+      attr_reader :compileUnit
+
+      # ------------------------------------------------------------------
+      # @!group Scoped
+
+      # @attr [Contract] currentContract which currently processing
+      attr_accessor :currentContract
+
+      # @attr [FunctionDefinition] currentFunction
+      attr_accessor :currentFunction
+      
+      
+      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
+
+      # @!endgroup
+      
+      
+      # ------------------------------------------------------------------
+      # @!group Construct & init & configure
+      
+      def initialize( options={} )
+        super( options )
+        logger.debug "#{__method__}: created"  if logger.debug?      
+
+        @options = options
+
+        initIt
+      end
+      
+
+      ## 
+      # Init +needs+ which knows what to canonize
+      # MUST BE CALLED FOR EACH FIX POINT ITERATION
+      def setNeeds( sexpProcessorNeedToCanonize )
+        @needs  = sexpProcessorNeedToCanonize
+        initIt
+      end
+
+      ##
+      # better log messages
+      def setCompileUnit( compileUnit )
+        @compileUnit = compileUnit
+      end
+
+      def initIt
+        # default no changes - toggle if changed
+        @somethingCanonized = false
+      end
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group scope support
+
+      # @attr [Contract] currentContract which currently processing
+      attr_accessor :currentContract
+
+      def contracted( expContract )
+
+        @currentContract = expContract
+        begin
+          yield
+        ensure
+          @currentContract = nil
+        end
+      end
+
+      ##
+      # Set flag +somethingCanonized+ to indicate that SexpAst has been modified
+      def addNewNode( exp, chldExp )
+
+        logger.debug "#{__method__}: add #{chldExp}, to #{exp}" if logger.debug?
+        
+        # # Added as child --> add pointer to parent
+        # chldExp.setParent(  exp )
+        # exp << chldExp
+        SexpUtils.addNewChild( exp, chldExp )
+
+        # Iterate as long as something has changed
+        @somethingCanonized = true
+      end
+
+      
+
+      # @!endgroup
+
+      ##
+      # @return [s(s(name,functionAst))] array of name/function Ast pair, which
+      # any address implements. 
+      def getAddressFunctions
+        return @addressFunctions if  @addressFunctions
+        @addressFunctions
+      end
+      
+
+      # ------------------------------------------------------------------
+      # @!group Tree traversal
+      def process_GlobalScope( exp )
+
+        mapLiterals
+        process_rest( exp  )
+        
+      end
+
+      def process_ContractDefinition( exp )
+        logger.debug "#{__method__}: exp=#{exp}" if logger.debug?
+
+
+        # Add constructor?
+        logger.debug "#{__method__}: #{compileUnit} needs.needConstructor=#{needs.needConstructor}" if logger.debug?
+        if needs.needConstructor
+          constructor = SexpUtils.createConstructorNode( exp.name )
+          logger.info "#{__method__}: add constructor=#{constructor} to exp=#{exp}"          
+          # exp << constructor
+          addNewNode( exp, constructor )
+        end
+
+
+        # Add variableDeclation?
+        logger.debug "#{__method__}: #{compileUnit} needs.needVariableDeclarations=#{needs.needVariableDeclarations}" if logger.debug?
+        needs.needVariableDeclarations.each do |variableName|
+
+          newVariableDeclaration = SexpUtils.createVariableDeclaration( variableName )
+          logger.info "#{__method__}: add newVariableDeclaration=#{newVariableDeclaration} to #{exp.name}"                    
+          
+          addNewNode( exp, newVariableDeclaration )
+        end
+
+        # Add getters?
+        logger.debug "#{__method__}: needs.neededGetters=#{needs.neededGetters}" if logger.debug?
+        needs.neededGetters.each do |variableName|
+
+          newGetter = SexpUtils.createGetter( variableName )
+          logger.info "#{__method__}: add newGetter=#{newGetter} to exp=#{exp}"                    
+          addNewNode( exp, newGetter )
+        end
+
+        logger.debug "#{__method__}: needs.assignmentOperatorSplits=#{needs.assignmentOperatorSplits}" if logger.debug?
+        needs.assignmentOperatorSplits.each do |assignmentOperatorSplit|
+          logger.info "#{__method__}: split assignment assignmentOperatorSplit=#{assignmentOperatorSplit}"
+          binOp = SexpUtils.createBinaryOperator( SexpUtils.mapAssignmentOperator(assignmentOperatorSplit.operator) )
+          binOp << assignmentOperatorSplit.lval
+          binOp << assignmentOperatorSplit.rval
+          # canonize
+          assignmentOperatorSplit.setOperator
+          assignmentOperatorSplit.setRval( binOp )          
+          logger.info "#{__method__}: canonizned assignment=#{assignmentOperatorSplit}"
+        end
+
+        # # TODO remove
+        # # Change assignment rval from :FunctionCall to :FunctionCallReadReturn
+        # logger.debug "#{__method__}: needs.assignmentsToSplit=#{needs.assignmentsToSplit}" if logger.debug?
+        # needs.assignmentsToSplit.each do |assignmentToSplit|
+        #   readReturn = FunctionCallReadReturn.define( assignmentToSplit.rval )
+        #   assignmentToSplit.changeRval( readReturn )
+        #   logger.info "#{__method__}: split assignmentToSplit=#{assignmentToSplit}"
+        # end
+
+        mapLiterals
+        
+        contracted( exp ) do 
+          process_rest(exp)
+        end
+        logger.info "#{__method__}: #{compileUnit} needs. somethingCanonized=#{somethingCanonized}"
+        
+        exp
+      end
+
+      
+      def process_FunctionDefinition( exp )
+        logger.debug "#{__method__}: exp=#{exp}" if logger.debug?
+
+        # [ s( FUnctionDef, [name, ...] )] 
+        parametersToAdd = needs.missing_request_parameters.
+                     select { |sexp| sexp[0] == exp }.
+                     map { |sexp| sexp[1] }.first
+
+        # something to add
+        if  parametersToAdd && parametersToAdd.any? then
+          logger.info "#{__method__}: #{exp.name} should add parametersToAdd=#{parametersToAdd} to with #{exp.parameterList.length} "
+
+          # parameter = s(:parameter, name, domainName )
+          parametersToAdd.each do |parameter|
+            # exp.parameterList << s(:VariableDeclaration, name, s(:Domain, domainName ))
+            newParameter = SexpUtils.createVariableDeclarationWithDomain( parameter[1], parameter[2] )
+            addNewNode( exp.parameterList, newParameter )
+          end
+          logger.info "#{__method__}: after add #{exp}"
+          
+        end
+
+        functed( exp ) do 
+          process_rest(exp)
+        end
+
+        s()
+      end
+
+      def process_Block( exp )
+        logger.debug "#{__method__}: exp=#{exp}" if logger.debug?
+        
+        # functionCallsToSplit: s( s(:Block), s(:Statement), s(:FunctionCall) )
+        bodySplitters = needs.functionCallsToSplit.select{ |functionCallToSplit| functionCallToSplit[0].equal?(exp) }
+
+        # something to expand in this body before recursion
+        if bodySplitters.any? then
+          
+          logger.debug "#{__method__}: should split #{bodySplitters.length} stmts with #{bodySplitters} in block #{exp} " if logger.debug?
+          
+          bodySplitters.each do |bodySplitter|
+
+            bodyStatement = bodySplitter[1] 
+            functionCall = bodySplitter[2]
+
+            logger.info "#{__method__} split stmt #{functionCall} for function call #{functionCall}"
+            # add s(:FunctionCall) to s(:Body) just before s(:Statement)
+            raise "Could not find #{bodyStatement} in #{exp}" if exp.find_index( bodyStatement ).nil?
+            exp.insert( exp.find_index( bodyStatement ), functionCall )
+
+            # wrap s(:FunctionCall ) in parent  with s(:FunctionCallReadReturn)
+            wrappedFunctionCall = FunctionCallReadReturn.define( functionCall  )
+            functionCall.parent[functionCall.parent.find_index( functionCall)] = wrappedFunctionCall
+          end
+          logger.info "#{__method__}: after split #{exp}"          
+        end
+        
+        process_rest( exp )
+      end
+        
+      
+
+      def process_VariableDeclaration( exp )
+        logger.debug "#{__method__}: exp=#{exp}" if logger.debug?
+
+        ##
+        # If there is variable declatrion without name for 'exp'
+        if needs.variable_declarations_without_name.include?( exp )
+          logger.info "#{__method__}: update name '#{currentFunction.name}' for #{exp}"
+          exp.setName( currentFunction.name )
+        end
+
+        s()        
+      end
+      
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group Utilities
+
+      ##
+      # Change value in literal
+      #
+      # @param [s(literalSexp,value):Array] map_literalValue
+      private def mapLiterals()
+        logger.debug "#{__method__}: needs.map_literalValue=#{needs.map_literalValue}" if logger.debug?
+        if needs.map_literalValue &&  needs.map_literalValue.any?
+          needs.map_literalValue.each do |literalSexpToValue|
+            literalSexp = literalSexpToValue[0]
+            newValue =  literalSexpToValue[1]
+            logger.info "#{__method__}: set newValue=#{newValue} in literalSexp #{literalSexp}"
+            literalSexp.setValue( newValue )
+          end
+        end
+      end
+
+      # @!endgroup      
+      
+    end
+  end
+end