beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-22 07:30:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

AK: Use size_t for the length of strings

Browse source 
Using int was a mistake. This patch changes String, StringImpl,
StringView and StringBuilder to use size_t instead of int for lengths.
Obviously a lot of code needs to change as a result of this.
This commit is contained in:
Andreas Kling 2019-12-09 17:45:40 +01:00
parent 1726c17d0d
commit 6f4c380d95
Notes: sideshowbarker 2024-07-19 10:54:44 +09:00 
Author: https://github.com/awesomekling
Commit: https://github.com/SerenityOS/serenity/commit/6f4c380d954
54 changed files with 387 additions and 377 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
AK/BufferStream.h
View file

@ -148,6 +148,12 @@ public:
m_buffer[m_offset++] = (u8)(value >> 24); m_buffer[m_offset++] = (u8)(value >> 24);
return *this; return *this;
} }
BufferStream& operator<<(size_t value)
{
return *this << (u32)value;
}
BufferStream& operator>>(u32& value) BufferStream& operator>>(u32& value)
{ {
if (m_offset + sizeof(value) > unsigned(m_buffer.size())) { if (m_offset + sizeof(value) > unsigned(m_buffer.size())) {
@ -200,7 +206,7 @@ public:
BufferStream& operator<<(const StringView& value) BufferStream& operator<<(const StringView& value)
{ {
for (ssize_t i = 0; i < value.length(); ++i) for (size_t i = 0; i < value.length(); ++i)
m_buffer[m_offset++] = value[i]; m_buffer[m_offset++] = value[i];
return *this; return *this;
} }

4
AK/JsonParser.cpp
View file

@ -47,7 +47,7 @@ String JsonParser::consume_quoted_string()
Vector<char, 1024> buffer; Vector<char, 1024> buffer;
for (;;) { for (;;) {
int peek_index = m_index; size_t peek_index = m_index;
char ch = 0; char ch = 0;
for (;;) { for (;;) {
if (peek_index == m_input.length()) if (peek_index == m_input.length())
@ -104,7 +104,7 @@ String JsonParser::consume_quoted_string()
return String::empty(); return String::empty();
auto& last_string_starting_with_character = m_last_string_starting_with_character[(int)buffer.first()]; auto& last_string_starting_with_character = m_last_string_starting_with_character[(int)buffer.first()];
if (last_string_starting_with_character.length() == buffer.size()) { if (last_string_starting_with_character.length() == (size_t)buffer.size()) {
if (!memcmp(last_string_starting_with_character.characters(), buffer.data(), buffer.size())) if (!memcmp(last_string_starting_with_character.characters(), buffer.data(), buffer.size()))
return last_string_starting_with_character; return last_string_starting_with_character;
} }

2
AK/JsonParser.h
View file

@ -36,7 +36,7 @@ private:
void consume_while(C); void consume_while(C);
StringView m_input; StringView m_input;
int m_index { 0 }; size_t m_index { 0 };
String m_last_string_starting_with_character[256]; String m_last_string_starting_with_character[256];
}; };

28
AK/String.cpp
View file

@ -76,7 +76,7 @@ String String::isolated_copy() const
return String(move(*impl)); return String(move(*impl));
} }
String String::substring(int start, int length) const String String::substring(size_t start, size_t length) const
{ {
if (!length) if (!length)
return {}; return {};
@ -86,7 +86,7 @@ String String::substring(int start, int length) const
return { characters() + start, length }; return { characters() + start, length };
} }
StringView String::substring_view(int start, int length) const StringView String::substring_view(size_t start, size_t length) const
{ {
if (!length) if (!length)
return {}; return {};
@ -101,23 +101,23 @@ Vector<String> String::split(const char separator) const
return split_limit(separator, 0); return split_limit(separator, 0);
} }
Vector<String> String::split_limit(const char separator, int limit) const Vector<String> String::split_limit(const char separator, size_t limit) const
{ {
if (is_empty()) if (is_empty())
return {}; return {};
Vector<String> v; Vector<String> v;
int substart = 0; size_t substart = 0;
for (int i = 0; i < length() && (v.size() + 1) != limit; ++i) { for (size_t i = 0; i < length() && ((size_t)v.size() + 1) != limit; ++i) {
char ch = characters()[i]; char ch = characters()[i];
if (ch == separator) { if (ch == separator) {
int sublen = i - substart; size_t sublen = i - substart;
if (sublen != 0) if (sublen != 0)
v.append(substring(substart, sublen)); v.append(substring(substart, sublen));
substart = i + 1; substart = i + 1;
} }
} }
int taillen = length() - substart; size_t taillen = length() - substart;
if (taillen != 0) if (taillen != 0)
v.append(substring(substart, taillen)); v.append(substring(substart, taillen));
if (characters()[length() - 1] == separator) if (characters()[length() - 1] == separator)
@ -131,17 +131,17 @@ Vector<StringView> String::split_view(const char separator, bool keep_empty) con
return {}; return {};
Vector<StringView> v; Vector<StringView> v;
int substart = 0; size_t substart = 0;
for (int i = 0; i < length(); ++i) { for (size_t i = 0; i < length(); ++i) {
char ch = characters()[i]; char ch = characters()[i];
if (ch == separator) { if (ch == separator) {
int sublen = i - substart; size_t sublen = i - substart;
if (sublen != 0 || keep_empty) if (sublen != 0 || keep_empty)
v.append(substring_view(substart, sublen)); v.append(substring_view(substart, sublen));
substart = i + 1; substart = i + 1;
} }
} }
int taillen = length() - substart; size_t taillen = length() - substart;
if (taillen != 0 || keep_empty) if (taillen != 0 || keep_empty)
v.append(substring_view(substart, taillen)); v.append(substring_view(substart, taillen));
if (characters()[length() - 1] == separator && keep_empty) if (characters()[length() - 1] == separator && keep_empty)
@ -160,7 +160,7 @@ int String::to_int(bool& ok) const
{ {
bool negative = false; bool negative = false;
int value = 0; int value = 0;
int i = 0; size_t i = 0;
if (is_empty()) { if (is_empty()) {
ok = false; ok = false;
@ -187,7 +187,7 @@ int String::to_int(bool& ok) const
unsigned String::to_uint(bool& ok) const unsigned String::to_uint(bool& ok) const
{ {
unsigned value = 0; unsigned value = 0;
for (int i = 0; i < length(); ++i) { for (size_t i = 0; i < length(); ++i) {
if (characters()[i] < '0' || characters()[i] > '9') { if (characters()[i] < '0' || characters()[i] > '9') {
ok = false; ok = false;
return 0; return 0;
@ -250,7 +250,7 @@ bool String::ends_with(const StringView& str) const
return !memcmp(characters() + (length() - str.length()), str.characters_without_null_termination(), str.length()); return !memcmp(characters() + (length() - str.length()), str.characters_without_null_termination(), str.length());
} }
String String::repeated(char ch, int count) String String::repeated(char ch, size_t count)
{ {
if (!count) if (!count)
return empty(); return empty();

14
AK/String.h
View file

@ -59,7 +59,7 @@ public:
{ {
} }
String(const char* cstring, int length, ShouldChomp shouldChomp = NoChomp) String(const char* cstring, size_t length, ShouldChomp shouldChomp = NoChomp)
: m_impl(StringImpl::create(cstring, length, shouldChomp)) : m_impl(StringImpl::create(cstring, length, shouldChomp))
{ {
} }
@ -89,7 +89,7 @@ public:
CaseSensitive, CaseSensitive,
}; };
static String repeated(char, int count); static String repeated(char, size_t count);
bool matches(const StringView& pattern, CaseSensitivity = CaseSensitivity::CaseInsensitive) const; bool matches(const StringView& pattern, CaseSensitivity = CaseSensitivity::CaseInsensitive) const;
// FIXME: These should be shared between String and StringView somehow! // FIXME: These should be shared between String and StringView somehow!
@ -112,18 +112,18 @@ public:
bool contains(const String&) const; bool contains(const String&) const;
Vector<String> split_limit(char separator, int limit) const; Vector<String> split_limit(char separator, size_t limit) const;
Vector<String> split(char separator) const; Vector<String> split(char separator) const;
String substring(int start, int length) const; String substring(size_t start, size_t length) const;
Vector<StringView> split_view(char separator, bool keep_empty = false) const; Vector<StringView> split_view(char separator, bool keep_empty = false) const;
StringView substring_view(int start, int length) const; StringView substring_view(size_t start, size_t length) const;
bool is_null() const { return !m_impl; } bool is_null() const { return !m_impl; }
bool is_empty() const { return length() == 0; } bool is_empty() const { return length() == 0; }
int length() const { return m_impl ? m_impl->length() : 0; } size_t length() const { return m_impl ? m_impl->length() : 0; }
const char* characters() const { return m_impl ? m_impl->characters() : nullptr; } const char* characters() const { return m_impl ? m_impl->characters() : nullptr; }
char operator[](int i) const char operator[](size_t i) const
{ {
ASSERT(m_impl); ASSERT(m_impl);
return (*m_impl)[i]; return (*m_impl)[i];

12
AK/StringBuilder.cpp
View file

@ -5,15 +5,15 @@
namespace AK { namespace AK {
inline void StringBuilder::will_append(int size) inline void StringBuilder::will_append(size_t size)
{ {
if ((m_length + size) > m_buffer.size()) if ((m_length + size) > (size_t)m_buffer.size())
m_buffer.grow(max((int)16, m_buffer.size() * 2 + size)); m_buffer.grow(max((size_t)16, (size_t)m_buffer.size() * 2 + size));
} }
StringBuilder::StringBuilder(int initial_capacity) StringBuilder::StringBuilder(size_t initial_capacity)
{ {
m_buffer.grow(initial_capacity); m_buffer.grow((int)initial_capacity);
} }
void StringBuilder::append(const StringView& str) void StringBuilder::append(const StringView& str)
@ -25,7 +25,7 @@ void StringBuilder::append(const StringView& str)
m_length += str.length(); m_length += str.length();
} }
void StringBuilder::append(const char* characters, int length) void StringBuilder::append(const char* characters, size_t length)
{ {
if (!length) if (!length)
return; return;

12
AK/StringBuilder.h
View file

@ -10,12 +10,12 @@ class StringBuilder {
public: public:
using OutputType = String; using OutputType = String;
explicit StringBuilder(int initial_capacity = 16); explicit StringBuilder(size_t initial_capacity = 16);
~StringBuilder() {} ~StringBuilder() {}
void append(const StringView&); void append(const StringView&);
void append(char); void append(char);
void append(const char*, int); void append(const char*, size_t);
void appendf(const char*, ...); void appendf(const char*, ...);
void appendvf(const char*, va_list); void appendvf(const char*, va_list);
@ -27,14 +27,14 @@ public:
StringView string_view() const; StringView string_view() const;
void clear(); void clear();
int length() const { return m_length; } size_t length() const { return m_length; }
void trim(int count) { m_length -= count; } void trim(size_t count) { m_length -= count; }
private: private:
void will_append(int); void will_append(size_t);
ByteBuffer m_buffer; ByteBuffer m_buffer;
int m_length { 0 }; size_t m_length { 0 };
}; };
} }

18
AK/StringImpl.cpp
View file

@ -17,7 +17,7 @@ void dump_all_stringimpls()
{ {
unsigned i = 0; unsigned i = 0;
for (auto& it : *g_all_live_stringimpls) { for (auto& it : *g_all_live_stringimpls) {
dbgprintf("%u: \"%s\"\n", i, (*it).characters()); dbgprsize_tf("%u: \"%s\"\n", i, (*it).characters());
++i; ++i;
} }
} }
@ -36,7 +36,7 @@ StringImpl& StringImpl::the_empty_stringimpl()
return *s_the_empty_stringimpl; return *s_the_empty_stringimpl;
} }
StringImpl::StringImpl(ConstructWithInlineBufferTag, int length) StringImpl::StringImpl(ConstructWithInlineBufferTag, size_t length)
: m_length(length) : m_length(length)
{ {
#ifdef DEBUG_STRINGIMPL #ifdef DEBUG_STRINGIMPL
@ -55,12 +55,12 @@ StringImpl::~StringImpl()
#endif #endif
} }
static inline int allocation_size_for_stringimpl(int length) static inline size_t allocation_size_for_stringimpl(size_t length)
{ {
return sizeof(StringImpl) + (sizeof(char) * length) + sizeof(char); return sizeof(StringImpl) + (sizeof(char) * length) + sizeof(char);
} }
NonnullRefPtr<StringImpl> StringImpl::create_uninitialized(int length, char*& buffer) NonnullRefPtr<StringImpl> StringImpl::create_uninitialized(size_t length, char*& buffer)
{ {
ASSERT(length); ASSERT(length);
void* slot = kmalloc(allocation_size_for_stringimpl(length)); void* slot = kmalloc(allocation_size_for_stringimpl(length));
@ -71,7 +71,7 @@ NonnullRefPtr<StringImpl> StringImpl::create_uninitialized(int length, char*& bu
return new_stringimpl; return new_stringimpl;
} }
RefPtr<StringImpl> StringImpl::create(const char* cstring, int length, ShouldChomp should_chomp) RefPtr<StringImpl> StringImpl::create(const char* cstring, size_t length, ShouldChomp should_chomp)
{ {
if (!cstring) if (!cstring)
return nullptr; return nullptr;
@ -133,7 +133,7 @@ static inline char to_ascii_uppercase(char c)
NonnullRefPtr<StringImpl> StringImpl::to_lowercase() const NonnullRefPtr<StringImpl> StringImpl::to_lowercase() const
{ {
for (int i = 0; i < m_length; ++i) { for (size_t i = 0; i < m_length; ++i) {
if (!is_ascii_lowercase(characters()[i])) if (!is_ascii_lowercase(characters()[i]))
goto slow_path; goto slow_path;
} }
@ -142,14 +142,14 @@ NonnullRefPtr<StringImpl> StringImpl::to_lowercase() const
slow_path: slow_path:
char* buffer; char* buffer;
auto lowercased = create_uninitialized(m_length, buffer); auto lowercased = create_uninitialized(m_length, buffer);
for (int i = 0; i < m_length; ++i) for (size_t i = 0; i < m_length; ++i)
buffer[i] = to_ascii_lowercase(characters()[i]); buffer[i] = to_ascii_lowercase(characters()[i]);
return lowercased; return lowercased;
} }
NonnullRefPtr<StringImpl> StringImpl::to_uppercase() const NonnullRefPtr<StringImpl> StringImpl::to_uppercase() const
{ {
for (int i = 0; i < m_length; ++i) { for (size_t i = 0; i < m_length; ++i) {
if (!is_ascii_uppercase(characters()[i])) if (!is_ascii_uppercase(characters()[i]))
goto slow_path; goto slow_path;
} }
@ -158,7 +158,7 @@ NonnullRefPtr<StringImpl> StringImpl::to_uppercase() const
slow_path: slow_path:
char* buffer; char* buffer;
auto uppercased = create_uninitialized(m_length, buffer); auto uppercased = create_uninitialized(m_length, buffer);
for (int i = 0; i < m_length; ++i) for (size_t i = 0; i < m_length; ++i)
buffer[i] = to_ascii_uppercase(characters()[i]); buffer[i] = to_ascii_uppercase(characters()[i]);
return uppercased; return uppercased;
} }

18
AK/StringImpl.h
View file

@ -14,9 +14,9 @@ enum ShouldChomp {
class StringImpl : public RefCounted<StringImpl> { class StringImpl : public RefCounted<StringImpl> {
public: public:
static NonnullRefPtr<StringImpl> create_uninitialized(int length, char*& buffer); static NonnullRefPtr<StringImpl> create_uninitialized(size_t length, char*& buffer);
static RefPtr<StringImpl> create(const char* cstring, ShouldChomp = NoChomp); static RefPtr<StringImpl> create(const char* cstring, ShouldChomp = NoChomp);
static RefPtr<StringImpl> create(const char* cstring, int length, ShouldChomp = NoChomp); static RefPtr<StringImpl> create(const char* cstring, size_t length, ShouldChomp = NoChomp);
NonnullRefPtr<StringImpl> to_lowercase() const; NonnullRefPtr<StringImpl> to_lowercase() const;
NonnullRefPtr<StringImpl> to_uppercase() const; NonnullRefPtr<StringImpl> to_uppercase() const;
@ -29,11 +29,11 @@ public:
~StringImpl(); ~StringImpl();
int length() const { return m_length; } size_t length() const { return m_length; }
const char* characters() const { return &m_inline_buffer[0]; } const char* characters() const { return &m_inline_buffer[0]; }
char operator[](int i) const char operator[](size_t i) const
{ {
ASSERT(i >= 0 && i < m_length); ASSERT(i < m_length);
return characters()[i]; return characters()[i];
} }
@ -56,20 +56,20 @@ private:
enum ConstructWithInlineBufferTag { enum ConstructWithInlineBufferTag {
ConstructWithInlineBuffer ConstructWithInlineBuffer
}; };
StringImpl(ConstructWithInlineBufferTag, int length); StringImpl(ConstructWithInlineBufferTag, size_t length);
void compute_hash() const; void compute_hash() const;
int m_length { 0 }; size_t m_length { 0 };
mutable unsigned m_hash { 0 }; mutable unsigned m_hash { 0 };
mutable bool m_has_hash { false }; mutable bool m_has_hash { false };
char m_inline_buffer[0]; char m_inline_buffer[0];
}; };
inline constexpr u32 string_hash(const char* characters, int length) inline constexpr u32 string_hash(const char* characters, size_t length)
{ {
u32 hash = 0; u32 hash = 0;
for (int i = 0; i < length; ++i) { for (size_t i = 0; i < length; ++i) {
hash += (u32)characters[i]; hash += (u32)characters[i];
hash += (hash << 10); hash += (hash << 10);
hash ^= (hash >> 6); hash ^= (hash >> 6);

28
AK/StringView.cpp
View file

@ -12,7 +12,7 @@ StringView::StringView(const String& string)
StringView::StringView(const ByteBuffer& buffer) StringView::StringView(const ByteBuffer& buffer)
: m_characters((const char*)buffer.data()) : m_characters((const char*)buffer.data())
, m_length(buffer.size()) , m_length((size_t)buffer.size())
{ {
} }
@ -22,17 +22,17 @@ Vector<StringView> StringView::split_view(const char separator, bool keep_empty)
return {}; return {};
Vector<StringView> v; Vector<StringView> v;
ssize_t substart = 0; size_t substart = 0;
for (ssize_t i = 0; i < length(); ++i) { for (size_t i = 0; i < length(); ++i) {
char ch = characters_without_null_termination()[i]; char ch = characters_without_null_termination()[i];
if (ch == separator) { if (ch == separator) {
ssize_t sublen = i - substart; size_t sublen = i - substart;
if (sublen != 0 || keep_empty) if (sublen != 0 || keep_empty)
v.append(substring_view(substart, sublen)); v.append(substring_view(substart, sublen));
substart = i + 1; substart = i + 1;
} }
} }
ssize_t taillen = length() - substart; size_t taillen = length() - substart;
if (taillen != 0 || keep_empty) if (taillen != 0 || keep_empty)
v.append(substring_view(substart, taillen)); v.append(substring_view(substart, taillen));
if (characters_without_null_termination()[length() - 1] == separator && keep_empty) if (characters_without_null_termination()[length() - 1] == separator && keep_empty)
@ -49,10 +49,10 @@ Vector<StringView> StringView::lines(bool consider_cr) const
return split_view('\n', true); return split_view('\n', true);
Vector<StringView> v; Vector<StringView> v;
ssize_t substart = 0; size_t substart = 0;
bool last_ch_was_cr = false; bool last_ch_was_cr = false;
bool split_view = false; bool split_view = false;
for (ssize_t i = 0; i < length(); ++i) { for (size_t i = 0; i < length(); ++i) {
char ch = characters_without_null_termination()[i]; char ch = characters_without_null_termination()[i];
if (ch == '\n') { if (ch == '\n') {
split_view = true; split_view = true;
@ -67,13 +67,13 @@ Vector<StringView> StringView::lines(bool consider_cr) const
last_ch_was_cr = true; last_ch_was_cr = true;
} }
if (split_view) { if (split_view) {
ssize_t sublen = i - substart; size_t sublen = i - substart;
v.append(substring_view(substart, sublen)); v.append(substring_view(substart, sublen));
substart = i + 1; substart = i + 1;
} }
split_view = false; split_view = false;
} }
ssize_t taillen = length() - substart; size_t taillen = length() - substart;
if (taillen != 0) if (taillen != 0)
v.append(substring_view(substart, taillen)); v.append(substring_view(substart, taillen));
return v; return v;
@ -92,7 +92,7 @@ bool StringView::starts_with(const StringView& str) const
return !memcmp(characters_without_null_termination(), str.characters_without_null_termination(), str.length()); return !memcmp(characters_without_null_termination(), str.characters_without_null_termination(), str.length());
} }
StringView StringView::substring_view(int start, int length) const StringView StringView::substring_view(size_t start, size_t length) const
{ {
if (!length) if (!length)
return {}; return {};
@ -105,7 +105,7 @@ StringView StringView::substring_view_starting_from_substring(const StringView&
const char* remaining_characters = substring.characters_without_null_termination(); const char* remaining_characters = substring.characters_without_null_termination();
ASSERT(remaining_characters >= m_characters); ASSERT(remaining_characters >= m_characters);
ASSERT(remaining_characters <= m_characters + m_length); ASSERT(remaining_characters <= m_characters + m_length);
int remaining_length = m_length - (remaining_characters - m_characters); size_t remaining_length = m_length - (remaining_characters - m_characters);
return { remaining_characters, remaining_length }; return { remaining_characters, remaining_length };
} }
@ -114,7 +114,7 @@ StringView StringView::substring_view_starting_after_substring(const StringView&
const char* remaining_characters = substring.characters_without_null_termination() + substring.length(); const char* remaining_characters = substring.characters_without_null_termination() + substring.length();
ASSERT(remaining_characters >= m_characters); ASSERT(remaining_characters >= m_characters);
ASSERT(remaining_characters <= m_characters + m_length); ASSERT(remaining_characters <= m_characters + m_length);
int remaining_length = m_length - (remaining_characters - m_characters); size_t remaining_length = m_length - (remaining_characters - m_characters);
return { remaining_characters, remaining_length }; return { remaining_characters, remaining_length };
} }
@ -122,7 +122,7 @@ int StringView::to_int(bool& ok) const
{ {
bool negative = false; bool negative = false;
int value = 0; int value = 0;
int i = 0; size_t i = 0;
if (is_empty()) { if (is_empty()) {
ok = false; ok = false;
@ -149,7 +149,7 @@ int StringView::to_int(bool& ok) const
unsigned StringView::to_uint(bool& ok) const unsigned StringView::to_uint(bool& ok) const
{ {
unsigned value = 0; unsigned value = 0;
for (ssize_t i = 0; i < length(); ++i) { for (size_t i = 0; i < length(); ++i) {
if (characters_without_null_termination()[i] < '0' || characters_without_null_termination()[i] > '9') { if (characters_without_null_termination()[i] < '0' || characters_without_null_termination()[i] > '9') {
ok = false; ok = false;
return 0; return 0;

14
AK/StringView.h
View file

@ -11,12 +11,12 @@ class StringImpl;
class StringView { class StringView {
public: public:
StringView() {} StringView() {}
StringView(const char* characters, int length) StringView(const char* characters, size_t length)
: m_characters(characters) : m_characters(characters)
, m_length(length) , m_length(length)
{ {
} }
StringView(const unsigned char* characters, int length) StringView(const unsigned char* characters, size_t length)
: m_characters((const char*)characters) : m_characters((const char*)characters)
, m_length(length) , m_length(length)
{ {
@ -36,14 +36,14 @@ public:
bool is_null() const { return !m_characters; } bool is_null() const { return !m_characters; }
bool is_empty() const { return m_length == 0; } bool is_empty() const { return m_length == 0; }
const char* characters_without_null_termination() const { return m_characters; } const char* characters_without_null_termination() const { return m_characters; }
int length() const { return m_length; } size_t length() const { return m_length; }
char operator[](int index) const { return m_characters[index]; } char operator[](size_t index) const { return m_characters[index]; }
unsigned hash() const; unsigned hash() const;
bool starts_with(const StringView&) const; bool starts_with(const StringView&) const;
StringView substring_view(int start, int length) const; StringView substring_view(size_t start, size_t length) const;
Vector<StringView> split_view(char, bool keep_empty = false) const; Vector<StringView> split_view(char, bool keep_empty = false) const;
// Create a Vector of StringViews split by line endings. As of CommonMark // Create a Vector of StringViews split by line endings. As of CommonMark
@ -81,7 +81,7 @@ public:
return !cstring; return !cstring;
if (!cstring) if (!cstring)
return false; return false;
int other_length = strlen(cstring); size_t other_length = strlen(cstring);
if (m_length != other_length) if (m_length != other_length)
return false; return false;
return !memcmp(m_characters, cstring, m_length); return !memcmp(m_characters, cstring, m_length);
@ -113,7 +113,7 @@ private:
friend class String; friend class String;
const StringImpl* m_impl { nullptr }; const StringImpl* m_impl { nullptr };
const char* m_characters { nullptr }; const char* m_characters { nullptr };
int m_length { 0 }; size_t m_length { 0 };
}; };
} }

4
AK/Tests/TestString.cpp
View file

@ -20,8 +20,8 @@ TEST_CASE(construct_contents)
String test_string = "ABCDEF"; String test_string = "ABCDEF";
EXPECT(!test_string.is_empty()); EXPECT(!test_string.is_empty());
EXPECT(!test_string.is_null()); EXPECT(!test_string.is_null());
EXPECT_EQ(test_string.length(), 6); EXPECT_EQ(test_string.length(), 6u);
EXPECT_EQ(test_string.length(), (int)strlen(test_string.characters())); EXPECT_EQ(test_string.length(), strlen(test_string.characters()));
EXPECT(test_string.characters() != nullptr); EXPECT(test_string.characters() != nullptr);
EXPECT(!strcmp(test_string.characters(), "ABCDEF")); EXPECT(!strcmp(test_string.characters(), "ABCDEF"));

2
AK/URL.cpp
View file

@ -31,7 +31,7 @@ bool URL::parse(const StringView& string)
Vector<char, 256> buffer; Vector<char, 256> buffer;
State state { State::InProtocol }; State state { State::InProtocol };
int index = 0; size_t index = 0;
auto peek = [&] { auto peek = [&] {
if (index >= string.length()) if (index >= string.length())

2
AK/Utf8View.cpp
View file

@ -30,7 +30,7 @@ const unsigned char* Utf8View::end_ptr() const
Utf8CodepointIterator Utf8View::begin() const Utf8CodepointIterator Utf8View::begin() const
{ {
return { begin_ptr(), m_string.length() }; return { begin_ptr(), (int)m_string.length() };
} }
Utf8CodepointIterator Utf8View::end() const Utf8CodepointIterator Utf8View::end() const

4
Applications/Help/main.cpp
View file

@ -56,7 +56,7 @@ int main(int argc, char* argv[])
go_forward_action->set_enabled(history.can_go_forward()); go_forward_action->set_enabled(history.can_go_forward());
}; };
auto open_page = [&](String path) { auto open_page = [&](const String& path) {
if (path.is_null()) { if (path.is_null()) {
html_view->set_document(nullptr); html_view->set_document(nullptr);
return; return;
@ -73,7 +73,7 @@ int main(int argc, char* argv[])
return; return;
} }
auto buffer = file->read_all(); auto buffer = file->read_all();
StringView source { (char*)buffer.data(), buffer.size() }; StringView source { (const char*)buffer.data(), (size_t)buffer.size() };
MDDocument md_document; MDDocument md_document;
bool success = md_document.parse(source); bool success = md_document.parse(source);

14
Applications/Welcome/TextWidget.cpp
View file

@ -66,20 +66,20 @@ void TextWidget::resize_event(GResizeEvent& event)
void TextWidget::wrap_and_set_height() void TextWidget::wrap_and_set_height()
{ {
Vector<String> words; Vector<String> words;
int start = -1; Optional<size_t> start;
for (int i = 0; i < m_text.length(); i++) { for (size_t i = 0; i < m_text.length(); i++) {
auto ch = m_text[i]; auto ch = m_text[i];
if (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n') { if (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n') {
if (start != -1) if (start.has_value())
words.append(m_text.substring(start, i - start)); words.append(m_text.substring(start.value(), i - start.value()));
start = -1; start = -1;
} else if (start == -1) { } else if (!start.has_value()) {
start = i; start = i;
} }
} }
if (start != -1) if (start.has_value())
words.append(m_text.substring(start, m_text.length() - start)); words.append(m_text.substring(start, m_text.length() - start.value()));
auto rect = frame_inner_rect(); auto rect = frame_inner_rect();
if (frame_thickness() > 0) if (frame_thickness() > 0)

4
DevTools/HackStudio/CppLexer.cpp
View file

@ -8,7 +8,7 @@ CppLexer::CppLexer(const StringView& input)
{ {
} }
char CppLexer::peek(int offset) const char CppLexer::peek(size_t offset) const
{ {
if ((m_index + offset) >= m_input.length()) if ((m_index + offset) >= m_input.length())
return 0; return 0;
@ -191,7 +191,7 @@ Vector<CppToken> CppLexer::lex()
{ {
Vector<CppToken> tokens; Vector<CppToken> tokens;
int token_start_index = 0; size_t token_start_index = 0;
CppPosition token_start_position; CppPosition token_start_position;
auto emit_token = [&](auto type) { auto emit_token = [&](auto type) {

8
DevTools/HackStudio/CppLexer.h
View file

@ -25,8 +25,8 @@
__TOKEN(Identifier) __TOKEN(Identifier)
struct CppPosition { struct CppPosition {
int line { -1 }; size_t line;
int column { -1 }; size_t column;
}; };
struct CppToken { struct CppToken {
@ -60,11 +60,11 @@ public:
Vector<CppToken> lex(); Vector<CppToken> lex();
private: private:
char peek(int offset = 0) const; char peek(size_t offset = 0) const;
char consume(); char consume();
StringView m_input; StringView m_input;
int m_index { 0 }; size_t m_index { 0 };
CppPosition m_previous_position { 0, 0 }; CppPosition m_previous_position { 0, 0 };
CppPosition m_position { 0, 0 }; CppPosition m_position { 0, 0 };
}; };

2
Kernel/FileSystem/FileSystem.cpp
View file

@ -46,7 +46,7 @@ FS::DirectoryEntry::DirectoryEntry(const char* n, InodeIdentifier i, u8 ft)
name[name_length] = '\0'; name[name_length] = '\0';
} }
FS::DirectoryEntry::DirectoryEntry(const char* n, int nl, InodeIdentifier i, u8 ft) FS::DirectoryEntry::DirectoryEntry(const char* n, size_t nl, InodeIdentifier i, u8 ft)
: name_length(nl) : name_length(nl)
, inode(i) , inode(i)
, file_type(ft) , file_type(ft)

4
Kernel/FileSystem/FileSystem.h
View file

@ -50,9 +50,9 @@ public:
// FIXME: This data structure is very clunky and unpleasant. Replace it with something nicer. // FIXME: This data structure is very clunky and unpleasant. Replace it with something nicer.
struct DirectoryEntry { struct DirectoryEntry {
DirectoryEntry(const char* name, InodeIdentifier, u8 file_type); DirectoryEntry(const char* name, InodeIdentifier, u8 file_type);
DirectoryEntry(const char* name, int name_length, InodeIdentifier, u8 file_type); DirectoryEntry(const char* name, size_t name_length, InodeIdentifier, u8 file_type);
char name[256]; char name[256];
int name_length { 0 }; size_t name_length { 0 };
InodeIdentifier inode; InodeIdentifier inode;
u8 file_type { 0 }; u8 file_type { 0 };
}; };

8
Kernel/FileSystem/ProcFS.cpp
View file

@ -1085,11 +1085,11 @@ bool ProcFSInode::traverse_as_directory(Function<bool(const FS::DirectoryEntry&)
if (!entry.name) if (!entry.name)
continue; continue;
if (entry.proc_file_type > __FI_Root_Start && entry.proc_file_type < __FI_Root_End) if (entry.proc_file_type > __FI_Root_Start && entry.proc_file_type < __FI_Root_End)
callback({ entry.name, (int)strlen(entry.name), to_identifier(fsid(), PDI_Root, 0, (ProcFileType)entry.proc_file_type), 0 }); callback({ entry.name, strlen(entry.name), to_identifier(fsid(), PDI_Root, 0, (ProcFileType)entry.proc_file_type), 0 });
} }
for (auto pid_child : Process::all_pids()) { for (auto pid_child : Process::all_pids()) {
char name[16]; char name[16];
int name_length = sprintf(name, "%u", pid_child); size_t name_length = (size_t)sprintf(name, "%u", pid_child);
callback({ name, name_length, to_identifier(fsid(), PDI_Root, pid_child, FI_PID), 0 }); callback({ name, name_length, to_identifier(fsid(), PDI_Root, pid_child, FI_PID), 0 });
} }
break; break;
@ -1119,7 +1119,7 @@ bool ProcFSInode::traverse_as_directory(Function<bool(const FS::DirectoryEntry&)
if (entry.proc_file_type == FI_PID_exe && !process.executable()) if (entry.proc_file_type == FI_PID_exe && !process.executable())
continue; continue;
// FIXME: strlen() here is sad. // FIXME: strlen() here is sad.
callback({ entry.name, (int)strlen(entry.name), to_identifier(fsid(), PDI_PID, pid, (ProcFileType)entry.proc_file_type), 0 }); callback({ entry.name, strlen(entry.name), to_identifier(fsid(), PDI_PID, pid, (ProcFileType)entry.proc_file_type), 0 });
} }
} }
} break; } break;
@ -1134,7 +1134,7 @@ bool ProcFSInode::traverse_as_directory(Function<bool(const FS::DirectoryEntry&)
if (!description) if (!description)
continue; continue;
char name[16]; char name[16];
int name_length = sprintf(name, "%u", i); size_t name_length = (size_t)sprintf(name, "%u", i);
callback({ name, name_length, to_identifier_with_fd(fsid(), pid, i), 0 }); callback({ name, name_length, to_identifier_with_fd(fsid(), pid, i), 0 });
} }
} break; } break;

2
Kernel/Net/LocalSocket.cpp
View file

@ -274,7 +274,7 @@ ssize_t LocalSocket::recvfrom(FileDescription& description, void* buffer, size_t
StringView LocalSocket::socket_path() const StringView LocalSocket::socket_path() const
{ {
int len = strnlen(m_address.sun_path, sizeof(m_address.sun_path)); size_t len = strnlen(m_address.sun_path, sizeof(m_address.sun_path));
return { m_address.sun_path, len }; return { m_address.sun_path, len };
} }

26
Kernel/Process.cpp
View file

@ -319,7 +319,7 @@ int Process::sys$gethostname(char* buffer, ssize_t size)
if (!validate_write(buffer, size)) if (!validate_write(buffer, size))
return -EFAULT; return -EFAULT;
LOCKER(*s_hostname_lock); LOCKER(*s_hostname_lock);
if (size < (s_hostname->length() + 1)) if ((size_t)size < (s_hostname->length() + 1))
return -ENAMETOOLONG; return -ENAMETOOLONG;
strcpy(buffer, s_hostname->characters()); strcpy(buffer, s_hostname->characters());
return 0; return 0;
@ -1038,7 +1038,7 @@ int Process::sys$ttyname_r(int fd, char* buffer, ssize_t size)
if (!description->is_tty()) if (!description->is_tty())
return -ENOTTY; return -ENOTTY;
auto tty_name = description->tty()->tty_name(); auto tty_name = description->tty()->tty_name();
if (size < tty_name.length() + 1) if ((size_t)size < tty_name.length() + 1)
return -ERANGE; return -ERANGE;
memcpy(buffer, tty_name.characters_without_null_termination(), tty_name.length()); memcpy(buffer, tty_name.characters_without_null_termination(), tty_name.length());
buffer[tty_name.length()] = '\0'; buffer[tty_name.length()] = '\0';
@ -1058,7 +1058,7 @@ int Process::sys$ptsname_r(int fd, char* buffer, ssize_t size)
if (!master_pty) if (!master_pty)
return -ENOTTY; return -ENOTTY;
auto pts_name = master_pty->pts_name(); auto pts_name = master_pty->pts_name();
if (size < pts_name.length() + 1) if ((size_t)size < pts_name.length() + 1)
return -ERANGE; return -ERANGE;
strcpy(buffer, pts_name.characters()); strcpy(buffer, pts_name.characters());
return 0; return 0;
@ -1347,7 +1347,7 @@ int Process::sys$getcwd(char* buffer, ssize_t size)
if (!validate_write(buffer, size)) if (!validate_write(buffer, size))
return -EFAULT; return -EFAULT;
auto path = current_directory().absolute_path(); auto path = current_directory().absolute_path();
if (size < path.length() + 1) if ((size_t)size < path.length() + 1)
return -ERANGE; return -ERANGE;
strcpy(buffer, path.characters()); strcpy(buffer, path.characters());
return 0; return 0;
@ -2991,11 +2991,14 @@ int Process::sys$join_thread(int tid, void** exit_value)
int Process::sys$set_thread_name(int tid, const char* buffer, int buffer_size) int Process::sys$set_thread_name(int tid, const char* buffer, int buffer_size)
{ {
if (buffer_size < 0)
return -EINVAL;
if (!validate_read(buffer, buffer_size)) if (!validate_read(buffer, buffer_size))
return -EFAULT; return -EFAULT;
const size_t max_thread_name_size = 64; const size_t max_thread_name_size = 64;
if (strnlen(buffer, buffer_size) > max_thread_name_size) if (strnlen(buffer, (size_t)buffer_size) > max_thread_name_size)
return -EINVAL; return -EINVAL;
Thread* thread = nullptr; Thread* thread = nullptr;
@ -3015,7 +3018,7 @@ int Process::sys$set_thread_name(int tid, const char* buffer, int buffer_size)
if (thread == &current->process().main_thread()) if (thread == &current->process().main_thread())
return -EINVAL; return -EINVAL;
thread->set_name({buffer, buffer_size}); thread->set_name({ buffer, (size_t)buffer_size });
return 0; return 0;
} }
@ -3039,7 +3042,7 @@ int Process::sys$get_thread_name(int tid, char* buffer, int buffer_size)
if (!thread) if (!thread)
return -ESRCH; return -ESRCH;
if (thread->name().length() >= buffer_size) if (thread->name().length() >= (size_t)buffer_size)
return -ENAMETOOLONG; return -ENAMETOOLONG;
strncpy(buffer, thread->name().characters(), buffer_size); strncpy(buffer, thread->name().characters(), buffer_size);
@ -3112,10 +3115,13 @@ int Process::sys$ftruncate(int fd, off_t length)
int Process::sys$watch_file(const char* path, int path_length) int Process::sys$watch_file(const char* path, int path_length)
{ {
if (path_length < 0)
return -EINVAL;
if (!validate_read(path, path_length)) if (!validate_read(path, path_length))
return -EFAULT; return -EFAULT;
auto custody_or_error = VFS::the().resolve_path({ path, path_length }, current_directory()); auto custody_or_error = VFS::the().resolve_path({ path, (size_t)path_length }, current_directory());
if (custody_or_error.is_error()) if (custody_or_error.is_error())
return custody_or_error.error(); return custody_or_error.error();
@ -3335,10 +3341,10 @@ int Process::sys$get_process_name(char* buffer, int buffer_size)
if (!validate_write(buffer, buffer_size)) if (!validate_write(buffer, buffer_size))
return -EFAULT; return -EFAULT;
if (m_name.length() >= buffer_size) if (m_name.length() >= (size_t)buffer_size)
return -ENAMETOOLONG; return -ENAMETOOLONG;
strncpy(buffer, m_name.characters(), buffer_size); strncpy(buffer, m_name.characters(), (size_t)buffer_size);
return 0; return 0;
} }

4
Libraries/LibC/netdb.cpp
View file

@ -81,7 +81,7 @@ hostent* gethostbyname(const char* name)
return nullptr; return nullptr;
} }
ASSERT(nsent == line.length()); ASSERT((size_t)nsent == line.length());
char buffer[1024]; char buffer[1024];
int nrecv = read(fd, buffer, sizeof(buffer) - 1); int nrecv = read(fd, buffer, sizeof(buffer) - 1);
@ -144,7 +144,7 @@ hostent* gethostbyaddr(const void* addr, socklen_t addr_size, int type)
return nullptr; return nullptr;
} }
ASSERT(nsent == line.length()); ASSERT((size_t)nsent == line.length());
char buffer[1024]; char buffer[1024];
int nrecv = read(fd, buffer, sizeof(buffer) - 1); int nrecv = read(fd, buffer, sizeof(buffer) - 1);

2
Libraries/LibCore/CHttpJob.cpp
View file

@ -101,7 +101,7 @@ void CHttpJob::on_socket_connected()
} }
auto name = parts[0]; auto name = parts[0];
if (chomped_line.length() < name.length() + 2) { if (chomped_line.length() < name.length() + 2) {
fprintf(stderr, "CHttpJob: Malformed HTTP header: '%s' (%d)\n", chomped_line.characters(), chomped_line.length()); fprintf(stderr, "CHttpJob: Malformed HTTP header: '%s' (%zu)\n", chomped_line.characters(), chomped_line.length());
return deferred_invoke([this](auto&) { did_fail(CNetworkJob::Error::ProtocolFailed); }); return deferred_invoke([this](auto&) { did_fail(CNetworkJob::Error::ProtocolFailed); });
} }
auto value = chomped_line.substring(name.length() + 2, chomped_line.length() - name.length() - 2); auto value = chomped_line.substring(name.length() + 2, chomped_line.length() - name.length() - 2);

2
Libraries/LibCore/CProcessStatisticsReader.cpp
View file

@ -19,7 +19,7 @@ HashMap<pid_t, CProcessStatistics> CProcessStatisticsReader::get_all()
HashMap<pid_t, CProcessStatistics> map; HashMap<pid_t, CProcessStatistics> map;
auto file_contents = file->read_all(); auto file_contents = file->read_all();
auto json = JsonValue::from_string({ file_contents.data(), file_contents.size() }); auto json = JsonValue::from_string({ file_contents.data(), (size_t)file_contents.size() });
json.as_array().for_each([&](auto& value) { json.as_array().for_each([&](auto& value) {
const JsonObject& process_object = value.as_object(); const JsonObject& process_object = value.as_object();
CProcessStatistics process; CProcessStatistics process;

2
Libraries/LibDraw/Font.cpp
View file

@ -154,7 +154,7 @@ bool Font::write_to_file(const StringView& path)
header.glyph_height = m_glyph_height; header.glyph_height = m_glyph_height;
header.type = 0; header.type = 0;
header.is_variable_width = !m_fixed_width; header.is_variable_width = !m_fixed_width;
memcpy(header.name, m_name.characters(), min(m_name.length(), 63)); memcpy(header.name, m_name.characters(), min(m_name.length(), (size_t)63));
size_t bytes_per_glyph = sizeof(unsigned) * m_glyph_height; size_t bytes_per_glyph = sizeof(unsigned) * m_glyph_height;

91
Libraries/LibGUI/GTextDocument.cpp
View file

@ -22,17 +22,17 @@ void GTextDocument::set_text(const StringView& text)
m_spans.clear(); m_spans.clear();
remove_all_lines(); remove_all_lines();
int start_of_current_line = 0; size_t start_of_current_line = 0;
auto add_line = [&](int current_position) { auto add_line = [&](size_t current_position) {
int line_length = current_position - start_of_current_line; size_t line_length = current_position - start_of_current_line;
auto line = make<GTextDocumentLine>(*this); auto line = make<GTextDocumentLine>(*this);
if (line_length) if (line_length)
line->set_text(*this, text.substring_view(start_of_current_line, current_position - start_of_current_line)); line->set_text(*this, text.substring_view(start_of_current_line, current_position - start_of_current_line));
append_line(move(line)); append_line(move(line));
start_of_current_line = current_position + 1; start_of_current_line = current_position + 1;
}; };
int i = 0; size_t i = 0;
for (i = 0; i < text.length(); ++i) { for (i = 0; i < text.length(); ++i) {
if (text[i] == '\n') if (text[i] == '\n')
add_line(i); add_line(i);
@ -44,10 +44,10 @@ void GTextDocument::set_text(const StringView& text)
client->document_did_set_text(); client->document_did_set_text();
} }
int GTextDocumentLine::first_non_whitespace_column() const size_t GTextDocumentLine::first_non_whitespace_column() const
{ {
for (int i = 0; i < length(); ++i) { for (size_t i = 0; i < length(); ++i) {
if (!isspace(m_text[i])) if (!isspace(m_text[(int)i]))
return i; return i;
} }
return length(); return length();
@ -78,12 +78,12 @@ void GTextDocumentLine::set_text(GTextDocument& document, const StringView& text
clear(document); clear(document);
return; return;
} }
m_text.resize(text.length() + 1); m_text.resize((int)text.length() + 1);
memcpy(m_text.data(), text.characters_without_null_termination(), text.length() + 1); memcpy(m_text.data(), text.characters_without_null_termination(), text.length() + 1);
document.update_views({}); document.update_views({});
} }
void GTextDocumentLine::append(GTextDocument& document, const char* characters, int length) void GTextDocumentLine::append(GTextDocument& document, const char* characters, size_t length)
{ {
int old_length = m_text.size() - 1; int old_length = m_text.size() - 1;
m_text.resize(m_text.size() + length); m_text.resize(m_text.size() + length);
@ -102,31 +102,31 @@ void GTextDocumentLine::prepend(GTextDocument& document, char ch)
insert(document, 0, ch); insert(document, 0, ch);
} }
void GTextDocumentLine::insert(GTextDocument& document, int index, char ch) void GTextDocumentLine::insert(GTextDocument& document, size_t index, char ch)
{ {
if (index == length()) { if (index == length()) {
m_text.last() = ch; m_text.last() = ch;
m_text.append(0); m_text.append(0);
} else { } else {
m_text.insert(index, move(ch)); m_text.insert((int)index, move(ch));
} }
document.update_views({}); document.update_views({});
} }
void GTextDocumentLine::remove(GTextDocument& document, int index) void GTextDocumentLine::remove(GTextDocument& document, size_t index)
{ {
if (index == length()) { if (index == length()) {
m_text.take_last(); m_text.take_last();
m_text.last() = 0; m_text.last() = 0;
} else { } else {
m_text.remove(index); m_text.remove((int)index);
} }
document.update_views({}); document.update_views({});
} }
void GTextDocumentLine::truncate(GTextDocument& document, int length) void GTextDocumentLine::truncate(GTextDocument& document, size_t length)
{ {
m_text.resize(length + 1); m_text.resize((int)length + 1);
m_text.last() = 0; m_text.last() = 0;
document.update_views({}); document.update_views({});
} }
@ -140,18 +140,18 @@ void GTextDocument::append_line(NonnullOwnPtr<GTextDocumentLine> line)
} }
} }
void GTextDocument::insert_line(int line_index, NonnullOwnPtr<GTextDocumentLine> line) void GTextDocument::insert_line(size_t line_index, NonnullOwnPtr<GTextDocumentLine> line)
{ {
lines().insert(line_index, move(line)); lines().insert((int)line_index, move(line));
if (m_client_notifications_enabled) { if (m_client_notifications_enabled) {
for (auto* client : m_clients) for (auto* client : m_clients)
client->document_did_insert_line(line_index); client->document_did_insert_line(line_index);
} }
} }
void GTextDocument::remove_line(int line_index) void GTextDocument::remove_line(size_t line_index)
{ {
lines().remove(line_index); lines().remove((int)line_index);
if (m_client_notifications_enabled) { if (m_client_notifications_enabled) {
for (auto* client : m_clients) for (auto* client : m_clients)
client->document_did_remove_line(line_index); client->document_did_remove_line(line_index);
@ -207,10 +207,10 @@ String GTextDocument::text_in_range(const GTextRange& a_range) const
auto range = a_range.normalized(); auto range = a_range.normalized();
StringBuilder builder; StringBuilder builder;
for (int i = range.start().line(); i <= range.end().line(); ++i) { for (size_t i = range.start().line(); i <= range.end().line(); ++i) {
auto& line = lines()[i]; auto& line = this->line(i);
int selection_start_column_on_line = range.start().line() == i ? range.start().column() : 0; size_t selection_start_column_on_line = range.start().line() == i ? range.start().column() : 0;
int selection_end_column_on_line = range.end().line() == i ? range.end().column() : line.length(); size_t selection_end_column_on_line = range.end().line() == i ? range.end().column() : line.length();
builder.append(line.characters() + selection_start_column_on_line, selection_end_column_on_line - selection_start_column_on_line); builder.append(line.characters() + selection_start_column_on_line, selection_end_column_on_line - selection_start_column_on_line);
if (i != range.end().line()) if (i != range.end().line())
builder.append('\n'); builder.append('\n');
@ -222,7 +222,7 @@ String GTextDocument::text_in_range(const GTextRange& a_range) const
char GTextDocument::character_at(const GTextPosition& position) const char GTextDocument::character_at(const GTextPosition& position) const
{ {
ASSERT(position.line() < line_count()); ASSERT(position.line() < line_count());
auto& line = lines()[position.line()]; auto& line = this->line(position.line());
if (position.column() == line.length()) if (position.column() == line.length())
return '\n'; return '\n';
return line.characters()[position.column()]; return line.characters()[position.column()];
@ -230,7 +230,7 @@ char GTextDocument::character_at(const GTextPosition& position) const
GTextPosition GTextDocument::next_position_after(const GTextPosition& position, SearchShouldWrap should_wrap) const GTextPosition GTextDocument::next_position_after(const GTextPosition& position, SearchShouldWrap should_wrap) const
{ {
auto& line = lines()[position.line()]; auto& line = this->line(position.line());
if (position.column() == line.length()) { if (position.column() == line.length()) {
if (position.line() == line_count() - 1) { if (position.line() == line_count() - 1) {
if (should_wrap == SearchShouldWrap::Yes) if (should_wrap == SearchShouldWrap::Yes)
@ -247,12 +247,12 @@ GTextPosition GTextDocument::previous_position_before(const GTextPosition& posit
if (position.column() == 0) { if (position.column() == 0) {
if (position.line() == 0) { if (position.line() == 0) {
if (should_wrap == SearchShouldWrap::Yes) { if (should_wrap == SearchShouldWrap::Yes) {
auto& last_line = lines()[line_count() - 1]; auto& last_line = this->line(line_count() - 1);
return { line_count() - 1, last_line.length() }; return { line_count() - 1, last_line.length() };
} }
return {}; return {};
} }
auto& prev_line = lines()[position.line() - 1]; auto& prev_line = this->line(position.line() - 1);
return { position.line() - 1, prev_line.length() }; return { position.line() - 1, prev_line.length() };
} }
return { position.line(), position.column() - 1 }; return { position.line(), position.column() - 1 };
@ -267,7 +267,7 @@ GTextRange GTextDocument::find_next(const StringView& needle, const GTextPositio
GTextPosition original_position = position; GTextPosition original_position = position;
GTextPosition start_of_potential_match; GTextPosition start_of_potential_match;
int needle_index = 0; size_t needle_index = 0;
do { do {
auto ch = character_at(position); auto ch = character_at(position);
@ -298,16 +298,16 @@ GTextRange GTextDocument::find_previous(const StringView& needle, const GTextPos
GTextPosition original_position = position; GTextPosition original_position = position;
GTextPosition end_of_potential_match; GTextPosition end_of_potential_match;
int needle_index = needle.length() - 1; size_t needle_index = needle.length() - 1;
do { do {
auto ch = character_at(position); auto ch = character_at(position);
if (ch == needle[needle_index]) { if (ch == needle[needle_index]) {
if (needle_index == needle.length() - 1) if (needle_index == needle.length() - 1)
end_of_potential_match = position; end_of_potential_match = position;
--needle_index; if (needle_index == 0)
if (needle_index < 0)
return { position, next_position_after(end_of_potential_match, should_wrap) }; return { position, next_position_after(end_of_potential_match, should_wrap) };
--needle_index;
} else { } else {
if (needle_index < needle.length() - 1) if (needle_index < needle.length() - 1)
position = end_of_potential_match; position = end_of_potential_match;
@ -441,9 +441,8 @@ void GTextDocument::update_undo_timer()
GTextPosition GTextDocument::insert_at(const GTextPosition& position, const StringView& text) GTextPosition GTextDocument::insert_at(const GTextPosition& position, const StringView& text)
{ {
GTextPosition cursor = position; GTextPosition cursor = position;
for (int i = 0; i < text.length(); ++i) { for (size_t i = 0; i < text.length(); ++i)
cursor = insert_at(cursor, text[i]); cursor = insert_at(cursor, text[i]);
}
return cursor; return cursor;
} }
@ -451,7 +450,7 @@ GTextPosition GTextDocument::insert_at(const GTextPosition& position, char ch)
{ {
// FIXME: We need these from GTextEditor! // FIXME: We need these from GTextEditor!
bool m_automatic_indentation_enabled = true; bool m_automatic_indentation_enabled = true;
int m_soft_tab_width = 4; size_t m_soft_tab_width = 4;
bool at_head = position.column() == 0; bool at_head = position.column() == 0;
bool at_tail = position.column() == line(position.line()).length(); bool at_tail = position.column() == line(position.line()).length();
@ -459,9 +458,9 @@ GTextPosition GTextDocument::insert_at(const GTextPosition& position, char ch)
if (at_tail || at_head) { if (at_tail || at_head) {
String new_line_contents; String new_line_contents;
if (m_automatic_indentation_enabled && at_tail) { if (m_automatic_indentation_enabled && at_tail) {
int leading_spaces = 0; size_t leading_spaces = 0;
auto& old_line = lines()[position.line()]; auto& old_line = lines()[position.line()];
for (int i = 0; i < old_line.length(); ++i) { for (size_t i = 0; i < old_line.length(); ++i) {
if (old_line.characters()[i] == ' ') if (old_line.characters()[i] == ' ')
++leading_spaces; ++leading_spaces;
else else
@ -471,9 +470,9 @@ GTextPosition GTextDocument::insert_at(const GTextPosition& position, char ch)
new_line_contents = String::repeated(' ', leading_spaces); new_line_contents = String::repeated(' ', leading_spaces);
} }
int row = position.line(); size_t row = position.line();
Vector<char> line_content; Vector<char> line_content;
for (int i = position.column(); i < line(row).length(); i++) for (size_t i = position.column(); i < line(row).length(); i++)
line_content.append(line(row).characters()[i]); line_content.append(line(row).characters()[i]);
insert_line(position.line() + (at_tail ? 1 : 0), make<GTextDocumentLine>(*this, new_line_contents)); insert_line(position.line() + (at_tail ? 1 : 0), make<GTextDocumentLine>(*this, new_line_contents));
notify_did_change(); notify_did_change();
@ -483,7 +482,7 @@ GTextPosition GTextDocument::insert_at(const GTextPosition& position, char ch)
new_line->append(*this, line(position.line()).characters() + position.column(), line(position.line()).length() - position.column()); new_line->append(*this, line(position.line()).characters() + position.column(), line(position.line()).length() - position.column());
Vector<char> line_content; Vector<char> line_content;
for (int i = 0; i < new_line->length(); i++) for (size_t i = 0; i < new_line->length(); i++)
line_content.append(new_line->characters()[i]); line_content.append(new_line->characters()[i]);
line(position.line()).truncate(*this, position.column()); line(position.line()).truncate(*this, position.column());
insert_line(position.line() + 1, move(new_line)); insert_line(position.line() + 1, move(new_line));
@ -491,9 +490,9 @@ GTextPosition GTextDocument::insert_at(const GTextPosition& position, char ch)
return { position.line() + 1, 0 }; return { position.line() + 1, 0 };
} }
if (ch == '\t') { if (ch == '\t') {
int next_soft_tab_stop = ((position.column() + m_soft_tab_width) / m_soft_tab_width) * m_soft_tab_width; size_t next_soft_tab_stop = ((position.column() + m_soft_tab_width) / m_soft_tab_width) * m_soft_tab_width;
int spaces_to_insert = next_soft_tab_stop - position.column(); size_t spaces_to_insert = next_soft_tab_stop - position.column();
for (int i = 0; i < spaces_to_insert; ++i) { for (size_t i = 0; i < spaces_to_insert; ++i) {
line(position.line()).insert(*this, position.column(), ' '); line(position.line()).insert(*this, position.column(), ' ');
} }
notify_did_change(); notify_did_change();
@ -512,14 +511,14 @@ void GTextDocument::remove(const GTextRange& unnormalized_range)
auto range = unnormalized_range.normalized(); auto range = unnormalized_range.normalized();
// First delete all the lines in between the first and last one. // First delete all the lines in between the first and last one.
for (int i = range.start().line() + 1; i < range.end().line();) { for (size_t i = range.start().line() + 1; i < range.end().line();) {
remove_line(i); remove_line(i);
range.end().set_line(range.end().line() - 1); range.end().set_line(range.end().line() - 1);
} }
if (range.start().line() == range.end().line()) { if (range.start().line() == range.end().line()) {
// Delete within same line. // Delete within same line.
auto& line = lines()[range.start().line()]; auto& line = this->line(range.start().line());
bool whole_line_is_selected = range.start().column() == 0 && range.end().column() == line.length(); bool whole_line_is_selected = range.start().column() == 0 && range.end().column() == line.length();
if (whole_line_is_selected) { if (whole_line_is_selected) {
@ -535,8 +534,8 @@ void GTextDocument::remove(const GTextRange& unnormalized_range)
} else { } else {
// Delete across a newline, merging lines. // Delete across a newline, merging lines.
ASSERT(range.start().line() == range.end().line() - 1); ASSERT(range.start().line() == range.end().line() - 1);
auto& first_line = lines()[range.start().line()]; auto& first_line = line(range.start().line());
auto& second_line = lines()[range.end().line()]; auto& second_line = line(range.end().line());
auto before_selection = String(first_line.characters(), first_line.length()).substring(0, range.start().column()); auto before_selection = String(first_line.characters(), first_line.length()).substring(0, range.start().column());
auto after_selection = String(second_line.characters(), second_line.length()).substring(range.end().column(), second_line.length() - range.end().column()); auto after_selection = String(second_line.characters(), second_line.length()).substring(range.end().column(), second_line.length() - range.end().column());
StringBuilder builder(before_selection.length() + after_selection.length()); StringBuilder builder(before_selection.length() + after_selection.length());

30
Libraries/LibGUI/GTextDocument.h
View file

@ -66,8 +66,8 @@ public:
public: public:
virtual ~Client(); virtual ~Client();
virtual void document_did_append_line() = 0; virtual void document_did_append_line() = 0;
virtual void document_did_insert_line(int) = 0; virtual void document_did_insert_line(size_t) = 0;
virtual void document_did_remove_line(int) = 0; virtual void document_did_remove_line(size_t) = 0;
virtual void document_did_remove_all_lines() = 0; virtual void document_did_remove_all_lines() = 0;
virtual void document_did_change() = 0; virtual void document_did_change() = 0;
virtual void document_did_set_text() = 0; virtual void document_did_set_text() = 0;
@ -79,9 +79,9 @@ public:
return adopt(*new GTextDocument(client)); return adopt(*new GTextDocument(client));
} }
int line_count() const { return m_lines.size(); } size_t line_count() const { return (size_t)m_lines.size(); }
const GTextDocumentLine& line(int line_index) const { return m_lines[line_index]; } const GTextDocumentLine& line(size_t line_index) const { return m_lines[(int)line_index]; }
GTextDocumentLine& line(int line_index) { return m_lines[line_index]; } GTextDocumentLine& line(size_t line_index) { return m_lines[(int)line_index]; }
void set_spans(const Vector<GTextDocumentSpan>& spans) { m_spans = spans; } void set_spans(const Vector<GTextDocumentSpan>& spans) { m_spans = spans; }
@ -92,12 +92,12 @@ public:
bool has_spans() const { return !m_spans.is_empty(); } bool has_spans() const { return !m_spans.is_empty(); }
const Vector<GTextDocumentSpan>& spans() const { return m_spans; } const Vector<GTextDocumentSpan>& spans() const { return m_spans; }
void set_span_at_index(int index, GTextDocumentSpan span) { m_spans[index] = move(span); } void set_span_at_index(size_t index, GTextDocumentSpan span) { m_spans[(int)index] = move(span); }
void append_line(NonnullOwnPtr<GTextDocumentLine>); void append_line(NonnullOwnPtr<GTextDocumentLine>);
void remove_line(int line_index); void remove_line(size_t line_index);
void remove_all_lines(); void remove_all_lines();
void insert_line(int line_index, NonnullOwnPtr<GTextDocumentLine>); void insert_line(size_t line_index, NonnullOwnPtr<GTextDocumentLine>);
void register_client(Client&); void register_client(Client&);
void unregister_client(Client&); void unregister_client(Client&);
@ -156,18 +156,18 @@ public:
explicit GTextDocumentLine(GTextDocument&); explicit GTextDocumentLine(GTextDocument&);
explicit GTextDocumentLine(GTextDocument&, const StringView&); explicit GTextDocumentLine(GTextDocument&, const StringView&);
StringView view() const { return { characters(), length() }; } StringView view() const { return { characters(), (size_t)length() }; }
const char* characters() const { return m_text.data(); } const char* characters() const { return m_text.data(); }
int length() const { return m_text.size() - 1; } size_t length() const { return (size_t)m_text.size() - 1; }
void set_text(GTextDocument&, const StringView&); void set_text(GTextDocument&, const StringView&);
void append(GTextDocument&, char); void append(GTextDocument&, char);
void prepend(GTextDocument&, char); void prepend(GTextDocument&, char);
void insert(GTextDocument&, int index, char); void insert(GTextDocument&, size_t index, char);
void remove(GTextDocument&, int index); void remove(GTextDocument&, size_t index);
void append(GTextDocument&, const char*, int); void append(GTextDocument&, const char*, size_t);
void truncate(GTextDocument&, int length); void truncate(GTextDocument&, size_t length);
void clear(GTextDocument&); void clear(GTextDocument&);
int first_non_whitespace_column() const; size_t first_non_whitespace_column() const;
private: private:
// NOTE: This vector is null terminated. // NOTE: This vector is null terminated.

184
Libraries/LibGUI/GTextEditor.cpp
View file

@ -97,30 +97,30 @@ GTextPosition GTextEditor::text_position_at(const Point& a_position) const
position.move_by(-(m_horizontal_content_padding + ruler_width()), 0); position.move_by(-(m_horizontal_content_padding + ruler_width()), 0);
position.move_by(-frame_thickness(), -frame_thickness()); position.move_by(-frame_thickness(), -frame_thickness());
int line_index = -1; size_t line_index = 0;
if (is_line_wrapping_enabled()) { if (is_line_wrapping_enabled()) {
for (int i = 0; i < lines().size(); ++i) { for (size_t i = 0; i < line_count(); ++i) {
auto& rect = m_line_visual_data[i].visual_rect; auto& rect = m_line_visual_data[i].visual_rect;
if (position.y() >= rect.top() && position.y() <= rect.bottom()) { if (position.y() >= rect.top() && position.y() <= rect.bottom()) {
line_index = i; line_index = i;
break; break;
} }
if (position.y() > rect.bottom()) if (position.y() > rect.bottom())
line_index = lines().size() - 1; line_index = line_count() - 1;
} }
} else { } else {
line_index = position.y() / line_height(); line_index = (size_t)(position.y() / line_height());
} }
line_index = max(0, min(line_index, line_count() - 1)); line_index = max((size_t)0, min(line_index, line_count() - 1));
int column_index; size_t column_index;
switch (m_text_alignment) { switch (m_text_alignment) {
case TextAlignment::CenterLeft: case TextAlignment::CenterLeft:
column_index = (position.x() + glyph_width() / 2) / glyph_width(); column_index = (position.x() + glyph_width() / 2) / glyph_width();
if (is_line_wrapping_enabled()) { if (is_line_wrapping_enabled()) {
for_each_visual_line(line_index, [&](const Rect& rect, const StringView&, int start_of_line) { for_each_visual_line(line_index, [&](const Rect& rect, const StringView&, size_t start_of_line) {
if (rect.contains_vertically(position.y())) { if (rect.contains_vertically(position.y())) {
column_index += start_of_line; column_index += start_of_line;
return IterationDecision::Break; return IterationDecision::Break;
@ -138,7 +138,7 @@ GTextPosition GTextEditor::text_position_at(const Point& a_position) const
ASSERT_NOT_REACHED(); ASSERT_NOT_REACHED();
} }
column_index = max(0, min(column_index, lines()[line_index].length())); column_index = max((size_t)0, min(column_index, line(line_index).length()));
return { line_index, column_index }; return { line_index, column_index };
} }
@ -155,7 +155,7 @@ void GTextEditor::doubleclick_event(GMouseEvent& event)
auto start = text_position_at(event.position()); auto start = text_position_at(event.position());
auto end = start; auto end = start;
auto& line = lines()[start.line()]; auto& line = this->line(start.line());
if (!document().has_spans()) { if (!document().has_spans()) {
while (start.column() > 0) { while (start.column() > 0) {
@ -201,11 +201,11 @@ void GTextEditor::mousedown_event(GMouseEvent& event)
if (is_multi_line()) { if (is_multi_line()) {
// select *current* line // select *current* line
start = GTextPosition(m_cursor.line(), 0); start = GTextPosition(m_cursor.line(), 0);
end = GTextPosition(m_cursor.line(), lines()[m_cursor.line()].length()); end = GTextPosition(m_cursor.line(), line(m_cursor.line()).length());
} else { } else {
// select *whole* line // select *whole* line
start = GTextPosition(0, 0); start = GTextPosition(0, 0);
end = GTextPosition(line_count() - 1, lines()[line_count() - 1].length()); end = GTextPosition(line_count() - 1, line(line_count() - 1).length());
} }
m_selection.set(start, end); m_selection.set(start, end);
@ -266,7 +266,7 @@ int GTextEditor::ruler_width() const
return 5 * font().glyph_width('x') + 4; return 5 * font().glyph_width('x') + 4;
} }
Rect GTextEditor::ruler_content_rect(int line_index) const Rect GTextEditor::ruler_content_rect(size_t line_index) const
{ {
if (!m_ruler_visible) if (!m_ruler_visible)
return {}; return {};
@ -318,14 +318,14 @@ void GTextEditor::paint_event(GPaintEvent& event)
if (m_ruler_visible) if (m_ruler_visible)
painter.translate(ruler_width(), 0); painter.translate(ruler_width(), 0);
int first_visible_line = text_position_at(event.rect().top_left()).line(); size_t first_visible_line = text_position_at(event.rect().top_left()).line();
int last_visible_line = text_position_at(event.rect().bottom_right()).line(); size_t last_visible_line = text_position_at(event.rect().bottom_right()).line();
auto selection = normalized_selection(); auto selection = normalized_selection();
bool has_selection = selection.is_valid(); bool has_selection = selection.is_valid();
if (m_ruler_visible) { if (m_ruler_visible) {
for (int i = first_visible_line; i <= last_visible_line; ++i) { for (size_t i = first_visible_line; i <= last_visible_line; ++i) {
bool is_current_line = i == m_cursor.line(); bool is_current_line = i == m_cursor.line();
auto ruler_line_rect = ruler_content_rect(i); auto ruler_line_rect = ruler_content_rect(i);
painter.draw_text( painter.draw_text(
@ -345,12 +345,12 @@ void GTextEditor::paint_event(GPaintEvent& event)
}; };
painter.add_clip_rect(text_clip_rect); painter.add_clip_rect(text_clip_rect);
for (int line_index = first_visible_line; line_index <= last_visible_line; ++line_index) { for (size_t line_index = first_visible_line; line_index <= last_visible_line; ++line_index) {
auto& line = lines()[line_index]; auto& line = this->line(line_index);
bool physical_line_has_selection = has_selection && line_index >= selection.start().line() && line_index <= selection.end().line(); bool physical_line_has_selection = has_selection && line_index >= selection.start().line() && line_index <= selection.end().line();
int first_visual_line_with_selection = -1; size_t first_visual_line_with_selection = 0;
int last_visual_line_with_selection = -1; size_t last_visual_line_with_selection = 0;
if (physical_line_has_selection) { if (physical_line_has_selection) {
if (selection.start().line() < line_index) if (selection.start().line() < line_index)
first_visual_line_with_selection = 0; first_visual_line_with_selection = 0;
@ -363,11 +363,11 @@ void GTextEditor::paint_event(GPaintEvent& event)
last_visual_line_with_selection = visual_line_containing(line_index, selection.end().column()); last_visual_line_with_selection = visual_line_containing(line_index, selection.end().column());
} }
int selection_start_column_within_line = selection.start().line() == line_index ? selection.start().column() : 0; size_t selection_start_column_within_line = selection.start().line() == line_index ? selection.start().column() : 0;
int selection_end_column_within_line = selection.end().line() == line_index ? selection.end().column() : line.length(); size_t selection_end_column_within_line = selection.end().line() == line_index ? selection.end().column() : line.length();
int visual_line_index = 0; size_t visual_line_index = 0;
for_each_visual_line(line_index, [&](const Rect& visual_line_rect, const StringView& visual_line_text, int start_of_visual_line) { for_each_visual_line(line_index, [&](const Rect& visual_line_rect, const StringView& visual_line_text, size_t start_of_visual_line) {
if (is_multi_line() && line_index == m_cursor.line()) if (is_multi_line() && line_index == m_cursor.line())
painter.fill_rect(visual_line_rect, Color(230, 230, 230)); painter.fill_rect(visual_line_rect, Color(230, 230, 230));
#ifdef DEBUG_GTEXTEDITOR #ifdef DEBUG_GTEXTEDITOR
@ -379,7 +379,7 @@ void GTextEditor::paint_event(GPaintEvent& event)
} else { } else {
int advance = font().glyph_width(' ') + font().glyph_spacing(); int advance = font().glyph_width(' ') + font().glyph_spacing();
Rect character_rect = { visual_line_rect.location(), { font().glyph_width(' '), line_height() } }; Rect character_rect = { visual_line_rect.location(), { font().glyph_width(' '), line_height() } };
for (int i = 0; i < visual_line_text.length(); ++i) { for (size_t i = 0; i < visual_line_text.length(); ++i) {
const Font* font = &this->font(); const Font* font = &this->font();
Color color; Color color;
Optional<Color> background_color; Optional<Color> background_color;
@ -426,8 +426,8 @@ void GTextEditor::paint_event(GPaintEvent& event)
painter.fill_rect(selection_rect, Color::from_rgb(0x955233)); painter.fill_rect(selection_rect, Color::from_rgb(0x955233));
int start_of_selection_within_visual_line = max(0, selection_start_column_within_line - start_of_visual_line); size_t start_of_selection_within_visual_line = max((size_t)0, selection_start_column_within_line - start_of_visual_line);
int end_of_selection_within_visual_line = selection_end_column_within_line - start_of_visual_line; size_t end_of_selection_within_visual_line = selection_end_column_within_line - start_of_visual_line;
StringView visual_selected_text { StringView visual_selected_text {
visual_line_text.characters_without_null_termination() + start_of_selection_within_visual_line, visual_line_text.characters_without_null_termination() + start_of_selection_within_visual_line,
@ -465,14 +465,14 @@ void GTextEditor::toggle_selection_if_needed_for_event(const GKeyEvent& event)
void GTextEditor::select_all() void GTextEditor::select_all()
{ {
GTextPosition start_of_document { 0, 0 }; GTextPosition start_of_document { 0, 0 };
GTextPosition end_of_document { line_count() - 1, lines()[line_count() - 1].length() }; GTextPosition end_of_document { line_count() - 1, line(line_count() - 1).length() };
m_selection.set(start_of_document, end_of_document); m_selection.set(start_of_document, end_of_document);
did_update_selection(); did_update_selection();
set_cursor(end_of_document); set_cursor(end_of_document);
update(); update();
} }
void GTextEditor::get_selection_line_boundaries(int& first_line, int& last_line) void GTextEditor::get_selection_line_boundaries(size_t& first_line, size_t& last_line)
{ {
auto selection = normalized_selection(); auto selection = normalized_selection();
if (!selection.is_valid()) { if (!selection.is_valid()) {
@ -488,15 +488,15 @@ void GTextEditor::get_selection_line_boundaries(int& first_line, int& last_line)
void GTextEditor::move_selected_lines_up() void GTextEditor::move_selected_lines_up()
{ {
int first_line; size_t first_line;
int last_line; size_t last_line;
get_selection_line_boundaries(first_line, last_line); get_selection_line_boundaries(first_line, last_line);
if (first_line == 0) if (first_line == 0)
return; return;
auto& lines = document().lines(); auto& lines = document().lines();
lines.insert(last_line, lines.take(first_line - 1)); lines.insert((int)last_line, lines.take((int)first_line - 1));
m_cursor = { first_line - 1, 0 }; m_cursor = { first_line - 1, 0 };
if (has_selection()) { if (has_selection()) {
@ -510,15 +510,15 @@ void GTextEditor::move_selected_lines_up()
void GTextEditor::move_selected_lines_down() void GTextEditor::move_selected_lines_down()
{ {
int first_line; size_t first_line;
int last_line; size_t last_line;
get_selection_line_boundaries(first_line, last_line); get_selection_line_boundaries(first_line, last_line);
auto& lines = document().lines(); auto& lines = document().lines();
if (last_line >= (lines.size() - 1)) if (last_line >= (size_t)(lines.size() - 1))
return; return;
lines.insert(first_line, lines.take(last_line + 1)); lines.insert((int)first_line, lines.take((int)last_line + 1));
m_cursor = { first_line + 1, 0 }; m_cursor = { first_line + 1, 0 };
if (has_selection()) { if (has_selection()) {
@ -538,14 +538,14 @@ void GTextEditor::sort_selected_lines()
if (!has_selection()) if (!has_selection())
return; return;
int first_line; size_t first_line;
int last_line; size_t last_line;
get_selection_line_boundaries(first_line, last_line); get_selection_line_boundaries(first_line, last_line);
auto& lines = document().lines(); auto& lines = document().lines();
auto start = lines.begin() + first_line; auto start = lines.begin() + (int)first_line;
auto end = lines.begin() + last_line + 1; auto end = lines.begin() + (int)last_line + 1;
quick_sort(start, end, [](auto& a, auto& b) { quick_sort(start, end, [](auto& a, auto& b) {
return strcmp(a.characters(), b.characters()) < 0; return strcmp(a.characters(), b.characters()) < 0;
@ -577,8 +577,8 @@ void GTextEditor::keydown_event(GKeyEvent& event)
move_selected_lines_up(); move_selected_lines_up();
return; return;
} }
int new_line = m_cursor.line() - 1; size_t new_line = m_cursor.line() - 1;
int new_column = min(m_cursor.column(), lines()[new_line].length()); size_t new_column = min(m_cursor.column(), line(new_line).length());
toggle_selection_if_needed_for_event(event); toggle_selection_if_needed_for_event(event);
set_cursor(new_line, new_column); set_cursor(new_line, new_column);
if (event.shift() && m_selection.start().is_valid()) { if (event.shift() && m_selection.start().is_valid()) {
@ -589,13 +589,13 @@ void GTextEditor::keydown_event(GKeyEvent& event)
return; return;
} }
if (event.key() == KeyCode::Key_Down) { if (event.key() == KeyCode::Key_Down) {
if (m_cursor.line() < (lines().size() - 1)) { if (m_cursor.line() < (line_count() - 1)) {
if (event.ctrl() && event.shift()) { if (event.ctrl() && event.shift()) {
move_selected_lines_down(); move_selected_lines_down();
return; return;
} }
int new_line = m_cursor.line() + 1; size_t new_line = m_cursor.line() + 1;
int new_column = min(m_cursor.column(), lines()[new_line].length()); size_t new_column = min(m_cursor.column(), line(new_line).length());
toggle_selection_if_needed_for_event(event); toggle_selection_if_needed_for_event(event);
set_cursor(new_line, new_column); set_cursor(new_line, new_column);
if (event.shift() && m_selection.start().is_valid()) { if (event.shift() && m_selection.start().is_valid()) {
@ -607,8 +607,8 @@ void GTextEditor::keydown_event(GKeyEvent& event)
} }
if (event.key() == KeyCode::Key_PageUp) { if (event.key() == KeyCode::Key_PageUp) {
if (m_cursor.line() > 0) { if (m_cursor.line() > 0) {
int new_line = max(0, m_cursor.line() - visible_content_rect().height() / line_height()); size_t new_line = max((size_t)0, m_cursor.line() - (size_t)visible_content_rect().height() / (size_t)line_height());
int new_column = min(m_cursor.column(), lines()[new_line].length()); size_t new_column = min(m_cursor.column(), line(new_line).length());
toggle_selection_if_needed_for_event(event); toggle_selection_if_needed_for_event(event);
set_cursor(new_line, new_column); set_cursor(new_line, new_column);
if (event.shift() && m_selection.start().is_valid()) { if (event.shift() && m_selection.start().is_valid()) {
@ -619,7 +619,7 @@ void GTextEditor::keydown_event(GKeyEvent& event)
return; return;
} }
if (event.key() == KeyCode::Key_PageDown) { if (event.key() == KeyCode::Key_PageDown) {
if (m_cursor.line() < (lines().size() - 1)) { if (m_cursor.line() < (line_count() - 1)) {
int new_line = min(line_count() - 1, m_cursor.line() + visible_content_rect().height() / line_height()); int new_line = min(line_count() - 1, m_cursor.line() + visible_content_rect().height() / line_height());
int new_column = min(m_cursor.column(), lines()[new_line].length()); int new_column = min(m_cursor.column(), lines()[new_line].length());
toggle_selection_if_needed_for_event(event); toggle_selection_if_needed_for_event(event);
@ -699,7 +699,7 @@ void GTextEditor::keydown_event(GKeyEvent& event)
return; return;
} }
if (!event.ctrl() && event.key() == KeyCode::Key_Home) { if (!event.ctrl() && event.key() == KeyCode::Key_Home) {
int first_nonspace_column = current_line().first_non_whitespace_column(); size_t first_nonspace_column = current_line().first_non_whitespace_column();
toggle_selection_if_needed_for_event(event); toggle_selection_if_needed_for_event(event);
if (m_cursor.column() == first_nonspace_column) if (m_cursor.column() == first_nonspace_column)
set_cursor(m_cursor.line(), 0); set_cursor(m_cursor.line(), 0);
@ -773,7 +773,7 @@ void GTextEditor::keydown_event(GKeyEvent& event)
} }
if (m_cursor.column() == 0 && m_cursor.line() != 0) { if (m_cursor.column() == 0 && m_cursor.line() != 0) {
// Backspace at column 0; merge with previous line // Backspace at column 0; merge with previous line
int previous_length = line(m_cursor.line() - 1).length(); size_t previous_length = line(m_cursor.line() - 1).length();
GTextRange erased_range({ m_cursor.line() - 1, previous_length }, m_cursor); GTextRange erased_range({ m_cursor.line() - 1, previous_length }, m_cursor);
execute<RemoveTextCommand>("\n", erased_range); execute<RemoveTextCommand>("\n", erased_range);
return; return;
@ -806,10 +806,10 @@ void GTextEditor::delete_current_line()
GTextPosition start; GTextPosition start;
GTextPosition end; GTextPosition end;
if (m_cursor.line() == 0 && lines().size() == 1) { if (m_cursor.line() == 0 && line_count() == 1) {
start = { 0, 0 }; start = { 0, 0 };
end = { 0, line(0).length() }; end = { 0, line(0).length() };
} else if (m_cursor.line() == lines().size() - 1) { } else if (m_cursor.line() == line_count() - 1) {
start = { m_cursor.line() - 1, line(m_cursor.line()).length() }; start = { m_cursor.line() - 1, line(m_cursor.line()).length() };
end = { m_cursor.line(), line(m_cursor.line()).length() }; end = { m_cursor.line(), line(m_cursor.line()).length() };
} else { } else {
@ -845,11 +845,11 @@ void GTextEditor::do_delete()
int GTextEditor::content_x_for_position(const GTextPosition& position) const int GTextEditor::content_x_for_position(const GTextPosition& position) const
{ {
auto& line = lines()[position.line()]; auto& line = this->line(position.line());
int x_offset = -1; int x_offset = -1;
switch (m_text_alignment) { switch (m_text_alignment) {
case TextAlignment::CenterLeft: case TextAlignment::CenterLeft:
for_each_visual_line(position.line(), [&](const Rect&, const StringView& view, int start_of_visual_line) { for_each_visual_line(position.line(), [&](const Rect&, const StringView& view, size_t start_of_visual_line) {
if (position.column() >= start_of_visual_line && ((position.column() - start_of_visual_line) <= view.length())) { if (position.column() >= start_of_visual_line && ((position.column() - start_of_visual_line) <= view.length())) {
x_offset = (position.column() - start_of_visual_line) * glyph_width(); x_offset = (position.column() - start_of_visual_line) * glyph_width();
return IterationDecision::Break; return IterationDecision::Break;
@ -882,7 +882,7 @@ Rect GTextEditor::content_rect_for_position(const GTextPosition& position) const
} }
Rect rect; Rect rect;
for_each_visual_line(position.line(), [&](const Rect& visual_line_rect, const StringView& view, int start_of_visual_line) { for_each_visual_line(position.line(), [&](const Rect& visual_line_rect, const StringView& view, size_t start_of_visual_line) {
if (position.column() >= start_of_visual_line && ((position.column() - start_of_visual_line) <= view.length())) { if (position.column() >= start_of_visual_line && ((position.column() - start_of_visual_line) <= view.length())) {
// NOTE: We have to subtract the horizontal padding here since it's part of the visual line rect // NOTE: We have to subtract the horizontal padding here since it's part of the visual line rect
// *and* included in what we get from content_x_for_position(). // *and* included in what we get from content_x_for_position().
@ -904,7 +904,7 @@ Rect GTextEditor::cursor_content_rect() const
return content_rect_for_position(m_cursor); return content_rect_for_position(m_cursor);
} }
Rect GTextEditor::line_widget_rect(int line_index) const Rect GTextEditor::line_widget_rect(size_t line_index) const
{ {
auto rect = line_content_rect(line_index); auto rect = line_content_rect(line_index);
rect.set_x(frame_thickness()); rect.set_x(frame_thickness());
@ -920,8 +920,8 @@ void GTextEditor::scroll_position_into_view(const GTextPosition& position)
auto rect = content_rect_for_position(position); auto rect = content_rect_for_position(position);
if (position.column() == 0) if (position.column() == 0)
rect.set_x(content_x_for_position({ position.line(), 0 }) - 2); rect.set_x(content_x_for_position({ position.line(), 0 }) - 2);
else if (position.column() == lines()[position.line()].length()) else if (position.column() == line(position.line()).length())
rect.set_x(content_x_for_position({ position.line(), lines()[position.line()].length() }) + 2); rect.set_x(content_x_for_position({ position.line(), line(position.line()).length() }) + 2);
scroll_into_view(rect, true, true); scroll_into_view(rect, true, true);
} }
@ -930,11 +930,11 @@ void GTextEditor::scroll_cursor_into_view()
scroll_position_into_view(m_cursor); scroll_position_into_view(m_cursor);
} }
Rect GTextEditor::line_content_rect(int line_index) const Rect GTextEditor::line_content_rect(size_t line_index) const
{ {
auto& line = lines()[line_index]; auto& line = this->line(line_index);
if (is_single_line()) { if (is_single_line()) {
Rect line_rect = { content_x_for_position({ line_index, 0 }), 0, line.length() * glyph_width(), font().glyph_height() + 2 }; Rect line_rect = { content_x_for_position({ line_index, 0 }), 0, (int)line.length() * glyph_width(), font().glyph_height() + 2 };
line_rect.center_vertically_within({ {}, frame_inner_rect().size() }); line_rect.center_vertically_within({ {}, frame_inner_rect().size() });
return line_rect; return line_rect;
} }
@ -942,8 +942,8 @@ Rect GTextEditor::line_content_rect(int line_index) const
return m_line_visual_data[line_index].visual_rect; return m_line_visual_data[line_index].visual_rect;
return { return {
content_x_for_position({ line_index, 0 }), content_x_for_position({ line_index, 0 }),
line_index * line_height(), (int)line_index * line_height(),
line.length() * glyph_width(), (int)line.length() * glyph_width(),
line_height() line_height()
}; };
} }
@ -953,7 +953,7 @@ void GTextEditor::update_cursor()
update(line_widget_rect(m_cursor.line())); update(line_widget_rect(m_cursor.line()));
} }
void GTextEditor::set_cursor(int line, int column) void GTextEditor::set_cursor(size_t line, size_t column)
{ {
set_cursor({ line, column }); set_cursor({ line, column });
} }
@ -964,15 +964,15 @@ void GTextEditor::set_cursor(const GTextPosition& a_position)
GTextPosition position = a_position; GTextPosition position = a_position;
if (position.line() >= lines().size()) if (position.line() >= line_count())
position.set_line(lines().size() - 1); position.set_line(line_count() - 1);
if (position.column() > lines()[position.line()].length()) if (position.column() > lines()[position.line()].length())
position.set_column(lines()[position.line()].length()); position.set_column(lines()[position.line()].length());
if (m_cursor != position) { if (m_cursor != position) {
// NOTE: If the old cursor is no longer valid, repaint everything just in case. // NOTE: If the old cursor is no longer valid, repaint everything just in case.
auto old_cursor_line_rect = m_cursor.line() < lines().size() auto old_cursor_line_rect = m_cursor.line() < line_count()
? line_widget_rect(m_cursor.line()) ? line_widget_rect(m_cursor.line())
: rect(); : rect();
m_cursor = position; m_cursor = position;
@ -1015,9 +1015,9 @@ bool GTextEditor::write_to_file(const StringView& path)
// Compute the final file size and ftruncate() to make writing fast. // Compute the final file size and ftruncate() to make writing fast.
// FIXME: Remove this once the kernel is smart enough to do this instead. // FIXME: Remove this once the kernel is smart enough to do this instead.
off_t file_size = 0; off_t file_size = 0;
for (int i = 0; i < lines().size(); ++i) for (size_t i = 0; i < line_count(); ++i)
file_size += lines()[i].length(); file_size += line(i).length();
file_size += lines().size() - 1; file_size += line_count() - 1;
int rc = ftruncate(fd, file_size); int rc = ftruncate(fd, file_size);
if (rc < 0) { if (rc < 0) {
@ -1025,8 +1025,8 @@ bool GTextEditor::write_to_file(const StringView& path)
return false; return false;
} }
for (int i = 0; i < lines().size(); ++i) { for (size_t i = 0; i < line_count(); ++i) {
auto& line = lines()[i]; auto& line = this->line(i);
if (line.length()) { if (line.length()) {
ssize_t nwritten = write(fd, line.characters(), line.length()); ssize_t nwritten = write(fd, line.characters(), line.length());
if (nwritten < 0) { if (nwritten < 0) {
@ -1035,7 +1035,7 @@ bool GTextEditor::write_to_file(const StringView& path)
return false; return false;
} }
} }
if (i != lines().size() - 1) { if (i != line_count() - 1) {
char ch = '\n'; char ch = '\n';
ssize_t nwritten = write(fd, &ch, 1); ssize_t nwritten = write(fd, &ch, 1);
if (nwritten != 1) { if (nwritten != 1) {
@ -1053,8 +1053,8 @@ bool GTextEditor::write_to_file(const StringView& path)
String GTextEditor::text() const String GTextEditor::text() const
{ {
StringBuilder builder; StringBuilder builder;
for (int i = 0; i < line_count(); ++i) { for (size_t i = 0; i < line_count(); ++i) {
auto& line = lines()[i]; auto& line = this->line(i);
builder.append(line.characters(), line.length()); builder.append(line.characters(), line.length());
if (i != line_count() - 1) if (i != line_count() - 1)
builder.append('\n'); builder.append('\n');
@ -1234,7 +1234,7 @@ void GTextEditor::clear_selection()
void GTextEditor::recompute_all_visual_lines() void GTextEditor::recompute_all_visual_lines()
{ {
int y_offset = 0; int y_offset = 0;
for (int line_index = 0; line_index < line_count(); ++line_index) { for (size_t line_index = 0; line_index < line_count(); ++line_index) {
recompute_visual_lines(line_index); recompute_visual_lines(line_index);
m_line_visual_data[line_index].visual_rect.set_y(y_offset); m_line_visual_data[line_index].visual_rect.set_y(y_offset);
y_offset += m_line_visual_data[line_index].visual_rect.height(); y_offset += m_line_visual_data[line_index].visual_rect.height();
@ -1246,18 +1246,18 @@ void GTextEditor::recompute_all_visual_lines()
void GTextEditor::ensure_cursor_is_valid() void GTextEditor::ensure_cursor_is_valid()
{ {
auto new_cursor = m_cursor; auto new_cursor = m_cursor;
if (new_cursor.line() >= lines().size()) if (new_cursor.line() >= line_count())
new_cursor.set_line(lines().size() - 1); new_cursor.set_line(line_count() - 1);
if (new_cursor.column() > lines()[new_cursor.line()].length()) if (new_cursor.column() > line(new_cursor.line()).length())
new_cursor.set_column(lines()[new_cursor.line()].length()); new_cursor.set_column(line(new_cursor.line()).length());
if (m_cursor != new_cursor) if (m_cursor != new_cursor)
set_cursor(new_cursor); set_cursor(new_cursor);
} }
int GTextEditor::visual_line_containing(int line_index, int column) const size_t GTextEditor::visual_line_containing(size_t line_index, size_t column) const
{ {
int visual_line_index = 0; size_t visual_line_index = 0;
for_each_visual_line(line_index, [&](const Rect&, const StringView& view, int start_of_visual_line) { for_each_visual_line(line_index, [&](const Rect&, const StringView& view, size_t start_of_visual_line) {
if (column >= start_of_visual_line && ((column - start_of_visual_line) < view.length())) if (column >= start_of_visual_line && ((column - start_of_visual_line) < view.length()))
return IterationDecision::Break; return IterationDecision::Break;
++visual_line_index; ++visual_line_index;
@ -1266,7 +1266,7 @@ int GTextEditor::visual_line_containing(int line_index, int column) const
return visual_line_index; return visual_line_index;
} }
void GTextEditor::recompute_visual_lines(int line_index) void GTextEditor::recompute_visual_lines(size_t line_index)
{ {
auto& line = document().line(line_index); auto& line = document().line(line_index);
auto& visual_data = m_line_visual_data[line_index]; auto& visual_data = m_line_visual_data[line_index];
@ -1278,7 +1278,7 @@ void GTextEditor::recompute_visual_lines(int line_index)
if (is_line_wrapping_enabled()) { if (is_line_wrapping_enabled()) {
int line_width_so_far = 0; int line_width_so_far = 0;
for (int i = 0; i < line.length(); ++i) { for (size_t i = 0; i < line.length(); ++i) {
auto ch = line.characters()[i]; auto ch = line.characters()[i];
auto glyph_width = font().glyph_width(ch); auto glyph_width = font().glyph_width(ch);
if ((line_width_so_far + glyph_width) > available_width) { if ((line_width_so_far + glyph_width) > available_width) {
@ -1299,11 +1299,11 @@ void GTextEditor::recompute_visual_lines(int line_index)
} }
template<typename Callback> template<typename Callback>
void GTextEditor::for_each_visual_line(int line_index, Callback callback) const void GTextEditor::for_each_visual_line(size_t line_index, Callback callback) const
{ {
auto editor_visible_text_rect = visible_text_rect_in_inner_coordinates(); auto editor_visible_text_rect = visible_text_rect_in_inner_coordinates();
int start_of_line = 0; size_t start_of_line = 0;
int visual_line_index = 0; size_t visual_line_index = 0;
auto& line = document().line(line_index); auto& line = document().line(line_index);
auto& visual_data = m_line_visual_data[line_index]; auto& visual_data = m_line_visual_data[line_index];
@ -1312,7 +1312,7 @@ void GTextEditor::for_each_visual_line(int line_index, Callback callback) const
auto visual_line_view = StringView(line.characters() + start_of_line, visual_line_break - start_of_line); auto visual_line_view = StringView(line.characters() + start_of_line, visual_line_break - start_of_line);
Rect visual_line_rect { Rect visual_line_rect {
visual_data.visual_rect.x(), visual_data.visual_rect.x(),
visual_data.visual_rect.y() + (visual_line_index * line_height()), visual_data.visual_rect.y() + ((int)visual_line_index * line_height()),
font().width(visual_line_view), font().width(visual_line_view),
line_height() line_height()
}; };
@ -1357,7 +1357,7 @@ void GTextEditor::document_did_append_line()
update(); update();
} }
void GTextEditor::document_did_remove_line(int line_index) void GTextEditor::document_did_remove_line(size_t line_index)
{ {
m_line_visual_data.remove(line_index); m_line_visual_data.remove(line_index);
recompute_all_visual_lines(); recompute_all_visual_lines();
@ -1371,7 +1371,7 @@ void GTextEditor::document_did_remove_all_lines()
update(); update();
} }
void GTextEditor::document_did_insert_line(int line_index) void GTextEditor::document_did_insert_line(size_t line_index)
{ {
m_line_visual_data.insert(line_index, make<LineVisualData>()); m_line_visual_data.insert(line_index, make<LineVisualData>());
recompute_all_visual_lines(); recompute_all_visual_lines();
@ -1387,7 +1387,7 @@ void GTextEditor::document_did_change()
void GTextEditor::document_did_set_text() void GTextEditor::document_did_set_text()
{ {
m_line_visual_data.clear(); m_line_visual_data.clear();
for (int i = 0; i < m_document->line_count(); ++i) for (size_t i = 0; i < m_document->line_count(); ++i)
m_line_visual_data.append(make<LineVisualData>()); m_line_visual_data.append(make<LineVisualData>());
document_did_change(); document_did_change();
} }
@ -1405,7 +1405,7 @@ void GTextEditor::set_document(GTextDocument& document)
m_document->unregister_client(*this); m_document->unregister_client(*this);
m_document = document; m_document = document;
m_line_visual_data.clear(); m_line_visual_data.clear();
for (int i = 0; i < m_document->line_count(); ++i) { for (size_t i = 0; i < m_document->line_count(); ++i) {
m_line_visual_data.append(make<LineVisualData>()); m_line_visual_data.append(make<LineVisualData>());
} }
m_cursor = { 0, 0 }; m_cursor = { 0, 0 };

30
Libraries/LibGUI/GTextEditor.h
View file

@ -56,7 +56,7 @@ public:
void set_text(const StringView&); void set_text(const StringView&);
void scroll_cursor_into_view(); void scroll_cursor_into_view();
void scroll_position_into_view(const GTextPosition&); void scroll_position_into_view(const GTextPosition&);
int line_count() const { return document().line_count(); } size_t line_count() const { return document().line_count(); }
int line_spacing() const { return m_line_spacing; } int line_spacing() const { return m_line_spacing; }
int line_height() const { return font().glyph_height() + m_line_spacing; } int line_height() const { return font().glyph_height() + m_line_spacing; }
GTextPosition cursor() const { return m_cursor; } GTextPosition cursor() const { return m_cursor; }
@ -99,7 +99,7 @@ public:
void add_custom_context_menu_action(GAction&); void add_custom_context_menu_action(GAction&);
void set_cursor(int line, int column); void set_cursor(size_t line, size_t column);
void set_cursor(const GTextPosition&); void set_cursor(const GTextPosition&);
protected: protected:
@ -130,8 +130,8 @@ private:
// ^GTextDocument::Client // ^GTextDocument::Client
virtual void document_did_append_line() override; virtual void document_did_append_line() override;
virtual void document_did_insert_line(int) override; virtual void document_did_insert_line(size_t) override;
virtual void document_did_remove_line(int) override; virtual void document_did_remove_line(size_t) override;
virtual void document_did_remove_all_lines() override; virtual void document_did_remove_all_lines() override;
virtual void document_did_change() override; virtual void document_did_change() override;
virtual void document_did_set_text() override; virtual void document_did_set_text() override;
@ -142,19 +142,19 @@ private:
void update_content_size(); void update_content_size();
void did_change(); void did_change();
Rect line_content_rect(int item_index) const; Rect line_content_rect(size_t item_index) const;
Rect line_widget_rect(int line_index) const; Rect line_widget_rect(size_t line_index) const;
Rect cursor_content_rect() const; Rect cursor_content_rect() const;
Rect content_rect_for_position(const GTextPosition&) const; Rect content_rect_for_position(const GTextPosition&) const;
void update_cursor(); void update_cursor();
const NonnullOwnPtrVector<GTextDocumentLine>& lines() const { return document().lines(); } const NonnullOwnPtrVector<GTextDocumentLine>& lines() const { return document().lines(); }
NonnullOwnPtrVector<GTextDocumentLine>& lines() { return document().lines(); } NonnullOwnPtrVector<GTextDocumentLine>& lines() { return document().lines(); }
GTextDocumentLine& line(int index) { return document().line(index); } GTextDocumentLine& line(size_t index) { return document().line(index); }
const GTextDocumentLine& line(int index) const { return document().line(index); } const GTextDocumentLine& line(size_t index) const { return document().line(index); }
GTextDocumentLine& current_line() { return line(m_cursor.line()); } GTextDocumentLine& current_line() { return line(m_cursor.line()); }
const GTextDocumentLine& current_line() const { return line(m_cursor.line()); } const GTextDocumentLine& current_line() const { return line(m_cursor.line()); }
int ruler_width() const; int ruler_width() const;
Rect ruler_content_rect(int line) const; Rect ruler_content_rect(size_t line) const;
void toggle_selection_if_needed_for_event(const GKeyEvent&); void toggle_selection_if_needed_for_event(const GKeyEvent&);
void insert_at_cursor_or_replace_selection(const StringView&); void insert_at_cursor_or_replace_selection(const StringView&);
void delete_selection(); void delete_selection();
@ -165,13 +165,13 @@ private:
void recompute_all_visual_lines(); void recompute_all_visual_lines();
void ensure_cursor_is_valid(); void ensure_cursor_is_valid();
void flush_pending_change_notification_if_needed(); void flush_pending_change_notification_if_needed();
void get_selection_line_boundaries(int& first_line, int& last_line); void get_selection_line_boundaries(size_t& first_line, size_t& last_line);
void move_selected_lines_up(); void move_selected_lines_up();
void move_selected_lines_down(); void move_selected_lines_down();
void sort_selected_lines(); void sort_selected_lines();
int visual_line_containing(int line_index, int column) const; size_t visual_line_containing(size_t line_index, size_t column) const;
void recompute_visual_lines(int line_index); void recompute_visual_lines(size_t line_index);
template<class T, class... Args> template<class T, class... Args>
inline void execute(Args&&... args) inline void execute(Args&&... args)
@ -193,7 +193,7 @@ private:
bool m_line_wrapping_enabled { false }; bool m_line_wrapping_enabled { false };
bool m_readonly { false }; bool m_readonly { false };
int m_line_spacing { 4 }; int m_line_spacing { 4 };
int m_soft_tab_width { 4 }; size_t m_soft_tab_width { 4 };
int m_horizontal_content_padding { 2 }; int m_horizontal_content_padding { 2 };
GTextRange m_selection; GTextRange m_selection;
OwnPtr<GMenu> m_context_menu; OwnPtr<GMenu> m_context_menu;
@ -209,10 +209,10 @@ private:
RefPtr<GTextDocument> m_document; RefPtr<GTextDocument> m_document;
template<typename Callback> template<typename Callback>
void for_each_visual_line(int line_index, Callback) const; void for_each_visual_line(size_t line_index, Callback) const;
struct LineVisualData { struct LineVisualData {
Vector<int, 1> visual_line_breaks; Vector<size_t, 1> visual_line_breaks;
Rect visual_rect; Rect visual_rect;
}; };

18
Libraries/LibGUI/GTextPosition.h
View file

@ -6,32 +6,32 @@
class GTextPosition { class GTextPosition {
public: public:
GTextPosition() {} GTextPosition() {}
GTextPosition(int line, int column) GTextPosition(size_t line, size_t column)
: m_line(line) : m_line(line)
, m_column(column) , m_column(column)
{ {
} }
bool is_valid() const { return m_line >= 0 && m_column >= 0; } bool is_valid() const { return m_line != 0xffffffffu && m_column != 0xffffffffu; }
int line() const { return m_line; } size_t line() const { return m_line; }
int column() const { return m_column; } size_t column() const { return m_column; }
void set_line(int line) { m_line = line; } void set_line(size_t line) { m_line = line; }
void set_column(int column) { m_column = column; } void set_column(size_t column) { m_column = column; }
bool operator==(const GTextPosition& other) const { return m_line == other.m_line && m_column == other.m_column; } bool operator==(const GTextPosition& other) const { return m_line == other.m_line && m_column == other.m_column; }
bool operator!=(const GTextPosition& other) const { return m_line != other.m_line || m_column != other.m_column; } bool operator!=(const GTextPosition& other) const { return m_line != other.m_line || m_column != other.m_column; }
bool operator<(const GTextPosition& other) const { return m_line < other.m_line || (m_line == other.m_line && m_column < other.m_column); } bool operator<(const GTextPosition& other) const { return m_line < other.m_line || (m_line == other.m_line && m_column < other.m_column); }
private: private:
int m_line { -1 }; size_t m_line { 0xffffffff };
int m_column { -1 }; size_t m_column { 0xffffffff };
}; };
inline const LogStream& operator<<(const LogStream& stream, const GTextPosition& value) inline const LogStream& operator<<(const LogStream& stream, const GTextPosition& value)
{ {
if (!value.is_valid()) if (!value.is_valid())
return stream << "GTextPosition(Invalid)"; return stream << "GTextPosition(Invalid)";
return stream << String::format("(%d,%d)", value.line(), value.column()); return stream << String::format("(%zu,%zu)", value.line(), value.column());
} }

2
Libraries/LibGUI/GWindow.cpp
View file

@ -338,7 +338,7 @@ void GWindow::paint_keybinds()
continue; continue;
auto& widget = *keypair.value; auto& widget = *keypair.value;
bool could_be_keybind = true; bool could_be_keybind = true;
for (int i = 0; i < m_entered_keybind.length(); ++i) { for (size_t i = 0; i < m_entered_keybind.length(); ++i) {
if (keypair.key.characters()[i] != m_entered_keybind.characters()[i]) { if (keypair.key.characters()[i] != m_entered_keybind.characters()[i]) {
could_be_keybind = false; could_be_keybind = false;
break; break;

2
Libraries/LibGUI/GWindow.h
View file

@ -175,7 +175,7 @@ private:
bool m_show_titlebar { true }; bool m_show_titlebar { true };
bool m_keybind_mode { false }; bool m_keybind_mode { false };
String m_entered_keybind; String m_entered_keybind;
int m_max_keybind_length { 0 }; size_t m_max_keybind_length { 0 };
HashMap<String, WeakPtr<GWidget>> m_keyboard_activation_targets; HashMap<String, WeakPtr<GWidget>> m_keyboard_activation_targets;
bool m_layout_pending { false }; bool m_layout_pending { false };
}; };

8
Libraries/LibHTML/CSS/StyleResolver.cpp
View file

@ -100,17 +100,17 @@ static Vector<String> split_on_whitespace(const StringView& string)
return {}; return {};
Vector<String> v; Vector<String> v;
int substart = 0; size_t substart = 0;
for (int i = 0; i < string.length(); ++i) { for (size_t i = 0; i < string.length(); ++i) {
char ch = string.characters_without_null_termination()[i]; char ch = string.characters_without_null_termination()[i];
if (isspace(ch)) { if (isspace(ch)) {
int sublen = i - substart; size_t sublen = i - substart;
if (sublen != 0) if (sublen != 0)
v.append(string.substring_view(substart, sublen)); v.append(string.substring_view(substart, sublen));
substart = i + 1; substart = i + 1;
} }
} }
int taillen = string.length() - substart; size_t taillen = string.length() - substart;
if (taillen != 0) if (taillen != 0)
v.append(string.substring_view(substart, taillen)); v.append(string.substring_view(substart, taillen));
return v; return v;

2
Libraries/LibHTML/DOMTreeModel.cpp
View file

@ -68,7 +68,7 @@ int DOMTreeModel::column_count(const GModelIndex&) const
static String with_whitespace_collapsed(const StringView& string) static String with_whitespace_collapsed(const StringView& string)
{ {
StringBuilder builder; StringBuilder builder;
for (int i = 0; i < string.length(); ++i) { for (size_t i = 0; i < string.length(); ++i) {
if (isspace(string[i])) { if (isspace(string[i])) {
builder.append(' '); builder.append(' ');
while (i < string.length()) { while (i < string.length()) {

2
Libraries/LibHTML/Layout/LayoutText.cpp
View file

@ -20,7 +20,7 @@ LayoutText::~LayoutText()
static bool is_all_whitespace(const String& string) static bool is_all_whitespace(const String& string)
{ {
for (int i = 0; i < string.length(); ++i) { for (size_t i = 0; i < string.length(); ++i) {
if (!isspace(string[i])) if (!isspace(string[i]))
return false; return false;
} }

10
Libraries/LibHTML/Parser/CSSParser.cpp
View file

@ -135,15 +135,15 @@ public:
bool next_is(const char* str) const bool next_is(const char* str) const
{ {
int len = strlen(str); size_t len = strlen(str);
for (int i = 0; i < len; ++i) { for (size_t i = 0; i < len; ++i) {
if (peek(i) != str[i]) if (peek(i) != str[i])
return false; return false;
} }
return true; return true;
} }
char peek(int offset = 0) const char peek(size_t offset = 0) const
{ {
if ((index + offset) < css.length()) if ((index + offset) < css.length())
return css[index + offset]; return css[index + offset];
@ -169,7 +169,7 @@ public:
bool consume_whitespace_or_comments() bool consume_whitespace_or_comments()
{ {
int original_index = index; size_t original_index = index;
bool in_comment = false; bool in_comment = false;
for (; index < css.length(); ++index) { for (; index < css.length(); ++index) {
char ch = peek(); char ch = peek();
@ -582,7 +582,7 @@ private:
CurrentRule current_rule; CurrentRule current_rule;
Vector<char> buffer; Vector<char> buffer;
int index = 0; size_t index = 0;
StringView css; StringView css;
}; };

6
Libraries/LibHTML/Parser/HTMLParser.cpp
View file

@ -129,8 +129,8 @@ static bool parse_html_document(const StringView& html, Document& document, Pare
} }
}; };
for (int i = 0; i < html.length(); ++i) { for (size_t i = 0; i < html.length(); ++i) {
auto peek = [&](int offset) -> char { auto peek = [&](size_t offset) -> char {
if (i + offset >= html.length()) if (i + offset >= html.length())
return '\0'; return '\0';
return html[i + offset]; return html[i + offset];
@ -356,7 +356,7 @@ RefPtr<Document> parse_html_document(const StringView& html, const URL& url)
String escape_html_entities(const StringView& html) String escape_html_entities(const StringView& html)
{ {
StringBuilder builder; StringBuilder builder;
for (int i = 0; i < html.length(); ++i) { for (size_t i = 0; i < html.length(); ++i) {
if (html[i] == '<') if (html[i] == '<')
builder.append("&lt;"); builder.append("&lt;");
else if (html[i] == '>') else if (html[i] == '>')

2
Libraries/LibMarkdown/MDCodeBlock.cpp
View file

@ -33,7 +33,7 @@ String MDCodeBlock::render_to_html() const
builder.appendf("<code style=\"white-space: pre;\" class=\"%s\">", style_language.characters()); builder.appendf("<code style=\"white-space: pre;\" class=\"%s\">", style_language.characters());
// TODO: This should also be done in other places. // TODO: This should also be done in other places.
for (int i = 0; i < m_code.length(); i++) for (size_t i = 0; i < m_code.length(); i++)
if (m_code[i] == '<') if (m_code[i] == '<')
builder.append("&lt;"); builder.append("&lt;");
else if (m_code[i] == '>') else if (m_code[i] == '>')

8
Libraries/LibMarkdown/MDHeading.cpp
View file

@ -38,14 +38,14 @@ bool MDHeading::parse(Vector<StringView>::ConstIterator& lines)
const StringView& line = *lines; const StringView& line = *lines;
for (m_level = 0; m_level < line.length(); m_level++) for (m_level = 0; m_level < (int)line.length(); m_level++)
if (line[m_level] != '#') if (line[(size_t)m_level] != '#')
break; break;
if (m_level >= line.length() || line[m_level] != ' ') if (m_level >= (int)line.length() || line[(size_t)m_level] != ' ')
return false; return false;
StringView title_view = line.substring_view(m_level + 1, line.length() - m_level - 1); StringView title_view = line.substring_view((size_t)m_level + 1, line.length() - (size_t)m_level - 1);
bool success = m_text.parse(title_view); bool success = m_text.parse(title_view);
ASSERT(success); ASSERT(success);

4
Libraries/LibMarkdown/MDList.cpp
View file

@ -49,7 +49,7 @@ bool MDList::parse(Vector<StringView>::ConstIterator& lines)
break; break;
bool appears_unordered = false; bool appears_unordered = false;
int offset = 0; size_t offset = 0;
if (line.length() > 2) if (line.length() > 2)
if (line[1] == ' ' && (line[0] == '*' || line[0] == '-')) { if (line[1] == ' ' && (line[0] == '*' || line[0] == '-')) {
appears_unordered = true; appears_unordered = true;
@ -57,7 +57,7 @@ bool MDList::parse(Vector<StringView>::ConstIterator& lines)
} }
bool appears_ordered = false; bool appears_ordered = false;
for (int i = 0; i < 10 && i < line.length(); i++) { for (size_t i = 0; i < 10 && i < line.length(); i++) {
char ch = line[i]; char ch = line[i];
if ('0' <= ch && ch <= '9') if ('0' <= ch && ch <= '9')
continue; continue;

10
Libraries/LibMarkdown/MDText.cpp
View file

@ -4,7 +4,7 @@
static String unescape(const StringView& text) static String unescape(const StringView& text)
{ {
StringBuilder builder; StringBuilder builder;
for (int i = 0; i < text.length(); ++i) { for (size_t i = 0; i < text.length(); ++i) {
if (text[i] == '\\' && i != text.length() - 1) { if (text[i] == '\\' && i != text.length() - 1) {
builder.append(text[i + 1]); builder.append(text[i + 1]);
i++; i++;
@ -125,10 +125,10 @@ String MDText::render_for_terminal() const
bool MDText::parse(const StringView& str) bool MDText::parse(const StringView& str)
{ {
Style current_style; Style current_style;
int current_span_start = 0; size_t current_span_start = 0;
int first_span_in_the_current_link = -1; int first_span_in_the_current_link = -1;
auto append_span_if_needed = [&](int offset) { auto append_span_if_needed = [&](size_t offset) {
if (current_span_start != offset) { if (current_span_start != offset) {
Span span { Span span {
unescape(str.substring_view(current_span_start, offset - current_span_start)), unescape(str.substring_view(current_span_start, offset - current_span_start)),
@ -138,7 +138,7 @@ bool MDText::parse(const StringView& str)
} }
}; };
for (int offset = 0; offset < str.length(); offset++) { for (size_t offset = 0; offset < str.length(); offset++) {
char ch = str[offset]; char ch = str[offset];
bool is_escape = ch == '\\'; bool is_escape = ch == '\\';
@ -179,7 +179,7 @@ bool MDText::parse(const StringView& str)
offset++; offset++;
ASSERT(str[offset] == '('); ASSERT(str[offset] == '(');
offset++; offset++;
int start_of_href = offset; size_t start_of_href = offset;
do do
offset++; offset++;

4
Libraries/LibPCIDB/Database.cpp
View file

@ -89,12 +89,12 @@ u8 parse_hex_digit(char digit)
} }
template<typename T> template<typename T>
T parse_hex(StringView str, int count) T parse_hex(StringView str, size_t count)
{ {
ASSERT(str.length() >= count); ASSERT(str.length() >= count);
T res = 0; T res = 0;
for (int i = 0; i < count; i++) for (size_t i = 0; i < count; i++)
res = (res << 4) + parse_hex_digit(str[i]); res = (res << 4) + parse_hex_digit(str[i]);
return res; return res;

2
Libraries/LibVT/Terminal.cpp
View file

@ -837,7 +837,7 @@ void Terminal::on_char(u8 ch)
void Terminal::inject_string(const StringView& str) void Terminal::inject_string(const StringView& str)
{ {
for (int i = 0; i < str.length(); ++i) for (size_t i = 0; i < str.length(); ++i)
on_char(str[i]); on_char(str[i]);
} }

11
Servers/TelnetServer/Client.cpp
View file

@ -1,3 +1,4 @@
#include "Client.h"
#include <AK/BufferStream.h> #include <AK/BufferStream.h>
#include <AK/ByteBuffer.h> #include <AK/ByteBuffer.h>
#include <AK/String.h> #include <AK/String.h>
@ -7,8 +8,7 @@
#include <LibCore/CNotifier.h> #include <LibCore/CNotifier.h>
#include <LibCore/CTCPSocket.h> #include <LibCore/CTCPSocket.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h>
#include "Client.h"
Client::Client(int id, RefPtr<CTCPSocket> socket, int ptm_fd) Client::Client(int id, RefPtr<CTCPSocket> socket, int ptm_fd)
: m_id(id) : m_id(id)
@ -56,7 +56,7 @@ void Client::drain_pty()
quit(); quit();
return; return;
} }
send_data(StringView(buffer, nread)); send_data(StringView(buffer, (size_t)nread));
} }
void Client::handle_data(const StringView& data) void Client::handle_data(const StringView& data)
@ -105,7 +105,7 @@ void Client::handle_error()
void Client::send_data(StringView data) void Client::send_data(StringView data)
{ {
bool fast = true; bool fast = true;
for (int i = 0; i < data.length(); i++) { for (size_t i = 0; i < data.length(); i++) {
u8 c = data[i]; u8 c = data[i];
if (c == '\n' || c == 0xff) if (c == '\n' || c == 0xff)
fast = false; fast = false;
@ -117,7 +117,7 @@ void Client::send_data(StringView data)
} }
StringBuilder builder; StringBuilder builder;
for (int i = 0; i < data.length(); i++) { for (size_t i = 0; i < data.length(); i++) {
u8 c = data[i]; u8 c = data[i];
switch (c) { switch (c) {
@ -136,7 +136,6 @@ void Client::send_data(StringView data)
m_socket->write(builder.to_string()); m_socket->write(builder.to_string());
} }
void Client::send_command(Command command) void Client::send_command(Command command)
{ {
send_commands({ command }); send_commands({ command });

2
Servers/TelnetServer/Parser.cpp
View file

@ -6,7 +6,7 @@
void Parser::write(const StringView& data) void Parser::write(const StringView& data)
{ {
for (int i = 0; i < data.length(); i++) { for (size_t i = 0; i < data.length(); i++) {
u8 ch = data[i]; u8 ch = data[i];
switch (m_state) { switch (m_state) {

54
Shell/LineEditor.cpp
View file

@ -21,7 +21,7 @@ void LineEditor::add_to_history(const String& line)
void LineEditor::clear_line() void LineEditor::clear_line()
{ {
for (int i = 0; i < m_cursor; ++i) for (size_t i = 0; i < m_cursor; ++i)
fputc(0x8, stdout); fputc(0x8, stdout);
fputs("\033[K", stdout); fputs("\033[K", stdout);
fflush(stdout); fflush(stdout);
@ -31,10 +31,10 @@ void LineEditor::clear_line()
void LineEditor::append(const String& string) void LineEditor::append(const String& string)
{ {
m_buffer.append(string.characters(), string.length()); m_buffer.append(string.characters(), (int)string.length());
fputs(string.characters(), stdout); fputs(string.characters(), stdout);
fflush(stdout); fflush(stdout);
m_cursor = m_buffer.size(); m_cursor = (size_t)m_buffer.size();
} }
void LineEditor::cache_path() void LineEditor::cache_path()
@ -68,9 +68,9 @@ void LineEditor::cache_path()
quick_sort(m_path.begin(), m_path.end(), AK::is_less_than<String>); quick_sort(m_path.begin(), m_path.end(), AK::is_less_than<String>);
} }
void LineEditor::cut_mismatching_chars(String& completion, const String& program, int token_length) void LineEditor::cut_mismatching_chars(String& completion, const String& program, size_t token_length)
{ {
int i = token_length; size_t i = token_length;
while (i < completion.length() && i < program.length() && completion[i] == program[i]) while (i < completion.length() && i < program.length() && completion[i] == program[i])
++i; ++i;
completion = completion.substring(0, i); completion = completion.substring(0, i);
@ -139,17 +139,17 @@ String LineEditor::get_line(const String& prompt)
} }
auto do_delete = [&] { auto do_delete = [&] {
if (m_cursor == m_buffer.size()) { if (m_cursor == (size_t)m_buffer.size()) {
fputc('\a', stdout); fputc('\a', stdout);
fflush(stdout); fflush(stdout);
return; return;
} }
m_buffer.remove(m_cursor - 1); m_buffer.remove((int)m_cursor - 1);
fputs("\033[3~", stdout); fputs("\033[3~", stdout);
fflush(stdout); fflush(stdout);
vt_save_cursor(); vt_save_cursor();
vt_clear_to_end_of_line(); vt_clear_to_end_of_line();
for (int i = m_cursor; i < m_buffer.size(); ++i) for (size_t i = m_cursor; i < (size_t)m_buffer.size(); ++i)
fputc(m_buffer[i], stdout); fputc(m_buffer[i], stdout);
vt_restore_cursor(); vt_restore_cursor();
}; };
@ -195,7 +195,7 @@ String LineEditor::get_line(const String& prompt)
m_state = InputState::Free; m_state = InputState::Free;
continue; continue;
case 'C': // right case 'C': // right
if (m_cursor < m_buffer.size()) { if (m_cursor < (size_t)m_buffer.size()) {
++m_cursor; ++m_cursor;
fputs("\033[C", stdout); fputs("\033[C", stdout);
fflush(stdout); fflush(stdout);
@ -204,17 +204,17 @@ String LineEditor::get_line(const String& prompt)
continue; continue;
case 'H': case 'H':
if (m_cursor > 0) { if (m_cursor > 0) {
fprintf(stdout, "\033[%dD", m_cursor); fprintf(stdout, "\033[%zuD", m_cursor);
fflush(stdout); fflush(stdout);
m_cursor = 0; m_cursor = 0;
} }
m_state = InputState::Free; m_state = InputState::Free;
continue; continue;
case 'F': case 'F':
if (m_cursor < m_buffer.size()) { if (m_cursor < (size_t)m_buffer.size()) {
fprintf(stdout, "\033[%dC", m_buffer.size() - m_cursor); fprintf(stdout, "\033[%zuC", (size_t)m_buffer.size() - m_cursor);
fflush(stdout); fflush(stdout);
m_cursor = m_buffer.size(); m_cursor = (size_t)m_buffer.size();
} }
m_state = InputState::Free; m_state = InputState::Free;
continue; continue;
@ -264,13 +264,13 @@ String LineEditor::get_line(const String& prompt)
fflush(stdout); fflush(stdout);
return; return;
} }
m_buffer.remove(m_cursor - 1); m_buffer.remove((int)m_cursor - 1);
--m_cursor; --m_cursor;
putchar(8); putchar(8);
vt_save_cursor(); vt_save_cursor();
vt_clear_to_end_of_line(); vt_clear_to_end_of_line();
for (int i = m_cursor; i < m_buffer.size(); ++i) for (size_t i = m_cursor; i < (size_t)m_buffer.size(); ++i)
fputc(m_buffer[i], stdout); fputc(m_buffer[(int)i], stdout);
vt_restore_cursor(); vt_restore_cursor();
}; };
@ -281,7 +281,7 @@ String LineEditor::get_line(const String& prompt)
if (ch == g.termios.c_cc[VWERASE]) { if (ch == g.termios.c_cc[VWERASE]) {
bool has_seen_nonspace = false; bool has_seen_nonspace = false;
while (m_cursor > 0) { while (m_cursor > 0) {
if (isspace(m_buffer[m_cursor - 1])) { if (isspace(m_buffer[(int)m_cursor - 1])) {
if (has_seen_nonspace) if (has_seen_nonspace)
break; break;
} else { } else {
@ -301,14 +301,14 @@ String LineEditor::get_line(const String& prompt)
fputs(prompt.characters(), stdout); fputs(prompt.characters(), stdout);
for (int i = 0; i < m_buffer.size(); ++i) for (int i = 0; i < m_buffer.size(); ++i)
fputc(m_buffer[i], stdout); fputc(m_buffer[i], stdout);
if (m_cursor < m_buffer.size()) if (m_cursor < (size_t)m_buffer.size())
printf("\033[%dD", m_buffer.size() - m_cursor); // Move cursor N steps left. printf("\033[%zuD", (size_t)m_buffer.size() - m_cursor); // Move cursor N steps left.
fflush(stdout); fflush(stdout);
continue; continue;
} }
if (ch == 0x01) { // ^A if (ch == 0x01) { // ^A
if (m_cursor > 0) { if (m_cursor > 0) {
printf("\033[%dD", m_cursor); printf("\033[%zuD", m_cursor);
fflush(stdout); fflush(stdout);
m_cursor = 0; m_cursor = 0;
} }
@ -322,10 +322,10 @@ String LineEditor::get_line(const String& prompt)
continue; continue;
} }
if (ch == 0x05) { // ^E if (ch == 0x05) { // ^E
if (m_cursor < m_buffer.size()) { if (m_cursor < (size_t)m_buffer.size()) {
printf("\033[%dC", m_buffer.size() - m_cursor); printf("\033[%zuC", (size_t)m_buffer.size() - m_cursor);
fflush(stdout); fflush(stdout);
m_cursor = m_buffer.size(); m_cursor = (size_t)m_buffer.size();
} }
continue; continue;
} }
@ -337,17 +337,17 @@ String LineEditor::get_line(const String& prompt)
return string; return string;
} }
if (m_cursor == m_buffer.size()) { if (m_cursor == (size_t)m_buffer.size()) {
m_buffer.append(ch); m_buffer.append(ch);
++m_cursor; ++m_cursor;
continue; continue;
} }
vt_save_cursor(); vt_save_cursor();
vt_clear_to_end_of_line(); vt_clear_to_end_of_line();
for (int i = m_cursor; i < m_buffer.size(); ++i) for (size_t i = m_cursor; i < (size_t)m_buffer.size(); ++i)
fputc(m_buffer[i], stdout); fputc(m_buffer[(int)i], stdout);
vt_restore_cursor(); vt_restore_cursor();
m_buffer.insert(m_cursor, move(ch)); m_buffer.insert((int)m_cursor, move(ch));
++m_cursor; ++m_cursor;
} }
} }

4
Shell/LineEditor.h
View file

@ -23,14 +23,14 @@ public:
private: private:
void clear_line(); void clear_line();
void append(const String&); void append(const String&);
void cut_mismatching_chars(String& completion, const String& program, int token_length); void cut_mismatching_chars(String& completion, const String& program, size_t token_length);
void tab_complete_first_token(); void tab_complete_first_token();
void vt_save_cursor(); void vt_save_cursor();
void vt_restore_cursor(); void vt_restore_cursor();
void vt_clear_to_end_of_line(); void vt_clear_to_end_of_line();
Vector<char, 1024> m_buffer; Vector<char, 1024> m_buffer;
int m_cursor { 0 }; size_t m_cursor { 0 };
// FIXME: This should be something more take_first()-friendly. // FIXME: This should be something more take_first()-friendly.
Vector<String> m_history; Vector<String> m_history;

4
Shell/Parser.cpp
View file

@ -48,7 +48,7 @@ void Parser::begin_redirect_write(int fd)
Vector<Command> Parser::parse() Vector<Command> Parser::parse()
{ {
for (int i = 0; i < m_input.length(); ++i) { for (size_t i = 0; i < m_input.length(); ++i) {
char ch = m_input.characters()[i]; char ch = m_input.characters()[i];
switch (m_state) { switch (m_state) {
case State::Free: case State::Free:
@ -107,7 +107,7 @@ Vector<Command> Parser::parse()
// redirection from zsh-style multi-digit fd, such as {10}>file // redirection from zsh-style multi-digit fd, such as {10}>file
if (ch == '{') { if (ch == '{') {
bool is_multi_fd_redirection = false; bool is_multi_fd_redirection = false;
int redir_end = i + 1; size_t redir_end = i + 1;
while (redir_end < m_input.length()) { while (redir_end < m_input.length()) {
char lookahead_ch = m_input.characters()[redir_end]; char lookahead_ch = m_input.characters()[redir_end];

10
Shell/main.cpp
View file

@ -457,7 +457,7 @@ struct CommandTimer {
static bool is_glob(const StringView& s) static bool is_glob(const StringView& s)
{ {
for (int i = 0; i < s.length(); i++) { for (size_t i = 0; i < s.length(); i++) {
char c = s.characters_without_null_termination()[i]; char c = s.characters_without_null_termination()[i];
if (c == '*' || c == '?') if (c == '*' || c == '?')
return true; return true;
@ -469,19 +469,19 @@ static Vector<StringView> split_path(const StringView& path)
{ {
Vector<StringView> parts; Vector<StringView> parts;
ssize_t substart = 0; size_t substart = 0;
for (ssize_t i = 0; i < path.length(); i++) { for (size_t i = 0; i < path.length(); i++) {
char ch = path.characters_without_null_termination()[i]; char ch = path.characters_without_null_termination()[i];
if (ch != '/') if (ch != '/')
continue; continue;
ssize_t sublen = i - substart; size_t sublen = i - substart;
if (sublen != 0) if (sublen != 0)
parts.append(path.substring_view(substart, sublen)); parts.append(path.substring_view(substart, sublen));
parts.append(path.substring_view(i, 1)); parts.append(path.substring_view(i, 1));
substart = i + 1; substart = i + 1;
} }
ssize_t taillen = path.length() - substart; size_t taillen = path.length() - substart;
if (taillen != 0) if (taillen != 0)
parts.append(path.substring_view(substart, taillen)); parts.append(path.substring_view(substart, taillen));

12
Userland/ls.cpp
View file

@ -28,8 +28,8 @@ static bool flag_human_readable = false;
static bool flag_sort_by_timestamp = false; static bool flag_sort_by_timestamp = false;
static bool flag_reverse_sort = false; static bool flag_reverse_sort = false;
static int terminal_rows = 0; static size_t terminal_rows = 0;
static int terminal_columns = 0; static size_t terminal_columns = 0;
static bool output_is_terminal = false; static bool output_is_terminal = false;
int main(int argc, char** argv) int main(int argc, char** argv)
@ -326,7 +326,7 @@ int do_file_system_object_short(const char* path)
} }
Vector<String> names; Vector<String> names;
int longest_name = 0; size_t longest_name = 0;
while (di.has_next()) { while (di.has_next()) {
String name = di.next_path(); String name = di.next_path();
names.append(name); names.append(name);
@ -335,7 +335,7 @@ int do_file_system_object_short(const char* path)
} }
quick_sort(names.begin(), names.end(), [](auto& a, auto& b) { return a < b; }); quick_sort(names.begin(), names.end(), [](auto& a, auto& b) { return a < b; });
int printed_on_row = 0; size_t printed_on_row = 0;
int nprinted; int nprinted;
for (int i = 0; i < names.size(); ++i) { for (int i = 0; i < names.size(); ++i) {
auto& name = names[i]; auto& name = names[i];
@ -352,10 +352,10 @@ int do_file_system_object_short(const char* path)
// The offset must be at least 2 because: // The offset must be at least 2 because:
// - With each file an aditional char is printed e.g. '@','*'. // - With each file an aditional char is printed e.g. '@','*'.
// - Each filename must be separated by a space. // - Each filename must be separated by a space.
int column_width = longest_name + (offset > 0 ? offset : 2); size_t column_width = longest_name + (offset > 0 ? offset : 2);
printed_on_row += column_width; printed_on_row += column_width;
for (int j = nprinted; i != (names.size() - 1) && j < column_width; ++j) for (int j = nprinted; i != (names.size() - 1) && j < (int)column_width; ++j)
printf(" "); printf(" ");
if ((printed_on_row + column_width) >= terminal_columns) { if ((printed_on_row + column_width) >= terminal_columns) {
printf("\n"); printf("\n");

2
Userland/man.cpp
View file

@ -57,7 +57,7 @@ int main(int argc, char* argv[])
} }
dbg() << "Loading man page from " << file->filename(); dbg() << "Loading man page from " << file->filename();
auto buffer = file->read_all(); auto buffer = file->read_all();
String source { (char*)buffer.data(), buffer.size() }; String source { (const char*)buffer.data(), (size_t)buffer.size() };
printf("%s(%s)\t\tSerenity manual\n", name.characters(), section.characters()); printf("%s(%s)\t\tSerenity manual\n", name.characters(), section.characters());

2
Userland/md.cpp
View file

@ -30,7 +30,7 @@ int main(int argc, char* argv[])
auto buffer = file->read_all(); auto buffer = file->read_all();
dbg() << "Read size " << buffer.size(); dbg() << "Read size " << buffer.size();
String input { (char*)buffer.data(), buffer.size() }; String input { (const char*)buffer.data(), (size_t)buffer.size() };
MDDocument document; MDDocument document;
success = document.parse(input); success = document.parse(input);