156 lines
3.5 KiB
C++
156 lines
3.5 KiB
C++
#ifndef CORE_HPP
|
|
#define CORE_HPP
|
|
|
|
#include <string.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/mman.h>
|
|
|
|
// ### Types ###
|
|
typedef int8_t int8;
|
|
typedef int16_t int16;
|
|
typedef int32_t int32;
|
|
typedef int64_t int64;
|
|
typedef uint8_t uint8;
|
|
typedef uint16_t uint16;
|
|
typedef uint32_t uint32;
|
|
typedef uint64_t uint64;
|
|
|
|
typedef uint8_t byte;
|
|
|
|
typedef float real32;
|
|
typedef double real64;
|
|
|
|
// ### Sizes and Numbers ###
|
|
#define Bytes(n) (n)
|
|
#define Kilobytes(n) (n << 10)
|
|
#define Megabytes(n) (n << 20)
|
|
#define Gigabytes(n) (((uint64)n) << 30)
|
|
#define Terabytes(n) (((uint64)n) << 40)
|
|
|
|
#define Thousand(n) ((n)*1000)
|
|
#define Million(n) ((n)*1000000)
|
|
#define Billion(n) ((n)*1000000000LL)
|
|
|
|
#define ArrayCount(arr) (sizeof(arr) / sizeof((arr)[0]))
|
|
|
|
// ### Arenas ###
|
|
struct Arena {
|
|
void *memory;
|
|
size_t capacity;
|
|
size_t head;
|
|
};
|
|
|
|
void *pushSize(Arena *arena, size_t size) {
|
|
if (arena->capacity - arena->head >= size) {
|
|
arena->head += size;
|
|
return (char *)arena->memory + arena->head + size;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#define PushArray(arena, type, size) (type *)pushSize(arena, sizeof(type) * (size))
|
|
#define PushStruct(arena, type, size) (type *)pushSize(arena, sizeof(type))
|
|
|
|
Arena createArena(size_t capacity) {
|
|
Arena result = {};
|
|
result.memory = mmap(0, capacity, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
|
|
result.capacity = capacity;
|
|
result.head = 0;
|
|
return result;
|
|
}
|
|
|
|
// ### Lists ###
|
|
template <typename T>
|
|
struct list {
|
|
T* data;
|
|
size_t capacity;
|
|
size_t length;
|
|
};
|
|
|
|
#define PushList(arena, type, size) ((list<type>){ PushArray(arena, type, size), size, 0 })
|
|
|
|
template <typename T>
|
|
T *appendList(list<T> *list, T element) {
|
|
if (list->length < list->capacity) {
|
|
list->data[list->length] = element;
|
|
list->length++;
|
|
return &(list->data[list->length - 1]);
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
void zeroList(list<T> *list) {
|
|
list->length = 0;
|
|
memset(list->data, 0, list->capacity * sizeof(T));
|
|
}
|
|
|
|
// ### Strings ###
|
|
#define strlit(lit) ((string){(char *)(lit), sizeof(lit) - 1})
|
|
|
|
struct string {
|
|
char *str;
|
|
size_t len;
|
|
};
|
|
|
|
const char *cstring(Arena *arena, list<char> buf) {
|
|
char *arr = PushArray(arena, char, buf.length + 1);
|
|
memcpy(arr, buf.data, sizeof(char) * buf.length);
|
|
arr[buf.length] = '\0';
|
|
return arr;
|
|
}
|
|
|
|
const char *cstring(Arena *arena, string str) {
|
|
char *arr = PushArray(arena, char, str.len + 1);
|
|
memcpy(arr, str.str, str.len * sizeof(char));
|
|
arr[str.len] = '\0';
|
|
return arr;
|
|
}
|
|
|
|
bool strEql(string s1, string s2) {
|
|
if (s1.len != s2.len) {
|
|
return false;
|
|
}
|
|
for (size_t i = 0; i < s1.len; i++) {
|
|
if (s1.str[i] != s2.str[i]) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
string strSlice(char *data, size_t start, size_t stop) {
|
|
return {
|
|
data + start,
|
|
stop - start,
|
|
};
|
|
}
|
|
|
|
// ### File IO ###
|
|
size_t getFileSize(string file) {
|
|
struct stat st;
|
|
stat((char *)file.str, &st);
|
|
return st.st_size;
|
|
}
|
|
|
|
list<char> readEntireFile(Arena *arena, string file) {
|
|
FILE *input = fopen((char *)file.str, "r");
|
|
size_t filesize = getFileSize(file);
|
|
list<char> readBuffer = PushList(arena, char, filesize);
|
|
readBuffer.length = filesize;
|
|
fread(readBuffer.data, sizeof(byte), filesize, input);
|
|
fclose(input);
|
|
return readBuffer;
|
|
}
|
|
|
|
int cmpint(const void *a, const void *b) {
|
|
int *x = (int *)a;
|
|
int *y = (int *)b;
|
|
return (*x > *y) - (*x < *y);
|
|
}
|
|
|
|
#endif
|