character-value-impl.h

//===-- include/flang/Evaluate/character-value-impl.h -----------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#ifndef FORTRAN_EVALUATE_CHARACTER_VALUE_IMPL_H_
#define FORTRAN_EVALUATE_CHARACTER_VALUE_IMPL_H_
 
#include "flang/Evaluate/common.h"
#include "llvm/Support/ErrorHandling.h"
#include <cstddef>
#include <optional>
#include <string>
#include <utility>
#include <variant>
 
namespace Fortran::evaluate::value {
 
class CharacterValueImpl {
  using Storage =
      std::variant<std::monostate, std::string, std::u16string, std::u32string>;
 
public:
  // rule-of-five
  ~CharacterValueImpl() = default;
  CharacterValueImpl(const CharacterValueImpl &) = default;
  CharacterValueImpl(CharacterValueImpl &&) = default;
  CharacterValueImpl &operator=(const CharacterValueImpl &) = default;
  CharacterValueImpl &operator=(CharacterValueImpl &&) = default;
 
  CharacterValueImpl() = default;
  explicit CharacterValueImpl(int kind, std::string s) {
    WithCharProto(kind, [&](auto c) {
      using CharT = std::decay_t<decltype(c)>;
      using StringT = std::basic_string<CharT>;
      if (std::is_same_v<StringT, std::string>) {
        storage_ = std::move(s);
      } else {
        StringT buf;
        buf.resize(s.length());
        for (auto [i, c] : llvm::enumerate(s)) {
          // Platforms may defined char as either signed or unsigned.
          // Cast to unsigned to avoid platform-dependent widening.
          buf[i] = static_cast<unsigned char>(c);
        }
        storage_ = std::move(buf);
      }
    });
 
    CHECK(this->kind() == kind);
  }
 
  explicit CharacterValueImpl(int kind, std::u16string s)
      : storage_{std::move(s)} {
    CHECK(kind == 2);
    CHECK(this->kind() == kind);
  }
 
  explicit CharacterValueImpl(int kind, std::u32string s)
      : storage_{std::move(s)} {
    CHECK(kind == 4);
    CHECK(this->kind() == kind);
  }

  CharacterValueImpl(int kind, std::size_t n, char32_t c);
 
  static CharacterValueImpl Zero(int kind);
 
  static CharacterValueImpl FromRawBytes(
      int kind, const void *raw, size_t byteSize);
 
  void print(llvm::raw_ostream &os) const;
 
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
  LLVM_DUMP_METHOD void dump() const;
#endif
 
  std::optional<llvm::StringRef> AsStringRef() const;

  std::optional<std::string> AsStdString() const;
  std::optional<std::u16string> AsU16String() const;
  std::optional<std::u32string> AsU32String() const;
 
  std::string ToStdString() const;
 
  bool IsNull() const { return storage_.index() == 0; }
  int kind() const;

  std::size_t charSize() const;

  std::size_t size() const;

  std::size_t length() const { return size(); }

  bool empty() const { return size() == 0; }

  void *data() { return charData(); }
  const void *data() const { return charData(); }
  void *charData();
  const void *charData() const;
 
  // Comparison operators
  Ordering Compare(const CharacterValueImpl &y) const;
  bool operator<(const CharacterValueImpl &y) const;
  bool operator<=(const CharacterValueImpl &y) const { return !(y < *this); }
  bool operator==(const CharacterValueImpl &y) const;
  bool operator!=(const CharacterValueImpl &y) const { return !(*this == y); }
  bool operator>=(const CharacterValueImpl &y) const { return !(*this < y); }
  bool operator>(const CharacterValueImpl &y) const { return y < *this; }

  void assign(int kind, std::size_t n, char32_t c);

  void assign(const char *p, std::size_t n) { storage_ = std::string(p, n); }
  void assign(const char16_t *p, std::size_t n) {
    storage_ = std::u16string(p, n);
  }
  void assign(const char32_t *p, std::size_t n) {
    storage_ = std::u32string(p, n);
  }

  void erase(std::size_t pos);

  void append(std::size_t n, char32_t c);

  CharacterValueImpl &replace(
      std::size_t pos, std::size_t len, const CharacterValueImpl &other);

  CharacterValueImpl substr(std::size_t pos) const;

  CharacterValueImpl substr(std::size_t pos, std::size_t len) const;
 
  CharacterValueImpl ToAscii(int kind) const;

  void reserve(std::size_t n);

  char32_t operator[](std::size_t i) const;

  CharacterValueImpl operator+(const CharacterValueImpl &y) const;

  CharacterValueImpl &operator+=(const CharacterValueImpl &y);

  CharacterValueImpl &operator+=(char32_t c);

  static constexpr std::size_t npos{std::string::npos};
 
  // Find-family methods; return npos when not found.
  std::size_t find(const CharacterValueImpl &pattern) const;
  std::size_t rfind(const CharacterValueImpl &pattern) const;
 
  std::size_t find_first_not_of(char c) const {
    return find_first_not_of(static_cast<char32_t>(c));
  }
  std::size_t find_first_not_of(char16_t c) const {
    return find_first_not_of(static_cast<char32_t>(c));
  }
  std::size_t find_first_not_of(char32_t c) const;
  std::size_t find_last_not_of(char c) const {
    return find_last_not_of(static_cast<char32_t>(c));
  }
  std::size_t find_last_not_of(char16_t c) const {
    return find_last_not_of(static_cast<char32_t>(c));
  }
  std::size_t find_last_not_of(char32_t c) const;
  std::size_t find_first_not_of(const CharacterValueImpl &set) const;
  std::size_t find_last_not_of(const CharacterValueImpl &set) const;
  std::size_t find_first_of(const CharacterValueImpl &set) const;
  std::size_t find_last_of(const CharacterValueImpl &set) const;
 
  void StoreRawBytes(
      void *dst, std::size_t size, bool *changed = nullptr) const;
 
  // Compile-time dispatchers to current/specified kind
 
  template <typename CharT, typename = std::void_t<std::basic_string<CharT>>>
  const std::basic_string<CharT> &GetBasicString() const;
 
  template <typename F>
  auto WithCharProto(F &&f) const
      -> decltype(std::declval<F>()(std::declval<char>())) {
    return WithCharProto(kind(), f);
  }
 
  template <typename F>
  static auto WithCharProto(int kind, F &&f)
      -> decltype(std::declval<F>()(std::declval<char>())) {
    switch (kind) {
    case 1:
      return f(char{});
    case 2:
      return f(char16_t{});
    case 4:
      return f(char32_t{});
    default:
      DIE("unsupported character kind/null state");
    }
  }
 
  template <typename F>
  auto WithBasicString(F &&f) const
      -> decltype(f(std::declval<const std::string &>())) {
    return common::visit(
        common::visitors{
            [](std::monostate) -> decltype(f(
                                   std::declval<const std::string &>())) {
              DIE("operation on uninitialized CharacterValueImpl");
            },
            f,
        },
        storage_);
  }
 
private:
  Storage storage_;
};
 
} // namespace Fortran::evaluate::value
 
namespace llvm {
inline raw_ostream &operator<<(
    raw_ostream &os, const Fortran::evaluate::value::CharacterValueImpl &v) {
  v.print(os);
  return os;
}
} // namespace llvm
 
#endif // FORTRAN_EVALUATE_CHARACTER_VALUE_IMPL_H_