home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgLangD.iso / C++-7 / DISK10 / MFC / SRC / FILE.CP$ / file
Encoding:
Text File  |  1992-03-17  |  12.4 KB  |  589 lines
  1. // This is a part of the Microsoft Foundation Classes C++ library.
  2. // Copyright (C) 1992 Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Microsoft Foundation Classes Reference and Microsoft
  7. // QuickHelp documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Microsoft Foundation Classes product.
  10.  
  11. #ifdef _WINDOWS
  12. #include "afxwin.h"
  13. #else
  14. #include "afx.h"
  15. #endif
  16. #pragma hdrstop
  17.  
  18. #include <errno.h>
  19. #include <io.h>
  20. #include <limits.h>
  21. #include <malloc.h>
  22.  
  23. #ifdef _DOSWIN
  24. #include <sys\types.h>
  25. #include <sys\stat.h>
  26. #endif
  27.  
  28. #include "dosio_.h"
  29.  
  30. #ifdef AFX_CORE_SEG
  31. #pragma code_seg(AFX_CORE_SEG)
  32. #endif
  33.  
  34. #ifdef _DEBUG
  35. #undef THIS_FILE
  36. static char BASED_CODE THIS_FILE[] = __FILE__;
  37. #endif
  38.  
  39. #define new DEBUG_NEW
  40.  
  41. ////////////////////////////////////////////////////////////////////////////
  42.  
  43. #ifdef _DOSWIN
  44.  
  45. // DOS INT 21h functions not provided by C Runtimes
  46. // additional Dos calls
  47. #pragma optimize("qgel", off) // assembler cannot be globally optimized
  48.  
  49. UINT _Afx_seek(UINT hFile, LONG lOff, UINT nMode, DWORD FAR* lpdwNew)
  50. { 
  51.     UINT res;
  52.     *lpdwNew = -1;
  53.     _asm { 
  54.             mov     bx, hFile
  55.             mov     ax, nMode
  56.             mov     ah, 42h
  57.             mov     dx, word ptr lOff
  58.             mov     cx, word ptr lOff+2
  59.             DOSCALL
  60.             jc      __seek_err
  61.             les     bx, lpdwNew
  62.             mov     word ptr es:[bx], ax
  63.             mov     word ptr es:[bx+2], dx
  64.             xor     ax, ax
  65.     __seek_err:
  66.             mov     res, ax
  67.     }
  68.     return res;
  69. }
  70.         
  71. UINT _Afx_rename(LPCSTR lpszOld, LPCSTR lpszNew)
  72. { 
  73.     UINT res;
  74.     _asm { 
  75.             mov     bx, ds
  76.             lds     dx, lpszOld
  77.             les     di, lpszNew
  78.             mov     ax, 5600h
  79.             DOSCALL
  80.             jc      __rename_err
  81.             xor     ax, ax
  82.     __rename_err:
  83.             mov     res, ax
  84.             mov     ds, bx
  85.     }
  86.     return res;
  87. }
  88.  
  89. UINT _Afx_remove(LPCSTR lpsz)  
  90. { 
  91.     UINT res;
  92.     _asm { 
  93.             mov     bx, ds
  94.             lds     dx, lpsz
  95.             mov     ax, 4100h
  96.             DOSCALL
  97.             jc      __remove_err
  98.             xor     ax, ax
  99.     __remove_err:
  100.             mov     res, ax
  101.             mov     ds, bx
  102.     }
  103.     return res;
  104. }
  105.  
  106. UINT _Afx_lock(UINT hFile, DWORD dwStart, DWORD dwLen, BOOL bUnlock)
  107. { 
  108.     UINT res;
  109.     _asm { 
  110.             mov     ax, bUnlock
  111.             mov     ah, 5ch
  112.             mov     bx, hFile
  113.             mov     dx, word ptr dwStart
  114.             mov     cx, word ptr dwStart+2
  115.             mov     di, word ptr dwLen
  116.             mov     si, word ptr dwLen+2
  117.             DOSCALL
  118.             jc      __lock_err1
  119.             xor     ax, ax
  120.     __lock_err1:
  121.             mov     res, ax
  122.             
  123.     }
  124.     return res;
  125. }
  126.  
  127. #pragma optimize("", on)    // return to default optimizations
  128.  
  129. #endif // _DOSWIN
  130.  
  131. /////////////////////////////////////////////////////////////////////////////
  132. // CFileStatus implementation
  133. #ifdef _DEBUG
  134. void
  135. CFileStatus::Dump(CDumpContext& dc) const
  136. {           
  137.     dc << "file status information:";
  138.     dc << "\nm_ctime = " << m_ctime;
  139.     dc << "\nm_mtime = " << m_mtime;
  140.     dc << "\nm_atime = " << m_atime;
  141.     dc << "\nm_size = " << m_size;
  142.     dc << "\nm_attribute = " << m_attribute;
  143.     dc << "\nm_szFullName = " << m_szFullName;
  144. }
  145. #endif
  146.  
  147.  
  148. ////////////////////////////////////////////////////////////////////////////
  149. // CFile implementation
  150. IMPLEMENT_DYNAMIC(CFile, CObject)
  151.  
  152.  
  153. CFile::CFile()
  154. {
  155.     m_hFile = hFileNull;
  156.     m_bCloseOnDelete = FALSE;
  157. }
  158.  
  159. CFile::CFile(int hFile)
  160. {
  161.     m_hFile = hFile;
  162.     m_bCloseOnDelete = FALSE;
  163. }
  164.  
  165. CFile::CFile(const char* pszFileName, UINT nOpenFlags)
  166. {
  167.     ASSERT(AfxIsValidAddress(pszFileName, strlen(pszFileName), FALSE));
  168.  
  169.     CFileException e;
  170.     if (!this->Open(pszFileName, nOpenFlags, &e))
  171.         AfxThrowFileException(e.m_cause, e.m_lOsError);
  172. }
  173.  
  174. CFile::~CFile()
  175. {   
  176.     if (m_hFile != hFileNull && m_bCloseOnDelete)
  177.         Close();
  178. }
  179.  
  180. CFile*
  181. CFile::Duplicate() const
  182. {
  183.     ASSERT_VALID(this);
  184.     ASSERT(m_hFile != hFileNull);
  185.  
  186.     CFile* pFile = new CFile(hFileNull);
  187.     pFile->m_hFile = _dup(this->m_hFile);
  188.     pFile->m_bCloseOnDelete = this->m_bCloseOnDelete;
  189.     return pFile;
  190. }
  191.  
  192. BOOL
  193. CFile::Open(const char* pszFileName, UINT nOpenFlags, 
  194.     CFileException* pException /* = NULL */)
  195. {
  196.     ASSERT(AfxIsValidAddress(pszFileName, strlen(pszFileName), FALSE));
  197.     ASSERT(pException == NULL || AfxIsValidAddress(pException, sizeof(CFileException)));
  198.     ASSERT((nOpenFlags & typeText) == 0);
  199.  
  200.     // CFile objects are always binary and _dos_open does not need flag
  201.     nOpenFlags &= ~(UINT)CFile::typeBinary;
  202.  
  203.     m_bCloseOnDelete = FALSE;
  204.     m_hFile = hFileNull;
  205.  
  206.  
  207. #ifdef _DOSWIN
  208.     ASSERT_VALID(this);
  209.  
  210.     char szOemPath[_MAX_PATH];
  211.     UINT nErr;
  212.  
  213.     AnsiToOem(pszFileName, szOemPath);
  214.  
  215.     if (nOpenFlags & (UINT)CFile::modeCreate)
  216.     {
  217.         if ((nErr = _dos_creat(szOemPath, CFile::normal, (int*)&m_hFile)) != 0)
  218.         {
  219.             if (pException != NULL)
  220.             {
  221.                 pException->m_lOsError = nErr;
  222.                 pException->m_cause = CFileException::OsErrorToException(nErr);
  223.                 return FALSE; // file was not created
  224.             }
  225.         }
  226.         if ((nErr = _dos_close(m_hFile)) != 0)
  227.         {
  228.             // try to delete the file and throw modeCreate exception
  229.             _Afx_remove(szOemPath);
  230.             if (pException != NULL)
  231.             {
  232.                 pException->m_lOsError = nErr;
  233.                 pException->m_cause = CFileException::OsErrorToException(nErr);
  234.             }
  235.             return FALSE;
  236.         }
  237.     }
  238.  
  239.     // the file has been modeCreated if needed, now open it
  240.     if ((nErr = _dos_open(szOemPath, nOpenFlags & ~(UINT)CFile::modeCreate, (int*)&m_hFile)) != 0)
  241.     {
  242.         // try to delete the file and throw open exception
  243.         _Afx_remove(szOemPath);
  244.         if (pException != NULL)
  245.         {
  246.             pException->m_lOsError = nErr;
  247.             pException->m_cause = CFileException::OsErrorToException(nErr);
  248.         }
  249.         return FALSE;
  250.     }
  251. #endif
  252.  
  253.     m_bCloseOnDelete = TRUE;
  254.     return TRUE;
  255. }
  256.  
  257.  
  258. UINT
  259. CFile::Read(void FAR* lpBuf, UINT nCount)
  260. {
  261.     ASSERT_VALID(this);
  262.     ASSERT(m_hFile != hFileNull);
  263.     ASSERT(lpBuf != NULL);
  264.     ASSERT(AfxIsValidAddress(lpBuf, nCount));
  265.  
  266.     UINT nRead = 0;
  267.     UINT nErr;
  268.  
  269.     if ((nErr = _dos_read(m_hFile, lpBuf, nCount, &nRead)) != 0)
  270.         CFileException::ThrowOsError(nErr);
  271.         
  272.     return nRead;
  273. }
  274.  
  275. void
  276. CFile::Write(const void FAR* lpBuf, UINT nCount)
  277. {
  278.     ASSERT_VALID(this);
  279.     ASSERT(m_hFile != hFileNull);
  280.     ASSERT(lpBuf != NULL);
  281.     ASSERT(AfxIsValidAddress(lpBuf, nCount, FALSE));
  282.  
  283.     UINT nWritten = 0;
  284.     UINT nErr;
  285.  
  286.     if ((nErr = _dos_write(m_hFile, lpBuf, nCount, &nWritten)) != 0)
  287.         CFileException::ThrowOsError(nErr);
  288.     
  289.     if (nCount != nWritten)
  290.         AfxThrowFileException(CFileException::diskFull);
  291. }
  292.  
  293.  
  294. LONG
  295. CFile::Seek(LONG lOff, UINT nFrom)
  296. {
  297.     ASSERT_VALID(this);
  298.     ASSERT(m_hFile != hFileNull);
  299.     ASSERT(nFrom == CFile::begin || nFrom == CFile::end || nFrom == CFile::current);
  300.  
  301.     DWORD dwNew;
  302.     UINT nErr;
  303.  
  304.     if ((nErr  = _Afx_seek(m_hFile, lOff, nFrom, &dwNew)) != 0)
  305.         CFileException::ThrowOsError(nErr);
  306.     
  307.     return dwNew;
  308. }
  309.  
  310.  
  311. DWORD
  312. CFile::GetPosition() const
  313. {
  314.     ASSERT_VALID(this);
  315.     ASSERT(m_hFile != hFileNull);
  316.  
  317.     DWORD dwPos;
  318.     UINT nErr;
  319.  
  320.     if ((nErr = _Afx_seek(m_hFile, 0, CFile::current, &dwPos)) != 0)
  321.         CFileException::ThrowOsError(nErr);
  322.     
  323.     return dwPos;
  324. }
  325.  
  326.  
  327. #pragma optimize("qgel", off) // assembler cannot be globally optimized
  328. void
  329. CFile::Flush()
  330. {
  331.     ASSERT_VALID(this);
  332.     ASSERT(m_hFile != hFileNull);
  333.     
  334.     UINT nErr;
  335.  
  336.     // SmartDrive 4.0 workaround, carry flag incorrectly propogated
  337.         _asm { CLC }
  338.  
  339.     if ((nErr = _dos_commit(m_hFile)) != 0)
  340.         CFileException::ThrowOsError(nErr);
  341. }
  342. #pragma optimize("", on)    // return to default optimizations
  343.  
  344. void
  345. CFile::Close()
  346. {
  347.     ASSERT_VALID(this);
  348.     ASSERT(m_hFile != hFileNull);
  349.  
  350.     UINT nErr;
  351.  
  352.     if (m_hFile != hFileNull && (nErr = _dos_close(m_hFile)) != 0)
  353.         CFileException::ThrowOsError(nErr);
  354.  
  355.     m_hFile = hFileNull;
  356.     m_bCloseOnDelete = FALSE;
  357. }
  358.  
  359.  
  360. void
  361. CFile::LockRange(DWORD dwPos, DWORD dwCount)
  362. {
  363.     ASSERT_VALID(this);
  364.     ASSERT(m_hFile != hFileNull);
  365.  
  366.     UINT nErr;
  367.  
  368.     if ((nErr = _Afx_lock(m_hFile, dwPos, dwCount, FALSE)) != 0)
  369.         CFileException::ThrowOsError(nErr);
  370. }
  371.  
  372.  
  373. void
  374. CFile::UnlockRange(DWORD dwPos, DWORD dwCount)
  375. {
  376.     ASSERT_VALID(this);
  377.     ASSERT(m_hFile != hFileNull);
  378.  
  379.     UINT nErr;
  380.  
  381.     if ((nErr = _Afx_lock(m_hFile, dwPos, dwCount, TRUE)) != 0)
  382.         CFileException::ThrowOsError(nErr);
  383. }
  384.  
  385.  
  386. void
  387. CFile::SetLength(DWORD dwNewLen)
  388. {
  389.     ASSERT_VALID(this);
  390.     ASSERT(m_hFile != hFileNull);
  391.  
  392.     UINT nErr;
  393.  
  394. #ifdef _DOSWIN
  395.     UINT nWritten = 0;
  396.  
  397.     this->Seek(dwNewLen, CFile::begin);
  398.  
  399.     if ((nErr = _dos_write(m_hFile, NULL, 0, &nWritten)) != 0)
  400.         CFileException::ThrowOsError(nErr);
  401. #endif
  402. }
  403.  
  404. DWORD
  405. CFile::GetLength() const
  406. {
  407.     ASSERT_VALID(this);
  408.  
  409.     DWORD dwLen, dwCur;
  410.     
  411.     // Seek is a non const operation 
  412.     dwCur = ((CFile*)this)->Seek(0, CFile::current);
  413.     dwLen = ((CFile*)this)->SeekToEnd();
  414.     VERIFY(dwCur == (DWORD)(((CFile*)this)->Seek(dwCur, CFile::begin)));
  415.  
  416.     return dwLen;
  417. }
  418.  
  419. BOOL
  420. CFile::GetStatus(CFileStatus& rStatus) const
  421. {
  422.     ASSERT_VALID(this);
  423.     ASSERT(m_hFile != hFileNull);
  424.  
  425.     //NOTE: cannot return name of file from handle
  426.     rStatus.m_szFullName[0] = '\0';
  427.  
  428.  
  429. #ifdef _DOSWIN
  430.     struct _stat s;
  431.  
  432.     if (_fstat(m_hFile, &s) == 0)
  433.     {
  434.         rStatus.m_ctime = CTime(s.st_atime);
  435.         rStatus.m_atime = rStatus.m_ctime;
  436.         rStatus.m_mtime = rStatus.m_ctime;
  437.         rStatus.m_size = s.st_size;
  438.         rStatus.m_attribute = 0;    // dos won't give us this from
  439.                                     // just a fd, need the path name
  440.         return TRUE;
  441.     }   
  442.     return FALSE;
  443. #endif
  444.  
  445. }
  446.  
  447. void
  448. CFile::Rename(const char* pszOldName, const char* pszNewName)
  449. {
  450.     char szOld[_MAX_PATH];
  451.     char szNew[_MAX_PATH];
  452.     UINT nErr;
  453.  
  454.     AnsiToOem(pszOldName, szOld);
  455.     AnsiToOem(pszNewName, szNew);
  456.  
  457.     if ((nErr = _Afx_rename(szOld, szNew)) != 0)
  458.         CFileException::ThrowOsError(nErr);
  459.  
  460. }
  461.  
  462. void
  463. CFile::Remove(const char* pszFileName)
  464. {
  465.     UINT nErr;
  466.     char sz[_MAX_PATH];
  467.  
  468.     AnsiToOem(pszFileName, sz);
  469.  
  470.     if ((nErr = _Afx_remove(sz)) != 0)
  471.         CFileException::ThrowOsError(nErr);
  472. }
  473.  
  474.  
  475. BOOL
  476. CFile::GetStatus(const char* pszFileName, CFileStatus& rStatus)
  477. {
  478.  
  479. #ifdef _DOSWIN
  480.     char sz[_MAX_PATH];
  481.  
  482.     // first fill in the full name of the file, undefined if we return FALSE
  483.     if (_fullpath(sz, pszFileName, _MAX_PATH) == NULL)
  484.     {
  485.         rStatus.m_szFullName[0] = '\0';
  486.         return FALSE;
  487.     }
  488.     strncpy(rStatus.m_szFullName, sz, _MAX_PATH);
  489.  
  490.     // finish filling in the structure
  491.     WORD wAttr = CFile::normal | CFile::readOnly |
  492.                 CFile::hidden | CFile::system |
  493.                 CFile::directory | CFile::archive;
  494.     struct _find_t find;
  495.  
  496.     AnsiToOem(pszFileName, sz);
  497.  
  498.     if (_dos_findfirst(sz, wAttr, &find) == 0)
  499.     {
  500.         rStatus.m_mtime = CTime((WORD)find.wr_date, (WORD)find.wr_time);
  501.         rStatus.m_ctime = rStatus.m_mtime;
  502.         rStatus.m_atime = rStatus.m_mtime;
  503.  
  504.         rStatus.m_size = find.size;
  505.         rStatus.m_attribute = find.attrib;
  506.         return TRUE;
  507.     }
  508.     else
  509.         return FALSE;
  510. #endif // _DOSWIN
  511. }
  512.  
  513.  
  514. void
  515. CFile::SetStatus(const char* pszFileName, const CFileStatus& status)
  516. {
  517.  
  518. #ifdef _DOSWIN
  519.     UINT nErr;
  520.     UINT wAttr;
  521.     char sz[_MAX_PATH];
  522.  
  523.     AnsiToOem(pszFileName, sz);
  524.  
  525.     if ((nErr = _dos_getfileattr(sz, &wAttr)) != 0)
  526.         CFileException::ThrowOsError(nErr);
  527.  
  528.     if (status.m_attribute != wAttr && wAttr & CFile::readOnly)
  529.     {
  530.         // Set file attribute, only if currently readonly.
  531.         // This way we will be able to modify the time assuming the
  532.         // caller changed the file from readonly.
  533.         if ((nErr = _dos_setfileattr(sz, status.m_attribute)) != 0)
  534.             CFileException::ThrowOsError(nErr);
  535.     }
  536.  
  537.     if (status.m_mtime.GetTime() != 0)
  538.     {
  539.         WORD wDate, wTime;
  540.         int handle;
  541.  
  542.         // set the file date/time
  543.         if ((nErr = _dos_open(sz, CFile::modeReadWrite, &handle)) != 0)
  544.             CFileException::ThrowOsError(nErr);
  545.  
  546.         wDate = (WORD)(((UINT)status.m_mtime.GetYear() - 1980) << 9);
  547.         wDate += (WORD)(((UINT)status.m_mtime.GetMonth()) << 5);
  548.         wDate += (WORD)((UINT)status.m_mtime.GetDay());
  549.  
  550.         wTime = (WORD)((UINT)(status.m_mtime.GetHour()) << 11);
  551.         wTime += (WORD)((UINT)status.m_mtime.GetMinute() << 5);
  552.         wTime += (WORD)((UINT)status.m_mtime.GetSecond() >> 1);
  553.  
  554.         if ((nErr = _dos_setftime(handle, wDate, wTime)) != 0)
  555.             CFileException::ThrowOsError(nErr);
  556.  
  557.         if ((nErr = _dos_close(handle)) != 0)
  558.             CFileException::ThrowOsError(nErr);
  559.     }
  560.  
  561.     if (status.m_attribute != wAttr && !(wAttr & CFile::readOnly))
  562.     {
  563.         // Set file attribute, only if currently not readonly.
  564.         if ((nErr = _dos_setfileattr(sz, status.m_attribute)) != 0)
  565.             CFileException::ThrowOsError(nErr);
  566.     }
  567.  
  568. #endif // _DOSWIN
  569. }
  570.  
  571.  
  572. #ifdef _DEBUG
  573. void
  574. CFile::AssertValid() const
  575. {
  576.     CObject::AssertValid();
  577.     // we permit the descriptor m_hFile to be any value for derived classes
  578. }
  579.  
  580. void
  581. CFile::Dump(CDumpContext& dc) const
  582. {
  583.     ASSERT_VALID(this);
  584.  
  585.     CObject::Dump(dc);
  586.     dc << "a " << GetRuntimeClass()->m_pszClassName << " with handle " << m_hFile;
  587. }
  588. #endif
  589.