ed/C_Intro
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

progress

Browse Source
This commit is contained in:
Edward R. Gonzalez 2025-05-04 11:24:16 -04:00
parent 673eb4d056
commit 42aed25b51
2 changed files with 91 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
build.ps1
View File

@ -107,8 +107,8 @@ $compiler_args += $flag_compile, $unit
$compiler_args | ForEach-Object { Write-Host $_ }
write-host
# $compiler_args += ( $flag_define + "DEMO_STR_SLICE" )
# $compiler_args += ( $flag_define + "DEMO_STR_SLICE" )
# $compiler_args += ( $flag_define + 'DEMO_STR_SLICE' )
# $compiler_args += ( $flag_define + 'DEMO__FILE_READ_CONTENTS_V1' )
# Compile the unit
& $compiler $compiler_args

100
demo.str_cache.c
View File

@ -9,8 +9,9 @@ Because of this, definitions will be kept on a need-to-have basis to target only
We will not use nearly any libraries and will be targeting only Windows 11 x64 using MSVC.
Even so the constructs defined and their dependencies can be properly abstracted into a ergonomic library for multiple targets with enough time and pain.
AI prompting will be used as a search engine I'll be provding the prompts used to gather specific vendor API information thats not-memorized.
If the prompt fails it will be noted and I'll fallback to traditional search engines to derive a reference to a specific vendor API document.
Definitions are defined linearly on the file on-demand as needed. Since the file is to be read linearly.
This will cause non-categorical organization so it will be more difficult to sift through if you wanted
to see definitions related to a sepecific kind of data or operation (strings, memory, etc).
*/
#if 0
int main()
@ -82,8 +83,10 @@ typedef ptrdiff_t SSIZE;
// Functional style cast
#define cast(type, data) ((type)(data))
#define nullptr cast(void*, 0)
// Enforces size querying uses SSIZE type.
#define size_of(data) cast(SSIZE, data)
#define size_of(data) cast(SSIZE, sizeof(data))
/*
The first construct we'll utilize is a String Slice.
@ -102,7 +105,7 @@ struct Str8 {
// For now this string can visualized using a debugger.
// #define DEMO__STR_SLICE
#ifdef DEMO__STR_SLICE
#ifdef DEMO__STR_SLICE
int main()
{
Str8 first = lit("Our first string as a slice");
@ -126,17 +129,20 @@ It will return a result in a composite struct: FileOpResult; which may be expand
typedef struct FileOpResult FileOpResult;
typedef struct Opts__read_file_contents Opts__read_file_contents;
void file__read_contents(FileOpResult* result, Str8 path, Opts__read_file_contents* opts);
FileOpResult file_read_contents ( Str8 path, Opts__read_file_contents* opts);
void api_file_read_contents(FileOpResult* result, Str8 path, Opts__read_file_contents* opts);
FileOpResult file__read_contents ( Str8 path, Opts__read_file_contents* opts);
#define file_read_contents(path, opts) file__read_contents(path, & (Opts__read_file_contents){0} )
/*
The above is a pattern that can be provided so that whether or not the result is formatted and provided to the user via the stack is entirely optional.
It also allows for default parameters to be defined conviently.
*/
// Now for our "Version 1"
#define DEMO__FILE_READ_CONTENTS_V1
#ifdef DEMO__FILE_READ_CONTENTS_V1
#ifdef DEMO__FILE_READ_CONTENTS_V1
/*
The file contents will be returned in bytes.
@ -171,11 +177,28 @@ struct Opts__read_file_contents
// We'll utilize the ReadFile procedure within the WinAPI: https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-readfile
#include "fileapi.h"
#if 0
BOOL ReadFile(
[in] HANDLE hFile,
[out] LPVOID lpBuffer,
[in] DWORD nNumberOfBytesToRead,
[out, optional] LPDWORD lpNumberOfBytesRead,
[in, out, optional] LPOVERLAPPED lpOverlapped
);
// In order to read a file we need a handle to a valid filesystem entity to read from: https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea
HANDLE CreateFileA(
[in] LPCSTR lpFileName,
[in] DWORD dwDesiredAccess,
[in] DWORD dwShareMode,
[in, optional] LPSECURITY_ATTRIBUTES lpSecurityAttributes,
[in] DWORD dwCreationDisposition,
[in] DWORD dwFlagsAndAttributes,
[in, optional] HANDLE hTemplateFile
);
#endif
#endif DEMO__FILE_READ_CONTENTS_V1
// We need to covert our string slice to a c-string for CreateFileA's path input.
#define KILOBTYES(n) (cast(SSIZE, n) << 10)
#define MEGABYTES(n) (cast(SSIZE, n) << 20)
@ -189,5 +212,60 @@ They will having the following format:
typedef U8 FMem_<size>KB [ <U8 amount> ];
*/
typedef U8 FMem_1KB [ KILOBTYES(1) ];
typedef U8 FMem_16KB [ KILOBTYES(16) ];
#define typeof __typeof__
#define fmem_slice(mem) (SliceMem) { mem, size_of(mem) }
// We'll be using an intrinsic for copying memory:
void* memory_copy(void* dest, const void* src, size_t count)
{
if (dest == NULL || src == NULL || count == 0) {
return NULL;
}
__movsb((unsigned char*)dest, (const unsigned char*)src, count);
return dest;
}
// Assumes memory is zeroed.
char const* str8_to_cstr_capped(Str8 content, SliceMem mem)
{
assert(mem.len >= content.len);
memory_copy(mem.ptr, content.ptr, content.ptr);
return mem.ptr;
}
void api_file_read_contents(FileOpResult* result, Str8 path, Opts__read_file_contents* opts)
{
FMem_16KB scratch = {0};
char const* path_cstr = str8_to_cstr_capped(path, fmem_slice(scratch) );
HANDLE id_file = CreateFileA(
path_cstr,
);
// BOOL op_result = ReadFile(
// id_file,
// buffer,
// to_read,
// read_amount,
// nullptr
// );
return
/*
TODO(Ed): You are here
*/
}
#endif DEMO__FILE_READ_CONTENTS_V1
// Version agnostic code:
inline
FileOpResult file__read_contents(Str8 path, Opts__read_file_contents* opts) {
FileOpResult result;
api_file_read_contents(& result, path, opts);
return result;
}