upl 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d7e5de431546d46c5f4998818e1360e10e5dab6497e0988e783e626393b35cc7
+  data.tar.gz: 4cd776d265de52483fe89e239041ee001ba21856c339fb067b661437c6cbfd25
+SHA512:
+  metadata.gz: a8ab63130414fe7d8ae8775c4a0f11199c76024952541b2820deb8e607361ca26cb07bcec64fc2a2df8e5790a5042caaa1598a0705d0271d6ac4dca4cd9497de
+  data.tar.gz: 58d09609f7888ee559bb626219f7be13576016aa40dff3992c12413a84d3113841e748f7896aa93d204dcceb2b5f0e40528e828bc30b930e7743ccb134efaf1f

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+.rvmrc
+Gemfile.lock
+*.sublime*

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.6
+before_install: gem install bundler -v 1.16.2

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/djellemah/upl" }
+
+# Specify your gem's dependencies in upl.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 John Anderson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,174 @@
+# Upl
+
+A ruby wrapper for SWI-Prolog that goes both ways.
+
+The main idea being that you want to just put in a chunk of prolog, and have the
+wrapper give you back your answers in terms of the variable names you specified.
+Just like what happens in your common-or-garden prolog REPL. But with pry's
+syntax colouring and pretty-printing :-)
+
+Also, do prolog-style queries on objects :-DD
+
+## Tutorial
+
+### 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])'
+=> #<Enumerator: ...>
+[12] 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}]
+```
+
+### Facts
+Also we want to be able to construct prolog-queryable facts from ruby objects.
+In prolog:
+
+``` prolog
+?- assert(person(john,anderson)).
+true.
+
+?- person(A,B).
+A = john,
+B = anderson.
+
+?- retract(person(john,anderson)).
+true.
+
+?- person(A,B).
+false.
+```
+
+And in Upl:
+
+``` ruby
+[1] pry(Upl):1> fact = Term.functor :person, :john, :anderson
+=> person/2(john,anderson)
+[2] pry(Upl):1> Runtime.eval Term.functor :assert, fact
+=> true
+[3] pry(Upl):1> Array query 'person(A,B)'
+=> [{:A=>john, :B=>anderson}]
+[4] pry(Upl):1> Runtime.eval Term.functor :retract, fact
+=> true
+[5] pry(Upl):1> Array query 'person(A,B)'
+=> []
+```
+
+### Objective Facts
+
+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)
+=> person/3(john,anderson,#<Object:0x0000563346a08e38 @_upl_atom=439429>)
+[2] pry(Upl):1> Runtime.eval Term.functor :assert, fact
+=> true
+[3] pry(Upl):1> ha, = Array query 'person(A,B,C)'
+=> [{:A=>john,
+  :B=>anderson,
+  :C=>#<Object:0x0000563346a08e38 @_upl_atom=439429>}]
+[4] pry(Upl):1> ha[:C].equal? o
+=> true
+```
+
+Woo. An object disappears into prolog, and comes back out again. Having gained
+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)
+Upl::Runtime.eval Upl::Term.functor :assert, fact
+
+fact2 = Upl::Term.functor :person, :thomas, :paine, (thing2 = Object.new)
+Upl::Runtime.eval Upl::Term.functor :assert, 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
+=>[{: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
+
+# ... 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
+=> [{:A=>thomas, :B=>paine, :C=>#<Object:0x0000563f56d2b5b8 @_upl_atom=439813>}]
+```
+
+## Disclaimer
+
+This is in-development code. I use it for some things other than just playing with. It might be useful for you too.
+
+ruby has a GC. swipl has a GC. At some point they will disagree. I haven't reached that point yet.
+
+## Naming
+
+```Upl```? Wat!? Why?
+
+Well. ```swipl``` was taken. ```ripl``` was taken. So maybe in keeping with long tradition: ```rupl```.
+
+But that leads to ```pry -I. -rrupl``` which is Not Fun.
+
+But ```upl``` gives you ```pry -I. -rupl``` So it's kinda like ```ubygems```.
+
+Also, ```Upl``` rhymes with tuple and/or supple. Depending on your pronunciation :-p
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'upl'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install upl
+
+## Usage
+
+For a REPL say
+
+    pry -rupl
+
+or
+
+    bin/console
+
+
+## Development
+
+Install SWI-Prolog with both the swipl executable and libswipl.so
+
+
+And bundler wants me to tell you the following:
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/djellemah/upl.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+# require "bundler/setup"
+require_relative '../lib/upl'
+
+require 'pry'
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/upl.rb

@@ -0,0 +1,22 @@
+require 'pathname'
+require_relative 'upl/version'
+
+require_relative 'upl/extern'
+require_relative 'upl/term'
+require_relative 'upl/variable'
+require_relative 'upl/atom'
+require_relative 'upl/runtime'
+require_relative 'upl/tree'
+require_relative 'upl/inter'
+
+module Upl
+  def self.query st, &blk
+    term, vars = Runtime::term_vars st
+    Runtime::term_vars_query term, vars, &blk
+  end
+
+  def self.consult filename
+    p = Pathname filename
+    Runtime::eval %Q{["#{p.realpath.to_s}"]}
+  end
+end

data/lib/upl/atom.rb

@@ -0,0 +1,36 @@
+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
+    end
+
+    # drop the term immediately, and just keep the atom pointer
+    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
+    end
+
+    attr_reader :atom_ptr
+
+    def == rhs
+      to_sym == rhs.to_sym
+    end
+
+    def to_sym
+      @_symbol or raise "no symbol for atom"
+    end
+
+    def to_s
+      @_string ||= to_sym.to_s
+    end
+
+    def inspect; to_sym end
+
+    def pretty_print pp
+      pp.text to_s
+    end
+  end
+end

data/lib/upl/extern.rb

@@ -0,0 +1,242 @@
+require 'fiddle'
+require 'fiddle/import'
+require 'pathname'
+
+module Upl
+  module Extern
+    extend Fiddle::Importer
+
+    # use swipl config to find the .so file
+    def self.so_path
+      begin
+        swipl_exe = 'swipl'
+        values = `#{swipl_exe} --dump-runtime-variables=sh`.each_line.with_object Hash.new do |line,ha|
+          line.chomp!
+          # split by = and for rhs strip surrounding quotes and trailing ;
+          line =~ /^([^=]+)="([^"]*)";$/
+          ha[$1] = $2.strip
+        end
+      rescue Errno::ENOENT => ex
+        puts "#{swipl_exe} not found on path #{ENV['PATH']}"
+        exit 1
+      end
+
+      begin
+        # should result in something like
+        #   /usr/lib64/swipl-7.7.18/lib/x86_64-linux/libswipl.so
+        # which should actually exist
+        p = Pathname "#{values['PLBASE']}/lib/#{values['PLARCH']}/#{values['PLLIB'].gsub('-l', 'lib')}.#{values['PLSOEXT']}"
+        p.realpath.to_s
+      rescue Errno::ENOENT => ex
+        puts "problem with library #{p.to_s}: #{ex.message}"
+        exit 1
+      end
+    end
+
+    dlload so_path
+
+    NULL = Fiddle::Pointer.new 0
+
+    typealias 'term_t', 'void *'
+    typealias 'module_t', 'void *'
+    typealias 'predicate_t', 'void *'
+    typealias 'atom_t', 'void *'
+    typealias 'qid_t', 'void *'
+    typealias 'fid_t', 'uintptr_t'
+    typealias 'functor_t', 'void *'
+
+    extern 'int PL_initialise(int argc, char **argv)'
+    extern 'int PL_halt(int status)'
+
+    # for constructing types see https://stackoverflow.com/questions/30293406/is-it-possible-to-use-fiddle-to-pass-or-return-a-struct-to-native-code
+    # Predicate_t = struct ['char *data','char *more_data','size_t len']
+
+    # terms
+    extern 'predicate_t PL_predicate(const char *name, int arity, const char *module)'
+
+    ##############
+    # querying and getting results
+
+    # copied from SWI-Prolog.h
+    module Flags
+      PL_Q_DEBUG =           0x0001  # = TRUE for backward compatibility
+      PL_Q_NORMAL =          0x0002  # normal usage
+      PL_Q_NODEBUG =         0x0004  # use this one
+      PL_Q_CATCH_EXCEPTION = 0x0008  # handle exceptions in C
+      PL_Q_PASS_EXCEPTION =  0x0010  # pass to parent environment
+      PL_Q_ALLOW_YIELD =     0x0020  # Support I_YIELD
+      PL_Q_EXT_STATUS =      0x0040  # Return extended status
+      PL_Q_DETERMINISTIC =   0x0100  # call was deterministic
+    end
+
+    extern 'fid_t PL_open_foreign_frame(void)'
+    extern 'void PL_rewind_foreign_frame(fid_t cid)'
+    extern 'void PL_close_foreign_frame(fid_t cid)'
+    extern 'void PL_discard_foreign_frame(fid_t cid)'
+
+    PL_VARIABLE =              (1)
+    PL_ATOM =                  (2)
+    PL_INTEGER =               (3)
+    PL_FLOAT =                 (4)
+    PL_STRING =                (5)
+    PL_TERM =                  (6)
+    PL_NIL =                   (7)
+    PL_BLOB =                  (8)
+    PL_LIST_PAIR =             (9)
+    PL_FUNCTOR =               (10)
+    PL_LIST =                  (11)
+    PL_CHARS =                 (12)
+    PL_POINTER =               (13)
+    PL_CODE_LIST =             (14)
+    PL_CHAR_LIST =             (15)
+    PL_BOOL =                  (16)
+    PL_FUNCTOR_CHARS =         (17)
+    _PL_PREDICATE_INDICATOR =  (18)
+    PL_SHORT =                 (19)
+    PL_INT =                   (20)
+    PL_LONG =                  (21)
+    PL_DOUBLE =                (22)
+    PL_NCHARS =                (23)
+    PL_UTF8_CHARS =            (24)
+    PL_UTF8_STRING =           (25)
+    PL_INT64 =                 (26)
+    PL_NUTF8_CHARS =           (27)
+    PL_NUTF8_CODES =           (29)
+    PL_NUTF8_STRING =          (30)
+    PL_NWCHARS =               (31)
+    PL_NWCODES =               (32)
+    PL_NWSTRING =              (33)
+    PL_MBCHARS =               (34)
+    PL_MBCODES =               (35)
+    PL_MBSTRING =              (36)
+    PL_INTPTR =                (37)
+    PL_CHAR =                  (38)
+    PL_CODE =                  (39)
+    PL_BYTE =                  (40)
+    PL_PARTIAL_LIST =          (41)
+    PL_CYCLIC_TERM =           (42)
+    PL_NOT_A_LIST =            (43)
+    PL_DICT =                  (44)
+
+    module Convert
+      REP_UTF8  = 0x1000
+      BUF_MALLOC = 0x0200
+
+      CVT_ATOM =            0x0001
+      CVT_STRING =          0x0002
+      CVT_LIST =            0x0004
+      CVT_INTEGER =         0x0008
+      CVT_FLOAT =           0x0010
+      CVT_VARIABLE =        0x0020
+      CVT_NUMBER =          CVT_INTEGER|CVT_FLOAT
+      CVT_ATOMIC =          CVT_NUMBER|CVT_ATOM|CVT_STRING
+      CVT_WRITE =           0x0040
+      CVT_WRITE_CANONICAL = 0x0080
+      CVT_WRITEQ =          0x00C0
+      CVT_ALL =             CVT_ATOMIC|CVT_LIST
+    end
+
+    extern 'predicate_t PL_pred(functor_t f, module_t m)'
+
+    # ctx can be NULL, p is the predicate with arity, t0 is the collection of terms to be filled by the query
+    extern 'qid_t PL_open_query(module_t ctx, int pl_q_flags, predicate_t p, term_t t0)'
+    extern 'int PL_next_solution(qid_t qid)'
+    extern 'void PL_cut_query(qid_t qid)'
+    extern 'void PL_close_query(qid_t qid)'
+
+    # shortcut when there will only be one answer
+    extern 'int PL_call_predicate(module_t m, int pl_q_flags, predicate_t p, term_t t0)'
+
+    extern 'term_t PL_exception(qid_t qid)'
+    extern 'int PL_raise_exception(term_t exception)'
+    extern 'int PL_throw(term_t exception)'
+    extern 'void PL_clear_exception(void)'
+
+    # qid_t PL_current_query(void)
+
+    # module can be NULL
+    extern 'int PL_call(term_t t, module_t m)'
+
+    ####################
+    # storage of db records. Not sure if it's useful
+    # http://www.swi-prolog.org/pldoc/man?section=foreign-misc
+    # void PL_erase(record_t record)
+    # record_t PL_record(term_t +t)
+
+    # create empty term(s)
+    extern 'term_t PL_new_term_ref()'
+    extern 'term_t PL_new_term_refs(int n)'
+    extern 'term_t PL_copy_term_ref(term_t from)'
+
+    extern 'int PL_new_atom(const char *s)'
+    extern 'int PL_new_atom_nchars(size_t len, const char *s)'
+    extern 'functor_t PL_new_functor(atom_t f, int a)'
+
+    extern 'const char * PL_atom_chars(atom_t a)'
+    extern 'int PL_get_atom(term_t t, atom_t * a)'
+
+    # get the type
+    extern 'int PL_term_type(term_t t)'
+    extern 'int PL_is_variable(term_t t)'
+    extern 'int PL_is_ground(term_t t)'
+    extern 'int PL_is_atom(term_t t)'
+    extern 'int PL_is_integer(term_t t)'
+    extern 'int PL_is_string(term_t t)'
+    extern 'int PL_is_float(term_t t)'
+    extern 'int PL_is_rational(term_t t)'
+    extern 'int PL_is_compound(term_t t)'
+    extern 'int PL_is_callable(term_t t)'
+    extern 'int PL_is_functor(term_t t, functor_t f)'
+    extern 'int PL_is_list(term_t t)'
+    extern 'int PL_is_pair(term_t t)'
+    extern 'int PL_is_atomic(term_t t)'
+    extern 'int PL_is_number(term_t t)'
+    extern 'int PL_is_acyclic(term_t t)'
+
+    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_cons_functor_v(term_t h, functor_t fd, term_t a0)'
+
+    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_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)'
+    extern "int PL_get_blob(term_t t, void **blob, size_t *len, PL_blob_t **type)"
+
+    extern 'int PL_get_functor(term_t t, functor_t *f)'
+
+    extern 'int PL_get_nil(term_t l)'
+    extern 'int PL_get_list(term_t l, term_t h, term_t t)'
+    extern 'int PL_get_head(term_t l, term_t h)'
+    extern 'int PL_get_tail(term_t l, term_t t)'
+
+    extern 'int PL_unify(term_t t1, term_t t2)'
+
+    extern 'int PL_skip_list(term_t list, term_t tail, size_t *len)'
+
+    ##################
+    # attributed variables. Don't do what I thought they did.
+    extern 'int PL_is_attvar(term_t t)'
+    extern 'int PL_get_attr(term_t v, term_t a)'
+
+    ##################
+    # memory
+    extern 'void PL_free(void *mem)'
+
+    ####################
+    # 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[]
+    # 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)'
+
+    extern 'int PL_chars_to_term(const char *chars, term_t term)'
+    extern 'int PL_wchars_to_term(const pl_wchar_t *chars, term_t term)'
+
+    extern 'void PL_unregister_atom(atom_t a)'
+  end
+end

data/lib/upl/functor.rb

@@ -0,0 +1,51 @@
+module Upl
+  # Just an idea, not used yet.
+  class Functor
+    def initialize( atom, args_or_arity )
+      @atom = atom
+
+      case args_or_arity
+      when Array
+        @args = args_or_arity
+        @arity = args.size
+      when Integer
+        @arity = args_or_arity
+      else
+        "dunno bout #{args_or_arity.inspect}"
+      end
+    end
+
+    attr_reader :atom
+    def args; @args || [] end
+    def arity; @arity || args.size end
+
+    # create a functor_t pointer
+    def functor_t
+      raise NotImplementedError
+    end
+
+    # create a predicate_t
+    def predicate_t
+      raise NotImplementedError
+    end
+
+    def pretty_print(pp)
+      unless atom.to_sym == :','
+        pp.text atom.to_s
+        if arity > 0
+          pp.text ?/
+          pp.text arity.to_s
+        end
+      end
+
+      if arity > 0
+        pp.group 1, ?(, ?) do
+          args.each_with_index do |ruby_term,i|
+            ruby_term.pretty_print pp
+            pp.text ?, if i < arity - 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/upl/inter.rb

@@ -0,0 +1,48 @@
+# TODO not used
+class Object
+  def to_atom
+    if frozen?
+      # TODO must check instance variable here
+      _upl_atomize
+    else
+      @_upl_atom ||= _upl_atomize
+    end
+  end
+
+  def to_term
+    if frozen?
+      # TODO must check instance variable here
+      _upl_termize
+    else
+      # @_upl_termize ||= _upl_termize
+      _upl_termize
+    end
+  end
+
+protected
+
+  def _upl_termize
+    term_t = Upl::Extern.PL_new_term_ref
+    rv = Upl::Extern.PL_put_atom term_t, to_atom
+    rv == 1 or raise "can't create atom from #{self}"
+    term_t
+  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}"
+  end
+end
+
+class Symbol
+  def to_atom
+    Upl::Extern.PL_new_atom to_s
+  end
+end
+
+module Inter
+end

data/lib/upl/runtime.rb

@@ -0,0 +1,183 @@
+require 'fiddle'
+
+require_relative 'extern'
+
+class Fiddle::Pointer
+  def term_type
+    ::Upl::Extern.PL_term_type self
+  end
+
+  def type_string
+    type_int = term_type
+    ::Upl::Extern.constants.find{|c| (::Upl::Extern.const_get c) == type_int}
+  end
+end
+
+module Upl
+  module Runtime
+    Ptr = Fiddle::Pointer
+
+    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]
+
+      # convert args to char **
+      ptr_size = Extern.sizeof 'char*'
+      arg_ptrs = Ptr.malloc(ptr_size * args.size)
+      args.each_with_index do |rg,i|
+        (arg_ptrs + i*ptr_size)[0,ptr_size] = Ptr[rg].ref
+      end
+
+      # call init
+      rv = Extern.PL_initialise args.size, arg_ptrs
+      rv == 1 or raise 'PL_initialise failed'
+    end
+
+    # once_only. Should probably be a singleton or something.
+    @inited ||= init
+
+    def self.predicate name, arity, module_name = nil
+      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
+    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
+
+      # 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)
+    end
+
+    def self.unify( term_a, term_b )
+      rv = Extern::PL_unify term_a.term_t, term_a.term_t
+      rv == 1 or raise "can't unify #{term_a} and #{term_b}"
+    end
+
+    # do a query for the given term and vars, as parsed by term_vars
+    def self.term_vars_query qterm, qvars
+      raise "not a term" unless Term === qterm
+      return enum_for __method__,  qterm, qvars 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
+
+        # module is NULL, flags is 0
+        query_id_p = Extern.PL_open_query Extern::NULL, 0, qterm.to_predicate, terms_ptr
+        query_id_p != 0 or raise 'no space on environment stack, see SWI-Prolog docs for PL_open_query'
+
+        loop do
+          # TODO handle PL_Q_EXT_STATUS
+          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
+
+            # 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
+            # binding.pry if val.to_sym == :query_debug_settings rescue false
+          end
+
+          yield hash
+        end
+
+      ensure
+        query_id_p&.to_i and Extern.PL_close_query query_id_p
+      end
+
+    ensure
+      # this also gets called after enum_for, so test for fid_t
+      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 = []
+
+      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)
+
+        break unless res == 1
+
+        rv << (elt_converter.call head)
+        lst = rst
+      end
+
+      rv
+    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
+
+      answer_lst = Extern.PL_new_term_refs arity
+      query_id_p = Extern.PL_open_query Extern::NULL, 0, p_predicate, answer_lst
+
+      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
+      end
+
+    ensure
+      # NOTE this also gets called after enum_for
+      query_id_p&.to_i and Extern.PL_close_query query_id_p
+    end
+  end
+end

data/lib/upl/term.rb

@@ -0,0 +1,132 @@
+module Upl
+  # So Prolog terms are a rose tree. Who woulda thunkit?
+
+  # OK, so I guess this thing's job is interacting with term_t, whereas Tree's
+  # job is being a ruby copy of a term-tree.
+  class Term
+    def initialize term_or_string
+      case term_or_string
+      when String
+        raise "can't do strings yet"
+        # PL_chars_to_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
+
+    def self.of_atom atom
+      term_t = Extern.PL_new_term_ref
+      rv = Extern.PL_put_atom term_t, atom.to_atom
+      rv == 1 or raise "can't set term to atom #{atom}"
+      term_t
+    end
+
+    # args are things that can be converted to term_t pointers using to_term 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
+      end
+
+      term_t = Extern.PL_new_term_ref
+      rv = Extern.PL_cons_functor_v term_t, functor_t, arg_terms
+      rv == 1 or raise "can't populate functor #{name}"
+
+      new term_t
+    end
+
+    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
+
+      @arity = int_ptr.ptr.to_i
+      @atom = Atom.new atom_ptr
+
+      self
+    end
+
+    def == rhs
+      @atom == rhs.atom && @arity == rhs.arity && args == rhs.args
+    end
+
+    def <=> rhs
+      [@atom, @arity] <=> [rhs.atom, rhs.arity]
+    end
+
+    # attr_reader :atom, :arity
+
+    def atom
+      @atom or begin
+        populate
+        @atom
+      end
+    end
+
+    def arity
+      @arity or begin
+        populate
+        @arity
+      end
+    end
+
+    def to_functor
+      Extern::PL_new_functor atom.atom_ptr, arity
+    end
+
+    def to_predicate
+      Extern::PL_pred to_functor, Extern::NULL
+    end
+
+    def tree; @tree || (Tree.new self) end
+    def to_ruby; tree end
+
+    # 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
+      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
+      end
+    end
+
+    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
+      rv == 1 or raise "can't set index #{idx}"
+    end
+
+    def pretty_print(pp)
+      # to_ruby.pretty_print pp
+      pp.text atom.to_s
+      pp.text ?/
+      pp.text arity.to_s
+    end
+  end
+end

data/lib/upl/tree.rb

@@ -0,0 +1,119 @@
+module Upl
+  # Convert a term into a tree of ruby objects. This is necessary because
+  # queries give back their results as terms which are invalidated as soon as
+  # the next set of results is calculated. So we need to turn those terms into a
+  # ruby representation and keep them around.
+  class Tree
+    # term is either a Term instance, or a Fiddle::Pointer to a term_t
+    def initialize( term )
+      init term
+    end
+
+    def init term
+      case term
+      when Term
+        @atom = term.atom
+        @args = term.args.map do |arg|
+          self.class.term_to_ruby arg
+        end
+      when Fiddle::Pointer
+        init Term.new term
+      end
+    end
+
+    attr_reader :atom, :args
+
+    def self.of_term term_t
+      term_to_ruby term_t
+    end
+
+    def self.term_to_ruby term
+      case term.term_type
+      when Extern::PL_VARIABLE
+        Variable.copy term
+
+      when Extern::PL_ATOM
+        atom = Atom.of_term term
+        if atom.to_s =~ /^ruby-(\d+)/
+          ObjectSpace._id2ref $1.to_i
+        else
+          atom
+        end
+
+      when Extern::PL_INTEGER
+        Extern.PL_get_integer term, (int_ptr = Fiddle::Pointer[0].ref)
+        int_ptr.ptr.to_i
+
+      when Extern::PL_STRING
+        rv = Extern.PL_get_string term, (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
+
+      when Extern::PL_NIL
+        # TODO maybe this should be [] - see what happens when term_vars has no vars
+        # although nil.to_a == []
+        nil
+
+      when Extern::PL_TERM
+        Tree.new term
+
+      when Extern::PL_LIST_PAIR
+        list_to_ary term
+
+      end
+    end
+
+    def self.list_to_ary lst
+      rv = []
+
+      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)
+
+        break unless res == 1
+
+        rv << (term_to_ruby head)
+        lst = rst
+      end
+
+      rv
+    end
+
+    def arity; args.size end
+
+    def pretty_print(pp)
+      unless atom == :','
+        pp.text atom.to_s
+        if arity > 0
+          pp.text ?/
+          pp.text arity.to_s
+        end
+      end
+
+      if arity > 0
+        pp.group 1, ?(, ?) do
+          args.each_with_index do |ruby_term,i|
+            ruby_term.pretty_print pp
+            pp.text ?, if i < arity - 1
+          end
+        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

@@ -0,0 +1,61 @@
+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
+    end
+
+    attr_reader :term_t
+
+    def self.copy term_t
+      inst = new term_t
+
+      inst.attributed? and inst.attribute
+      inst.to_s
+
+      inst
+    end
+
+    # bit of a hack to create empty variables for a functor
+    def self.to_term
+      new
+    end
+
+    def to_s; _string end
+
+    def _string
+      @_string ||= begin
+        Extern::PL_get_chars \
+          term_t,
+          (str_ref = Runtime::Ptr[''].ref),
+          Extern::Convert::CVT_VARIABLE | Extern::Convert::REP_UTF8 | Extern::Convert::BUF_MALLOC # | Extern::CVT_ALL
+
+        str_ref.ptr.to_s
+      end
+    end
+
+    def attributed?
+      if instance_variable_defined? :@attributed
+        @attributed
+      else
+        @attributed = (Extern::PL_is_attvar term_t) == 1
+      end
+    end
+
+    def attribute
+      @attribute ||= begin
+        rv = Extern::PL_get_attr term_t, (val = Extern.PL_new_term_ref)
+        rv == 1 or raise "can't get attribute for variable"
+        Tree.of_term val
+      end
+    end
+
+    def pretty_print pp
+      if attributed?
+        attribute.pretty_print pp
+      else
+        pp.text to_s
+      end
+    end
+  end
+end

data/lib/upl/version.rb

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

data/upl.gemspec

@@ -0,0 +1,38 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'upl/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'upl'
+  spec.version       = Upl::VERSION
+  spec.authors       = ['John Anderson']
+  spec.email         = ['panic@semiosix.com']
+
+  spec.summary       = %q{Access SWI-Prolog engine from ruby}
+  spec.description   = %q{Access SWI-Prolog engine from ruby}
+  spec.homepage      = 'https://github.com/djellemah/upl'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = 'https://rubygems.org'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.'
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  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_dependency 'pry'
+  spec.add_dependency 'fiddle'
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: upl
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- John Anderson
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-09-13 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
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fiddle
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Access SWI-Prolog engine from ruby
+email:
+- panic@semiosix.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/upl.rb
+- lib/upl/atom.rb
+- lib/upl/extern.rb
+- lib/upl/functor.rb
+- lib/upl/inter.rb
+- lib/upl/runtime.rb
+- lib/upl/term.rb
+- lib/upl/tree.rb
+- lib/upl/variable.rb
+- lib/upl/version.rb
+- upl.gemspec
+homepage: https://github.com/djellemah/upl
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: Access SWI-Prolog engine from ruby
+test_files: []