webruby 0.2.7 → 0.9.1

data/modules/emscripten/system/include/libcxx/dynarray

@@ -1,311 +0,0 @@
-// -*- C++ -*-
-//===-------------------------- dynarray ----------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_DYNARRAY
-#define _LIBCPP_DYNARRAY
-
-#include <__config>
-#if _LIBCPP_STD_VER > 11
-
-/*
-    dynarray synopsis
-
-namespace std {
-
-template< typename T >
-class dynarray
-{
-    // types:
-    typedef       T                               value_type;
-    typedef       T&                              reference;
-    typedef const T&                              const_reference;
-    typedef       T*                              pointer;
-    typedef const T*                              const_pointer;
-    typedef       implementation-defined          iterator;
-    typedef       implementation-defined          const_iterator;
-    typedef reverse_iterator<iterator>            reverse_iterator;
-    typedef reverse_iterator<const_iterator>      const_reverse_iterator;
-    typedef size_t                                size_type;
-    typedef ptrdiff_t                             difference_type;
-
-public:
-    // construct/copy/destroy:
-    explicit dynarray(size_type c);
-    template <typename Alloc>
-      dynarray(size_type c, const Alloc& alloc);
-    dynarray(size_type c, const T& v);
-    template <typename Alloc>
-      dynarray(size_type c, const T& v, const Alloc& alloc);
-    dynarray(const dynarray& d);
-    template <typename Alloc>
-      dynarray(const dynarray& d, const Alloc& alloc);
-    dynarray(initializer_list<T>);
-    template <typename Alloc>
-      dynarray(initializer_list<T>, const Alloc& alloc);
-
-    dynarray& operator=(const dynarray&) = delete;
-    ~dynarray();
-
-    // iterators:
-    iterator       begin()        noexcept;
-    const_iterator begin()  const noexcept;
-    const_iterator cbegin() const noexcept;
-    iterator       end()          noexcept;
-    const_iterator end()    const noexcept;
-    const_iterator cend()   const noexcept;
-
-    reverse_iterator       rbegin()        noexcept;
-    const_reverse_iterator rbegin()  const noexcept;
-    const_reverse_iterator crbegin() const noexcept;
-    reverse_iterator       rend()          noexcept;
-    const_reverse_iterator rend()    const noexcept;
-    const_reverse_iterator crend()   const noexcept;
-
-    // capacity:
-    size_type size()     const noexcept;
-    size_type max_size() const noexcept;
-    bool      empty()    const noexcept;
-
-    // element access:
-    reference       operator[](size_type n);
-    const_reference operator[](size_type n) const;
-
-    reference       front();
-    const_reference front() const;
-    reference       back();
-    const_reference back()  const;
-
-    const_reference at(size_type n) const;
-    reference       at(size_type n);
-
-    // data access:
-    T*       data()       noexcept;
-    const T* data() const noexcept;
-
-    // mutating member functions:
-    void fill(const T& v);
-};
-
-}  // std
-
-*/
-
-#include <__functional_base>
-#include <iterator>
-#include <stdexcept>
-#include <initializer_list>
-#include <new>
-#include <algorithm>
-
-#if defined(_LIBCPP_NO_EXCEPTIONS)
-    #include <cassert>
-#endif
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY dynarray
-{
-public:
-    // types:
-    typedef dynarray __self;
-    typedef _Tp                                   value_type;
-    typedef value_type&                           reference;
-    typedef const value_type&                     const_reference;
-    typedef value_type*                           iterator;
-    typedef const value_type*                     const_iterator;
-    typedef value_type*                           pointer;
-    typedef const value_type*                     const_pointer;
-    typedef size_t                                size_type;
-    typedef ptrdiff_t                             difference_type;
-    typedef std::reverse_iterator<iterator>       reverse_iterator;
-    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-
-private:
-    size_t                  __size_;
-    value_type *            __base_;
-    _LIBCPP_ALWAYS_INLINE dynarray () noexcept : __base_(nullptr), __size_(0) {}
-    
-    static inline _LIBCPP_INLINE_VISIBILITY value_type* __allocate ( size_t count )
-    {
-        if ( numeric_limits<size_t>::max() / sizeof (value_type) <= count )
-        {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-            throw bad_array_length();
-#else
-            assert(!"dynarray::allocation");
-#endif
-        }
-        return static_cast<value_type *> (::operator new (sizeof(value_type) * count));
-    }
-
-    static inline _LIBCPP_INLINE_VISIBILITY void __deallocate ( value_type* __ptr ) noexcept
-    {
-        ::operator delete (static_cast<void *> (__ptr));
-    }
-
-public:
-
-    explicit dynarray(size_type __c);
-    dynarray(size_type __c, const value_type& __v);
-    dynarray(const dynarray& __d);
-    dynarray(initializer_list<value_type>);
-
-//  We're not implementing these right now.
-//  Waiting for the resolution of LWG issue #2235
-//     template <typename _Alloc>
-//       dynarray(size_type __c, const _Alloc& __alloc);
-//     template <typename _Alloc>
-//       dynarray(size_type __c, const value_type& __v, const _Alloc& __alloc);
-//     template <typename _Alloc>
-//       dynarray(const dynarray& __d, const _Alloc& __alloc);
-//     template <typename _Alloc>
-//       dynarray(initializer_list<value_type>, const _Alloc& __alloc);
-
-    dynarray& operator=(const dynarray&) = delete;
-    ~dynarray();
-
-    // iterators:
-    inline _LIBCPP_INLINE_VISIBILITY iterator       begin()        noexcept { return iterator(data()); }
-    inline _LIBCPP_INLINE_VISIBILITY const_iterator begin()  const noexcept { return const_iterator(data()); }
-    inline _LIBCPP_INLINE_VISIBILITY const_iterator cbegin() const noexcept { return const_iterator(data()); }
-    inline _LIBCPP_INLINE_VISIBILITY iterator       end()          noexcept { return iterator(data() + __size_); }
-    inline _LIBCPP_INLINE_VISIBILITY const_iterator end()    const noexcept { return const_iterator(data() + __size_); }
-    inline _LIBCPP_INLINE_VISIBILITY const_iterator cend()   const noexcept { return const_iterator(data() + __size_); }
-
-    inline _LIBCPP_INLINE_VISIBILITY reverse_iterator       rbegin()        noexcept { return reverse_iterator(end()); }
-    inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rbegin()  const noexcept { return const_reverse_iterator(end()); }
-    inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); }
-    inline _LIBCPP_INLINE_VISIBILITY reverse_iterator       rend()          noexcept { return reverse_iterator(begin()); }
-    inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rend()    const noexcept { return const_reverse_iterator(begin()); }
-    inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator crend()   const noexcept { return const_reverse_iterator(begin()); }
-
-    // capacity:
-    inline _LIBCPP_INLINE_VISIBILITY size_type size()     const noexcept { return __size_; }
-    inline _LIBCPP_INLINE_VISIBILITY size_type max_size() const noexcept { return __size_; }
-    inline _LIBCPP_INLINE_VISIBILITY bool      empty()    const noexcept { return __size_ == 0; }
-
-    // element access:
-    inline _LIBCPP_INLINE_VISIBILITY reference       operator[](size_type __n)       { return data()[__n]; }
-    inline _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const { return data()[__n]; }
-
-    inline _LIBCPP_INLINE_VISIBILITY reference       front()       { return data()[0]; }
-    inline _LIBCPP_INLINE_VISIBILITY const_reference front() const { return data()[0]; }
-    inline _LIBCPP_INLINE_VISIBILITY reference       back()        { return data()[__size_-1]; }
-    inline _LIBCPP_INLINE_VISIBILITY const_reference back()  const { return data()[__size_-1]; }
-
-    inline _LIBCPP_INLINE_VISIBILITY const_reference at(size_type __n) const;
-    inline _LIBCPP_INLINE_VISIBILITY reference       at(size_type __n);
-
-    // data access:
-    inline _LIBCPP_INLINE_VISIBILITY _Tp*       data()       noexcept { return __base_; }
-    inline _LIBCPP_INLINE_VISIBILITY const _Tp* data() const noexcept { return __base_; }
-
-    // mutating member functions:
-    inline _LIBCPP_INLINE_VISIBILITY void fill(const value_type& __v) { fill_n(begin(), __size_, __v); }
-};
-
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-dynarray<_Tp>::dynarray(size_type __c) : dynarray ()
-{
-    __base_ = __allocate (__c);
-    value_type *__data = data ();
-    for ( __size_ = 0; __size_ < __c; ++__size_, ++__data )
-        ::new (__data) value_type;
-}
-
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-dynarray<_Tp>::dynarray(size_type __c, const value_type& __v) : dynarray ()
-{
-    __base_ = __allocate (__c);
-    value_type *__data = data ();
-    for ( __size_ = 0; __size_ < __c; ++__size_, ++__data )
-        ::new (__data) value_type (__v);
-}
-
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-dynarray<_Tp>::dynarray(initializer_list<value_type> __il) : dynarray ()
-{
-    size_t sz = __il.size();
-    __base_ = __allocate (sz);
-    value_type *__data = data ();
-    auto src = __il.begin();
-    for ( __size_ = 0; __size_ < sz; ++__size_, ++__data, ++src )
-        ::new (__data) value_type (*src);
-}
-
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-dynarray<_Tp>::dynarray(const dynarray& __d) : dynarray ()
-{
-    size_t sz = __d.size();
-    __base_ = __allocate (sz);
-    value_type *__data = data ();
-    auto src = __d.begin();
-    for ( __size_ = 0; __size_ < sz; ++__size_, ++__data, ++src )
-        ::new (__data) value_type (*src);
-}
-
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-dynarray<_Tp>::~dynarray()
-{ 
-    value_type *__data = data () + __size_;
-    for ( size_t i = 0; i < __size_; ++i )
-        (--__data)->value_type::~value_type();
-    __deallocate ( __base_ );
-}
-
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-typename dynarray<_Tp>::reference
-dynarray<_Tp>::at(size_type __n)
-{
-    if (__n >= __size_)
-    {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        throw out_of_range("dynarray::at");
-#else
-        assert(!"dynarray::at out_of_range");
-#endif
-    }
-    return data()[__n];
-}
-
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-typename dynarray<_Tp>::const_reference
-dynarray<_Tp>::at(size_type __n) const
-{
-    if (__n >= __size_)
-    {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        throw out_of_range("dynarray::at");
-#else
-        assert(!"dynarray::at out_of_range");
-#endif
-    }
-    return data()[__n];
-}
-
-template <class _Tp, class _Alloc>
-struct _LIBCPP_TYPE_VIS_ONLY uses_allocator<dynarray<_Tp>, _Alloc> : true_type {};
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif  // if _LIBCPP_STD_VER > 11 
-#endif  // _LIBCPP_DYNARRAY

data/modules/emscripten/system/include/libcxx/exception

@@ -1,250 +0,0 @@
-// -*- C++ -*-
-//===-------------------------- exception ---------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXCEPTION
-#define _LIBCPP_EXCEPTION
-
-/*
-    exception synopsis
-
-namespace std
-{
-
-class exception
-{
-public:
-    exception() noexcept;
-    exception(const exception&) noexcept;
-    exception& operator=(const exception&) noexcept;
-    virtual ~exception() noexcept;
-    virtual const char* what() const noexcept;
-};
-
-class bad_exception
-    : public exception
-{
-public:
-    bad_exception() noexcept;
-    bad_exception(const bad_exception&) noexcept;
-    bad_exception& operator=(const bad_exception&) noexcept;
-    virtual ~bad_exception() noexcept;
-    virtual const char* what() const noexcept;
-};
-
-typedef void (*unexpected_handler)();
-unexpected_handler set_unexpected(unexpected_handler  f ) noexcept;
-unexpected_handler get_unexpected() noexcept;
-[[noreturn]] void unexpected();
-
-typedef void (*terminate_handler)();
-terminate_handler set_terminate(terminate_handler  f ) noexcept;
-terminate_handler get_terminate() noexcept;
-[[noreturn]] void terminate() noexcept;
-
-bool uncaught_exception() noexcept;
-
-typedef unspecified exception_ptr;
-
-exception_ptr current_exception() noexcept;
-void rethrow_exception [[noreturn]] (exception_ptr p);
-template<class E> exception_ptr make_exception_ptr(E e) noexcept;
-
-class nested_exception
-{
-public:
-    nested_exception() noexcept;
-    nested_exception(const nested_exception&) noexcept = default;
-    nested_exception& operator=(const nested_exception&) noexcept = default;
-    virtual ~nested_exception() = default;
-
-    // access functions
-    [[noreturn]] void rethrow_nested() const;
-    exception_ptr nested_ptr() const noexcept;
-};
-
-template <class T> [[noreturn]] void throw_with_nested(T&& t);
-template <class E> void rethrow_if_nested(const E& e);
-
-}  // std
-
-*/
-
-#include <__config>
-#include <cstddef>
-#include <type_traits>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#pragma GCC system_header
-#endif
-
-namespace std  // purposefully not using versioning namespace
-{
-
-class _LIBCPP_EXCEPTION_ABI exception
-{
-public:
-    _LIBCPP_INLINE_VISIBILITY exception() _NOEXCEPT {}
-    virtual ~exception() _NOEXCEPT {} // XXX EMSCRIPTEN - implement in header
-    virtual const char* what() const _NOEXCEPT { return "std::exception"; } // XXX EMSCRIPTEN - implement in header
-};
-
-class _LIBCPP_EXCEPTION_ABI bad_exception
-    : public exception
-{
-public:
-    _LIBCPP_INLINE_VISIBILITY bad_exception() _NOEXCEPT {}
-    virtual ~bad_exception() _NOEXCEPT;
-    virtual const char* what() const _NOEXCEPT;
-};
-
-typedef void (*unexpected_handler)();
-_LIBCPP_FUNC_VIS unexpected_handler set_unexpected(unexpected_handler) _NOEXCEPT;
-_LIBCPP_FUNC_VIS unexpected_handler get_unexpected() _NOEXCEPT;
-_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void unexpected();
-
-typedef void (*terminate_handler)();
-_LIBCPP_FUNC_VIS terminate_handler set_terminate(terminate_handler) _NOEXCEPT;
-_LIBCPP_FUNC_VIS terminate_handler get_terminate() _NOEXCEPT;
-_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void terminate() _NOEXCEPT;
-
-_LIBCPP_FUNC_VIS bool uncaught_exception() _NOEXCEPT;
-
-class _LIBCPP_TYPE_VIS exception_ptr;
-
-_LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
-_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr);
-
-class _LIBCPP_TYPE_VIS exception_ptr
-{
-    void* __ptr_;
-public:
-    _LIBCPP_INLINE_VISIBILITY exception_ptr() _NOEXCEPT : __ptr_() {}
-    _LIBCPP_INLINE_VISIBILITY exception_ptr(nullptr_t) _NOEXCEPT : __ptr_() {}
-    exception_ptr(const exception_ptr&) _NOEXCEPT;
-    exception_ptr& operator=(const exception_ptr&) _NOEXCEPT;
-    ~exception_ptr() _NOEXCEPT;
-
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_EXPLICIT
-        operator bool() const _NOEXCEPT {return __ptr_ != nullptr;}
-
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT
-        {return __x.__ptr_ == __y.__ptr_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT
-        {return !(__x == __y);}
-
-    friend _LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
-    friend _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr);
-};
-
-template<class _Ep>
-exception_ptr
-make_exception_ptr(_Ep __e) _NOEXCEPT
-{
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    try
-    {
-        throw __e;
-    }
-    catch (...)
-    {
-        return current_exception();
-    }
-#endif  // _LIBCPP_NO_EXCEPTIONS
-}
-
-// nested_exception
-
-class _LIBCPP_EXCEPTION_ABI nested_exception
-{
-    exception_ptr __ptr_;
-public:
-    nested_exception() _NOEXCEPT;
-//     nested_exception(const nested_exception&) noexcept = default;
-//     nested_exception& operator=(const nested_exception&) noexcept = default;
-    virtual ~nested_exception() _NOEXCEPT;
-
-    // access functions
-    _LIBCPP_NORETURN void rethrow_nested() const;
-    _LIBCPP_INLINE_VISIBILITY exception_ptr nested_ptr() const _NOEXCEPT {return __ptr_;}
-};
-
-template <class _Tp>
-struct __nested
-    : public _Tp,
-      public nested_exception
-{
-    _LIBCPP_INLINE_VISIBILITY explicit __nested(const _Tp& __t) : _Tp(__t) {}
-};
-
-template <class _Tp>
-_LIBCPP_NORETURN
-void
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-throw_with_nested(_Tp&& __t, typename enable_if<
-                  is_class<typename remove_reference<_Tp>::type>::value &&
-                  !is_base_of<nested_exception, typename remove_reference<_Tp>::type>::value
-                                    >::type* = 0)
-#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-throw_with_nested (_Tp& __t, typename enable_if<
-                  is_class<_Tp>::value && !is_base_of<nested_exception, _Tp>::value
-                                    >::type* = 0)
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-{
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    throw __nested<typename remove_reference<_Tp>::type>(_VSTD::forward<_Tp>(__t));
-#endif
-}
-
-template <class _Tp>
-_LIBCPP_NORETURN
-void
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-throw_with_nested(_Tp&& __t, typename enable_if<
-                  !is_class<typename remove_reference<_Tp>::type>::value ||
-                  is_base_of<nested_exception, typename remove_reference<_Tp>::type>::value
-                                    >::type* = 0)
-#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-throw_with_nested (_Tp& __t, typename enable_if<
-                  !is_class<_Tp>::value || is_base_of<nested_exception, _Tp>::value
-                                    >::type* = 0)
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-{
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    throw _VSTD::forward<_Tp>(__t);
-#endif
-}
-
-template <class _Ep>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-rethrow_if_nested(const _Ep& __e, typename enable_if<
-                                   is_polymorphic<_Ep>::value
-                                                   >::type* = 0)
-{
-    const nested_exception* __nep = dynamic_cast<const nested_exception*>(&__e);
-    if (__nep)
-        __nep->rethrow_nested();
-}
-
-template <class _Ep>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-rethrow_if_nested(const _Ep&, typename enable_if<
-                                   !is_polymorphic<_Ep>::value
-                                                   >::type* = 0)
-{
-}
-
-}  // std
-
-#endif  // _LIBCPP_EXCEPTION

data/modules/emscripten/system/include/libcxx/ext/__hash

@@ -1,46 +0,0 @@
-// -*- C++ -*-
-//===------------------------- hash_set ------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXT_HASH
-#define _LIBCPP_EXT_HASH
-
-#pragma GCC system_header
-
-#include <string>
-#include <cstring>
-
-namespace __gnu_cxx {
-using namespace std;
-
-template <typename T> struct _LIBCPP_TYPE_VIS_ONLY hash : public std::hash<T>
-    { };
-
-template <> struct _LIBCPP_TYPE_VIS_ONLY hash<const char*>
-    : public unary_function<const char*, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(const char *__c) const _NOEXCEPT
-    {
-        return __do_string_hash(__c, __c + strlen(__c));
-    }
-};
-
-template <> struct _LIBCPP_TYPE_VIS_ONLY hash<char *>
-    : public unary_function<char*, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(char *__c) const _NOEXCEPT
-    {
-        return __do_string_hash<const char *>(__c, __c + strlen(__c));
-    }
-};
-}
-
-#endif  // _LIBCPP_EXT_HASH