home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c480 / 18.ddi / MFC / SRC / FILECORE.CP_ / FILECORE.CP
Encoding:
Text File  |  1993-02-08  |  11.2 KB  |  557 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 and/or WinHelp documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Microsoft Foundation Classes product.
  10.  
  11. #include "stdafx.h"
  12. #include <errno.h>
  13. #include <io.h>
  14. #include <limits.h>
  15. #include <malloc.h>
  16.  
  17. #include <sys\types.h>
  18. #include <sys\stat.h>
  19. #ifdef _PORTABLE
  20. #include <sys\locking.h>
  21. #endif
  22.  
  23. #ifdef AFX_CORE2_SEG
  24. #pragma code_seg(AFX_CORE2_SEG)
  25. #endif
  26.  
  27. #ifdef _DEBUG
  28. #undef THIS_FILE
  29. static char BASED_CODE THIS_FILE[] = __FILE__;
  30. #endif
  31.  
  32. #define new DEBUG_NEW
  33.  
  34. ////////////////////////////////////////////////////////////////////////////
  35. // Low level File i/o portability layer
  36. // DOS functions not provided by C Runtimes
  37.  
  38.  
  39. #include <dos.h>
  40. #ifdef _WINDOWS
  41. extern "C" void FAR PASCAL DOS3Call();
  42. #define DOSCALL call DOS3Call
  43. #else // _DOS
  44. #define DOSCALL int 21h
  45. #endif // _WINDOWS
  46.  
  47. #ifndef _PORTABLE
  48. // Non-Portable, DOSCALL specific implementation
  49. //  Most efficient and gives most accurate failure codes
  50.  
  51. #pragma optimize("qgel", off) // assembler cannot be globally optimized
  52.  
  53. static UINT PASCAL _Afx_seek(UINT hFile, LONG lOff, UINT nMode, 
  54.             DWORD FAR* lpdwNew)
  55. { 
  56.     UINT res;
  57.     *lpdwNew = -1;
  58.     _asm { 
  59.             mov     bx, hFile
  60.             mov     ax, nMode
  61.             mov     ah, 42h
  62.             mov     dx, word ptr lOff
  63.             mov     cx, word ptr lOff+2
  64.             DOSCALL
  65.             jc      __seek_err
  66.             les     bx, lpdwNew
  67.             mov     word ptr es:[bx], ax
  68.             mov     word ptr es:[bx+2], dx
  69.             xor     ax, ax
  70.     __seek_err:
  71.             mov     res, ax
  72.     }
  73.     return res;
  74. }
  75.         
  76. static UINT PASCAL _Afx_rename(LPCSTR lpszOld, LPCSTR lpszNew)
  77. { 
  78.     UINT res;
  79.     _asm { 
  80.             mov     bx, ds
  81.             lds     dx, lpszOld
  82.             les     di, lpszNew
  83.             mov     ax, 5600h
  84.             DOSCALL
  85.             jc      __rename_err
  86.             xor     ax, ax
  87.     __rename_err:
  88.             mov     res, ax
  89.             mov     ds, bx
  90.     }
  91.     return res;
  92. }
  93.  
  94. static UINT PASCAL _Afx_remove(LPCSTR lpsz)  
  95. { 
  96.     UINT res;
  97.     _asm { 
  98.             mov     bx, ds
  99.             lds     dx, lpsz
  100.             mov     ax, 4100h
  101.             DOSCALL
  102.             jc      __remove_err
  103.             xor     ax, ax
  104.     __remove_err:
  105.             mov     res, ax
  106.             mov     ds, bx
  107.     }
  108.     return res;
  109. }
  110.  
  111. static UINT PASCAL _Afx_lock(UINT hFile, DWORD dwStart, DWORD dwLen, BOOL bUnlock)
  112. { 
  113.     UINT res;
  114.     _asm { 
  115.             mov     ax, bUnlock
  116.             mov     ah, 5ch
  117.             mov     bx, hFile
  118.             mov     dx, word ptr dwStart
  119.             mov     cx, word ptr dwStart+2
  120.             mov     di, word ptr dwLen
  121.             mov     si, word ptr dwLen+2
  122.             DOSCALL
  123.             jc      __lock_err1
  124.             xor     ax, ax
  125.     __lock_err1:
  126.             mov     res, ax
  127.             
  128.     }
  129.     return res;
  130. }
  131.  
  132. #pragma optimize("", on)    // return to default optimizations
  133.  
  134. #else   // _PORTABLE implementations
  135.  
  136. // Portable, C-Runtime implementation
  137. //  More portable but can gives less accurate failure codes
  138. static UINT PASCAL _Afx_seek(UINT hFile, LONG lOff, UINT nMode, 
  139.             DWORD FAR* lpdwNew)
  140. {
  141.     *lpdwNew = (DWORD)_lseek((int)hFile, lOff, (int)nMode);
  142.     if (*lpdwNew == (DWORD)-1L)
  143.     {
  144.         if (errno == EBADF)
  145.             return 0x6; // invalid file
  146.         else
  147.             return 0x19; // bad seek
  148.     }
  149.     return 0;
  150. }
  151.  
  152. static UINT PASCAL _Afx_rename(LPCSTR lpszOld, LPCSTR lpszNew)
  153. {
  154.     char* pszOld;
  155.     char* pszNew;
  156. #ifdef _NEARDATA
  157.     char szOld[_MAX_PATH];
  158.     char szNew[_MAX_PATH];
  159.     lstrcpy(szOld, lpszOld);
  160.     lstrcpy(szNew, lpszNew);
  161.     pszOld = szOld;
  162.     pszNew = szNew;
  163. #else
  164.     pszOld = (LPSTR)lpszOld;
  165.     pszNew = (LPSTR)lpszNew;
  166. #endif
  167.     if (rename(pszOld, pszNew) != 0)
  168.     {
  169.         if (errno == EACCES)
  170.             return 0x5; // access denied
  171.         else
  172.             return 0x2; // file not found
  173.     }
  174.     return 0;
  175. }
  176.  
  177. static UINT PASCAL _Afx_remove(LPCSTR lpsz)  
  178. {
  179.     char* psz;
  180. #ifdef _NEARDATA
  181.     char sz[_MAX_PATH];
  182.     lstrcpy(sz, lpsz);
  183.     psz = sz;
  184. #else
  185.     psz = (LPSTR)lpsz;
  186. #endif
  187.     if (remove(psz) != 0)
  188.     {
  189.         if (errno == EACCES)
  190.             return 0x5; // access denied
  191.         else
  192.             return 0x2; // file not found
  193.     }
  194.     return 0;
  195. }
  196.  
  197. static UINT PASCAL _Afx_lock(UINT hFile, DWORD dwStart, DWORD dwLen, BOOL bUnlock)
  198. { 
  199.     DWORD dwPos;
  200.     DWORD dw;
  201.     UINT nErr;
  202.  
  203.     if (_Afx_seek(hFile, 0, 0, &dwPos) != 0)
  204.         return 0;
  205.     if ((nErr = _Afx_seek(hFile, (LONG)dwStart, 0, &dw)) != 0)
  206.     {
  207.         _Afx_seek(hFile, dwPos, 0, &dw);
  208.         return nErr;
  209.     }
  210.     if (_locking(hFile, bUnlock ? _LK_UNLCK : _LK_NBLCK, dwLen) != 0)
  211.     {
  212.         switch (errno)
  213.         {
  214.         case EACCES:
  215.             return 0x21; // lock violation
  216.         case EBADF:
  217.             return 0x6; // bad file handle
  218.         default:
  219.             return 0x1;
  220.         }
  221.     }
  222.     _Afx_seek(hFile, dwPos, 0, &dw);
  223.     return 0;
  224. }
  225.  
  226. #endif // _PORTABLE
  227.  
  228. ////////////////////////////////////////////////////////////////////////////
  229. // CFile implementation
  230. IMPLEMENT_DYNAMIC(CFile, CObject)
  231.  
  232.  
  233. CFile::CFile()
  234. {
  235.     m_hFile = hFileNull;
  236.     m_bCloseOnDelete = FALSE;
  237. }
  238.  
  239. CFile::CFile(int hFile)
  240. {
  241.     m_hFile = hFile;
  242.     m_bCloseOnDelete = FALSE;
  243. }
  244.  
  245. CFile::CFile(const char* pszFileName, UINT nOpenFlags)
  246. {
  247.     ASSERT(AfxIsValidString(pszFileName));
  248.  
  249.     CFileException e;
  250.     if (!Open(pszFileName, nOpenFlags, &e))
  251.         AfxThrowFileException(e.m_cause, e.m_lOsError);
  252. }
  253.  
  254. CFile::~CFile()
  255. {   
  256.     if (m_hFile != (UINT)hFileNull && m_bCloseOnDelete)
  257.         Close();
  258. }
  259.  
  260. CFile*
  261. CFile::Duplicate() const
  262. {
  263.     ASSERT_VALID(this);
  264.     ASSERT(m_hFile != (UINT)hFileNull);
  265.  
  266.     CFile* pFile = new CFile(hFileNull);
  267.     pFile->m_hFile = (UINT) _dup((int)m_hFile);
  268.     ASSERT(((int)(pFile->m_hFile)) != -1);
  269.     pFile->m_bCloseOnDelete = m_bCloseOnDelete;
  270.     return pFile;
  271. }
  272.  
  273.  
  274. BOOL
  275. CFile::Open(const char* pszFileName, UINT nOpenFlags, 
  276.     CFileException* pException /* = NULL */)
  277. {
  278.     ASSERT(AfxIsValidString(pszFileName));
  279.     ASSERT(pException == NULL || AfxIsValidAddress(pException, sizeof(CFileException)));
  280.     ASSERT((nOpenFlags & typeText) == 0);
  281.  
  282.     // CFile objects are always binary and _dos_open does not need flag
  283.     nOpenFlags &= ~(UINT)CFile::typeBinary;
  284.  
  285.     m_bCloseOnDelete = FALSE;
  286.     m_hFile = (UINT)hFileNull;
  287.  
  288.     ASSERT_VALID(this);
  289.  
  290.     char szOemPath[_MAX_PATH];
  291.     UINT nErr;
  292.  
  293.     AnsiToOem(pszFileName, szOemPath);
  294.  
  295.     if (nOpenFlags & (UINT)CFile::modeCreate)
  296.     {
  297.         if ((nErr = _dos_creat(szOemPath, CFile::normal, (int*)&m_hFile)) != 0)
  298.         {
  299.             if (pException != NULL)
  300.             {
  301.                 pException->m_lOsError = nErr;
  302.                 pException->m_cause = CFileException::OsErrorToException(nErr);
  303.                 return FALSE; // file was not created
  304.             }
  305.         }
  306.         if ((nErr = _dos_close(m_hFile)) != 0)
  307.         {
  308.             // try to delete the file and throw modeCreate exception
  309.             _Afx_remove(szOemPath);
  310.             if (pException != NULL)
  311.             {
  312.                 pException->m_lOsError = nErr;
  313.                 pException->m_cause = CFileException::OsErrorToException(nErr);
  314.             }
  315.             return FALSE;
  316.         }
  317.     }
  318.  
  319.     // the file has been modeCreated if needed, now open it
  320.     if ((nErr = _dos_open(szOemPath, nOpenFlags & ~(UINT)CFile::modeCreate, (int*)&m_hFile)) != 0)
  321.     {
  322.         // throw open exception if requested
  323.         if (pException != NULL)
  324.         {
  325.             pException->m_lOsError = nErr;
  326.             pException->m_cause = CFileException::OsErrorToException(nErr);
  327.         }
  328.         return FALSE;
  329.     }
  330.     m_bCloseOnDelete = TRUE;
  331.     return TRUE;
  332. }
  333.  
  334.  
  335. UINT
  336. CFile::Read(void FAR* lpBuf, UINT nCount)
  337. {
  338.     ASSERT_VALID(this);
  339.     ASSERT(m_hFile != (UINT)hFileNull);
  340.     ASSERT(lpBuf != NULL);
  341.     ASSERT(AfxIsValidAddress(lpBuf, nCount));
  342.  
  343.     UINT nRead = 0;
  344.     UINT nErr;
  345.  
  346.     if ((nErr = _dos_read(m_hFile, lpBuf, nCount, &nRead)) != 0)
  347.         CFileException::ThrowOsError(nErr);
  348.         
  349.     return nRead;
  350. }
  351.  
  352. void
  353. CFile::Write(const void FAR* lpBuf, UINT nCount)
  354. {
  355.     ASSERT_VALID(this);
  356.     ASSERT(m_hFile != (UINT)hFileNull);
  357.     ASSERT(lpBuf != NULL);
  358.     ASSERT(AfxIsValidAddress(lpBuf, nCount, FALSE));
  359.  
  360.     UINT nWritten = 0;
  361.     UINT nErr;
  362.  
  363.     if ((nErr = _dos_write(m_hFile, lpBuf, nCount, &nWritten)) != 0)
  364.         CFileException::ThrowOsError(nErr);
  365.     
  366.     if (nCount != nWritten)
  367.         AfxThrowFileException(CFileException::diskFull);
  368. }
  369.  
  370.  
  371. LONG
  372. CFile::Seek(LONG lOff, UINT nFrom)
  373. {
  374.     ASSERT_VALID(this);
  375.     ASSERT(m_hFile != (UINT)hFileNull);
  376.     ASSERT(nFrom == CFile::begin || nFrom == CFile::end || nFrom == CFile::current);
  377.  
  378.     DWORD dwNew;
  379.     UINT nErr;
  380.  
  381.     if ((nErr = _Afx_seek(m_hFile, lOff, nFrom, &dwNew)) != 0)
  382.         CFileException::ThrowOsError(nErr);
  383.     
  384.     return dwNew;
  385. }
  386.  
  387.  
  388. DWORD
  389. CFile::GetPosition() const
  390. {
  391.     ASSERT_VALID(this);
  392.     ASSERT(m_hFile != (UINT)hFileNull);
  393.  
  394.     DWORD dwPos;
  395.     UINT nErr;
  396.  
  397.     if ((nErr = _Afx_seek(m_hFile, 0, CFile::current, &dwPos)) != 0)
  398.         CFileException::ThrowOsError(nErr);
  399.     
  400.     return dwPos;
  401. }
  402.  
  403.  
  404. #pragma optimize("qgel", off) // assembler cannot be globally optimized
  405. void
  406. CFile::Flush()
  407. {
  408.     ASSERT_VALID(this);
  409.     
  410.     UINT nErr;
  411.  
  412.     if (m_hFile == (UINT)hFileNull)
  413.         return;
  414.  
  415. #ifndef _PORTABLE
  416.     // SmartDrive 4.0 workaround, carry flag incorrectly propogated
  417.     _asm { CLC }
  418. #endif
  419.  
  420.     if ((nErr = _dos_commit(m_hFile)) != 0)
  421.         CFileException::ThrowOsError(nErr);
  422. }
  423. #pragma optimize("", on)    // return to default optimizations
  424.  
  425. void
  426. CFile::Close()
  427. {
  428.     ASSERT_VALID(this);
  429.     ASSERT(m_hFile != (UINT)hFileNull);
  430.  
  431.     UINT nErr = 0;
  432.  
  433.     if (m_hFile != (UINT)hFileNull)
  434.         nErr = _dos_close(m_hFile);
  435.  
  436.     m_hFile = hFileNull;
  437.     m_bCloseOnDelete = FALSE;
  438.  
  439.     if (nErr != 0)
  440.         CFileException::ThrowOsError(nErr);
  441. }
  442.  
  443. void
  444. CFile::Abort()
  445. {
  446.     ASSERT_VALID(this);
  447.     if (m_hFile != (UINT)hFileNull)
  448.     {
  449.         // close but ignore errors
  450.         _dos_close(m_hFile);
  451.         m_hFile = (UINT)hFileNull;
  452.     }
  453. }
  454.  
  455. void
  456. CFile::LockRange(DWORD dwPos, DWORD dwCount)
  457. {
  458.     ASSERT_VALID(this);
  459.     ASSERT(m_hFile != (UINT)hFileNull);
  460.  
  461.     UINT nErr;
  462.  
  463.     if ((nErr = _Afx_lock(m_hFile, dwPos, dwCount, FALSE)) != 0)
  464.         CFileException::ThrowOsError(nErr);
  465. }
  466.  
  467.  
  468. void
  469. CFile::UnlockRange(DWORD dwPos, DWORD dwCount)
  470. {
  471.     ASSERT_VALID(this);
  472.     ASSERT(m_hFile != (UINT)hFileNull);
  473.  
  474.     UINT nErr;
  475.  
  476.     if ((nErr = _Afx_lock(m_hFile, dwPos, dwCount, TRUE)) != 0)
  477.         CFileException::ThrowOsError(nErr);
  478. }
  479.  
  480.  
  481. void
  482. CFile::SetLength(DWORD dwNewLen)
  483. {
  484.     ASSERT_VALID(this);
  485.     ASSERT(m_hFile != (UINT)hFileNull);
  486.  
  487.     UINT nErr;
  488.     UINT nWritten = 0;
  489.  
  490.     Seek(dwNewLen, CFile::begin);
  491.  
  492.     if ((nErr = _dos_write(m_hFile, NULL, 0, &nWritten)) != 0)
  493.         CFileException::ThrowOsError(nErr);
  494. }
  495.  
  496. DWORD
  497. CFile::GetLength() const
  498. {
  499.     ASSERT_VALID(this);
  500.  
  501.     DWORD dwLen, dwCur;
  502.     
  503.     // Seek is a non const operation 
  504.     dwCur = ((CFile*)this)->Seek(0L, CFile::current);
  505.     dwLen = ((CFile*)this)->SeekToEnd();
  506.     VERIFY(dwCur == (DWORD)(((CFile*)this)->Seek(dwCur, CFile::begin)));
  507.  
  508.     return dwLen;
  509. }
  510.  
  511. void PASCAL
  512. CFile::Rename(const char* pszOldName, const char* pszNewName)
  513. {
  514.     char szOld[_MAX_PATH];
  515.     char szNew[_MAX_PATH];
  516.     UINT nErr;
  517.  
  518.     AnsiToOem(pszOldName, szOld);
  519.     AnsiToOem(pszNewName, szNew);
  520.  
  521.     if ((nErr = _Afx_rename(szOld, szNew)) != 0)
  522.         CFileException::ThrowOsError(nErr);
  523.  
  524. }
  525.  
  526. void PASCAL
  527. CFile::Remove(const char* pszFileName)
  528. {
  529.     UINT nErr;
  530.     char sz[_MAX_PATH];
  531.  
  532.     AnsiToOem(pszFileName, sz);
  533.  
  534.     if ((nErr = _Afx_remove(sz)) != 0)
  535.         CFileException::ThrowOsError(nErr);
  536. }
  537.  
  538.  
  539. #ifdef _DEBUG
  540. void
  541. CFile::AssertValid() const
  542. {
  543.     CObject::AssertValid();
  544.     // we permit the descriptor m_hFile to be any value for derived classes
  545. }
  546.  
  547. void
  548. CFile::Dump(CDumpContext& dc) const
  549. {
  550.     ASSERT_VALID(this);
  551.  
  552.     CObject::Dump(dc);
  553.     AFX_DUMP1(dc, " with handle ", (UINT)m_hFile);
  554. }
  555.  
  556. #endif
  557.