/elec/propeller-clock : contents of src/utility/istream

: (revision 57)

To get this branch, use:

bzr branch
http://bzr.ed.am/elec/propeller-clock

/*	Copyright (C) 2004 Garrett A. Kajmowicz

	This file is part of the uClibc++ Library.

	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public
	License along with this library; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include <ios>
#include <cctype>

#include <string>

#ifndef __STD_HEADER_ISTREAM_HELPERS
#define __STD_HEADER_ISTREAM_HELPERS 1

#pragma GCC visibility push(default)

namespace std{


	/* We are making the following template class for serveral reasons.  Firstly,
	 * we want to keep the main istream code neat and tidy.  Secondly, we want it
	 * to be easy to do partial specialization of the istream code so that it can
	 * be expanded and put into the library.  This will allow us to make application
	 * code smaller at the expense of increased library size.  This is a fair
	 * trade-off when there are multiple applications being compiled.  Also, this
	 * feature will be used optionally via configuration options.  It will also
	 * allow us to keep the code bases in sync, dramatically simplifying the
	 * maintenance required.  We specialized for char because wchar and others
	 * require different scanf functions
	 */

	template <class C, class traits> _UCXXEXPORT 
		basic_string<C, traits> _readToken(basic_istream<C, traits>& stream)
	{
		basic_string<C, traits> temp;
		typename traits::int_type c;
		while(true){
			c = stream.rdbuf()->sgetc();
			if(c != traits::eof() && isspace(c) == false){
				stream.rdbuf()->sbumpc();
				temp.append(1, traits::to_char_type(c));
			}else{
				break;
			}
		}
		if (temp.size() == 0)
			stream.setstate(ios_base::eofbit|ios_base::failbit);

		return temp;
	}

	template <class C, class traits> _UCXXEXPORT 
		basic_string<C, traits> _readTokenDecimal(basic_istream<C, traits>& stream)
	{
		basic_string<C, traits> temp;
		typename traits::int_type c;
		while(true){
			c = stream.rdbuf()->sgetc();
			if(c != traits::eof() && isspace(c) == false && (
				isdigit(c) ||
				c == '.' ||
				c == ',' ||
				((c == '-' || c == '+') && temp.size() == 0) )
			){
				stream.rdbuf()->sbumpc();
				temp.append(1, traits::to_char_type(c));
			}else{
				break;
			}
		}
		if (temp.size() == 0)
			stream.setstate(ios_base::eofbit|ios_base::failbit);

		return temp;
	}

#ifdef __UCLIBCXX_EXPAND_ISTREAM_CHAR__

	template <> _UCXXEXPORT string _readToken<char, char_traits<char> >(istream & stream);

#endif


	template <class traits, class charT, class dataType> class _UCXXEXPORT __istream_readin{
	public:
		static void readin(basic_istream<charT,traits>& stream, dataType & var);
	};

	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, bool>{
	public:
		inline static void readin(basic_istream<char, traits >& stream, bool & var)
		{
			basic_string<char, traits > temp;
			temp = _readToken( stream);
			if(temp == "true" || temp == "True" || temp == "TRUE" || temp == "1"){
				var = true;
			}else{
				var = false;
			}
		}
	};


	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, short>{
	public:
		inline static void readin(basic_istream<char, traits >& stream, short & var)
		{
			basic_string<char, traits > temp;

			if(stream.flags() & ios_base::dec){
				temp = _readTokenDecimal( stream);
				sscanf(temp.c_str(), "%hd", &var );
			}else{
				temp = _readToken( stream);
				if( stream.flags() & ios_base::oct){
					sscanf(temp.c_str(), "%ho", (unsigned short int *)(&var) );
				}else if(stream.flags() & ios_base::hex){
					if(stream.flags() & ios_base::uppercase){
						sscanf(temp.c_str(), "%hX", (unsigned short int *)(&var) );
					}else{
						sscanf(temp.c_str(), "%hx", (unsigned short int *)(&var) );
					}
				}else{
					sscanf(temp.c_str(), "%hi", &var);
		
				}
			}
		}
	};

	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, unsigned short>{
	public:
		inline static void readin(basic_istream<char, traits >& stream, unsigned short & var)
		{
			basic_string<char, traits > temp;

			if(stream.flags() & ios_base::dec){
				temp = _readTokenDecimal( stream);
				sscanf(temp.c_str(), "%hu", &var );
			}else{
				temp = _readToken( stream);
				if( stream.flags() & ios_base::oct){
					sscanf(temp.c_str(), "%ho", &var);
				}else if(stream.flags() & ios_base::hex){
					if(stream.flags() & ios_base::uppercase){
						sscanf(temp.c_str(), "%hX", &var );
					}else{
						sscanf(temp.c_str(), "%hx", &var);
					}
				}else{
					sscanf(temp.c_str(), "%hi", (signed short int*)(&var) );
				}
			}
		}
	};

	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, int>{
	public:
		inline static void readin(basic_istream<char, traits >& stream, int & var)
		{
			basic_string<char, traits > temp;

			if(stream.flags() & ios_base::dec){
				temp = _readTokenDecimal( stream);
				sscanf(temp.c_str(), "%d", &var );
			}else{
				temp = _readToken( stream);
				if( stream.flags() & ios_base::oct){
					sscanf(temp.c_str(), "%o", (unsigned int *)(&var) );
				}else if(stream.flags() & ios_base::hex){
					if(stream.flags() & ios_base::uppercase){
						sscanf(temp.c_str(), "%X", (unsigned int *)(&var) );
					}else{
						sscanf(temp.c_str(), "%x", (unsigned int *)(&var) );
					}
				}else{
					sscanf(temp.c_str(), "%i", &var);
				}
			}
		}
	};

	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, unsigned int>{
	public:
		inline static void readin(basic_istream<char, traits >& stream, unsigned int & var)
		{
			basic_string<char, traits > temp;

			if(stream.flags() & ios_base::dec){
				temp = _readTokenDecimal( stream);
				sscanf(temp.c_str(), "%u", &var );
			}else{
				temp = _readToken( stream);
				if( stream.flags() & ios_base::oct){
					sscanf(temp.c_str(), "%o", (unsigned int *)(&var) );
				}else if(stream.flags() & ios_base::hex){
					if(stream.flags() & ios_base::uppercase){
						sscanf(temp.c_str(), "%X", (unsigned int *)(&var) );
					}else{
						sscanf(temp.c_str(), "%x", (unsigned int *)(&var) );
					}
				}else{
					sscanf(temp.c_str(), "%i", (int *)(&var) );
				}
			}	

		}
	};


	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, long int>{
	public:
		inline static void readin(basic_istream<char, traits >& stream, long int & var)
		{
			basic_string<char, traits > temp;

			if(stream.flags() & ios_base::dec){
				temp = _readTokenDecimal( stream);
				sscanf(temp.c_str(), "%ld", &var );
			}else{
				temp = _readToken( stream);
				if( stream.flags() & ios_base::oct){
					sscanf(temp.c_str(), "%lo", (unsigned long int *)(&var) );
				}else if(stream.flags() & ios_base::hex){
					if(stream.flags() & ios_base::uppercase){
						sscanf(temp.c_str(), "%lX", (unsigned long int *)(&var) );
					}else{
						sscanf(temp.c_str(), "%lx", (unsigned long int *)(&var) );
					}
				}else{
					sscanf(temp.c_str(), "%li", (long int *)(&var) );
				}
			}

		}
	};


	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, unsigned long int>{
	public:
		inline static void readin(basic_istream<char, traits >& stream, unsigned long int & var)
		{
			basic_string<char, traits > temp;

			if(stream.flags() & ios_base::dec){
				temp = _readTokenDecimal( stream);
				sscanf(temp.c_str(), "%lu", &var );
			}else{
				temp = _readToken( stream);
				if( stream.flags() & ios_base::oct){
					sscanf(temp.c_str(), "%lo", &var );
				}else if(stream.flags() & ios_base::hex){
					if(stream.flags() & ios_base::uppercase){
						sscanf(temp.c_str(), "%lX", &var );
					}else{
						sscanf(temp.c_str(), "%lx", &var);
					}
				}else{
					sscanf(temp.c_str(), "%li", (long int *)(&var) );
				}
			}
		}
	};


#ifdef __UCLIBCXX_HAS_FLOATS__

	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, float>{
	public:
		inline static void readin(basic_istream<char, traits >& stream, float & var)
		{
			basic_string<char, traits > temp;
			temp = _readTokenDecimal( stream);
#if defined (__AVR__) 
			var = strtod(temp.c_str(), NULL);
#else
			sscanf(temp.c_str(), "%g", &var);
#endif
			
		}
	};

	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, double>{
	public:
		inline static void readin(basic_istream<char, traits >& stream, double & var)
		{
			basic_string<char, traits > temp;
			temp = _readTokenDecimal( stream);
#if defined (__AVR__)
			var = strtod(temp.c_str(), NULL);
#else			
			sscanf(temp.c_str(), "%lg", &var);
#endif			
		}
	};

	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, long double>{
	public:
		inline static void readin(basic_istream<char, traits >& stream, long double & var)
		{
			basic_string<char, traits > temp;
			temp = _readTokenDecimal( stream);
#if defined (__AVR__)
			var = strtod(temp.c_str(), NULL);
#else			
			sscanf(temp.c_str(), "%Lg", &var);
#endif			
		}
	};

#endif	// ifdef __UCLIBCXX_HAS_FLOATS__

	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, void*>{
	public:
		inline static void readin(basic_istream<char, traits >& stream, void* & var)
		{
			basic_string<char, traits > temp;
			temp = _readToken( stream);
			sscanf(temp.c_str(), "%p", &var);
		}
	};


	template<class charT, class traits> void __skipws(basic_istream<charT,traits>& is){
		const typename basic_istream<charT,traits>::int_type eof = traits::eof();
		typename basic_istream<charT,traits>::int_type c;
		//While the next character normally read doesn't equal eof
		//and that character is a space, advance to the next read position
		//Thus itterating through all whitespace until we get to the meaty stuff
		while (
			!traits::eq_int_type((c = is.rdbuf()->sgetc()),	eof)
			&& isspace(c)
                      )
		{
			is.rdbuf()->sbumpc();
		}
		if(traits::eq_int_type(c, eof)){
			is.setstate(ios_base::eofbit);
		}
	}
}

#pragma GCC visibility pop

#endif




57 by edam added ulibc	1	/* Copyright (C) 2004 Garrett A. Kajmowicz
	2
	3	This file is part of the uClibc++ Library.
	4
	5	This library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
	9
	10	This library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Lesser General Public License for more details.
	14
	15	You should have received a copy of the GNU Lesser General Public
	16	License along with this library; if not, write to the Free Software
	17	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	*/
	19
	20	#include <ios>
	21	#include <cctype>
	22
	23	#include <string>
	24
	25	#ifndef __STD_HEADER_ISTREAM_HELPERS
	26	#define __STD_HEADER_ISTREAM_HELPERS 1
	27
	28	#pragma GCC visibility push(default)
	29
	30	namespace std{
	31
	32
	33	/* We are making the following template class for serveral reasons. Firstly,
	34	* we want to keep the main istream code neat and tidy. Secondly, we want it
	35	* to be easy to do partial specialization of the istream code so that it can
	36	* be expanded and put into the library. This will allow us to make application
	37	* code smaller at the expense of increased library size. This is a fair
	38	* trade-off when there are multiple applications being compiled. Also, this
	39	* feature will be used optionally via configuration options. It will also
	40	* allow us to keep the code bases in sync, dramatically simplifying the
	41	* maintenance required. We specialized for char because wchar and others
	42	* require different scanf functions
	43	*/
	44
	45	template <class C, class traits> _UCXXEXPORT
	46	basic_string<C, traits> _readToken(basic_istream<C, traits>& stream)
	47	{
	48	basic_string<C, traits> temp;
	49	typename traits::int_type c;
	50	while(true){
	51	c = stream.rdbuf()->sgetc();
	52	if(c != traits::eof() && isspace(c) == false){
	53	stream.rdbuf()->sbumpc();
	54	temp.append(1, traits::to_char_type(c));
	55	}else{
	56	break;
	57	}
	58	}
	59	if (temp.size() == 0)
	60	stream.setstate(ios_base::eofbit\|ios_base::failbit);
	61
	62	return temp;
	63	}
	64
65	template <class C, class traits> _UCXXEXPORT
66	basic_string<C, traits> _readTokenDecimal(basic_istream<C, traits>& stream)
67	{
68	basic_string<C, traits> temp;
69	typename traits::int_type c;
70	while(true){
71	c = stream.rdbuf()->sgetc();
72	if(c != traits::eof() && isspace(c) == false && (
73	isdigit(c) \|\|
74	c == '.' \|\|
75	c == ',' \|\|
76	((c == '-' \|\| c == '+') && temp.size() == 0) )
77	){
78	stream.rdbuf()->sbumpc();
79	temp.append(1, traits::to_char_type(c));
80	}else{
81	break;
82	}
83	}
84	if (temp.size() == 0)
85	stream.setstate(ios_base::eofbit\|ios_base::failbit);
86
87	return temp;
88	}
89
90	#ifdef __UCLIBCXX_EXPAND_ISTREAM_CHAR__
91
92	template <> _UCXXEXPORT string _readToken<char, char_traits<char> >(istream & stream);
93
94	#endif
95
96
97	template <class traits, class charT, class dataType> class _UCXXEXPORT __istream_readin{
98	public:
99	static void readin(basic_istream<charT,traits>& stream, dataType & var);
100	};
101
102	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, bool>{
103	public:
104	inline static void readin(basic_istream<char, traits >& stream, bool & var)
105	{
106	basic_string<char, traits > temp;
107	temp = _readToken( stream);
108	if(temp == "true" \|\| temp == "True" \|\| temp == "TRUE" \|\| temp == "1"){
109	var = true;
110	}else{
111	var = false;
112	}
113	}
114	};
115
116
117	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, short>{
118	public:
119	inline static void readin(basic_istream<char, traits >& stream, short & var)
120	{
121	basic_string<char, traits > temp;
122
123	if(stream.flags() & ios_base::dec){
124	temp = _readTokenDecimal( stream);
125	sscanf(temp.c_str(), "%hd", &var );
126	}else{
127	temp = _readToken( stream);
128	if( stream.flags() & ios_base::oct){
129	sscanf(temp.c_str(), "%ho", (unsigned short int *)(&var) );
130	}else if(stream.flags() & ios_base::hex){
131	if(stream.flags() & ios_base::uppercase){
132	sscanf(temp.c_str(), "%hX", (unsigned short int *)(&var) );
133	}else{
134	sscanf(temp.c_str(), "%hx", (unsigned short int *)(&var) );
135	}
136	}else{
137	sscanf(temp.c_str(), "%hi", &var);
138
139	}
140	}
141	}
142	};
143
144	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, unsigned short>{
145	public:
146	inline static void readin(basic_istream<char, traits >& stream, unsigned short & var)
147	{
148	basic_string<char, traits > temp;
149
150	if(stream.flags() & ios_base::dec){
151	temp = _readTokenDecimal( stream);
152	sscanf(temp.c_str(), "%hu", &var );
153	}else{
154	temp = _readToken( stream);
155	if( stream.flags() & ios_base::oct){
156	sscanf(temp.c_str(), "%ho", &var);
157	}else if(stream.flags() & ios_base::hex){
158	if(stream.flags() & ios_base::uppercase){
159	sscanf(temp.c_str(), "%hX", &var );
160	}else{
161	sscanf(temp.c_str(), "%hx", &var);
162	}
163	}else{
164	sscanf(temp.c_str(), "%hi", (signed short int*)(&var) );
165	}
166	}
167	}
168	};
169
170	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, int>{
171	public:
172	inline static void readin(basic_istream<char, traits >& stream, int & var)
173	{
174	basic_string<char, traits > temp;
175
176	if(stream.flags() & ios_base::dec){
177	temp = _readTokenDecimal( stream);
178	sscanf(temp.c_str(), "%d", &var );
179	}else{
180	temp = _readToken( stream);
181	if( stream.flags() & ios_base::oct){
182	sscanf(temp.c_str(), "%o", (unsigned int *)(&var) );
183	}else if(stream.flags() & ios_base::hex){
184	if(stream.flags() & ios_base::uppercase){
185	sscanf(temp.c_str(), "%X", (unsigned int *)(&var) );
186	}else{
187	sscanf(temp.c_str(), "%x", (unsigned int *)(&var) );
188	}
189	}else{
190	sscanf(temp.c_str(), "%i", &var);
191	}
192	}
193	}
194	};
195
196	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, unsigned int>{
197	public:
198	inline static void readin(basic_istream<char, traits >& stream, unsigned int & var)
199	{
200	basic_string<char, traits > temp;
201
202	if(stream.flags() & ios_base::dec){
203	temp = _readTokenDecimal( stream);
204	sscanf(temp.c_str(), "%u", &var );
205	}else{
206	temp = _readToken( stream);
207	if( stream.flags() & ios_base::oct){
208	sscanf(temp.c_str(), "%o", (unsigned int *)(&var) );
209	}else if(stream.flags() & ios_base::hex){
210	if(stream.flags() & ios_base::uppercase){
211	sscanf(temp.c_str(), "%X", (unsigned int *)(&var) );
212	}else{
213	sscanf(temp.c_str(), "%x", (unsigned int *)(&var) );
214	}
215	}else{
216	sscanf(temp.c_str(), "%i", (int *)(&var) );
217	}
218	}
219
220	}
221	};
222
223
224	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, long int>{
225	public:
226	inline static void readin(basic_istream<char, traits >& stream, long int & var)
227	{
228	basic_string<char, traits > temp;
229
230	if(stream.flags() & ios_base::dec){
231	temp = _readTokenDecimal( stream);
232	sscanf(temp.c_str(), "%ld", &var );
233	}else{
234	temp = _readToken( stream);
235	if( stream.flags() & ios_base::oct){
236	sscanf(temp.c_str(), "%lo", (unsigned long int *)(&var) );
237	}else if(stream.flags() & ios_base::hex){
238	if(stream.flags() & ios_base::uppercase){
239	sscanf(temp.c_str(), "%lX", (unsigned long int *)(&var) );
240	}else{
241	sscanf(temp.c_str(), "%lx", (unsigned long int *)(&var) );
242	}
243	}else{
244	sscanf(temp.c_str(), "%li", (long int *)(&var) );
245	}
246	}
247
248	}
249	};
250
251
252	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, unsigned long int>{
253	public:
254	inline static void readin(basic_istream<char, traits >& stream, unsigned long int & var)
255	{
256	basic_string<char, traits > temp;
257
258	if(stream.flags() & ios_base::dec){
259	temp = _readTokenDecimal( stream);
260	sscanf(temp.c_str(), "%lu", &var );
261	}else{
262	temp = _readToken( stream);
263	if( stream.flags() & ios_base::oct){
264	sscanf(temp.c_str(), "%lo", &var );
265	}else if(stream.flags() & ios_base::hex){
266	if(stream.flags() & ios_base::uppercase){
267	sscanf(temp.c_str(), "%lX", &var );
268	}else{
269	sscanf(temp.c_str(), "%lx", &var);
270	}
271	}else{
272	sscanf(temp.c_str(), "%li", (long int *)(&var) );
273	}
274	}
275	}
276	};
277
278
279	#ifdef __UCLIBCXX_HAS_FLOATS__
280
281	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, float>{
282	public:
283	inline static void readin(basic_istream<char, traits >& stream, float & var)
284	{
285	basic_string<char, traits > temp;
286	temp = _readTokenDecimal( stream);
287	#if defined (__AVR__)
288	var = strtod(temp.c_str(), NULL);
289	#else
290	sscanf(temp.c_str(), "%g", &var);
291	#endif
292
293	}
294	};
295
296	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, double>{
297	public:
298	inline static void readin(basic_istream<char, traits >& stream, double & var)
299	{
300	basic_string<char, traits > temp;
301	temp = _readTokenDecimal( stream);
302	#if defined (__AVR__)
303	var = strtod(temp.c_str(), NULL);
304	#else
305	sscanf(temp.c_str(), "%lg", &var);
306	#endif
307	}
308	};
309
310	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, long double>{
311	public:
312	inline static void readin(basic_istream<char, traits >& stream, long double & var)
313	{
314	basic_string<char, traits > temp;
315	temp = _readTokenDecimal( stream);
316	#if defined (__AVR__)
317	var = strtod(temp.c_str(), NULL);
318	#else
319	sscanf(temp.c_str(), "%Lg", &var);
320	#endif
321	}
322	};
323
324	#endif // ifdef __UCLIBCXX_HAS_FLOATS__
325
326	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, void*>{
327	public:
328	inline static void readin(basic_istream<char, traits >& stream, void* & var)
329	{
330	basic_string<char, traits > temp;
331	temp = _readToken( stream);
332	sscanf(temp.c_str(), "%p", &var);
333	}
334	};
335
336
337	template<class charT, class traits> void __skipws(basic_istream<charT,traits>& is){
338	const typename basic_istream<charT,traits>::int_type eof = traits::eof();
339	typename basic_istream<charT,traits>::int_type c;
340	//While the next character normally read doesn't equal eof
341	//and that character is a space, advance to the next read position
342	//Thus itterating through all whitespace until we get to the meaty stuff
343	while (
344	!traits::eq_int_type((c = is.rdbuf()->sgetc()), eof)
345	&& isspace(c)
346	)
347	{
348	is.rdbuf()->sbumpc();
349	}
350	if(traits::eq_int_type(c, eof)){
351	is.setstate(ios_base::eofbit);
352	}
353	}
354	}
355
356	#pragma GCC visibility pop
357
358	#endif
359
360
361