upl 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc30b39fd062308b8cbae9bcaeca09c2b4921ff888c42ba00d100c2a045b39bf
-  data.tar.gz: 11adee909aee233bae48fe9ea7d1c33b25ba35ef33c1fabe6526e399e7920d81
+  metadata.gz: 74895ae80e02af92445e7d4fb47413dbb67b0996ced75014b250c18bba5bb444
+  data.tar.gz: 7288b2b9b91bb4a7127ff05341ccb053d5a159e7dcdd70537d4d6a21cfc186bb
 SHA512:
-  metadata.gz: 5cc115b7e58995a480463b226df08d68fa54ee9a441d64b47efbc13546f184d3f4ee91fc14881f4f6df5773c2dd6b7f8f5268d86db2a7009bac036afa564b462
-  data.tar.gz: cb405495fee3c55030f520c3be3c6305b8158848aa77c9d597233bf15a76c82b352d675d4277fc75acaec9c87d4e6ed21a977e79290301ec5882f500f86385c8
+  metadata.gz: 516ebd68a80b61d75d12d1ca91833409cce8bc0d84d3d44346e07fc7b444c70f3d9d11eaca42cdbe39ff78f28e06fcc15af53c0659fa29ece17e316364e23706
+  data.tar.gz: ded90962d4080696c29e87cf83ec3a429e8feca7b693b01ae2b2b2596fa7980a6ea0d44af876c014fff8b8f371bf27b3810dd8f2515bf5f157ccc9efb4e7cf5a

data/Gemfile

@@ -4,3 +4,6 @@ git_source(:github) {|repo_name| "https://github.com/djellemah/upl" }
 
 # Specify your gem's dependencies in upl.gemspec
 gemspec
+
+gem 'pry-stack_explorer'
+gem 'pry-byebug'

data/History.txt

@@ -0,0 +1,3 @@
+== 0.0.3
+* rectify README errors
+* specs to handle variable unification from variables from top-level queries.

data/README.md

@@ -17,7 +17,7 @@ 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])'
 => #<Enumerator: ...>
-[12] pry(main) enum.to_a
+[2] pry(main) enum.to_a
 => [{:K=>home, :V=>/usr/lib64/swipl-7.7.18},
  {:K=>executable, :V=>/usr/local/rvm/rubies/ruby-2.6.0-preview2/bin/ruby},
  {:K=>shared_object_extension, :V=>so}]
@@ -51,15 +51,15 @@ false.
 And in Upl:
 
 ``` ruby
-[2] pry(main)> fact = Upl::Term.functor :person, :john, :anderson
+[1] pry(main)> fact = Upl::Term.functor :person, :john, :anderson
 => person/2(john,anderson)
-[3] pry(main)> Upl.assertz fact
+[2] pry(main)> Upl.assertz fact
 => true
-[4] pry(main)> Array Upl.query 'person(A,B)'
+[3] pry(main)> Array Upl.query 'person(A,B)'
 => [{:A=>john, :B=>anderson}]
-[5] pry(main)> Upl.retract fact
+[4] pry(main)> Upl.retract fact
 => true
-[6] pry(main)> Array Upl.query 'person(A,B)'
+[5] 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
-[2] pry(main)> fact = Upl::Term.functor :person, :john, :anderson, (o = Object.new)
+[1] pry(main)> fact = Upl::Term.functor :person, :john, :anderson, (o = Object.new)
 => person/3(john,anderson,#<Object:0x0000563346a08e38 @_upl_atom=439429>)
-[3] pry(main)> Upl.assertz fact
+[2] pry(main)> Upl.assertz fact
 => true
-[4] pry(main)> ha, = Array Upl.query 'person(A,B,C)'
+[3] pry(main)> ha, = Array Upl.query 'person(A,B,C)'
 => [{:A=>john,
   :B=>anderson,
   :C=>#<Object:0x0000563346a08e38 @_upl_atom=439429>}]
-[5] pry(main)> ha[:C].equal? o
+[4] pry(main)> ha[:C].equal? o
 => true
 ```
 
@@ -87,28 +87,40 @@ much wisdom. Hurhur. And at least one extra instance variable.
 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)
+fact =  Upl::Term.functor :person, :james, :madison, (o = Object.new)
 Upl.assertz fact
 
 fact2 = Upl::Term.functor :person, :thomas, :paine, (thing2 = Object.new)
 Upl.assertz fact2
 
-# Note that both facts are in the result
-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>}]
+# Note that both facts are in the result and the values for C are different
+query_term, query_vars = Upl::Runtime.term_vars 'person(A,B,C)'
+Array Upl::Runtime.term_vars_query query_term, query_vars
+=>[
+ {: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_hash = Upl::Runtime.term_vars 'person(A,B,C)'
-Upl::Extern.PL_unify query_hash[:C].term_t, thing2.to_term_t
+# Unify C with thing2
+query_term, query_vars = Upl::Runtime.term_vars 'person(A,B,C)'
+query_vars.C = thing2
 
 # ... 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_hash
+Array Upl::Runtime.term_vars_query query_term, query_vars
 => [{:A=>thomas, :B=>paine, :C=>#<Object:0x0000563f56d2b5b8 @_upl_atom=439813>}]
 ```
 
+### Ruby Predicates
+
+You can define predicates in ruby.
+``` ruby
+
+
+```
+
+So you can (theoretically) define a query in prolog that searches a ruby object graph.
+
 ## Disclaimer
 
 This is in-development code. I use it for some things other than just playing with. It might be useful for you too.

data/lib/upl.rb

@@ -4,41 +4,47 @@ require_relative 'upl/version'
 require_relative 'upl/extern'
 require_relative 'upl/term'
 require_relative 'upl/variable'
+require_relative 'upl/variables'
 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'
+require_relative 'upl/foreign'
 
 module Upl
-  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
+  module_function def query string_or_term, vars = nil, &blk
+    if string_or_term.is_a?(Term) && vars
+      Runtime.term_vars_query string_or_term, vars
     else
-      raise "dunno about #{string_or_term.inspect}"
+      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
   end
 
-  def self.consult filename
+  module_function def consult filename
     p = Pathname filename
     Runtime::call %Q{["#{p.realpath.to_s}"]}
   end
 
-  def self.asserta term
+  module_function def asserta term
     Runtime.call Term.functor :asserta, term
   end
 
-  def self.assertz term
+  module_function def 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
+  module_function def retract term
     Runtime.call Term.functor :retract, term
   end
 
@@ -57,7 +63,7 @@ module Upl
   #
   #   Upl.query Term :current_prolog_flag, Variable.new, Variable.new
   #
-  def self.Term name, *args
+  module_function def Term name, *args
     Term.functor name, *args
   end
 end

data/lib/upl/atom.rb

@@ -1,35 +1,74 @@
 module Upl
   class Atom
-    def initialize( atom_ref )
-      @atom_ptr = atom_ref.ptr
-      atom_chars_ptr = ::Upl::Extern::PL_atom_chars @atom_ptr
-      @_symbol = atom_chars_ptr.to_s.to_sym
+    # NOTE these are atom_t, NOT term_t and NOT Fiddle::Pointer to atom_t
+    def initialize( atom_t )
+      @atom_t = atom_t
+
+      # pretty much all other methods need chars, so just do it now.
+      @chars = (::Upl::Extern::PL_atom_chars @atom_t).to_s.freeze
     end
 
-    # drop the term immediately, and just keep the atom pointer
+    # drop the term immediately, and just keep the atom value
     def self.of_term( term_t )
-      rv = Extern::PL_get_atom term_t, (atom_ref = Fiddle::Pointer.new(0).ref)
-      raise "can't get atom from term" unless rv == 1
-      new atom_ref
+      rv = Extern::PL_get_atom term_t, (atom_t = Fiddle::Pointer[0].ref)
+      rv == 1 or raise "can't get atom from term"
+      new atom_t.ptr
+    end
+
+    attr_reader :atom_t
+
+    # NOTE this returns an atom_t for obj.object_id embedded in an atom
+    def self.t_of_ruby obj
+      Upl::Extern.PL_new_atom "ruby-#{obj.object_id.to_s}"
     end
 
-    attr_reader :atom_ptr
+    # return the object_id embedded in the atom, or nil if it's not an embedded
+    # object_id
+    def to_obj_id
+      if instance_variable_defined? :@to_obj_id
+        @to_obj_id
+      else
+        @to_obj_id =
+        if @chars =~ /^ruby-(\d+)/
+          $1.to_i
+        end
+      end
+    end
+
+    # return the ruby object associated with the object_id embedded in the atom
+    def to_ruby
+      if to_obj_id
+        ObjectSpace._id2ref to_obj_id
+      else
+        case _sym = to_sym
+        when :false; false
+        when :true; true
+        else _sym
+        end
+      end
+    rescue RangeError
+      # object with the given obj_id no longer exists in ruby, so just return
+      # the symbol with the embedded object_id.
+      to_sym
+    end
 
     def == rhs
-      to_sym == rhs.to_sym
+      atom_t == rhs.atom_t
     end
 
     def to_sym
-      @_symbol or raise "no symbol for atom"
+      @chars.to_sym
     end
 
     def to_s
-      @_string ||= to_sym.to_s
+      @chars
     end
 
     def inspect; to_sym end
 
     def pretty_print pp
+      pp.text atom_t
+      pp.text '-'
       pp.text to_s
     end
   end

data/lib/upl/extern.rb

@@ -54,6 +54,9 @@ module Upl
     # terms
     extern 'predicate_t PL_predicate(const char *name, int arity, const char *module)'
 
+    TRUE =  (1)
+    FALSE = (0)
+
     ##############
     # querying and getting results
 
@@ -118,6 +121,17 @@ module Upl
     PL_NOT_A_LIST =            (43)
     PL_DICT =                  (44)
 
+    # Foreign predicate flags
+    PL_FA_NOTRACE =           (0x01)  # foreign cannot be traced
+    # PL_FA_TRANSPARENT =       (0x02)  # foreign is module transparent. Deprecated.
+    PL_FA_NONDETERMINISTIC =  (0x04)  # foreign is non-deterministic
+    PL_FA_VARARGS =           (0x08)  # call using t0, ac, ctx
+    PL_FA_CREF =              (0x10)  # Internal: has clause-reference
+    PL_FA_ISO =               (0x20)  # Internal: ISO core predicate
+    PL_FA_META =              (0x40)  # Additional meta-argument spec
+
+    extern 'int PL_register_foreign_in_module(char *mod, char *name, int arity, foreign_t (*f)(), int flags, ...)'
+
     module Convert
       REP_UTF8  = 0x1000
       BUF_MALLOC = 0x0200
@@ -197,6 +211,10 @@ module Upl
     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_put_integer(term_t t, long i)'
+    extern 'int PL_put_int64(term_t t, int64_t i)'
+
+    extern 'int PL_put_string_nchars(term_t t, size_t len, const char *chars)'
 
     extern 'int PL_cons_functor_v(term_t h, functor_t fd, term_t a0)'
 
@@ -243,5 +261,8 @@ module Upl
     extern 'int PL_wchars_to_term(const pl_wchar_t *chars, term_t term)'
 
     extern 'void PL_unregister_atom(atom_t a)'
+
+    # signature is actually PL_agc_hook_t, not void*
+    extern 'void* PL_agc_hook(void*)'
   end
 end

data/lib/upl/foreign.rb

@@ -0,0 +1,55 @@
+module Upl
+  # Register a foreign predicate in prolog
+  # Upl::Extern.PL_register_foreign_in_module(char *mod, char *name, int arity, foreign_t (*f)(), int flags, ...)
+
+  # create the foreign predicate as a class in ruby
+  #
+  # closure = Class.new(Fiddle::Closure) {
+  #   def call
+  #     10
+  #   end
+  # }.new(Fiddle::TYPE_INT, [])
+  #
+  # func = Fiddle::Function.new(closure, [], Fiddle::TYPE_INT)
+
+  # create the foreign predicate as a block in ruby
+  #
+  # new(ctype, args, abi = Fiddle::Function::DEFAULT, &block)
+  # cb = Closure::BlockCaller.new(TYPE_INT, [TYPE_INT]) do |one|
+  #   one
+  # end
+  #
+  # func = Function.new(cb, [TYPE_INT], TYPE_INT)
+
+  module Foreign
+    def self.predicates
+      @predicates ||= Hash.new
+    end
+
+    def self.register_semidet name, arity = nil, module: nil, &blk
+      arity ||= blk.arity
+      arg_types = arity.times.map{Fiddle::TYPE_VOIDP}
+      ruby_pred = Fiddle::Closure::BlockCaller.new Fiddle::TYPE_INT, arg_types do |*args|
+        case (rv = blk.call *args)
+        when true;            Upl::Extern::TRUE
+        when false, NilClass; Upl::Extern::FALSE
+        when 0, 1;            rv
+        else                  Upl::Extern::TRUE
+        end
+      rescue
+        # TODO raise an exception here, otherwise errors get lost in an empty result set.
+        Upl::Extern::FALSE
+      end
+
+      module_name = Fiddle::Pointer[module_name&.to_s || 0]
+
+      fn = Fiddle::Function.new ruby_pred, arg_types, Fiddle::TYPE_INT
+      rv = Upl::Extern.PL_register_foreign_in_module module_name, name.to_s, arity, fn, 0
+      rv == 1 or raise "can't register ruby predicate #{name}/#{arity}"
+
+      # NOTE you have to keep ruby_pred and fn around somewhere, otherwise they
+      # get garbage collected, and then the callback segfaults.
+      predicates[[name,arity].join('/').to_sym] = ruby_pred, fn
+    end
+  end
+end

data/lib/upl/inter.rb

@@ -1,3 +1,6 @@
+require_relative 'extern'
+require_relative 'foreign'
+
 module Upl
   module Inter
     # Try Term, then Fiddle::Pointer, then to_term_t.
@@ -13,6 +16,19 @@ module Upl
       end
     end
 
+    # call any method on any object, from prolog
+    def self.register_mcall_predicate
+      Upl::Foreign.register_semidet :mcall do |obj_term_t,meth_term_t,v_term_t|
+        obj = Upl::Tree.of_term obj_term_t
+        meth = Upl::Tree.of_term meth_term_t
+        v = obj.send meth
+
+        Upl::Extern::PL_unify v_term_t, v.to_term_t
+      end
+    end
+
+    register_mcall_predicate
+
     # 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
@@ -31,6 +47,57 @@ module Upl
         lst_term = rst_t
       end
     end
+
+    # keep track of object_id atoms that were assigned in prolog, and prolog now
+    # wants to garbage collect them.
+    class Agc
+      def initialize
+        @id_objects = {}
+      end
+
+      def self.instance
+        @instance ||= new
+      end
+
+      def register obj
+        @id_objects[obj.object_id] = obj
+      end
+
+      def deregister obj
+        @id_objects.delete obj.object_id
+      end
+    end
+
+    module_function def attach_atom_hook
+      @atom_hook = atom_hook = Fiddle::Closure::BlockCaller.new Fiddle::TYPE_INT, [Fiddle::TYPE_VOIDP] do |atom_t|
+        atom = Upl::Atom.new atom_t
+        p atom_t: atom_t.to_i, atom: atom
+        if atom.to_obj_id
+          obj = atom.to_ruby
+          p obj: obj, dereg: (Agc.instance.deregister obj)
+        end
+
+        #  FALSE here will prevent garbage collection
+        Upl::Extern::TRUE
+      end
+
+      # NOTENOTE this must NOT be garbage-collected, otherwise the callback to it will fail.
+      @atom_hook_fn = Fiddle::Function.new atom_hook, atom_hook.args, atom_hook.ctype
+
+      # returns old fn ptr
+      Upl::Extern.PL_agc_hook @atom_hook_fn
+    end
+
+    def register_mcall_predicate
+      Upl::Foreign.register_semidet :mcall do |obj_term_t,meth_term_t,v_term_t|
+        obj = Upl::Tree.of_term obj_term_t
+        meth = Upl::Tree.of_term meth_term_t
+        v = obj.send meth
+
+        Upl::Extern::PL_unify v_term_t, v.to_term_t
+      end
+    end
+
   end
 end
 
@@ -70,12 +137,16 @@ protected
   end
 
   def _upl_atomize
-    # see also PL_agc_hook for hooking into the swipl GC
-    ObjectSpace.define_finalizer self do |this_obj|
-      # TODO PL_unregister_atom? Finalizer?
-      Upl::Extern.PL_unregister_atom this_obj.instance_variable_get :@_upl_atom
-    end
-    Upl::Extern.PL_new_atom "ruby-#{object_id.to_s}"
+    # TODO see also PL_agc_hook for hooking into the swipl GC
+    atom_t = Upl::Atom.t_of_ruby self
+    ObjectSpace.define_finalizer self, &self.class._upl_finalizer_blk(atom_t)
+    atom_t
+  end
+
+  # Have to put this in a separate method, otherwise the finalizer block's
+  # binding holds onto the obj it's trying to finalize.
+  def self._upl_finalizer_blk atom_t
+    proc do |objid| Upl::Extern.PL_unregister_atom atom_t end
   end
 end
 
@@ -84,3 +155,19 @@ class Symbol
     Upl::Extern.PL_new_atom to_s
   end
 end
+
+class Integer
+  def to_term_t
+    rv = Upl::Extern.PL_put_int64 (term_t = Upl::Extern.PL_new_term_ref), self
+    rv == 1 or raise "can't convert #{self} to term. Maybe too big."
+    term_t
+  end
+end
+
+class String
+  def to_term_t
+    rv = Upl::Extern.PL_put_string_nchars (term_t = Upl::Extern.PL_new_term_ref), length, Fiddle::Pointer[self]
+    rv == 1 or raise "can't convert #{self} to term"
+    term_t
+  end
+end

data/lib/upl/runtime.rb

@@ -9,7 +9,7 @@ class Fiddle::Pointer
 
   def type_string
     type_int = term_type
-    ::Upl::Extern.constants.find{|c| (::Upl::Extern.const_get c) == type_int}
+    ::Upl::Extern.constants.find{|c| (::Upl::Extern.const_get c) == type_int} || type_int
   end
 end
 
@@ -32,15 +32,23 @@ module Upl
       rv == 1 # don't raise
     end
 
+    def self.ruby_free_fn
+      @ruby_free_fn ||= Fiddle::Function.new Fiddle::RUBY_FREE, [Fiddle::TYPE_VOIDP], Fiddle::TYPE_VOID
+    end
+
+    def self.swipl_free_fn
+      @swipl_free_fn ||= Fiddle::Function.new Extern['PL_free'], [Fiddle::TYPE_VOIDP], Fiddle::TYPE_VOID
+    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
+      # TODO from gem-swipl args = [ @swipl_lib, "-tty", "-q", "-t", "true", "-g", "true", "--nodebug", "--nosignals" ]
       args = %w[upl --tty=false --signals=false --debug=false --quiet=true]
 
       # convert args to char **
       ptr_size = Extern.sizeof 'char*'
-      arg_ptrs = Ptr.malloc(ptr_size * args.size)
+      arg_ptrs = Ptr.malloc ptr_size * args.size, ruby_free_fn
       args.each_with_index do |rg,i|
         (arg_ptrs + i*ptr_size)[0,ptr_size] = Ptr[rg].ref
       end
@@ -70,13 +78,13 @@ module Upl
         (predicate 'atom_to_term', 3),
         (args = TermVector[st.to_sym, nil, nil]).terms
 
-      vars_hash = Inter.each_of_list(args[2]).map do |term_t|
+      vars = Inter.each_of_list(args[2]).each_with_object Variables.new do |term_t, vars|
         # 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
+        vars.store t.first.atom.to_sym, (Variable.new t.last.term_t, name: t.first.atom.to_sym)
+      end
 
-      return args[1], vars_hash
+      return args[1], vars
     end
 
     def self.unify( term_a, term_b )
@@ -85,6 +93,7 @@ module Upl
     end
 
     # do a query for the given term and vars, as parsed by term_vars
+    # qvars_hash is a hash of :VariableName => Term(PL_VARIABLE)
     def self.term_vars_query qterm, qvars_hash
       raise "not a term" unless Term === qterm
       return enum_for __method__,  qterm, qvars_hash unless block_given?
@@ -105,10 +114,9 @@ module Upl
           break if res == 0
 
           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_sym] = var.to_ruby
-            # binding.pry if val.to_sym == :query_debug_settings rescue false
+            # var will be invalidated by the next call to PL_next_solution,
+            # so we need to construct a ruby tree copy of the value term.
+            ha[name_sym] = var.to_ruby
           end
 
           yield hash
@@ -151,7 +159,7 @@ module Upl
 
     def self.query term
       raise "not a Term" unless Term === term
-      return enum_for :query_term, term unless block_given?
+      return enum_for :query, term unless block_given?
 
       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

data/lib/upl/term.rb

@@ -56,7 +56,7 @@ module Upl
       rv == 1 or raise "can't populate term"
 
       @arity = int_ptr.ptr.to_i
-      @atom = Atom.new atom_ptr
+      @atom = Atom.new atom_ptr.ptr
 
       self
     end
@@ -84,7 +84,7 @@ module Upl
     end
 
     def to_functor
-      Extern::PL_new_functor atom.atom_ptr, arity
+      Extern::PL_new_functor atom.atom_t, arity
     end
 
     def to_predicate
@@ -94,7 +94,6 @@ module Upl
     def tree; @tree || (Tree.of_term term_t) end
     alias to_ruby tree
 
-    # TODO leaning hard towards each with Enumerable
     def each
       return enum_for :args unless block_given?
 

data/lib/upl/tree.rb

@@ -27,18 +27,15 @@ module Upl
       term_to_ruby term_t
     end
 
+    def to_ruby; self end
+
     def self.term_to_ruby term_t
       case term_t.term_type
       when Extern::PL_VARIABLE
         Variable.copy term_t
 
       when Extern::PL_ATOM
-        atom = Atom.of_term term_t
-        if atom.to_s =~ /^ruby-(\d+)/
-          ObjectSpace._id2ref $1.to_i
-        else
-          atom.to_sym
-        end
+        Atom.of_term(term_t).to_ruby
 
       # I think integers > 63 bits can be fetched with PL_get_mpz
       # Other than PL_INTEGER, most of these seem to be unused?
@@ -56,7 +53,7 @@ module Upl
       when Extern::PL_STRING
         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
+        value_ptr.to_s[0,len_ptr.ptr.to_i]
 
       when Extern::PL_NIL
         # TODO maybe this should be [] - see what happens when term_vars has no vars
@@ -67,13 +64,13 @@ module Upl
         Tree.new term_t
 
       when Extern::PL_LIST_PAIR
-        Inter.each_of_list(term_t).to_a
+        Inter.each_of_list(term_t).map{|term_t| Term.new(term_t).to_ruby}
 
       when Extern::PL_DICT
         Dict.of_term term_t
 
       else
-        :NotImplemented
+        :"#{term_t.type_string} NotImplemented"
 
       end
     end
@@ -81,7 +78,7 @@ module Upl
     def arity; args.size end
 
     def pretty_print(pp)
-      unless atom == :','
+      unless atom.to_sym == :','
         pp.text atom.to_s
         if arity > 0
           pp.text ?/

data/lib/upl/variable.rb

@@ -1,13 +1,17 @@
 module Upl
   # Really this is just an empty term.
   class Variable
-    def initialize term_t = nil
+    def initialize term_t = nil, name: nil
       @term_t = term_t || self.class.to_term
+      @name = name
     end
 
-    attr_reader :term_t
+    attr_reader :term_t, :name
     alias to_term_t term_t
 
+    # create a ruby represetation of the term_t
+    def to_ruby; Tree.of_term term_t end
+
     def self.copy term_t
       inst = new term_t
 
@@ -22,15 +26,21 @@ module Upl
       Extern.PL_new_term_ref
     end
 
+    def self.[]( *names )
+      vars = names.map{|name| new name: name}
+      if vars.size == 1 then vars.first else vars end
+    end
+
     def to_s; _string end
 
     def _string
       @_string ||= begin
         Extern::PL_get_chars \
           term_t,
-          (str_ref = Runtime::Ptr[''].ref),
+          (str_ref = Runtime::Ptr[0].ref),
           Extern::Convert::CVT_VARIABLE | Extern::Convert::REP_UTF8 | Extern::Convert::BUF_MALLOC # | Extern::CVT_ALL
 
+        str_ref.ptr.free = Runtime.swipl_free_fn
         str_ref.ptr.to_s
       end
     end
@@ -55,6 +65,10 @@ module Upl
       if attributed?
         attribute.pretty_print pp
       else
+        if name
+          pp.text name
+          pp.text '='
+        end
         pp.text to_s
       end
     end

data/lib/upl/variables.rb

@@ -0,0 +1,42 @@
+module Upl
+  # Storage from variables, where setting one just calls unify on the underlying terms.
+  # Cos it's hard to hang unify on a single variable.
+  class Variables < Hash
+    def initialize *names
+      super
+      names.each do |name|
+        self.store name, Variable.new
+      end
+    end
+
+    #  calls unify, so you can't set a given variable more than once.
+    def []=( name, term )
+      Extern::PL_unify self[name.to_sym].to_term_t, term.to_term_t
+    end
+
+    def method_missing meth, *args
+      name = meth.to_s
+
+      the_method =
+      if name.chomp! '='
+        # set the value
+        :'[]='
+      else
+        # fetch the value
+        :'[]'
+      end
+
+      var_name = name.to_sym
+
+      if has_key? var_name
+        send the_method, var_name, *args
+      else
+        super
+      end
+    end
+
+    def pretty_print pp
+      transform_values{|v| v.to_ruby}.pretty_print pp
+    end
+  end
+end

data/lib/upl/version.rb

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

data/scratch/register_predicate.rb

@@ -0,0 +1,33 @@
+def register_test_predicate
+  Upl::Foreign.register_semidet :upl_block do |term_t0, term_t1|
+    fterm = (Upl::Tree.of_term term_t0)
+    p foreign: fterm
+
+    if Symbol === fterm then
+      Upl::Extern::PL_unify term_t1, :there.to_term_t
+    end
+  end
+
+  Array Upl.query "upl_block(hello,A)"
+end
+
+=begin
+  include UPL
+  vars = Variables.new :V
+  term = Term :mcall, (o = Object.new), :to_s, vars.V
+  def o.to_s; "This is from Ruby, with Love :-D"; end
+  Array Runtime.term_vars_query term, vars
+  => [{:V=>"This is from Ruby, with Love :-D"}]
+
+  mcall(+Object, +Method, -Result)
+=end
+
+def doit
+  fact = Upl::Term.functor :person, :john, :anderson, Object.new
+  Upl.assertz fact
+  vs = Array Upl.query 'person(A,B,C)'
+  p vs
+  1000.times{Array Upl.query 'current_prolog_flag(K,V)'}
+  Upl.retract fact
+  Upl::Runtime.call Upl::Term :garbage_collect_atoms
+end

data/upl.gemspec

@@ -30,9 +30,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 1.16'
-  spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'bundler', '>= 1.16'
+  spec.add_development_dependency 'rake', '>= 10.0'
+  spec.add_development_dependency 'rspec', '>= 3.0'
   spec.add_dependency 'pry'
   spec.add_dependency 'fiddle'
 end

metadata

@@ -1,55 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: upl
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - John Anderson
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-09-17 00:00:00.000000000 Z
+date: 2019-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.16'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.16'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
@@ -91,6 +91,7 @@ files:
 - ".rspec"
 - ".travis.yml"
 - Gemfile
+- History.txt
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -100,6 +101,7 @@ files:
 - lib/upl/atom.rb
 - lib/upl/dict.rb
 - lib/upl/extern.rb
+- lib/upl/foreign.rb
 - lib/upl/functor.rb
 - lib/upl/inter.rb
 - lib/upl/runtime.rb
@@ -107,7 +109,9 @@ files:
 - lib/upl/term_vector.rb
 - lib/upl/tree.rb
 - lib/upl/variable.rb
+- lib/upl/variables.rb
 - lib/upl/version.rb
+- scratch/register_predicate.rb
 - upl.gemspec
 homepage: https://github.com/djellemah/upl
 licenses:
@@ -129,8 +133,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: Access SWI-Prolog engine from ruby