Bananymous
/
banan-os
1
1
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

BAN: Make String and StringView header only 

This allows linking with libc without having to link ban
This commit is contained in:
Bananymous 2024-05-23 15:43:26 +03:00
parent e22821799b
commit 06f4b0b29a
16 changed files with 444 additions and 554 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

280
BAN/BAN/String.cpp
View File

@ -1,280 +0,0 @@
#include <BAN/String.h>
#include <BAN/New.h>
namespace BAN
{
String::String()
{
}
String::String(const String& other)
{
*this = other;
}
String::String(String&& other)
{
*this = move(other);
}
String::String(StringView other)
{
*this = other;
}
String::~String()
{
clear();
}
String& String::operator=(const String& other)
{
clear();
MUST(ensure_capacity(other.size()));
memcpy(data(), other.data(), other.size() + 1);
m_size = other.size();
return *this;
}
String& String::operator=(String&& other)
{
clear();
if (other.has_sso())
memcpy(data(), other.data(), other.size() + 1);
else
{
m_storage.general_storage = other.m_storage.general_storage;
m_has_sso = false;
}
m_size = other.m_size;
other.m_size = 0;
other.m_storage.sso_storage = SSOStorage();
other.m_has_sso = true;
return *this;
}
String& String::operator=(StringView other)
{
clear();
MUST(ensure_capacity(other.size()));
memcpy(data(), other.data(), other.size());
m_size = other.size();
data()[m_size] = '\0';
return *this;
}
ErrorOr<void> String::push_back(char c)
{
TRY(ensure_capacity(m_size + 1));
data()[m_size] = c;
m_size++;
data()[m_size] = '\0';
return {};
}
ErrorOr<void> String::insert(char c, size_type index)
{
ASSERT(index <= m_size);
TRY(ensure_capacity(m_size + 1));
memmove(data() + index + 1, data() + index, m_size - index);
data()[index] = c;
m_size++;
data()[m_size] = '\0';
return {};
}
ErrorOr<void> String::insert(StringView str, size_type index)
{
ASSERT(index <= m_size);
TRY(ensure_capacity(m_size + str.size()));
memmove(data() + index + str.size(), data() + index, m_size - index);
memcpy(data() + index, str.data(), str.size());
m_size += str.size();
data()[m_size] = '\0';
return {};
}
ErrorOr<void> String::append(StringView str)
{
TRY(ensure_capacity(m_size + str.size()));
memcpy(data() + m_size, str.data(), str.size());
m_size += str.size();
data()[m_size] = '\0';
return {};
}
void String::pop_back()
{
ASSERT(m_size > 0);
m_size--;
data()[m_size] = '\0';
}
void String::remove(size_type index)
{
ASSERT(index < m_size);
memcpy(data() + index, data() + index + 1, m_size - index);
m_size--;
data()[m_size] = '\0';
}
void String::clear()
{
if (!has_sso())
{
deallocator(m_storage.general_storage.data);
m_storage.sso_storage = SSOStorage();
m_has_sso = true;
}
m_size = 0;
data()[m_size] = '\0';
}
bool String::operator==(const String& str) const
{
if (size() != str.size())
return false;
for (size_type i = 0; i < m_size; i++)
if (data()[i] != str.data()[i])
return false;
return true;
}
bool String::operator==(StringView str) const
{
if (size() != str.size())
return false;
for (size_type i = 0; i < m_size; i++)
if (data()[i] != str.data()[i])
return false;
return true;
}
bool String::operator==(const char* cstr) const
{
for (size_type i = 0; i < m_size; i++)
if (data()[i] != cstr[i])
return false;
if (cstr[size()] != '\0')
return false;
return true;
}
ErrorOr<void> String::resize(size_type new_size, char init_c)
{
if (m_size == new_size)
return {};
// expanding
if (m_size < new_size)
{
TRY(ensure_capacity(new_size));
memset(data() + m_size, init_c, new_size - m_size);
m_size = new_size;
data()[m_size] = '\0';
return {};
}
m_size = new_size;
data()[m_size] = '\0';
return {};
}
ErrorOr<void> String::reserve(size_type new_size)
{
TRY(ensure_capacity(new_size));
return {};
}
ErrorOr<void> String::shrink_to_fit()
{
if (has_sso())
return {};
if (fits_in_sso())
{
char* data = m_storage.general_storage.data;
m_storage.sso_storage = SSOStorage();
m_has_sso = true;
memcpy(this->data(), data, m_size + 1);
deallocator(data);
return {};
}
GeneralStorage& storage = m_storage.general_storage;
if (storage.capacity == m_size)
return {};
char* new_data = (char*)allocator(m_size + 1);
if (new_data == nullptr)
return Error::from_errno(ENOMEM);
memcpy(new_data, storage.data, m_size);
deallocator(storage.data);
storage.capacity = m_size;
storage.data = new_data;
return {};
}
String::size_type String::capacity() const
{
if (has_sso())
return sso_capacity;
return m_storage.general_storage.capacity;
}
char* String::data()
{
if (has_sso())
return m_storage.sso_storage.data;
return m_storage.general_storage.data;
}
const char* String::data() const
{
if (has_sso())
return m_storage.sso_storage.data;
return m_storage.general_storage.data;
}
ErrorOr<void> String::ensure_capacity(size_type new_size)
{
if (m_size >= new_size)
return {};
if (has_sso() && fits_in_sso(new_size))
return {};
char* new_data = (char*)allocator(new_size + 1);
if (new_data == nullptr)
return Error::from_errno(ENOMEM);
if (m_size)
memcpy(new_data, data(), m_size + 1);
if (has_sso())
{
m_storage.general_storage = GeneralStorage();
m_has_sso = false;
}
else
deallocator(m_storage.general_storage.data);
auto& storage = m_storage.general_storage;
storage.capacity = new_size;
storage.data = new_data;
return {};
}
bool String::has_sso() const
{
return m_has_sso;
}
}

185
BAN/BAN/StringView.cpp
View File

@ -1,196 +1,11 @@
#include <BAN/String.h> #include <BAN/String.h>
#include <BAN/StringView.h> #include <BAN/StringView.h>
#include <BAN/Vector.h>
#include <string.h>
namespace BAN namespace BAN
{ {
StringView::StringView()
{ }
StringView::StringView(const String& other) StringView::StringView(const String& other)
: StringView(other.data(), other.size()) : StringView(other.data(), other.size())
{ } { }
StringView::StringView(const char* string, size_type len)
{
if (len == size_type(-1))
len = strlen(string);
m_data = string;
m_size = len;
}
char StringView::operator[](size_type index) const
{
ASSERT(index < m_size);
return m_data[index];
}
bool StringView::operator==(const String& other) const
{
if (m_size != other.size())
return false;
return memcmp(m_data, other.data(), m_size) == 0;
}
bool StringView::operator==(StringView other) const
{
if (m_size != other.m_size)
return false;
return memcmp(m_data, other.m_data, m_size) == 0;
}
bool StringView::operator==(const char* other) const
{
if (memcmp(m_data, other, m_size))
return false;
return other[m_size] == '\0';
}
StringView StringView::substring(size_type index, size_type len) const
{
ASSERT(index <= m_size);
if (len == size_type(-1))
len = m_size - index;
ASSERT(len <= m_size - index); // weird order to avoid overflow
StringView result;
result.m_data = m_data + index;
result.m_size = len;
return result;
}
ErrorOr<Vector<StringView>> StringView::split(char delim, bool allow_empties) const
{
size_type count = 0;
{
size_type start = 0;
for (size_type i = 0; i < m_size; i++)
{
if (m_data[i] == delim)
{
if (allow_empties || start != i)
count++;
start = i + 1;
}
}
if (start != m_size)
count++;
}
Vector<StringView> result;
TRY(result.reserve(count));
size_type start = 0;
for (size_type i = 0; i < m_size; i++)
{
if (m_data[i] == delim)
{
if (allow_empties || start != i)
TRY(result.push_back(this->substring(start, i - start)));
start = i + 1;
}
}
if (start < m_size || (start == m_size && allow_empties))
TRY(result.push_back(this->substring(start)));
return result;
}
ErrorOr<Vector<StringView>> StringView::split(bool(*comp)(char), bool allow_empties) const
{
size_type count = 0;
{
size_type start = 0;
for (size_type i = 0; i < m_size; i++)
{
if (comp(m_data[i]))
{
if (allow_empties || start != i)
count++;
start = i + 1;
}
}
if (start != m_size)
count++;
}
Vector<StringView> result;
TRY(result.reserve(count));
size_type start = 0;
for (size_type i = 0; i < m_size; i++)
{
if (comp(m_data[i]))
{
if (allow_empties || start != i)
TRY(result.push_back(this->substring(start, i - start)));
start = i + 1;
}
}
if (start < m_size || (start == m_size && allow_empties))
TRY(result.push_back(this->substring(start)));
return result;
}
char StringView::back() const
{
ASSERT(m_size > 0);
return m_data[m_size - 1];
}
char StringView::front() const
{
ASSERT(m_size > 0);
return m_data[0];
}
BAN::Optional<StringView::size_type> StringView::find(char ch) const
{
for (size_type i = 0; i < m_size; i++)
if (m_data[i] == ch)
return i;
return {};
}
BAN::Optional<StringView::size_type> StringView::find(bool(*comp)(char)) const
{
for (size_type i = 0; i < m_size; i++)
if (comp(m_data[i]))
return i;
return {};
}
bool StringView::contains(char ch) const
{
for (size_type i = 0; i < m_size; i++)
if (m_data[i] == ch)
return true;
return false;
}
StringView::size_type StringView::count(char ch) const
{
size_type result = 0;
for (size_type i = 0; i < m_size; i++)
if (m_data[i] == ch)
result++;
return result;
}
bool StringView::empty() const
{
return m_size == 0;
}
StringView::size_type StringView::size() const
{
return m_size;
}
const char* StringView::data() const
{
return m_data;
}
} }

1
BAN/CMakeLists.txt
View File

@ -5,7 +5,6 @@ project(BAN CXX)
set(BAN_SOURCES set(BAN_SOURCES
BAN/Assert.cpp BAN/Assert.cpp
BAN/New.cpp BAN/New.cpp
BAN/String.cpp
BAN/StringView.cpp BAN/StringView.cpp
BAN/Time.cpp BAN/Time.cpp
) )

5
BAN/include/BAN/Errors.h
View File

@ -1,7 +1,6 @@
#pragma once #pragma once
#include <BAN/Formatter.h> #include <BAN/Formatter.h>
#include <BAN/StringView.h>
#include <BAN/Variant.h> #include <BAN/Variant.h>
#include <errno.h> #include <errno.h>
@ -56,7 +55,7 @@ namespace BAN
#endif #endif
uint64_t get_error_code() const { return m_error_code; } uint64_t get_error_code() const { return m_error_code; }
BAN::StringView get_message() const const char* get_message() const
{ {
#ifdef __is_kernel #ifdef __is_kernel
if (m_error_code & kernel_error_mask) if (m_error_code & kernel_error_mask)
@ -64,7 +63,7 @@ namespace BAN
#endif #endif
if (auto* desc = strerrordesc_np(m_error_code)) if (auto* desc = strerrordesc_np(m_error_code))
return desc; return desc;
return "Unknown error"sv; return "Unknown error";
} }
private: private:

286
BAN/include/BAN/String.h
View File

@ -2,9 +2,10 @@
#include <BAN/Errors.h> #include <BAN/Errors.h>
#include <BAN/Formatter.h> #include <BAN/Formatter.h>
#include <BAN/ForwardList.h>
#include <BAN/Hash.h> #include <BAN/Hash.h>
#include <BAN/Iterators.h> #include <BAN/Iterators.h>
#include <BAN/New.h>
#include <BAN/StringView.h>
namespace BAN namespace BAN
{ {
@ -18,28 +19,125 @@ namespace BAN
static constexpr size_type sso_capacity = 15; static constexpr size_type sso_capacity = 15;
public: public:
String(); String() {}
String(const String&); String(const String& other) { *this = other; }
String(String&&); String(String&& other) { *this = move(other); }
String(StringView); String(StringView other) { *this = other; }
~String(); ~String() { clear(); }
template<typename... Args> template<typename... Args>
static String formatted(const char* format, const Args&... args); static String formatted(const char* format, const Args&... args)
{
String result;
BAN::Formatter::print([&](char c){ MUST(result.push_back(c)); }, format, args...);
return result;
}
String& operator=(const String&); String& operator=(const String& other)
String& operator=(String&&); {
String& operator=(StringView); clear();
MUST(ensure_capacity(other.size()));
memcpy(data(), other.data(), other.size() + 1);
m_size = other.size();
return *this;
}
ErrorOr<void> push_back(char); String& operator=(String&& other)
ErrorOr<void> insert(char, size_type); {
ErrorOr<void> insert(StringView, size_type); clear();
ErrorOr<void> append(StringView);
void pop_back(); if (other.has_sso())
void remove(size_type); memcpy(data(), other.data(), other.size() + 1);
else
{
m_storage.general_storage = other.m_storage.general_storage;
m_has_sso = false;
}
m_size = other.m_size;
void clear(); other.m_size = 0;
other.m_storage.sso_storage = SSOStorage();
other.m_has_sso = true;
return *this;
}
String& operator=(StringView other)
{
clear();
MUST(ensure_capacity(other.size()));
memcpy(data(), other.data(), other.size());
m_size = other.size();
data()[m_size] = '\0';
return *this;
}
ErrorOr<void> push_back(char c)
{
TRY(ensure_capacity(m_size + 1));
data()[m_size] = c;
m_size++;
data()[m_size] = '\0';
return {};
}
ErrorOr<void> insert(char c, size_type index)
{
ASSERT(index <= m_size);
TRY(ensure_capacity(m_size + 1));
memmove(data() + index + 1, data() + index, m_size - index);
data()[index] = c;
m_size++;
data()[m_size] = '\0';
return {};
}
ErrorOr<void> insert(StringView str, size_type index)
{
ASSERT(index <= m_size);
TRY(ensure_capacity(m_size + str.size()));
memmove(data() + index + str.size(), data() + index, m_size - index);
memcpy(data() + index, str.data(), str.size());
m_size += str.size();
data()[m_size] = '\0';
return {};
}
ErrorOr<void> append(StringView str)
{
TRY(ensure_capacity(m_size + str.size()));
memcpy(data() + m_size, str.data(), str.size());
m_size += str.size();
data()[m_size] = '\0';
return {};
}
void pop_back()
{
ASSERT(m_size > 0);
m_size--;
data()[m_size] = '\0';
}
void remove(size_type index)
{
ASSERT(index < m_size);
memcpy(data() + index, data() + index + 1, m_size - index);
m_size--;
data()[m_size] = '\0';
}
void clear()
{
if (!has_sso())
{
deallocator(m_storage.general_storage.data);
m_storage.sso_storage = SSOStorage();
m_has_sso = true;
}
m_size = 0;
data()[m_size] = '\0';
}
const_iterator begin() const { return const_iterator(data()); } const_iterator begin() const { return const_iterator(data()); }
iterator begin() { return iterator(data()); } iterator begin() { return iterator(data()); }
@ -55,27 +153,151 @@ namespace BAN
char operator[](size_type index) const { ASSERT(index < m_size); return data()[index]; } char operator[](size_type index) const { ASSERT(index < m_size); return data()[index]; }
char& operator[](size_type index) { ASSERT(index < m_size); return data()[index]; } char& operator[](size_type index) { ASSERT(index < m_size); return data()[index]; }
bool operator==(const String&) const; bool operator==(const String& str) const
bool operator==(StringView) const; {
bool operator==(const char*) const; if (size() != str.size())
return false;
for (size_type i = 0; i < m_size; i++)
if (data()[i] != str.data()[i])
return false;
return true;
}
ErrorOr<void> resize(size_type, char = '\0'); bool operator==(StringView str) const
ErrorOr<void> reserve(size_type); {
ErrorOr<void> shrink_to_fit(); if (size() != str.size())
return false;
for (size_type i = 0; i < m_size; i++)
if (data()[i] != str.data()[i])
return false;
return true;
}
bool operator==(const char* cstr) const
{
for (size_type i = 0; i < m_size; i++)
if (data()[i] != cstr[i])
return false;
if (cstr[size()] != '\0')
return false;
return true;
}
ErrorOr<void> resize(size_type new_size, char init_c = '\0')
{
if (m_size == new_size)
return {};
// expanding
if (m_size < new_size)
{
TRY(ensure_capacity(new_size));
memset(data() + m_size, init_c, new_size - m_size);
m_size = new_size;
data()[m_size] = '\0';
return {};
}
m_size = new_size;
data()[m_size] = '\0';
return {};
}
ErrorOr<void> reserve(size_type new_size)
{
TRY(ensure_capacity(new_size));
return {};
}
ErrorOr<void> shrink_to_fit()
{
if (has_sso())
return {};
if (fits_in_sso())
{
char* data = m_storage.general_storage.data;
m_storage.sso_storage = SSOStorage();
m_has_sso = true;
memcpy(this->data(), data, m_size + 1);
deallocator(data);
return {};
}
GeneralStorage& storage = m_storage.general_storage;
if (storage.capacity == m_size)
return {};
char* new_data = (char*)allocator(m_size + 1);
if (new_data == nullptr)
return Error::from_errno(ENOMEM);
memcpy(new_data, storage.data, m_size);
deallocator(storage.data);
storage.capacity = m_size;
storage.data = new_data;
return {};
}
StringView sv() const { return StringView(data(), size()); } StringView sv() const { return StringView(data(), size()); }
bool empty() const { return m_size == 0; } bool empty() const { return m_size == 0; }
size_type size() const { return m_size; } size_type size() const { return m_size; }
size_type capacity() const;
char* data(); size_type capacity() const
const char* data() const; {
if (has_sso())
return sso_capacity;
return m_storage.general_storage.capacity;
}
char* data()
{
if (has_sso())
return m_storage.sso_storage.data;
return m_storage.general_storage.data;
}
const char* data() const
{
if (has_sso())
return m_storage.sso_storage.data;
return m_storage.general_storage.data;
}
private: private:
ErrorOr<void> ensure_capacity(size_type); ErrorOr<void> ensure_capacity(size_type new_size)
{
if (m_size >= new_size)
return {};
if (has_sso() && fits_in_sso(new_size))
return {};
bool has_sso() const; char* new_data = (char*)allocator(new_size + 1);
if (new_data == nullptr)
return Error::from_errno(ENOMEM);
if (m_size)
memcpy(new_data, data(), m_size + 1);
if (has_sso())
{
m_storage.general_storage = GeneralStorage();
m_has_sso = false;
}
else
deallocator(m_storage.general_storage.data);
auto& storage = m_storage.general_storage;
storage.capacity = new_size;
storage.data = new_data;
return {};
}
bool has_sso() const { return m_has_sso; }
bool fits_in_sso() const { return fits_in_sso(m_size); } bool fits_in_sso() const { return fits_in_sso(m_size); }
static bool fits_in_sso(size_type size) { return size < sso_capacity; } static bool fits_in_sso(size_type size) { return size < sso_capacity; }
@ -100,14 +322,6 @@ namespace BAN
size_type m_has_sso : 1 { true }; size_type m_has_sso : 1 { true };
}; };
template<typename... Args>
String String::formatted(const char* format, const Args&... args)
{
String result;
BAN::Formatter::print([&](char c){ MUST(result.push_back(c)); }, format, args...);
return result;
}
template<> template<>
struct hash<String> struct hash<String>
{ {

171
BAN/include/BAN/StringView.h
View File

@ -4,6 +4,7 @@
#include <BAN/ForwardList.h> #include <BAN/ForwardList.h>
#include <BAN/Iterators.h> #include <BAN/Iterators.h>
#include <BAN/Optional.h> #include <BAN/Optional.h>
#include <BAN/Vector.h>
namespace BAN namespace BAN
{ {
@ -15,37 +16,171 @@ namespace BAN
using const_iterator = ConstIteratorSimple<char, StringView>; using const_iterator = ConstIteratorSimple<char, StringView>;
public: public:
StringView(); StringView() {}
StringView(const String&); StringView(const String&);
StringView(const char*, size_type = -1); StringView(const char* string, size_type len = -1)
{
if (len == size_type(-1))
len = strlen(string);
m_data = string;
m_size = len;
}
const_iterator begin() const { return const_iterator(m_data); } const_iterator begin() const { return const_iterator(m_data); }
const_iterator end() const { return const_iterator(m_data + m_size); } const_iterator end() const { return const_iterator(m_data + m_size); }
char operator[](size_type) const; char operator[](size_type index) const
{
ASSERT(index < m_size);
return m_data[index];
}
bool operator==(const String&) const; bool operator==(StringView other) const
bool operator==(StringView) const; {
bool operator==(const char*) const; if (m_size != other.m_size)
return false;
return memcmp(m_data, other.m_data, m_size) == 0;
}
StringView substring(size_type, size_type = -1) const; bool operator==(const char* other) const
{
if (memcmp(m_data, other, m_size))
return false;
return other[m_size] == '\0';
}
ErrorOr<Vector<StringView>> split(char, bool = false) const; StringView substring(size_type index, size_type len = -1) const
ErrorOr<Vector<StringView>> split(bool(*comp)(char), bool = false) const; {
ASSERT(index <= m_size);
if (len == size_type(-1))
len = m_size - index;
ASSERT(len <= m_size - index); // weird order to avoid overflow
StringView result;
result.m_data = m_data + index;
result.m_size = len;
return result;
}
char back() const; ErrorOr<Vector<StringView>> split(char delim, bool allow_empties = false) const
char front() const; {
size_type count = 0;
{
size_type start = 0;
for (size_type i = 0; i < m_size; i++)
{
if (m_data[i] == delim)
{
if (allow_empties || start != i)
count++;
start = i + 1;
}
}
if (start != m_size)
count++;
}
BAN::Optional<size_type> find(char) const; Vector<StringView> result;
BAN::Optional<size_type> find(bool(*comp)(char)) const; TRY(result.reserve(count));
bool contains(char) const; size_type start = 0;
size_type count(char) const; for (size_type i = 0; i < m_size; i++)
{
if (m_data[i] == delim)
{
if (allow_empties || start != i)
TRY(result.push_back(this->substring(start, i - start)));
start = i + 1;
}
}
if (start < m_size || (start == m_size && allow_empties))
TRY(result.push_back(this->substring(start)));
return result;
}
bool empty() const; ErrorOr<Vector<StringView>> split(bool(*comp)(char), bool allow_empties = false) const
size_type size() const; {
size_type count = 0;
{
size_type start = 0;
for (size_type i = 0; i < m_size; i++)
{
if (comp(m_data[i]))
{
if (allow_empties || start != i)
count++;
start = i + 1;
}
}
if (start != m_size)
count++;
}
const char* data() const; Vector<StringView> result;
TRY(result.reserve(count));
size_type start = 0;
for (size_type i = 0; i < m_size; i++)
{
if (comp(m_data[i]))
{
if (allow_empties || start != i)
TRY(result.push_back(this->substring(start, i - start)));
start = i + 1;
}
}
if (start < m_size || (start == m_size && allow_empties))
TRY(result.push_back(this->substring(start)));
return result;
}
char back() const
{
ASSERT(m_size > 0);
return m_data[m_size - 1];
}
char front() const
{
ASSERT(m_size > 0);
return m_data[0];
}
BAN::Optional<size_type> find(char ch) const
{
for (size_type i = 0; i < m_size; i++)
if (m_data[i] == ch)
return i;
return {};
}
BAN::Optional<size_type> find(bool(*comp)(char)) const
{
for (size_type i = 0; i < m_size; i++)
if (comp(m_data[i]))
return i;
return {};
}
bool contains(char ch) const
{
for (size_type i = 0; i < m_size; i++)
if (m_data[i] == ch)
return true;
return false;
}
size_type count(char ch) const
{
size_type result = 0;
for (size_type i = 0; i < m_size; i++)
if (m_data[i] == ch)
result++;
return result;
}
bool empty() const { return m_size == 0; }
size_type size() const { return m_size; }
const char* data() const { return m_data; }
private: private:
const char* m_data = nullptr; const char* m_data = nullptr;

1
kernel/CMakeLists.txt
View File

@ -137,7 +137,6 @@ endif()
set(BAN_SOURCES set(BAN_SOURCES
../BAN/BAN/Assert.cpp ../BAN/BAN/Assert.cpp
../BAN/BAN/New.cpp ../BAN/BAN/New.cpp
../BAN/BAN/String.cpp
../BAN/BAN/StringView.cpp ../BAN/BAN/StringView.cpp
../BAN/BAN/Time.cpp ../BAN/BAN/Time.cpp
) )

6
kernel/include/kernel/Errors.h
View File

@ -1,11 +1,9 @@
#pragma once #pragma once
#include <BAN/StringView.h>
namespace Kernel namespace Kernel
{ {
enum class ErrorCode : uint32_t enum class ErrorCode
{ {
None, None,
ACPI_NoRootSDT, ACPI_NoRootSDT,
@ -31,6 +29,6 @@ namespace Kernel
Count Count
}; };
BAN::StringView error_string(ErrorCode); const char* error_string(ErrorCode);
} }

48
kernel/kernel/Errors.cpp
View File

@ -1,34 +1,38 @@
#include <BAN/Assert.h>
#include <kernel/Errors.h> #include <kernel/Errors.h>
#include <stdint.h>
#include <stddef.h>
namespace Kernel namespace Kernel
{ {
static BAN::StringView s_error_strings[] { static const char* s_error_strings[] {
"No Error"sv, "No Error",
"ACPI could not find root SDT header"sv, "ACPI could not find root SDT header",
"ACPI no such header"sv, "ACPI no such header",
"ACPI root invalid", "ACPI root invalid",
"Invalid ext2 filesystem"sv, "Invalid ext2 filesystem",
"Ext2 filesystem corrupted"sv, "Ext2 filesystem corrupted",
"Ext2 filesystem out of inodes"sv, "Ext2 filesystem out of inodes",
"Attempted to access outside of device boundaries"sv, "Attempted to access outside of device boundaries",
"Device has invalid GPT header"sv, "Device has invalid GPT header",
"Device does not support LBA addressing"sv, "Device does not support LBA addressing",
"Address mark not found"sv, "Address mark not found",
"Track zero not found"sv, "Track zero not found",
"Aborted command"sv, "Aborted command",
"Media change request"sv, "Media change request",
"ID not found"sv, "ID not found",
"Media changed"sv, "Media changed",
"Uncorrectable data error"sv, "Uncorrectable data error",
"Bad Block detected"sv, "Bad Block detected",
"Unsupported ata device"sv, "Unsupported ata device",
"Font file too small"sv, "Font file too small",
"Unsupported font format"sv, "Unsupported font format",
}; };
static_assert(sizeof(s_error_strings) / sizeof(*s_error_strings) == (size_t)ErrorCode::Count); static_assert(sizeof(s_error_strings) / sizeof(*s_error_strings) == (size_t)ErrorCode::Count);
BAN::StringView error_string(ErrorCode error) const char* error_string(ErrorCode error)
{ {
ASSERT((uint32_t)error < (uint32_t)ErrorCode::Count); ASSERT((uint32_t)error < (uint32_t)ErrorCode::Count);
return s_error_strings[(uint32_t)error]; return s_error_strings[(uint32_t)error];

5
userspace/aoc2023/day17/main.cpp
View File

@ -1,6 +1,7 @@
#include <BAN/HashSet.h>
#include <BAN/Vector.h>
#include <BAN/Hash.h> #include <BAN/Hash.h>
#include <BAN/HashSet.h>
#include <BAN/StringView.h>
#include <BAN/Vector.h>
#include <ctype.h> #include <ctype.h>
#include <inttypes.h> #include <inttypes.h>

3
userspace/aoc2023/day21/main.cpp
View File

@ -1,5 +1,6 @@
#include <BAN/Vector.h>
#include <BAN/HashSet.h> #include <BAN/HashSet.h>
#include <BAN/StringView.h>
#include <BAN/Vector.h>
#include <ctype.h> #include <ctype.h>
#include <inttypes.h> #include <inttypes.h>

1
userspace/aoc2023/day24/main.cpp
View File

@ -1,3 +1,4 @@
#include <BAN/StringView.h>
#include <BAN/Vector.h> #include <BAN/Vector.h>
#include <ctype.h> #include <ctype.h>

1
userspace/aoc2023/day5/main.cpp
View File

@ -1,4 +1,5 @@
#include <BAN/HashMap.h> #include <BAN/HashMap.h>
#include <BAN/StringView.h>
#include <BAN/Vector.h> #include <BAN/Vector.h>
#include <inttypes.h> #include <inttypes.h>

1
userspace/aoc2023/day6/main.cpp
View File

@ -1,3 +1,4 @@
#include <BAN/StringView.h>
#include <BAN/Vector.h> #include <BAN/Vector.h>
#include <ctype.h> #include <ctype.h>

1
userspace/dhcp-client/main.cpp
View File

@ -2,6 +2,7 @@
#include <BAN/Endianness.h> #include <BAN/Endianness.h>
#include <BAN/IPv4.h> #include <BAN/IPv4.h>
#include <BAN/MAC.h> #include <BAN/MAC.h>
#include <BAN/Optional.h>
#include <BAN/Vector.h> #include <BAN/Vector.h>
#include <arpa/inet.h> #include <arpa/inet.h>

3
userspace/image/Image.h
View File

@ -1,7 +1,8 @@
#pragma once #pragma once
#include <BAN/Vector.h> #include <BAN/StringView.h>
#include <BAN/UniqPtr.h> #include <BAN/UniqPtr.h>
#include <BAN/Vector.h>
class Image class Image
{ {