webruby 0.2.7 → 0.9.1

data/modules/emscripten/system/lib/libcxxabi/src/cxa_unexpected.cpp

@@ -1,27 +0,0 @@
-//===------------------------- cxa_unexpected.cpp -------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include <exception>
-#include <cxxabi.h>
-#include "cxa_exception.hpp"
-
-namespace __cxxabiv1
-{
-
-#pragma GCC visibility push(default)
-
-extern "C"
-{
-
-}
-
-#pragma GCC visibility pop
-
-}  // namespace __cxxabiv1
-

data/modules/emscripten/system/lib/libcxxabi/src/cxa_vector.cpp

@@ -1,367 +0,0 @@
-//===-------------------------- cxa_vector.cpp ---------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//  
-//  This file implements the "Array Construction and Destruction APIs"
-//  http://www.codesourcery.com/public/cxx-abi/abi.html#array-ctor
-//  
-//===----------------------------------------------------------------------===//
-
-#include "cxxabi.h"
-
-#include <exception>        // for std::terminate
-
-namespace __cxxabiv1 {
-
-#pragma mark --Helper routines and classes --
-
-namespace {
-    inline static size_t __get_element_count ( void *p ) {
-        return static_cast <size_t *> (p)[-1];
-        }
-
-    inline static void __set_element_count ( void *p, size_t element_count ) {
-        static_cast <size_t *> (p)[-1] = element_count;
-        }
-
-
-//  A pair of classes to simplify exception handling and control flow.
-//  They get passed a block of memory in the constructor, and unless the
-//  'release' method is called, they deallocate the memory in the destructor.
-//  Preferred usage is to allocate some memory, attach it to one of these objects,
-//  and then, when all the operations to set up the memory block have succeeded,
-//  call 'release'. If any of the setup operations fail, or an exception is
-//  thrown, then the block is automatically deallocated.
-//
-//  The only difference between these two classes is the signature for the
-//  deallocation function (to match new2/new3 and delete2/delete3.
-    class st_heap_block2 {
-    public:
-        typedef void (*dealloc_f)(void *);
-        
-        st_heap_block2 ( dealloc_f dealloc, void *ptr ) 
-            : dealloc_ ( dealloc ), ptr_ ( ptr ), enabled_ ( true ) {}
-        ~st_heap_block2 () { if ( enabled_ ) dealloc_ ( ptr_ ) ; }
-        void release () { enabled_ = false; }
-    
-    private:
-        dealloc_f dealloc_;
-        void *ptr_;
-        bool enabled_;
-    };
-    
-    class st_heap_block3 {
-    public:
-        typedef void (*dealloc_f)(void *, size_t);
-        
-        st_heap_block3 ( dealloc_f dealloc, void *ptr, size_t size ) 
-            : dealloc_ ( dealloc ), ptr_ ( ptr ), size_ ( size ), enabled_ ( true ) {}
-        ~st_heap_block3 () { if ( enabled_ ) dealloc_ ( ptr_, size_ ) ; }
-        void release () { enabled_ = false; }
-    
-    private:
-        dealloc_f dealloc_;
-        void *ptr_;
-        size_t size_;
-        bool enabled_;
-    };
-
-    class st_cxa_cleanup {
-    public:
-        typedef void (*destruct_f)(void *);
-        
-        st_cxa_cleanup ( void *ptr, size_t &idx, size_t element_size, destruct_f destructor )
-            : ptr_ ( ptr ), idx_ ( idx ), element_size_ ( element_size ), 
-                destructor_ ( destructor ), enabled_ ( true ) {}
-        ~st_cxa_cleanup () {
-            if ( enabled_ ) 
-                __cxa_vec_cleanup ( ptr_, idx_, element_size_, destructor_ );
-            }
-        
-        void release () { enabled_ = false; }
-    
-    private:
-        void *ptr_;
-        size_t &idx_;
-        size_t element_size_;
-        destruct_f destructor_;
-        bool enabled_;
-    };
-    
-    class st_terminate {
-    public:
-        st_terminate ( bool enabled = true ) : enabled_ ( enabled ) {}
-        ~st_terminate () { if ( enabled_ ) std::terminate (); }
-        void release () { enabled_ = false; }
-    private:
-        bool enabled_ ;
-    };
-}
-
-#pragma mark --Externally visible routines--
-
-extern "C" {
-
-// Equivalent to
-// 
-//   __cxa_vec_new2(element_count, element_size, padding_size, constructor,
-//                  destructor, &::operator new[], &::operator delete[])
-void* __cxa_vec_new(
-    size_t element_count, size_t element_size, size_t padding_size, 
-        void (*constructor)(void*), void (*destructor)(void*) ) {
-
-    return __cxa_vec_new2 ( element_count, element_size, padding_size, 
-        constructor, destructor, &::operator new [], &::operator delete [] );
-}
-
-
-
-// Given the number and size of elements for an array and the non-negative
-// size of prefix padding for a cookie, allocate space (using alloc) for
-// the array preceded by the specified padding, initialize the cookie if
-// the padding is non-zero, and call the given constructor on each element.
-// Return the address of the array proper, after the padding.
-// 
-// If alloc throws an exception, rethrow the exception. If alloc returns
-// NULL, return NULL. If the constructor throws an exception, call
-// destructor for any already constructed elements, and rethrow the
-// exception. If the destructor throws an exception, call std::terminate.
-// 
-// The constructor may be NULL, in which case it must not be called. If the
-// padding_size is zero, the destructor may be NULL; in that case it must
-// not be called.
-// 
-// Neither alloc nor dealloc may be NULL.
-void* __cxa_vec_new2(
-    size_t element_count, size_t element_size, size_t padding_size,
-        void  (*constructor)(void*), void  (*destructor)(void*),
-        void* (*alloc)(size_t), void  (*dealloc)(void*) ) {
-
-    const size_t heap_size = element_count * element_size + padding_size;
-    char * const heap_block = static_cast<char *> ( alloc ( heap_size ));
-    char *vec_base = heap_block;
-    
-    if ( NULL != vec_base ) {
-        st_heap_block2 heap ( dealloc, heap_block );
-
-    //  put the padding before the array elements
-        if ( 0 != padding_size ) {
-            vec_base += padding_size;
-            __set_element_count ( vec_base, element_count );
-        }
-            
-    //  Construct the elements
-        __cxa_vec_ctor ( vec_base, element_count, element_size, constructor, destructor );
-        heap.release ();    // We're good!
-    }
-    
-    return vec_base;
-}
-
-
-// Same as __cxa_vec_new2 except that the deallocation function takes both
-// the object address and its size.
-void* __cxa_vec_new3(
-    size_t element_count, size_t element_size, size_t padding_size,
-        void  (*constructor)(void*), void  (*destructor)(void*),
-        void* (*alloc)(size_t), void  (*dealloc)(void*, size_t) ) {
-
-    const size_t heap_size = element_count * element_size + padding_size;
-    char * const heap_block = static_cast<char *> ( alloc ( heap_size ));
-    char *vec_base = heap_block;
-    
-    if ( NULL != vec_base ) {
-        st_heap_block3 heap ( dealloc, heap_block, heap_size );
-
-    //  put the padding before the array elements
-        if ( 0 != padding_size ) {
-            vec_base += padding_size;
-            __set_element_count ( vec_base, element_count );
-        }
-            
-    //  Construct the elements
-        __cxa_vec_ctor ( vec_base, element_count, element_size, constructor, destructor );
-        heap.release ();    // We're good!
-    }
-    
-    return vec_base;
-}
- 
- 
-// Given the (data) addresses of a destination and a source array, an
-// element count and an element size, call the given copy constructor to
-// copy each element from the source array to the destination array. The
-// copy constructor's arguments are the destination address and source
-// address, respectively. If an exception occurs, call the given destructor
-// (if non-NULL) on each copied element and rethrow. If the destructor
-// throws an exception, call terminate(). The constructor and or destructor
-// pointers may be NULL. If either is NULL, no action is taken when it
-// would have been called.
-
-void __cxa_vec_cctor( void*  dest_array, void*  src_array, 
-    size_t element_count, size_t element_size, 
-        void  (*constructor) (void*, void*), void  (*destructor)(void*) ) {
-
-    if ( NULL != constructor ) {
-        size_t idx = 0;
-        char *src_ptr  = static_cast<char *>(src_array);
-        char *dest_ptr = static_cast<char *>(dest_array);
-        st_cxa_cleanup cleanup ( dest_array, idx, element_size, destructor );        
-
-        for ( idx = 0; idx < element_count; 
-                    ++idx, src_ptr += element_size, dest_ptr += element_size )
-            constructor ( dest_ptr, src_ptr );
-        cleanup.release ();     // We're good!
-    }
-}
-
-
-// Given the (data) address of an array, not including any cookie padding,
-// and the number and size of its elements, call the given constructor on
-// each element. If the constructor throws an exception, call the given
-// destructor for any already-constructed elements, and rethrow the
-// exception. If the destructor throws an exception, call terminate(). The
-// constructor and/or destructor pointers may be NULL. If either is NULL,
-// no action is taken when it would have been called.
-void __cxa_vec_ctor(
-    void*  array_address, size_t element_count, size_t element_size, 
-       void (*constructor)(void*), void (*destructor)(void*) ) {
-
-    if ( NULL != constructor ) {
-        size_t idx;
-        char *ptr = static_cast <char *> ( array_address );
-        st_cxa_cleanup cleanup ( array_address, idx, element_size, destructor );        
-        
-    //  Construct the elements
-        for ( idx = 0; idx < element_count; ++idx, ptr += element_size )
-            constructor ( ptr );
-        cleanup.release ();     // We're good!
-    }
-}
-
-// Given the (data) address of an array, the number of elements, and the
-// size of its elements, call the given destructor on each element. If the
-// destructor throws an exception, rethrow after destroying the remaining
-// elements if possible. If the destructor throws a second exception, call
-// terminate(). The destructor pointer may be NULL, in which case this
-// routine does nothing.
-void __cxa_vec_dtor(
-    void*  array_address, size_t element_count, size_t element_size, 
-       void (*destructor)(void*) ) {
-    
-    if ( NULL != destructor ) {
-        char *ptr = static_cast <char *> (array_address);
-        size_t idx = element_count;
-        st_cxa_cleanup cleanup ( array_address, idx, element_size, destructor );        
-        {
-            st_terminate exception_guard (__cxa_uncaught_exception ());
-            ptr +=  element_count * element_size;   // one past the last element
-
-            while ( idx-- > 0 ) {
-                ptr -= element_size;
-                destructor ( ptr );
-            }
-            exception_guard.release (); //  We're good !
-        }
-        cleanup.release ();     // We're still good!
-    }
-}
-
-// Given the (data) address of an array, the number of elements, and the
-// size of its elements, call the given destructor on each element. If the
-// destructor throws an exception, call terminate(). The destructor pointer
-// may be NULL, in which case this routine does nothing.
-void __cxa_vec_cleanup( void* array_address, size_t element_count,
-        size_t element_size, void  (*destructor)(void*) ) {
-
-    if ( NULL != destructor ) {
-        char *ptr = static_cast <char *> (array_address);
-        size_t idx = element_count;
-        st_terminate exception_guard;
-        
-        ptr += element_count * element_size;    // one past the last element
-        while ( idx-- > 0 ) {
-            ptr -= element_size;
-            destructor ( ptr );
-            }
-        exception_guard.release ();     // We're done!
-    }
-}
-
-
-// If the array_address is NULL, return immediately. Otherwise, given the
-// (data) address of an array, the non-negative size of prefix padding for
-// the cookie, and the size of its elements, call the given destructor on
-// each element, using the cookie to determine the number of elements, and
-// then delete the space by calling ::operator delete[](void *). If the
-// destructor throws an exception, rethrow after (a) destroying the
-// remaining elements, and (b) deallocating the storage. If the destructor
-// throws a second exception, call terminate(). If padding_size is 0, the
-// destructor pointer must be NULL. If the destructor pointer is NULL, no
-// destructor call is to be made.
-// 
-// The intent of this function is to permit an implementation to call this
-// function when confronted with an expression of the form delete[] p in
-// the source code, provided that the default deallocation function can be
-// used. Therefore, the semantics of this function are consistent with
-// those required by the standard. The requirement that the deallocation
-// function be called even if the destructor throws an exception derives
-// from the resolution to DR 353 to the C++ standard, which was adopted in
-// April, 2003.
-void __cxa_vec_delete( void* array_address,
-        size_t element_size, size_t padding_size, void  (*destructor)(void*) ) {
-
-    __cxa_vec_delete2 ( array_address, element_size, padding_size,
-               destructor, &::operator delete [] );
-}
-
-
-// Same as __cxa_vec_delete, except that the given function is used for
-// deallocation instead of the default delete function. If dealloc throws
-// an exception, the result is undefined. The dealloc pointer may not be
-// NULL.
-void __cxa_vec_delete2( void* array_address,
-        size_t element_size, size_t padding_size, 
-        void  (*destructor)(void*), void  (*dealloc)(void*) ) {
-
-    if ( NULL != array_address ) {
-        char *vec_base   = static_cast <char *> (array_address);
-        char *heap_block = vec_base - padding_size;
-        st_heap_block2 heap ( dealloc, heap_block );
-        
-        if ( 0 != padding_size && NULL != destructor ) // call the destructors
-            __cxa_vec_dtor ( array_address, __get_element_count ( vec_base ), 
-                                    element_size, destructor );
-    }
-}
-
-
-// Same as __cxa_vec_delete, except that the given function is used for
-// deallocation instead of the default delete function. The deallocation
-// function takes both the object address and its size. If dealloc throws
-// an exception, the result is undefined. The dealloc pointer may not be
-// NULL.
-void __cxa_vec_delete3( void* array_address, 
-        size_t element_size, size_t padding_size, 
-        void  (*destructor)(void*), void  (*dealloc) (void*, size_t)) {
-
-    if ( NULL != array_address ) {
-        char *vec_base   = static_cast <char *> (array_address);
-        char *heap_block = vec_base - padding_size;
-        const size_t element_count = padding_size ? __get_element_count ( vec_base ) : 0;
-        const size_t heap_block_size = element_size * element_count + padding_size;
-        st_heap_block3 heap ( dealloc, heap_block, heap_block_size );
-
-        if ( 0 != padding_size && NULL != destructor ) // call the destructors
-            __cxa_vec_dtor ( array_address, element_count, element_size, destructor );
-    }
-}
-
-
-}  // extern "C"
-
-}  // abi

data/modules/emscripten/system/lib/libcxxabi/src/cxa_virtual.cpp

@@ -1,31 +0,0 @@
-//===-------------------------- cxa_virtual.cpp ---------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "cxxabi.h"
-#include "abort_message.h"
-
-namespace __cxxabiv1
-{
-
-extern "C"
-{
-
-LIBCXXABI_NORETURN
-void __cxa_pure_virtual(void) {
-    abort_message("Pure virtual function called!");
-}
-
-LIBCXXABI_NORETURN
-void __cxa_deleted_virtual(void) {
-    abort_message("Deleted virtual function called!");
-}
-
-}  // extern "C"
-
-}  // abi

data/modules/emscripten/system/lib/libcxxabi/src/exception.cpp

@@ -1,41 +0,0 @@
-//===---------------------------- exception.cpp ---------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include <exception>
-
-#pragma GCC visibility push(default)
-
-namespace std
-{
-
-// exception
-
-exception::~exception() _NOEXCEPT
-{
-}
-
-const char* exception::what() const _NOEXCEPT
-{
-  return "std::exception";
-}
-
-// bad_exception
-
-bad_exception::~bad_exception() _NOEXCEPT
-{
-}
-
-const char* bad_exception::what() const _NOEXCEPT
-{
-  return "std::bad_exception";
-}
-
-}  // std
-
-#pragma GCC visibility pop

data/modules/emscripten/system/lib/libcxxabi/src/fallback_malloc.ipp

@@ -1,174 +0,0 @@
-//===------------------------ fallback_malloc.ipp -------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//  
-//  This file implements the "Exception Handling APIs"
-//  http://www.codesourcery.com/public/cxx-abi/abi-eh.html
-//  
-//===----------------------------------------------------------------------===//
-
-//  A small, simple heap manager based (loosely) on 
-//  the startup heap manager from FreeBSD, optimized for space.
-//
-//  Manages a fixed-size memory pool, supports malloc and free only.
-//  No support for realloc.
-//
-//  Allocates chunks in multiples of four bytes, with a four byte header
-//  for each chunk. The overhead of each chunk is kept low by keeping pointers
-//  as two byte offsets within the heap, rather than (4 or 8 byte) pointers.
-
-namespace {
-
-static pthread_mutex_t heap_mutex = PTHREAD_MUTEX_INITIALIZER;
-
-class mutexor {
-public:
-    mutexor ( pthread_mutex_t *m ) : mtx_(m) { pthread_mutex_lock ( mtx_ ); }
-    ~mutexor () { pthread_mutex_unlock ( mtx_ ); }
-private:
-    mutexor ( const mutexor &rhs );
-    mutexor & operator = ( const mutexor &rhs );
-    pthread_mutex_t *mtx_;
-    };
-
-        
-#define HEAP_SIZE   512
-char heap [ HEAP_SIZE ];
-
-typedef unsigned short heap_offset;
-typedef unsigned short heap_size;
-
-struct heap_node {
-    heap_offset next_node;  // offset into heap
-    heap_size   len;        // size in units of "sizeof(heap_node)"
-};
-
-static const heap_node *list_end = (heap_node *) ( &heap [ HEAP_SIZE ] );   // one past the end of the heap
-static heap_node *freelist = NULL;
-
-heap_node *node_from_offset ( const heap_offset offset )
-    { return (heap_node *) ( heap + ( offset * sizeof (heap_node))); }
-
-heap_offset offset_from_node ( const heap_node *ptr )
-    { return static_cast<heap_offset>(static_cast<size_t>(((char *) ptr ) - heap)  / sizeof (heap_node)); }
- 
-void init_heap () {
-    freelist = (heap_node *) heap;
-    freelist->next_node = offset_from_node ( list_end );
-    freelist->len = HEAP_SIZE / sizeof (heap_node);
-    }
-    
-//  How big a chunk we allocate
-size_t alloc_size (size_t len)
-    { return (len + sizeof(heap_node) - 1) / sizeof(heap_node) + 1; }
-
-bool is_fallback_ptr ( void *ptr )
-    { return ptr >= heap && ptr < ( heap + HEAP_SIZE ); }
-
-void *fallback_malloc(size_t len) {
-    heap_node *p, *prev;
-    const size_t nelems = alloc_size ( len );
-    mutexor mtx ( &heap_mutex );
-    
-    if ( NULL == freelist )
-        init_heap ();
-
-//  Walk the free list, looking for a "big enough" chunk
-    for (p = freelist, prev = 0; 
-            p && p != list_end;     prev = p, p = node_from_offset ( p->next_node)) {
-
-        if (p->len > nelems) {  //  chunk is larger, shorten, and return the tail
-            heap_node *q;
-            
-            p->len -= nelems;
-            q = p + p->len;
-            q->next_node = 0;
-            q->len = static_cast<heap_size>(nelems);
-            return (void *) (q + 1);
-        }
-        
-        if (p->len == nelems) { // exact size match
-            if (prev == 0)
-                freelist = node_from_offset(p->next_node);
-            else
-                prev->next_node = p->next_node;
-            p->next_node = 0;
-            return (void *) (p + 1);
-        }
-    }
-    return NULL;    // couldn't find a spot big enough
-}
-
-//  Return the start of the next block
-heap_node *after ( struct heap_node *p ) { return p + p->len; }
-
-void fallback_free (void *ptr) {
-    struct heap_node *cp = ((struct heap_node *) ptr) - 1;      // retrieve the chunk
-    struct heap_node *p, *prev;
-
-    mutexor mtx ( &heap_mutex );
-
-#ifdef DEBUG_FALLBACK_MALLOC
-        std::cout << "Freeing item at " << offset_from_node ( cp ) << " of size " << cp->len << std::endl;
-#endif
-
-    for (p = freelist, prev = 0; 
-            p && p != list_end;     prev = p, p = node_from_offset (p->next_node)) {
-#ifdef DEBUG_FALLBACK_MALLOC
-        std::cout << "  p, cp, after (p), after(cp) "
-            << offset_from_node ( p ) << ' '
-            << offset_from_node ( cp ) << ' '
-            << offset_from_node ( after ( p )) << ' '
-            << offset_from_node ( after ( cp )) << std::endl;
-#endif
-        if ( after ( p ) == cp ) {
-#ifdef DEBUG_FALLBACK_MALLOC
-            std::cout << "  Appending onto chunk at " << offset_from_node ( p ) << std::endl;
-#endif
-            p->len += cp->len;  // make the free heap_node larger
-            return;
-            }
-        else if ( after ( cp ) == p ) { // there's a free heap_node right after
-#ifdef DEBUG_FALLBACK_MALLOC
-            std::cout << "  Appending free chunk at " << offset_from_node ( p ) << std::endl;
-#endif
-            cp->len += p->len;
-            if ( prev == 0 ) {
-                freelist = cp;
-                cp->next_node = p->next_node;
-                }
-            else
-                prev->next_node = offset_from_node(cp);
-            return;
-            }
-        }
-//  Nothing to merge with, add it to the start of the free list
-#ifdef DEBUG_FALLBACK_MALLOC
-            std::cout << "  Making new free list entry " << offset_from_node ( cp ) << std::endl;
-#endif
-    cp->next_node = offset_from_node ( freelist );
-    freelist = cp;
-}
-
-#ifdef INSTRUMENT_FALLBACK_MALLOC
-size_t print_free_list () {
-    struct heap_node *p, *prev;
-    heap_size total_free = 0;
-    if ( NULL == freelist )
-        init_heap ();
-    
-    for (p = freelist, prev = 0; 
-            p && p != list_end;     prev = p, p = node_from_offset (p->next_node)) {
-        std::cout << ( prev == 0 ? "" : "  ")  << "Offset: " << offset_from_node ( p ) 
-                << "\tsize: " << p->len << " Next: " << p->next_node << std::endl;
-        total_free += p->len;
-        }
-    std::cout << "Total Free space: " << total_free << std::endl;
-    return total_free;
-    }
-#endif
-}  // end unnamed namespace