prolog.cpp

#include <cassert>
#include <cstdlib>
#include <iostream>
#include <unistd.h>
#include <vector>

#include <SWI-Prolog.h>
#include <SWI-Stream.h>

#include "base.hpp"
#include "config.h"
#include "prolog.hpp"

namespace
{
  // RAII class for foreign frames
  class Frame
  {
    fid_t fid;

public:
    Frame() : fid(PL_open_foreign_frame()) {}
    ~Frame() { PL_close_foreign_frame(fid); }
  };

  inline void put_term(term_t term, std::string const &pred)
  {
    auto rv = PL_put_term_from_chars(term, 0, pred.size(), pred.data());
    if (!rv)
    {
      std::cerr << "Invalid term: " << pred << std::endl;
      abort();
    }
  }

  bool consult_file(std::string filename)
  {
    Frame fid{}; /* All created terms will go away when
                  * fid goes out of scope */

    /* Create a single term */
    term_t term = PL_new_term_ref();
    /* Fill it with a predicate */
    put_term(term, "consult(\"" + filename + "\")");
    /* Run the query */
    auto succeed = PL_call(term, nullptr);
    if (!succeed)
    {
      std::cerr << "Could not consult file" << std::endl;
      PL_halt(EXIT_FAILURE);
    }
    return succeed;
  }

  void initialize_helper()
  {
    static bool init = false;

    if (!init)
    {
      std::vector<const char *> args = {"dummy", "--quiet=true", "--threads=false"};
      auto rv = PL_initialise(args.size(), const_cast<char **>(args.data()));
      if (!rv)
      {
        std::cerr << "Could not start SWIPL" << std::endl;
        exit(EXIT_FAILURE);
      }

      init = true;
    }
  }
}; // namespace

// Initialize prolog before main
namespace
{
#ifdef PHAROS_RULES_DIR
  static auto dummy = (initialize_helper(), consult_file(PHAROS_RULES_DIR "/setup.pl"), true);
#endif
}; // namespace

namespace Prolog
{

  bool run_prolog(std::string filename, std::string query_string)
  {
    initialize_helper();

    consult_file(filename);

    {

      Frame fid{}; /* All created terms will go away when
                    * fid goes out of scope */

      /* Create a single term */
      term_t term = PL_new_term_ref();
      put_term(term, query_string);
      bool succeed = PL_call(term, nullptr);
      return succeed;
    }
  }

  bool run_prolog(std::string const &prolog_data, std::string const &streamname,
                  std::string const &query_string)
  {
    initialize_helper();

    {
      Frame fid{}; /* All created terms will go away when
                    * fid goes out of scope */

      term_t term = PL_new_term_ref();
      char *buffer = const_cast<char *>(prolog_data.data());
      size_t size = prolog_data.size();

      {
        Frame fid_t{};

        term_t terms = PL_new_term_refs(5);
        term_t stream = terms + 0;
        term_t name = terms + 1;
        PL_put_atom(name, PL_new_atom(streamname.c_str()));
        // Name -> atom of name

        PL_unify_stream(stream, Sopenmem(&buffer, &size, "r"));
        // Stream -> pipe stream
        term_t stream_opt = terms + 2;
        functor_t stream_functor = PL_new_functor(PL_new_atom("stream"), 1);
        [[maybe_unused]] int rv;
        rv = PL_cons_functor(stream_opt, stream_functor, stream);
        // StreamOpt -> stream(Stream)
        term_t nil = terms + 3;
        PL_put_nil(nil);
        // Nil -> []
        term_t opts = terms + 4;
        rv = PL_cons_list(opts, stream_opt, nil);
        // Opts -> [StreamOpt]
        functor_t lf_functor = PL_new_functor(PL_new_atom("load_files"), 2);
        rv = PL_cons_functor(term, lf_functor, name, opts);
        // Term -> load_files(Name, Opts)
      }
      /* Run the query */
      auto succeed = PL_call(term, nullptr);
      if (!succeed)
      {
        std::cerr << "Could not consult file" << std::endl;
        PL_halt(EXIT_FAILURE);
      }
      put_term(term, query_string);
      succeed = PL_call(term, nullptr);
      return succeed;
    }
  }

  std::vector<coverage_entry> run_prolog_with_coverage(std::string const &prolog_data,
                                                       std::string const &streamname,
                                                       std::string const &query_string)
  {
    initialize_helper();

    std::vector<coverage_entry> out;

    {
      Frame fid{}; /* All created terms will go away when
                    * fid goes out of scope */

      term_t term = PL_new_term_ref();
      term_t inner_term = PL_new_term_ref();
      char *buffer = const_cast<char *>(prolog_data.data());
      size_t size = prolog_data.size();

      {
        Frame fid_t{};

        term_t terms = PL_new_term_refs(5);
        term_t stream = terms + 0;
        term_t name = terms + 1;
        PL_put_atom(name, PL_new_atom(streamname.c_str()));
        // Name -> atom of name

        PL_unify_stream(stream, Sopenmem(&buffer, &size, "r"));
        // Stream -> pipe stream
        term_t stream_opt = terms + 2;
        functor_t stream_functor = PL_new_functor(PL_new_atom("stream"), 1);
        [[maybe_unused]] int rv;
        rv = PL_cons_functor(stream_opt, stream_functor, stream);
        // StreamOpt -> stream(Stream)
        term_t nil = terms + 3;
        PL_put_nil(nil);
        // Nil -> []
        term_t opts = terms + 4;
        rv = PL_cons_list(opts, stream_opt, nil);
        // Opts -> [StreamOpt]
        functor_t lf_functor = PL_new_functor(PL_new_atom("load_files"), 2);
        rv = PL_cons_functor(term, lf_functor, name, opts);
        // Term -> load_files(Name, Opts)
      }
      /* Run load_files */
      auto succeed = PL_call(term, nullptr);
      if (!succeed)
      {
        std::cerr << "Could not consult file" << std::endl;
        PL_halt(EXIT_FAILURE);
      }

      {
        Frame fid_t{};
        term_t terms = PL_new_term_refs(6);
        predicate_t cov_pred = PL_predicate("get_coverage", 6, NULL);
        if (!cov_pred)
        {
          std::cerr << "Could not find get_coverage/6" << std::endl;
          PL_halt(EXIT_FAILURE);
        }

        put_term(terms + 0, query_string);

        qid_t qid = PL_open_query(NULL, PL_Q_NORMAL | PL_Q_EXT_STATUS, cov_pred, terms);
        if (!qid)
        {
          std::cerr << "Unable to open query" << std::endl;
          PL_halt(EXIT_FAILURE);
        }

        int rv;
        bool continue_loop = true;
        while (continue_loop)
        {
          rv = PL_next_solution(qid);
          switch (rv)
          {
          case PL_S_EXCEPTION:
            std::cerr << "Exception" << std::endl;
            abort();
            PL_halt(EXIT_FAILURE);
            break;
          case PL_S_FALSE:
            std::cerr << "Query failed: " << query_string << std::endl;
            PL_halt(EXIT_FAILURE);
            break;
          case PL_S_TRUE:
          case PL_S_LAST:

            const auto get_string_from_prolog = [](const term_t &term)
            {
              size_t len;
              char *s;
              int rv = PL_get_string_chars(term, &s, &len);
              if (rv)
              {
                return std::string(s, len);
              }
              else
              {
                rv = PL_get_atom_chars(term, &s);
                assert(rv);
                return std::string(s);
              }
              abort();
            };

            const auto get_size_from_prolog = [](const term_t &term)
            {
              uint64_t sz;
              assert(PL_get_uint64(term, &sz));
              return sz;
            };

            coverage_entry cov;

            cov.file = get_string_from_prolog(terms + 1);
            cov.predicate = get_string_from_prolog(terms + 2);
            cov.line = get_size_from_prolog(terms + 3);
            cov.pos = get_size_from_prolog(terms + 4);
            cov.neg = get_size_from_prolog(terms + 5);

            out.push_back(cov);

            if (rv == PL_S_LAST)
              continue_loop = false;

            break;
          }
        }
        PL_close_query(qid);
      }

      return out;
    }
  }

} // namespace Prolog