Subversion Repositories openrisc_me

//####COPYRIGHTBEGIN####
//                                                                          
// ----------------------------------------------------------------------------
// Copyright (C) 1998, 1999, 2000 Red Hat, Inc.
//
// This program is part of the eCos host tools.
//
// 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.
//
// ----------------------------------------------------------------------------
//                                                                          
//####COPYRIGHTEND####
#include "stdafx.h"
#include "FileName.h"
#include <shlwapi.h>
 
const TCHAR CFileName::cSep=_TCHAR('\\');
 
CFileName::CFileName(LPCTSTR psz1,LPCTSTR psz2):
CString(psz1)
{
  Normalize();
  operator+=(psz2);
}
 
CFileName::CFileName(LPCTSTR psz1,LPCTSTR psz2,LPCTSTR psz3):
CString(psz1)
{
  Normalize();
  operator+=(psz2);
  operator+=(psz3);
}
 
CFileName::CFileName(LPCTSTR psz1,LPCTSTR psz2,LPCTSTR psz3,LPCTSTR psz4):
CString(psz1)
{
  Normalize();
  operator+=(psz2);
  operator+=(psz3);
  operator+=(psz4);
}
 
CFileName::CFileName(LPCTSTR psz1,LPCTSTR psz2,LPCTSTR psz3,LPCTSTR psz4,LPCTSTR psz5):
CString(psz1)
{
  operator+=(psz2);
  operator+=(psz3);
  operator+=(psz4);
  operator+=(psz5);
}
 
CFileName AFXAPI operator+(const CFileName& string1, const CFileName& string2)
{
  CFileName s;
  s.ConcatCopy(string1.GetData()->nDataLength, string1.m_pchData,
    string2.GetData()->nDataLength, string2.m_pchData);
  return s;
}
 
CFileName AFXAPI operator+(const CFileName& string, LPCTSTR lpsz)
{
  ASSERT(lpsz == NULL || AfxIsValidString(lpsz));
  CFileName s;
  s.ConcatCopy(string.GetData()->nDataLength, string.m_pchData,
    CFileName::SafeStrlen(lpsz), lpsz);
  return s;
}
 
CFileName AFXAPI operator+(LPCTSTR lpsz, const CFileName& string)
{
  ASSERT(lpsz == NULL || AfxIsValidString(lpsz));
  CFileName s;
  s.ConcatCopy(CFileName::SafeStrlen(lpsz), lpsz, string.GetData()->nDataLength,
    string.m_pchData);
  return s;
}
 
CFileName AFXAPI operator+(const CFileName& string1, TCHAR ch)
{
  CFileName s;
  s.ConcatCopy(string1.GetData()->nDataLength, string1.m_pchData, 1, &ch);
  return s;
}
 
CFileName AFXAPI operator+(TCHAR ch, const CFileName& string)
{
  CFileName s;
  s.ConcatCopy(1, &ch, string.GetData()->nDataLength, string.m_pchData);
  return s;
}
 
const CFileName& CFileName::operator+=(LPCTSTR lpsz)
{
  ASSERT(lpsz == NULL || AfxIsValidString(lpsz));
  ConcatInPlace(SafeStrlen(lpsz), lpsz);
  return *this;
}
 
const CFileName& CFileName::operator+=(TCHAR ch)
{
  ConcatInPlace(1, &ch);
  return *this;
}
 
const CFileName& CFileName::operator+=(const CFileName& string)
{
  ConcatInPlace(string.GetData()->nDataLength, string.m_pchData);
  return *this;
}
 
void CFileName::ConcatInPlace(int nSrcLen, LPCTSTR lpszSrcData)
{
  if(nSrcLen>0){
    if(GetLength()>0){
      // Appending a single separator to a non-null string is a no-op
      if(1==nSrcLen && cSep==*lpszSrcData){
        return;
      }
      // Count the intervening separators
      int n=(cSep==m_pchData[GetLength()-1])+(cSep==*lpszSrcData);
      switch(n){
      case 0:
        CString::ConcatInPlace(1, &cSep);
        break;
      case 1:
        break;
      case 2:
        lpszSrcData++;
        nSrcLen--;
        break;
      }
    }
    CString::ConcatInPlace(nSrcLen, lpszSrcData);
  }
}
 
void CFileName::ConcatCopy(int nSrc1Len, LPCTSTR lpszSrc1Data,
                           int nSrc2Len, LPCTSTR lpszSrc2Data)
{
  int n=1;
  int nNewLen = nSrc1Len + nSrc2Len;
  if(nSrc1Len>0){
    if(1==nSrc2Len && cSep==*lpszSrc2Data){
      // Appending a single separator to a non-null string is a no-op
      lpszSrc2Data++;
      nSrc2Len--;
      nNewLen--;
    } else {
      // Count the intervening separators
      n=(cSep==lpszSrc1Data[nSrc1Len-1])+(cSep==*lpszSrc2Data);
 
      switch(n){
      case 0:
        nNewLen++;
        break;
      case 1:
        break;
      case 2:
        lpszSrc2Data++;
        nSrc2Len--;
        nNewLen--;
        break;
      }
    }
  }
  if (nNewLen != 0)
  {
    AllocBuffer(nNewLen);
    memcpy(m_pchData, lpszSrc1Data, nSrc1Len*sizeof(TCHAR));
    LPTSTR p=m_pchData+nSrc1Len;
    if(0==n){
      *p++=cSep;
    }
    memcpy(p, lpszSrc2Data, nSrc2Len*sizeof(TCHAR));
  }
}
 
void CFileName::Normalize()
{
  // Remove any trailing slash
  int &n=GetData()->nDataLength;
  if(n>1 && (cSep==m_pchData[n-1])){
    n--;
    m_pchData[n] = _TCHAR('\0');
  }
}
 
 
const CFileName CFileName::FullName() const
{
  PTCHAR pFile;
  DWORD dwSize=::GetFullPathName (*this, 0, NULL, &pFile);
  if(dwSize>0){
    CString strCopy;
    ::GetFullPathName (*this, 1+dwSize, strCopy.GetBuffer(1+dwSize), &pFile);
    strCopy.ReleaseBuffer();
    return strCopy;
  } else {
    return *this;
  }
}
 
const CFileName CFileName::ShortName() const
{
  DWORD dwSize=::GetShortPathName (*this, NULL, 0);
  if(dwSize>0){
    CString strCopy;
    ::GetShortPathName (*this, strCopy.GetBuffer(1+dwSize), 1+dwSize);
    strCopy.ReleaseBuffer();
    return strCopy;
  } else {
    return *this;
  }
}
 
const CFileName CFileName::NoSpaceName() const// sans spaces
{
  CStringArray ar1,ar2;
  const CString str2(ShortName());
 
  LPCTSTR pc,pcStart;
 
  pcStart=*this;
  for(pc=*this;*pc;pc++){
    if(_TCHAR('\\')==*pc){
      ar1.Add(CString(pcStart,pc-pcStart));
      pcStart=pc;
    }
  }
  ar1.Add(CString(pcStart,pc-pcStart));
 
  pcStart=str2;
  for(pc=str2;*pc;pc++){
    if(_TCHAR('\\')==*pc){
      ar2.Add(CString(pcStart,pc-pcStart));
      pcStart=pc;
    }
  }
  ar2.Add(CString(pcStart,pc-pcStart));
 
  ASSERT(ar1.GetSize()==ar2.GetSize());
 
  CString rc;
  for(int i=0;i<ar1.GetSize();i++){
    rc+=(-1==ar1[i].Find(_TCHAR(' ')))?ar1[i]:ar2[i];
  }
  return rc;
}
 
//
const CFileName CFileName::Tail() const
{
  TCHAR *ch=_tcsrchr(m_pchData,cSep);
  return ch?ch+1:m_pchData;
}
 
const CFileName CFileName::Head() const
{
  TCHAR *ch=_tcsrchr(m_pchData,cSep);
  return ch?CFileName(m_pchData,ch-m_pchData):m_pchData;
}
 
// GetFileAttributes is not available in Win95 so we test the water first
FILETIME CFileName::LastModificationTime() const
{
  static HINSTANCE hInst=LoadLibrary(_T("kernel32.dll"));
  ASSERT(hInst);
 
#ifdef _UNICODE
#define GETFILEATTRIBUTESNAME "GetFileAttributesExW"
#else
#define GETFILEATTRIBUTESNAME "GetFileAttributesExA"
#endif // !UNICODE
 
  typedef BOOL (WINAPI *GetFileAttributesP)(LPCTSTR,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;
}
 
bool CFileName::SetFileAttributes(DWORD dwFileAttributes) const
{
  return ::SetFileAttributes (*this, dwFileAttributes)!=0;
}
 
bool CFileName::SameFile(const CFileName &o) const
{
  return 0==ShortName().CompareNoCase(o.ShortName());
}
 
CFileName CFileName::ExpandEnvironmentStrings(LPCTSTR psz)
{
  // First call simply determines the size
  CFileName f;
  DWORD dwSize=::ExpandEnvironmentStrings(psz, NULL, 0);
  if(dwSize>0){
    ::ExpandEnvironmentStrings(psz, f.GetBuffer(dwSize), dwSize);
    f.ReleaseBuffer();
  } else {
    f=psz;
  }
  return f;
}
 
const CFileName& CFileName::ExpandEnvironmentStrings()
{
  *this=CFileName::ExpandEnvironmentStrings(*this);
  return *this;
}
 
// Helper for Relative()  psz is in full format.
CFileName CFileName::Drive(LPCTSTR psz)
{
  if(_istalpha(psz[0])){
    return psz[0];
  } else if(cSep==psz[0]&&cSep==psz[1]){
    TCHAR *c=_tcschr(psz+2,cSep);
    if(c){
      c=_tcschr(c+1,cSep);
      if(c){
        return CString(psz,c-psz);
      }
    }
  }
  return _T("");
}
 
CFileName CFileName::Relative(LPCTSTR compare,LPCTSTR current)
{
  CString rc;
  bool b=(TRUE==PathRelativePathTo(rc.GetBuffer(1+MAX_PATH),current,FILE_ATTRIBUTE_DIRECTORY,compare,0));
  rc.ReleaseBuffer();
  //TRACE(_T("compare=%s current=%s result=%s (b=%d)\n"),compare,current,b?rc:compare,b);
  return b?rc:compare;
} 
 
const CFileName& CFileName::MakeRelative(LPCTSTR pszRelativeTo)
{
  *this=CFileName::Relative(*this,pszRelativeTo);
  return *this;
}
 
 
CFileName CFileName::GetCurrentDirectory()
{
  CFileName f;
  ::GetCurrentDirectory(1+_MAX_PATH,f.GetBuffer(1+_MAX_PATH));
  f.ReleaseBuffer();
  f.Normalize();
  return f;
}
 
 
const CFileName& CFileName::Append(LPCTSTR lpsz)
{
  ASSERT(lpsz == NULL || AfxIsValidString(lpsz));
  CString::ConcatInPlace(SafeStrlen(lpsz), lpsz);
  return *this;
 
}
 
const CFileName& CFileName::Append(TCHAR ch)
{
  ConcatInPlace(1, &ch);
  return *this;
}
 
bool CFileName::IsAbsolute() const
{
  int nLength=GetLength();
  LPCTSTR psz=*this;
  return 
    (nLength>0 && (cSep==psz[0]))|| // starts with '\'
    (nLength>1 && (
    (_istalpha(psz[0]) && _TCHAR(':')==psz[1]) ||  // starts with [e.g.] "c:\"
    (cSep==psz[0] && cSep==psz[1])));              // UNC
}
 
// Return an array of filename pieces.  Plugs '\0's into 'this', which
// is therefore subsequently only usable as referenced by the returned array.
LPCTSTR *CFileName::Chop()
{
  TCHAR *c;
  // Count the separators
  int nSeps=0;
  for(c=_tcschr(m_pchData,cSep);c;c=_tcschr(c+1,cSep)){
    nSeps++;
  }
  LPCTSTR *ar=new LPCTSTR[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=_TCHAR('\0');
  }
  ar[i]=0;
  return ar;
}
 
CFileName CFileName::GetTempPath()
{
  CFileName f;
  ::GetTempPath(1+_MAX_PATH,f.GetBuffer(1+_MAX_PATH));
  f.ReleaseBuffer();
  f.Normalize();
  return f;
 
}
 
const CFileName CFileName::CygPath () const 
{
  TCHAR buf[2+MAX_PATH];
  LPCTSTR rc=buf+1;
  if(!GetShortPathName(m_pchData,1+buf,MAX_PATH)){
    _tcscpy(1+buf,m_pchData);
  }
  if(_istalpha(*rc)&&_TCHAR(':')==rc[1]){
    // Convert c:\ to //c/ [this is the bit that requires the first char of buf]
    buf[0]=_TCHAR('/');
    buf[2]=buf[1];
    buf[1]=_TCHAR('/');
    rc=buf;
  }
  for(TCHAR *c=buf+1;*c;c++){
    if(_TCHAR('\\')==*c){
      *c=_TCHAR('/');
    }
  }
 
  return rc;
}
 
bool CFileName::CreateDirectory(bool bParentsToo,bool bFailIfAlreadyExists) const
{
  LPCTSTR pszDir=m_pchData;
  if(bParentsToo){
    // Create intermediate directories
    for(LPCTSTR c=_tcschr(pszDir,_TCHAR('\\'));c;c=_tcschr(c+1,_TCHAR('\\'))){
      if(c==pszDir+2 && _istalpha(pszDir[0]) && _TCHAR(':')==pszDir[1]){
        continue; // don't attempt to create "C:"
      }
      const CFileName strDir(pszDir,c-pszDir);
      if(!(strDir.IsDir()? (!bFailIfAlreadyExists) : ::CreateDirectory(strDir,NULL))){
        return false;
      }
    }
  }
  return IsDir()? (!bFailIfAlreadyExists) : (TRUE==::CreateDirectory(pszDir,NULL));
}
 
 
const CString CFileName::Extension() const
{
  LPCTSTR ch=_tcsrchr(m_pchData,_TCHAR('.'));
  if(ch && !_tcschr(ch,cSep)){
    return CString(ch+1);
  } else {
    return _T("");
  }
}
 
const CString CFileName::Root() const
{
  LPCTSTR ch=_tcsrchr(m_pchData,_TCHAR('.'));
  if(ch && !_tcschr(ch,cSep)){
    return CString(m_pchData,ch-m_pchData);
  } else {
    return m_pchData;
  }
}
 
CFileName CFileName::SetCurrentDirectory(LPCTSTR pszDir)
{
  const CFileName strPwd=GetCurrentDirectory();
  return ::SetCurrentDirectory(pszDir)?strPwd:_T("");
}
 
bool CFileName::RecursivelyDelete()
{
  CFileNameArray ar;
  for(int i=FindFiles(*this,ar)-1;i>=0;--i){
    ::DeleteFile(ar[i]);
  }
  for(i=FindFiles(*this,ar,_T("*.*"),true,0)-1;i>=0;--i){
    ::RemoveDirectory(ar[i]);
  }
  return TRUE==::RemoveDirectory(*this);
}
 
int CFileName::FindFiles (LPCTSTR pszDir,CFileNameArray &ar,LPCTSTR pszPattern/*=_T("*.*")*/,bool bRecurse/*=true*/,DWORD dwExclude/*=FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_HIDDEN*/)
{
  ar.RemoveAll();
  CFileFind finder;
  BOOL bMore=finder.FindFile(CFileName(pszDir)+pszPattern);
  while (bMore)    {
    bMore = finder.FindNextFile();
    if(!finder.IsDots() && !finder.MatchesMask(dwExclude)){
      CFileName strFile(finder.GetFilePath());
      ar.Add(strFile);
    }
  }
  if(bRecurse){
    CFileFind finder;
    BOOL bMore=finder.FindFile(CFileName(pszDir)+_T("*.*"));
    while (bMore)    {
      bMore = finder.FindNextFile();
      if(!finder.IsDots() && finder.IsDirectory()){
        CFileNameArray ar2;
        FindFiles(finder.GetFilePath(),ar2,pszPattern,bRecurse,dwExclude);
        ar.Append(ar2);
      }
    }
  }
  return ar.GetSize();
}
 
void CFileName::ReplaceExtension(LPCTSTR pszNewExt)
{
  ASSERT(pszNewExt);
  if(_TCHAR('.')==*pszNewExt){
    // Be tolerant of whether '.' is included in what we are passed:
    pszNewExt++;
  }
  LPTSTR pch=GetBuffer(2+GetLength()+_tcslen(pszNewExt));
  LPTSTR pcExt=_tcsrchr(pch,_TCHAR('.'));
  if(NULL==pcExt || _tcschr(pcExt,cSep)){
    // No existing extension
    pcExt=pch+GetLength();
    *pcExt++=_TCHAR('.');
  }
  _tcscpy(pcExt+1,pszNewExt);
  ReleaseBuffer();
}