Changeset dc0fff11 in mainline

Timestamp:

2018-07-05T21:41:18Z (7 years ago)

Author:

Dzejrou <dzejrou@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

9315761

Parents:

c20cccb

git-author:

Jaroslav Jindrak <dzejrou@…> (2017-10-30 12:49:17)

git-committer:

Dzejrou <dzejrou@…> (2018-07-05 21:41:18)

Message:

cpp: fixed some bugs found by the string tests

Location:

uspace/lib/cpp/include/impl

Files:

• iosfwd.hpp (modified) (2 diffs)
• memory.hpp (modified) (1 diff)
• string.hpp (modified) (22 diffs)
• type_traits.hpp (modified) (1 diff)

uspace/lib/cpp/include/impl/iosfwd.hpp

@@ -82 +82 @@
     template<class Char, class Traits = char_traits<Char>,
              class Allocator = allocator<Char>>
-    class basic_istringstream;
+    class basic_ostringstream;
 
     template<class Char, class Traits = char_traits<Char>,
              class Allocator = allocator<Char>>
-    class basic_istringstream;
+    class basic_stringstream;
 
 
@@ -147 +147 @@
 
     // TODO: standard p. 1012, this is circular, it offers fix
-    using streampos  = fpos<char_traits<char>::state_type>;
-    using wstreampos = fpos<char_traits<wchar_t>::state_type>;
+    /* using streampos  = fpos<char_traits<char>::state_type>; */
+    /* using wstreampos = fpos<char_traits<wchar_t>::state_type>; */
+    // Temporary workaround.
+    using streampos =  unsigned long long;
+    using wstreampos = unsigned long long;
+    // TODO: This should be in ios and not here?
+    using streamoff = long long;
 }

uspace/lib/cpp/include/impl/memory.hpp

@@ -31 +31 @@
 
 #include <internal/aux.hpp>
+#include <utility>
 #include <type_traits>
 

uspace/lib/cpp/include/impl/string.hpp

@@ -30 +30 @@
 #define LIBCPP_STRING
 
-#include <initializer_list>
+#include <algorithm>
 #include <iosfwd>
+#include <iterator>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
+#include <memory>
+#include <utility>
+
+#include <initializer_list>
 
 namespace std
@@ -179 +184 @@
         static int compare(const char_type* s1, const char_type* s2, size_t n)
         {
-            return std::wstr_lcmp(s1, s2, n);
+            // TODO: This function does not exits...
+            //return std::wstr_lcmp(s1, s2, n);
+            return 0;
         }
 
@@ -260 +267 @@
             using reference       = value_type&;
             using const_reference = const value_type&;
-            using pointer         = allocator_traits<allocator_type>::pointer;
-            using const_pointer   = allocator_traits<allocator_type>::const_pointer;
+            using pointer         = typename allocator_traits<allocator_type>::pointer;
+            using const_pointer   = typename allocator_traits<allocator_type>::const_pointer;
 
             using iterator               = pointer;
@@ -286 +293 @@
                  *  capacity() = unspecified
                  */
-                data_ = allocator_.allocate(initial_capacity_);
-                capacity_ = initial_capacity_;
+                data_ = allocator_.allocate(default_capacity_);
+                capacity_ = default_capacity_;
             }
 
@@ -315 +322 @@
             }
 
-            basic_string(const value_type* str, size_type n, const allocator_type& alloc = allocator{})
+            basic_string(const value_type* str, size_type n, const allocator_type& alloc = allocator_type{})
                 : data_{}, size_{n}, capacity_{n}, allocator_{alloc}
             {
@@ -321 +328 @@
             }
 
-            basic_string(const value_type* str, const allocator_type& alloc = allocator{})
+            basic_string(const value_type* str, const allocator_type& alloc = allocator_type{})
                 : data_{}, size_{}, capacity_{}, allocator_{alloc}
             {
@@ -327 +334 @@
             }
 
-            basic_string(size_type n, value_type c, const allocator_type& alloc = allocator{})
+            basic_string(size_type n, value_type c, const allocator_type& alloc = allocator_type{})
                 : data_{}, size_{n}, capacity_{n}, allocator_{alloc}
             {
@@ -338 +345 @@
             template<class InputIterator>
             basic_string(InputIterator first, InputIterator last,
-                         const allocator_type& alloc = allocator{})
+                         const allocator_type& alloc = allocator_type{})
                 : data_{}, size_{}, capacity_{}, allocator_{alloc}
             {
-                if constexpr (is_integral_t<InputIterator>)
+                if constexpr (is_integral<InputIterator>::value)
                 { // Required by the standard.
                     size_ = static_cast<size_type>(first);
@@ -358 +365 @@
             }
 
-            basic_string(initializer_list<value_type> init, const allocator_type& alloc = allocator{})
+            basic_string(initializer_list<value_type> init, const allocator_type& alloc = allocator_type{})
                 : basic_string{init.begin(), init.size(), alloc}
             { /* DUMMY BODY */ }
@@ -629 +636 @@
             }
 
-            basic_string& append(const basic_string& str, size_type pos
+            basic_string& append(const basic_string& str, size_type pos,
                                  size_type n = npos)
             {
@@ -666 +673 @@
             basic_string& append(InputIterator first, InputIterator last)
             {
-                return append(basic_string(frist, last));
+                return append(basic_string(first, last));
             }
 
@@ -704 +711 @@
                 }
                 // TODO: Else throw out_of_range.
+
+                return *this;
             }
 
@@ -711 +720 @@
                 resize_without_copy_(n);
                 traits_type::copy(begin(), str, n);
+                size_ = n;
+                ensure_null_terminator_();
 
                 return *this;
@@ -792 +803 @@
                 copy_backward_(begin() + pos, end(), end() + n);
 
-                auto it = position;
+                auto it = pos;
                 for (size_type i = 0; i < n; ++i)
-                    type_traits::assign(*it++, c);
+                    traits_type::assign(*it++, c);
                 ensure_null_terminator_();
 
@@ -812 +823 @@
             }
 
-            basic_string& erase(size_type pos = 0; size_type n = npos)
+            basic_string& erase(size_type pos = 0, size_type n = npos)
             {
                 auto len = min(n, size_ - pos);
@@ -825 +836 @@
             {
                 auto idx = static_cast<size_type>(pos - cbegin());
-                erase(dx, 1);
+                erase(idx, 1);
 
                 return begin() + idx;
@@ -851 +862 @@
             }
 
-            basic_string& replace(size_type pos1, size_type n1, const basic_string& str
+            basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
                                   size_type pos2, size_type n2 = npos)
             {
@@ -895 +906 @@
                                   const value_type* str, size_type n)
             {
-                return replace(i1 - begin(), i2 - i1, s, n);
+                return replace(i1 - begin(), i2 - i1, str, n);
             }
 
@@ -1256 +1267 @@
              * set capacity to 0, but that would be too cryptic.)
              */
-            static constexpr size_type default_capacity_{4}
+            static constexpr size_type default_capacity_{4};
 
             void init_(const value_type* str, size_type size)
@@ -1286 +1297 @@
                  *       reserve can cause shrinking.
                  */
-                if (size_ + 1 + n > capacity)
+                if (size_ + 1 + n > capacity_)
                     resize_with_copy_(size_, max(size_ + 1 + n, next_capacity_()));
             }
@@ -1342 +1353 @@
             void ensure_null_terminator_()
             {
-                traits_type::assign(data_[size_], value_type{});
+                value_type c{};
+                traits_type::assign(data_[size_], c);
             }
 
@@ -1369 +1381 @@
             }
     };
+
+    using string = basic_string<char>;
 }
 

uspace/lib/cpp/include/impl/type_traits.hpp

@@ -153 +153 @@
     { /* DUMMY BODY */ };
 
-    template<class T>
-    struct is_integral: __is_integral<remove_cv_t<T>>
+    template<class T> // TODO: use remove_cv when implemented
+    struct is_integral: __is_integral<T>
     { /* DUMMY BODY */ };