skeem 0.0.17 → 0.0.18

data/lib/skeem/primitive/primitive_procedure.rb

@@ -0,0 +1,111 @@
+require_relative '../s_expr_nodes'
+
+module Skeem
+  module Primitive
+    class PrimitiveProcedure
+      attr_reader(:identifier)
+      attr_reader(:arity)
+      attr_reader(:code)
+
+      # param [anArity] Arity of the lambda code (ignoring the runtime object)
+      def initialize(anId, anArity, aRubyLambda)
+        @identifier = anId.kind_of?(String) ? SkmIdentifier.create(anId) : anId
+        @code = code_validated(aRubyLambda)
+        @arity = arity_validated(anArity)
+      end
+
+      # Arguments are positional in a primitive procedure.
+      def call(aRuntime, aProcedureCall)
+        check_actual_count(aProcedureCall)
+        do_call(aRuntime, aProcedureCall.operands.to_a)
+      end
+
+      private
+
+      def code_validated(aRubyLambda)
+        unless aRubyLambda.lambda?
+          error_lambda('must be implemented with a Ruby lambda.')
+        end
+        if aRubyLambda.parameters.size.zero?
+          error_lambda('lambda takes no parameter.')
+        end
+
+        aRubyLambda
+      end
+
+      def arity_validated(anArity)
+        count_param = code.parameters.size
+
+        if anArity.variadic?
+          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
+        end
+
+        anArity
+      end
+
+      def check_actual_count(aProcedureCall)
+        count_actuals = aProcedureCall.operands.size
+        if arity.nullary?
+          unless count_actuals.zero?
+            wrong_number_arguments(arity.high, count_actuals)
+          end
+        elsif arity.variadic?
+          if count_actuals < arity.low
+            wrong_number_arguments(arity.low, count_actuals)
+          end
+        else # fixed non-zero arity...
+          if count_actuals != arity.high
+            wrong_number_arguments(arity.high, count_actuals)
+          end
+        end
+      end
+
+      def do_call(aRuntime, operands)
+        if arity.nullary?
+          result = code.call(aRuntime)
+        elsif arity.variadic?
+          if arity.low.zero?
+            result = code.call(aRuntime, operands)
+          else
+            arguments = []
+            arguments << operands.take(arity.low).flatten
+            count_delta = operands.size - arity.low
+            arguments << SkmList.new(operands.slice(-count_delta, count_delta))
+            #p operands.size
+            #p count_delta
+            #p arguments.inspect
+            result = code.send(:call, aRuntime, *arguments.flatten)
+          end
+        else
+          result = code.send(:call, aRuntime, *operands)
+        end
+
+        result
+      end
+
+      def error_lambda(message_suffix)
+        msg1 = "Primitive procedure '#{identifier.value}'"
+        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
+      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
+      end
+    end # class
+  end # module
+end # module

data/lib/skeem/s_expr_builder.rb

@@ -61,7 +61,7 @@ module Skeem
     def reduce_definition(_production, aRange, _tokens, theChildren)
       SkmDefinition.new(aRange, theChildren[2], theChildren[3])
     end
-    
+
     # rule('definition' => 'LPAREN DEFINE LPAREN IDENTIFIER def_formals RPAREN body RPAREN').as 'alt_definition'
     # Equivalent to: (define IDENTIFIER (lambda (formals) body))
     def reduce_alt_definition(_production, aRange, _tokens, theChildren)
@@ -73,7 +73,7 @@ module Skeem
     def reduce_variable_reference(_production, aRange, _tokens, theChildren)
       SkmVariableReference.new(aRange, theChildren[0])
     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], [])
@@ -89,6 +89,11 @@ module Skeem
       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]
@@ -99,18 +104,23 @@ module Skeem
       lmbd = SkmLambda.new(aRange, theChildren[2], theChildren[3])
       # $stderr.puts lmbd.inspect
       lmbd
+    end    
+
+    # rule('formals' => 'LPAREN identifier_star RPAREN').as 'fixed_arity_formals'
+    def reduce_fixed_arity_formals(_production, _range, _tokens, theChildren)
+      SkmFormals.new(theChildren[1], :fixed)
+    end
+
+    # rule('formals' => 'IDENTIFIER').as 'variadic_formals'
+    def reduce_variadic_formals(_production, _range, _tokens, theChildren)
+      SkmFormals.new([theChildren[0]], :variadic)
     end
     
-    # rule('def_formals' => 'identifier_star period identifier').as 'dotted_formals'
-    def reduce_last_operand(_production, _range, _tokens, theChildren)
-      [theChildren.last]
+    # rule('formals' => 'LPAREN identifier_plus PERIOD IDENTIFIER RPAREN').as 'dotted_formals'
+    def reduce_dotted_formals(_production, _range, _tokens, theChildren)
+      formals = theChildren[1] << theChildren[3]
+      SkmFormals.new(formals, :variadic)
     end    
-    
-    
-    # rule('formals' => 'LPAREN identifier_star RPAREN').as 'identifiers_as_formals'
-    def reduce_identifiers_as_formals(_production, _range, _tokens, theChildren)
-      theChildren[1]
-    end
 
     # rule('identifier_star' => 'identifier_star IDENTIFIER').as 'identifier_star'
     def reduce_identifier_star(_production, _range, _tokens, theChildren)
@@ -121,6 +131,16 @@ module Skeem
     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)

data/lib/skeem/s_expr_nodes.rb

@@ -171,7 +171,7 @@ module Skeem
     attr_accessor(:members)
     extend Forwardable
 
-    def_delegators :@members, :each, :first, :length, :empty?
+    def_delegators :@members, :each, :first, :last, :length, :empty?, :size
 
     def initialize(theMembers)
       super(nil)
@@ -187,13 +187,8 @@ module Skeem
     end
 
     def evaluate(aRuntime)
-      result = nil
-
-      members.each do |elem|
-        result = elem.evaluate(aRuntime)
-      end
-
-      result
+      list_evaluated = members.map { |elem| elem.evaluate(aRuntime) }
+      SkmList.new(list_evaluated)
     end
 
     # Factory method.
@@ -233,6 +228,7 @@ module Skeem
 
     alias children members
     alias subnodes members
+    alias to_a members  
     alias rest tail
   end # class
 
@@ -248,11 +244,11 @@ module Skeem
 
     def evaluate(aRuntime)
       var_key = variable.evaluate(aRuntime)
-      aRuntime.define(var_key, self)      
+      aRuntime.define(var_key, self)
       case expression
         when SkmLambda
-          result = expression.evaluate(aRuntime) 
-          
+          result = expression.evaluate(aRuntime)
+
         when SkmVariableReference
           other_key = expression.variable.evaluate(aRuntime)
           if var_key.value != other_key.value
@@ -399,6 +395,75 @@ module Skeem
     end
   end # class
 
+  SkmArity = Struct.new(:low, :high) do
+    def nullary?
+      low.zero? && high == 0
+    end
+
+    def variadic?
+      high == '*'
+    end
+
+    def ==(other)
+      return true if self.object_id == other.object_id
+      result = false
+
+      case other
+        when SkmArity
+          result = true if (low == other.low) && (high == other.high)
+        when Array
+          result = true if (low == other.first) && (high == other.last)
+        when Integer
+          result = true if (low == other) && (high == other)
+      end
+
+      result
+    end
+  end
+
+  class SkmFormals
+    attr_reader :formals
+    attr_reader :arity
+
+    # @param arityKind [Symbol] One of the following: :fixed, :variadic
+    def initialize(theFormals, arityKind)
+      @formals = theFormals
+      arity_set(arityKind)
+    end
+
+    def evaluate(aRuntime)
+      formals.map! { |param| param.evaluate(aRuntime) }
+    end
+
+    def nullary?
+      arity.nullary?
+    end
+
+    def variadic?
+      arity.variadic?
+    end
+
+    def required_arity
+      (arity.high == '*') ? arity.low : arity.high
+    end
+
+    private
+
+    def arity_set(arityKind)
+      fixed_arity = formals.size
+
+      if arityKind == :fixed
+        @arity = SkmArity.new(fixed_arity, fixed_arity)
+      else # :variadic
+        if formals.empty?
+          raise StandardError, 'Internal error: inconsistent arity'
+        else
+          @arity = SkmArity.new(fixed_arity - 1, '*')
+        end
+      end
+    end
+  end # class
+
   class SkmLambda < SkmElement
     # @!attribute [r] formals
     # @return [Array<SkmIdentifier>] the argument names
@@ -414,7 +479,7 @@ module Skeem
     end
 
     def evaluate(aRuntime)
-      formals.map! { |param| param.evaluate(aRuntime) }
+      formals.evaluate(aRuntime)
     end
 
     def call(aRuntime, aProcedureCall)
@@ -429,6 +494,14 @@ module Skeem
       result
     end
 
+    def arity
+      formals.arity
+    end
+
+    def required_arity
+      formals.required_arity
+    end
+
     def inspect
       result = inspect_prefix + '@formals ' + formals.inspect + ', '
       result << '@definitions ' + definitions.inspect + ', '
@@ -439,18 +512,29 @@ module Skeem
     private
 
     def bind_locals(aRuntime, aProcedureCall)
-      arguments =  aProcedureCall.operands.members
-      formals.each_with_index do |arg_name, index|
-        arg = arguments[index]
-        if arg.nil?
-          raise StandardError, "Unbound variable: '#{arg_name.value}'"
+      actuals =  aProcedureCall.operands.members
+      count_actuals = actuals.size
+      
+      if (count_actuals < required_arity) ||
+        ((count_actuals > required_arity) && !formals.variadic?)
+        raise StandardError, msg_arity_mismatch(aProcedureCall)
+      end
+      return if count_actuals.zero?
+      bind_required_locals(aRuntime, aProcedureCall)
+      
+      if formals.variadic?
+        variadic_part_raw = actuals.drop(required_arity)
+        variadic_part = variadic_part_raw.map do |actual|
+          if actual.kind_of?(ProcedureCall)
+            actual.evaluate(aRuntime)           
+          else
+            actual
+          end
         end
-
-        # IMPORTANT: execute procedure call in argument list now
-        arg = arg.evaluate(aRuntime) if arg.kind_of?(ProcedureCall)
-        a_def = SkmDefinition.new(position, arg_name, arg)
-        a_def.evaluate(aRuntime)
-        # $stderr.puts "LOCAL #{a_def.inspect}"
+        variadic_arg_name = formals.formals.last
+        args_coll = SkmList.new(variadic_part)
+        a_def = SkmDefinition.new(position, variadic_arg_name, args_coll)
+        a_def.evaluate(aRuntime)        
       end
     end
 
@@ -466,6 +550,33 @@ module Skeem
 
       result
     end
+
+    def bind_required_locals(aRuntime, aProcedureCall)
+      max_index = required_arity - 1
+      actuals =  aProcedureCall.operands.members
+
+      formals.formals.each_with_index do |arg_name, index|
+        arg = actuals[index]
+        if arg.nil?
+          raise StandardError, "Unbound variable: '#{arg_name.value}'"
+        end
+
+        # IMPORTANT: execute procedure call in argument list now
+        arg = arg.evaluate(aRuntime) if arg.kind_of?(ProcedureCall)
+        a_def = SkmDefinition.new(position, arg_name, arg)
+        a_def.evaluate(aRuntime)
+        # $stderr.puts "LOCAL #{a_def.inspect}"
+        break if index >= max_index
+      end
+    end
+    
+    def msg_arity_mismatch(aProcedureCall)
+      # *** ERROR: wrong number of arguments for #<closure morph> (required 2, got 1)
+      msg1 = "Wrong number of arguments for procedure #{operator} "
+      count_actuals = aProcedureCall.operands.members.size
+      msg2 = "(required #{required_arity}, got #{count_actuals})"
+      msg1 + msg2
+    end
   end # class
 end # module
 # End of file

data/lib/skeem/standard/base.skm

@@ -18,6 +18,11 @@
       #t
       #f)))
 
+; For backwards compatibility      
+(define modulo
+  (lambda (x y)
+    (floor-remainder x y)))
+      
 (define odd?
   (lambda (n)
     (if (= (modulo n 2) 1)
@@ -38,4 +43,7 @@
 
 (define square
   (lambda (z)
-    (* z z)))
+    (* z z)))
+    
+(define list
+  (lambda args args))

data/lib/skeem/tokenizer.rb

@@ -22,7 +22,8 @@ module Skeem
       "'" => 'APOSTROPHE',
       '`' => 'BACKQUOTE',
       '(' => 'LPAREN',
-      ')' => 'RPAREN'
+      ')' => 'RPAREN',
+      '.' => 'PERIOD'
     }.freeze
 
     # Here are all the SRL keywords (in uppercase)
@@ -73,7 +74,7 @@ module Skeem
       if "()'`".include? curr_ch
         # Delimiters, separators => single character token
         token = build_token(@@lexeme2name[curr_ch], scanner.getch)
-      elsif (lexeme = scanner.scan(/#(?:\.)(?=\s|[|()";]|$)/)) # Single char occurring alone
+      elsif (lexeme = scanner.scan(/(?:\.)(?=\s|[|()";]|$)/)) # Single char occurring alone
         token = build_token('PERIOD', lexeme)
       elsif (lexeme = scanner.scan(/#(?:t|f|true|false)(?=\s|[|()";]|$)/))
         token = build_token('BOOLEAN', lexeme)
@@ -193,13 +194,13 @@ module Skeem
         found = scanner.skip(/(?:\r\n)|\r|\n/)
         if found
           ws_found = true
-          @lineno += 1
-          @line_start = scanner.pos
+          next_line
         end
         next_ch = scanner.peek(1)
         if next_ch == ';'
           cmt_found = true
           scanner.skip(/;[^\r\n]*(?:(?:\r\n)|\r|\n)?/)
+          next_line
         end
         break unless ws_found or cmt_found
       end
@@ -207,6 +208,11 @@ module Skeem
       curr_pos = scanner.pos
       return if curr_pos == pre_pos
     end
+    
+    def next_line
+      @lineno += 1
+      @line_start = scanner.pos
+    end
   end # class
 end # module
 # End of file