Shell编程

开发平台：
Visual C++

adfwrapper.h：源码内容
							#if !defined(AFX_ADFWRAPPER_H__20001226_7276_AC4A_215B_0080AD509054__INCLUDED_)
#define AFX_ADFWRAPPER_H__20001226_7276_AC4A_215B_0080AD509054__INCLUDED_
#pragma once
//
// These classes are C++ wrappers for the ADFlib (Amiga Disk File library).
// ADFlib is developed by Laurent Cl関y.
//
// They do not extend the functionality of ADFlib in any way,
// except that they give me: nice C++ classes, dtor cleanup,
// more const-ness, Windows datatypes, MBCS and UNICODE compilation.
//
#ifndef __ATLBASE_H__
  #error adfwrappers.h requires atlbase.h to be included first
#endif
#ifdef _DEBUG
#pragma comment(lib, "adflib\libs\adfdbg.lib")
#else
#pragma comment(lib, "adflib\libs\adf.lib")
#endif
#include "adflibincludeadflib.h"
extern "C" {
   #include "adflibincludeadf_util.h"
   #include "adflibincludeadf_dir.h"
   #include "adflibincludeWin32adf_nativ.h"
}
extern "C" struct Env adfEnv;
class CAdfDevice;
class CAdfVolume;
class CAdfFile;
class CAdfDirList;
class CAdfDelList;
class CAdf
{
public:
   CAdf()
   {
      // System initialize...
      adfEnvInitDefault();
      // Use the dir cache blocks
      BOOL boolPr = TRUE;
      adfChgEnvProp(PR_USEDIRC, (void*)&boolPr);   
      // Need to set callbacks to prevent Console output
      adfSetEnvFct(ADFError, ADFWarning, ADFVerbose);
      adfEnv.rwhAccess = ADFAccess;
      adfEnv.progressBar = ADFProgress;
      adfEnv.useRWAccess = TRUE;
      adfEnv.useProgressBar = TRUE;
      adfEnv.useDirCache = FALSE;
   }
   virtual ~CAdf()
   {
      // Shutdown ADF system
      adfEnvCleanUp();
   }
   LPCSTR GetVersionNumber() { return adfGetVersionNumber(); };
   LPCSTR GetVersionDate() { return adfGetVersionDate(); };
   BOOL IsSilent() const { return m_bSilent; };
   void SetSilent(BOOL bSilent) { m_bSilent = bSilent; };
// Attributes
private:
   static BOOL m_bSilent; // Supress error/warnings?
                          // Needs to be static because it's used by the callbacks.
// Callbacks
private:
   static VOID ADFError(char *strMessage)
   {
      USES_CONVERSION;
      if( !m_bSilent ) ::MessageBox(NULL, A2CT(strMessage), NULL, MB_OK | MB_ICONERROR);
   }
   static VOID ADFWarning(char *strMessage)
   {
      strMessage;
#ifdef _DEBUG
      USES_CONVERSION;
      if( !m_bSilent ) ::MessageBox(NULL, A2CT(strMessage), _T("Warning"), MB_OK | MB_ICONWARNING);
#endif
   }
   static VOID ADFVerbose(char *strMessage)
   {
      strMessage;
#ifdef _DEBUG
      USES_CONVERSION;
      if( !m_bSilent ) ::MessageBox(NULL, A2CT(strMessage), _T("Verbose Warning"), MB_OK | MB_ICONINFORMATION);
#endif
   }
   static VOID ADFAccess(SECTNUM physical, SECTNUM logical, BOOL write)
   {
      physical;
      logical;
      write;
   }
   static VOID ADFProgress(int perCentDone)
   {
      perCentDone;
   }
};
__declspec(selectany) BOOL CAdf::m_bSilent = FALSE;
class CAdfFile
{
friend CAdfVolume;
protected:
   File *m_file;
public:
   CAdfFile()
   {
      m_file = NULL;
   }
   virtual ~CAdfFile()
   {
      if( m_file!=NULL ) adfCloseFile(m_file);
   }
   BOOL IsOpen() const { return m_file!=NULL; };
   UINT GetType() const { return m_file->fileHdr->secType; };
   
   BOOL IsDirectory() const { return _IsDirectory(GetType()); };
   
   BOOL IsLink() const { return _IsLink(GetType()); };
   ULONG Read(LPVOID pv, ULONG cb)
   {
      return (ULONG)adfReadFile(m_file, cb, (unsigned char *)pv);
   }
   ULONG Write(LPCVOID pv, ULONG cb)
   {
      return (ULONG)adfWriteFile(m_file, cb, (unsigned char *)pv);
   }
   BOOL Eof()
   {
      return adfEndOfFile(m_file);
   }
   BOOL Seek(DWORD dwPos)
   {
      adfFileSeek(m_file, dwPos);
      return TRUE; // Erh?
   }
   DWORD GetPos() const
   {
      return m_file->pos;
   }
   DWORD GetAccess() const
   {
      return m_file->fileHdr->access;
   }
   static void ConvertAccess(DWORD dwAccess, LPTSTR pstrAccess)
   {
      USES_CONVERSION;
      _tcscpy( pstrAccess, A2CT(adfAccess2String(dwAccess)) );
   }
   FILETIME GetFileTime()
   {
      int y,m,d;
      adfDays2Date(m_file->fileHdr->days, &y, &m, &d);
      SYSTEMTIME st;
      st.wYear = (WORD)y;
      st.wMonth = (WORD)m;
      st.wDay = (WORD)d;
      st.wHour = (WORD)((m_file->fileHdr->mins / 60)+1);
      st.wMinute = (WORD)((m_file->fileHdr->mins % 60)+1);
      st.wSecond = (WORD)((m_file->fileHdr->ticks / 50));
      FILETIME ft;
      ::SystemTimeToFileTime(&st, &ft);
      FILETIME ftLocal;
      ::FileTimeToLocalFileTime(&ft, &ftLocal);
      return ftLocal;
   }
   void Flush()
   {
      adfFlushFile(m_file);
   }
   void Close()
   {
      adfCloseFile(m_file);
      m_file = NULL;
   }
   void GetName(LPTSTR pstrName, UINT cbChars)
   {
      USES_CONVERSION;
      cbChars--;
      _tcsncpy( pstrName, m_file->fileHdr->fileName==NULL ? _T("") : A2CT(m_file->fileHdr->fileName), cbChars);
      if( m_file->fileHdr->nameLen < (int)cbChars ) cbChars = (UINT)m_file->fileHdr->nameLen;
      pstrName[cbChars] = _T('');
   }
   DWORD GetSize() const
   {
      return m_file->fileHdr->byteSize;
   }
   DWORD GetActualSize(DWORD dwDataBlockSize=LOGICAL_BLOCK_SIZE)
   {
      return _CalcBlocksNeeded(GetSize(), dwDataBlockSize);
   }
   static DWORD _CalcBlocksNeeded(DWORD dwFileSize, DWORD dwDataBlockSize=LOGICAL_BLOCK_SIZE)
   {
      return (DWORD)adfFileRealSize(dwFileSize, dwDataBlockSize, NULL, NULL);
   }
   static BOOL _IsDirectory(DWORD dwAccess)
   {
      return dwAccess==ST_DIR || dwAccess==ST_LDIR;
   }
   static BOOL _IsLink(DWORD dwAccess)
   {
      return dwAccess==ST_LDIR || dwAccess==ST_LFILE || dwAccess==ST_LSOFT;
   }
};
class CAdfDirList
{
friend CAdfVolume;
protected:
   List *m_list;
public:
   CAdfDirList()
   {
      m_list = NULL;
   }
   virtual ~CAdfDirList()
   {
      if( m_list!=NULL ) adfFreeDirList(m_list);
   }
   operator List *() const
   {
      return m_list;
   };
};
class CAdfDelList
{
friend CAdfVolume;
protected:
   List *m_list;
public:
   CAdfDelList()
   {
      m_list = NULL;
   }
   virtual ~CAdfDelList()
   {
      if( m_list!=NULL ) adfFreeDelList(m_list);
   }
   operator List *() const
   {
      return m_list;
   };
};
class CAdfVolume
{
friend CAdfDevice;
protected:
   Volume *m_vol;
public:
   CAdfVolume()
   {
      m_vol = NULL;
   }
   virtual ~CAdfVolume()
   {
      if( m_vol!=NULL ) adfUnMount(m_vol);
   }
   BOOL IsOpen() const { return m_vol!=NULL; };
   void GetName(LPTSTR pstrName, UINT cbChars)
   {
      USES_CONVERSION;
      cbChars--;
      _tcsncpy( pstrName, m_vol->volName==NULL ? _T("") : A2CT(m_vol->volName), cbChars);
      pstrName[cbChars] = _T('');
   }
   
   SECTNUM GetDirectoryPtr() const { return m_vol->curDirPtr; };
   
   SECTNUM GetFirstBlock() const { return m_vol->firstBlock; };
   
   SECTNUM GetLastBlock() const { return m_vol->lastBlock; };
   
   SECTNUM GetRootBlock() const { return m_vol->rootBlock; };
   
   DWORD GetDataBlockSize() const { return m_vol->datablockSize; };
   
   DWORD GetFreeBlockCount() { return adfCountFreeBlocks(m_vol); };
   
   BOOL IsBootable() const { return m_vol->bootCode; };
   
   BOOL IsReadOnly() const { return m_vol->readOnly; };
   
   int GetDOSType() const { return (int)(m_vol->dosType); };
   BOOL GetFile(LPCTSTR pstrFileName, LPCTSTR pstrAccess, CAdfFile &AmigaFile)
   {
      USES_CONVERSION;
      
      File * file = adfOpenFile(m_vol, 
         T2A(const_cast<LPTSTR>(pstrFileName)), 
         T2A(const_cast<LPTSTR>(pstrAccess)));
      if( file==NULL ) return FALSE;
      AmigaFile.m_file = file;
      return TRUE;
   }
   BOOL CreateDirectory(SECTNUM nSector, LPCTSTR pstrName)
   {
      USES_CONVERSION;
      return adfCreateDir(m_vol, nSector, T2A(const_cast<LPTSTR>(pstrName)))==RC_OK;
   }
   BOOL GetDirctory(SECTNUM nSector, CAdfDirList &DirList)
   {
      List *dir = adfGetDirEnt(m_vol, nSector);
      if( dir==NULL ) return TRUE;   // Empty?
      DirList.m_list = dir;
      return TRUE;
   }
   
   BOOL GetCurrentDirctory(CAdfDirList &DirList)
   {
      return GetDirctory(GetDirectoryPtr(), DirList);
   }
   BOOL ChangeDirectoryParent()
   {
      return( adfParentDir(m_vol)==RC_OK );
   }
   BOOL ChangeDirectory(LPCTSTR pstrPath)
   {
      USES_CONVERSION;
      if( *pstrPath==_T('') ) return TRUE;
      // In the case where only one subdir is requested we just pass
      // the value.
      // This is the only type ADFlib supports.
      if( *pstrPath!=_T('/') ) return adfChangeDir(m_vol, T2A(const_cast<LPTSTR>(pstrPath)))==RC_OK;
      // If a complete path is given, we need to do the parsing
      // ourselves! So start by going to root dir..
      pstrPath++;
      adfToRootDir(m_vol);
      // then parse remaining sub-dirs
      LPTSTR p;
      while( (p = _tcschr(pstrPath, _T('/')))!=NULL ) {
         TCHAR szPath[MAXNAMELEN+1];
         int size = p - pstrPath;
         _tcsncpy( szPath, pstrPath, size);
         szPath[ size ] = _T('');
         if( adfChangeDir(m_vol, T2A(szPath))!=RC_OK ) return FALSE;
         pstrPath = p+1;
      }
      if( *pstrPath!=_T('') ) {
         return adfChangeDir(m_vol, T2A(const_cast<LPTSTR>(pstrPath)))==RC_OK;
      }
      return TRUE;
   }
   BOOL GetDeletedEntries(CAdfDelList &DelList)
   {
      List *dir = adfGetDelEnt(m_vol);
      if( dir==NULL ) return TRUE;   // Empty?
      DelList.m_list = dir;
      return TRUE;
   }
   BOOL CheckDeletedFile(SECTNUM nSector, int nLevel=0)
   {
      return adfCheckEntry(m_vol, nSector, nLevel)==RC_OK;
   }
   BOOL UndeleteFile(SECTNUM nParentSector, SECTNUM nSector)
   {
      return adfUndelEntry(m_vol, nParentSector, nSector)==RC_OK;
   }
   BOOL SetFileAccess(LPCTSTR pstrName, SECTNUM nSector, DWORD dwAccess)
   {
      USES_CONVERSION;
      return adfSetEntryAccess(m_vol,  nSector, T2A(const_cast<LPTSTR>(pstrName)), (long)dwAccess)==RC_OK;
   }
   BOOL SetFileComment(LPCTSTR pstrName, SECTNUM nSector, LPCTSTR pstrComment)
   {
      USES_CONVERSION;
      return adfSetEntryComment(m_vol, nSector, T2A(const_cast<LPTSTR>(pstrName)), T2A(const_cast<LPTSTR>(pstrComment)))==RC_OK;
   }
   BOOL Rename(SECTNUM nOldSector, LPCTSTR pstrOldName,
               SECTNUM nNewSector, LPCTSTR pstrNewName)
   {
      USES_CONVERSION;
      return adfRenameEntry(m_vol, 
                            nOldSector, T2A(const_cast<LPTSTR>(pstrOldName)), 
                            nNewSector, T2A(const_cast<LPTSTR>(pstrNewName)))==RC_OK;
   }
   BOOL Delete(SECTNUM nParentSector, LPCTSTR pstrName)
   {
      USES_CONVERSION;
      return adfRemoveEntry(m_vol, nParentSector, T2A(const_cast<LPTSTR>(pstrName)))==RC_OK;
   }
};
class CAdfDevice
{
protected:
   Device *m_dev;
public:
   CAdfDevice()
   {
      m_dev = NULL;
   }
   virtual ~CAdfDevice()
   {
      if( m_dev!=NULL ) adfUnMountDev(m_dev);
   }
   static BOOL _IsNativeDevice(LPCTSTR pstrDeviceName)
   {
      USES_CONVERSION;
      nativeFunctions *nFct = (struct nativeFunctions *)adfEnv.nativeFct;
      return (*nFct->adfIsDevNative)(T2A(const_cast<LPTSTR>(pstrDeviceName)));
   }
   BOOL IsOpen() const { return m_dev!=NULL; };
   BOOL Open(LPCTSTR pstrFileName, BOOL bReadOnly=FALSE)
   {
      USES_CONVERSION;
      m_dev = adfMountDev(T2A(const_cast<LPTSTR>(pstrFileName)), bReadOnly);
      if( m_dev==NULL ) return FALSE;
      switch( m_dev->devType ) {
      case DEVTYPE_FLOPDD:
      case DEVTYPE_FLOPHD:
      case DEVTYPE_HARDDISK:
      case DEVTYPE_HARDFILE:
         break;
      case -1:
         // Invalid device read! ADFlib will crash on adfUnMountDev()
         // BUG: Causes memory-leak.
         m_dev = NULL;
         return FALSE;
      }
      return TRUE;
   }
   
   BOOL Close()
   {
      if( m_dev==NULL ) return TRUE;
      adfUnMountDev(m_dev);
      return TRUE;
   }
   UINT GetType() const { return m_dev->devType; };
   
   BOOL IsReadOnly() const { return m_dev->readOnly; };
   
   DWORD GetDiskSize() const { return m_dev->size; };
   
   DWORD GetPartitionCount() const { return m_dev->nVol; };
   BOOL Mount(DWORD nPartition, BOOL bReadOnly, CAdfVolume &volume)
   {
      Volume *vol = adfMount(m_dev, (int)nPartition, bReadOnly);
      if( vol==NULL ) return FALSE;      
      volume.m_vol = vol;
      return TRUE;
   }
};
#endif // !defined(AFX_ADFWRAPPER_H__20001226_7276_AC4A_215B_0080AD509054__INCLUDED_)

						