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

More moving towards using signed types.

Browse source 
I'm still feeling this out, but I am starting to like the general idea.
This commit is contained in:
Andreas Kling 2019-02-25 22:06:55 +01:00
parent beda478821
commit 9624b54703
Notes: sideshowbarker 2024-07-19 15:37:54 +09:00 
Author: https://github.com/awesomekling
Commit: https://github.com/SerenityOS/serenity/commit/9624b54703f
48 changed files with 234 additions and 250 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
AK/AKString.h
View file

@ -29,7 +29,7 @@ public:
{
}
String(const char* cstring, size_t length, ShouldChomp shouldChomp = NoChomp)
String(const char* cstring, ssize_t length, ShouldChomp shouldChomp = NoChomp)
: m_impl(StringImpl::create(cstring, length, shouldChomp))
{
}
@ -66,13 +66,13 @@ public:
}
Vector<String> split(char separator) const;
String substring(size_t start, size_t length) const;
String substring(ssize_t start, ssize_t length) const;
bool is_null() const { return !m_impl; }
bool is_empty() const { return length() == 0; }
size_t length() const { return m_impl ? m_impl->length() : 0; }
ssize_t length() const { return m_impl ? m_impl->length() : 0; }
const char* characters() const { return m_impl ? m_impl->characters() : nullptr; }
char operator[](size_t i) const { ASSERT(m_impl); return (*m_impl)[i]; }
char operator[](ssize_t i) const { ASSERT(m_impl); return (*m_impl)[i]; }
bool operator==(const String&) const;
bool operator!=(const String& other) const { return !(*this == other); }

18
AK/Bitmap.h
View file

@ -10,12 +10,12 @@ namespace AK {
class Bitmap {
public:
// NOTE: A wrapping Bitmap won't try to free the wrapped data.
static Bitmap wrap(byte* data, unsigned size)
static Bitmap wrap(byte* data, int size)
{
return Bitmap(data, size);
}
static Bitmap create(unsigned size, bool default_value = 0)
static Bitmap create(int size, bool default_value = 0)
{
return Bitmap(size, default_value);
}
@ -27,13 +27,13 @@ public:
m_data = nullptr;
}
unsigned size() const { return m_size; }
bool get(unsigned index) const
int size() const { return m_size; }
bool get(int index) const
{
ASSERT(index < m_size);
return 0 != (m_data[index / 8] & (1u << (index % 8)));
}
void set(unsigned index, bool value) const
void set(int index, bool value) const
{
ASSERT(index < m_size);
if (value)
@ -46,17 +46,17 @@ public:
const byte* data() const { return m_data; }
private:
explicit Bitmap(unsigned size, bool default_value)
explicit Bitmap(int size, bool default_value)
: m_size(size)
, m_owned(true)
{
ASSERT(m_size != 0);
size_t size_to_allocate = ceil_div(size, 8u);
int size_to_allocate = ceil_div(size, 8);
m_data = reinterpret_cast<byte*>(kmalloc(size_to_allocate));
memset(m_data, default_value ? 0xff : 0x00, size_to_allocate);
}
Bitmap(byte* data, unsigned size)
Bitmap(byte* data, int size)
: m_data(data)
, m_size(size)
, m_owned(false)
@ -64,7 +64,7 @@ private:
}
byte* m_data { nullptr };
unsigned m_size { 0 };
int m_size { 0 };
bool m_owned { false };
};

46
AK/Buffer.h
View file

@ -11,10 +11,10 @@ namespace AK {
template<typename T>
class Buffer : public Retainable<Buffer<T>> {
public:
static Retained<Buffer> create_uninitialized(size_t count);
static Retained<Buffer> copy(const T*, size_t count);
static Retained<Buffer> wrap(T*, size_t count);
static Retained<Buffer> adopt(T*, size_t count);
static Retained<Buffer> create_uninitialized(ssize_t count);
static Retained<Buffer> copy(const T*, ssize_t count);
static Retained<Buffer> wrap(T*, ssize_t count);
static Retained<Buffer> adopt(T*, ssize_t count);
~Buffer() { clear(); }
@ -27,42 +27,42 @@ public:
m_elements = nullptr;
}
T& operator[](size_t i) { ASSERT(i < m_size); return m_elements[i]; }
const T& operator[](size_t i) const { ASSERT(i < m_size); return m_elements[i]; }
T& operator[](ssize_t i) { ASSERT(i < m_size); return m_elements[i]; }
const T& operator[](ssize_t i) const { ASSERT(i < m_size); return m_elements[i]; }
bool is_empty() const { return !m_size; }
size_t size() const { return m_size; }
ssize_t size() const { return m_size; }
T* pointer() { return m_elements; }
const T* pointer() const { return m_elements; }
T* offset_pointer(size_t offset) { return m_elements + offset; }
const T* offset_pointer(size_t offset) const { return m_elements + offset; }
T* offset_pointer(ssize_t offset) { return m_elements + offset; }
const T* offset_pointer(ssize_t offset) const { return m_elements + offset; }
const void* end_pointer() const { return m_elements + m_size; }
// NOTE: trim() does not reallocate.
void trim(size_t size)
void trim(ssize_t size)
{
ASSERT(size <= m_size);
m_size = size;
}
void grow(size_t size);
void grow(ssize_t size);
private:
enum ConstructionMode { Uninitialized, Copy, Wrap, Adopt };
explicit Buffer(size_t); // For ConstructionMode=Uninitialized
Buffer(const T*, size_t, ConstructionMode); // For ConstructionMode=Copy
Buffer(T*, size_t, ConstructionMode); // For ConstructionMode=Wrap/Adopt
explicit Buffer(ssize_t); // For ConstructionMode=Uninitialized
Buffer(const T*, ssize_t, ConstructionMode); // For ConstructionMode=Copy
Buffer(T*, ssize_t, ConstructionMode); // For ConstructionMode=Wrap/Adopt
Buffer() { }
T* m_elements { nullptr };
size_t m_size { 0 };
ssize_t m_size { 0 };
bool m_owned { false };
};
template<typename T>
inline Buffer<T>::Buffer(size_t size)
inline Buffer<T>::Buffer(ssize_t size)
: m_size(size)
{
m_elements = static_cast<T*>(kmalloc(size * sizeof(T)));
@ -70,7 +70,7 @@ inline Buffer<T>::Buffer(size_t size)
}
template<typename T>
inline Buffer<T>::Buffer(const T* elements, size_t size, ConstructionMode mode)
inline Buffer<T>::Buffer(const T* elements, ssize_t size, ConstructionMode mode)
: m_size(size)
{
ASSERT(mode == Copy);
@ -80,7 +80,7 @@ inline Buffer<T>::Buffer(const T* elements, size_t size, ConstructionMode mode)
}
template<typename T>
inline Buffer<T>::Buffer(T* elements, size_t size, ConstructionMode mode)
inline Buffer<T>::Buffer(T* elements, ssize_t size, ConstructionMode mode)
: m_elements(elements)
, m_size(size)
{
@ -92,7 +92,7 @@ inline Buffer<T>::Buffer(T* elements, size_t size, ConstructionMode mode)
}
template<typename T>
inline void Buffer<T>::grow(size_t size)
inline void Buffer<T>::grow(ssize_t size)
{
ASSERT(size > m_size);
ASSERT(m_owned);
@ -105,25 +105,25 @@ inline void Buffer<T>::grow(size_t size)
}
template<typename T>
inline Retained<Buffer<T>> Buffer<T>::create_uninitialized(size_t size)
inline Retained<Buffer<T>> Buffer<T>::create_uninitialized(ssize_t size)
{
return ::adopt(*new Buffer<T>(size));
}
template<typename T>
inline Retained<Buffer<T>> Buffer<T>::copy(const T* elements, size_t size)
inline Retained<Buffer<T>> Buffer<T>::copy(const T* elements, ssize_t size)
{
return ::adopt(*new Buffer<T>(elements, size, Copy));
}
template<typename T>
inline Retained<Buffer<T>> Buffer<T>::wrap(T* elements, size_t size)
inline Retained<Buffer<T>> Buffer<T>::wrap(T* elements, ssize_t size)
{
return ::adopt(*new Buffer<T>(elements, size, Wrap));
}
template<typename T>
inline Retained<Buffer<T>> Buffer<T>::adopt(T* elements, size_t size)
inline Retained<Buffer<T>> Buffer<T>::adopt(T* elements, ssize_t size)
{
return ::adopt(*new Buffer<T>(elements, size, Adopt));
}

13
AK/BufferStream.h
View file

@ -37,20 +37,21 @@ public:
void operator<<(const char* str)
{
size_t len = strlen(str);
for (unsigned i = 0; i < len; ++i)
ssize_t len = strlen(str);
ASSERT(len >= 0);
for (ssize_t i = 0; i < len; ++i)
m_buffer[m_offset++] = str[i];
}
void operator<<(const String& value)
{
for (unsigned i = 0; i < value.length(); ++i)
for (ssize_t i = 0; i < value.length(); ++i)
m_buffer[m_offset++] = value[i];
}
void operator<<(const ByteBuffer& value)
{
for (size_t i = 0; i < value.size(); ++i)
for (ssize_t i = 0; i < value.size(); ++i)
m_buffer[m_offset++] = value[i];
}
@ -65,11 +66,11 @@ public:
m_buffer[m_offset++] = ch;
}
size_t offset() const { return m_offset; }
ssize_t offset() const { return m_offset; }
private:
ByteBuffer& m_buffer;
size_t m_offset { 0 };
ssize_t m_offset { 0 };
};
}

24
AK/ByteBuffer.h
View file

@ -30,10 +30,10 @@ public:
return *this;
}
static ByteBuffer create_uninitialized(size_t size) { return ByteBuffer(Buffer<byte>::create_uninitialized(size)); }
static ByteBuffer copy(const byte* data, size_t size) { return ByteBuffer(Buffer<byte>::copy(data, size)); }
static ByteBuffer wrap(byte* data, size_t size) { return ByteBuffer(Buffer<byte>::wrap(data, size)); }
static ByteBuffer adopt(byte* data, size_t size) { return ByteBuffer(Buffer<byte>::adopt(data, size)); }
static ByteBuffer create_uninitialized(ssize_t size) { return ByteBuffer(Buffer<byte>::create_uninitialized(size)); }
static ByteBuffer copy(const byte* data, ssize_t size) { return ByteBuffer(Buffer<byte>::copy(data, size)); }
static ByteBuffer wrap(byte* data, ssize_t size) { return ByteBuffer(Buffer<byte>::wrap(data, size)); }
static ByteBuffer adopt(byte* data, ssize_t size) { return ByteBuffer(Buffer<byte>::adopt(data, size)); }
~ByteBuffer() { clear(); }
void clear() { m_impl = nullptr; }
@ -42,27 +42,27 @@ public:
bool operator!() const { return is_null(); }
bool is_null() const { return m_impl == nullptr; }
byte& operator[](size_t i) { ASSERT(m_impl); return (*m_impl)[i]; }
byte operator[](size_t i) const { ASSERT(m_impl); return (*m_impl)[i]; }
byte& operator[](ssize_t i) { ASSERT(m_impl); return (*m_impl)[i]; }
byte operator[](ssize_t i) const { ASSERT(m_impl); return (*m_impl)[i]; }
bool is_empty() const { return !m_impl || m_impl->is_empty(); }
size_t size() const { return m_impl ? m_impl->size() : 0; }
ssize_t size() const { return m_impl ? m_impl->size() : 0; }
byte* pointer() { return m_impl ? m_impl->pointer() : nullptr; }
const byte* pointer() const { return m_impl ? m_impl->pointer() : nullptr; }
byte* offset_pointer(size_t offset) { return m_impl ? m_impl->offset_pointer(offset) : nullptr; }
const byte* offset_pointer(size_t offset) const { return m_impl ? m_impl->offset_pointer(offset) : nullptr; }
byte* offset_pointer(ssize_t offset) { return m_impl ? m_impl->offset_pointer(offset) : nullptr; }
const byte* offset_pointer(ssize_t offset) const { return m_impl ? m_impl->offset_pointer(offset) : nullptr; }
const void* end_pointer() const { return m_impl ? m_impl->end_pointer() : nullptr; }
// NOTE: trim() does not reallocate.
void trim(size_t size)
void trim(ssize_t size)
{
if (m_impl)
m_impl->trim(size);
}
ByteBuffer slice(size_t offset, size_t size) const
ByteBuffer slice(ssize_t offset, ssize_t size) const
{
if (is_null())
return { };
@ -73,7 +73,7 @@ public:
return copy(offset_pointer(offset), size);
}
void grow(size_t size)
void grow(ssize_t size)
{
if (!m_impl)
m_impl = Buffer<byte>::create_uninitialized(size);

12
AK/String.cpp
View file

@ -36,7 +36,7 @@ String String::isolated_copy() const
return String(move(*impl));
}
String String::substring(size_t start, size_t length) const
String String::substring(ssize_t start, ssize_t length) const
{
ASSERT(m_impl);
ASSERT(start + length <= m_impl->length());
@ -54,17 +54,17 @@ Vector<String> String::split(const char separator) const
return { };
Vector<String> v;
size_t substart = 0;
for (size_t i = 0; i < length(); ++i) {
ssize_t substart = 0;
for (ssize_t i = 0; i < length(); ++i) {
char ch = characters()[i];
if (ch == separator) {
size_t sublen = i - substart;
ssize_t sublen = i - substart;
if (sublen != 0)
v.append(substring(substart, sublen));
substart = i + 1;
}
}
size_t taillen = length() - substart;
ssize_t taillen = length() - substart;
if (taillen != 0)
v.append(substring(substart, taillen));
if (characters()[length() - 1] == separator)
@ -82,7 +82,7 @@ ByteBuffer String::to_byte_buffer() const
unsigned String::to_uint(bool& ok) const
{
unsigned value = 0;
for (size_t i = 0; i < length(); ++i) {
for (ssize_t i = 0; i < length(); ++i) {
if (characters()[i] < '0' || characters()[i] > '9') {
ok = false;
return 0;

8
AK/StringBuilder.cpp
View file

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

8
AK/StringBuilder.h
View file

@ -8,12 +8,12 @@ namespace AK {
class StringBuilder {
public:
explicit StringBuilder(size_t initial_capacity = 16);
explicit StringBuilder(ssize_t initial_capacity = 16);
~StringBuilder() { }
void append(const String&);
void append(char);
void append(const char*, size_t);
void append(const char*, ssize_t);
void appendf(const char*, ...);
void appendvf(const char*, va_list);
@ -21,10 +21,10 @@ public:
ByteBuffer to_byte_buffer();
private:
void will_append(size_t);
void will_append(ssize_t);
ByteBuffer m_buffer;
size_t m_length { 0 };
ssize_t m_length { 0 };
};
}

18
AK/StringImpl.cpp
View file

@ -30,7 +30,7 @@ StringImpl& StringImpl::the_empty_stringimpl()
return *s_the_empty_stringimpl;
}
StringImpl::StringImpl(ConstructWithInlineBufferTag, size_t length)
StringImpl::StringImpl(ConstructWithInlineBufferTag, ssize_t length)
: m_length(length)
, m_characters(m_inline_buffer)
{
@ -50,12 +50,12 @@ StringImpl::~StringImpl()
#endif
}
static inline size_t allocation_size_for_stringimpl(size_t length)
static inline ssize_t allocation_size_for_stringimpl(ssize_t length)
{
return sizeof(StringImpl) + (sizeof(char) * length) + sizeof(char);
}
Retained<StringImpl> StringImpl::create_uninitialized(size_t length, char*& buffer)
Retained<StringImpl> StringImpl::create_uninitialized(ssize_t length, char*& buffer)
{
ASSERT(length);
void* slot = kmalloc(allocation_size_for_stringimpl(length));
@ -66,7 +66,7 @@ Retained<StringImpl> StringImpl::create_uninitialized(size_t length, char*& buff
return new_stringimpl;
}
RetainPtr<StringImpl> StringImpl::create(const char* cstring, size_t length, ShouldChomp shouldChomp)
RetainPtr<StringImpl> StringImpl::create(const char* cstring, ssize_t length, ShouldChomp shouldChomp)
{
if (!cstring)
return nullptr;
@ -123,7 +123,7 @@ static inline char to_ascii_uppercase(char c)
Retained<StringImpl> StringImpl::to_lowercase() const
{
for (size_t i = 0; i < m_length; ++i) {
for (ssize_t i = 0; i < m_length; ++i) {
if (!is_ascii_lowercase(m_characters[i]))
goto slow_path;
}
@ -132,14 +132,14 @@ Retained<StringImpl> StringImpl::to_lowercase() const
slow_path:
char* buffer;
auto lowercased = create_uninitialized(m_length, buffer);
for (size_t i = 0; i < m_length; ++i)
for (ssize_t i = 0; i < m_length; ++i)
buffer[i] = to_ascii_lowercase(m_characters[i]);
return lowercased;
}
Retained<StringImpl> StringImpl::to_uppercase() const
{
for (size_t i = 0; i < m_length; ++i) {
for (ssize_t i = 0; i < m_length; ++i) {
if (!is_ascii_uppercase(m_characters[i]))
goto slow_path;
}
@ -148,7 +148,7 @@ Retained<StringImpl> StringImpl::to_uppercase() const
slow_path:
char* buffer;
auto uppercased = create_uninitialized(m_length, buffer);
for (size_t i = 0; i < m_length; ++i)
for (ssize_t i = 0; i < m_length; ++i)
buffer[i] = to_ascii_uppercase(m_characters[i]);
return uppercased;
}
@ -159,7 +159,7 @@ void StringImpl::compute_hash() const
m_hash = 0;
} else {
unsigned hash = 0;
for (size_t i = 0; i < m_length; ++i) {
for (ssize_t i = 0; i < m_length; ++i) {
hash += m_characters[i];
hash += (hash << 10);
hash ^= (hash >> 6);

12
AK/StringImpl.h
View file

@ -10,9 +10,9 @@ enum ShouldChomp { NoChomp, Chomp };
class StringImpl : public Retainable<StringImpl> {
public:
static Retained<StringImpl> create_uninitialized(size_t length, char*& buffer);
static Retained<StringImpl> create_uninitialized(ssize_t length, char*& buffer);
static RetainPtr<StringImpl> create(const char* cstring, ShouldChomp = NoChomp);
static RetainPtr<StringImpl> create(const char* cstring, size_t length, ShouldChomp = NoChomp);
static RetainPtr<StringImpl> create(const char* cstring, ssize_t length, ShouldChomp = NoChomp);
Retained<StringImpl> to_lowercase() const;
Retained<StringImpl> to_uppercase() const;
@ -20,9 +20,9 @@ public:
~StringImpl();
size_t length() const { return m_length; }
ssize_t length() const { return m_length; }
const char* characters() const { return m_characters; }
char operator[](size_t i) const { ASSERT(i < m_length); return m_characters[i]; }
char operator[](ssize_t i) const { ASSERT(i >= 0 && i < m_length); return m_characters[i]; }
unsigned hash() const
{
@ -36,11 +36,11 @@ private:
explicit StringImpl(ConstructTheEmptyStringImplTag) : m_characters("") { }
enum ConstructWithInlineBufferTag { ConstructWithInlineBuffer };
StringImpl(ConstructWithInlineBufferTag, size_t length);
StringImpl(ConstructWithInlineBufferTag, ssize_t length);
void compute_hash() const;
size_t m_length { 0 };
ssize_t m_length { 0 };
mutable bool m_hasHash { false };
const char* m_characters { nullptr };
mutable unsigned m_hash { 0 };

78
AK/Vector.h
View file

@ -9,12 +9,12 @@ namespace AK {
template<typename T, typename Allocator> class Vector;
struct KmallocAllocator {
static void* allocate(size_t size) { return kmalloc(size); }
static void* allocate(ssize_t size) { return kmalloc(size); }
static void deallocate(void* ptr) { kfree(ptr); }
};
struct KmallocEternalAllocator {
static void* allocate(size_t size) { return kmalloc_eternal(size); }
static void* allocate(ssize_t size) { return kmalloc_eternal(size); }
static void deallocate(void*) { }
};
@ -22,25 +22,25 @@ template<typename T, typename Allocator>
class VectorImpl {
public:
~VectorImpl() { }
static VectorImpl* create(size_t capacity)
static VectorImpl* create(ssize_t capacity)
{
size_t size = sizeof(VectorImpl) + sizeof(T) * capacity;
ssize_t size = sizeof(VectorImpl) + sizeof(T) * capacity;
void* slot = Allocator::allocate(size);
new (slot) VectorImpl(capacity);
return (VectorImpl*)slot;
}
size_t size() const { return m_size; }
size_t capacity() const { return m_capacity; }
ssize_t size() const { return m_size; }
ssize_t capacity() const { return m_capacity; }
T& at(size_t i) { ASSERT(i < m_size); return *slot(i); }
const T& at(size_t i) const { ASSERT(i < m_size); return *slot(i); }
T& at(ssize_t i) { ASSERT(i < m_size); return *slot(i); }
const T& at(ssize_t i) const { ASSERT(i < m_size); return *slot(i); }
void remove(size_t index)
void remove(ssize_t index)
{
ASSERT(index < m_size);
at(index).~T();
for (size_t i = index + 1; i < m_size; ++i) {
for (ssize_t i = index + 1; i < m_size; ++i) {
new (slot(i - 1)) T(move(at(i)));
at(i).~T();
}
@ -51,16 +51,16 @@ public:
//private:
friend class Vector<T, Allocator>;
VectorImpl(size_t capacity) : m_capacity(capacity) { }
VectorImpl(ssize_t capacity) : m_capacity(capacity) { }
T* tail() { return reinterpret_cast<T*>(this + 1); }
T* slot(size_t i) { return &tail()[i]; }
T* slot(ssize_t i) { return &tail()[i]; }
const T* tail() const { return reinterpret_cast<const T*>(this + 1); }
const T* slot(size_t i) const { return &tail()[i]; }
const T* slot(ssize_t i) const { return &tail()[i]; }
size_t m_size { 0 };
size_t m_capacity;
ssize_t m_size { 0 };
ssize_t m_capacity;
};
template<typename T, typename Allocator = KmallocAllocator>
@ -78,7 +78,7 @@ public:
Vector(const Vector& other)
{
ensure_capacity(other.size());
for (size_t i = 0; i < other.size(); ++i)
for (ssize_t i = 0; i < other.size(); ++i)
unchecked_append(other[i]);
}
@ -93,7 +93,7 @@ public:
void clear()
{
for (size_t i = 0; i < size(); ++i) {
for (ssize_t i = 0; i < size(); ++i) {
at(i).~T();
}
Allocator::deallocate(m_impl);
@ -104,14 +104,14 @@ public:
{
if (!m_impl)
return;
for (size_t i = 0; i < size(); ++i)
for (ssize_t i = 0; i < size(); ++i)
at(i).~T();
m_impl->m_size = 0;
}
bool contains_slow(const T& value) const
{
for (size_t i = 0; i < size(); ++i) {
for (ssize_t i = 0; i < size(); ++i) {
if (at(i) == value)
return true;
}
@ -119,17 +119,17 @@ public:
}
bool is_empty() const { return size() == 0; }
size_t size() const { return m_impl ? m_impl->size() : 0; }
size_t capacity() const { return m_impl ? m_impl->capacity() : 0; }
ssize_t size() const { return m_impl ? m_impl->size() : 0; }
ssize_t capacity() const { return m_impl ? m_impl->capacity() : 0; }
T* data() { return m_impl ? m_impl->slot(0) : nullptr; }
const T* data() const { return m_impl ? m_impl->slot(0) : nullptr; }
const T& at(size_t i) const { return m_impl->at(i); }
T& at(size_t i) { return m_impl->at(i); }
const T& at(ssize_t i) const { return m_impl->at(i); }
T& at(ssize_t i) { return m_impl->at(i); }
const T& operator[](size_t i) const { return at(i); }
T& operator[](size_t i) { return at(i); }
const T& operator[](ssize_t i) const { return at(i); }
T& operator[](ssize_t i) { return at(i); }
const T& first() const { return at(0); }
T& first() { return at(0); }
@ -154,7 +154,7 @@ public:
return value;
}
void remove(size_t index)
void remove(ssize_t index)
{
m_impl->remove(index);
}
@ -211,23 +211,23 @@ public:
++m_impl->m_size;
}
void append(const T* values, size_t count)
void append(const T* values, ssize_t count)
{
ensure_capacity(size() + count);
for (size_t i = 0; i < count; ++i)
for (ssize_t i = 0; i < count; ++i)
new (m_impl->slot(m_impl->m_size + i)) T(values[i]);
m_impl->m_size += count;
}
void ensure_capacity(size_t neededCapacity)
void ensure_capacity(ssize_t neededCapacity)
{
if (capacity() >= neededCapacity)
return;
size_t new_capacity = padded_capacity(neededCapacity);
ssize_t new_capacity = padded_capacity(neededCapacity);
auto new_impl = VectorImpl<T, Allocator>::create(new_capacity);
if (m_impl) {
new_impl->m_size = m_impl->m_size;
for (size_t i = 0; i < size(); ++i) {
for (ssize_t i = 0; i < size(); ++i) {
new (new_impl->slot(i)) T(move(m_impl->at(i)));
m_impl->at(i).~T();
}
@ -236,13 +236,13 @@ public:
m_impl = new_impl;
}
void resize(size_t new_size)
void resize(ssize_t new_size)
{
ASSERT(new_size >= size());
if (!new_size)
return;
ensure_capacity(new_size);
for (size_t i = size(); i < new_size; ++i)
for (ssize_t i = size(); i < new_size; ++i)
new (m_impl->slot(i)) T;
m_impl->m_size = new_size;
}
@ -254,9 +254,9 @@ public:
T& operator*() { return m_vector[m_index]; }
private:
friend class Vector;
Iterator(Vector& vector, size_t index) : m_vector(vector), m_index(index) { }
Iterator(Vector& vector, ssize_t index) : m_vector(vector), m_index(index) { }
Vector& m_vector;
size_t m_index { 0 };
ssize_t m_index { 0 };
};
Iterator begin() { return Iterator(*this, 0); }
@ -269,18 +269,18 @@ public:
const T& operator*() const { return m_vector[m_index]; }
private:
friend class Vector;
ConstIterator(const Vector& vector, const size_t index) : m_vector(vector), m_index(index) { }
ConstIterator(const Vector& vector, const ssize_t index) : m_vector(vector), m_index(index) { }
const Vector& m_vector;
size_t m_index { 0 };
ssize_t m_index { 0 };
};
ConstIterator begin() const { return ConstIterator(*this, 0); }
ConstIterator end() const { return ConstIterator(*this, size()); }
//private:
static size_t padded_capacity(size_t capacity)
static ssize_t padded_capacity(ssize_t capacity)
{
return max(size_t(4), capacity + (capacity / 4) + 4);
return max(ssize_t(4), capacity + (capacity / 4) + 4);
}
VectorImpl<T, Allocator>* m_impl { nullptr };

2
Applications/FileManager/DirectoryView.cpp
View file

@ -138,7 +138,7 @@ void DirectoryView::paint_event(GPaintEvent&)
int painted_item_index = 0;
auto process_entries = [&] (const Vector<Entry>& entries) {
for (size_t i = 0; i < entries.size(); ++i, ++painted_item_index) {
for (int i = 0; i < entries.size(); ++i, ++painted_item_index) {
auto& entry = entries[i];
int y = painted_item_index * item_height();
Rect icon_rect(horizontal_padding, y, icon_size, item_height());

2
Applications/FileManager/DirectoryView.h
View file

@ -37,7 +37,7 @@ private:
bool is_directory() const { return S_ISDIR(mode); }
};
const Entry& entry(size_t index) const
const Entry& entry(int index) const
{
if (index < m_directories.size())
return m_directories[index];

4
Applications/FontEditor/FontEditor.cpp
View file

@ -227,8 +227,8 @@ void GlyphEditorWidget::draw_at_mouse(const GMouseEvent& event)
int x = (event.x() - 1) / m_scale;
int y = (event.y() - 1) / m_scale;
auto bitmap = font().glyph_bitmap(m_glyph);
ASSERT((unsigned)x < bitmap.width());
ASSERT((unsigned)y < bitmap.height());
ASSERT(x < bitmap.width());
ASSERT(y < bitmap.height());
if (bitmap.bit_at(x, y) == set)
return;
bitmap.set_bit_at(x, y, set);

10
Applications/Terminal/Terminal.cpp
View file

@ -84,7 +84,7 @@ void Terminal::Line::clear(Attribute attribute)
Terminal::~Terminal()
{
for (size_t i = 0; i < m_rows; ++i)
for (int i = 0; i < m_rows; ++i)
delete m_lines[i];
delete [] m_lines;
free(m_horizontal_tabs);
@ -115,7 +115,7 @@ inline bool is_valid_final_character(byte ch)
unsigned parse_uint(const String& str, bool& ok)
{
unsigned value = 0;
for (size_t i = 0; i < str.length(); ++i) {
for (int i = 0; i < str.length(); ++i) {
if (str[i] < '0' || str[i] > '9') {
ok = false;
return 0;
@ -552,7 +552,7 @@ void Terminal::on_char(byte ch)
void Terminal::inject_string(const String& str)
{
for (size_t i = 0; i < str.length(); ++i)
for (int i = 0; i < str.length(); ++i)
on_char(str[i]);
}
@ -562,12 +562,12 @@ void Terminal::unimplemented_escape()
builder.appendf("((Unimplemented escape: %c", m_final);
if (!m_parameters.is_empty()) {
builder.append(" parameters:");
for (size_t i = 0; i < m_parameters.size(); ++i)
for (int i = 0; i < m_parameters.size(); ++i)
builder.append((char)m_parameters[i]);
}
if (!m_intermediates.is_empty()) {
builder.append(" intermediates:");
for (size_t i = 0; i < m_intermediates.size(); ++i)
for (int i = 0; i < m_intermediates.size(); ++i)
builder.append((char)m_intermediates[i]);
}
builder.append("))");

4
Kernel/DiskBackedFileSystem.h
View file

@ -10,7 +10,7 @@ public:
DiskDevice& device() { return *m_device; }
const DiskDevice& device() const { return *m_device; }
size_t block_size() const { return m_block_size; }
int block_size() const { return m_block_size; }
protected:
explicit DiskBackedFS(Retained<DiskDevice>&&);
@ -24,6 +24,6 @@ protected:
bool write_blocks(unsigned index, unsigned count, const ByteBuffer&);
private:
size_t m_block_size { 0 };
int m_block_size { 0 };
Retained<DiskDevice> m_device;
};

58
Kernel/Ext2FileSystem.cpp
View file

@ -190,7 +190,7 @@ bool Ext2FS::write_block_list_for_inode(InodeIndex inode_index, ext2_inode& e2in
{
LOCKER(m_lock);
dbgprintf("Ext2FS: writing %u block(s) to i_block array\n", min((size_t)EXT2_NDIR_BLOCKS, blocks.size()));
dbgprintf("Ext2FS: writing %u block(s) to i_block array\n", min(EXT2_NDIR_BLOCKS, blocks.size()));
auto old_shape = compute_block_list_shape(e2inode.i_blocks / (2 << super_block().s_log_block_size));
auto new_shape = compute_block_list_shape(blocks.size());
@ -429,7 +429,7 @@ RetainPtr<Inode> Ext2FS::get_inode(InodeIdentifier inode) const
return new_inode;
}
ssize_t Ext2FSInode::read_bytes(off_t offset, size_t count, byte* buffer, FileDescriptor*) const
ssize_t Ext2FSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileDescriptor*) const
{
Locker inode_locker(m_lock);
ASSERT(offset >= 0);
@ -441,7 +441,7 @@ ssize_t Ext2FSInode::read_bytes(off_t offset, size_t count, byte* buffer, FileDe
static const unsigned max_inline_symlink_length = 60;
if (is_symlink() && size() < max_inline_symlink_length) {
ssize_t nread = min((off_t)size() - offset, static_cast<off_t>(count));
memcpy(buffer, m_raw_inode.i_block + offset, nread);
memcpy(buffer, m_raw_inode.i_block + offset, (size_t)nread);
return nread;
}
@ -494,7 +494,7 @@ ssize_t Ext2FSInode::read_bytes(off_t offset, size_t count, byte* buffer, FileDe
return nread;
}
ssize_t Ext2FSInode::write_bytes(off_t offset, size_t count, const byte* data, FileDescriptor*)
ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const byte* data, FileDescriptor*)
{
Locker inode_locker(m_lock);
Locker fs_locker(fs().m_lock);
@ -504,7 +504,7 @@ ssize_t Ext2FSInode::write_bytes(off_t offset, size_t count, const byte* data, F
ASSERT(offset >= 0);
const size_t block_size = fs().block_size();
const ssize_t block_size = fs().block_size();
size_t old_size = size();
size_t new_size = max(static_cast<size_t>(offset) + count, size());
@ -539,8 +539,8 @@ ssize_t Ext2FSInode::write_bytes(off_t offset, size_t count, const byte* data, F
auto buffer_block = ByteBuffer::create_uninitialized(block_size);
for (dword bi = first_block_logical_index; remaining_count && bi <= last_block_logical_index; ++bi) {
dword offset_into_block = (bi == first_block_logical_index) ? offset_into_first_block : 0;
dword num_bytes_to_copy = min(block_size - offset_into_block, remaining_count);
size_t offset_into_block = (bi == first_block_logical_index) ? offset_into_first_block : 0;
size_t num_bytes_to_copy = min((size_t)block_size - offset_into_block, remaining_count);
ByteBuffer block;
if (offset_into_block != 0) {
@ -702,24 +702,24 @@ bool Ext2FS::write_directory_inode(unsigned directoryInode, Vector<DirectoryEntr
LOCKER(m_lock);
dbgprintf("Ext2FS: New directory inode %u contents to write:\n", directoryInode);
unsigned directory_size = 0;
int directory_size = 0;
for (auto& entry : entries) {
//kprintf(" - %08u %s\n", entry.inode.index(), entry.name);
directory_size += EXT2_DIR_REC_LEN(entry.name_length);
}
unsigned blocks_needed = ceil_div(directory_size, block_size());
unsigned occupied_size = blocks_needed * block_size();
int blocks_needed = ceil_div(directory_size, block_size());
int occupied_size = blocks_needed * block_size();
dbgprintf("Ext2FS: directory size: %u (occupied: %u)\n", directory_size, occupied_size);
auto directory_data = ByteBuffer::create_uninitialized(occupied_size);
BufferStream stream(directory_data);
for (unsigned i = 0; i < entries.size(); ++i) {
for (int i = 0; i < entries.size(); ++i) {
auto& entry = entries[i];
unsigned record_length = EXT2_DIR_REC_LEN(entry.name_length);
int record_length = EXT2_DIR_REC_LEN(entry.name_length);
if (i == entries.size() - 1)
record_length += occupied_size - directory_size;
@ -735,27 +735,13 @@ bool Ext2FS::write_directory_inode(unsigned directoryInode, Vector<DirectoryEntr
stream << byte(entry.file_type);
stream << entry.name;
unsigned padding = record_length - entry.name_length - 8;
//dbgprintf(" *** pad %u bytes\n", padding);
for (unsigned j = 0; j < padding; ++j) {
int padding = record_length - entry.name_length - 8;
for (int j = 0; j < padding; ++j)
stream << byte(0);
}
}
stream.fill_to_end(0);
#if 0
kprintf("data to write (%u):\n", directory_data.size());
for (unsigned i = 0; i < directory_data.size(); ++i) {
kprintf("%02x ", directory_data[i]);
if ((i + 1) % 8 == 0)
kprintf(" ");
if ((i + 1) % 16 == 0)
kprintf("\n");
}
kprintf("\n");
#endif
auto directory_inode = get_inode({ fsid(), directoryInode });
ssize_t nwritten = directory_inode->write_bytes(0, directory_data.size(), directory_data.pointer(), nullptr);
return nwritten == directory_data.size();
@ -806,7 +792,7 @@ void Ext2FS::dump_inode_bitmap(unsigned groupIndex) const
{
LOCKER(m_lock);
traverse_inode_bitmap(groupIndex, [] (unsigned, const Bitmap& bitmap) {
for (unsigned i = 0; i < bitmap.size(); ++i)
for (int i = 0; i < bitmap.size(); ++i)
kprintf("%c", bitmap.get(i) ? '1' : '0');
return true;
});
@ -882,7 +868,7 @@ Vector<Ext2FS::BlockIndex> Ext2FS::allocate_blocks(unsigned group, unsigned coun
// FIXME: Implement a scan that finds consecutive blocks if possible.
Vector<BlockIndex> blocks;
traverse_block_bitmap(group, [&blocks, count] (unsigned first_block_in_bitmap, const Bitmap& bitmap) {
for (unsigned i = 0; i < bitmap.size(); ++i) {
for (int i = 0; i < bitmap.size(); ++i) {
if (!bitmap.get(i)) {
blocks.append(first_block_in_bitmap + i);
if (blocks.size() == count)
@ -931,23 +917,23 @@ unsigned Ext2FS::allocate_inode(unsigned preferred_group, unsigned expected_size
dbgprintf("Ext2FS: allocate_inode: found suitable group [%u] for new inode with %u blocks needed :^)\n", groupIndex, needed_blocks);
unsigned firstFreeInodeInGroup = 0;
traverse_inode_bitmap(groupIndex, [&firstFreeInodeInGroup] (unsigned firstInodeInBitmap, const Bitmap& bitmap) {
for (unsigned i = 0; i < bitmap.size(); ++i) {
unsigned first_free_inode_in_group = 0;
traverse_inode_bitmap(groupIndex, [&first_free_inode_in_group] (unsigned firstInodeInBitmap, const Bitmap& bitmap) {
for (int i = 0; i < bitmap.size(); ++i) {
if (!bitmap.get(i)) {
firstFreeInodeInGroup = firstInodeInBitmap + i;
first_free_inode_in_group = firstInodeInBitmap + i;
return false;
}
}
return true;
});
if (!firstFreeInodeInGroup) {
if (!first_free_inode_in_group) {
kprintf("Ext2FS: first_free_inode_in_group returned no inode, despite bgd claiming there are inodes :(\n");
return 0;
}
unsigned inode = firstFreeInodeInGroup;
unsigned inode = first_free_inode_in_group;
dbgprintf("Ext2FS: found suitable inode %u\n", inode);
ASSERT(get_inode_allocation_state(inode) == false);

4
Kernel/Ext2FileSystem.h
View file

@ -25,13 +25,13 @@ public:
private:
// ^Inode
virtual ssize_t read_bytes(off_t, size_t, byte* buffer, FileDescriptor*) const override;
virtual ssize_t read_bytes(off_t, ssize_t, byte* buffer, FileDescriptor*) const override;
virtual InodeMetadata metadata() const override;
virtual bool traverse_as_directory(Function<bool(const FS::DirectoryEntry&)>) const override;
virtual InodeIdentifier lookup(const String& name) override;
virtual String reverse_lookup(InodeIdentifier) override;
virtual void flush_metadata() override;
virtual ssize_t write_bytes(off_t, size_t, const byte* data, FileDescriptor*) override;
virtual ssize_t write_bytes(off_t, ssize_t, const byte* data, FileDescriptor*) override;
virtual bool add_child(InodeIdentifier child_id, const String& name, byte file_type, int& error) override;
virtual bool remove_child(const String& name, int& error) override;
virtual RetainPtr<Inode> parent() const override;

2
Kernel/FileSystem.cpp
View file

@ -104,7 +104,7 @@ void Inode::will_be_destroyed()
flush_metadata();
}
void Inode::inode_contents_changed(off_t offset, size_t size, const byte* data)
void Inode::inode_contents_changed(off_t offset, ssize_t size, const byte* data)
{
if (m_vmo)
m_vmo->inode_contents_changed(Badge<Inode>(), offset, size, data);

8
Kernel/FileSystem.h
View file

@ -47,7 +47,7 @@ public:
DirectoryEntry(const char* name, InodeIdentifier, byte file_type);
DirectoryEntry(const char* name, size_t name_length, InodeIdentifier, byte file_type);
char name[256];
size_t name_length { 0 };
int name_length { 0 };
InodeIdentifier inode;
byte file_type { 0 };
};
@ -88,11 +88,11 @@ public:
ByteBuffer read_entire(FileDescriptor* = nullptr) const;
virtual ssize_t read_bytes(off_t, size_t, byte* buffer, FileDescriptor*) const = 0;
virtual ssize_t read_bytes(off_t, ssize_t, byte* buffer, FileDescriptor*) const = 0;
virtual bool traverse_as_directory(Function<bool(const FS::DirectoryEntry&)>) const = 0;
virtual InodeIdentifier lookup(const String& name) = 0;
virtual String reverse_lookup(InodeIdentifier) = 0;
virtual ssize_t write_bytes(off_t, size_t, const byte* data, FileDescriptor*) = 0;
virtual ssize_t write_bytes(off_t, ssize_t, const byte* data, FileDescriptor*) = 0;
virtual bool add_child(InodeIdentifier child_id, const String& name, byte file_type, int& error) = 0;
virtual bool remove_child(const String& name, int& error) = 0;
virtual RetainPtr<Inode> parent() const = 0;
@ -123,7 +123,7 @@ public:
protected:
Inode(FS& fs, unsigned index);
void set_metadata_dirty(bool b) { m_metadata_dirty = b; }
void inode_contents_changed(off_t, size_t, const byte*);
void inode_contents_changed(off_t, ssize_t, const byte*);
void inode_size_changed(size_t old_size, size_t new_size);
mutable Lock m_lock;

3
Kernel/MemoryManager.cpp
View file

@ -791,6 +791,7 @@ void VMObject::for_each_region(Callback callback)
void VMObject::inode_size_changed(Badge<Inode>, size_t old_size, size_t new_size)
{
(void)old_size;
InterruptDisabler disabler;
size_t old_page_count = page_count();
@ -813,7 +814,7 @@ void VMObject::inode_size_changed(Badge<Inode>, size_t old_size, size_t new_size
});
}
void VMObject::inode_contents_changed(Badge<Inode>, off_t offset, size_t size, const byte* data)
void VMObject::inode_contents_changed(Badge<Inode>, off_t offset, ssize_t size, const byte* data)
{
(void)size;
(void)data;

2
Kernel/MemoryManager.h
View file

@ -107,7 +107,7 @@ public:
const Vector<RetainPtr<PhysicalPage>>& physical_pages() const { return m_physical_pages; }
Vector<RetainPtr<PhysicalPage>>& physical_pages() { return m_physical_pages; }
void inode_contents_changed(Badge<Inode>, off_t, size_t, const byte*);
void inode_contents_changed(Badge<Inode>, off_t, ssize_t, const byte*);
void inode_size_changed(Badge<Inode>, size_t old_size, size_t new_size);
size_t size() const { return m_size; }

4
Kernel/ProcFS.cpp
View file

@ -808,7 +808,7 @@ InodeMetadata ProcFSInode::metadata() const
return metadata;
}
ssize_t ProcFSInode::read_bytes(off_t offset, size_t count, byte* buffer, FileDescriptor* descriptor) const
ssize_t ProcFSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileDescriptor* descriptor) const
{
#ifdef PROCFS_DEBUG
dbgprintf("ProcFS: read_bytes %u\n", index());
@ -1034,7 +1034,7 @@ void ProcFSInode::flush_metadata()
{
}
ssize_t ProcFSInode::write_bytes(off_t offset, size_t size, const byte* buffer, FileDescriptor*)
ssize_t ProcFSInode::write_bytes(off_t offset, ssize_t size, const byte* buffer, FileDescriptor*)
{
auto* directory_entry = fs().get_directory_entry(identifier());
if (!directory_entry || !directory_entry->write_callback)

4
Kernel/ProcFS.h
View file

@ -76,13 +76,13 @@ public:
private:
// ^Inode
virtual ssize_t read_bytes(off_t, size_t, byte* buffer, FileDescriptor*) const override;
virtual ssize_t read_bytes(off_t, ssize_t, byte* buffer, FileDescriptor*) const override;
virtual InodeMetadata metadata() const override;
virtual bool traverse_as_directory(Function<bool(const FS::DirectoryEntry&)>) const override;
virtual InodeIdentifier lookup(const String& name) override;
virtual String reverse_lookup(InodeIdentifier) override;
virtual void flush_metadata() override;
virtual ssize_t write_bytes(off_t, size_t, const byte* buffer, FileDescriptor*) override;
virtual ssize_t write_bytes(off_t, ssize_t, const byte* buffer, FileDescriptor*) override;
virtual bool add_child(InodeIdentifier child_id, const String& name, byte file_type, int& error) override;
virtual bool remove_child(const String& name, int& error) override;
virtual RetainPtr<Inode> parent() const override;

24
Kernel/Process.cpp
View file

@ -121,7 +121,7 @@ Region* Process::allocate_region_with_vmo(LinearAddress laddr, size_t size, Reta
bool Process::deallocate_region(Region& region)
{
InterruptDisabler disabler;
for (size_t i = 0; i < m_regions.size(); ++i) {
for (int i = 0; i < m_regions.size(); ++i) {
if (m_regions[i].ptr() == &region) {
MM.unmap_region(region);
m_regions.remove(i);
@ -367,7 +367,7 @@ int Process::do_exec(String path, Vector<String> arguments, Vector<String> envir
m_signal_mask = 0xffffffff;
m_pending_signals = 0;
for (size_t i = 0; i < m_fds.size(); ++i) {
for (int i = 0; i < m_fds.size(); ++i) {
auto& daf = m_fds[i];
if (daf.descriptor && daf.flags & FD_CLOEXEC) {
daf.descriptor->close();
@ -441,21 +441,19 @@ void Process::make_userspace_stack(Vector<String> arguments, Vector<String> envi
// FIXME: It would be better if this didn't make us panic.
ASSERT((total_blob_size + total_meta_size) < default_userspace_stack_size);
for (size_t i = 0; i < arguments.size(); ++i) {
for (int i = 0; i < arguments.size(); ++i) {
argv[i] = bufptr;
memcpy(bufptr, arguments[i].characters(), arguments[i].length());
bufptr += arguments[i].length();
*(bufptr++) = '\0';
printf("argv[%u] = %p (%s)\n", i, argv[i], argv[i]);
}
argv[arguments.size()] = nullptr;
for (size_t i = 0; i < environment.size(); ++i) {
for (int i = 0; i < environment.size(); ++i) {
env[i] = bufptr;
memcpy(bufptr, environment[i].characters(), environment[i].length());
bufptr += environment[i].length();
*(bufptr++) = '\0';
printf("env[%u] = %p (%s)\n", i, env[i], env[i]);
}
env[environment.size()] = nullptr;
@ -623,7 +621,7 @@ Process::Process(String&& name, uid_t uid, gid_t gid, pid_t ppid, RingLevel ring
if (fork_parent) {
m_fds.resize(fork_parent->m_fds.size());
for (size_t i = 0; i < fork_parent->m_fds.size(); ++i) {
for (int i = 0; i < fork_parent->m_fds.size(); ++i) {
if (!fork_parent->m_fds[i].descriptor)
continue;
#ifdef FORK_DEBUG
@ -959,7 +957,7 @@ FileDescriptor* Process::file_descriptor(int fd)
{
if (fd < 0)
return nullptr;
if ((size_t)fd < m_fds.size())
if (fd < m_fds.size())
return m_fds[fd].descriptor.ptr();
return nullptr;
}
@ -968,7 +966,7 @@ const FileDescriptor* Process::file_descriptor(int fd) const
{
if (fd < 0)
return nullptr;
if ((size_t)fd < m_fds.size())
if (fd < m_fds.size())
return m_fds[fd].descriptor.ptr();
return nullptr;
}
@ -1894,7 +1892,7 @@ int Process::sys$sigaction(int signum, const sigaction* act, sigaction* old_act)
return 0;
}
int Process::sys$getgroups(int count, gid_t* gids)
int Process::sys$getgroups(ssize_t count, gid_t* gids)
{
if (count < 0)
return -EINVAL;
@ -1911,8 +1909,10 @@ int Process::sys$getgroups(int count, gid_t* gids)
return 0;
}
int Process::sys$setgroups(size_t count, const gid_t* gids)
int Process::sys$setgroups(ssize_t count, const gid_t* gids)
{
if (count < 0)
return -EINVAL;
if (!is_superuser())
return -EPERM;
if (count >= MAX_PROCESS_GIDS)
@ -1921,7 +1921,7 @@ int Process::sys$setgroups(size_t count, const gid_t* gids)
return -EFAULT;
m_gids.clear();
m_gids.set(m_gid);
for (size_t i = 0; i < count; ++i)
for (int i = 0; i < count; ++i)
m_gids.set(gids[i]);
return 0;
}

4
Kernel/Process.h
View file

@ -198,8 +198,8 @@ public:
int sys$sigaction(int signum, const sigaction* act, sigaction* old_act);
int sys$sigprocmask(int how, const sigset_t* set, sigset_t* old_set);
int sys$sigpending(sigset_t*);
int sys$getgroups(int size, gid_t*);
int sys$setgroups(size_t, const gid_t*);
int sys$getgroups(ssize_t, gid_t*);
int sys$setgroups(ssize_t, const gid_t*);
int sys$pipe(int* pipefd);
int sys$killpg(int pgrp, int sig);
int sys$setgid(gid_t);

9
Kernel/SyntheticFileSystem.cpp
View file

@ -112,10 +112,9 @@ bool SynthFS::remove_file(InodeIndex inode)
if (pit == m_inodes.end())
return false;
auto& parent = *(*pit).value;
for (size_t i = 0; i < parent.m_children.size(); ++i) {
if (parent.m_children[i]->m_metadata.inode.index() != inode) {
for (ssize_t i = 0; i < parent.m_children.size(); ++i) {
if (parent.m_children[i]->m_metadata.inode.index() != inode)
continue;
}
parent.m_children.remove(i);
break;
}
@ -193,7 +192,7 @@ InodeMetadata SynthFSInode::metadata() const
return m_metadata;
}
ssize_t SynthFSInode::read_bytes(off_t offset, size_t count, byte* buffer, FileDescriptor* descriptor) const
ssize_t SynthFSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileDescriptor* descriptor) const
{
LOCKER(m_lock);
#ifdef SYNTHFS_DEBUG
@ -269,7 +268,7 @@ void SynthFSInode::flush_metadata()
{
}
ssize_t SynthFSInode::write_bytes(off_t offset, size_t size, const byte* buffer, FileDescriptor*)
ssize_t SynthFSInode::write_bytes(off_t offset, ssize_t size, const byte* buffer, FileDescriptor*)
{
LOCKER(m_lock);
if (!m_write_callback)

4
Kernel/SyntheticFileSystem.h
View file

@ -56,13 +56,13 @@ public:
private:
// ^Inode
virtual ssize_t read_bytes(off_t, size_t, byte* buffer, FileDescriptor*) const override;
virtual ssize_t read_bytes(off_t, ssize_t, byte* buffer, FileDescriptor*) const override;
virtual InodeMetadata metadata() const override;
virtual bool traverse_as_directory(Function<bool(const FS::DirectoryEntry&)>) const override;
virtual InodeIdentifier lookup(const String& name) override;
virtual String reverse_lookup(InodeIdentifier) override;
virtual void flush_metadata() override;
virtual ssize_t write_bytes(off_t, size_t, const byte* buffer, FileDescriptor*) override;
virtual ssize_t write_bytes(off_t, ssize_t, const byte* buffer, FileDescriptor*) override;
virtual bool add_child(InodeIdentifier child_id, const String& name, byte file_type, int& error) override;
virtual bool remove_child(const String& name, int& error) override;
virtual RetainPtr<Inode> parent() const override;

4
Kernel/Syscall.cpp
View file

@ -154,9 +154,9 @@ static dword handle(RegisterDump& regs, dword function, dword arg1, dword arg2,
case Syscall::SC_umask:
return current->sys$umask((mode_t)arg1);
case Syscall::SC_getgroups:
return current->sys$getgroups((int)arg1, (gid_t*)arg2);
return current->sys$getgroups((ssize_t)arg1, (gid_t*)arg2);
case Syscall::SC_setgroups:
return current->sys$setgroups((size_t)arg1, (const gid_t*)arg2);
return current->sys$setgroups((ssize_t)arg1, (const gid_t*)arg2);
case Syscall::SC_sigreturn:
current->sys$sigreturn();
ASSERT_NOT_REACHED();

2
Kernel/VirtualFileSystem.cpp
View file

@ -512,7 +512,7 @@ KResultOr<InodeIdentifier> VFS::resolve_path(const String& path, InodeIdentifier
if (parent_id)
*parent_id = crumb_id;
for (unsigned i = 0; i < parts.size(); ++i) {
for (int i = 0; i < parts.size(); ++i) {
bool inode_was_root_at_head_of_loop = crumb_id.is_root_inode();
auto& part = parts[i];
if (part.is_empty())

2
LibC/grp.cpp
View file

@ -107,7 +107,7 @@ next_entry:
__grdb_entry->gr_gid = e_gid;
__grdb_entry->gr_name = __grdb_entry->name_buffer;
__grdb_entry->gr_passwd = __grdb_entry->passwd_buffer;
for (size_t i = 0; i < members.size(); ++i) {
for (ssize_t i = 0; i < members.size(); ++i) {
__grdb_entry->members[i] = __grdb_entry->members_buffer[i];
strcpy(__grdb_entry->members_buffer[i], members[i].characters());
}

2
LibGUI/GEventLoop.cpp
View file

@ -426,7 +426,7 @@ bool GEventLoop::wait_for_specific_event(WSAPI_ServerMessage::Type type, WSAPI_S
bool success = drain_messages_from_server();
if (!success)
return false;
for (size_t i = 0; i < m_unprocessed_messages.size(); ++i) {
for (ssize_t i = 0; i < m_unprocessed_messages.size(); ++i) {
if (m_unprocessed_messages[i].type == type) {
event = move(m_unprocessed_messages[i]);
m_unprocessed_messages.remove(i);

8
LibGUI/GMenu.cpp
View file

@ -43,14 +43,14 @@ int GMenu::realize_menu()
{
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::CreateMenu;
ASSERT(m_name.length() < sizeof(request.text));
ASSERT(m_name.length() < (ssize_t)sizeof(request.text));
strcpy(request.text, m_name.characters());
request.text_length = m_name.length();
auto response = GEventLoop::main().sync_request(request, WSAPI_ServerMessage::Type::DidCreateMenu);
m_menu_id = response.menu.menu_id;
ASSERT(m_menu_id > 0);
for (size_t i = 0; i < m_items.size(); ++i) {
for (int i = 0; i < m_items.size(); ++i) {
auto& item = *m_items[i];
if (item.type() == GMenuItem::Separator) {
WSAPI_ClientMessage request;
@ -65,7 +65,7 @@ int GMenu::realize_menu()
request.type = WSAPI_ClientMessage::Type::AddMenuItem;
request.menu.menu_id = m_menu_id;
request.menu.identifier = i;
ASSERT(action.text().length() < sizeof(request.text));
ASSERT(action.text().length() < (ssize_t)sizeof(request.text));
strcpy(request.text, action.text().characters());
request.text_length = action.text().length();
GEventLoop::main().sync_request(request, WSAPI_ServerMessage::Type::DidAddMenuItem);
@ -87,7 +87,7 @@ void GMenu::unrealize_menu()
m_menu_id = 0;
}
GAction* GMenu::action_at(size_t index)
GAction* GMenu::action_at(int index)
{
if (index >= m_items.size())
return nullptr;

2
LibGUI/GMenu.h
View file

@ -13,7 +13,7 @@ public:
static GMenu* from_menu_id(int);
GAction* action_at(size_t);
GAction* action_at(int);
void add_action(RetainPtr<GAction>&&);
void add_separator();

2
LibGUI/GObject.cpp
View file

@ -43,7 +43,7 @@ void GObject::add_child(GObject& object)
void GObject::remove_child(GObject& object)
{
for (unsigned i = 0; i < m_children.size(); ++i) {
for (ssize_t i = 0; i < m_children.size(); ++i) {
if (m_children[i] == &object) {
m_children.remove(i);
return;

6
LibGUI/GTextBox.cpp
View file

@ -35,13 +35,13 @@ void GTextBox::paint_event(GPaintEvent&)
Rect inner_rect = rect();
inner_rect.shrink(6, 6);
size_t max_chars_to_paint = inner_rect.width() / font().glyph_width();
ssize_t max_chars_to_paint = inner_rect.width() / font().glyph_width();
int first_visible_char = max((int)m_cursor_position - (int)max_chars_to_paint, 0);
size_t chars_to_paint = min(m_text.length() - first_visible_char, max_chars_to_paint);
ssize_t chars_to_paint = min(m_text.length() - first_visible_char, max_chars_to_paint);
int y = inner_rect.center().y() - font().glyph_height() / 2;
for (size_t i = 0; i < chars_to_paint; ++i) {
for (ssize_t i = 0; i < chars_to_paint; ++i) {
char ch = m_text[first_visible_char + i];
if (ch == ' ')
continue;

2
LibGUI/GTextBox.h
View file

@ -27,7 +27,7 @@ private:
void handle_backspace();
String m_text;
unsigned m_cursor_position { 0 };
int m_cursor_position { 0 };
bool m_cursor_blink_state { false };
};

10
LibGUI/GWindow.cpp
View file

@ -63,7 +63,7 @@ void GWindow::show()
request.window.opacity = m_opacity_when_windowless;
request.window.size_increment = m_size_increment;
request.window.base_size = m_base_size;
ASSERT(m_title_when_windowless.length() < sizeof(request.text));
ASSERT(m_title_when_windowless.length() < (ssize_t)sizeof(request.text));
strcpy(request.text, m_title_when_windowless.characters());
request.text_length = m_title_when_windowless.length();
auto response = GEventLoop::main().sync_request(request, WSAPI_ServerMessage::Type::DidCreateWindow);
@ -81,9 +81,6 @@ void GWindow::hide()
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::DestroyWindow;
request.window_id = m_window_id;
ASSERT(m_title_when_windowless.length() < sizeof(request.text));
strcpy(request.text, m_title_when_windowless.characters());
request.text_length = m_title_when_windowless.length();
GEventLoop::main().post_message_to_server(request);
}
@ -96,7 +93,7 @@ void GWindow::set_title(String&& title)
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::SetWindowTitle;
request.window_id = m_window_id;
ASSERT(m_title_when_windowless.length() < sizeof(request.text));
ASSERT(m_title_when_windowless.length() < (ssize_t)sizeof(request.text));
strcpy(request.text, m_title_when_windowless.characters());
request.text_length = m_title_when_windowless.length();
GEventLoop::main().post_message_to_server(request);
@ -110,9 +107,6 @@ String GWindow::title() const
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::GetWindowTitle;
request.window_id = m_window_id;
ASSERT(m_title_when_windowless.length() < sizeof(request.text));
strcpy(request.text, m_title_when_windowless.characters());
request.text_length = m_title_when_windowless.length();
auto response = GEventLoop::main().sync_request(request, WSAPI_ServerMessage::Type::DidGetWindowTitle);
return String(response.text, response.text_length);
}

4
SharedGraphics/DisjointRectSet.cpp
View file

@ -20,9 +20,9 @@ void DisjointRectSet::shatter()
do {
pass_had_intersections = false;
output.clear_with_capacity();
for (size_t i = 0; i < m_rects.size(); ++i) {
for (int i = 0; i < m_rects.size(); ++i) {
auto& r1 = m_rects[i];
for (size_t j = 0; j < m_rects.size(); ++j) {
for (int j = 0; j < m_rects.size(); ++j) {
if (i == j)
continue;
auto& r2 = m_rects[j];

2
SharedGraphics/Font.cpp
View file

@ -120,7 +120,7 @@ bool Font::write_to_file(const String& path)
header.glyph_width = m_glyph_width;
header.glyph_height = m_glyph_height;
header.type = 0;
memcpy(header.name, m_name.characters(), min(m_name.length(), (size_t)63));
memcpy(header.name, m_name.characters(), min(m_name.length(), 63));
size_t bytes_per_glyph = sizeof(unsigned) * m_glyph_height;

2
SharedGraphics/Painter.cpp
View file

@ -336,7 +336,7 @@ void Painter::draw_text(const Rect& rect, const String& text, TextAlignment alig
ASSERT_NOT_REACHED();
}
for (unsigned i = 0; i < text.length(); ++i, point.move_by(font().glyph_width(), 0)) {
for (ssize_t i = 0; i < text.length(); ++i, point.move_by(font().glyph_width(), 0)) {
byte ch = text[i];
if (ch == ' ')
continue;

3
Userland/df.cpp
View file

@ -42,6 +42,9 @@ int main(int, char**)
ASSERT(ok);
String mount_point = parts[5];
(void)total_inode_count;
(void)free_inode_count;
printf("% 10s", fs.characters());
printf("%10u ", total_block_count);
printf("%10u ", total_block_count - free_block_count);

4
Userland/kill.cpp
View file

@ -11,13 +11,13 @@ static unsigned parse_uint(const String& str, bool& ok)
return 0;
}
unsigned value = 0;
for (size_t i = 0; i < str.length(); ++i) {
for (int i = 0; i < str.length(); ++i) {
if (str[i] < '0' || str[i] > '9') {
ok = false;
return 0;
}
value = value * 10;
value += str[i] - '0';
value += (unsigned)(str[i] - '0');
}
ok = true;
return value;

16
Userland/ls.cpp
View file

@ -55,7 +55,7 @@ int main(int argc, char** argv)
return do_dir_short(path);
}
void get_geometry(unsigned& rows, unsigned& columns)
void get_geometry(int& rows, int& columns)
{
struct winsize ws;
ioctl(0, TIOCGWINSZ, &ws);
@ -187,8 +187,8 @@ int do_dir(const char* path)
int do_dir_short(const char* path)
{
unsigned rows;
unsigned columns;
int rows;
int columns;
get_geometry(rows, columns);
DIR* dirp = opendir(path);
@ -198,7 +198,7 @@ int do_dir_short(const char* path)
}
Vector<String> names;
size_t longest_name = 0;
int longest_name = 0;
while (auto* de = readdir(dirp)) {
if (de->d_name[0] == '.' && !flag_show_dotfiles)
continue;
@ -210,7 +210,7 @@ int do_dir_short(const char* path)
int printed_on_row = 0;
for (size_t i = 0; i < names.size(); ++i) {
for (int i = 0; i < names.size(); ++i) {
auto& name = names[i];
struct stat st;
char pathbuf[256];
@ -221,11 +221,11 @@ int do_dir_short(const char* path)
return 2;
}
unsigned nprinted = print_name(st, name.characters());
unsigned column_width = 14;
int nprinted = print_name(st, name.characters());
int column_width = 14;
printed_on_row += column_width;
for (unsigned i = nprinted; i < column_width; ++i)
for (int i = nprinted; i < column_width; ++i)
printf(" ");
if ((printed_on_row + column_width) >= columns) {
if (i != names.size() - 1)

2
Userland/sleep.cpp
View file

@ -6,7 +6,7 @@
static unsigned parse_uint(const String& str, bool& ok)
{
unsigned value = 0;
for (size_t i = 0; i < str.length(); ++i) {
for (int i = 0; i < str.length(); ++i) {
if (str[i] < '0' || str[i] > '9') {
ok = false;
return 0;

4
WindowServer/WSAPITypes.h
View file

@ -88,7 +88,7 @@ struct WSAPI_ServerMessage {
};
Type type { Invalid };
int window_id { -1 };
size_t text_length;
int text_length { 0 };
char text[256];
union {
@ -156,7 +156,7 @@ struct WSAPI_ClientMessage {
};
Type type { Invalid };
int window_id { -1 };
size_t text_length;
int text_length { 0 };
char text[256];
int value { 0 };

4
WindowServer/WSClientConnection.cpp
View file

@ -63,7 +63,7 @@ void WSClientConnection::post_error(const String& error_message)
dbgprintf("WSClientConnection::post_error: client_id=%d: %s\n", m_client_id, error_message.characters());
WSAPI_ServerMessage message;
message.type = WSAPI_ServerMessage::Type::Error;
ASSERT(error_message.length() < sizeof(message.text));
ASSERT(error_message.length() < (ssize_t)sizeof(message.text));
strcpy(message.text, error_message.characters());
message.text_length = error_message.length();
post_message(message);
@ -277,7 +277,7 @@ void WSClientConnection::handle_request(WSAPIGetWindowTitleRequest& request)
WSAPI_ServerMessage response;
response.type = WSAPI_ServerMessage::Type::DidGetWindowTitle;
response.window_id = window.window_id();
ASSERT(window.title().length() < sizeof(response.text));
ASSERT(window.title().length() < (ssize_t)sizeof(response.text));
strcpy(response.text, window.title().characters());
response.text_length = window.title().length();
post_message(response);

10
WindowServer/WSMessageLoop.cpp
View file

@ -290,29 +290,29 @@ void WSMessageLoop::on_receive_from_client(int client_id, const WSAPI_ClientMess
post_message(client, make<WSAPIAddMenuToMenubarRequest>(client_id, message.menu.menubar_id, message.menu.menu_id));
break;
case WSAPI_ClientMessage::Type::CreateMenu:
ASSERT(message.text_length < sizeof(message.text));
ASSERT(message.text_length < (ssize_t)sizeof(message.text));
post_message(client, make<WSAPICreateMenuRequest>(client_id, String(message.text, message.text_length)));
break;
case WSAPI_ClientMessage::Type::DestroyMenu:
post_message(client, make<WSAPIDestroyMenuRequest>(client_id, message.menu.menu_id));
break;
case WSAPI_ClientMessage::Type::AddMenuItem:
ASSERT(message.text_length < sizeof(message.text));
ASSERT(message.text_length < (ssize_t)sizeof(message.text));
post_message(client, make<WSAPIAddMenuItemRequest>(client_id, message.menu.menu_id, message.menu.identifier, String(message.text, message.text_length)));
break;
case WSAPI_ClientMessage::Type::CreateWindow:
ASSERT(message.text_length < sizeof(message.text));
ASSERT(message.text_length < (ssize_t)sizeof(message.text));
post_message(client, make<WSAPICreateWindowRequest>(client_id, message.window.rect, String(message.text, message.text_length), message.window.has_alpha_channel, message.window.opacity, message.window.base_size, message.window.size_increment));
break;
case WSAPI_ClientMessage::Type::DestroyWindow:
post_message(client, make<WSAPIDestroyWindowRequest>(client_id, message.window_id));
break;
case WSAPI_ClientMessage::Type::SetWindowTitle:
ASSERT(message.text_length < sizeof(message.text));
ASSERT(message.text_length < (ssize_t)sizeof(message.text));
post_message(client, make<WSAPISetWindowTitleRequest>(client_id, message.window_id, String(message.text, message.text_length)));
break;
case WSAPI_ClientMessage::Type::GetWindowTitle:
ASSERT(message.text_length < sizeof(message.text));
ASSERT(message.text_length < (ssize_t)sizeof(message.text));
post_message(client, make<WSAPIGetWindowTitleRequest>(client_id, message.window_id));
break;
case WSAPI_ClientMessage::Type::SetWindowRect: