RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-28 04:57:45 +00:00
Code Issues Activity Actions

Unicode: s/codepoint/code_point/g

Browse source 
Unicode calls them "code points" so let's follow their style.
This commit is contained in:
Andreas Kling 2020-08-03 19:06:41 +02:00
parent b139fb9f38
commit ea9ac3155d
45 changed files with 449 additions and 449 deletions
Download patch file Download diff file Expand all files Collapse all files

6
AK/JsonParser.cpp
View file

@ -126,9 +126,9 @@ String JsonParser::consume_quoted_string()
sb.append(consume());
sb.append(consume());
auto codepoint = AK::StringUtils::convert_to_uint_from_hex(sb.to_string());
if (codepoint.has_value()) {
final_sb.append_codepoint(codepoint.value());
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());
} else {
final_sb.append('?');
}

34
AK/StringBuilder.cpp
View file

@ -113,22 +113,22 @@ void StringBuilder::clear()
m_length = 0;
}
void StringBuilder::append_codepoint(u32 codepoint)
void StringBuilder::append_code_points(u32 code_points)
{
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));
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));
} else {
append(0xef);
append(0xbf);
@ -139,8 +139,8 @@ void StringBuilder::append_codepoint(u32 codepoint)
void StringBuilder::append(const Utf32View& utf32_view)
{
for (size_t i = 0; i < utf32_view.length(); ++i) {
auto codepoint = utf32_view.codepoints()[i];
append_codepoint(codepoint);
auto code_points = utf32_view.code_pointss()[i];
append_code_points(code_points);
}
}

2
AK/StringBuilder.h
View file

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

8
AK/Tests/TestUtf8.cpp
View file

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

12
AK/Utf32View.h
View file

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

62
AK/Utf8View.cpp
View file

@ -81,12 +81,12 @@ Utf8View Utf8View::substring_view(int byte_offset, int byte_length) const
static inline bool decode_first_byte(
unsigned char byte,
int& out_codepoint_length_in_bytes,
int& out_code_points_length_in_bytes,
u32& out_value)
{
if ((byte & 128) == 0) {
out_value = byte;
out_codepoint_length_in_bytes = 1;
out_code_points_length_in_bytes = 1;
return true;
}
if ((byte & 64) == 0) {
@ -94,17 +94,17 @@ static inline bool decode_first_byte(
}
if ((byte & 32) == 0) {
out_value = byte & 31;
out_codepoint_length_in_bytes = 2;
out_code_points_length_in_bytes = 2;
return true;
}
if ((byte & 16) == 0) {
out_value = byte & 15;
out_codepoint_length_in_bytes = 3;
out_code_points_length_in_bytes = 3;
return true;
}
if ((byte & 8) == 0) {
out_value = byte & 7;
out_codepoint_length_in_bytes = 4;
out_code_points_length_in_bytes = 4;
return true;
}
@ -115,13 +115,13 @@ bool Utf8View::validate(size_t& valid_bytes) const
{
valid_bytes = 0;
for (auto ptr = begin_ptr(); ptr < end_ptr(); ptr++) {
int codepoint_length_in_bytes;
int code_points_length_in_bytes;
u32 value;
bool first_byte_makes_sense = decode_first_byte(*ptr, codepoint_length_in_bytes, value);
bool first_byte_makes_sense = decode_first_byte(*ptr, code_points_length_in_bytes, value);
if (!first_byte_makes_sense)
return false;
for (int i = 1; i < codepoint_length_in_bytes; i++) {
for (int i = 1; i < code_points_length_in_bytes; i++) {
ptr++;
if (ptr >= end_ptr())
return false;
@ -129,17 +129,17 @@ bool Utf8View::validate(size_t& valid_bytes) const
return false;
}
valid_bytes += codepoint_length_in_bytes;
valid_bytes += code_points_length_in_bytes;
}
return true;
}
size_t Utf8View::length_in_codepoints() const
size_t Utf8View::length_in_code_pointss() const
{
size_t length = 0;
for (auto codepoint : *this) {
(void)codepoint;
for (auto code_points : *this) {
(void)code_points;
++length;
}
return length;
@ -165,54 +165,54 @@ Utf8CodepointIterator& Utf8CodepointIterator::operator++()
{
ASSERT(m_length > 0);
int codepoint_length_in_bytes = 0;
int code_points_length_in_bytes = 0;
u32 value;
bool first_byte_makes_sense = decode_first_byte(*m_ptr, codepoint_length_in_bytes, value);
bool first_byte_makes_sense = decode_first_byte(*m_ptr, code_points_length_in_bytes, value);
ASSERT(first_byte_makes_sense);
(void)value;
ASSERT(codepoint_length_in_bytes <= m_length);
m_ptr += codepoint_length_in_bytes;
m_length -= codepoint_length_in_bytes;
ASSERT(code_points_length_in_bytes <= m_length);
m_ptr += code_points_length_in_bytes;
m_length -= code_points_length_in_bytes;
return *this;
}
int Utf8CodepointIterator::codepoint_length_in_bytes() const
int Utf8CodepointIterator::code_points_length_in_bytes() const
{
ASSERT(m_length > 0);
int codepoint_length_in_bytes = 0;
int code_points_length_in_bytes = 0;
u32 value;
bool first_byte_makes_sense = decode_first_byte(*m_ptr, codepoint_length_in_bytes, value);
bool first_byte_makes_sense = decode_first_byte(*m_ptr, code_points_length_in_bytes, value);
ASSERT(first_byte_makes_sense);
return codepoint_length_in_bytes;
return code_points_length_in_bytes;
}
u32 Utf8CodepointIterator::operator*() const
{
ASSERT(m_length > 0);
u32 codepoint_value_so_far = 0;
int codepoint_length_in_bytes = 0;
u32 code_points_value_so_far = 0;
int code_points_length_in_bytes = 0;
bool first_byte_makes_sense = decode_first_byte(m_ptr[0], codepoint_length_in_bytes, codepoint_value_so_far);
bool first_byte_makes_sense = decode_first_byte(m_ptr[0], code_points_length_in_bytes, code_points_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 (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;
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;
}
ASSERT(codepoint_length_in_bytes <= m_length);
ASSERT(code_points_length_in_bytes <= m_length);
for (int offset = 1; offset < codepoint_length_in_bytes; offset++) {
for (int offset = 1; offset < code_points_length_in_bytes; offset++) {
ASSERT(m_ptr[offset] >> 6 == 2);
codepoint_value_so_far <<= 6;
codepoint_value_so_far |= m_ptr[offset] & 63;
code_points_value_so_far <<= 6;
code_points_value_so_far |= m_ptr[offset] & 63;
}
return codepoint_value_so_far;
return code_points_value_so_far;
}
}

4
AK/Utf8View.h
View file

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