flor 0.14.0 → 0.15.0

data/lib/flor/parser.rb

@@ -1,7 +1,40 @@
 
 module Flor
 
-  module Lang include Raabro
+  def self.parse(input, fname=nil, opts={})
+
+    opts = fname if fname.is_a?(Hash) && opts.empty?
+
+    #Raabro.pp(Flor::Parser.parse(input, debug: 2), colours: true)
+    #Raabro.pp(Flor::Parser.parse(input, debug: 3), colours: true)
+
+    if r = Flor::Parser.parse(input, opts)
+      r << fname if fname
+      r
+    else
+      r = Flor::Parser.parse(input, opts.merge(error: true))
+      fail Flor::ParseError.new(r, fname)
+    end
+  end
+
+  class ParseError < StandardError
+
+    attr_reader :line, :column, :offset, :msg, :visual, :fname
+
+    def initialize(error_array, fname)
+
+#puts "-" * 80
+#p error_array
+#puts error_array.last
+#puts "-" * 80
+      @line, @column, @offset, @msg, @visual = error_array
+      @fname = fname
+
+      super("syntax error at line #{@line} column #{@column}")
+    end
+  end
+
+  module Parser include Raabro
 
     # parsing
 
@@ -28,9 +61,10 @@ module Flor
     def fls(i); str(nil, i, 'false'); end
     def boolean(i); alt(:boolean, i, :tru, :fls); end
 
+    def rf_sq_symbol(i); rex(nil, i, /[^.| \b\f\n\r\t"'()\[\]{}#\\]+/); end
+    def rf_sq_index(i); alt(nil, i, :rf_sq_symbol, :dqstring, :sqstring); end
+    def rf_square(i); seq(nil, i, :sbstart, :rf_sq_index, :sbend); end
     def rf_symbol(i); rex(nil, i, /[^.:;| \b\f\n\r\t"',()\[\]{}#\\]+/); end
-    def rf_square_index(i); alt(nil, i, :rf_symbol, :dqstring, :sqstring); end
-    def rf_square(i); seq(nil, i, :sbstart, :rf_square_index, :sbend); end
     def rf_dot(i); seq(nil, i, :dot, :rf_symbol); end
     def rf_index(i); alt(nil, i, :rf_dot, :rf_square); end
     def reference(i); seq(:ref, i, :rf_symbol, :rf_index, '*'); end
@@ -79,8 +113,12 @@ module Flor
     def comma_qmark_eol(i); seq(nil, i, :comma, '?', :eol); end
     def coll_sep(i); alt(nil, i, :comma_qmark_eol, :ws_star); end
 
-    def ent(i); seq(:ent, i, :key, :postval, :colon, :postval, :exp, :postval); end
-    def ent_qmark(i); rep(nil, i, :ent, 0, 1); end
+    def ent(i)
+      seq(:ent, i, :key, :postval, :colon, :postval, :exp, :postval)
+    end
+    def ent_qmark(i)
+      rep(nil, i, :ent, 0, 1)
+    end
 
     def exp_qmark(i); rep(nil, i, :exp, 0, 1); end
 
@@ -191,22 +229,26 @@ module Flor
 
     def rewrite_obj(t)
 
+      l = ln(t)
+
       cn =
         t.subgather(nil).inject([]) do |a, tt|
           a << rewrite(tt.c0.c0)
           a << rewrite(tt.c4)
         end
-      cn = 0 if cn.empty?
+      cn = [ [ '_att', [ [ '_', [], l ] ], l ] ] if cn.empty?
 
-      [ '_obj', cn, ln(t) ]
+      [ '_obj', cn, l ]
     end
 
     def rewrite_arr(t)
 
+      l = ln(t)
+
       cn = t.subgather(nil).collect { |n| rewrite(n) }
-      cn = 0 if cn.empty?
+      cn = [ [ '_att', [ [ '_', [], l ] ], l ] ] if cn.empty?
 
-      [ '_arr', cn, ln(t) ]
+      [ '_arr', cn, l ]
     end
 
     def rewrite_val(t)
@@ -236,6 +278,7 @@ fail "don't know how to invert #{operation.inspect}" # FIXME
 
       return rewrite(t.c0) if t.children.size == 1
 
+#Raabro.pp(t, colours: true)
       cn = t.children.collect { |ct| ct.lookup(nil) }
 
       operation = cn.find { |ct| ct.name == :sop }.string
@@ -342,14 +385,18 @@ fail "don't know how to invert #{operation.inspect}" # FIXME
 
       def ta_rework_core(core)
 
+        dig = Digest::SHA256.hexdigest(JSON.dump(core))[0, 7]
+        tsp = Flor.tamp.gsub(/\./, '_')
+        h = "_head_#{dig}_#{tsp}"
+
         l = core[2]
 
         [ 'sequence', [
           [ 'set', [
-            [ 'head_', [], l ],
+            [ h, [], l ],
             core[0]
           ], l ],
-          [ 'head_', core[1], l ]
+          [ h, core[1], l ]
         ], l ]
       end
 
@@ -358,19 +405,19 @@ fail "don't know how to invert #{operation.inspect}" # FIXME
         @indent = tree.lookup(:indent).string.length
 
         ht = tree.lookup(:head)
-        @line = Flor::Lang.line_number(ht)
+        @line = Flor::Parser.line_number(ht)
 
-        @head = Flor::Lang.rewrite(ht.c0)
+        @head = Flor::Parser.rewrite(ht.c0)
         @head = @head[0] if @head[0].is_a?(String) && @head[1] == []
 
         atts = tree.children[2..-1]
           .inject([]) { |as, ct|
 
             kt = ct.children.size == 3 ? ct.children[1].lookup(:key) : nil
-            v = Flor::Lang.rewrite(ct.clast)
+            v = Flor::Parser.rewrite(ct.clast)
 
             if kt
-              k = Flor::Lang.rewrite(kt.c0)
+              k = Flor::Parser.rewrite(kt.c0)
               as << [ '_att', [ k, v ], k[2] ]
             else
               as << [ '_att', [ v ], v[2] ]
@@ -399,7 +446,7 @@ fail "don't know how to invert #{operation.inspect}" # FIXME
         elsif %w[ - + ].include?(c[0])
           @head = c[0]
           @children = c[1]
-          @children[0] = Flor::Lang.invert('+', @children[0])
+          @children[0] = Flor::Parser.invert('+', @children[0])
         end
       end
 
@@ -434,20 +481,7 @@ fail "don't know how to invert #{operation.inspect}" # FIXME
       root.children.count == 1 ? root.children.first.to_a : root.to_a
     end
     alias rewrite_panode rewrite_flor
-
-    def parse(input, fname=nil, opts={})
-
-      opts = fname if fname.is_a?(Hash) && opts.empty?
-
-      #Raabro.pp(super(input, debug: 2))
-      #Raabro.pp(super(input, debug: 3))
-
-      r = super(input, opts)
-      r << fname if fname
-
-      r
-    end
-  end # module Lang
+  end # module Parser
 
   def self.unescape_u(cs)
 
@@ -470,14 +504,14 @@ fail "don't know how to invert #{operation.inspect}" # FIXME
 
       if c == '\\'
         case cn = cs.next
-          when 'u' then sio.print(unescape_u(cs))
-          when '\\', '"', '\'' then sio.print(cn)
-          when 'b' then sio.print("\b")
-          when 'f' then sio.print("\f")
-          when 'n' then sio.print("\n")
-          when 'r' then sio.print("\r")
-          when 't' then sio.print("\t")
-          else sio.print("\\#{cn}")
+        when 'u' then sio.print(unescape_u(cs))
+        when '\\', '"', '\'' then sio.print(cn)
+        when 'b' then sio.print("\b")
+        when 'f' then sio.print("\f")
+        when 'n' then sio.print("\n")
+        when 'r' then sio.print("\r")
+        when 't' then sio.print("\t")
+        else sio.print("\\#{cn}")
         end
       else
         sio.print(c)

data/lib/flor/pcore/_arr.rb

@@ -1,5 +1,8 @@
 
-class Flor::Pro::Arr < Flor::Procedure
+require 'flor/pcore/_coll'
+
+
+class Flor::Pro::Arr < Flor::Pro::Coll
   #
   # "_arr" is the procedure behind arrays.
   #
@@ -18,23 +21,20 @@ class Flor::Pro::Arr < Flor::Procedure
 
   name '_arr'
 
-  def pre_execute
+  def receive_last_att
 
-    @node['rets'] = []
-  end
+    elts = tree[1][@ncid..-1]
 
-  def receive
-
-    return wrap_reply('ret' => []) if children == 0
+    return wrap_reply('ret' => elts.collect { |e| e[1] }) \
+      if elts.all? { |e| atomic?(e) }
 
+    @node['rets'] = []
     super
   end
 
   def receive_last
 
-    payload['ret'] = @node['rets']
-
-    wrap_reply
+    wrap_reply('ret' => @node['rets'])
   end
 end
 

data/lib/flor/pcore/_att.rb

@@ -67,8 +67,7 @@ class Flor::Pro::Att < Flor::Procedure
 
     if Flor.child_id(@message['from']) == 0
       ret = payload['ret']
-      ret = ret[1]['task'] if Flor.is_task_tree?(ret)
-      @node['key'] = k = ret
+      @node['key'] = k = unref(ret, :key)
       as = (parent_node || {})['atts_accepting_symbols'] || []
       execute_child(1, nil, 'accept_symbol' => as.include?(k))
     else
@@ -107,12 +106,18 @@ class Flor::Pro::Att < Flor::Procedure
     wrap_reply
   end
 
-  # vars: { ... }, inits a scope for the parent node
+  # `vars: { ... }` inits a scope for the parent node
+  # `vars: 'copy'` copies the parent scope and use as local scope
+  # `vars: [ 'a', 'b' ]` inits a new scope containing vars a and b
   #
   def receive_vars
 
-    vars = payload['ret']
-    vars = @executor.vars(nid) if vars == 'copy' || vars == '*'
+    vars =
+      case (vs = payload['ret'])
+      when 'copy', '*' then copy_vars
+      when Array then wlist_vars(vs)
+      else vs
+      end
 
     (parent_node['vars'] ||= {}).merge!(vars)
 
@@ -121,6 +126,42 @@ class Flor::Pro::Att < Flor::Procedure
     wrap_reply
   end
 
+  def copy_vars
+
+    @executor.vars(nid)
+      # Returns a hash of all the vars known at point `nid` of the execution
+  end
+
+  def wlist_vars(vs)
+
+    mode =
+      case vs.first
+      when '+' then '+'
+      when '-', '^', '!' then '-'
+      #else nil
+      end
+    vs.shift if mode
+
+    vs = vs.collect { |v| Flor.is_regex_tree?(v) ? Flor.to_regex(v) : v }
+    vars = copy_vars
+
+    if mode == '-'
+      Hash[vars.map { |k, v| [ k, var_match?(vs, k) ? nil : v ] }]
+    else
+      Hash[vars.map { |k, v| [ k, var_match?(vs, k) ? v : nil ] }]
+    end
+  end
+
+  def var_match?(vs, key)
+
+    vs.each do |v|
+      return true if v == key
+      return true if v.is_a?(Regexp) && v =~ key
+    end
+
+    false
+  end
+
   def parent_is_trap?
 
     pt = parent_node_tree; return false unless pt
@@ -167,15 +208,9 @@ class Flor::Pro::Att < Flor::Procedure
     wrap_reply
   end
 
-  def receive_on_error
-
-    oe = payload['ret']
-    oe[1]['on_error'] = true
-
-    (parent_node['on_error'] ||= []) << oe
-
-    wrap_reply
-  end
+  def receive_on_error; store_on(:error); wrap_reply; end
+  def receive_on_cancel; store_on(:cancel); wrap_reply; end
+  def receive_on_timeout; store_on(:timeout); wrap_reply; end
 
   def receive_flank
 

data/lib/flor/pcore/_coll.rb

@@ -0,0 +1,18 @@
+
+class Flor::Pro::Coll < Flor::Procedure
+
+  protected
+
+  def atomic?(child_tree)
+
+    t0, t1 = child_tree
+
+    return false if t1.is_a?(Array)
+    return false if t0 == '_dqs' && t1.index('$(')
+    return false if t0 == '_rxs'
+    return false if t0 == '_func'
+
+    Flor::Pro::Atom.names.include?(t0)
+  end
+end
+

data/lib/flor/pcore/_obj.rb

@@ -1,5 +1,8 @@
 
-class Flor::Pro::Obj < Flor::Procedure
+require 'flor/pcore/_coll'
+
+
+class Flor::Pro::Obj < Flor::Pro::Coll
   #
   # "_obj" is the procedure behind objects (maps).
   #
@@ -27,8 +30,6 @@ class Flor::Pro::Obj < Flor::Procedure
 
   def execute_child(index=0, sub=nil, h=nil)
 
-    return wrap_reply('ret' => {}) if children == 0
-
     return super if @node['rets'].size.odd?
 
     ct = children[index]
@@ -43,13 +44,28 @@ class Flor::Pro::Obj < Flor::Procedure
     super
   end
 
+  def receive_last_att
+
+    cn = tree[1][@ncid..-1]
+
+    return wrap_object(cn.collect { |c| c[1] }) \
+      if cn.all? { |c| atomic?(c) }
+
+    super
+  end
+
   def receive_last
 
-    payload['ret'] = @node['rets']
-      .each_slice(2)
-      .inject({}) { |h, (k, v)| h[k.to_s] = v; h }
+    wrap_object(@node['rets'])
+  end
+
+  protected
+
+  def wrap_object(arr)
 
-    wrap_reply
+    wrap_reply(
+      'ret' =>
+        arr.each_slice(2).inject({}) { |h, (k, v)| h[k.to_s] = v; h })
   end
 end
 

data/lib/flor/pcore/_pat_.rb

@@ -56,7 +56,7 @@ class Flor::Pro::PatContainer < Flor::Procedure
     ct0 = ct[0]
 
     return :att if ct0 == '_att'
-    return :pattern if /\A_pat_(arr|obj|or|guard)\z/ === ct0
+    return :pattern if /\A_pat_(arr|obj|or|guard|regex)\z/ === ct0
     return '_' if ct0 == '_'
     return ct0 if /\A[a-z][a-z0-9]*\z/ === ct0 && ct[1] == []
 

data/lib/flor/pcore/_pat_guard.rb

@@ -29,6 +29,9 @@ class Flor::Pro::PatGuard < Flor::Pro::PatContainer
     if ct == nil && @node['key'] == nil && payload['ret'].is_a?(String)
 
       k = payload['ret']
+
+      return wrap_no_match_reply if k == '_'
+
       m = k.match(Flor::SPLAT_REGEX)
       k = m ? k[0] : k
 
@@ -44,6 +47,11 @@ class Flor::Pro::PatGuard < Flor::Pro::PatContainer
       b = payload['_pat_binding']
       return wrap_no_match_reply unless b
 
+      if (k = @node['key']) && (m = b['match'])
+        b["#{k}__match"] = m
+        b["#{k}__matched"] = val
+      end
+
       @node['binding'].merge!(b)
     end
 

data/lib/flor/pcore/_pat_obj.rb

@@ -53,7 +53,7 @@ class Flor::Pro::PatObj < Flor::Pro::PatContainer
 
     unless key
       ret = ret.to_s
-      return wrap_no_match_reply unless Flor.deep_has_key?(val, ret)
+      return wrap_no_match_reply unless Dense.has_key?(val, ret)
       @node['key'] = ret
       @node['keys'] << ret if @node['keys']
       return super
@@ -77,7 +77,7 @@ class Flor::Pro::PatObj < Flor::Pro::PatContainer
 
       @node['binding'][ct[0]] = val[@node['key']] if ct[0].length > 0
 
-    elsif Flor.deep_get(val, key) != ret
+    elsif Dense.get(val, key) != ret
 
       return wrap_no_match_reply
     end
@@ -137,7 +137,7 @@ class Flor::Pro::PatObj < Flor::Pro::PatContainer
 
   def sub_val(child_index)
 
-    [ 1, val[@node['key']] ]
+    [ 1, Dense.get(val, @node['key']) ]
   end
 end