sbuilder-eth 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b62782275cc9f06d62897fda5dd8066bbd13f30a
+  data.tar.gz: ba81ab05d6ff401f4502c7fc6083f534030c45ec
+SHA512:
+  metadata.gz: e440647e8d019f30fcea31dab54eb23ae4fc7db7fe02ded360eac0a5bbf2d09ab28f870a2e41ca82b3a97ea58427e8191b0e9463df4daecccc47e96a0c0d3aea
+  data.tar.gz: 1dafec9250e8e950cc1053a8745829cc43f311ed45a09adf56cd03454bb26a40bde9022a4170c595bad9e8783f9ae21606224cd5e7c9536dfe6aa23f79137cf2

data/README.org

@@ -0,0 +1,19 @@
+# -*- mode: flyspell; mode: org- *-
+
+* sbuilder-eth - Ethereum Plugin for =tla-sbuilder=
+
+  [[https://github.com/jarjuk/tla-sbuilder][tla-sbuilder]] is tool to generate runnable formal models in [[http://research.microsoft.com/en-us/um/people/lamport/tla/book.html][TLA+
+  language]] for [[https://github.com/jarjuk/tla-sbuilder#TARGET-SYSTEM][business IT systems]]. A formal model can be [[https://en.wikipedia.org/wiki/Model_checking][model
+  checked]] using [[http://research.microsoft.com/en-us/um/people/lamport/tla/tools.html][TLA+ Tools]].
+
+   [[https://github.com/jarjuk/sbuilder-eth][sbuillder-eth]] loads Ethreum Solidity implementations into
+   =tla-sbuilder= context using API Language (AL) provided by
+   [[https://github.com/jarjuk/sbuilder-al][sbuillder-al]] GEM.
+
+   *Notice* replaces a previous plugin [[https://github.com/jarjuk/sbuilder-ethereum][sbuilder-ethereum]]. 
+
+
+* Solidity language support
+
+
+

data/VERSION

@@ -0,0 +1 @@
+0.0.4

data/bin/state-explorer.sh

@@ -0,0 +1,215 @@
+#!/bin/bash
+
+
+usage() {
+
+
+    cat <<EOF
+    Usage $0:
+
+    $0  file ([STATE][-STATE]|last) VARIBALE[:VARIABLE]* [VARIABLE=[!]value,[VARIABLE=[-]value]*]"
+
+    where 
+    - STATE is number 1 or string 'last'
+    - VARIABLE is shown for commnad $0 file 1
+    - query is comma ',' separated list of variable queries
+      'variable=value' or 'variable=!value"
+
+    Exmpale 
+    $0 DUMP 1-99999  x1_addressPool now=1
+EOF
+    
+}
+
+if [ $# -lt 2 ]; then
+    usage
+    exit
+fi
+
+DUMP=$1; shift
+
+STATE=$1; shift
+KEY=$1; shift
+QUERY=$1;shift
+
+# echo gawk -vrange="$STATE" -vkey=$KEY -vquerystr=$QUERY
+
+gawk -vrange="$STATE" -vkey=$KEY -vquerystr=$QUERY '
+BEGIN {
+      empty_lines = 0
+      max_state = 0
+      
+      # printf( "Starting state=%s, variable=%s\n", state, variable )
+
+      # manage state
+      # in_state  - processing state
+      # in_variable - processing variable
+      # collect hash[in_state][variable]= ...state
+      delete states
+}
+
+# qs: var1=val1,var2=!val2
+# @return 1 true if match all
+function checkquery( qs, states, state ) {
+
+     # no state to explore
+     if ( length( states[state])  == 0  )  {
+         return( 0 )
+     }
+
+     # printf( "DBG: qs=%s\n", qs )
+     split( qs, queries, "," )
+     for ( query in queries ) {
+         # printf( "DBG: query=%s--> %s\n", query, queries[query] )
+	 split( queries[query], q, "=" )
+         query_variable=q[1]
+	 if ( substr(q[2],1,1) == "~" ) {
+	   # regexp matach
+	   query_value= substr(q[2],2)
+	   match_equal = 0
+           negate = 0
+	 }
+	 # else if ( substr(q[2],1,1) == "-" ) {
+	 #   # negated match
+	 #   query_value= substr(q[2],2)
+	 #   match_equal = 0
+         #   negate = 1
+	 # }
+	 else if ( substr(q[2],1,1) == "-" ) {
+	   # negated match
+	   query_value= substr(q[2],2)
+	   match_equal = 1
+           negate = 1
+	 }
+	 else {
+	   # match equal
+	   query_value=q[2]
+	   match_equal = 1
+           negate = 0
+	 }
+
+         # printf( "DBG: match-equal=%d, var=%s, qv=%s, state=%s match=%s\n",  match_equal, query_variable, query_value, state, match( states[state][query_variable], query_value)  )
+         check =  (match_equal && states[state][query_variable] == query_value)  || (!match_equal &&  match( states[state][query_variable], query_value))
+         if ( !check && !negate ) {
+	     # query failed: because no match made
+	     return( 0 )
+         }
+         if ( check && negate ) {
+	     # query failed: becaue match made - but should not have 
+	     return( 0 )
+         }
+
+     } # for q in queries
+
+     # all match
+     return( 1 )
+
+}    
+    
+
+
+END {
+
+
+
+    if ( key ) {
+
+        if ( range == "last" ) {
+            # last
+	    start=0+max_state
+            end=0+max_state
+        }
+       else {
+	
+            # 1-2
+            # 1-
+            # -2
+            # -
+
+	    split( range, s, "-" )
+	    start = 0+s[1]
+	    # end   = (0+s[2]<0+start)?0+start:0+s[2]
+	    end   = 0+s[2]
+	    if (start == "" ){
+	       start=1
+	    }
+        }
+
+	split( key, variables, ":" )
+
+	# printf ("range=%s %d-%d querystr=%s\n", range, start, end, querystr )
+
+
+	for ( state=start; (end!= 0 && state <= end) || state<=max_state; state +=1 ) {
+             if ( !querystr || checkquery( querystr, states, state )) { 
+                 # no querystr or query match
+		 for ( i in variables ) {
+			 variable = variables[i]
+			 # show timetick - instead of state number
+			 now = states[state]["now"]
+			 # printf( "%s@%s=%s\n", variable, state, states[state][variable] )
+			 printf( "%s@%s=%s\n§\n", variable, now, states[state][variable] )
+		 }
+		 print ""
+             } # query
+       }
+    }
+    else if ( !key ) {
+
+         min=1
+         max=0
+
+	 for ( key in states ) {
+	      max=(0+max>0+key)?max:key
+	      min=(0+min<0+key)?min:key
+         }
+	 print "States: " min " - " max
+
+
+	 print "variables:"
+	 for ( key in states[1] ) {
+	    printf( "   %s\n", key  )
+	 }
+
+	 print "Usage:"
+	 print 
+	 print "'$0' file ([STATE][-STATE]|last) VARIBALE[:VARIABLE]* [VARIABLE=[!]value,[VARIABLE=[-]value]*]"
+    }
+
+}
+
+# State 9999:
+match( $0, /State\s([0-9]+)/, ary) {
+        in_state = ary[1] 
+        in_variable = 0
+        if ( in_state > max_state ) {
+            max_state = in_state
+        }
+}
+
+# collect variable. Notice before setting in_variable
+in_variable && !/^\/\\/ {
+   # print "invariable " in_variable $0
+   states[in_state][in_variable]=states[in_state][in_variable] $0
+   # print "invariable " states[in_state][in_variable]
+}
+
+# /\ variabale = state info
+match( $0, /^\/\\ ([^ ]*) = (.*)/, ary) {
+       # printf( "and *%s*\n", ary[1] )
+       # printf( "AND *%s*\n", ary[2] )
+       in_variable = ary[1]
+       # first variable content
+       states[in_state][in_variable] = ary[2]
+}
+
+# Emtpy line - discard  && reset
+/^\s*$/ {
+        in_variable = 0
+	empty_lines = empty_lines + 1
+}
+
+
+' $DUMP
+
+# | fold -w 80 -s 

data/lib/eth/al_api.rb

@@ -0,0 +1,12 @@
+require "sbuilder-al"
+
+module Sbuilder
+
+  module Eth
+    
+    # Mix {Sbuilder::Al::Model::Api} to enable Sbuilder API Language (AL).
+    class AlApi
+      include Sbuilder::Al::Model::Api
+    end
+  end
+end

data/lib/eth/ast_sexp.rb

@@ -0,0 +1,519 @@
+require 'sexp_processor'
+
+module Sbuilder
+  module Eth
+
+    ##
+    # AstSexp subclasses Sexps, which furher subclasses Array.
+    #
+    # First element is a symbol defining sexp type. AstSexp uses hash
+    # as the second array element for storing attributes. Elements
+    # starting with position are AST tree children.
+    #
+    # Method {.from_hash} creates AstSexp object for AST structure
+    # from solc Solidity compiler.  It recurses AST nodes along
+    # 'children' property, and constructs AstSexp -object using 'name'
+    # (for sexp type), and 'attribute' properties.
+    # 
+    
+    class AstSexp < Sexp
+
+
+      # ------------------------------------------------------------------
+      # @!group Constructor
+
+      # Create a new Sexp containing +args+.
+      def initialize(*args)
+        super(*args)
+      end
+
+      # Create AstSexp tree from 'hash' with 'name' property,
+      # 'attributes' -property and 'children' -property
+      #
+      # @param hash [Hash ] Hash to convert to  sexp
+      #
+      
+      def self.from_hash( hash )
+        
+        # create sexp Node based on json['name']
+        result = new_node( hash )
+
+        # add children from hash['children']
+        hash['children'] && hash['children'].each do |c|
+          chld = self.from_hash(c)
+          # chld.setParent( result )
+          # result << chld
+          result.addChild( chld )
+        end
+
+        # rename childs if needed
+        result.finalizeChilds
+        
+        result
+        
+      end
+
+      # Add 'chld' to Sexp
+      def addChild( chld )
+        self << chld
+      end
+
+      # Insert 'child' in 'pos'
+      def insertChild( pos, child )
+        # children start counting from 2,...
+        self.insert(2+pos, child)
+      end
+      
+
+      # After all childs processed
+      def finalizeChilds
+        # no-operation
+      end
+
+      # Find class to build for 'hash#name' and use constructor
+      # '.start' to construct an instance for dispatched class.
+      def self.new_node( hash )
+
+        
+        # map solc node type to Sexp-class. This allows us to create
+        # AST nodes with better semantic information.
+        node2class = {
+          :ContractDefinition => ContractDefinition,
+          :FunctionDefinition => FunctionDefinition,
+          :ModifierDefinition => ModifierDefinition,
+          :ModifierInvocation => ModifierInvocation,          
+          :ParameterList => ParameterList,
+          :VariableDeclaration => VariableDeclaration,
+          :Identifier => Identifier,
+          :UserDefinedTypeName => UserDefinedTypeName,
+          :NewExpression => NewExpression,
+          :IndexAccess => IndexAccess,
+          :Assignment => Assignment,
+          :MemberAccess => MemberAccess,
+          :IfStatement => IfStatement,
+          :FunctionCall => FunctionCall,          
+        }
+
+        # 
+        raise "Missing property 'name' on hash #{hash}" if hash['name'].nil?
+        sexp_type = hash['name'].to_sym
+        klass = node2class[sexp_type]
+
+        # default klass
+        klass = AstSexp if klass.nil?
+
+        ret = klass.start( klass, hash )
+        ret 
+      end
+
+      def self.start( klass, hash )
+
+        attributes = hash['attributes'] && hash['attributes'].keys.reduce( {} ) do |memo,key|
+          # memo << [key,hash['attributes'][key]]
+          memo[key] = hash['attributes'][key]
+          memo
+        end || {}
+        # link to sourceLine from a string  'line:col:lenggth' e.g. 102:6:1 
+        attributes['sourceLine'] = hash['src'] ? hash['src'].split(':')[0].to_i : nil
+        ary = [ hash['name'].to_sym ] + [ attributes ]
+        klass.new( *ary  )
+        
+      end
+
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group traverse support
+
+      # @return [s(AstSexp) nodes matching 'sym' or 'blk' returning
+      # true anywhere in sexp-tree
+      def nodes_with_match( sym=nil, &blk )
+        blk = ->( chldSexp )  { chldSexp.sexp_type == sym } unless sym.nil?
+        sexpAstArray = s() # []
+        deep_each { |n|
+          sexpAstArray << n  if blk[n]
+        }
+        sexpAstArray    
+      end
+
+      # Restore behaviour missing methods
+      def method_missing meth, *args 
+        raise "Unknwon method '#{meth}' called on #{self}"
+      end
+
+      def respond_to? msg, private = false # :nodoc:
+        # why do I need this? Because ruby 2.0 is broken. That's why.
+        super
+      end
+      
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group Access sexp instance properties
+
+      # @return [Hash] hash in position 1 for attribute mapping
+      def attributes
+        self[1] || {}
+      end
+
+      # @return [value] value of first attribute with key == 'attrName' 
+      def attribute( attrName )
+        # attributes.select{ |a| a[0] == attrName }.map{ |a| a[1] }.first
+        attributes[attrName]
+      end
+
+
+      # String/symbols index access attributes, all other are
+      # delegated to parent (array class)
+      def [](index)
+        if index.is_a?(String) || index.is_a?(Symbol)
+          ret = attribute(index)
+          raise "Accessing non existing attribute '#{index}' in #{self}" if ret.nil?
+          return ret
+        end
+        super(index) 
+      end
+
+      # Override square bracket assignment to work on strings/symbols
+      # on 'attributes' hash in pos 1 of the sexp
+      def []=(index, val)
+        if index.is_a?(String) || index.is_a?(Symbol)
+          self[1] = attributes.merge( { index => val })
+          return self
+        end
+        super(index,val) 
+      end
+
+
+      # @return [Boolean] true if 'key' is present in '#attributes'
+      def key?( key )
+        attributes.key?( key )
+      end
+      
+
+      # @param sym [Symbol] create 'blk' c.sexpt_type == 'sym' if
+      # 'sym' given
+      #
+      # @param blk [Block] to filter children element to return
+      #
+      # @return [Array] array of childs (starting from position 2)
+      # where &blk evaluates true, return all childs if no block given
+      def children( sym=nil, &blk )
+        blk = ->( chldSexp )  { chldSexp.sexp_type == sym } unless sym.nil?
+        blk.nil? ? self[2..-1] : self[2..-1].select{ |e| blk[e] }
+      end
+
+      def hasChild( sym=nil )
+        children( sym ).any?
+      end
+
+      # @!endgroup 
+    end # class AstSexp < Sexp
+
+    
+    # Class defining context Solidity expression 'expressionAst'
+    class ExpressionContext < AstSexp;
+      # Create ExpressionContext  for 'expressionAst' in context 'ctx'
+      def self.createExpressionContext( expressionAst, ctx={} )
+        expressionContext = ExpressionContext.new( :ExpressionContext )
+        expressionContext["expressionAst"] = expressionAst
+        expressionContext["context"] = ctx
+        expressionContext
+      end
+      # @return [SexpAst] expressionAst wrapped within ExpressionContext
+      def expressionAst
+        self["expressionAst"]
+      end
+      def setContextContract( contract )
+        self["context"][:ContractDefinition] = contract
+      end
+      def context
+        self["context"]
+      end
+        
+      # supports :ContractDefinition
+      def getContext( contextType )
+        # supportContextTypes =  [:ContractDefinition]
+        # raise "Unsupportted contextType:#{contextType}, supported #{supportContextTypes.join(',')} " unless supportContextTypes.include?( contextType )
+        context[contextType]
+      end
+    end
+    
+    class ContractDefinition < AstSexp;
+      include Scope;
+      include Scoped;
+      # @return [Array<AstSexp>] member :VariableDeclaration  of contract
+      def memberVariables
+        children(:VariableDeclaration )
+      end
+    end
+
+    class FunctionOrModifierDefinition < AstSexp
+      include Scope
+      include Scoped
+      # @return [:ParameterList] input to Function/Modifier 
+      def requestParameters
+        children[0]
+      end
+      def block
+        children(:Block).first        
+      end
+      # statements are children of :Block sexp entry
+      def statements
+        block.children
+      end
+    end
+    class FunctionDefinition < FunctionOrModifierDefinition
+      # Make a difference between (Request)ParameterList and
+      # ResponseParameterList
+      def finalizeChilds
+        # change sexp-type
+        responseParameters[0] = :ResponseParameterList
+      end
+      def responseParameters
+        children[1]        
+      end
+      def modifierInvocations
+        children(:ModifierInvocation)
+      end
+    end
+    class ModifierDefinition < FunctionOrModifierDefinition
+      # Statements until 'PlaceholderStatement'
+      def preambleStatements
+        statements.take_while{ |stmt| stmt.sexp_type != :PlaceholderStatement }
+      end
+
+      # Enable access to translated actual parameters
+      # for :ModifierInvocation during :FunctionDefintion
+      # translation.
+      # @# @!attribute [Hash] map formal parameter name to TlaSexp
+      attr_accessor :invocationCtx
+      
+      def define(name, astSexp)
+        super( name, astSexp )
+      end
+
+
+      # @return [Scoped,ScopedWrapper] wraper if 'name' is symbol in
+      #     :ModifierDefinition, else propagate resolve to scope
+      #     hierarchy (to return Scoped)
+      def resolve( name )
+        return ScopedWrapper.wrap( self, name, getSymbol( name ) ) if getSymbol( name )
+        super( name )
+      end
+      
+    end
+
+    # Wrap 'Scoped' (e.g. VariabeDeclation) 'astSexp' to allow access
+    # to evaluated arguments of a :ModifierInvcation in
+    # 'invocationCtx' -attribute of 'scopeDefining'.
+    class ScopedWrapper < AstSexp
+
+      def resolve( name )
+        scoped.resolve(name)
+      end
+
+      # @return [ScopedWrapper] constructor wrapping 'astSexp' with 'name' in 'scope'
+      def self.wrap( scope, name, astSexp )
+        wrapper = ScopedWrapper.new( :ScopedWrapper, astSexp.attributes, *astSexp.children )
+        wrapper.scopeDefining = scope
+        wrapper.scoped = astSexp
+        wrapper.name = name
+        wrapper
+      end
+
+
+        
+      # @# @!attribute [Scoped] scoped  being wrapped
+      attr_accessor :scoped
+
+      # @# @!attribute [String] name of scoped used in define  
+      attr_accessor :name
+
+      # @# @!attribute [Scope] scopeDefining i.e. scope defining {#scoped}
+      attr_writer :scopeDefining
+
+      # @return [TlaExpression,Scope] invocationCtx return expression
+      #         evaluated in @scopeDefining.invocationCtx, else return
+      #         scope {#scopeDefining} for {#scoped} (=wrapped) object
+      def scopeDefining
+        # return evaluated value from context
+        if @scopeDefining.invocationCtx
+          ctxElement = @scopeDefining.invocationCtx[name] 
+          raise "Missing evaluation for key '#{name}' of class #{scoped.class}, known keys in invocationCtx=#{@scopeDefining.invocationCtx.keys.join(',')}" if ctxElement.nil?
+          return ctxElement
+        end
+        
+        @scopeDefining
+      end
+      
+    end
+
+    class ModifierInvocation < AstSexp
+      # @return [:ModifierDefinition] :ModifierDefinition resolved for
+      #         :ModifierInvocation :Identifier
+      def modifierDefinition
+        children(:Identifier).first.reference
+      end
+      # Actual parametes used in :ModifierInvocation
+      def arguments
+        children[1..-1]
+      end
+    end
+    
+    
+    
+    class Assignment < AstSexp
+      def lval
+        children[0]        
+      end
+      def rval
+        children[1]
+      end
+    end            
+    class ParameterList < AstSexp;
+      include Scope
+      include Scoped
+
+      def parameters
+        children
+      end
+      
+      # @return [VariableDeclaration] index-th parameter declaration
+      def parameterByIndex( index )
+        children[index]
+      end
+
+    end
+    class VariableDeclarationWithDomain < AstSexp
+      include Scoped      
+      # @param name_domain [Array] array of length with name and
+      # domain
+      def self.create( name_domain)
+        VariableDeclarationWithDomain.new(:VariableDeclarationWithDomain,
+                               {"name" => name_domain[0],
+                                "domain" => name_domain[1]})
+      end
+    end
+    class VariableDeclaration < AstSexp
+      include Scoped
+      def variableType
+        children[0]        
+      end
+    end
+    class Identifier < AstSexp; include Reference;  end
+    class MemberAccess < AstSexp;
+      include Reference;      
+      def memberName
+        self['member_name']
+      end
+      def struct
+        children[0]
+      end
+      # Identifier for the MemberAccess
+      def identifierAst
+        return struct if struct.sexp_type == :Identifier
+        struct.identifierAst
+      end
+    end    
+    class UserDefinedTypeName < AstSexp; include Reference;  end    
+    class NewExpression < AstSexp
+      include Reference
+      def classConstructed
+        children(:UserDefinedTypeName).first
+      end
+    end
+    class IndexAccess < AstSexp;
+      # @return [Identifier] identifier indexed
+      def identifier
+        children[0]
+      end
+      def indexer
+        children[1]
+      end
+    end
+    class FunctionCall < AstSexp
+      # AST nodes
+      def functionCalled
+        children[0]                
+      end
+      def arguments
+        children[1..-1]                
+      end
+      
+      # @return [true] for selfdestruct, revert, require etc
+      def isCallToReservedFunctionType
+        # case this.f.value(1).gas(2)(3,4,5)
+        return false if functionCalled.sexp_type == :FunctionCall
+        # case f(3,4,5) is selfdestruct, require etc.
+        return functionCalled.reference.respond_to?(:functionType) &&
+               functionCalled.reference.functionType == :reservedFunctionType 
+      end
+      # @return [Boolean] true if functionCalled.sexp_type == :NewExpression
+      def isConstructorCall
+        functionCalled.sexp_type == :NewExpression
+      end
+      
+      # @return [nil,FunctionCall] if functionCalled contains :MemberAccess to value      
+      def valueModified
+        (nodes_with_match { |n|  n.sexp_type == :FunctionCall && n.functionCalled.sexp_type == :MemberAccess && n.functionCalled["member_name"] == "value" } || []).first
+      end
+
+      # @return [Identifier,:MemberAccess] Solidity expression AST in
+      #       :FunctionCall to dispatch the calle = functionCalled
+      #        minus gas/value modifiers
+      def callExpression
+        functionCalled.nodes_with_match(:Identifier).first
+
+        # nodes_with_match do |n|
+        #   n.sexp_type != :FunctionCall &&
+        #     ( n.sexp_type == :Identifier ||
+        #       ( [:MemberAccess].include?( n.sexp_type ) &&
+        #       ! [Constants::FIELD_NAME_GAS, Constants::FIELD_NAME_VALUE ].include?( n["member_name"] ))
+        #     )
+        # end.first
+      end
+      
+      def callTarget
+        case functionCalled.sexp_type
+        when :MemberAccess
+          if functionCalled.struct.respond_to?( :callTarget )
+            # recurse FunctionCall (while value/gas modifier)
+            functionCalled.struct.callTarget
+          else
+            # if value/gas then ptr to modify fun else resolved-func
+            [Constants::FIELD_NAME_GAS, Constants::FIELD_NAME_VALUE].include?( functionCalled["member_name"] ) ?
+              functionCalled.struct.reference :
+              functionCalled.reference
+          end
+        when :Identifier
+          functionCalled.reference
+        when :NewExpression
+          functionCalled.reference
+        when :FunctionCall
+          # recursion :FunctionCall modifiers
+          functionCalled.callTarget
+        else
+          raise "Do know how to process '#{functionCalled.sexp_type}' to get 'callTarget' in #{self}"
+        end
+      end
+      
+    end
+    
+    class IfStatement < AstSexp
+      def condition
+        children[0]                
+      end
+      def ifThen
+        children[1]                
+      end
+      def elseThen
+        children[2]                
+      end
+    end    
+    
+  end
+end
+