root/trunk/filefuncs.cpp

#include "stdafx.h"
#include "filefuncs.h"
#include "PCRE/pme-1.0.4/pme.h"

int determineEncoding(unsigned char* pBuf, int nLen, EElephantEncoding& eEncoding) {
    eEncoding = eUnknown;
    
    int nRet = 0;
    
    if (nLen > 1) {
        if (pBuf[0] == Utf8_16::k_Boms[eUtf16BigEndian][0] && pBuf[1] == Utf8_16::k_Boms[eUtf16BigEndian][1]) {
            eEncoding = eUtf16BigEndian;
            nRet = 2;
        } else if (pBuf[0] == Utf8_16::k_Boms[eUtf16LittleEndian][0] && pBuf[1] == Utf8_16::k_Boms[eUtf16LittleEndian][1]) {
            eEncoding = eUtf16LittleEndian;
            nRet = 2;
        } else if (nLen > 2 && pBuf[0] == Utf8_16::k_Boms[eUtf8][0] && pBuf[1] == Utf8_16::k_Boms[eUtf8][1] && pBuf[2] == Utf8_16::k_Boms[eUtf8][2]) {
            eEncoding = eUtf8;
            nRet = 3;
        }
    }
    
    return nRet;
}

EElephantSaveFormat determineLineEndings(char* pBuf, int nLen)
{
    char c, n, p;
    int linesCRLF, linesCR, linesLF;
    
    linesCRLF = linesCR = linesLF = 0;
    p = NULL;
    
    for(int i = 0; i < nLen; i++)
    {
        c = pBuf[i];
        n = ((i < nLen) ? pBuf[i+1] : NULL);
        
        if (c == '\r') 
        {
            if (n == '\n')
            {
                linesCRLF++;
                // Skip the next character (\n).
                i++;
                p = '\n';
                continue;
            }
            else
                linesCR++;
        } 
        else if (c == '\n') 
        {
            linesLF++;
        }
        
        p = c;
    }
    
    if (((linesLF >= linesCR) && (linesLF > linesCRLF)) || ((linesLF > linesCR) && (linesLF >= linesCRLF)))
        return ElephantSF_Unix;
    else if (((linesCR >= linesLF) && (linesCR > linesCRLF)) || ((linesCR > linesLF) && (linesCR >= linesCRLF)))
        return ElephantSF_Mac;
    
    else if (((linesCRLF >= linesLF) && (linesCRLF > linesCR)) || ((linesCRLF > linesLF) && (linesCRLF >= linesCR)))
        return ElephantSF_Windows;
    
    // Default
    return ElephantSF_Windows;
}


string GetPathFromFiles(vector<string>& paths, const string &file)
{
    for (int i = 0 ; i < paths.size(); i++)
        
    {
        if ( StripFileName(paths[i]) == file) return paths[i];
    }
    
    return "";
}

string GetRelativePath( const string& basePath, const string& comparePath)
{
    vector<string> baseElements, compareElements;
    Split(basePath,"\\",baseElements);
    Split(comparePath,"\\",compareElements);
    int depth = 0;
    for ( int i = 0; i < baseElements.size(); i++ )
    {
        if ( i >= compareElements.size() ) {
            depth = i;
            break;
        }
        if ( baseElements[i] == compareElements[i]) continue;
        else {
            depth = i;
            break;
        }
        
    }
    
    string base;
    int fileCounter = depth;
    
    if ( depth == 0 ) 
    {
        fileCounter = baseElements.size();
    }
    else {
        depth = baseElements.size() - depth;
        
        for (int j = 0 ; j < ( depth ); j++) {
            base += "..\\";
        }
    }
    
    for ( int k = fileCounter;k < compareElements.size();k++)
    {
        base += compareElements[k] + "\\";
    }
    return base;
    
}

void GetFilesFromDir(const string& dir, vector<string> &files, const string& extension)
{
    WIN32_FIND_DATA fdat;
    char x[500];
    GetCurrentDirectory(500,x);
    if (!SetCurrentDirectory(dir.c_str()))
    {
        //MessageBox(0,"Couldnt set directory",dir.c_str(),0);
        return;
    }
    HANDLE hfind=FindFirstFile("*",&fdat);
    
    while (hfind!=INVALID_HANDLE_VALUE)
    { 
        if ((strcmp(fdat.cFileName, ".") == 0) || (strcmp(fdat.cFileName,"..") ==0)) ; //if it is . or .. dont push it on
        else 
        {
            if ( extension == "" ) files.push_back(fdat.cFileName);
            else if (LowerCase(FileExtension(fdat.cFileName)) == extension ) files.push_back(fdat.cFileName);
        }
        if (!FindNextFile(hfind,&fdat)) {FindClose(hfind); hfind=INVALID_HANDLE_VALUE;}
    }
    
    if (!SetCurrentDirectory(x)) 
    {
        return;
        MessageBox(0,"Couldnt set directory",x,0);
    }
    
    FindClose(hfind);
}

string ReadTemplate(const string& path, const string& name,const string& pname)
{
    string buffer = "";
    
    if (FileExists(path)) {
        string line = "";
        ifstream in(path.c_str() );
        while (!in.eof () ) {
            std::getline(in,line );
            buffer += ReplaceConstants(line, name, pname) + "\n";
        }
    }
    
    
    
    return buffer;
}

bool CopyTemplateFile(const string& source, const string& dest, const string & name, const string& pname )
{
    
    if ( !FileExists(source)) return false;
    
    ifstream in(source.c_str());
    
    
    if (!in.good() ) return false;
    
    
    
    string line = "", buffer = "";
    
    while (!in.eof () ) {
        std::getline(in,line );
        buffer += ReplaceConstants(line, name, pname) + "\n";
    }
    
    in.close();
    
    
    ofstream out(dest.c_str());
    
    if (!out.good() ) return false;
    
    out << buffer;
    out.close();
    
    return true;
    
}

bool ReplaceLine(const string& path, int lineNo, const string& regex, const string& replaceRegex, const string& options )
{
    
    PME reg(regex, options);
    
    if ( !FileExists(path)) return false;
    
    ifstream in(path.c_str());
    int currentLine = 1;
    string buffer, line;
    while ( !in.eof() )
    {
        std::getline(in,line);
        
        if ( currentLine == lineNo)
        {
            line = reg.sub( line, replaceRegex);
            buffer += line + "\n";
            
        }
        else buffer += line + "\n";
        
        currentLine++;
        
    }
    
    in.close();
    
    ofstream out(path.c_str());
    out << buffer;
    out.close();
    
    return true;
    
}


void readImportDirFiles(const string& dir, vector<string> &files, bool stripExtension)
{
    WIN32_FIND_DATA fdat;
    char x[500];
    GetCurrentDirectory(500,x);
    if (!SetCurrentDirectory(dir.c_str())) return;
    HANDLE hfind=FindFirstFile("*",&fdat);
    
    while (hfind!=INVALID_HANDLE_VALUE)
    { 
        if ((strcmp(fdat.cFileName, ".") == 0) || (strcmp(fdat.cFileName,"..") ==0)) ; //if it is . or .. dont push it on
        else {
            
            DWORD Code = GetFileAttributes(fdat.cFileName); 
            if ( !( Code & FILE_ATTRIBUTE_DIRECTORY ) ) {
                
                if ( FileExtension(fdat.cFileName) == "d" ) 
                {
                    
                    
                    string str =  fdat.cFileName;
                    StripExtension(str);
                    files.push_back(str);
                    
                }
                
            }
        }
        if (!FindNextFile(hfind,&fdat)) {FindClose(hfind); hfind=INVALID_HANDLE_VALUE;}
    }
    
    if (!SetCurrentDirectory(x)) return;
    FindClose(hfind);
}
void readImportDirDirs(const string& dir, vector<string> &files )
{
    WIN32_FIND_DATA fdat;
    char x[500];
    GetCurrentDirectory(500,x);
    if (!SetCurrentDirectory(dir.c_str())) return;
    
    HANDLE hfind=FindFirstFile("*",&fdat);
    while (hfind!=INVALID_HANDLE_VALUE)
    { 
        DWORD Code = GetFileAttributes(fdat.cFileName); 
        if ((Code != -1) && (Code & FILE_ATTRIBUTE_DIRECTORY )) {
            if ((strcmp(fdat.cFileName, ".") == 0) || (strcmp(fdat.cFileName,"..") ==0)) ; //if it is . or .. dont push it on
            else 
            {
                //              if ( markAsDir )
                //              {
                //                  string temp = fdat.cFileName;
                //                  temp += "/";
                //                  files.push_back(temp);
                //changed my mind on this one, redo later
                //                  files.push_back(fdat.cFileName);
                //              }
                //              else 
                //              {
                
                files.push_back(fdat.cFileName);
                //}
                
            }
            
        }
        
        if (!FindNextFile(hfind,&fdat)) {
            FindClose(hfind); 
            hfind=INVALID_HANDLE_VALUE;
        }
        
    }
    if (!SetCurrentDirectory(x)) return;
    FindClose(hfind);
}

void readImportDirContents(const string& dir, vector<string> &files)
{
    readImportDirDirs(dir,files);
    readImportDirFiles(dir,files,true);
    
}

bool CreateDirRecursive(const string& dir )
{
  vector<string> items;
  Split(dir,"\\",items );
  string createDir;
  for ( int i = 0 ; i < items.size();i++ )
    {

      createDir += items[i] + "\\";
      //      AfxMessageBox(createDir.c_str() );
      if ( !DirectoryExists(createDir) ) 
    {
      if ( !CreateDirectory(createDir.c_str(),NULL ) ) 
        return false;
    }
      //      else AfxMessageBox(string("Dir exists" + createDir ) .c_str() );
    }



  return true;
}