utf_codecs.h

// Copyright 2024 The Pigweed Authors
//
// 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
//
//     https://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.
 
#pragma once
 
#include <array>
#include <cstdint>
#include <string_view>
 
#include "pw_result/result.h"
#include "pw_status/status.h"
#include "pw_string/string_builder.h"
 
namespace pw {
 
namespace utf {
 
 
constexpr inline bool IsValidCodepoint(uint32_t code_point) {
  return code_point < 0xD800u ||
         (code_point >= 0xE000u && code_point <= 0x10FFFFu);
}
 
constexpr inline bool IsValidCharacter(uint32_t code_point) {
  return code_point < 0xD800u ||
         (code_point >= 0xE000u && code_point < 0xFDD0u) ||
         (code_point > 0xFDEFu && code_point <= 0x10FFFFu &&
          (code_point & 0xFFFEu) != 0xFFFEu);
}
 
class CodePointAndSize final {
 public:
  explicit constexpr CodePointAndSize(uint32_t code_point, size_t size)
      : code_point_((static_cast<uint32_t>(size) << kSizeShift) | code_point) {}
 
  constexpr CodePointAndSize(const CodePointAndSize&) = default;
  constexpr CodePointAndSize& operator=(const CodePointAndSize&) = default;
  constexpr CodePointAndSize(CodePointAndSize&&) = default;
  constexpr CodePointAndSize& operator=(CodePointAndSize&&) = default;
 
  constexpr uint32_t code_point() const { return code_point_ & kCodePointMask; }
 
  constexpr size_t size() const {
    return (code_point_ & kSizeMask) >> kSizeShift;
  }
 
 private:
  static constexpr size_t kSizeBits = 4;
  static constexpr uint32_t kCodePointMask = ~0U >> kSizeBits;
  static constexpr uint32_t kSizeMask = ~kCodePointMask;
  static constexpr size_t kSizeShift = sizeof(uint32_t) * 8 - kSizeBits;
  uint32_t code_point_;
};
 
 
}  // namespace utf
 
namespace utf8 {
 
 
constexpr pw::Result<utf::CodePointAndSize> ReadCodePoint(
    std::string_view str) {
  if (str.empty()) {
    return pw::Status::InvalidArgument();
  }
 
  const uint8_t leading_byte = static_cast<uint8_t>(str.front());
  size_t byte_count = 0;
  uint32_t code_point = 0xFFFFFFFFu;
 
  if (leading_byte <= 0x7F) {
    byte_count = 1;
    // b0xxx xxxx
    code_point = leading_byte;
  } else if (leading_byte <= 0xDF) {
    byte_count = 2;
    if (str.size() < byte_count) {
      return pw::Status::InvalidArgument();
    }
    // b110x xxxx 10xx xxxx
    if ((str[1] & 0xC0) != 0x80) {
      // Invalid continuation
      return pw::Status::InvalidArgument();
    }
    code_point = (static_cast<uint32_t>(str[0] & 0x1F) << 6) +
                 static_cast<uint32_t>(str[1] & 0x3F);
  } else if (leading_byte <= 0xEF) {
    byte_count = 3;
    if (str.size() < byte_count) {
      return pw::Status::InvalidArgument();
    }
    if ((str[1] & 0xC0) != 0x80 || (str[2] & 0xC0) != 0x80) {
      // Invalid continuation
      return pw::Status::InvalidArgument();
    }
    // b1110 xxxx 10xx xxxx 10xx xxxx
    code_point = (static_cast<uint32_t>(str[0] & 0x0F) << 12) +
                 (static_cast<uint32_t>(str[1] & 0x3F) << 6) +
                 static_cast<uint32_t>(str[2] & 0x3F);
  } else if (leading_byte <= 0xF7) {
    byte_count = 4;
    if (str.size() < byte_count) {
      return pw::Status::InvalidArgument();
    }
    if ((str[1] & 0xC0) != 0x80 || (str[2] & 0xC0) != 0x80 ||
        (str[3] & 0xC0) != 0x80) {
      // Invalid continuation
      return pw::Status::InvalidArgument();
    }
    // b1111 0xxx 10xx xxxx 10xx xxxx 10xx xxxx
    code_point = (static_cast<uint32_t>(str[0] & 0x07) << 18) +
                 (static_cast<uint32_t>(str[1] & 0x3F) << 12) +
                 (static_cast<uint32_t>(str[2] & 0x3F) << 6) +
                 static_cast<uint32_t>(str[3] & 0x3F);
  } else {
    return pw::Status::InvalidArgument();
  }
 
  // Validate the decoded value.
  if (utf::IsValidCodepoint(code_point)) {
    return utf::CodePointAndSize(code_point, byte_count);
  }
 
  return pw::Status::OutOfRange();
}
 
constexpr bool IsStringValid(std::string_view str) {
  while (!str.empty()) {
    auto rslt = utf8::ReadCodePoint(str);
    if (!rslt.ok() || !utf::IsValidCharacter(rslt->code_point())) {
      return false;
    }
    str = str.substr(rslt->size());
  }
  return true;
}
 
class EncodedCodePoint {
 public:
  constexpr EncodedCodePoint(uint32_t size, std::array<char, 4> data)
      : size_(size), data_(std::move(data)) {}
  constexpr EncodedCodePoint(EncodedCodePoint&& encoded) = default;
  constexpr std::string_view as_view() const { return {data_.data(), size_}; }
 
 private:
  uint32_t size_;
  std::array<char, 4> data_;
};
 
constexpr Result<EncodedCodePoint> EncodeCodePoint(uint32_t code_point) {
  if (code_point <= 0x7F) {
    return EncodedCodePoint{1, {static_cast<char>(code_point)}};
  }
  if (code_point <= 0x7FF) {
    return EncodedCodePoint{2,
                            {static_cast<char>(0xC0 | (code_point >> 6)),
                             static_cast<char>(0x80 | (code_point & 0x3F))}};
  }
  if (code_point <= 0xFFFF) {
    return EncodedCodePoint{
        3,
        {static_cast<char>(0xE0 | (code_point >> 12)),
         static_cast<char>(0x80 | ((code_point >> 6) & 0x3F)),
         static_cast<char>(0x80 | (code_point & 0x3F))}};
  }
  if (code_point <= 0x10FFFF) {
    return EncodedCodePoint{
        4,
        {static_cast<char>(0xF0 | (code_point >> 18)),
         static_cast<char>(0x80 | ((code_point >> 12) & 0x3F)),
         static_cast<char>(0x80 | ((code_point >> 6) & 0x3F)),
         static_cast<char>(0x80 | (code_point & 0x3F))}};
  }
 
  return pw::Status::OutOfRange();
}
 
Status WriteCodePoint(uint32_t code_point, pw::StringBuilder& output);
 
 
}  // namespace utf8
 
}  // namespace pw