Ledda
/
gym-tracker
1
0
Derivar 0
Código Questões 0 Pedidos de integração 0 Lançamentos 0 Wiki Trabalho
Ver a proveniência

remove djstdlib hardcopy

master
Daniel Ledda há 1 semana
ascendente
4a8621940e
cometimento
133a02593d
11 ficheiros alterados com 0 adições e 2898 eliminações
Visualização em 2 colunas
Opções das diferenças
Mostrar estatísticas Descarregar ficheiro patch Descarregar ficheiro diff
  1. +0
    -3
      djstdlib/.clangd
  2. +0
    -14
      djstdlib/app.cpp
  3. +0
    -3
      djstdlib/build
  4. +0
    -27
      djstdlib/build.bat
  5. +0
    -436
      djstdlib/core.cpp
  6. +0
    -270
      djstdlib/core.h
  7. +0
    -12
      djstdlib/os.cpp
  8. +0
    -20
      djstdlib/os.h
  9. +0
    -98
      djstdlib/os_linux.cpp
  10. +0
    -92
      djstdlib/os_win32.cpp
  11. +0
    -1923
      djstdlib/vendor/stb_sprintf.h

+ 0
- 3
djstdlib/.clangd Ver ficheiro

@@ -1,3 +0,0 @@
CompileFlags:
Add:
- -DOS_LINUX

+ 0
- 14
djstdlib/app.cpp Ver ficheiro

@@ -1,14 +0,0 @@
#include <stdio.h>
#include "core.cpp"
#include "core.h"

int main(int argc, char **argv) {
int statusCode = 0;
initialiseCore();
Arena *arena = arenaAlloc(Megabytes(64));
list<string> args = getArgs(arena, argc, argv);

prinft("%S", strSplit(arena, "-"_s, "hallo-world"_s));

return statusCode;
}

+ 0
- 3
djstdlib/build Ver ficheiro

@@ -1,3 +0,0 @@
#!/bin/bash

g++ -g -g3 -lm -DOS_LINUX=1 -DENABLE_ASSERT=1 ./app.cpp -o ./target/app

+ 0
- 27
djstdlib/build.bat Ver ficheiro

@@ -1,27 +0,0 @@
@echo off

if NOT EXIST .\target mkdir .\target

set commonLinkerFlags=-opt:ref
set commonCompilerFlags=^
-MT %= Make sure the C runtime library is statically linked =%^
-Gm- %= Turns off incremental building =%^
-nologo %= No one cares you made the compiler Microsoft =%^
-Oi %= Always use intrinsics =%^
-EHa- %= Disable exception handling =%^
-GR- %= Never use runtime type info from C++ =%^
-WX -W4 -wd4201 -wd4100 -wd4189 -wd4505 %= Compiler warnings, -WX warnings as errors, -W4 warning level 4, -wdXXXX disable warning XXXX =%^
-DAPP_DEBUG=0 -DENABLE_ASSERT=1 -DOS_WINDOWS=1 %= Custom #defines =%^
-D_CRT_SECURE_NO_WARNINGS=1^
-FC %= Full path of source code file in diagnostics =%^
-Zi %= Generate debugger info =%

pushd .\target
cl %commonCompilerFlags% -Fe:.\app.exe ..\app.cpp /link -incremental:no %commonLinkerFlags%
popd

exit /b

:error
echo Failed with error #%errorlevel%.
exit /b %errorlevel%

+ 0
- 436
djstdlib/core.cpp Ver ficheiro

@@ -1,436 +0,0 @@
#include "os.cpp"
#include <math.h>
#include <string.h>
#include "core.h"
#define STB_SPRINTF_IMPLEMENTATION
#include "vendor/stb_sprintf.h"

void *pushSizeFill(Arena *arena, size_t bytes, byte fill) {
if (arena->capacity - arena->head >= bytes) {
void *ptr = (char *)arena->memory + arena->head;
arena->head += bytes;
memset(ptr, fill, bytes);
return ptr;
}
return 0;
}

void *pushSize(Arena *arena, size_t bytes) {
if (arena->capacity - arena->head >= bytes) {
void *ptr = (char *)arena->memory + arena->head;
arena->head += bytes;
return ptr;
}
return 0;
}

Arena *arenaAlloc(size_t capacity) {
Arena *result = (Arena *)os_alloc(sizeof(Arena) + capacity);
result->memory = result + sizeof(Arena);
result->capacity = capacity;
result->head = 0;
return result;
}

void arenaFree(Arena *arena) {
os_free(arena, arena->capacity);
}

void arenaFreeFrom(Arena *arena, size_t position) {
arena->head = position;
}

void arenaPopTo(Arena *arena, void *position) {
arena->head = (byte *)position - (byte *)arena->memory;
}

Arena *scratchArenas[2];

void initialiseCore() {
for (EachInArray(scratchArenas, i)) {
scratchArenas[i] = arenaAlloc(Megabytes(64));
}
}

Scratch scratchStart(Arena **conflicts, size_t conflictCount) {
Scratch scratch = {0};
for (size_t i = 0; i < ArrayCount(scratchArenas); i += 1) {
bool conflicted = false;
for (Arena **conflict = conflicts; conflict < conflicts + conflictCount; conflict += 1) {
if (*conflict == scratchArenas[i]) {
conflicted = true;
break;
}
}
if (conflicted == false) {
scratch.arena = scratchArenas[i];
scratch.start = scratch.arena->head;
break;
}
}
return scratch;
}

#define DeferLoop(begin_stmnt, end_stmnt) for(int __defer_i = ((begin_stmnt), 0); __defer_i < 1; (++__defer_i, (end_stmnt)))
#define WithScratch(scratchName) Scratch scratchName; DeferLoop(scratchName = scratchStart(0, 0), scratchEnd(scratchName))

void scratchEnd(Scratch scratch) {
arenaFreeFrom(scratch.arena, scratch.start);
}

template <typename T>
T *appendList(list<T> *list, T element) {
if (list->head < list->length) {
list->data[list->head] = element;
list->head++;
return &(list->data[list->head - 1]);
} else {
return 0;
}
}

template <typename T>
void zeroListFull(list<T> *list) {
memset(list->data, 0, list->head * sizeof(T));
}

template <typename T>
void zeroList(list<T> *list) {
list->head = 0;
memset(list->data, 0, list->head * sizeof(T));
}

inline string operator""_s(const char *cstrLiteral, size_t length) {
return {
(char *)cstrLiteral,
length,
};
}

const char *cstring(Arena *arena, list<char> buf) {
char *arr = PushArray(arena, char, buf.length + 1);
memmove(arr, buf.data, buf.length);
arr[buf.length] = '\0';
return arr;
}

const char *cstring(Arena *arena, string str) {
char *arr = PushArray(arena, char, str.length + 1);
memmove(arr, str.str, str.length);
arr[str.length] = '\0';
return arr;
}

bool strStartsWith(string str, string testStr) {
if (str.length < testStr.length) {
return false;
}
for (size_t i = 0; i < testStr.length; i++) {
if (str.str[i] != testStr.str[i]) {
return false;
}
}
return true;
}

bool strEql(string s1, string s2) {
if (s1.length != s2.length) {
return false;
}
for (size_t i = 0; i < s1.length; i++) {
if (s1.str[i] != s2.str[i]) {
return false;
}
}
return true;
}

size_t calcStringLen(const char *str) {
size_t size = 0;
if (str == NULL) {
return size;
}
while (str[size] != '\0') {
size++;
}
return size;
}

string strFromCString(Arena *arena, const char *str) {
string result = PushString(arena, calcStringLen(str));
memcpy(result.str, str, result.length);
return result;
}

string strReverse(Arena *arena, string str) {
string reversed = PushString(arena, str.length);
for (
size_t mainIndex = str.length - 1, reversedIndex = 0;
mainIndex < str.length;
mainIndex--, reversedIndex++
) {
reversed.str[reversedIndex] = str.str[mainIndex];
}
return reversed;
}

string strPrintfv(Arena *arena, const char *fmt, va_list args) {
string result = {0};
va_list argsCopy;
va_copy(argsCopy, args);
uint64 bufSize = stb_vsnprintf(0, 0, fmt, args) + 1;
result.str = PushArray(arena, char, bufSize);
result.length = bufSize - 1;
stb_vsnprintf((char *)result.str, (int)bufSize, fmt, argsCopy);
return result;
}

string strPrintf(Arena *arena, const char *fmt, ...) {
string result = {0};
va_list args;
va_start(args, fmt);
result = strPrintfv(arena, fmt, args);
va_end(args);
return result;
}

template <typename T>
list<T> listSlice(list<T> l, size_t start, size_t stop) {
if (stop == 0) {
stop = l.head;
}
// TODO(djledda): maybe assert instead
if (stop > l.head || start > stop) {
return {0};
}
return {
l.data + start,
stop - start,
stop - start,
};
}

string strSlice(string str, size_t start, size_t stop) {
if (stop == 0) {
stop = str.length;
}
// TODO(djledda): maybe assert instead
if (stop > str.length || start > stop) {
return {0};
}
return {
str.str + start,
stop - start,
};
}

string strSlice(char *data, size_t start, size_t stop) {
return {
data + start,
stop - start,
};
}

bool stringContains(string str, char c) {
for (size_t i = 0; i < str.length; i++) {
if (str.str[i] == c) {
return true;
}
}
return false;
}

string NUMERIC_CHARS = "0123456789"_s;
inline bool isNumeric(char c) {
return stringContains(NUMERIC_CHARS, c);
}

list<string> strSplit(Arena *arena, string splitStr, string inputStr) {
list<string> result = {0};
if (inputStr.length > 0) {
size_t splitCount = 0;
size_t c = 0;
size_t start = 0;
void *beginning = (char *)arena->memory + arena->head;
while (c < inputStr.length - splitStr.length) {
if (strEql(strSlice(inputStr, c, c + splitStr.length), splitStr)) {
string *splitString = PushStruct(arena, string);
splitString->str = inputStr.str + start;
splitString->length = c - start;
splitCount++;
start = c + 1;
}
c++;
}

string *splitString = PushStruct(arena, string);
splitString->str = inputStr.str + start;
splitString->length = inputStr.length - start;
splitCount++;
result.data = (string *)beginning,
result.head = splitCount,
result.length = splitCount;
}
return result;
}

ParsePositiveIntResult parsePositiveInt(string str, size_t *lengthPointer) {
size_t numEnd = 0;
char currChar = str.str[numEnd];
while (numEnd < str.length && isNumeric(currChar)) {
currChar = str.str[++numEnd];
*lengthPointer += 1;
}
*lengthPointer -= 1;
if (numEnd > 0) {
uint8 result = 0;
for (size_t i = 0; i < numEnd; i++) {
result *= 10;
result += str.str[i] - '0';
}
return {result, true};
} else {
return {0, false};
}
}

ParsePositiveReal32Result parsePositiveReal32(string str, size_t *lengthPointer) {
ParsePositiveReal32Result result = {NAN, false};

string wholePartStr = string{0};
string fractionalPartStr = string{0};

bool split = false;
size_t c = 0;
while (c < str.length) {
if (str.str[c] == '.') {
wholePartStr.str = str.str;
wholePartStr.length = c;
fractionalPartStr.str = str.str + c + 1;
fractionalPartStr.length = str.length - c - 1;
split = true;
break;
}
c++;
}
if (split) {
ParsePositiveIntResult wholePartParsed = parsePositiveInt(wholePartStr, lengthPointer);
*lengthPointer += 1;
ParsePositiveIntResult fractionalPartParsed = parsePositiveInt(fractionalPartStr, lengthPointer);
if (wholePartParsed.valid && fractionalPartParsed.valid) {
// TODO(dledda): implement powf with intrinsics? or just custom
real32 fractionalPartMultiplier = 1.0f / powf(10.0f, (real32)fractionalPartStr.length);
result.result = (real32)wholePartParsed.result + (real32)fractionalPartParsed.result * (real32)fractionalPartMultiplier;
result.valid = true;
}
} else if (c > 0) {
ParsePositiveIntResult intPartParsed = parsePositiveInt(str, lengthPointer);
if (intPartParsed.valid) {
result.result = (real32)intPartParsed.result;
result.valid = true;
}
}
return result;
}

list<string> getArgs(Arena *arena, int argc, char **argv) {
list<string> args = PushList(arena, string, (size_t)argc - 1);
for (int i = 1; i < argc; i++) {
appendList(&args, strFromCString(arena, argv[i]));
}
return args;
}
UnixTimestamp getSystemUnixTime() {
time_t now;
time(&now);
return (UnixTimestamp)now;
}

Timestamp timestampFromUnixTime(UnixTimestamp *unixTimestamp) {
tm timestamp = {0};
gmtime_r((time_t *)unixTimestamp, &timestamp);
return timestamp;
}

string formatTimeHms(Arena *arena, UnixTimestamp time) {
local_persist const string format = "HH-MM-SS"_s;
string buf = PushString(arena, format.length);
tm *timestamp = gmtime((time_t *)&time);
strftime(buf.str, buf.length + 1, "%T", timestamp);
return buf;
}

string formatTimeHms(Arena *arena, Timestamp *time) {
local_persist const string format = "HH-MM-SS"_s;
string buf = PushString(arena, format.length);
strftime(buf.str, buf.length + 1, "%T", (tm *)time);
return buf;
}

string formatTimeYmd(Arena *arena, UnixTimestamp time) {
local_persist const string format = "YYYY-mm-dd"_s;
string buf = PushString(arena, format.length);
tm *timestamp = gmtime((time_t *)&time);
strftime(buf.str, buf.length + 1, "%Y-%m-%d", timestamp);
return buf;
}

string formatTimeYmd(Arena *arena, Timestamp *time) {
local_persist const string format = "YYYY-mm-dd"_s;
string buf = PushString(arena, format.length);
strftime(buf.str, buf.length + 1, "%Y-%m-%d", (tm *)time);
return buf;
}

void logErr(const char *fmt, ...) {
va_list argList;
va_start(argList, fmt);
os_log(LogTarget_stdout, fmt, argList);
va_end(argList);
}

function void logStdout(const char *fmt, ...) {
va_list argList;
va_start(argList, fmt);
os_log(LogTarget_stdout, fmt, argList);
va_end(argList);
}

void log(const char *fmt, ...) {
va_list argList;
va_start(argList, fmt);
os_log(LogTarget_stdout, fmt, argList);
va_end(argList);
}

void log(list<int> l, LogTarget target) {
void (*logFn)(const char *fmt, ...) = target == LogTarget_stdout ? &logStdout : &logErr;
logFn("{ ");
for (size_t i = 0; i < l.length; i++) {
if (i != 0) {
logFn(", ");
}
logFn("%i", l.data[i]);
}
logFn(" } length: %zu, head: %zu\n", l.length, l.head);
}

void log(list<string> l, LogTarget target) {
void (*logFn)(const char *fmt, ...) = target == LogTarget_stdout ? &logStdout : &logErr;
logFn("{ ");
for (size_t i = 0; i < l.length; i++) {
if (i != 0) {
logFn(", ");
}
logFn("\"%S\"", l.data[i]);
}
logFn(" } length: %zu, head: %zu\n", l.length, l.head);
}

int intCompare(const void *a, const void *b) {
int *x = (int *)a;
int *y = (int *)b;
return (*x > *y) - (*x < *y);
}


+ 0
- 270
djstdlib/core.h Ver ficheiro

@@ -1,270 +0,0 @@
#ifndef CORE_H
#define CORE_H

// cstdlib includes
#include <math.h>
#include <stdint.h> // necessary for int type sizes
#include <stdio.h>
#include <time.h> // TODO(djledda): try not to depend on this one

// ### Misc macros ###
#if ENABLE_ASSERT
#define Assert(expression) if (!(expression)) {*(volatile int *)0 = 0;}
#else
#define Assert(expression)
#endif

#define function static
#define global static
#define local_persist static

// ### 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;
};

struct Scratch {
Arena *arena;
size_t start;
};

void *pushSize(Arena *arena, size_t bytes);
void *pushSizeFill(Arena *arena, size_t bytes, byte fill);
Arena *arenaAlloc(size_t capacity);
void arenaFree(Arena *arena);
void arenaFreeFrom(Arena *arena, size_t pos);
void arenaPopTo(Arena *arena, void *pos);

void initialiseCore();

Scratch scratchStart(Arena **conflicts, size_t conflictCount);
void scratchEnd(Scratch scratch);

#define PushArray(arena, type, size) (type *)pushSize(arena, sizeof(type) * (size))
#define PushArrayZero(arena, type, size) (type *)pushSizeFill(arena, sizeof(type) * (size), 0)
#define PushStruct(arena, type) (type *)pushSize(arena, sizeof(type))
#define PushStructZero(arena, type) (type *)pushSizeFill(arena, sizeof(type), 0)

// ### Vectors ###
template <typename T>
union Vector2 {
struct {
T x;
T y;
};
T vec[2];
};
template <typename T>
inline function Vector2<T> vec2(T x, T y) {
Vector2<T> result = {0};
result.x = x;
result.y = y;
return result;
}

template <typename T>
union Vector3 {
struct {
T x;
T y;
T z;
};
T vec[3];
};
template <typename T>
inline function Vector3<T> vec3(T x, T y, T z) {
Vector3<T> result = {0};
result.x = x;
result.y = y;
result.z = z;
return result;
}

template <typename T>
union Vector4 {
struct {
T x;
T y;
T z;
T w;
};
T vec[4];
};
template <typename T>
inline function Vector4<T> vec4(T x, T y, T z, T w) {
Vector4<T> result = {0};
result.x = x;
result.y = y;
result.z = z;
result.w = w;
return result;
}

// ### Lists ###
template <typename T>
struct list {
T* data;
size_t length;
size_t head;
};

#define PushList(arena, type, size) (list<type>{ PushArray(arena, type, size), size, 0 })
#define PushListZero(arena, type, size) (list<type>{ PushArrayZero(arena, type, size), size, 0 })
#define PushFullList(arena, type, size) (list<type>{ PushArray(arena, type, size), size, size })
#define PushFullListZero(arena, type, size) (list<type>{ PushArrayZero(arena, type, size), size, size })

template <typename T> T *appendList(list<T> *list, T element);
template <typename T> void zeroList(list<T> *list);
template <typename T> void zeroListFull(list<T> *list);
template <typename T> list<T> listSlice(list<T> l, size_t start, size_t stop = 0);

// ### Strings ###
struct string {
char *str;
size_t length;
};
#define STB_SPRINTF_DECORATE(name) stb_##name // define this before including if you want to change the names
#include "vendor/stb_sprintf.h"

#define strlit(lit) (string{(char *)(lit), sizeof(lit) - 1})
#define PushString(arena, length) (string{ (char *)pushSize(arena, length), (length) })
#define PushStringFill(arena, length, characterByte) (string{ (char *)pushSizeFill(arena, length, characterByte), (length) })
string operator""_s(const char *cstrLiteral, size_t length);

// C Strings
const char *cstring(Arena *arena, list<char> buf);
const char *cstring(Arena *arena, string str);
size_t calcStringLen(const char *str);
string strFromCString(Arena *arena, const char *str);

bool strEql(string s1, string s2);
bool strStartsWith(string str, string testStr);
bool stringContains(string str, char c);

string strReverse(Arena *arena, string str);
string strSlice(string str, size_t start, size_t stop = 0);
string strSlice(char *data, size_t start, size_t stop = 0);
list<string> strSplit(Arena *arena, string splitStr, string inputStr);
string strPrintfv(Arena *arena, const char *fmt, va_list args);
string strPrintf(Arena *arena, const char *fmt, ...);

struct ParsePositiveIntResult { uint8 result; bool valid; };
ParsePositiveIntResult parsePositiveInt(string str, size_t *lengthPointer);
struct ParsePositiveReal32Result { real32 result; bool valid; };
ParsePositiveReal32Result parsePositiveReal32(Arena *arena, string str, size_t *lengthPointer);

inline function bool isNumeric(char c);

// ### Cmdline ###
list<string> getArgs(Arena *arena, int argc, char **argv);

// ### Time ###
typedef uint64 UnixTimestamp;
typedef tm Timestamp;

UnixTimestamp getSystemUnixTime();
Timestamp timestampFromUnixTime(UnixTimestamp *unixTimestamp);
string formatTimeHms(Arena *arena, UnixTimestamp time);
string formatTimeHms(Arena *arena, Timestamp *time);
string formatTimeYmd(Arena *arena, UnixTimestamp time);
string formatTimeYmd(Arena *arena, Timestamp *time);

// ### Linked Lists ###
// TODO(djledda): implement basic linked lists (based on arenas?)

// ### Logging ###
enum LogTarget {
LogTarget_stdout,
LogTarget_stdin,
LogTarget_stderr,
LogTarget_count,
};

#define ANSI_INSTRUCTION_FROM_ENUM(ansiCodeEnum) ANSI_INSTRUCTION(ansiCodeEnum)
#define ANSI_INSTRUCTION(ansiCode) "\u001b[" #ansiCode "m"
#define ANSI_INSTRUCTION_STR(ansiCodeStr) "\u001b[" ansiCodeStr "m"
#define ANSI_RESET ANSI_INSTRUCTION(0)

#define ANSI_fg_black 30
#define ANSI_fg_red 31
#define ANSI_fg_green 32
#define ANSI_fg_yellow 33
#define ANSI_fg_blue 34
#define ANSI_fg_magenta 35
#define ANSI_fg_cyan 36
#define ANSI_fg_white 37

#define ANSI_fg_bblack 90
#define ANSI_fg_bred 91
#define ANSI_fg_bgreen 92
#define ANSI_fg_byellow 93
#define ANSI_fg_bblue 94
#define ANSI_fg_bmagenta 95
#define ANSI_fg_bcyan 96
#define ANSI_fg_bwhite 97

#define ANSI_bg_black 40
#define ANSI_bg_red 41
#define ANSI_bg_green 42
#define ANSI_bg_yellow 43
#define ANSI_bg_blue 44
#define ANSI_bg_magenta 45
#define ANSI_bg_cyan 46
#define ANSI_bg_white 47

#define ANSI_bg_bblack 100
#define ANSI_bg_bred 101
#define ANSI_bg_bgreen 102
#define ANSI_bg_byellow 103
#define ANSI_bg_bblue 104
#define ANSI_bg_bmagenta 105
#define ANSI_bg_bcyan 106
#define ANSI_bg_bwhite 107

#define COLOR_TEXT(text, foregroundcolor) ANSI_INSTRUCTION_FROM_ENUM(foregroundcolor) text ANSI_RESET
#define COLOR_TEXT_BG(text, backgroundcolor) ANSI_INSTRUCTION_FROM_ENUM(backgroundcolor) text ANSI_RESET
#define COLOR_TEXT_FG_BG(text, foregroundcolor, backgroundcolor) ANSI_INSTRUCTION_FROM_ENUM(foregroundcolor) ANSI_INSTRUCTION_FROM_ENUM(backgroundcolor) text ANSI_RESET
#define COLOR_TEXT_RGB(text, red, green, blue) ANSI_INSTRUCTION_STR("38;2;" #red ";" #green ";" #blue) text ANSI_RESET

void log(list<int> l, LogTarget target = LogTarget_stdout);
void log(list<string> l, LogTarget target = LogTarget_stdout);
void log(const char *fmt, ...);
void logError(const char *fmt, ...);

// ### Loops ###
#define EachIn(list, it) size_t it = 0; it < (list).head; it++
#define EachInReversed(list, it) size_t it = (list).head - 1; it >= 0 && it < (list).head; it--
#define EachInArray(arr, it) size_t it = 0; it < ArrayCount(arr); ++it

// ### Misc ###
int intCompare(const void *a, const void *b);

#endif

+ 0
- 12
djstdlib/os.cpp Ver ficheiro

@@ -1,12 +0,0 @@
#ifndef OS_CPP
#define OS_CPP

#if OS_WINDOWS
#include "os_win32.cpp"
#elif OS_LINUX
#include "os_linux.cpp"
#else
#error Development environment not supported.
#endif

#endif

+ 0
- 20
djstdlib/os.h Ver ficheiro

@@ -1,20 +0,0 @@
#ifndef OS_H
#define OS_H

#include "core.h"

// ### Memory ###
void *os_alloc(size_t capacity);
void os_reserve(void *ptr);
void os_decommit(void *ptr);
void os_free(void *ptr, size_t freeSize);

// ### File IO ###
string os_readEntireFile(Arena *arena, string filename);
bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, size_t contentsLength);
bool os_fileAppend(Arena *arena, string filename, const byte *contents, size_t contentsLength);

// ### Standard IO ###
void os_log(LogTarget target, const char *fmt, va_list argList);

#endif

+ 0
- 98
djstdlib/os_linux.cpp Ver ficheiro

@@ -1,98 +0,0 @@
#ifndef OS_IMPL_LINUX_CPP
#define OS_IMPL_LINUX_CPP

#include "os.h"

#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>

void *os_alloc(size_t capacity) {
return mmap(0, capacity, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
}

void os_commit(void *ptr) {
}

void os_decommit(void *ptr) {
}

void os_free(void *ptr, size_t size) {
int err = munmap(ptr, size);
Assert(err != -1);
}

string os_readEntireFile(Arena *arena, string filename) {
Scratch temp = scratchStart(&arena, 1);

FILE *input = fopen(cstring(temp.arena, filename), "r");
string readBuffer;
if (input) {
struct stat st;
stat((char *)filename.str, &st);
size_t fsize = st.st_size;
readBuffer = PushString(arena, fsize);
fread(readBuffer.str, sizeof(byte), readBuffer.length, input);
fclose(input);
} else {
readBuffer = PushString(arena, 0);
}

scratchEnd(temp);
return readBuffer;
}

bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, size_t contentsLength) {
Scratch temp = scratchStart(&arena, 1);

bool result = false;
FILE *output = fopen(cstring(temp.arena, filename), "w");
if (output) {
fwrite(contents, sizeof(byte), contentsLength, output);
fclose(output);
result = true;
}

scratchEnd(temp);
return result;
}

bool os_fileAppend(Arena *arena, string filename, const byte *contents, size_t contentsLength) {
Scratch temp = scratchStart(&arena, 1);

bool result = false;
FILE *output = fopen(cstring(temp.arena, filename), "a");
if (output) {
fwrite(contents, sizeof(byte), contentsLength, output);
fclose(output);
result = true;
}

scratchEnd(temp);
return result;
}

void os_log(LogTarget target, const char *fmt, va_list argList) {
Scratch temp = scratchStart(0, 0);

string result = strPrintfv(temp.arena, fmt, argList);
// TODO(djledda): finish implementation without cstdlib
switch (target) {
case LogTarget_stdin:
write(0, (const void *)result.str, result.length);
break;
case LogTarget_stderr:
fflush(stderr);
write(2, (const void *)result.str, result.length);
break;
case LogTarget_stdout:
default:
fflush(stdout);
write(1, (const void *)result.str, result.length);
break;
}

scratchEnd(temp);
}

#endif

+ 0
- 92
djstdlib/os_win32.cpp Ver ficheiro

@@ -1,92 +0,0 @@
#ifndef OS_IMPL_WIN32_CPP
#define OS_IMPL_WIN32_CPP

#include "Windows.h"
#include "os.h"

void *os_alloc(size_t commitSize) {
return VirtualAlloc(NULL, commitSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
}

void os_reserve(void *ptr) {
}

void os_decommit(void *ptr) {
}

void os_free(void *ptr, size_t size) {
VirtualFree(ptr, NULL, MEM_RELEASE);
}

string os_readEntireFile(Arena *arena, string filename) {
string result = {0};
HANDLE fileHandle = CreateFileA(cstring(arena, filename), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
if (fileHandle != INVALID_HANDLE_VALUE) {
LARGE_INTEGER fileSize;
if (GetFileSizeEx(fileHandle, &fileSize)) {
string readfile = PushString(arena, (size_t)fileSize.QuadPart);
if (readfile.str) {
DWORD bytesRead;
if (ReadFile(fileHandle, readfile.str, (DWORD)fileSize.QuadPart, &bytesRead, NULL) && (fileSize.QuadPart == bytesRead)) {
result = readfile;
}
}
}
CloseHandle(fileHandle);
}
return result;
}

bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, size_t contentsLength) {
bool result = false;
HANDLE fileHandle = CreateFileA(cstring(arena, filename), GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, NULL, NULL);
if (fileHandle != INVALID_HANDLE_VALUE) {
DWORD bytesWritten;
if (WriteFile(fileHandle, contents, (DWORD)contentsLength, &bytesWritten, NULL)) {
// file written successfully
result = bytesWritten == contentsLength;
}
CloseHandle(fileHandle);
}
return result;
}

bool os_fileAppend(Arena *arena, string filename, const byte *contents, size_t contentsLength) {
bool result = false;
HANDLE fileHandle = CreateFileA(cstring(arena, filename), FILE_APPEND_DATA | FILE_GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (fileHandle != INVALID_HANDLE_VALUE) {
DWORD bytesWritten;
DWORD position = SetFilePointer(fileHandle, 0, NULL, FILE_END);
if (WriteFile(fileHandle, contents, (DWORD)contentsLength, &bytesWritten, NULL)) {
// file written successfully
result = bytesWritten == contentsLength;
}
CloseHandle(fileHandle);
}
return result;
}

function void os_log(LogTarget target, const char *fmt, va_list argList) {
Scratch scratch = scratchStart(0, 0);
string result = strPrintfv(scratch.arena, fmt, argList);
DWORD done;
HANDLE stdHandle;
switch (target) {
case LogTarget_stdin:
stdHandle = GetStdHandle(STD_INPUT_HANDLE);
break;
case LogTarget_stdout:
stdHandle = GetStdHandle(STD_ERROR_HANDLE);
break;
case LogTarget_stderr:
stdHandle = GetStdHandle(STD_OUTPUT_HANDLE);
break;
default:
stdHandle = GetStdHandle(STD_OUTPUT_HANDLE);
break;
}
WriteFile(stdHandle, result.str, (DWORD)result.length, &done, 0);
scratchEnd(scratch);
}

#endif

+ 0
- 1923
djstdlib/vendor/stb_sprintf.h
A apresentação das diferenças no ficheiro foi suprimida por ser demasiado grande
Ver ficheiro


Escrever Pré-visualizar
Carregando…
Cancelar
Guardar