URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-3.0/] [host/] [tools/] [configtool/] [standalone/] [wxwin/] [filename.cpp] - Blame information for rev 786

Details | Compare with Previous | View Log


// ####ECOSHOSTGPLCOPYRIGHTBEGIN####                                        
// -------------------------------------------                              
// This file is part of the eCos host tools.                                
// Copyright (C) 1998, 1999, 2000, 2003, 2005, 2009 Free Software Foundation, Inc.
//
// 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 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., 51 Franklin Street,                      
// Fifth Floor, Boston, MA  02110-1301, USA.                                
// -------------------------------------------                              
// ####ECOSHOSTGPLCOPYRIGHTEND####                                          
 
#ifdef __GNUG__
#pragma implementation "filename.h"
#endif
 
// Includes other headers for precompiled compilation
#include "ecpch.h"
 
#ifdef __BORLANDC__
#pragma hdrstop
#endif
 
#ifdef __CYGWIN__
#include <sys/cygwin.h> /* for cygwin_conv_to_posix_path() */
#endif
 
#include "wx/filefn.h"
#include "wx/confbase.h" // For wxExpandEnvVars
 
#include "filename.h"
 
#ifdef __WXMSW__
//#include <direct.h>
//#include <dos.h>
 
#include <windows.h>
#include <shlwapi.h>
 
#include "wx/msw/winundef.h"
#ifdef CreateDirectory
#undef CreateDirectory
#endif
#ifdef ExpandEnvironmentStrings
#undef ExpandEnvironmentStrings
#endif
#ifdef GetCurrentDirectory
#undef GetCurrentDirectory
#endif
#ifdef SetCurrentDirectory
#undef SetCurrentDirectory
#endif
#ifdef GetTempPath
#undef GetTempPath
#endif
 
#else
 
// #include <dir.h>
#endif
 
#include <sys/stat.h>
 
#define wxTChar wxT
 
#ifdef __WXMSW__
const wxChar ecFileName::cSep=wxT('\\');
#else
const wxChar ecFileName::cSep=wxFILE_SEP_PATH;
#endif
 
 
ecFileName::ecFileName(const wxChar* psz1,const wxChar* psz2):
wxString(psz1)
{
    Normalize();
    operator+=(psz2);
}
 
ecFileName::ecFileName(const wxChar* psz1,const wxChar* psz2,const wxChar* psz3):
wxString(psz1)
{
    Normalize();
    operator+=(psz2);
    operator+=(psz3);
}
 
ecFileName::ecFileName(const wxChar* psz1,const wxChar* psz2,const wxChar* psz3,const wxChar* psz4):
wxString(psz1)
{
    Normalize();
    operator+=(psz2);
    operator+=(psz3);
    operator+=(psz4);
}
 
ecFileName::ecFileName(const wxChar* psz1,const wxChar* psz2,const wxChar* psz3,const wxChar* psz4,const wxChar* psz5):
wxString(psz1)
{
    operator+=(psz2);
    operator+=(psz3);
    operator+=(psz4);
    operator+=(psz5);
}
 
/*
ecFileName::~ecFileName()
{
    // Unfortunately we can't do this since GetStringData is private in wxString.
    // So for now, we may memory leaks since ~wxString is not virtual.
    //GetStringData()->Unlock();
}
*/
 
ecFileName operator+(const ecFileName& string1, const ecFileName& string2)
{
    ecFileName s;
    s.ConcatCopy(string1, string2);
    return s;
}
 
ecFileName operator+(const ecFileName& string, const wxChar* lpsz)
{
    if (lpsz == NULL)
        return string;
 
    ecFileName s;
    s.ConcatCopy(string, wxString(lpsz));
    return s;
}
 
ecFileName operator+(const wxChar* lpsz, const ecFileName& string)
{
    if (lpsz == NULL)
        return string;
 
    ecFileName s;
    s.ConcatCopy(wxString(lpsz), string);
    return s;
}
 
ecFileName operator+(const ecFileName& string1, wxChar ch)
{
    ecFileName s;
    s.ConcatCopy(string1, wxString(ch));
    return s;
}
 
ecFileName operator+(wxChar ch, const ecFileName& string)
{
    ecFileName s;
    s.ConcatCopy(wxString(ch), string);
    return s;
}
 
const ecFileName& ecFileName::operator+=(const wxChar* lpsz)
{
    if (lpsz == NULL)
        return *this;
 
    ConcatInPlace(wxString(lpsz));
    return *this;
}
 
const ecFileName& ecFileName::operator+=(wxChar ch)
{
    ConcatInPlace(wxString(ch));
    return *this;
}
 
const ecFileName& ecFileName::operator+=(const ecFileName& string)
{
    ConcatInPlace(string);
    return *this;
}
 
void ecFileName::ConcatInPlace(const wxString& src)
{
    ConcatCopy(* this, src);
}
 
void ecFileName::ConcatCopy(const wxString& src1,
                            const wxString& src2)
{
    int nSrc1Len = src1.Len();
    int nSrc2Len = src2.Len();
    int n=1;
    int nNewLen = nSrc1Len + nSrc2Len;
    if(nSrc1Len>0)
    {
        if(1==nSrc2Len && cSep==src2[0])
        {
            // Appending a single separator to a non-null string is a no-op
            return;
        } else {
            // Count the intervening separators
            n=(cSep==src1[nSrc1Len-1])+(cSep==src2[0]);
 
            switch(n){
            case 0:
                (*this) = src1 + wxString(cSep) + src2;
                break;
            case 1:
                (*this) = src1 + src2;
                break;
            case 2:
                (*this) = src1 + src2.Mid(1);
                break;
            }
            return;
        }
    }
}
 
void ecFileName::Normalize()
{
    // Remove any trailing seperator
    int len = Len();
    if (len > 0 && (*this)[(size_t)(len - 1)] == cSep)
        (*this) = Mid(0, len - 1);
}
 
 
const ecFileName ecFileName::FullName() const
{
#ifdef __WXMSW__
    TCHAR* pFile;
    long dwSize=::GetFullPathName (*this, 0, NULL, &pFile);
    if(dwSize>0){
        wxString strCopy;
        ::GetFullPathName (*this, 1+dwSize, strCopy.GetWriteBuf(1+dwSize), &pFile);
        strCopy.UngetWriteBuf();
        return strCopy;
    } else {
        return *this;
    }
#else
    return wxGetCwd() + wxString(cSep) + wxString(*this);
#endif
}
 
const ecFileName ecFileName::ShortName() const
{
#ifdef __WXMSW__
    long dwSize=::GetShortPathName (*this, NULL, 0);
    if(dwSize>0){
        wxString strCopy;
        ::GetShortPathName (*this, strCopy.GetWriteBuf(1+dwSize), 1+dwSize);
        strCopy.UngetWriteBuf();
        return strCopy;
    } else {
        return *this;
    }
#else
    return *this;
#endif
}
 
const ecFileName ecFileName::NoSpaceName() const// sans spaces
{
#ifndef __WXMSW__
    return *this;
#else
    // Only replace components with spaces with FAT names.
    wxArrayString ar1,ar2;
    const wxString str2(ShortName());
 
    size_t i,pcStart;
 
    unsigned int len = Len();
    pcStart = 0;
    for (i = 0; i < len; i++)
    {
        if(wxTChar('\\')==(*this)[i])
        {
            ar1.Add(this->Mid(pcStart, i - pcStart + 1));
            pcStart = i + 1;
        }
    }
    ar1.Add(this->Mid(pcStart, i - pcStart + 1));
 
    len = str2.Len();
    pcStart = 0;
    for (i = 0; i < len; i++)
    {
        if(wxTChar('\\')==str2[i])
        {
            ar2.Add(str2.Mid(pcStart, i - pcStart + 1));
            pcStart = i + 1;
        }
    }
    ar2.Add(str2.Mid(pcStart, i - pcStart + 1));
 
    wxASSERT(ar1.Count()==ar2.Count());
 
    wxString rc;
    for(i=0;i<ar1.Count();i++){
        rc+=(-1==ar1[i].Find(wxTChar(' ')))?ar1[i]:ar2[i];
    }
    return rc;
#endif
}
 
//
const ecFileName ecFileName::Tail() const
{
    return AfterLast(cSep);
}
 
const ecFileName ecFileName::Head() const
{
    return BeforeLast(cSep);
}
 
time_t ecFileName::LastModificationTime() const
{
    return wxFileModificationTime(* this);
 
#if 0
    // GetFileAttributes is not available in Win95 so we test the water first
    static HINSTANCE hInst=LoadLibrary(_T("kernel32.dll"));
    wxASSERT(hInst);
 
#ifdef _UNICODE
#define GETFILEATTRIBUTESNAME "GetFileAttributesExW"
#else
#define GETFILEATTRIBUTESNAME "GetFileAttributesExA"
#endif // !UNICODE
 
    typedef BOOL (WINAPI *GetFileAttributesP)(const wxChar*,GET_FILEEX_INFO_LEVELS,LPVOID);
 
    static GetFileAttributesP p=(GetFileAttributesP)GetProcAddress(hInst,GETFILEATTRIBUTESNAME);
    if(p){
        WIN32_FILE_ATTRIBUTE_DATA data;
 
        if((*p)(*this, GetFileExInfoStandard, (LPVOID)&data)){
            return data.ftLastWriteTime;
        }
    } else {
        HANDLE h=CreateFile(*this,0,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
        FILETIME ft;
        if(INVALID_HANDLE_VALUE!=h){
            BOOL b=::GetFileTime(h,NULL,NULL,&ft);
            ::CloseHandle(h);
            if(b){
                return ft;
            }
        }
    }
    static FILETIME ftNull={0,0};
    return ftNull;
#endif
}
 
/* TODO
bool ecFileName::SetFileAttributes(long dwFileAttributes) const
{
return ::SetFileAttributes (*this, dwFileAttributes)!=0;
}
*/
 
bool ecFileName::Exists     () const
{
    return IsFile() || IsDir() ;
}
 
bool ecFileName::IsDir      () const
{
#if wxCHECK_VERSION(2, 6, 0)
        return (wxDirExists(* this));
#else
    return wxPathExists(* this);
#endif
}
 
bool ecFileName::IsFile     () const
{
#if defined(__WXMAC__)
    struct stat stbuf;
    if (filename && stat (wxUnix2MacFilename(filename), &stbuf) == 0 )
        return TRUE;
    return FALSE ;
#else
    wxStructStat st;
    if ((*this) != wxT("") && wxStat (wxFNSTRINGCAST fn_str(), &st) == 0 && (st.st_mode & S_IFREG))
        return TRUE;
 
    return FALSE;
#endif
}
 
bool ecFileName::IsReadOnly () const
{
#ifdef __WXMSW__
    long a=GetFileAttributes(* this); return 0xFFFFFFFF!=a && (0!=(a&FILE_ATTRIBUTE_READONLY ));
#else
    wxFAIL_MSG("ecFileName::IsReadOnly not supported on this platform.");
    return FALSE;
#endif
}
 
bool ecFileName::SameFile(const ecFileName &o) const
{
#ifdef __WXMSW__
    return 0==ShortName().CmpNoCase(o.ShortName());
#else
    // On most other platforms, case is important.
    return o == (*this);
#endif
}
 
ecFileName ecFileName::EC_ExpandEnvironmentStrings(const wxChar* psz)
{
    // wxExpandEnvVars is from confbase.h
 
    ecFileName f = wxExpandEnvVars(psz);
    return f;
}
 
const ecFileName& ecFileName::EC_ExpandEnvironmentStrings()
{
    *this=ecFileName::EC_ExpandEnvironmentStrings(*this);
    return *this;
}
 
#if 0
// Helper for Relative()  psz is in full format.
ecFileName ecFileName::Drive(const wxChar* psz)
{
    if(wxIsalpha(psz[0])){
        return psz[0];
    } else if(cSep==psz[0]&&cSep==psz[1]){
        wxChar *c=_tcschr(psz+2,cSep);
        if(c){
            c=_tcschr(c+1,cSep);
            if(c){
                return wxString(psz,c-psz);
            }
        }
    }
    return _T("");
}
#endif
 
ecFileName ecFileName::Relative(const wxChar* compare,const wxChar* current)
{
#ifdef __WXMSW__
    wxString rc;
    bool b=(TRUE==PathRelativePathTo(rc.GetWriteBuf(1+MAX_PATH),current,FILE_ATTRIBUTE_DIRECTORY,compare,0));
    rc.UngetWriteBuf();
    return b?(ecFileName)rc:(ecFileName)compare;
#else
    wxFAIL_MSG("ecFileName::Relative not implemented on this platform.");
    return ecFileName();
#endif
}
 
const ecFileName& ecFileName::MakeRelative(const wxChar* pszRelativeTo)
{
    *this=ecFileName::Relative(*this,pszRelativeTo);
    return *this;
}
 
 
ecFileName ecFileName::EC_GetCurrentDirectory()
{
    ecFileName f;
    f = wxGetCwd();
    f.Normalize();
 
    return f;
}
 
 
const ecFileName& ecFileName::Append(const wxChar* lpsz)
{
    if (lpsz)
        return *this;
 
    //wxString::ConcatInPlace(lpsz);
    wxString::Append(lpsz);
    return *this;
 
}
 
const ecFileName& ecFileName::Append(wxChar ch)
{
    ConcatInPlace(wxString(ch));
    return *this;
}
 
bool ecFileName::IsAbsolute() const
{
    int nLength=Len();
    const wxString& psz=*this;
    return
        (nLength>0 && (cSep==psz[0]))|| // starts with '\'
        (nLength>1 && (
        (wxIsalpha(psz[0]) && wxTChar(':')==psz[1]) ||  // starts with [e.g.] "c:\"
        (cSep==psz[0] && cSep==psz[1])));              // UNC
}
 
// TODO (?)
#if 0
// Return an array of filename pieces.  Plugs '\0's into 'this', which
// is therefore subsequently only usable as referenced by the returned array.
const wxChar* *ecFileName::Chop()
{
    wxChar *c;
    // Count the separators
    int nSeps=0;
    for(c=_tcschr(m_pchData,cSep);c;c=_tcschr(c+1,cSep)){
        nSeps++;
    }
    const wxChar* *ar=new const wxChar*[2+nSeps]; // +1 for first, +1 for terminating 0
    ar[0]=m_pchData;
    int i=1;
    for(c=_tcschr(m_pchData,cSep);c;c=_tcschr(c+1,cSep)){
        ar[i++]=c+1;
        *c=wxTChar('\0');
    }
    ar[i]=0;
    return ar;
}
#endif
 
ecFileName ecFileName::EC_GetTempPath()
{
    ecFileName f;
#ifdef __WXMSW__
#ifdef _UNICODE
    ::GetTempPathW(1+MAX_PATH,f.GetWriteBuf(1+MAX_PATH));
#else
    ::GetTempPathA(1+MAX_PATH,f.GetWriteBuf(1+MAX_PATH));
#endif
  f.UngetWriteBuf();
#elif defined(__WXGTK__)
#else
    wxFAIL("ecFileName::GetTempPath() not implemented on this platform.");
#endif
    f.Normalize();
    return f;
}
 
const ecFileName ecFileName::CygPath () const
{
#ifdef __WXMSW__
    ecFileName rc = NoSpaceName();
#ifdef __CYGWIN__
        char buffer [MAX_PATH + 1];
        cygwin_conv_to_posix_path (rc.c_str (), buffer);
        rc = buffer;
#else
    if(wxIsalpha(rc[(size_t)0]) && wxTChar(':')==rc[(size_t)1])
    {
        // Convert c:\ to /cygdrive/c/
        wxString s = wxString(wxT("/cygdrive/")) + wxString(rc[(size_t)0]) + rc.Mid(2);
        rc = s;
    }
    size_t i;
    for (i = 0; i < rc.Len(); i++)
    {
        if (rc[i] == wxTChar('\\'))
            rc[i] = wxTChar('/');
    }
#endif
#else
    const ecFileName& rc = * this;
#endif
 
    return rc;
}
 
bool ecFileName::EC_CreateDirectory(bool bParentsToo,bool bFailIfAlreadyExists) const
{
    if(bParentsToo)
    {
        // Create intermediate directories
 
        // 'rest' will progressively have its separators replaced by underscores in order
        // to find the next separator
        wxString rest = * this;
        size_t lastPos = 0;
        int len = rest.Len();
 
#ifdef __WXMSW__
        // If the path is a network path, ignore the first part of the path
        if (len > 2 && (rest.GetChar(0) == wxT('\\') || rest.GetChar(0) == wxT('/')) && (rest.GetChar(1) == wxT('\\') || rest.GetChar(1) == wxT('/')))
        {
            rest.SetChar(0,wxT('_')); rest.SetChar(1,wxT('_'));
            lastPos = rest.Find(cSep);
            if (lastPos != -1 && lastPos >= 0)
                rest.SetChar(lastPos,wxT('_'));
        }
#endif
 
        while (lastPos != -1)
        {
            lastPos = rest.Find(cSep);
            if (lastPos != -1 && lastPos >= 0)
            {
                rest[lastPos] = wxT('_'); // So we find the NEXT separator
 
                // don't attempt to create "C: or /"
                if (lastPos > 0 && (*this)[lastPos-1] == wxT(':'))
                    continue;
                else if (lastPos == 0)
                    continue;
            }
 
            // Fail if any of the dirs exist already
            wxString str(this->Mid(0, lastPos));
            bool alreadyExists = wxDirExists(str);
            if (alreadyExists && bFailIfAlreadyExists)
                return FALSE;
 
            if (!alreadyExists)
                if (!wxMkdir(str))
                    return FALSE;
        }
    }
 
 
    return IsDir()? (!bFailIfAlreadyExists) : (TRUE==wxMkdir(*this));
}
 
 
const wxString ecFileName::Extension() const
{
    wxString path, name, ext;
 
    wxSplitPath(*this, & path, & name, & ext);
    return ext;
}
 
const wxString ecFileName::Root() const
{
    return wxPathOnly(*this);
}
 
ecFileName ecFileName::EC_SetCurrentDirectory(const wxChar* pszDir)
{
    const ecFileName strPwd=wxGetCwd();
    if (::wxSetWorkingDirectory(pszDir))
        return strPwd;
    else
        return wxT("");
}
 
bool ecFileName::RecursivelyDelete()
{
    wxArrayString ar;
    int i;
    for(i=FindFiles(*this,ar)-1;i>=0;--i){
        wxRemoveFile(ar[i]);
    }
    for(i=FindFiles(*this,ar,wxT("*.*"),TRUE,0)-1;i>=0;--i){
        wxRmdir(ar[i]);
    }
    return TRUE==wxRmdir(*this);
}
 
// TODO: take account of dwExclude
int ecFileName::FindFiles (const wxString& pszDir,wxArrayString &ar,const wxString& pszPattern/*=wxT("*.*")*/,bool bRecurse/*=TRUE*/,long dwExclude/*=wxDIR_DIRS|wxDIR_HIDDEN*/)
{
    ar.Clear();
 
    // Scoping for wxDir
    {
        wxDir dir(pszDir);
 
        wxString fileName;
        bool bMore = dir.GetFirst(& fileName, pszPattern, wxDIR_FILES);
        while (bMore)
        {
            if (fileName != wxT(".") && fileName != wxT(".."))
            {
                // Add full path
                ecFileName path(pszDir);
                path += (const wxChar*) fileName;
                ar.Add(path);
            }
            bMore = dir.GetNext(& fileName);
        }
    }
 
    if (bRecurse)
    {
        // Since wxDir isn't rentrant, we need to gather all the directories
        // first
        wxArrayString ar2;
 
        // Scoping
        {
            wxDir dir(pszDir);
 
            wxString fileName;
 
            bool bMore = dir.GetFirst(& fileName, wxT("*"), wxDIR_DIRS);
            while (bMore)
            {
                if (fileName != wxT(".") && fileName != wxT(".."))
                {
                    // Add full path
                    ecFileName path(pszDir);
                    path += (const wxChar*) fileName;
                    ar2.Add(path);
                }
                bMore = dir.GetNext(& fileName);
            }
        }
 
        unsigned int i;
        for (i = 0; i < ar2.Count(); i++)
        {
            wxString f(ar2[i]);
            FindFiles(f, ar, pszPattern, bRecurse, dwExclude);
        }
    }
 
    return ar.Count();
}
 
void ecFileName::ReplaceExtension(const wxString& newExt)
{
    wxString ext = newExt;
    if (ext[(unsigned) 0] == wxT('.'))
        ext = ext.Mid(1);
 
    wxStripExtension(* this);
    this->wxString::Append(wxT("."));
    this->wxString::Append(ext);
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-3.0/] [host/] [tools/] [configtool/] [standalone/] [wxwin/] [filename.cpp] - Blame information for rev 786

Line No.	Rev	Author	Line
1	786	skrzyp	`// ####ECOSHOSTGPLCOPYRIGHTBEGIN####`
2			`// -------------------------------------------`
3			`// This file is part of the eCos host tools.`
4			`// Copyright (C) 1998, 1999, 2000, 2003, 2005, 2009 Free Software Foundation, Inc.`
5			`//`
6			`// This program is free software; you can redistribute it and/or modify`
7			`// it under the terms of the GNU General Public License as published by`
8			`// the Free Software Foundation; either version 2 or (at your option) any`
9			`// later version.`
10			`//`
11			`// This program is distributed in the hope that it will be useful, but`
12			`// WITHOUT ANY WARRANTY; without even the implied warranty of`
13			`// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU`
14			`// General Public License for more details.`
15			`//`
16			`// You should have received a copy of the GNU General Public License`
17			`// along with this program; if not, write to the`
18			`// Free Software Foundation, Inc., 51 Franklin Street,`
19			`// Fifth Floor, Boston, MA 02110-1301, USA.`
20			`// -------------------------------------------`
21			`// ####ECOSHOSTGPLCOPYRIGHTEND####`
22
23			`#ifdef __GNUG__`
24			`#pragma implementation "filename.h"`
25			`#endif`
26
27			`// Includes other headers for precompiled compilation`
28			`#include "ecpch.h"`
29
30			`#ifdef __BORLANDC__`
31			`#pragma hdrstop`
32			`#endif`
33
34			`#ifdef __CYGWIN__`
35			`#include <sys/cygwin.h> /* for cygwin_conv_to_posix_path() */`
36			`#endif`
37
38			`#include "wx/filefn.h"`
39			`#include "wx/confbase.h" // For wxExpandEnvVars`
40
41			`#include "filename.h"`
42
43			`#ifdef __WXMSW__`
44			`//#include <direct.h>`
45			`//#include <dos.h>`
46
47			`#include <windows.h>`
48			`#include <shlwapi.h>`
49
50			`#include "wx/msw/winundef.h"`
51			`#ifdef CreateDirectory`
52			`#undef CreateDirectory`
53			`#endif`
54			`#ifdef ExpandEnvironmentStrings`
55			`#undef ExpandEnvironmentStrings`
56			`#endif`
57			`#ifdef GetCurrentDirectory`
58			`#undef GetCurrentDirectory`
59			`#endif`
60			`#ifdef SetCurrentDirectory`
61			`#undef SetCurrentDirectory`
62			`#endif`
63			`#ifdef GetTempPath`
64			`#undef GetTempPath`
65			`#endif`
66
67			`#else`
68
69			`// #include <dir.h>`
70			`#endif`
71
72			`#include <sys/stat.h>`
73
74			`#define wxTChar wxT`
75
76			`#ifdef __WXMSW__`
77			`const wxChar ecFileName::cSep=wxT('\\');`
78			`#else`
79			`const wxChar ecFileName::cSep=wxFILE_SEP_PATH;`
80			`#endif`
81
82
83			`ecFileName::ecFileName(const wxChar* psz1,const wxChar* psz2):`
84			`wxString(psz1)`
85			`{`
86			`Normalize();`
87			`operator+=(psz2);`
88			`}`
89
90			`ecFileName::ecFileName(const wxChar* psz1,const wxChar* psz2,const wxChar* psz3):`
91			`wxString(psz1)`
92			`{`
93			`Normalize();`
94			`operator+=(psz2);`
95			`operator+=(psz3);`
96			`}`
97
98			`ecFileName::ecFileName(const wxChar* psz1,const wxChar* psz2,const wxChar* psz3,const wxChar* psz4):`
99			`wxString(psz1)`
100			`{`
101			`Normalize();`
102			`operator+=(psz2);`
103			`operator+=(psz3);`
104			`operator+=(psz4);`
105			`}`
106
107			`ecFileName::ecFileName(const wxChar* psz1,const wxChar* psz2,const wxChar* psz3,const wxChar* psz4,const wxChar* psz5):`
108			`wxString(psz1)`
109			`{`
110			`operator+=(psz2);`
111			`operator+=(psz3);`
112			`operator+=(psz4);`
113			`operator+=(psz5);`
114			`}`
115
116			`/*`
117			`ecFileName::~ecFileName()`
118			`{`
119			`// Unfortunately we can't do this since GetStringData is private in wxString.`
120			`// So for now, we may memory leaks since ~wxString is not virtual.`
121			`//GetStringData()->Unlock();`
122			`}`
123			`*/`
124
125			`ecFileName operator+(const ecFileName& string1, const ecFileName& string2)`
126			`{`
127			`ecFileName s;`
128			`s.ConcatCopy(string1, string2);`
129			`return s;`
130			`}`
131
132			`ecFileName operator+(const ecFileName& string, const wxChar* lpsz)`
133			`{`
134			`if (lpsz == NULL)`
135			`return string;`
136
137			`ecFileName s;`
138			`s.ConcatCopy(string, wxString(lpsz));`
139			`return s;`
140			`}`
141
142			`ecFileName operator+(const wxChar* lpsz, const ecFileName& string)`
143			`{`
144			`if (lpsz == NULL)`
145			`return string;`
146
147			`ecFileName s;`
148			`s.ConcatCopy(wxString(lpsz), string);`
149			`return s;`
150			`}`
151
152			`ecFileName operator+(const ecFileName& string1, wxChar ch)`
153			`{`
154			`ecFileName s;`
155			`s.ConcatCopy(string1, wxString(ch));`
156			`return s;`
157			`}`
158
159			`ecFileName operator+(wxChar ch, const ecFileName& string)`
160			`{`
161			`ecFileName s;`
162			`s.ConcatCopy(wxString(ch), string);`
163			`return s;`
164			`}`
165
166			`const ecFileName& ecFileName::operator+=(const wxChar* lpsz)`
167			`{`
168			`if (lpsz == NULL)`
169			`return *this;`
170
171			`ConcatInPlace(wxString(lpsz));`
172			`return *this;`
173			`}`
174
175			`const ecFileName& ecFileName::operator+=(wxChar ch)`
176			`{`
177			`ConcatInPlace(wxString(ch));`
178			`return *this;`
179			`}`
180
181			`const ecFileName& ecFileName::operator+=(const ecFileName& string)`
182			`{`
183			`ConcatInPlace(string);`
184			`return *this;`
185			`}`
186
187			`void ecFileName::ConcatInPlace(const wxString& src)`
188			`{`
189			`ConcatCopy(* this, src);`
190			`}`
191
192			`void ecFileName::ConcatCopy(const wxString& src1,`
193			`const wxString& src2)`
194			`{`
195			`int nSrc1Len = src1.Len();`
196			`int nSrc2Len = src2.Len();`
197			`int n=1;`
198			`int nNewLen = nSrc1Len + nSrc2Len;`
199			`if(nSrc1Len>0)`
200			`{`
201			`if(1==nSrc2Len && cSep==src2[0])`
202			`{`
203			`// Appending a single separator to a non-null string is a no-op`
204			`return;`
205			`} else {`
206			`// Count the intervening separators`
207			`n=(cSep==src1[nSrc1Len-1])+(cSep==src2[0]);`
208
209			`switch(n){`
210			`case 0:`
211			`(*this) = src1 + wxString(cSep) + src2;`
212			`break;`
213			`case 1:`
214			`(*this) = src1 + src2;`
215			`break;`
216			`case 2:`
217			`(*this) = src1 + src2.Mid(1);`
218			`break;`
219			`}`
220			`return;`
221			`}`
222			`}`
223			`}`
224
225			`void ecFileName::Normalize()`
226			`{`
227			`// Remove any trailing seperator`
228			`int len = Len();`
229			`if (len > 0 && (*this)[(size_t)(len - 1)] == cSep)`
230			`(*this) = Mid(0, len - 1);`
231			`}`
232
233
234			`const ecFileName ecFileName::FullName() const`
235			`{`
236			`#ifdef __WXMSW__`
237			`TCHAR* pFile;`
238			`long dwSize=::GetFullPathName (*this, 0, NULL, &pFile);`
239			`if(dwSize>0){`
240			`wxString strCopy;`
241			`::GetFullPathName (*this, 1+dwSize, strCopy.GetWriteBuf(1+dwSize), &pFile);`
242			`strCopy.UngetWriteBuf();`
243			`return strCopy;`
244			`} else {`
245			`return *this;`
246			`}`
247			`#else`
248			`return wxGetCwd() + wxString(cSep) + wxString(*this);`
249			`#endif`
250			`}`
251
252			`const ecFileName ecFileName::ShortName() const`
253			`{`
254			`#ifdef __WXMSW__`
255			`long dwSize=::GetShortPathName (*this, NULL, 0);`
256			`if(dwSize>0){`
257			`wxString strCopy;`
258			`::GetShortPathName (*this, strCopy.GetWriteBuf(1+dwSize), 1+dwSize);`
259			`strCopy.UngetWriteBuf();`
260			`return strCopy;`
261			`} else {`
262			`return *this;`
263			`}`
264			`#else`
265			`return *this;`
266			`#endif`
267			`}`
268
269			`const ecFileName ecFileName::NoSpaceName() const// sans spaces`
270			`{`
271			`#ifndef __WXMSW__`
272			`return *this;`
273			`#else`
274			`// Only replace components with spaces with FAT names.`
275			`wxArrayString ar1,ar2;`
276			`const wxString str2(ShortName());`
277
278			`size_t i,pcStart;`
279
280			`unsigned int len = Len();`
281			`pcStart = 0;`
282			`for (i = 0; i < len; i++)`
283			`{`
284			`if(wxTChar('\\')==(*this)[i])`
285			`{`
286			`ar1.Add(this->Mid(pcStart, i - pcStart + 1));`
287			`pcStart = i + 1;`
288			`}`
289			`}`
290			`ar1.Add(this->Mid(pcStart, i - pcStart + 1));`
291
292			`len = str2.Len();`
293			`pcStart = 0;`
294			`for (i = 0; i < len; i++)`
295			`{`
296			`if(wxTChar('\\')==str2[i])`
297			`{`
298			`ar2.Add(str2.Mid(pcStart, i - pcStart + 1));`
299			`pcStart = i + 1;`
300			`}`
301			`}`
302			`ar2.Add(str2.Mid(pcStart, i - pcStart + 1));`
303
304			`wxASSERT(ar1.Count()==ar2.Count());`
305
306			`wxString rc;`
307			`for(i=0;i<ar1.Count();i++){`
308			`rc+=(-1==ar1[i].Find(wxTChar(' ')))?ar1[i]:ar2[i];`
309			`}`
310			`return rc;`
311			`#endif`
312			`}`
313
314			`//`
315			`const ecFileName ecFileName::Tail() const`
316			`{`
317			`return AfterLast(cSep);`
318			`}`
319
320			`const ecFileName ecFileName::Head() const`
321			`{`
322			`return BeforeLast(cSep);`
323			`}`
324
325			`time_t ecFileName::LastModificationTime() const`
326			`{`
327			`return wxFileModificationTime(* this);`
328
329			`#if 0`
330			`// GetFileAttributes is not available in Win95 so we test the water first`
331			`static HINSTANCE hInst=LoadLibrary(_T("kernel32.dll"));`
332			`wxASSERT(hInst);`
333
334			`#ifdef _UNICODE`
335			`#define GETFILEATTRIBUTESNAME "GetFileAttributesExW"`
336			`#else`
337			`#define GETFILEATTRIBUTESNAME "GetFileAttributesExA"`
338			`#endif // !UNICODE`
339
340			`typedef BOOL (WINAPI GetFileAttributesP)(const wxChar,GET_FILEEX_INFO_LEVELS,LPVOID);`
341
342			`static GetFileAttributesP p=(GetFileAttributesP)GetProcAddress(hInst,GETFILEATTRIBUTESNAME);`
343			`if(p){`
344			`WIN32_FILE_ATTRIBUTE_DATA data;`
345
346			`if((p)(this, GetFileExInfoStandard, (LPVOID)&data)){`
347			`return data.ftLastWriteTime;`
348			`}`
349			`} else {`
350			`HANDLE h=CreateFile(*this,0,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);`
351			`FILETIME ft;`
352			`if(INVALID_HANDLE_VALUE!=h){`
353			`BOOL b=::GetFileTime(h,NULL,NULL,&ft);`
354			`::CloseHandle(h);`
355			`if(b){`
356			`return ft;`
357			`}`
358			`}`
359			`}`
360			`static FILETIME ftNull={0,0};`
361			`return ftNull;`
362			`#endif`
363			`}`
364
365			`/* TODO`
366			`bool ecFileName::SetFileAttributes(long dwFileAttributes) const`
367			`{`
368			`return ::SetFileAttributes (*this, dwFileAttributes)!=0;`
369			`}`
370			`*/`
371
372			`bool ecFileName::Exists () const`
373			`{`
374			`return IsFile() \|\| IsDir() ;`
375			`}`
376
377			`bool ecFileName::IsDir () const`
378			`{`
379			`#if wxCHECK_VERSION(2, 6, 0)`
380			`return (wxDirExists(* this));`
381			`#else`
382			`return wxPathExists(* this);`
383			`#endif`
384			`}`
385
386			`bool ecFileName::IsFile () const`
387			`{`
388			`#if defined(__WXMAC__)`
389			`struct stat stbuf;`
390			`if (filename && stat (wxUnix2MacFilename(filename), &stbuf) == 0 )`
391			`return TRUE;`
392			`return FALSE ;`
393			`#else`
394			`wxStructStat st;`
395			`if ((*this) != wxT("") && wxStat (wxFNSTRINGCAST fn_str(), &st) == 0 && (st.st_mode & S_IFREG))`
396			`return TRUE;`
397
398			`return FALSE;`
399			`#endif`
400			`}`
401
402			`bool ecFileName::IsReadOnly () const`
403			`{`
404			`#ifdef __WXMSW__`
405			`long a=GetFileAttributes(* this); return 0xFFFFFFFF!=a && (0!=(a&FILE_ATTRIBUTE_READONLY ));`
406			`#else`
407			`wxFAIL_MSG("ecFileName::IsReadOnly not supported on this platform.");`
408			`return FALSE;`
409			`#endif`
410			`}`
411
412			`bool ecFileName::SameFile(const ecFileName &o) const`
413			`{`
414			`#ifdef __WXMSW__`
415			`return 0==ShortName().CmpNoCase(o.ShortName());`
416			`#else`
417			`// On most other platforms, case is important.`
418			`return o == (*this);`
419			`#endif`
420			`}`
421
422			`ecFileName ecFileName::EC_ExpandEnvironmentStrings(const wxChar* psz)`
423			`{`
424			`// wxExpandEnvVars is from confbase.h`
425
426			`ecFileName f = wxExpandEnvVars(psz);`
427			`return f;`
428			`}`
429
430			`const ecFileName& ecFileName::EC_ExpandEnvironmentStrings()`
431			`{`
432			`this=ecFileName::EC_ExpandEnvironmentStrings(this);`
433			`return *this;`
434			`}`
435
436			`#if 0`
437			`// Helper for Relative() psz is in full format.`
438			`ecFileName ecFileName::Drive(const wxChar* psz)`
439			`{`
440			`if(wxIsalpha(psz[0])){`
441			`return psz[0];`
442			`} else if(cSep==psz[0]&&cSep==psz[1]){`
443			`wxChar *c=_tcschr(psz+2,cSep);`
444			`if(c){`
445			`c=_tcschr(c+1,cSep);`
446			`if(c){`
447			`return wxString(psz,c-psz);`
448			`}`
449			`}`
450			`}`
451			`return _T("");`
452			`}`
453			`#endif`
454
455			`ecFileName ecFileName::Relative(const wxChar* compare,const wxChar* current)`
456			`{`
457			`#ifdef __WXMSW__`
458			`wxString rc;`
459			`bool b=(TRUE==PathRelativePathTo(rc.GetWriteBuf(1+MAX_PATH),current,FILE_ATTRIBUTE_DIRECTORY,compare,0));`
460			`rc.UngetWriteBuf();`
461			`return b?(ecFileName)rc:(ecFileName)compare;`
462			`#else`
463			`wxFAIL_MSG("ecFileName::Relative not implemented on this platform.");`
464			`return ecFileName();`
465			`#endif`
466			`}`
467
468			`const ecFileName& ecFileName::MakeRelative(const wxChar* pszRelativeTo)`
469			`{`
470			`this=ecFileName::Relative(this,pszRelativeTo);`
471			`return *this;`
472			`}`
473
474
475			`ecFileName ecFileName::EC_GetCurrentDirectory()`
476			`{`
477			`ecFileName f;`
478			`f = wxGetCwd();`
479			`f.Normalize();`
480
481			`return f;`
482			`}`
483
484
485			`const ecFileName& ecFileName::Append(const wxChar* lpsz)`
486			`{`
487			`if (lpsz)`
488			`return *this;`
489
490			`//wxString::ConcatInPlace(lpsz);`
491			`wxString::Append(lpsz);`
492			`return *this;`
493
494			`}`
495
496			`const ecFileName& ecFileName::Append(wxChar ch)`
497			`{`
498			`ConcatInPlace(wxString(ch));`
499			`return *this;`
500			`}`
501
502			`bool ecFileName::IsAbsolute() const`
503			`{`
504			`int nLength=Len();`
505			`const wxString& psz=*this;`
506			`return`
507			`(nLength>0 && (cSep==psz[0]))\|\| // starts with '\'`
508			`(nLength>1 && (`
509			`(wxIsalpha(psz[0]) && wxTChar(':')==psz[1]) \|\| // starts with [e.g.] "c:\"`
510			`(cSep==psz[0] && cSep==psz[1]))); // UNC`
511			`}`
512
513			`// TODO (?)`
514			`#if 0`
515			`// Return an array of filename pieces. Plugs '\0's into 'this', which`
516			`// is therefore subsequently only usable as referenced by the returned array.`
517			`const wxChar* *ecFileName::Chop()`
518			`{`
519			`wxChar *c;`
520			`// Count the separators`
521			`int nSeps=0;`
522			`for(c=_tcschr(m_pchData,cSep);c;c=_tcschr(c+1,cSep)){`
523			`nSeps++;`
524			`}`
525			`const wxChar* ar=new const wxChar[2+nSeps]; // +1 for first, +1 for terminating 0`
526			`ar[0]=m_pchData;`
527			`int i=1;`
528			`for(c=_tcschr(m_pchData,cSep);c;c=_tcschr(c+1,cSep)){`
529			`ar[i++]=c+1;`
530			`*c=wxTChar('\0');`
531			`}`
532			`ar[i]=0;`
533			`return ar;`
534			`}`
535			`#endif`
536
537			`ecFileName ecFileName::EC_GetTempPath()`
538			`{`
539			`ecFileName f;`
540			`#ifdef __WXMSW__`
541			`#ifdef _UNICODE`
542			`::GetTempPathW(1+MAX_PATH,f.GetWriteBuf(1+MAX_PATH));`
543			`#else`
544			`::GetTempPathA(1+MAX_PATH,f.GetWriteBuf(1+MAX_PATH));`
545			`#endif`
546			`f.UngetWriteBuf();`
547			`#elif defined(__WXGTK__)`
548			`#else`
549			`wxFAIL("ecFileName::GetTempPath() not implemented on this platform.");`
550			`#endif`
551			`f.Normalize();`
552			`return f;`
553			`}`
554
555			`const ecFileName ecFileName::CygPath () const`
556			`{`
557			`#ifdef __WXMSW__`
558			`ecFileName rc = NoSpaceName();`
559			`#ifdef __CYGWIN__`
560			`char buffer [MAX_PATH + 1];`
561			`cygwin_conv_to_posix_path (rc.c_str (), buffer);`
562			`rc = buffer;`
563			`#else`
564			`if(wxIsalpha(rc[(size_t)0]) && wxTChar(':')==rc[(size_t)1])`
565			`{`
566			`// Convert c:\ to /cygdrive/c/`
567			`wxString s = wxString(wxT("/cygdrive/")) + wxString(rc[(size_t)0]) + rc.Mid(2);`
568			`rc = s;`
569			`}`
570			`size_t i;`
571			`for (i = 0; i < rc.Len(); i++)`
572			`{`
573			`if (rc[i] == wxTChar('\\'))`
574			`rc[i] = wxTChar('/');`
575			`}`
576			`#endif`
577			`#else`
578			`const ecFileName& rc = * this;`
579			`#endif`
580
581			`return rc;`
582			`}`
583
584			`bool ecFileName::EC_CreateDirectory(bool bParentsToo,bool bFailIfAlreadyExists) const`
585			`{`
586			`if(bParentsToo)`
587			`{`
588			`// Create intermediate directories`
589
590			`// 'rest' will progressively have its separators replaced by underscores in order`
591			`// to find the next separator`
592			`wxString rest = * this;`
593			`size_t lastPos = 0;`
594			`int len = rest.Len();`
595
596			`#ifdef __WXMSW__`
597			`// If the path is a network path, ignore the first part of the path`
598			`if (len > 2 && (rest.GetChar(0) == wxT('\\') \|\| rest.GetChar(0) == wxT('/')) && (rest.GetChar(1) == wxT('\\') \|\| rest.GetChar(1) == wxT('/')))`
599			`{`
600			`rest.SetChar(0,wxT('_')); rest.SetChar(1,wxT('_'));`
601			`lastPos = rest.Find(cSep);`
602			`if (lastPos != -1 && lastPos >= 0)`
603			`rest.SetChar(lastPos,wxT('_'));`
604			`}`
605			`#endif`
606
607			`while (lastPos != -1)`
608			`{`
609			`lastPos = rest.Find(cSep);`
610			`if (lastPos != -1 && lastPos >= 0)`
611			`{`
612			`rest[lastPos] = wxT('_'); // So we find the NEXT separator`
613
614			`// don't attempt to create "C: or /"`
615			`if (lastPos > 0 && (*this)[lastPos-1] == wxT(':'))`
616			`continue;`
617			`else if (lastPos == 0)`
618			`continue;`
619			`}`
620
621			`// Fail if any of the dirs exist already`
622			`wxString str(this->Mid(0, lastPos));`
623			`bool alreadyExists = wxDirExists(str);`
624			`if (alreadyExists && bFailIfAlreadyExists)`
625			`return FALSE;`
626
627			`if (!alreadyExists)`
628			`if (!wxMkdir(str))`
629			`return FALSE;`
630			`}`
631			`}`
632
633
634			`return IsDir()? (!bFailIfAlreadyExists) : (TRUE==wxMkdir(*this));`
635			`}`
636
637
638			`const wxString ecFileName::Extension() const`
639			`{`
640			`wxString path, name, ext;`
641
642			`wxSplitPath(*this, & path, & name, & ext);`
643			`return ext;`
644			`}`
645
646			`const wxString ecFileName::Root() const`
647			`{`
648			`return wxPathOnly(*this);`
649			`}`
650
651			`ecFileName ecFileName::EC_SetCurrentDirectory(const wxChar* pszDir)`
652			`{`
653			`const ecFileName strPwd=wxGetCwd();`
654			`if (::wxSetWorkingDirectory(pszDir))`
655			`return strPwd;`
656			`else`
657			`return wxT("");`
658			`}`
659
660			`bool ecFileName::RecursivelyDelete()`
661			`{`
662			`wxArrayString ar;`
663			`int i;`
664			`for(i=FindFiles(*this,ar)-1;i>=0;--i){`
665			`wxRemoveFile(ar[i]);`
666			`}`
667			`for(i=FindFiles(this,ar,wxT(".*"),TRUE,0)-1;i>=0;--i){`
668			`wxRmdir(ar[i]);`
669			`}`
670			`return TRUE==wxRmdir(*this);`
671			`}`
672
673			`// TODO: take account of dwExclude`
674			`int ecFileName::FindFiles (const wxString& pszDir,wxArrayString &ar,const wxString& pszPattern/=wxT(".")/,bool bRecurse/=TRUE/,long dwExclude/=wxDIR_DIRS\|wxDIR_HIDDEN/)`
675			`{`
676			`ar.Clear();`
677
678			`// Scoping for wxDir`
679			`{`
680			`wxDir dir(pszDir);`
681
682			`wxString fileName;`
683			`bool bMore = dir.GetFirst(& fileName, pszPattern, wxDIR_FILES);`
684			`while (bMore)`
685			`{`
686			`if (fileName != wxT(".") && fileName != wxT(".."))`
687			`{`
688			`// Add full path`
689			`ecFileName path(pszDir);`
690			`path += (const wxChar*) fileName;`
691			`ar.Add(path);`
692			`}`
693			`bMore = dir.GetNext(& fileName);`
694			`}`
695			`}`
696
697			`if (bRecurse)`
698			`{`
699			`// Since wxDir isn't rentrant, we need to gather all the directories`
700			`// first`
701			`wxArrayString ar2;`
702
703			`// Scoping`
704			`{`
705			`wxDir dir(pszDir);`
706
707			`wxString fileName;`
708
709			`bool bMore = dir.GetFirst(& fileName, wxT("*"), wxDIR_DIRS);`
710			`while (bMore)`
711			`{`
712			`if (fileName != wxT(".") && fileName != wxT(".."))`
713			`{`
714			`// Add full path`
715			`ecFileName path(pszDir);`
716			`path += (const wxChar*) fileName;`
717			`ar2.Add(path);`
718			`}`
719			`bMore = dir.GetNext(& fileName);`
720			`}`
721			`}`
722
723			`unsigned int i;`
724			`for (i = 0; i < ar2.Count(); i++)`
725			`{`
726			`wxString f(ar2[i]);`
727			`FindFiles(f, ar, pszPattern, bRecurse, dwExclude);`
728			`}`
729			`}`
730
731			`return ar.Count();`
732			`}`
733
734			`void ecFileName::ReplaceExtension(const wxString& newExt)`
735			`{`
736			`wxString ext = newExt;`
737			`if (ext[(unsigned) 0] == wxT('.'))`
738			`ext = ext.Mid(1);`
739
740			`wxStripExtension(* this);`
741			`this->wxString::Append(wxT("."));`
742			`this->wxString::Append(ext);`
743			`}`