00001
00002
00003
00004
00005 #include "StdAfx.h"
00006
00007 #ifndef _WIN32
00008 #include <fcntl.h>
00009 #include <unistd.h>
00010 #include <errno.h>
00011 #endif
00012
00013 #include "FileStreams.h"
00014
00015 static inline HRESULT ConvertBoolToHRESULT(bool result)
00016 {
00017
00018 #ifdef _WIN32
00019 return result ? S_OK: (::GetLastError());
00020 #else
00021 return result ? S_OK: E_FAIL;
00022 #endif
00023 }
00024
00025 bool CInFileStream::Open(LPCTSTR fileName)
00026 {
00027 return File.Open(fileName);
00028 }
00029
00030 #ifdef _WIN32
00031 #ifndef _UNICODE
00032 bool CInFileStream::Open(LPCWSTR fileName)
00033 {
00034 return File.Open(fileName);
00035 }
00036 #endif
00037 #endif
00038
00039 STDMETHODIMP CInFileStream::Read(void *data, UInt32 size, UInt32 *processedSize)
00040 {
00041 #ifdef _WIN32
00042
00043 UInt32 realProcessedSize;
00044 bool result = File.ReadPart(data, size, realProcessedSize);
00045 if(processedSize != NULL)
00046 *processedSize = realProcessedSize;
00047 return ConvertBoolToHRESULT(result);
00048
00049 #else
00050
00051 if(processedSize != NULL)
00052 *processedSize = 0;
00053 ssize_t res = File.Read(data, (size_t)size);
00054 if (res == -1)
00055 return E_FAIL;
00056 if(processedSize != NULL)
00057 *processedSize = (UInt32)res;
00058 return S_OK;
00059
00060 #endif
00061 }
00062
00063 #ifndef _WIN32_WCE
00064 STDMETHODIMP CStdInFileStream::Read(void *data, UInt32 size, UInt32 *processedSize)
00065 {
00066 #ifdef _WIN32
00067 UInt32 realProcessedSize;
00068 BOOL res = ::ReadFile(GetStdHandle(STD_INPUT_HANDLE),
00069 data, size, (DWORD *)&realProcessedSize, NULL);
00070 if(processedSize != NULL)
00071 *processedSize = realProcessedSize;
00072 if (res == FALSE && GetLastError() == ERROR_BROKEN_PIPE)
00073 return S_OK;
00074 return ConvertBoolToHRESULT(res != FALSE);
00075
00076 #else
00077
00078 if(processedSize != NULL)
00079 *processedSize = 0;
00080 ssize_t res;
00081 do
00082 {
00083 res = read(0, data, (size_t)size);
00084 }
00085 while (res < 0 && (errno == EINTR));
00086 if (res == -1)
00087 return E_FAIL;
00088 if(processedSize != NULL)
00089 *processedSize = (UInt32)res;
00090 return S_OK;
00091
00092 #endif
00093 }
00094
00095 #endif
00096
00097 STDMETHODIMP CInFileStream::Seek(Int64 offset, UInt32 seekOrigin,
00098 UInt64 *newPosition)
00099 {
00100 if(seekOrigin >= 3)
00101 return STG_E_INVALIDFUNCTION;
00102
00103 #ifdef _WIN32
00104
00105 UInt64 realNewPosition;
00106 bool result = File.Seek(offset, seekOrigin, realNewPosition);
00107 if(newPosition != NULL)
00108 *newPosition = realNewPosition;
00109 return ConvertBoolToHRESULT(result);
00110
00111 #else
00112
00113 off_t res = File.Seek(offset, seekOrigin);
00114 if (res == -1)
00115 return E_FAIL;
00116 if(newPosition != NULL)
00117 *newPosition = (UInt64)res;
00118 return S_OK;
00119
00120 #endif
00121 }
00122
00123 STDMETHODIMP CInFileStream::GetSize(UInt64 *size)
00124 {
00125 return ConvertBoolToHRESULT(File.GetLength(*size));
00126 }
00127
00128 bool COutFileStream::Create(LPCTSTR fileName, bool createAlways)
00129 {
00130 return File.Create(fileName, createAlways);
00131 }
00132
00133 #ifdef _WIN32
00134 #ifndef _UNICODE
00135 bool COutFileStream::Create(LPCWSTR fileName, bool createAlways)
00136 {
00137 return File.Create(fileName, createAlways);
00138 }
00139 #endif
00140 #endif
00141
00142 STDMETHODIMP COutFileStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
00143 {
00144 #ifdef _WIN32
00145
00146 UInt32 realProcessedSize;
00147 bool result = File.WritePart(data, size, realProcessedSize);
00148 if(processedSize != NULL)
00149 *processedSize = realProcessedSize;
00150 return ConvertBoolToHRESULT(result);
00151
00152 #else
00153
00154 if(processedSize != NULL)
00155 *processedSize = 0;
00156 ssize_t res = File.Write(data, (size_t)size);
00157 if (res == -1)
00158 return E_FAIL;
00159 if(processedSize != NULL)
00160 *processedSize = (UInt32)res;
00161 return S_OK;
00162
00163 #endif
00164 }
00165
00166 STDMETHODIMP COutFileStream::Seek(Int64 offset, UInt32 seekOrigin,
00167 UInt64 *newPosition)
00168 {
00169 if(seekOrigin >= 3)
00170 return STG_E_INVALIDFUNCTION;
00171 #ifdef _WIN32
00172
00173 UInt64 realNewPosition;
00174 bool result = File.Seek(offset, seekOrigin, realNewPosition);
00175 if(newPosition != NULL)
00176 *newPosition = realNewPosition;
00177 return ConvertBoolToHRESULT(result);
00178
00179 #else
00180
00181 off_t res = File.Seek(offset, seekOrigin);
00182 if (res == -1)
00183 return E_FAIL;
00184 if(newPosition != NULL)
00185 *newPosition = (UInt64)res;
00186 return S_OK;
00187
00188 #endif
00189 }
00190
00191 STDMETHODIMP COutFileStream::SetSize(Int64 newSize)
00192 {
00193 #ifdef _WIN32
00194 UInt64 currentPos;
00195 if(!File.Seek(0, FILE_CURRENT, currentPos))
00196 return E_FAIL;
00197 bool result = File.SetLength(newSize);
00198 UInt64 currentPos2;
00199 result = result && File.Seek(currentPos, currentPos2);
00200 return result ? S_OK : E_FAIL;
00201 #else
00202 return E_FAIL;
00203 #endif
00204 }
00205
00206 #ifndef _WIN32_WCE
00207 STDMETHODIMP CStdOutFileStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
00208 {
00209 if(processedSize != NULL)
00210 *processedSize = 0;
00211
00212 #ifdef _WIN32
00213 UInt32 realProcessedSize;
00214 BOOL res = TRUE;
00215 if (size > 0)
00216 {
00217
00218
00219 UInt32 sizeTemp = (1 << 15);
00220 if (sizeTemp > size)
00221 sizeTemp = size;
00222 res = ::WriteFile(GetStdHandle(STD_OUTPUT_HANDLE),
00223 data, sizeTemp, (DWORD *)&realProcessedSize, NULL);
00224 size -= realProcessedSize;
00225 data = (const void *)((const Byte *)data + realProcessedSize);
00226 if(processedSize != NULL)
00227 *processedSize += realProcessedSize;
00228 }
00229 return ConvertBoolToHRESULT(res != FALSE);
00230
00231 #else
00232
00233 ssize_t res;
00234 do
00235 {
00236 res = write(1, data, (size_t)size);
00237 }
00238 while (res < 0 && (errno == EINTR));
00239 if (res == -1)
00240 return E_FAIL;
00241 if(processedSize != NULL)
00242 *processedSize = (UInt32)res;
00243 return S_OK;
00244
00245 return S_OK;
00246 #endif
00247 }
00248
00249 #endif
