1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
#ifndef COMMON_CC
#define COMMON_CC
#include <cstdarg>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
/* typedefs for common types */
typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;
typedef int8_t i8;
typedef int16_t i16;
typedef int32_t i32;
typedef int64_t i64;
typedef uintptr_t usize;
typedef intptr_t isize;
/* intrinsics */
#define likely(cond) __builtin_expect(!!(cond), 1)
#define unlikely(cond) __builtin_expect(!!(cond), 0)
/* error handling sort of */
[[noreturn]] void panic_impl(const char* file, i32 line, const char* fmt, ...) {
fprintf(stderr, "PANIC at %s:%d: ", file, line);
va_list args;
va_start(args, fmt);
vfprintf(stderr, fmt, args);
va_end(args);
fputc('\n', stderr);
fflush(stderr);
abort();
}
#define panic(fmt, ...) panic_impl(__FILE__, __LINE__, fmt, __VA_ARGS__)
#define spanic(msg) panic("%s", msg)
#undef assert
#define assert(cond) \
do { \
if (unlikely(!(cond))) panic("assertion failed: %s", #cond); \
} while (0)
/* slice and string handling */
template <typename T>
struct Slice {
T* ptr;
usize length;
Slice() : ptr(nullptr), length(0) {}
Slice(T* ptr, usize length) : ptr(ptr), length(length) {}
T* operator[](usize index) {
assert(index < this->length);
return this->ptr + index;
}
const T* operator[](usize index) const {
assert(index < this->size());
return this->ptr + index;
}
inline usize size() const { return this->length * sizeof(T); }
};
template <typename T>
bool slice_write(const Slice<T>* slice, FILE* stream) {
usize rc = fwrite(slice->ptr, sizeof(T), slice->length, stream);
if (rc == 0 || slice->size() > rc) return false;
return true;
}
typedef Slice<const u8> String;
/* linked list */
struct Link {
Link* next;
Link* prev;
Link(Link* next, Link* prev) : next(next), prev(prev) {}
};
struct List {
Link head;
Link tail;
};
static inline void link_after(Link* prev, Link* nlink) {
assert(prev != nullptr);
assert(nlink != nullptr);
Link* next = prev->next;
nlink->prev = prev;
nlink->next = next;
prev->next = nlink;
if(next == nullptr) return;
next->prev = nlink;
}
#endif
|
