upl 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7e5de431546d46c5f4998818e1360e10e5dab6497e0988e783e626393b35cc7
-  data.tar.gz: 4cd776d265de52483fe89e239041ee001ba21856c339fb067b661437c6cbfd25
+  metadata.gz: dc30b39fd062308b8cbae9bcaeca09c2b4921ff888c42ba00d100c2a045b39bf
+  data.tar.gz: 11adee909aee233bae48fe9ea7d1c33b25ba35ef33c1fabe6526e399e7920d81
 SHA512:
-  metadata.gz: a8ab63130414fe7d8ae8775c4a0f11199c76024952541b2820deb8e607361ca26cb07bcec64fc2a2df8e5790a5042caaa1598a0705d0271d6ac4dca4cd9497de
-  data.tar.gz: 58d09609f7888ee559bb626219f7be13576016aa40dff3992c12413a84d3113841e748f7896aa93d204dcceb2b5f0e40528e828bc30b930e7743ccb134efaf1f
+  metadata.gz: 5cc115b7e58995a480463b226df08d68fa54ee9a441d64b47efbc13546f184d3f4ee91fc14881f4f6df5773c2dd6b7f8f5268d86db2a7009bac036afa564b462
+  data.tar.gz: cb405495fee3c55030f520c3be3c6305b8158848aa77c9d597233bf15a76c82b352d675d4277fc75acaec9c87d4e6ed21a977e79290301ec5882f500f86385c8

data/README.md

@@ -13,12 +13,6 @@ Also, do prolog-style queries on objects :-DD
 
 ### Queries
 
-To read rules from a prolog file:
-``` ruby
-[1] pry(main)> Upl.consult '/home/yours/funky_data.pl'
-=> true
-```
-
 Query a built-in predicate, with a full expression:
 ``` ruby
 [1] pry(main)> enum = Upl.query 'current_prolog_flag(K,V), member(K,[home,executable,shared_object_extension])'
@@ -29,12 +23,18 @@ Query a built-in predicate, with a full expression:
  {:K=>shared_object_extension, :V=>so}]
 ```
 
+To read rules from a prolog file:
+``` ruby
+[1] pry(main)> Upl.consult '/home/yours/funky_data.pl'
+=> true
+```
+
 ### Facts
 Also we want to be able to construct prolog-queryable facts from ruby objects.
 In prolog:
 
 ``` prolog
-?- assert(person(john,anderson)).
+?- assertz(person(john,anderson)).
 true.
 
 ?- person(A,B).
@@ -51,15 +51,15 @@ false.
 And in Upl:
 
 ``` ruby
-[1] pry(Upl):1> fact = Term.functor :person, :john, :anderson
+[2] pry(main)> fact = Upl::Term.functor :person, :john, :anderson
 => person/2(john,anderson)
-[2] pry(Upl):1> Runtime.eval Term.functor :assert, fact
+[3] pry(main)> Upl.assertz fact
 => true
-[3] pry(Upl):1> Array query 'person(A,B)'
+[4] pry(main)> Array Upl.query 'person(A,B)'
 => [{:A=>john, :B=>anderson}]
-[4] pry(Upl):1> Runtime.eval Term.functor :retract, fact
+[5] pry(main)> Upl.retract fact
 => true
-[5] pry(Upl):1> Array query 'person(A,B)'
+[6] pry(main)> Array Upl.query 'person(A,B)'
 => []
 ```
 
@@ -69,15 +69,15 @@ Also, with objects other than symbols. Obviously, this is a rabbit-hole of
 Alician proportions. So, here we GOOOoooo...
 
 ``` ruby
-[1] pry(Upl):1> fact = Term.functor :person, :john, :anderson, (o = Object.new)
+[2] pry(main)> fact = Upl::Term.functor :person, :john, :anderson, (o = Object.new)
 => person/3(john,anderson,#<Object:0x0000563346a08e38 @_upl_atom=439429>)
-[2] pry(Upl):1> Runtime.eval Term.functor :assert, fact
+[3] pry(main)> Upl.assertz fact
 => true
-[3] pry(Upl):1> ha, = Array query 'person(A,B,C)'
+[4] pry(main)> ha, = Array Upl.query 'person(A,B,C)'
 => [{:A=>john,
   :B=>anderson,
   :C=>#<Object:0x0000563346a08e38 @_upl_atom=439429>}]
-[4] pry(Upl):1> ha[:C].equal? o
+[5] pry(main)> ha[:C].equal? o
 => true
 ```
 
@@ -88,24 +88,24 @@ And now, the pièce de résistance - using an object as an input term:
 
 ``` ruby
 fact = Upl::Term.functor :person, :james, :madison, (o = Object.new)
-Upl::Runtime.eval Upl::Term.functor :assert, fact
+Upl.assertz fact
 
 fact2 = Upl::Term.functor :person, :thomas, :paine, (thing2 = Object.new)
-Upl::Runtime.eval Upl::Term.functor :assert, fact2
+Upl.assertz fact2
 
 # Note that both facts are in the result
-query_term, query_vars = Upl::Runtime.term_vars 'person(A,B,C)'
-Array Upl::Runtime.term_vars_query query_term, query_vars
+query_term, query_hash = Upl::Runtime.term_vars 'person(A,B,C)'
+Array Upl::Runtime.term_vars_query query_term, query_hash
 =>[{:A=>james, :B=>madison, :C=>#<Object:0x0000563f56e35580 @_upl_atom=439429>},
   {:A=>thomas, :B=>paine, :C=>#<Object:0x0000563f56d2b5b8 @_upl_atom=439813>}]
 
 # Unify C with thing2. This needs a nicer api :-\
-query_term, query_vars = Upl::Runtime.term_vars 'person(A,B,C)'
-Upl::Extern.PL_unify query_vars.last.args.to_a.last, thing2.to_term
+query_term, query_hash = Upl::Runtime.term_vars 'person(A,B,C)'
+Upl::Extern.PL_unify query_hash[:C].term_t, thing2.to_term_t
 
 # ... and we get the correct result
 # Note that the first fact is not in the result.
-Array Upl::Runtime.term_vars_query query_term, query_vars
+Array Upl::Runtime.term_vars_query query_term, query_hash
 => [{:A=>thomas, :B=>paine, :C=>#<Object:0x0000563f56d2b5b8 @_upl_atom=439813>}]
 ```
 

data/lib/upl/dict.rb

@@ -0,0 +1,61 @@
+module Upl
+  class Dict < Hash
+    def initialize( tag, default_value = nil, &default_blk )
+      @tag = tag
+      super default_value, &default_blk
+    end
+
+    # fetch the tag for the dict
+    def self.dict_tag( dict_term_t )
+      args = TermVector[dict_term_t, nil]
+
+      # TODO need a better api here as well, and other places
+      # eg, need to check that args.size == predicate.arity
+      # otherwise segfaults and other weird stuff ensue
+      rv = Extern::PL_call_predicate \
+        Extern::NULL, # module
+        0, # flags, see PL_open_query
+        (Runtime.predicate 'is_dict', args.size),
+        args.terms
+
+      rv == 1 or raise "can't retrieve dict tag"
+
+      # now retrieve the variable's value
+      args.last.to_ruby
+    end
+
+    # copy dict_term_t into a ruby structure
+    def self.of_term( dict_term_t )
+      # Have to do a little hoop-jumping here. There are no c-level calls to
+      # access dicts, so we have to break them down with prolog predicates. But
+      # we can't process queries that have dicts in their results, otherwise we
+      # have an endless recursion.
+
+      query_term, query_hash = Runtime.term_vars 'get_dict(K,Dict,V)'
+
+      # So set the Dict value to dict_term_t above ...
+      query_term[1] = dict_term_t
+      # ...and remove it from the output variables
+      query_hash.delete :Dict
+
+      # now we have a result set with K,V values
+      en = Upl::Runtime.term_vars_query query_term, query_hash
+
+      # map to a hash-y thing
+      en.each_with_object Dict.new(dict_tag dict_term_t) do |row,values|
+        values[row[:K]] = row[:V]
+      end
+    end
+
+    attr_reader :tag, :values
+
+    def == rhs
+      [tag,to_h] == [rhs.tag,rhs.to_h]
+    end
+
+    def pretty_print pp
+      tag.pretty_print pp
+      super
+    end
+  end
+end

data/lib/upl/extern.rb

@@ -196,12 +196,17 @@ module Upl
     extern 'int PL_put_atom(term_t t, atom_t a)'
     extern 'int PL_put_variable(term_t t)'
     extern 'int PL_put_functor(term_t t, functor_t functor)'
+    extern 'int PL_put_term(term_t t1, term_t t2)' # Make t1 point to the same term as t2.
 
     extern 'int PL_cons_functor_v(term_t h, functor_t fd, term_t a0)'
 
+    extern 'int PL_unify_arg(int index, term_t t, term_t a)' # set index-th arg of t to a
+
     extern 'int PL_get_atom_chars(term_t t, char **a)'
     extern 'int PL_get_string(term_t t, char **s, size_t *len)'
     extern 'int PL_get_integer(term_t t, int *i)'
+    extern 'int PL_get_int64(term_t t, int64_t *i)'
+    extern 'int PL_get_float(term_t t, double *f)'
     extern 'int PL_get_chars(term_t t, char **s, unsigned int flags)'
     extern 'int PL_get_name_arity(term_t t, atom_t *name, int *arity)'
     extern 'int PL_get_arg(int index, term_t t, term_t a)'
@@ -230,7 +235,7 @@ module Upl
     ####################
     # looks like parsing of terms
     # only >= 7.6.0
-    # get version, eval current_prolog_flag(version_data,swi(M,I,P,E)). Major, mInor, Patch, Extra[]
+    # get version, call current_prolog_flag(version_data,swi(M,I,P,E)). Major, mInor, Patch, Extra[]
     # PL_EXPORT(int)  PL_put_term_from_chars(term_t t, int flags, size_t len, const char *s);
     # extern 'int PL_put_term_from_chars(term_t t, int flags, size_t len, const char *s)'
 

data/lib/upl/inter.rb

@@ -1,4 +1,39 @@
-# TODO not used
+module Upl
+  module Inter
+    # Try Term, then Fiddle::Pointer, then to_term_t.
+    # Return a term_t pointer
+    def self.term_t_of term_or_ptr
+      case term_or_ptr
+      when Term
+        term_or_ptr.term_t
+      when Fiddle::Pointer
+        term_or_ptr
+      else
+        term_or_ptr.to_term_t
+      end
+    end
+
+    # lst_term is a Term, or a Fiddle::Pointer to term_t
+    # yield term_t items of the lst_term
+    def self.each_of_list lst_term, &blk
+      return enum_for __method__, lst_term unless block_given?
+      lst_term = Inter.term_t_of lst_term
+
+      while Extern::PL_get_nil(lst_term) != 1 # not end of list
+        res = Extern::PL_get_list \
+          lst_term,
+          (head_t = Extern.PL_new_term_ref),
+          (rst_t = Extern.PL_new_term_ref)
+
+        break unless res == 1
+
+        yield head_t
+        lst_term = rst_t
+      end
+    end
+  end
+end
+
 class Object
   def to_atom
     if frozen?
@@ -9,7 +44,13 @@ class Object
     end
   end
 
+  # return a Term object from to_term_t
   def to_term
+    Upl::Term.new to_term_t
+  end
+
+  # return a term_t pointer
+  def to_term_t
     if frozen?
       # TODO must check instance variable here
       _upl_termize
@@ -43,6 +84,3 @@ class Symbol
     Upl::Extern.PL_new_atom to_s
   end
 end
-
-module Inter
-end

data/lib/upl/runtime.rb

@@ -17,11 +17,26 @@ module Upl
   module Runtime
     Ptr = Fiddle::Pointer
 
+    def self.call st_or_term
+      term =
+      case st_or_term
+      when String
+        Term.new st_or_term
+      when Term
+        st_or_term
+      else
+        raise "dunno bout #{st_or_term}"
+      end
+
+      rv = Extern.PL_call term.term_t, Extern::NULL
+      rv == 1 # don't raise
+    end
+
     def self.init
       # set up no output so we don't get swipl command line interfering in ruby
       # TODO exception handling should not kick off a prolog terminal
       # TODO see gem-swipl for more useful stuff here
-      args = %w[upl -q --tty=false --nosignals]
+      args = %w[upl --tty=false --signals=false --debug=false --quiet=true]
 
       # convert args to char **
       ptr_size = Extern.sizeof 'char*'
@@ -33,6 +48,9 @@ module Upl
       # call init
       rv = Extern.PL_initialise args.size, arg_ptrs
       rv == 1 or raise 'PL_initialise failed'
+
+      # we really don't want the prolog console showing up in ruby.
+      call 'set_prolog_flag(debug_on_error,false)'
     end
 
     # once_only. Should probably be a singleton or something.
@@ -42,26 +60,23 @@ module Upl
       Extern.PL_predicate Fiddle::Pointer[name.to_s], arity, NULL
     end
 
-    # Use prolog predicate to parse the string into a term with its named variables
+    # Use prolog predicate to parse the string into a term, with its named variables as a hash of Name => _variable
+    # TODO maybe use read_term_from_chars, or at least don't force the term to be an atom
+    # TODO need to use read_term_from_atom('retry(A,B,C)', Term, [variable_names(VarNames)]).
     def self.term_vars st
-      # atom_to_term('your_pred(A,B,C,D)',Term,Options).
-      terms = Extern.PL_new_term_refs 3
-      atom, term, options = terms+0, terms+1, terms+2
-
-      Extern::PL_put_atom atom, (Extern::PL_new_atom Fiddle::Pointer[st])
-      Extern::PL_put_variable term
-      Extern::PL_put_variable options
-
-      # docs say to use read_term_from_atom/3, but it fails with uninstantiated variables for 7.7.18
       rv = Extern::PL_call_predicate \
         Extern::NULL, # module
         0, # flags, see PL_open_query
         (predicate 'atom_to_term', 3),
-        terms
+        (args = TermVector[st.to_sym, nil, nil]).terms
+
+      vars_hash = Inter.each_of_list(args[2]).map do |term_t|
+        # each of these is =(Atom,variable), and we want Atom => variable
+        t = Term.new term_t
+        [t.first.atom.to_sym, t.last]
+      end.to_h
 
-      # first must be Term.new otherwise Term unhooks the term_t pointer
-      # vars *must* be unhooked though ¯\_(ツ)_/¯
-      return (Term.new term), (list_to_ary options do |elt| Term.new elt end)
+      return args[1], vars_hash
     end
 
     def self.unify( term_a, term_b )
@@ -70,21 +85,18 @@ module Upl
     end
 
     # do a query for the given term and vars, as parsed by term_vars
-    def self.term_vars_query qterm, qvars
+    def self.term_vars_query qterm, qvars_hash
       raise "not a term" unless Term === qterm
-      return enum_for __method__,  qterm, qvars unless block_given?
+      return enum_for __method__,  qterm, qvars_hash unless block_given?
 
       fid_t = Extern.PL_open_foreign_frame
 
       begin
-        # input values
-        terms_ptr = Extern.PL_new_term_refs qterm.arity
-         qterm.args.each_with_index do |arg,idx|
-          Extern::PL_unify (terms_ptr+idx), arg
-        end
+        # populate input values from qterm
+        args = TermVector.new qterm.arity do |idx| qterm[idx] end
 
         # module is NULL, flags is 0
-        query_id_p = Extern.PL_open_query Extern::NULL, 0, qterm.to_predicate, terms_ptr
+        query_id_p = Extern.PL_open_query Extern::NULL, 0, qterm.to_predicate, args.terms
         query_id_p != 0 or raise 'no space on environment stack, see SWI-Prolog docs for PL_open_query'
 
         loop do
@@ -92,13 +104,10 @@ module Upl
           res = Extern.PL_next_solution query_id_p
           break if res == 0
 
-          hash = qvars.each_with_object Hash.new do |name_var,ha|
-            name_term_t, var_term_t = name_var.args.to_a
-            name = Term.new name_term_t
-
+          hash = qvars_hash.each_with_object Hash.new do |(name_sym,var),ha|
             # term_t will be invalidated by the next call to PL_next_solution,
             # so we need to construct a ruby tree of the value term
-            val = ha[name.atom.to_sym] = Tree.of_term var_term_t
+            val = ha[name_sym] = var.to_ruby
             # binding.pry if val.to_sym == :query_debug_settings rescue false
           end
 
@@ -114,65 +123,43 @@ module Upl
       fid_t and Extern.PL_close_foreign_frame fid_t
     end
 
-    def self.eval st_or_term
-      p_term =
-      case st_or_term
-      when String
-        rv = Extern.PL_chars_to_term Fiddle::Pointer[st_or_term], (p_term = Extern.PL_new_term_ref)
-        raise "failure parsing term #{st_or_term}" unless rv == 1
-        p_term
-      when Term
-        st_or_term.term_t
-      else
-        raise "dunno bout #{st_or_term}"
-      end
-
-      rv = Extern.PL_call p_term, Extern::NULL
-      rv == 1 or raise "failure executing term #{st}"
-    end
-
     def self.predicate name, arity
       pred_p = Extern.PL_predicate Ptr[name.to_s], arity, Extern::NULL
     end
 
-    def self.list_to_ary lst, &elt_converter
-      rv = []
+    # Simple query with predicate / arity
+    # Returns an array of arrays.
+    def self.squery predicate_str, arity
+      return enum_for :squery, predicate_str, arity unless block_given?
 
-      while Extern::PL_get_nil(lst) != 1 # not end of list
-        res = Extern::PL_get_list \
-          lst,
-          (head = Extern.PL_new_term_ref),
-          (rst = Extern.PL_new_term_ref)
+      p_functor = Extern::PL_new_functor predicate_str.to_sym.to_atom, arity
+      p_predicate = Extern::PL_pred p_functor, Extern::NULL
 
-        break unless res == 1
+      answer_lst = TermVector.new arity
+      query_id_p = Extern.PL_open_query Extern::NULL, 0, p_predicate, answer_lst.terms
 
-        rv << (elt_converter.call head)
-        lst = rst
+      loop do
+        rv = Extern.PL_next_solution query_id_p
+        break if rv == 0
+        yield answer_lst.each_t.map{|term_t| Tree.of_term term_t}
       end
 
-      rv
+    ensure
+      # NOTE this also gets called after enum_for
+      query_id_p&.to_i and Extern.PL_close_query query_id_p
     end
 
-    # simple query with predicate / arity
-    def self.squery predicate_str, arity
-      return enum_for :squery, predicate_str, arity unless block_given?
-      p_atom = Extern::PL_new_atom Fiddle::Pointer[predicate_str]
-      p_functor = Extern::PL_new_functor p_atom, arity
-      p_predicate = Extern::PL_pred p_functor, Extern::NULL
+    def self.query term
+      raise "not a Term" unless Term === term
+      return enum_for :query_term, term unless block_given?
 
-      answer_lst = Extern.PL_new_term_refs arity
-      query_id_p = Extern.PL_open_query Extern::NULL, 0, p_predicate, answer_lst
+      answer_lst = TermVector.new term.arity do |idx| term[idx] end
+      query_id_p = Extern.PL_open_query Extern::NULL, 0, term.to_predicate, answer_lst.terms
 
       loop do
-        res = Extern.PL_next_solution query_id_p
-        break if res == 0
-
-        answrs =
-        arity.times.map do |i|
-          term_to_ruby answer_lst+i
-        end
-
-        yield answrs
+        rv = Extern.PL_next_solution query_id_p
+        break if rv == 0
+        yield answer_lst.each_t.map{|term_t| Tree.of_term term_t}
       end
 
     ensure

data/lib/upl/term.rb

@@ -7,25 +7,21 @@ module Upl
     def initialize term_or_string
       case term_or_string
       when String
-        raise "can't do strings yet"
-        # PL_chars_to_term term_or_string
+        @term_t = Extern.PL_new_term_ref
+        rv = Extern.PL_chars_to_term Fiddle::Pointer[term_or_string], @term_t
+        rv == 1 or raise "failure parsing term #{term_or_string}"
+
       when Fiddle::Pointer
         # assume this is a pointer to a term. Unsafe, but there's no choice really
         @term_t = term_or_string
+
       else
         raise "can't handle #{term_or_string}"
       end
     end
 
     attr_reader :term_t
-
-    def to_term; term_t end
-
-    # Make a copy of all the term information. Useful for passing in to queries, apparently.
-    def self.copy term_t
-      copy_term_t = Extern.PL_copy_term_ref term_t
-      new copy_term_t
-    end
+    alias to_term_t term_t
 
     def self.of_atom atom
       term_t = Extern.PL_new_term_ref
@@ -34,14 +30,14 @@ module Upl
       term_t
     end
 
-    # args are things that can be converted to term_t pointers using to_term method
+    # args are things that can be converted to term_t pointers using to_term_t method
     def self.functor name, *args
       # TODO maybe use a frame or something because this allocates quite a few sub-terms
       functor_t = Extern.PL_new_functor name.to_sym.to_atom, args.size
 
       arg_terms = Extern.PL_new_term_refs args.size
-      args.each_with_index do |arg,i|
-        Extern::PL_unify (arg_terms+i), arg.to_term
+      args.each_with_index do |arg,idx|
+        Extern::PL_unify (arg_terms+idx), arg.to_term_t
       end
 
       term_t = Extern.PL_new_term_ref
@@ -54,9 +50,10 @@ module Upl
     def populate
       int_ptr = Runtime::Ptr[0].ref
       atom_ptr = Runtime::Ptr[0].ref
+
       rv = Extern::PL_get_name_arity term_t, atom_ptr, int_ptr
       # This happens when the term_t is not a PL_TERM (ie a compound)
-      raise "can't populate term" unless rv == 1
+      rv == 1 or raise "can't populate term"
 
       @arity = int_ptr.ptr.to_i
       @atom = Atom.new atom_ptr
@@ -72,8 +69,6 @@ module Upl
       [@atom, @arity] <=> [rhs.atom, rhs.arity]
     end
 
-    # attr_reader :atom, :arity
-
     def atom
       @atom or begin
         populate
@@ -96,29 +91,37 @@ module Upl
       Extern::PL_pred to_functor, Extern::NULL
     end
 
-    def tree; @tree || (Tree.new self) end
-    def to_ruby; tree end
+    def tree; @tree || (Tree.of_term term_t) end
+    alias to_ruby tree
 
-    # Assume that term_t still has a value. Which means we have to copy all
-    # values before the underlying term_t is changed.
     # TODO leaning hard towards each with Enumerable
-    def args
+    def each
       return enum_for :args unless block_given?
 
-      (1..arity).each do |i|
-        rv = Extern::PL_get_arg i, term_t, (subterm = Extern.PL_new_term_ref)
-        if rv == 1
-          yield subterm
-        else
-          puts "#{rv}: can't convert #{i} arg of #{atom}"
-          yield subterm
-        end
+      (1..arity).each do |idx|
+        rv = Extern::PL_get_arg idx, term_t, (subterm = Extern.PL_new_term_ref)
+        rv == 1 or raise "#{rv}: can't convert #{i} arg of #{atom}"
+        yield subterm
       end
     end
 
+    include Enumerable
+
+    def first; self[0] end
+    def last; self[arity-1] end
+
+    def [](idx)
+      # remember args for terms are 1-based
+      rv = Extern::PL_get_arg idx+1, term_t, (arg = Extern.PL_new_term_ref)
+      rv == 1 or raise "can't access term at #{idx}"
+      Term.new arg
+    end
+
+    # set term_t[idx] = val_term_t
+    # idx is zero-based, unlike the prolog calls
     def []=( idx, val_term_t)
-      Extern::PL_get_arg idx+1, term_t, (subterm = Extern.PL_new_term_ref)
-      rv = Extern.PL_unify subterm, val_term_t
+      raise IndexError, "max index is #{arity-1}" if idx >= arity
+      rv = Extern.PL_unify_arg idx+1, term_t, val_term_t
       rv == 1 or raise "can't set index #{idx}"
     end
 

data/lib/upl/term_vector.rb

@@ -0,0 +1,67 @@
+require 'fiddle'
+
+module Upl
+  # Create a c-array of terms using PL_new_term_refs. Methods on this class
+  # will return the term_t pointers wrapped in Term objects. If you want access
+  # to the underlying term_t pointers, use terms + idx, or the term_t method of
+  # the Term objects.
+  class TermVector
+    # args must all be convertible to term_t Fiddle::Pointers, via term_t_of.
+    #
+    # nil values are defaulted to Variable.new, but beware passing in the wrong
+    # number of arguments.
+    def self.[]( *args )
+      new args.size do |idx|
+        args[idx]
+      end
+    end
+
+    # similar to Array.new, but each value yielded from blk will be converted to
+    # term_t using term_t_of
+    def initialize size, &blk
+      @size = Integer size
+      @terms = Extern.PL_new_term_refs @size
+
+      if block_given?
+        @size.times do |idx|
+          termable = (yield idx) || Variable.new
+          term_t = Inter.term_t_of termable
+          # TODO not sure if Extern::PL_put_term should be available as a possibility here?
+          rv = Extern::PL_unify @terms+idx, term_t
+          rv == 1 or raise "can't set index #{idx} of term_vector to #{termable}"
+        end
+      end
+    end
+
+    attr_reader :size, :terms
+
+    def each_t
+      return enum_for :each_t unless block_given?
+      size.times.each do |idx| yield @terms+idx end
+    end
+
+    def each
+      return enum_for :each unless block_given?
+      size.times.each do |idx| yield Term.new @terms+idx end
+    end
+
+    include Enumerable
+
+    def first; Term.new @terms+0; end
+    def last; Term.new @terms+(size-1); end
+
+    def [](idx)
+      raise IndexError unless idx < @size
+      Term.new @terms+idx
+    end
+
+    def []=(idx, value)
+      raise IndexError unless idx < @size
+      Extern::PL_put_term @terms + idx, (Inter.term_t_of value)
+    end
+
+    def to_a
+      size.times.map{|idx| @terms+idx}
+    end
+  end
+end

data/lib/upl/tree.rb

@@ -13,7 +13,7 @@ module Upl
       case term
       when Term
         @atom = term.atom
-        @args = term.args.map do |arg|
+        @args = term.map do |arg|
           self.class.term_to_ruby arg
         end
       when Fiddle::Pointer
@@ -27,25 +27,34 @@ module Upl
       term_to_ruby term_t
     end
 
-    def self.term_to_ruby term
-      case term.term_type
+    def self.term_to_ruby term_t
+      case term_t.term_type
       when Extern::PL_VARIABLE
-        Variable.copy term
+        Variable.copy term_t
 
       when Extern::PL_ATOM
-        atom = Atom.of_term term
+        atom = Atom.of_term term_t
         if atom.to_s =~ /^ruby-(\d+)/
           ObjectSpace._id2ref $1.to_i
         else
-          atom
+          atom.to_sym
         end
 
-      when Extern::PL_INTEGER
-        Extern.PL_get_integer term, (int_ptr = Fiddle::Pointer[0].ref)
+      # I think integers > 63 bits can be fetched with PL_get_mpz
+      # Other than PL_INTEGER, most of these seem to be unused?
+      when Extern::PL_INTEGER, Extern::PL_LONG, Extern::PL_INT, Extern::PL_INT64, Extern::PL_SHORT
+        rv = Extern.PL_get_int64 term_t, (int_ptr = Fiddle::Pointer[0].ref)
+        rv == 1 or raise "Can't convert to int64. Maybe too large."
         int_ptr.ptr.to_i
 
+      when Extern::PL_FLOAT
+        rv = Extern.PL_get_float term_t, (double_ptr = Fiddle::Pointer[0].ref)
+        rv == 1 or raise "Can't convert to double. Maybe too large."
+        bytes = double_ptr[0,8]
+        bytes.unpack('D').first
+
       when Extern::PL_STRING
-        rv = Extern.PL_get_string term, (str_ptr = Fiddle::Pointer[0].ref), (len_ptr = Fiddle::Pointer[0].ref)
+        rv = Extern.PL_get_string term_t, (str_ptr = Fiddle::Pointer[0].ref), (len_ptr = Fiddle::Pointer[0].ref)
         value_ptr = Fiddle::Pointer.new str_ptr.ptr, len_ptr.ptr.to_i
         value_ptr.to_s
 
@@ -55,30 +64,18 @@ module Upl
         nil
 
       when Extern::PL_TERM
-        Tree.new term
+        Tree.new term_t
 
       when Extern::PL_LIST_PAIR
-        list_to_ary term
-
-      end
-    end
-
-    def self.list_to_ary lst
-      rv = []
+        Inter.each_of_list(term_t).to_a
 
-      while Extern::PL_get_nil(lst) != 1 # not end of list
-        res = Extern::PL_get_list \
-          lst,
-          (head = Extern.PL_new_term_ref),
-          (rst = Extern.PL_new_term_ref)
+      when Extern::PL_DICT
+        Dict.of_term term_t
 
-        break unless res == 1
+      else
+        :NotImplemented
 
-        rv << (term_to_ruby head)
-        lst = rst
       end
-
-      rv
     end
 
     def arity; args.size end
@@ -101,19 +98,5 @@ module Upl
         end
       end
     end
-
-    protected
-
-    def populate_args count
-      (1..arity).each do |i|
-        rv = Extern::PL_get_arg i, term_t, (subterm = Extern.PL_new_term_ref)
-        if rv == 1
-          yield subterm
-        else
-          puts "#{rv}: can't convert #{i} arg of #{atom}"
-          yield subterm
-        end
-      end
-    end
   end
 end

data/lib/upl/variable.rb

@@ -2,10 +2,11 @@ module Upl
   # Really this is just an empty term.
   class Variable
     def initialize term_t = nil
-      @term_t = term_t || Extern.PL_new_term_ref
+      @term_t = term_t || self.class.to_term
     end
 
     attr_reader :term_t
+    alias to_term_t term_t
 
     def self.copy term_t
       inst = new term_t
@@ -18,7 +19,7 @@ module Upl
 
     # bit of a hack to create empty variables for a functor
     def self.to_term
-      new
+      Extern.PL_new_term_ref
     end
 
     def to_s; _string end

data/lib/upl/version.rb

@@ -1,3 +1,3 @@
 module Upl
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/lib/upl.rb

@@ -6,17 +6,58 @@ require_relative 'upl/term'
 require_relative 'upl/variable'
 require_relative 'upl/atom'
 require_relative 'upl/runtime'
+require_relative 'upl/dict'
 require_relative 'upl/tree'
 require_relative 'upl/inter'
+require_relative 'upl/term_vector'
 
 module Upl
-  def self.query st, &blk
-    term, vars = Runtime::term_vars st
-    Runtime::term_vars_query term, vars, &blk
+  def self.query string_or_term, &blk
+    case string_or_term
+    when Term
+      Runtime.query string_or_term
+    when String
+      term, vars = Runtime.term_vars string_or_term
+      Runtime.term_vars_query term, vars, &blk
+    else
+      raise "dunno about #{string_or_term.inspect}"
+    end
   end
 
   def self.consult filename
     p = Pathname filename
-    Runtime::eval %Q{["#{p.realpath.to_s}"]}
+    Runtime::call %Q{["#{p.realpath.to_s}"]}
+  end
+
+  def self.asserta term
+    Runtime.call Term.functor :asserta, term
+  end
+
+  def self.assertz term
+    Runtime.call Term.functor :assertz, term
+  end
+
+  # behaves as if run under once, cos of the way call works
+  def self.retract term
+    Runtime.call Term.functor :retract, term
+  end
+
+  def self.listing
+    (Upl.query 'with_output_to(string(Buffer),listing)').first[:Buffer]
+  end
+
+  # Nicer syntax for Term.functor. Construct a Term from a symbol and args that
+  # all respond to 'to_term_t'.
+  #
+  # In other words:
+  #
+  #   Upl.query 'current_prolog_flag(A,B)'
+  #
+  # is moreorless the same as
+  #
+  #   Upl.query Term :current_prolog_flag, Variable.new, Variable.new
+  #
+  def self.Term name, *args
+    Term.functor name, *args
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: upl
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - John Anderson
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-09-13 00:00:00.000000000 Z
+date: 2018-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -98,11 +98,13 @@ files:
 - bin/setup
 - lib/upl.rb
 - lib/upl/atom.rb
+- lib/upl/dict.rb
 - lib/upl/extern.rb
 - lib/upl/functor.rb
 - lib/upl/inter.rb
 - lib/upl/runtime.rb
 - lib/upl/term.rb
+- lib/upl/term_vector.rb
 - lib/upl/tree.rb
 - lib/upl/variable.rb
 - lib/upl/version.rb