Commit d01bd98390bc474a6082bc2a9b95b97ba62d08fc

Petr Ovtchenkov
Fri Oct 16 21:56:27 CEST 2009

Tree SHA1: cf45deb
Parent SHA1: fbb49c7 (-I./cppunit removed from options)
raw diff | raw patch

_Filebuf_base: replace three chars by unsigned and bit flags.

Replace three chars, used as flags by single unsigned and bit
flags.

In many platforms access to unsigned is better then to chars.

As about alignment, single unsigned at least the same as
three chars...

Diff rendering mode:
inline
side by side


150	150
151	151	size_t _Filebuf_base::_M_page_size = 4096;
152	152
153		_Filebuf_base::_Filebuf_base()
154		: _M_file_id(INVALID_STLP_FD),
	153	_Filebuf_base::_Filebuf_base() :
	154	_M_file_id(INVALID_STLP_FD),
155	155	_M_openmode(0),
156		_M_is_open(false),
157		_M_should_close(false)
	156	int_flags_(0)
158	157	{}
159	158
160	159	void _Filebuf_base::_S_initialize()
…	…
173	173	{
174	174	_STLP_fd file_no;
175	175
176		if (_M_is_open)
	176	if ( __is_open() ) {
177	177	return false;
	178	}
178	179
179	180	// use FILE-based i/o
180	181	const char* flags;
…	…
240	240	// unset buffering immediately
241	241	setbuf(_M_file, 0);
242	242
243		_M_is_open = true;
	243	int_flags_ \|= _is_open;
244	244
245	245	if (openmode & ios_base::ate) {
246		if (FSEEK(_M_file, 0, SEEK_END) != 0)
247		_M_is_open = false;
	246	if (FSEEK(_M_file, 0, SEEK_END) != 0) {
	247	int_flags_ &= ~_is_open;
	248	}
248	249	}
249	250
250	251	_M_file_id = file_no;
251		_M_should_close = _M_is_open;
	252	int_flags_ \|= (int_flags_ & _is_open) << 1; // _should_close == _is_open
252	253	_M_openmode = openmode;
253	254
254		if (_M_is_open)
255		_M_regular_file = _STLP_PRIV __is_regular_file(_M_file_id);
	255	if ( (int_flags_ & _is_open) && _STLP_PRIV __is_regular_file(_M_file_id) ) {
	256	int_flags_ \|= _regular;
	257	}
256	258
257		return (_M_is_open != 0);
	259	return (int_flags_ & _is_open) != 0;
258	260	}
259	261
260	262
…	…
274	274	// was opened.
275	275	bool _Filebuf_base::_M_open( int file_no, ios_base::openmode )
276	276	{
277		if (_M_is_open \|\| file_no < 0)
	277	if ( (int_flags_ & _is_open) \|\| (file_no < 0) ) {
278	278	return false;
	279	}
279	280
280	281	struct STAT buf;
281	282	if (FSTAT(file_no, &buf) != 0)
…	…
297	297	return false;
298	298	}
299	299	_M_file_id = file_no;
300		_M_is_open = true;
301		_M_should_close = false;
302		_M_regular_file = _STLP_PRIV __is_regular_file(_M_file_id);
	300	int_flags_ \|= _is_open;
	301	if ( _STLP_PRIV __is_regular_file(_M_file_id) ) {
	302	int_flags_ \|= _regular;
	303	}
	304
303	305	return true;
304	306	}
305	307
306	308	bool _Filebuf_base::_M_close()
307	309	{
308		if (!_M_is_open)
	310	if ( (int_flags_ & _is_open) == 0 ) {
309	311	return false;
	312	}
310	313
311		bool ok = _M_should_close ? (fclose(_M_file) == 0) : true;
	314	bool ok = (int_flags_ & _should_close) != 0 ? (fclose(_M_file) == 0) : true;
312	315
313		_M_is_open = _M_should_close = false;
	316	int_flags_ = 0;
314	317	_M_openmode = 0;
	318
315	319	return ok;
316	320	}
317	321


121	121
122	122	size_t _Filebuf_base::_M_page_size = 4096;
123	123
124		_Filebuf_base::_Filebuf_base()
125		: _M_file_id(INVALID_STLP_FD),
	124	_Filebuf_base::_Filebuf_base() :
	125	_M_file_id(INVALID_STLP_FD),
126	126	_M_openmode(0),
127		_M_is_open(false),
128		_M_should_close(false)
	127	int_flags_(0)
129	128	{}
130	129
131	130	void _Filebuf_base::_S_initialize()
…	…
156	156	{
157	157	_STLP_fd file_no;
158	158
159		if (_M_is_open)
	159	if ( __is_open() ) {
160	160	return false;
	161	}
161	162
162	163	int flags = 0;
163	164
…	…
192	192
193	193	file_no = OPEN(name, flags, permission);
194	194
195		if (file_no < 0)
	195	if ( file_no < 0 ) {
196	196	return false;
	197	}
197	198
198		_M_is_open = true;
	199	int_flags_ \|= _is_open;
199	200
200	201	if ((openmode & (ios_base::ate \| ios_base::app)) && (LSEEK(file_no, 0, SEEK_END) == -1)) {
201		_M_is_open = false;
	202	int_flags_ &= ~_is_open;
202	203	}
203	204
204	205	_M_file_id = file_no;
205		_M_should_close = _M_is_open;
	206	int_flags_ \|= (int_flags_ & _is_open) << 1; // _should_close == _is_open
206	207	_M_openmode = openmode;
207	208
208		if (_M_is_open)
209		_M_regular_file = _STLP_PRIV __is_regular_file(_M_file_id);
	209	if ( (int_flags_ & _is_open) && _STLP_PRIV __is_regular_file(_M_file_id) ) {
	210	int_flags_ \|= _regular;
	211	}
210	212
211		return (_M_is_open != 0);
	213	return (int_flags_ & _is_open) != 0;
212	214	}
213	215
214	216
…	…
228	228	// was opened.
229	229	bool _Filebuf_base::_M_open(int file_no, ios_base::openmode)
230	230	{
231		if (_M_is_open \|\| file_no < 0)
	231	if ( (int_flags_ & _is_open) \|\| (file_no < 0) ) {
232	232	return false;
	233	}
233	234
234	235	int mode = fcntl(file_no, F_GETFL);
235	236
236		if (mode == -1)
	237	if ( mode == -1 ) {
237	238	return false;
	239	}
238	240
239	241	_M_openmode = flag_to_openmode(mode);
240	242	_M_file_id = file_no;
241	243
242		_M_is_open = true;
243		_M_should_close = false;
244		_M_regular_file = _STLP_PRIV __is_regular_file(_M_file_id);
	244	int_flags_ \|= _is_open;
	245	if ( _STLP_PRIV __is_regular_file(_M_file_id) ) {
	246	int_flags_ \|= _regular;
	247	}
	248
245	249	return true;
246	250	}
247	251
248	252	bool _Filebuf_base::_M_close()
249	253	{
250		if (!_M_is_open)
	254	if ( (int_flags_ & _is_open) == 0 ) {
251	255	return false;
	256	}
252	257
253		bool ok = _M_should_close ? (close(_M_file_id) == 0) : true;
	258	bool ok = (int_flags_ & _should_close) != 0 ? (close(_M_file_id) == 0) : true;
254	259
255		_M_is_open = _M_should_close = false;
	260	int_flags_ = 0;
256	261	_M_openmode = 0;
	262
257	263	return ok;
258	264	}
259	265


194	194
195	195	size_t _Filebuf_base::_M_page_size = 4096;
196	196
197		_Filebuf_base::_Filebuf_base()
198		: _M_file_id(INVALID_STLP_FD),
	197	_Filebuf_base::_Filebuf_base() :
	198	_M_file_id(INVALID_STLP_FD),
199	199	_M_openmode(0),
200		_M_is_open(false),
201		_M_should_close(false),
	200	int_flags_(0),
202	201	_M_view_id(0)
203	202	{}
204	203
…	…
218	218	long permission) {
219	219	_STLP_fd file_no;
220	220
221		if (_M_is_open)
	221	if ( __is_open() ) {
222	222	return false;
	223	}
223	224
224	225	DWORD dwDesiredAccess, dwCreationDisposition;
225	226	bool doTruncate = false;
…	…
280	280	return false;
281	281	}
282	282
283		_M_is_open = true;
	283	int_flags_ \|= _is_open \| _should_close;
284	284	_M_file_id = file_no;
285		_M_should_close = _M_is_open;
286	285	_M_openmode = openmode;
287	286
288		if (_M_is_open)
289		_M_regular_file = _STLP_PRIV __is_regular_file(_M_file_id);
	287	if ( _STLP_PRIV __is_regular_file(_M_file_id) ) {
	288	int_flags_ \|= _regular;
	289	}
290	290
291		return (_M_is_open != 0);
	291	return true;
292	292	}
293	293
294	294	bool _Filebuf_base::_M_open(const char* name, ios_base::openmode openmode) {
…	…
298	298	return this->_M_open(name, openmode, FILE_ATTRIBUTE_NORMAL);
299	299	}
300	300
301		bool _Filebuf_base::_M_open(_STLP_fd __id, ios_base::openmode init_mode) {
	301	bool _Filebuf_base::_M_open(_STLP_fd __id, ios_base::openmode init_mode)
	302	{
302	303	#if (defined (_STLP_MSVC_LIB) && !defined (_STLP_WCE)) \|\| \
303	304	(defined (__MINGW32__) && defined (__MSVCRT__)) \|\| defined (__DMC__)
304	305
305		if (_M_is_open \|\| __id == INVALID_STLP_FD)
	306	if ( (int_flags_ & _is_open) \|\| (__id == INVALID_STLP_FD) ) {
306	307	return false;
	308	}
307	309
308		if (init_mode != ios_base::__default_mode)
	310	if (init_mode != ios_base::__default_mode) {
309	311	_M_openmode = init_mode;
310		else
	312	} else {
311	313	_M_openmode = _get_osfflags(-1, __id);
	314	}
312	315
313		_M_is_open = true;
	316	int_flags_ \|= _is_open;
314	317	_M_file_id = __id;
315		_M_should_close = false;
316		_M_regular_file = _STLP_PRIV __is_regular_file(_M_file_id);
	318	if ( _STLP_PRIV __is_regular_file(_M_file_id) ) {
	319	int_flags_ \|= _regular;
	320	}
317	321
318	322	return true;
319	323	#else
…	…
333	333	// Associated the filebuf with a file descriptor pointing to an already-
334	334	// open file. Mode is set to be consistent with the way that the file
335	335	// was opened.
336		bool _Filebuf_base::_M_open(int file_no, ios_base::openmode init_mode) {
337		if (_M_is_open \|\| file_no < 0)
	336	bool _Filebuf_base::_M_open(int file_no, ios_base::openmode init_mode)
	337	{
	338	if ( (int_flags_ & _is_open) \|\| (file_no < 0) ) {
338	339	return false;
	340	}
339	341
340	342	#if (defined (_STLP_MSVC_LIB) && !defined (_STLP_WCE)) \|\| \
341	343	(defined (__MINGW32__) && defined (__MSVCRT__)) \|\| defined (__DMC__)
…	…
352	352	_M_openmode = _get_osfflags(file_no, oshandle);
353	353
354	354	_M_file_id = oshandle;
355		_M_is_open = true;
356		_M_should_close = false;
357		_M_regular_file = _STLP_PRIV __is_regular_file(_M_file_id);
	355	int_flags_ \|= _is_open;
	356	if ( _STLP_PRIV __is_regular_file(_M_file_id) ) {
	357	int_flags_ \|= _regular;
	358	}
	359
358	360	return true;
359	361	#else
360	362	_STLP_MARK_PARAMETER_AS_UNUSED(&init_mode)
…	…
365	365	#endif
366	366	}
367	367
368		bool _Filebuf_base::_M_close() {
369		if (!_M_is_open)
	368	bool _Filebuf_base::_M_close()
	369	{
	370	if ( (int_flags_ & _is_open) == 0 ) {
370	371	return false;
371
372		bool ok;
373
374		if (!_M_should_close)
375		ok = true;
376		else {
377		if (_M_file_id != INVALID_STLP_FD) {
378		ok = (CloseHandle(_M_file_id) != 0);
379		}
380		else {
381		ok = false;
382		}
383	372	}
384	373
385		_M_is_open = _M_should_close = false;
	374	bool ok = (int_flags_ & _should_close) == 0 ? true : (_M_file_id == INVALID_STLP_FD ? false : (CloseHandle(_M_file_id) != 0));
	375
	376	int_flags_ = 0;
386	377	_M_openmode = 0;
	378
387	379	return ok;
388	380	}
389	381


52	52	// Class _Filebuf_base, a private base class to factor out the system-
53	53	// dependent code from basic_filebuf<>.
54	54
55		class _STLP_CLASS_DECLSPEC _Filebuf_base {
	55	class _STLP_CLASS_DECLSPEC _Filebuf_base
	56	{
56	57	public: // Opening and closing files.
57	58	_Filebuf_base();
58	59
…	…
110	110	protected: // Static data members.
111	111	static size_t _M_page_size;
112	112
113		protected: // Data members.
114		_STLP_fd _M_file_id;
	113	protected:
	114	_STLP_fd _M_file_id;
115	115	#if defined (_STLP_USE_STDIO_IO)
116		// for stdio, the whole FILE* is being kept here
117		FILE* _M_file;
	116	// for stdio, the whole FILE* is being kept here
	117	FILE* _M_file;
118	118	#endif
119		ios_base::openmode _M_openmode ;
120		unsigned char _M_is_open ;
121		unsigned char _M_should_close ;
122		unsigned char _M_regular_file ;
	119	ios_base::openmode _M_openmode;
123	120
	121	enum {
	122	_is_open = 0x1,
	123	_should_close = 0x2,
	124	_regular = 0x4
	125	};
	126
	127	unsigned int_flags_;
	128
124	129	#if defined (_STLP_USE_WIN32_IO)
125		_STLP_fd _M_view_id;
	130	_STLP_fd _M_view_id;
126	131	#endif
127	132
128		public :
129		static size_t _STLP_CALL __page_size() { return _M_page_size; }
130		int __o_mode() const { return (int)_M_openmode; }
131		bool __is_open() const { return (_M_is_open !=0 ); }
132		bool __should_close() const { return (_M_should_close != 0); }
133		bool __regular_file() const { return (_M_regular_file != 0); }
134		_STLP_fd __get_fd() const { return _M_file_id; }
	133	public:
	134	static size_t _STLP_CALL __page_size()
	135	{ return _M_page_size; }
	136	int __o_mode() const
	137	{ return (int)_M_openmode; }
	138	bool __is_open() const
	139	{ return (int_flags_ & _is_open) != 0; }
	140	bool __should_close() const
	141	{ return (int_flags_ & _should_close) != 0; }
	142	bool __regular_file() const
	143	{ return (int_flags_ & _regular) != 0; }
	144	_STLP_fd __get_fd() const
	145	{ return _M_file_id; }
135	146	};
136	147
137	148	//----------------------------------------------------------------------

Commit d01bd98390bc474a6082bc2a9b95b97ba62d08fc

Gitorious