+2008-01-31 Ralf Wildenhues <Ralf.Wildenhues@gmx.de>
+
+ * include/backward/auto_ptr.h: Fix comment typos.
+ * include/bits/algorithmfwd.h: Likewise.
+ * include/bits/basic_ios.h: Likewise.
+ * include/bits/c++config: Likewise.
+ * include/bits/char_traits.h: Likewise.
+ * include/bits/codecvt.h: Likewise.
+ * include/bits/gslice.h: Likewise.
+ * include/bits/ios_base.h: Likewise.
+ * include/bits/locale_facets.h: Likewise.
+ * include/bits/locale_facets_nonio.tcc: Likewise.
+ * include/bits/postypes.h: Likewise.
+ * include/bits/sstream.tcc: Likewise.
+ * include/bits/stl_algo.h: Likewise.
+ * include/bits/stl_deque.h: Likewise.
+ * include/bits/stl_iterator.h: Likewise.
+ * include/bits/stl_iterator_base_types.h Likewise.
+ * include/bits/stl_list.h: Likewise.
+ * include/bits/stl_map.h: Likewise.
+ * include/bits/stl_multimap.h: Likewise.
+ * include/bits/stl_multiset.h: Likewise.
+ * include/bits/stl_set.h: Likewise.
+ * include/bits/stl_vector.h: Likewise.
+ * include/bits/valarray_array.h: Likewise.
+ * include/debug/safe_base.h: Likewise.
+ * include/ext/bitmap_allocator.h: Likewise.
+ * include/ext/codecvt_specializations.h Likewise.
+ * include/ext/mt_allocator.h: Likewise.
+ * include/ext/rc_string_base.h: Likewise.
+ * include/ext/rope: Likewise.
+ * include/parallel/checkers.h: Likewise.
+ * include/parallel/find.h: Likewise.
+ * include/parallel/multiseq_selection.h: Likewise.
+ * include/parallel/partition.h: Likewise.
+ * include/parallel/settings.h: Likewise.
+ * include/std/bitset: Likewise.
+ * include/std/complex: Likewise.
+ * include/std/fstream: Likewise.
+ * include/std/istream: Likewise.
+ * include/std/limits: Likewise.
+ * include/std/ostream: Likewise.
+ * include/std/stdexcept: Likewise.
+ * include/std/streambuf: Likewise.
+ * include/tr1/bessel_function.tcc: Likewise.
+ * include/tr1/cmath: Likewise.
+ * include/tr1/ell_integral.tcc: Likewise.
+ * include/tr1/hypergeometric.tcc: Likewise.
+ * include/tr1/legendre_function.tcc: Likewise.
+ * include/tr1_impl/random: Likewise.
+ * include/tr1_impl/regex: Likewise.
+
2008-01-31 Paolo Carlini <pcarlini@suse.de>
* testsuite/27_io/basic_istream/extractors_character/pod/3983-2.cc:
* @param a Another %auto_ptr of the same type.
*
* This object now @e owns the object previously owned by @a a,
- * which has given up ownsership.
+ * which has given up ownership.
*/
auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
* pointer-to-Tp/element_type.
*
* This object now @e owns the object previously owned by @a a,
- * which has given up ownsership.
+ * which has given up ownership.
*/
template<typename _Tp1>
auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
* @param a Another %auto_ptr of the same type.
*
* This object now @e owns the object previously owned by @a a,
- * which has given up ownsership. The object that this one @e
+ * which has given up ownership. The object that this one @e
* used to own and track has been deleted.
*/
auto_ptr&
* A pointer-to-Tp1 must be convertible to a pointer-to-Tp/element_type.
*
* This object now @e owns the object previously owned by @a a,
- * which has given up ownsership. The object that this one @e
+ * which has given up ownership. The object that this one @e
* used to own and track has been deleted.
*/
template<typename _Tp1>
mismatch
next_permutation
nth_element
- parital_sort
+ partial_sort
partial_sort_copy
partition
pop_heap
rotate_copy
search
search_n
- set_differernce
+ set_difference
set_intersection
set_symmetric_difference
set_union
* in the error flags, then an exception of type
* std::ios_base::failure is thrown.
*
- * If the error flage is already set when the exceptions mask is
+ * If the error flag is already set when the exceptions mask is
* added, the exception is immediately thrown. Try running the
* following under GCC 3.1 or later:
* @code
copyfmt(const basic_ios& __rhs);
/**
- * @brief Retreives the "empty" character.
+ * @brief Retrieves the "empty" character.
* @return The current fill character.
*
* It defaults to a space (' ') in the current locale.
// _GLIBCXX_STD_P
//
-// Macros for enclosing namepaces and possibly nested namespaces.
+// Macros for enclosing namespaces and possibly nested namespaces.
// _GLIBCXX_BEGIN_NAMESPACE
// _GLIBCXX_END_NAMESPACE
// _GLIBCXX_BEGIN_NESTED_NAMESPACE
# endif
# if __NO_INLINE__ && !__GXX_WEAK__
-# warning currently using namepace associated mode which may fail \
+# warning currently using namespace associated mode which may fail \
without inlining due to lack of weak symbols
# endif
* right, but the int_type and state_type typedefs, and the eof()
* member function, are likely to be wrong.) The reason this class
* exists is so users can specialize it. Classes in namespace std
- * may not be specialized for fundamentl types, but classes in
+ * may not be specialized for fundamental types, but classes in
* namespace __gnu_cxx may be.
*
* See http://gcc.gnu.org/onlinedocs/libstdc++/21_strings/howto.html#5
* respectively. If the result needed no conversion, from_next and
* to_next are not affected.
*
- * The @a state argument should be intialized if the input is at the
+ * The @a state argument should be initialized if the input is at the
* beginning and carried from a previous call if continuing
* conversion. There are no guarantees about how @a state is used.
*
* respectively. If the result needed no conversion, from_next and
* to_next are not affected.
*
- * The @a state argument should be intialized if the input is at the
+ * The @a state argument should be initialized if the input is at the
* beginning and carried from a previous call if continuing
* conversion. There are no guarantees about how @a state is used.
*
gslice(size_t, const valarray<size_t>&, const valarray<size_t>&);
// XXX: the IS says the copy-ctor and copy-assignment operators are
- // synthetized by the compiler but they are just unsuitable
+ // synthesized by the compiler but they are just unsuitable
// for a ref-counted semantic
/// Copy constructor.
gslice(const gslice&);
return __base;
}
- // [27.4.5.2] adjustfield anipulators
+ // [27.4.5.2] adjustfield manipulators
/// Calls base.setf(ios_base::internal, ios_base::adjustfield).
inline ios_base&
internal(ios_base& __base)
return __base;
}
- // [27.4.5.3] basefield anipulators
+ // [27.4.5.3] basefield manipulators
/// Calls base.setf(ios_base::dec, ios_base::basefield).
inline ios_base&
dec(ios_base& __base)
return __base;
}
- // [27.4.5.4] floatfield anipulators
+ // [27.4.5.4] floatfield manipulators
/// Calls base.setf(ios_base::fixed, ios_base::floatfield).
inline ios_base&
fixed(ios_base& __base)
* This template class provides implementations of the public functions
* that forward to the protected virtual functions.
*
- * This template also provides abtract stubs for the protected virtual
+ * This template also provides abstract stubs for the protected virtual
* functions.
*/
template<typename _CharT>
* specifier. Otherwise, parses like %d for signed and %u for unsigned
* types. The matching type length modifier is also used.
*
- * Digit grouping is intrepreted according to numpunct::grouping() and
+ * Digit grouping is interpreted according to numpunct::grouping() and
* numpunct::thousands_sep(). If the pattern of digit groups isn't
* consistent, sets err to ios_base::failbit.
*
* matching type length modifier is also used.
*
* The decimal point character used is numpunct::decimal_point().
- * Digit grouping is intrepreted according to numpunct::grouping() and
+ * Digit grouping is interpreted according to numpunct::grouping() and
* numpunct::thousands_sep(). If the pattern of digit groups isn't
* consistent, sets err to ios_base::failbit.
*
*
* The input characters are parsed like the scanf %p specifier.
*
- * Digit grouping is intrepreted according to numpunct::grouping() and
+ * Digit grouping is interpreted according to numpunct::grouping() and
* numpunct::thousands_sep(). If the pattern of digit groups isn't
* consistent, sets err to ios_base::failbit.
*
break;
case money_base::sign:
// Sign might not exist, or be more than one
- // charater long. In that case, add in the rest
+ // character long. In that case, add in the rest
// below.
if (__sign_size)
__res += __sign[0];
// The types streamoff, streampos and wstreampos and the class
// template fpos<> are described in clauses 21.1.2, 21.1.3, 27.1.2,
- // 27.2, 27.4.1, 27.4.3 and D.6. Despite all this verbage, the
+ // 27.2, 27.4.1, 27.4.3 and D.6. Despite all this verbiage, the
// behaviour of these types is mostly implementation defined or
// unspecified. The behaviour in this implementation is as noted
// below.
{ return _M_state; }
// The standard requires that this operator must be defined, but
- // gives no semantics. In this implemenation it just adds it's
+ // gives no semantics. In this implementation it just adds its
// argument to the stored offset and returns *this.
/// Add offset to this position.
fpos&
}
// The standard requires that this operator must be defined, but
- // gives no semantics. In this implemenation it just subtracts
- // it's argument from the stored offset and returns *this.
+ // gives no semantics. In this implementation it just subtracts
+ // its argument from the stored offset and returns *this.
/// Subtract offset from this position.
fpos&
operator-=(streamoff __off)
}
// The standard requires that this operator must be defined, but
- // defines it's semantics only in terms of operator-. In this
+ // defines its semantics only in terms of operator-. In this
// implementation it constructs a copy of *this, adds the
// argument to that copy using operator+= and then returns the
// copy.
}
// The standard requires that this operator must be defined, but
- // defines it's semantics only in terms of operator+. In this
+ // defines its semantics only in terms of operator+. In this
// implementation it constructs a copy of *this, subtracts the
// argument from that copy using operator-= and then returns the
// copy.
}
// The standard requires that this operator must be defined, but
- // defines it's semantics only in terms of operator+. In this
+ // defines its semantics only in terms of operator+. In this
// implementation it returns the difference between the offset
// stored in *this and in the argument.
/// Subtract position to return offset.
{
// NB: Start ostringstream buffers at 512 chars. This is an
// experimental value (pronounced "arbitrary" in some of the
- // hipper english-speaking countries), and can be changed to
+ // hipper English-speaking countries), and can be changed to
// suit particular needs.
//
// _GLIBCXX_RESOLVE_LIB_DEFECTS
* @param first An iterator.
* @param last Another iterator.
* @param val The search term.
- * @return True if @a val (or its equivelent) is in [@a first,@a last ].
+ * @return True if @a val (or its equivalent) is in [@a first,@a last ].
* @ingroup binarysearch
*
* Note that this does not actually return an iterator to @a val. For
* @param last Another iterator.
* @param val The search term.
* @param comp A functor to use for comparisons.
- * @return True if @a val (or its equivelent) is in [@a first,@a last ].
+ * @return True if @a val (or its equivalent) is in [@a first,@a last ].
* @ingroup binarysearch
*
* Note that this does not actually return an iterator to @a val. For
* @param last2 End of match candidates.
* @return The first iterator @c i in the range
* @p [first1,last1) such that @c *i == @p *(i2) such that i2 is an
- * interator in [first2,last2), or @p last1 if no such iterator exists.
+ * iterator in [first2,last2), or @p last1 if no such iterator exists.
*
* Searches the range @p [first1,last1) for an element that is equal to
* some element in the range [first2,last2). If found, returns an iterator
* @param comp Predicate to use.
* @return The first iterator @c i in the range
* @p [first1,last1) such that @c comp(*i, @p *(i2)) is true and i2 is an
- * interator in [first2,last2), or @p last1 if no such iterator exists.
+ * iterator in [first2,last2), or @p last1 if no such iterator exists.
*
* Searches the range @p [first1,last1) for an element that is
*
* This function started off as a compiler kludge from SGI, but seems to
* be a useful wrapper around a repeated constant expression. The '512' is
- * tuneable (and no other code needs to change), but no investigation has
+ * tunable (and no other code needs to change), but no investigation has
* been done since inheriting the SGI code.
*/
inline size_t
using _Base::_M_get_Tp_allocator;
/**
- * A total of four data members accumulated down the heirarchy.
+ * A total of four data members accumulated down the hierarchy.
* May be accessed via _M_impl.*
*/
using _Base::_M_impl;
/**
* The dtor only erases the elements, and note that if the elements
* themselves are pointers, the pointed-to memory is not touched in any
- * way. Managing the pointer is the user's responsibilty.
+ * way. Managing the pointer is the user's responsibility.
*/
~deque()
{ _M_destroy_data(begin(), end(), _M_get_Tp_allocator()); }
* The user is cautioned that
* this function only erases the element, and that if the element is
* itself a pointer, the pointed-to memory is not touched in any way.
- * Managing the pointer is the user's responsibilty.
+ * Managing the pointer is the user's responsibility.
*/
iterator
erase(iterator __position);
* The user is cautioned that
* this function only erases the elements, and that if the elements
* themselves are pointers, the pointed-to memory is not touched in any
- * way. Managing the pointer is the user's responsibilty.
+ * way. Managing the pointer is the user's responsibility.
*/
iterator
erase(iterator __first, iterator __last);
* Erases all the elements. Note that this function only erases the
* elements, and that if the elements themselves are pointers, the
* pointed-to memory is not touched in any way. Managing the pointer is
- * the user's responsibilty.
+ * the user's responsibility.
*/
void
clear()
// Note: In what follows, the left- and right-hand-side iterators are
// allowed to vary in types (conceptually in cv-qualification) so that
- // comparaison between cv-qualified and non-cv-qualified iterators be
+ // comparison between cv-qualified and non-cv-qualified iterators be
// valid. However, the greedy and unfriendly operators in std::rel_ops
// will make overload resolution ambiguous (when in scope) if we don't
// provide overloads whose operands are of the same type. Can someone
* These are empty types, used to distinguish different iterators. The
* distinction is not made by what they contain, but simply by what they
* are. Different underlying algorithms can then be used based on the
- * different operations supporetd by different iterator types.
+ * different operations supported by different iterator types.
*/
/// Marking input iterators.
struct input_iterator_tag {};
* things. The _Base dtor only erases the elements, and note
* that if the elements themselves are pointers, the pointed-to
* memory is not touched in any way. Managing the pointer is
- * the user's responsibilty.
+ * the user's responsibility.
*/
/**
* the element being removed. The user is also cautioned that
* this function only erases the element, and that if the element
* is itself a pointer, the pointed-to memory is not touched in
- * any way. Managing the pointer is the user's responsibilty.
+ * any way. Managing the pointer is the user's responsibility.
*/
iterator
erase(iterator __position);
* The user is also cautioned that this function only erases the
* elements, and that if the elements themselves are pointers, the
* pointed-to memory is not touched in any way. Managing the pointer
- * is the user's responsibilty.
+ * is the user's responsibility.
*/
iterator
erase(iterator __first, iterator __last)
* Erases all the elements. Note that this function only erases
* the elements, and that if the elements themselves are
* pointers, the pointed-to memory is not touched in any way.
- * Managing the pointer is the user's responsibilty.
+ * Managing the pointer is the user's responsibility.
*/
void
clear()
* function only erases the elements, and that if the elements
* themselves are pointers, the pointed-to memory is not
* touched in any way. Managing the pointer is the user's
- * responsibilty.
+ * responsibility.
*/
void
remove(const _Tp& __value);
* that this function only erases the elements, and that if the
* elements themselves are pointers, the pointed-to memory is
* not touched in any way. Managing the pointer is the user's
- * responsibilty.
+ * responsibility.
*/
template<typename _Predicate>
void
* list order. Note that this function only erases the
* elements, and that if the elements themselves are pointers,
* the pointed-to memory is not touched in any way. Managing
- * the pointer is the user's responsibilty.
+ * the pointer is the user's responsibility.
*/
void
unique();
* elements stay in list order. Note that this function only
* erases the elements, and that if the elements themselves are
* pointers, the pointed-to memory is not touched in any way.
- * Managing the pointer is the user's responsibilty.
+ * Managing the pointer is the user's responsibility.
*/
template<typename _BinaryPredicate>
void
/**
* @brief Merge sorted lists according to comparison function.
* @param x Sorted list to merge.
- * @param StrictWeakOrdering Comparison function definining
+ * @param StrictWeakOrdering Comparison function defining
* sort order.
*
* Assumes that both @a x and this list are sorted according to
/**
* The dtor only erases the elements, and note that if the elements
* themselves are pointers, the pointed-to memory is not touched in any
- * way. Managing the pointer is the user's responsibilty.
+ * way. Managing the pointer is the user's responsibility.
*/
/**
{ return _M_t._M_insert_unique_(__position, __x); }
/**
- * @brief Template function that attemps to insert a range of elements.
+ * @brief Template function that attempts to insert a range of elements.
* @param first Iterator pointing to the start of the range to be
* inserted.
* @param last Iterator pointing to the end of the range.
* iterator, from a %map. Note that this function only erases
* the element, and that if the element is itself a pointer,
* the pointed-to memory is not touched in any way. Managing
- * the pointer is the user's responsibilty.
+ * the pointer is the user's responsibility.
*/
void
erase(iterator __position)
* a %map.
* Note that this function only erases the element, and that if
* the element is itself a pointer, the pointed-to memory is not touched
- * in any way. Managing the pointer is the user's responsibilty.
+ * in any way. Managing the pointer is the user's responsibility.
*/
size_type
erase(const key_type& __x)
* This function erases a sequence of elements from a %map.
* Note that this function only erases the element, and that if
* the element is itself a pointer, the pointed-to memory is not touched
- * in any way. Managing the pointer is the user's responsibilty.
+ * in any way. Managing the pointer is the user's responsibility.
*/
void
erase(iterator __first, iterator __last)
* Erases all elements in a %map. Note that this function only
* erases the elements, and that if the elements themselves are
* pointers, the pointed-to memory is not touched in any way.
- * Managing the pointer is the user's responsibilty.
+ * Managing the pointer is the user's responsibility.
*/
void
clear()
/**
* The dtor only erases the elements, and note that if the elements
* themselves are pointers, the pointed-to memory is not touched in any
- * way. Managing the pointer is the user's responsibilty.
+ * way. Managing the pointer is the user's responsibility.
*/
/**
{ return _M_t._M_insert_equal_(__position, __x); }
/**
- * @brief A template function that attemps to insert a range of elements.
+ * @brief A template function that attempts to insert a range of elements.
* @param first Iterator pointing to the start of the range to be
* inserted.
* @param last Iterator pointing to the end of the range.
* from a %multimap. Note that this function only erases the element,
* and that if the element is itself a pointer, the pointed-to memory is
* not touched in any way. Managing the pointer is the user's
- * responsibilty.
+ * responsibility.
*/
void
erase(iterator __position)
* %multimap.
* Note that this function only erases the element, and that if
* the element is itself a pointer, the pointed-to memory is not touched
- * in any way. Managing the pointer is the user's responsibilty.
+ * in any way. Managing the pointer is the user's responsibility.
*/
size_type
erase(const key_type& __x)
* This function erases a sequence of elements from a %multimap.
* Note that this function only erases the elements, and that if
* the elements themselves are pointers, the pointed-to memory is not
- * touched in any way. Managing the pointer is the user's responsibilty.
+ * touched in any way. Managing the pointer is the user's responsibility.
*/
void
erase(iterator __first, iterator __last)
* Erases all elements in a %multimap. Note that this function only
* erases the elements, and that if the elements themselves are pointers,
* the pointed-to memory is not touched in any way. Managing the pointer
- * is the user's responsibilty.
+ * is the user's responsibility.
*/
void
clear()
{ return _M_t._M_insert_equal_(__position, __x); }
/**
- * @brief A template function that attemps to insert a range of elements.
+ * @brief A template function that attempts to insert a range of elements.
* @param first Iterator pointing to the start of the range to be
* inserted.
* @param last Iterator pointing to the end of the range.
* from a %multiset. Note that this function only erases the element,
* and that if the element is itself a pointer, the pointed-to memory is
* not touched in any way. Managing the pointer is the user's
- * responsibilty.
+ * responsibility.
*/
void
erase(iterator __position)
* %multiset.
* Note that this function only erases the element, and that if
* the element is itself a pointer, the pointed-to memory is not touched
- * in any way. Managing the pointer is the user's responsibilty.
+ * in any way. Managing the pointer is the user's responsibility.
*/
size_type
erase(const key_type& __x)
* This function erases a sequence of elements from a %multiset.
* Note that this function only erases the elements, and that if
* the elements themselves are pointers, the pointed-to memory is not
- * touched in any way. Managing the pointer is the user's responsibilty.
+ * touched in any way. Managing the pointer is the user's responsibility.
*/
void
erase(iterator __first, iterator __last)
* Erases all elements in a %multiset. Note that this function only
* erases the elements, and that if the elements themselves are pointers,
* the pointed-to memory is not touched in any way. Managing the pointer
- * is the user's responsibilty.
+ * is the user's responsibility.
*/
void
clear()
{ return _M_t._M_insert_unique_(__position, __x); }
/**
- * @brief A template function that attemps to insert a range of elements.
+ * @brief A template function that attempts to insert a range of elements.
* @param first Iterator pointing to the start of the range to be
* inserted.
* @param last Iterator pointing to the end of the range.
* This function erases an element, pointed to by the given iterator,
* from a %set. Note that this function only erases the element, and
* that if the element is itself a pointer, the pointed-to memory is not
- * touched in any way. Managing the pointer is the user's responsibilty.
+ * touched in any way. Managing the pointer is the user's responsibility.
*/
void
erase(iterator __position)
* a %set.
* Note that this function only erases the element, and that if
* the element is itself a pointer, the pointed-to memory is not touched
- * in any way. Managing the pointer is the user's responsibilty.
+ * in any way. Managing the pointer is the user's responsibility.
*/
size_type
erase(const key_type& __x)
* This function erases a sequence of elements from a %set.
* Note that this function only erases the element, and that if
* the element is itself a pointer, the pointed-to memory is not touched
- * in any way. Managing the pointer is the user's responsibilty.
+ * in any way. Managing the pointer is the user's responsibility.
*/
void
erase(iterator __first, iterator __last)
* Erases all elements in a %set. Note that this function only erases
* the elements, and that if the elements themselves are pointers, the
* pointed-to memory is not touched in any way. Managing the pointer is
- * the user's responsibilty.
+ * the user's responsibility.
*/
void
clear()
* The dtor only erases the elements, and note that if the
* elements themselves are pointers, the pointed-to memory is
* not touched in any way. Managing the pointer is the user's
- * responsibilty.
+ * responsibility.
*/
~vector()
{ std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
* The user is also cautioned that this function only erases
* the element, and that if the element is itself a pointer,
* the pointed-to memory is not touched in any way. Managing
- * the pointer is the user's responsibilty.
+ * the pointer is the user's responsibility.
*/
iterator
erase(iterator __position);
* The user is also cautioned that this function only erases
* the elements, and that if the elements themselves are
* pointers, the pointed-to memory is not touched in any way.
- * Managing the pointer is the user's responsibilty.
+ * Managing the pointer is the user's responsibility.
*/
iterator
erase(iterator __first, iterator __last);
* Erases all the elements. Note that this function only erases the
* elements, and that if the elements themselves are pointers, the
* pointed-to memory is not touched in any way. Managing the pointer is
- * the user's responsibilty.
+ * the user's responsibility.
*/
void
clear()
*__a = __t;
}
- // fill indir ect array __a[__i[<__n>]] with __i
+ // fill indirect array __a[__i[<__n>]] with __i
template<typename _Tp>
inline void
__valarray_fill(_Tp* __restrict__ __a, const size_t* __restrict__ __i,
/** Revalidates all attached singular iterators. This method may
* be used to validate iterators that were invalidated before
- * (but for some reasion, such as an exception, need to become
+ * (but for some reason, such as an exception, need to become
* valid again).
*/
void
// Set the _rover to the last physical location bitmap,
// which is the bitmap which belongs to the first free
// block. Thus, the bitmaps are in exact reverse order of
- // the actual memory layout. So, we count down the bimaps,
+ // the actual memory layout. So, we count down the bitmaps,
// which is the same as moving up the memory.
// If the used count stored at the start of the Bit Map headers
else
{
// Deallocate the last block in the list of free lists,
- // and insert the new one in it's correct position.
+ // and insert the new one in its correct position.
::operator delete(static_cast<void*>(__free_list.back()));
__free_list.pop_back();
}
_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
- /// @brief Extension to use icov for dealing with character encodings.
+ /// @brief Extension to use iconv for dealing with character encodings.
// This includes conversions and comparisons between various character
// sets. This object encapsulates data that may need to be shared between
// char_traits, codecvt and ctype.
// typedef STATE_T state_type
// requires: state_type shall meet the requirements of
// CopyConstructible types (20.1.3)
- // NB: This does not preseve the actual state of the conversion
+ // NB: This does not preserve the actual state of the conversion
// descriptor member, but it does duplicate the encoding
// information.
encoding_state(const encoding_state& __obj) : _M_in_desc(0), _M_out_desc(0)
// In order to avoid fragmenting and minimize the number of
// new() calls we always request new memory using this
// value. Based on previous discussions on the libstdc++
- // mailing list we have choosen the value below.
+ // mailing list we have chosen the value below.
// See http://gcc.gnu.org/ml/libstdc++/2001-07/msg00077.html
// NB: At least one order of magnitude > _M_max_bytes.
size_t _M_chunk_size;
// (NB: last two terms for rounding reasons, see _M_create below)
// Solving for m:
// m = ((npos - 2 * sizeof(_Rep) + 1) / sizeof(_CharT)) - 1
- // In addition, this implementation halfs this amount.
+ // In addition, this implementation halves this amount.
enum { _S_max_size = (((static_cast<size_type>(-1) - 2 * sizeof(_Rep)
+ 1) / sizeof(_CharT)) - 1) / 2 };
{ __c = 0; }
// char_producers are logically functions that generate a section of
- // a string. These can be convereted to ropes. The resulting rope
+ // a string. These can be converted to ropes. The resulting rope
// invokes the char_producer on demand. This allows, for example,
// files to be viewed as ropes without reading the entire file.
template <class _CharT>
// definition.
static _RopeRep* _S_balance(_RopeRep* __r);
- // Add all unbalanced subtrees to the forest of balanceed trees.
+ // Add all unbalanced subtrees to the forest of balanced trees.
// Used only by balance.
static void _S_add_to_forest(_RopeRep*__r, _RopeRep** __forest);
// Embedded 0s in the input do not terminate the copy.
const _CharT* c_str() const;
- // As above, but lso use the flattened representation as the
+ // As above, but also use the flattened representation as
// the new rope representation.
const _CharT* replace_with_c_str();
max_size() const
{
return _S_min_len[int(__detail::_S_max_rope_depth) - 1] - 1;
- // Guarantees that the result can be sufficirntly
+ // Guarantees that the result can be sufficiently
// balanced. Longer ropes will probably still work,
// but it's harder to make guarantees.
}
/**
* @brief Check whether @c [begin, @c end) is sorted according to @c comp.
- * Prints the position in case an misordered pair is found.
+ * Prints the position in case an unordered pair is found.
* @param begin Begin iterator of sequence.
* @param end End iterator of sequence.
* @param first_failure The first failure is returned in this variable.
/**
* @brief Check whether @c [begin, @c end) is sorted according to @c comp.
- * Prints all misordered pair, including the surrounding two elements.
+ * Prints all unordered pair, including the surrounding two elements.
* @param begin Begin iterator of sequence.
* @param end End iterator of sequence.
* @param comp Comparator.
// 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 PURstartE. See the GNU
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Public License for more details.
// You should have received a copy of the GNU General Public License
if (!maxleftset || comp(minright, maxleft))
{
- // Good luck, everything is split unambigiously.
+ // Good luck, everything is split unambiguously.
offset = 0;
}
else
|| (end - split_pos1) < (n >> 7))
{
// Very unequal split, one part smaller than one 128th
- // elements not stricly larger than the pivot.
+ // elements not strictly larger than the pivot.
__gnu_parallel::unary_negate<__gnu_parallel::
binder1st<Comparator, value_type, value_type, bool>, value_type>
pred(__gnu_parallel::binder1st<Comparator, value_type,
/**
* @brief The extensible condition on whether the parallel variant of
- * an algorithm sould be called.
+ * an algorithm should be called.
* @param c A condition that is overruled by
* __gnu_parallel::Settings::force_parallel, i. e. usually a decision based on
* the input size.
{
// NB: Including this file cannot produce (unresolved) symbols from
// the OpenMP runtime unless the parallel mode is actually invoked
- // and active, which imples that the OpenMP runtime is actually
+ // and active, which implies that the OpenMP runtime is actually
// going to be linked in.
inline int
get_max_threads()
_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
/**
- * Base class, general case. It is a class inveriant that _Nw will be
+ * Base class, general case. It is a class invariant that _Nw will be
* nonnegative.
*
* See documentation for bitset.
//@}
/**
- * @brief Retuns a numerical interpretation of the %bitset.
+ * @brief Returns a numerical interpretation of the %bitset.
* @return The integral equivalent of the bits.
* @throw std::overflow_error If there are too many bits to be
* represented in an @c unsigned @c long.
{ return this->_M_do_to_ulong(); }
/**
- * @brief Retuns a character interpretation of the %bitset.
+ * @brief Returns a character interpretation of the %bitset.
* @return The string equivalent of the bits.
*
* Note the ordering of the bits: decreasing character positions
arg(const complex<_Tp>& __z) { return __complex_arg(__z); }
#endif
- // 26.2.7/5: norm(__z) returns the squared magintude of __z.
+ // 26.2.7/5: norm(__z) returns the squared magnitude of __z.
// As defined, norm() is -not- a norm is the common mathematical
// sens used in numerics. The helper class _Norm_helper<> tries to
// distinguish between builtin floating point and the rest, so as
exp(const complex<_Tp>& __z) { return __complex_exp(__z); }
#endif
- // 26.2.8/5 log(__z): Reurns the natural complex logaritm of __z.
+ // 26.2.8/5 log(__z): Returns the natural complex logarithm of __z.
// The branch cut is along the negative axis.
template<typename _Tp>
inline complex<_Tp>
complex<float>& operator*=(float);
complex<float>& operator/=(float);
- // Let's the compiler synthetize the copy and assignment
+ // Let the compiler synthesize the copy and assignment
// operator. It always does a pretty good job.
// complex& operator= (const complex&);
template<typename _Tp>
complex<double>& operator*=(double);
complex<double>& operator/=(double);
- // The compiler will synthetize this, efficiently.
+ // The compiler will synthesize this, efficiently.
// complex& operator= (const complex&);
template<typename _Tp>
complex<double>& operator=(const complex<_Tp>&);
*
* This class associates both its input and output sequence with an
* external disk file, and maintains a joint file position for both
- * sequences. Many of its sematics are described in terms of similar
+ * sequences. Many of its semantics are described in terms of similar
* behavior in the Standard C Library's @c FILE streams.
*/
// Requirements on traits_type, specific to this class:
// Stroustrup, 1998, p. 628
// underflow() and uflow() functions are called to get the next
- // charater from the real input source when the buffer is empty.
+ // character from the real input source when the buffer is empty.
// Buffered input uses underflow()
virtual int_type
// [27.8.1.11] Template class basic_fstream
/**
- * @brief Controlling intput and output for files.
+ * @brief Controlling input and output for files.
*
* This class supports reading from and writing to named files, using
* the inherited functions from std::basic_iostream. To control the
/**
* @brief Interface for manipulators.
*
- * Manuipulators such as @c std::ws and @c std::dec use these
+ * Manipulators such as @c std::ws and @c std::dec use these
* functions in constructs like "std::cin >> std::ws". For more
* information, see the iomanip header.
*/
// double (1)
// long double (1)
//
-// GNU C++ undertstands (where supported by the host C-library)
+// GNU C++ understands (where supported by the host C-library)
// * integer
// long long, unsigned long long (2)
//
// These values can be overridden in the target configuration file.
// The default values are appropriate for many 32-bit targets.
-// GCC only intrinsicly supports modulo integral types. The only remaining
+// GCC only intrinsically supports modulo integral types. The only remaining
// integral exceptional values is division by zero. Only targets that do not
// signal division by zero in some "hard to ignore" way should use false.
#ifndef __glibcxx_integral_traps
// float
//
-// Default values. Should be overriden in configuration files if necessary.
+// Default values. Should be overridden in configuration files if necessary.
#ifndef __glibcxx_float_has_denorm_loss
# define __glibcxx_float_has_denorm_loss false
// double
-// Default values. Should be overriden in configuration files if necessary.
+// Default values. Should be overridden in configuration files if necessary.
#ifndef __glibcxx_double_has_denorm_loss
# define __glibcxx_double_has_denorm_loss false
// long double
-// Default values. Should be overriden in configuration files if necessary.
+// Default values. Should be overridden in configuration files if necessary.
#ifndef __glibcxx_long_double_has_denorm_loss
# define __glibcxx_long_double_has_denorm_loss false
* The @c static @c const members are usable as integral constant
* expressions.
*
- * @note This is a seperate class for purposes of efficiency; you
+ * @note This is a separate class for purposes of efficiency; you
* should only access these members as part of an instantiation
* of the std::numeric_limits class.
*/
/** True if trapping is implemented for this type. */
static const bool traps = false;
- /** True if tinyness is detected before rounding. (see IEC 559) */
+ /** True if tininess is detected before rounding. (see IEC 559) */
static const bool tinyness_before = false;
/** See std::float_round_style for more information. This is only
meaningful for floating types; integer types will all be
/**
* @brief Interface for manipulators.
*
- * Manuipulators such as @c std::endl and @c std::hex use these
+ * Manipulators such as @c std::endl and @c std::hex use these
* functions in constructs like "std::cout << std::endl". For more
* information, see the iomanip header.
*/
basic_ostream<_CharT, _Traits> &
operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
- // Partial specializationss
+ // Partial specializations
template<class _Traits>
inline basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
};
/** Thrown by the library, or by you, to report domain errors (domain in
- * the mathmatical sense). */
+ * the mathematical sense). */
class domain_error : public logic_error
{
public:
// [27.5.2.4.2] buffer management and positioning
/**
- * @brief Maniuplates the buffer.
+ * @brief Manipulates the buffer.
*
* Each derived class provides its own appropriate behavior. See
* the next-to-last paragraph of
* next available character is returned, or @c traits::eof() to
* indicate a null pending sequence.
*
- * For a formal definiton of the pending sequence, see a good text
+ * For a formal definition of the pending sequence, see a good text
* such as Langer & Kreft, or [27.5.2.4.3]/7-14.
*
* A functioning input streambuf can be created by overriding only
* sequence verbatim.) In either case, the character @a c is also
* written out, if @a c is not @c eof().
*
- * For a formal definiton of this function, see a good text
+ * For a formal definition of this function, see a good text
* such as Langer & Kreft, or [27.5.2.4.5]/3-7.
*
* A functioning output streambuf can be created by overriding only
* @param __nu The order of the Bessel functions.
* @param __x The argument of the Bessel functions.
* @param __Jnu The output Bessel function of the first kind.
- * @param __Nnu The output Neumann function (Bessel fuction of the second kind).
+ * @param __Nnu The output Neumann function (Bessel function of the second kind).
* @param __Jpnu The output derivative of the Bessel function of the first kind.
* @param __Npnu The output derivative of the Neumann function.
*/
/**
- * @brief This routine computes the asyptotic cylindrical Bessel
+ * @brief This routine computes the asymptotic cylindrical Bessel
* and Neumann functions of order nu: \f$ J_{\nu} \f$,
* \f$ N_{\nu} \f$.
*
* @param __nu The order of the Bessel functions.
* @param __x The argument of the Bessel functions.
* @param __Jnu The output Bessel function of the first kind.
- * @param __Nnu The output Neumann function (Bessel fuction of the second kind).
+ * @param __Nnu The output Neumann function (Bessel function of the second kind).
*/
template <typename _Tp>
void
* \frac{\sigma^k (x/2)^{\nu + 2k}}{k!\Gamma(\nu+k+1)}
* @f]
* where \f$ \sigma = +1 \f$ or\f$ -1 \f$ for
- * \f$ Z = I \f$ or \f$ J \f$ respecively.
+ * \f$ Z = I \f$ or \f$ J \f$ respectively.
*
* See Abramowitz & Stegun, 9.1.10
* Abramowitz & Stegun, 9.6.7
/**
- * @brief Return the Neunamm function of order \f$ \nu \f$:
+ * @brief Return the Neumann function of order \f$ \nu \f$:
* \f$ N_{\nu}(x) \f$.
*
* The Neumann function is defined by:
return __detail::__beta<__type>(__x, __y);
}
- // 5.2.1.4 Complete elliptic interals of the first kind.
+ // 5.2.1.4 Complete elliptic integrals of the first kind.
inline float
comp_ellint_1f(float __k)
{ return __detail::__comp_ellint_1<float>(__k); }
return __detail::__comp_ellint_1<__type>(__k);
}
- // 5.2.1.5 Complete elliptic interals of the second kind.
+ // 5.2.1.5 Complete elliptic integrals of the second kind.
inline float
comp_ellint_2f(float __k)
{ return __detail::__comp_ellint_2<float>(__k); }
return __detail::__comp_ellint_2<__type>(__k);
}
- // 5.2.1.6 Complete elliptic interals of the third kind.
+ // 5.2.1.6 Complete elliptic integrals of the third kind.
inline float
comp_ellint_3f(float __k, float __nu)
{ return __detail::__comp_ellint_3<float>(__k, __nu); }
return __detail::__cyl_neumann_n<__type>(__nu, __x);
}
- // 5.2.1.12 Incomplete elliptic interals of the first kind.
+ // 5.2.1.12 Incomplete elliptic integrals of the first kind.
inline float
ellint_1f(float __k, float __phi)
{ return __detail::__ellint_1<float>(__k, __phi); }
return __detail::__ellint_1<__type>(__k, __phi);
}
- // 5.2.1.13 Incomplete elliptic interals of the second kind.
+ // 5.2.1.13 Incomplete elliptic integrals of the second kind.
inline float
ellint_2f(float __k, float __phi)
{ return __detail::__ellint_2<float>(__k, __phi); }
return __detail::__ellint_2<__type>(__k, __phi);
}
- // 5.2.1.14 Incomplete elliptic interals of the third kind.
+ // 5.2.1.14 Incomplete elliptic integrals of the third kind.
inline float
ellint_3f(float __k, float __nu, float __phi)
{ return __detail::__ellint_3<float>(__k, __nu, __phi); }
* Based on Carlson's algorithms:
* - B. C. Carlson Numer. Math. 33, 1 (1979)
* - B. C. Carlson, Special Functions of Applied Mathematics (1977)
- * - Nunerical Recipes in C, 2nd ed, pp. 261-269,
+ * - Numerical Recipes in C, 2nd ed, pp. 261-269,
* by Press, Teukolsky, Vetterling, Flannery (1992)
*
* @param __x The first of two symmetric arguments.
* Based on Carlson's algorithms:
* - B. C. Carlson Numer. Math. 33, 1 (1979)
* - B. C. Carlson, Special Functions of Applied Mathematics (1977)
- * - Nunerical Recipes in C, 2nd ed, pp. 261-269,
+ * - Numerical Recipes in C, 2nd ed, pp. 261-269,
* by Press, Teukolsky, Vetterling, Flannery (1992)
*
* @param __x The first argument.
* Based on Carlson's algorithms:
* - B. C. Carlson Numer. Math. 33, 1 (1979)
* - B. C. Carlson, Special Functions of Applied Mathematics (1977)
- * - Nunerical Recipes in C, 2nd ed, pp. 261-269,
+ * - Numerical Recipes in C, 2nd ed, pp. 261-269,
* by Press, Teukolsky, Vetterling, Flannery (1992)
*
* @param __x The first of three symmetric arguments.
{
/**
- * @brief This routine returns the confluent hypereometric function
+ * @brief This routine returns the confluent hypergeometric function
* by series expansion.
*
* @f[
*
* If a and b are integers and a < 0 and either b > 0 or b < a then the
* series is a polynomial with a finite number of terms. If b is an integer
- * and b <= 0 the the confluent hypergeometric function is undefined.
+ * and b <= 0 the confluent hypergeometric function is undefined.
*
* @param __a The "numerator" parameter.
* @param __c The "denominator" parameter.
* on @f$ l @f$.
*
* The associated Legendre function is derived from the Legendre function
- * @f$ P_l(x) @f$ by the Rodruigez formula:
+ * @f$ P_l(x) @f$ by the Rodrigues formula:
* @f[
* P_l^m(x) = (1 - x^2)^{m/2}\frac{d^m}{dx^m}P_l(x)
* @f]
} // namespace __detail
/**
- * Produces random numbers on a given disribution function using a un uniform
+ * Produces random numbers on a given distribution function using a non-uniform
* random number generation engine.
*
* @todo the engine_value_type needs to be studied more carefully.
* A number generator is a function object with an operator() that
* takes zero arguments and returns a number.
*
- * A compliant random number generator must satisy the following
+ * A compliant random number generator must satisfy the following
* requirements. <table border=1 cellpadding=10 cellspacing=0>
* <caption align=top>Random Number Generator Requirements</caption>
* <tr><td>To be documented.</td></tr> </table>
/**
* Gets the smallest possible value in the output range.
*
- * The minumum depends on the @p __c parameter: if it is zero, the
+ * The minimum depends on the @p __c parameter: if it is zero, the
* minimum generated must be > 0, otherwise 0 is allowed.
*/
result_type
/**
* A generalized feedback shift register discrete random number generator.
*
- * This algorithm avoind multiplication and division and is designed to be
+ * This algorithm avoids multiplication and division and is designed to be
* friendly to a pipelined architecture. If the parameters are chosen
* correctly, this generator will produce numbers with a very long period and
* fairly good apparent entropy, although still not cryptographically strong.
/**
* Copy constructs a %discard_block engine.
*
- * Copies an existing base class random number geenerator.
+ * Copies an existing base class random number generator.
* @param rng An existing (base class) engine object.
*/
explicit
// result_type, ArithmeticTypeConcept)
public:
- /** The type of the the first underlying generator engine. */
+ /** The type of the first underlying generator engine. */
typedef _UniformRandomNumberGenerator1 base1_type;
- /** The type of the the second underlying generator engine. */
+ /** The type of the second underlying generator engine. */
typedef _UniformRandomNumberGenerator2 base2_type;
private:
const uniform_int<_IntType1>& __x);
/**
- * Extracts a %unform_int random number distribution
+ * Extracts a %uniform_int random number distribution
* @p __x from the input stream @p __is.
*
* @param __is An input stream.
/**
* Resets the distribution state.
*
- * Does nothing for a bernoulli distribution.
+ * Does nothing for a Bernoulli distribution.
*/
void
reset() { }
/**
* @brief A discrete Poisson random number distribution.
*
- * The formula for the poisson probability mass function is
+ * The formula for the Poisson probability mass function is
* @f$ p(i) = \frac{mean^i}{i!} e^{-mean} @f$ where @f$ mean @f$ is the
* parameter of the distribution.
*/
const uniform_real<_RealType1>& __x);
/**
- * Extracts a %unform_real random number distribution
+ * Extracts a %uniform_real random number distribution
* @p __x from the input stream @p __is.
*
* @param __is An input stream.
/// The expression does not match an empty sequence.
static const match_flag_type match_not_null = 1 << _S_not_null;
- /// The expression only matchs a sub-sequence that begins at first .
+ /// The expression only matches a sub-sequence that begins at first .
static const match_flag_type match_continuous = 1 << _S_continuous;
/// --first is a valid iterator position. When this flag is set then the
/// Format strings (from ECMA-262 [15.5.4.11]):
/// $$ $
/// $& The matched substring.
- /// $` The portion of <em>string</em> that preceeds the matched substring.
+ /// $` The portion of <em>string</em> that precedes the matched substring.
/// $' The portion of <em>string</em> that follows the matched substring.
/// $n The nth capture, where n is in [1,9] and $n is not followed by a
/// decimal digit. If n <= m and the nth capture is undefined, use the
*
* @returns the number of characters between @p *__p and the first
* default-initialized value of type @p char_type. In other words, uses
- * the C-string algorithm for determiining the length of a sequence of
+ * the C-string algorithm for determining the length of a sequence of
* characters.
*/
static std::size_t
{ return string_type(); }
/**
- * @breief Gets a collation element by name.
+ * @brief Gets a collation element by name.
*
* @param first beginning of the collation element name.
* @param last one-past-the-end of the collation element name.
{ _M_compile(); }
/**
- * @brief Copy-contructs a basic regular expression.
+ * @brief Copy-constructs a basic regular expression.
*
* @param rhs A @p regex object.
*/
* @brief Constructs a basic regular expression from the range
* [first, last) interpreted according to the flags in @p f.
*
- * @param first The start of arange containing a valid regular
+ * @param first The start of a range containing a valid regular
* expression.
* @param last The end of a range containing a valid regular
* expression.
// [7.8.4] const operations
/**
* @brief Gets the number of marked subexpressions within the regular
- * expresison.
+ * expression.
*/
unsigned int
mark_count() const
// [7.8.6] swap
/**
- * @brief Swaps the contents of two regular expression obects.
+ * @brief Swaps the contents of two regular expression objects.
*
* @param rhs Another regular expression object.
*/
* @brief Tests the ordering of two regular expression submatches.
* @param lhs First regular expression submatch.
* @param rhs Second regular expression submatch.
- * @returns true if @a lhs does not preceed @a rhs, false otherwise.
+ * @returns true if @a lhs does not precede @a rhs, false otherwise.
*/
template<typename _BiIter>
inline bool
* @brief Tests the ordering of a string and a regular expression submatch.
* @param lhs A string.
* @param rhs A regular expression submatch.
- * @returns true if @a lhs does not preceed @a rhs, false otherwise.
+ * @returns true if @a lhs does not precede @a rhs, false otherwise.
*/
template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
inline bool
* @brief Tests the ordering of a regular expression submatch and a string.
* @param lhs A regular expression submatch.
* @param rhs A string.
- * @returns true if @a lhs does not preceed @a rhs, false otherwise.
+ * @returns true if @a lhs does not precede @a rhs, false otherwise.
*/
template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
inline bool
* @brief Tests the ordering of a string and a regular expression submatch.
* @param lhs A string.
* @param rhs A regular expression submatch.
- * @returns true if @a lhs does not preceed @a rhs, false otherwise.
+ * @returns true if @a lhs does not precede @a rhs, false otherwise.
*/
template<typename _Bi_iter>
inline bool
* @brief Tests the ordering of a string and a regular expression submatch.
* @param lhs A string.
* @param rhs A regular expression submatch.
- * @returns true if @a lhs does not preceed @a rhs, false otherwise.
+ * @returns true if @a lhs does not precede @a rhs, false otherwise.
*/
template<typename _Bi_iter>
inline bool
* @brief Tests the ordering of a regular expression submatch and a string.
* @param lhs A regular expression submatch.
* @param rhs A const string reference.
- * @returns true if @a lhs preceeds @a rhs, false otherwise.
+ * @returns true if @a lhs precedes @a rhs, false otherwise.
*/
template<typename _Bi_iter>
inline bool
* @brief Tests the ordering of a regular expression submatch and a string.
* @param lhs A regular expression submatch.
* @param rhs A const string reference.
- * @returns true if @a lhs does not preceed @a rhs, false otherwise.
+ * @returns true if @a lhs does not precede @a rhs, false otherwise.
*/
template<typename _Bi_iter>
inline bool
/**
* @brief Searches for a regular expression within a C-string.
* @param s [IN] A C-string to search for the regex.
- * @param m [OUT] The set of regex mnatches.
+ * @param m [OUT] The set of regex matches.
* @param e [IN] The regex to search for in @p s.
* @param f [IN] The search flags.
* @retval true A match was found within the string.
/**
* @brief Searches for a regular expression within a C-string.
* @param s [IN] The C-string to search.
- * @param e [IN] The regular expressioon to search for.
+ * @param e [IN] The regular expression to search for.
* @param f [IN] Search policy flags.
* @retval true A match was found within the string.
* @retval false No match was found within the string.
/**
* @brief Searches for a regular expression within a string.
* @param s [IN] The string to search.
- * @param e [IN] The regular expressioon to search for.
+ * @param e [IN] The regular expression to search for.
* @param flags [IN] Search policy flags.
* @retval true A match was found within the string.
* @retval false No match was found within the string.
/**
* @brief Searches for a regular expression within a string.
* @param s [IN] A C++ string to search for the regex.
- * @param m [OUT] The set of regex mnatches.
+ * @param m [OUT] The set of regex matches.
* @param e [IN] The regex to search for in @p s.
* @param f [IN] The search flags.
* @retval true A match was found within the string.
regex_token_iterator();
/**
- * Constrcts a %regex_token_iterator...
+ * Constructs a %regex_token_iterator...
* @param a [IN] The start of the text to search.
- * @param b [IN] One-past-the-eend of the text to search.
+ * @param b [IN] One-past-the-end of the text to search.
* @param re [IN] The regular expression to search for.
* @param submatch [IN] Which submatch to return. There are some
- * special values for thsi parameter:
+ * special values for this parameter:
* - -1 each enumerated subexpression does NOT
* match the regular expression (aka field
* splitting)
= regex_constants::match_default);
/**
- * Constrcts a %regex_token_iterator...
+ * Constructs a %regex_token_iterator...
* @param a [IN] The start of the text to search.
- * @param b [IN] One-past-the-eend of the text to search.
+ * @param b [IN] One-past-the-end of the text to search.
* @param re [IN] The regular expression to search for.
* @param submatches [IN] A list of subexpressions to return for each
* regular expression match within the text.
= regex_constants::match_default);
/**
- * Constrcts a %regex_token_iterator...
+ * Constructs a %regex_token_iterator...
* @param a [IN] The start of the text to search.
- * @param b [IN] One-past-the-eend of the text to search.
+ * @param b [IN] One-past-the-end of the text to search.
* @param re [IN] The regular expression to search for.
* @param submatches [IN] A list of subexpressions to return for each
* regular expression match within the text.
OSDN Git Service
