skeem 0.2.15 → 0.2.19

data/lib/skeem/primitive/primitive_procedure.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../s_expr_nodes'
 
 module Skeem
@@ -17,7 +19,7 @@ module Skeem
       def callable?
         true
       end
-      
+
       def procedure?
         true
       end
@@ -40,10 +42,11 @@ module Skeem
         check_actual_count(actuals)
         # TODO: check that next line became useless
         # aProcedureCall.operands_consumed = true
-        result = do_call(aRuntime, actuals)
+        # result = do_call(aRuntime, actuals)
         # $stderr.puts "  Result: #{result.inspect}"
         # $stderr.puts "--- End of procedure #{identifier}"
-        result
+        # result
+        do_call(aRuntime, actuals)
       end
 
       def skm_equal?(other)
@@ -76,10 +79,8 @@ module Skeem
           if (anArity.low + 2) != count_param
             discrepancy_arity_argument_count(anArity.low, count_param, 2)
           end
-        else # fixed arity...
-          if (anArity.high + 1) != count_param
-            discrepancy_arity_argument_count(anArity.high, count_param, 1)
-          end
+        elsif (anArity.high + 1) != count_param # fixed arity...
+          discrepancy_arity_argument_count(anArity.high, count_param, 1)
         end
 
         anArity
@@ -102,10 +103,8 @@ module Skeem
           if count_actuals > arity.high
             wrong_number_arguments(arity.high, count_actuals)
           end
-        else # fixed non-zero arity...
-          if count_actuals != arity.high
-            wrong_number_arguments(arity.high, count_actuals)
-          end
+        elsif count_actuals != arity.high # fixed non-zero arity...
+          wrong_number_arguments(arity.high, count_actuals)
         end
       end
 
@@ -114,11 +113,11 @@ module Skeem
           result = code.call(aRuntime)
         elsif arity.variadic? || (arity.low < arity.high)
           if arity.low.zero?
-            if ['and', 'or', 'append'].include? identifier
+            if %w[and or append].include? identifier
               # Defer the evaluation of arguments to the primitive
               result = code.call(aRuntime, operands)
             else
-              evaluated_args = operands.map {|opernd| opernd.evaluate(aRuntime) }
+              evaluated_args = operands.map { |opernd| opernd.evaluate(aRuntime) }
               result = code.call(aRuntime, evaluated_args)
             end
           else
@@ -134,14 +133,13 @@ module Skeem
             # p args.inspect
             result = code.send(:call, aRuntime, *args)
           end
-        else # Fixed arity...
-          if identifier.value =~ /^set-[a-zA-Z]+!/ || identifier.value =~ /[a-zA-Z]+-set!/
-            # Defer evaluation inside the primitive
-            result = code.send(:call, aRuntime, *operands)
-          else
-            evaluated_args = operands.map {|opernd| opernd.evaluate(aRuntime) }
-            result = code.send(:call, aRuntime, *evaluated_args)          
-          end
+        elsif identifier.value =~ /^set-[a-zA-Z]+!/ || identifier.value =~ /[a-zA-Z]+-set!/
+          # Fixed arity...
+          # Defer evaluation inside the primitive
+          result = code.send(:call, aRuntime, *operands)
+        else
+          evaluated_args = operands.map { |opernd| opernd.evaluate(aRuntime) }
+          result = code.send(:call, aRuntime, *evaluated_args)
         end
 
         result
@@ -149,21 +147,21 @@ module Skeem
 
       def error_lambda(message_suffix)
         msg1 = "Primitive procedure '#{identifier.value}'"
-        raise StandardError, msg1 + ' ' + message_suffix
+        raise StandardError, "#{msg1} #{message_suffix}"
       end
 
       def discrepancy_arity_argument_count(arity_required, count_param, delta)
         msg1 = "Discrepancy in primitive procedure '#{identifier.value}'"
         msg2 = "between arity (#{arity_required}) + #{delta}"
         msg3 = "and parameter count of lambda #{count_param}."
-        raise StandardError, msg1 + ' ' + msg2 + ' ' + msg3
+        raise StandardError, "#{msg1} #{msg2} #{msg3}"
       end
 
       def wrong_number_arguments(required, actual)
         msg1 = "Wrong number of arguments for #<Procedure #{identifier.value}>"
         msg2 = "(required at least #{required}, got #{actual})"
-        raise StandardError, msg1 + ' ' + msg2
+        raise StandardError, "#{msg1} #{msg2}"
       end
     end # class
   end # module
-end # module
+end # module

data/lib/skeem/runtime.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 's_expr_nodes'
 
 module Skeem
@@ -41,13 +43,12 @@ module Skeem
         result = nil
         begin
           result = entry.evaluate(self)
-
-        rescue NoMethodError => exc
+        rescue NoMethodError => e
           # $stderr.puts 'In rescue block'
           # $stderr.puts key_value.inspect
           # $stderr.puts entry.inspect
           # $stderr.puts entry.expression.inspect
-          raise exc
+          raise e
         end
         result
       else
@@ -66,13 +67,14 @@ module Skeem
       invokation.evaluate(self)
     end
 
-    def nest()
+    def nest
       nested = SkmFrame.new(environment)
       push(nested)
     end
 
     def unnest
       raise StandardError, 'Cannot unnest environment' unless environment.parent
+
       environment.bindings.clear
       pop
     end
@@ -90,6 +92,7 @@ module Skeem
       if env_stack.empty?
         raise StandardError, 'Skeem environment stack empty!'
       end
+
       env_stack.pop
     end
 
@@ -110,6 +113,7 @@ module Skeem
       if call_stack.empty?
         raise StandardError, 'Skeem call stack empty!'
       end
+
       call_stack.pop
     end
 
@@ -120,16 +124,14 @@ module Skeem
     private
 
     def normalize_key(aKey)
-      result = case aKey
-                 when String
-                   aKey
-                 when SkmVariableReference
-                    aKey.child.value
-                 else
-                   aKey.evaluate(self).value
-               end
-
-      result
+      case aKey
+        when String
+          aKey
+        when SkmVariableReference
+          aKey.child.value
+        else
+          aKey.evaluate(self).value
+      end
     end
   end # class
-end # module
+end # module

data/lib/skeem/s_expr_builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'stringio'
 require_relative 'skm_pair'
 require_relative 'skm_binding'
@@ -22,17 +24,6 @@ module Skeem
       'STRING_LIT' => SkmString
     }.freeze
 
-    # Create a new AST builder instance.
-    # @param theTokens [Array<Token>] The sequence of input tokens.
-    def initialize(theTokens)
-      super(theTokens)
-    end
-
-    # Notification that the parse tree construction is complete.
-    def done!
-      super
-    end
-
     protected
 
     def terminal2node
@@ -43,11 +34,23 @@ module Skeem
     def reduce_main(_production, _range, _tokens, theChildren)
       last_child = theChildren.last
       # $stderr.puts last_child.inspect
-      result = if last_child.length == 1
-                  last_child.car
-                else
-                  last_child
-                end
+      if last_child.length == 1
+        last_child.car
+      else
+        last_child
+      end
+    end
+
+    # Default semantic action for rules of the form:
+    # rule 'some_symbol_star' => 'some_symbol_star some_symbol'
+    def reduce_star_default(_production, _range, _tokens, theChildren)
+      theChildren[0] << theChildren[1]
+    end
+
+    # Default semantic action for rules of the form:
+    # rule 'some_symbol_star' => []
+    def reduce_star_base(_production, _range, _tokens, _children)
+      []
     end
 
     # rule('cmd_or_def_plus' => 'cmd_or_def_plus cmd_or_def').as 'multiple_cmd_def'
@@ -81,7 +84,7 @@ module Skeem
     end
 
     # rule('definition' => 'LPAREN BEGIN definition_star RPAREN').as 'definitions_within_begin'
-    def reduce_definitions_within_begin(_production, aRange, _tokens, theChildren)
+    def reduce_definitions_within_begin(_production, _range, _tokens, theChildren)
       SkmSequencingBlock.new(SkmPair.create_from_a(theChildren[2]))
     end
 
@@ -135,20 +138,10 @@ module Skeem
     end
 
     # rule('vector' => 'VECTOR_BEGIN datum_star RPAREN').as 'vector'
-    def reduce_vector(_production, aRange, _tokens, theChildren)
+    def reduce_vector(_production, _range, _tokens, theChildren)
       SkmVector.new(theChildren[1])
     end
 
-    # rule('datum_star' => 'datum_star datum').as 'datum_star'
-    def reduce_datum_star(_production, aRange, _tokens, theChildren)
-      theChildren[0] << theChildren[1]
-    end
-
-    # rule('datum_star' => []).as 'no_datum_yet'
-    def reduce_no_datum_yet(_production, aRange, _tokens, theChildren)
-      []
-    end
-
     # rule('procedure_call' => 'LPAREN operator RPAREN').as 'proc_call_nullary'
     def reduce_proc_call_nullary(_production, aRange, _tokens, theChildren)
       ProcedureCall.new(aRange, theChildren[1], [])
@@ -164,21 +157,6 @@ module Skeem
       pcall
     end
 
-    # rule('operand_plus' => 'operand_plus operand').as 'multiple_operands'
-    def reduce_multiple_operands(_production, _range, _tokens, theChildren)
-      theChildren[0] << theChildren[1]
-    end
-
-    # rule('operand_plus' => 'operand').as 'last_operand'
-    def reduce_last_operand(_production, _range, _tokens, theChildren)
-      [theChildren.last]
-    end
-
-    # rule('operand_plus' => 'operand').as 'last_operand'
-    def reduce_last_operand(_production, _range, _tokens, theChildren)
-      [theChildren.last]
-    end
-
     # rule('def_formals' => 'identifier_star').as 'def_formals'
     def reduce_def_formals(_production, _range, _tokens, theChildren)
       SkmFormals.new(theChildren[0], :fixed)
@@ -192,9 +170,10 @@ module Skeem
 
     # rule('lambda_expression' => 'LPAREN LAMBDA formals body RPAREN').as 'lambda_expression'
     def reduce_lambda_expression(_production, aRange, _tokens, theChildren)
-      lmbd = SkmLambdaRep.new(aRange, theChildren[2], theChildren[3])
+      # lmbd = SkmLambdaRep.new(aRange, theChildren[2], theChildren[3])
       # $stderr.puts lmbd.inspect
-      lmbd
+      # lmbd
+      SkmLambdaRep.new(aRange, theChildren[2], theChildren[3])
     end
 
     # rule('formals' => 'LPAREN identifier_star RPAREN').as 'fixed_arity_formals'
@@ -213,58 +192,17 @@ module Skeem
       SkmFormals.new(formals, :variadic)
     end
 
-    # rule('identifier_star' => 'identifier_star IDENTIFIER').as 'identifier_star'
-    def reduce_identifier_star(_production, _range, _tokens, theChildren)
-      theChildren[0] << theChildren[1]
-    end
-
-    # rule('identifier_star' => []).as 'no_identifier_yet'
-    def reduce_no_identifier_yet(_production, _range, _tokens, theChildren)
-      []
-    end
-
-    # rule('identifier_plus' => 'identifier_plus IDENTIFIER').as 'multiple_identifiers'
-    def reduce_multiple_identifiers(_production, _range, _tokens, theChildren)
-      theChildren[0] << theChildren[1]
-    end
-
-    # rule('identifier_plus' => 'IDENTIFIER').as 'last_identifier'
-    def reduce_last_identifier(_production, _range, _tokens, theChildren)
-      [theChildren[0]]
-    end
-
     # rule('body' => 'definition_star sequence').as 'body'
     def reduce_body(_production, _range, _tokens, theChildren)
       definitions = theChildren[0].nil? ? [] : theChildren[0]
       { defs: definitions, sequence: theChildren[1] }
     end
 
-    # rule('definition_star' => 'definition_star definition').as 'definition_star'
-    def reduce_definition_star(_production, _range, _tokens, theChildren)
-      theChildren[0] << theChildren[1]
-    end
-
-
-    # rule('definition_star' => []).as 'no_definition_yet'
-    def reduce_no_definition_yet(_production, _range, _tokens, theChildren)
-      []
-    end
-
     # rule('sequence' => 'command_star expression').as 'sequence'
     def reduce_sequence(_production, _range, _tokens, theChildren)
       SkmPair.create_from_a(theChildren[0] << theChildren[1])
     end
 
-    # rule('command_star' => 'command_star command').as 'multiple_commands'
-    def reduce_multiple_commands(_production, _range, _tokens, theChildren)
-      theChildren[0] << theChildren[1]
-    end
-
-    # rule('command_star' => []).as 'no_command_yet'
-    def reduce_no_command_yet(_production, _range, _tokens, theChildren)
-      []
-    end
-
     # rule('conditional' => 'LPAREN IF test consequent alternate RPAREN').as 'conditional'
     def reduce_conditional(_production, aRange, _tokens, theChildren)
       SkmCondition.new(aRange, theChildren[2], theChildren[3], theChildren[4])
@@ -286,7 +224,7 @@ module Skeem
     end
 
     # rule('derived_expression' => 'LPAREN LET LPAREN binding_spec_star RPAREN body RPAREN').as 'short_let_form'
-    def reduce_short_let_form(_production, aRange, _tokens, theChildren)
+    def reduce_short_let_form(_production, _range, _tokens, theChildren)
       SkmBindingBlock.new(:let, theChildren[3], theChildren[5])
     end
 
@@ -309,32 +247,12 @@ module Skeem
 
       # We reky on utility 'builder' object
       worker = SkmDoExprBuilder.new(theChildren[3], theChildren[6],
-        theChildren[7], theChildren[9])
+                                    theChildren[7], theChildren[9])
       do_expression = worker.do_expression
-      body = { :defs => [], :sequence => do_expression }
+      body = { defs: [], sequence: do_expression }
       SkmBindingBlock.new(:let_star, worker.bindings, body)
     end
 
-    # rule('cond_clause_plus' => 'cond_clause_plus cond_clause').as 'multiple_cond_clauses'
-    def reduce_multiple_cond_clauses(_production, _range, _tokens, theChildren)
-      theChildren[0] << theChildren[1]
-    end
-
-    # rule('cond_clause_plus' => 'cond_clause').as 'last_cond_clauses'
-    def reduce_last_cond_clauses(_production, _range, _tokens, theChildren)
-      [theChildren[0]]
-    end
-
-    # rule('cond_clause_star' => 'cond_clause_star cond_clause').as 'cond_clauses_star'
-    def reduce_cond_clauses_star(_production, _range, _tokens, theChildren)
-      theChildren[0] << theChildren[1]
-    end
-
-    # rule('cond_clause_star' => []).as 'last_cond_clauses_star'
-    def reduce_last_cond_clauses_star(_production, _range, _tokens, _children)
-      []
-    end
-
     # rule('cond_clause' => 'LPAREN test sequence RPAREN').as 'cond_clause'
     def reduce_cond_clause(_production, _range, _tokens, theChildren)
       [theChildren[1], SkmSequencingBlock.new(SkmPair.create_from_a(theChildren[2]))]
@@ -346,40 +264,20 @@ module Skeem
     end
 
     # rule('quasiquotation' => 'LPAREN QUASIQUOTE qq_template RPAREN').as 'quasiquotation'
-    def reduce_quasiquotation(_production, aRange, _tokens, theChildren)
+    def reduce_quasiquotation(_production, _range, _tokens, theChildren)
       SkmQuasiquotation.new(theChildren[2])
     end
 
     # rule('quasiquotation' => 'GRAVE_ACCENT qq_template').as 'quasiquotation_short'
-    def reduce_quasiquotation_short(_production, aRange, _tokens, theChildren)
+    def reduce_quasiquotation_short(_production, _range, _tokens, theChildren)
       SkmQuasiquotation.new(theChildren[1])
     end
 
-    # rule('binding_spec_star' => 'binding_spec_star binding_spec').as 'multiple_binding_specs'
-    def reduce_multiple_binding_specs(_production, aRange, _tokens, theChildren)
-      theChildren[0] << theChildren[1]
-    end
-
-    # rule('binding_spec_star' => []).as 'no_binding_spec_yet'
-    def reduce_no_binding_spec_yet(_production, aRange, _tokens, _children)
-      []
-    end
-
     # rule('binding_spec' => 'LPAREN IDENTIFIER expression RPAREN').as 'binding_spec'
-    def reduce_binding_spec(production, _range, _tokens, theChildren)
+    def reduce_binding_spec(_production, _range, _tokens, theChildren)
       SkmBinding.new(theChildren[1], theChildren[2])
     end
 
-    # rule('iteration_spec_star' => 'iteration_spec_star iteration_spec').as 'multiple_iter_specs'
-    def reduce_multiple_iter_specs(_production, _range, _tokens, theChildren)
-      theChildren[0] << theChildren[1]
-    end
-
-    # rule('iteration_spec_star' => []).as 'no_iter_spec_yet'
-    def reduce_no_iter_spec_yet(_production, _range, _tokens, _children)
-      []
-    end
-
     # rule('iteration_spec' => 'LPAREN IDENTIFIER init step RPAREN').as 'iteration_spec_long'
     def reduce_iteration_spec_long(_production, _range, _tokens, theChildren)
       SkmIterationSpec.new(theChildren[1], theChildren[2], theChildren[3])
@@ -391,10 +289,16 @@ module Skeem
     end
 
     # rule('do_result' => []).as 'empty_do_result'
-    def reduce_empty_do_result(_production, _range, _tokens, theChildren)
+    def reduce_empty_do_result(_production, _range, _tokens, _children)
       SkmEmptyList.instance
     end
 
+    # rule('includer' => 'LPAREN INCLUDE string_plus RPAREN').as 'include'
+    def reduce_include(_production, _range, _tokens, theChildren)
+      includer = SkmIncluder.new(theChildren[2])
+      includer.build
+    end
+
     # rule('list_qq_template' => 'LPAREN qq_template_or_splice_star RPAREN').as 'list_qq'
     def reduce_list_qq(_production, _range, _tokens, theChildren)
       SkmPair.create_from_a(theChildren[1])
@@ -406,21 +310,9 @@ module Skeem
     end
 
     # rule('unquotation' => 'COMMA qq_template').as 'unquotation_short'
-    def reduce_unquotation_short(_production, aRange, _tokens, theChildren)
+    def reduce_unquotation_short(_production, _range, _tokens, theChildren)
       SkmUnquotation.new(theChildren[1])
     end
-
-    # rule('qq_template_or_splice_star' => 'qq_template_or_splice_star qq_template_or_splice').as 'multiple_template_splice'
-    def reduce_multiple_template_splice(_production, _range, _tokens, theChildren)
-      theChildren[0] << theChildren[1]
-    end
-
-    # rule('qq_template_or_splice_star' => []).as 'no_template_splice_yet'
-    def reduce_no_template_splice_yet(_production, _range, _tokens, theChildren)
-      []
-    end
-
-
   end # class
 end # module
-# End of file
+# End of file