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

Big, possibly complete sweep of naming changes.

Browse source
This commit is contained in:
Andreas Kling 2019-01-31 17:31:23 +01:00
parent 27fa09aee4
commit ffab6897aa
93 changed files with 830 additions and 885 deletions
Download patch file Download diff file Expand all files Collapse all files

6
AK/AKString.h
View file

@ -15,7 +15,7 @@ public:
String() { }
String(const String& other)
: m_impl(const_cast<String&>(other).m_impl.copyRef())
: m_impl(const_cast<String&>(other).m_impl.copy_ref())
{
}
@ -44,7 +44,7 @@ public:
{
}
unsigned toUInt(bool& ok) const;
unsigned to_uint(bool& ok) const;
String to_lowercase() const
{
@ -89,7 +89,7 @@ public:
String& operator=(const String& other)
{
if (this != &other)
m_impl = const_cast<String&>(other).m_impl.copyRef();
m_impl = const_cast<String&>(other).m_impl.copy_ref();
return *this;
}

4
AK/Assertions.h
View file

@ -8,9 +8,9 @@
namespace AK {
inline void notImplemented() { ASSERT(false); }
inline void not_implemented() { ASSERT(false); }
}
using AK::notImplemented;
using AK::not_implemented;

2
AK/Bitmap.h
View file

@ -51,7 +51,7 @@ private:
, m_owned(true)
{
ASSERT(m_size != 0);
size_t size_to_allocate = ceilDiv(size, 8u);
size_t size_to_allocate = ceil_div(size, 8u);
m_data = reinterpret_cast<byte*>(kmalloc(size_to_allocate));
memset(m_data, default_value ? 0xff : 0x00, size_to_allocate);
}

4
AK/ByteBuffer.h
View file

@ -11,7 +11,7 @@ public:
ByteBuffer() { }
ByteBuffer(std::nullptr_t) { }
ByteBuffer(const ByteBuffer& other)
: m_impl(other.m_impl.copyRef())
: m_impl(other.m_impl.copy_ref())
{
}
ByteBuffer(ByteBuffer&& other)
@ -26,7 +26,7 @@ public:
}
ByteBuffer& operator=(const ByteBuffer& other)
{
m_impl = other.m_impl.copyRef();
m_impl = other.m_impl.copy_ref();
return *this;
}

2
AK/DoublyLinkedList.h
View file

@ -48,7 +48,7 @@ public:
append_node(new Node(value));
}
bool containsSlow(const T& value) const
bool contains_slow(const T& value) const
{
for (auto* node = m_head; node; node = node->next) {
if (node->value == value)

2
AK/FileSystemPath.cpp
View file

@ -40,7 +40,7 @@ bool FileSystemPath::canonicalize(bool resolve_symbolic_links)
builder.append('/');
builder.append(cpart);
}
m_string = builder.build();
m_string = builder.to_string();
return true;
}

18
AK/Function.h
View file

@ -41,41 +41,41 @@ public:
template<typename CallableType, class = typename EnableIf<!(IsPointer<CallableType>::value && IsFunction<typename RemovePointer<CallableType>::Type>::value) && IsRvalueReference<CallableType&&>::value>::Type>
Function(CallableType&& callable)
: m_callableWrapper(make<CallableWrapper<CallableType>>(move(callable)))
: m_callable_wrapper(make<CallableWrapper<CallableType>>(move(callable)))
{
}
template<typename FunctionType, class = typename EnableIf<IsPointer<FunctionType>::value && IsFunction<typename RemovePointer<FunctionType>::Type>::value>::Type>
Function(FunctionType f)
: m_callableWrapper(make<CallableWrapper<FunctionType>>(move(f)))
: m_callable_wrapper(make<CallableWrapper<FunctionType>>(move(f)))
{
}
Out operator()(In... in) const
{
ASSERT(m_callableWrapper);
return m_callableWrapper->call(forward<In>(in)...);
ASSERT(m_callable_wrapper);
return m_callable_wrapper->call(forward<In>(in)...);
}
explicit operator bool() const { return !!m_callableWrapper; }
explicit operator bool() const { return !!m_callable_wrapper; }
template<typename CallableType, class = typename EnableIf<!(IsPointer<CallableType>::value && IsFunction<typename RemovePointer<CallableType>::Type>::value) && IsRvalueReference<CallableType&&>::value>::Type>
Function& operator=(CallableType&& callable)
{
m_callableWrapper = make<CallableWrapper<CallableType>>(move(callable));
m_callable_wrapper = make<CallableWrapper<CallableType>>(move(callable));
return *this;
}
template<typename FunctionType, class = typename EnableIf<IsPointer<FunctionType>::value && IsFunction<typename RemovePointer<FunctionType>::Type>::value>::Type>
Function& operator=(FunctionType f)
{
m_callableWrapper = make<CallableWrapper<FunctionType>>(move(f));
m_callable_wrapper = make<CallableWrapper<FunctionType>>(move(f));
return *this;
}
Function& operator=(std::nullptr_t)
{
m_callableWrapper = nullptr;
m_callable_wrapper = nullptr;
return *this;
}
@ -103,7 +103,7 @@ private:
CallableType m_callable;
};
OwnPtr<CallableWrapperBase> m_callableWrapper;
OwnPtr<CallableWrapperBase> m_callable_wrapper;
};
}

6
AK/HashFunctions.h
View file

@ -2,7 +2,7 @@
#include "Types.h"
inline unsigned intHash(dword key)
inline unsigned int_hash(dword key)
{
key += ~(key << 15);
key ^= (key >> 10);
@ -13,8 +13,8 @@ inline unsigned intHash(dword key)
return key;
}
inline unsigned pairIntHash(dword key1, dword key2)
inline unsigned pair_int_hash(dword key1, dword key2)
{
return intHash((intHash(key1) * 209) ^ (intHash(key2 * 413)));
return int_hash((int_hash(key1) * 209) ^ (int_hash(key2 * 413)));
}

2
AK/HashMap.h
View file

@ -54,7 +54,7 @@ public:
void set(const K&, const V&);
void set(const K&, V&&);
void remove(const K&);
void removeOneRandomly() { m_table.remove(m_table.begin()); }
void remove_one_randomly() { m_table.remove(m_table.begin()); }
typedef HashTable<Entry, EntryTraits> HashTableType;
typedef typename HashTableType::Iterator IteratorType;

22
AK/MappedFile.cpp
View file

@ -6,40 +6,40 @@
namespace AK {
MappedFile::MappedFile(String&& fileName)
: m_fileName(std::move(fileName))
MappedFile::MappedFile(String&& file_name)
: m_file_name(std::move(file_name))
{
m_fileLength = 1024;
m_fd = open(m_fileName.characters(), O_RDONLY);
m_file_length = 1024;
m_fd = open(m_file_name.characters(), O_RDONLY);
if (m_fd != -1) {
struct stat st;
fstat(m_fd, &st);
m_fileLength = st.st_size;
m_map = mmap(nullptr, m_fileLength, PROT_READ, MAP_SHARED, m_fd, 0);
m_file_length = st.st_size;
m_map = mmap(nullptr, m_file_length, PROT_READ, MAP_SHARED, m_fd, 0);
if (m_map == MAP_FAILED)
perror("");
}
printf("MappedFile{%s} := { m_fd=%d, m_fileLength=%zu, m_map=%p }\n", m_fileName.characters(), m_fd, m_fileLength, m_map);
printf("MappedFile{%s} := { m_fd=%d, m_file_length=%zu, m_map=%p }\n", m_file_name.characters(), m_fd, m_file_length, m_map);
}
MappedFile::~MappedFile()
{
if (m_map != (void*)-1) {
ASSERT(m_fd != -1);
munmap(m_map, m_fileLength);
munmap(m_map, m_file_length);
}
}
MappedFile::MappedFile(MappedFile&& other)
: m_fileName(std::move(other.m_fileName))
, m_fileLength(other.m_fileLength)
: m_file_name(std::move(other.m_file_name))
, m_file_length(other.m_file_length)
, m_fd(other.m_fd)
, m_map(other.m_map)
{
other.m_fileLength = 0;
other.m_file_length = 0;
other.m_fd = -1;
other.m_map = (void*)-1;
}

10
AK/MappedFile.h
View file

@ -7,19 +7,19 @@ namespace AK {
class MappedFile {
public:
MappedFile() { }
explicit MappedFile(String&& fileName);
explicit MappedFile(String&& file_name);
MappedFile(MappedFile&&);
~MappedFile();
bool isValid() const { return m_map != (void*)-1; }
bool is_valid() const { return m_map != (void*)-1; }
void* pointer() { return m_map; }
const void* pointer() const { return m_map; }
size_t fileLength() const { return m_fileLength; }
size_t file_length() const { return m_file_length; }
private:
String m_fileName;
size_t m_fileLength { 0 };
String m_file_name;
size_t m_file_length { 0 };
int m_fd { -1 };
void* m_map { (void*)-1 };
};

10
AK/OwnPtr.h
View file

@ -11,8 +11,8 @@ class OwnPtr {
public:
OwnPtr() { }
explicit OwnPtr(T* ptr) : m_ptr(ptr) { }
OwnPtr(OwnPtr&& other) : m_ptr(other.leakPtr()) { }
template<typename U> OwnPtr(OwnPtr<U>&& other) : m_ptr(static_cast<T*>(other.leakPtr())) { }
OwnPtr(OwnPtr&& other) : m_ptr(other.leak_ptr()) { }
template<typename U> OwnPtr(OwnPtr<U>&& other) : m_ptr(static_cast<T*>(other.leak_ptr())) { }
OwnPtr(std::nullptr_t) { };
~OwnPtr()
{
@ -29,7 +29,7 @@ public:
{
if (this != &other) {
delete m_ptr;
m_ptr = other.leakPtr();
m_ptr = other.leak_ptr();
}
return *this;
}
@ -39,7 +39,7 @@ public:
{
if (this != static_cast<void*>(&other)) {
delete m_ptr;
m_ptr = other.leakPtr();
m_ptr = other.leak_ptr();
}
return *this;
}
@ -69,7 +69,7 @@ public:
typedef T* OwnPtr::*UnspecifiedBoolType;
operator UnspecifiedBoolType() const { return m_ptr ? &OwnPtr::m_ptr : nullptr; }
T* leakPtr()
T* leak_ptr()
{
T* leakedPtr = m_ptr;
m_ptr = nullptr;

40
AK/RetainPtr.h
View file

@ -6,14 +6,14 @@
namespace AK {
template<typename T>
inline void retainIfNotNull(T* ptr)
inline void retain_if_not_null(T* ptr)
{
if (ptr)
ptr->retain();
}
template<typename T>
inline void releaseIfNotNull(T* ptr)
inline void release_if_not_null(T* ptr)
{
if (ptr)
ptr->release();
@ -25,15 +25,15 @@ public:
enum AdoptTag { Adopt };
RetainPtr() { }
RetainPtr(const T* ptr) : m_ptr(const_cast<T*>(ptr)) { retainIfNotNull(m_ptr); }
RetainPtr(T* ptr) : m_ptr(ptr) { retainIfNotNull(m_ptr); }
RetainPtr(const T* ptr) : m_ptr(const_cast<T*>(ptr)) { retain_if_not_null(m_ptr); }
RetainPtr(T* ptr) : m_ptr(ptr) { retain_if_not_null(m_ptr); }
RetainPtr(T& object) : m_ptr(&object) { m_ptr->retain(); }
RetainPtr(AdoptTag, T& object) : m_ptr(&object) { }
RetainPtr(RetainPtr& other) : m_ptr(other.copyRef().leakRef()) { }
RetainPtr(RetainPtr&& other) : m_ptr(other.leakRef()) { }
template<typename U> RetainPtr(RetainPtr<U>&& other) : m_ptr(static_cast<T*>(other.leakRef())) { }
RetainPtr(const RetainPtr& other) : m_ptr(const_cast<RetainPtr&>(other).copyRef().leakRef()) { }
template<typename U> RetainPtr(const RetainPtr<U>& other) : m_ptr(const_cast<RetainPtr<U>&>(other).copyRef().leakRef()) { }
RetainPtr(RetainPtr& other) : m_ptr(other.copy_ref().leak_ref()) { }
RetainPtr(RetainPtr&& other) : m_ptr(other.leak_ref()) { }
template<typename U> RetainPtr(RetainPtr<U>&& other) : m_ptr(static_cast<T*>(other.leak_ref())) { }
RetainPtr(const RetainPtr& other) : m_ptr(const_cast<RetainPtr&>(other).copy_ref().leak_ref()) { }
template<typename U> RetainPtr(const RetainPtr<U>& other) : m_ptr(const_cast<RetainPtr<U>&>(other).copy_ref().leak_ref()) { }
~RetainPtr()
{
clear();
@ -49,8 +49,8 @@ public:
RetainPtr& operator=(RetainPtr&& other)
{
if (this != &other) {
releaseIfNotNull(m_ptr);
m_ptr = other.leakRef();
release_if_not_null(m_ptr);
m_ptr = other.leak_ref();
}
return *this;
}
@ -59,8 +59,8 @@ public:
RetainPtr& operator=(RetainPtr<U>&& other)
{
if (this != static_cast<void*>(&other)) {
releaseIfNotNull(m_ptr);
m_ptr = other.leakRef();
release_if_not_null(m_ptr);
m_ptr = other.leak_ref();
}
return *this;
}
@ -68,18 +68,18 @@ public:
RetainPtr& operator=(T* ptr)
{
if (m_ptr != ptr)
releaseIfNotNull(m_ptr);
release_if_not_null(m_ptr);
m_ptr = ptr;
retainIfNotNull(m_ptr);
retain_if_not_null(m_ptr);
return *this;
}
RetainPtr& operator=(T& object)
{
if (m_ptr != &object)
releaseIfNotNull(m_ptr);
release_if_not_null(m_ptr);
m_ptr = &object;
retainIfNotNull(m_ptr);
retain_if_not_null(m_ptr);
return *this;
}
@ -89,14 +89,14 @@ public:
return *this;
}
RetainPtr copyRef() const
RetainPtr copy_ref() const
{
return RetainPtr(m_ptr);
}
void clear()
{
releaseIfNotNull(m_ptr);
release_if_not_null(m_ptr);
m_ptr = nullptr;
}
@ -105,7 +105,7 @@ public:
typedef T* RetainPtr::*UnspecifiedBoolType;
operator UnspecifiedBoolType() const { return m_ptr ? &RetainPtr::m_ptr : nullptr; }
T* leakRef()
T* leak_ref()
{
T* leakedPtr = m_ptr;
m_ptr = nullptr;

70
AK/SimpleMalloc.cpp
View file

@ -50,28 +50,28 @@ public:
void initialize(byte* base)
{
m_base = base;
m_free = capacityInAllocations();
m_free = capacity_in_allocations();
dump();
}
static constexpr dword capacityInAllocations()
static constexpr dword capacity_in_allocations()
{
return 1048576 / chunkSize;
}
static constexpr dword capacityInBytes()
static constexpr dword capacity_in_bytes()
{
return capacityInAllocations() * chunkSize;
return capacity_in_allocations() * chunkSize;
}
byte* allocate()
{
auto bitmap = this->bitmap();
for (dword i = 0; i < capacityInAllocations(); ++i) {
for (dword i = 0; i < capacity_in_allocations(); ++i) {
if (!bitmap.get(i)) {
bitmap.set(i, true);
--m_free;
return pointerToChunk(i);
return pointer_to_chunk(i);
}
}
return nullptr;
@ -84,57 +84,57 @@ public:
void free(byte* ptr)
{
ASSERT(isInAllocator(ptr));
ASSERT(is_in_allocator(ptr));
auto bitmap = this->bitmap();
auto chunkIndex = chunkIndexFromPointer(ptr);
ASSERT(bitmap.get(chunkIndex));
bitmap.set(chunkIndex, false);
auto chunk_index = chunk_index_from_pointer(ptr);
ASSERT(bitmap.get(chunk_index));
bitmap.set(chunk_index, false);
++m_free;
}
bool isInAllocator(byte* ptr)
bool is_in_allocator(byte* ptr)
{
return ptr >= pointerToChunk(0) && ptr <= addressAfterThisAllocator();
return ptr >= pointer_to_chunk(0) && ptr <= address_after_this_allocator();
}
dword chunkIndexFromPointer(byte* ptr)
dword chunk_index_from_pointer(byte* ptr)
{
return (ptr - pointerToChunk(0)) / chunkSize;
return (ptr - pointer_to_chunk(0)) / chunkSize;
}
byte* pointerToChunk(dword index)
byte* pointer_to_chunk(dword index)
{
return m_base + sizeOfAllocationBitmapInBytes() + (index * chunkSize);
return m_base + size_of_allocation_bitmap_in_bytes() + (index * chunkSize);
}
AllocationBitmap bitmap()
{
return AllocationBitmap::wrap(m_base, capacityInAllocations());
return AllocationBitmap::wrap(m_base, capacity_in_allocations());
}
static constexpr dword sizeOfAllocationBitmapInBytes()
static constexpr dword size_of_allocation_bitmap_in_bytes()
{
return capacityInAllocations() / 8;
return capacity_in_allocations() / 8;
}
byte* addressAfterThisAllocator() const
byte* address_after_this_allocator() const
{
return m_base + sizeOfAllocationBitmapInBytes() + capacityInBytes();
return m_base + size_of_allocation_bitmap_in_bytes() + capacity_in_bytes();
}
dword numberOfFreeChunks() const
dword number_of_free_chunks() const
{
return m_free;
}
private:
byte* m_base { nullptr };
dword m_free { capacityInAllocations() };
dword m_free { capacity_in_allocations() };
};
struct Allocator {
void initialize();
void initializeIfNeeded();
void initialize_if_needed();
void dump();
ChunkAllocator<8> alloc8;
@ -148,7 +148,7 @@ struct Allocator {
static Allocator allocator;
void Allocator::initializeIfNeeded()
void Allocator::initialize_if_needed()
{
if (initialized)
return;
@ -161,9 +161,9 @@ void Allocator::initialize()
space = (byte*)mmap((void*)0x20000000, 32 * MB, PROT_WRITE | PROT_READ | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT(space != MAP_FAILED);
alloc8.initialize(space + 0x10000);
alloc16.initialize(alloc8.addressAfterThisAllocator());
alloc4096.initialize(alloc16.addressAfterThisAllocator());
alloc16384.initialize(alloc4096.addressAfterThisAllocator());
alloc16.initialize(alloc8.address_after_this_allocator());
alloc4096.initialize(alloc16.address_after_this_allocator());
alloc16384.initialize(alloc4096.address_after_this_allocator());
}
void Allocator::dump()
@ -188,7 +188,7 @@ byte* allocate(dword size)
{
if (!size)
return nullptr;
allocator.initializeIfNeeded();
allocator.initialize_if_needed();
if (size <= 8) {
if (auto* ptr = allocator.alloc8.allocate())
return ptr;
@ -210,7 +210,7 @@ byte* allocate(dword size)
return nullptr;
}
byte* allocateZeroed(dword size)
byte* allocate_zeroed(dword size)
{
auto* ptr = allocate(size);
if (!ptr)
@ -232,20 +232,20 @@ void free(byte* ptr)
{
if (!ptr)
return;
allocator.initializeIfNeeded();
if (allocator.alloc8.isInAllocator(ptr)) {
allocator.initialize_if_needed();
if (allocator.alloc8.is_in_allocator(ptr)) {
allocator.alloc8.free(ptr);
return;
}
if (allocator.alloc16.isInAllocator(ptr)) {
if (allocator.alloc16.is_in_allocator(ptr)) {
allocator.alloc16.free(ptr);
return;
}
if (allocator.alloc4096.isInAllocator(ptr)) {
if (allocator.alloc4096.is_in_allocator(ptr)) {
allocator.alloc4096.free(ptr);
return;
}
if (allocator.alloc16384.isInAllocator(ptr)) {
if (allocator.alloc16384.is_in_allocator(ptr)) {
allocator.alloc16384.free(ptr);
return;
}

2
AK/SimpleMalloc.h
View file

@ -7,7 +7,7 @@ namespace SimpleMalloc {
void initialize();
void dump();
byte* allocate(dword);
byte* allocateZeroed(dword);
byte* allocate_zeroed(dword);
void free(byte*);
byte* reallocate(byte*, dword);

2
AK/SinglyLinkedList.h
View file

@ -47,7 +47,7 @@ public:
m_tail = node;
}
bool containsSlow(const T& value) const
bool contains_slow(const T& value) const
{
for (auto* node = m_head; node; node = node->next) {
if (node->value == value)

4
AK/StdLibExtras.h
View file

@ -45,7 +45,7 @@ inline T max(const T& a, const T& b)
template<typename T, typename U>
static inline T ceilDiv(T a, U b)
static inline T ceil_div(T a, U b)
{
static_assert(sizeof(T) == sizeof(U));
T result = a / b;
@ -173,5 +173,5 @@ using AK::move;
using AK::forward;
using AK::exchange;
using AK::swap;
using AK::ceilDiv;
using AK::ceil_div;

8
AK/String.cpp
View file

@ -42,10 +42,10 @@ String String::substring(size_t start, size_t length) const
ASSERT(start + length <= m_impl->length());
// FIXME: This needs some input bounds checking.
char* buffer;
auto newImpl = StringImpl::create_uninitialized(length, buffer);
auto new_impl = StringImpl::create_uninitialized(length, buffer);
memcpy(buffer, characters() + start, length);
buffer[length] = '\0';
return newImpl;
return new_impl;
}
Vector<String> String::split(const char separator) const
@ -79,7 +79,7 @@ ByteBuffer String::to_byte_buffer() const
return ByteBuffer::copy(reinterpret_cast<const byte*>(characters()), length());
}
unsigned String::toUInt(bool& ok) const
unsigned String::to_uint(bool& ok) const
{
unsigned value = 0;
for (size_t i = 0; i < length(); ++i) {
@ -101,7 +101,7 @@ String String::format(const char* fmt, ...)
va_start(ap, fmt);
builder.appendvf(fmt, ap);
va_end(ap);
return builder.build();
return builder.to_string();
}
}

4
AK/StringBuilder.cpp
View file

@ -43,7 +43,7 @@ void StringBuilder::append(char ch)
void StringBuilder::appendvf(const char* fmt, va_list ap)
{
printfInternal([this] (char*&, char ch) {
printf_internal([this] (char*&, char ch) {
append(ch);
}, nullptr, fmt, ap);
}
@ -62,7 +62,7 @@ ByteBuffer StringBuilder::to_byte_buffer()
return move(m_buffer);
}
String StringBuilder::build()
String StringBuilder::to_string()
{
auto string = String((const char*)m_buffer.pointer(), m_length);
m_buffer.clear();

2
AK/StringBuilder.h
View file

@ -17,7 +17,7 @@ public:
void appendf(const char*, ...);
void appendvf(const char*, va_list);
String build();
String to_string();
ByteBuffer to_byte_buffer();
private:

46
AK/StringImpl.cpp
View file

@ -55,7 +55,7 @@ StringImpl::~StringImpl()
#endif
}
static inline size_t allocationSizeForStringImpl(size_t length)
static inline size_t allocation_size_for_stringimpl(size_t length)
{
return sizeof(StringImpl) + (sizeof(char) * length) + sizeof(char);
}
@ -63,14 +63,14 @@ static inline size_t allocationSizeForStringImpl(size_t length)
RetainPtr<StringImpl> StringImpl::create_uninitialized(size_t length, char*& buffer)
{
ASSERT(length);
void* slot = kmalloc(allocationSizeForStringImpl(length));
void* slot = kmalloc(allocation_size_for_stringimpl(length));
if (!slot)
return nullptr;
auto newStringImpl = adopt(*new (slot) StringImpl(ConstructWithInlineBuffer, length));
buffer = const_cast<char*>(newStringImpl->m_characters);
auto new_stringimpl = adopt(*new (slot) StringImpl(ConstructWithInlineBuffer, length));
buffer = const_cast<char*>(new_stringimpl->m_characters);
buffer[length] = '\0';
return newStringImpl;
return new_stringimpl;
}
RetainPtr<StringImpl> StringImpl::create(const char* cstring, size_t length, ShouldChomp shouldChomp)
@ -82,17 +82,17 @@ RetainPtr<StringImpl> StringImpl::create(const char* cstring, size_t length, Sho
return the_empty_stringimpl();
char* buffer;
auto newStringImpl = create_uninitialized(length, buffer);
if (!newStringImpl)
auto new_stringimpl = create_uninitialized(length, buffer);
if (!new_stringimpl)
return nullptr;
memcpy(buffer, cstring, length * sizeof(char));
if (shouldChomp && buffer[length - 1] == '\n') {
buffer[length - 1] = '\0';
--newStringImpl->m_length;
--new_stringimpl->m_length;
}
return newStringImpl;
return new_stringimpl;
}
RetainPtr<StringImpl> StringImpl::create(const char* cstring, ShouldChomp shouldChomp)
@ -103,26 +103,26 @@ RetainPtr<StringImpl> StringImpl::create(const char* cstring, ShouldChomp should
return create(cstring, strlen(cstring), shouldChomp);
}
static inline bool isASCIILowercase(char c)
static inline bool is_ascii_lowercase(char c)
{
return c >= 'a' && c <= 'z';
}
static inline bool isASCIIUppercase(char c)
static inline bool is_ascii_uppercase(char c)
{
return c >= 'A' && c <= 'Z';
}
static inline char toASCIILowercase(char c)
static inline char to_ascii_lowercase(char c)
{
if (isASCIIUppercase(c))
if (is_ascii_uppercase(c))
return c | 0x20;
return c;
}
static inline char toASCIIUppercase(char c)
static inline char to_ascii_uppercase(char c)
{
if (isASCIILowercase(c))
if (is_ascii_lowercase(c))
return c & ~0x20;
return c;
}
@ -133,18 +133,18 @@ RetainPtr<StringImpl> StringImpl::to_lowercase() const
return const_cast<StringImpl*>(this);
for (size_t i = 0; i < m_length; ++i) {
if (!isASCIILowercase(m_characters[i]))
goto slowPath;
if (!is_ascii_lowercase(m_characters[i]))
goto slow_path;
}
return const_cast<StringImpl*>(this);
slowPath:
slow_path:
char* buffer;
auto lowercased = create_uninitialized(m_length, buffer);
if (!lowercased)
return nullptr;
for (size_t i = 0; i < m_length; ++i)
buffer[i] = toASCIILowercase(m_characters[i]);
buffer[i] = to_ascii_lowercase(m_characters[i]);
return lowercased;
}
@ -155,18 +155,18 @@ RetainPtr<StringImpl> StringImpl::to_uppercase() const
return const_cast<StringImpl*>(this);
for (size_t i = 0; i < m_length; ++i) {
if (!isASCIIUppercase(m_characters[i]))
goto slowPath;
if (!is_ascii_uppercase(m_characters[i]))
goto slow_path;
}
return const_cast<StringImpl*>(this);
slowPath:
slow_path:
char* buffer;
auto uppercased = create_uninitialized(m_length, buffer);
if (!uppercased)
return nullptr;
for (size_t i = 0; i < m_length; ++i)
buffer[i] = toASCIIUppercase(m_characters[i]);
buffer[i] = to_ascii_uppercase(m_characters[i]);
return uppercased;
}

6
AK/TemporaryFile.cpp
View file

@ -11,14 +11,14 @@ TemporaryFile::TemporaryFile()
int fd = mkstemp(nameBuffer);
if (fd != -1) {
m_stream = fdopen(fd, "w+");
m_fileName = nameBuffer;
m_file_name = nameBuffer;
}
}
TemporaryFile::~TemporaryFile()
{
if (isValid()) {
unlink(m_fileName.characters());
if (is_valid()) {
unlink(m_file_name.characters());
fclose(m_stream);
}
}

6
AK/TemporaryFile.h
View file

@ -10,14 +10,14 @@ public:
TemporaryFile();
~TemporaryFile();
bool isValid() const { return m_stream; }
bool is_valid() const { return m_stream; }
FILE* stream() { return m_stream; }
String fileName() const { return m_fileName; }
String file_name() const { return m_file_name; }
void sync();
private:
FILE* m_stream { nullptr };
String m_fileName;
String m_file_name;
};
}

6
AK/Traits.h
View file

@ -12,13 +12,13 @@ struct Traits
template<>
struct Traits<int> {
static unsigned hash(int i) { return intHash(i); }
static unsigned hash(int i) { return int_hash(i); }
static void dump(int i) { kprintf("%d", i); }
};
template<>
struct Traits<unsigned> {
static unsigned hash(unsigned u) { return intHash(u); }
static unsigned hash(unsigned u) { return int_hash(u); }
static void dump(unsigned u) { kprintf("%u", u); }
};
@ -26,7 +26,7 @@ template<typename T>
struct Traits<T*> {
static unsigned hash(const T* p)
{
return intHash((dword)p);
return int_hash((dword)p);
}
static void dump(const T* p) { kprintf("%p", p); }
};

8
AK/Vector.h
View file

@ -219,16 +219,16 @@ public:
if (capacity() >= neededCapacity)
return;
size_t new_capacity = padded_capacity(neededCapacity);
auto newImpl = VectorImpl<T, Allocator>::create(new_capacity);
auto new_impl = VectorImpl<T, Allocator>::create(new_capacity);
if (m_impl) {
newImpl->m_size = m_impl->m_size;
new_impl->m_size = m_impl->m_size;
for (size_t i = 0; i < size(); ++i) {
new (newImpl->slot(i)) T(move(m_impl->at(i)));
new (new_impl->slot(i)) T(move(m_impl->at(i)));
m_impl->at(i).~T();
}
Allocator::deallocate(m_impl);
}
m_impl = newImpl;
m_impl = new_impl;
}
void resize(size_t new_size)

10
AK/WeakPtr.h
View file

@ -13,14 +13,14 @@ public:
template<typename U>
WeakPtr(WeakPtr<U>&& other)
: m_link(reinterpret_cast<WeakLink<T>*>(other.leakLink()))
: m_link(reinterpret_cast<WeakLink<T>*>(other.leak_link()))
{
}
template<typename U>
WeakPtr& operator=(WeakPtr<U>&& other)
{
m_link = reinterpret_cast<WeakLink<T>*>(other.leakLink());
m_link = reinterpret_cast<WeakLink<T>*>(other.leak_link());
return *this;
}
@ -38,7 +38,7 @@ public:
bool is_null() const { return !m_link || !m_link->ptr(); }
void clear() { m_link = nullptr; }
WeakLink<T>* leakLink() { return m_link.leakRef(); }
WeakLink<T>* leak_link() { return m_link.leak_ref(); }
private:
WeakPtr(RetainPtr<WeakLink<T>>&& link) : m_link(move(link)) { }
@ -47,11 +47,11 @@ private:
};
template<typename T>
inline WeakPtr<T> Weakable<T>::makeWeakPtr()
inline WeakPtr<T> Weakable<T>::make_weak_ptr()
{
if (!m_link)
m_link = adopt(*new WeakLink<T>(static_cast<T&>(*this)));
return WeakPtr<T>(m_link.copyRef());
return WeakPtr<T>(m_link.copy_ref());
}
}

2
AK/Weakable.h
View file

@ -26,7 +26,7 @@ class Weakable {
private:
class Link;
public:
WeakPtr<T> makeWeakPtr();
WeakPtr<T> make_weak_ptr();
protected:
Weakable() { }

2
AK/kmalloc.cpp
View file

@ -84,7 +84,7 @@ void* kcalloc(size_t nmemb, size_t size)
{
if (!nmemb || !size)
return nullptr;
return SimpleMalloc::allocateZeroed(nmemb * size);
return SimpleMalloc::allocate_zeroed(nmemb * size);
}
void* kmalloc(size_t size)

28
AK/printf.cpp
View file

@ -13,7 +13,7 @@ ALWAYS_INLINE size_t strlen(const char* str)
static constexpr const char* h = "0123456789abcdef";
template<typename PutChFunc>
ALWAYS_INLINE int printHex(PutChFunc putch, char*& bufptr, dword number, byte fields)
ALWAYS_INLINE int print_hex(PutChFunc putch, char*& bufptr, dword number, byte fields)
{
int ret = 0;
byte shr_count = fields * 4;
@ -26,7 +26,7 @@ ALWAYS_INLINE int printHex(PutChFunc putch, char*& bufptr, dword number, byte fi
}
template<typename PutChFunc>
ALWAYS_INLINE int printNumber(PutChFunc putch, char*& bufptr, dword number, bool leftPad, bool zeroPad, dword fieldWidth)
ALWAYS_INLINE int print_number(PutChFunc putch, char*& bufptr, dword number, bool leftPad, bool zeroPad, dword fieldWidth)
{
dword divisor = 1000000000;
char ch;
@ -108,7 +108,7 @@ ALWAYS_INLINE int print_octal_number(PutChFunc putch, char*& bufptr, dword numbe
}
template<typename PutChFunc>
ALWAYS_INLINE int printString(PutChFunc putch, char*& bufptr, const char* str, bool leftPad, dword fieldWidth)
ALWAYS_INLINE int print_string(PutChFunc putch, char*& bufptr, const char* str, bool leftPad, dword fieldWidth)
{
size_t len = strlen(str);
if (!fieldWidth || fieldWidth < len)
@ -129,17 +129,17 @@ ALWAYS_INLINE int printString(PutChFunc putch, char*& bufptr, const char* str, b
template<typename PutChFunc>
ALWAYS_INLINE int printSignedNumber(PutChFunc putch, char*& bufptr, int number, bool leftPad, bool zeroPad, dword fieldWidth)
ALWAYS_INLINE int print_signed_number(PutChFunc putch, char*& bufptr, int number, bool leftPad, bool zeroPad, dword fieldWidth)
{
if (number < 0) {
putch(bufptr, '-');
return printNumber(putch, bufptr, 0 - number, leftPad, zeroPad, fieldWidth) + 1;
return print_number(putch, bufptr, 0 - number, leftPad, zeroPad, fieldWidth) + 1;
}
return printNumber(putch, bufptr, number, leftPad, zeroPad, fieldWidth);
return print_number(putch, bufptr, number, leftPad, zeroPad, fieldWidth);
}
template<typename PutChFunc>
ALWAYS_INLINE int printfInternal(PutChFunc putch, char* buffer, const char*& fmt, char*& ap)
ALWAYS_INLINE int printf_internal(PutChFunc putch, char* buffer, const char*& fmt, char*& ap)
{
const char *p;
@ -174,16 +174,16 @@ one_more:
case 's':
{
const char* sp = va_arg(ap, const char*);
ret += printString(putch, bufptr, sp ? sp : "(null)", leftPad, fieldWidth);
ret += print_string(putch, bufptr, sp ? sp : "(null)", leftPad, fieldWidth);
}
break;
case 'd':
ret += printSignedNumber(putch, bufptr, va_arg(ap, int), leftPad, zeroPad, fieldWidth);
ret += print_signed_number(putch, bufptr, va_arg(ap, int), leftPad, zeroPad, fieldWidth);
break;
case 'u':
ret += printNumber(putch, bufptr, va_arg(ap, dword), leftPad, zeroPad, fieldWidth);
ret += print_number(putch, bufptr, va_arg(ap, dword), leftPad, zeroPad, fieldWidth);
break;
case 'o':
@ -191,15 +191,15 @@ one_more:
break;
case 'x':
ret += printHex(putch, bufptr, va_arg(ap, dword), 8);
ret += print_hex(putch, bufptr, va_arg(ap, dword), 8);
break;
case 'w':
ret += printHex(putch, bufptr, va_arg(ap, int), 4);
ret += print_hex(putch, bufptr, va_arg(ap, int), 4);
break;
case 'b':
ret += printHex(putch, bufptr, va_arg(ap, int), 2);
ret += print_hex(putch, bufptr, va_arg(ap, int), 2);
break;
case 'c':
@ -211,7 +211,7 @@ one_more:
putch(bufptr, '0');
putch(bufptr, 'x');
ret += 2;
ret += printHex(putch, bufptr, va_arg(ap, dword), 8);
ret += print_hex(putch, bufptr, va_arg(ap, dword), 8);
break;
}
}

36
AK/test.cpp
View file

@ -13,7 +13,7 @@
#include "FileSystemPath.h"
#include "Lock.h"
static void testWeakPtr();
static void test_weak_ptr();
void log_locked() { }
void log_unlocked() { }
@ -223,7 +223,7 @@ int main(int c, char** v)
}
{
auto printInts = [] (const Vector<int>& v) {
auto print_ints = [] (const Vector<int>& v) {
printf("Vector {\n size: %zu\n capacity: %zu\n elements: ", v.size(), v.capacity());
for (auto i : v)
printf("%d ", i);
@ -235,23 +235,23 @@ int main(int c, char** v)
v.append(1);
v.append(2);
v.append(3);
printInts(v);
print_ints(v);
v.remove(1);
printInts(v);
print_ints(v);
v.remove(0);
printInts(v);
print_ints(v);
v.remove(0);
printInts(v);
print_ints(v);
v.remove(0);
printInts(v);
print_ints(v);
}
{
auto printInts = [] (const HashTable<int>& h) {
auto print_ints = [] (const HashTable<int>& h) {
printf("HashTable {\n size: %u\n capacity: %u\n elements: ", h.size(), h.capacity());
for (auto i : h)
printf("%d ", i);
@ -268,17 +268,17 @@ int main(int c, char** v)
h.dump();
printInts(h);
print_ints(h);
h.remove(30);
printInts(h);
print_ints(h);
h.set(30);
h.remove(30);
printInts(h);
print_ints(h);
}
testWeakPtr();
test_weak_ptr();
return 0;
}
@ -289,16 +289,16 @@ public:
~TestWeakable() { }
};
void testWeakPtr()
void test_weak_ptr()
{
auto* weakable = new TestWeakable;
auto weakPtr = weakable->makeWeakPtr();
ASSERT(weakPtr);
ASSERT(weakPtr.ptr() == weakable);
auto weak_ptr = weakable->make_weak_ptr();
ASSERT(weak_ptr);
ASSERT(weak_ptr.ptr() == weakable);
delete weakable;
ASSERT(!weakPtr);
ASSERT(weakPtr.ptr() == nullptr);
ASSERT(!weak_ptr);
ASSERT(weak_ptr.ptr() == nullptr);
}