Re-implemented poor man's version of vector, array, and pair from C++…

… standard lib to work in restricted C++ environment (no exceptions, no standard lib) in preparation for later getting the serialization/deserialization code to run within WebAssembly (for EOSIO/eos#354)

libraries/table/CMakeLists.txt

@@ -1,7 +1,7 @@
 
 file(GLOB HEADERS  "${CMAKE_CURRENT_SOURCE_DIR}/include/eos/table/*.hpp")
 
-add_definitions(-DBOOST_PP_VARIADICS)
+add_definitions(-DBOOST_PP_VARIADICS -DEOS_TYPES_FULL_CAPABILITY)
 
 add_library( eos_table
              dynamic_object.cpp 

libraries/types/include/eos/eoslib/array.hpp

@@ -0,0 +1,99 @@
+#pragma once
+
+// Derived from: https://github.com/llvm-mirror/libcxx/blob/master/include/array
+// Using MIT License. See: https://github.com/llvm-mirror/libcxx/blob/master/LICENSE.TXT
+
+#include <eos/eoslib/type_traits.hpp>
+#include <eos/eoslib/cstddef.hpp>
+#include <eos/eoslib/iterator.hpp>
+#include <eos/eoslib/exceptions.hpp>
+
+namespace eoslib {
+
+   template <class _Tp, size_t _Size>
+   struct array
+   {
+      // types:
+      typedef array __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;
+
+      value_type __elems_[_Size > 0 ? _Size : 1];
+
+      // No explicit construct/copy/destroy for aggregate type
+      void fill(const value_type& __u) 
+      {
+         for( size_type i = 0; i < _Size; ++i )
+            __elems_[i] = __u;
+      }
+
+      /*
+      void swap(array& __a)
+      { 
+         __swap_dispatch((std::integral_constant<bool, _Size == 0>()), __a); 
+      }
+
+      void __swap_dispatch(std::true_type, array&) {}
+
+      void __swap_dispatch(std::false_type, array& __a)
+      { 
+         swap_ranges(__elems_, __elems_ + _Size, __a.__elems_);
+      }
+      */
+
+      iterator begin() { return iterator(__elems_); }
+      const_iterator begin()const { return const_iterator(__elems_); }
+      iterator end() { return iterator(__elems_ + _Size); }
+      const_iterator end()const { return const_iterator(__elems_ + _Size); }
+
+      const_iterator cbegin()const { return begin(); }
+      const_iterator cend()const { return end(); }
+
+      constexpr size_type size()const { return _Size; }
+      constexpr size_type max_size()const { return _Size; }
+      constexpr bool empty()const { return _Size == 0; }
+
+      reference operator[](size_type __n) { return __elems_[__n]; }
+      constexpr const_reference operator[](size_type __n)const { return __elems_[__n]; }
+
+      reference at(size_type __n);
+      constexpr const_reference at(size_type __n)const;
+
+      reference front() { return __elems_[0]; }
+      constexpr const_reference front()const { return __elems_[0]; }
+      reference back()  { return __elems_[_Size > 0 ? _Size-1 : 0]; }
+      constexpr const_reference back()const { return __elems_[_Size > 0 ? _Size-1 : 0]; }
+
+      value_type* data() { return __elems_; }
+      const value_type* data()const { return __elems_; }
+   };
+
+   template <class _Tp, size_t _Size>
+   typename array<_Tp, _Size>::reference
+   array<_Tp, _Size>::at(size_type __n)
+   {
+      if (__n >= _Size)
+         EOS_ERROR(std::out_of_range, "array::at");
+
+      return __elems_[__n];
+   }
+
+   template <class _Tp, size_t _Size>
+   constexpr
+   typename array<_Tp, _Size>::const_reference
+   array<_Tp, _Size>::at(size_type __n) const
+   {
+      if (__n >= _Size)
+         EOS_ERROR(std::out_of_range, "array::at");
+      return __elems_[__n];
+   }
+
+}
+

libraries/types/include/eos/eoslib/cstddef.hpp

@@ -0,0 +1,9 @@
+#pragma once
+
+namespace eoslib {
+
+   typedef decltype(nullptr) nullptr_t;
+   typedef long unsigned int size_t;
+   typedef long int          ptrdiff_t;
+
+}

libraries/types/include/eos/eoslib/deserialize_visitor.hpp

@@ -139,9 +139,9 @@ EOS_TYPES_CUSTOM_BUILTIN_MATCH_END
       typename enable_if<eos::types::reflector<Container>::is_array::value>::type
       operator()(Container& c)const
       {
-         type_id element_tid;
-         uint32_t num_elements;
-         std::tie(element_tid, num_elements) = tm.get_container_element_type(tid);
+         auto res = tm.get_container_element_type(tid);
+         type_id element_tid = res.first;
+         uint32_t num_elements = res.second;
          if( num_elements < 2 )
             EOS_ERROR(std::runtime_error, "Type mismatch");
          if( num_elements != c.size() )
@@ -163,9 +163,9 @@ EOS_TYPES_CUSTOM_BUILTIN_MATCH_END
          if( c.size() != 0 )
             EOS_ERROR(std::runtime_error, "Expected vector to construct to be initially empty.");
 
-         type_id element_tid;
-         uint32_t num_elements;
-         std::tie(element_tid, num_elements) = tm.get_container_element_type(tid);
+         auto res = tm.get_container_element_type(tid);
+         type_id element_tid = res.first;
+         uint32_t num_elements = res.second;
          if( num_elements != 0 )
             EOS_ERROR(std::runtime_error, "Type mismatch");
 
@@ -183,15 +183,15 @@ EOS_TYPES_CUSTOM_BUILTIN_MATCH_END
          if( (vector_data_offset + (num_elements * stride)) > r.offset_end() )
             EOS_ERROR(std::logic_error, "Raw region is too small to contain this type.");
 
-         deserialize_visitor vis(tm, r, element_tid, vector_data_offset); 
-         auto itr = std::inserter(c, c.end());
+         deserialize_visitor vis(tm, r, element_tid, vector_data_offset);
+         c.clear(); 
          if( extra_zero_at_end )
             --num_elements;
          for( uint32_t i = 0; i < num_elements; ++i )
          {
             typename Container::value_type x;
             eos::types::reflector<typename Container::value_type>::visit(x, vis);
-            itr = std::move(x);
+            c.push_back(eoslib::move(x));
             vis.offset += stride;
          }
       }
@@ -207,9 +207,9 @@ EOS_TYPES_CUSTOM_BUILTIN_MATCH_END
       typename enable_if<eos::types::reflector<Container>::is_optional::value>::type
       operator()(Container& c)const
       {
-         type_id element_tid;
-         uint32_t num_elements;
-         std::tie(element_tid, num_elements) = tm.get_container_element_type(tid);
+         auto res = tm.get_container_element_type(tid);
+         type_id element_tid = res.first;
+         uint32_t num_elements = res.second;
          if( num_elements != 1 )
             EOS_ERROR(std::runtime_error, "Type mismatch");
 
@@ -223,7 +223,7 @@ EOS_TYPES_CUSTOM_BUILTIN_MATCH_END
          typename Container::value_type x;
          deserialize_visitor vis(tm, r, element_tid, offset); 
          eos::types::reflector<typename Container::value_type>::visit(x, vis);
-         c = std::move(x);
+         c = eoslib::move(x);
       }
 
    };

libraries/types/include/eos/eoslib/exceptions.hpp

@@ -4,7 +4,7 @@
 
 #include <stdexcept>
 
-#define EOS_ERROR(type, message) do { throw type(message); } while(0)
+#define EOS_ERROR(type, message) throw type(message)
 
 #else
 
@@ -14,6 +14,8 @@
 
 #include <cassert>
 
-#define EOS_ERROR(type, message) do { assert(0); } while(0)
+#define EOS_ERROR(type, message) assert(0)
 
 #endif
+
+#define EOS_ASSERT(x, msg) ((x) ? (void)0 : EOS_ERROR(std::runtime_error, msg))

libraries/types/include/eos/eoslib/immutable_region.hpp

@@ -42,7 +42,7 @@ namespace eos { namespace types {
          eos::types::reflector<PlainT>::visit(type, vis);
       }
 
-      inline const vector<byte>& get_raw_data()const { return raw_data.get_raw_data(); }
+      inline const Vector<byte>& get_raw_data()const { return raw_data.get_raw_data(); }
 
    private:
       const full_types_manager& tm;

libraries/types/include/eos/eoslib/initializer_list.hpp

@@ -0,0 +1,65 @@
+#pragma once
+
+// Derived from: https://github.com/llvm-mirror/libcxx/blob/master/include/initializer_list
+// Using MIT License. See: https://github.com/llvm-mirror/libcxx/blob/master/LICENSE.TXT
+
+// initializer_list is one of few  special cases in the C++ standard library. i
+// It must be defined as std::initializer_list because that is what the compiler expects.
+
+//#ifndef EOS_TYPES_REFLET_FULL_CAPABILITY
+
+#include <eos/eoslib/cstddef.hpp>
+
+namespace std { 
+
+   template<class _Ep>
+   class initializer_list
+   {
+      const _Ep* __begin_;
+      size_t    __size_;
+
+      constexpr
+      initializer_list(const _Ep* __b, size_t __s)
+        : __begin_(__b), __size_(__s)
+      {}
+
+   public:
+      typedef _Ep        value_type;
+      typedef const _Ep& reference;
+      typedef const _Ep& const_reference;
+      typedef size_t    size_type;
+
+      typedef const _Ep* iterator;
+      typedef const _Ep* const_iterator;
+
+      constexpr initializer_list() 
+         : __begin_(nullptr), __size_(0) 
+      {}
+
+      constexpr size_t size()const { return __size_; }
+
+      constexpr const _Ep* begin()const { return __begin_; }
+
+      constexpr const _Ep* end()const { return __begin_ + __size_; }
+   };
+
+   template<class _Ep>
+   inline constexpr
+   const _Ep*
+   begin(initializer_list<_Ep> __il)
+   {
+      return __il.begin();
+   }
+
+   template<class _Ep>
+   inline constexpr
+   const _Ep*
+   end(initializer_list<_Ep> __il)
+   {
+      return __il.end();
+   }
+
+}
+
+//#endif
+

libraries/types/include/eos/eoslib/iterator.hpp

@@ -0,0 +1,93 @@
+#pragma once
+
+// Derived from: https://github.com/llvm-mirror/libcxx/blob/master/include/iterator
+// Using MIT License. See: https://github.com/llvm-mirror/libcxx/blob/master/LICENSE.TXT
+
+#include <eos/eoslib/type_traits.hpp>
+#include <eos/eoslib/cstddef.hpp>
+
+namespace eoslib {
+
+   struct input_iterator_tag {};
+   struct output_iterator_tag {};
+   struct forward_iterator_tag       : public input_iterator_tag {};
+   struct bidirectional_iterator_tag : public forward_iterator_tag {};
+   struct random_access_iterator_tag : public bidirectional_iterator_tag {};
+
+   template <class _Tp>
+   struct __has_iterator_category
+   {
+   private:
+      struct __two {char __lx; char __lxx;};
+      template <class _Up> static __two __test(...);
+      template <class _Up> static char __test(typename _Up::iterator_category* = 0);
+   public:
+      static const bool value = sizeof(__test<_Tp>(0)) == 1;
+   };
+
+   template <class _Iter, bool> struct __iterator_traits_impl {};
+
+   template <class _Iter>
+   struct __iterator_traits_impl<_Iter, true>
+   {
+      typedef typename _Iter::difference_type   difference_type;
+      typedef typename _Iter::value_type        value_type;
+      typedef typename _Iter::pointer           pointer;
+      typedef typename _Iter::reference         reference;
+      typedef typename _Iter::iterator_category iterator_category;
+   };
+
+   template <class _Iter, bool> struct __iterator_traits {};
+
+   template <class _Iter>
+   struct __iterator_traits<_Iter, true> : __iterator_traits_impl<_Iter, is_convertible<typename _Iter::iterator_category, input_iterator_tag>::value ||
+                                                                         is_convertible<typename _Iter::iterator_category, output_iterator_tag>::value>
+   {};
+
+   // iterator_traits<Iterator> will only have the nested types if Iterator::iterator_category
+   //    exists.  Else iterator_traits<Iterator> will be an empty class.  This is a
+   //    conforming extension which allows some programs to compile and behave as
+   //    the client expects instead of failing at compile time.
+
+   template <class _Iter> struct iterator_traits : __iterator_traits<_Iter, __has_iterator_category<_Iter>::value> {};
+
+   template<class _Tp>
+   struct iterator_traits<_Tp*>
+   {
+      typedef ptrdiff_t difference_type;
+      typedef typename remove_const<_Tp>::type value_type;
+      typedef _Tp* pointer;
+      typedef _Tp& reference;
+      typedef random_access_iterator_tag iterator_category;
+   };
+
+   template <class _Tp, class _Up, bool = __has_iterator_category<iterator_traits<_Tp> >::value>
+   struct __has_iterator_category_convertible_to : public integral_constant<bool, is_convertible<typename iterator_traits<_Tp>::iterator_category, _Up>::value>
+   {};
+
+   template <class _Tp, class _Up> struct __has_iterator_category_convertible_to<_Tp, _Up, false> : public false_type {};
+
+   template <class _Tp> struct __is_input_iterator : public __has_iterator_category_convertible_to<_Tp, input_iterator_tag> {};
+
+   template <class _Tp> struct __is_forward_iterator : public __has_iterator_category_convertible_to<_Tp, forward_iterator_tag> {};
+
+   template <class _Tp> struct __is_bidirectional_iterator : public __has_iterator_category_convertible_to<_Tp, bidirectional_iterator_tag> {};
+
+   template <class _Tp> struct __is_random_access_iterator : public __has_iterator_category_convertible_to<_Tp, random_access_iterator_tag> {};
+
+   template <class _Tp> struct __is_exactly_input_iterator : public integral_constant<bool, __has_iterator_category_convertible_to<_Tp, input_iterator_tag>::value && 
+                                                                                            !__has_iterator_category_convertible_to<_Tp, forward_iterator_tag>::value>
+   {};
+
+   template<class _Category, class _Tp, class _Distance = ptrdiff_t, class _Pointer = _Tp*, class _Reference = _Tp&>
+   struct iterator
+   {
+      typedef _Tp        value_type;
+      typedef _Distance  difference_type;
+      typedef _Pointer   pointer;
+      typedef _Reference reference;
+      typedef _Category  iterator_category;
+   };
+
+}
+