+2000-10-21 Benjamin Kosnik <bkoz@purist.soma.redhat.com>
+
+ * docs/links.html: Add links to defects list, standards FAQ.
+
+ * testsuite/21_strings/ctor_copy_dtor.cc (test01): Disable tests
+ with string creation that allocate huge ammounts of memory.
+
+ * include/c/bits/std_cstddef.h: Put size_t, ptrdiff_t in
+ namepace std.
+
+2000-10-21 Theodore Papadopoulo <Theodore.Papadopoulo@sophia.inria.fr>
+
+ * libsupc++/exception.cc: Use namespace std.
+ * libsupc++/new: DITTO.
+ * libsupc++/new_op.cc: DITTO.
+ * libsupc++/new_opnt.cc: DITTO.
+ * libsupc++/new_opv.cc: DITTO.
+ * libsupc++/new_opvnt.cc: DITTO.
+ * libsupc++/tinfo.cc: DITTO.
+ * libsupc++/tinfo.h: DITTO.
+ * libsupc++/vec.cc: DITTO.
+ * libsupc++/Makefile.am: Blank lines removal.
+
2000-10-21 Joseph S. Myers <jsm28@cam.ac.uk>
* docs/configopts.html, docs/install.html, docs/17_intro/BADNAMES,
<H3>Links</H3>
+Public websites that have info on known defects in the standard:
+<P><UL>
+ <LI><A HREF="http://www.dkuug.dk/jtc1/sc22/wg21/">defect reflector</A>
+ <LI><A HREF="http://www.comeaucomputing.com/iso/">comeau reflector</A>
+ <LI><A HREF="http://reality.sgi.com/austern_mti/std-c++/faq.html">c++ standards FAQ</A>
+</UL></P>
+
<P><UL>
<LI><A HREF="http://www.sgi.com/Technology/STL">The SGI STL page</A>
<LI><A HREF="http://www.stlport.org/">STLport homepage</A>
# pragma GCC system_header
# include_next <stddef.h>
#endif
+
+namespace std {
+ using ::size_t;
+ using ::ptrdiff_t;
+} // namespace std
+
+
#include "typeinfo"
#include "exception"
-#include <stddef.h>
+#include <cstddef>
#include "gansidecl.h" /* Needed to support macros used in eh-common.h. */
#include "eh-common.h"
extern "C" cp_eh_info **__get_eh_info (); // actually void **
/* Exception allocate and free, defined in libgcc2. */
-extern "C" void *__eh_alloc(size_t);
+extern "C" void *__eh_alloc(std::size_t);
extern "C" void __eh_free(void *);
/* Is P the type_info node for a pointer of some kind? */
#pragma interface "new"
#include <cstddef>
-//#include <stddef.h>
#include <exception>
extern "C++" {
} // namespace std
// replaceable signatures
-void *operator new (size_t) throw (std::bad_alloc);
-void *operator new[] (size_t) throw (std::bad_alloc);
+void *operator new (std::size_t) throw (std::bad_alloc);
+void *operator new[] (std::size_t) throw (std::bad_alloc);
void operator delete (void *) throw();
void operator delete[] (void *) throw();
-void *operator new (size_t, const std::nothrow_t&) throw();
-void *operator new[] (size_t, const std::nothrow_t&) throw();
+void *operator new (std::size_t, const std::nothrow_t&) throw();
+void *operator new[] (std::size_t, const std::nothrow_t&) throw();
void operator delete (void *, const std::nothrow_t&) throw();
void operator delete[] (void *, const std::nothrow_t&) throw();
// default placement versions of operator new
-inline void *operator new(size_t, void *place) throw() { return place; }
-inline void *operator new[](size_t, void *place) throw() { return place; }
+inline void *operator new(std::size_t, void *place) throw() { return place; }
+inline void *operator new[](std::size_t, void *place) throw() { return place; }
} // extern "C++"
#endif
using std::new_handler;
using std::bad_alloc;
-extern "C" void *malloc (size_t);
+extern "C" void *malloc (std::size_t);
extern new_handler __new_handler;
void *
-operator new (size_t sz) throw (std::bad_alloc)
+operator new (std::size_t sz) throw (std::bad_alloc)
{
void *p;
using std::new_handler;
using std::bad_alloc;
-extern "C" void *malloc (size_t);
+extern "C" void *malloc (std::size_t);
extern new_handler __new_handler;
void *
-operator new (size_t sz, const std::nothrow_t&) throw()
+operator new (std::size_t sz, const std::nothrow_t&) throw()
{
void *p;
#include "new"
void *
-operator new[] (size_t sz) throw (std::bad_alloc)
+operator new[] (std::size_t sz) throw (std::bad_alloc)
{
return ::operator new(sz);
}
#include "new"
void *
-operator new[] (size_t sz, const std::nothrow_t& nothrow) throw()
+operator new[] (std::size_t sz, const std::nothrow_t& nothrow) throw()
{
return ::operator new(sz, nothrow);
}
#pragma implementation "typeinfo"
-#include <stddef.h>
+#include <cstddef>
#include "tinfo.h"
#include "new" // for placement new
extern "C" void
__rtti_class (void *addr, const char *name,
- const __class_type_info::base_info *bl, size_t bn)
+ const __class_type_info::base_info *bl, std::size_t bn)
{ new (addr) __class_type_info (name, bl, bn); }
extern "C" void
return contained_nonpublic_p (access_path);
}
- for (size_t i = n_bases; i--;)
+ for (std::size_t i = n_bases; i--;)
{
upcast_result result2;
void *p = objptr;
return false;
}
bool result_ambig = false;
- for (size_t i = n_bases; i--;)
+ for (std::size_t i = n_bases; i--;)
{
dyncast_result result2;
void *p;
if (objptr == subptr && subtype == *this)
return contained_public;
- for (size_t i = n_bases; i--;)
+ for (std::size_t i = n_bases; i--;)
{
if (base_list[i].access != PUBLIC)
continue; // Not public, can't be here.
if (obj_ptr == src_ptr && *this == *src_type)
return __contained_public;
- for (size_t i = __base_count; i--;)
+ for (std::size_t i = __base_count; i--;)
{
if (!__base_info[i].__is_public_p ())
continue; // Not public, can't be here.
}
bool result_ambig = false;
- for (size_t i = __base_count; i--;)
+ for (std::size_t i = __base_count; i--;)
{
__dyncast_result result2 (result.whole_details);
void const *base = obj_ptr;
if (src_details & __flags_unknown_mask)
src_details = __flags;
- for (size_t i = __base_count; i--;)
+ for (std::size_t i = __base_count; i--;)
{
__upcast_result result2 (src_details);
const void *base = obj_ptr;
// Copyright (C) 1994, 1995, 1996, 1998, 1999, 2000 Free Software Foundation
#include "typeinfo"
+#include <cstddef>
// Class declarations shared between the typeinfo implementation files.
};
const base_info *base_list;
- size_t n_bases;
+ std::size_t n_bases;
- __class_type_info (const char *name, const base_info *bl, size_t bn)
+ __class_type_info (const char *name, const base_info *bl, std::size_t bn)
: __user_type_info (name), base_list (bl), n_bases (bn) {}
public:
/* allocate and construct array */
extern "C" void *
-__cxa_vec_new (size_t element_count,
- size_t element_size,
- size_t padding_size,
+__cxa_vec_new (std::size_t element_count,
+ std::size_t element_size,
+ std::size_t padding_size,
void (*constructor) (void *),
void (*destructor) (void *))
{
}
extern "C" void *
-__cxa_vec_new2 (size_t element_count,
- size_t element_size,
- size_t padding_size,
+__cxa_vec_new2 (std::size_t element_count,
+ std::size_t element_size,
+ std::size_t padding_size,
void (*constructor) (void *),
void (*destructor) (void *),
void *(*alloc) (size_t),
void (*dealloc) (void *))
{
- size_t size = element_count * element_size + padding_size;
+ std::size_t size = element_count * element_size + padding_size;
char *base = static_cast <char *> (alloc (size));
if (padding_size)
{
base += padding_size;
- reinterpret_cast <size_t *> (base)[-1] = element_count;
+ reinterpret_cast <std::size_t *> (base)[-1] = element_count;
}
try
{
}
extern "C" void *
-__cxa_vec_new3 (size_t element_count,
- size_t element_size,
- size_t padding_size,
+__cxa_vec_new3 (std::size_t element_count,
+ std::size_t element_size,
+ std::size_t padding_size,
void (*constructor) (void *),
void (*destructor) (void *),
- void *(*alloc) (size_t),
- void (*dealloc) (void *, size_t))
+ void *(*alloc) (std::size_t),
+ void (*dealloc) (void *, std::size_t))
{
- size_t size = element_count * element_size + padding_size;
+ std::size_t size = element_count * element_size + padding_size;
char *base = static_cast <char *> (alloc (size));
if (padding_size)
{
base += padding_size;
- reinterpret_cast <size_t *> (base)[-1] = element_count;
+ reinterpret_cast <std::size_t *> (base)[-1] = element_count;
}
try
{
/* construct array */
extern "C" void
__cxa_vec_ctor (void *array_address,
- size_t element_count,
- size_t element_size,
+ std::size_t element_count,
+ std::size_t element_size,
void (*constructor) (void *),
void (*destructor) (void *))
{
- size_t ix = 0;
+ std::size_t ix = 0;
char *ptr = static_cast <char *> (array_address);
try
extern "C" void
__cxa_vec_cctor (void *dest_array,
void *src_array,
- size_t element_count,
- size_t element_size,
+ std::size_t element_count,
+ std::size_t element_size,
void (*constructor) (void *, void *),
void (*destructor) (void *))
{
- size_t ix = 0;
+ std::size_t ix = 0;
char *dest_ptr = static_cast <char *> (dest_array);
char *src_ptr = static_cast <char *> (src_array);
/* destruct array */
extern "C" void
__cxa_vec_dtor (void *array_address,
- size_t element_count,
- size_t element_size,
+ std::size_t element_count,
+ std::size_t element_size,
void (*destructor) (void *))
{
if (destructor)
{
char *ptr = static_cast <char *> (array_address);
- size_t ix = element_count;
+ std::size_t ix = element_count;
bool unwinding = std::uncaught_exception ();
ptr += element_count * element_size;
/* destruct and release array */
extern "C" void
__cxa_vec_delete (void *array_address,
- size_t element_size,
- size_t padding_size,
+ std::size_t element_size,
+ std::size_t padding_size,
void (*destructor) (void *))
{
__cxa_vec_delete2 (array_address, element_size, padding_size,
extern "C" void
__cxa_vec_delete2 (void *array_address,
- size_t element_size,
- size_t padding_size,
+ std::size_t element_size,
+ std::size_t padding_size,
void (*destructor) (void *),
void (*dealloc) (void *))
{
if (padding_size)
{
- size_t element_count = reinterpret_cast <size_t *> (base)[-1];
+ std::size_t element_count = reinterpret_cast <std::size_t *> (base)[-1];
base -= padding_size;
try
{
extern "C" void
__cxa_vec_delete3 (void *array_address,
- size_t element_size,
- size_t padding_size,
+ std::size_t element_size,
+ std::size_t padding_size,
void (*destructor) (void *),
- void (*dealloc) (void *, size_t))
+ void (*dealloc) (void *, std::size_t))
{
char *base = static_cast <char *> (array_address);
- size_t size = 0;
+ std::size_t size = 0;
if (padding_size)
{
- size_t element_count = reinterpret_cast <size_t *> (base)[-1];
+ std::size_t element_count = reinterpret_cast <std::size_t *> (base)[-1];
base -= padding_size;
size = element_count * element_size + padding_size;
try
VERIFY( false );
}
-
+#if 0
+ // XXX These tests have been temporarily disabled.
+ //http://sources.redhat.com/ml/libstdc++/2000-10/msg00033.html
// basic_string(const char* s, size_type n, alloc)
csz01 = str01.max_size();
// NB: As strlen(str_lit01) != csz01, this test is undefined. It
VERIFY( false );
}
- // Build a maxsize-1 lengthed string consisting of all A's
+ // Build a maxsize - 1 lengthed string consisting of all A's
try {
std::string str03(csz01 - 1, 'A');
VERIFY( str03.size() == csz01 - 1 );
catch(...) {
VERIFY( false );
}
-
+#endif
// basic_string(const char* s, const allocator& a = allocator())
std::string str04(str_lit01);
projects / gcc.git / commitdiff