sbuilder-eth 0.0.4

data/lib/eth/exception.rb

@@ -0,0 +1,9 @@
+module Sbuilder
+  module Eth
+    class CompilerException < Exception; end
+    class TranslatorException < Exception; end
+    class MissingImplementation < Exception; end    
+    class EthereumException < Exception; end
+    class ScopeException < Exception; end            
+  end
+end

data/lib/eth/global_scope.rb

@@ -0,0 +1,100 @@
+
+module Sbuilder
+  module Eth
+
+    module Test
+      def hei
+      end
+    end
+
+    class GlobalScopeEntry  < AstSexp
+
+      include Sbuilder::Eth::Scoped
+      def initialize
+        super( self.class.name.split('::').last.to_sym  )
+      end
+      # @return [Symbol] class basename (as a symbol)
+      # def sexp_type
+      #   self.class.name.split('::').last.to_sym
+      # end
+    end
+
+    class SolidityFunction < GlobalScopeEntry
+      # @return [Symbol] :reservedFunctionType to indicate that
+      # specaial Solidity function
+      def functionType
+        :reservedFunctionType
+      end
+    end
+
+    # Solidity function pushed in global scope
+    class SelfDestruct < SolidityFunction; end
+    class Revert < SolidityFunction; end
+    class Require < SolidityFunction; end    
+
+
+    # # SexpExtry for keyword 'this' 
+    # class This < GlobalScopeEntry;  end
+    
+    class GlobalScope    < AstSexp
+      
+
+      include Sbuilder::Eth::Scope
+
+      GLOBAL_SCOPE_DEFS = 
+        [
+          {
+            :name => Constants::SOL_SELF_DESTRUCT,
+            :astSexp => SelfDestruct.new,
+          },
+          {
+            :name => Constants::SOL_REVERT,
+            :astSexp => Revert.new,
+          },
+          {
+            :name => Constants::SOL_REQUIRE,
+            :astSexp => Require.new,
+          },
+          # {
+          #   :name => Constants::SOL_THIS,
+          #   :astSexp => This.new,
+          # }
+        ]
+
+      # ------------------------------------------------------------------
+      # @!group Constructor
+
+      # @return [GlobalScope] initialized (defined scope) GlobalScope
+      # instance
+      def initialize( options={})
+        super( self.class.name.split('::').last.to_sym  )
+      end
+
+
+      def self.start( options={} )
+        globalScope = GlobalScope.new( options )
+
+        globalScopeInit.each do |scopeDef|
+          globalScope.define( scopeDef[:name], scopeDef[:astSexp])
+        end
+        
+        globalScope        
+      end
+
+      # @return [Array<Hash>] initHash array of hashes defining
+      # initial gloabl scope, hash defines properties ':name' and
+      # ':astSexp'
+      # @option initHash [:Symbol] :name
+      # @option initHash [:Symbol] :astSexp
+      def self.globalScopeInit
+        GLOBAL_SCOPE_DEFS
+      end
+
+      # @!endgroup
+
+      extend Test
+      
+    end
+    
+  end
+end

data/lib/eth/module.rb

@@ -0,0 +1,18 @@
+require_relative 'constants'
+require_relative 'exception'
+require_relative 'al_api'
+require_relative 'ethereum_expression'
+require_relative 'ethereum'
+require_relative 'ast_sexp'
+require_relative 'global_scope'
+require_relative "solidity_compiler"
+require_relative "solidity_loader"
+require_relative "solidity_translator"
+
+require_relative "sexp_utils"
+require_relative "sexp_processor"
+# require_relative "sexp_processor_constructors"
+require_relative "sexp_processor_getter"
+require_relative "sexp_processor_call_separator"
+require_relative "sexp_processor_scope"
+require_relative "sexp_processor_resolve"

data/lib/eth/sexp_processor.rb

@@ -0,0 +1,66 @@
+require 'sexp_processor'
+
+module Sbuilder
+  module Eth
+    class SexpProcessorEth < SexpProcessor
+
+      # include logger
+      include Sbuilder::Al::Util::MyLogger         # mix logger
+
+      # @# @!attribute [Hash] options
+      attr_accessor :options
+
+      # @# @!attribute [Logger] logger 
+      attr_reader :logger
+
+      def initialize( options={})
+        super()
+
+        self.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
+
+      # Use for default processor when we need to control what gets
+      # processed.
+      def process_skip exp
+        s()
+      end
+      
+
+      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
+      
+      
+    end
+  end
+end
+

data/lib/eth/sexp_processor_call_separator.rb

@@ -0,0 +1,163 @@
+require 'sexp_processor'
+
+module Sbuilder
+  module Eth
+
+    # Sexp preprocessor find call statements in expression and add a
+    # separate call immediately before statement containing the
+    # expression
+    #
+    class  SexpProcessorCallSeparator < SexpProcessorEth
+
+      # ------------------------------------------------------------------
+      # @!group Object state
+
+            
+      # @!attribute [Ast::Statement] current statement
+      attr_accessor :currentStatement
+
+
+      # @!endgroup
+
+
+      # ------------------------------------------------------------------
+      # @!group Constructor
+
+      def initialize( options={} )
+        super( options )
+      end
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group Scope hierarch utils
+
+      def wrapStatement( stmtSexp )
+        
+        # remember  'prevScope', update enclosing scope, switch '@currentScope', 
+        prevStatement = currentStatement
+        self.currentStatement = stmtSexp
+        
+        begin
+          yield
+        ensure
+          self.currentStatement = prevStatement
+        end
+        
+      end
+
+      # @!endgroup
+
+
+      # ------------------------------------------------------------------
+      # @!group AST-node processors
+
+
+      # Add :FunctionCalls immediately before a statement, which has
+      # expressions with requiring :FunctionCall
+      #
+      # Implementation visits block statements AST nodes, and finds
+      # FunctionCalls expect for "calls without assignment"
+      # i.e. :ExpressionStatement with direct child[0] as
+      # :FunctionCall.
+
+      def process_Block( sexp )
+        
+        logger.debug "#{__method__}: sexp=#{sexp}" if logger.debug?
+
+        # Array of [Int, Array<:FunctionCall>]
+        callsToAdd = []
+        
+        sexp.children.each_with_index do |stmt,i|
+
+          calls = process( stmt )
+          @logger.debug "\n\nstmt=#{stmt}\ncalls=#{calls}" if @logger.debug?
+          
+          # collect index && :FunctionCalls lValueRequested
+          calls = unwrap(calls).select{ |s| s.sexp_type == :FunctionCall  }  || []
+          @logger.debug "#{__method__}: calls=#{calls}" if @logger.debug?
+          
+          # build [ 0, [f1,f2] ], [ 1, [f3,f4, ..] ], ...
+          if calls.length
+            # normal function/constructor!!
+            logger.info "#{__method__}: add #{calls.length} function calls #{calls.map { |call| call.callTarget["name"] }  }"
+            callsToAdd << [ i, calls ]
+          end
+            
+        end # each with index
+
+        # Process in reverse order to keep index valid
+        callsToAdd.reverse.each do |posToAdd|
+          pos = posToAdd[0]
+          calls = posToAdd[1]
+          calls.reverse.each do  |call|
+            logger.info "#{__method__}: insert pos #{pos}, call #{call}"
+            sexp.insertChild( pos, call )
+            logger.debug "#{__method__}: sexp.children #{sexp.children}" if logger.debug?
+          end
+        end
+
+        s()
+        
+      end
+
+
+      # @!endgroup
+
+
+      
+      # ------------------------------------------------------------------
+      # @!group Function found
+
+
+      def process_ExpressionStatement( sexp )
+        return s() if sexp.children[0].sexp_type ==  :FunctionCall
+        process_rest( sexp )
+      end
+
+      def process_FunctionCall( sexp )
+        sexp
+      end
+
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group Helpers
+
+      # Recursively flatten 1 level until sArray is Array<Sexp> (with
+      # non-empty Sexps)
+      #
+      # @param sArray [Array<Array*<Sexp>>] Array 
+      #
+      # @return  [Array<Sexp>]
+      def unwrap( sArray )
+
+        # not an array - no change
+        return sArray unless sArray.is_a?(Array)
+        
+        sArray = sArray.
+                 # unwrap non sexps 
+                 map { |e| e.is_a?( Sexp) && e.sexp_type.is_a?( Symbol )  ? e :  unwrap(e) }.
+                 # reject empty elements
+                 select { |e| e != [] }
+
+        # peel off proper outer arrays 
+        sArray = sArray[0] while sArray.is_a?(Array) &&
+                                 sArray.length == 1 &&
+                                 sArray[0].is_a?(Array)  && sArray[0].length == 1 && sArray[0][0].is_a?( Array)
+        
+
+        sArray
+        
+      end
+
+      # @!endgroup
+
+
+      
+    end # class
+
+  end
+end
+

data/lib/eth/sexp_processor_getter.rb

@@ -0,0 +1,125 @@
+require 'sexp_processor'
+
+module Sbuilder
+  module Eth
+
+    # Sexp preprocessor, which adds getters for public variable
+    # declarations
+    #
+    class  SexpProcessorGetter < SexpProcessorEth
+
+      def initialize( options={} )
+        super( options )
+      end
+
+      # Find public variable declarations without getter method
+      # {Sbuilder::Eth::SexpUtils.getterName}, add default getter to
+      # the contract using {Sbuilder::Eth::SexpUtils.sexpGetter}.
+      #
+      # Uses {#SexpProcessorGetterFinder} to get an array
+      # ':VariableDeclaration' and ':FunctionDefinition' sexps.  Array
+      # contains also sexp_types :NONE for variable declaration which
+      # are not public.
+      
+      def process_ContractDefinition( sexp )
+        logger.debug "#{__method__}: sexp=#{sexp}" if logger.debug?
+
+        # find public variable declarations without getter
+        gettersToImplemt =
+          SexpProcessorGetterFinder.new(options).
+          process( sexp ).
+          # s() generated by sexp-processor default-method e.g modifiers
+          select { |sexp| sexp.length > 0 }.
+          # sieve :VariableDeclaration before :FunctionDefinition
+          sort { |s1,s2| -1 * (s1.sexp_type.to_s <=> s2.sexp_type.to_s) }.
+          # sieve builds a hash getter name -> VariableDeclaration
+          reduce( {} ) do |getters,sexp|
+          case sexp.sexp_type
+          when :VariableDeclaration
+            # should implement getter with 'getterName'
+            getters[ SexpUtils.getterName( sexp['name']) ] = sexp
+          when :FunctionDefinition
+            # getter already implemented - remove
+            getters[ sexp["name"] ] = nil
+          when :NONE
+          # getter not needed for a variable declation
+          else
+            raise "Unexppected sexp-type #{sexp.sexp_type} for #{sexp}"
+          end
+          getters
+        end.
+          # create getter only for var-decls without getter
+          select do |k,sexp|
+          !sexp.nil?
+        end
+          
+        logger.info "#{__method__}:gettersToImplemt=#{gettersToImplemt.keys.join(',')}"
+        
+        # add getter method to contract 'sexp'
+        gettersToImplemt.each do |name, variableDeclarationSexp|
+          # create getter for contract 'sexp'
+          sexp.addChild( SexpUtils.sexpGetter( variableDeclarationSexp["name"]) )
+        end
+        sexp
+      end  # process_ContractDefinition( sexp )
+      
+    end
+
+    # Get an array ':VariableDeclaration' and ':FunctionDefinition'
+    # sexps.  Array contains also sexp_types :NONE for variable
+    # declaration which are not public.
+    
+    class  SexpProcessorGetterFinder < SexpProcessorEth
+      # ------------------------------------------------------------------
+      # @!group Constructor
+
+      def initialize( options={} )
+        super( options )
+        
+        # Process known sexp
+        self.default_method = :process_skip
+        
+      end
+
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group Resolvers for reference node types
+
+      def process_ContractDefinition( sexp )
+        process_rest( sexp )
+      end
+
+      # We know that we are processing 'VariableDeclaration' for a
+      # contrcact (because we have intercepted FunctionDefinition in
+      # {#process_FunctionDefinition}). Create getter for public
+      # variable declaration.
+      #
+      # @return [AstSexp(:VariableDeclaration), AstSexp(:NONE)] :NONE
+      #         if no getter needed
+      def process_VariableDeclaration( sexp )
+        logger.debug "#{__method__}: sexp=#{sexp}" if @logger.debug?
+        logger.info "#{__method__}: variable name =#{sexp['name']}, visibility #{sexp['visibility']}"
+        if sexp["visibility"] == Constants::SOL_VISIBILITY_PUBLIC
+          return  sexp
+        end
+        # not public --> no getter needed
+        s(:NONE)
+      end
+
+      # Intercept 'FunctionDefinition' to prevent recursion into
+      # variable declaration for function parameters and locals.  just
+      # return so that we can check, whether some getter already
+      # defined
+      # 
+      def process_FunctionDefinition( sexp )
+        sexp
+      end
+
+      # @!endgroup
+      
+    end
+  end
+end
+