vos/applibs/otd/otdutil.cc

Go to the documentation of this file.

/*  $Id: otdutil.cc,v 1.8 2003/07/24 16:12:00 reed Exp $

    Copyright (C) 2002 Reed Hedges <reed@interreality.org>

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

    This program 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 General Public License for more details.

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


/*  This code is partially based on the "outline.c" example distributed
    with expat. (debian: libexpat1-dev) 

    This code requires expat (debian: libexpat1, libexpat1-dev), and
    VOS core libs. 

    See otdutil.hh for documentation.

*/

#include "otdutil.hh"
#include <vos/corelibs/vos/vos.hh>

#ifdef HAVE_CONFIG_H
#include "vos_applibs_config.h"
#endif


#include <stdio.h>
#include <dirent.h>
#include <sys/stat.h>
#include <string.h>
#include <assert.h>
#include <map>
#include <deque>

#include <expat.h>

#ifndef S_ISDIR
#define S_ISDIR(x) (x & _S_IFDIR)
#endif

#ifndef S_ISREG
#define S_ISREG(x) (x & _S_IFREG)
#endif


namespace OTD {


#ifndef INSTALL_PREFIX
#    define INSTALL_PREFIX "/usr"
#endif

#define MAX_BUFF_SIZE   8192

// if this is true, then only files ending in ".otd" are scanned
static bool ONLY_DOT_OTD = true;

#define DEBUG(s)    {cerr << "OTDUTIL DEBUG: " << s << endl;}
//#define DEBUG(s)    {}
#define WARNING(s)  {cerr << "OTD Warning: " << s << endl;}
#define NOTIFY(s)   {cerr << "OTD: " << s << endl;}
#define ERROR(s)    {cerr << "OTD Error: " << s << endl;}


// struct that is attached to parser for access from handlers
typedef struct {
    deque<string>* types;
    XML_Parser parser;
    int stop;
    FILE* file;
    string filename;
    vRef<Vobject> object;
    vRef<Site> site;
} OTD_XML_Info ;

typedef struct  {
    FILE* file;
    string filename;
    deque<string> extends;
} OTD_Info;

// map all otd types -> types they extend
map<string, OTD_Info*> otds;


/* search & replace in string */
inline static void sreplace(string& s, const string& oldc, const string& newc) {
    string::size_type i = 0;
    while( (i = s.find(oldc, i)) != s.npos ) {
        s.replace(i, oldc.length(), newc);
    }
}
inline static void sreplace(string& s, char oldc, char newc) {
    string::size_type i = 0;
    while( (i = s.find(oldc, i)) != s.npos ) {
        s.replace(i, 1, 1, newc);
    }
}

/* split s on sep */
static deque<string> ssplit(const string& s, char sep, char esc = '\\', int max = -1) {
    string::size_type cur, start, found, last;
    deque<string> r;
    cur = start = last = found = 0;
    int n = 0;
    while( (found = s.find(sep, start)) != s.npos) {
        if( s[found-1] == esc ) {
            start = found+1;
            continue;
        }
        cur = found;
        string part = s.substr(last, cur-last);
        sreplace(part, ( string(1, esc) + string(1, sep) ), string(1, sep) );
        r.push_back(part);
        start = last = cur+1;
        if(++n == (max-1) )
            break;
    }
    string rest = s.substr(start);
    sreplace(rest, ( string(1, esc) + string(1, sep) ), string(1, sep) );
    r.push_back(rest);
    return r;
}

/* <object> element handler: create new object if required */
static void xml_cb_createObjects(void* data, const char* el, const char ** attr) {

    /** @BUG  Assumes 8 bit characters.  */
    int i;
    int reqd = 1;
    OTD_XML_Info* info;
    char* type = 0;
    char* name = 0;

    assert(data);
    info = (OTD_XML_Info*)data;

    if(strcmp(el, "object")) 
        return;

    for(i = 0; attr[i]; i+=2) {
        if(!strcmp(attr[i], "name")) 
            name = strdup(attr[i+1]);
        else if(!strcmp(attr[i], "type")) 
            type = ( !strcmp(attr[i+1], "property") ) ?  strdup("property:property") : strdup(attr[i+1]);
        else if(!strcmp(attr[i], "optional"))
            reqd = strcmp(attr[i+1], "yes");
    }
    if(!name)
        name = strdup("foo");
    if(!type)
        type = strdup("");

    if(reqd) {
        if(!strcmp(name, "*"))
            name = "something";
        NOTIFY("Creating new object \"" << name << "\" of type \"" << type << "\".");
        if(!strcmp(type, ""))
            type = 0;
        assert(&(info->object));
        assert(&(info->site));
        deque<string> types = ssplit(type, ',');
        // TODO: trim WS frem each type
        try {
            vRef<MetaObject> newobj = info->site->createMetaObject(0, types);
            info->object->insertChild(-1, name, &newobj);
        } catch(exception& e) {
            ERROR("Caught exception while creating new MetaObject \"" << name << "\" : " << e.what());
        }
    } else {
        WARNING("subobject \"" << name << "\" is optional, please create it manually if needed.");
    }

    if(name)
        free(name);
    if(type)
        free(type);
}




/* <otd> element handler: augment global data structures */
static void xml_cb_otdScan(void* data, const char* el, const char** attr) {

    /** @BUG  Assumes 8 bit characters. Should use XML_Char */
    int i;
    char* group = 0;
    char* name = 0;
    char* exts= 0;
    char* typestring = 0;
    OTD_XML_Info* info;
    assert(data);
    info = (OTD_XML_Info*)data;
    DEBUG("xml parser: element is " << el);

    if(strcmp(el, "otd") != 0) 
        return;

    // get attributes (type name and extends list)
    for(i = 0; attr[i]; i+=2) {
        if(!strcmp(attr[i], "group")) 
            group = strdup(attr[i+1]);
        else if(!strcmp(attr[i], "name")) 
            name = strdup(attr[i+1]);
        else if(!strcmp(attr[i], "extends")) {
            exts = strdup(attr[i+1]);
            DEBUG("xml parser: found 'extends' list: " << exts);
        }
    }


    if(group) {
        typestring = (char*) malloc( strlen(group) + strlen(name) + 1 );
        strcpy(typestring, group);
        strcat(typestring, ":");
        strcat(typestring, name);
        free(group);
    } else {
        typestring = strdup(name);
    }
        
    // save extends list
    OTD_Info* otd = new OTD_Info();
    otd->file = info->file;
    otd->filename = info->filename;
    if(exts)
        otd->extends = ssplit(exts, ',');
    otds[typestring] = otd;

    info->stop = 1;
    XML_SetStartElementHandler(info->parser, NULL);

    if(name)
        free(name);
    if(typestring)
        free(typestring);
    if(exts)
        free(exts);
}

/* parse an otd on stream 'f' with element handler 'handler'
   types, filename, f, vobj and site are passed on to the handler.
    vobj, types and site may be null (0).
*/
static void do_otd(FILE* f, string filename, deque<string>* types, XML_StartElementHandler handler, Vobject* vobj, Site* site) {
    char buff[MAX_BUFF_SIZE];
    int len;
    int eof = 0;
    OTD_XML_Info xml;

    assert(f);

    xml.stop = 0;
    xml.types = types; 
    xml.file = f;
    xml.filename = filename;
    xml.object = vobj;
    xml.site = site;
    xml.parser = XML_ParserCreate(NULL);

    if(!xml.parser) {
        ERROR("Could not create XML parser! (not enough memory?)\n");
        exit(-1);
    }
    XML_SetUserData(xml.parser, &xml);
    XML_SetStartElementHandler(xml.parser, handler);

    // read text and feed to parser until EOF or handler sets stop flag
    while (!eof && !xml.stop) {
        len = fread(buff, 1, MAX_BUFF_SIZE, f);
        if (ferror(f)) {
            ERROR("Read error in " << filename << "\n");
            exit(-1);
        }
        eof = feof(f);
        if (! XML_Parse(xml.parser, buff, len, eof)) {
            ERROR("Parse error in " << filename  << " at line " << 
                    XML_GetCurrentLineNumber(xml.parser) << ": " << 
                    XML_ErrorString(XML_GetErrorCode(xml.parser)));
            break;
        }
    }
    XML_ParserFree(xml.parser);
    return;
}


static void accumulate_extends(string t, deque<string>* dest) {
    if(otds.find(t) == otds.end()) {
        return;
    }
    DEBUG("checking extends for " << t << "...");
    OTD_Info* i = otds[t];
    for(deque<string>::const_iterator x = i->extends.begin();
        x != i->extends.end(); x++) {
          dest->push_back(*x);
        DEBUG("added type: " << *x);
        accumulate_extends(*x, dest);
    }
}



void scan() {
    char* path = getenv("VOS_OTD_PATH");
    if(path) {
        deque<string> ds = ssplit(path, ':');
        for(deque<string>::const_iterator d = ds.begin(); d != ds.end(); d++) {
            scanDir(*d);
        }
    } else {
#ifdef INSTALL_PREFIX
        string dir = INSTALL_PREFIX;
#else
        string dir = "/usr";
#endif
        dir += "/share/vos/otd";
        scanDir(dir);
    }
}


void scanDir(string d) {
    // scan otds, build types list 
    if(d == "") 
        return;
    DEBUG("Scanning directory: " << d);
    DIR* dir = opendir(d.c_str());
    if(!dir) {
        WARNING("Could not open directory: " << d);
        return;
    }
    string fn;
    struct dirent* f;
    while( (f = readdir(dir)) != NULL ) {
        if( !strcmp(f->d_name, ".") || !strcmp(f->d_name, "..")  )
            continue;
        fn = d + "/" + f->d_name;
        struct stat fileinfo;
        stat(fn.c_str(), &fileinfo);
        if(S_ISREG(fileinfo.st_mode)) {
            // skip files that don't end in .otd
            DEBUG("last 4 chars of \"" << fn << "\" is: " << fn.substr( fn.length()-4, 4 ) );
            if(ONLY_DOT_OTD && 
#ifdef BACKWARDS_CXX_STRING_COMPARE
#warning Using "Backwards" string::compare function...
                (fn.compare(".otd", (fn.length()-4), 4) != 0)
#else
                (fn.compare((fn.length()-4), 4, ".otd") != 0)
#endif
            ) {
                DEBUG("skipping file: " << fn);
                continue;
            }
            DEBUG("parsing file: " << fn);
            do_otd(fopen(fn.c_str(), "r"), fn, 0, xml_cb_otdScan, 0, 0);
        } else if(S_ISDIR(fileinfo.st_mode)) {
            DEBUG("scanning dir: " << fn);
            scanDir(fn);
        }
    }
    closedir(dir);
}

void cleanup() {
    for(map<string,OTD_Info*>::const_iterator i = otds.begin(); i != otds.end();
i++) {
        if( i->second->file)
            fclose(i->second->file);
        delete i->second;
    }
}

void rescan() {
    cleanup();
    scan();
}
    

void initObject(deque<string>& types, Vobject* vobj, Site* site) {

    assert(vobj);
    if(!site) 
        site = &(vobj->getSite());

    // build list of types and 'extends' anscestors; add types to object
    deque<string> xtypes = types;
    for(deque<string>::const_iterator t = types.begin(); t != types.end(); t++) {
        accumulate_extends(*t, &xtypes);
    }

    // parse otds for each subobject's type and parent type
    DEBUG("[parsing otds...]");
    for(deque<string>::const_iterator t = xtypes.begin(); t != xtypes.end(); t++) {
        if(otds.find(*t) == otds.end()) {
            WARNING("OTD not found for type: " << (*t));
            continue;
        }
        DEBUG("parsing otd for " << (*t));
        OTD_Info* i = otds[*t];
        rewind(i->file);
        do_otd(i->file, i->filename, &types, xml_cb_createObjects, vobj, site);
    }

    return;
}


};  // ns OTD



#if 0
int main() {
    LocalSocketSite site(&NoAccessControl::static_);
    Vobject* vobj = site.createMetaObject("foo", 0);
    OTD::scan();
    deque<string> t;
    t.push_back("a3dl:object3D.sphere");
    t.push_back("misc:hypercard");
    OTD::initObject(t, vobj, &site);
    OTD::cleanup();
    return 0;
}
#endif

---