CppTools.cpp

Go to the documentation of this file.

/* ImLib3D
 * Copyright (c) 2001, ULP-IPB Strasbourg.
 *
 * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
#include<ImLib3D/CppTools.hpp>
#include <unistd.h>
#include <sys/types.h> 
#include <sys/stat.h>
#include <stdexcept>
#include <map>
#include <errno.h>
#include <iterator>
void  FatalError(const string &message="");


// **************************************************************
// runtime type info
// **************************************************************


string 
TypeNameParser(string typeName)
{
    static map<string,string> typeNameCache;
    // check if typeName is cached
    if(typeNameCache.find(typeName)==typeNameCache.end())
    {
        printf("TypeNameParser:: trying to guess typename for :\"%s\", this may be unreliable, or unportable\n",typeName.c_str());
        string demangled=typeName;
#if __GNUC__==2
        // gnuc typeinfo gives mangled result
        // try to demangle using external "c++filt" command
        // if demangling fails, just use typename
        string fakeFct="FakeFct";
        string todemangle=fakeFct+"__G"+typeName;
        printf("demangle_typename gcc2:%s\n",todemangle.c_str());
        string demangleRes=Command("c++filt "+todemangle);
        if(demangleRes!=todemangle)
        {
            string tmp=demangleRes.substr(fakeFct.size()+1);
            demangled=tmp.substr(0,tmp.size()-2);
        }
        printf("demangled:%s\n",demangled.c_str());
#elif __GNUC__>=3// __GNUC__
        // gnuc typeinfo gives mangled result
        // try to demangle using external "c++filt" command
        // if demangling fails, just use typename
        string fakeFct="_ZTI";
        string todemangle=fakeFct+typeName;
        printf("demangle_typename gcc3:%s\n",todemangle.c_str());
        string demangleRes=Command("c++filt "+todemangle);
        if(demangleRes!=todemangle)
        {
            if(demangleRes.size()<strlen("typeinfo for ")+1)
            {
                ThrowError("TypeNameParser demangle failed");
            }
            demangled=demangleRes.substr(strlen("typeinfo for "));
            demangled=demangled.substr(0,demangled.size()-1);
        }
        printf("demangled:%s\n",demangled.c_str());
#else // __GNUC__
        ThrowError("TypeNameParser does  supports only gcc2 or gcc3 compilers");
#endif // __GNUC__
        typeNameCache[typeName]=demangled;
    }
    return typeNameCache[typeName];
}


// **************************************************************
// error processing
// **************************************************************
ErrorManagementType errorManagementType(ERROR_USE_EXCEPTIONS);
void (*ErrorHandler)(string)=NULL;
void 
SetErrorManagementType(ErrorManagementType _errorManagementType,void(*_ErrorHandler)(string))
{
    errorManagementType=_errorManagementType;
    ErrorHandler=_ErrorHandler;
}

void 
FatalError(const string &message) 
{
    if(errorManagementType==ERROR_USE_EXCEPTIONS)
    {
        fprintf(stderr,"FatalError throwing exception:\"%s\"\n",message.c_str());
        throw runtime_error(message);
    }
    else
    if(errorManagementType==ERROR_CALL_HANDLER)
    {
        if(!ErrorHandler)
        {
            fprintf(stderr,"FatalError: error while processing error: ERROR_CALL_HANDLER requested, but handler is NULL: aborting");
            exit(1);
        }

        (*ErrorHandler)(message);
        fprintf(stderr,"FatalError: error while processing error: error handler returned after error processing, this is not allowed. Error handler function should NEVER return: aborting");
        exit(1);
    }
    else
    {
        fprintf(stderr,"%s\n",message.c_str());
        fprintf(stderr,"Aborting with segfault:");
        (*((char *)(NULL)))=0;
    }

    fprintf(stderr,"FatalError: error while processing error: something very strange is happening: aborting");
    exit(1);//should never get here!
}

void 
ThrowErrorVA(const char *fmt, ...)
{
    va_list args;
    va_start(args,fmt);
    fflush(stdout);
    if(!fmt)
    {
        fprintf(stderr,"ThrowError: error while processing error: no error information\n");
        FatalError();
    }
    
    char tempString[1000];
#ifdef HPUX
    vsprintf(tempString,fmt,args);
#else//HPUX
    vsnprintf(tempString,1000,fmt,args);
#endif//HPUX
    string message="FATAL ERROR:";
    message+=tempString;
    va_end(args);
//  fprintf(stderr,"%s\n",message.c_str());
    FatalError(message);
}

// **************************************************************
// debug output
// **************************************************************
int globalVerbose=1;
//  void 
//  mprintf(const char *fmt, ...)
//  {
//      va_list args;
//      va_start(args,fmt);
//      if(globalVerbose){vprintf(fmt,args);}
//  }


// **************************************************************
// string related  funtions
// **************************************************************
vector<string> Strings(string s1,string s2,string s3,string s4,string s5,string s6,string s7,string s8,string s9,string s10)
{string s[]={s1,s2,s3,s4,s5,s6,s7,s8,s9,s10};vector<string> v;v.insert(v.end(),s,s+10);return v;}
vector<string> Strings(string s1,string s2,string s3,string s4,string s5,string s6,string s7,string s8,string s9)
{string s[]={s1,s2,s3,s4,s5,s6,s7,s8,s9};vector<string> v;v.insert(v.end(),s,s+9);return v;}
vector<string> Strings(string s1,string s2,string s3,string s4,string s5,string s6,string s7,string s8)
{string s[]={s1,s2,s3,s4,s5,s6,s7,s8};vector<string> v;v.insert(v.end(),s,s+8);return v;}
vector<string> Strings(string s1,string s2,string s3,string s4,string s5,string s6,string s7)
{string s[]={s1,s2,s3,s4,s5,s6,s7};vector<string> v;v.insert(v.end(),s,s+7);return v;}
vector<string> Strings(string s1,string s2,string s3,string s4,string s5,string s6)
{string s[]={s1,s2,s3,s4,s5,s6};vector<string> v;v.insert(v.end(),s,s+6);return v;}
vector<string> Strings(string s1,string s2,string s3,string s4,string s5)
{string s[]={s1,s2,s3,s4,s5};vector<string> v;v.insert(v.end(),s,s+5);return v;}
vector<string> Strings(string s1,string s2,string s3,string s4)
{string s[]={s1,s2,s3,s4};vector<string> v;v.insert(v.end(),s,s+4);return v;}
vector<string> Strings(string s1,string s2,string s3)
{string s[]={s1,s2,s3};vector<string> v;v.insert(v.end(),s,s+3);return v;}
vector<string> Strings(string s1,string s2)
{string s[]={s1,s2};vector<string> v;v.insert(v.end(),s,s+2);return v;}
vector<string> Strings(string s1)
{string s[]={s1};vector<string> v;v.insert(v.end(),s,s+1);return v;}
vector<string> Strings()
{vector<string> v;return v;}

string
SPrintfVA(const char *fmt, ...)
{
    va_list args;
    va_start(args,fmt);
    if(!fmt){ThrowError("SPrintf: format string null\n");}
    char tempString[1000];
#ifdef HPUX
    vsprintf(tempString,fmt,args);
#else//HPUX
    if(vsnprintf(tempString,1000,fmt,args)<0)
    {
        ThrowError("SPrintf:  string too long \n");
    }   
#endif//HPUX
    va_end(args);
    return(tempString);
}


bool 
FileIsMoreRecent(const string &filename1,const string &filename2)
{
    struct stat s1,s2;
    stat(filename1.c_str(),&s1);
    stat(filename2.c_str(),&s2);
    return s1.st_mtime > s2.st_mtime;
}

bool IsSameFile(string filename1,string filename2)
{
    if(filename1==filename2){return true;}
    struct stat stat1;  
    struct stat stat2;
    stat(filename1.c_str(), &stat1);
    stat(filename2.c_str(), &stat2);
    return stat1.st_ino==stat2.st_ino;
}


string 
WriteTmpFile(const string &data)
{
    static bool init=false;
    static string tmpdir;
    if(!init)
    {
        tmpdir=(getenv("IMLIB3D_TMP") ? getenv("IMLIB3D_TMP") : "/tmp");
        // check if it is a valid directory
        struct stat stats;  
        stat(tmpdir.c_str(),&stats);
        if(!S_ISDIR(stats.st_mode))
        {
            ThrowError("WriteTmpFile: invalid temporary directory \"%s\"",tmpdir);
        }
    }
    string fnametemplate=tmpdir+"/imlib3d.XXXXXX";
    char *sfn=strdup(fnametemplate.c_str());
    FILE *F;
    int fd = -1;
    
    if ((fd = mkstemp(sfn)) == -1 || (F = fdopen(fd, "w+")) == NULL) 
    {
        if (fd != -1) 
        {
            unlink(sfn);
            close(fd);
        }
        ThrowError("WriteTmpFile: %s: %s\n", sfn, strerror(errno));
    }
    fnametemplate=sfn;
    free(sfn);
    fwrite((void *)data.c_str(),data.length(),1,F);
    fclose(F);
    return fnametemplate;       
}
void
WriteStringToFile(const string& fname,const string& data)
{
    FILE *F=fopen(fname.c_str(),"w");
    if(!F){ThrowError("WriteStringToFile failed:%s",fname);}
    fwrite((void *)data.c_str(),data.length(),1,F);
    fclose(F);
}

void 
RemoveFile(string fname)
{
    remove(fname.c_str());
}

 
void 
RemoveFiles(const vector<string>& fnames)
{
    vector<string>::const_iterator p;
    for (p=fnames.begin(); p!=fnames.end(); p++)
        RemoveFile(*p);
}


int
Split( const string &s, char c, vector<string> &res)
{
    res.clear();
    if(s==""){return 0;}
    uint i;
    uint pos=0;
    for( i=0; i<=s.size(); i++)
    {
        if( i == s.size() || s[i] == c )
        {
            uint j;
            string tmps;
            for( j=pos; j<i; j++)
            {
                tmps += s[j];
            }
            res.push_back(tmps);
            pos=i+1;
        }
    }
    return res.size();
}

int
Split( const string &s, const string &sep, vector<string> &res)
{
    res.clear();
    uint pos=0;
    uint lpos=0;
    do
    {
        pos=s.find(sep,lpos);
        if(pos==s.npos){pos=s.size();}
        string tmps;
        tmps.assign(s.begin()+lpos,s.begin()+pos);
        res.push_back(tmps);
        lpos=pos+sep.size();
    }
    while(pos<s.size());

    return res.size();
}




void
Replace(string &res,const string & s1,const string & s2)
{
    uint pos;
    while( (pos=res.find(s1)) != res.npos)
    {
    res.replace(pos,s1.size(),s2);
    }
}

int
FileSize(const string& fname)
{
    FILE *F=fopen(fname.c_str(),"r");
    if(!F)
    {
        return -1;
    }
    fseek(F,0,SEEK_END);
    int sz=ftell(F);
    fclose(F);
    return sz;
}

void
AppendToFile(const string& fname,const string &data)
{
    FILE *F=fopen(fname.c_str(),"a+");
    if(!F)
    {
        ThrowError("AppendToFile:: failed opening file:\"%s\"",fname);
    }
    fwrite((void *)data.c_str(),data.length(),1,F); 
    fclose(F);
}

string FindFileInPath(const string &path,const string &fname)
{
    vector<string> pathv;
    Split(path, ':', pathv);
    return FindFileInPath(pathv,fname);
}
string FindFileInPath(const vector<string> &path,const string &fname)
{
    for(uint i=0;i<path.size();i++)
    {
        string fullName=path[i]+"/"+fname;
        if(FileExists(fullName)){return fullName;}
    }
    return "";
}

string 
Command(const string &cmd)
{
    string tmp=WriteTmpFile(SPrintf("Command:(%s)empty",cmd));
    string call=cmd+" >" +tmp;
    errno=0;
    int ret=system(call.c_str());
    if(ret==-1 && errno!=0)
    {
        ThrowError("Command: executing command:\"%s\" failed:%s\n",call,strerror(errno));
    }
    if(ret!=0)
    {
        ThrowError("Command: command:\"%s\" failed (return value: %d)\n",call,ret);
    }
    string res;
    if(!FileExists(tmp)){ThrowError("Command: while executing:\"%s\", result file not created",cmd);}
    Read(tmp,res);
    RemoveFile(tmp);
    return res;
}


int
Read(const string& fname,string& res,bool fail)
{
    FILE *F=fopen(fname.c_str(),"r");
    if(!F)
    {
        if(!fail) {res="";return 0;}
        ThrowError("Read: (into string) read file failed for file: \"%s\" ",fname);
    }
    fseek(F,0,SEEK_END);
    int sz=ftell(F);
    fseek(F,0,SEEK_SET);
    char *s=new char[sz+1];
    fread(s,sz,1,F);
    fclose(F);
    s[sz]=0;
    res=s;
    delete [] s;

//      cout << "Read: fname:" << fname << endl;
//      cout << "Read: file:" << res << endl;
    return 1;
}
void *
Read(const string& fname,int *rsize,bool fail)
{
    int size0;
    int *psize=(rsize ? rsize : &size0);
    int &size=*psize;
    size=0;
    FILE *F=fopen(fname.c_str(),"r");
    if(!F)
    {
        if(!fail) {return NULL;}
        ThrowError("Read: (into void*) read file failed for file: \"%s\"",fname);
    }
    fseek(F,0,SEEK_END);
    size=ftell(F);
    fseek(F,0,SEEK_SET);
    void *res=(void *)(new char[size]);
    fread(res,size,1,F);
    fclose(F);
    return res;
}
void
Write(const string& fname,void *data,int size,bool fail)
{
    FILE *F=fopen(fname.c_str(),"w");
    if(!F)
    {
        if(!fail) {return;}
        ThrowError("Write file failed : %s",fname);
    }
    fwrite(data,size,1,F);
    fclose(F);
}


string FilenameExtension(const string& fname)
{
    vector<string> parts;
    Split(fname, '.', parts);
    if (parts.size()==1){return "";}
    else
    {return parts.back();}
}

string FilenamePath(const string& fname)
{
    vector<string> parts;
    string rstring;
    int n = Split(fname, '/', parts);
    if (n==1){
        return "";
    }
    else{
        for (int i=0; i<n-1; i++)
            rstring += parts[i] + "/";
        return rstring;
    }
}

string FilenameBasename(const string& fname)
{
    vector<string> parts;
    string rstring;
    int n = Split(fname, '/', parts);
    return parts[n-1];
}


ostream& operator<< (ostream& out, const vector<string>& v)
{
//  ThrowError("unimplemented for gcc3.0");
    copy(v.begin(), v.end(), ostream_iterator<string>(out,"\n"));
    return out;
}


string Chop(const string&s, char c)
{
    vector<string> list;
    int n=Split(s, c, list);
    string temp = "";
    for (int i=0; i<n-1; i++)
    {
        temp += list[i];
        temp += c;
    }
    return temp;
}




// ******************************************************
// External Unix programs
// ******************************************************
void
GnuPlot(const vector<double> &x,const vector<double> &y,const string &xlabel,const string &ylabel)
{
    string plotFile;
    string plotData;
    for(uint i=0;i<x.size();i++)
    {
        plotData+=SPrintf("%20.20f %20.20f \n",x[i],y[i]);
    }
    
    string dataFname=WriteTmpFile(plotData);
    plotFile+="set encoding iso_8859_1\n";
    if(xlabel!=""){plotFile+="set xlabel \""+xlabel+"\"\n";}
    if(ylabel!=""){plotFile+="set ylabel \""+ylabel+"\"\n";}
    plotFile+="plot '"+dataFname+"' with lines\n"+"pause 1000\n";
    string plotFname=WriteTmpFile(plotFile);
    string cmd=SPrintf("gnuplot %s &",plotFname);
    system(cmd.c_str());
    usleep(1000000);
    //RemoveFile(plotFname);
    //RemoveFile(dataFname);
}
void
GnuPlot(const vector<double> &y,const string &ylabel)
{
    vector<double> x;
    for(uint i=0;i<y.size();i++){x.push_back(i);}
    GnuPlot(x,y,"",ylabel);
}
void
GnuPlot(const vector<float> &x0,const vector<float> &y0,const string &xlabel,const string &ylabel)
{
    vector<double> x;x.insert(x.end(),x0.begin(),x0.end());
    vector<double> y;y.insert(y.end(),y0.begin(),y0.end());
    GnuPlot(x,y,xlabel,ylabel);
}
void
GnuPlot(const vector<float> &y0,const string &ylabel)
{
    vector<double> y;y.insert(y.end(),y0.begin(),y0.end());
    GnuPlot(y,ylabel);
}

// **************************************************************
// portability
// **************************************************************
#ifdef __CYGWIN__
extern "C"
{
double drand48()
{
    return((random()%1000000)/1000000.0);
}
}
#endif // __CYGWIN__

---