Annotation of elwix/tools/oldlzma/SRC/7zip/Common/FileStreams.cpp, revision 1.1.1.1
1.1 misho 1: // FileStreams.cpp
2:
3: #include "StdAfx.h"
4:
5: #ifndef _WIN32
6: #include <fcntl.h>
7: #include <unistd.h>
8: #endif
9:
10: #include "FileStreams.h"
11:
12: static inline HRESULT ConvertBoolToHRESULT(bool result)
13: {
14: // return result ? S_OK: E_FAIL;
15: #ifdef _WIN32
16: return result ? S_OK: (::GetLastError());
17: #else
18: return result ? S_OK: E_FAIL;
19: #endif
20: }
21:
22: bool CInFileStream::Open(LPCTSTR fileName)
23: {
24: return File.Open(fileName);
25: }
26:
27: #ifdef _WIN32
28: #ifndef _UNICODE
29: bool CInFileStream::Open(LPCWSTR fileName)
30: {
31: return File.Open(fileName);
32: }
33: #endif
34: #endif
35:
36: STDMETHODIMP CInFileStream::Read(void *data, UInt32 size, UInt32 *processedSize)
37: {
38: #ifdef _WIN32
39:
40: UInt32 realProcessedSize;
41: bool result = File.Read(data, size, realProcessedSize);
42: if(processedSize != NULL)
43: *processedSize = realProcessedSize;
44: return ConvertBoolToHRESULT(result);
45:
46: #else
47:
48: if(processedSize != NULL)
49: *processedSize = 0;
50: ssize_t res = File.Read(data, (size_t)size);
51: if (res == -1)
52: return E_FAIL;
53: if(processedSize != NULL)
54: *processedSize = (UInt32)res;
55: return S_OK;
56:
57: #endif
58: }
59:
60: STDMETHODIMP CInFileStream::ReadPart(void *data, UInt32 size, UInt32 *processedSize)
61: {
62: return Read(data, size, processedSize);
63: }
64:
65: #ifndef _WIN32_WCE
66: STDMETHODIMP CStdInFileStream::Read(void *data, UInt32 size, UInt32 *processedSize)
67: {
68: #ifdef _WIN32
69: UInt32 realProcessedSize;
70: BOOL res = ::ReadFile(GetStdHandle(STD_INPUT_HANDLE),
71: data, size, (DWORD *)&realProcessedSize, NULL);
72: if(processedSize != NULL)
73: *processedSize = realProcessedSize;
74: if (res == FALSE && GetLastError() == ERROR_BROKEN_PIPE)
75: return S_OK;
76: return ConvertBoolToHRESULT(res != FALSE);
77:
78: #else
79:
80: if(processedSize != NULL)
81: *processedSize = 0;
82: ssize_t res = read(0, data, (size_t)size);
83: if (res == -1)
84: return E_FAIL;
85: if(processedSize != NULL)
86: *processedSize = (UInt32)res;
87: return S_OK;
88:
89: #endif
90: }
91:
92: STDMETHODIMP CStdInFileStream::ReadPart(void *data, UInt32 size, UInt32 *processedSize)
93: {
94: return Read(data, size, processedSize);
95: }
96: #endif
97:
98: STDMETHODIMP CInFileStream::Seek(Int64 offset, UInt32 seekOrigin,
99: UInt64 *newPosition)
100: {
101: if(seekOrigin >= 3)
102: return STG_E_INVALIDFUNCTION;
103:
104: #ifdef _WIN32
105:
106: UInt64 realNewPosition;
107: bool result = File.Seek(offset, seekOrigin, realNewPosition);
108: if(newPosition != NULL)
109: *newPosition = realNewPosition;
110: return ConvertBoolToHRESULT(result);
111:
112: #else
113:
114: off_t res = File.Seek(offset, seekOrigin);
115: if (res == -1)
116: return E_FAIL;
117: if(newPosition != NULL)
118: *newPosition = (UInt64)res;
119: return S_OK;
120:
121: #endif
122: }
123:
124: STDMETHODIMP CInFileStream::GetSize(UInt64 *size)
125: {
126: return ConvertBoolToHRESULT(File.GetLength(*size));
127: }
128:
129:
130: //////////////////////////
131: // COutFileStream
132:
133: bool COutFileStream::Create(LPCTSTR fileName, bool createAlways)
134: {
135: return File.Create(fileName, createAlways);
136: }
137:
138: #ifdef _WIN32
139: #ifndef _UNICODE
140: bool COutFileStream::Create(LPCWSTR fileName, bool createAlways)
141: {
142: return File.Create(fileName, createAlways);
143: }
144: #endif
145: #endif
146:
147: STDMETHODIMP COutFileStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
148: {
149: #ifdef _WIN32
150:
151: UInt32 realProcessedSize;
152: bool result = File.Write(data, size, realProcessedSize);
153: if(processedSize != NULL)
154: *processedSize = realProcessedSize;
155: return ConvertBoolToHRESULT(result);
156:
157: #else
158:
159: if(processedSize != NULL)
160: *processedSize = 0;
161: ssize_t res = File.Write(data, (size_t)size);
162: if (res == -1)
163: return E_FAIL;
164: if(processedSize != NULL)
165: *processedSize = (UInt32)res;
166: return S_OK;
167:
168: #endif
169: }
170:
171: STDMETHODIMP COutFileStream::WritePart(const void *data, UInt32 size, UInt32 *processedSize)
172: {
173: return Write(data, size, processedSize);
174: }
175:
176:
177: STDMETHODIMP COutFileStream::Seek(Int64 offset, UInt32 seekOrigin,
178: UInt64 *newPosition)
179: {
180: if(seekOrigin >= 3)
181: return STG_E_INVALIDFUNCTION;
182: #ifdef _WIN32
183:
184: UInt64 realNewPosition;
185: bool result = File.Seek(offset, seekOrigin, realNewPosition);
186: if(newPosition != NULL)
187: *newPosition = realNewPosition;
188: return ConvertBoolToHRESULT(result);
189:
190: #else
191:
192: off_t res = File.Seek(offset, seekOrigin);
193: if (res == -1)
194: return E_FAIL;
195: if(newPosition != NULL)
196: *newPosition = (UInt64)res;
197: return S_OK;
198:
199: #endif
200: }
201:
202: STDMETHODIMP COutFileStream::SetSize(Int64 newSize)
203: {
204: #ifdef _WIN32
205: UInt64 currentPos;
206: if(!File.Seek(0, FILE_CURRENT, currentPos))
207: return E_FAIL;
208: bool result = File.SetLength(newSize);
209: UInt64 currentPos2;
210: result = result && File.Seek(currentPos, currentPos2);
211: return result ? S_OK : E_FAIL;
212: #else
213: return E_FAIL;
214: #endif
215: }
216:
217: #ifndef _WIN32_WCE
218: STDMETHODIMP CStdOutFileStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
219: {
220: if(processedSize != NULL)
221: *processedSize = 0;
222:
223: #ifdef _WIN32
224: UInt32 realProcessedSize;
225: BOOL res = TRUE;
226: while (size > 0)
227: {
228: // Seems that Windows doesn't like big amounts writing to stdout.
229: // So we limit portions by 32KB.
230: UInt32 sizeTemp = (1 << 15);
231: if (sizeTemp > size)
232: sizeTemp = size;
233: res = ::WriteFile(GetStdHandle(STD_OUTPUT_HANDLE),
234: data, sizeTemp, (DWORD *)&realProcessedSize, NULL);
235: if (realProcessedSize == 0)
236: break;
237: size -= realProcessedSize;
238: data = (const void *)((const Byte *)data + realProcessedSize);
239: if(processedSize != NULL)
240: *processedSize += realProcessedSize;
241: }
242: return ConvertBoolToHRESULT(res != FALSE);
243:
244: #else
245:
246: ssize_t res = write(1, data, (size_t)size);
247: if (res == -1)
248: return E_FAIL;
249: if(processedSize != NULL)
250: *processedSize = (UInt32)res;
251: return S_OK;
252:
253: return S_OK;
254: #endif
255: }
256:
257: STDMETHODIMP CStdOutFileStream::WritePart(const void *data, UInt32 size, UInt32 *processedSize)
258: {
259: return Write(data, size, processedSize);
260: }
261: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to FileStreams.cpp CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / elwix / tools / oldlzma / SRC / 7zip / Common