flor 0.15.0 → 0.16.0

data/lib/flor/log.rb

@@ -41,7 +41,7 @@ module Flor
       a << " #{_c.lg}#{fla}#{_c.dg}" if fla
 
       st = nd && nd['status'].last
-      a << " #{_c.dim}#{_c.lg}#{st['status']}:#{st['flavour']}#{_c.rs}#{_c.dg}" \
+      a << " #{_c.dim}#{_c.lg}#{st['status']}:#{st['flavour']}#{_c.rs}#{_c.dg}"\
         if st && st['status']
 
       t = m['tree']
@@ -56,7 +56,7 @@ module Flor
           ''
         end
 
-      a << m['on_error'] ? " #{_c.rd}on_error" : ''
+      a << (m['on_error'] ? " #{_c.rd}on_error" : '')
 
       tmi = m['timer_id']
       tmi = tmi ? " #{_c.dg}tmi:#{tmi}" : ''
@@ -71,7 +71,7 @@ module Flor
       a << cn
 
       hp = nd && nd['heap']
-      hp = hp && (hp != (t || [])[0]) ? " #{_c.dg}hp:#{nd['heap']}" : ''
+      hp = (hp && (hp != (t || [])[0])) ? " #{_c.dg}hp:#{nd['heap']}" : ''
       a << hp
 
       msr = " #{_c.dg}m#{m['m']}s#{m['sm'] || '_'}"
@@ -155,11 +155,14 @@ module Flor
       c = t1.is_a?(Array) ? '' : " #{_c.yl}#{t1}"
       l = " #{_c.dg}L#{t2}"
 
-      o.puts "#{ind}#{_c.dg}+--- #{opts[:title]}#{_c.rs}" if headers && nid == '0'
+      o.puts "#{ind}#{_c.dg}+--- #{opts[:title]}#{_c.rs}" \
+        if headers && nid == '0'
       o.puts "#{ind}#{_c.dg}| #{nid} #{h}#{c}#{l}#{_c.rs}"
       t1.each_with_index { |ct, i|
-        o.puts tree_to_s(ct, Flor.child_nid(nid, i), opts) } if t1.is_a?(Array)
-      o.puts "#{ind}#{_c.dg}.#{_c.rs}" if headers && nid == '0'
+        o.puts tree_to_s(ct, Flor.child_nid(nid, i), opts) } \
+          if t1.is_a?(Array)
+      o.puts "#{ind}#{_c.dg}.#{_c.rs}" \
+        if headers && nid == '0'
 
       o.string
     end
@@ -184,6 +187,9 @@ module Flor
 
     def to_compact_tree_s(tree, nid='0', opts={})
 
+      close = opts[:close]
+      opts.merge!(close: false)
+
       o = StringIO.new
       _c = colours(opts)
 
@@ -213,8 +219,7 @@ module Flor
         o << "\n" << to_compact_tree_s(ct, "#{nid}_#{i}", opts)
       end
 
-      #o << "\n" << ind << _c.dg << '\---' if is_root && opts[:close]
-      o << "\n" << ind << _c.dg << '\---' if opts[:close]
+      o << "\n" << ind << _c.dg << '\---' if close
 
       o << _c.rs
 
@@ -225,9 +230,23 @@ module Flor
 
     def ret_to_s(executor, m, c)
 
-      ret = (m['payload'] || {})['ret']
-      s = Flor.to_d(ret, compact: true)
-      Flor.truncate_string(s, 35, Proc.new { |x| "#{c.dg}... (L#{x})#{c.rs}" })
+      case pl = m['payload']
+      when NilClass, Hash
+        ret = (pl || {})['ret']
+        Flor.truncate_string(
+          Flor.to_d(ret, compact: true),
+          35,
+          Proc.new { |x| "#{c.dg}... (ln#{x})#{c.rs}" })
+      else
+        s =
+          "#{c.rd}(/!\\ payload is an instance of #{pl.class}: " +
+          Flor.truncate_string(
+            Flor.to_d(pl, compact: true, color: false),
+            35,
+            Proc.new { |x| "... (ln#{x})" }) +
+          ")#{c.rs}"
+        s
+      end
     end
 
     def nod_to_s(executor, n, opts, here=false)
@@ -235,16 +254,19 @@ module Flor
       _c = colours(opts)
 
       t = n['tree'] || Node.new(executor, n, nil).lookup_tree(n['nid'])
-      t = Flor.to_d(t, compact: true) if t
-      t = Flor.truncate_string(t, 42);
-
-      h = {}
-      %w[ parent cnid noreply dbg ].each do |k|
-        h[k] = n[k] if n.has_key?(k)
+      if t
+        t = Flor.to_d(t, compact: true)
+        t = Flor.truncate_string(t, 42)
       end
 
-      dbg = n['dbg'] ? "dbg:#{n['dbg']}" : nil
-      nr = n.has_key?('noreply') ? "nr:#{n['noreply']}" : nil
+      h =
+        n.select { |k, _| [
+          'parent' 'cnid' 'dbg' 'replyto',
+          'noreply' # "for backward compatibility
+        ].include?(k) }
+
+      #dbg = n['dbg'] ? "dbg:#{n['dbg']}" : nil
+      #nr = n.has_key?('noreply') ? "nr:#{n['noreply']}" : nil
       h = h.collect { |k, v| "#{k}:#{v}" }.join(' ')
 
       vs = n['vars']
@@ -280,9 +302,8 @@ module Flor
       nodes = nodes.inject({}) { |h, n| h[n['nid']] = [ n, [] ]; h }
       nodes.values.each { |ncn|
         pa = ncn.first['parent']; next unless pa
-        pan, pacn = nodes[pa]
-        pacn << ncn if pacn
-      }
+        _, pacn = nodes[pa]
+        pacn << ncn if pacn }
 
       sio = StringIO.new
       seen = []

data/lib/flor/migrations/0001_tables.rb

@@ -5,7 +5,7 @@ Sequel.migration do
 
     create_table :flor_messages do
 
-      primary_key :id, type: :Bignum
+      primary_key :id, type: :Integer
       String :domain, null: false
       String :exid, null: false
       String :point, null: false # 'execute', 'task', 'receive', 'schedule', ...
@@ -19,7 +19,7 @@ Sequel.migration do
 
     create_table :flor_executions do
 
-      primary_key :id, type: :Bignum
+      primary_key :id, type: :Integer
       String :domain, null: false
       String :exid, null: false
       File :content # JSON
@@ -32,7 +32,7 @@ Sequel.migration do
 
     create_table :flor_timers do
 
-      primary_key :id, type: :Bignum
+      primary_key :id, type: :Integer
       String :domain, null: false
       String :exid, null: false
       String :nid, null: false
@@ -40,7 +40,7 @@ Sequel.migration do
       String :schedule, null: false # '20141128.103239' or '00 23 * * *'
       String :ntime # next time
       File :content # JSON msg to trigger
-      Bignum :count, null: false
+      Integer :count, null: false
       String :status, null: false
       String :ctime, null: false
       String :mtime, null: false
@@ -51,7 +51,7 @@ Sequel.migration do
 
     create_table :flor_traps do
 
-      primary_key :id, type: :Bignum
+      primary_key :id, type: :Integer
       String :domain, null: false
       String :exid, null: false
       String :onid, null: false
@@ -76,7 +76,7 @@ Sequel.migration do
 
     create_table :flor_pointers do
 
-      primary_key :id, type: :Bignum
+      primary_key :id, type: :Integer
       String :domain, null: false
       String :exid, null: false
       String :nid, null: false
@@ -97,7 +97,7 @@ Sequel.migration do
 
     create_table :flor_traces do
 
-      primary_key :id, type: :Bignum
+      primary_key :id, type: :Integer
       String :domain, null: false
       String :exid, null: false
       String :nid, null: true

data/lib/flor/parser.rb

@@ -3,11 +3,10 @@ module Flor
 
   def self.parse(input, fname=nil, opts={})
 
+#Raabro.pp(Flor::Parser.parse(input, debug: 2), colours: true)
+#Raabro.pp(Flor::Parser.parse(input, debug: 3), colours: true)
     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
@@ -23,10 +22,7 @@ module Flor
 
     def initialize(error_array, fname)
 
-#puts "-" * 80
-#p error_array
-#puts error_array.last
-#puts "-" * 80
+#puts "-" * 80; p error_array; puts error_array.last; puts "-" * 80
       @line, @column, @offset, @msg, @visual = error_array
       @fname = fname
 
@@ -38,11 +34,17 @@ module Flor
 
     # parsing
 
-    def ws_star(i); rex(nil, i, /[ \t]*/); end
+    def wstar(i); rex(nil, i, /[ \t]*/); end
+
     def retnew(i); rex(nil, i, /[\r\n]*/); end
     def dot(i); str(nil, i, '.'); end
     def colon(i); str(nil, i, ':'); end
+    def semicolon(i); str(nil, i, ';'); end
     def comma(i); str(nil, i, ','); end
+    def dquote(i); str(nil, i, '"'); end
+    def slash(i); str(nil, i, '/'); end
+    def dollar(i); str(nil, i, '$'); end
+    def pipepipe(i); str(nil, i, '||'); end
 
     def pstart(i); str(nil, i, '('); end
     def pend(i); str(nil, i, ')'); end
@@ -61,57 +63,112 @@ 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_dot(i); seq(nil, i, :dot, :rf_symbol); end
-    def rf_index(i); alt(nil, i, :rf_dot, :rf_square); end
+    def colon_eol(i); seq(:colo, i, :colon, :eol); end
+    def semicolon_eol(i); seq(nil, i, :semicolon, :eol); end
+      #
+    def rf_slice(i)
+      seq(:refsl, i, :exp, :comma_qmark_eol, :exp)
+    end
+    def colon_exp(i)
+      seq(nil, i, :colon_eol, :exp_qmark)
+    end
+    def rf_steps(i)
+      seq(:refst, i, :exp_qmark, :colon_exp, :colon_exp, '?')
+    end
+    def rf_sqa_index(i)
+      alt(nil, i, :rf_slice, :rf_steps, :exp)
+    end
+    def rf_sqa_semico_index(i)
+      seq(nil, i, :semicolon_eol, :rf_sqa_index)
+    end
+    def rf_sqa_idx(i)
+      seq(:refsq, i, :sbstart, :rf_sqa_index, :rf_sqa_semico_index, '*', :sbend)
+    end
+    def rf_dot_idx(i)
+      seq(nil, i, :dot, :rf_symbol)
+    end
+    def rf_index(i); alt(nil, i, :rf_dot_idx, :rf_sqa_idx); end
+    def rf_symbol(i); rex(:refsym, i, /[^.:;| \b\f\n\r\t"',()\[\]{}#\\]+/); end
+      #
     def reference(i); seq(:ref, i, :rf_symbol, :rf_index, '*'); end
 
-    def dqstring(i)
-
-      rex(:dqstring, i, %r{
-        "(
+    def dqsc(i)
+      rex(:dqsc, i, %r{
+        (
           \\["\\\/bfnrt] |
           \\u[0-9a-fA-F]{4} |
-          [^"\\\b\f\n\r\t]
-        )*"
+          \$(?!\() |
+          [^\$"\\\b\f\n\r\t]
+        )+
       }x)
     end
 
-    def sqstring(i)
+    def rxoc(i); rex(:rxoc, i, /[imxouesn]/); end
 
-      rex(:sqstring, i, %r{
-        '(
-          \\['\\\/bfnrt] |
+    def rxsc(i)
+      rex(:rxsc, i, %r{
+        (
+          \\[\/bfnrt] |
           \\u[0-9a-fA-F]{4} |
-          [^'\\\b\f\n\r\t]
-        )*'
+          \$(?!\() |
+          [^\$/\b\f\n\r\t]
+        )+
       }x)
     end
 
+    def dor_lines(i)
+      seq(:dpar_lines, i, :pipepipe, :eol_wstar, :line, '+')
+    end
+    def dpar_lines(i)
+      seq(:dpar_lines, i, :eol_wstar, :line, '+')
+    end
+
+    def dpar(i)
+      seq(
+        :dpar, i,
+        :dollar, :pstart, :dpar_lines, :dor_lines, '?', :eol_wstar, :pend)
+    end
+
+    def dpar_or_rxoc(i); alt(nil, i, :dpar, :rxoc); end
+
+    def rxopts(i); rep(:rxopts, i, :dpar_or_rxoc, 0); end
+
+    def dpar_or_dqsc(i); alt(nil, i, :dpar, :dqsc); end
+    def dpar_or_rxsc(i); alt(nil, i, :dpar, :rxsc); end
+
+    def dqstring(i)
+      seq(:dqstring, i, :dquote, :dpar_or_dqsc, '*', :dquote)
+    end
+
+    def rxr(i) # used to break ambiguity against / (infix division)
+      rex(nil, i, /(regex|rex|rx|re|r)/)
+    end
+
     def rxstring(i)
+      seq(:rxstring, i, :rxr, '?', :slash, :dpar_or_rxsc, '*', :slash, :rxopts)
+    end
 
-      rex(:rxstring, i, %r{
-        /(
-          \\[\/bfnrt] |
+    def sqstring(i)
+      rex(:sqstring, i, %r{
+        '(
+          \\['\\\/bfnrt] |
           \\u[0-9a-fA-F]{4} |
-          [^/\b\f\n\r\t]
-        )*/[a-z]*
+          [^'\\\b\f\n\r\t]
+        )*'
       }x)
     end
 
     def comment(i); rex(nil, i, /#[^\r\n]*/); end
 
-    def eol(i); seq(nil, i, :ws_star, :comment, '?', :retnew); end
+    def eol(i); seq(nil, i, :wstar, :comment, '?', :retnew); end
+    def eol_wstar(i); seq(nil, i, :wstar, :comment, '?', :retnew, :wstar); end
     def postval(i); rep(nil, i, :eol, 0); end
 
-    def comma_eol(i); seq(nil, i, :comma, :eol, :ws_star); end
-    def sep(i); alt(nil, i, :comma_eol, :ws_star); end
+    def comma_eol(i); seq(nil, i, :comma, :eol, :wstar); end
+    def sep(i); alt(nil, i, :comma_eol, :wstar); end
 
     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 coll_sep(i); alt(nil, i, :comma_qmark_eol, :wstar); end
 
     def ent(i)
       seq(:ent, i, :key, :postval, :colon, :postval, :exp, :postval)
@@ -125,7 +182,9 @@ module Flor
     def obj(i); eseq(:obj, i, :pbstart, :ent_qmark, :coll_sep, :pbend); end
     def arr(i); eseq(:arr, i, :sbstart, :exp_qmark, :coll_sep, :sbend); end
 
-    def par(i); seq(:par, i, :pstart, :eol, :ws_star, :node, :eol, :pend); end
+    def par(i)
+      seq(:par, i, :pstart, :eol_wstar, :node, :eol_wstar, :pend)
+    end
 
     def val(i)
       altg(:val, i,
@@ -134,7 +193,7 @@ module Flor
         :arr, :obj,
         :number, :boolean, :null)
     end
-    def val_ws(i); seq(nil, i, :val, :ws_star); end
+    def val_ws(i); seq(nil, i, :val, :wstar); end
 
     # precedence
     #  %w[ or or ], %w[ and and ],
@@ -167,23 +226,27 @@ module Flor
     alias exp eor
 
     def key(i); seq(:key, i, :exp); end
-    def keycol(i); seq(nil, i, :key, :ws_star, :colon, :eol, :ws_star); end
+    def keycol(i); seq(nil, i, :key, :wstar, :colon, :eol_wstar); end
 
     def att(i); seq(:att, i, :sep, :keycol, '?', :exp); end
+    def riou(i); rex(:iou, i, /(if|unless)/); end
+    def iou(i); seq(nil, i, :sep, :riou); end
+    def natt(i); alt(nil, i, :iou, :att); end
+
     def head(i); seq(:head, i, :exp); end
     def indent(i); rex(:indent, i, /[ \t]*/); end
-    def node(i); seq(:node, i, :indent, :head, :att, '*'); end
+    def node(i); seq(:node, i, :indent, :head, :natt, '*'); end
 
-    def linjoin(i); rex(nil, i, /[ \t]*[\\|;][ \t]*/); end
+    def linjoin(i); rex(nil, i, /[ \t]*(\\|\|(?!\|)|;)[ \t]*/); end
     def outjnl(i); seq(nil, i, :linjoin, :comment, '?', :retnew); end
-    def outnlj(i); seq(nil, i, :ws_star, :comment, '?', :retnew, :linjoin); end
+    def outnlj(i); seq(nil, i, :wstar, :comment, '?', :retnew, :linjoin); end
     def outdent(i); alt(:outdent, i, :outjnl, :outnlj, :eol); end
 
     def line(i)
       seq(:line, i, :node, '?', :outdent)
     end
     def panode(i)
-      seq(:panode, i, :pstart, :eol, :ws_star, :line, '*', :eol, :pend)
+      seq(:panode, i, :pstart, :eol_wstar, :line, '*', :eol, :pend)
     end
 
     def flor(i); rep(:flor, i, :line, 0); end
@@ -201,7 +264,76 @@ module Flor
       Nod.new(t.lookup(:node), nil).to_a
     end
 
-    def rewrite_ref(t); [ t.string, [], ln(t) ]; end
+    def rewrite_node(t)
+
+      Nod.new(t, nil).to_a
+    end
+
+    def rewrite_ref(t)
+
+      tts = t.subgather(nil)
+
+      if tts.length == 1
+        tt = tts.first
+        [ tt.string, [], ln(tt) ]
+      else
+        [ '_ref', tts.collect { |ct| rewrite(ct) }, ln(t) ]
+      end
+    end
+
+    def rewrite_refsym(t)
+
+      s = t.string
+
+      if s.match(/\A\d+\z/)
+        [ '_num', s.to_i, ln(t) ]
+      else
+        [ '_sqs', s, ln(t) ]
+      end
+    end
+
+    def rewrite_refsq(t)
+
+      tts = t.subgather(nil)
+
+      if tts.length == 1
+        rewrite(tts.first)
+      else
+        [ '_arr', tts.collect { |tt| rewrite(tt) }, ln(t) ]
+      end
+    end
+
+    def rewrite_refsl(t)
+
+      st, co = t.subgather(nil)
+
+      [ '_obj', [
+        [ '_sqs', 'start', ln(st) ], rewrite(st),
+        [ '_sqs', 'count', ln(co) ], rewrite(co),
+      ], ln(t) ]
+    end
+
+    def rewrite_refst(t)
+
+#puts "-" * 80
+#Raabro.pp(t, colours: true)
+      ts = t.subgather(nil).collect { |tt| tt.name == :colo ? ':' : tt }
+      ts.unshift(0) if ts.first == ':'                 # begin
+      ts.push(':') if ts.count { |ct| ct == ':' } < 2  #
+      ts.push(1) if ts.last == ':'                     # step
+      ts.insert(2, -1) if ts[2] == ':'                 # end
+
+      be, _, en, _, st = ts
+      be = be.is_a?(Integer) ? [ '_num', be, ln(t) ] : rewrite(be)
+      en = en.is_a?(Integer) ? [ '_num', en, ln(t) ] : rewrite(en)
+      st = st.is_a?(Integer) ? [ '_num', st, ln(t) ] : rewrite(st)
+
+      [ '_obj', [
+        [ '_sqs', 'start', be[2] ], be,
+        [ '_sqs', 'end', en[2] ], en,
+        [ '_sqs', 'step', st[2] ], st,
+      ], ln(t) ]
+    end
 
     UNESCAPE = {
       "'" => "'", '"' => '"', '\\' => '\\', '/' => '/',
@@ -215,10 +347,52 @@ module Flor
       }
     end
 
-    def rewrite_dqstring(t); [ '_dqs', restring(t.string[1..-2]), ln(t) ]; end
-    def rewrite_sqstring(t); [ '_sqs', restring(t.string[1..-2]), ln(t) ]; end
-    def rewrite_rxstring(t); [ '_rxs', t.string, ln(t) ]; end
+    def rewrite_dqsc(t); [ '_sqs', restring(t.string), ln(t) ]; end
+    alias rewrite_rxsc rewrite_dqsc
+
+    def rewrite_dpar_lines(t)
+
+#Raabro.pp(t, colours: true); p t.string
+      [ '_dmute', t.subgather(:node).collect { |ct| rewrite(ct) }, ln(t) ]
+    end
+
+    def rewrite_dpar(t)
+
+      [ '_dol', t.subgather(nil).collect { |ct| rewrite(ct) }, ln(t) ]
+    end
+
+    def rewrite_dqstring(t)
+
+      cn = t.subgather(nil).collect { |tt| rewrite(tt) }
+
+      if cn.size == 1 && cn[0][0] == '_sqs'
+        cn[0]
+      elsif cn.size == 0
+        [ '_sqs', '', ln(t) ]
+      else
+        [ '_dqs', cn, ln(t) ]
+      end
+    end
 
+    alias rewrite_rxopts rewrite_dqstring
+
+    def rewrite_rxoc(t); [ '_sqs', t.string, ln(t) ]; end
+
+    def rewrite_rxstring(t)
+
+      l = ln(t)
+      cts = t.subgather(nil)
+      rot = cts.pop
+
+      cn = cts.collect(&method(:rewrite))
+
+      cn.unshift([ '_att', [ [ 'rxopts', [], l ], rewrite(rot) ], l ]) \
+        if rot.length > 0
+
+      [ '_rxs', cn, l ]
+    end
+
+    def rewrite_sqstring(t); [ '_sqs', restring(t.string[1..-2]), ln(t) ]; end
     def rewrite_boolean(t); [ '_boo', t.string == 'true', line_number(t) ]; end
     def rewrite_null(t); [ '_nul', nil, line_number(t) ]; end
 
@@ -276,9 +450,14 @@ fail "don't know how to invert #{operation.inspect}" # FIXME
 
     def rewrite_exp(t)
 
+#puts "-" * 80
+#puts caller[0, 7]
+#Raabro.pp(t, colours: true)
       return rewrite(t.c0) if t.children.size == 1
-
+#puts "-" * 80
+#puts caller[0, 7]
 #Raabro.pp(t, colours: true)
+
       cn = t.children.collect { |ct| ct.lookup(nil) }
 
       operation = cn.find { |ct| ct.name == :sop }.string
@@ -349,8 +528,14 @@ fail "don't know how to invert #{operation.inspect}" # FIXME
 
         as.each do |c|
 
-          c1 = c[1]; c10 = c1.size == 1 && c1[0]
-          suff = [] if c10 && c10[1] == [] && %w[ if unless ].include?(c10[0])
+          if %w[ if unless ].include?(c[1])
+            suff = []
+          elsif suff && c[1].length > 1
+            iou = suff.shift; iou[1] = [ [ iou[1], [], iou[2] ] ]
+            atts << iou
+            atts.concat(suff)
+            suff = nil
+          end
 
           (suff || atts) << c
         end
@@ -363,13 +548,19 @@ fail "don't know how to invert #{operation.inspect}" # FIXME
 
         return core unless suff
 
-        iou = suff.shift[1][0][0]
-
-        [ iou, [ suff.first[1].first, core ], @line ]
+        ta_rework_suff(core, suff)
       end
 
       protected
 
+      def ta_rework_suff(core, suff)
+
+        cond = suff[1][1][0]
+        suff[2..-1].each { |ct| cond[1] << ct }
+
+        [ '_' + suff.shift[1], [ cond, core ], @line ]
+      end
+
       def ta_rework_arr_or_obj(atts, non_atts)
 
         return [ atts, non_atts ] unless (
@@ -385,23 +576,22 @@ 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}"
+        hd, cn, ln = core
+        s = @tree.lookup(:head).string.strip
 
-        l = core[2]
-
-        [ 'sequence', [
-          [ 'set', [
-            [ h, [], l ],
-            core[0]
-          ], l ],
-          [ h, core[1], l ]
-        ], l ]
+        [ '_head', [
+          [ '_sqs', s, ln ],
+          hd,
+          [ '__head', cn, ln ]
+        ], ln ]
       end
 
       def read(tree)
 
+        @tree = tree
+#puts "-" * 80
+#Raabro.pp(tree, colours: true)
+
         @indent = tree.lookup(:indent).string.length
 
         ht = tree.lookup(:head)
@@ -413,17 +603,24 @@ fail "don't know how to invert #{operation.inspect}" # FIXME
         atts = tree.children[2..-1]
           .inject([]) { |as, ct|
 
-            kt = ct.children.size == 3 ? ct.children[1].lookup(:key) : nil
-            v = Flor::Parser.rewrite(ct.clast)
+            ct = ct.lookup(nil)
+
+            if ct.name == :iou
+
+              as.push([ '_att', ct.string, @line ])
 
-            if kt
-              k = Flor::Parser.rewrite(kt.c0)
-              as << [ '_att', [ k, v ], k[2] ]
             else
-              as << [ '_att', [ v ], v[2] ]
-            end
 
-            as }
+              kt = ct.children.size == 3 ? ct.children[1].lookup(:key) : nil
+              v = Flor::Parser.rewrite(ct.clast)
+
+              if kt
+                k = Flor::Parser.rewrite(kt.c0)
+                as.push([ '_att', [ k, v ], k[2] ])
+              else
+                as.push([ '_att', [ v ], v[2] ])
+              end
+            end }
 
         @children.concat(atts)
 
@@ -452,7 +649,7 @@ fail "don't know how to invert #{operation.inspect}" # FIXME
 
       def rework_addition
 
-        katts, atts, cn = @children
+        katts, atts, children = @children
           .inject([ [], [], [] ]) { |cn, ct|
             if ct[0] == '_att'
               cn[ct[1].size == 2 ? 0 : 1] << ct
@@ -462,7 +659,7 @@ fail "don't know how to invert #{operation.inspect}" # FIXME
             cn }
 
         @children =
-          katts + atts.collect { |ct| ct[1].first } + cn
+          katts + atts.collect { |ct| ct[1].first } + children
       end
     end