Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 347 insertions, 0 deletions

diff --git a/third_party/wasm2c/src/string-view.h b/third_party/wasm2c/src/string-view.h
new file mode 100644
index 0000000000..534e675c73
--- /dev/null
+++ b/third_party/wasm2c/src/string-view.h
@@ -0,0 +1,347 @@
+/*
+ * Copyright 2017 WebAssembly Community Group participants
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef WABT_STRING_VIEW_H_
+#define WABT_STRING_VIEW_H_
+
+#include <cassert>
+#include <functional>
+#include <iterator>
+#include <ostream>
+#include <string>
+
+#include "src/hash-util.h"
+
+namespace wabt {
+
+// This is a simplified implemention of C++17's basic_string_view template.
+//
+// Missing features:
+// * Not a template
+// * No allocator support
+// * Some functions are not implemented
+// * Asserts instead of exceptions
+// * Some functions are not constexpr because we don't compile in C++17 mode
+
+class string_view {
+ public:
+  typedef std::char_traits<char> traits_type;
+  typedef char value_type;
+  typedef char* pointer;
+  typedef const char* const_pointer;
+  typedef char& reference;
+  typedef const char& const_reference;
+  typedef const char* const_iterator;
+  typedef const_iterator iterator;
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+  typedef const_reverse_iterator reverse_iterator;
+  typedef std::size_t size_type;
+  typedef std::ptrdiff_t difference_type;
+  static const size_type npos = size_type(-1);
+
+  // construction and assignment
+  constexpr string_view() noexcept;
+  constexpr string_view(const string_view&) noexcept = default;
+  string_view& operator=(const string_view&) noexcept = default;
+  string_view(const std::string& str) noexcept;
+  /*constexpr*/ string_view(const char* str);
+  constexpr string_view(const char* str, size_type len);
+
+  // iterator support
+  constexpr const_iterator begin() const noexcept;
+  constexpr const_iterator end() const noexcept;
+  constexpr const_iterator cbegin() const noexcept;
+  constexpr const_iterator cend() const noexcept;
+  const_reverse_iterator rbegin() const noexcept;
+  const_reverse_iterator rend() const noexcept;
+  const_reverse_iterator crbegin() const noexcept;
+  const_reverse_iterator crend() const noexcept;
+
+  // capacity
+  constexpr size_type size() const noexcept;
+  constexpr size_type length() const noexcept;
+  constexpr size_type max_size() const noexcept;
+  constexpr bool empty() const noexcept;
+
+  // element access
+  constexpr const_reference operator[](size_type pos) const;
+  /*constexpr*/ const_reference at(size_type pos) const;
+  /*constexpr*/ const_reference front() const;
+  /*constexpr*/ const_reference back() const;
+  constexpr const_pointer data() const noexcept;
+
+  // modifiers
+  /*constexpr*/ void remove_prefix(size_type n);
+  /*constexpr*/ void remove_suffix(size_type n);
+  /*constexpr*/ void swap(string_view& s) noexcept;
+
+  // string operations
+  explicit operator std::string() const;
+  std::string to_string() const;
+  size_type copy(char* s, size_type n, size_type pos = 0) const;
+  /*constexpr*/ string_view substr(size_type pos = 0, size_type n = npos) const;
+  /*constexpr*/ int compare(string_view s) const noexcept;
+  /*constexpr*/ int compare(size_type pos1, size_type n1, string_view s) const;
+  /*constexpr*/ int compare(size_type pos1,
+                            size_type n1,
+                            string_view s,
+                            size_type pos2,
+                            size_type n2) const;
+  /*constexpr*/ int compare(const char* s) const;
+  /*constexpr*/ int compare(size_type pos1, size_type n1, const char* s) const;
+  /*constexpr*/ int compare(size_type pos1,
+                            size_type n1,
+                            const char* s,
+                            size_type n2) const;
+  /*constexpr*/ size_type find(string_view s, size_type pos = 0) const noexcept;
+  /*constexpr*/ size_type find(char c, size_type pos = 0) const noexcept;
+  /*constexpr*/ size_type find(const char* s, size_type pos, size_type n) const;
+  /*constexpr*/ size_type find(const char* s, size_type pos = 0) const;
+  /*constexpr*/ size_type rfind(string_view s, size_type pos = npos) const
+      noexcept;
+  /*constexpr*/ size_type rfind(char c, size_type pos = npos) const noexcept;
+  /*constexpr*/ size_type rfind(const char* s,
+                                size_type pos,
+                                size_type n) const;
+  /*constexpr*/ size_type rfind(const char* s, size_type pos = npos) const;
+  /*constexpr*/ size_type find_first_of(string_view s, size_type pos = 0) const
+      noexcept;
+  /*constexpr*/ size_type find_first_of(char c, size_type pos = 0) const
+      noexcept;
+  /*constexpr*/ size_type find_first_of(const char* s,
+                                        size_type pos,
+                                        size_type n) const;
+  /*constexpr*/ size_type find_first_of(const char* s, size_type pos = 0) const;
+  /*constexpr*/ size_type find_last_of(string_view s,
+                                       size_type pos = npos) const noexcept;
+  /*constexpr*/ size_type find_last_of(char c, size_type pos = npos) const
+      noexcept;
+  /*constexpr*/ size_type find_last_of(const char* s,
+                                       size_type pos,
+                                       size_type n) const;
+  /*constexpr*/ size_type find_last_of(const char* s,
+                                       size_type pos = npos) const;
+
+// TODO(binji): These are defined by C++17 basic_string_view but not
+// implemented here.
+#if 0
+  constexpr size_type find_first_not_of(string_view s, size_type pos = 0) const
+      noexcept;
+  constexpr size_type find_first_not_of(char c, size_type pos = 0) const
+      noexcept;
+  constexpr size_type find_first_not_of(const char* s,
+                                        size_type pos,
+                                        size_type n) const;
+  constexpr size_type find_first_not_of(const char* s, size_type pos = 0) const;
+  constexpr size_type find_last_not_of(string_view s,
+                                       size_type pos = npos) const noexcept;
+  constexpr size_type find_last_not_of(char c, size_type pos = npos) const
+      noexcept;
+  constexpr size_type find_last_not_of(const char* s,
+                                       size_type pos,
+                                       size_type n) const;
+  constexpr size_type find_last_not_of(const char* s,
+                                       size_type pos = npos) const;
+#endif
+
+ private:
+  const char* data_;
+  size_type size_;
+};
+
+// non-member comparison functions
+inline bool operator==(string_view x, string_view y) noexcept {
+  return x.compare(y) == 0;
+}
+
+inline bool operator!=(string_view x, string_view y) noexcept {
+  return x.compare(y) != 0;
+}
+
+inline bool operator<(string_view x, string_view y) noexcept {
+  return x.compare(y) < 0;
+}
+
+inline bool operator>(string_view x, string_view y) noexcept {
+  return x.compare(y) > 0;
+}
+
+inline bool operator<=(string_view x, string_view y) noexcept {
+  return x.compare(y) <= 0;
+}
+
+inline bool operator>=(string_view x, string_view y) noexcept {
+  return x.compare(y) >= 0;
+}
+
+// non-member append.
+inline std::string& operator+=(std::string& x, string_view y) {
+  x.append(y.data(), y.size());
+  return x;
+}
+
+inline std::string operator+(string_view x, string_view y) {
+  std::string s;
+  s.reserve(x.size() + y.size());
+  s.append(x.data(), x.size());
+  s.append(y.data(), y.size());
+  return s;
+}
+
+inline std::string operator+(const std::string& x, string_view y) {
+  return string_view(x) + y;
+}
+
+inline std::string operator+(string_view x, const std::string& y) {
+  return x + string_view(y);
+}
+
+inline std::string operator+(const char* x, string_view y) {
+  return string_view(x) + y;
+}
+
+inline std::string operator+(string_view x, const char* y) {
+  return x + string_view(y);
+}
+
+inline void cat_concatenate(std::string&) {}
+
+template<typename T, typename ...Ts>
+void cat_concatenate(std::string& s, const T& t, const Ts&... args) {
+    s += t;
+    cat_concatenate(s, args...);
+}
+
+inline size_t cat_compute_size() { return 0; }
+
+template<typename T, typename ...Ts>
+size_t cat_compute_size(const T& t, const Ts&... args) {
+    return string_view(t).size() + cat_compute_size(args...);
+}
+
+// Is able to concatenate any combination of string/string_view/char*
+template<typename ...Ts> std::string cat(const Ts&... args) {
+    std::string s;
+    s.reserve(cat_compute_size(args...));
+    cat_concatenate(s, args...);
+    return s;
+}
+
+inline constexpr string_view::string_view() noexcept
+    : data_(nullptr), size_(0) {}
+
+inline string_view::string_view(const std::string& str) noexcept
+    : data_(str.data()), size_(str.size()) {}
+
+inline string_view::string_view(const char* str)
+    : data_(str), size_(traits_type::length(str)) {}
+
+inline constexpr string_view::string_view(const char* str, size_type len)
+    : data_(str), size_(len) {}
+
+inline constexpr string_view::const_iterator string_view::begin() const
+    noexcept {
+  return data_;
+}
+
+inline constexpr string_view::const_iterator string_view::end() const noexcept {
+  return data_ + size_;
+}
+
+inline constexpr string_view::const_iterator string_view::cbegin() const
+    noexcept {
+  return data_;
+}
+
+inline constexpr string_view::const_iterator string_view::cend() const
+    noexcept {
+  return data_ + size_;
+}
+
+inline string_view::const_reverse_iterator string_view::rbegin() const
+    noexcept {
+  return const_reverse_iterator(end());
+}
+
+inline string_view::const_reverse_iterator string_view::rend() const noexcept {
+  return const_reverse_iterator(begin());
+}
+
+inline string_view::const_reverse_iterator string_view::crbegin() const
+    noexcept {
+  return const_reverse_iterator(cend());
+}
+
+inline string_view::const_reverse_iterator string_view::crend() const noexcept {
+  return const_reverse_iterator(cbegin());
+}
+
+constexpr inline string_view::size_type string_view::size() const noexcept {
+  return size_;
+}
+
+constexpr inline string_view::size_type string_view::length() const noexcept {
+  return size_;
+}
+
+constexpr inline bool string_view::empty() const noexcept {
+  return size_ == 0;
+}
+
+constexpr inline string_view::const_reference string_view::operator[](
+    size_type pos) const {
+  return data_[pos];
+}
+
+inline string_view::const_reference string_view::at(size_type pos) const {
+  assert(pos < size_);
+  return data_[pos];
+}
+
+inline string_view::const_reference string_view::front() const {
+  assert(!empty());
+  return *data_;
+}
+
+inline string_view::const_reference string_view::back() const {
+  assert(!empty());
+  return data_[size_ - 1];
+}
+
+constexpr inline string_view::const_pointer string_view::data() const noexcept {
+  return data_;
+}
+
+inline std::ostream& operator<<(std::ostream& os, string_view sv) {
+    os.write(sv.data(), sv.size());
+    return os;
+}
+
+}  // namespace wabt
+
+namespace std {
+
+// hash support
+template <>
+struct hash<::wabt::string_view> {
+  ::wabt::hash_code operator()(const ::wabt::string_view& sv) {
+    return ::wabt::HashRange(sv.begin(), sv.end());
+  }
+};
+
+}  // namespace std
+
+#endif  // WABT_STRING_VIEW_H_