vos/corelibs/typechain/typechain.cc

Go to the documentation of this file.

/* $Id: typechain.cc,v 1.32 2003/07/24 16:12:05 reed Exp $ */

/*
    This file is part of the Virtual Object System of
    the Interreality project (http://interreality.org).

    Copyright (C) 2001, 2002 Reed Hedges <reed@zerohour.net>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
*/

#include <sys/types.h>

#include <errno.h>
#include <sys/stat.h>
#include <string.h>
#include <dirent.h>

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif


#include <stdarg.h>

#include <string>
#include <map>
#include <vector>
#include <list>
#include <iostream>

#include <pluginloader/plugins.hh>

#include "typechain.hh"
#include "typehandler.hh"

#include "tclexer.hh"

// a macro for debugging (e.g.: "make typechain CPPFLAGS+=-DLOGLEV=3")

#if !defined(LOGLEV)
#define LOGLEV  2
#else
//#warning Using predefined LOGLEV.
#endif

#define LOG(c, l, m)    if (l <= LOGLEV) std::clog << c << ": " << m << endl;


/* A lexer which decodes as it scans */
class DecodingTCLexer : public TypechainLexer {
protected:
    // these store state only for the course of one call to decode or
    // encode.
    string* datap;
    string finaltype;
    map<string,string> finalparams;

    void complete_token(string token, map<string, string> params) ;
    void final_type(string type, map<string, string> params);


public:
    DecodingTCLexer(const string& t);
    string decode(string& data, map<string,string>& params) ;
};

/* A lexer which encodes as it scans */
class EncodingTCLexer : public TypechainLexer {
protected:
    // these store state only for the course of one call to decode or
    // encode.
    string* datap;
    string finaltype;
    map<string, string> finalparams;
    void complete_token(string token, map<string, string> params);
    void final_type(string type, map<string, string> params);
public:
    EncodingTCLexer(const string& t);
    void encode(string& data, map<string, string>& params);
};


    /* TODO lexer which encodes as it scans (needs a reversed typechain string!) */



/* A lexer that makes a string of abbreviated type identifiers as it scans, for file names (used by makeFilename) */
class FilenameTCLexer : public TypechainLexer {
protected:
    string filename;
    void complete_token(string token, map<string, string> params) ;
    void final_type(string type, map<string, string> params) ;
public:
    FilenameTCLexer(string t) : TypechainLexer(t) {
    }
    string makeExtensions() ;
};


/* The lexer that decodes */

DecodingTCLexer::DecodingTCLexer(const string& t) :
    TypechainLexer(t), datap(0) { }

string DecodingTCLexer::decode(string& targetdata, map<string,string>& params)  {
    datap = &targetdata;
    LOG("DecodingTCLexer::decode", 5, "parsing data...");
    yylex();
    LOG("DecodingTCLexer::decode", 5, "done parsing data. final type is " << finaltype);
    params = finalparams;
    //targetdata = *datap;
    return finaltype;
}

void DecodingTCLexer::complete_token(string token, map<string,string> params)  {
    if( (token != "") && (token != "type") && (token != "?") )    // type is to be ignored.
    {
        if (TypeChain::handlers.find(token) == TypeChain::handlers.end()) {
            throw TypeChain::DecodeError("No handler found", token);
        }


        LOG("TypeChain decoding lexer", 5, "decoding data of type " << token << "...");
        TypeChain::handlers[token]->decode(*datap, params);
    }
}

void DecodingTCLexer::final_type(string token, map<string,string> params) {
    finaltype = token;
    finalparams = params;
}


/* The encoding lexer */

EncodingTCLexer::EncodingTCLexer(const string& t) :
    TypechainLexer(t), datap(0) { }

void EncodingTCLexer::encode(string& targetdata, map<string, string>& params) {
    datap = &targetdata;
    yylex();
    params = finalparams;
    //targetdata = *datap;
}

void EncodingTCLexer::complete_token(string token, map<string, string> params) {
    if( (token != "") && (token != "type") && (token != "?") )
    {
        if(TypeChain::handlers.find(token) == TypeChain::handlers.end()) {
            throw TypeChain::EncodeError("No handler found", token);
        }
        TypeChain::handlers[token]->encode(*datap, params);
    }
}

void EncodingTCLexer::final_type(string token, map<string, string> params) {
    finaltype = token;
    finalparams = params;
}




/* Static TypeChain class */

map<string,TypeHandler*> TypeChain::handlers;
map<string,string> TypeChain::filename_extensions;


void TypeChain::initialize() {
    TypeChain::registerHandler(new TypeHandler("identity"));
    Plugins::scanDir(TC_PLUGIN_DIR, "plugin_init", (void*)&TypeChain::registerHandler);
}


void TypeChain::initialize(const char *dirname, ...) {

    LOG("typechain", 4, "initialize: registering handler for identity");
    TypeChain::registerHandler(new TypeHandler("identity"));

    LOG("typechain", 4, "initialize: scanning directory with libplugins: " << dirname);

    Plugins::scanDir(dirname, "plugin_init", (void*)&TypeChain::registerHandler);

    va_list args;
    va_start(args, dirname);
    for(;;) {
        char* dir=va_arg(args, char*);
        if(dir == 0) break;
        LOG("typechain", 4, "initialize: scanning directory with libplugins: " << dir);
        Plugins::scanDir(dir, "plugin_init", (void*)&TypeChain::registerHandler);
    }
    va_end(args);

    LOG("typechain", 4, "initialize: scanning directory: " << TC_PLUGIN_DIR);
    Plugins::scanDir(TC_PLUGIN_DIR, "plugin_init", (void*)&TypeChain::registerHandler);
}

void TypeChain::uninitialize() {

    LOG("typechain", 3, "uninitialize: deleting handlers...");

    for( map<string, TypeHandler*>::iterator i = handlers.begin(); i != handlers.end(); i++) {
        LOG("typechain", 4, "removing handler for " << (*i).first);
        if( (*i).second != NULL )
            delete (*i).second;
        else
            LOG("typechain", 4, "handler was NULL. not deleted.");
        handlers.erase(i);
    }

    for( map<string, string>::iterator i = filename_extensions.begin(); i != filename_extensions.end(); i++) {
        filename_extensions.erase(i);
    }

    LOG("typechain", 3, "closing plugins...");

    Plugins::closeAll();
    LOG("typechain", 3, "done.");
}

string TypeChain::decode(string& data, const string& type, map<string,string>& params)  {
    LOG("typechain", 5, "TypeChain::decode: calling DecodingTCLexer.decode()");
    DecodingTCLexer lexer(type);
    return lexer.decode(data, params);
}




void TypeChain::encode(string& data, const string& type, map<string,string>& params) {
    EncodingTCLexer lexer(type);
    lexer.encode(data, params);
}


void TypeChain::registerHandler(TypeHandler* handler) {
    LOG("typechain", 3, "registering handler for " << handler->type_name);
    handlers[handler->type_name] = handler;
    filename_extensions[handler->filename_extension] = handler->type_name;
}



TypeHandler* TypeChain::removeHandler(const string& type) {
    TypeHandler* h;
    h = handlers[type];
    handlers.erase(type);
    return h;
}

void TypeChain::deleteHandler(const string& type) {
    TypeHandler* h;
    h = handlers[type];
    handlers.erase(type);
    delete h;
}

// does nothing.
inline string string_tolower(string s) {
    return s;
//  return string(  strlwr( s.c_str() )  );
}

string TypeChain::guessTypeFromFilename(const string& filename) {
    unsigned int oldpos, pos;
    string type;

    oldpos = filename.find('.') + 1;
    pos = filename.find('.', oldpos);
    while(pos != filename.npos) {
        type = ";" +  filename_extensions[ string_tolower( filename.substr(oldpos, (pos-oldpos)) ) ] + type;;
        pos = filename.find('.', oldpos);
        oldpos = pos + 1;
    }


    type.erase(0, 1); // the above loop causes the first char to always be '|'

    return type;
}


string TypeChain::makeFilename(const string& type, const string& basename) {
    FilenameTCLexer lex(type);
    return basename + lex.makeExtensions();
}

void FilenameTCLexer::complete_token(string token, map<string, string> params) {
    filename = "." + TypeChain::handlers[token]->filename_extension + filename;
}

void FilenameTCLexer::final_type(string type, map<string, string> params) {
    complete_token(type, params);
}

string FilenameTCLexer::makeExtensions() {
    filename = "";
    yylex();
    return filename;
}

/* lexer which counts the number of encodings */
class CountEncodingsLexer : public TypechainLexer {
protected:
    int n;
public:
    CountEncodingsLexer(string t) : TypechainLexer(t), n(0) {};
    void complete_token(string, map<string,string>) {
        n++;
    }
    void final_type(string /*type*/, map<string, string> /*params*/) { } 
    int count() {
        n = 0;
        yylex();
        return n;
    }
};

int TypeChain::countEncodings(const string& type) {
    CountEncodingsLexer lexer(type);
    return lexer.count();
}

---