From c5585bbb0c802cde1ece63fffef03ad9f13462e1 Mon Sep 17 00:00:00 2001 From: timerix Date: Thu, 8 Jun 2023 15:15:38 +0600 Subject: [PATCH] refactoring --- .gitignore | 4 + kerep.sln | 62 +-- kerep.vcxproj | 592 ++++++++++++------------- src/Array/Array.c | 27 -- src/Array/Array.h | 32 -- src/Array/Array_declare.h | 39 -- src/Array/Array_define.h | 14 - src/Array/README.md | 2 - src/Autoarr/Autoarr.h | 2 +- src/Autoarr/Autoarr_KVPair_exported.c | 6 +- src/Autoarr/Autoarr_Unitype_exported.c | 6 +- src/Autoarr/Autoarr_declare.h | 10 +- src/Autoarr/Autoarr_define.h | 18 +- src/DtsodParser/DtsodV24.c | 6 +- src/DtsodParser/DtsodV24.h | 4 +- src/DtsodParser/DtsodV24_deserialize.c | 68 ++- src/DtsodParser/DtsodV24_exported.c | 12 +- src/DtsodParser/DtsodV24_serialize.c | 12 +- src/Filesystem/dir.c | 13 +- src/Filesystem/dir.h | 2 +- src/Filesystem/file.c | 15 +- src/Filesystem/file.h | 17 +- src/Filesystem/io_includes.h | 2 +- src/Filesystem/path.c | 31 +- src/Filesystem/path.h | 16 +- src/HashFunctions/hash.c | 84 ++-- src/HashFunctions/hash.h | 2 +- src/Hashtable/Hashtable.c | 14 +- src/Hashtable/Hashtable.h | 8 +- src/Hashtable/KeyValuePair.c | 8 +- src/Hashtable/KeyValuePair.h | 6 +- src/LinkedList/LinkedList.c | 2 +- src/LinkedList/LinkedList.h | 2 +- src/LinkedList/LinkedList_declare.h | 2 +- src/LinkedList/LinkedList_define.h | 20 +- src/SearchTree/SearchTree.c | 16 +- src/SearchTree/SearchTree.h | 6 +- src/SearchTree/SearchTree.md | 2 +- src/String/StringBuilder.c | 31 +- src/String/StringBuilder.h | 6 +- src/String/string.c | 5 +- src/String/string.h | 4 +- src/base/base.h | 2 +- src/base/cptr.c | 30 +- src/base/cptr.h | 29 +- src/base/errors.c | 14 +- src/base/errors.h | 4 +- src/base/memory/CstdAllocator.c | 8 +- src/base/memory/LinearAllocator.c | 4 +- src/base/memory/StackingAllocator.c | 4 +- src/base/memory/allocator_base.h | 34 ++ src/base/memory/allocators.c | 2 +- src/base/memory/allocators.h | 29 +- src/base/memory/allocators_internal.h | 2 +- src/base/optime.h | 4 +- src/base/std.h | 4 +- src/base/type_system/base_toString.c | 104 ++--- src/base/type_system/base_toString.h | 39 +- src/base/type_system/init.c | 25 +- src/base/type_system/init.h | 2 +- src/base/type_system/ktDescriptor.h | 5 +- src/base/type_system/kt_functions.c | 28 +- src/base/type_system/kt_functions.h | 6 +- src/base/type_system/ktid.h | 2 +- src/base/type_system/unitype.c | 45 +- src/base/type_system/unitype.h | 9 +- src/kprint/kprint.c | 53 ++- src/kprint/kprint.h | 20 +- src/kprint/kprint_colors.h | 12 +- src/kprint/kprint_format.h | 4 +- src/kprint/kprintf.c | 23 +- src/kprint/kprintf.h | 2 +- src/random/xoshiro-xoroshiro.md | 24 - tests/main.cpp | 2 +- tests/test_allocators.c | 8 +- tests/test_autoarr-vs-vector.cpp | 2 +- tests/test_autoarr.c | 2 +- tests/test_cptr.c | 2 +- tests/test_dtsod.c | 6 +- tests/test_hash_functions.c | 4 +- tests/test_hashtable.c | 45 +- tests/test_marshalling.c | 7 +- tests/test_rng_algorithms.c | 70 ++- tests/test_safethrow.c | 4 +- tests/test_searchtree.c | 8 +- tests/test_string.c | 2 +- tests/test_type_system.c | 2 +- tests/tests.h | 26 +- 88 files changed, 922 insertions(+), 1071 deletions(-) delete mode 100644 src/Array/Array.c delete mode 100644 src/Array/Array.h delete mode 100644 src/Array/Array_declare.h delete mode 100644 src/Array/Array_define.h delete mode 100644 src/Array/README.md create mode 100644 src/base/memory/allocator_base.h delete mode 100644 src/random/xoshiro-xoroshiro.md diff --git a/.gitignore b/.gitignore index a48562e..fe1fafe 100644 --- a/.gitignore +++ b/.gitignore @@ -4,6 +4,10 @@ obj/ # user files .old*/ +[Tt]mp/ +[Tt]emp/ +.[Tt]mp/ +.[Tt]emp/ .vs/ .vshistory/ .editorconfig diff --git a/kerep.sln b/kerep.sln index 8ecc4f3..f40d538 100644 --- a/kerep.sln +++ b/kerep.sln @@ -1,31 +1,31 @@ - -Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio Version 17 -VisualStudioVersion = 17.2.32317.152 -MinimumVisualStudioVersion = 10.0.40219.1 -Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "kerep", "kerep.vcxproj", "{52F0BD29-A3CB-47CE-B25D-CEAF5DFB2D73}" -EndProject -Global - GlobalSection(SolutionConfigurationPlatforms) = preSolution - Debug|x64 = Debug|x64 - Debug|x86 = Debug|x86 - Release|x64 = Release|x64 - Release|x86 = Release|x86 - EndGlobalSection - GlobalSection(ProjectConfigurationPlatforms) = postSolution - {52F0BD29-A3CB-47CE-B25D-CEAF5DFB2D73}.Debug|x64.ActiveCfg = Debug|x64 - {52F0BD29-A3CB-47CE-B25D-CEAF5DFB2D73}.Debug|x64.Build.0 = Debug|x64 - {52F0BD29-A3CB-47CE-B25D-CEAF5DFB2D73}.Debug|x86.ActiveCfg = Debug|Win32 - {52F0BD29-A3CB-47CE-B25D-CEAF5DFB2D73}.Debug|x86.Build.0 = Debug|Win32 - {52F0BD29-A3CB-47CE-B25D-CEAF5DFB2D73}.Release|x64.ActiveCfg = Release|x64 - {52F0BD29-A3CB-47CE-B25D-CEAF5DFB2D73}.Release|x64.Build.0 = Release|x64 - {52F0BD29-A3CB-47CE-B25D-CEAF5DFB2D73}.Release|x86.ActiveCfg = Release|Win32 - {52F0BD29-A3CB-47CE-B25D-CEAF5DFB2D73}.Release|x86.Build.0 = Release|Win32 - EndGlobalSection - GlobalSection(SolutionProperties) = preSolution - HideSolutionNode = FALSE - EndGlobalSection - GlobalSection(ExtensibilityGlobals) = postSolution - SolutionGuid = {22F8C351-9A96-4F37-94E6-37E6AB5BA058} - EndGlobalSection -EndGlobal + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.2.32317.152 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "kerep", "kerep.vcxproj", "{52F0BD29-A3CB-47CE-B25D-CEAF5DFB2D73}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {52F0BD29-A3CB-47CE-B25D-CEAF5DFB2D73}.Debug|x64.ActiveCfg = Debug|x64 + {52F0BD29-A3CB-47CE-B25D-CEAF5DFB2D73}.Debug|x64.Build.0 = Debug|x64 + {52F0BD29-A3CB-47CE-B25D-CEAF5DFB2D73}.Debug|x86.ActiveCfg = Debug|Win32 + {52F0BD29-A3CB-47CE-B25D-CEAF5DFB2D73}.Debug|x86.Build.0 = Debug|Win32 + {52F0BD29-A3CB-47CE-B25D-CEAF5DFB2D73}.Release|x64.ActiveCfg = Release|x64 + {52F0BD29-A3CB-47CE-B25D-CEAF5DFB2D73}.Release|x64.Build.0 = Release|x64 + {52F0BD29-A3CB-47CE-B25D-CEAF5DFB2D73}.Release|x86.ActiveCfg = Release|Win32 + {52F0BD29-A3CB-47CE-B25D-CEAF5DFB2D73}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {22F8C351-9A96-4F37-94E6-37E6AB5BA058} + EndGlobalSection +EndGlobal \ No newline at end of file diff --git a/kerep.vcxproj b/kerep.vcxproj index 2a8ffb6..ca20c64 100644 --- a/kerep.vcxproj +++ b/kerep.vcxproj @@ -1,297 +1,297 @@ - - - - - Debug - Win32 - - - Release - Win32 - - - Debug - x64 - - - Release - x64 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 16.0 - Win32Proj - {52f0bd29-a3cb-47ce-b25d-ceaf5dfb2d73} - kerep - 10.0 - - - - DynamicLibrary - true - ClangCL - MultiByte - false - - - DynamicLibrary - false - ClangCL - true - MultiByte - false - - - DynamicLibrary - true - ClangCL - MultiByte - false - - - DynamicLibrary - false - ClangCL - true - MultiByte - false - - - - - - - - - - - - - - - - - - - - - bin\$(Configuration)-$(Platform)\ - obj\$(Configuration)-$(Platform)\ - true - false - - - bin\x86\ - obj\x86\ - true - false - - - true - bin\$(Configuration)-$(Platform)\ - obj\$(Configuration)-$(Platform)\ - false - - - true - bin\x64\ - obj\x64\ - false - - - - TurnOffAllWarnings - true - WIN32;_DEBUG;KEREP_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) - true - NotUsing - - - stdc17 - Speed - - /Zc:twoPhase- /MP -fms-compatibility-version=14 -Wno-clang-analyzer-valist.Uninitialized %(AdditionalOptions) - Default - stdcpp17 - None - Disabled - - - Windows - true - false - - - - - TurnOffAllWarnings - true - true - true - WIN32;NDEBUG;KEREP_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) - true - NotUsing - - - stdc17 - Speed - - /Zc:twoPhase- /MP -fms-compatibility-version=14 -Wno-clang-analyzer-valist.Uninitialized %(AdditionalOptions) - MultiThreadedDLL - Default - stdcpp17 - None - - - Windows - true - true - true - false - - - - - TurnOffAllWarnings - true - _DEBUG;KEREP_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) - true - NotUsing - - - stdc17 - Speed - - /Zc:twoPhase- /MP -fms-compatibility-version=14 -Wno-clang-analyzer-valist.Uninitialized %(AdditionalOptions) - Default - stdcpp17 - None - true - true - - - Windows - true - false - - - - - TurnOffAllWarnings - true - true - true - NDEBUG;KEREP_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) - true - NotUsing - - - stdc17 - Speed - - /Zc:twoPhase- /MP -fms-compatibility-version=14 -Wno-clang-analyzer-valist.Uninitialized %(AdditionalOptions) - MultiThreadedDLL - Default - stdcpp17 - None - - - Windows - true - true - true - false - - - - - + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 16.0 + Win32Proj + {52f0bd29-a3cb-47ce-b25d-ceaf5dfb2d73} + kerep + 10.0 + + + + DynamicLibrary + true + ClangCL + MultiByte + false + + + DynamicLibrary + false + ClangCL + true + MultiByte + false + + + DynamicLibrary + true + ClangCL + MultiByte + false + + + DynamicLibrary + false + ClangCL + true + MultiByte + false + + + + + + + + + + + + + + + + + + + + + bin\$(Configuration)-$(Platform)\ + obj\$(Configuration)-$(Platform)\ + true + false + + + bin\x86\ + obj\x86\ + true + false + + + true + bin\$(Configuration)-$(Platform)\ + obj\$(Configuration)-$(Platform)\ + false + + + true + bin\x64\ + obj\x64\ + false + + + + TurnOffAllWarnings + true + WIN32;_DEBUG;KEREP_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + NotUsing + + + stdc17 + Speed + + /Zc:twoPhase- /MP -fms-compatibility-version=14 -Wno-clang-analyzer-valist.Uninitialized %(AdditionalOptions) + Default + stdcpp17 + None + Disabled + + + Windows + true + false + + + + + TurnOffAllWarnings + true + true + true + WIN32;NDEBUG;KEREP_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + NotUsing + + + stdc17 + Speed + + /Zc:twoPhase- /MP -fms-compatibility-version=14 -Wno-clang-analyzer-valist.Uninitialized %(AdditionalOptions) + MultiThreadedDLL + Default + stdcpp17 + None + + + Windows + true + true + true + false + + + + + TurnOffAllWarnings + true + _DEBUG;KEREP_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + NotUsing + + + stdc17 + Speed + + /Zc:twoPhase- /MP -fms-compatibility-version=14 -Wno-clang-analyzer-valist.Uninitialized %(AdditionalOptions) + Default + stdcpp17 + None + true + true + + + Windows + true + false + + + + + TurnOffAllWarnings + true + true + true + NDEBUG;KEREP_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + NotUsing + + + stdc17 + Speed + + /Zc:twoPhase- /MP -fms-compatibility-version=14 -Wno-clang-analyzer-valist.Uninitialized %(AdditionalOptions) + MultiThreadedDLL + Default + stdcpp17 + None + + + Windows + true + true + true + false + + + + + \ No newline at end of file diff --git a/src/Array/Array.c b/src/Array/Array.c deleted file mode 100644 index 63d1ead..0000000 --- a/src/Array/Array.c +++ /dev/null @@ -1,27 +0,0 @@ -#include "Array.h" - -Array_define(char) -Array_define(bool) -Array_define(f32) -Array_define(f64) -Array_define(i8) -Array_define(u8) -Array_define(i16) -Array_define(u16) -Array_define(i32) -Array_define(u32) -Array_define(i64) -Array_define(u64) -Array_define(Pointer) - -Array_define(Unitype) - -void Array_Unitype_free_(Array_Unitype* array, bool freeMembers){ - if(freeMembers) for (u32 i=0; ilength; i++) - Unitype_free(array->values[i]); - if(array->allocatedOnHeap) - free(array->values); -} - -void __Array_Unitype_free_(void* ar) -{ Array_Unitype_free_(ar, true); } diff --git a/src/Array/Array.h b/src/Array/Array.h deleted file mode 100644 index 0f16588..0000000 --- a/src/Array/Array.h +++ /dev/null @@ -1,32 +0,0 @@ -#pragma once - -#if __cplusplus -extern "C" { -#endif - -#include "Array_declare.h" -#include "Array_define.h" - -Array_declare(char) -Array_declare(bool) -Array_declare(f32) -Array_declare(f64) -Array_declare(i8) -Array_declare(u8) -Array_declare(i16) -Array_declare(u16) -Array_declare(i32) -Array_declare(u32) -Array_declare(i64) -Array_declare(u64) -Array_declare(Pointer) - -Array_declare(Unitype) - -/// use this function instead of auto generated -void Array_Unitype_free_(Array_Unitype* array, bool freeMembers); -void __Array_Unitype_free_(void* ar); - -#if __cplusplus -} -#endif \ No newline at end of file diff --git a/src/Array/Array_declare.h b/src/Array/Array_declare.h deleted file mode 100644 index 0c18b52..0000000 --- a/src/Array/Array_declare.h +++ /dev/null @@ -1,39 +0,0 @@ -#pragma once - -#if __cplusplus -extern "C" { -#endif - -#include "../base/base.h" - -#define Array_declare(type) \ -STRUCT(Array_##type, \ - type* values; \ - u32 length; \ - bool allocatedOnHeap; \ -) \ -\ -static inline Array_##type Array_##type##_allocValues(u32 length){ \ - return (Array_##type) { \ - .values=(type*)malloc(sizeof(type)*length), \ - .length=length, \ - .allocatedOnHeap=true \ - }; \ -} \ -\ -static inline Array_##type Array_##type##_fromBuffer(type* buffer, u32 bufferLength, bool allocatedOnHeap){ \ - return (Array_##type) { \ - .values=buffer, \ - .length=bufferLength, \ - .allocatedOnHeap=allocatedOnHeap \ - }; \ -} \ -\ -static inline void Array_##type##_free(Array_##type* array){ \ - if(array->allocatedOnHeap) \ - free(array->values); \ -} - -#if __cplusplus -} -#endif \ No newline at end of file diff --git a/src/Array/Array_define.h b/src/Array/Array_define.h deleted file mode 100644 index f15533c..0000000 --- a/src/Array/Array_define.h +++ /dev/null @@ -1,14 +0,0 @@ -#pragma once - -#if __cplusplus -extern "C" { -#endif - -#include "../base/base.h" - -#define Array_define(type) \ -kt_define(Array_##type, (freeMembers_t)Array_##type##_free, NULL); - -#if __cplusplus -} -#endif \ No newline at end of file diff --git a/src/Array/README.md b/src/Array/README.md deleted file mode 100644 index 3027ac9..0000000 --- a/src/Array/README.md +++ /dev/null @@ -1,2 +0,0 @@ -# Array struct -This struct stores array pointer and length. If you want to use `Array` of some type, it should be declared in header file by macro `Array_declare` and defined in source file by `Array_define`. diff --git a/src/Autoarr/Autoarr.h b/src/Autoarr/Autoarr.h index cfc67d0..09249d3 100644 --- a/src/Autoarr/Autoarr.h +++ b/src/Autoarr/Autoarr.h @@ -40,4 +40,4 @@ Autoarr_declare(Unitype) #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/Autoarr/Autoarr_KVPair_exported.c b/src/Autoarr/Autoarr_KVPair_exported.c index f08122f..e9ccc2e 100644 --- a/src/Autoarr/Autoarr_KVPair_exported.c +++ b/src/Autoarr/Autoarr_KVPair_exported.c @@ -9,8 +9,8 @@ EXPORT void CALL kerep_Autoarr_KVPair_create(u16 max_chunks_count, u16 max_chunk *output=Autoarr_create(KVPair, max_chunks_count, max_chunk_length); } -EXPORT void CALL kerep_Autoarr_KVPair_free(Autoarr_KVPair* ar){ - Autoarr_free(ar, true); +EXPORT void CALL kerep_Autoarr_KVPair_destruct(Autoarr_KVPair* ar){ + Autoarr_destruct(ar, true); } EXPORT void CALL kerep_Autoarr_KVPair_get(Autoarr_KVPair* ar, u32 index, KVPair* output){ @@ -35,4 +35,4 @@ EXPORT void CALL kerep_Autoarr_KVPair_max_length(Autoarr_KVPair* ar, u32* output #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/Autoarr/Autoarr_Unitype_exported.c b/src/Autoarr/Autoarr_Unitype_exported.c index d4439c2..5ea7c12 100644 --- a/src/Autoarr/Autoarr_Unitype_exported.c +++ b/src/Autoarr/Autoarr_Unitype_exported.c @@ -8,8 +8,8 @@ EXPORT void CALL kerep_Autoarr_Unitype_create(u16 max_chunks_count, u16 max_chun *output=Autoarr_create(Unitype, max_chunks_count, max_chunk_length); } -EXPORT void CALL kerep_Autoarr_Unitype_free(Autoarr_Unitype* ar){ - Autoarr_free(ar, true); +EXPORT void CALL kerep_Autoarr_Unitype_destruct(Autoarr_Unitype* ar){ + Autoarr_destruct(ar, true); } EXPORT void CALL kerep_Autoarr_Unitype_get(Autoarr_Unitype* ar, u32 index, Unitype* output){ @@ -34,4 +34,4 @@ EXPORT void CALL kerep_Autoarr_Unitype_max_length(Autoarr_Unitype* ar, u32* outp #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/Autoarr/Autoarr_declare.h b/src/Autoarr/Autoarr_declare.h index 5f96b11..21725df 100644 --- a/src/Autoarr/Autoarr_declare.h +++ b/src/Autoarr/Autoarr_declare.h @@ -32,8 +32,8 @@ STRUCT(Autoarr_##type, \ ) \ \ Autoarr_##type* __Autoarr_##type##_create(u16 max_chunks_count, u16 max_chunk_length); \ -void __Autoarr_##type##_freeWithMembers(Autoarr_##type* ar, bool freePtr); \ -void ____Autoarr_##type##_freeWithMembers(void* ar); +void __Autoarr_##type##_destructWithMembers(Autoarr_##type* ar, bool freePtr); \ +void ____Autoarr_##type##_destructWithMembers(void* ar); #define Autoarr(type) Autoarr_##type @@ -47,9 +47,9 @@ void ____Autoarr_##type##_freeWithMembers(void* ar); autoarr->functions->getPtr(autoarr,index) #define Autoarr_set(autoarr, index, element) \ autoarr->functions->set(autoarr, index, element) -#define Autoarr_free(autoarr, freePtr) \ +#define Autoarr_destruct(autoarr, freePtr) \ autoarr->functions->freeWithMembers(autoarr, freePtr) -#define Autoarr_freeWithoutMembers(autoarr, freePtr) \ +#define Autoarr_destructWithoutMembers(autoarr, freePtr) \ autoarr->functions->freeWithoutMembers(autoarr, freePtr) #define Autoarr_toArray(autoarr) \ autoarr->functions->toArray(autoarr) @@ -71,4 +71,4 @@ void ____Autoarr_##type##_freeWithMembers(void* ar); #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/Autoarr/Autoarr_define.h b/src/Autoarr/Autoarr_define.h index 4e90fd5..91cbf3d 100644 --- a/src/Autoarr/Autoarr_define.h +++ b/src/Autoarr/Autoarr_define.h @@ -8,7 +8,7 @@ extern "C" { #define Autoarr_define(type, TYPE_IS_PTR) \ \ -kt_define(Autoarr_##type, ____Autoarr_##type##_freeWithMembers, NULL); \ +kt_define(Autoarr_##type, ____Autoarr_##type##_destructWithMembers, NULL); \ \ void __Autoarr_##type##_add(Autoarr_##type* ar, type element){ \ if(!ar->chunks){ \ @@ -41,14 +41,14 @@ void __Autoarr_##type##_set(Autoarr_##type* ar, u32 index, type element){ \ ar->chunks[index/ar->max_chunk_length][index%ar->max_chunk_length]=element; \ } \ \ -void __Autoarr_##type##_freeWithoutMembers(Autoarr_##type* ar, bool freePtr){ \ +void __Autoarr_##type##_destructWithoutMembers(Autoarr_##type* ar, bool freePtr){ \ for(u16 i=0; ichunks_count;i++) \ free(ar->chunks[i]); \ free(ar->chunks); \ if(freePtr) free(ar); \ } \ \ -void __Autoarr_##type##_freeWithMembers(Autoarr_##type* ar, bool freePtr){ \ +void __Autoarr_##type##_destructWithMembers(Autoarr_##type* ar, bool freePtr){ \ if(ktDescriptor_##type.freeMembers!=NULL) { \ Autoarr_foreach(ar, el, \ void* members_ptr=⪙ \ @@ -56,10 +56,10 @@ void __Autoarr_##type##_freeWithMembers(Autoarr_##type* ar, bool freePtr){ \ ktDescriptor_##type.freeMembers(members_ptr); \ ); \ } \ - __Autoarr_##type##_freeWithoutMembers(ar, freePtr);\ + __Autoarr_##type##_destructWithoutMembers(ar, freePtr); \ } \ -void ____Autoarr_##type##_freeWithMembers(void* ar){ \ - __Autoarr_##type##_freeWithMembers((Autoarr_##type*)ar, false); \ +void ____Autoarr_##type##_destructWithMembers(void* ar){ \ + __Autoarr_##type##_destructWithMembers((Autoarr_##type*)ar, false); \ } \ \ type* __Autoarr_##type##_toArray(Autoarr_##type* ar){ \ @@ -77,8 +77,8 @@ __Autoarr_##type##_functions_list_t __Autoarr_##type##_functions_list={ \ &__Autoarr_##type##_get, \ &__Autoarr_##type##_getPtr, \ &__Autoarr_##type##_set, \ - &__Autoarr_##type##_freeWithMembers, \ - &__Autoarr_##type##_freeWithoutMembers, \ + &__Autoarr_##type##_destructWithMembers, \ + &__Autoarr_##type##_destructWithoutMembers, \ &__Autoarr_##type##_toArray \ }; \ \ @@ -97,4 +97,4 @@ Autoarr_##type* __Autoarr_##type##_create(u16 max_chunks_count, u16 max_chunk_le #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/DtsodParser/DtsodV24.c b/src/DtsodParser/DtsodV24.c index 0a5170b..74b7e13 100644 --- a/src/DtsodParser/DtsodV24.c +++ b/src/DtsodParser/DtsodV24.c @@ -25,6 +25,6 @@ bool DtsodV24_remove(Hashtable* dtsod, char* key){ } // frees memory including memory of elements (hashtables, autoarrs, etc.) -void DtsodV24_free(Hashtable* dtsod){ - Hashtable_free(dtsod); -} \ No newline at end of file +void DtsodV24_destruct(Hashtable* dtsod){ + Hashtable_destruct(dtsod); +} diff --git a/src/DtsodParser/DtsodV24.h b/src/DtsodParser/DtsodV24.h index a49f07e..b31e8cc 100644 --- a/src/DtsodParser/DtsodV24.h +++ b/src/DtsodParser/DtsodV24.h @@ -25,8 +25,8 @@ bool DtsodV24_contains(Hashtable* dtsod, char* key); bool DtsodV24_remove(Hashtable* dtsod, char* key); // frees memory including memory of elements (hashtables, autoarrs, etc.) -void DtsodV24_free(Hashtable* dtsod); +void DtsodV24_destruct(Hashtable* dtsod); #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/DtsodParser/DtsodV24_deserialize.c b/src/DtsodParser/DtsodV24_deserialize.c index 57ac4d0..af2131f 100644 --- a/src/DtsodParser/DtsodV24_deserialize.c +++ b/src/DtsodParser/DtsodV24_deserialize.c @@ -44,16 +44,10 @@ Maybe ERROR_WRONGCHAR(const char c, char* _text, char* text_first, const char* s if(!_c) break; } char errmsg[1024]; - IFMSC( - sprintf_s(errmsg,1024, "unexpected <%c> at:\n" - " \"%s\"\n" - "\\___[%s:%d] %s()", - c,errBuf, srcfile,line,funcname), - sprintf(errmsg, "unexpected <%c> at:\n" - " \"%s\"\n" - " \\___[%s:%d] %s()", - c,errBuf, srcfile,line,funcname) - ); + sprintf_s(errmsg, sizeof(errmsg), "unexpected <%c> at:\n" + " \"%s\"\n" + "\\___[%s:%d] %s()", + c,errBuf, srcfile,line,funcname); safethrow(errmsg,;); } #define safethrow_wrongchar(C, freeMem) { freeMem; return ERROR_WRONGCHAR(C, text, shared->sh_text_first, __FILE__,__LINE__,__func__); } @@ -96,7 +90,7 @@ Maybe __ReadName(DeserializeSharedData* shared){ nameStr.ptr=text+1; // skips '\n' break; case '}': - if(!calledRecursively || nameStr.length!=0) + if(!calledRecursively || nameStr.length!=0) safethrow_wrongchar(c,;); return SUCCESS(UniHeapPtr(char,NULL)); case ':': @@ -131,7 +125,7 @@ Maybe __ReadString(DeserializeSharedData* shared){ if(c=='"') { if(prevIsBackslash) { // replacing <\"> with <"> - StringBuilder_rmchar(b); + StringBuilder_rmchar(b); StringBuilder_append_char(b,c); prevIsBackslash=false; } @@ -139,14 +133,14 @@ Maybe __ReadString(DeserializeSharedData* shared){ char* str=StringBuilder_build(b).ptr; return SUCCESS(UniHeapPtr(char,str)); } - } + } else { prevIsBackslash= c=='\\' && !prevIsBackslash; StringBuilder_append_char(b,c); } } - safethrow(ERR_ENDOFSTR, StringBuilder_free(b)); + safethrow(ERR_ENDOFSTR, StringBuilder_destruct(b)); } #define ReadString() __ReadString(shared) @@ -154,8 +148,8 @@ Maybe __ReadList(DeserializeSharedData* shared){ Autoarr(Unitype)* list=Autoarr_create(Unitype,ARR_BC,ARR_BL); bool readingList=true; while (true){ - try(ReadValue((&readingList)), m_val, Autoarr_free(list, true)) - Autoarr_add(list,m_val.value); + try(ReadValue((&readingList)), m_val, Autoarr_destruct(list, true)) + Autoarr_add(list,m_val.value); if (!readingList){ if(Unitype_isUniNull(m_val.value)) Autoarr_pop(list); @@ -192,10 +186,7 @@ Maybe __ParseValue(DeserializeSharedData* shared, string str){ char* _c=string_extract(str); if(sscanf(_c, IFWIN("%llu", "%lu"), &lu)!=1){ char err[64]; - IFMSC( - sprintf_s(err,64,"can't parse to int: <%s>",_c), - sprintf(err,"can't parse to int: <%s>",_c) - ); + sprintf_s(err, sizeof(err), "can't parse to int: <%s>", _c); safethrow(err,free(_c)); } free(_c); @@ -208,10 +199,7 @@ Maybe __ParseValue(DeserializeSharedData* shared, string str){ char* _c=string_extract(str); if(sscanf(_c, IFWIN("%lli", "%li"), &li)!=1){ char err[64]; - IFMSC( - sprintf_s(err,64,"can't parse to int: <%s>",_c), - sprintf(err,"can't parse to int: <%s>",_c) - ); + sprintf_s(err, sizeof(err),"can't parse to int: <%s>",_c); safethrow(err,free(_c)); } free(_c); @@ -239,53 +227,53 @@ Maybe __ReadValue(DeserializeSharedData* shared, bool* readingList){ spaceAfterVal=true; else valueStr.ptr++; break; - case '=': case ':': + case '=': case ':': case '}': case '$': case '\'': - safethrow_wrongchar(c,Unitype_free(value)); + safethrow_wrongchar(c,Unitype_destruct(&value)); case '#':; char _c=c; char* _text=text; try(SkipComment(),_,;); if(valueStr.length!=0){ text=_text; - safethrow_wrongchar(_c,Unitype_free(value)); + safethrow_wrongchar(_c,Unitype_destruct(&value)); } valueStr.ptr=text+1; // skips '\n' break; case '"': - if(valueStr.length!=0) safethrow_wrongchar(c,Unitype_free(value)); + if(valueStr.length!=0) safethrow_wrongchar(c,Unitype_destruct(&value)); try(ReadString(),maybeString,;) value=maybeString.value; break; case '{': - if(valueStr.length!=0) safethrow_wrongchar(c,Unitype_free(value)); - ++text; // skips '{' - try(__deserialize(&text,true), val,Unitype_free(value)) + if(valueStr.length!=0) safethrow_wrongchar(c,Unitype_destruct(&value)); + ++text; // skips '{' + try(__deserialize(&text,true), val,Unitype_destruct(&value)) value=val.value; break; case '[': - if(valueStr.length!=0) safethrow_wrongchar(c,Unitype_free(value)); - try(ReadList(),maybeList,Unitype_free(value)) + if(valueStr.length!=0) safethrow_wrongchar(c,Unitype_destruct(&value)); + try(ReadList(),maybeList,Unitype_destruct(&value)) value=maybeList.value; break; case ']': - if(!readingList) safethrow_wrongchar(c,Unitype_free(value)); + if(!readingList) safethrow_wrongchar(c,Unitype_destruct(&value)); *readingList=false; goto return_value; case ';': case ',': return_value: if(valueStr.length!=0){ - if(!Unitype_isUniNull(value)) - safethrow_wrongchar(c,Unitype_free(value)); + if(!Unitype_isUniNull(value)) + safethrow_wrongchar(c,Unitype_destruct(&value)); try(ParseValue(valueStr),maybeParsed,;) value=maybeParsed.value; } return SUCCESS(value); default: if(spaceAfterVal) - safethrow_wrongchar(c,Unitype_free(value)); + safethrow_wrongchar(c,Unitype_destruct(&value)); valueStr.length++; break; } @@ -306,12 +294,12 @@ Maybe __deserialize(char** _text, bool _calledRecursively) { text--; while(true){ - try(ReadName(), maybeName, Hashtable_free(dict)) - if(!maybeName.value.VoidPtr) // end of file or '}' in recursive call + try(ReadName(), maybeName, Hashtable_destruct(dict)) + if(!maybeName.value.VoidPtr) // end of file or '}' in recursive call goto END; char* nameCPtr=maybeName.value.VoidPtr; try(ReadValue(NULL), val, { - Hashtable_free(dict); + Hashtable_destruct(dict); free(nameCPtr); }) { if(partOfDollarList){ diff --git a/src/DtsodParser/DtsodV24_exported.c b/src/DtsodParser/DtsodV24_exported.c index 466e75a..1544d85 100644 --- a/src/DtsodParser/DtsodV24_exported.c +++ b/src/DtsodParser/DtsodV24_exported.c @@ -1,8 +1,8 @@ -// -// I planned to export functions from DtsodV24.h, +// +// I planned to export functions from DtsodV24.h, // but C# P/Invoke can't get returned values for some reason. // Following functions return values by pointer, which looks in C# like out parameter -// +// #if __cplusplus extern "C" { @@ -45,8 +45,8 @@ EXPORT void CALL kerep_DtsodV24_remove(Hashtable* dtsod, char* key, bool* output } // replaces value with UniNull if key exists in dtsod -EXPORT void CALL kerep_DtsodV24_free(Hashtable* dtsod){ - DtsodV24_free(dtsod); +EXPORT void CALL kerep_DtsodV24_destruct(Hashtable* dtsod){ + DtsodV24_destruct(dtsod); } EXPORT void CALL kerep_DtsodV24_height(Hashtable* dtsod, u16* heigth){ @@ -59,4 +59,4 @@ EXPORT void CALL kerep_DtsodV24_getrow(Hashtable* dtsod, u16 h, Autoarr_KVPair** #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/DtsodParser/DtsodV24_serialize.c b/src/DtsodParser/DtsodV24_serialize.c index 1c81feb..31c1a03 100644 --- a/src/DtsodParser/DtsodV24_serialize.c +++ b/src/DtsodParser/DtsodV24_serialize.c @@ -3,7 +3,7 @@ STRUCT(SerializeSharedData, - StringBuilder* sh_builder; + StringBuilder* sh_builder; u8 sh_tabs; ) #define b shared->sh_builder @@ -55,7 +55,7 @@ Maybe __AppendValue(SerializeSharedData* shared, Unitype u){ AppendTabs(); addc('['); tabs++; - Autoarr_foreach(((Autoarr_Unitype*)(u.VoidPtr)), e, + Autoarr_foreach(((Autoarr_Unitype*)(u.VoidPtr)), e, addc('\n'); AppendTabs(); try(AppendValue(e),__,;); @@ -75,7 +75,7 @@ Maybe __AppendValue(SerializeSharedData* shared, Unitype u){ else if(u.typeId==ktid_ptrName(Hashtable)){ // check hashtable is blank bool hashtableNotBlank=false; - Hashtable_foreach(((Hashtable*)u.VoidPtr), __, + Hashtable_foreach(((Hashtable*)u.VoidPtr), __, hashtableNotBlank=true; if(__.key) {} // weird way to disable warning break; @@ -96,7 +96,7 @@ Maybe __AppendValue(SerializeSharedData* shared, Unitype u){ } } else { - dbg((u.typeId)); + dbg((u.typeId)); safethrow(ERR_WRONGTYPE,;); } return MaybeNull; @@ -109,7 +109,7 @@ Maybe __serialize(StringBuilder* _b, u8 _tabs, Hashtable* dtsod){ }; SerializeSharedData* shared=&_shared; - Hashtable_foreach(dtsod, p, + Hashtable_foreach(dtsod, p, AppendTabs(); StringBuilder_append_cptr(b,p.key); addc(':'); @@ -124,7 +124,7 @@ Maybe __serialize(StringBuilder* _b, u8 _tabs, Hashtable* dtsod){ Maybe DtsodV24_serialize(Hashtable* dtsod){ StringBuilder* sb=StringBuilder_create(); - try(__serialize(sb,0,dtsod),__, StringBuilder_free(sb)); + try(__serialize(sb,0,dtsod),__, StringBuilder_destruct(sb)); char* str=StringBuilder_build(sb).ptr; return SUCCESS(UniHeapPtr(char, str)); } diff --git a/src/Filesystem/dir.c b/src/Filesystem/dir.c index 812c755..2531468 100644 --- a/src/Filesystem/dir.c +++ b/src/Filesystem/dir.c @@ -4,7 +4,7 @@ bool dir_exists(const char* path){ if(path[0]=='.'){ - if(path[1]==0 || (path[1]==path_sep && path[1]==0)) + if(path[1]==0 || (path[1]==path_sep && path[1]==0)) return true; // dir . or ./ always exists // else if(path[1]=='.' && path[2]==path_sep) //TODO path_resolve because windows doesnt recognize .\ pattern @@ -26,9 +26,10 @@ bool dir_exists(const char* path){ Maybe dir_create(const char* path){ if (dir_exists(path)) return MaybeNull; - char* parentDir=path_parentDir(path); + LinearAllocator _al; LinearAllocator_construct(&_al, 128); + allocator_ptr al=&_al.base; + char* parentDir=path_parentDir(al, path); dir_create(parentDir); - free(parentDir); #if KFS_USE_WINDOWS_H if(!CreateDirectory(path, NULL)) #else @@ -36,12 +37,10 @@ Maybe dir_create(const char* path){ #endif { char err[512]; - IFWIN( - sprintf_s(err, 512, "can't create dicectory <%s>", path), - sprintf(err, "can't create dicectory <%s>", path)); + sprintf_s(err, sizeof(err), "can't create dicectory <%s>", path); safethrow(err,;); } - + LinearAllocator_destruct(&_al); return MaybeNull; } diff --git a/src/Filesystem/dir.h b/src/Filesystem/dir.h index 3821229..9481662 100644 --- a/src/Filesystem/dir.h +++ b/src/Filesystem/dir.h @@ -25,4 +25,4 @@ Maybe dir_findDirs(const char* path, char* searchPattern, bool recursive); #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/Filesystem/file.c b/src/Filesystem/file.c index 5c38523..c079097 100644 --- a/src/Filesystem/file.c +++ b/src/Filesystem/file.c @@ -2,9 +2,9 @@ #include "../String/StringBuilder.h" #include "io_includes.h" -void __file_freeMembers(void* _f){ fclose((FileHandle)_f); } +void __file_destructMembers(void* _f){ fclose((FileHandle)_f); } -kt_define(FileHandle, __file_freeMembers, NULL) +kt_define(FileHandle, __file_destructMembers, NULL) bool file_exists(const char* path){ if(path[0]=='.'){ @@ -50,8 +50,11 @@ char* FileOpenMode_toStr(FileOpenMode m){ Maybe file_open(const char* path, FileOpenMode mode){ FileHandle file=fopen(path, FileOpenMode_toStr(mode)); + LinearAllocator _al; LinearAllocator_construct(&_al, 128); + allocator_ptr al=&_al.base; if(!file) - safethrow(cptr_concat("can't open file ", (char*)path),;); + safethrow(cptr_concat(al, "can't open file ", (char*)path),;); + LinearAllocator_destruct(&_al); return SUCCESS(UniHeapPtr(FileHandle,file)); } @@ -117,8 +120,8 @@ Maybe file_readAll(FileHandle file, char** allBytes){ while(true){ rezult=fgetc(file); if(rezult==EOF){ - if(ferror(file)) - safethrow(ERR_IO, StringBuilder_free(sb)); + if(ferror(file)) + safethrow(ERR_IO, StringBuilder_destruct(sb)); break; } buffer[i%sizeof(buffer)]=(char)rezult; @@ -132,7 +135,7 @@ Maybe file_readAll(FileHandle file, char** allBytes){ string str=StringBuilder_build(sb); *allBytes=str.ptr; // i dont know how can it happen, but if it will have, it will be very dangerous - if(i!=str.length) + if(i!=str.length) throw(ERR_UNEXPECTEDVAL); return SUCCESS(UniUInt64(i)); } diff --git a/src/Filesystem/file.h b/src/Filesystem/file.h index 412d218..44022e5 100644 --- a/src/Filesystem/file.h +++ b/src/Filesystem/file.h @@ -5,7 +5,6 @@ extern "C" { #endif #include "../base/base.h" -#include "../Array/Array.h" #include "../String/string.h" typedef FILE* FileHandle; @@ -17,15 +16,15 @@ bool file_exists(const char* path); Maybe file_delete(const char* path, bool recursive); PACKED_ENUM(FileOpenMode, - // open a file for reading - FileOpenMode_Read=1, + // open a file for reading + FileOpenMode_Read=1, // (re)create a file for writing - FileOpenMode_Write=2, - // opens file for writing additional data to the end / creates new file + FileOpenMode_Write=2, + // opens file for writing additional data to the end / creates new file FileOpenMode_Append=4, // (re)creates file for reading/writing - FileOpenMode_ReadWrite=FileOpenMode_Read|FileOpenMode_Write, - // opens file for readng/writing additional data to the end / creates new file + FileOpenMode_ReadWrite=FileOpenMode_Read|FileOpenMode_Write, + // opens file for readng/writing additional data to the end / creates new file FileOpenMode_ReadAppend=FileOpenMode_Read|FileOpenMode_Append ) @@ -67,10 +66,10 @@ Maybe file_readChar(FileHandle file); Maybe file_readBuffer(FileHandle file, char* buffer, u64 length); /// @brief reads all bytes from file -/// @param allBytes ptr to the file's content will be pushed there +/// @param allBytes ptr to the file's content will be pushed there /// @return Maybe total number of successfully read bytes Maybe file_readAll(FileHandle file, char** allBytes); #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/Filesystem/io_includes.h b/src/Filesystem/io_includes.h index 033adf6..9d43b8c 100644 --- a/src/Filesystem/io_includes.h +++ b/src/Filesystem/io_includes.h @@ -2,7 +2,7 @@ #if defined(_WIN64) || defined(_WIN32) #define KFS_USE_WINDOWS_H 1 -#else +#else #define KFS_USE_WINDOWS_H 0 #endif diff --git a/src/Filesystem/path.c b/src/Filesystem/path.c index dbccdda..b3e7557 100644 --- a/src/Filesystem/path.c +++ b/src/Filesystem/path.c @@ -1,8 +1,8 @@ #include "filesystem.h" -char* __path_concat(u32 n, ...){ - char** parts=(char**)malloc(n*sizeof(char*)); - u32* lengths=malloc(n*sizeof(u32)); +char* __path_concat(allocator_ptr al, u32 n, ...){ + char** parts=(char**)allocator_alloc(al, n*sizeof(char*)); + u32* lengths=allocator_alloc(al, n*sizeof(u32)); u32 totalLength=0; // reading args from va_list @@ -18,7 +18,7 @@ char* __path_concat(u32 n, ...){ va_end(vl); // allocating memory for output value - char* totality=malloc(totalLength+1); + char* totality=allocator_alloc(al, totalLength+1); const char* output=totality; totality[totalLength]=0; @@ -32,13 +32,13 @@ char* __path_concat(u32 n, ...){ } memcpy(totality, parts[k], lengths[k]); - free(parts); - free(lengths); + allocator_free(al, lengths); + allocator_free(al, parts); return output; } -char* path_fixSeparators(const char* path){ - char* pathCopy=cptr_copy(path); +char* path_fixSeparators(allocator_ptr al, const char* path){ + char* pathCopy=cptr_copy(al, path); char c; while((c=*pathCopy)){ if(c==path_notSep) @@ -49,13 +49,16 @@ char* path_fixSeparators(const char* path){ } Maybe path_throwIfEscapes(const char* path){ + LinearAllocator _al; LinearAllocator_construct(&_al, 128); + allocator_ptr al=&_al.base; if(cptr_contains(path,"..")) - safethrow(cptr_concat("path <",path,"> uses <..>, that's not allowed"),); + safethrow(cptr_concat(al, "path <",path,"> uses <..>, that's not allowed"),); + LinearAllocator_destruct(&_al); return MaybeNull; } -char* path_parentDir(char* dir){ - char* copy=cptr_copy(dir); +char* path_parentDir(allocator_ptr al, char* dir){ + char* copy=cptr_copy(al, dir); i32 length=cptr_length(copy); i32 i=cptr_lastIndexOfChar(copy,path_sep); if(i!=-1 && i==length-1){ @@ -63,8 +66,8 @@ char* path_parentDir(char* dir){ i=cptr_lastIndexOfChar(copy,path_sep); } if(i==-1){ - free(copy); - copy=malloc(2); + allocator_free(al, copy); + copy=allocator_alloc(al, 2); copy[0]='.'; copy[1]=0; } @@ -72,7 +75,7 @@ char* path_parentDir(char* dir){ } -char* path_basename(char* path, bool with_extension){ +char* path_basename(allocator_ptr al, char* path, bool with_extension){ i32 nameIndex=cptr_lastIndexOfChar(path, path_sep)+1; string rezult=string_fromCptr(path+nameIndex); if(!with_extension){ diff --git a/src/Filesystem/path.h b/src/Filesystem/path.h index 65e0f31..ce7f6e9 100644 --- a/src/Filesystem/path.h +++ b/src/Filesystem/path.h @@ -14,17 +14,17 @@ static const char path_sep='/'; static const char path_notSep='\\'; #endif -char* __path_concat(u32 n, ...); +char* __path_concat(allocator_ptr al, u32 n, ...); /// @brief merges path parts together and puts between them /// @return new cstr -#define path_concat(PATH_PARTS...) __path_concat(count_args(PATH_PARTS), PATH_PARTS) +#define path_concat(ALLOCATOR, PATH_PARTS...) __path_concat(ALLOCATOR, count_args(PATH_PARTS), PATH_PARTS) /// @brief fixes path separators /// @param cstr where can be -/// @return new cstr with correct separators -char* path_fixSeparators(const char* path); +/// @return new cstr with correct separators +char* path_fixSeparators(allocator_ptr al, const char* path); -#define path_resolve(PATH_PARTS...) path_fixSeparators(path_concat(PATH_PARTS)) +#define path_resolve(ALLOCATOR, PATH_PARTS...) path_fixSeparators(ALLOCATOR, path_concat(ALLOCATOR, PATH_PARTS)) /// @brief calls safethrow() if finds escape sequense in path /// @param path cstr where can be <..> @@ -32,11 +32,11 @@ char* path_fixSeparators(const char* path); Maybe path_throwIfEscapes(const char* path); ///@return path of parent dir -char* path_parentDir(char* path); +char* path_parentDir(allocator_ptr al, char* path); ///@return file name -char* path_basename(char* path, bool with_extension); +char* path_basename(allocator_ptr al, char* path, bool with_extension); #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/HashFunctions/hash.c b/src/HashFunctions/hash.c index 3f2761b..b137e64 100644 --- a/src/HashFunctions/hash.c +++ b/src/HashFunctions/hash.c @@ -9,68 +9,68 @@ u32 hash_sdbm32(u32 oldhash, void* buf, u32 len){ } static const u32 crc_32_tab[]={ - 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, - 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, + 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, + 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, - 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, - 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, + 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, + 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, - 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, - 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, + 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, + 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, - 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, - 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, + 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, + 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, - 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, - 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, + 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, + 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, - 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, - 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, + 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, + 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, - 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, - 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, + 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, + 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, - 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, - 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, + 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, + 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, - 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, - 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, + 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, + 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, - 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, - 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, + 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, + 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, - 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, - 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, + 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, + 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, - 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, - 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, + 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, + 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, - 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, - 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, + 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, + 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, - 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, - 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, + 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, + 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, - 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, - 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, + 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, + 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, - 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, - 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, + 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, + 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, - 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, - 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, + 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, + 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, - 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, - 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, + 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, + 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, - 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, - 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, + 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, + 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, - 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, - 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, + 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, + 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, - 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, - 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, + 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, + 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d }; diff --git a/src/HashFunctions/hash.h b/src/HashFunctions/hash.h index c4b71ef..5b80c9d 100644 --- a/src/HashFunctions/hash.h +++ b/src/HashFunctions/hash.h @@ -14,4 +14,4 @@ u32 hash_crc32(u32 oldhash, void* buf, u32 len); #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/Hashtable/Hashtable.c b/src/Hashtable/Hashtable.c index 9c8fe15..5b7b513 100644 --- a/src/Hashtable/Hashtable.c +++ b/src/Hashtable/Hashtable.c @@ -1,6 +1,6 @@ #include "Hashtable.h" -kt_define(Hashtable, __Hashtable_free, NULL); +kt_define(Hashtable, __Hashtable_destruct, NULL); // amount of rows static const u16 HT_HEIGHTS[]={17,61,257,1021,4099,16381,65521}; @@ -19,14 +19,14 @@ Hashtable* Hashtable_create(){ return ht; } -void __Hashtable_free(void* _ht){ +void __Hashtable_destruct(void* _ht){ Hashtable* ht=_ht; for(u16 i=0;ihein];i++) - Autoarr_free(ht->rows[i], true); + Autoarr_destruct(ht->rows[i], true); free(ht->rows); } -void Hashtable_free(Hashtable* ht){ - __Hashtable_free(ht); +void Hashtable_destruct(Hashtable* ht){ + __Hashtable_destruct(ht); free(ht); } @@ -51,7 +51,7 @@ void Hashtable_expand(Hashtable* ht){ } // there is no need to free array values, because they are copied into new array // so dont replace this incorrect auto-generated function - Autoarr_freeWithoutMembers(ar, true); + Autoarr_destructWithoutMembers(ar, true); } free(ht->rows); @@ -68,7 +68,7 @@ Autoarr(KVPair)* getrow(Hashtable* ht, char* key, bool can_expand){ } /// @param key must be heap allocated -/// Hashtable_free will free this pointer +/// Hashtable_destruct will free this pointer void Hashtable_add(Hashtable* ht, char* key, Unitype u){ KVPair p={ .key=key, .value=u }; Autoarr_add(getrow(ht,key,true),p); diff --git a/src/Hashtable/Hashtable.h b/src/Hashtable/Hashtable.h index 726f4b1..18b5925 100644 --- a/src/Hashtable/Hashtable.h +++ b/src/Hashtable/Hashtable.h @@ -9,13 +9,13 @@ extern "C" { #include "KeyValuePair.h" STRUCT(Hashtable, - u8 hein; // height=HT_HEIGHTS[hein] + u8 hein; // height=HT_HEIGHTS[hein] Autoarr(KVPair)** rows; // Autoarr[height] ) Hashtable* Hashtable_create(); -void Hashtable_free(Hashtable* ht); -void __Hashtable_free(void* ht); +void Hashtable_destruct(Hashtable* ht); +void __Hashtable_destruct(void* ht); // amount of rows u16 Hashtable_height(Hashtable* ht); @@ -46,4 +46,4 @@ bool Hashtable_tryGet(Hashtable* ht, char* key, Unitype* output); #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/Hashtable/KeyValuePair.c b/src/Hashtable/KeyValuePair.c index 952ebe8..3071f39 100644 --- a/src/Hashtable/KeyValuePair.c +++ b/src/Hashtable/KeyValuePair.c @@ -1,15 +1,15 @@ #include "KeyValuePair.h" -kt_define(KVPair, __KVPair_free, NULL); +kt_define(KVPair, __KVPair_destruct, NULL); Autoarr_define(KVPair, false) // proper way to clean a KVP -void KVPair_free(KVPair p){ +void KVPair_destruct(KVPair p){ free(p.key); - Unitype_free(p.value); + Unitype_destruct(&p.value); } -void __KVPair_free(void* p){ KVPair_free(*(KVPair*)p); } +void __KVPair_destruct(void* p){ KVPair_destruct(*(KVPair*)p); } void printkvp(KVPair p){ kprintf("{\"%s\", ",p.key); diff --git a/src/Hashtable/KeyValuePair.h b/src/Hashtable/KeyValuePair.h index 99d8117..815bdb1 100644 --- a/src/Hashtable/KeyValuePair.h +++ b/src/Hashtable/KeyValuePair.h @@ -15,11 +15,11 @@ STRUCT(KVPair, Autoarr_declare(KVPair) // proper way to clean a KVP -void KVPair_free(KVPair p); -void __KVPair_free(void* p); +void KVPair_destruct(KVPair p); +void __KVPair_destruct(void* p); void printkvp(KVPair p); #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/LinkedList/LinkedList.c b/src/LinkedList/LinkedList.c index 26732c6..d27f50b 100644 --- a/src/LinkedList/LinkedList.c +++ b/src/LinkedList/LinkedList.c @@ -34,7 +34,7 @@ void LinkedList_addToEnd(void* _llist, void* _new_node) { llist->last_node=new_node; } -static inline void _insertNode(LinkedList(Pointer)* llist, +static inline void _insertNode(LinkedList(Pointer)* llist, LLNode(Pointer)* prev_node, LLNode(Pointer)* new_node, LLNode(Pointer)* next_node){ if(prev_node==NULL){ if(next_node==llist->first_node) diff --git a/src/LinkedList/LinkedList.h b/src/LinkedList/LinkedList.h index f8435d6..0ffd2b7 100644 --- a/src/LinkedList/LinkedList.h +++ b/src/LinkedList/LinkedList.h @@ -16,7 +16,7 @@ extern "C" { #define LLNode_create(TYPE, VALUE) LLNode_##TYPE##_create(VALUE) #define LinkedList_create(TYPE) LinkedList_##TYPE##_create() -#define LinkedList_free(LLIST) ({ LLIST->_functions->freeMembers(LLIST); free(LLIST); }) +#define LinkedList_destruct(LLIST) ({ LLIST->_functions->freeMembers(LLIST); free(LLIST); }) void LinkedList_addToBeginning(void* _llist, void* _new_node); diff --git a/src/LinkedList/LinkedList_declare.h b/src/LinkedList/LinkedList_declare.h index a0f4c9e..e7dbff4 100644 --- a/src/LinkedList/LinkedList_declare.h +++ b/src/LinkedList/LinkedList_declare.h @@ -12,7 +12,7 @@ STRUCT(LLNode(TYPE), \ ) \ \ LLNode(TYPE)* LLNode_##TYPE##_create(TYPE value); \ -void LLNode_##TYPE##_free(LLNode(TYPE)* node, bool free_value); +void LLNode_##TYPE##_destruct(LLNode(TYPE)* node, bool free_value); #define LinkedList_declare(TYPE)\ diff --git a/src/LinkedList/LinkedList_define.h b/src/LinkedList/LinkedList_define.h index f978638..503574e 100644 --- a/src/LinkedList/LinkedList_define.h +++ b/src/LinkedList/LinkedList_define.h @@ -14,19 +14,19 @@ LLNode(TYPE)* LLNode_##TYPE##_create(TYPE value){ \ return node; \ } \ \ -void LLNode_##TYPE##_freeMembers(void* _node){ \ +void LLNode_##TYPE##_destructMembers(void* _node){ \ LLNode(TYPE)* node=(LLNode(TYPE)*)_node; \ void* value_ptr=&node->value; \ if(TYPE_IS_PTR) value_ptr=*(TYPE**)value_ptr; \ ktDescriptor_##TYPE.freeMembers(value_ptr); \ } \ \ -void LLNode_##TYPE##_free(LLNode(TYPE)* node, bool free_value){ \ - if(free_value) LLNode_##TYPE##_freeMembers(node); \ +void LLNode_##TYPE##_destruct(LLNode(TYPE)* node, bool free_value){ \ + if(free_value) LLNode_##TYPE##_destructMembers(node); \ free(node); \ } \ \ -kt_define(LLNode_##TYPE, LLNode_##TYPE##_freeMembers, NULL) +kt_define(LLNode_##TYPE, LLNode_##TYPE##_destructMembers, NULL) #define LinkedList_define(TYPE, VALUE_IS_PTR)\ @@ -41,10 +41,10 @@ LinkedList(TYPE)* LinkedList_##TYPE##_create(){ \ return l; \ } \ \ -void LinkedList_##TYPE##_freeMembers(void* _l){ \ +void LinkedList_##TYPE##_destructMembers(void* _l){ \ LinkedList(TYPE)* l=(LinkedList(TYPE)*)_l; \ if(l->first_node!=NULL) \ - LinkedList_foreach(l, node, LLNode_##TYPE##_free(node, true)); \ + LinkedList_foreach(l, node, LLNode_##TYPE##_destruct(node, true)); \ l->first_node=NULL; l->last_node=NULL; l->count=0; \ } \ \ @@ -55,7 +55,7 @@ void LinkedList_##TYPE##_removePrev(LinkedList(TYPE)* llist, LLNode(TYPE)* nextN nextNode->prev=prevNode; \ prevNode->next=nextNode; \ if(freeRemoved) \ - LLNode_##TYPE##_free(removedNode, true); \ + LLNode_##TYPE##_destruct(removedNode, true); \ } \ \ void LinkedList_##TYPE##_removeNext(LinkedList(TYPE)* llist, LLNode(TYPE)* prevNode, bool freeRemoved){ \ @@ -65,16 +65,16 @@ void LinkedList_##TYPE##_removeNext(LinkedList(TYPE)* llist, LLNode(TYPE)* prevN prevNode->next=nextNode; \ nextNode->prev=prevNode; \ if(freeRemoved) \ - LLNode_##TYPE##_free(removedNode, true); \ + LLNode_##TYPE##_destruct(removedNode, true); \ } \ \ LinkedList_##TYPE##_functions_t _LinkedList_##TYPE##_functions={ \ - .freeMembers=LinkedList_##TYPE##_freeMembers, \ + .freeMembers=LinkedList_##TYPE##_destructMembers, \ .removePrev=LinkedList_##TYPE##_removePrev, \ .removeNext=LinkedList_##TYPE##_removeNext \ }; \ \ -kt_define(LinkedList_##TYPE, LinkedList_##TYPE##_freeMembers, NULL) +kt_define(LinkedList_##TYPE, LinkedList_##TYPE##_destructMembers, NULL) #if __cplusplus diff --git a/src/SearchTree/SearchTree.c b/src/SearchTree/SearchTree.c index 5433696..c772659 100644 --- a/src/SearchTree/SearchTree.c +++ b/src/SearchTree/SearchTree.c @@ -1,6 +1,6 @@ #include "SearchTree.h" -kt_define(STNode, __STNode_free, NULL); +kt_define(STNode, __STNode_destruct, NULL); STNode* STNode_create(){ STNode* node=malloc(sizeof(STNode)); @@ -9,20 +9,20 @@ STNode* STNode_create(){ return node; } -void __STNode_free(void* _node){ +void __STNode_destruct(void* _node){ STNode* node=_node; if (!node) throw(ERR_NULLPTR); if(node->branches){ for(u8 n32 = 0;n32<8;n32++){ STNode*** ptrn32=(STNode***)node->branches[n32]; - if(ptrn32){ + if(ptrn32){ for(u8 n4 = 0;n4<8;n4++){ STNode** ptrn4=ptrn32[n4]; if (ptrn4){ for(u8 rem=0;rem<4;rem++){ STNode* ptrrem=ptrn4[rem]; if(ptrrem) - STNode_free(ptrrem); + STNode_destruct(ptrrem); } free(ptrn4); } @@ -32,11 +32,11 @@ void __STNode_free(void* _node){ } free(node->branches); } - if(node->value.VoidPtr) - Unitype_free(node->value); + if(node->value.VoidPtr) + Unitype_destruct(&node->value); } -void STNode_free(STNode* node){ - __STNode_free(node); +void STNode_destruct(STNode* node){ + __STNode_destruct(node); free(node); } diff --git a/src/SearchTree/SearchTree.h b/src/SearchTree/SearchTree.h index ba72486..628727c 100644 --- a/src/SearchTree/SearchTree.h +++ b/src/SearchTree/SearchTree.h @@ -13,8 +13,8 @@ STRUCT(STNode, ) STNode* STNode_create(); -void STNode_free(STNode* node); -void __STNode_free(void* node); +void STNode_destruct(STNode* node); +void __STNode_destruct(void* node); void ST_push(STNode* node, char* key, Unitype value); void ST_pushString(STNode* node, string key, Unitype value); @@ -23,4 +23,4 @@ Unitype ST_pullString(STNode* node, string key); #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/SearchTree/SearchTree.md b/src/SearchTree/SearchTree.md index a18d4e3..a33fb25 100644 --- a/src/SearchTree/SearchTree.md +++ b/src/SearchTree/SearchTree.md @@ -22,4 +22,4 @@ STNode.branches byte ┗━[7]━┳━[0] 252 ┣━... ┗━[3] 255 -``` \ No newline at end of file +``` diff --git a/src/String/StringBuilder.c b/src/String/StringBuilder.c index eedceb8..d1ab98f 100644 --- a/src/String/StringBuilder.c +++ b/src/String/StringBuilder.c @@ -1,23 +1,23 @@ #include "StringBuilder.h" -kt_define(StringBuilder, __StringBuilder_free, NULL); +kt_define(StringBuilder, __StringBuilder_destruct, NULL); #define BL_C 32 #define BL_L 1024 void complete_buf(StringBuilder* b){ - if(!b->compl_bufs) + if(!b->compl_bufs) b->compl_bufs=Autoarr_create(string,BL_C,BL_L); u32 len=Autoarr_length(b->curr_buf); if(!len) return; string str={.length=len, .ptr=malloc(len)}; u32 i=0; - Autoarr_foreach(b->curr_buf, c, + Autoarr_foreach(b->curr_buf, c, str.ptr[i++]=c; ); Autoarr_add(b->compl_bufs,str); - Autoarr_free(b->curr_buf, true); + Autoarr_destruct(b->curr_buf, true); b->curr_buf=Autoarr_create(i8,BL_C,BL_L); } @@ -34,31 +34,31 @@ StringBuilder* StringBuilder_create(){ return b; } -void __StringBuilder_free(void* _b){ +void __StringBuilder_destruct(void* _b){ StringBuilder* b=_b; - if(b->compl_bufs) Autoarr_free(b->compl_bufs, true); - Autoarr_free(b->curr_buf, true); + if(b->compl_bufs) Autoarr_destruct(b->compl_bufs, true); + Autoarr_destruct(b->curr_buf, true); } -void StringBuilder_free(StringBuilder* b){ - __StringBuilder_free(b); +void StringBuilder_destruct(StringBuilder* b){ + __StringBuilder_destruct(b); free(b); } string StringBuilder_build(StringBuilder* b){ complete_buf(b); u32 len=0; - Autoarr_foreach(b->compl_bufs, cs, + Autoarr_foreach(b->compl_bufs, cs, len+=cs.length; ); string str= { .length=len, .ptr=malloc(len+1) }; str.ptr[len]='\0'; u32 i=0; - Autoarr_foreach(b->compl_bufs, cs, + Autoarr_foreach(b->compl_bufs, cs, for(u32 n=0;n0) - if(*str0.ptr++ != *str1.ptr++) + if(*str0.ptr++ != *str1.ptr++) return false; return true; } diff --git a/src/String/string.h b/src/String/string.h index 9faef9e..2f84b86 100644 --- a/src/String/string.h +++ b/src/String/string.h @@ -5,7 +5,6 @@ extern "C" { #endif #include "../base/base.h" -#include "../Array/Array.h" #include "../Autoarr/Autoarr.h" // my fixed length string struct @@ -15,7 +14,6 @@ STRUCT(string, u64 length; // amount of chars in ptr value ) -Array_declare(string) Autoarr_declare(string) static const string stringNull={NULL,0}; @@ -37,4 +35,4 @@ string string_reverse(string s); #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/base/base.h b/src/base/base.h index e99c551..a3074f5 100644 --- a/src/base/base.h +++ b/src/base/base.h @@ -15,4 +15,4 @@ extern "C" { #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/base/cptr.c b/src/base/cptr.c index 4f916ae..038f0ab 100644 --- a/src/base/cptr.c +++ b/src/base/cptr.c @@ -11,16 +11,16 @@ u32 cptr_length(const char* str){ } // allocates new char[] and copies src there -char* cptr_copy(const char* src){ +char* cptr_copy(allocator_ptr al, const char* src){ u32 len=cptr_length(src)+1; - char* dst=malloc(len); + char* dst=allocator_alloc(al, len); memcpy(dst, src, len); return dst; } // multiplies char n times -char* char_multiply(char c, u32 n){ - char* rez=malloc(n+1); +char* char_multiply(allocator_ptr al, char c, u32 n){ + char* rez=allocator_alloc(al, n+1); rez[n]=0; while(n--!=0) rez[n]=c; @@ -130,9 +130,9 @@ i32 cptr_seekCharReverse(const char* src, char fragment, u32 startIndex, u32 see return -1; } -char* __cptr_concat(u32 n, ...){ - char** strs=(char**)malloc(n*sizeof(char*)); - u32* lengths=malloc(n*sizeof(u32)); +char* __cptr_concat(allocator_ptr al, u32 n, ...){ + char** strs=(char**)allocator_alloc(al, n*sizeof(char*)); + u32* lengths=allocator_alloc(al, n*sizeof(u32)); u32 totalLength=0; // reading args from va_list @@ -148,7 +148,7 @@ char* __cptr_concat(u32 n, ...){ va_end(vl); // allocating memory for output value - char* totality=malloc(totalLength+1); + char* totality=allocator_alloc(al, totalLength+1); char* output=totality; totality[totalLength]=0; @@ -163,26 +163,26 @@ char* __cptr_concat(u32 n, ...){ return output; } -char* cptr_toLower(const char* src) { +char* cptr_toLower(allocator_ptr al, const char* src) { u32 length=cptr_length(src); - char *p=malloc(length+1); + char *p=allocator_alloc(al, length+1); p[length]=0; for(u32 i=0; i inclusion in or -1 if not found i32 cptr_seek(const char* src, const char* fragment, u32 startIndex, u32 seekLength); @@ -66,27 +67,27 @@ static inline bool cptr_contains(const char* src, const char* fragment){ return cptr_seek(src, fragment, 0, -1) +1; } -char* __cptr_concat(u32 n, ...); -#define cptr_concat(STR...) __cptr_concat(count_args(STR), STR) +char* __cptr_concat(allocator_ptr al, u32 n, ...); +#define cptr_concat(ALLOCATOR, STR...) __cptr_concat(ALLOCATOR, count_args(STR), STR) -char* cptr_toLower(const char* src); -char* cptr_toUpper(const char* src); +char* cptr_toLower(allocator_ptr al, const char* src); +char* cptr_toUpper(allocator_ptr al, const char* src); /// @param startIndex 0 ... src length /// @param seekLength 0 ... -1 /// @return with replaced by or empty cstring if not found -char* cptr_replaceIn(const char* src, const char* str_old, const char* str_new, u32 startIndex, u32 seekLength); +char* cptr_replaceIn(allocator_ptr al, const char* src, const char* str_old, const char* str_new, u32 startIndex, u32 seekLength); /// @param startIndex 0 ... src length /// @param seekLength 0 ... -1 /// @return with replaced by or empty cstring if not found -char* cptr_replaceCharIn(const char* src, char c_old, char c_new, u32 startIndex, u32 seekLength); +char* cptr_replaceCharIn(allocator_ptr al, const char* src, char c_old, char c_new, u32 startIndex, u32 seekLength); -static inline char* cptr_replace(const char* src, const char* str_old, const char* str_new) -{ return cptr_replaceIn(src, str_old, str_new, 0, -1); } +static inline char* cptr_replace(allocator_ptr al, const char* src, const char* str_old, const char* str_new) +{ return cptr_replaceIn(al, src, str_old, str_new, 0, -1); } -static inline char* cptr_replaceChar(const char* src, char c_old, char c_new) -{ return cptr_replaceCharIn(src, c_old, c_new, 0, -1); } +static inline char* cptr_replaceChar(allocator_ptr al, const char* src, char c_old, char c_new) +{ return cptr_replaceCharIn(al, src, c_old, c_new, 0, -1); } #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/base/errors.c b/src/base/errors.c index 6f093f1..eb403a4 100644 --- a/src/base/errors.c +++ b/src/base/errors.c @@ -26,27 +26,21 @@ char* errname(ErrorId err){ char* __genErrMsg(const char* errmsg, const char* srcfile, i32 line, const char* funcname){ size_t bufsize=ERRMSG_MAXLENGTH; char* rezult=malloc(bufsize); - IFMSC( - sprintf_s(rezult,bufsize,"[%s:%d] %s() throwed error: %s",srcfile,line,funcname,errmsg), - sprintf(rezult,"[%s:%d] %s() throwed error: %s",srcfile,line,funcname,errmsg) - ); + sprintf_s(rezult,bufsize,"[%s:%d] %s() throwed error: %s",srcfile,line,funcname,errmsg); return rezult; } char* __extendErrMsg(const char* errmsg, const char* srcfile, i32 line, const char* funcname){ size_t bufsize=cptr_length(errmsg)+ERRMSG_MAXLENGTH; char* rezult=malloc(bufsize); - IFMSC( - sprintf_s(rezult,bufsize,"%s\n \\___[%s:%d] %s()",errmsg,srcfile,line,funcname), - sprintf(rezult,"%s\n \\___[%s:%d] %s()",errmsg,srcfile,line,funcname) - ); + sprintf_s(rezult,bufsize,"%s\n \\___[%s:%d] %s()",errmsg,srcfile,line,funcname); free(errmsg); return rezult; } -void Maybe_free(Maybe e){ +void Maybe_destruct(Maybe e){ free(e.errmsg); - Unitype_free(e.value); + Unitype_destruct(&e.value); } void printMaybe(Maybe e){ diff --git a/src/base/errors.h b/src/base/errors.h index a0e228a..0eb53ba 100644 --- a/src/base/errors.h +++ b/src/base/errors.h @@ -29,7 +29,7 @@ STRUCT(Maybe, // .value .errmsg #define MaybeNull (Maybe){UniNull, NULL} -void Maybe_free(Maybe e); +void Maybe_destruct(Maybe e); void printMaybe(Maybe e); @@ -87,4 +87,4 @@ char* __unknownErr( ); #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/base/memory/CstdAllocator.c b/src/base/memory/CstdAllocator.c index 1df363c..ef1557d 100644 --- a/src/base/memory/CstdAllocator.c +++ b/src/base/memory/CstdAllocator.c @@ -1,12 +1,12 @@ #include "allocators_internal.h" -void* CstdAllocator_alloc(allocator_t* self, size_t size){ - assert(size>0); +void* CstdAllocator_alloc(allocator_ptr self, size_t size){ + // assert(size>0); return malloc(size); } -void CstdAllocator_free(allocator_t* self, void* ptr){ - assert(ptr!=NULL); +void CstdAllocator_free(allocator_ptr self, void* ptr){ + // assert(ptr!=NULL); free(ptr); } diff --git a/src/base/memory/LinearAllocator.c b/src/base/memory/LinearAllocator.c index 75933e4..9641962 100644 --- a/src/base/memory/LinearAllocator.c +++ b/src/base/memory/LinearAllocator.c @@ -30,7 +30,7 @@ __attribute__ ((noinline)) void* __alloc_new_chunk(LinearAllocator* self, size_t return curr_chunk->data; } -void* LinearAllocator_alloc(allocator_t* _self, size_t size){ +void* LinearAllocator_alloc(allocator_ptr _self, size_t size){ // assert(_self!=NULL); // assert(size>0); LinearAllocator* self = (LinearAllocator*)_self; @@ -55,7 +55,7 @@ void* LinearAllocator_alloc(allocator_t* _self, size_t size){ } } -void LinearAllocator_free(allocator_t* _self, void* ptr){ +void LinearAllocator_free(allocator_ptr _self, void* ptr){ // LinearAllocator can't free pointers } diff --git a/src/base/memory/StackingAllocator.c b/src/base/memory/StackingAllocator.c index d44edbf..b1ae21c 100644 --- a/src/base/memory/StackingAllocator.c +++ b/src/base/memory/StackingAllocator.c @@ -8,7 +8,7 @@ typedef struct { size_t data_size; } AllocationHeader; -void* StackingAllocator_alloc(allocator_t* _self, size_t size){ +void* StackingAllocator_alloc(allocator_ptr _self, size_t size){ assert(_self!=NULL); assert(size>0); StackingAllocator* self = (StackingAllocator*)_self; @@ -23,7 +23,7 @@ void* StackingAllocator_alloc(allocator_t* _self, size_t size){ return data_ptr; } -void StackingAllocator_free(allocator_t* _self, void* data_ptr){ +void StackingAllocator_free(allocator_ptr _self, void* data_ptr){ assert(_self!=NULL); assert(data_ptr!=NULL); StackingAllocator* self = (StackingAllocator*)_self; diff --git a/src/base/memory/allocator_base.h b/src/base/memory/allocator_base.h new file mode 100644 index 0000000..8f1a62a --- /dev/null +++ b/src/base/memory/allocator_base.h @@ -0,0 +1,34 @@ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../std.h" + +/////////////////////////////////////////// +// MemoryAllocator interface // +/////////////////////////////////////////// + +typedef struct MemoryAllocator* allocator_ptr; + +typedef void* (*alloc_t)(allocator_ptr, size_t size); +typedef void (*free_t)(allocator_ptr, void* ptr); + +typedef struct MemoryAllocator { + alloc_t alloc_f; + free_t free_f; +} MemoryAllocator; + +#define allocator_alloc(ALLOCATOR, SIZE) \ + ((allocator_ptr)ALLOCATOR)->alloc_f(ALLOCATOR, SIZE) +#define allocator_free(ALLOCATOR, PTR) \ + ((allocator_ptr)ALLOCATOR)->free_f(ALLOCATOR, PTR) +#define allocator_destruct(ALLOCATOR) \ + ((allocator_ptr)ALLOCATOR)->destruct_f(ALLOCATOR) + +void* allocator_transfer(allocator_ptr src, allocator_ptr dest, void* data, size_t data_size); + +#ifdef __cplusplus +} +#endif diff --git a/src/base/memory/allocators.c b/src/base/memory/allocators.c index a2bd8ec..ae92737 100644 --- a/src/base/memory/allocators.c +++ b/src/base/memory/allocators.c @@ -1,6 +1,6 @@ #include "memory.h" -void* allocator_transfer(allocator_t* src, allocator_t* dest, void* data, size_t data_size) +void* allocator_transfer(allocator_ptr src, allocator_ptr dest, void* data, size_t data_size) { void* transfered=allocator_alloc(dest, data_size); memcpy(transfered, data, data_size); diff --git a/src/base/memory/allocators.h b/src/base/memory/allocators.h index 97f22bd..27ee401 100644 --- a/src/base/memory/allocators.h +++ b/src/base/memory/allocators.h @@ -6,30 +6,7 @@ extern "C" { #include "../std.h" #include "../type_system/ktDescriptor.h" - -/////////////////////////////////////////// -// MemoryAllocator interface // -/////////////////////////////////////////// - -typedef struct MemoryAllocator allocator_t; - -typedef void* (*alloc_t)(allocator_t*, size_t size); -typedef void (*free_t)(allocator_t*, void* ptr); - -typedef struct MemoryAllocator { - alloc_t alloc_f; - free_t free_f; -} allocator_t; - -#define allocator_alloc(ALLOCATOR, SIZE) \ - ((allocator_t*)ALLOCATOR)->alloc_f(ALLOCATOR, SIZE) -#define allocator_free(ALLOCATOR, PTR) \ - ((allocator_t*)ALLOCATOR)->free_f(ALLOCATOR, PTR) -#define allocator_destruct(ALLOCATOR) \ - ((allocator_t*)ALLOCATOR)->destruct_f(ALLOCATOR) - -void* allocator_transfer(allocator_t* src, allocator_t* dest, void* data, size_t data_size); - +#include "allocator_base.h" /////////////////////////////////////////// // CstdAllocator // @@ -38,7 +15,7 @@ void* allocator_transfer(allocator_t* src, allocator_t* dest, void* data, size_t /////////////////////////////////////////// STRUCT(CstdAllocator, - allocator_t base; + MemoryAllocator base; ); void CstdAllocator_construct(CstdAllocator* self); @@ -59,7 +36,7 @@ typedef struct MemoryChunk { } MemoryChunk; STRUCT(LinearAllocator, - allocator_t base; + MemoryAllocator base; MemoryChunk* chunks; /* MemoryChunk[max_chunks_count] */ u16 chunks_count; /* allocated chunks */ u16 max_chunks_count; /* chunks that can be allocated without reallocating .chunks */ diff --git a/src/base/memory/allocators_internal.h b/src/base/memory/allocators_internal.h index da7fc88..2205d63 100644 --- a/src/base/memory/allocators_internal.h +++ b/src/base/memory/allocators_internal.h @@ -1,4 +1,4 @@ #include #include "memory.h" -void* LinearAllocator_alloc(allocator_t* _self, size_t size); +void* LinearAllocator_alloc(allocator_ptr _self, size_t size); diff --git a/src/base/optime.h b/src/base/optime.h index d6a65ae..6b3e3b4 100644 --- a/src/base/optime.h +++ b/src/base/optime.h @@ -15,7 +15,7 @@ kprintf("\e[93moperation \e[94m%s\e[93m lasted \e[94m%f \e[93m%s\n", \ opname, t, tnames[tni]); -#ifdef CLOCK_REALTIME +#ifdef CLOCK_REALTIME /// executes codeblock and prints execution time /// u64 op_i is counter of the internal loop /// uses non-standard high-precision clock @@ -28,7 +28,7 @@ f64 t=(f64)(stop.tv_sec-start.tv_sec)*1000000+(f64)(stop.tv_nsec-start.tv_nsec)/1000; \ __optime_print(opname,t); \ } -#else +#else /// uses standard low precision clock #define optime(opname, repeats, codeblock...) { \ clock_t start=clock(); \ diff --git a/src/base/std.h b/src/base/std.h index e81e41e..002035a 100644 --- a/src/base/std.h +++ b/src/base/std.h @@ -28,7 +28,7 @@ typedef double f64; /// anonymous pointer without specified freeMembers() func typedef void* Pointer; -// Usually bool from stdbool.h is defined as macro, +// Usually bool from stdbool.h is defined as macro, // so in other macros like ktid_##TYPE it will be replaced by _Bool. // ktid__Bool will be created instead of ktid_bool // In C++ bool is a keyword, so there is no need to redefine it. @@ -136,4 +136,4 @@ You can even embed it into macro in header (see kprint.h) #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/base/type_system/base_toString.c b/src/base/type_system/base_toString.c index b63d82d..be43da2 100644 --- a/src/base/type_system/base_toString.c +++ b/src/base/type_system/base_toString.c @@ -5,14 +5,14 @@ // accepts char* (ptr to char) and char* (ptr to string) // uses format kp_s and kp_c to determine what type is argument -char* __toString_char(void* c, u32 fmt) { +char* __toString_char(allocator_ptr al, void* c, u32 fmt) { // *c=char* if(kp_fmt_dataFormat(fmt)==kp_s){ - return cptr_copy((char*)c); // to avoid segmentation fault on free() when *c allocalet on stack + return cptr_copy(al, (char*)c); // to avoid segmentation fault on free() when *c allocalet on stack } // *c=char if(kp_fmt_dataFormat(fmt)==kp_c){ - char* cc=malloc(2); + char* cc=allocator_alloc(al, 2); cc[0]=*(char*)c; cc[1]=0; return cc; @@ -20,10 +20,10 @@ char* __toString_char(void* c, u32 fmt) { else throw(ERR_FORMAT); } -char* __toString_bool(void* c, u32 fmt) { +char* __toString_bool(allocator_ptr al, void* c, u32 fmt) { static const char _strbool[4][6]={ "false", "true\0", "False", "True\0" }; u8 strind=*(bool*)c==1 + kp_fmt_isUpper(fmt)*2; - char* rez=malloc(6); + char* rez=allocator_alloc(al, 6); rez[0]=_strbool[strind][0]; rez[1]=_strbool[strind][1]; rez[2]=_strbool[strind][2]; @@ -33,7 +33,7 @@ char* __toString_bool(void* c, u32 fmt) { return rez; } -char* toString_i64(i64 n){ +char* toString_i64(allocator_ptr al, i64 n){ i64 d=n<0 ? -1*n : n; char str[32]; u8 i=sizeof(str); @@ -46,10 +46,10 @@ char* toString_i64(i64 n){ } if(n<0) str[--i]='-'; - return cptr_copy((char*)str+i); + return cptr_copy(al, (char*)str+i); } -char* toString_u64(u64 n, bool withPostfix, bool uppercase){ +char* toString_u64(allocator_ptr al, u64 n, bool withPostfix, bool uppercase){ char str[32]; u8 i=sizeof(str); str[--i]=0; @@ -61,33 +61,30 @@ char* toString_u64(u64 n, bool withPostfix, bool uppercase){ str[--i]='0' + n%10; n/=10; } - return cptr_copy((char*)str+i); + return cptr_copy(al, (char*)str+i); } -#define _toString_float_impl(bufsize, maxPrecision) { \ +#define _toString_float_impl(al, bufsize, maxPrecision) { \ char str[bufsize]; \ if(precision>maxPrecision) \ throw("too big precision"); \ if(precision==0) \ precision=toString_float_default_precision; \ - i32 cn=IFMSC( \ - sprintf_s(str, bufsize, "%.*f", precision, n), \ - sprintf(str, "%.*f", precision, n) \ - ); \ + i32 cn=sprintf_s(str, bufsize, "%.*f", precision, n); \ /* remove trailing zeroes except .0*/ \ while(str[cn-1]=='0' && str[cn-2]!='.') \ cn--; \ if(withPostfix) \ str[cn++]= uppercase ? 'F' : 'f'; \ str[cn]='\0'; \ - return cptr_copy(str); \ + return cptr_copy(al, str); \ } -char* toString_f32(f32 n, u8 precision, bool withPostfix, bool uppercase) - _toString_float_impl(48, toString_f32_max_precision) +char* toString_f32(allocator_ptr al, f32 n, u8 precision, bool withPostfix, bool uppercase) + _toString_float_impl(al, 48, toString_f32_max_precision) -char* toString_f64(f64 n, u8 precision, bool withPostfix, bool uppercase) - _toString_float_impl(512, toString_f64_max_precision) +char* toString_f64(allocator_ptr al, f64 n, u8 precision, bool withPostfix, bool uppercase) + _toString_float_impl(al, 512, toString_f64_max_precision) #define byte_to_bits(byte) { \ str[cn++]='0' + (u8)((byte>>7)&1); /* 8th bit */ \ @@ -100,9 +97,9 @@ char* toString_f64(f64 n, u8 precision, bool withPostfix, bool uppercase) str[cn++]='0' + (u8)((byte>>0)&1); /* 1th bit */ \ } -char* toString_bin(void* _bytes, u32 size, bool inverse, bool withPrefix){ +char* toString_bin(allocator_ptr al, void* _bytes, u32 size, bool inverse, bool withPrefix){ char* bytes=_bytes; - char* str=malloc(size*8 + (withPrefix?2:0) +1); + char* str=allocator_alloc(al, size*8 + (withPrefix?2:0) +1); u32 cn=0; // char number if(withPrefix){ str[cn++]='0'; @@ -126,19 +123,19 @@ char _4bitsHex(u8 u, bool uppercase){ case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: case 8: case 9: return '0'+u; - case 0xA: case 0xB: case 0xC: + case 0xA: case 0xB: case 0xC: case 0xD: case 0xE: case 0xF: return (uppercase ? 'A' : 'a') + u -10; - default: + default: dbg(u); throw("incorrect number"); - return 219; + return (char)219; } } -char* toString_hex(void* _bytes, u32 size, bool inverse, bool withPrefix, bool uppercase){ +char* toString_hex(allocator_ptr al, void* _bytes, u32 size, bool inverse, bool withPrefix, bool uppercase){ char* bytes=_bytes; - char* str=malloc(size*2 + (withPrefix?2:0) + 1); + char* str=allocator_alloc(al, size*2 + (withPrefix?2:0) + 1); u32 cn=0; // char number if(withPrefix){ str[cn++]='0'; @@ -147,7 +144,7 @@ char* toString_hex(void* _bytes, u32 size, bool inverse, bool withPrefix, bool u // left to right if(inverse){ // byte number - for(i32 bn=size-1; bn>=0; bn--){ + for(i32 bn=size-1; bn>=0; bn--){ unsigned char byte=bytes[bn]; str[cn++]=_4bitsHex(byte/16, uppercase); str[cn++]=_4bitsHex(byte%16, uppercase); @@ -166,67 +163,58 @@ char* toString_hex(void* _bytes, u32 size, bool inverse, bool withPrefix, bool u } -#define __toString_i32_def(BITS) char* __toString_i##BITS(void* _n, u32 f){ \ +#define __toString_i_def(BITS) char* __toString_i##BITS(allocator_ptr al, void* _n, u32 f){ \ switch(kp_fmt_dataFormat(f)){ \ case kp_i: ; \ i##BITS n=*(i##BITS*)_n; \ - return toString_i64(n); \ + return toString_i64(al,n); \ case kp_b: \ - return toString_bin(_n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f)); \ + return toString_bin(al, _n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f)); \ case kp_h: \ - return toString_hex(_n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f), kp_fmt_isUpper(f)); \ + return toString_hex(al, _n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f), kp_fmt_isUpper(f)); \ default: \ kprintf("\n%u\n", kp_fmt_dataFormat(f)); \ throw(ERR_FORMAT); \ return NULL; \ } \ } -__toString_i32_def(8) -__toString_i32_def(16) -__toString_i32_def(32) -__toString_i32_def(64) -#define __toString_u_def(BITS) char* __toString_u##BITS(void* _n, u32 f){ \ +__toString_i_def(8) +__toString_i_def(16) +__toString_i_def(32) +__toString_i_def(64) + +#define __toString_u_def(BITS) char* __toString_u##BITS(allocator_ptr al, void* _n, u32 f){ \ switch(kp_fmt_dataFormat(f)){ \ case kp_u: ; \ u##BITS n=*(u##BITS*)_n; \ - return toString_u64(n, kp_fmt_withPostfix(f), kp_fmt_isUpper(f)); \ + return toString_u64(al, n, kp_fmt_withPostfix(f), kp_fmt_isUpper(f)); \ case kp_b: \ - return toString_bin(_n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f)); \ + return toString_bin(al, _n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f)); \ case kp_h: \ - return toString_hex(_n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f), kp_fmt_isUpper(f)); \ + return toString_hex(al, _n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f), kp_fmt_isUpper(f)); \ default: \ kprintf("\n%u\n", kp_fmt_dataFormat(f)); \ throw(ERR_FORMAT); \ return NULL; \ } \ } + __toString_u_def(8) __toString_u_def(16) __toString_u_def(32) -// __toString_u_def(64) -char* __toString_u64(void* _n, u32 f){ - switch(kp_fmt_dataFormat(f)){ - case kp_u: ; - u64 n=*(u64*)_n; - return toString_u64(n, kp_fmt_withPostfix(f), kp_fmt_isUpper(f)); - case kp_b: - return toString_bin(_n, 64/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f)); - case kp_h: - return toString_hex(_n, 64/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f), kp_fmt_isUpper(f)); - default: - kprintf("\n%u\n", kp_fmt_dataFormat(f)); throw(ERR_FORMAT); return NULL; } -} +__toString_u_def(64) -#define __toString_float_def(BITS) char* __toString_f##BITS(void* _n, u32 f){ \ + +#define __toString_f_def(BITS) char* __toString_f##BITS(allocator_ptr al, void* _n, u32 f){ \ switch(kp_fmt_dataFormat(f)){ \ case kp_f: ; \ f##BITS n=*(f##BITS*)_n; \ - return toString_f64(n, toString_float_default_precision, kp_fmt_withPostfix(f), kp_fmt_isUpper(f)); \ + return toString_f64(al, n, toString_float_default_precision, kp_fmt_withPostfix(f), kp_fmt_isUpper(f)); \ case kp_b: \ - return toString_bin(_n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f)); \ + return toString_bin(al, _n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f)); \ case kp_h: \ - return toString_hex(_n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f), kp_fmt_isUpper(f)); \ + return toString_hex(al, _n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f), kp_fmt_isUpper(f)); \ default: \ kprintf("\n%u\n", kp_fmt_dataFormat(f)); \ throw(ERR_FORMAT); \ @@ -234,5 +222,5 @@ char* __toString_u64(void* _n, u32 f){ } \ } -__toString_float_def(32) -__toString_float_def(64) +__toString_f_def(32) +__toString_f_def(64) diff --git a/src/base/type_system/base_toString.h b/src/base/type_system/base_toString.h index 0446ce9..855812b 100644 --- a/src/base/type_system/base_toString.h +++ b/src/base/type_system/base_toString.h @@ -5,43 +5,44 @@ extern "C" { #endif #include "../errors.h" +#include "../memory/allocator_base.h" // accepts char* (ptr to char) and char* (ptr to string) // uses format kp_s and kp_c to determine what type is argument -char* __toString_char(void* c, u32 fmt); +char* __toString_char(allocator_ptr al, void* c, u32 fmt); // bool -char* __toString_bool(void* c, u32 fmt); +char* __toString_bool(allocator_ptr al, void* c, u32 fmt); // signed int -char* toString_i64(i64 n); -char* __toString_i8(void* n, u32 fmt); -char* __toString_i16(void* n, u32 fmt); -char* __toString_i32(void* n, u32 fmt); -char* __toString_i64(void* n, u32 fmt); +char* toString_i64(allocator_ptr al, i64 n); +char* __toString_i8(allocator_ptr al, void* n, u32 fmt); +char* __toString_i16(allocator_ptr al, void* n, u32 fmt); +char* __toString_i32(allocator_ptr al, void* n, u32 fmt); +char* __toString_i64(allocator_ptr al, void* n, u32 fmt); // unsigned int -char* toString_u64(u64 n, bool withPostfix, bool uppercase); -char* __toString_u8(void* n, u32 fmt); -char* __toString_u16(void* n, u32 fmt); -char* __toString_u32(void* n, u32 fmt); -char* __toString_u64(void* n, u32 fmt); +char* toString_u64(allocator_ptr al, u64 n, bool withPostfix, bool uppercase); +char* __toString_u8(allocator_ptr al, void* n, u32 fmt); +char* __toString_u16(allocator_ptr al, void* n, u32 fmt); +char* __toString_u32(allocator_ptr al, void* n, u32 fmt); +char* __toString_u64(allocator_ptr al, void* n, u32 fmt); // float #define toString_f32_max_precision 6 #define toString_f64_max_precision 15 #define toString_float_default_precision 6 -char* toString_f32(f32 n, u8 precision, bool withPostfix, bool uppercase); // uses sprintf -char* toString_f64(f64 n, u8 precision, bool withPostfix, bool uppercase); // uses sprintf -char* __toString_f32(void* n, u32 fmt); -char* __toString_f64(void* n, u32 fmt); +char* toString_f32(allocator_ptr al, f32 n, u8 precision, bool withPostfix, bool uppercase); // uses sprintf +char* toString_f64(allocator_ptr al, f64 n, u8 precision, bool withPostfix, bool uppercase); // uses sprintf +char* __toString_f32(allocator_ptr al, void* n, u32 fmt); +char* __toString_f64(allocator_ptr al, void* n, u32 fmt); ///@param inverse set to true for little endian numbers (their bytes are in reverse order) -char* toString_bin(void* bytes, u32 size, bool inverse, bool withPrefix); +char* toString_bin(allocator_ptr al, void* bytes, u32 size, bool inverse, bool withPrefix); ///@param inverse set to true for little endian numbers (their bytes are in reverse order) -char* toString_hex(void* bytes, u32 size, bool inverse, bool withPrefix, bool uppercase); +char* toString_hex(allocator_ptr al, void* bytes, u32 size, bool inverse, bool withPrefix, bool uppercase); #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/base/type_system/init.c b/src/base/type_system/init.c index 424b759..456face 100644 --- a/src/base/type_system/init.c +++ b/src/base/type_system/init.c @@ -1,5 +1,4 @@ #include "../base.h" -#include "../../Array/Array.h" #include "../../Autoarr/Autoarr.h" #include "../../SearchTree/SearchTree.h" #include "../../Hashtable/Hashtable.h" @@ -29,21 +28,6 @@ void kt_initKerepTypes(){ // ktDescriptor kt_register(ktDescriptor); - // base type arrays - kt_register(Array_char); - kt_register(Array_bool); - kt_register(Array_f32); - kt_register(Array_f64); - kt_register(Array_i8); - kt_register(Array_u8); - kt_register(Array_i16); - kt_register(Array_u16); - kt_register(Array_i32); - kt_register(Array_u32); - kt_register(Array_i64); - kt_register(Array_u64); - kt_register(Array_Pointer); - // base type autoarrs kt_register(Autoarr_Pointer); kt_register(Autoarr_char); @@ -61,7 +45,6 @@ void kt_initKerepTypes(){ // Unitype kt_register(Unitype); - kt_register(Array_Unitype); kt_register(Autoarr_Unitype); // STNode @@ -76,12 +59,16 @@ void kt_initKerepTypes(){ // string kt_register(string); - kt_register(Array_string); kt_register(Autoarr_string); // StringBuilder kt_register(StringBuilder); - //File + // File kt_register(FileHandle); + + // Allocators + kt_register(CstdAllocator); + kt_register(LinearAllocator); + kt_register(StackingAllocator); } diff --git a/src/base/type_system/init.h b/src/base/type_system/init.h index df787ca..079f79f 100644 --- a/src/base/type_system/init.h +++ b/src/base/type_system/init.h @@ -9,4 +9,4 @@ void kt_initKerepTypes(); #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/base/type_system/ktDescriptor.h b/src/base/type_system/ktDescriptor.h index 189160a..e492cf1 100644 --- a/src/base/type_system/ktDescriptor.h +++ b/src/base/type_system/ktDescriptor.h @@ -7,6 +7,7 @@ extern "C" { #include "../std.h" #include "ktid.h" #include "typedef_macros.h" +#include "../memory/allocator_base.h" #define kt_declare(TYPE)\ ktid_declare(TYPE);\ @@ -31,7 +32,7 @@ extern "C" { }; typedef void (*freeMembers_t)(void*); -typedef char* (*toString_t)(void* obj, u32 fmt); +typedef char* (*toString_t)(allocator_ptr al, void* obj, u32 fmt); STRUCT(ktDescriptor, char* name; @@ -48,4 +49,4 @@ STRUCT(ktDescriptor, #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/base/type_system/kt_functions.c b/src/base/type_system/kt_functions.c index f066c75..0758bc4 100644 --- a/src/base/type_system/kt_functions.c +++ b/src/base/type_system/kt_functions.c @@ -17,33 +17,33 @@ kt_define(i64, NULL, __toString_i64); kt_define(u64, NULL, __toString_u64); -char* ktDescriptor_toString(ktDescriptor* d){ +char* ktDescriptor_toString(allocator_ptr al, ktDescriptor* d){ const char* n="null"; - char *s0 = toString_u64(d->id, 0,0); - char *s1 = toString_u64(d->size, 0,0); - char *s2 = d->toString ? toString_hex(d->toString, sizeof(void*), 0,1,0) : n; - char *s3 = d->freeMembers ? toString_hex(d->freeMembers, sizeof(void*), 0,1,0) : n; - char *rez=cptr_concat("ktDescriptor {" + char *s0 = toString_u64(al, d->id, 0,0); + char *s1 = toString_u64(al, d->size, 0,0); + char *s2 = d->toString ? toString_hex(al, d->toString, sizeof(void*), 0,1,0) : n; + char *s3 = d->freeMembers ? toString_hex(al, d->freeMembers, sizeof(void*), 0,1,0) : n; + char *rez=cptr_concat(al, "ktDescriptor {" " name:", d->name, " id:",s0, " size:",s1, " toString:",s2, " freeMembers:",s3, " }"); - free(s0); - free(s1); - if(s2!=n) free(s2); - if(s3!=n) free(s3); + if(s3!=n) allocator_free(al, s3); + if(s2!=n) allocator_free(al, s2); + allocator_free(al, s1); + allocator_free(al, s0); return rez; } -char* _ktDescriptor_toString(void* _d, u32 fmt) { return ktDescriptor_toString(_d); } +char* _ktDescriptor_toString(allocator_ptr al, void* _d, u32 fmt) { return ktDescriptor_toString(al, _d); } kt_define(ktDescriptor, NULL, _ktDescriptor_toString); typedef ktDescriptor* ktDescriptor_Ptr; -// type descriptors are stored here during initialization +// type descriptors are stored here during initialization Autoarr(Pointer)* __descriptorPointers=NULL; // here type descriptors are stored when initialization is complited ktDescriptor** typeDescriptors=NULL; @@ -63,7 +63,7 @@ void kt_endInit(){ if(__descriptorPointers==NULL) throw(ERR_NULLPTR); typeDescriptors=(ktDescriptor**)Autoarr_toArray(__descriptorPointers); - Autoarr_free(__descriptorPointers,true); + Autoarr_destruct(__descriptorPointers,true); if(typeDescriptors==NULL) throw(ERR_NULLPTR); kprintf("\e[92minitialized %u type descriptors\n", ktid_last); } @@ -81,6 +81,6 @@ ktDescriptor* ktDescriptor_get(ktid id){ return typeDescriptors[id]; } -void kt_free(){ +void kt_deinit(){ free(typeDescriptors); } diff --git a/src/base/type_system/kt_functions.h b/src/base/type_system/kt_functions.h index 435e28f..a741226 100644 --- a/src/base/type_system/kt_functions.h +++ b/src/base/type_system/kt_functions.h @@ -23,10 +23,10 @@ void kt_endInit(); /// @param id id of registered type ktDescriptor* ktDescriptor_get(ktid id); -char* ktDescriptor_toString(ktDescriptor* d); +char* ktDescriptor_toString(allocator_ptr al, ktDescriptor* d); // call it to free heap-allocated ktDescriptors array -void kt_free(); +void kt_deinit(); kt_declare(Pointer); kt_declare(char); @@ -46,4 +46,4 @@ kt_declare(ktDescriptor); #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/base/type_system/ktid.h b/src/base/type_system/ktid.h index be08484..f21fe70 100644 --- a/src/base/type_system/ktid.h +++ b/src/base/type_system/ktid.h @@ -25,4 +25,4 @@ static const ktid ktid_undefined=-1; #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/base/type_system/unitype.c b/src/base/type_system/unitype.c index a85c05e..85e7ebe 100644 --- a/src/base/type_system/unitype.c +++ b/src/base/type_system/unitype.c @@ -1,40 +1,36 @@ #include "../../kprint/kprint_format.h" #include "../base.h" -char *__Unitype_toString(void *_u, u32 fmt) +char *__Unitype_toString(allocator_ptr al, void *_u, u32 fmt) { - return Unitype_toString(*(Unitype *)_u, fmt); + return Unitype_toString(al, *(Unitype *)_u, fmt); } -kt_define(Unitype, __UnitypePtr_free, __Unitype_toString); +kt_define(Unitype, (freeMembers_t)Unitype_destruct, __Unitype_toString); -void Unitype_free(Unitype u) +void Unitype_destruct(Unitype* u) { - if (u.typeId == ktid_undefined) + if (u->typeId == ktid_undefined) { - if (u.VoidPtr != NULL) + if (u->VoidPtr != NULL) throw("unitype with undefined typeId has value"); return; } - ktDescriptor *type = ktDescriptor_get(u.typeId); + ktDescriptor *type = ktDescriptor_get(u->typeId); if (type->freeMembers) - type->freeMembers(u.VoidPtr); - if (u.allocatedInHeap) - free(u.VoidPtr); -} -void __UnitypePtr_free(void *u) -{ - Unitype_free(*(Unitype *)u); + type->freeMembers(u->VoidPtr); + if (u->allocatedInHeap) + free(u->VoidPtr); } -char *Unitype_toString(Unitype u, u32 fmt) +char *Unitype_toString(allocator_ptr al, Unitype u, u32 fmt) { if (u.typeId == ktid_undefined) { if (u.VoidPtr != NULL) throw("unitype with undefined typeId has value"); - return cptr_copy("{ERROR_TYPE}"); + return cptr_copy(al, "{ERROR_TYPE}"); } if (fmt == 0) @@ -74,7 +70,7 @@ char *Unitype_toString(Unitype u, u32 fmt) else if (u.typeId == ktid_name(Pointer)) { if (u.VoidPtr == NULL) - return cptr_copy("{ UniNull }"); + return cptr_copy(al, "{ UniNull }"); fmt = kp_h; } } @@ -82,19 +78,22 @@ char *Unitype_toString(Unitype u, u32 fmt) ktDescriptor *type = ktDescriptor_get(u.typeId); char *valuestr; if (type->toString) - valuestr = type->toString(u.VoidPtr, fmt); + valuestr = type->toString(al, u.VoidPtr, fmt); else valuestr = "ERR_NO_TOSTRING_FUNC"; - char *rezult = cptr_concat("{ type: ", type->name, ", allocated on heap: ", (u.allocatedInHeap ? "true" : "false"), + char *rezult = cptr_concat(al, "{ type: ", type->name, ", allocated on heap: ", (u.allocatedInHeap ? "true" : "false"), ", value:", valuestr, " }"); if (type->toString) - free(valuestr); + allocator_free(al, valuestr); return rezult; } void printuni(Unitype v) { - char *s = Unitype_toString(v, 0); + LinearAllocator _al; + LinearAllocator_construct(&_al, 256); + allocator_ptr al=&_al.base; + char *s = Unitype_toString(al, v, 0); fputs(s, stdout); - free(s); -} \ No newline at end of file + LinearAllocator_destruct(&_al); +} diff --git a/src/base/type_system/unitype.h b/src/base/type_system/unitype.h index 1fef31f..cb5bd40 100644 --- a/src/base/type_system/unitype.h +++ b/src/base/type_system/unitype.h @@ -17,7 +17,7 @@ STRUCT(Unitype, char Bytes[8]; }; ktid typeId; - bool allocatedInHeap; // should Unitype_free call free() to VoidPtr* + bool allocatedInHeap; // should Unitype_destruct call free() to VoidPtr* ) @@ -45,11 +45,10 @@ STRUCT(Unitype, #define UniCheckTypePtr(UNI, TYPE) UniCheckTypeId(UNI, ktid_ptrName(TYPE)) // frees VoidPtr value or does nothing if type isn't pointer -void Unitype_free(Unitype u); -void __UnitypePtr_free(void* u); -char* Unitype_toString(Unitype v, u32 fmt); +void Unitype_destruct(Unitype* u); +char* Unitype_toString(allocator_ptr al, Unitype v, u32 fmt); void printuni(Unitype v); #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/kprint/kprint.c b/src/kprint/kprint.c index 046cf29..de5ed34 100644 --- a/src/kprint/kprint.c +++ b/src/kprint/kprint.c @@ -3,27 +3,27 @@ ktid __typeFromFormat(kp_fmt f){ ktid typeId=kp_fmt_ktid(f); - if(typeId) + if(typeId) return typeId; switch(kp_fmt_dataFormat(f)){ case kp_i: case kp_h: - case kp_b: + case kp_b: return ktid_name(i64); case kp_u: - return ktid_name(u64); + return ktid_name(u64); case kp_f: - return ktid_name(f64); + return ktid_name(f64); case kp_c: - return ktid_name(char); + return ktid_name(char); case kp_s: - return ktid_ptrName(char); - default: + return ktid_ptrName(char); + default: return ktid_undefined; } } -Maybe __next_toString(kp_fmt f, void* object){ +Maybe __next_toString(allocator_ptr al, kp_fmt f, void* object){ // detecting type ktid typeId=__typeFromFormat(f); if(typeId==ktid_undefined) @@ -35,7 +35,7 @@ Maybe __next_toString(kp_fmt f, void* object){ ktDescriptor* type=ktDescriptor_get(typeId); if(!type->toString) safethrow("type descriptor doesnt have toString() func",;); - return SUCCESS(UniHeapPtr(char, type->toString(object, f))); + return SUCCESS(UniHeapPtr(char, type->toString(al, object, f))); } Maybe check_argsN(u8 n){ @@ -44,14 +44,14 @@ Maybe check_argsN(u8 n){ return MaybeNull; } -Maybe __ksprint(u8 n, kp_fmt* formats, __kp_value_union* objects){ +Maybe __ksprint(allocator_ptr al, u8 n, kp_fmt* formats, __kp_value_union* objects){ try(check_argsN(n), _,;); n/=2; StringBuilder* strb=StringBuilder_create(); for(u8 i=0; i #define FOREGROUND_YELLOW FOREGROUND_GREEN | FOREGROUND_RED -DWORD kp_fgColor_toWin(kp_fgColor f){ +DWORD kp_fgColor_toWin(kp_fgColor f){ //kprintf("fg: %x\n", f); switch(f){ case kp_fgBlack: return 0; @@ -112,7 +119,7 @@ DWORD kp_fgColor_toWin(kp_fgColor f){ } } -DWORD kp_bgColor_toWin(kp_bgColor f){ +DWORD kp_bgColor_toWin(kp_bgColor f){ //kprintf("bg: %x\n", f); switch(f){ case kp_bgBlack: return 0; @@ -199,12 +206,12 @@ static const char* _kp_colorNames[16]={ "white" }; -char* kp_bgColor_toString(kp_bgColor c){ +char* kp_bgColor_toString(allocator_ptr al, kp_bgColor c){ u32 color_index=(c&0x00f00000)>>20; if(color_index>15) throw(ERR_WRONGINDEX); return _kp_colorNames[color_index]; } -char* kp_fgColor_toString(kp_fgColor c){ +char* kp_fgColor_toString(allocator_ptr al, kp_fgColor c){ u32 color_index=(c&0x00f00000)>>24; if(color_index>15) throw(ERR_WRONGINDEX); return _kp_colorNames[color_index]; diff --git a/src/kprint/kprint.h b/src/kprint/kprint.h index 69cc63c..27540ab 100644 --- a/src/kprint/kprint.h +++ b/src/kprint/kprint.h @@ -9,7 +9,7 @@ extern "C" { /* -This file looks like a mess, but all cotnent here just solves the problem of putting variadic arguments to array of formats and array of objects. +This file looks like a mess, but all cotnent here just solves the problem of putting variadic arguments to array of formats and array of objects. */ @@ -18,11 +18,11 @@ typedef union { u64 u64; f64 f64; void* ptr; -} __kp_value_union; +} __kp_value_union; -static inline __kp_value_union __kpVU_f(f64 f) { return (__kp_value_union){ .f64=f }; } -static inline __kp_value_union __kpVU_i(i64 f) { return (__kp_value_union){ .i64=f }; } +static inline __kp_value_union __kpVU_f(f64 f) { return (__kp_value_union){ .f64=f }; } +static inline __kp_value_union __kpVU_i(i64 f) { return (__kp_value_union){ .i64=f }; } #define __kpVU_selectType(V) _Generic(V, float: __kpVU_f, f64: __kpVU_f, default: __kpVU_i)(V) @@ -70,18 +70,18 @@ static inline __kp_value_union __kpVU_i(i64 f) { return (__kp_value_union){ .i64 __kp_argsToObjs32(ARGS)) -Maybe __ksprint(u8 n, kp_fmt* formats, __kp_value_union* objects); +Maybe __ksprint(allocator_ptr al, u8 n, kp_fmt* formats, __kp_value_union* objects); /// @param ARGS kp_fmt, value, kp_fmt, value... ///@returns Maybe -#define ksprint(ARGS...) WARNING_DISABLE( W_INT_CONVERSION, \ - __ksprint(count_args(ARGS), __kp_argsToArrs(count_args(ARGS),ARGS, __32zeroes)) \ +#define ksprint(ALLOCATOR, ARGS...) WARNING_DISABLE( W_INT_CONVERSION, \ + __ksprint(ALLOCATOR, count_args(ARGS), __kp_argsToArrs(count_args(ARGS),ARGS, __32zeroes)) \ ) -/*-Wint-conversion warning was produced during value to __kp_value_union conversion*/ +/*-Wint-conversion warning was produced during value to __kp_value_union conversion*/ Maybe __kfprint(FILE* fd, u8 n, kp_fmt* formats, __kp_value_union* objects); -/// @param FD FILE* +/// @param FD FILE* /// @param ARGS kp_fmt, value, kp_fmt, value... ///@returns Maybe #define kfprint(FD, ARGS...) WARNING_DISABLE( W_INT_CONVERSION, \ @@ -99,4 +99,4 @@ void __kprint(u8 n, kp_fmt* formats, __kp_value_union* objects); #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/kprint/kprint_colors.h b/src/kprint/kprint_colors.h index 5131651..f6912a1 100644 --- a/src/kprint/kprint_colors.h +++ b/src/kprint/kprint_colors.h @@ -4,10 +4,12 @@ extern "C" { #endif +#include "../base/memory/allocator_base.h" + // 10000000 00000000 00000000 00000000 // ^ ^^^^ // | color num -// fgColorSet flag +// fgColorSet flag PACKED_ENUM(kp_fgColor, /// black foreground kp_fgBlack = 0x80000000, @@ -40,7 +42,7 @@ PACKED_ENUM(kp_fgColor, /// cyan foreground kp_fgCyan = 0x8e000000, /// white foreground - kp_fgWhite = 0x8f000000 + kp_fgWhite = 0x8f000000 ) // 01000000 00000000 00000000 00000000 @@ -81,9 +83,9 @@ PACKED_ENUM(kp_bgColor, kp_bgWhite = 0x40f00000 ) -char* kp_bgColor_toString(kp_bgColor c); -char* kp_fgColor_toString(kp_fgColor c); +char* kp_bgColor_toString(allocator_ptr al, kp_bgColor c); +char* kp_fgColor_toString(allocator_ptr al, kp_fgColor c); #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/kprint/kprint_format.h b/src/kprint/kprint_format.h index 33e8aea..4c03198 100644 --- a/src/kprint/kprint_format.h +++ b/src/kprint/kprint_format.h @@ -45,9 +45,9 @@ PACKED_ENUM(kp_dataFmt, #define kp_fmt_dataFormat(FMT) (kp_dataFmt)(FMT&0x000f0000) #define kp_fmt_ktid(FMT) (ktid)(FMT&0x0000ffff) -///@param f bgColor | fgColor +///@param f bgColor | fgColor void kprint_setColor(kp_fmt f); #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/kprint/kprintf.c b/src/kprint/kprintf.c index 0f9e0a6..114c0eb 100644 --- a/src/kprint/kprintf.c +++ b/src/kprint/kprintf.c @@ -49,6 +49,9 @@ void kprintf(const char* format, ...){ va_list vl; va_start(vl, format); u32 i=0; + LinearAllocator _al; + LinearAllocator_construct(&_al, 256); + allocator_ptr al=(allocator_ptr)&_al; for(char c=format[i++]; c!=0; c=format[i++]){ // value format specifiers if(c=='%'){ @@ -58,18 +61,18 @@ void kprintf(const char* format, ...){ format_escape_seq: switch (c) { case 'u': - argstr=toString_u64( + argstr=toString_u64(al, l ? va_arg(vl, u64) : va_arg(vl, u32) ,0,0); break; case 'i': case 'd': - argstr=toString_i64( + argstr=toString_i64(al, l ? va_arg(vl, i64) : va_arg(vl, i32) ); break; case 'f': // f32 is promoted to f64 when passed through '...' - argstr=toString_f64(va_arg(vl, f64), toString_float_default_precision,0,0); + argstr=toString_f64(al, va_arg(vl, f64), toString_float_default_precision,0,0); break; case 'l': l=true; @@ -78,16 +81,16 @@ void kprintf(const char* format, ...){ break; case 'p': ; void* phex=va_arg(vl, void*); - argstr=toString_hex(&phex,getEndian()==LittleEndian,sizeof(phex),1,0); + argstr=toString_hex(al, &phex,getEndian()==LittleEndian,sizeof(phex),1,0); break; case 'x': ; if(l){ u64 xhex=va_arg(vl, u64); - argstr=toString_hex(&xhex,getEndian()==LittleEndian,sizeof(xhex),0,1); + argstr=toString_hex(al, &xhex,getEndian()==LittleEndian,sizeof(xhex),0,1); } else { u32 xhex=va_arg(vl, u32); - argstr=toString_hex(&xhex,getEndian()==LittleEndian,sizeof(xhex),0,1); + argstr=toString_hex(al, &xhex,getEndian()==LittleEndian,sizeof(xhex),0,1); } break; case 's': ; @@ -98,7 +101,7 @@ void kprintf(const char* format, ...){ fputs(cptr, stdout); break; case 'c': - argstr=malloc(2); + argstr=allocator_alloc(al, 2); argstr[0]=(char)va_arg(vl,int); argstr[1]=0; break; @@ -111,10 +114,9 @@ void kprintf(const char* format, ...){ } if(argstr){ fputs(argstr, stdout); - free(argstr); } } - // escape sequences + // escape sequences else if(c=='\e'){ IFWIN( /* WINDOWS */ @@ -143,7 +145,7 @@ void kprintf(const char* format, ...){ putc(c,stdout); ); } - // common characters + // common characters else { putc(c,stdout); } @@ -152,4 +154,5 @@ void kprintf(const char* format, ...){ #endif } va_end(vl); + LinearAllocator_destruct(&_al); } diff --git a/src/kprint/kprintf.h b/src/kprint/kprintf.h index d4df677..5a787f6 100644 --- a/src/kprint/kprintf.h +++ b/src/kprint/kprintf.h @@ -11,4 +11,4 @@ void kprintf(const char* format, ...); #if __cplusplus } -#endif \ No newline at end of file +#endif diff --git a/src/random/xoshiro-xoroshiro.md b/src/random/xoshiro-xoroshiro.md deleted file mode 100644 index 269477c..0000000 --- a/src/random/xoshiro-xoroshiro.md +++ /dev/null @@ -1,24 +0,0 @@ -# Xoshiro/Xoroshiro RNG algorithms -There are a bunch of versions of xoshiro/xoroshiro algorithms, which are created by [David Blackman and Sebastiano Vigna](https://prng.di.unimi.it/) - - -``` -xoroshiro -├── 32bitValue -| ├── xoroshiro64star.c -| └── xoroshiro64starstar.c -└── 64bitValue - ├── xoroshiro128plus.c - ├── xoroshiro128plusplus.c - └── xoroshiro128starstar.c - -xoshiro -├── 32bitValue -│ ├── xoshiro128plus.c -│ ├── xoshiro128plusplus.c -│ └── xoshiro128starstar.c -└── 64bitValue - ├── xoshiro256plus.c - ├── xoshiro256plusplus.c - └── xoshiro256starstar.c -``` diff --git a/tests/main.cpp b/tests/main.cpp index c6876e2..a167660 100644 --- a/tests/main.cpp +++ b/tests/main.cpp @@ -7,7 +7,7 @@ i32 main(){ kt_initKerepTypes(); kt_endInit(); test_all(); - kt_free(); + kt_deinit(); kprintf("\e[0m\n"); return 0; } diff --git a/tests/test_allocators.c b/tests/test_allocators.c index 153ffe4..b63220e 100644 --- a/tests/test_allocators.c +++ b/tests/test_allocators.c @@ -1,6 +1,6 @@ #include "tests.h" -void _test_allocator(allocator_t* al){ +void _test_allocator(allocator_ptr al){ void* ptr=allocator_alloc(al, 1); allocator_free(al, ptr); ptr=allocator_alloc(al, 5); @@ -30,18 +30,18 @@ void test_allocators(){ optime("test CstdAllocator", 10000, CstdAllocator al; CstdAllocator_construct(&al); - _test_allocator((allocator_t*)&al); + _test_allocator((allocator_ptr)&al); ); optime("test LinearAllocator", 10000, LinearAllocator al; LinearAllocator_construct(&al, 4096); - _test_allocator((allocator_t*)&al); + _test_allocator((allocator_ptr)&al); LinearAllocator_destruct(&al); ); optime("test StackingAllocator", 10000, StackingAllocator al; StackingAllocator_construct(&al, 4096); - _test_allocator((allocator_t*)&al); + _test_allocator((allocator_ptr)&al); StackingAllocator_destruct(&al); ); } diff --git a/tests/test_autoarr-vs-vector.cpp b/tests/test_autoarr-vs-vector.cpp index f0231f6..dd97b66 100644 --- a/tests/test_autoarr-vs-vector.cpp +++ b/tests/test_autoarr-vs-vector.cpp @@ -16,7 +16,7 @@ i64 _autoarrVsVector(u16 chunkCount, u16 chunkLength){ t=Autoarr_get(ar, op_i)); optime("vector_get", count, t=vec[op_i]); - Autoarr_free(ar, true); + Autoarr_destruct(ar, true); return t; } diff --git a/tests/test_autoarr.c b/tests/test_autoarr.c index 5705758..0a8e0a3 100644 --- a/tests/test_autoarr.c +++ b/tests/test_autoarr.c @@ -47,7 +47,7 @@ void test_autoarr(){ resetar(ar); kprintf("\e[92mautoarr values reset\n"); printallval(ar); - Autoarr_free(ar, true); + Autoarr_destruct(ar, true); kprintf("\e[92mautoarr deleted\n"); ); } diff --git a/tests/test_cptr.c b/tests/test_cptr.c index 83dfadb..e58dea6 100644 --- a/tests/test_cptr.c +++ b/tests/test_cptr.c @@ -151,4 +151,4 @@ void test_cptr(){ // TODO cptr_replace ); -} \ No newline at end of file +} diff --git a/tests/test_dtsod.c b/tests/test_dtsod.c index 508d140..fce870b 100644 --- a/tests/test_dtsod.c +++ b/tests/test_dtsod.c @@ -52,7 +52,7 @@ void test_dtsod(){ tryLast(DtsodV24_serialize(dtsod),r,;) s=r.value.VoidPtr; ); - DtsodV24_free(dtsod); + DtsodV24_destruct(dtsod); kprintf("\e[92m%s",s); optime("reserialize",10, @@ -61,9 +61,9 @@ void test_dtsod(){ free(s); tryLast(DtsodV24_serialize(dtsod),rr,;) s=rr.value.VoidPtr; - DtsodV24_free(dtsod); + DtsodV24_destruct(dtsod); ); free(s); ); -} \ No newline at end of file +} diff --git a/tests/test_hash_functions.c b/tests/test_hash_functions.c index 7357b81..93e6fef 100644 --- a/tests/test_hash_functions.c +++ b/tests/test_hash_functions.c @@ -33,7 +33,7 @@ char data[]="iojihiojopijiugbjmoihftytryfdrh"; } \ kprintf("\e[93m%u \e[94mcollisions detected in %u hashes\n", collisions, COLLISION_TESTS); \ ); \ - Autoarr_free(hashes, true); \ + Autoarr_destruct(hashes, true); \ kprintf("\e[96m--------------------------------------\n"); \ } @@ -43,4 +43,4 @@ void test_hash_functions(){ test_hashfunc(u32, hash_crc32); test_hashfunc(u32, hash_sdbm32); ); -} \ No newline at end of file +} diff --git a/tests/test_hashtable.c b/tests/test_hashtable.c index 24e5dab..06985b9 100644 --- a/tests/test_hashtable.c +++ b/tests/test_hashtable.c @@ -13,7 +13,7 @@ void print_hashtable(Hashtable* ht){ ht->rows); } -void printrowgraph(Hashtable* ht){ +void printrowgraph(allocator_ptr al, Hashtable* ht){ kprintf("\e[94mrow length graph:\n"); u16 lgs_l=1000; u32 lgs[lgs_l]; @@ -26,36 +26,33 @@ void printrowgraph(Hashtable* ht){ } for(u32 i=0; i0) { - char* str0=char_multiply(' ',i>=100?0:(i>=10?1:2)); - char* str1=char_multiply(' ',lgs[i]>=100?0:(lgs[i]>=10?1:2)); - char* str2=char_multiply('#',lgs[i]/100); + char* str0=char_multiply(al, ' ',i>=100?0:(i>=10?1:2)); + char* str1=char_multiply(al, ' ',lgs[i]>=100?0:(lgs[i]>=10?1:2)); + char* str2=char_multiply(al, '#',lgs[i]/100); kprintf("\e[94m length: \e[96m%u %s \e[94mfrequency: \e[96m%u %s \e[90m%s\n",i,str0,lgs[i],str1,str2); - free(str0); - free(str1); - free(str2); + allocator_free(al, str2); + allocator_free(al, str1); + allocator_free(al, str0); } } -char* genkey(u32 i){ - char* key=malloc(12); - IFMSC( - sprintf_s(key,12,"key_%u",i), - sprintf(key,"key_%u",i) - ); +char* genkey(allocator_ptr al, u32 i){ + char* key=allocator_alloc(al, 16); + sprintf_s(key,16,"key_%u",i); return key; } -void fill(Hashtable* ht){ +void fill(allocator_ptr al, Hashtable* ht){ for(u32 i=0;i<100000;i++) - Hashtable_add(ht,genkey(i),UniUInt64(i)); + Hashtable_add(ht,genkey(al, i), UniUInt64(i)); } -Unitype gett(Hashtable* ht){ +Unitype gett(allocator_ptr al, Hashtable* ht){ Unitype u; for(u32 i=0;i<100000;i++){ - char* key=genkey(i); + char* key=genkey(al, i); u=Hashtable_get(ht,key); - free(key); + allocator_free(al, key); } return u; } @@ -64,14 +61,18 @@ Unitype gett(Hashtable* ht){ void test_hashtable(){ optime("test_hashtable",1, kprintf("\e[96m-----------[test_hashtable]-----------\n"); + StackingAllocator _al; + allocator_ptr al=(allocator_ptr)&_al; + StackingAllocator_construct(&_al, 4096); Hashtable* ht=Hashtable_create(); kprintf("\e[92mhashtable created\n"); print_hashtable(ht); - optime("fill",1,fill(ht)); - optime("get",1,gett(ht)); - printrowgraph(ht); + optime("fill",1,fill(al, ht)); + optime("get",1,gett(al, ht)); + printrowgraph(al, ht); print_hashtable(ht); - Hashtable_free(ht); + Hashtable_destruct(ht); kprintf("\e[92mhashtable freed\n"); + StackingAllocator_destruct(&_al); ); } diff --git a/tests/test_marshalling.c b/tests/test_marshalling.c index e29835c..26b26ba 100644 --- a/tests/test_marshalling.c +++ b/tests/test_marshalling.c @@ -1,9 +1,12 @@ #include "../src/Hashtable/KeyValuePair.h" EXPORT void CALL test_marshalling(char* text, KVPair** kptr){ - KVPair* k=malloc(sizeof(KVPair)); + CstdAllocator _al; + allocator_ptr al=(allocator_ptr)&_al; + CstdAllocator_construct(&_al); + KVPair* k=allocator_alloc(al, sizeof(KVPair)); k->key="message"; - char* tc=cptr_copy(text); + char* tc=cptr_copy(al, text); Unitype u=UniHeapPtr(char,tc); k->value=u; *kptr=k; diff --git a/tests/test_rng_algorithms.c b/tests/test_rng_algorithms.c index 1ae83c7..8fbb69c 100644 --- a/tests/test_rng_algorithms.c +++ b/tests/test_rng_algorithms.c @@ -1,45 +1,43 @@ #include "tests.h" -#include "../src/random/krandom.h" +#include "../src/random/random.h" - -#define test_alg(ALG, VALUE_SIZE, EXPECTED_FROM_ZERO) { \ +#define test_alg(ALG, STATE_TYPE, EXPECTED_FROM_ZERO) { \ kprintf("\e[94mrng algorithm: \e[96m" #ALG "\n"); \ - void* s= ALG##_init(0); \ - u##VALUE_SIZE r=ALG##_next(s); \ + STATE_TYPE##_state state; \ + STATE_TYPE##_construct(&state, 0); \ + u64 rn=ALG##_next(&state); \ kprintf("\e[97m next from zero seed:"); \ - if(r!=EXPECTED_FROM_ZERO){ \ - kprintf("\e[91m " IFWIN("%llu\n","%lu\n"), (u64)r); \ + if(rn != EXPECTED_FROM_ZERO){ \ + kprintf("\e[91m %lu\n", rn); \ throw(ERR_UNEXPECTEDVAL); \ } \ - kprintf("\e[92m " IFWIN("%llu\n","%lu\n"), (u64)r); \ - ALG##_free(s); \ - s= ALG##_initFromTime(); \ - r=ALG##_next(s); \ - ALG##_free(s); \ - kprintf("\e[97m next from time seed:\e[92m " IFWIN("%llu\n","%lu\n"), (u64)r); \ + kprintf("\e[92m %lu\n", rn); \ + STATE_TYPE##_construct(&state, random_seedFromTime()); \ + rn=ALG##_next(&state); \ + kprintf("\e[97m next from time seed:\e[92m %lu\n", rn); \ } void test_rng_algorithms(){ - optime("test_rng_algorithms",1, - kprintf("\e[96m--------[test_rng_algorithms]---------\n"); - // for ALG32 - // xoroshiro64 - test_alg(xoroshiro64star, 32, 932574677ULL) - test_alg(xoroshiro64starstar, 32, 3183060286ULL) - // xoshiro128 - test_alg(xoshiro128plus, 32, 3918949401ULL) - test_alg(xoshiro128plusplus, 32, 1179900579ULL) - test_alg(xoshiro128starstar, 32, 3737715805ULL) - // for ALG64 - // xoroshiro128 - test_alg(xoroshiro128plus, 64, 4778832803ULL) - test_alg(xoroshiro128plusplus, 64, 626373238705583ULL) - test_alg(xoroshiro128starstar, 64, 11897572417920ULL) - // xoshiro256 - test_alg(xoshiro256plus, 64, 15757075719729598363ULL) - test_alg(xoshiro256plusplus, 64, 5987356902031041503ULL) - test_alg(xoshiro256starstar, 64, 11091344671253066420ULL) - // splitmix64 - test_alg(splitmix64, 64, 16294208416658607535ULL) - ); -} \ No newline at end of file + // optime("test_rng_algorithms",1, + kprintf("\e[96m--------[test_rng_algorithms]---------\n"); + // splitmix64 + test_alg(splitmix64, splitmix64, 16294208416658607535ULL) + // 32-bit + // xoroshiro64 + test_alg(xoroshiro64star, xoroshiro64, 932574677ULL) + test_alg(xoroshiro64starstar, xoroshiro64, 3183060286ULL) + // xoshiro128 + test_alg(xoshiro128plus, xoshiro128, 3918949401ULL) + test_alg(xoshiro128plusplus, xoshiro128, 1179900579ULL) + test_alg(xoshiro128starstar, xoshiro128, 3737715805ULL) + // 64-bit + // xoroshiro128 + test_alg(xoroshiro128plus, xoroshiro128, 4778832803ULL) + test_alg(xoroshiro128plusplus, xoroshiro128, 626373238705583ULL) + test_alg(xoroshiro128starstar, xoroshiro128, 11897572417920ULL) + // xoshiro256 + test_alg(xoshiro256plus, xoshiro256, 15757075719729598363ULL) + test_alg(xoshiro256plusplus, xoshiro256, 5987356902031041503ULL) + test_alg(xoshiro256starstar, xoshiro256, 11091344671253066420ULL) + // ); +} diff --git a/tests/test_safethrow.c b/tests/test_safethrow.c index f283c3d..3cc185c 100644 --- a/tests/test_safethrow.c +++ b/tests/test_safethrow.c @@ -34,10 +34,10 @@ void test_safethrow(){ Maybe e=test_maybe(); kprintf("\e[94mthrow_error:\n\e[92m"); printMaybe(e); - Maybe_free(e); + Maybe_destruct(e); kprintf("\e[94mthrow_errcode:\n\e[92m"); e=a(); printMaybe(e); - Maybe_free(e); + Maybe_destruct(e); ); } diff --git a/tests/test_searchtree.c b/tests/test_searchtree.c index 4682e0b..fa72925 100644 --- a/tests/test_searchtree.c +++ b/tests/test_searchtree.c @@ -25,6 +25,9 @@ void printstnode(STNode* node){ void test_searchtree(){ optime("test_searchtree",1, kprintf("\e[96m-----------[test_searchtree]----------\n"); + LinearAllocator _al; + LinearAllocator_construct(&_al, 1024); + allocator_ptr al=(allocator_ptr)&_al; STNode* node=STNode_create(); kprintf("\e[92mnode created\n"); kprintf("push:\e[94m\n "); @@ -44,7 +47,7 @@ void test_searchtree(){ printuni(u); ST_push(node,"channel_id", u); kprintf(" -> channel_id\n "); - u=UniHeapPtr(char, cptr_copy("32.2004")); + u=UniHeapPtr(char, cptr_copy(al, "32.2004")); printuni(u); ST_push(node,"message_id", u); kprintf(" -> message_id\n "); @@ -68,7 +71,8 @@ void test_searchtree(){ kprintf("\n"); kprintf("\e[92mfirst node: "); printstnode(node); - STNode_free(node); + STNode_destruct(node); kprintf("\e[92mnode deleted\n"); + LinearAllocator_destruct(&_al); ); } diff --git a/tests/test_string.c b/tests/test_string.c index 6bb9743..d59c12d 100644 --- a/tests/test_string.c +++ b/tests/test_string.c @@ -11,4 +11,4 @@ void test_string(){ kprintf("\e[94mstring_extract() -> \e[92m\"%s\"\n",p); free(p); ); -} \ No newline at end of file +} diff --git a/tests/test_type_system.c b/tests/test_type_system.c index 58ed2e5..7d52799 100644 --- a/tests/test_type_system.c +++ b/tests/test_type_system.c @@ -1,7 +1,7 @@ #include "tests.h" void test_type_system(){ - for(ktid id=0; idid, type->name, type->size, type->freeMembers, type->toString); diff --git a/tests/tests.h b/tests/tests.h index c8d9edf..ec89757 100644 --- a/tests/tests.h +++ b/tests/tests.h @@ -24,20 +24,20 @@ void test_type_system(); static inline void test_all(){ kprintf("\e[97mkerep tests are starting!\n"); optime(__func__, 1, + // test_type_system(); test_allocators(); - /*test_cptr(); - test_string(); - test_safethrow(); - test_searchtree(); - test_autoarr(); - test_hash_functions(); - test_hashtable(); - test_dtsod(); - test_autoarrVsVector(); - test_rng_algorithms(); - test_kprint_colors(); - test_kprint(); - test_type_system();*/ + // test_kprint_colors(); + // test_kprint(); + // test_safethrow(); + // test_rng_algorithms(); + // test_cptr(); + // test_string(); + // test_searchtree(); + // test_autoarr(); + // test_autoarrVsVector(); + // test_hash_functions(); + // test_hashtable(); + // test_dtsod();*/ kprintf("\e[96m--------------------------------------\e[0m\n"); ); }