---

NTriplesParser.cpp

#define TRACE_NAME "NTriplesParser"
#include "config.h"
#include "NTriplesParser.h"
#include "ntriples.h"
#include "Triple.h"
#include "TripleSink.h"
#include "VariableScope.h"

NTriplesParser* ntriples_parser = 0;

//
//  Standard Member Functions
//

NTriplesParser::NTriplesParser()
    : line(1)
{
    // blank default    
}

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

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

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

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

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

size_t NTriplesParser::hash() const
{
    NOT_IMPLEMENTED
}

std::ostream& NTriplesParser::print_to(std::ostream& stream) const
{
    NOT_IMPLEMENTED
}

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

//
//  Additional Public Member Functions
//

#ifdef STREAMING

// we want a way to tell the Symbol() it should own allocated char* ...

void NTriplesParser::write(const void* byteBuffer, size_t numBytes)
{
    const char* end = byteBuffer+numBytes;
    const char* text = 0;
    for (const char *p = byteBuffer; p<end; ++p) {
    switch (state) {
    case START:
        switch(*p) {
        case '\n':
        line++;
        case ' ':
        case '\r':
        case '\t':
        case '.':
        break;
        case '#': 
        state = IN_COMMENT;
        break;
        case '<':
        state = IN_URI;
        break;
        case '_':
        state = GOT_UNDERLINE;
        break;
        case '"':
        state = IN_STRING;
        default:
        ERROR("unexpected character outside of a term");
        }
        break;
    case IN_COMMENT:
        switch(*p) {
        case '\n':
        line++;
        state = START;
        break;
        default:
        // everything else okay in comments
        break;
        }
        break;
    case GOT_UNDERLINE:
        switch(*p) {
        case ':':
        state = IN_VAR;
        break;
        default:
        ERROR("expecting : after _");
        state = START;
        break;
        }
        break;
    case IN_URI:
        if (!text) text = p;
        switch(*p) {
        case '>':
        NEW_CONSTANT;     // combine fifo text and text-p, neither null-terminated
        state = START;
        break;
        case '(':  case ')':  
        case '[':  case ']':
        case '{':  case '}':
        case '<':  case ' ':
        case '\'':  case '"':
        ERROR("illegal char in URI refernce");
        break;
        default:
        // perhaps we should explicitely list URIC; also more syntax checking?
        break;
        }
        break;
    case IN_VAR:
        if (!text) text = p;
        switch(*p) {
        case ' ':
        NEW_VARIABLE;
        state = START;
        break;
        case '(':  case ')':  
        case '[':  case ']':
        case '{':  case '}':
        case '<':  case '>':
        case '\'':  case '"':
        ERROR("illegal char in QName");
        break;
        default:
        // perhaps we should explicitely list them?
        break;
        }
        break;
    case IN_STRING:

        break;
    }
    }
    if (text) {
    fifo.write(text, (end-text));
    }
}

#else

void NTriplesParser::write(const void* byteBuffer, size_t numBytes)
{
    fifo.write(byteBuffer, numBytes);
}
#if EXTERNAL

void NTriplesParser::close()
{
    if (ntriples_parser) die("re-entrant use of NTriplesParser");
    ntriples_parser = this;
    if (!ntriples_parse()) {
    // should throw exception
    std::cout << "parse failed?";
    }
    ntriples_parser = 0;
}
#else

Symbol NTriplesParser::getSym(char*& p, VariableScope* scope) 
{
    Symbol::Type type;
    char* start;
    for ( ; *p; ++p) {
    switch (*p) {
    case '\n':
        line++;
    case ' ':
    case '\r':
    case '\t':
    case '.':
        break;
    case '#': {
        for ( ; *p; ++p) {
        if (*p == '\n') break;
        }
        break;
        line++;
    }
    case '_': {
        start = ++p;
        if (*start++ != ':') {
        std::cerr << "_ not followed by :" << " on line " << line << std::endl;
        exit(2);
        }
        type = Symbol::VARIABLE;
        for ( ; *p; ++p) {
        switch (*p) {
        case ' ':
        case '.':
            *p++ = '\0';
            return scope->getVar(start);
        case '\n':
            line++;
        case '\r':
        case '"':
        case '\'':
        case '{':
        case '}':
            std::cerr << "Invalid character in QName on line " << line << std::endl;
            exit(2);
        default:
            break;
        }
        }
    }

    case '<': {
        start = ++p;
        type = Symbol::CONSTANT;
        if (start[0] == '_' && start[1] == ':') {
        start += 2;
        type = Symbol::VARIABLE;
        exit(2);
        }
        for ( ; *p; ++p) {
        switch (*p) {
        case '>':
            *p++ = '\0';
            return Symbol(type, start);
        case '\n':
            line++;
        case ' ':
        case '\r':
        case '"':
        case '\'':
        case '{':
        case '}':
            std::cerr << "Invalid character in URI-Reference: '" <<
            *p << "' (ascii " << static_cast<int>(*p) << ")" << " on line " << line << std::endl;

            exit(2);
        default:
            break;
        }
        }
    }
    case '"': {
        char* start = ++p;
        for ( ; *p; ++p) {
        switch (*p) {
        case '"':
            *p++ = '\0';
            return Symbol(Symbol::LITERAL, start);
        case '\\':
            // needs a copy-to buffer thing
            std::cerr << "back-slash Escapes not yet implemented.   Used on line" << line << std::endl;
            exit(2);
        }
        }
    }

    default:
        std::cerr << "Invalid character: '" << *p << "', " << (int) *p << " on line " << line << std::endl;
        exit(2);
    }
    }
    return Symbol::null;
    }

void NTriplesParser::close()
{
    fifo.write("", 1);
    TRACE "** Parsing to scope ";
    if (TRACING) scopeForSink->print_to(TRACEOUT);
    TRACE std::endl;
    // we need it for adding, but we don't WANT to merge here, ... or do we...?
    for (char *p = (char*) fifo.peek(); *p; p++) {
    Triple t;
    for (int i=0; i<3; i++) {
        t.set(i, getSym(p, scopeForSink));
    }
    if (t) getSink()->add(t);
    //std::cout << "Triple " << t << " is " << (t?"true":"false") << std::endl;
    } 
}

#endif
#endif

//
//  Additional Private Member Functions
//

#undef TRACE_NAME

---

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