sbuilder-ial 0.0.1

data/lib/action/render/producer_ethereum.rb

@@ -0,0 +1,404 @@
+require_relative 'producer_ethereum_const.rb'
+
+module Sbuilder
+  module Ial
+    module Action
+      module Render
+
+        class ProducerEthereum < Producer
+
+          PROGNAME = nil                        # progname for logger default class name
+          include Sbuilder::Ial::MyLogger       # mix logger
+
+          # @attr [Boolean] fixed_snippet_produced guarantee that
+          # 'p_base_snippets' called only once
+          @@fixed_snippet_produced=false
+
+
+          # ------------------------------------------------------------------
+          # @!group Construct & configure
+          
+          def initialize( options = {}, metatypes=nil )
+            super( options, metatypes )
+            @logger = getLogger( nil, options )
+            @logger.info "#{__method__}: starting options=#{options}"
+            
+          end
+
+          def self.start( options = {}, metatypes=nil )
+            ProducerEthereum.new( options, metatypes )
+          end
+          # @!endgroup
+
+          # ------------------------------------------------------------------
+          # @!group Bridge to other modules
+
+          # @return [Hash] constanExpressions from
+          # 'Sbuilder::Ial::Model::Constants::CONSTANT_EXPRESSIONS'
+          #
+          # @option constanExpressions [:symbol] key constant
+          #
+          # @option constanExpressions [String] value constant in tla
+          # language
+          
+          def constanExpressions
+            Sbuilder::Ial::Model::Constants::CONSTANT_EXPRESSIONS
+          end
+
+          # @return [Hash] IAL_OPERATORS to map ialOperator to
+          # corresponding tlaOperatr
+          def ialOperators
+            Sbuilder::Ial::Model::Constants::IAL_OPERATORS
+          end
+
+          # @!endgroup
+
+          # ------------------------------------------------------------------
+          # @!group Production rules
+
+          # produce fixed snippet only once
+          def p_base_snippets
+            return [] if @@fixed_snippet_produced
+            # toggle flag to produce only once
+            @@fixed_snippet_produced = true
+            ProducerEthereumConstants::BASE_SNIPPETS
+          end
+
+          def p_variable_definition( varName, initExpression )
+            @logger.info "#{__method__}: varName=#{varName}, initExpression=#{initExpression}"
+            {
+              :metatype => metatype4varName,
+              :appName => varName,
+              :specName => nil,
+              :comment => "Variable #{varName}",
+              :template => gen_state_variable( varName2Specname( varName ), initExpression )
+            }
+          end
+
+          # Produce macro snippet for 'macroName'
+          def p_macro( macroName, parameters, stmts )
+            @logger.info "#{__method__}: macroName=#{macroName}, parameters=#{parameters}"
+            @logger.debug "#{__method__}: macroName=#{macroName} stmts=#{stmts}" if @logger.debug?
+            {
+              :metatype => metatype4macro,
+              :appName => macroName,
+              :specName => nil,
+              :comment => "Macro #{macroName}",
+              :template => gen_macro( macroName2Specname( macroName ), parameters, stmts )
+            }
+          end
+
+          # Produce 'operator' snippet for 'operatorName' with
+          # 'parameters' and 'body' -expression
+          def p_operator( operatorName, parameters, body )
+            {
+              :metatype => metatype4operator,
+              :appName => operatorName,
+              :specName => nil,
+              :comment => "Operator #{operatorName}",
+              :template => gen_operator( operatorName2Specname( operatorName ), parameters, body )
+            }
+          end
+
+          # Entry-macro for transaction 'txName'
+          def p_tx_entry( txName, operationName, stmts=nil )
+            @logger.info "#{__method__}: txName=#{txName}, operationName=#{operationName}" 
+            @logger.debug "#{__method__}: txName=#{txName} stmts=#{stmts}" if @logger.debug?
+            
+            # appName = "#{ctx[:transaction_entry].name}(action)"
+            metatype = metaTxEntry
+            appName = txName2appName( txName, operationName )
+            
+            #
+            formalParameter_for_tx_input = 'input'
+            
+            # default calls 'service procedure' of txName
+            if stmts.nil? || !stmts.any?
+              stmts = 
+                s(gen_procedure_call( txName2ServiceProcedure( txName, operationName ), formalParameter_for_tx_input))
+            end
+
+            stmts = gen_stmts( stmts )
+            
+            {
+              :metatype => metatype,
+              :appName => appName,
+              :specName => nil,
+              :comment => "Enter transaction '#{txName}'",
+              :template => gen_macro( gen_specname( metatype, appName), formalParameter_for_tx_input, stmts )
+            }
+          end
+
+          # @param [String:Array] locals array names of local variables
+          def p_tx_function( txName, operationName, locals, stmts )
+            @logger.info "#{__method__}: txName=#{txName}, locals=#{locals}" 
+            @logger.debug "#{__method__}: txName=#{txName} stmts=#{stmts}" if @logger.debug?
+            metatype = metaTxFunc
+            appName = txName2appName( txName, operationName )
+            interfaceName = txName2interfaceName( txName, operationName )
+            labelPrefix = gen_specname( metatype, appName )
+            labeledStmts = gen_stmts(gen_serviceProcedureLabelStatements( stmts, labelPrefix ))
+            # functionName = gen_specname( metatype, appName )
+            {
+              :metatype => metatype,
+              :appName => appName,
+              :specName => nil,
+              :comment => "Implementation of transaction '#{txName}'",
+              :template => gen_service_procedure( txName2ServiceProcedure( txName, operationName ), interfaceName, locals, labeledStmts )
+            }
+          end
+
+          # Produce exit (macro) for transaction 'txName'
+          def p_tx_exit( txName, operationName )
+            metatype = metaTxExit
+            appName = txName2appName( txName, operationName )
+            specName = "dummy"
+            {
+              :metatype => metatype,
+              :appName => appName,
+              :specName => specName,
+              :comment => "Exit from transaction #{appName}",
+              :template => nil,  # no body - just map appName->specName
+              :body => nil,  # no body - just map appName->specName              
+            }
+          end
+
+          # @!endgroup
+
+          # ------------------------------------------------------------------
+          # @!group Production rules
+
+          private def varName2Specname( varName )
+            gen_specname( metatype4varName, varName )
+          end
+          
+          private def domainName2Specname( domainName )
+            # gen_plainname( domainName )
+            gen_specname( metatype4Domain, domainName )
+          end
+
+          def macroName2Specname( macroName )
+            gen_specname( metatype4macro, macroName )            
+          end
+          
+          def operatorName2Specname( operatorName )
+            gen_specname( metatype4operator, operatorName )            
+          end
+          
+          private def metatype4varName
+            metaApp
+          end
+
+          # Domain are known to be defined under metatype
+          # 'META_MODEL_DOMAINS'
+          private def metatype4Domain
+            Sbuilder::FacadeConstants::META_MODEL_DOMAINS
+          end
+
+          private def metatype4macro
+            metaApp
+          end
+          
+          private def metatype4operator
+            metaApp
+          end
+
+          private def metatype4txFunction
+            metaTxFunc
+          end
+            
+          private def txName2InputVariable( txName, operationName )
+            gen_interface_input_variable_name( txName2interfaceName( txName, operationName ), metatype4txFunction )
+          end
+          
+          private def txName2appName( txName, operationName )
+            "#{txName}(#{operationName})"            
+          end
+          
+          private def txName2interfaceName( txName, operationName )
+            "#{txName}(#{operationName})"            
+          end
+
+          private def txName2EntryMacro( txName )
+            gen_specname( metaTxEntry, txName2appName( txName ) )
+          end
+          
+          private def txName2ServiceProcedure( txName, operationName )
+            gen_specname( metatype4txFunction, txName2appName( txName, operationName ) )
+          end
+
+          # @!endgroup
+          
+          # ------------------------------------------------------------------
+          # @!group Production rules for statements
+          def p_skipStatement
+            @logger.info "#{__method__}"
+            s(gen_skip )
+          end
+
+          def p_conditionalStatement( condition, ifBlock, elseBlock )
+            @logger.info "#{__method__}: condition=#{condition}"
+            @logger.debug "#{__method__}: ifBlock=#{ifBlock}" if @logger.debug?
+            @logger.debug "#{__method__}: elseBlock=#{elseBlock}" if @logger.debug?            
+            s(gen_if( condition, ifBlock, elseBlock ))
+          end
+
+          def p_callServiceStatement( txName, operation, parameters )
+            @logger.info "#{__method__}: txName=#{txName}, operation=#{operation}, parameters=#{parameters}"
+            serviceSpecname = txName2ServiceProcedure( txName, operation )
+            s(gen_procedure_call( serviceSpecname, parameters))
+          end
+
+          def p_callMacroStatement( macroName, parameters )
+            @logger.info "#{__method__}: macroTarget=#{macroName}, parameters=#{parameters}"
+            s(gen_macro_call( macroName2Specname( macroName ), parameters ))
+          end
+
+          def p_printStatement( msg )
+            @logger.info "#{__method__}: msg=#{msg}"            
+            s(gen_print( msg ))
+          end
+
+          def p_assignTo( assignTo, rval )
+            @logger.info "#{__method__}: assignTo=#{assignTo}, rval=#{rval}"            
+            s(gen_assign( assignTo, rval ))
+          end
+          
+
+          # @!endgroup
+
+          # ------------------------------------------------------------------
+          # @!group Production rules for expressions
+
+          # @param [String] varName (appName) of variable expression
+          # @return [sTla] specname of variable 'varName'
+          def p_variable_expression( varName )
+            @logger.info "#{__method__}: varName=#{varName}"                        
+            varName2Specname( varName )            
+          end
+
+          # ----------
+          # expressions referencign parameters
+          
+          # Expression accessing 'parameterName' of transaction 'txtName'
+          #
+          # @return [sTla] 
+          def p_tx_parameter_expression( txName, operationName, parameterName )
+            @logger.info "#{__method__}: txName=#{txName}, parameterName=#{parameterName}"
+            gen_record_field( txName2InputVariable(txName, operationName),  parameterName )
+          end
+
+          # Expression referencing  'paramaterName' in 'macro'          
+          def p_macro_parameter_expression( macroName, parameterName )
+            @logger.info "#{__method__}: macroName=#{macroName}, parameterName=#{parameterName}"
+            p_parameter_expression( parameterName )            
+          end
+
+          # Expression referencing  'paramaterName' in 'operatorName'
+          def p_operator_parameter_expression( operatorName, parameterName )
+            @logger.info "#{__method__}: operatorName=#{operatorName}, parameterName=#{parameterName}"
+            p_parameter_expression( parameterName )
+          end
+
+          # Local DRY method to access paramterName
+          private def p_parameter_expression( parameterName )
+            gen_plainname( parameterName )            
+          end
+
+          # ----------
+          # Operator expressions
+
+          def p_operator_expression( operatorName, args )
+            @logger.info "#{__method__}: operatorName=#{operatorName}, args=#{args}"
+            p_operator_expression_exec( operatorName2Specname( operatorName ), args )
+          end
+
+          # Call operator 'operatorName' with arguments. NB:
+          # 'operatorName' not mapped using metatype (it is
+          # infrastructure operator).
+          def p_infra_operator_expression( operatorName, args )
+            @logger.info "#{__method__}: operatorName=#{operatorName}, args=#{args}"
+            p_operator_expression_exec( operatorName, args )
+          end
+
+          private def p_operator_expression_exec( opExpression, args )
+            gen_operator_call( opExpression, args )
+          end
+
+          # ----------
+
+          # Expression for calling 'operatorName' with arguments 'args'
+          # Expression for accessing domain (set) with name 'domainName'
+          def p_domain_expression( domainName )
+            @logger.info "#{__method__}: domainName=#{domainName}"            
+            domainName2Specname( domainName )
+          end
+
+          # expression refering to local variable 'local'
+          def p_local_expression( local )
+            @logger.info "#{__method__}: local=#{local}"            
+            gen_plainname( local )
+          end
+
+          def p_binary_expression( lval, op, rval )
+            @logger.info "#{__method__}: lval=#{lval}, op=#{op}, rval=#{rval}"
+            gen_bin_op( p_op(op), lval, rval )
+          end
+
+          # @param [Lambda] templateEval is lambda ->(gen, args)
+          # evaluate the template
+          def p_template_expression( templateEval, args )
+            @logger.info "#{__method__}: template=#{templateEval}, args=#{args}"
+            # Sbuilder::Ial::Model::Constants::TLA_TEMPLATES[template].call(self, args)
+            templateEval[self, *args]
+          end
+
+          # @param [String|Numeric|TrueClass|FalseClass] val
+          def p_constant_expression( val )
+            @logger.info "#{__method__}: val=#{val}"            
+            case val
+            when String
+              gen_str( val )
+            when Numeric
+              gen_constant( val )
+            when TrueClass
+              gen_constant( "TRUE" )
+            when FalseClass
+              gen_constant( "FALSE" )
+            when Symbol
+              # map symbol 'val' to sTla for constant expression
+              p_constant_value( val )
+            else
+              raise "Unsupported type #{val.class} for val '#{val}'"
+            end
+          end
+
+          # Map 'constSymbol' to gen_constant( 'constValue') using
+          # hash table 'constanExpressions'
+          #
+          # @param [:Symbol] constSymbol any value :empty
+          #
+          # @return [sTla] expression value for 'constSymbol'
+          def p_constant_value( constSymbol )
+            constValue = constanExpressions[constSymbol]
+            raise "Unsupported symbol value  #{constSymbol}" if constValue.nil?
+            gen_constant(constValue)
+          end
+
+          # Map 'ialOp' to 'tlaOperator' using hash table 'ialOperators'
+          def p_op( ialOp )
+            tlaOperator = ialOperators[ialOp]
+            raise "Unsupported operator value  #{ialOp}" if tlaOperator.nil?
+            tlaOperator
+          end
+          
+          # @!endgroup
+
+          
+        end # class ProducerEthreum < Producer
+
+
+      end
+    end
+  end
+end

data/lib/action/render/producer_ethereum_const.rb

@@ -0,0 +1,221 @@
+module Sbuilder
+  module Ial
+    module Action
+      module Render
+        class ProducerEthereumConstants
+
+          # Metatypes used to produce ethreum code
+
+          # OP_INFRA_SET_RESPONSE="InfrastructureServiceResponse"
+          OP_INFRA_RETURN="InfrastructureServiceReturn"
+          OP_INFRA_GET_RESPONSE="InfrastructureServiceGetResponse"
+          OP_INFRA_GET_STATUS="InfrastructureServiceGetStatus"
+          OP_INFRA_STATUS_INIT="InfrastructureServiceInit"      
+          OP_INFRA_THROW="schedule_throw"
+          OP_INFRA_UPDATE_TOP='UpdateTop'
+          OP_INFRA_RESPONSES='responses'
+          OP_INFRA_NEXT_ID='NextId'
+
+
+          # ------------------------------------------------------------------
+          # FRAMEWORK -services
+          FW_SVC_UNIQUE_ELEMENTS='uniqueElements'
+          FW_OP_ELEMENT_EXISTS = 'elementExists'
+          FW_OP_GET_ELEMENT = "getElement"
+
+          FW_STATE_ACCOUNTS = "accounts"
+          FW_STATE_ACCOUNTS_TEMP = "accounts_temp"      
+          FW_STATE_STORAGE_ROOT = 'storageRoot'
+          FW_STATE_STORAGE_ROOT_TEMP = 'storageRoot_temp'
+          FW_STATE_MINED = 'mined'
+          
+          ETH_OPEATOR_INTRINSIC_GAS = 'intrinsicGas'
+          ETH_OPEATOR_TRANSACTION_GAS = 'transactionGas'
+          ETH_OPEATOR_UP_FRONT_COST = 'upFrontCost'
+          ETH_OPEATOR_GAS_VALUE = 'gasValue'
+
+
+          # ethereum specific services
+          TLA_SERVICE_POP="ethereum_service_pop"      
+
+          
+          INITIAL_SNIPPETS=
+            [
+
+              # ------------------------------------------------------------------
+              # Base snippets - i.e. no connection to ethreums
+              # {
+              #   :comment => "macro to update existing contract",
+              #   :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+              #   :appName => 'update_existing_contract',
+              #   :body =>
+              #   <<-EOS.unindent,
+              #   macro update_existing_contract() {
+              #      print <<"update_existing_contract">>;
+              #   }
+              #   EOS
+              # },
+
+              {
+                :comment => "Add element to sequence head",
+                :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+                :appName => 'Push',
+                :body =>
+                <<-EOS.unindent,
+            Push( s, e ) == <<e>> \\o s
+            EOS
+              },
+
+              {
+                :comment => "Update element to sequence head",
+                :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+                :appName => OP_INFRA_UPDATE_TOP,
+                :body =>
+                <<-EOS.unindent,
+            UpdateTop( s, e ) == <<e>> \\o Tail(s)
+            EOS
+              },
+
+              
+              {
+                :comment => "Propgate top element to stack & pop",
+                :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+                :appName => 'PropageOnStack',
+                :body =>
+                <<-EOS.unindent,
+                (* PropageOnStack( s, v ) == [i \\in 1..Len(s) |-> v ]  *)
+                PropageOnStack( s, v ) == [i \\in 1..Len(s) |-> IF i = 1 THEN v ELSE s[i] ]
+                EOS
+              },
+
+              {
+                :comment => "Check if unique element exists",
+                :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+                :appName => 'elementExists',
+                :body =>
+                <<-EOS.unindent,
+                elementExists( set, key, id ) ==  Cardinality( { e \\in set : e[key] = id } ) = 1
+               EOS
+              },
+
+              {
+                :comment => "Check if unique element exists",
+                :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+                :appName => 'getElement',
+                :body =>
+                <<-EOS.unindent,
+               (*
+                * Return element from 'set' such that element['key'] == 'id'
+                * Assume 'id' unique, and element exists
+                *)
+                getElement( set, key, id ) == ( CHOOSE x \\in { e \\in set : e[key] = id } : TRUE )
+                EOS
+              },
+
+              {
+                :comment => "stable when process finished running",
+                :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+                :appName => 'Stable',
+                :body =>
+                <<-EOS.unindent,
+            Stable == tx_running = FALSE
+            EOS
+              },
+
+              {
+                :comment => "Sum record fields",
+                :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+                :appName => 'SumRecordField',
+                :body =>
+                <<-EOS.unindent,
+            RECURSIVE SumRecordField(_,_)
+            (* 
+             *  Sum of field 'f' of record elements in set 'S'
+             * 
+             *  @param [Set] S set of records
+             *  @param [String] f name of field 
+             *)
+            SumRecordField(S,f) == 
+               IF S = {} THEN 0
+               ELSE LET x == CHOOSE x \\in S : TRUE
+                    IN x[f] + SumRecordField(S \\ {x}, f)
+            EOS
+              },
+
+              {
+                :comment => "Sum function",
+                :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+                :appName => 'SumOfFunction',
+                :body =>
+                <<-EOS.unindent,
+            RECURSIVE SumOfFunction(_)
+            (*
+             * Sum of function values
+             *
+             * @param [Sequnce|Function] F to sum over
+             *
+             *)
+            SumOfFunction( F ) ==
+               IF F = <<>> THEN 0
+               ELSE LET x == CHOOSE x \\in DOMAIN F : TRUE
+                    IN F[x] + SumOfFunction( [ v \\in DOMAIN F \\ {x} |-> F[v] ] )
+            EOS
+              },
+
+              {
+                :comment => "Operator to check element uniques in a set",
+                :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+                :appName => FW_SVC_UNIQUE_ELEMENTS, 
+                :body =>
+                <<-EOS.unindent,
+            #{FW_SVC_UNIQUE_ELEMENTS}( set, key ) == \\A e1  \\in set:  \\A e2 \\in set:   e1[key] = e2[key] => e1 = e2
+            EOS
+              },
+
+              {
+                :comment => "Take given 'address', or choose any address from pool of 'ids'. Notice (CHOOSE operation is deterministic)",
+                :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+                :appName => OP_INFRA_NEXT_ID,
+                :body =>
+                <<-EOS.unindent,
+            #{OP_INFRA_NEXT_ID}( ids, address ) == CHOOSE x \\in ids: (address = x /\\ address # Nil) \\/ address = Nil
+            EOS
+              },
+            ] # BASE_SNIPPETS
+
+          ETHEREUM_SNIPPETS =
+            [
+              {
+                :comment  => 'Finish service procedure: propage stack top on succcess && pop',                        
+                :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+                :appName => TLA_SERVICE_POP, 
+                :body => <<-EOS.unindent
+             (*
+              * Service procedure for 'interface' has finished.
+              * Check status of service response.
+              * For success make changes in procedure permanent by propagating
+              * stack top to top-1..bottom.
+              *
+              * In any case pop one element from stack.
+              * 
+              *)
+
+             macro ethereum_service_pop( interface ) {
+                 \\* TODO - add implementation
+                 skip;
+             }
+            
+            EOS
+              },
+
+
+            ] # ETHEREUM_SNIPPETS 
+
+          BASE_SNIPPETS =  INITIAL_SNIPPETS + ETHEREUM_SNIPPETS 
+
+          
+        end
+      end
+    end
+  end
+end