Revert "Unicode: s/codepoint/code_point/g"

This reverts commit ea9ac31.
It replaced "codepoint" with "code_points", not "code_point".

AK/JsonParser.cpp

@@ -126,9 +126,9 @@ String JsonParser::consume_quoted_string()
  sb.append(consume());
  sb.append(consume());
 
- auto code_points = AK::StringUtils::convert_to_uint_from_hex(sb.to_string());
- if (code_points.has_value()) {
- final_sb.append_code_points(code_points.value());
+ auto codepoint = AK::StringUtils::convert_to_uint_from_hex(sb.to_string());
+ if (codepoint.has_value()) {
+ final_sb.append_codepoint(codepoint.value());
  } else {
  final_sb.append('?');
  }

AK/StringBuilder.cpp

@@ -113,22 +113,22 @@ void StringBuilder::clear()
  m_length = 0;
 }
 
-void StringBuilder::append_code_points(u32 code_points)
+void StringBuilder::append_codepoint(u32 codepoint)
 {
- if (code_points <= 0x7f) {
- append((char)code_points);
- } else if (code_points <= 0x07ff) {
- append((char)(((code_points >> 6) & 0x1f) | 0xc0));
- append((char)(((code_points >> 0) & 0x3f) | 0x80));
- } else if (code_points <= 0xffff) {
- append((char)(((code_points >> 12) & 0x0f) | 0xe0));
- append((char)(((code_points >> 6) & 0x3f) | 0x80));
- append((char)(((code_points >> 0) & 0x3f) | 0x80));
- } else if (code_points <= 0x10ffff) {
- append((char)(((code_points >> 18) & 0x07) | 0xf0));
- append((char)(((code_points >> 12) & 0x3f) | 0x80));
- append((char)(((code_points >> 6) & 0x3f) | 0x80));
- append((char)(((code_points >> 0) & 0x3f) | 0x80));
+ if (codepoint <= 0x7f) {
+ append((char)codepoint);
+ } else if (codepoint <= 0x07ff) {
+ append((char)(((codepoint >> 6) & 0x1f) | 0xc0));
+ append((char)(((codepoint >> 0) & 0x3f) | 0x80));
+ } else if (codepoint <= 0xffff) {
+ append((char)(((codepoint >> 12) & 0x0f) | 0xe0));
+ append((char)(((codepoint >> 6) & 0x3f) | 0x80));
+ append((char)(((codepoint >> 0) & 0x3f) | 0x80));
+ } else if (codepoint <= 0x10ffff) {
+ append((char)(((codepoint >> 18) & 0x07) | 0xf0));
+ append((char)(((codepoint >> 12) & 0x3f) | 0x80));
+ append((char)(((codepoint >> 6) & 0x3f) | 0x80));
+ append((char)(((codepoint >> 0) & 0x3f) | 0x80));
  } else {
  append(0xef);
  append(0xbf);
@@ -139,8 +139,8 @@ void StringBuilder::append_code_points(u32 code_points)
 void StringBuilder::append(const Utf32View& utf32_view)
 {
  for (size_t i = 0; i < utf32_view.length(); ++i) {
- auto code_points = utf32_view.code_pointss()[i];
- append_code_points(code_points);
+ auto codepoint = utf32_view.codepoints()[i];
+ append_codepoint(codepoint);
  }
 }
 

AK/StringBuilder.h

@@ -42,7 +42,7 @@ class StringBuilder {
  void append(const StringView&);
  void append(const Utf32View&);
  void append(char);
- void append_code_points(u32);
+ void append_codepoint(u32);
  void append(const char*, size_t);
  void appendf(const char*, ...);
  void appendvf(const char*, va_list);

AK/Tests/TestUtf8.cpp

@@ -37,9 +37,9 @@ TEST_CASE(decode_ascii)
  size_t expected_size = sizeof(expected) / sizeof(expected[0]);
 
  size_t i = 0;
- for (u32 code_points : utf8) {
+ for (u32 codepoint : utf8) {
  ASSERT(i < expected_size);
- EXPECT_EQ(code_points, expected[i]);
+ EXPECT_EQ(codepoint, expected[i]);
  i++;
  }
  EXPECT_EQ(i, expected_size);
@@ -56,9 +56,9 @@ TEST_CASE(decode_utf8)
  size_t expected_size = sizeof(expected) / sizeof(expected[0]);
 
  size_t i = 0;
- for (u32 code_points : utf8) {
+ for (u32 codepoint : utf8) {
  ASSERT(i < expected_size);
- EXPECT_EQ(code_points, expected[i]);
+ EXPECT_EQ(codepoint, expected[i]);
  i++;
  }
  EXPECT_EQ(i, expected_size);

AK/Utf32View.h

@@ -35,14 +35,14 @@ namespace AK {
 class Utf32View {
 public:
  Utf32View() { }
- Utf32View(const u32* code_pointss, size_t length)
- : m_code_pointss(code_pointss)
+ Utf32View(const u32* codepoints, size_t length)
+ : m_codepoints(codepoints)
  , m_length(length)
  {
- ASSERT(code_pointss || length == 0);
+ ASSERT(codepoints || length == 0);
  }
 
- const u32* code_pointss() const { return m_code_pointss; }
+ const u32* codepoints() const { return m_codepoints; }
  bool is_empty() const { return m_length == 0; }
  size_t length() const { return m_length; }
 
@@ -53,11 +53,11 @@ class Utf32View {
  ASSERT(offset < m_length);
  ASSERT(!Checked<size_t>::addition_would_overflow(offset, length));
  ASSERT((offset + length) <= m_length);
- return Utf32View(m_code_pointss + offset, length);
+ return Utf32View(m_codepoints + offset, length);
  }
 
 private:
- const u32* m_code_pointss { nullptr };
+ const u32* m_codepoints { nullptr };
  size_t m_length { 0 };
 };
 

AK/Utf8View.cpp

@@ -81,30 +81,30 @@ Utf8View Utf8View::substring_view(int byte_offset, int byte_length) const
 
 static inline bool decode_first_byte(
  unsigned char byte,
- int& out_code_points_length_in_bytes,
+ int& out_codepoint_length_in_bytes,
  u32& out_value)
 {
  if ((byte & 128) == 0) {
  out_value = byte;
- out_code_points_length_in_bytes = 1;
+ out_codepoint_length_in_bytes = 1;
  return true;
  }
  if ((byte & 64) == 0) {
  return false;
  }
  if ((byte & 32) == 0) {
  out_value = byte & 31;
- out_code_points_length_in_bytes = 2;
+ out_codepoint_length_in_bytes = 2;
  return true;
  }
  if ((byte & 16) == 0) {
  out_value = byte & 15;
- out_code_points_length_in_bytes = 3;
+ out_codepoint_length_in_bytes = 3;
  return true;
  }
  if ((byte & 8) == 0) {
  out_value = byte & 7;
- out_code_points_length_in_bytes = 4;
+ out_codepoint_length_in_bytes = 4;
  return true;
  }
 
@@ -115,31 +115,31 @@ bool Utf8View::validate(size_t& valid_bytes) const
 {
  valid_bytes = 0;
  for (auto ptr = begin_ptr(); ptr < end_ptr(); ptr++) {
- int code_points_length_in_bytes;
+ int codepoint_length_in_bytes;
  u32 value;
- bool first_byte_makes_sense = decode_first_byte(*ptr, code_points_length_in_bytes, value);
+ bool first_byte_makes_sense = decode_first_byte(*ptr, codepoint_length_in_bytes, value);
  if (!first_byte_makes_sense)
  return false;
 
- for (int i = 1; i < code_points_length_in_bytes; i++) {
+ for (int i = 1; i < codepoint_length_in_bytes; i++) {
  ptr++;
  if (ptr >= end_ptr())
  return false;
  if (*ptr >> 6 != 2)
  return false;
  }
 
- valid_bytes += code_points_length_in_bytes;
+ valid_bytes += codepoint_length_in_bytes;
  }
 
  return true;
 }
 
-size_t Utf8View::length_in_code_pointss() const
+size_t Utf8View::length_in_codepoints() const
 {
  size_t length = 0;
- for (auto code_points : *this) {
- (void)code_points;
+ for (auto codepoint : *this) {
+ (void)codepoint;
  ++length;
  }
  return length;
@@ -165,54 +165,54 @@ Utf8CodepointIterator& Utf8CodepointIterator::operator++()
 {
  ASSERT(m_length > 0);
 
- int code_points_length_in_bytes = 0;
+ int codepoint_length_in_bytes = 0;
  u32 value;
- bool first_byte_makes_sense = decode_first_byte(*m_ptr, code_points_length_in_bytes, value);
+ bool first_byte_makes_sense = decode_first_byte(*m_ptr, codepoint_length_in_bytes, value);
 
  ASSERT(first_byte_makes_sense);
  (void)value;
 
- ASSERT(code_points_length_in_bytes <= m_length);
- m_ptr += code_points_length_in_bytes;
- m_length -= code_points_length_in_bytes;
+ ASSERT(codepoint_length_in_bytes <= m_length);
+ m_ptr += codepoint_length_in_bytes;
+ m_length -= codepoint_length_in_bytes;
 
  return *this;
 }
 
-int Utf8CodepointIterator::code_points_length_in_bytes() const
+int Utf8CodepointIterator::codepoint_length_in_bytes() const
 {
  ASSERT(m_length > 0);
- int code_points_length_in_bytes = 0;
+ int codepoint_length_in_bytes = 0;
  u32 value;
- bool first_byte_makes_sense = decode_first_byte(*m_ptr, code_points_length_in_bytes, value);
+ bool first_byte_makes_sense = decode_first_byte(*m_ptr, codepoint_length_in_bytes, value);
  ASSERT(first_byte_makes_sense);
- return code_points_length_in_bytes;
+ return codepoint_length_in_bytes;
 }
 
 u32 Utf8CodepointIterator::operator*() const
 {
  ASSERT(m_length > 0);
 
- u32 code_points_value_so_far = 0;
- int code_points_length_in_bytes = 0;
+ u32 codepoint_value_so_far = 0;
+ int codepoint_length_in_bytes = 0;
 
- bool first_byte_makes_sense = decode_first_byte(m_ptr[0], code_points_length_in_bytes, code_points_value_so_far);
+ bool first_byte_makes_sense = decode_first_byte(m_ptr[0], codepoint_length_in_bytes, codepoint_value_so_far);
  if (!first_byte_makes_sense) {
  dbg() << "First byte doesn't make sense, bytes: " << StringView((const char*)m_ptr, m_length);
  }
  ASSERT(first_byte_makes_sense);
- if (code_points_length_in_bytes > m_length) {
- dbg() << "Not enough bytes (need " << code_points_length_in_bytes << ", have " << m_length << "), first byte is: " << m_ptr[0] << " " << (const char*)m_ptr;
+ if (codepoint_length_in_bytes > m_length) {
+ dbg() << "Not enough bytes (need " << codepoint_length_in_bytes << ", have " << m_length << "), first byte is: " << m_ptr[0] << " " << (const char*)m_ptr;
  }
- ASSERT(code_points_length_in_bytes <= m_length);
+ ASSERT(codepoint_length_in_bytes <= m_length);
 
- for (int offset = 1; offset < code_points_length_in_bytes; offset++) {
+ for (int offset = 1; offset < codepoint_length_in_bytes; offset++) {
  ASSERT(m_ptr[offset] >> 6 == 2);
- code_points_value_so_far <<= 6;
- code_points_value_so_far |= m_ptr[offset] & 63;
+ codepoint_value_so_far <<= 6;
+ codepoint_value_so_far |= m_ptr[offset] & 63;
  }
 
- return code_points_value_so_far;
+ return codepoint_value_so_far;
 }
 
 }

AK/Utf8View.h

@@ -45,7 +45,7 @@ class Utf8CodepointIterator {
  Utf8CodepointIterator& operator++();
  u32 operator*() const;
 
- int code_points_length_in_bytes() const;
+ int codepoint_length_in_bytes() const;
  bool done() const { return !m_length; }
 
 private:
@@ -80,7 +80,7 @@ class Utf8View {
  return validate(valid_bytes);
  }
 
- size_t length_in_code_pointss() const;
+ size_t length_in_codepoints() const;
 
 private:
  const unsigned char* begin_ptr() const;

Applications/KeyboardMapper/KeyboardMapperWidget.cpp

@@ -267,7 +267,7 @@ void KeyboardMapperWidget::set_current_map(const String current_map)
  continue;
 
  AK::StringBuilder sb;
- sb.append_code_points(map[index]);
+ sb.append_codepoint(map[index]);
 
  m_keys.at(k)->set_text(sb.to_string());
  }

Kernel/TTY/VirtualConsole.cpp

@@ -287,10 +287,10 @@ void VirtualConsole::flush_dirty_lines()
  if (!line.is_dirty() && !m_terminal.m_need_full_flush)
  continue;
  for (size_t column = 0; column < line.length(); ++column) {
- u32 code_points = line.code_points(column);
+ u32 codepoint = line.codepoint(column);
  auto attribute = line.attributes()[column];
  u16 vga_index = (visual_row * 160) + (column * 2);
- m_current_vga_window[vga_index] = code_points < 128 ? code_points : '?';
+ m_current_vga_window[vga_index] = codepoint < 128 ? codepoint : '?';
  m_current_vga_window[vga_index + 1] = attribute_to_vga(attribute);
  }
  line.set_dirty(false);

Libraries/LibGUI/EmojiInputDialog.cpp

@@ -37,9 +37,9 @@
 
 namespace GUI {
 
-static Vector<u32> supported_emoji_code_pointss()
+static Vector<u32> supported_emoji_codepoints()
 {
- Vector<u32> code_pointss;
+ Vector<u32> codepoints;
  Core::DirIterator dt("/res/emoji", Core::DirIterator::SkipDots);
  while (dt.has_next()) {
  auto filename = dt.next_path();
@@ -49,10 +49,10 @@ static Vector<u32> supported_emoji_code_pointss()
  auto basename = lexical_path.basename();
  if (!basename.starts_with("U+"))
  continue;
- u32 code_points = strtoul(basename.characters() + 2, nullptr, 16);
- code_pointss.append(code_points);
+ u32 codepoint = strtoul(basename.characters() + 2, nullptr, 16);
+ codepoints.append(codepoint);
  }
- return code_pointss;
+ return codepoints;
 }
 
 EmojiInputDialog::EmojiInputDialog(Window* parent_window)
@@ -67,20 +67,20 @@ EmojiInputDialog::EmojiInputDialog(Window* parent_window)
  auto& main_layout = main_widget.set_layout<VerticalBoxLayout>();
  main_layout.set_spacing(0);
 
- auto code_pointss = supported_emoji_code_pointss();
+ auto codepoints = supported_emoji_codepoints();
 
  size_t index = 0;
  size_t columns = 6;
- size_t rows = ceil_div(code_pointss.size(), columns);
+ size_t rows = ceil_div(codepoints.size(), columns);
 
- for (size_t row = 0; row < rows && index < code_pointss.size(); ++row) {
+ for (size_t row = 0; row < rows && index < codepoints.size(); ++row) {
  auto& horizontal_container = main_widget.add<Widget>();
  auto& horizontal_layout = horizontal_container.set_layout<HorizontalBoxLayout>();
  horizontal_layout.set_spacing(0);
  for (size_t column = 0; column < columns; ++column) {
- if (index < code_pointss.size()) {
+ if (index < codepoints.size()) {
  StringBuilder builder;
- builder.append(Utf32View(&code_pointss[index++], 1));
+ builder.append(Utf32View(&codepoints[index++], 1));
  auto emoji_text = builder.to_string();
  auto& button = horizontal_container.add<Button>(emoji_text);
  button.set_button_style(Gfx::ButtonStyle::CoolBar);

Libraries/LibGUI/Event.h

@@ -298,7 +298,7 @@ class KeyEvent final : public Event {
  String text() const
  {
  StringBuilder sb;
- sb.append_code_points(m_code_point);
+ sb.append_codepoint(m_code_point);
  return sb.to_string();
  }
  u32 scancode() const { return m_scancode; }