---

XSBAgent.cpp

#define TRACE_NAME "XSBAgent"
#include "XSBAgent.h"
// $Id: XSBAgent_8cpp-source.html,v 1.5 2001/10/10 20:40:58 sandro Exp $
#include "XSBQuery.h"
#include "FlowManager.h"
#include "XSBPool.h"

#include <stdlib.h>
#include <fstream>
#include <sstream>
#include <cstdio>


//
//  Standard Member Functions
//

static void ensure_file(const char* filename,
            const char* text)
{
    std::ifstream in(filename);

    if (in.good()) {
    const char *p = text;
    while (true) {
        char c;
        in.get(c);
        if (in.eof()) { c = '\0'; }
        if (*p != c) {
        TRACE "File " << filename << " has the wrong char (" 
                  << *p << " != " << c << ") at position " 
                  << (p-text) << "; correcting." << endl;
        break;
        } 
        if (*p == '\0') return;
        ++p;
    }
    }

    std::ofstream out(filename);
    out << text;
}

static void write_c_support() 
{
    ensure_file("/tmp/blindfold_xsb_support.c", 
        "#include <stdio.h>\n"
        "#define TRUE 1\n"
        "\n"
        "extern int blindfold_xsb_status;\n"
        "int blindfold_xsb_status = -1;\n"
        "\n"
        "void set_status_c(int status)\n"
        "{\n"
        "    //   We DONT need to do a high-water thing, because XSB will\n"
        "    //   not call this again during backtracking.\n"
        "    // if (status > blindfold_xsb_status) \n"
        "    blindfold_xsb_status = status;\n"
        "    // printf(\"status reported as: %d\\n\", status);\n"
        "}\n"
        "\n"
        "void get_status_c(int* ii)\n"
        "{\n"
        "    *ii = blindfold_xsb_status;\n"
        "    // blindfold_xsb_status = -1;\n"
        "}\n");
        
    ensure_file("/tmp/blindfold_xsb_support.H",
        "%\n"
        " \n"
        ":- foreign_pred set_status(+a) from\n"
        "                set_status_c(a:int):void.\n"
        "\n"
        ":- foreign_pred get_status(-a) from\n"
        "                get_status_c(a:intptr):void.\n");
}

XSBAgent::XSBAgent()
    : predicateCounter(0),
      currentQuery(0)
{
    out = FlowManager::main.streamThrough("x-shell:", *this, true);
    write_c_support();
    if (TRACING) {
    *out << "cd /tmp; xsb -e \"['/tmp/blindfold_xsb_support'].  put(5).\";echo '~'\n";
    } else {
    *out << "cd /tmp; xsb --nobanner --quietload --noprompt -e \"['/tmp/blindfold_xsb_support'].  put(5).\";echo '~'\n";
    }
    waitingForAck = true;
    while (waitingForAck) FlowManager::main.run();
}

#if 0  /* omit definitions until they are implemented */

XSBAgent::XSBAgent(const XSBAgent& other)
{
    NOT_IMPLEMENTED
}

const XSBAgent& XSBAgent::operator=(const XSBAgent& other)
{
    NOT_IMPLEMENTED
}

bool XSBAgent::operator==(const XSBAgent& other) const
{
    NOT_IMPLEMENTED
}

bool XSBAgent::operator<(const XSBAgent& other) const
{
    NOT_IMPLEMENTED
}

size_t XSBAgent::hash() const
{
    NOT_IMPLEMENTED
}

ostream& XSBAgent::print_to(ostream& stream) const
{
    NOT_IMPLEMENTED
}

#endif /* omit definitions until they are implemented */
    
XSBAgent::~XSBAgent()
{
    // blank default    
}

//
//  Private Classes
//


//
//  Additional Public Member Functions
//

QueryablePool* XSBAgent::newQueryablePool(VariableScope* scope = 0)
{
    return new XSBPool(*this, scope);
}


#if 0
Query* XSBAgent::getQuery(TripleSource* pattern, TripleSource* dataset)
{
    XSBQuery* m = new XSBQuery(this, pattern, dataset);
    currentQueryer = m;
    FlowManager::main.run();
    return m;
}
#endif

std::ostream* XSBAgent::getFile(char** fileNameBuffer)
{
    *fileNameBuffer = strdup("/tmp/blindfold_XXXXXX");
    int fd = mkstemp(*fileNameBuffer);
    assert(fd >= 0);
    return new std::fstream(fd);
}

std::string XSBAgent::getNewPredicate()
{
#if 0
    std::string result;
    {
    std::ostringstream ss(result);
    ss << "auto" << predicateCounter++;
    }
    std::cout << "Generated name " << result << "\n";
    return result;
#endif
    char buf[80];
    sprintf(buf, "auto%02d", predicateCounter++);
    return std::string(buf);
}

// this is all kind of stupid -- it should be using our parser
// system!!!
void XSBAgent::write(const void* byteBuffer, size_t numBytes)
{
    char* end;
    if (waitingForAck) {
    TRACE "XSB waiting for ACK or NACK" << endl;
    // is there a ascii 5 or 126 in the buffer yet?

    end = static_cast<char*>(memchr(byteBuffer, 5, numBytes));
    if (end) {
        waitingForAck = false;
        TRACE "XSB is working." << endl;
        FlowManager::main.returnFromRun();
        return;
    }

    end = static_cast<char*>(memchr(byteBuffer, 126, numBytes));
    if (end) {
        std::cerr << "Unable to run 'xsb'.   It must be in your path." << endl;
        exit(2);
    }

    TRACE "...not yet.   Hmmm." << endl;
    return;
    }

    TRACE "XSB Output " << numBytes << " chars\n";
    buffer.write(byteBuffer, numBytes);

    // is there a ctl-D in the buffer yet?
    end = static_cast<char*>(memchr(buffer.peek(), 4, buffer.size()));
    if (!end) return;
    *end = '\0';

    char* start = static_cast<char*>(memchr(buffer.peek(), 1, buffer.size()));
    TRACE "Parsing buffer: *****" << start << "*****\n";
    assert(start);
    start++;
    
    char* delim;
    while (*start) {
    TRACE "trying to convert \"" << start << "\"\n";
    long int value = strtol(start, &delim, 10);
    if (delim != start) {
        TRACE "got a value! (" << value << ")\n";
        currentQuery->handleValue(value);
    }
    start = delim+1;
    }

    currentQuery->handleValue(-1);
    buffer.skip(end-static_cast<char*>(buffer.peek()));

    // really just signal THIS part is done, but....?
    FlowManager::main.returnFromRun();
}

void XSBAgent::shutdown() {
    *out << "halt.\n";
    FlowManager::main.runPending();
//    *out << "exit\n";
//    FlowManager::main.runPending();
}

//
//  Additional Private Member Functions
//

void XSBAgent::sync() {
    std::list<XSBPool*>::iterator i;
    for (i=pools.begin(); i != pools.end(); ++i) {
    (*i)->sync();
    }
}
#undef TRACE_NAME

---

Home to blindfold. This page generated via doxygen 1.2.11.1 Wed Oct 10 16:40:33 2001.