sbuilder-al 0.0.8

data/lib/translator/renderer.rb

@@ -0,0 +1,159 @@
+# ------------------------------------------------------------------
+# Hack mustache to allow change default otag '{{' ctag '}}'
+require 'mustache'
+
+class Mustache
+
+
+  # Open mustache to define class accessors 'otag' and 'ctag'
+  def self.otag=( o )
+    @@otag = o
+  end
+  def self.ctag=( c )
+    @@ctag = c
+  end
+  def self.otag
+    @@otag ||= '{{'  
+  end
+  def self.ctag
+    @@ctag ||=  '}}'
+  end
+
+
+  class Template
+    
+    # Open template to set otag/ctag on parser.
+    #
+    # Returns an array of tokens for a given template.
+    #
+    # @return [Array] Array of tokens.
+    #
+    def tokens(src = @source)
+      p = Parser.new
+      p.otag = Mustache.otag
+      p.ctag = Mustache.ctag
+      p.compile(src)
+    end
+  end    
+
+end
+
+module Sbuilder
+  module Al
+    module Translator
+
+      # not catched
+      class RendererException < Sbuilder::Al::Util::AlException; end
+      # to be catched
+      class RendererError < Sbuilder::Al::Util::AlError; end
+      
+
+      class Renderer < Mustache
+
+        # @attr [Logger] loger
+        attr_reader :logger
+        PROGNAME = nil                        # progname for logger default class name
+        include Sbuilder::Al::Util::MyLogger       # mix logger
+
+        # @!attribute partials [Hash] must be set before +to_str+, see
+        # {#partials} for reader
+        attr_writer :partials
+
+        # @!attribute preferences modify mustache rendering (debug?)
+        attr_reader :preferences
+
+        # @!attribute partialsRef [Object] object with partials method
+        attr_accessor :partialsRef
+
+        def initialize( options={} ) 
+          # exception raise if accessing unknown property
+          self.raise_on_context_miss = true
+
+          @options = options
+          @logger = getLogger( nil, options )
+          @logger.info "#{__method__}: starting options=#{options}"
+
+          self.partials = {}
+          
+        end
+
+        def self.start( partialsRef )
+          renderer = Renderer.new
+          raise RendererException, "Expect partialsRef #{partialsRef} to respond to :partials" unless partialsRef.respond_to?( :partials )
+          renderer.partialsRef= partialsRef
+          renderer
+        end
+
+        def setPreferences( preferences )
+          @preferences = preferences
+          @logger.info "#{__method__}:  preferences=#{preferences}"
+        end
+
+        # Use 'to_str' instead of 'render' to use non-default otag/ctag's
+        def to_str( template, data=nil )
+          Mustache.otag = '{|'
+          Mustache.ctag = '|}'    
+
+          begin 
+            ret = render( template, data )
+          ensure
+            # restore default otag/ctag
+            Mustache.otag = '{{'
+            Mustache.ctag = '}}'
+          end
+          ret
+        end
+
+        # partials with key for partial name, and value
+        # a partial template to render.
+        #
+        # @return [Hash] @partialsRef.partials if @partialsRef given, else @partials
+        
+        def partials
+          @partialsRef.nil? ? @partials : @partialsRef.partials
+        end
+
+        # Render conxtext.current[key].
+
+        # @param [String, '.'] key to render, '.' means current context,
+        # string lookup key in current context
+        def EVAL( key )
+          
+          logger.info "#{__method__}: key='#{key}', context.current=#{context.current}" if logger.debug?
+          
+          # find generate sexp( :sym, data ) to render 
+          if key == '.'
+            sexp = context.current
+          else
+            #  to evaluate 
+            hash = context.current.is_a?( Array ) ? context.current[1] : context.current
+            sexp = hash[key] || hash[key.to_sym]
+            raise RendererException, "No such key #{key}:#{key.class} found in #{hash}"  if sexp.nil?      
+          end
+          
+          sexp_type = sexp[0]
+          data = sexp[1]
+          logger.debug "#{__method__}: key=#{key}, sexp_type=#{sexp_type}" if logger.debug?
+          
+
+          # find correct template 
+          template = partials[sexp_type]
+          raise RendererException,
+                <<-EOS if (template.nil?)
+                  Unknown partial for sexp_type '#{sexp_type}'
+
+                  Known partials: #{partials.keys.join(',')}"  
+                  Conxt = #{context.current}
+                  EOS
+
+          logger.debug "#{__method__}: template=#{template}, data=#{data}" if logger.debug?    
+          return render( template, data )
+
+        end
+      end # class Renderer < Mustache
+      
+
+    end
+  end
+end
+

data/lib/translator/sexp.rb

@@ -0,0 +1,57 @@
+module Sbuilder
+  module Al
+    module Translator
+      class Sexp < Array
+
+        def initialize(*args)
+          super(args)
+        end
+
+        ##
+        # Returns the node type of the Sexp.
+
+        def sexp_type
+          first
+        end
+
+        ##
+        # Returns the Sexp body, ie the values without the node type.
+
+        def sexp_body
+          self[1..-1]
+        end
+
+        # @return [Sexp|Nil] sexp_body.first for corresponding 'prop'
+        def sexp_property( prop )
+          sexp_element = sexp_body && sexp_body.select{ |e| e.is_a?(Sexp) && e.sexp_type == prop }.first
+          sexp_element.sexp_body.first unless sexp_element.nil?
+        end
+        
+        # @return [Sexp:Array] sexp_body for corresponding 'prop'
+        def sexp_properties( prop )
+          sexp_element = sexp_body && sexp_body.select{ |e| e.is_a?(Sexp) && e.sexp_type == prop }
+          # [[:sexp, [:sexp1, ...], [:sexp1, ...]]] --> [:sexp, [:sexp1, ...], [:sexp1, ...]]
+          sexp_element.flatten(1)[1..-1]
+        end
+        
+
+        # alias :head :sexp_type
+        # alias :rest :sexp_body
+        
+        
+      end # class Sexp
+
+      
+      # Important shortcut
+      def s(*args)
+        Sexp.new(*args )
+      end
+      module_function :s
+      public :s
+      
+    end # module Translator
+    
+  end
+end
+
+

data/lib/translator/tlagenerator.rb

@@ -0,0 +1,1348 @@
+
+require 'mustache'
+
+
+module Sbuilder
+  module Al
+    module Translator
+
+
+      ##
+      # Create tla sexps, which can be rendered using
+      # {Sbuilder::Al::Translator::Renderer}
+      #
+      # To be able procude valid tla-language snippets tla sexps
+      # created by class have to consider:
+      #
+      # 1) strings for tla-language constructs:
+      #    {Sbuilder::Al::Translator::Renderer} Mustache template
+      #    generator uses tag separator {| }} and implements #EVAL
+      #
+      # 2) need to add statement labels in tla proc language: 2.1)
+      #    flag proc language statement requiring labels (see
+      #    {Sbuilder::Al::Translator::TlaGenerator#tlaStatementTypeRequiresLabel}
+      #    2.2) proc block statements implement recursion to check for
+      #    labels
+      #    {Sbuilder::Al::Translator::TlaGenerator#setLabelBlockStatements}
+      #
+      # 3) avoid name collisions in final tla language result:
+      #    tla-sbuilder facade mustache template generator uses {{ }}
+      #    tags and implements #SPEC_NAME
+      #
+      # 4) performance: manages tla -snippets in a
+      #    {Sbuilder::Al::Translator::TlaGenerator#partials} hash,
+      #    which contains compiled templates Mustache.templateify
+      #
+      #
+
+      class TlaGenerator
+
+        # @attr [Hash] partials intialized with #setPartials, cumulated
+        # using #addPartial
+        attr_reader :partials
+
+        # @attr [Hash] partials_duplicateCheck, used only as guarantee
+        # againts redefinition
+        attr_reader :partials_duplicateCheck
+
+        # # @attr [Hash] validMetatypes raise exception for unknwon mentateyps
+        # attr_reader :validMetatypes
+
+        # @attr [Hash] labeledStmts
+        #
+        # @option labeledStmts [:Symbol] <sTlaType> generate template
+        # map to true is label should be followed
+        attr_reader :labeledStmts
+
+        # text to prefix trace print
+        TRACE_PREFIX="TRACE>"
+
+        # Constants
+        TLA_LABEL_ABORT = "_abort"
+        TLA_LABEL_END = "_end"      
+        TLA_LABEL_FAIL = "_fail"      
+        
+
+
+        # ------------------------------------------------------------------
+        # @!group Construct & configure
+
+        def initialize( options = {} )
+          @options = options
+          # @logger = getLogger( nil, options )
+          # @logger.info "#{__method__}: initalized"
+
+          # initially no known template requiring labe
+          @labeledStmts = {}
+
+        end
+
+        # Init w. application context
+        def self.start( partials = {} )
+          tlaGenerator = TlaGenerator.new
+          tlaGenerator.setPartials( partials )
+          # tlaGenerator.setValidMetatypes( METATYPES )
+          tlaGenerator
+        end
+
+
+        # # @return [Hash] defaultPartials for mustache templates
+        # def self.defaultPartials
+        #   {
+        #     :Snippet => <<-EOS
+        #     (* {|metatype|}:{|appName|}{|# comment |} - {|{ comment }|}{|/ comment |} *)
+        #     {|#snippet|}{|#EVAL|}.{|/EVAL|}{|/snippet|}
+        #     EOS
+        #   }
+        # end
+
+        def setPartials( partials )
+          @partials = partials
+          @partials_duplicateCheck = {}
+        end
+
+        # def setValidMetatypes( validMetatypes )
+        #   @validMetatypes = validMetatypes
+        # end
+
+        
+        # @!endgroup
+
+
+        # ------------------------------------------------------------------
+        # @!group Utitilities to create generate elements
+
+        # create s() with +sym+ (to dispatch correct template) and +hash+ as
+        # template data to render.
+        def stla( sym, hash)
+          sTla = Sbuilder::Al::Translator.s( sym, hash )
+        end
+
+        def s(*args)
+          Sbuilder::Al::Translator::Sexp.new(*args )
+        end
+
+        ###
+        # Add +partialTemplate+ with name +partialSymbol+ to partial
+        # collection.
+        #
+        # NOTICE: as an optimization Mustache template implementation
+        # can use partials, which are initalized using
+        # 'Mustache.templateify' to speed up rendering phase.
+        #
+        # @param [Symbol] partialSymbol identifying partial
+        #
+        # @param [String] partialTemplate to render element SEXP
+        #
+        #
+        def addPartial( partialSymbol, partialTemplate )
+          raise "Should have called #setPartials before actions" if partials.nil?
+          # would like to guarantee that no template refinition takes
+          # place - currently assume that implementation is correct and
+          # just return
+          
+          return if partials.key?(partialSymbol)
+          raise <<~EOS  if partials_duplicateCheck.key?(partialSymbol) && partials_duplicateCheckpartials[partialSymbol] != partialTemplate 
+          Partial  #{partialSymbol} redefinitition:
+
+          Previous: 
+            #{partials[partialSymbol]}
+
+            New: 
+            #{partialTemplate}
+
+            EOS
+          
+                                                                partials[partialSymbol]  = Mustache.templateify(partialTemplate)
+                                                                partials_duplicateCheck[partialSymbol]  = partialTemplate
+        end
+
+        # @!endgroup
+
+        
+        # ------------------------------------------------------------------
+        # @!group Statement labeling
+
+        ##
+        # Configure +sTlaType+ in +labeledStmts+ to require a label
+        #
+        # @see requiresLabelAfter
+        def tlaStatementTypeRequiresLabel( sTlaType )
+          labeledStmts[sTlaType] = true
+        end
+
+        ##
+        # Flag +stmt+ to include label if +hiddenStmt+ requires label.
+        #
+        # @see requiresLabelAfter
+        def statementRequiresLabel( stmt, labedStatement=nil )
+          stmt.define_singleton_method( :labelFollowingStatement ) do |inBlock|
+            return true if labedStatement.nil?
+            inBlock ? true : labedStatement
+          end
+        end
+
+        ##
+        # Statement 'stmt' contains a block with 'stmts', which should
+        # also be labeled. Later, use :labelBlockStatements to return
+        # 'stmts' to label.
+        def setLabelBlockStatements( stmt, stmts, methodName = :labelBlockStatements )
+          stmt.define_singleton_method( methodName ) do
+            stmts
+          end
+        end
+
+
+        ##
+        # Check whether +stmt+ with +stmt.sexp_type+ should be followed
+        # by a labeled statement.
+        #
+        # @param [SexpTla] stmt sexp which may respond to ':labelFollowingStatement'
+        #
+        # @return [Boolean] true is +sTlaType+ is found in
+        # +labeledStmts+ hash OR stmt.labelFollowingStatement
+        def requiresLabelAfter( stmt, inBlock=false )
+          return false unless stmt
+          # if s( s(:sym, ..), s(:sym,)) vs. s(:sym, ..)
+          sTlaType = stmt.any? && !stmt[0].is_a?(Symbol) ? stmt.last.sexp_type : stmt.sexp_type
+
+          # static 
+          if labeledStmts[sTlaType] ||
+             ( stmt.respond_to?(:labelFollowingStatement) && stmt.labelFollowingStatement(inBlock))
+            return true
+          end
+          # dynamic recursion to block
+          if stmt.respond_to?(:requiresLabelAfterChecker)
+            stmt.requiresLabelAfterChecker.each do |st|
+              return true if requiresLabelAfter( st, true )
+            end
+          end
+          return false
+        end
+        
+        def gen_serviceProcedureLabelStatements( stmts, labelPrefix )
+          stmts = stmts[1][:stmts] if stmts.is_a?(Array) &&  stmts[0] == :TLA_stmts
+          stmts, index = serviceProcedureLabelStatementsWorker( stmts, labelPrefix, 0, 0, true, [], [] )
+          stmts
+        end
+
+        ##
+        # Should add label 1) if block statements requires label after
+        # the statements 2) label between assignments to a same
+        # variable 3) call same macro
+        #
+        # @return [Array, index] stmts as passed as input, index incremented
+        ##
+        private def serviceProcedureLabelStatementsWorker( stmts, labelPrefix, index, level, labelFirst, assignments, macrocalls )
+          # assignments = []
+          stmts.each_with_index do |stmt,i|
+
+            # prev stamement in current block
+            prevStmt = stmts[i-1] if i > 0 
+            # puts "#{' ' * level } - #{level}: #{labelPrefix[1][:specname][:appName]}-#{index} #{stmts[i][0]}"
+            if labelFirst || ( !prevStmt.nil? && requiresLabelAfter( prevStmt ) ) ||
+               stmt.respond_to?( :labelCurrentStatement ) && stmt.labelCurrentStatement || 
+               ( stmt[0] == :TLA_assign  ) && assignments.include?( getLvalVariableName(stmt[1][:lval]) ) ||
+               ( stmt[0] == :TLA_macro_call  ) && macrocalls.include?( getMacroName(stmt[1][:macroName]) )              
+              stmts[i] = gen_labeled_stmt( stmt, labelPrefix, index )
+              # puts "#{' ' * level } - #{level}: --> label #{labelPrefix[1][:specname][:appName]}-#{index} #{stmt[0]}"            
+              index += 1
+              # restart collection
+              assignments = []
+              macrocalls = []
+            end
+            # collect assingments
+            assignments << getLvalVariableName(stmt[1][:lval]) if stmt[0] == :TLA_assign
+            macrocalls <<  getMacroName(stmt[1][:macroName]) if stmt[0] == :TLA_macro_call
+            
+            labelFirst = false
+
+            # then & while>?
+            if stmt.respond_to?( :labelBlockStatements )
+              # recursion 
+              s, index = serviceProcedureLabelStatementsWorker( stmt.labelBlockStatements, labelPrefix, index, level+1, false, assignments, macrocalls )
+            end
+
+            # else block
+            if stmt.respond_to?( :labelBlockStatementsElse )
+              # recursion 
+              s, index = serviceProcedureLabelStatementsWorker( stmt.labelBlockStatementsElse, labelPrefix, index, level+1, false, assignments, macrocalls )
+            end
+            
+            
+          end
+          return stmts, index
+        end
+
+        # @param [:TLA_plainname, :TLA_specname] tla from which to exect macro name
+        def getMacroName( macroTla )
+          getLvalVariableName(macroTla )
+        end
+
+        # @param [TLA_plainname] lval from which to extract variable name
+        def getLvalVariableName( lval )
+          case lval[0]
+          when :TLA_plainname
+            lval[1][:name]
+          when :TLA_specname
+            lval[1][:specname][:appName]
+          else
+            raise "Unknown lval type '#{lval[0]}' in #{lval}"
+          end
+        end
+        
+
+
+        # @!endgroup
+
+        # ------------------------------------------------------------------
+        # @!group Create TLA specific generate element SEXPs
+        
+        def gen_label_it( tla )
+          sym = :TLA_label_it
+          tlaStatementTypeRequiresLabel( sym )
+          addPartial(  sym, "{|#EVAL|}tla{|/EVAL|}" )
+          stla( sym, { :tla => tla } )
+        end
+
+        # @param name [String,tlaSexp] name of macro to call 
+        def gen_macro( name, parameters, stmts )
+          
+          sym = :TLA_macro
+          addPartial(
+            sym,
+            "macro {|#EVAL|}name{|/EVAL|}( {|#parameters|}{|#EVAL|}parameter{|/EVAL|}{|_comma|}{|/parameters|} ) {\n"\
+            "{|#EVAL|}stmts{|/EVAL|}"\
+            "}"
+          )
+
+          # allow singleton parameter
+          parameters = parameters.is_a?( Array ) ? parameters : [parameters]
+          
+          stla( sym, {
+                  :name => name.is_a?( String ) ? gen_plainname(name) : name,
+                  :parameters => parameters.any?  ?
+                                   parameters.map.with_index do |p,i|
+                                     { :_comma => (i+1) == parameters.length ? '' : ',',
+                                       :parameter => p.is_a?(String)  ? gen_plainname( p ): p,
+                                     }
+                                   end :
+                                   false,
+                  :stmts => stmts,
+                })
+        end
+        
+        def gen_service_procedure( serviceName, interfaceName, localVariables, stmts=gen_stmts(s()) )
+          
+          sym = :TLA_Procedure
+          addPartial(
+            sym,
+            <<~EOS
+          procedure {|#EVAL|}name{|/EVAL|}( {|#EVAL|}name{|/EVAL|}_input ) 
+             {|#locals|}variable {|/locals|}{|#localVariables|} {|#EVAL|}variable{|/EVAL|}{|_comma|}{|/localVariables|}{|#locals|};
+             {|/locals|}{|!
+                 Start procudedure block 
+             |}{
+            {|#EVAL|}name{|/EVAL|}_start:
+              {|#EVAL|}start{|/EVAL|};
+
+              (* Body of {|#EVAL|}interfaceName{|/EVAL|} *)
+              {|#EVAL|}stmts{|/EVAL|}
+
+            {|#EVAL|}name{|/EVAL|}_exit:
+              goto {|#EVAL|}name{|/EVAL|}#{TLA_LABEL_END};
+            {|#EVAL|}name{|/EVAL|}#{TLA_LABEL_FAIL}:
+               \\* throw command sends here
+               InfrastructureServiceReturn( "{|#EVAL|}interfaceName{|/EVAL|}", FALSE, Nil);
+               goto {|#EVAL|}name{|/EVAL|}#{TLA_LABEL_END};
+
+            {|#EVAL|}name{|/EVAL|}#{TLA_LABEL_ABORT}:
+               \\* should not happen??
+               print <<"ABORT {|#EVAL|}name{|/EVAL|}">>;
+               InfrastructureServiceReturn( "{|#EVAL|}interfaceName{|/EVAL|}", Abort, Nil);
+               \\* schedule_throw( "{|#EVAL|}name{|/EVAL|}_exit" );
+            {|#EVAL|}name{|/EVAL|}#{TLA_LABEL_END}:
+                skip;
+                (* ethereum_service_pop( "{|#EVAL|}interfaceName{|/EVAL|}" ); *)
+            {|#EVAL|}return{|/EVAL|};
+            }
+          EOS
+          )
+
+          name = serviceName.is_a?( String)  ? gen_plainname(serviceName) : serviceName
+          
+          stla( sym, {
+                  :name => name,
+                  :locals => localVariables && localVariables.length > 0 ? true : false, 
+                  :localVariables => localVariables.map.with_index do |v,i|
+                    {
+                      :variable => v.is_a?(String) ? gen_plainname(v) : v,
+                      :_comma => (i+1) == localVariables.length ? '' : ',',
+                    }
+                  end,
+                  :interfaceName => interfaceName.is_a?( String)  ? gen_plainname(interfaceName) : interfaceName,
+                  :start => gen_traced_stmt(
+                    gen_skip,
+                    s( "ENTRY:" ), #  + entry_exit,
+                  ),
+                  :stmts => stmts,
+                  :return =>
+                  gen_traced_stmt(
+                    gen_return,
+                    s( "EXIT:", ), #  + entry_exit, 
+                  ),
+                })
+        end
+        
+        
+        
+        ##
+        # @return +specName+
+        def gen_expression2( expr1, op, expr2 )
+          sym = :TLA_expression2
+          addPartial( sym, "{|#EVAL|}expr1{|/EVAL|} {|#EVAL|}op{|/EVAL|} {|#EVAL|}expr2{|/EVAL|}" )
+          stla( sym, {
+                  :expr1 => expr1,
+                  :op => op,
+                  :expr2 => expr2,                                
+                })
+        end
+
+        ##
+        # @return [ f1 |-> type1, f2 |->type2 ]
+        def gen_record_definition( arrOfFields )
+
+          sym = :TLA_record_definition
+          addPartial( sym, "[ {|#fields|}{|#EVAL|}val{|/EVAL|}{|_comma|} {|/fields|}]" )
+
+          # simplify if just one given
+          arrOfFields = arrOfFields[0].is_a?( Symbol ) ? s(arrOfFields) : arrOfFields
+          
+          # last element no comma
+          stla( sym,
+                {
+                  :fields => arrOfFields.map.with_index { |f,i|
+                    { :_comma => (i+1) == arrOfFields.length ? '' : ',', :val => f }
+                  }
+                })
+          
+        end
+
+
+        ##
+        # +variable+ \in +set+
+        def gen_set_iterate( variable, set )
+
+          sym = :TLA_set_iterate
+          addPartial( sym, "{|#EVAL|}variable{|/EVAL|} \\in {|#EVAL|}set{|/EVAL|} " )
+
+          # last element no comma
+          stla( sym,
+                {
+                  :variable => variable.is_a?( String)  ? gen_plainname(variable) : variable,
+                  :set => set.is_a?( String)  ? gen_plainname(set) : set,                
+                })
+        end
+
+        ##
+        # { map : S}
+        def gen_set_map( map, set )
+
+          sym = :TLA_set_map
+          addPartial( sym, "{ {|#EVAL|}map{|/EVAL|} : {|#EVAL|}set{|/EVAL|} } " )
+
+          # last element no comma
+          stla( sym,
+                {
+                  :map => map.is_a?( String)  ? gen_plainname(map) : map,
+                  :set => set.is_a?( String)  ? gen_plainname(set) : set,                
+                })
+        end
+        
+        
+        
+
+        # # @return [ idName |-> idVal, f2 |-> Nil, ... ]
+        def gen_new_record( idVal, arrOfFields )
+
+          sym = :TLA_new_record
+          addPartial(
+            sym,
+            <<~EOS
+          [ {|#EVAL|}idVal{|/EVAL|}, {|#fields|}{|#EVAL|}val{|/EVAL|}{|_comma|} {|/fields|} ]
+          EOS
+          )
+
+          # last element no comma
+          stla( sym,
+                {
+                  :idVal => idVal,
+                  :fields => arrOfFields.map.with_index do |f,i|
+                    { :_comma => (i+1) == arrOfFields.length ? '' : ',',
+                      :val => f
+                    }
+                  end
+                })
+          
+          
+        end
+
+        def gen_record_field_definition( name, value )
+          # name |-> value (notice spaces)
+          gen_name_op_operand( name, '|->', value )
+        end
+        def gen_record_field( record, field )
+          # A.x 
+          gen_name_op_operand( record, '.', field, "" )        
+        end
+        def gen_record_named_field( record, field )
+          # A[x]
+          sym = :TLA_record_named_field
+          
+          addPartial( sym, "{|#EVAL|}record{|/EVAL|}{|sepl|}{|#EVAL|}field{|/EVAL|}{|sepr|}" )
+          
+          stla( sym,
+                {
+                  :record => record.is_a?( String ) ? gen_plainname(record) : record,
+                  :sepl => '[',
+                  :sepr => ']',                
+                  :field => field.is_a?( String ) ? gen_plainname(field) : field,
+                })
+        end
+        
+        
+        
+        def gen_name_op_operand( name, op, operand, sep=" " )
+          
+          sym = :TLA_name_op_operand
+          addPartial( sym, "{|#EVAL|}name{|/EVAL|}{|sep|}{|{op}|}{|sep|}{|#EVAL|}operand{|/EVAL|}" )
+          
+          stla( sym,
+                {
+                  :name => name.is_a?( String ) ? gen_plainname(name) : name,
+                  :op => op,
+                  :sep => sep,
+                  :operand => operand.is_a?( String ) ? gen_plainname(operand) : operand,
+                })
+          
+        end
+
+        ##
+        # Map interface to service name e.g./customer(get), Demo()
+        def gen_service_name( interface )
+          gen_identifier( interface )
+        end
+
+        def gen_identifier( identifier, posfix="" )
+
+          sym = :TLA_identifier
+          addPartial( sym, "{|#EVAL|}identifier{|/EVAL|}{|#EVAL|}postfix{|/EVAL|}" )
+          
+          stla( sym, {
+                  :identifier => identifier.is_a?( String) ?
+                                   gen_plainname(identifier) :
+                                   identifier,
+                  :postfix => posfix.is_a?( String) ? gen_plainname(posfix) : posfix,
+                })
+        end
+
+
+        ##
+        # @return Nil
+        def gen_empty_set()
+          sym = :TLA_emptyset
+
+          addPartial( sym, "{}" )
+          
+          stla(sym, {
+               })
+        end
+
+        def gen_list( elements )
+          sym = :TLA_list
+          addPartial( sym, "{|#elements|}{|#EVAL|}element{|/EVAL|}{|_comma|}{|/elements|}" )
+
+          # allow singleton parameter
+
+          elements = elements.is_a?( String)  ? gen_plainname(elements) : elements
+          elements = elements[0].is_a?( Symbol ) ? s(elements) : elements
+          
+          stla( sym,
+                {
+                  :elements => elements.map.with_index { |f,i|
+                    { :_comma => (i+1) == elements.length ? '' : ',', :element => f }
+                  }
+                })
+
+          
+        end
+
+        def gen_set( element=nil )
+          element = s() if element.nil?
+          element = gen_list( element  )
+
+          sym = :TLA_set
+          addPartial( sym, "{ {|#EVAL|}element{|/EVAL|} }" )
+          
+          stla(sym, {
+                 :element => element
+               })
+        end
+
+        def gen_sequence( element=nil )
+          element = s() if element.nil?
+          element = gen_list( element  )
+
+          sym = :TLA_sequence
+          addPartial( sym, "<< {|#EVAL|}element{|/EVAL|} >>" )
+
+          stla(sym, {
+                 :element => element
+               })
+
+
+          # elements = elements.is_a?( String)  ? gen_plainname(elements) : elements
+          # elements = elements[0].is_a?( Symbol ) ? s(elements) : elements
+          # stla(sym, {
+          #        :elements => elements.any?  ?
+          #                       elements.map.with_index do |p,i|
+          #                         { :_comma => (i+1) == elements.length ? '' : ',',
+          #                           :element => p.is_a?(String)  ? gen_plainname( p ): p,
+          #                         }
+          #                       end :
+          #                       false,
+          #      })
+        end
+
+        def gen_TRUE
+          gen_plainname( "TRUE" )
+        end
+
+        def gen_FALSE
+          gen_plainname( "FALSE" )
+        end
+
+        ##
+        # @return Nil
+        def gen_nilElement( args )
+          sym = :TLA_nil_element
+
+          addPartial( sym, "Nil" )
+          
+          stla( sym, {})
+        end
+
+
+        def gen_op_set_minus()
+          gen_op_operator( "\\" )
+        end
+
+        ## 
+        # Common behavior to output operator +op+
+        def  gen_op_operator( op )
+          sym = :TLA_op_operator
+
+          addPartial( sym, "{|operator|}" )
+          
+          stla( sym, {
+                  :operator => op
+                })
+
+        end
+
+        ##
+        # Define state variable +variable+ and initialize
+        # with +initExpr+
+        def gen_state_variable( variable, initExpr )
+          sym = :TLA_state_variable
+          addPartial( sym, "{|#EVAL|}variable{|/EVAL|} = {|#EVAL|}init_expression{|/EVAL|};" )
+          
+          stla( sym, {
+                  :variable => variable, 
+                  :init_expression => initExpr, 
+                })
+        end
+
+        ##
+        # @param [String] interfaceName e.g. 'Demo()' or 'Demo(set)'
+        #
+        # @return [String] input variable name
+        def gen_interface_input_variable_name( interfaceName, metatype=:solidity_contract_function )
+          gen_identifier( gen_specname( metatype, interfaceName), "_input" )
+        end
+
+        ##
+        # @param [String] interfaceName e.g. 'Demo()' or 'Demo(set)'
+        #
+        def gen_interface_abort_label( interfaceName, serviceName=nil )
+          serviceName = gen_serviceName( interfaceName ) if serviceName.nil?
+          gen_identifier( serviceName, TlaElementText::TLA_LABEL_ABORT )
+        end
+
+        def gen_interface_end_label( interfaceName, serviceName=nil )
+          serviceName = gen_serviceName( interfaceName ) if serviceName.nil?
+          gen_identifier( serviceName, TlaElementText::TLA_LABEL_END )
+        end
+
+        ##
+        # Solidity code should check for error
+        def gen_interface_fail_label( interfaceName, serviceName=nil )
+          serviceName = gen_serviceName( interfaceName ) if serviceName.nil?
+          gen_identifier( serviceName, TlaElementText::TLA_LABEL_FAIL )
+        end
+
+        private def gen_serviceName( interfaceName )
+          metatype = :solidity_contract_function
+          gen_specname( metatype, interfaceName)
+        end
+        
+
+        ##
+        # Create +specName+ corresponging +appName+ in +metatype+
+        def gen_specname( metatype, appName )
+
+          sym = :TLA_specname
+          addPartial( sym, "#{spec_name('specname')}" )
+          
+          stla( sym,{
+                  :specname => {
+                    :metatype => metatype,
+                    :appName => appName,
+                  }})
+        end
+
+        # @return name
+        def gen_plainname( name )
+
+          sym = :TLA_plainname
+          addPartial( sym, "{|{name}|}" )
+          
+          stla( sym, {
+                  :name => name
+                })
+        end
+
+        def gen_constant( constant )
+          gen_plainname( constant )
+        end
+
+        # @return "str"
+        def gen_str( str )
+
+          sym = :TLA_str
+          addPartial( sym, '"{|#EVAL|}str{|/EVAL|}"' )
+          
+          stla( sym, {
+                  :str=> str.is_a?( String ) ? gen_plainname(str) : str,
+                })
+        end
+        
+        # @return ( "expr" )
+        def gen_parenthesis( expr )
+
+          sym = :TLA_parenthesis
+          addPartial( sym, '( {|#EVAL|}expr{|/EVAL|} )' )
+          
+          stla( sym, {
+                  :expr=> expr.is_a?( String ) ? gen_plainname(expr) : expr,
+                })
+        end
+        
+
+        # ------------------------------------------------------------------
+        # Statements
+
+        def gen_stmts( stmts )
+          # do not wrap twice
+          return stmts if stmts.is_a?( Array ) && stmts.any? && stmts[0] == :TLA_stmts
+          
+          sym = :TLA_stmts
+          addPartial( sym,
+                      "{|#stmts|}{|#EVAL|}.{|/EVAL|};\n"\
+                      "{|/stmts|}"
+                    )
+          
+          stmts = stla( sym, {
+                          # 1 stmt or array of stmts
+                          :stmts => stmts && stmts.any? && stmts[0].is_a?(Symbol) ? s(stmts) : stmts
+                        })
+          
+          # add method to return statements in stmts block for checking
+          # the need to add label after if-statement
+          methodName = :requiresLabelAfterChecker
+          stmts.define_singleton_method( methodName ) do
+            # pass if & else
+            stmts[1][:stmts]
+          end
+
+          stmts        
+          
+        end
+
+        # @param [Integer|String] labelIndex generate unique labels using index
+        #
+        def gen_labeled_stmt( stmt, labelPrefix=false, labelIndex=0 )
+          sym = :TLA_labeled_stmt
+          addPartial( sym, "{|#label|}{|#EVAL|}labelPrefix{|/EVAL|}_{|labelIndex|}: {|/label|}{|#EVAL|}stmt{|/EVAL|}" )        
+          labTla = stla( sym, {
+                           :stmt => stmt,
+                           :label => labelPrefix ? true : false,
+                           :labelPrefix => labelPrefix.is_a?( String)  ? gen_plainname(labelPrefix) : labelPrefix,
+                           :labelIndex => labelIndex,
+                         })
+
+          # labelel stmt should be followed by a label - if it is infront
+          # +stmt+, which should be followed by a label or if
+          # label is used within block
+          statementRequiresLabel( labTla, requiresLabelAfter( stmt ))
+          labTla 
+        end
+
+        ##
+        # Generate statement, which may also generate trace output.
+        #
+        # @param [Array] traceArray message/evaluatable mesage
+        # @option traceArray [String|TlaSexp] parameter for print operation
+        #
+        def gen_traced_stmt( stmt, traceArray=false )
+          sym = :TLA_traced_stmt
+          addPartial( sym,
+                      <<~EOS
+            {|#trace|}{|^preferences.tla-trace|}\\* {|/preferences.tla-trace|} {|#EVAL|}trace_print{|/EVAL|};
+            {|^preferences.tla-trace|}
+            {|/preferences.tla-trace|}{|/trace|}{|#EVAL|}stmt{|/EVAL|}
+            EOS
+                    )
+          
+          trace_stmt = stla( sym, {
+                               :stmt => stmt,
+                               :trace => traceArray ? true : false,
+                               :trace_print => gen_print( traceArray ),
+                             })
+
+          # trace_stmt should be followed by a label - if it is infront
+          # +stmt+, which should be followed by a label
+          statementRequiresLabel( trace_stmt ) if requiresLabelAfter( stmt )
+          trace_stmt
+          
+        end
+
+        def gen_print( parameters )
+          sym = :TLA_print
+          addPartial(
+            sym,
+            "print "\
+            "{|#parameters|}{|#EVAL|}parameter{|/EVAL|}{|_comma|}{|/parameters|}"\
+            ""
+          )
+
+          # String mapper to Sexp && convert whole into to s() -array
+          parameters = gen_str( parameters ) if parameters.is_a?( String )
+          parameters = parameters[0].is_a?( Symbol ) ? s(parameters) : parameters
+          # parameters.unshift( TRACE_PREFIX ) 
+
+          stla( sym, {
+                  :parameters => parameters.any?  ?
+                                   parameters.map.with_index do |p,i|
+                                     { :_comma => (i+1) == parameters.length ? '' : ',',
+                                       :parameter => p.is_a?(String) ?  gen_str(p) : p
+                                     }
+                                   end :
+                                   false,
+                })
+          
+        end
+
+        def gen_assign( lval, rval )
+          sym = :TLA_assign
+          # tlaStatementTypeRequiresLabel( sym )
+          addPartial( sym, "{|#EVAL|}lval{|/EVAL|} := {|#EVAL|}rval{|/EVAL|}" )
+          stla( sym, {
+                  :lval => lval.is_a?( String)  ? gen_plainname(lval) : lval,
+                  :rval => rval.is_a?( String)  ? gen_plainname(rval) : rval,                
+                })
+        end
+
+        def gen_return()
+
+          sym = :TLA_return
+          tlaStatementTypeRequiresLabel( sym )        
+          addPartial( sym, "return" )
+          stla( sym, {})
+          
+        end
+
+        def gen_assert( cond, msg )
+
+          sym = :TLA_assert
+          tlaStatementTypeRequiresLabel( sym )        
+          addPartial( sym,
+                      "(* {|#EVAL|}msg{|/EVAL|} *)\n"\
+                      "assert( {|#EVAL|}cond{|/EVAL|} )"
+                    )
+          stla( sym, {
+                  :cond => cond.is_a?(String)  ? gen_plainname(cond) : cond,
+                  :msg => msg.is_a?(String)  ? gen_str(msg) : msg,
+                })
+        end
+
+        
+
+        
+        def gen_free_text( str )
+          sym = :TLA_free_text
+          addPartial( sym, "{|{text}|}" )
+          # tlaStatementTypeRequiresLabel( sym )
+          stla( sym, {
+                  :text => str,
+                })
+        end
+
+        ##
+        # preable at the start of service procedure
+        def gen_check_resume( procedureName )
+
+          sym = :TLA_check_resume
+          addPartial(
+            sym,
+            <<~EOS
+          (* check if resuming  {|#EVAL|}procedureName{|/EVAL|} *)
+          if ( resume_context # Nil ) {
+              (* prepare stack entry with resume context followed by 
+                 a return to jump to resume location *)
+              stack := <<resume_context.ret_ctx >> \\o stack[self];
+          {|#EVAL|}procedureName{|/EVAL|}_resumed:
+              return;
+          }
+          EOS
+          )
+          tlaStatementTypeRequiresLabel( sym )
+          stla( sym, {
+                  :procedureName => procedureName,
+                })
+          
+        end
+
+        def gen_construct_contract( stateVariable, newContract, idPool, id )
+          sym = :TLA_construct_contract
+          addPartial( sym,
+                      <<~EOS
+                    \\* construct  {|#EVAL|}contracts{|/EVAL|}
+                    create_new_contract( {|#EVAL|}contracts{|/EVAL|}, {|#EVAL|}newContract{|/EVAL|}, {|#EVAL|}idPool{|/EVAL|}, {|#EVAL|}id{|/EVAL|} )
+                    EOS
+                    )
+          stla( sym, {
+                  :contracts => stateVariable,
+                  :newContract => newContract,
+                  :idPool => idPool,
+                  :id => id, 
+                })
+          
+        end
+
+
+        def gen_debug_msg( str )
+          sym = :TLA_debug_msg
+          # addPartial( sym, '{|^preferences.tla-debug|}\*{|/preferences.tla-debug|} print << "DEBUG: {|#EVAL|}text{|/EVAL|}" >>' )
+          addPartial( sym, 'print << "DEBUG: {|#EVAL|}text{|/EVAL|}" >>' )        
+          # tlaStatementTypeRequiresLabel( sym )
+          stla( sym, {
+                  :text => str.is_a?( String ) ? gen_plainname(str) : str,
+                })
+        end
+
+        def gen_commented( content )
+          sym = :TLA_commented
+          addPartial( sym,
+                      "(*  {|#EVAL|}content{|/EVAL|} *)\n"\
+                      "skip"
+                    )        
+          stla( sym, {
+                  :content => content.is_a?( String ) ? gen_plainname(content) : content,
+                })
+        end
+
+
+        def gen_procedure_call( procedure, parameters=s() )
+          sym = :TLA_procedure_call
+          # add label after proc.call
+          tlaStatementTypeRequiresLabel( sym )
+          addPartial(
+            sym,
+            "call {|#EVAL|}procedure{|/EVAL|}( {|#parameters|}{|#EVAL|}parameter{|/EVAL|}{|_comma|}{|/parameters|})"
+          )
+
+          parameters = parameters.is_a?( String ) ? gen_plainname(parameters) : parameters
+          parameters = parameters[0].is_a?( Symbol ) ? s(parameters) : parameters
+          stla( sym, {
+                  :procedure => procedure.is_a?( String ) ? gen_plainname(procedure) : procedure,
+                  # false or [ {:p, _comma: }] 
+                  :parameters => parameters.any?  ?
+                                   parameters.map.with_index do |p,i|
+                                     { :_comma => (i+1) == parameters.length ? '' : ',',
+                                       :parameter => p
+                                     }
+                                   end :
+                                   false,
+                })
+        end
+
+        def gen_and( lhs, rhs )
+          gen_bin_op( '/\\', lhs, rhs )
+        end
+
+        def gen_not( expression )
+          gen_unary_op( '~', expression )
+          # sym = :TLA_not
+          # addPartial(
+          #   sym,
+          #   "~{|#EVAL|}expression{|/EVAL|}"
+          # )
+          # stla( sym, {
+          #         :expression =>expression,
+          #       })
+        end
+
+        def gen_unary_op( op, expr )
+          sym = :TLA_unary_op
+          addPartial(
+            sym, "{|{op}|} {|#EVAL|}expr{|/EVAL|}"
+          )
+
+          stla( sym, {
+                  :expr => expr.is_a?( String)  ? gen_plainname(expr) : expr,
+                  :op => op,
+                })
+        end
+
+        def gen_bin_op( op, lhs, rhs )
+          sym = :TLA_bin_op
+          addPartial(
+            sym, "{|#EVAL|}lhs{|/EVAL|} {|{op}|} {|#EVAL|}rhs{|/EVAL|}"
+          )
+
+          stla( sym, {
+                  :lhs => lhs.is_a?( String)  ? gen_plainname(lhs) : lhs,
+                  :op => op,
+                  :rhs => rhs.is_a?( String)  ? gen_plainname(rhs) : rhs,                
+                })
+        end
+
+        def gen_either( stmt, stmts )
+          sym = :TLA_either
+          tlaStatementTypeRequiresLabel( sym )
+          addPartial(
+            sym,
+            "either {|#EVAL|}stmt{|/EVAL|}" \
+            "{|#stmts|} or {|#EVAL|}.{|/EVAL|}"\
+            "{|/stmts|}"
+          )
+          
+          stla( sym, {
+                  :stmt => stmt,
+                  :stmts => stmts[0].is_a?(Symbol) ? s(stmts) : stmts,
+                })
+
+        end
+
+        # @param [TLA_stmts|sTla] thenStatement
+        # @param [TLA_stmts|sTla|nil|false] elseStatement          
+        def gen_if( expression, thenStatement, elseStatement=nil )
+          sym = :TLA_if
+          addPartial(
+            sym,
+            
+            "if ( {|#EVAL|}cond{|/EVAL|} ) {\n"\
+            '      {|#EVAL|}then{|/EVAL|}'\
+            '}{|#else_given|} '\
+            "else {\n"\
+            '      {|#EVAL|}else{|/EVAL|}'\
+            '}{|/else_given|}'
+          )
+
+          
+          stmt_if = stla( sym, {
+                            :cond => expression.is_a?(String)  ? gen_plainname(expression) : expression,
+                            # :then => gen_stmts( thenStatement.length == 1 ? s(stmt) : thenStatement ),
+                            :then => thenStatement[0] == :TLA_stmts ? thenStatement : gen_stmts( thenStatement ),
+                            :else_given => elseStatement && elseStatement.length > 0  ? true : false,
+                            :else => elseStatement ? ( elseStatement[0] == :TLA_stmts ? elseStatement : gen_stmts( elseStatement ) ) : false,
+                          })
+
+          tlaStatementTypeRequiresLabel( sym )
+          # add label if then part of else part requires label
+          # statementRequiresLabel( stmt_if ) if requiresLabelAfter( thenStatement) || requiresLabelAfter(elseStatement)
+
+          # add method to return statements in then/else braches for
+          # checking the need to add label after if-statement
+          methodName = :requiresLabelAfterChecker
+          stmt_if.define_singleton_method( methodName ) do
+            # pass if & else
+            stmt_if[1][:then][1][:stmts]  + ( stmt_if[1][:else] ? stmt_if[1][:else][1][:stmts] : [] )
+          end
+          
+          # add method to recurse into then/else block to label
+          # statements within these blocks
+          setLabelBlockStatements( stmt_if, stmt_if[1][:then][1][:stmts] )
+          setLabelBlockStatements( stmt_if, stmt_if[1][:else][1][:stmts], :labelBlockStatementsElse )   if elseStatement
+          
+          stmt_if
+        end
+
+        def gen_IF( expression, thenExpr, elseExpr )
+          sym = :TLA_IF
+          addPartial(
+            sym,
+            
+            "IF {|#EVAL|}cond{|/EVAL|} THEN "\
+            '{|#EVAL|}then{|/EVAL|} '\
+            'ELSE '\
+            '{|#EVAL|}else{|/EVAL|}'
+          )
+
+          stla( sym, {
+                  :cond => expression.is_a?( String)  ? gen_plainname(expression) : expression,
+                  # :then => gen_stmts( thenExpr.length == 1 ? s(stmt) : thenExpr ),
+                  :then => thenExpr.is_a?( String)  ? gen_plainname(thenExpr) : thenExpr,
+                  :else => elseExpr.is_a?( String)  ? gen_plainname(elseExpr) : elseExpr,                
+                })
+        end
+
+        def gen_EXCEPT( variable, excepts )
+          sym = :TLA_EXCEPT
+          addPartial(
+            sym,
+            "[ {|#EVAL|}variable{|/EVAL|} "\
+            "EXCEPT "\
+            '{|#excepts|}{|#EVAL|}except{|/EVAL|}{|_comma|}{|/excepts|} '\
+            ']'
+          )
+
+          # if signleton given
+          excepts = excepts[0].is_a?(Symbol) ? s(excepts)  : excepts
+          stla( sym, {
+                  :variable => variable.is_a?( String ) ? gen_plainname(variable ) : variable,
+                  # :then => gen_stmts( thenExpr.length == 1 ? s(stmt) : thenExpr ),
+                  :excepts => excepts.any?  ?
+                                excepts.map.with_index do |p,i|
+                                  { :_comma => (i+1) == excepts.length ? '' : ',',
+                                    :except => p
+                                  }
+                                end :
+                                false,
+                })
+        end
+
+
+        def gen_skip()
+          sym = :TLA_skip
+          addPartial( sym, "skip" )
+          # tlaStatementTypeRequiresLabel( sym )
+          stla( sym, {})
+        end
+
+        ##
+        # skip statement, but reqeuires label infront
+        def gen_label
+          sym = :TLA_label
+          # tlaLabelCurrentStatement( sym )
+          addPartial( sym, "skip" )
+          stmt = stla( sym, {})
+
+          # make it add label infront
+          stmt.define_singleton_method( :labelCurrentStatement ) do 
+               true
+          end
+          stmt
+
+        end
+        
+        
+
+        # ------------------------------------------------------------------
+        # NOT USED
+
+
+        # Generate element for a lval to set a +return_variable+ of +function_name+
+        def lval_function_return( function_name, return_variable )
+
+          sym = :TLA_lval_function_return 
+          addPartial( sym,
+                      "{|function_name|}_{|return_variable|}" )
+          
+          stla( sym,
+                {
+                  :function_name =>function_name,
+                  :return_variable =>return_variable,
+                })
+          
+        end
+
+        # TODO: remove
+        def rval_todo_remove
+
+          sym = :TLA_rval_todo_remove
+          addPartial( sym, "{|demo|}" )
+          
+          stla( sym,
+                {
+                  :demo =>1,
+                })
+        end
+
+        # Usefull as a placeholder
+        def gen_operator_dummy( metatype, name )
+          gen_operator(
+            gen_specname( metatype, name ),
+            s(),
+            gen_free_text( "TRUE"  ),
+          )
+        end
+
+        def gen_operator_call( operatorName, parameters=[] )
+          sym = :TLA_operator_call
+          addPartial(
+            sym,
+            "{|#EVAL|}operatorName{|/EVAL|}"\
+            "{|#parameters.length|}( {|/parameters.length|}"\
+            "{|#parameters|}{|#EVAL|}parameter{|/EVAL|}{|_comma|}{|/parameters|}"\
+            "{|#parameters.length|} ){|/parameters.length|}"
+          )
+          
+          parameters = parameters[0].is_a?( Symbol ) ? s(parameters) : parameters
+          
+          stla( sym, {
+                  :operatorName => operatorName.is_a?( String ) ? gen_plainname(operatorName ) : operatorName,
+                  :parameters => parameters.any?  ?
+                                   parameters.map.with_index do |p,i|
+                                     { :_comma => (i+1) == parameters.length ? '' : ',',
+                                       :parameter => p
+                                     }
+                                   end :
+                                   false,
+                })
+          
+        end
+
+        ##
+        # Like operator call, but allways use ()
+        def gen_macro_call( macroName, parameters=[] )
+          sym = :TLA_macro_call
+          addPartial(
+            sym,
+            "{|#EVAL|}macroName{|/EVAL|}("\
+            "{|#parameters|}{|#EVAL|}parameter{|/EVAL|}{|_comma|}{|/parameters|}"\
+            ")"
+          )
+          
+          parameters = parameters[0].is_a?( Symbol ) ? s(parameters) : parameters
+          
+          stla( sym, {
+                  :macroName => macroName.is_a?( String ) ? gen_plainname(macroName ) : macroName,
+                  :parameters => parameters.any?  ?
+                                   parameters.map.with_index do |p,i|
+                                     { :_comma => (i+1) == parameters.length ? '' : ',',
+                                       :parameter => p
+                                     }
+                                   end :
+                                   false,
+                })
+          
+        end
+
+        
+
+        def gen_goto( label )
+          sym = :TLA_goto
+          tlaStatementTypeRequiresLabel( sym )
+          addPartial( sym, "goto {|#EVAL|}goto{|/EVAL|}" )
+          
+          stla( sym, {
+                  :goto => label.is_a?( String) ? gen_plainname(label) : label,
+                })
+          
+        end
+
+
+
+        # 
+        def gen_operator( operatorName, parameters, operatorBody )
+          sym = :TLA_operator
+          addPartial(
+            sym,
+            "{|#EVAL|}operatorName{|/EVAL|}"\
+            "{|#parameters.length|}({|/parameters.length|}{|#parameters|}"\
+            "{|#EVAL|}parameter{|/EVAL|}{|_comma|}{|/parameters|}"\
+            "{|#parameters.length|}){|/parameters.length|}"\
+            " == {|#EVAL|}operatorBody{|/EVAL|}"\
+            "\n"
+          )
+          
+          stla( sym,
+                {
+                  :operatorName => operatorName,
+                  :parameters => parameters.any?  ?
+                                   parameters.map.with_index do |p,i|
+                                     { :_comma => (i+1) == parameters.length ? '' : ',',
+                                       :parameter => p.is_a?(String)  ? gen_plainname( p ): p,
+                                     }
+                                   end :
+                                   false,
+                  :operatorBody => operatorBody.is_a?( String ) ? gen_plainname( operatorBody ) : operatorBody, 
+                })
+        end
+
+        def return_stmt( functionNameDef )
+          sym = :TLA_return_stmt
+          addPartial( sym, "goto #{spec_name('return_from')}_exit; \\* return contract '{| return_from |}'" )
+          
+          stla( sym,
+                {
+                  :return_from =>functionNameDef
+                })
+        end
+
+
+        # NOT USED
+        # ------------------------------------------------------------------
+        
+
+
+        # ------------------------------------------------------------------
+        # @!group common idioms
+
+        ##
+        # Mustache SPEC_NAME lamba call for +metatype+ & +appName+
+        # access unique name for +metatype+/+appName+ combination in
+        # specification code.
+        #
+        # @param [Hash] specNameDef name in tla generate element
+        # @option specNameDef [Symbol] :metatype
+        # @option specNameDef [Symbol] :appName      
+        #
+        # @return [String] string wrapped within SPEC_NAME mustache
+        # lambda call
+        def spec_name( specNameDef )
+          # "{{#SPEC_NAME}}#{specNameDef[:metatype]}.#{specNameDef[:appName]}{{/SPEC_NAME}}"
+          # "{{#SPEC_NAME}}{{#{specNameDef}.metatype}}.{{#{specNameDef}.appName}}{{/SPEC_NAME}}"
+          # "{{#SPEC_NAME}}{{metatype}}.{{appName}}{{/SPEC_NAME}}"
+          "{{#SPEC_NAME}}{|#{specNameDef}.metatype|}.{|#{specNameDef}.appName|}{{/SPEC_NAME}}"        
+        end
+
+        def appName( specNameDef )
+          "{|#{specNameDef}.metatype|}.{|#{specNameDef}.appName|}"        
+        end
+        
+
+        def exit_label( funcNameDef )
+        end
+
+        
+
+        # @!endgroup      
+        
+        
+      end
+    end
+  end
+end