flor 0.13.0 → 0.14.0

data/lib/flor/pcore/_pat_or.rb

@@ -0,0 +1,46 @@
+
+require 'flor/pcore/_pat_'
+
+
+class Flor::Pro::PatOr < Flor::Pro::PatContainer
+
+  name '_pat_or'
+
+  def pre_execute
+
+    unatt_unkeyed_children
+  end
+
+  def receive_non_att
+
+    ct = child_type(@fcid)
+
+    if ct == :pattern
+
+      b = payload.delete('_pat_binding')
+      return wrap_match_reply(b) if b
+
+    elsif payload['ret'] == val
+
+      return wrap_match_reply({})
+    end
+
+    super
+  end
+
+  def receive_last
+
+    wrap_no_match_reply
+  end
+
+  protected
+
+  def wrap_match_reply(binding)
+
+    payload['_pat_binding'] = binding
+    payload.delete('_pat_val')
+
+    wrap_reply
+  end
+end
+

data/lib/flor/pcore/_val.rb

@@ -0,0 +1,20 @@
+
+class Flor::Pro::Val < Flor::Procedure
+
+  name '_val'
+
+  def wrap_reply
+
+    if node_open?
+
+      heat = @node['heat']
+      #heat = nil if heat == [ '_proc', 'val', -1 ] || heat[0] == '_nul'
+      heat = nil if heat[0] == '_nul'
+
+      payload['ret'] = heat
+    end
+
+    super
+  end
+end
+

data/lib/flor/pcore/arith.rb

@@ -1,7 +1,7 @@
 
 class Flor::Pro::Arith < Flor::Procedure
 
-  names %w[ + - * / ]
+  names %w[ + - * / % ]
 
   DEFAULTS = { :+ => 0, :* => 1, :- => 0, :/ => 1 }
 
@@ -13,6 +13,12 @@ class Flor::Pro::Arith < Flor::Procedure
   def receive_last
 
     sign = tree.first.to_sym
+    count = @node['rets'].size
+
+    if sign == :% && count < 2
+      fail ArgumentError.new(
+        "modulo % requires at least 2 arguments (line #{tree[2]})")
+    end
 
     payload['ret'] = @node['rets'].reduce(&sign) || DEFAULTS[sign]
 

data/lib/flor/pcore/case.rb

@@ -9,11 +9,11 @@ class Flor::Pro::Case < Flor::Procedure
   #
   # ```
   # case level
-  #   [ 0 1 2 ];; 'low'
-  #   [ 3 4 5 ];; 'medium'
-  #   else;; 'high'
+  #   [ 0 1 2 ]; 'low'
+  #   [ 3 4 5 ]; 'medium'
+  #   else; 'high'
   # ```
-  # which is a ";;"ed version of
+  # which is a ";"ed version of
   # ```
   # case level
   #   [ 0 1 2 ]
@@ -37,89 +37,66 @@ class Flor::Pro::Case < Flor::Procedure
   def pre_execute
 
     unatt_unkeyed_children
-#    flatten
+
+    @node['val'] = payload['ret'] if non_att_children.size.even?
   end
 
-  def receive_non_att
+  def receive
 
     return wrap_reply if @node['found']
 
-    return receive_array if @node.has_key?('key')
+    determine_fcid_and_ncid
+
+    return execute_child(@ncid) if @fcid == nil
+
+    has_no_val = ! @node.has_key?('val')
 
-    @node['key'] = payload['ret']
-    super
+    if has_no_val && ! from_att?
+      @node['val'] = payload['ret']
+      execute_conditional
+    elsif has_no_val
+      execute_child(@ncid)
+    elsif m = match?
+      execute_then(@ncid, m)
+    else
+      execute_conditional(@ncid + 1)
+    end
   end
 
   protected
 
-  def receive_array
+  def execute_conditional(ncid=@ncid)
 
-    a = payload['ret']
-    a = a.nil? ? [ a ] : Array(a)
+    if else?(ncid)
+      execute_then(ncid + 1)
+    else
+      payload['ret'] = node_payload_ret
+      execute_child(ncid)
+    end
+  end
 
-    payload['ret'] = node_payload_ret
+  def execute_then(ncid, vars=nil)
 
-    if a.include?(@node['key'])
+    payload['ret'] = node_payload_ret
+    @node['found'] = true
 
-      @node['found'] = true
-      execute_child(@fcid + 1)
+    h = vars.is_a?(Hash) ? { 'vars' => vars } : nil
 
-    else
+    execute_child(ncid, nil, h)
+  end
 
-      t = tree[1][@fcid + 2]
+  def else?(ncid)
 
-      if t && t[0, 2] == [ 'else', [] ]
-        @node['found'] = true
-        execute_child(@fcid + 3)
-      else
-        execute_child(@fcid + 2)
-      end
-    end
+    (t = tree[1][ncid]) &&
+    t[0, 2] == [ 'else', [] ]
   end
 
-#  def flatten
-#
-#    ot = tree; return if ot[1].size < 2
-#    t = Flor.dup(ot)
-#
-#    nchildren = []
-#    mode = :array
-#
-#    #t[1][1..-1].each do |ct|
-#    non_att_children.each do |ct|
-#
-#      if nchildren.empty? || mode == :clause
-#        nchildren << ct
-#        mode = :array
-#        next
-#      end
-#
-#      ct0, ct1, ct2 = ct
-#
-#      if (Flor.is_tree?(ct0) || ct0 == 'else') && ct1.any?
-#        nchildren << (ct0 == 'else' ? [ 'else', [], ct2 ] : ct0)
-#        if ct1.size == 1
-#          nchildren << ct1.first
-#        else # ct1.size > 1
-#          sequence = [ 'sequence', ct1, ct1.first[2] ]
-#          nchildren << sequence
-#        end
-#      #elsif ct0.is_a?(String) && ct1.is_a?(Array) && ct1.any?
-#      #  p ct
-#      #  dct0 = deref(ct0)
-#      #  hct0 = reheap(ct, dct0)
-#      #  p dct0
-#      #  p hct0
-#      else
-#        nchildren << ct
-#        mode = :clause
-#      end
-#    end
-#
-#    t[1] = nchildren
-#pp nchildren
-#
-#    @node['tree'] = t if t != ot
-#  end
+  def match?
+
+    a = payload['ret']
+    a = a.nil? ? [ a ] : Array(a)
+
+    a.include?(@node['val'])
+  end
 end
 

data/lib/flor/pcore/cursor.rb

@@ -132,20 +132,27 @@ class Flor::Pro::Cursor < Flor::Procedure
     fail("move target #{to.inspect} not found")
   end
 
+  def is_tag_tree?(t, tagname)
+
+    Flor.is_att_tree?(t) &&
+    t[1].size == 2 &&
+    t[1][0][0, 2] == [ 'tag', [] ] &&
+    Flor.is_string_tree?(t[1][1], tagname)
+  end
+
+  def is_att_string_tree?(t, s)
+
+    Flor.is_att_tree?(t) &&
+    t[1].size == 1 &&
+    Flor.is_string_tree?(t[1].first, s)
+  end
+
   def find_tag_target(to)
 
     tree[1]
-      .index { |c|
-        c[1].is_a?(Array) &&
-        c[1].index { |cc|
-          Flor.is_tree?(cc) &&
-          cc[0] == '_att' &&
-          cc[1].size == 2 &&
-          cc[1][0][0] == 'tag' &&
-          %w[ _sqs _dqs ].include?(cc[1][1][0]) &&
-          cc[1][1][1] == to
-        }
-      }
+      .index { |ct|
+        ct[1].is_a?(Array) &&
+        ct[1].index { |cc| is_tag_tree?(cc, to) } }
   end
 
   def find_string_arg_target(to)
@@ -153,24 +160,19 @@ class Flor::Pro::Cursor < Flor::Procedure
     tree[1]
       .index { |c|
         c[1].is_a?(Array) &&
-        c[1].index { |cc|
-          Flor.is_tree?(cc) &&
-          cc[0] == '_att' &&
-          cc[1].size == 1 &&
-          %w[ _sqs _dqs ].include?(cc[1][0][0]) &&
-          cc[1][0][1] == to
-        }
-      }
+        c[1].index { |cc| is_att_string_tree?(cc, to) } }
   end
 
   def find_string_target(to)
 
-    tree[1].index { |c| %w[ _sqs _dqs ].include?(c[0]) && c[1] == to }
+    tree[1]
+      .index { |ct| Flor.is_string_tree?(ct, to) }
   end
 
   def find_name_target(to)
 
-    tree[1].index { |c| c[0] == to }
+    tree[1]
+      .index { |ct| ct[0] == to }
   end
 
   def find_att_target(to)
@@ -182,9 +184,7 @@ class Flor::Pro::Cursor < Flor::Procedure
         c[1].find { |cc|
           cc[0] == '_att' &&
           cc[1].is_a?(Array) &&
-          cc[1][0][0, 2] == [ 'here', [] ]
-        }
-      }
+          cc[1][0][0, 2] == [ 'here', [] ] } } # FIXME hardcoded...
   end
 end
 

data/lib/flor/pcore/define.rb

@@ -50,9 +50,13 @@ class Flor::Pro::Define < Flor::Procedure
     cnode = lookup_var_node(@node, 'l')
     cnid = cnode['nid']
     fun = counter_next('funs') - 1
+
     (cnode['closures'] ||= []) << fun
 
-    val = [ '_func', { 'nid' => nid, 'cnid' => cnid, 'fun' => fun }, t[2] ]
+    val = [
+      '_func',
+      { 'nid' => nid, 'tree' => t, 'cnid' => cnid, 'fun' => fun },
+      t[2] ]
 
     if t[0] == 'define'
       name =

data/lib/flor/pcore/do_return.rb

@@ -0,0 +1,32 @@
+
+class Flor::Pro::DoReturn < Flor::Macro
+  #
+  # Takes a set of arguments and returns a function
+  # that will return those arguments again.
+  #
+  # ```
+  # set a
+  #   do-return 1
+  # a _
+  # ```
+  # will set 1 in the payload `ret`.
+  #
+  # It might be useful in cases like:
+  # ```
+  # sequence on_error: (do-return 1)
+  #   do-this-failure-prone-thing _
+  # ```
+  #
+
+  name 'do-return'
+
+  def rewrite_tree
+
+    l = tree[2]
+
+    [ 'sequence', [
+      [ 'def', att_children.first[1], l ]
+    ], l ]
+  end
+end
+

data/lib/flor/pcore/length.rb

@@ -0,0 +1,18 @@
+
+class Flor::Pro::Length < Flor::Procedure
+
+  name 'length'
+
+  def receive_last
+
+    r = payload['ret']
+
+    payload['ret'] =
+      if r.respond_to?(:length) then r.length
+      else -1
+      end
+
+    super
+  end
+end
+

data/lib/flor/pcore/logo.rb

@@ -0,0 +1,47 @@
+
+class Flor::Pro::Logo < Flor::Procedure
+
+  names %w[ and or ]
+
+  def execute
+
+    payload['ret'] = @node['heat0'] == 'and'
+
+    super
+  end
+
+  def receive_att
+
+    c = children[@fcid]; return super if c[0] == '_att' && [1].size == 2
+
+    h0 = @node['heat0']
+
+    ret = Flor.true?(payload['ret'])
+
+    return wrap_reply if ((h0 == 'or' && ret) || (h0 == 'and' && ! ret))
+
+    super
+  end
+
+  alias receive_non_att receive_att
+
+#  def pre_execute
+#
+#    @node['rets'] = []
+#  end
+#
+#  def receive_last
+#
+#    payload['ret'] =
+#      if @node['heat0'] == 'or'
+#        !! @node['rets'].index { |r| Flor.true?(r) }
+#      else
+#        ! @node['rets'].index { |r| Flor.false?(r) }
+#      end
+#
+#    wrap_reply
+#  end
+  #
+  # Keep me around for a "aand" and a "oor"... Maybe...
+end
+

data/lib/flor/pcore/map.rb

@@ -1,19 +1,17 @@
 
 class Flor::Pro::Map < Flor::Procedure
 
-  name 'map'
+  names %w[ map for-each ]
 
   def pre_execute
 
-    #@node['ret'] = Flor.dup(payload['ret']) # now using @node['payload']
-
-    @node['vars'] = {}
-      # just to store the local idx
+    @node['vars'] ||= {}
 
     @node['col'] = nil
     @node['idx'] = -1
     @node['fun'] = nil
-    @node['res'] = []
+
+    @node['res'] = @node['heat0'] == 'map' ? [] : nil
 
     unatt_unkeyed_children
   end
@@ -33,15 +31,19 @@ class Flor::Pro::Map < Flor::Procedure
 
     if @node['idx'] < 0
       @node['fun'] = payload['ret']
-    else
-      @node['res'] << payload['ret']
+    elsif res = @node['res']
+      res << payload['ret']
     end
 
     @node['idx'] += 1
     @node['mtime'] = Flor.tstamp
 
-    return wrap_reply('ret' => @node['res']) \
-      if @node['idx'] == @node['col'].size
+    if @node['idx'] == @node['col'].size
+      if res = @node['res']
+        payload['ret'] = @node['res']
+      end
+      return wrap_reply
+    end
 
     @node['vars']['idx'] = @node['idx']