LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-20 13:28:13 +03:00
Code Issues Packages Projects Releases Wiki Activity

Everywhere: Use east const in more places

Browse Source 
These changes are compatible with clang-format 16 and will be mandatory
when we eventually bump clang-format version. So, since there are no
real downsides, let's commit them now.
This commit is contained in:
Dan Klishch 2024-04-18 15:32:56 -04:00 committed by Tim Flynn
parent 5ef6df79ed
commit 5ed7cd6e32
Notes: sideshowbarker 2024-07-16 23:38:54 +09:00 
Author: https://github.com/DanShaders
Commit: https://github.com/SerenityOS/serenity/commit/5ed7cd6e32
Pull-request: https://github.com/SerenityOS/serenity/pull/24014
175 changed files with 353 additions and 353 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
AK/CheckedFormatString.h
View File

@ -28,7 +28,7 @@ struct Array {
constexpr static size_t size() { return Size; }
constexpr T const& operator[](size_t index) const { return __data[index]; }
constexpr T& operator[](size_t index) { return __data[index]; }
using ConstIterator = SimpleIterator<const Array, T const>;
using ConstIterator = SimpleIterator<Array const, T const>;
using Iterator = SimpleIterator<Array, T>;
constexpr ConstIterator begin() const { return ConstIterator::begin(*this); }

2
AK/CircularQueue.h
View File

@ -80,7 +80,7 @@ public:
private:
friend class CircularQueue;
ConstIterator(CircularQueue const& queue, const size_t index)
ConstIterator(CircularQueue const& queue, size_t const index)
: m_queue(queue)
, m_index(index)
{

6
AK/Complex.h
View File

@ -105,7 +105,7 @@ public:
template<AK::Concepts::Arithmetic U>
constexpr Complex<T> operator*=(Complex<U> const& x)
{
const T real = m_real;
T const real = m_real;
m_real = real * x.real() - m_imag * x.imag();
m_imag = real * x.imag() + m_imag * x.real();
return *this;
@ -122,8 +122,8 @@ public:
template<AK::Concepts::Arithmetic U>
constexpr Complex<T> operator/=(Complex<U> const& x)
{
const T real = m_real;
const T divisor = x.real() * x.real() + x.imag() * x.imag();
T const real = m_real;
T const divisor = x.real() * x.real() + x.imag() * x.imag();
m_real = (real * x.real() + m_imag * x.imag()) / divisor;
m_imag = (m_imag * x.real() - x.real() * x.imag()) / divisor;
return *this;

2
AK/DoublyLinkedList.h
View File

@ -158,7 +158,7 @@ public:
Iterator begin() { return Iterator(m_head); }
Iterator end() { return Iterator::universal_end(); }
using ConstIterator = DoublyLinkedListIterator<const DoublyLinkedList, T const>;
using ConstIterator = DoublyLinkedListIterator<DoublyLinkedList const, T const>;
friend ConstIterator;
ConstIterator begin() const { return ConstIterator(m_head); }
ConstIterator end() const { return ConstIterator::universal_end(); }

6
AK/FloatingPoint.h
View File

@ -95,9 +95,9 @@ static_assert(AssertSize<FloatExtractor<f32>, sizeof(f32)>());
template<size_t S, size_t E, size_t M>
requires(S <= 1 && E >= 1 && M >= 1 && (S + E + M) <= 64) class FloatingPointBits final {
public:
static const size_t signbit = S;
static const size_t exponentbits = E;
static const size_t mantissabits = M;
static size_t const signbit = S;
static size_t const exponentbits = E;
static size_t const mantissabits = M;
template<typename T>
requires(IsIntegral<T> && IsUnsigned<T> && sizeof(T) <= 8) constexpr FloatingPointBits(T bits)

4
AK/HashTable.h
View File

@ -280,8 +280,8 @@ public:
}
using ConstIterator = Conditional<IsOrdered,
OrderedHashTableIterator<const HashTable, const T, BucketType const>,
HashTableIterator<const HashTable, const T, BucketType const>>;
OrderedHashTableIterator<HashTable const, T const, BucketType const>,
HashTableIterator<HashTable const, T const, BucketType const>>;
[[nodiscard]] ConstIterator begin() const
{

4
AK/Hex.cpp
View File

@ -35,7 +35,7 @@ ErrorOr<ByteBuffer> decode_hex(StringView input)
}
#ifdef KERNEL
ErrorOr<NonnullOwnPtr<Kernel::KString>> encode_hex(const ReadonlyBytes input)
ErrorOr<NonnullOwnPtr<Kernel::KString>> encode_hex(ReadonlyBytes const input)
{
StringBuilder output(input.size() * 2);
@ -45,7 +45,7 @@ ErrorOr<NonnullOwnPtr<Kernel::KString>> encode_hex(const ReadonlyBytes input)
return Kernel::KString::try_create(output.string_view());
}
#else
ByteString encode_hex(const ReadonlyBytes input)
ByteString encode_hex(ReadonlyBytes const input)
{
StringBuilder output(input.size() * 2);

4
AK/IPv4Address.h
View File

@ -41,7 +41,7 @@ public:
m_data = (d << 24) | (c << 16) | (b << 8) | a;
}
constexpr IPv4Address(const u8 data[4])
constexpr IPv4Address(u8 const data[4])
{
m_data = (u32(data[3]) << 24) | (u32(data[2]) << 16) | (u32(data[1]) << 8) | u32(data[0]);
}
@ -149,7 +149,7 @@ public:
}
private:
constexpr u32 octet(const SubnetClass subnet) const
constexpr u32 octet(SubnetClass const subnet) const
{
constexpr auto bits_per_byte = 8;
auto const bits_to_shift = bits_per_byte * int(subnet);

4
AK/Random.cpp
View File

@ -17,7 +17,7 @@ u32 get_random_uniform(u32 max_bounds)
// `arc4random() % max_bounds` would be insufficient. Here we compute the last number of the
// last "full group". Note that if max_bounds is a divisor of UINT32_MAX,
// then we end up with UINT32_MAX:
const u32 max_usable = UINT32_MAX - (static_cast<u64>(UINT32_MAX) + 1) % max_bounds;
u32 const max_usable = UINT32_MAX - (static_cast<u64>(UINT32_MAX) + 1) % max_bounds;
auto random_value = get_random<u32>();
for (int i = 0; i < 20 && random_value > max_usable; ++i) {
// By chance we picked a value from the incomplete group. Note that this group has size at
@ -34,7 +34,7 @@ u64 get_random_uniform_64(u64 max_bounds)
{
// Uses the same algorithm as `get_random_uniform`,
// by replacing u64 with u128 and u32 with u64.
const u64 max_usable = UINT64_MAX - static_cast<u64>((static_cast<u128>(UINT64_MAX) + 1) % max_bounds);
u64 const max_usable = UINT64_MAX - static_cast<u64>((static_cast<u128>(UINT64_MAX) + 1) % max_bounds);
auto random_value = get_random<u64>();
for (int i = 0; i < 20 && random_value > max_usable; ++i) {
random_value = get_random<u64>();

2
AK/RedBlackTree.h
View File

@ -505,7 +505,7 @@ public:
Iterator end() { return {}; }
Iterator begin_from(K key) { return Iterator(static_cast<Node*>(BaseTree::find(this->m_root, key))); }
using ConstIterator = RedBlackTreeIterator<const RedBlackTree, V const>;
using ConstIterator = RedBlackTreeIterator<RedBlackTree const, V const>;
friend ConstIterator;
ConstIterator begin() const { return ConstIterator(static_cast<Node*>(this->m_minimum)); }
ConstIterator end() const { return {}; }

2
AK/SinglyLinkedList.h
View File

@ -205,7 +205,7 @@ public:
Iterator begin() { return Iterator(m_head); }
Iterator end() { return {}; }
using ConstIterator = SinglyLinkedListIterator<const SinglyLinkedList, T const>;
using ConstIterator = SinglyLinkedListIterator<SinglyLinkedList const, T const>;
friend ConstIterator;
ConstIterator begin() const { return ConstIterator(m_head); }
ConstIterator end() const { return {}; }

12
AK/Trie.h
View File

@ -183,13 +183,13 @@ public:
TRY(state.try_empend(false, m_children.begin(), m_children.end()));
auto invoke = [&](auto& current_node) -> ErrorOr<IterationDecision> {
if constexpr (VoidFunction<Fn, const BaseType&>) {
callback(static_cast<const BaseType&>(current_node));
if constexpr (VoidFunction<Fn, BaseType const&>) {
callback(static_cast<BaseType const&>(current_node));
return IterationDecision::Continue;
} else if constexpr (IsSpecializationOf<decltype(callback(declval<const BaseType&>())), ErrorOr>) {
return callback(static_cast<const BaseType&>(current_node));
} else if constexpr (IteratorFunction<Fn, const BaseType&>) {
return callback(static_cast<const BaseType&>(current_node));
} else if constexpr (IsSpecializationOf<decltype(callback(declval<BaseType const&>())), ErrorOr>) {
return callback(static_cast<BaseType const&>(current_node));
} else if constexpr (IteratorFunction<Fn, BaseType const&>) {
return callback(static_cast<BaseType const&>(current_node));
} else {
static_assert(DependentFalse<Fn>, "Invalid iterator function type signature");
}

4
AK/Types.h
View File

@ -180,12 +180,12 @@ static_assert(explode_byte(0x80) == static_cast<FlatPtr>(0x8080808080808080ull))
static_assert(explode_byte(0x7f) == static_cast<FlatPtr>(0x7f7f7f7f7f7f7f7full));
static_assert(explode_byte(0) == 0);
constexpr size_t align_up_to(const size_t value, const size_t alignment)
constexpr size_t align_up_to(size_t const value, size_t const alignment)
{
return (value + (alignment - 1)) & ~(alignment - 1);
}
constexpr size_t align_down_to(const size_t value, const size_t alignment)
constexpr size_t align_down_to(size_t const value, size_t const alignment)
{
return value & ~(alignment - 1);
}

2
AK/UFixedBigInt.h
View File

@ -108,7 +108,7 @@ public:
}
template<UFixedInt T, size_t n>
requires((assumed_bit_size<T> * n) <= bit_size) constexpr UFixedBigInt(const T (&value)[n])
requires((assumed_bit_size<T> * n) <= bit_size) constexpr UFixedBigInt(T const (&value)[n])
{
size_t offset = 0;

2
AK/kmalloc.cpp
View File

@ -63,7 +63,7 @@ void operator delete[](void* ptr, size_t) noexcept
// This is usually provided by libstdc++ in most cases, and the kernel has its own definition in
// Kernel/Heap/kmalloc.cpp. If neither of those apply, the following should suffice to not fail during linking.
namespace AK_REPLACED_STD_NAMESPACE {
const nothrow_t nothrow;
nothrow_t const nothrow;
}
#endif

4
Kernel/API/TimePage.h
View File

@ -22,9 +22,9 @@ inline bool time_page_supports(clockid_t clock_id)
}
struct TimePage {
volatile u32 update1;
u32 volatile update1;
struct timespec clocks[CLOCK_ID_COUNT];
volatile u32 update2;
u32 volatile update2;
};
}

2
Kernel/API/kcov.h
View File

@ -8,5 +8,5 @@
#include <AK/Types.h>
typedef volatile u64 kcov_pc_t;
typedef u64 volatile kcov_pc_t;
#define KCOV_ENTRY_SIZE sizeof(kcov_pc_t)

2
Kernel/API/ttydefaultschars.h
View File

@ -18,7 +18,7 @@
extern "C" {
#endif
static const cc_t ttydefchars[NCCS] = {
static cc_t const ttydefchars[NCCS] = {
[VINTR] = CINTR,
[VQUIT] = CQUIT,
[VERASE] = CERASE,

2
Kernel/Arch/Processor.h
View File

@ -192,7 +192,7 @@ private:
// FIXME: On aarch64, once there is code in place to differentiate IRQs from synchronous exceptions (syscalls),
// this member should be incremented. Also this member shouldn't be a FlatPtr.
FlatPtr m_in_irq { 0 };
volatile u32 m_in_critical;
u32 volatile m_in_critical;
// NOTE: Since these variables are accessed with atomic magic on x86 (through GP with a single load instruction),
// they need to be FlatPtrs or everything becomes highly unsound and breaks. They are actually just booleans.
FlatPtr m_in_scheduler;

2
Kernel/Arch/SmapDisabler.h
View File

@ -16,7 +16,7 @@ public:
~SmapDisabler();
private:
const FlatPtr m_flags;
FlatPtr const m_flags;
};
}

2
Kernel/Arch/aarch64/RPi/Mailbox.cpp
View File

@ -76,7 +76,7 @@ static void wait_for_reply(MMIO& mmio)
bool Mailbox::send_queue(void* queue, u32 queue_size) const
{
// According to Raspberry Pi specs this is the only channel implemented.
const u32 channel = ARM_TO_VIDEOCORE_CHANNEL;
u32 const channel = ARM_TO_VIDEOCORE_CHANNEL;
auto message_header = reinterpret_cast<MessageHeader*>(queue);
message_header->set_queue_size(queue_size);

2
Kernel/Arch/aarch64/RPi/MiniUART.cpp
View File

@ -105,7 +105,7 @@ ErrorOr<size_t> MiniUART::write(Kernel::OpenFileDescription& description, u64, K
return EAGAIN;
return buffer.read_buffered<128>(size, [&](ReadonlyBytes bytes) {
for (const auto& byte : bytes)
for (auto const& byte : bytes)
put_char(byte);
return bytes.size();
});

8
Kernel/Arch/x86_64/InterruptManagement.h
View File

@ -34,10 +34,10 @@ public:
u16 flags() const { return m_flags; }
private:
const u8 m_bus;
const u8 m_source;
const u32 m_global_system_interrupt;
const u16 m_flags;
u8 const m_bus;
u8 const m_source;
u32 const m_global_system_interrupt;
u16 const m_flags;
};
class InterruptManagement {

18
Kernel/Arch/x86_64/Interrupts/IOAPIC.h
View File

@ -11,9 +11,9 @@
namespace Kernel {
struct [[gnu::packed]] ioapic_mmio_regs {
volatile u32 select;
u32 volatile select;
u32 reserved[3];
volatile u32 window;
u32 volatile window;
};
class PCIInterruptOverrideMetadata {
@ -28,13 +28,13 @@ public:
u16 ioapic_interrupt_pin() const { return m_ioapic_interrupt_pin; }
private:
const u8 m_bus_id;
const u8 m_polarity;
const u8 m_trigger_mode;
const u8 m_pci_interrupt_pin;
const u8 m_pci_device_number;
const u32 m_ioapic_id;
const u16 m_ioapic_interrupt_pin;
u8 const m_bus_id;
u8 const m_polarity;
u8 const m_trigger_mode;
u8 const m_pci_interrupt_pin;
u8 const m_pci_device_number;
u32 const m_ioapic_id;
u16 const m_ioapic_interrupt_pin;
};
class IOAPIC final : public IRQController {

6
Kernel/Arch/x86_64/Time/APICTimer.cpp
View File

@ -44,10 +44,10 @@ UNMAP_AFTER_INIT bool APICTimer::calibrate(HardwareTimerBase& calibration_source
size_t ticks_in_100ms { 0 };
Atomic<size_t, AK::memory_order_relaxed> calibration_ticks { 0 };
#ifdef APIC_TIMER_MEASURE_CPU_CLOCK
volatile u64 start_tsc { 0 }, end_tsc { 0 };
u64 volatile start_tsc { 0 }, end_tsc { 0 };
#endif
volatile u64 start_reference { 0 }, end_reference { 0 };
volatile u32 start_apic_count { 0 }, end_apic_count { 0 };
u64 volatile start_reference { 0 }, end_reference { 0 };
u32 volatile start_apic_count { 0 }, end_apic_count { 0 };
bool query_reference { false };
} state;

16
Kernel/Arch/x86_64/Time/HPET.cpp
View File

@ -46,26 +46,26 @@ enum class TimerConfiguration : u32 {
struct [[gnu::packed]] HPETRegister {
union {
volatile u64 full;
u64 volatile full;
struct {
volatile u32 low;
volatile u32 high;
u32 volatile low;
u32 volatile high;
};
};
};
struct [[gnu::packed]] TimerStructure {
volatile u32 capabilities;
volatile u32 interrupt_routing;
u32 volatile capabilities;
u32 volatile interrupt_routing;
HPETRegister comparator_value;
volatile u64 fsb_interrupt_route;
u64 volatile fsb_interrupt_route;
u64 reserved;
};
struct [[gnu::packed]] HPETCapabilityRegister {
// Note: We must do a 32 bit access to offsets 0x0, or 0x4 only, according to HPET spec.
volatile u32 attributes;
volatile u32 main_counter_tick_period;
u32 volatile attributes;
u32 volatile main_counter_tick_period;
u64 reserved;
};

6
Kernel/Bus/PCI/Definitions.h
View File

@ -337,9 +337,9 @@ public:
void write32(size_t offset, u32 value) const;
private:
const Address m_address;
const CapabilityID m_id;
const u8 m_ptr;
Address const m_address;
CapabilityID const m_id;
u8 const m_ptr;
};
AK_TYPEDEF_DISTINCT_ORDERED_ID(u8, ClassCode);

8
Kernel/Bus/USB/EHCI/Registers.h
View File

@ -202,21 +202,21 @@ struct OperationalRegisters {
// 2.3.4 FRINDEX - Frame Index Register
// Note: We use `volatile` to ensure 32 bit writes
// Note: Only up to 14 bits are actually used, and the last 3 bits must never be `000` or `111`
volatile u32 frame_index;
u32 volatile frame_index;
// 2.3.5 CTRLDSSEGMENT - Control Data Structure Segment Register
// Note: We use `volatile` to ensure 32 bit writes
// Note: Upper 32 bits of periodic-frame- and asynchronous-list pointers
volatile u32 segment_selector;
u32 volatile segment_selector;
// 2.3.6 PERIODICLISTBASE - Periodic Frame List Base Address Register
// Note: We use `volatile` to ensure 32 bit writes
// Note: Page-aligned addresses only
volatile u32 frame_list_base_address;
u32 volatile frame_list_base_address;
// 2.3.7 ASYNCLISTADDR - Current Asynchronous List Address Register
// Note: We use `volatile` to ensure 32 bit writes
// Note: 32 byte (cache-line) aligned addresses only
volatile u32 next_asynchronous_list_address;
u32 volatile next_asynchronous_list_address;
u32 _padding[9];

4
Kernel/Bus/USB/UHCI/UHCIDescriptorTypes.h
View File

@ -241,7 +241,7 @@ struct alignas(16) TransferDescriptor final {
private:
u32 m_link_ptr; // Points to another Queue Head or Transfer Descriptor
volatile u32 m_control_status; // Control and status field
u32 volatile m_control_status; // Control and status field
u32 m_token; // Contains all information required to fill in a USB Start Token
u32 m_buffer_ptr; // Points to a data buffer for this transaction (i.e what we want to send or recv)
@ -367,7 +367,7 @@ struct alignas(16) QueueHead {
private:
u32 m_link_ptr { 0 }; // Pointer to the next horizontal object that the controller will execute after this one
volatile u32 m_element_link_ptr { 0 }; // Pointer to the first data object in the queue (can be modified by hw)
u32 volatile m_element_link_ptr { 0 }; // Pointer to the first data object in the queue (can be modified by hw)
// This structure pointer will be ignored by the controller, but we can use it for configuration and bookkeeping
QueueHeadBookkeeping* m_bookkeeping { nullptr };

4
Kernel/Bus/VirtIO/Queue.h
View File

@ -87,8 +87,8 @@ private:
QueueDeviceItem rings[];
};
const u16 m_queue_size;
const u16 m_notify_offset;
u16 const m_queue_size;
u16 const m_notify_offset;
u16 m_free_buffers;
u16 m_free_head { 0 };
u16 m_used_tail { 0 };

2
Kernel/Devices/Audio/Channel.h
View File

@ -34,6 +34,6 @@ private:
virtual StringView class_name() const override { return "AudioChannel"sv; }
LockWeakPtr<AudioController> m_controller;
const size_t m_channel_index;
size_t const m_channel_index;
};
}

8
Kernel/Devices/BlockDevice.h
View File

@ -85,11 +85,11 @@ public:
private:
BlockDevice& m_block_device;
const RequestType m_request_type;
const u64 m_block_index;
const u32 m_block_count;
RequestType const m_request_type;
u64 const m_block_index;
u32 const m_block_count;
UserOrKernelBuffer m_buffer;
const size_t m_buffer_size;
size_t const m_buffer_size;
};
}

6
Kernel/Devices/GPU/Intel/DisplayConnectorGroup.h
View File

@ -86,11 +86,11 @@ private:
Array<OwnPtr<IntelDisplayTranscoder>, 5> m_transcoders;
Array<OwnPtr<IntelDisplayPlane>, 3> m_planes;
const MMIORegion m_mmio_first_region;
const MMIORegion m_mmio_second_region;
MMIORegion const m_mmio_first_region;
MMIORegion const m_mmio_second_region;
MMIORegion const& m_assigned_mmio_registers_region;
const IntelGraphics::Generation m_generation;
IntelGraphics::Generation const m_generation;
NonnullOwnPtr<Memory::Region> m_registers_region;
NonnullOwnPtr<GMBusConnector> m_gmbus_connector;
};

2
Kernel/Devices/GPU/Intel/Plane/G33DisplayPlane.h
View File

@ -21,6 +21,6 @@ public:
virtual ErrorOr<void> enable(Badge<IntelDisplayConnectorGroup>) override;
private:
explicit IntelG33DisplayPlane(Memory::TypedMapping<volatile IntelDisplayPlane::PlaneRegisters> plane_registers_mapping);
explicit IntelG33DisplayPlane(Memory::TypedMapping<IntelDisplayPlane::PlaneRegisters volatile> plane_registers_mapping);
};
}

2
Kernel/Devices/GPU/VirtIO/GraphicsAdapter.cpp
View File

@ -305,7 +305,7 @@ ErrorOr<void> VirtIOGraphicsAdapter::ensure_backing_storage(Graphics::VirtIOGPU:
auto writer = create_scratchspace_writer();
auto& request = writer.append_structure<Graphics::VirtIOGPU::Protocol::ResourceAttachBacking>();
const size_t header_block_size = sizeof(request) + num_mem_regions * sizeof(Graphics::VirtIOGPU::Protocol::MemoryEntry);
size_t const header_block_size = sizeof(request) + num_mem_regions * sizeof(Graphics::VirtIOGPU::Protocol::MemoryEntry);
populate_virtio_gpu_request_header(request.header, Graphics::VirtIOGPU::Protocol::CommandType::VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING, 0);
request.resource_id = resource_id.value();

2
Kernel/Devices/Generic/ConsoleDevice.cpp
View File

@ -50,7 +50,7 @@ ErrorOr<size_t> ConsoleDevice::write(OpenFileDescription&, u64, Kernel::UserOrKe
return 0;
return data.read_buffered<256>(size, [&](ReadonlyBytes readonly_bytes) {
for (const auto& byte : readonly_bytes)
for (auto const& byte : readonly_bytes)
put_char(byte);
return readonly_bytes.size();
});

2
Kernel/Devices/SerialDevice.cpp
View File

@ -57,7 +57,7 @@ ErrorOr<size_t> SerialDevice::write(OpenFileDescription& description, u64, UserO
return EAGAIN;
return buffer.read_buffered<128>(size, [&](ReadonlyBytes bytes) {
for (const auto& byte : bytes)
for (auto const& byte : bytes)
put_char(byte);
return bytes.size();
});

2
Kernel/Devices/Storage/ATA/AHCI/Definitions.h
View File

@ -197,7 +197,7 @@ public:
private:
u32 volatile& m_bitfield;
const u32 m_bit_mask;
u32 const m_bit_mask;
};
enum Limits : u16 {

4
Kernel/Devices/Storage/ATA/ATADevice.h
View File

@ -39,8 +39,8 @@ protected:
ATADevice(ATAController const&, Address, u16, u16, u64);
LockWeakPtr<ATAController> m_controller;
const Address m_ata_address;
const u16 m_capabilities;
Address const m_ata_address;
u16 const m_capabilities;
};
}

2
Kernel/Devices/Storage/ATA/ATAPort.h
View File

@ -148,7 +148,7 @@ protected:
RefPtr<Memory::PhysicalPage> m_prdt_page;
RefPtr<Memory::PhysicalPage> m_dma_buffer_page;
const u8 m_port_index;
u8 const m_port_index;
Vector<NonnullLockRefPtr<ATADevice>> m_ata_devices;
NonnullOwnPtr<KBuffer> m_ata_identify_data_buffer;
NonnullLockRefPtr<ATAController> m_parent_ata_controller;

10
Kernel/Devices/Storage/SD/SDHostController.cpp
View File

@ -157,7 +157,7 @@ ErrorOr<NonnullLockRefPtr<SDMemoryCard>> SDHostController::try_initialize_insert
// 2. Send CMD8 (SEND_IF_COND) to the card
// SD interface condition: 7:0 = check pattern, 11:8 = supply voltage
// 0x1aa: check pattern = 10101010, supply voltage = 1 => 2.7-3.6V
const u32 voltage_window = 0x1aa;
u32 const voltage_window = 0x1aa;
TRY(issue_command(SD::Commands::send_if_cond, voltage_window));
auto interface_condition_response = wait_for_response();
@ -456,14 +456,14 @@ ErrorOr<void> SDHostController::sd_clock_supply(u32 frequency)
VERIFY((m_registers->host_configuration_1 & sd_clock_enable) == 0);
// 1. Find out the divisor to determine the SD Clock Frequency
const u32 sd_clock_frequency = TRY(retrieve_sd_clock_frequency());
u32 const sd_clock_frequency = TRY(retrieve_sd_clock_frequency());
u32 divisor = TRY(calculate_sd_clock_divisor(sd_clock_frequency, frequency));
// 2. Set Internal Clock Enable and SDCLK Frequency Select in the Clock Control register
const u32 eight_lower_bits_of_sdclk_frequency_select = (divisor & 0xff) << 8;
u32 const eight_lower_bits_of_sdclk_frequency_select = (divisor & 0xff) << 8;
u32 sdclk_frequency_select = eight_lower_bits_of_sdclk_frequency_select;
if (host_version() == SD::HostVersion::Version3) {
const u32 two_upper_bits_of_sdclk_frequency_select = (divisor >> 8 & 0x3) << 6;
u32 const two_upper_bits_of_sdclk_frequency_select = (divisor >> 8 & 0x3) << 6;
sdclk_frequency_select |= two_upper_bits_of_sdclk_frequency_select;
}
m_registers->host_configuration_1 = (m_registers->host_configuration_1 & ~sd_clock_divisor_mask) | internal_clock_enable | sdclk_frequency_select;
@ -958,7 +958,7 @@ ErrorOr<u32> SDHostController::retrieve_sd_clock_frequency()
// If these bits are all 0, the Host System has to get information via another method
TODO();
}
const i64 one_mhz = 1'000'000;
i64 const one_mhz = 1'000'000;
return { m_registers->capabilities.base_clock_frequency * one_mhz };
}

2
Kernel/Devices/TTY/SlavePTY.cpp
View File

@ -67,7 +67,7 @@ void SlavePTY::echo(u8 ch)
void SlavePTY::on_master_write(UserOrKernelBuffer const& buffer, size_t size)
{
auto result = buffer.read_buffered<128>(size, [&](ReadonlyBytes data) {
for (const auto& byte : data)
for (auto const& byte : data)
emit(byte, false);
return data.size();
});

2
Kernel/Devices/TTY/TTY.cpp
View File

@ -89,7 +89,7 @@ ErrorOr<size_t> TTY::write(OpenFileDescription&, u64, UserOrKernelBuffer const&
return buffer.read_buffered<num_chars>(size, [&](ReadonlyBytes bytes) -> ErrorOr<size_t> {
u8 modified_data[num_chars * 2];
size_t modified_data_size = 0;
for (const auto& byte : bytes) {
for (auto const& byte : bytes) {
process_output(byte, [&modified_data, &modified_data_size](u8 out_ch) {
modified_data[modified_data_size++] = out_ch;
});

2
Kernel/Devices/TTY/VirtualConsole.cpp
View File

@ -285,7 +285,7 @@ ErrorOr<size_t> VirtualConsole::on_tty_write(UserOrKernelBuffer const& data, siz
{
SpinlockLocker global_lock(ConsoleManagement::the().tty_write_lock());
auto result = data.read_buffered<512>(size, [&](ReadonlyBytes buffer) {
for (const auto& byte : buffer)
for (auto const& byte : buffer)
m_console_impl.on_input(byte);
return buffer.size();
});

2
Kernel/FileSystem/MountFile.cpp
View File

@ -54,7 +54,7 @@ ErrorOr<void> MountFile::ioctl(OpenFileDescription&, unsigned request, Userspace
if ((mount_specific_data.value_type == MountSpecificFlag::ValueType::SignedInteger || mount_specific_data.value_type == MountSpecificFlag::ValueType::UnsignedInteger) && mount_specific_data.value_length != 8)
return EDOM;
Syscall::StringArgument user_key_string { reinterpret_cast<const char*>(mount_specific_data.key_string_addr), static_cast<size_t>(mount_specific_data.key_string_length) };
Syscall::StringArgument user_key_string { reinterpret_cast<char const*>(mount_specific_data.key_string_addr), static_cast<size_t>(mount_specific_data.key_string_length) };
auto key_string = TRY(Process::get_syscall_name_string_fixed_buffer<MOUNT_SPECIFIC_FLAG_KEY_STRING_MAX_LENGTH>(user_key_string));
if (mount_specific_data.value_type != MountSpecificFlag::ValueType::Boolean && mount_specific_data.value_length == 0)

2
Kernel/FileSystem/Plan9FS/FileSystem.h
View File

@ -69,7 +69,7 @@ private:
struct ReceiveCompletion final : public AtomicRefCounted<ReceiveCompletion> {
mutable Spinlock<LockRank::None> lock {};
bool completed { false };
const u16 tag;
u16 const tag;
OwnPtr<Plan9FSMessage> message;
ErrorOr<void> result;

4
Kernel/FileSystem/SysFS/Subsystems/Kernel/DiskUsage.cpp
View File

@ -45,13 +45,13 @@ ErrorOr<void> SysFSDiskUsage::try_generate(KBufferBuilder& builder)
TRY(fs_object.add("source"sv, "unknown"));
} else {
if (fs.is_file_backed()) {
auto& file = static_cast<const FileBackedFileSystem&>(fs).file();
auto& file = static_cast<FileBackedFileSystem const&>(fs).file();
if (file.is_loop_device()) {
auto& device = static_cast<LoopDevice const&>(file);
auto path = TRY(device.custody().try_serialize_absolute_path());
TRY(fs_object.add("source"sv, path->view()));
} else {
auto pseudo_path = TRY(static_cast<const FileBackedFileSystem&>(fs).file_description().pseudo_path());
auto pseudo_path = TRY(static_cast<FileBackedFileSystem const&>(fs).file_description().pseudo_path());
TRY(fs_object.add("source"sv, pseudo_path->view()));
}
} else {

2
Kernel/FileSystem/SysFS/Subsystems/Kernel/Processes.cpp
View File

@ -114,7 +114,7 @@ ErrorOr<void> SysFSOverallProcesses::try_generate(KBufferBuilder& builder)
TRY(process_object.add("dumpable"sv, process.is_dumpable()));
TRY(process_object.add("kernel"sv, process.is_kernel_process()));
auto thread_array = TRY(process_object.add_array("threads"sv));
TRY(process.try_for_each_thread([&](const Thread& thread) -> ErrorOr<void> {
TRY(process.try_for_each_thread([&](Thread const& thread) -> ErrorOr<void> {
SpinlockLocker locker(thread.get_lock());
auto thread_object = TRY(thread_array.add_object());
#if LOCK_DEBUG

2
Kernel/Heap/kmalloc.cpp
View File

@ -33,7 +33,7 @@ static constexpr size_t KMALLOC_DEFAULT_ALIGNMENT = 16;
__attribute__((section(".heap"))) static u8 initial_kmalloc_memory[INITIAL_KMALLOC_MEMORY_SIZE];
namespace std {
const nothrow_t nothrow;
nothrow_t const nothrow;
}
// FIXME: Figure out whether this can be MemoryManager.

2
Kernel/Heap/kmalloc.h
View File

@ -38,7 +38,7 @@ struct nothrow_t {
explicit nothrow_t() = default;
};
extern const nothrow_t nothrow;
extern nothrow_t const nothrow;
enum class align_val_t : size_t {};
};

2
Kernel/Library/StdLib.cpp
View File

@ -213,7 +213,7 @@ ErrorOr<void> memset_user(void* dest_ptr, int c, size_t n)
// See https://bugs.llvm.org/show_bug.cgi?id=39634
FlatPtr missing_got_workaround()
{
extern volatile FlatPtr _GLOBAL_OFFSET_TABLE_;
extern FlatPtr volatile _GLOBAL_OFFSET_TABLE_;
return _GLOBAL_OFFSET_TABLE_;
}
#endif

2
Kernel/Net/IPv4Socket.cpp
View File

@ -624,7 +624,7 @@ ErrorOr<void> IPv4Socket::ioctl(OpenFileDescription&, unsigned request, Userspac
rtentry route;
TRY(copy_from_user(&route, user_route));
Userspace<const char*> user_rt_dev((FlatPtr)route.rt_dev);
Userspace<char const*> user_rt_dev((FlatPtr)route.rt_dev);
auto ifname = TRY(Process::get_syscall_name_string_fixed_buffer<IFNAMSIZ>(user_rt_dev));
auto adapter = NetworkingManagement::the().lookup_by_name(ifname.representable_view());
if (!adapter)

26
Kernel/Net/Intel/E1000NetworkAdapter.h
View File

@ -51,22 +51,22 @@ protected:
virtual StringView class_name() const override { return "E1000NetworkAdapter"sv; }
struct [[gnu::packed]] e1000_rx_desc {
volatile uint64_t addr { 0 };
volatile uint16_t length { 0 };
volatile uint16_t checksum { 0 };
volatile uint8_t status { 0 };
volatile uint8_t errors { 0 };
volatile uint16_t special { 0 };
uint64_t volatile addr { 0 };
uint16_t volatile length { 0 };
uint16_t volatile checksum { 0 };
uint8_t volatile status { 0 };
uint8_t volatile errors { 0 };
uint16_t volatile special { 0 };
};
struct [[gnu::packed]] e1000_tx_desc {
volatile uint64_t addr { 0 };
volatile uint16_t length { 0 };
volatile uint8_t cso { 0 };
volatile uint8_t cmd { 0 };
volatile uint8_t status { 0 };
volatile uint8_t css { 0 };
volatile uint16_t special { 0 };
uint64_t volatile addr { 0 };
uint16_t volatile length { 0 };
uint8_t volatile cso { 0 };
uint8_t volatile cmd { 0 };
uint8_t volatile status { 0 };
uint8_t volatile css { 0 };
uint16_t volatile special { 0 };
};
virtual void detect_eeprom();

6
Kernel/Net/NetworkTask.cpp
View File

@ -340,9 +340,9 @@ void send_tcp_rst(IPv4Packet const& ipv4_packet, TCPPacket const& tcp_packet, Re
auto ipv4_payload_offset = routing_decision.adapter->ipv4_payload_offset();
const size_t options_size = 0;
const size_t tcp_header_size = sizeof(TCPPacket) + options_size;
const size_t buffer_size = ipv4_payload_offset + tcp_header_size;
size_t const options_size = 0;
size_t const tcp_header_size = sizeof(TCPPacket) + options_size;
size_t const buffer_size = ipv4_payload_offset + tcp_header_size;
auto packet = routing_decision.adapter->acquire_packet_buffer(buffer_size);
if (!packet)

24
Kernel/Net/Realtek/RTL8168NetworkAdapter.h
View File

@ -50,12 +50,12 @@ private:
bool determine_supported_version() const;
struct [[gnu::packed]] TXDescriptor {
volatile u16 frame_length; // top 2 bits are reserved
volatile u16 flags;
volatile u16 vlan_tag;
volatile u16 vlan_flags;
volatile u32 buffer_address_low;
volatile u32 buffer_address_high;
u16 volatile frame_length; // top 2 bits are reserved
u16 volatile flags;
u16 volatile vlan_tag;
u16 volatile vlan_flags;
u32 volatile buffer_address_low;
u32 volatile buffer_address_high;
// flags bit field
static constexpr u16 Ownership = 0x8000u;
@ -68,12 +68,12 @@ private:
static_assert(AssertSize<TXDescriptor, 16u>());
struct [[gnu::packed]] RXDescriptor {
volatile u16 buffer_size; // top 2 bits are reserved
volatile u16 flags;
volatile u16 vlan_tag;
volatile u16 vlan_flags;
volatile u32 buffer_address_low;
volatile u32 buffer_address_high;
u16 volatile buffer_size; // top 2 bits are reserved
u16 volatile flags;
u16 volatile vlan_tag;
u16 volatile vlan_flags;
u32 volatile buffer_address_low;
u32 volatile buffer_address_high;
// flags bit field
static constexpr u16 Ownership = 0x8000u;

8
Kernel/Net/Routing.h
View File

@ -34,10 +34,10 @@ struct Route final : public AtomicRefCounted<Route> {
return destination == other.destination && (gateway == other.gateway || other.gateway.is_zero()) && netmask == other.netmask && flags == other.flags && adapter.ptr() == other.adapter.ptr();
}
const IPv4Address destination;
const IPv4Address gateway;
const IPv4Address netmask;
const u16 flags;
IPv4Address const destination;
IPv4Address const gateway;
IPv4Address const netmask;
u16 const flags;
NonnullRefPtr<NetworkAdapter> const adapter;
IntrusiveListNode<Route, RefPtr<Route>> route_list_node {};

2
Kernel/Net/TCPSocket.cpp
View File

@ -733,7 +733,7 @@ void TCPSocket::retransmit_packets()
packet.tx_counter++;
if constexpr (TCP_SOCKET_DEBUG) {
auto& tcp_packet = *(const TCPPacket*)(packet.buffer->buffer->data() + packet.ipv4_payload_offset);
auto& tcp_packet = *(TCPPacket const*)(packet.buffer->buffer->data() + packet.ipv4_payload_offset);
dbgln("Sending TCP packet from {}:{} to {}:{} with ({}{}{}{}) seq_no={}, ack_no={}, tx_counter={}",
local_address(), local_port(),
peer_address(), peer_port(),

2
Kernel/Net/UDPSocket.cpp
View File

@ -91,7 +91,7 @@ ErrorOr<size_t> UDPSocket::protocol_send(UserOrKernelBuffer const& data, size_t
return set_so_error(EHOSTUNREACH);
auto ipv4_payload_offset = routing_decision.adapter->ipv4_payload_offset();
data_length = min(data_length, routing_decision.adapter->mtu() - ipv4_payload_offset - sizeof(UDPPacket));
const size_t udp_buffer_size = sizeof(UDPPacket) + data_length;
size_t const udp_buffer_size = sizeof(UDPPacket) + data_length;
auto packet = routing_decision.adapter->acquire_packet_buffer(ipv4_payload_offset + udp_buffer_size);
if (!packet)
return set_so_error(ENOMEM);

4
Kernel/Prekernel/UBSanitizer.cpp
View File

@ -130,8 +130,8 @@ void __ubsan_handle_implicit_conversion(ImplicitConversionData const& data, Valu
print_location(data.location);
}
void __ubsan_handle_invalid_builtin(const InvalidBuiltinData) __attribute__((used));
void __ubsan_handle_invalid_builtin(const InvalidBuiltinData data)
void __ubsan_handle_invalid_builtin(InvalidBuiltinData const) __attribute__((used));
void __ubsan_handle_invalid_builtin(InvalidBuiltinData const data)
{
print_location(data.location);
}

4
Kernel/Security/UBSanitizer.cpp
View File

@ -188,8 +188,8 @@ void __ubsan_handle_implicit_conversion(ImplicitConversionData const& data, Valu
print_location(data.location);
}
void __ubsan_handle_invalid_builtin(const InvalidBuiltinData) __attribute__((used));
void __ubsan_handle_invalid_builtin(const InvalidBuiltinData data)
void __ubsan_handle_invalid_builtin(InvalidBuiltinData const) __attribute__((used));
void __ubsan_handle_invalid_builtin(InvalidBuiltinData const data)
{
critical_dmesgln("KUBSAN: passing invalid argument");
print_location(data.location);

2
Kernel/Syscalls/SyscallHandler.cpp
View File

@ -31,7 +31,7 @@ struct HandlerMetadata {
};
#define __ENUMERATE_SYSCALL(sys_call, needs_lock) { bit_cast<Handler>(&Process::sys$##sys_call), needs_lock },
static const HandlerMetadata s_syscall_table[] = {
static HandlerMetadata const s_syscall_table[] = {
ENUMERATE_SYSCALLS(__ENUMERATE_SYSCALL)
};
#undef __ENUMERATE_SYSCALL

2
Kernel/Tasks/Thread.h
View File

@ -526,7 +526,7 @@ public:
private:
NonnullRefPtr<OpenFileDescription> m_blocked_description;
const BlockFlags m_flags;
BlockFlags const m_flags;
BlockFlags& m_unblocked_flags;
bool m_did_unblock { false };
};

12
Userland/Applications/3DFileViewer/Mesh.cpp
View File

@ -13,7 +13,7 @@
#include "Mesh.h"
const Color colors[] {
Color const colors[] {
Color::Red,
Color::Green,
Color::Blue,
@ -36,17 +36,17 @@ void Mesh::draw(float uv_scale)
for (u32 i = 0; i < m_triangle_list.size(); i++) {
auto const& triangle = m_triangle_list[i];
const FloatVector3 vertex_a(
FloatVector3 const vertex_a(
m_vertex_list.at(triangle.a).x,
m_vertex_list.at(triangle.a).y,
m_vertex_list.at(triangle.a).z);
const FloatVector3 vertex_b(
FloatVector3 const vertex_b(
m_vertex_list.at(triangle.b).x,
m_vertex_list.at(triangle.b).y,
m_vertex_list.at(triangle.b).z);
const FloatVector3 vertex_c(
FloatVector3 const vertex_c(
m_vertex_list.at(triangle.c).x,
m_vertex_list.at(triangle.c).y,
m_vertex_list.at(triangle.c).z);
@ -70,8 +70,8 @@ void Mesh::draw(float uv_scale)
} else {
// Compute the triangle normal
const FloatVector3 vec_ab = vertex_b - vertex_a;
const FloatVector3 vec_ac = vertex_c - vertex_a;
FloatVector3 const vec_ab = vertex_b - vertex_a;
FloatVector3 const vec_ac = vertex_c - vertex_a;
normal_a = vec_ab.cross(vec_ac).normalized();
normal_b = normal_a;
normal_c = normal_a;

2
Userland/Applications/Calendar/CalendarWidget.cpp
View File

@ -299,7 +299,7 @@ ErrorOr<NonnullRefPtr<GUI::Action>> CalendarWidget::create_open_settings_action(
void CalendarWidget::create_on_tile_doubleclick()
{
m_event_calendar->on_tile_doubleclick = [&] {
for (const auto& event : m_event_calendar->event_manager().events()) {
for (auto const& event : m_event_calendar->event_manager().events()) {
auto start = event.start;
auto selected_date = m_event_calendar->selected_date();

8
Userland/Applications/Debugger/main.cpp
View File

@ -248,14 +248,14 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
}
VERIFY(optional_regs.has_value());
const PtraceRegisters& regs = optional_regs.value();
PtraceRegisters const& regs = optional_regs.value();
#if ARCH(X86_64)
const FlatPtr ip = regs.rip;
FlatPtr const ip = regs.rip;
#elif ARCH(AARCH64)
const FlatPtr ip = 0; // FIXME
FlatPtr const ip = 0; // FIXME
TODO_AARCH64();
#elif ARCH(RISCV64)
const FlatPtr ip = 0; // FIXME
FlatPtr const ip = 0; // FIXME
TODO_RISCV64();
#else
# error Unknown architecture

6
Userland/Applications/KeyboardMapper/KeyboardMapperWidget.cpp
View File

@ -97,7 +97,7 @@ void KeyboardMapperWidget::create_frame()
bottom_widget.add_spacer();
}
void KeyboardMapperWidget::add_map_radio_button(const StringView map_name, String button_text)
void KeyboardMapperWidget::add_map_radio_button(StringView const map_name, String button_text)
{
auto& map_radio_button = m_map_group->add<GUI::RadioButton>(button_text);
map_radio_button.set_name(map_name);
@ -106,7 +106,7 @@ void KeyboardMapperWidget::add_map_radio_button(const StringView map_name, Strin
};
}
u32* KeyboardMapperWidget::map_from_name(const StringView map_name)
u32* KeyboardMapperWidget::map_from_name(StringView const map_name)
{
u32* map;
if (map_name == "map"sv) {
@ -234,7 +234,7 @@ void KeyboardMapperWidget::keyup_event(GUI::KeyEvent& event)
}
}
void KeyboardMapperWidget::set_current_map(const ByteString current_map)
void KeyboardMapperWidget::set_current_map(ByteString const current_map)
{
m_current_map_name = current_map;
u32* map = map_from_name(m_current_map_name);

6
Userland/Applications/KeyboardMapper/KeyboardMapperWidget.h
View File

@ -31,7 +31,7 @@ protected:
virtual void keydown_event(GUI::KeyEvent&) override;
virtual void keyup_event(GUI::KeyEvent&) override;
void set_current_map(const ByteString);
void set_current_map(ByteString const);
void update_window_title();
private:
@ -39,8 +39,8 @@ private:
Vector<KeyButton*> m_keys;
RefPtr<GUI::Widget> m_map_group;
void add_map_radio_button(const StringView map_name, String button_text);
u32* map_from_name(const StringView map_name);
void add_map_radio_button(StringView const map_name, String button_text);
u32* map_from_name(StringView const map_name);
void update_modifier_radio_buttons(GUI::KeyEvent&);
ByteString m_filename;

2
Userland/Applications/Mail/MailWidget.cpp
View File

@ -475,7 +475,7 @@ void MailWidget::selected_email_to_load(GUI::ModelIndex const& index)
auto& body_data = fetch_response_data.body_data();
auto body_text_part_iterator = body_data.find_if([](Tuple<IMAP::FetchCommand::DataItem, ByteString>& data) {
const auto data_item = data.get<0>();
auto const data_item = data.get<0>();
return data_item.section.has_value() && data_item.section->type == IMAP::FetchCommand::DataItem::SectionType::Parts;
});
VERIFY(body_text_part_iterator != body_data.end());

8
Userland/Applications/Piano/Music.h
View File

@ -51,10 +51,10 @@ constexpr KeyColor key_pattern[] = {
White,
};
const Color note_pressed_color(64, 64, 255);
const Color column_playing_color(128, 128, 255);
Color const note_pressed_color(64, 64, 255);
Color const column_playing_color(128, 128, 255);
const Color left_wave_colors[] = {
Color const left_wave_colors[] = {
// Sine
{
255,
@ -96,7 +96,7 @@ const Color left_wave_colors[] = {
// HACK: make the display code shut up for now
constexpr int RecordedSample = 5;
const Color right_wave_colors[] = {
Color const right_wave_colors[] = {
// Sine
{
255,

4
Userland/Applications/Piano/RollWidget.cpp
View File

@ -237,8 +237,8 @@ void RollWidget::mousemove_event(GUI::MouseEvent& event)
int const x_start = get_note_for_x(m_mousedown_event.value().x());
int const x_end = get_note_for_x(event.x());
const u32 on_sample = round(roll_length * (static_cast<double>(min(x_start, x_end)) / m_num_notes));
const u32 off_sample = round(roll_length * (static_cast<double>(max(x_start, x_end) + 1) / m_num_notes)) - 1;
u32 const on_sample = round(roll_length * (static_cast<double>(min(x_start, x_end)) / m_num_notes));
u32 const off_sample = round(roll_length * (static_cast<double>(max(x_start, x_end) + 1) / m_num_notes)) - 1;
auto const note = RollNote { on_sample, off_sample, get_pitch_for_y(m_mousedown_event.value().y()), 127 };
m_track_manager.current_track()->set_note(note);

12
Userland/Applications/PixelPaint/ImageEditor.cpp
View File

@ -248,8 +248,8 @@ void ImageEditor::paint_event(GUI::PaintEvent& event)
}
// Mouse position indicator
const Gfx::IntPoint indicator_x({ m_mouse_position.x(), m_ruler_thickness });
const Gfx::IntPoint indicator_y({ m_ruler_thickness, m_mouse_position.y() });
Gfx::IntPoint const indicator_x({ m_mouse_position.x(), m_ruler_thickness });
Gfx::IntPoint const indicator_y({ m_ruler_thickness, m_mouse_position.y() });
painter.draw_triangle(indicator_x, indicator_x + Gfx::IntPoint(-m_mouse_indicator_triangle_size, -m_mouse_indicator_triangle_size), indicator_x + Gfx::IntPoint(m_mouse_indicator_triangle_size, -m_mouse_indicator_triangle_size), mouse_indicator_color);
painter.draw_triangle(indicator_y, indicator_y + Gfx::IntPoint(-m_mouse_indicator_triangle_size, -m_mouse_indicator_triangle_size), indicator_y + Gfx::IntPoint(-m_mouse_indicator_triangle_size, m_mouse_indicator_triangle_size), mouse_indicator_color);
@ -276,15 +276,15 @@ int ImageEditor::calculate_ruler_step_size() const
Gfx::IntRect ImageEditor::mouse_indicator_rect_x() const
{
const Gfx::IntPoint top_left({ m_ruler_thickness, m_ruler_thickness - m_mouse_indicator_triangle_size });
const Gfx::IntSize size({ width() + 1, m_mouse_indicator_triangle_size + 1 });
Gfx::IntPoint const top_left({ m_ruler_thickness, m_ruler_thickness - m_mouse_indicator_triangle_size });
Gfx::IntSize const size({ width() + 1, m_mouse_indicator_triangle_size + 1 });
return Gfx::IntRect(top_left, size);
}
Gfx::IntRect ImageEditor::mouse_indicator_rect_y() const
{
const Gfx::IntPoint top_left({ m_ruler_thickness - m_mouse_indicator_triangle_size, m_ruler_thickness });
const Gfx::IntSize size({ m_mouse_indicator_triangle_size + 1, height() + 1 });
Gfx::IntPoint const top_left({ m_ruler_thickness - m_mouse_indicator_triangle_size, m_ruler_thickness });
Gfx::IntSize const size({ m_mouse_indicator_triangle_size + 1, height() + 1 });
return Gfx::IntRect(top_left, size);
}

2
Userland/Applications/PixelPaint/Tools/GradientTool.cpp
View File

@ -343,7 +343,7 @@ void GradientTool::calculate_gradient_lines()
m_editor->update();
}
void GradientTool::draw_gradient(GUI::Painter& painter, bool with_guidelines, const Gfx::FloatPoint drawing_offset, float scale, Optional<Gfx::IntRect const&> gradient_clip)
void GradientTool::draw_gradient(GUI::Painter& painter, bool with_guidelines, Gfx::FloatPoint const drawing_offset, float scale, Optional<Gfx::IntRect const&> gradient_clip)
{
auto t_gradient_begin_line = m_gradient_begin_line.scaled(scale, scale).translated(drawing_offset);
auto t_gradient_center_line = m_gradient_center_line.scaled(scale, scale).translated(drawing_offset);

2
Userland/Applications/PixelPaint/Tools/GradientTool.h
View File

@ -72,7 +72,7 @@ private:
void calculate_gradient_lines();
void calculate_transversal_points(float scale_fraction);
void draw_gradient(GUI::Painter&, bool with_guidelines = false, const Gfx::FloatPoint drawing_offset = { 0.0f, 0.0f }, float scale = 1, Optional<Gfx::IntRect const&> gradient_clip = {});
void draw_gradient(GUI::Painter&, bool with_guidelines = false, Gfx::FloatPoint const drawing_offset = { 0.0f, 0.0f }, float scale = 1, Optional<Gfx::IntRect const&> gradient_clip = {});
bool has_gradient_data() { return m_gradient_center.has_value() && m_gradient_end.has_value() && m_gradient_start.has_value(); }
void move_gradient_position(Gfx::IntPoint const movement_delta);
void rasterize_gradient();

4
Userland/Applications/SoundPlayer/Playlist.h
View File

@ -41,8 +41,8 @@ private:
class BloomFilter {
public:
void reset() { m_bitmap = 0; }
void add(const StringView key) { m_bitmap |= mask_for_key(key); }
bool maybe_contains(const StringView key) const
void add(StringView const key) { m_bitmap |= mask_for_key(key); }
bool maybe_contains(StringView const key) const
{
auto mask = mask_for_key(key);
return (m_bitmap & mask) == mask;

8
Userland/Applications/SpaceAnalyzer/TreeMapWidget.cpp
View File

@ -122,12 +122,12 @@ void TreeMapWidget::lay_out_children(TreeNode const& node, Gfx::IntRect const& r
Gfx::IntRect canvas = rect;
bool remaining_nodes_are_too_small = false;
for (size_t i = 0; !remaining_nodes_are_too_small && i < node.num_children(); i++) {
const i64 i_node_area = node.child_at(i).area();
i64 const i_node_area = node.child_at(i).area();
if (i_node_area == 0)
break;
const size_t long_side_size = max(canvas.width(), canvas.height());
const size_t short_side_size = min(canvas.width(), canvas.height());
size_t const long_side_size = max(canvas.width(), canvas.height());
size_t const short_side_size = min(canvas.width(), canvas.height());
size_t row_or_column_size = long_side_size * i_node_area / total_area;
i64 node_area_sum = i_node_area;
@ -163,7 +163,7 @@ void TreeMapWidget::lay_out_children(TreeNode const& node, Gfx::IntRect const& r
// Paint the elements from 'i' up to and including 'k-1'.
{
const size_t fixed_side_size = row_or_column_size;
size_t const fixed_side_size = row_or_column_size;
i64 placement_area = node_area_sum;
size_t main_dim = short_side_size;

2
Userland/Applications/SpaceAnalyzer/main.cpp
View File

@ -163,7 +163,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
continue;
}
const TreeNode* node = tree_map_widget.path_node(k);
TreeNode const* node = tree_map_widget.path_node(k);
builder.append('/');
builder.append(node->name());

2
Userland/Applications/Spreadsheet/CellTypeDialog.cpp
View File

@ -145,7 +145,7 @@ void CellTypeDialog::setup_tabs(GUI::TabWidget& tabs, Vector<Position> const& po
type_list.set_model(*GUI::ItemListModel<ByteString>::create(g_types));
type_list.set_should_hide_unnecessary_scrollbars(true);
type_list.on_selection_change = [&] {
const auto& index = type_list.selection().first();
auto const& index = type_list.selection().first();
if (!index.is_valid()) {
m_type = nullptr;
return;

4
Userland/Applications/Spreadsheet/Readers/XSV.h
View File

@ -107,7 +107,7 @@ public:
size_t index() const { return m_index; }
size_t size() const { return m_xsv.headers().size(); }
using ConstIterator = AK::SimpleIterator<const Row, StringView const>;
using ConstIterator = AK::SimpleIterator<Row const, StringView const>;
using Iterator = AK::SimpleIterator<Row, StringView>;
constexpr ConstIterator begin() const { return ConstIterator::begin(*this); }
@ -168,7 +168,7 @@ public:
size_t m_index { 0 };
};
const Row operator[](size_t index) const;
Row const operator[](size_t index) const;
Row operator[](size_t index);
Row at(size_t index) const;

2
Userland/Applications/Spreadsheet/Spreadsheet.cpp
View File

@ -455,7 +455,7 @@ RefPtr<Sheet> Sheet::from_json(JsonObject const& object, Workbook& workbook)
auto conditional_formats = obj.get_array("conditional_formats"sv);
auto cformats = cell->conditional_formats();
if (conditional_formats.has_value()) {
conditional_formats->for_each([&](const auto& fmt_val) {
conditional_formats->for_each([&](auto const& fmt_val) {
if (!fmt_val.is_object())
return IterationDecision::Continue;

2
Userland/Applications/Spreadsheet/SpreadsheetWidget.cpp
View File

@ -193,7 +193,7 @@ SpreadsheetWidget::SpreadsheetWidget(GUI::Window& parent_window, Vector<NonnullR
auto& sheet = *worksheet_ptr;
auto& cells = sheet.selected_cells();
VERIFY(!cells.is_empty());
const auto& data = GUI::Clipboard::the().fetch_data_and_type();
auto const& data = GUI::Clipboard::the().fetch_data_and_type();
if (auto spreadsheet_data = data.metadata.get("text/x-spreadsheet-data"); spreadsheet_data.has_value()) {
Vector<Spreadsheet::Position> source_positions, target_positions;
auto lines = spreadsheet_data.value().split_view('\n');

4
Userland/Demos/Gradient/Gradient.cpp
View File

@ -56,7 +56,7 @@ void Gradient::timer_event(Core::TimerEvent&)
void Gradient::draw()
{
const Color colors[] {
Color const colors[] {
Color::Blue,
Color::Cyan,
Color::Green,
@ -65,7 +65,7 @@ void Gradient::draw()
Color::Yellow,
};
const Orientation orientations[] {
Orientation const orientations[] {
Gfx::Orientation::Horizontal,
Gfx::Orientation::Vertical
};

4
Userland/DevTools/HackStudio/ClassViewWidget.cpp
View File

@ -19,11 +19,11 @@ ClassViewWidget::ClassViewWidget()
m_class_tree = add<GUI::TreeView>();
m_class_tree->on_selection_change = [this] {
const auto& index = m_class_tree->selection().first();
auto const& index = m_class_tree->selection().first();
if (!index.is_valid())
return;
auto* node = static_cast<const ClassViewNode*>(index.internal_data());
auto* node = static_cast<ClassViewNode const*>(index.internal_data());
if (!node->declaration)
return;

2
Userland/DevTools/HackStudio/Debugger/DebugInfoWidget.cpp
View File

@ -81,7 +81,7 @@ DebugInfoWidget::DebugInfoWidget()
variables_tab_widget.add_widget(build_registers_tab());
m_backtrace_view->on_selection_change = [this] {
const auto& index = m_backtrace_view->selection().first();
auto const& index = m_backtrace_view->selection().first();
if (!index.is_valid()) {
return;

2
Userland/DevTools/HackStudio/Debugger/Debugger.cpp
View File

@ -187,7 +187,7 @@ int Debugger::debugger_loop(Debug::DebugSession::DesiredInitialDebugeeState init
}
remove_temporary_breakpoints();
VERIFY(optional_regs.has_value());
const PtraceRegisters& regs = optional_regs.value();
PtraceRegisters const& regs = optional_regs.value();
auto source_position = m_debug_session->get_source_position(regs.ip());
if (!source_position.has_value())

2
Userland/DevTools/HackStudio/FindInFilesWidget.cpp
View File

@ -128,7 +128,7 @@ FindInFilesWidget::FindInFilesWidget()
m_result_view = add<GUI::TableView>();
m_result_view->on_activation = [](auto& index) {
auto& match = *(const Match*)index.internal_data();
auto& match = *(Match const*)index.internal_data();
open_file(match.filename);
current_editor().set_selection(match.range);
current_editor().set_focus(true);

4
Userland/DevTools/HackStudio/Git/GitWidget.cpp
View File

@ -43,11 +43,11 @@ GitWidget::GitWidget()
[this](auto const& file) { stage_file(file); },
Gfx::Bitmap::load_from_file("/res/icons/16x16/plus.png"sv).release_value_but_fixme_should_propagate_errors());
m_unstaged_files->on_selection_change = [this] {
const auto& index = m_unstaged_files->selection().first();
auto const& index = m_unstaged_files->selection().first();
if (!index.is_valid())
return;
const auto& selected = index.data().as_string();
auto const& selected = index.data().as_string();
show_diff(selected);
};

2
Userland/DevTools/HackStudio/HackStudioWidget.cpp
View File

@ -1044,7 +1044,7 @@ void HackStudioWidget::initialize_debugger()
m_project->root_path(),
[this](PtraceRegisters const& regs) {
VERIFY(Debugger::the().session());
const auto& debug_session = *Debugger::the().session();
auto const& debug_session = *Debugger::the().session();
auto source_position = debug_session.get_source_position(regs.ip());
if (!source_position.has_value()) {
dbgln("Could not find source position for address: {:p}", regs.ip());

2
Userland/DevTools/HackStudio/ProjectTemplate.h
View File

@ -29,7 +29,7 @@ public:
ByteString const& name() const { return m_name; }
ByteString const& description() const { return m_description; }
const GUI::Icon& icon() const { return m_icon; }
const ByteString content_path() const
ByteString const content_path() const
{
return LexicalPath::canonicalized_path(ByteString::formatted("{}/{}", templates_path(), m_id));
}

4
Userland/Games/Chess/ChessWidget.cpp
View File

@ -121,8 +121,8 @@ void ChessWidget::paint_event(GUI::PaintEvent& event)
float hdx = h * cosf(phi);
float hdy = h * sinf(phi);
const auto cos_pi_2_phi = cosf(float { M_PI_2 } - phi);
const auto sin_pi_2_phi = sinf(float { M_PI_2 } - phi);
auto const cos_pi_2_phi = cosf(float { M_PI_2 } - phi);
auto const sin_pi_2_phi = sinf(float { M_PI_2 } - phi);
Gfx::FloatPoint A1(A.x() - (w1 / 2) * cos_pi_2_phi, A.y() - (w1 / 2) * sin_pi_2_phi);
Gfx::FloatPoint B3(A.x() + (w1 / 2) * cos_pi_2_phi, A.y() + (w1 / 2) * sin_pi_2_phi);

4
Userland/Games/FlappyBug/Game.h
View File

@ -176,8 +176,8 @@ private:
float m_difficulty {};
float m_restart_cooldown {};
NonnullRefPtr<Gfx::Bitmap> m_background_bitmap { Gfx::Bitmap::load_from_file("/res/graphics/flappybug/background.png"sv).release_value_but_fixme_should_propagate_errors() };
const Gfx::IntRect m_score_rect { 10, 10, 20, 20 };
const Gfx::IntRect m_text_rect { game_width / 2 - 80, game_height / 2 - 40, 160, 80 };
Gfx::IntRect const m_score_rect { 10, 10, 20, 20 };
Gfx::IntRect const m_text_rect { game_width / 2 - 80, game_height / 2 - 40, 160, 80 };
Game(Bug, Cloud);
};

4
Userland/Libraries/LibAudio/Resampler.h
View File

@ -90,8 +90,8 @@ public:
u32 target() const { return m_target; }
private:
const u32 m_source;
const u32 m_target;
u32 const m_source;
u32 const m_target;
u32 m_current_ratio { 0 };
SampleType m_last_sample_l {};
SampleType m_last_sample_r {};

4
Userland/Libraries/LibC/net.cpp
View File

@ -11,8 +11,8 @@
#include <sys/ioctl.h>
#include <sys/socket.h>
const in6_addr in6addr_any = IN6ADDR_ANY_INIT;
const in6_addr in6addr_loopback = IN6ADDR_LOOPBACK_INIT;
in6_addr const in6addr_any = IN6ADDR_ANY_INIT;
in6_addr const in6addr_loopback = IN6ADDR_LOOPBACK_INIT;
// https://pubs.opengroup.org/onlinepubs/9699919799/functions/if_nametoindex.html
unsigned int if_nametoindex([[maybe_unused]] char const* ifname)

4
Userland/Libraries/LibC/qsort.cpp
View File

@ -31,7 +31,7 @@ template<>
inline void swap(SizedObject const& a, SizedObject const& b)
{
VERIFY(a.size() == b.size());
const size_t size = a.size();
size_t const size = a.size();
auto const a_data = reinterpret_cast<char*>(a.data());
auto const b_data = reinterpret_cast<char*>(b.data());
for (auto i = 0u; i < size; ++i) {
@ -49,7 +49,7 @@ public:
, m_element_size(element_size)
{
}
const SizedObject operator[](size_t index)
SizedObject const operator[](size_t index)
{
return { static_cast<char*>(m_data) + index * m_element_size, m_element_size };
}

2
Userland/Libraries/LibC/scanf.cpp
View File

@ -316,7 +316,7 @@ private:
return invert ^ scan_set.contains(c);
}
const StringView scan_set;
StringView const scan_set;
bool invert { false };
};

6
Userland/Libraries/LibC/stdlib.cpp
View File

@ -144,7 +144,7 @@ private:
return m_sign != Sign::Negative;
}
const T m_base;
T const m_base;
T m_num;
T m_cutoff;
int m_max_digit_after_cutoff;
@ -313,7 +313,7 @@ static T c_str_to_floating_point(char const* str, char** endptr)
// - One of INF or INFINITY, ignoring case
// - One of NAN or NAN(n-char-sequenceopt), ignoring case in the NAN part
const Sign sign = strtosign(parse_ptr, &parse_ptr);
Sign const sign = strtosign(parse_ptr, &parse_ptr);
if (is_infinity_string(parse_ptr, endptr)) {
// Don't set errno to ERANGE here:
@ -973,7 +973,7 @@ long long strtoll(char const* str, char** endptr, int base)
// Parse spaces and sign
char* parse_ptr = const_cast<char*>(str);
strtons(parse_ptr, &parse_ptr);
const Sign sign = strtosign(parse_ptr, &parse_ptr);
Sign const sign = strtosign(parse_ptr, &parse_ptr);
// Parse base
if (base == 0) {

2
Userland/Libraries/LibCards/Card.h
View File

@ -103,7 +103,7 @@ public:
bool is_disabled() const { return m_disabled; }
Gfx::Color color() const { return (m_suit == Suit::Diamonds || m_suit == Suit::Hearts) ? Color::Red : Color::Black; }
void set_position(const Gfx::IntPoint p) { m_rect.set_location(p); }
void set_position(Gfx::IntPoint const p) { m_rect.set_location(p); }
void set_moving(bool moving) { m_moving = moving; }
void set_upside_down(bool upside_down) { m_upside_down = upside_down; }
void set_inverted(bool inverted) { m_inverted = inverted; }

4
Userland/Libraries/LibChess/Chess.cpp
View File

@ -116,7 +116,7 @@ ErrorOr<String> Move::to_long_algebraic() const
return builder.to_string();
}
Move Move::from_algebraic(StringView algebraic, const Color turn, Board const& board)
Move Move::from_algebraic(StringView algebraic, Color const turn, Board const& board)
{
auto move_string = algebraic;
Move move({ 50, 50 }, { 50, 50 });
@ -294,7 +294,7 @@ ErrorOr<String> Board::to_fen() const
int empty = 0;
for (int rank = 0; rank < 8; rank++) {
for (int file = 0; file < 8; file++) {
const Piece p(get_piece({ 7 - rank, file }));
Piece const p(get_piece({ 7 - rank, file }));
if (p.type == Type::None) {
empty++;
continue;

2
Userland/Libraries/LibChess/Chess.h
View File

@ -117,7 +117,7 @@ struct Move {
}
bool operator==(Move const& other) const { return from == other.from && to == other.to && promote_to == other.promote_to; }
static Move from_algebraic(StringView algebraic, const Color turn, Board const& board);
static Move from_algebraic(StringView algebraic, Color const turn, Board const& board);
ErrorOr<String> to_long_algebraic() const;
ErrorOr<String> to_algebraic() const;
};

2
Userland/Libraries/LibCodeComprehension/Cpp/CppComprehensionEngine.cpp
View File

@ -206,7 +206,7 @@ Vector<StringView> CppComprehensionEngine::scope_of_reference_to_symbol(ASTNode
return scope_parts;
}
Vector<CodeComprehension::AutocompleteResultEntry> CppComprehensionEngine::autocomplete_property(DocumentData const& document, MemberExpression const& parent, const ByteString partial_text) const
Vector<CodeComprehension::AutocompleteResultEntry> CppComprehensionEngine::autocomplete_property(DocumentData const& document, MemberExpression const& parent, ByteString const partial_text) const
{
VERIFY(parent.object());
auto type = type_of(document, *parent.object());

2
Userland/Libraries/LibCodeComprehension/Cpp/CppComprehensionEngine.h
View File

@ -95,7 +95,7 @@ private:
HashTable<ByteString> m_available_headers;
};
Vector<CodeComprehension::AutocompleteResultEntry> autocomplete_property(DocumentData const&, MemberExpression const&, const ByteString partial_text) const;
Vector<CodeComprehension::AutocompleteResultEntry> autocomplete_property(DocumentData const&, MemberExpression const&, ByteString const partial_text) const;
Vector<AutocompleteResultEntry> autocomplete_name(DocumentData const&, ASTNode const&, ByteString const& partial_text) const;
ByteString type_of(DocumentData const&, Expression const&) const;
ByteString type_of_property(DocumentData const&, Identifier const&) const;

Some files were not shown because too many files have changed in this diff Show More