---

GrammarManager.cpp

Go to the documentation of this file.

#define TRACE_NAME "GrammarManager"
extern "C" {
#include <stdio.h>
#include <dlfcn.h>
#include "ebnf.h"
#include "abstract_grammar.h"
}
#include "GrammarManager.h"
#include "YaccGeneratedParser.h"

//
//  Standard Member Functions
//

GrammarManager::GrammarManager()
{
    // blank default    
}

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

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

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

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

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

size_t GrammarManager::hash() const
{
    NOT_IMPLEMENTED
}

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

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

//
//  Additional Public Member Functions
//

Parser* GrammarManager::obtainParser(std::string name)
{
    //
    // prepare input stream & parse it
    //
    std::string::size_type pos = name.find(':');
    std::string scheme;
    std::string rest;
    if (pos == std::string::npos) {
    scheme = "file";
    rest = name;
    } else {
    scheme = name.substr((unsigned) 0,pos-1);
    rest = name.substr(pos+1);
    } 

    Grammar* grammar = 0;
    if (scheme == "file") {
    NOT_IMPLEMENTED;
    grammar = parse_file(rest.c_str());
    } else {
    die("Only 'file:' URIs are currently implemented.");
    }

#if 0
    //
    // write grammar to the file
    //
    char *grammar_file = tempnam(0, "bnf.");
    if (!grammar_file) die("can't generate unique filename");
    FILE *f = fopen(grammar_file, "w");
    if (!f) { perror(grammar_file); die("can't open temp file"); }
    print_grammar(f, grammar);
    fclose(f);

    // 
    // call compiler
    //
    std::string command;
    std::string library_file = grammar_file;
    library_file.append(".so");

    char *prog = getenv("BLINDFOLD_GRAMMAR_COMPILER");
    if (prog) {
    command.append(prog);
    } else {
    command.append("blindfold_grammar_compiler");
    }
    command.append(" ");
    command.append(grammar_file);
    command.append(" ");
    command.append(library_file);

    int rc = system(command.c_str());
    if (rc != 0) die("grammar compiler failed.");
    
    //
    // dynamicly load generated code
    //
    // (alternatively, we could run it on a pipe, or
    // have generated the tables in our own memory.)
    //
    putenv("LD_LIBRARY=.");    /* or LD_LIBRARY_PATH? */
    void* lib = dlopen(library_file.c_str(), RTLD_NOW);
    if (!lib) {
    fprintf(stderr, "Error loading newly-compiled parser:\n  ");
    fputs (dlerror(), stderr);
    fputs("\n", stderr);
    exit(1);
    }

    // should we look for both C and C++ versions?  nah, we compiled it.
    void* entry_point = dlsym(lib, "generated_parser__FP17TripleSinkReifierPc");
    char *error;
    if ((error = dlerror()) != NULL)  {
    fprintf(stderr, "Error linking with newly-compiled parser:\n  ");
    fputs(error, stderr);
    fputs("\n", stderr);
    exit(1);
    }

    // ISO C++ doesn't seem to allow this, even with reinterpret_cast ?!
    // so I do it this way:
    parse_function ep = (parse_function) entry_point;

    std::cerr <<  "New parser generated, compiled, and loaded.\n";
    std::cerr.flush();

    return new YaccGeneratedParser(ep);
#else
    return 0;
#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.