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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
/*
* a small library of types, functions and macros that
* are used throughout the bootstrap compiler.
* allocation done purely statically.
*/
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define uint8 uint8_t
#define uint16 uint16_t
#define uint32 uint32_t
#define uint64 uint64_t
#define int8 int8_t
#define int16 int16_t
#define int32 int32_t
#define int64 int64_t
#define float32 float
#define float64 double
#define real float64
#define uint uint64
#define integer int64
#define flags int32
#define ascii char
#define byte char
#define bool _Bool
#define true 1
#define false 0
#define nil NULL
#define unknown void
// call on irrecoverable failure.
// prints a very sad, apologetic message for
// the user and aborts program with failure status.
void
failure(const ascii* message)
{
const ascii* format =
"\\e[0;31m"
";( sorry, a failure has occurred...\n"
"-> %s!\n"
"\\e[0m";
fprintf(stderr, format, message);
exit(EXIT_FAILURE);
}
// check a condition, triggering a failure if it's false.
void
check(bool condition, const ascii* message)
{
if (!condition) failure(message);
}
// the common size of region memory blocks.
#define REGION_SIZE 65536
// statically allocates a region of memory of a given size
// for a single type.
#define REGION_OF_SIZE(type, of, size) \
type region_##of[size]; \
uint region_##of##_cursor = 0;
// statically allocates a region of memory for a type.
#define REGION(type, of) REGION_OF_SIZE(type, of, REGION_SIZE)
// the global string region.
REGION(ascii, string)
// a string.
struct String
{
ascii* data;
uint length;
};
#define STRING_ITERATE(index, c, str) \
ascii c = string_at(str, 0); \
for (uint index = 0; index < str.length; c = string_at(str, ++index))
// allocates a new string in the global string region.
struct String
string_new(const ascii* data, uint length)
{
// for compatibility, we include an additional null byte at the end.
uint allocation_length = length + 1;
check(region_string_cursor + allocation_length < REGION_SIZE, "out of string memory");
ascii* at = region_string + region_string_cursor;
region_string_cursor += allocation_length;
for (uint i = 0; i < length; ++i) at[i] = data[i];
at[length] = '\0';
return (struct String){
.data = at,
.length = length,
};
}
struct String
string_empty()
{
return (struct String){
.data = nil,
.length = 0,
};
}
// allocates a new string in the global string region,
// taking the data from a null-terminated C string.
struct String
string_from_c_string(const char* c_string)
{
uint length = strlen(c_string);
return string_new(c_string, length);
}
// allocates a new string in the global string region,
// taking the data from a static null-terminated C string.
//
// NOTE: The string is not copied, so it MUST have a lifetime
// spanning the entire program.
struct String
string_from_static_c_string(const char* c_string)
{
uint length = strlen(c_string);
return (struct String){
.data = (ascii*)c_string,
.length = length,
};
}
// returns the character at a given index.
// does bounds-checking.
ascii
string_at(struct String s, uint index)
{
check(index < s.length, "index out of bounds");
return s.data[index];
}
uint
string_length(struct String s)
{
return s.length;
}
|
