Timerix/kerep
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: Timerix:c30a23669bc4b193ca4501e220a82a33417c19df
Branches Tags
Timerix:main Timerix:memory_allocator
..
compare: Timerix:memory_allocator
Branches Tags
Timerix:main Timerix:memory_allocator

13 Commits
c30a23669b ... memory_all

Author SHA1 Message Date
timerix
885ef7fea6 Hashtable 2023-10-27 14:21:29 +06:00
timerix
b6088845d9 removed elements freeing in autoarr 2023-10-27 14:21:10 +06:00
timerix
5ddc96e1b4 StringBuilder 2023-10-27 13:37:18 +06:00
timerix
e7280038fb typeof 2023-10-12 14:01:39 +06:00
timerix
14630e509d Autuarr 2023-07-10 18:31:16 +06:00
timerix
28169450cf LinearAllocator improved 2023-06-08 21:29:47 +06:00
timerix
8d36fd8042 string and StringBuilder 2023-06-08 18:41:05 +06:00
timerix
32ce7d3a70 some fixes 2023-06-08 15:59:52 +06:00
timerix
080bbb28fd random 2023-06-08 15:15:50 +06:00
timerix
c5585bbb0c refactoring 2023-06-08 15:15:38 +06:00
timerix
a983df1ac6 memory allocators 2023-06-05 14:10:00 +06:00
timerix
490d450a82 changed Autoarr field names 2023-06-05 13:56:14 +06:00
timerix
61da9ad161 memcpy 2023-06-05 13:55:00 +06:00
141 changed files with 1958 additions and 3277 deletions
Expand all files Collapse all files

8
.gitignore vendored
View File

@@ -4,12 +4,12 @@ obj/
# user files
.old*/
[Tt]mp/
[Tt]emp/
.[Tt]mp/
.[Tt]emp/
.vs/
.vshistory/
tmp/
temp/
*.tmp
*.temp
.editorconfig
*.user
*.vcxproj.filters

5
.idea/codeStyles/codeStyleConfig.xml generated Normal file
View File

@@ -0,0 +1,5 @@
<component name="ProjectCodeStyleConfiguration">
<state>
<option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
</state>
</component>

7
.idea/discord.xml generated
View File

@@ -1,7 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="DiscordProjectSettings">
<option name="show" value="PROJECT_FILES" />
<option name="description" value="" />
</component>
</project>

102
.idea/editor.xml generated
View File

@@ -1,102 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="BackendCodeEditorSettings">
<option name="/Default/CodeStyle/CodeFormatting/CppClangFormat/EnableClangFormatSupport/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/EditorConfig/EnableClangFormatSupport/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ALIGN_MULTILINE_BINARY_EXPRESSIONS_CHAIN/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ALIGN_MULTILINE_CALLS_CHAIN/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ALIGN_MULTILINE_EXPRESSION/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ALIGN_MULTILINE_FOR_STMT/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ALIGN_MULTIPLE_DECLARATION/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ALIGN_TERNARY/@EntryValue" value="ALIGN_ALL" type="string" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/BLANK_LINES_AROUND_CLASS_DEFINITION/@EntryValue" value="1" type="int" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/KEEP_BLANK_LINES_IN_DECLARATIONS/@EntryValue" value="2" type="int" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/KEEP_BLANK_LINES_IN_CODE/@EntryValue" value="2" type="int" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/KEEP_USER_LINEBREAKS/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/INDENT_CASE_FROM_SWITCH/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/INDENT_COMMENT/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/INT_ALIGN_EQ/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SIMPLE_BLOCK_STYLE/@EntryValue" value="DO_NOT_CHANGE" type="string" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_COMMA_IN_TEMPLATE_ARGS/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_COMMA_IN_TEMPLATE_PARAMS/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_FOR_SEMICOLON/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_FOR_SEMICOLON/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_UNARY_OPERATOR/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_WITHIN_ARRAY_ACCESS_BRACKETS/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_WITHIN_CAST_EXPRESSION_PARENTHESES/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_WITHIN_EMPTY_INITIALIZER_BRACES/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_WITHIN_EMPTY_METHOD_PARENTHESES/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_WITHIN_INITIALIZER_BRACES/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPECIAL_ELSE_IF_TREATMENT/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_CAST_EXPRESSION_PARENTHESES/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_AFTER_BINARY_OPSIGN/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_BEFORE_TERNARY_OPSIGNS/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/TYPE_DECLARATION_BRACES/@EntryValue" value="END_OF_LINE" type="string" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/OTHER_BRACES/@EntryValue" value="END_OF_LINE" type="string" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/CASE_BLOCK_BRACES/@EntryValue" value="END_OF_LINE" type="string" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/BLANK_LINES_AROUND_FUNCTION_DECLARATION/@EntryValue" value="1" type="int" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/BLANK_LINES_AROUND_FUNCTION_DEFINITION/@EntryValue" value="1" type="int" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/PLACE_WHILE_ON_NEW_LINE/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/PLACE_ELSE_ON_NEW_LINE/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/PLACE_CATCH_ON_NEW_LINE/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/NAMESPACE_INDENTATION/@EntryValue" value="All" type="string" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ALIGN_MULTILINE_ARGUMENT/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ALIGN_MULTILINE_EXTENDS_LIST/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ALIGN_MULTILINE_PARAMETER/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ALIGN_MULTILINE_TYPE_ARGUMENT/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ALIGN_MULTILINE_TYPE_PARAMETER/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/BLANK_LINES_AROUND_DECLARATIONS/@EntryValue" value="0" type="int" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/INDENT_ACCESS_SPECIFIERS_FROM_CLASS/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/INDENT_CLASS_MEMBERS_FROM_ACCESS_SPECIFIERS/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/LINE_BREAK_AFTER_COLON_IN_MEMBER_INITIALIZER_LISTS/@EntryValue" value="ON_SINGLE_LINE" type="string" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/MEMBER_INITIALIZER_LIST_STYLE/@EntryValue" value="DO_NOT_CHANGE" type="string" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/PLACE_NAMESPACE_DEFINITIONS_ON_SAME_LINE/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_COLON_IN_BITFIELD_DECLARATOR/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_COLON_IN_BITFIELD_DECLARATOR/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_EXTENDS_COLON/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_EXTENDS_COLON/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_FOR_COLON/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_FOR_COLON/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_PTR_IN_DATA_MEMBER/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_PTR_IN_DATA_MEMBERS/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_PTR_IN_METHOD/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_PTR_IN_NESTED_DECLARATOR/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_REF_IN_DATA_MEMBER/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_REF_IN_DATA_MEMBERS/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_REF_IN_METHOD/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_PTR_IN_ABSTRACT_DECL/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_PTR_IN_DATA_MEMBER/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_PTR_IN_DATA_MEMBERS/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_PTR_IN_METHOD/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_REF_IN_ABSTRACT_DECL/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_REF_IN_DATA_MEMBER/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_REF_IN_DATA_MEMBERS/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_REF_IN_METHOD/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_TEMPLATE_ARGS/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_TEMPLATE_PARAMS/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BETWEEN_CLOSING_ANGLE_BRACKETS_IN_TEMPLATE_ARGS/@EntryValue" value="true" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_WITHIN_EMPTY_TEMPLATE_PARAMS/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_WITHIN_TEMPLATE_ARGS/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_WITHIN_TEMPLATE_PARAMS/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_WITHIN_DECLARATION_PARENTHESES/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_WITHIN_EMPTY_BLOCKS/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_BEFORE_INVOCATION_LPAR/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_AFTER_INVOCATION_LPAR/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_BEFORE_INVOCATION_RPAR/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_BEFORE_DECLARATION_LPAR/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_AFTER_DECLARATION_LPAR/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_BEFORE_DECLARATION_RPAR/@EntryValue" value="false" type="bool" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_ARGUMENTS_STYLE/@EntryValue" value="WRAP_IF_LONG" type="string" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_PARAMETERS_STYLE/@EntryValue" value="WRAP_IF_LONG" type="string" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/BREAK_TEMPLATE_DECLARATION/@EntryValue" value="LINE_BREAK" type="string" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/NAMESPACE_DECLARATION_BRACES/@EntryValue" value="END_OF_LINE" type="string" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/FREE_BLOCK_BRACES/@EntryValue" value="END_OF_LINE" type="string" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/INVOCABLE_DECLARATION_BRACES/@EntryValue" value="END_OF_LINE" type="string" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ANONYMOUS_METHOD_DECLARATION_BRACES/@EntryValue" value="END_OF_LINE" type="string" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/INITIALIZER_BRACES/@EntryValue" value="END_OF_LINE_NO_SPACE" type="string" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/INDENT_STYLE/@EntryValue" value="Space" type="string" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/INDENT_SIZE/@EntryValue" value="4" type="int" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/CONTINUOUS_LINE_INDENT/@EntryValue" value="Double" type="string" />
<option name="/Default/CodeStyle/CodeFormatting/CppFormatting/TAB_WIDTH/@EntryValue" value="4" type="int" />
</component>
</project>

25
.idea/inspectionProfiles/Project_Default.xml generated
View File

@@ -1,6 +1,29 @@
<component name="InspectionProjectProfileManager">
<profile version="1.0">
<option name="myName" value="Project Default" />
<inspection_tool class="CodeBlock2Expr" enabled="true" level="TEXT ATTRIBUTES" enabled_by_default="true" editorAttributes="CONSIDERATION_ATTRIBUTES" />
<inspection_tool class="ClangTidy" enabled="true" level="WARNING" enabled_by_default="true">
<option name="clangTidyCheckOptions">
<list>
<ClangTidyCheckOption />
</list>
</option>
<option name="clangTidyChecks" value="-*,bugprone-argument-comment,bugprone-assert-side-effect,bugprone-bad-signal-to-kill-thread,bugprone-branch-clone,bugprone-copy-constructor-init,bugprone-dangling-handle,bugprone-dynamic-static-initializers,bugprone-fold-init-type,bugprone-forward-declaration-namespace,bugprone-forwarding-reference-overload,bugprone-inaccurate-erase,bugprone-incorrect-roundings,bugprone-integer-division,bugprone-lambda-function-name,bugprone-macro-repeated-side-effects,bugprone-misplaced-operator-in-strlen-in-alloc,bugprone-misplaced-pointer-arithmetic-in-alloc,bugprone-misplaced-widening-cast,bugprone-move-forwarding-reference,bugprone-multiple-statement-macro,bugprone-no-escape,bugprone-not-null-terminated-result,bugprone-parent-virtual-call,bugprone-posix-return,bugprone-sizeof-container,bugprone-sizeof-expression,bugprone-spuriously-wake-up-functions,bugprone-string-constructor,bugprone-string-integer-assignment,bugprone-string-literal-with-embedded-nul,bugprone-suspicious-enum-usage,bugprone-suspicious-include,bugprone-suspicious-memory-comparison,bugprone-suspicious-memset-usage,bugprone-suspicious-missing-comma,bugprone-suspicious-semicolon,bugprone-suspicious-string-compare,bugprone-swapped-arguments,bugprone-terminating-continue,bugprone-throw-keyword-missing,bugprone-too-small-loop-variable,bugprone-undefined-memory-manipulation,bugprone-undelegated-constructor,bugprone-unhandled-self-assignment,bugprone-unused-raii,bugprone-unused-return-value,bugprone-use-after-move,bugprone-virtual-near-miss,cert-dcl21-cpp,cert-dcl58-cpp,cert-err34-c,cert-err52-cpp,cert-err58-cpp,cert-err60-cpp,cert-flp30-c,cert-msc50-cpp,cert-msc51-cpp,cert-str34-c,cppcoreguidelines-interfaces-global-init,cppcoreguidelines-narrowing-conversions,cppcoreguidelines-pro-type-member-init,cppcoreguidelines-pro-type-static-cast-downcast,cppcoreguidelines-slicing,google-default-arguments,google-explicit-constructor,google-runtime-operator,hicpp-exception-baseclass,hicpp-multiway-paths-covered,misc-misplaced-const,misc-new-delete-overloads,misc-no-recursion,misc-non-copyable-objects,misc-throw-by-value-catch-by-reference,misc-unconventional-assign-operator,misc-uniqueptr-reset-release,modernize-avoid-bind,modernize-concat-nested-namespaces,modernize-deprecated-headers,modernize-deprecated-ios-base-aliases,modernize-loop-convert,modernize-make-shared,modernize-make-unique,modernize-pass-by-value,modernize-raw-string-literal,modernize-redundant-void-arg,modernize-replace-auto-ptr,modernize-replace-disallow-copy-and-assign-macro,modernize-replace-random-shuffle,modernize-return-braced-init-list,modernize-shrink-to-fit,modernize-unary-static-assert,modernize-use-auto,modernize-use-bool-literals,modernize-use-emplace,modernize-use-equals-default,modernize-use-equals-delete,modernize-use-nodiscard,modernize-use-noexcept,modernize-use-nullptr,modernize-use-override,modernize-use-transparent-functors,modernize-use-uncaught-exceptions,mpi-buffer-deref,mpi-type-mismatch,openmp-use-default-none,performance-faster-string-find,performance-for-range-copy,performance-implicit-conversion-in-loop,performance-inefficient-algorithm,performance-inefficient-string-concatenation,performance-inefficient-vector-operation,performance-move-const-arg,performance-move-constructor-init,performance-no-automatic-move,performance-noexcept-move-constructor,performance-trivially-destructible,performance-type-promotion-in-math-fn,performance-unnecessary-copy-initialization,performance-unnecessary-value-param,portability-simd-intrinsics,readability-avoid-const-params-in-decls,readability-const-return-type,readability-container-size-empty,readability-convert-member-functions-to-static,readability-delete-null-pointer,readability-deleted-default,readability-inconsistent-declaration-parameter-name,readability-make-member-function-const,readability-misleading-indentation,readability-misplaced-array-index,readability-non-const-parameter,readability-redundant-control-flow,readability-redundant-declaration,readability-redundant-function-ptr-dereference,readability-redundant-smartptr-get,readability-redundant-string-cstr,readability-redundant-string-init,readability-simplify-subscript-expr,readability-static-accessed-through-instance,readability-static-definition-in-anonymous-namespace,readability-string-compare,readability-uniqueptr-delete-release,readability-use-anyofallof" />
</inspection_tool>
<inspection_tool class="ClangdErrorsAndWarnings" enabled="false" level="WARNING" enabled_by_default="false" />
<inspection_tool class="EmptyDeclOrStmt" enabled="false" level="WARNING" enabled_by_default="false" />
<inspection_tool class="GrazieInspection" enabled="false" level="TYPO" enabled_by_default="false" />
<inspection_tool class="LanguageDetectionInspection" enabled="false" level="WARNING" enabled_by_default="false" />
<inspection_tool class="Misra" enabled="false" level="WARNING" enabled_by_default="false">
<option name="myMisraCPPChecks" value="clion-misra-cpp2008-*,-clion-misra-cpp2008-11-0-1" />
</inspection_tool>
<inspection_tool class="OCUnusedGlobalDeclaration" enabled="false" level="WARNING" enabled_by_default="false" />
<inspection_tool class="ShellCheck" enabled="false" level="ERROR" enabled_by_default="false">
<shellcheck_settings value="SC2034,SC2035,SC2059,SC2061,SC2091,SC2155" />
</inspection_tool>
<inspection_tool class="SpellCheckingInspection" enabled="false" level="TYPO" enabled_by_default="false">
<option name="processCode" value="true" />
<option name="processLiterals" value="true" />
<option name="processComments" value="true" />
</inspection_tool>
</profile>
</component>

1
.idea/vcs.xml generated
View File

@@ -2,6 +2,5 @@
<project version="4">
<component name="VcsDirectoryMappings">
<mapping directory="$PROJECT_DIR$" vcs="Git" />
<mapping directory="$PROJECT_DIR$/cbuild" vcs="Git" />
</component>
</project>

24
.vscode/launch.json vendored
View File

@@ -11,7 +11,19 @@
"stopAtEntry": false,
"externalConsole": false,
"MIMode": "gdb",
"miDebuggerPath": "gdb"
"miDebuggerPath": "gdb",
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "-enable-pretty-printing",
"ignoreFailures": true
},
{
"description": "Set Disassembly Flavor to Intel",
"text": "-gdb-set disassembly-flavor intel",
"ignoreFailures": true
}
]
},
{
"name": "(gdb-pipe) Debug",
@@ -30,16 +42,6 @@
"pipeArgs": ["-c"],
"pipeCwd": "${workspaceFolder}"
}
},
{
"name": "(msvc) Debug",
"type": "cppvsdbg",
"request": "launch",
"preLaunchTask": "build_dbg",
"program": "${workspaceFolder}\\bin\\kerep",
"cwd": "${workspaceFolder}\\bin",
"stopAtEntry": false,
"console": "integratedTerminal"
}
]
}

3
.vscode/tasks.json vendored
View File

@@ -23,8 +23,7 @@
"reveal": "always",
"focus": true,
"panel": "shared",
"showReuseMessage": false,
"clean": true
"showReuseMessage": false
}
}
]

2
Makefile
View File

@@ -57,7 +57,7 @@ gprof:
# compiles program and runs it with callgrind (part of valgrind)
# uses gprof2dot python script to generate function call tree (pip install gprof2dot)
# requires graphviz (https://www.graphviz.org/download/source/)
# P.S. detailed results can be viewed in KCacheGrind
# P.S. detailed rezults can be viewed in KCacheGrind
callgrind:
@cbuild/call_task.sh callgrind 2>&1 | tee make_raw.log

29
TODO.md Normal file
View File

@@ -0,0 +1,29 @@
## Allocators
- replace all malloc() and free() with allocator_alloc() and allocator_free()
- replace allocating constructors with Type_construct(var_ptr, ...)
- replace Struct_free functions with Struct_destruct which will not call free() on the struct ptr
- store in resizable structs their buffer allocators and free them with Struct_destruct()
- check allocator_free call order
- deal with StackingAllocator_free not freing memory sometimes
- replace LinearAllocator with StackingAllocator when possible (in DtsodV24_deserialize)
- use LinkedList instead of complicated LinearAllocator logic
- configurable LinearAllocator chunk size (static/growing)
## Autoarr
- store length and max_length inside the struct instead of calculating them by macro
- keep Autoarr_length() and Autoarr_maxLength() to old code compatibility
- toString()
## Hashtable
- store hash in KVPair
- don't use Autoarr in Hashtable
- make Hashtable generic struct
## Unitype
- replace UniPtrHeap with UniPtrStack
- do something with VoidPtr ownership
## String
- add `bool zero_terminated`
- rewrite all code to use `string` instead of `char*`
- rewrite `StringBuilder`

2
cbuild

Submodule cbuild updated: 574ce6eab3...60fa8c11c2

22
default.config
View File

@@ -1,6 +1,6 @@
#!/bin/bash
CBUILD_VERSION=7
CONFIG_VERSION=8
CONFIG_VERSION=7
PROJECT="kerep"
CMP_C="gcc"
@@ -37,12 +37,10 @@ case "$OS" in
WINDOWS)
EXEC_FILE="$PROJECT.exe"
SHARED_LIB_FILE="$PROJECT.dll"
LINKER_LIBS="-lpthread -lws2_32"
;;
LINUX)
EXEC_FILE="$PROJECT"
SHARED_LIB_FILE="$PROJECT.so"
LINKER_LIBS=""
;;
*)
error "operating system $OS has no configuration variants"
@@ -61,7 +59,7 @@ case "$TASK" in
# -fdata-sections -ffunction-sections -Wl,--gc-sections removes unused code
C_ARGS="-O2 -flto=auto -fuse-linker-plugin -fprofile-use -fprofile-prefix-path=$(realpath $OBJDIR)/objects -fdata-sections -ffunction-sections -Wl,--gc-sections"
CPP_ARGS="$C_ARGS"
LINKER_ARGS="$CPP_ARGS $LINKER_LIBS"
LINKER_ARGS="$CPP_ARGS"
PRE_TASK_SCRIPT=
TASK_SCRIPT=cbuild/default_tasks/build_exec.sh
POST_TASK_SCRIPT=
@@ -70,7 +68,7 @@ case "$TASK" in
build_exec_dbg)
C_ARGS="-O0 -g3"
CPP_ARGS="$C_ARGS"
LINKER_ARGS="$CPP_ARGS $LINKER_LIBS"
LINKER_ARGS="$CPP_ARGS"
PRE_TASK_SCRIPT=
TASK_SCRIPT=cbuild/default_tasks/build_exec.sh
POST_TASK_SCRIPT=
@@ -79,7 +77,7 @@ case "$TASK" in
build_shared_lib)
C_ARGS="-O2 -fpic -flto -shared"
CPP_ARGS="$C_ARGS"
LINKER_ARGS="$CPP_ARGS -Wl,-soname,$SHARED_LIB_FILE $LINKER_LIBS"
LINKER_ARGS="$CPP_ARGS -Wl,-soname,$SHARED_LIB_FILE"
PRE_TASK_SCRIPT=
TASK_SCRIPT=cbuild/default_tasks/build_shared_lib.sh
POST_TASK_SCRIPT=
@@ -88,7 +86,7 @@ case "$TASK" in
build_shared_lib_dbg)
C_ARGS="-O0 -g3 -fpic -shared"
CPP_ARGS="$C_ARGS"
LINKER_ARGS="$CPP_ARGS -Wl,-soname,$SHARED_LIB_FILE $LINKER_LIBS"
LINKER_ARGS="$CPP_ARGS -Wl,-soname,$SHARED_LIB_FILE"
PRE_TASK_SCRIPT=
TASK_SCRIPT=cbuild/default_tasks/build_shared_lib.sh
POST_TASK_SCRIPT=
@@ -129,7 +127,7 @@ case "$TASK" in
# -fprofile-prefix-path sets path where profiling info about objects will be saved
C_ARGS="-O2 -flto=auto -fuse-linker-plugin -fprofile-generate -fprofile-prefix-path=$(realpath $OBJDIR)/objects"
CPP_ARGS="$C_ARGS"
LINKER_ARGS="$CPP_ARGS $LINKER_LIBS"
LINKER_ARGS="$CPP_ARGS"
PRE_TASK_SCRIPT=cbuild/default_tasks/build_exec.sh
TASK_SCRIPT=cbuild/default_tasks/profile.sh
POST_TASK_SCRIPT=
@@ -142,7 +140,7 @@ case "$TASK" in
# -pg adds code to executable, that generates file containing function call info (gmon.out)
C_ARGS="-O2 -flto=auto -fuse-linker-plugin -pg"
CPP_ARGS="$C_ARGS"
LINKER_ARGS="$CPP_ARGS $LINKER_LIBS"
LINKER_ARGS="$CPP_ARGS"
PRE_TASK_SCRIPT=cbuild/default_tasks/build_exec.sh
TASK_SCRIPT=cbuild/default_tasks/gprof.sh
POST_TASK_SCRIPT=
@@ -150,13 +148,13 @@ case "$TASK" in
# compiles program and runs it with callgrind (part of valgrind)
# uses gprof2dot python script to generate function call tree (pip install gprof2dot)
# requires graphviz (https://www.graphviz.org/download/source/)
# P.S. detailed results can be viewed in KCacheGrind
# P.S. detailed rezults can be viewed in KCacheGrind
callgrind)
OUTDIR="$OUTDIR/callgrind"
# -pg adds code to executable, that generates file containing function call info (gmon.out)
C_ARGS="-O2 -flto=auto -fuse-linker-plugin"
CPP_ARGS="$C_ARGS"
LINKER_ARGS="$CPP_ARGS $LINKER_LIBS"
LINKER_ARGS="$CPP_ARGS"
PRE_TASK_SCRIPT=tasks/pre_build.sh
TASK_SCRIPT=cbuild/default_tasks/build_exec.sh
POST_TASK_SCRIPT=cbuild/default_tasks/callgrind.sh
@@ -166,7 +164,7 @@ case "$TASK" in
OUTDIR="$OUTDIR/sanitize"
C_ARGS="-O0 -g3 -fsanitize=undefined,address"
CPP_ARGS="$C_ARGS"
LINKER_ARGS="$CPP_ARGS $LINKER_LIBS"
LINKER_ARGS="$CPP_ARGS"
PRE_TASK_SCRIPT=cbuild/default_tasks/build_exec.sh
TASK_SCRIPT=cbuild/default_tasks/exec.sh
POST_TASK_SCRIPT=

27
src/Array/Array.c
View File

@@ -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; i<array->length; i++)
Unitype_free(array->values[i]);
if(array->allocatedOnHeap)
free(array->values);
}
void __Array_Unitype_free_(void* ar)
{ Array_Unitype_free_(ar, true); }

32
src/Array/Array.h
View File

@@ -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

39
src/Array/Array_declare.h
View File

@@ -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

14
src/Array/Array_define.h
View File

@@ -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

2
src/Array/README.md
View File

@@ -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`.

28
src/Autoarr/Autoarr.c
View File

@@ -1,17 +1,17 @@
#include "Autoarr.h"
Autoarr_define(Pointer, true)
Autoarr_define(char, false)
Autoarr_define(bool, false)
Autoarr_define(f32, false)
Autoarr_define(f64, false)
Autoarr_define(u8, false)
Autoarr_define(i8, false)
Autoarr_define(u16, false)
Autoarr_define(i16, false)
Autoarr_define(u32, false)
Autoarr_define(i32, false)
Autoarr_define(u64, false)
Autoarr_define(i64, false)
Autoarr_define(Pointer)
Autoarr_define(char)
Autoarr_define(bool)
Autoarr_define(f32)
Autoarr_define(f64)
Autoarr_define(u8)
Autoarr_define(i8)
Autoarr_define(u16)
Autoarr_define(i16)
Autoarr_define(u32)
Autoarr_define(i32)
Autoarr_define(u64)
Autoarr_define(i64)
Autoarr_define(Unitype, false)
Autoarr_define(Unitype)

15
src/Autoarr/Autoarr.h
View File

@@ -23,21 +23,6 @@ Autoarr_declare(u64)
Autoarr_declare(Unitype)
#define Autoarr_foreach(ar, elem, codeblock...) { \
if(ar->blocks_count>0) { \
typeof(**ar->values) elem; \
for(u16 blockI=0;blockI<ar->blocks_count-1;blockI++) \
for(u32 elemI=0;elemI<ar->max_block_length;elemI++){ \
elem=ar->values[blockI][elemI]; \
{ codeblock; } \
} \
for(u16 elemI=0;elemI<ar->block_length;elemI++){ \
elem=ar->values[ar->blocks_count-1][elemI]; \
{ codeblock; } \
} \
} \
}
#if __cplusplus
}
#endif

38
src/Autoarr/Autoarr_KVPair_exported.c
View File

@@ -1,38 +0,0 @@
#if __cplusplus
extern "C" {
#endif
#include "Autoarr.h"
#include "../Hashtable/KeyValuePair.h"
EXPORT void CALL kerep_Autoarr_KVPair_create(u16 max_blocks_count, u16 max_block_length, Autoarr_KVPair** output){
*output=Autoarr_create(KVPair, max_blocks_count, max_block_length);
}
EXPORT void CALL kerep_Autoarr_KVPair_free(Autoarr_KVPair* ar){
Autoarr_free(ar, true);
}
EXPORT void CALL kerep_Autoarr_KVPair_get(Autoarr_KVPair* ar, u32 index, KVPair* output){
*output=Autoarr_get(ar, index);
}
EXPORT void CALL kerep_Autoarr_KVPair_add(Autoarr_KVPair* ar, KVPair element){
Autoarr_add(ar, element);
}
EXPORT void CALL kerep_Autoarr_KVPair_set(Autoarr_KVPair* ar, u32 index, KVPair element){
Autoarr_set(ar, index, element);
}
EXPORT void CALL kerep_Autoarr_KVPair_length(Autoarr_KVPair* ar, u32* output){
*output=Autoarr_length(ar);
}
EXPORT void CALL kerep_Autoarr_KVPair_max_length(Autoarr_KVPair* ar, u32* output){
*output=Autoarr_max_length(ar);
}
#if __cplusplus
}
#endif

8
src/Autoarr/Autoarr_Unitype_exported.c → src/Autoarr/Autoarr_Unitype_exported.c_old
View File

@@ -4,12 +4,12 @@ extern "C" {
#include "Autoarr.h"
EXPORT void CALL kerep_Autoarr_Unitype_create(u16 max_blocks_count, u16 max_block_length, Autoarr_Unitype** output){
*output=Autoarr_create(Unitype, max_blocks_count, max_block_length);
EXPORT void CALL kerep_Autoarr_Unitype_create(u16 max_chunks_count, u16 max_chunk_length, Autoarr_Unitype** output){
*output=Autoarr_construct(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){

97
src/Autoarr/Autoarr_declare.h
View File

@@ -6,67 +6,60 @@ extern "C" {
#include "../base/base.h"
#define Autoarr_declare(type) \
#define Autoarr_declare(TYPE) \
\
struct Autoarr_##type; \
typedef struct Autoarr_##TYPE Autoarr_##TYPE; \
\
typedef struct __Autoarr_##type##_functions_list_t { \
void (*add)(struct Autoarr_##type* ar, type element); \
type (*get)(struct Autoarr_##type* ar, u32 index); \
type* (*getPtr)(struct Autoarr_##type* ar, u32 index); \
void (*set)(struct Autoarr_##type* ar, u32 index, type element); \
void (*freeWithMembers)(struct Autoarr_##type* ar, bool freePtr); \
void (*freeWithoutMembers)(struct Autoarr_##type* ar, bool freePtr); \
type* (*toArray)(struct Autoarr_##type* ar); \
} __Autoarr_##type##_functions_list_t; \
typedef struct __Autoarr_##TYPE##_functions_list_t { \
void (*add)(Autoarr_##TYPE* ar, TYPE element); \
TYPE (*get)(Autoarr_##TYPE* ar, u32 index); \
TYPE* (*getPtr)(Autoarr_##TYPE* ar, u32 index); \
void (*set)(Autoarr_##TYPE* ar, u32 index, TYPE element); \
TYPE* (*toArray)(Autoarr_##TYPE* ar, allocator_ptr array_holder); \
} __Autoarr_##TYPE##_functions_list_t; \
\
extern __Autoarr_##type##_functions_list_t __Autoarr_##type##_functions_list; \
\
STRUCT(Autoarr_##type, \
u16 blocks_count; \
u16 max_blocks_count; \
u16 block_length; \
u16 max_block_length; \
type** values; \
__Autoarr_##type##_functions_list_t* functions; \
STRUCT(Autoarr_##TYPE, \
InternalAllocator_declare(LinearAllocator); \
__Autoarr_##TYPE##_functions_list_t* functions; \
ktDescriptor* type; \
u32 length; \
TYPE* _typeof_target; \
) \
\
Autoarr_##type* __Autoarr_##type##_create(u16 max_blocks_count, u16 max_block_length); \
void __Autoarr_##type##_freeWithMembers(Autoarr_##type* ar, bool freePtr); \
void ____Autoarr_##type##_freeWithMembers(void* ar);
void __Autoarr_##TYPE##_construct(Autoarr_##TYPE* ar, alloc_size_t starting_size, allocator_ptr external_al); \
void __Autoarr_##TYPE##_destruct(Autoarr_##TYPE* ar); \
#define Autoarr(type) Autoarr_##type
#define Autoarr(TYPE) Autoarr_##TYPE
#define Autoarr_create(type, max_blocks_count, max_block_length) \
__Autoarr_##type##_create(max_blocks_count, max_block_length)
#define Autoarr_add(autoarr, element) \
autoarr->functions->add(autoarr, element)
#define Autoarr_get(autoarr, index) \
autoarr->functions->get(autoarr,index)
#define Autoarr_getPtr(autoarr, index) \
autoarr->functions->getPtr(autoarr,index)
#define Autoarr_set(autoarr, index, element) \
autoarr->functions->set(autoarr, index, element)
#define Autoarr_free(autoarr, freePtr) \
autoarr->functions->freeWithMembers(autoarr, freePtr)
#define Autoarr_freeWithoutMembers(autoarr, freePtr) \
autoarr->functions->freeWithoutMembers(autoarr, freePtr)
#define Autoarr_toArray(autoarr) \
autoarr->functions->toArray(autoarr)
#define Autoarr_construct(ptr, TYPE, starting_size, data_allocator) \
__Autoarr_##TYPE##_construct(ptr, starting_size, data_allocator)
#define Autoarr_destruct(autoarr) (autoarr)->type->destruct(autoarr)
#define Autoarr_add(autoarr, element) (autoarr)->functions->add(autoarr, element)
#define Autoarr_get(autoarr, index) (autoarr)->functions->get(autoarr,index)
#define Autoarr_getPtr(autoarr, index) (autoarr)->functions->getPtr(autoarr,index)
#define Autoarr_set(autoarr, index, element) (autoarr)->functions->set(autoarr, index, element)
#define Autoarr_toArray(autoarr, array_alloctr) (autoarr)->functions->toArray(autoarr, array_alloctr)
#define Autoarr_length(autoarr) (autoarr)->length
#define Autoarr_pop(autoarr) { \
u32 new_len=(autoarr)->length-1; \
allocator_free(InternalAllocator_getPtr((autoarr)), Autoarr_getPtr((autoarr), new_len)); \
(autoarr)->length=new_len; \
}
#define Autoarr_length(autoarr) \
(u32)(!autoarr->blocks_count ? 0 : \
autoarr->max_block_length*(autoarr->blocks_count-1)+autoarr->block_length)
#define Autoarr_max_length(autoarr) \
(u32)(autoarr->max_block_length*autoarr->max_blocks_count)
#define Autoarr_pop(AR){ \
if(AR->block_length==1){ \
AR->blocks_count--; \
AR->block_length=AR->max_block_length; \
free(AR->values[AR->blocks_count]); \
#define Autoarr_foreach(ar, elem, codeblock...) { \
if((ar)->length > 0) { \
typeof(*((ar)->_typeof_target)) elem; \
LinearAllocator* al=(LinearAllocator*)InternalAllocator_getPtr(ar); \
for(u16 chunk_i=0; chunk_i <= al->curr_chunk_i; chunk_i++) { \
MemoryChunk chunk = al->chunks[chunk_i]; \
alloc_size_t chunk_elem_count = chunk.occupied_size/sizeof(elem); \
typeof((ar)->_typeof_target) chunk_data = (void*)chunk.data; \
for(u32 elem##_i=0; elem##_i < chunk_elem_count; elem##_i++) { \
elem = chunk_data[elem##_i]; \
{ codeblock; } \
} \
} \
} \
else AR->block_length--; \
}
#if __cplusplus

116
src/Autoarr/Autoarr_define.h
View File

@@ -6,94 +6,72 @@ extern "C" {
#include "../base/base.h"
#define Autoarr_define(type, TYPE_IS_PTR) \
#define Autoarr_define(TYPE) \
\
kt_define(Autoarr_##type, ____Autoarr_##type##_freeWithMembers, NULL); \
void __Autoarr_##TYPE##_add(Autoarr_##TYPE* ar, TYPE element){ \
TYPE* ptr = allocator_alloc(InternalAllocator_getPtr(ar), sizeof(element)); \
*ptr=element; \
ar->length++; \
} \
\
void __Autoarr_##type##_add(Autoarr_##type* ar, type element){ \
if(!ar->values){ \
ar->values=malloc(ar->max_blocks_count*sizeof(type*)); \
goto create_block; \
TYPE* __Autoarr_##TYPE##_getPtr(Autoarr_##TYPE* ar, u32 index){ \
if(index >= Autoarr_length(ar)) \
throw(ERR_WRONGINDEX); \
u32 elem_count_sum=0; \
LinearAllocator* al=(LinearAllocator*)InternalAllocator_getPtr(ar); \
for(u16 chunk_i=0; chunk_i <= al->curr_chunk_i; chunk_i++) { \
MemoryChunk chunk = al->chunks[chunk_i]; \
alloc_size_t chunk_elem_count = chunk.occupied_size/sizeof(TYPE); \
alloc_size_t chunk_elem_i = index - elem_count_sum; \
if(chunk_elem_i < chunk_elem_count){ \
return chunk.data + chunk_elem_i*sizeof(TYPE); \
} \
elem_count_sum += chunk_elem_count; \
} \
if(ar->block_length==ar->max_block_length){ \
if (ar->blocks_count>=ar->max_blocks_count) throw(ERR_MAXLENGTH); \
ar->block_length=0; \
create_block: \
ar->values[ar->blocks_count]=malloc(ar->max_block_length*sizeof(type)); \
ar->blocks_count++; \
} \
ar->values[ar->blocks_count-1][ar->block_length]=element; \
ar->block_length++; \
return NULL; \
} \
\
type __Autoarr_##type##_get(Autoarr_##type* ar, u32 index){ \
if(index>=Autoarr_length(ar)) throw(ERR_WRONGINDEX); \
return ar->values[index/ar->max_block_length][index%ar->max_block_length]; \
TYPE __Autoarr_##TYPE##_get(Autoarr_##TYPE* ar, u32 index){ \
TYPE* ptr=__Autoarr_##TYPE##_getPtr(ar, index); \
return *ptr; \
} \
\
type* __Autoarr_##type##_getPtr(Autoarr_##type* ar, u32 index){ \
if(index>=Autoarr_length(ar)) throw(ERR_WRONGINDEX); \
return ar->values[index/ar->max_block_length]+(index%ar->max_block_length); \
void __Autoarr_##TYPE##_set(Autoarr_##TYPE* ar, u32 index, TYPE value){ \
TYPE* ptr=__Autoarr_##TYPE##_getPtr(ar, index); \
*ptr=value; \
} \
\
void __Autoarr_##type##_set(Autoarr_##type* ar, u32 index, type element){ \
if(index>=Autoarr_length(ar)) throw(ERR_WRONGINDEX); \
ar->values[index/ar->max_block_length][index%ar->max_block_length]=element; \
void __Autoarr_##TYPE##_destruct(Autoarr_##TYPE* ar){ \
InternalAllocator_destructIfInternal(LinearAllocator, ar); \
} \
\
void __Autoarr_##type##_freeWithoutMembers(Autoarr_##type* ar, bool freePtr){ \
for(u16 i=0; i<ar->blocks_count;i++) \
free(ar->values[i]); \
free(ar->values); \
if(freePtr) free(ar); \
} \
\
void __Autoarr_##type##_freeWithMembers(Autoarr_##type* ar, bool freePtr){ \
if(ktDescriptor_##type.freeMembers!=NULL) { \
Autoarr_foreach(ar, el, \
void* members_ptr=&el; \
if(TYPE_IS_PTR) members_ptr=*(type**)members_ptr; \
ktDescriptor_##type.freeMembers(members_ptr); \
); \
} \
__Autoarr_##type##_freeWithoutMembers(ar, freePtr);\
} \
void ____Autoarr_##type##_freeWithMembers(void* ar){ \
__Autoarr_##type##_freeWithMembers((Autoarr_##type*)ar, false); \
} \
\
type* __Autoarr_##type##_toArray(Autoarr_##type* ar){ \
TYPE* __Autoarr_##TYPE##_toArray(Autoarr_##TYPE* ar, allocator_ptr array_alloctr){ \
u32 length=Autoarr_length(ar); \
if(length==0) \
return NULL; \
type* array=malloc(length * sizeof(type)); \
for(u32 i=0; i<length; i++) \
array[i]=__Autoarr_##type##_get(ar, i); \
TYPE* array=allocator_alloc(array_alloctr, length); \
Autoarr_foreach(ar, el, { \
array[el_i]=el; \
}); \
return array; \
} \
\
__Autoarr_##type##_functions_list_t __Autoarr_##type##_functions_list={ \
&__Autoarr_##type##_add, \
&__Autoarr_##type##_get, \
&__Autoarr_##type##_getPtr, \
&__Autoarr_##type##_set, \
&__Autoarr_##type##_freeWithMembers, \
&__Autoarr_##type##_freeWithoutMembers, \
&__Autoarr_##type##_toArray \
__Autoarr_##TYPE##_functions_list_t __Autoarr_##TYPE##_functions_list={ \
&__Autoarr_##TYPE##_add, \
&__Autoarr_##TYPE##_get, \
&__Autoarr_##TYPE##_getPtr, \
&__Autoarr_##TYPE##_set, \
&__Autoarr_##TYPE##_toArray \
}; \
\
Autoarr_##type* __Autoarr_##type##_create(u16 max_blocks_count, u16 max_block_length){ \
Autoarr_##type* ar=malloc(sizeof(Autoarr_##type)); \
*ar=(Autoarr_##type){ \
.max_blocks_count=max_blocks_count, \
.blocks_count=0, \
.max_block_length=max_block_length, \
.block_length=0, \
.values=NULL, \
.functions=&__Autoarr_##type##_functions_list \
}; \
return ar; \
}
void __Autoarr_##TYPE##_construct(Autoarr_##TYPE* ar, alloc_size_t starting_size, allocator_ptr data_allocator){ \
InternalAllocator_setExternalOrConstruct(ar, data_allocator, LinearAllocator, starting_size); \
ar->functions=&__Autoarr_##TYPE##_functions_list; \
ar->type = &ktDescriptor_name(TYPE); \
ar->length=0; \
} \
\
kt_define(Autoarr_##TYPE, (destruct_t)__Autoarr_##TYPE##_destruct, NULL);
#if __cplusplus
}

4
src/DtsodParser/DtsodV24.c
View File

@@ -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);
void DtsodV24_destruct(Hashtable* dtsod){
Hashtable_destruct(dtsod);
}

2
src/DtsodParser/DtsodV24.h
View File

@@ -25,7 +25,7 @@ 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
}

96
src/DtsodParser/DtsodV24_deserialize.c
View File

@@ -1,8 +1,7 @@
#include "DtsodV24.h"
#include "../String/StringBuilder.h"
#define ARR_BC 64
#define ARR_BL 1024
#define ARR_SZ_START 64
typedef struct DeserializeSharedData{
@@ -10,11 +9,13 @@ typedef struct DeserializeSharedData{
char* sh_text;
bool sh_partOfDollarList;
bool sh_calledRecursively;
allocator_ptr sh_tmp_al;
} DeserializeSharedData;
#define text shared->sh_text
#define partOfDollarList shared->sh_partOfDollarList
#define calledRecursively shared->sh_calledRecursively
#define tmp_al shared->sh_tmp_al
// special func for throwing error messages about wrong characters in deserializing text
@@ -44,7 +45,7 @@ Maybe ERROR_WRONGCHAR(const char c, char* _text, char* text_first, const char* s
if(!_c) break;
}
char errmsg[1024];
ksprintf(errmsg,1024, "unexpected <%c> at:\n"
sprintf_s(errmsg, sizeof(errmsg), "unexpected <%c> at:\n"
" \"%s\"\n"
"\\___[%s:%d] %s()",
c,errBuf, srcfile,line,funcname);
@@ -94,7 +95,7 @@ Maybe __ReadName(DeserializeSharedData* shared){
safethrow_wrongchar(c,;);
return SUCCESS(UniHeapPtr(char,NULL));
case ':':
return SUCCESS(UniHeapPtr(char,string_extract(nameStr)));
return SUCCESS(UniHeapPtr(char,string_extract(tmp_al, nameStr)));
case '$':
if(nameStr.length!=0)
safethrow_wrongchar(c,;);
@@ -111,7 +112,7 @@ Maybe __ReadName(DeserializeSharedData* shared){
}
#define ReadName() __ReadName(shared)
Maybe __deserialize(char** _text, bool _calledRecursively);
Maybe __deserialize(char** _text, bool _calledRecursively, allocator_ptr _tmp_al);
Maybe __ReadValue(DeserializeSharedData* shared, bool* readingList);
#define ReadValue(rL) __ReadValue(shared, rL)
@@ -119,7 +120,9 @@ Maybe __ReadValue(DeserializeSharedData* shared, bool* readingList);
Maybe __ReadString(DeserializeSharedData* shared){
char c;
bool prevIsBackslash=false;
StringBuilder* b=StringBuilder_create();
StringBuilder _sb;
StringBuilder* b=&_sb;
StringBuilder_construct(b, tmp_al);
while ((c=*++text)){
if(c=='"') {
@@ -140,24 +143,25 @@ Maybe __ReadString(DeserializeSharedData* shared){
}
}
safethrow(ERR_ENDOFSTR, StringBuilder_free(b));
safethrow(ERR_ENDOFSTR, StringBuilder_destruct(b));
}
#define ReadString() __ReadString(shared)
Maybe __ReadList(DeserializeSharedData* shared){
Autoarr(Unitype)* list=Autoarr_create(Unitype,ARR_BC,ARR_BL);
Autoarr(Unitype) list;
Autoarr_construct(&list, Unitype, ARR_SZ_START, NULL);
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))
Autoarr_add(&list, m_val.value);
if (!readingList){
if(Unitype_isUniNull(m_val.value))
Autoarr_pop(list);
Autoarr_pop(&list);
break;
}
}
return SUCCESS(UniHeapPtr(Autoarr_Unitype,list));
return SUCCESS(UniHeapPtr(Autoarr_Unitype, &list));
};
#define ReadList() __ReadList(shared)
@@ -175,34 +179,34 @@ Maybe __ParseValue(DeserializeSharedData* shared, string str){
else safethrow_wrongchar(*str.ptr,;);
// Float64
case 'f': {
char* _c=string_extract(str);
char* _c=string_extract(tmp_al, str);
Unitype rez=UniFloat64(strtod(_c,NULL));
free(_c);
// allocator_free(tmp_al,_c);
return SUCCESS(rez);
}
// UInt64
case 'u': {
u64 lu=0;
char* _c=string_extract(str);
char* _c=string_extract(tmp_al, str);
if(sscanf(_c, IFWIN("%llu", "%lu"), &lu)!=1){
char err[64];
ksprintf(err,64,"can't parse to int: <%s>",_c);
safethrow(err,free(_c));
sprintf_s(err, sizeof(err), "can't parse to int: <%s>", _c);
safethrow(err, /*allocator_free(tmp_al, _c)*/);
}
free(_c);
// allocator_free(tmp_al, _c);
return SUCCESS(UniUInt64(lu));
}
// Int64
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9': {
i64 li=0;
char* _c=string_extract(str);
char* _c=string_extract(tmp_al, str);
if(sscanf(_c, IFWIN("%lli", "%li"), &li)!=1){
char err[64];
ksprintf(err,64,"can't parse to int: <%s>",_c);
safethrow(err,free(_c));
sprintf_s(err, sizeof(err),"can't parse to int: <%s>",_c);
// safethrow(err,allocator_free(tmp_al, _c));
}
free(_c);
// allocator_free(tmp_al, _c);
return SUCCESS(UniInt64(li));
}
// wrong type
@@ -230,35 +234,35 @@ Maybe __ReadValue(DeserializeSharedData* shared, bool* readingList){
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));
if(valueStr.length!=0) safethrow_wrongchar(c,Unitype_destruct(&value));
++text; // skips '{'
try(__deserialize(&text,true), val,Unitype_free(value))
try(__deserialize(&text,true,tmp_al), 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 ';':
@@ -266,14 +270,14 @@ Maybe __ReadValue(DeserializeSharedData* shared, bool* readingList){
return_value:
if(valueStr.length!=0){
if(!Unitype_isUniNull(value))
safethrow_wrongchar(c,Unitype_free(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;
}
@@ -282,25 +286,29 @@ Maybe __ReadValue(DeserializeSharedData* shared, bool* readingList){
}
Maybe __deserialize(char** _text, bool _calledRecursively) {
Maybe __deserialize(char** _text, bool _calledRecursively, allocator_ptr _tmp_al) {
DeserializeSharedData _shared={
.sh_text_first=*_text,
.sh_text=*_text,
.sh_partOfDollarList=false,
.sh_calledRecursively=_calledRecursively
.sh_calledRecursively=_calledRecursively,
.sh_tmp_al=_tmp_al
};
DeserializeSharedData* shared=&_shared;
Hashtable* dict=Hashtable_create();
Hashtable _dict;
Hashtable* dict = &_dict;
Hashtable_construct(dict, _tmp_al);
text--;
while(true){
try(ReadName(), maybeName, Hashtable_free(dict))
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);
free(nameCPtr);
Hashtable_destruct(dict);
// do not use, free call order is incorrect
// allocator_free(tmp_al, nameCPtr);
}) {
if(partOfDollarList){
partOfDollarList=false;
@@ -310,10 +318,12 @@ Maybe __deserialize(char** _text, bool _calledRecursively) {
list=(Autoarr(Unitype)*)lu.VoidPtr;
// Key is not used in that case, because it is already added
// to the table with the first dollar list item.
free(nameCPtr);
// do not use, free call order is incorrect
// allocator_free(tmp_al, nameCPtr);
}
else{
list=Autoarr_create(Unitype,ARR_BC,ARR_BL);
list=allocator_alloc(tmp_al, sizeof(*list));
Autoarr_construct(list, Unitype, ARR_SZ_START, NULL);
Hashtable_add(dict,nameCPtr,UniHeapPtr(Autoarr_Unitype,list));
}
Autoarr_add(list,val.value);
@@ -328,5 +338,9 @@ Maybe __deserialize(char** _text, bool _calledRecursively) {
}
Maybe DtsodV24_deserialize(char* _text) {
return __deserialize(&_text, false);
LinearAllocator _tmp_al;
LinearAllocator_construct(&_tmp_al, 1024);
Maybe m=__deserialize(&_text, false, (allocator_ptr)&_tmp_al);
LinearAllocator_destruct(&_tmp_al);
return m;
}

62
src/DtsodParser/DtsodV24_exported.c
View File

@@ -1,62 +0,0 @@
//
// 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" {
#endif
#include "DtsodV24.h"
// parses text to binary values
EXPORT void CALL kerep_DtsodV24_deserialize(char* text, Hashtable** output, char** errmsg){
Maybe r=DtsodV24_deserialize(text);
*errmsg=r.errmsg;
*output=r.value.VoidPtr;
}
// creates text representation of dtsod
EXPORT void CALL kerep_DtsodV24_serialize(Hashtable* dtsod, char** output, char** errmsg){
Maybe r=DtsodV24_serialize(dtsod);
*errmsg=r.errmsg;
*output=r.value.VoidPtr;
}
// returns value or UniNull if key not found
EXPORT void CALL kerep_DtsodV24_get(Hashtable* dtsod, char* key, Unitype* output){
*output=DtsodV24_get(dtsod, key);
}
// adds or sets the value
EXPORT void CALL kerep_DtsodV24_addOrSet(Hashtable* dtsod, char* key, Unitype value){
DtsodV24_addOrSet(dtsod, key, value);
}
// checks for dtsod contains value or dont
EXPORT void CALL kerep_DtsodV24_contains(Hashtable* dtsod, char* key, bool* output){
*output=DtsodV24_contains(dtsod, key);
}
// replaces value with UniNull if key exists in dtsod
EXPORT void CALL kerep_DtsodV24_remove(Hashtable* dtsod, char* key, bool* output){
*output=DtsodV24_remove(dtsod, key);
}
// 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_height(Hashtable* dtsod, u16* heigth){
*heigth=Hashtable_height(dtsod);
}
EXPORT void CALL kerep_DtsodV24_getrow(Hashtable* dtsod, u16 h, Autoarr_KVPair** row){
*row=dtsod->rows[h];
}
#if __cplusplus
}
#endif

9
src/DtsodParser/DtsodV24_serialize.c
View File

@@ -123,8 +123,13 @@ 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));
LinearAllocator _al; allocator_ptr al=(allocator_ptr)&_al;
LinearAllocator_construct(&_al, 512);
StringBuilder _sb;
StringBuilder* sb=&_sb;
StringBuilder_construct(sb, al);
try(__serialize(sb,0,dtsod),__, StringBuilder_destruct(sb); LinearAllocator_destruct(&_al););
char* str=StringBuilder_build(sb).ptr;
LinearAllocator_destruct(&_al);
return SUCCESS(UniHeapPtr(char, str));
}

11
src/Filesystem/dir.c
View File

@@ -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,10 +37,10 @@ Maybe dir_create(const char* path){
#endif
{
char err[512];
ksprintf(err, 512, "can't create dicectory <%s>", path);
safethrow(err,;);
sprintf_s(err, sizeof(err), "can't create dicectory <%s>", path);
safethrow(err, LinearAllocator_destruct(&_al));
}
LinearAllocator_destruct(&_al);
return MaybeNull;
}

49
src/Filesystem/file.c
View File

@@ -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));
LinearAllocator_destruct(&_al);
return SUCCESS(UniHeapPtr(FileHandle,file));
}
@@ -64,64 +67,66 @@ Maybe file_close(FileHandle file){
}
#define ioWriteCheck() \
if(result==EOF) \
if(rezult==EOF) \
safethrow(ERR_IO_EOF,;); \
if(result!=0) \
if(rezult!=0) \
safethrow(ERR_IO,;);
Maybe file_writeChar(FileHandle file, char byte){
i32 result=fputc(byte, file);
i32 rezult=fputc(byte, file);
ioWriteCheck();
return MaybeNull;
}
Maybe file_writeBuffer(FileHandle file, char* buffer, u64 length){
i32 result=0;
for(u64 i=0; i<length && !result; i++)
result=fputc(buffer[i], file);
i32 rezult=0;
for(u64 i=0; i<length && !rezult; i++)
rezult=fputc(buffer[i], file);
ioWriteCheck();
return MaybeNull;
}
Maybe file_writeCptr(FileHandle file, char* cptr){
i32 result=fputs(cptr, file);
i32 rezult=fputs(cptr, file);
ioWriteCheck();
return MaybeNull;
}
Maybe file_readChar(FileHandle file){
i32 result=fgetc(file);
i32 rezult=fgetc(file);
if(feof(file)) safethrow(ERR_IO_EOF,;);
if(ferror(file)) safethrow(ERR_IO,;);
return SUCCESS(UniUInt64(result));
return SUCCESS(UniUInt64(rezult));
}
Maybe file_readBuffer(FileHandle file, char* buffer, u64 length){
i32 result=0;
i32 rezult=0;
u64 i=0;
for(; i<length && result!=EOF; i++){
result=fgetc(file);
buffer[i]=(char)result;
for(; i<length && rezult!=EOF; i++){
rezult=fgetc(file);
buffer[i]=(char)rezult;
}
if(ferror(file)) safethrow(ERR_IO,;);
return SUCCESS(UniUInt64(i));
}
Maybe file_readAll(FileHandle file, char** allBytes){
i32 result=0;
i32 rezult=0;
char buffer[256];
string bufStr={.ptr=buffer, .length=sizeof(buffer)};
StringBuilder* sb=StringBuilder_create();
StringBuilder _sb;
StringBuilder* sb=&_sb;
StringBuilder_construct(sb, NULL);
u64 i=0;
while(true){
result=fgetc(file);
if(result==EOF){
rezult=fgetc(file);
if(rezult==EOF){
if(ferror(file))
safethrow(ERR_IO, StringBuilder_free(sb));
safethrow(ERR_IO, StringBuilder_destruct(sb));
break;
}
buffer[i%sizeof(buffer)]=(char)result;
buffer[i%sizeof(buffer)]=(char)rezult;
i++;
if(!(i%sizeof(buffer)))
StringBuilder_append_string(sb,bufStr);

1
src/Filesystem/file.h
View File

@@ -5,7 +5,6 @@ extern "C" {
#endif
#include "../base/base.h"
#include "../Array/Array.h"
#include "../String/string.h"
typedef FILE* FileHandle;

42
src/Filesystem/path.c
View File

@@ -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,11 +18,11 @@ 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;
// copying content of all strings to result
// copying content of all strings to rezult
u16 k=0;
for(; k<n-1; k++){
memcpy(totality, parts[k], lengths[k]);
@@ -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,17 @@ 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));
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 +67,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,13 +76,13 @@ 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 result=string_fromCptr(path+nameIndex);
string rezult=string_fromCptr(path+nameIndex);
if(!with_extension){
i32 extIndex=cptr_lastIndexOfChar(result.ptr, '.');
i32 extIndex=cptr_lastIndexOfChar(rezult.ptr, '.');
if(extIndex!=0 && extIndex!=-1)
result.length=extIndex;
rezult.length=extIndex;
}
return string_extract(result);
return string_extract(al, rezult);
}

12
src/Filesystem/path.h
View File

@@ -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 <path_sep> 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 <path_notSep>
/// @return new cstr with correct separators
char* path_fixSeparators(const char* path);
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,10 +32,10 @@ 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
}

60
src/Hashtable/Hashtable.c
View File

@@ -1,74 +1,70 @@
#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};
#define HT_HEIN_MIN 0
#define HT_HEIN_MAX 6
#define ARR_BC 2
#define ARR_BL 8
#define ARR_SIZE_MAX 16
Hashtable* Hashtable_create(){
Hashtable* ht=malloc(sizeof(Hashtable));
void Hashtable_construct(Hashtable* ht, allocator_ptr external_al){
InternalAllocator_setExternalOrConstruct(ht, external_al, LinearAllocator, 1024);
ht->hein=HT_HEIN_MIN;
ht->rows=malloc(HT_HEIGHTS[HT_HEIN_MIN]*sizeof(Autoarr(KVPair)*));
for(u16 i=0;i<HT_HEIGHTS[HT_HEIN_MIN];i++)
ht->rows[i]=Autoarr_create(KVPair,ARR_BC,ARR_BL);
return ht;
allocator_ptr internal_al = InternalAllocator_getPtr(ht);
for(u16 i=0; i<HT_HEIGHTS[HT_HEIN_MIN]; i++)
Autoarr_construct(&ht->rows[i], KVPair, 16, internal_al);
}
void __Hashtable_free(void* _ht){
u16 __Hashtable_height(Hashtable* ht) { return HT_HEIGHTS[ht->hein]; }
void __Hashtable_destruct(void* _ht){
Hashtable* ht=_ht;
for(u16 i=0;i<HT_HEIGHTS[ht->hein];i++)
Autoarr_free(ht->rows[i], true);
free(ht->rows);
Autoarr_destruct(&ht->rows[i]);
allocator_free(InternalAllocator_getPtr(ht), ht->rows);
InternalAllocator_destructIfInternal(LinearAllocator, ht);
}
void Hashtable_free(Hashtable* ht){
__Hashtable_free(ht);
free(ht);
void Hashtable_destruct(Hashtable* ht){
__Hashtable_destruct(ht);
}
u16 Hashtable_height(Hashtable* ht) { return HT_HEIGHTS[ht->hein]; }
void Hashtable_expand(Hashtable* ht){
if(ht->hein>=HT_HEIN_MAX) throw(ERR_MAXLENGTH);
Autoarr(KVPair)** newrows=malloc(HT_HEIGHTS[++ht->hein]*sizeof(Autoarr(KVPair)*));
Autoarr(KVPair)* newrows=malloc(HT_HEIGHTS[++ht->hein]*sizeof(Autoarr(KVPair)*));
for(u16 i=0;i<HT_HEIGHTS[ht->hein];i++)
newrows[i]=Autoarr_create(KVPair,ARR_BC,ARR_BL);
Autoarr_construct(&newrows[i], KVPair, ARR_SIZE_MAX, InternalAllocator_getPtr(ht));
for(u16 i=0;i<HT_HEIGHTS[ht->hein-1];i++){
Autoarr(KVPair)* ar=ht->rows[i];
Autoarr(KVPair)* ar=&ht->rows[i];
u32 arlen=Autoarr_length(ar);
for(u32 k=0;k<arlen;k++){
KVPair p=Autoarr_get(ar,k);
u16 newrown=hashs(hash_sdbm32, p.key)%HT_HEIGHTS[ht->hein];
Autoarr(KVPair)* newar=newrows[newrown];
Autoarr(KVPair)* newar=&newrows[newrown];
Autoarr_add(newar,p);
}
// 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_destruct(ar);
}
free(ht->rows);
ht->rows=newrows;
ht->rows = newrows;
}
Autoarr(KVPair)* getrow(Hashtable* ht, char* key, bool can_expand){
u32 hash=hashs(hash_sdbm32, key);
Autoarr(KVPair)* ar=ht->rows[hash%HT_HEIGHTS[ht->hein]];
if(can_expand && Autoarr_length(ar)==Autoarr_max_length(ar))
Autoarr(KVPair)* ar=&ht->rows[hash%HT_HEIGHTS[ht->hein]];
if(can_expand && Autoarr_length(ar) == ARR_SIZE_MAX)
Hashtable_expand(ht);
ar=ht->rows[hash%HT_HEIGHTS[ht->hein]];
ar=&ht->rows[hash%HT_HEIGHTS[ht->hein]];
return ar;
}
/// @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);
@@ -86,7 +82,8 @@ Unitype* Hashtable_getPtr(Hashtable* ht, char* key){
u32 arlen=Autoarr_length(ar);
for(u32 i=0;i<arlen;i++){
KVPair* p=Autoarr_getPtr(ar,i);
if(cptr_equals(key,p->key)) return &p->value;
if(cptr_equals(key,p->key))
return &p->value;
}
return NULL;
}
@@ -96,7 +93,8 @@ Unitype Hashtable_get(Hashtable* ht, char* key){
u32 arlen=Autoarr_length(ar);
for(u32 i=0;i<arlen;i++){
KVPair p=Autoarr_get(ar,i);
if(cptr_equals(key,p.key)) return p.value;
if(cptr_equals(key,p.key))
return p.value;
}
return UniNull;
}

20
src/Hashtable/Hashtable.h
View File

@@ -9,16 +9,14 @@ extern "C" {
#include "KeyValuePair.h"
STRUCT(Hashtable,
InternalAllocator_declare(LinearAllocator);
u8 hein; // height=HT_HEIGHTS[hein]
Autoarr(KVPair)** rows; // Autoarr[height]
Autoarr(KVPair)* rows; // Autoarr[height]
)
Hashtable* Hashtable_create();
void Hashtable_free(Hashtable* ht);
void __Hashtable_free(void* ht);
// amount of rows
u16 Hashtable_height(Hashtable* ht);
void Hashtable_construct(Hashtable* ht, allocator_ptr external_al);
void Hashtable_destruct(Hashtable* ht);
void __Hashtable_destruct(void* ht);
// don't add pairs with the same keys,
// or something weird will happen
@@ -36,11 +34,13 @@ Unitype* Hashtable_getPtr(Hashtable* ht, char* key);
Unitype Hashtable_get(Hashtable* ht, char* key);
bool Hashtable_tryGet(Hashtable* ht, char* key, Unitype* output);
u16 __Hashtable_height(Hashtable* ht);
#define Hashtable_foreach(HT, EL, codeblock...) { \
u16 hmax=Hashtable_height(HT); \
u16 hmax=__Hashtable_height(HT); \
for(u16 h=0; h<hmax; h++){ \
Autoarr(KVPair)* AR=HT->rows[h]; \
Autoarr_foreach(AR, EL, codeblock); \
Autoarr(KVPair)* row=&HT->rows[h]; \
Autoarr_foreach(row, EL, codeblock); \
} \
}

11
src/Hashtable/KeyValuePair.c
View File

@@ -1,15 +1,8 @@
#include "KeyValuePair.h"
kt_define(KVPair, __KVPair_free, NULL);
kt_define(KVPair, NULL, NULL);
Autoarr_define(KVPair, false)
// proper way to clean a KVP
void KVPair_free(KVPair p){
free(p.key);
Unitype_free(p.value);
}
void __KVPair_free(void* p){ KVPair_free(*(KVPair*)p); }
Autoarr_define(KVPair)
void printkvp(KVPair p){
kprintf("{\"%s\", ",p.key);

4
src/Hashtable/KeyValuePair.h
View File

@@ -14,9 +14,7 @@ STRUCT(KVPair,
Autoarr_declare(KVPair)
// proper way to clean a KVP
void KVPair_free(KVPair p);
void __KVPair_free(void* p);
void __KVPair_destruct(void* p);
void printkvp(KVPair p);

2
src/LinkedList/LinkedList.h
View File

@@ -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->destruct(LLIST); free(LLIST); })
void LinkedList_addToBeginning(void* _llist, void* _new_node);

4
src/LinkedList/LinkedList_declare.h
View File

@@ -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)\
@@ -27,7 +27,7 @@ STRUCT(LinkedList(TYPE), \
) \
\
typedef struct LinkedList_##TYPE##_functions_t { \
freeMembers_t freeMembers; \
destruct_t destruct; \
void (*removePrev)(LinkedList(TYPE)* llist, LLNode(TYPE)* nextNode, bool freeRemoved); \
void (*removeNext)(LinkedList(TYPE)* llist, LLNode(TYPE)* prevNode, bool freeRemoved); \
} LinkedList_##TYPE##_functions_t; \

22
src/LinkedList/LinkedList_define.h
View File

@@ -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); \
ktDescriptor_##TYPE.destruct(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, \
.destruct=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

4
src/Network/README.md
View File

@@ -1,4 +0,0 @@
# kerep network
Don't forget to call `kn_tryInit()` before doint anything with network.

44
src/Network/network.c
View File

@@ -1,44 +0,0 @@
#include "network_internal.h"
Maybe kn_tryInit(){
#if _WIN32
// Initialize Winsock
WSADATA wsaData = {0};
int startupResult = WSAStartup(MAKEWORD(2,2), &wsaData);
if (startupResult != 0) {
char* errcode = toString_hex(&startupResult, sizeof(int), 0 , 1, 1);
safethrow(cptr_concat("WSAStartup failed with error: ", errcode), ;);
}
#endif
return SUCCESS(UniNull);
}
Maybe kt_tryDispose(){
#if _WIN32
// Deinitialize Winsock
int cleanupResult = WSACleanup();
if (cleanupResult != 0) {
char* errcode = toString_hex(&cleanupResult, sizeof(int), 0, 1, 1);
safethrow(cptr_concat("WSAStartup failed with error: ", errcode), ;);
}
#endif
return SUCCESS(UniNull);
}
Maybe __kn_StdSocket_shutdown(i64 socketfd, knShutdownType direction){
if(shutdown(socketfd, (int)direction) == -1)
safethrow("can't shutdown socket", ;);
return MaybeNull;
}
Maybe __kn_StdSocket_close(i64 socketfd){
#if KN_USE_WINSOCK
if(closesocket(socketfd) == -1)
#else
if(close(socketfd) == -1)
#endif
safethrow("can't close socket", ;);
return MaybeNull;
}

19
src/Network/network.h
View File

@@ -1,19 +0,0 @@
#pragma once
#if __cplusplus
extern "C" {
#endif
#include "../base/base.h"
#include "network_types.h"
#include "sockets/knSocketTCP.h"
#include "sockets/knSocketUDP.h"
#include "sockets/knSocketChanneled.h"
Maybe kn_tryInit();
Maybe kt_tryDispose();
#if __cplusplus
}
#endif

32
src/Network/network_internal.h
View File

@@ -1,32 +0,0 @@
#pragma once
#if __cplusplus
extern "C" {
#endif
#include "network.h"
#include "socket_impl_includes.h"
/// shutdown TCP/UDP/other std socket
Maybe __kn_StdSocket_shutdown(i64 socketfd, knShutdownType direction);
/// close TCP/UDP/other std socket
Maybe __kn_StdSocket_close(i64 socketfd);
static inline struct sockaddr_in knIPV4Endpoint_toSockaddr(knIPV4Endpoint end){
struct sockaddr_in saddr = {0};
saddr.sin_family = AF_INET;
saddr.sin_addr.s_addr = end.address.UintBigEndian;
saddr.sin_port = htons(end.port); /* transforms port number to big endian (network order) */
return saddr;
}
static inline knIPV4Endpoint knIPV4Endpoint_fromSockaddr(struct sockaddr_in saddr_ptr){
knIPV4Address ipv4 = knIPV4Address_fromU32(saddr_ptr.sin_addr.s_addr);
u16 port = ntohs(saddr_ptr.sin_port); /* transforms port number to little endian (normal order) */
return knIPV4Endpoint_create(ipv4, port);
}
#if __cplusplus
}
#endif

95
src/Network/network_types.c
View File

@@ -1,95 +0,0 @@
#include "network_types.h"
char* __knIPV4Address_toString(void* p, u32 f){ return knIPV4Address_toString(*(knIPV4Address*)p); }
char* __knIPV4Endpoint_toString(void* p, u32 f){ return knIPV4Endpoint_toString(*(knIPV4Endpoint*)p); }
kt_define(knIPV4Address, NULL, __knIPV4Address_toString);
kt_define(knIPV4Endpoint, NULL, __knIPV4Endpoint_toString);
Maybe knIPV4Address_fromStr(char* addrStr, knIPV4Address* addrVal){
char* addrStr_src=addrStr;
char* errmsg_extra="wrong char";
u8 c;
knIPV4Address addr;
addr.UintBigEndian=0;
u16 n=0;
for(u8 i=0; i<4; ){
c=*addrStr++;
switch (c){
case '\0':
if(i<3){
errmsg_extra="end of string";
goto default_case;
}
addr.bytes[i++]=n;
n=0;
break;
case '.':
addr.bytes[i++]=n;
n=0;
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
n=n*10+c-'0';
if(n>255) {
errmsg_extra="one part of address > 255";
goto default_case;
}
break;
default_case:
default:
u32 errmsgL=cptr_length(addrStr) + 80;
char* errmsg=malloc(errmsgL);
ksprintf(errmsg, errmsgL, "wrong ip address string: %s\n %s", addrStr_src, errmsg_extra);
safethrow(errmsg,;);
break;
}
}
*addrVal=addr;
return MaybeNull;
}
char* knIPV4Address_toString(knIPV4Address address) {
char* a = toString_u64(address.bytes[0], 0, 0);
char* b = toString_u64(address.bytes[1], 0, 0);
char* c = toString_u64(address.bytes[2], 0, 0);
char* d = toString_u64(address.bytes[3], 0, 0);
char* s = cptr_concat(a,".",b,".",c,".",d);
free(a);
free(b);
free(c);
free(d);
return s;
}
Maybe knIPV4Endpoint_fromStr(char* endStr, knIPV4Endpoint* endVal){
i32 sep_i = cptr_seekChar(endStr, ':', 0, 48);
if(sep_i < 7)
safethrow(cptr_concat("can't find ':' in '", endStr, "'"), ;);
const char* portBegin = endStr+sep_i+1;
u64 port = knPort_INVALID;
if(sscanf(portBegin, IFWIN("%llu", "%lu"), &port)!=1)
safethrow(cptr_concat("can't recognise port number in '", portBegin, "'"), ;)
knIPV4Address addr = knIPV4Address_INVALID;
char* addrStr = cptr_copy(endStr);
addrStr[sep_i] = 0;
try(knIPV4Address_fromStr(addrStr, &addr), _m865, ;);
free(addrStr);
*endVal = knIPV4Endpoint_create(addr, port);
return MaybeNull;
}
char* knIPV4Endpoint_toString(knIPV4Endpoint end) {
char* a = knIPV4Address_toString(end.address);
char* p = toString_u64(end.port, 0, 0);
char* s = cptr_concat(a,":",p);
free(a);
free(p);
return s;
}

58
src/Network/network_types.h
View File

@@ -1,58 +0,0 @@
#pragma once
#if __cplusplus
extern "C" {
#endif
#include "../base/base.h"
typedef u16 knPort;
#define knPort_INVALID ((knPort)~0)
#define knPort_isINVALID(PORT) (PORT == knPort_INVALID)
typedef union knIPV4Address {
u32 UintBigEndian;
u8 bytes[4];
} knIPV4Address;
kt_declare(knIPV4Address);
#define knIPV4Address_fromBytes(A, B, C, D) ((knIPV4Address){.bytes={A,B,C,D}})
#define knIPV4Address_fromU32(N) ((knIPV4Address){.UintBigEndian=N})
#define knIPV4Address_ANY knIPV4Address_fromBytes(0,0,0,0)
#define knIPV4Address_LOOPBACK knIPV4Address_fromBytes(127,0,0,1)
#define knIPV4Address_INVALID knIPV4Address_fromBytes(255,255,255,255)
#define knIPV4Address_isINVALID(ADDR) (ADDR.UintBigEndian == (u32)~0)
///@return Maybe<null>
Maybe knIPV4Address_fromStr(char* addrStr, knIPV4Address* addrPtr);
char* knIPV4Address_toString(knIPV4Address address);
STRUCT(knIPV4Endpoint,
knIPV4Address address;
knPort port;
)
#define knIPV4Endpoint_create(ADDR, PORT) ((knIPV4Endpoint){ADDR, PORT})
#define knIPV4Endpoint_INVALID knIPV4Endpoint_create(knIPV4Address_INVALID, knPort_INVALID)
#define knIPV4Endpoint_isINVALID(ENDP) (knIPV4Address_isINVALID(ENDP.address) || knPort_isINVALID(ENDP.port))
///@return Maybe<null>
Maybe knIPV4Endpoint_fromStr(char* endStr, knIPV4Endpoint* endVal);
char* knIPV4Endpoint_toString(knIPV4Endpoint end);
typedef enum knShutdownType {
knShutdownType_Receive = 0,
knShutdownType_Send = 1,
knShutdownType_Both = 2,
} knShutdownType;
#if __cplusplus
}
#endif

27
src/Network/socket_impl_includes.h
View File

@@ -1,27 +0,0 @@
#pragma once
#if __cplusplus
extern "C" {
#endif
#if defined(_WIN64) || defined(_WIN32)
#define KN_USE_WINSOCK 1
#else
#define KN_USE_WINSOCK 0
#endif
#if KN_USE_WINSOCK
#include <winsock2.h>
// #include <ws2tcpip.h>
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#endif
#if __cplusplus
}
#endif

52
src/Network/sockets/knSocketChanneled.c
View File

@@ -1,52 +0,0 @@
#include "../network_internal.h"
void __knSocketChanneled_close(void* p){ knSocketChanneled_close(p); }
kt_define(knPackage, NULL, NULL);
kt_define(knPackageQueueElem, NULL, NULL);
kt_define(knChannel, NULL, NULL);
kt_define(knSocketChanneled, __knSocketChanneled_close, NULL);
Maybe knSocketChanneled_open(){
knSocketChanneled* newSocket=malloc(sizeof(knSocketChanneled));
newSocket->localEndpoint=knIPV4Endpoint_INVALID;
newSocket->remoteEndpoint=knIPV4Endpoint_INVALID;
newSocket->channels=NULL;
newSocket->channelsAmount=0;
return SUCCESS(UniHeapPtr(knSocketChanneled, newSocket));
}
Maybe knSocketChanneled_close(knSocketChanneled* socket){
try(__kn_StdSocket_close(socket->socketfd), _m762, ;);
free(socket);
return MaybeNull;
}
knChannel* __createChannel(){
knChannel* ch=malloc(sizeof(knChannel));
ch->queueStart=NULL;
return ch;
}
Maybe knSocketChanneled_createChannel(knSocketChanneled* socket){
if(socket->channelsAmount == 65535)
safethrow("max amount of channels",;);
u16 channelsAmountPrev=socket->channelsAmount;
socket->channelsAmount++;
if(channelsAmountPrev==0)
socket->channels=malloc(sizeof(knChannel*));
else
socket->channels=realloc(socket->channels, socket->channelsAmount*sizeof(knChannel*));
socket->channels[channelsAmountPrev]=__createChannel();
return SUCCESS(UniUInt64(channelsAmountPrev));
}
Maybe knSocketChanneled_listen(knSocketChanneled* socket, knIPV4Endpoint localEndp);
Maybe knSocketChanneled_connect(knSocketChanneled* socket, knIPV4Endpoint remoteEndp);
Maybe knSocketChanneled_accept(knSocketChanneled* socket);
Maybe knSocketChanneled_send(knSocketChanneled* socket, u16 destinationIndex, u8* data, u32 dataLength);
Maybe knSocketChanneled_receive(knSocketChanneled* socket, u16 destinationIndex, u8* buffer, u32 bufferLength);

77
src/Network/sockets/knSocketChanneled.h
View File

@@ -1,77 +0,0 @@
#pragma once
#if __cplusplus
extern "C" {
#endif
#include "../network_types.h"
#define KNPAC_MAX_DATA_SIZE (65535-sizeof(knPackage)+sizeof(u8*))
typedef enum __attribute__((__packed__)) knPacVersion {
knPac_V1=1
} knPacVersion;
static const char knPacHeader[5]={'k','n','p','a','c'};
STRUCT(knPackage,
char header[5]; /* knpac */
knPacVersion version; /* protocol version */
u16 data_size; /* size of data block in bytes (1-KNPAC_MAX_DATA_SIZE) */
u32 channel_id; /* id of knChannel in socket */
u32 package_num; /* number in sequence of sent packages */
u64 data_hash; /* hash64 of data */
u8* data; /* ptr to data */
)
STRUCT(knPackageQueueElem,
knPackage package;
knPackageQueueElem* previousElem;
knPackageQueueElem* nextElem;
)
STRUCT(knChannel,
knPackageQueueElem* queueStart;
)
STRUCT(knSocketChanneled,
i64 socketfd;
knIPV4Endpoint localEndpoint;
knIPV4Endpoint remoteEndpoint;
u16 channelsAmount;
knChannel** channels;
)
///@return Maybe<knSocketChanneled*> new socket
Maybe knSocketChanneled_open();
///@return Maybe<void> error or nothing
Maybe knSocketChanneled_close(knSocketChanneled* socket);
///@return Maybe<u64> channel index
Maybe knSocketChanneled_createChannel(knSocketChanneled* socket);
///start listening at local endpoint
///@return Maybe<void> error or nothing
Maybe knSocketChanneled_listen(knSocketChanneled* socket, knIPV4Endpoint localEndp);
///sets socket remote endpoint
///@return Maybe<void> error or nothing
Maybe knSocketChanneled_connect(knSocketChanneled* socket, knIPV4Endpoint remoteEndp);
///@return Maybe<knSocketChanneled*> new socket connected to client
Maybe knSocketChanneled_accept(knSocketChanneled* socket);
///@param dataLength 0-4294967295
///@return Maybe<void>
Maybe knSocketChanneled_send(knSocketChanneled* socket, u16 destinationIndex, u8* data, u32 dataLength);
///@param buffer buffer for receiving data
///@param bufferLength 0-4294967295
///@return Maybe<u64> received bytes amount
Maybe knSocketChanneled_receive(knSocketChanneled* socket, u16 destinationIndex, u8* buffer, u32 bufferLength);
#if __cplusplus
}
#endif

129
src/Network/sockets/knSocketTCP.c
View File

@@ -1,129 +0,0 @@
#include "../network_internal.h"
void __knSocketTCP_close(void* p){ knSocketTCP_close(p); }
kt_define(knSocketTCP, __knSocketTCP_close, NULL);
Maybe knSocketTCP_open(bool allowReuse){
knSocketTCP* newSocket=malloc(sizeof(knSocketTCP));
newSocket->localEndpoint=knIPV4Endpoint_INVALID;
newSocket->remoteEndpoint=knIPV4Endpoint_INVALID;
newSocket->socketfd=socket(AF_INET, SOCK_STREAM, 0);
if(newSocket->socketfd==-1 || newSocket->socketfd == ~0)
safethrow("can't create socket", free(newSocket));
// set value of REUSEADDR socket option
int opt_val = allowReuse;
if(setsockopt(newSocket->socketfd, SOL_SOCKET, SO_REUSEADDR, (void*)&opt_val, sizeof(opt_val)) != 0)
safethrow("can't set socket options", knSocketTCP_close(newSocket));
return SUCCESS(UniHeapPtr(knSocketTCP, newSocket));
}
Maybe knSocketTCP_shutdown(knSocketTCP* socket, knShutdownType direction){
try(__kn_StdSocket_shutdown(socket->socketfd, direction), _m875, ;);
return MaybeNull;
}
Maybe knSocketTCP_close(knSocketTCP* socket){
try(__kn_StdSocket_close(socket->socketfd), _m875, ;);
free(socket);
return MaybeNull;
}
Maybe knSocketTCP_bind(knSocketTCP* socket, knIPV4Endpoint localEndp){
struct sockaddr_in servaddr = knIPV4Endpoint_toSockaddr(localEndp);
if(bind(socket->socketfd, (void*)&servaddr, sizeof(servaddr)) != 0)
safethrow("socket bind failed", ;);
socket->localEndpoint = localEndp;
return MaybeNull;
}
Maybe knSocketTCP_listen(knSocketTCP* socket){
if(listen(socket->socketfd, 1024) != 0)
safethrow("socket listen failed", ;);
return MaybeNull;
}
Maybe knSocketTCP_connect(knSocketTCP* socket, knIPV4Endpoint remoteEnd){
struct sockaddr_in localAddr = {0};
struct sockaddr_in remoteAddr = knIPV4Endpoint_toSockaddr(remoteEnd);
u64 sockaddr_size = sizeof(localAddr);
if(connect(socket->socketfd, (struct sockaddr*)&remoteAddr, sizeof(remoteAddr)) != 0)
safethrow("socket connect failed", ;);
if(getsockname(socket->socketfd, (struct sockaddr*)&localAddr, (void*)&sockaddr_size) != 0)
safethrow("can't get connected socket local address", ;);
socket->localEndpoint = knIPV4Endpoint_fromSockaddr(localAddr);
socket->remoteEndpoint = remoteEnd;
return MaybeNull;
}
Maybe knSocketTCP_accept(knSocketTCP* socket){
struct sockaddr_in localAddr = {0};
struct sockaddr_in remoteAddr = {0};
u64 sockaddr_size = sizeof(localAddr);
i64 client_fd = accept(socket->socketfd, (struct sockaddr*)&remoteAddr, (void*)&sockaddr_size);
if(client_fd == -1 || client_fd == ~0)
safethrow("can't accept client connection", ;);
if(getsockname(client_fd, (struct sockaddr*)&localAddr, (void*)&sockaddr_size) != 0)
safethrow("can't get accepted socket local address", __kn_StdSocket_close(client_fd));
// if accept() didn't set remoteAddr for some reason
if(remoteAddr.sin_addr.s_addr == 0 && remoteAddr.sin_port == 0 && remoteAddr.sin_family == 0){
if(getpeername(client_fd, (struct sockaddr*)&remoteAddr, (void*)&sockaddr_size) != 0)
safethrow("can't get accepted socket remote address", __kn_StdSocket_close(client_fd));
}
knSocketTCP* clientSocket = malloc(sizeof(knSocketTCP));
clientSocket->socketfd = client_fd;
clientSocket->localEndpoint = knIPV4Endpoint_fromSockaddr(localAddr);
clientSocket->remoteEndpoint = knIPV4Endpoint_fromSockaddr(remoteAddr);
return SUCCESS(UniHeapPtr(knSocketTCP, clientSocket));
}
Maybe knSocketTCP_send(knSocketTCP* socket, void* _buf, u32 dataLength){
char* buf = _buf;
u32 sentTotal = 0;
while(sentTotal < dataLength){
int sentCount = send(socket->socketfd, buf+sentTotal, dataLength-sentTotal, 0);
if(sentCount == -1){
safethrow(
cptr_concat("can't send ", toString_u64(dataLength-sentTotal,0,0),
" bytes out of ", toString_u64(dataLength,0,0),
" at index ", toString_u64(sentTotal,0,0)
),
;);
}
sentTotal += sentCount;
}
return MaybeNull;
}
Maybe knSocketTCP_receive(knSocketTCP* socket, void* _buf, u32 bufferLength){
char* buf = _buf;
int receivedCount = recv(socket->socketfd, buf, bufferLength, 0);
if(receivedCount == -1 || receivedCount == 0)
safethrow("can't receive data from socket", ;)
return SUCCESS(UniUInt64(receivedCount));
}
Maybe knSocketTCP_receiveN(knSocketTCP* socket, void* _buf, u32 bufsize, u32 n){
char* buf = _buf;
if(bufsize < n)
safethrow(ERR_UNEXPECTEDVAL, ;);
u32 receivedTotal = 0;
while(receivedTotal < n) {
try(knSocketTCP_receive(socket, buf+receivedTotal, n-receivedTotal), m_receivedCount, ;);
receivedTotal += m_receivedCount.value.UInt64;
}
return MaybeNull;
}

64
src/Network/sockets/knSocketTCP.h
View File

@@ -1,64 +0,0 @@
#pragma once
#if __cplusplus
extern "C" {
#endif
#include "../network_types.h"
STRUCT(knSocketTCP,
i64 socketfd;
knIPV4Endpoint localEndpoint;
knIPV4Endpoint remoteEndpoint;
/* TODO socket status enum */
)
///@note EXAMPLE 1: socket = open(false); bind(socket, localhost:8080); close(socket); - the socket on port 8080 still unavaliable for several minutes
///@note EXAMPLE 2: socket = open(true); bind(socket, localhost:8080); close(socket); - the socket on port 8080 can be opened again
///@param allowReuse enables binding multiple sockets to single port. Set to TRUE on a listening socket if you want to bind it to the same port after close.
///@return Maybe<knSocketTCP*> new socket
Maybe knSocketTCP_open(bool allowReuse);
///@param direction receive/send/both
///@return Maybe<void> error or nothing
Maybe knSocketTCP_shutdown(knSocketTCP* socket, knShutdownType direction);
/// closes file descriptor and frees socket pointer
///@return Maybe<void> error or nothing
Maybe knSocketTCP_close(knSocketTCP* socket);
/// binds socket to a local endpoint
///@return Maybe<void> error or nothing
Maybe knSocketTCP_bind(knSocketTCP* socket, knIPV4Endpoint localEndp);
/// begins listening for incoming TCP connections
Maybe knSocketTCP_listen(knSocketTCP* socket);
///@return Maybe<void> error or nothing
/// establishes TCP connection with a remote endpoint
///@return Maybe<void> error or nothing
Maybe knSocketTCP_connect(knSocketTCP* socket, knIPV4Endpoint remoteEnd);
///@return Maybe<knSocketTCP*> new socket connected to client
Maybe knSocketTCP_accept(knSocketTCP* socket);
/// sends <dataLength> bytes from buffer
///@param buffer buffer for receiving data
///@param dataLength 0-4294967295
///@return Maybe<void>
Maybe knSocketTCP_send(knSocketTCP* socket, void* buffer, u32 dataLength);
/// receives a package of any size
/// (by TCP 32 bytes han be sent as 32x1byte, 4x8byte, 32x1byte or in any other combination)
///@param buffer buffer for receiving data
///@param bufferLength 0-4294967295
///@return Maybe<u64> received bytes amount
Maybe knSocketTCP_receive(knSocketTCP* socket, void* buffer, u32 bufferLength);
/// receives a package of size n
///@return Maybe<void>
Maybe knSocketTCP_receiveN(knSocketTCP* socket, void* buf, u32 bufsize, u32 n);
#if __cplusplus
}
#endif

94
src/Network/sockets/knSocketUDP.c
View File

@@ -1,94 +0,0 @@
#include "../network_internal.h"
void __knSocketUDP_close(void* p){ knSocketUDP_close(p); }
kt_define(knSocketUDP, __knSocketUDP_close, NULL);
Maybe knSocketUDP_open(bool allowReuse){
knSocketUDP* newSocket=malloc(sizeof(knSocketUDP));
newSocket->localEndpoint=knIPV4Endpoint_INVALID;
newSocket->socketfd=socket(AF_INET, SOCK_DGRAM, 0);
if(newSocket->socketfd==-1 || newSocket->socketfd == ~0)
safethrow("can't create socket", free(newSocket));
// set value of REUSEADDR socket option
int opt_val = allowReuse;
if(setsockopt(newSocket->socketfd, SOL_SOCKET, SO_REUSEADDR, (void*)&opt_val, sizeof(opt_val)) != 0)
safethrow("can't set socket options", knSocketUDP_close(newSocket));
return SUCCESS(UniHeapPtr(knSocketUDP, newSocket));
}
Maybe knSocketUDP_shutdown(knSocketUDP* socket, knShutdownType direction){
try(__kn_StdSocket_shutdown(socket->socketfd, direction), _m875, ;);
return MaybeNull;
}
Maybe knSocketUDP_close(knSocketUDP* socket){
try(__kn_StdSocket_close(socket->socketfd), _m875, ;);
free(socket);
return MaybeNull;
}
Maybe knSocketUDP_bind(knSocketUDP* socket, knIPV4Endpoint localEndp){
struct sockaddr_in servaddr = {
.sin_family = AF_INET,
.sin_addr.s_addr = localEndp.address.UintBigEndian,
.sin_port = htons(localEndp.port) /* transforms port to big endian */
};
if(bind(socket->socketfd, (void*)&servaddr, sizeof(servaddr)) != 0)
safethrow("socket bind failed", ;);
socket->localEndpoint = localEndp;
return MaybeNull;
}
Maybe knSocketUDP_sendTo(knSocketUDP* socket, char* buffer, u32 dataLength, knIPV4Endpoint destEnd){
struct sockaddr_in dest_saddr = knIPV4Endpoint_toSockaddr(destEnd);
u32 sentCount = sendto(
socket->socketfd,
buffer,
dataLength,
0,
(struct sockaddr*)&dest_saddr,
sizeof(struct sockaddr_in)
);
if(sentCount != dataLength) {
safethrow(
cptr_concat("can't send ", toString_u64(dataLength-sentCount,0,0),
" bytes out of ", toString_u64(dataLength,0,0)
),
;);
}
struct sockaddr_in localAddr = {0};
u64 sockaddr_size = sizeof(localAddr);
if(getsockname(socket->socketfd, (struct sockaddr*)&localAddr, (void*)&sockaddr_size) != 0)
safethrow("can't get implicitely bound socket local address", ;);
socket->localEndpoint = knIPV4Endpoint_fromSockaddr(localAddr);
return MaybeNull;
}
Maybe knSocketUDP_receiveAny(knSocketUDP* socket, char* buffer, u32 bufferLength, knIPV4Endpoint* senderEnd){
struct sockaddr_in remote_saddr = {0};
u64 remote_saddr_size = sizeof(remote_saddr);
int receivedCount = recvfrom(
socket->socketfd,
buffer,
bufferLength,
0,
(struct sockaddr*)&remote_saddr,
(void*)&remote_saddr_size
);
if(receivedCount == -1 || receivedCount == 0)
safethrow("can't receive data from socket", ;)
*senderEnd = knIPV4Endpoint_fromSockaddr(remote_saddr);
return SUCCESS(UniUInt64(receivedCount));
}

49
src/Network/sockets/knSocketUDP.h
View File

@@ -1,49 +0,0 @@
#pragma once
#if __cplusplus
extern "C" {
#endif
#include "../network_types.h"
STRUCT(knSocketUDP,
i64 socketfd;
knIPV4Endpoint localEndpoint;
/* TODO socket status enum */
)
///@note EXAMPLE 1: socket = open(false); bind(socket, localhost:8080); close(socket); - the socket on port 8080 still unavaliable for several minutes
///@note EXAMPLE 2: socket = open(true); bind(socket, localhost:8080); close(socket); - the socket on port 8080 can be opened again
///@param allowReuse enables binding multiple sockets to single port. Set to TRUE on a listening socket if you want to bind it to the same port after close.
///@return Maybe<knSocketUDP*> new socket
Maybe knSocketUDP_open(bool allowReuse);
///@param direction receive/send/both
///@return Maybe<void> error or nothing
Maybe knSocketUDP_shutdown(knSocketUDP* socket, knShutdownType direction);
/// closes file descriptor and frees socket pointer
///@return Maybe<void> error or nothing
Maybe knSocketUDP_close(knSocketUDP* socket);
/// binds socket to a local endpoint
///@return Maybe<void> error or nothing
Maybe knSocketUDP_bind(knSocketUDP* socket, knIPV4Endpoint localEndp);
/// sends one package to destination endpoint
///@param buffer buffer for receiving data
///@param dataLength 0-64k
///@param destEnd destination endpoint
///@return Maybe<void>
Maybe knSocketUDP_sendTo(knSocketUDP* socket, char* buffer, u32 dataLength, knIPV4Endpoint destEnd);
/// receives one package from anywhere
///@param buffer buffer for receiving data
///@param bufferLength 0-64k
///@param senderEnd [OUT] endpoint UPD package was sent from
///@return Maybe<u64> received bytes amount
Maybe knSocketUDP_receiveAny(knSocketUDP* socket, char* buffer, u32 bufferLength, knIPV4Endpoint* senderEnd);
#if __cplusplus
}
#endif

12
src/SearchTree/SearchTree.c
View File

@@ -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,7 +9,7 @@ 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){
@@ -22,7 +22,7 @@ void __STNode_free(void* _node){
for(u8 rem=0;rem<4;rem++){
STNode* ptrrem=ptrn4[rem];
if(ptrrem)
STNode_free(ptrrem);
STNode_destruct(ptrrem);
}
free(ptrn4);
}
@@ -33,10 +33,10 @@ void __STNode_free(void* _node){
free(node->branches);
}
if(node->value.VoidPtr)
Unitype_free(node->value);
Unitype_destruct(&node->value);
}
void STNode_free(STNode* node){
__STNode_free(node);
void STNode_destruct(STNode* node){
__STNode_destruct(node);
free(node);
}

4
src/SearchTree/SearchTree.h
View File

@@ -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);

144
src/String/StringBuilder.c
View File

@@ -1,144 +1,90 @@
#include "StringBuilder.h"
kt_define(StringBuilder, __StringBuilder_free, NULL);
kt_define(StringBuilder, (destruct_t)StringBuilder_destruct, NULL);
#define BL_C 32
#define BL_L 1024
#define createBuffer() (MemoryChunk){.data = allocator_alloc(InternalAllocator_getPtr(b), 512), .size=512, .occupied_size=0}
void complete_buf(StringBuilder* b){
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,
str.ptr[i++]=c;
);
Autoarr_add(b->compl_bufs,str);
Autoarr_free(b->curr_buf, true);
b->curr_buf=Autoarr_create(i8,BL_C,BL_L);
}
void try_complete_buf(StringBuilder* b){
if(b->curr_buf->blocks_count==BL_C)
complete_buf(b);
if(b->curr_buf.occupied_size == 0)
return;
string str={ .length=b->curr_buf.occupied_size, .ptr= b->curr_buf.data };
Autoarr_add(&b->compl_bufs,str);
b->curr_buf = createBuffer();
}
StringBuilder* StringBuilder_create(){
StringBuilder* b=malloc(sizeof(StringBuilder));
b->compl_bufs=NULL;
b->curr_buf=Autoarr_create(i8,BL_C,BL_L);
return b;
void StringBuilder_construct(StringBuilder* b, allocator_ptr external_al){
InternalAllocator_setExternalOrConstruct(b, external_al, LinearAllocator, 1024);
Autoarr_construct(&b->compl_bufs, string, 0, InternalAllocator_getPtr(b));
b->curr_buf = createBuffer();
b->total_length = 0;
}
void __StringBuilder_free(void* _b){
StringBuilder* b=_b;
if(b->compl_bufs) Autoarr_free(b->compl_bufs, true);
Autoarr_free(b->curr_buf, true);
}
void StringBuilder_free(StringBuilder* b){
__StringBuilder_free(b);
free(b);
void StringBuilder_destruct(StringBuilder* b){
Autoarr_destruct(&b->compl_bufs);
allocator_free(InternalAllocator_getPtr(b), b->curr_buf.data);
InternalAllocator_destructIfInternal(LinearAllocator, b);
}
string StringBuilder_build(StringBuilder* b){
complete_buf(b);
u32 len=0;
Autoarr_foreach(b->compl_bufs, cs,
len+=cs.length;
string str= {
.length = b->total_length,
.ptr = allocator_alloc(InternalAllocator_getPtr(b), b->total_length+1)
};
str.ptr[b->total_length]='\0';
char* free_space_ptr = str.ptr;
Autoarr_foreach(&b->compl_bufs, buf,
memcpy(free_space_ptr, buf.ptr, buf.length);
free_space_ptr += buf.length;
);
string str= { .length=len, .ptr=malloc(len+1) };
str.ptr[len]='\0';
u32 i=0;
Autoarr_foreach(b->compl_bufs, cs,
for(u32 n=0;n<cs.length;n++)
str.ptr[i++]=cs.ptr[n];
free(cs.ptr);
);
StringBuilder_free(b);
StringBuilder_destruct(b);
return str;
}
void StringBuilder_rmchar(StringBuilder* b){
if(b->curr_buf->block_length!=0)
Autoarr_pop(b->curr_buf)
if(b->curr_buf.occupied_size != 0)
b->curr_buf.occupied_size--;
else {
if(!b->compl_bufs) throw(ERR_NULLPTR);
string* lastcb=Autoarr_getPtr(b->compl_bufs, (Autoarr_length(b->compl_bufs)-1));
lastcb->length--;
for(u32 buf_i = Autoarr_length(&b->compl_bufs) - 1; buf_i != (u32)-1; buf_i--){
string* lastcb = Autoarr_getPtr(&b->compl_bufs, buf_i);
if(lastcb->length != 0){
lastcb->length--;
break;
}
}
}
}
void StringBuilder_append_char(StringBuilder* b, char c){
try_complete_buf(b);
Autoarr_add(b->curr_buf,c);
if(b->curr_buf.occupied_size==b->curr_buf.size)
complete_buf(b);
((char*)b->curr_buf.data)[b->curr_buf.occupied_size] = c;
}
void StringBuilder_append_string(StringBuilder* b, string s){
complete_buf(b);
Autoarr_add(b->compl_bufs, string_copy(s));
Autoarr_add(&b->compl_bufs, s);
}
void StringBuilder_append_cptr(StringBuilder* b, char* s){
string str={
.ptr=s,
.length=cptr_length(s)
};
StringBuilder_append_string(b,str);
}
void curr_buf_add_string(StringBuilder* b, string s){
for(u32 i=0; i<s.length; i++)
Autoarr_add(b->curr_buf,s.ptr[i]);
string str={ .ptr=s, .length=cptr_length(s) };
StringBuilder_append_string(b, str);
}
void StringBuilder_append_i64(StringBuilder* b, i64 a){
try_complete_buf(b);
u8 i=0;
if(a==0){
Autoarr_add(b->curr_buf,'0');
return;
}
else if(a<0){
Autoarr_add(b->curr_buf,'-');
a=-a;
}
char buf[24];
while(a!=0){
buf[i++]='0'+a%10;
a/=10;
}
string rev=string_reverse((string){buf,i});
curr_buf_add_string(b,rev);
free(rev.ptr);
StringBuilder_append_cptr(b, toString_i64(InternalAllocator_getPtr(b), a));
}
void StringBuilder_append_u64(StringBuilder* b, u64 a){
try_complete_buf(b);
u8 i=0;
if(a==0){
Autoarr_add(b->curr_buf,'0');
return;
}
char buf[24];
while(a!=0){
buf[i++]='0'+a%10;
a/=10;
}
string rev=string_reverse((string){buf,i});
curr_buf_add_string(b,rev);
free(rev.ptr);
StringBuilder_append_cptr(b, toString_u64(InternalAllocator_getPtr(b), a, 0, 0));
}
void StringBuilder_append_f64(StringBuilder* b, f64 a){
try_complete_buf(b);
char buf[32];
ksprintf(buf,32,"%lf",a);
curr_buf_add_string(b, (string){.ptr=buf, .length=cptr_length(buf)});
StringBuilder_append_cptr(b, toString_f64(InternalAllocator_getPtr(b), a, toString_f64_max_precision, 0, 0));
}

21
src/String/StringBuilder.h
View File

@@ -8,20 +8,25 @@ extern "C" {
#include "string.h"
STRUCT(StringBuilder,
Autoarr(string)* compl_bufs;
Autoarr(i8)* curr_buf;
InternalAllocator_declare(LinearAllocator);
Autoarr(string) compl_bufs;
MemoryChunk curr_buf;
u64 total_length;
)
StringBuilder* StringBuilder_create(void);
void StringBuilder_free(StringBuilder* b);
void __StringBuilder_free(void* b);
///@param external_al if null, creates internal allocator
void StringBuilder_construct(StringBuilder* b, allocator_ptr external_al);
void StringBuilder_destruct(StringBuilder* b);
// Joins all strings from compl_bufs.
// Returns zero-terminated string.
// No need to call string_extract()!
// Frees StringBuilder.
// No need to call string_extract!
// Destructs StringBuilder.
string StringBuilder_build(StringBuilder* b);
// removes last char
/// OBSOLETE! Will be removed later
void StringBuilder_rmchar(StringBuilder* b);
void StringBuilder_append_char(StringBuilder* b, char c);
void StringBuilder_append_cptr(StringBuilder* b, char* s);
void StringBuilder_append_string(StringBuilder* b, string s);

34
src/String/string.c
View File

@@ -1,36 +1,35 @@
#include "string.h"
kt_define(string, NULL, NULL);
Array_define(string)
Autoarr_define(string, false)
Autoarr_define(string);
// copies str content to new char pointer value (adding '\0' at the end)
char* string_extract(string str){
char* string_extract(allocator_ptr al, string str){
if(str.length==0) return NULL;
char* cptr=malloc(str.length*sizeof(char)+1);
char* cptr=allocator_alloc(al, str.length+1);
memcpy(cptr, str.ptr, str.length);
cptr[str.length]=0;
while(str.length-->0)
cptr[str.length]=str.ptr[str.length];
return cptr;
}
// copies src.ptr content to new string and adds \0 at the end
string string_copy(string src){
string string_copy(allocator_ptr al, string src){
if(!src.ptr)
return src;
throw(ERR_NULLPTR);
string nstr;
nstr.length=src.length;
nstr.ptr=malloc(nstr.length+1);
for(u32 i=0;i<nstr.length;i++)
nstr.ptr[i]=src.ptr[i];
nstr.ptr=allocator_alloc(al, nstr.length+1);
memcpy(nstr.ptr, src.ptr, nstr.length);
nstr.ptr[nstr.length]='\0';
return nstr;
}
// compares two strings, NullPtr-friendly
bool string_compare(string str0, string str1){
if(str0.length!=str1.length) return false;
if(!str0.ptr) return str1.ptr ? false : true;
if(str0.length!=str1.length)
return false;
if(!str0.ptr)
return str1.ptr ? false : true;
else if(!str1.ptr) return false;
while(str0.length-->0)
if(*str0.ptr++ != *str1.ptr++)
@@ -39,9 +38,12 @@ bool string_compare(string str0, string str1){
}
// creates new string which is reversed variant of <s>
string string_reverse(string s){
if(s.length==0) return s;
string r={malloc(s.length), s.length};
string string_reverse(allocator_ptr al, string s){
if(s.length==0)
return s;
string r;
r.ptr=allocator_alloc(al, s.length);
r.length=s.length;
for(u32 i=0; i<s.length; i++)
r.ptr[i]=s.ptr[s.length-i-1];
return r;

8
src/String/string.h
View File

@@ -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};
@@ -24,16 +22,16 @@ static const string stringNull={NULL,0};
#define string_fromCptr(CPTR) (string){ .ptr=CPTR, .length=cptr_length(CPTR) }
// copies str content to new char pointer value (adding '\0' at the end)
char* string_extract(string str);
char* string_extract(allocator_ptr al, string str);
// copies src.ptr content to new string and adds \0 at the end
string string_copy(string src);
string string_copy(allocator_ptr al, string src);
// compares two strings, NullPtr-friendly
bool string_compare(string str0, string str1);
// creates new string which is reversed variant of <s>
string string_reverse(string s);
string string_reverse(allocator_ptr al, string s);
#if __cplusplus
}

1
src/base/base.h
View File

@@ -11,6 +11,7 @@ extern "C" {
#include "type_system/type_system.h"
#include "../kprint/kprintf.h"
#include "endian.h"
#include "memory/memory.h"
#if __cplusplus
}

47
src/base/cptr.c
View File

@@ -11,17 +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);
while(len--!=0)
dst[len]=src[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;
@@ -131,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
@@ -149,41 +148,41 @@ 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;
// copying content of all strings to result
// copying content of all strings to rezult
for(u16 k=0; k<n; k++){
memcpy(totality, strs[k], lengths[k]);
totality+=lengths[k];
}
free(strs);
free(lengths);
allocator_free(al, lengths);
allocator_free(al, strs);
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<length; i++)
p[i]=tolower(src[i]);
return p;
}
char* cptr_toUpper(const char* src) {
char* cptr_toUpper(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<length; i++)
p[i]=toupper(src[i]);
return p;
}
char* cptr_replaceCharIn(const char* src, char c_old, char c_new, u32 startIndex, u32 seekLength){
char* rzlt=cptr_copy(src);
char* cptr_replaceCharIn(allocator_ptr al, const char* src, char c_old, char c_new, u32 startIndex, u32 seekLength){
char* rzlt=cptr_copy(al, src);
for(u32 i=startIndex; i!=seekLength && src[i]!=0; i++){
if(src[i]==c_old)
rzlt[i]=c_new;
@@ -191,8 +190,10 @@ char* cptr_replaceCharIn(const char* src, char c_old, char c_new, u32 startIndex
return rzlt;
}
char* cptr_replaceIn(const char* src, const char* str_old, const char* str_new, u32 startIndex, u32 seekLength){
StringBuilder* sb=StringBuilder_create();
char* cptr_replaceIn(allocator_ptr al, const char* src, const char* str_old, const char* str_new, u32 startIndex, u32 seekLength){
StringBuilder _sb;
StringBuilder* sb=&_sb;
StringBuilder_construct(sb, al);
const u32 str_old_len=cptr_length(str_old);
const u32 str_new_len=cptr_length(str_new);
i32 i=startIndex;
@@ -205,6 +206,6 @@ char* cptr_replaceIn(const char* src, const char* str_old, const char* str_new,
u32 src_remains_len=cptr_length(src);
if(src_remains_len>0)
StringBuilder_append_string(sb, (string){.ptr=(char*)src, .length=src_remains_len});
string result=StringBuilder_build(sb);
return result.ptr;
string rezult=StringBuilder_build(sb);
return rezult.ptr;
}

31
src/base/cptr.h
View File

@@ -5,12 +5,13 @@ extern "C" {
#endif
#include "std.h"
#include "memory/allocator_base.h"
// returns length of char buffer (without \0)
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);
bool cptr_equals(const char* key0, const char* key1);
@@ -19,7 +20,7 @@ bool cptr_startsWith(const char* src, const char* fragment);
bool cptr_endsWith(const char* src, const char* fragment);
// multiplies char n times
char* char_multiply(char c, u32 n);
char* char_multiply(allocator_ptr al, char c, u32 n);
/// @param startIndex 0 ... src length
/// @param seekLength 0 ... -1
@@ -63,33 +64,29 @@ static inline i32 cptr_lastIndexOfChar(const char* src, char fragment)
static inline bool cptr_contains(const char* src, const char* fragment){
return cptr_seek(src, fragment, 0, -1) != -1;
return cptr_seek(src, fragment, 0, -1) +1;
}
static inline bool cptr_containsChar(const char* src, char c){
return cptr_seekChar(src, c, 0, -1) != -1;
}
char* __cptr_concat(allocator_ptr al, u32 n, ...);
#define cptr_concat(ALLOCATOR, STR...) __cptr_concat(ALLOCATOR, count_args(STR), STR)
char* __cptr_concat(u32 n, ...);
#define cptr_concat(STR...) __cptr_concat(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 <src> with <str_old> replaced by <str_new> or empty cstring if <str_old> 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 <src> with <c_old> replaced by <c_new> or empty cstring if <str_old> 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
}

23
src/base/errors.c
View File

@@ -1,4 +1,7 @@
#include "base.h"
#include "std.h"
#include "errors.h"
#include "cptr.h"
#include "../kprint/kprintf.h"
char* errname(ErrorId err){
switch(err){
@@ -18,26 +21,26 @@ char* errname(ErrorId err){
}
}
#define ERRMSG_MAXLENGTH 4096
#define ERRMSG_MAXLENGTH 1024
char* __genErrMsg(const char* errmsg, const char* srcfile, i32 line, const char* funcname){
size_t bufsize=ERRMSG_MAXLENGTH;
char* result=malloc(bufsize);
ksprintf(result,bufsize,"[%s:%d] %s() throwed error: %s",srcfile,line,funcname,errmsg);
return result;
char* rezult=malloc(bufsize);
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* result=malloc(bufsize);
ksprintf(result,bufsize,"%s\n \\___[%s:%d] %s()",errmsg,srcfile,line,funcname);
char* rezult=malloc(bufsize);
sprintf_s(rezult,bufsize,"%s\n \\___[%s:%d] %s()",errmsg,srcfile,line,funcname);
free(errmsg);
return result;
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){

21
src/base/errors.h
View File

@@ -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);
@@ -60,10 +60,10 @@ char* __unknownErr( );
__RETURN_EXCEPTION(((char*)__genErrMsg(E, __FILE__,__LINE__,__func__))); \
}
#define try_cpp(_funcCall, _result, freeMem) Maybe _result=_funcCall; if(_result.errmsg){ \
#define try_cpp(_funcCall, _rezult, freeMem) Maybe _rezult=_funcCall; if(_rezult.errmsg){ \
freeMem; \
_result.errmsg=__extendErrMsg(_result.errmsg, __FILE__,__LINE__,__func__); \
return _result; \
_rezult.errmsg=__extendErrMsg(_rezult.errmsg, __FILE__,__LINE__,__func__); \
return _rezult; \
}
#else
@@ -73,17 +73,16 @@ char* __unknownErr( );
__RETURN_EXCEPTION(((char*)__genErrMsg((__stringify_err(E)), __FILE__,__LINE__,__func__))); \
}
#define try(_funcCall, _result, freeMem) Maybe _result=_funcCall; if(_result.errmsg){ \
#define try(_funcCall, _rezult, freeMem) Maybe _rezult=_funcCall; if(_rezult.errmsg){ \
freeMem; \
_result.errmsg=__extendErrMsg(_result.errmsg, __FILE__,__LINE__,__func__); \
return _result; \
_rezult.errmsg=__extendErrMsg(_rezult.errmsg, __FILE__,__LINE__,__func__); \
return _rezult; \
}
#endif
#define tryLast(_funcCall, _result, ON_EXIT) Maybe _result=_funcCall; if(_result.errmsg){ \
ON_EXIT; \
_result.errmsg=__extendErrMsg(_result.errmsg, __FILE__,__LINE__,__func__); \
__EXIT(_result.errmsg); \
#define tryLast(_funcCall, _rezult, ON_EXIT) Maybe _rezult=_funcCall; if(_rezult.errmsg){ \
_rezult.errmsg=__extendErrMsg(_rezult.errmsg, __FILE__,__LINE__,__func__); \
__EXIT(_rezult.errmsg); \
}
#if __cplusplus

15
src/base/memory/CstdAllocator.c Normal file
View File

@@ -0,0 +1,15 @@
#include "allocators_internal.h"
void* CstdAllocator_alloc(allocator_ptr self, alloc_size_t size){
// assert(size>0);
return malloc(size);
}
void CstdAllocator_free(allocator_ptr self, void* ptr){
// assert(ptr!=NULL);
free(ptr);
}
kt_define(CstdAllocator, NULL, NULL);
CstdAllocator CstdAllocator_instance=(CstdAllocator){.base.alloc_f=CstdAllocator_alloc, .base.free_f=CstdAllocator_free};

102
src/base/memory/LinearAllocator.c Normal file
View File

@@ -0,0 +1,102 @@
#include "allocators_internal.h"
#include <stdio.h>
#define default_chunks_per_allocation 16
// growing chunk array size
#define new_max_chunks_count ( default_chunks_per_allocation*(self->chunks_count/16 == 0) + \
default_chunks_per_allocation*add_padding(self->chunks_count/2)/4 )
#define default_chunk_size 1024
// growing chunk size
#define new_chunk_size ( default_chunk_size*(self->chunks_count/16 == 0) + \
default_chunk_size*add_padding(self->chunks_count/8) )
#define chunk_alloc(SZ, OCCUPIED) (MemoryChunk){ .data=malloc(SZ), .size=SZ, .occupied_size=OCCUPIED }
#define curr_chunk (self->chunks+self->curr_chunk_i)
__attribute__ ((noinline)) void* ___alloc_realloc_chunk(LinearAllocator* self, alloc_size_t alloc_size){
free(curr_chunk->data);
*curr_chunk=chunk_alloc(alloc_size, alloc_size);
return curr_chunk->data;
}
__attribute__ ((noinline)) void* __alloc_new_chunk(LinearAllocator* self, alloc_size_t alloc_size){
self->curr_chunk_i++;
// next chunk has been already allocated
if(self->curr_chunk_i < self->chunks_count)
return curr_chunk->data;
// self->chunks array is full
if(self->chunks_count == self->max_chunks_count){
self->max_chunks_count = new_max_chunks_count;
self->chunks = realloc(self->chunks, sizeof(MemoryChunk) * self->max_chunks_count);
}
// new chunk allocation
self->chunks_count++;
alloc_size_t _new_chunk_size= alloc_size > new_chunk_size ? alloc_size : new_chunk_size;
*curr_chunk=chunk_alloc(_new_chunk_size, alloc_size);
return curr_chunk->data;
}
void* LinearAllocator_alloc(allocator_ptr _self, alloc_size_t alloc_size){
// assert(_self!=NULL);
// assert(alloc_size>0);
LinearAllocator* self = (LinearAllocator*)_self;
alloc_size=add_padding(alloc_size);
// aligned alloc_size can fit into the current chunk
if(curr_chunk->occupied_size + alloc_size <= curr_chunk->size){
void* data_ptr=curr_chunk->data + curr_chunk->occupied_size;
curr_chunk->occupied_size += alloc_size;
return data_ptr;
}
// reallocation of current chunk because it is clean
if(curr_chunk->occupied_size == 0){
// It is very unefficient operation.
// If it happens not only in the first chunk, code have to be refactored
assert(self->curr_chunk_i==0);
return ___alloc_realloc_chunk(self, alloc_size);
}
// creation of a new chunk
else {
return __alloc_new_chunk(self, alloc_size);
}
}
void LinearAllocator_free(allocator_ptr _self, void* ptr){
// LinearAllocator can't free pointers
}
void LinearAllocator_destruct(LinearAllocator* self){
// assert(_self!=NULL);
u32 size=0;
u32 oc_size=0;
for(u32 chunk_i=0; chunk_i < self->chunks_count; chunk_i++){
free(self->chunks[chunk_i].data);
size+=self->chunks[chunk_i].size;
oc_size+=self->chunks[chunk_i].occupied_size;
}
printf("\e[35m%u/%u\n",oc_size,size);
free(self->chunks);
self->chunks=NULL;
self->chunks_count=0;
self->curr_chunk_i=0;
self->max_chunks_count=0;
}
void LinearAllocator_construct(LinearAllocator* self, alloc_size_t starting_size){
assert(self!=NULL);
assert(starting_size>0);
self->base.alloc_f=LinearAllocator_alloc;
self->base.free_f=LinearAllocator_free;
self->curr_chunk_i=0;
self->chunks_count=1;
self->max_chunks_count=new_max_chunks_count;
self->chunks=malloc(sizeof(MemoryChunk) * new_max_chunks_count);
self->chunks[0]=chunk_alloc(starting_size, 0);
}
kt_define(LinearAllocator, (destruct_t)LinearAllocator_destruct, NULL)

58
src/base/memory/StackingAllocator.c Normal file
View File

@@ -0,0 +1,58 @@
#include "allocators_internal.h"
#define chunk_alloc(SZ) (MemoryChunk){ .data=malloc(SZ), .size=SZ, .occupied_size=0 }
#define linear self->base
#define curr_chunk (linear.chunks+linear.curr_chunk_i)
typedef struct {
alloc_size_t data_size;
} AllocationHeader;
void* StackingAllocator_alloc(allocator_ptr _self, alloc_size_t size){
assert(_self!=NULL);
assert(size>0);
StackingAllocator* self = (StackingAllocator*)_self;
size=add_padding(size);
// allocates memory with header struct before data
AllocationHeader* header_ptr=LinearAllocator_alloc(_self, sizeof(AllocationHeader) + size);
void* data_ptr = (void*)header_ptr + sizeof(AllocationHeader);
header_ptr->data_size = size;
self->allocations_count++;
return data_ptr;
}
void StackingAllocator_free(allocator_ptr _self, void* data_ptr){
assert(_self!=NULL);
assert(data_ptr!=NULL);
StackingAllocator* self = (StackingAllocator*)_self;
AllocationHeader* header_ptr = data_ptr - sizeof(AllocationHeader);
// TODO check is data_ptr pointer to the last allocation
// chunk is empty
if(curr_chunk->occupied_size==0){
// isn't the first chunk
assert(linear.curr_chunk_i>0);
linear.curr_chunk_i--;
}
alloc_size_t allocation_size=header_ptr->data_size+sizeof(*header_ptr);
// data must fit in chunk
assert(allocation_size <= curr_chunk->occupied_size);
curr_chunk->occupied_size -= allocation_size;
}
void StackingAllocator_destruct(StackingAllocator* self){
LinearAllocator_destruct(&self->base);
}
void StackingAllocator_construct(StackingAllocator* self, alloc_size_t starting_size){
assert(self!=NULL);
assert(starting_size>0);
LinearAllocator_construct(&linear, starting_size);
linear.base.alloc_f=StackingAllocator_alloc;
linear.base.free_f=StackingAllocator_free;
self->allocations_count=0;
}
kt_define(StackingAllocator, (destruct_t)StackingAllocator_destruct, NULL)

36
src/base/memory/allocator_base.h Normal file
View File

@@ -0,0 +1,36 @@
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#include "../std.h"
///////////////////////////////////////////
// MemoryAllocator interface //
///////////////////////////////////////////
typedef u32 alloc_size_t;
typedef struct MemoryAllocator MemoryAllocator;
typedef MemoryAllocator* allocator_ptr;
typedef void* (*alloc_t)(allocator_ptr, alloc_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, alloc_size_t data_size);
#ifdef __cplusplus
}
#endif

9
src/base/memory/allocators.c Normal file
View File

@@ -0,0 +1,9 @@
#include "memory.h"
void* allocator_transfer(allocator_ptr src, allocator_ptr dest, void* data, alloc_size_t data_size)
{
void* transfered=allocator_alloc(dest, data_size);
memcpy(transfered, data, data_size);
allocator_free(src, data);
return transfered;
}

69
src/base/memory/allocators.h Normal file
View File

@@ -0,0 +1,69 @@
#pragma once
#if __cplusplus
extern "C" {
#endif
#include "../std.h"
#include "../type_system/ktDescriptor.h"
#include "allocator_base.h"
///////////////////////////////////////////
// CstdAllocator //
///////////////////////////////////////////
// Just wrapper for malloc() and free() //
///////////////////////////////////////////
STRUCT(CstdAllocator,
MemoryAllocator base;
);
extern CstdAllocator CstdAllocator_instance;
#define CstdAllocator_instPtr (allocator_ptr)(&CstdAllocator_instance)
///////////////////////////////////////////
// LinearAllocator //
///////////////////////////////////////////
// Can't free allocated memory. //
// Allocates new memory chunk when the //
// current is full. //
///////////////////////////////////////////
typedef struct MemoryChunk {
void* data;
alloc_size_t size;
alloc_size_t occupied_size; /* free memory position in the current chunk. */
} MemoryChunk;
STRUCT(LinearAllocator,
MemoryAllocator base;
MemoryChunk* chunks; /* MemoryChunk[max_chunks_count] */
u32 chunks_count; /* allocated chunks */
u32 max_chunks_count; /* chunks that can be allocated without reallocating .chunks */
u32 curr_chunk_i; /* index of current chunk in .chunks, can be < .chunks_count */
);
void LinearAllocator_construct(LinearAllocator* self, alloc_size_t starting_size);
void LinearAllocator_destruct(LinearAllocator* self);
///////////////////////////////////////////
// StackingAllocator //
///////////////////////////////////////////
// The same as Linear, but can free //
// allocations in reverse order //
///////////////////////////////////////////
STRUCT(StackingAllocator,
LinearAllocator base;
u32 allocations_count;
);
void StackingAllocator_construct(StackingAllocator* self, alloc_size_t starting_size);
void StackingAllocator_destruct(StackingAllocator* self);
#if __cplusplus
}
#endif

4
src/base/memory/allocators_internal.h Normal file
View File

@@ -0,0 +1,4 @@
#include <assert.h>
#include "memory.h"
void* LinearAllocator_alloc(allocator_ptr _self, alloc_size_t size);

44
src/base/memory/memory.h Normal file
View File

@@ -0,0 +1,44 @@
#include "allocators.h"
// addresses must be aligned to this value
#define memory_align sizeof(void*)
// adds padding if memory_align if N isn't a multiple of memory_aligh
#define add_padding(N) (N + (N%memory_align != 0)*(memory_align - N%memory_align))
///////////////////////////////////////////
// NOT AN ALLOCATOR //
///////////////////////////////////////////
// Macros to embed internal allocator //
// into some collection struct. //
///////////////////////////////////////////
/// call this macro inside struct declaration
#define InternalAllocator_declare(AL_TYPE) \
AL_TYPE _internal_al; \
allocator_ptr _internal_al_ptr;
/// get pointer to allocator
#define InternalAllocator_getPtr(STRUCT_PTR) ((STRUCT_PTR)->_internal_al_ptr)
/// true if allocator is stored inside the struct, otherwise false
#define InternalAllocator_isInternal(STRUCT_PTR) (bool)((STRUCT_PTR)->_internal_al_ptr == (allocator_ptr)&(STRUCT_PTR)->_internal_al)
/// set ptr to external allocator
#define InternalAllocator_setExternal(STRUCT_PTR, EXT_AL_PTR) ((STRUCT_PTR)->_internal_al_ptr = EXT_AL_PTR);
/// create internal allocator and set ptr to it
#define InternalAllocator_construct(STRUCT_PTR, TYPE, CTOR_ARGS...) { \
TYPE##_construct(&(STRUCT_PTR)->_internal_al, CTOR_ARGS); \
(STRUCT_PTR)->_internal_al_ptr = (allocator_ptr)&(STRUCT_PTR)->_internal_al; \
}
/// if EXT_AL_PTR isn't null, set external allocator, otherwise create new
#define InternalAllocator_setExternalOrConstruct(STRUCT_PTR, EXT_AL_PTR, TYPE, CTOR_ARGS...) \
if(EXT_AL_PTR!=NULL) InternalAllocator_setExternal(STRUCT_PTR, EXT_AL_PTR) \
else InternalAllocator_construct(STRUCT_PTR, TYPE, CTOR_ARGS)
#define InternalAllocator_destructIfInternal(TYPE, STRUCT_PTR) {\
if(InternalAllocator_isInternal(STRUCT_PTR)) \
TYPE##_destruct((TYPE*)InternalAllocator_getPtr(STRUCT_PTR)); \
}

3
src/base/optime.h
View File

@@ -13,7 +13,8 @@
tni=1; \
} else tni=2; \
kprintf("\e[93moperation \e[94m%s\e[93m lasted \e[94m%f \e[93m%s\n", \
opname, t, tnames[tni]);
opname, t, tnames[tni]); \
fflush(stdout);
#ifdef CLOCK_REALTIME
/// executes codeblock and prints execution time

11
src/base/std.h
View File

@@ -14,7 +14,6 @@ extern "C" {
#include <setjmp.h>
#include <signal.h>
#include <math.h>
#include <string.h>
typedef int8_t i8;
typedef uint8_t u8;
@@ -26,7 +25,7 @@ typedef int64_t i64;
typedef uint64_t u64;
typedef float f32;
typedef double f64;
/// anonymous pointer without specified freeMembers() func
/// anonymous pointer without specified destruct() func
typedef void* Pointer;
// Usually bool from stdbool.h is defined as macro,
@@ -39,6 +38,14 @@ typedef u8 bool;
#define false 0
#endif
#ifndef memcpy
extern void* memcpy(void *dest, const void * src, size_t n);
#endif
#ifndef typeof
#define typeof __typeof__
#endif
#define dbg(N) kprintf("\e[95m%d\n",N)
#define nameof(V) #V

2
src/base/type_system/README.md
View File

@@ -22,7 +22,7 @@ and register it.
## type descriptors
Every registered type should have it's own descriptor (`ktDescriptor`). It's a struct, which contains some information about type and pointers to some specific functions for this type (`toString`, `freeMembers`).
Every registered type should have it's own descriptor (`ktDescriptor`). It's a struct, which contains some information about type and pointers to some specific functions for this type (`toString`, `destruct`).
## type registration

95
src/base/type_system/base_toString.c
View File

@@ -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 <c> 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,30 +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 = sprintf_s(str, bufsize, "%.*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 */ \
@@ -97,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';
@@ -129,13 +129,13 @@ char _4bitsHex(u8 u, bool uppercase){
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';
@@ -163,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); \
@@ -231,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)

37
src/base/type_system/base_toString.h
View File

@@ -5,42 +5,43 @@ 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 <c> 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
}

29
src/base/type_system/init.c
View File

@@ -1,11 +1,9 @@
#include "../base.h"
#include "../../Array/Array.h"
#include "../../Autoarr/Autoarr.h"
#include "../../SearchTree/SearchTree.h"
#include "../../Hashtable/Hashtable.h"
#include "../../String/StringBuilder.h"
#include "../../Filesystem/filesystem.h"
#include "../../Network/network.h"
#include "base_toString.h"
void kt_initKerepTypes(){
@@ -30,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);
@@ -62,7 +45,6 @@ void kt_initKerepTypes(){
// Unitype
kt_register(Unitype);
kt_register(Array_Unitype);
kt_register(Autoarr_Unitype);
// STNode
@@ -77,7 +59,6 @@ void kt_initKerepTypes(){
// string
kt_register(string);
kt_register(Array_string);
kt_register(Autoarr_string);
// StringBuilder
@@ -86,10 +67,8 @@ void kt_initKerepTypes(){
// File
kt_register(FileHandle);
// Network
kt_register(knIPV4Address);
kt_register(knIPV4Endpoint);
kt_register(knSocketTCP);
kt_register(knSocketUDP);
kt_register(knSocketChanneled);
// Allocators
kt_register(CstdAllocator);
kt_register(LinearAllocator);
kt_register(StackingAllocator);
}

11
src/base/type_system/ktDescriptor.h
View File

@@ -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);\
@@ -19,25 +20,25 @@ extern "C" {
.name=#TYPE, \
.id=ktid_undefined, \
.size=sizeof(TYPE), \
.freeMembers=FREE_MEMBERS_F, \
.destruct=FREE_MEMBERS_F, \
.toString=TOSTRING_F \
}; \
ktDescriptor ktDescriptor_##TYPE##_Ptr={\
.name=#TYPE "_Ptr", \
.id=ktid_undefined, \
.size=sizeof(TYPE), \
.freeMembers=FREE_MEMBERS_F, \
.destruct=FREE_MEMBERS_F, \
.toString=TOSTRING_F \
};
typedef void (*freeMembers_t)(void*);
typedef char* (*toString_t)(void* obj, u32 fmt);
typedef void (*destruct_t)(void*);
typedef char* (*toString_t)(allocator_ptr al, void* obj, u32 fmt);
STRUCT(ktDescriptor,
char* name;
ktid id;
u16 size;
freeMembers_t freeMembers; // NULL or function which frees all struct members
destruct_t destruct; // NULL or function which frees all struct members
toString_t toString; // NULL or function which generates string representaion of object
)

54
src/base/type_system/kt_functions.c
View File

@@ -17,27 +17,27 @@ 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->destruct ? toString_hex(al, d->destruct, sizeof(void*), 0,1,0) : n;
char *rez=cptr_concat(al, "ktDescriptor {"
" name:", d->name,
" id:",s0,
" size:",s1,
" toString:",s2,
" freeMembers:",s3,
" destruct:",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);
@@ -52,26 +52,21 @@ ktid ktid_last=-1;
ENUM(ktDescriptorsState,
NotInitialized, Initializing, Initialized
)
ktDescriptorsState initState=NotInitialized;
bool _printDebugMessages = false;
void kt_beginInit(bool printDebugMessages){
_printDebugMessages = printDebugMessages;
if(printDebugMessages)
kprintf("\e[94mtype descriptors initializing...\n");
__descriptorPointers=Autoarr_create(Pointer, 256, 256);
void kt_beginInit(){
kprintf("\e[94mtype descriptors initializing...\n");
Autoarr_construct(__descriptorPointers, Pointer, 256, NULL);
}
void kt_endInit(){
if(__descriptorPointers==NULL)
throw(ERR_NULLPTR);
typeDescriptors=(ktDescriptor**)Autoarr_toArray(__descriptorPointers);
Autoarr_free(__descriptorPointers,true);
if(typeDescriptors==NULL) throw(ERR_NULLPTR);
if(_printDebugMessages)
kprintf("\e[92minitialized %u type descriptors\n", ktid_last);
typeDescriptors=(ktDescriptor**)Autoarr_toArray(__descriptorPointers, CstdAllocator_instPtr);
Autoarr_destruct(__descriptorPointers);
if(typeDescriptors==NULL)
throw(ERR_NULLPTR);
kprintf("\e[92minitialized %u type descriptors\n", ktid_last);
}
void __kt_register(ktDescriptor* descriptor){
@@ -80,12 +75,13 @@ void __kt_register(ktDescriptor* descriptor){
}
ktDescriptor* ktDescriptor_get(ktid id){
if(id>ktid_last || id==ktid_undefined)
throw(cptr_concat("invalid type id ", toString_i64(id)));
if(id>ktid_last || id==ktid_undefined) {
kprintf("\ntype id: %u\n",id);
throw("invalid type id");
}
return typeDescriptors[id];
}
void kt_free(){
void kt_deinit(){
free(typeDescriptors);
}

6
src/base/type_system/kt_functions.h
View File

@@ -17,16 +17,16 @@ void __kt_register(ktDescriptor* descriptor);
__kt_register(&ktDescriptor_##TYPE##_Ptr); \
ktid_##TYPE##_Ptr=ktid_last;
void kt_beginInit(bool printDebugMessages);
void kt_beginInit();
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);

4
src/base/type_system/typedef_macros.h
View File

@@ -8,6 +8,10 @@
ENUM_MEMBERS \
} __attribute__((__packed__)) ENUM_NAME;
#define PACKED_STRUCT(STRUCT_NAME, STRUCT_MEMBERS...) typedef struct STRUCT_NAME { \
STRUCT_MEMBERS \
} __attribute__((__packed__)) STRUCT_NAME;
#define STRUCT(STRUCT_NAME, STRUCT_MEMBERS...) typedef struct STRUCT_NAME STRUCT_NAME; \
typedef struct STRUCT_NAME { \
STRUCT_MEMBERS \

47
src/base/type_system/unitype.c
View File

@@ -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, (destruct_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);
if (type->freeMembers)
type->freeMembers(u.VoidPtr);
if (u.allocatedInHeap)
free(u.VoidPtr);
}
void __UnitypePtr_free(void *u)
{
Unitype_free(*(Unitype *)u);
ktDescriptor *type = ktDescriptor_get(u->typeId);
if (type->destruct)
type->destruct(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 *result = 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);
return result;
allocator_free(al, valuestr);
return rezult;
}
void printuni(Unitype v)
{
char *s = Unitype_toString(v, 0);
LinearAllocator _al;
LinearAllocator_construct(&_al, 128);
allocator_ptr al=&_al.base;
char *s = Unitype_toString(al, v, 0);
fputs(s, stdout);
free(s);
LinearAllocator_destruct(&_al);
}

7
src/base/type_system/unitype.h
View File

@@ -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,9 +45,8 @@ 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

68
src/kprint/kprint.c
View File

@@ -23,7 +23,7 @@ ktid __typeFromFormat(kp_fmt f){
}
}
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,54 +35,62 @@ 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){
if(n%2 != 0) safethrow("kprint received non-even number of arguments",;);
if(n > 32) safethrow("kprint received >32 number of arguments",;);
if(n%2 != 0) safethrow("kprint recieved non-even number of arguments",;);
if(n > 32) safethrow("kprint recieved >32 number of arguments",;);
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();
StringBuilder _sb;
StringBuilder* sb=&_sb;
StringBuilder_construct(sb, al);
for(u8 i=0; i<n; i++){
try(__next_toString(formats[i], &objects[i]),mStr,;);
StringBuilder_append_cptr(strb, mStr.value.VoidPtr);
Unitype_free(mStr.value);
try(__next_toString(al, formats[i], &objects[i]),mStr,;);
StringBuilder_append_cptr(sb, mStr.value.VoidPtr);
allocator_free(al, mStr.value.VoidPtr);
}
char* result=StringBuilder_build(strb).ptr;
return SUCCESS(UniHeapPtr(char, result));
char* rezult=StringBuilder_build(sb).ptr;
return SUCCESS(UniHeapPtr(char, rezult));
}
Maybe __kfprint(FILE* file, u8 n, kp_fmt* formats, __kp_value_union* objects){
try(check_argsN(n), _,;);
n/=2;
LinearAllocator _al;
LinearAllocator_construct(&_al, 256);
allocator_ptr al=&_al.base;
for(u8 i=0; i<n; i++){
try(__next_toString(formats[i], &objects[i]),maybeStr,;);
try(__next_toString(al, formats[i], &objects[i]),maybeStr, LinearAllocator_destruct(&_al));
if(fputs(maybeStr.value.VoidPtr, file)==EOF)
safethrow("can't write string to file", Unitype_free(maybeStr.value));
Unitype_free(maybeStr.value);
safethrow("can't write string to file", LinearAllocator_destruct(&_al));
}
fflush(file);
LinearAllocator_destruct(&_al);
return MaybeNull;
}
void __kprint(u8 n, kp_fmt* formats, __kp_value_union* objects){
tryLast(check_argsN(n), _,;);
n/=2;
LinearAllocator _al;
LinearAllocator_construct(&_al, 256);
allocator_ptr al=&_al.base;
for(u8 i=0; i<n; i++){
kp_fmt fmt=formats[i];
kprint_setColor(fmt);
tryLast(__next_toString(fmt, &objects[i]),maybeStr, kprint_setColor(kp_bgBlack|kp_fgGray));
if(fputs(maybeStr.value.VoidPtr, stdout)==EOF) \
tryLast(__next_toString(al, fmt, &objects[i]), maybeStr,
kprint_setColor(kp_bgBlack|kp_fgGray););
if(fputs(maybeStr.value.VoidPtr, stdout)==EOF)
throw("can't write string to stdout");
//, Unitype_free(maybeStr.value)
Unitype_free(maybeStr.value);
}
fflush(stdout);
LinearAllocator_destruct(&_al);
}
#if defined(_WIN32)|| defined(_WIN64)
@@ -90,6 +98,7 @@ void __kprint(u8 n, kp_fmt* formats, __kp_value_union* objects){
#define FOREGROUND_YELLOW FOREGROUND_GREEN | FOREGROUND_RED
DWORD kp_fgColor_toWin(kp_fgColor f){
//kprintf("fg: %x\n", f);
switch(f){
case kp_fgBlack: return 0;
case kp_fgRedD: return FOREGROUND_RED;
@@ -112,6 +121,7 @@ DWORD kp_fgColor_toWin(kp_fgColor f){
}
DWORD kp_bgColor_toWin(kp_bgColor f){
//kprintf("bg: %x\n", f);
switch(f){
case kp_bgBlack: return 0;
case kp_bgRedD: return BACKGROUND_RED;
@@ -165,17 +175,19 @@ void kprint_setColor(kp_fmt f){
ktDescriptor* type=ktDescriptor_get(format.typeId);
if(!type->toString)
safethrow("type descriptor doesnt have toString() func",;);
StringBuilder* strb=StringBuilder_create();
StringBuilder_append_char(strb, '[');
StringBuilder _sb;
StringBuilder* sb=&_sb;
StringBuilder_construct(sb, al);
StringBuilder_append_char(sb, '[');
for (u16 e=1; e<count; e++){
StringBuilder_append_char(strb, ' ');
StringBuilder_append_char(sb, ' ');
char* elStr=type->toString(array+type->size*e, &format);
StringBuilder_append_cptr(strb, elStr);
StringBuilder_append_char(strb, ',');
StringBuilder_append_cptr(sb, elStr);
StringBuilder_append_char(sb, ',');
}
StringBuilder_rmchar(strb);
StringBuilder_append_char(strb, ' ');
StringBuilder_append_char(strb, ']');
StringBuilder_rmchar(sb);
StringBuilder_append_char(sb, ' ');
StringBuilder_append_char(sb, ']');
} */
static const char* _kp_colorNames[16]={
@@ -197,12 +209,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];

6
src/kprint/kprint.h
View File

@@ -70,12 +70,12 @@ 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<char*>
#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*/

6
src/kprint/kprint_colors.h
View File

@@ -4,7 +4,7 @@
extern "C" {
#endif
#include "../base/type_system/typedef_macros.h"
#include "../base/memory/allocator_base.h"
// 10000000 00000000 00000000 00000000
// ^ ^^^^
@@ -83,8 +83,8 @@ 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
}

221
src/kprint/kprintf.c
View File

@@ -45,219 +45,114 @@ WORD unixColorToWin(u8 c){
}
#endif
i32 _kprintf(const char* format, const i32 args_count, ...){
void kprintf(const char* format, ...){
va_list vl;
va_start(vl, args_count);
i32 i = 0;
i32 args_left = args_count;
for(char c = format[i++]; c != 0; c = format[i++]){
va_start(vl, format);
u32 i=0;
LinearAllocator _al;
LinearAllocator_construct(&_al, 128);
allocator_ptr al=(allocator_ptr)&_al;
for(char c=format[i++]; c!=0; c=format[i++]){
// value format specifiers
if(c == '%'){
if(args_left-- == 0)
return kprintf_NOT_ENOUGH_ARGUMENTS;
char* argstr = NULL;
bool l = false;
c = format[i++];
if(c=='%'){
char* argstr=NULL;
bool l=false;
c=format[i++];
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;
if((c = format[i++]))
l=true;
if((c=format[i++]))
goto format_escape_seq;
break;
case 'p': ;
void* phex = va_arg(vl, void*);
argstr = toString_hex(&phex,getEndian() == LittleEndian,sizeof(phex),1,0);
void* phex=va_arg(vl, void*);
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);
u64 xhex=va_arg(vl, u64);
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);
u32 xhex=va_arg(vl, u32);
argstr=toString_hex(al, &xhex,getEndian()==LittleEndian,sizeof(xhex),0,1);
}
break;
case 's': ;
char* cptr = va_arg(vl,char*);
char* cptr=va_arg(vl,char*);
if(!cptr)
cptr = "<nullstr>";
cptr="<nullstr>";
if(*cptr)
fputs(cptr, stdout);
break;
case 'c':
putc((char)va_arg(vl,int), stdout);
argstr=allocator_alloc(al, 2);
argstr[0]=(char)va_arg(vl,int);
argstr[1]=0;
break;
default:
fputs("<INCORRECT FORMAT STRING>", stdout);
return kprintf_INVALID_FORMAT;
putc('\n',stdout);
putc('<',stdout);
putc(c,stdout);
putc('>',stdout);
throw(ERR_FORMAT);
}
if(argstr){
fputs(argstr, stdout);
free(argstr);
}
}
// escape sequences
else if(c == '\e'){
//////////////////// WINDOWS ////////////////////
#if defined(_WIN64) || defined(_WIN32)
if((c = format[i++]) == '['){
u8 colorUnix = 0;
for(i8 n = 0; n<6 && c != 0; n++){
c = format[i++];
switch (c){
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
colorUnix = colorUnix*10+c-'0';
break;
case 'm': ;
WORD colorWin = unixColorToWin(colorUnix);
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(hConsole, colorWin);
goto end_iteration;
default:
goto end_iteration;
else if(c=='\e'){
IFWIN(
/* WINDOWS */
({
if((c=format[i++])=='['){
u8 colorUnix=0;
for(i8 n=0; n<6 && c!=0; n++){
c=format[i++];
switch (c){
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
colorUnix=colorUnix*10+c-'0';
break;
case 'm': ;
WORD colorWin=unixColorToWin(colorUnix);
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(hConsole, colorWin);
goto end_iteration;
default:
goto end_iteration;
}
}
}
}
////////////////////// UNIX //////////////////////
#else
}),
/* UNIX */
putc(c,stdout);
#endif
);
}
// common characters
else {
putc(c,stdout);
}
#if defined(_WIN64) || defined(_WIN32)
end_iteration:;
end_iteration:;
#endif
}
va_end(vl);
return i;
}
i32 _ksprintf(char* buffer, i32 buffer_size, const char* format, const i32 args_count, ...){
if(buffer == NULL)
return kprintf_BUFFER_IS_NULL;
va_list vl;
va_start(vl, args_count);
i32 i = 0;
i32 written = 0;
i32 args_left = args_count;
for(char c = format[i++]; c != 0; c = format[i++]){
// value format specifiers
if(c == '%'){
if(args_left-- == 0)
return kprintf_NOT_ENOUGH_ARGUMENTS;
char* argstr = NULL;
bool l = false;
c = format[i++];
format_escape_seq:
switch (c) {
case 'u':
argstr = toString_u64(
l ? va_arg(vl, u64) : va_arg(vl, u32)
,0,0);
break;
case 'i': case 'd':
argstr = toString_i64(
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);
break;
case 'l':
l = true;
if((c = format[i++]))
goto format_escape_seq;
break;
case 'p': ;
void* phex = va_arg(vl, void*);
argstr = toString_hex(&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);
}
else {
u32 xhex = va_arg(vl, u32);
argstr = toString_hex(&xhex,getEndian() == LittleEndian,sizeof(xhex),0,1);
}
break;
case 's': ;
char* cptr = va_arg(vl,char*);
if(!cptr)
cptr = "<nullstr>";
if(*cptr){
i32 str_length = cptr_length(cptr);
if(written + str_length > buffer_size)
return kprintf_BUFFER_IS_TOO_SMALL;
memcpy(buffer + written, cptr, str_length);
written += str_length;
}
break;
case 'c': ;
char ch = (char)va_arg(vl,int);
if(written > buffer_size)
return kprintf_BUFFER_IS_TOO_SMALL;
buffer[written++] = ch;
break;
default:
const char errformat_str[] = "<INCORRECT FORMAT STRING>";
if(written + (i32)sizeof(errformat_str) <= buffer_size)
memcpy(buffer + written, errformat_str, sizeof(errformat_str));
return kprintf_INVALID_FORMAT;
}
if(argstr){
i32 str_length = cptr_length(argstr);
if(written + str_length > buffer_size)
return kprintf_BUFFER_IS_TOO_SMALL;
memcpy(buffer + written, argstr, str_length);
written += str_length;
free(argstr);
}
}
// common characters
else {
if(written > buffer_size)
return kprintf_BUFFER_IS_TOO_SMALL;
buffer[written++] = c;
}
}
va_end(vl);
if(written > buffer_size)
return kprintf_BUFFER_IS_TOO_SMALL;
buffer[written] = '\0';
return i;
LinearAllocator_destruct(&_al);
}

59
src/kprint/kprintf.h
View File

@@ -6,63 +6,8 @@ extern "C" {
#include "../base/type_system/base_toString.h"
#define kprintf_INVALID_FORMAT -1
#define kprintf_NOT_ENOUGH_ARGUMENTS -2
#define kprintf_BUFFER_IS_TOO_SMALL -3
#define kprintf_BUFFER_IS_NULL -4
/// cross-platform printf analog
///@return number of processed format string characters or error code
i32 _kprintf(const char* format, const i32 args_count, ...);
#define kprintf(FORMAT, ARGS... ) _kprintf(FORMAT, count_args(ARGS) ,##ARGS)
/// @return number of processed format string characters or error code
i32 _ksprintf(char* buffer, i32 buffer_size, const char* format, const i32 args_count, ...);
#define ksprintf(BUFFER, BUFFER_SIZE, FORMAT, ARGS... ) _ksprintf(BUFFER, BUFFER_SIZE, FORMAT, count_args(ARGS) ,##ARGS)
// printf format terminal color sequence
#define _PRINTF_COLOR(N) "\e["#N"m"
// foreground dark color codes
#define FBLK _PRINTF_COLOR(30)
#define FREDD _PRINTF_COLOR(31)
#define FGRND _PRINTF_COLOR(32)
#define FYELD _PRINTF_COLOR(33)
#define FBLUD _PRINTF_COLOR(34)
#define FMAGD _PRINTF_COLOR(35)
#define FCYND _PRINTF_COLOR(36)
#define FGRY _PRINTF_COLOR(37)
// foreground bright color codes
#define FGRYD _PRINTF_COLOR(90)
#define FRED _PRINTF_COLOR(91)
#define FGRN _PRINTF_COLOR(92)
#define FYEL _PRINTF_COLOR(93)
#define FBLU _PRINTF_COLOR(94)
#define FMAG _PRINTF_COLOR(95)
#define FCYN _PRINTF_COLOR(96)
#define FWHI _PRINTF_COLOR(97)
// background dark color codes
#define BBLK _PRINTF_COLOR(40)
#define BREDD _PRINTF_COLOR(41)
#define BGRND _PRINTF_COLOR(42)
#define BYELD _PRINTF_COLOR(43)
#define BBLUD _PRINTF_COLOR(44)
#define BMAGD _PRINTF_COLOR(45)
#define BCYND _PRINTF_COLOR(46)
#define BGRY _PRINTF_COLOR(47)
// background bright color codes
#define BGRYD _PRINTF_COLOR(100)
#define BRED _PRINTF_COLOR(101)
#define BGRN _PRINTF_COLOR(102)
#define BYEL _PRINTF_COLOR(103)
#define BBLU _PRINTF_COLOR(104)
#define BMAG _PRINTF_COLOR(105)
#define BCYN _PRINTF_COLOR(106)
#define BWHI _PRINTF_COLOR(107)
// cross-platform printf analog
void kprintf(const char* format, ...);
#if __cplusplus
}

7
src/random/xoshiro-xoroshiro.md → src/random/RANDOM.md
View File

@@ -1,7 +1,10 @@
# 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/)
# Random
This directory contains some popular random functions. I recommend you using `splitmix64` initialized with `random_seedFromTime` for fast rng, hoshiro128plus for more accurate 32-bit rng and hoshiro256plus for 64-bit.
## 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

72
src/random/krandom.h
View File

@@ -1,72 +0,0 @@
#pragma once
#if __cplusplus
extern "C" {
#endif
#include "../base/std.h"
#include "splitmix64/splitmix64.h"
#include "xoroshiro/xoroshiro.h"
#include "xoshiro/xoshiro.h"
/*
You can choose any algorithm that has required functions:
some_alg32_statePtr some_alg32_init(u32 seed);
u32 some_alg32_next(some_alg32_statePtr);
void some_alg32_free(some_alg32_statePtr);
#define KRAND_ALG32_init some_alg32_init
#define KRAND_ALG32_next some_alg32_next
#define KRAND_ALG32_free some_alg32_free
#include "kerep/random/krandom.h"
The same way it works for 64-bit RNGs
*/
// default rng_next function
#ifndef KRAND_ALG32_next
#define KRAND_ALG32_next xoshiro128plus##_next
#endif
#ifndef KRAND_ALG32_init
#define KRAND_ALG32_init xoshiro128plus##_init
#endif
#ifndef KRAND_ALG32_free
#define KRAND_ALG32_free xoshiro128plus##_free
#endif
#ifndef KRAND_ALG64_next
#define KRAND_ALG64_next xoshiro256plus##_next
#endif
#ifndef KRAND_ALG64_init
#define KRAND_ALG64_init xoshiro256plus##_init
#endif
#ifndef KRAND_ALG64_free
#define KRAND_ALG64_free xoshiro256plus##_free
#endif
typedef void* krand_statePtr;
#define KRAND_ALG32_initFromTime xoshiro128plus##_initFromTime
#define KRAND_ALG64_initFromTime xoshiro256plus##_initFromTime
#define __krand_next_definition(VALUE_SIZE) { return from+KRAND_ALG##VALUE_SIZE##_next(state)%(to-from); }
// ready-to-use functions
static inline i8 krand_next8 (krand_statePtr state, i8 from, i8 to) __krand_next_definition(32)
static inline i16 krand_next16(krand_statePtr state, i16 from, i16 to) __krand_next_definition(32)
static inline i32 krand_next32(krand_statePtr state, i32 from, i32 to) __krand_next_definition(32)
static inline i64 krand_next64(krand_statePtr state, i64 from, i64 to) __krand_next_definition(64)
// divides random number by 2^64 to return a value between 0 and 1
static inline f32 krand_nextFloat32(krand_statePtr state) {return (f32)KRAND_ALG32_next(state) / (u32)(-1); }
static inline f64 krand_nextFloat64(krand_statePtr state) {return (f64)KRAND_ALG64_next(state) / (u64)(-1); }
///@param chance (0-1.0) is probability of success
static inline bool fate(krand_statePtr state,float chance){
i32 limit=1/chance + 0.01f;
return KRAND_ALG32_next(state)%limit == 0;
}
#if __cplusplus
}
#endif

33
src/random/random.h Normal file
View File

@@ -0,0 +1,33 @@
#pragma once
#if __cplusplus
extern "C" {
#endif
#include "../base/std.h"
#include "splitmix64/splitmix64.h"
#include "xoroshiro/32bitValue/xoroshiro64.h"
#include "xoroshiro/64bitValue/xoroshiro128.h"
#include "xoshiro/32bitValue/xoshiro128.h"
#include "xoshiro/64bitValue/xoshiro256.h"
#define random_seedFromTime() time(NULL)
/// divides random number by 2^32
/// @return value between 0 and 1
static inline f32 random_toFloat32(u32 random_value) { return (f32)random_value / (f32)0xffff; }
/// divides random number by 2^64
/// @return value between 0 and 1
static inline f64 random_nextFloat64(u64 random_value) { return (f64)random_value / (f64)0xffffffff; }
///@param probability (0-1.0) probability of success
///@return is action sucsessfull or not
static inline bool random_probability(u32 random_value, float probability){
i32 limit=1.0f/probability + 0.0002f;
return random_value%limit == 0;
}
#if __cplusplus
}
#endif

15
src/random/splitmix64/splitmix64.c
View File

@@ -11,20 +11,11 @@ computations) or xorshift1024* (for massively parallel computations)
generator.
*/
// The state can be seeded with any (upto) 64 bit integer value.
void* splitmix64_init(u64 seed){
splitmix64_state* state=malloc(sizeof(splitmix64_state));
*state=seed;
return state;
}
u64 splitmix64_next(void* _state) {
splitmix64_state* state=_state;
u64 splitmix64_next(splitmix64_state* state_ptr) {
// increment the state variable
*state += 0x9e3779b97f4a7c15;
*state_ptr += 0x9e3779b97f4a7c15;
// copy the state to a working variable
u64 z = *state;
u64 z = *state_ptr;
// xor the variable with the variable right bit shifted 30 then multiply by a constant
z = (z ^ (z>>30)) * 0xbf58476d1ce4e5b9;
// xor the variable with the variable right bit shifted 27 then multiply by a constant

11
src/random/splitmix64/splitmix64.h
View File

@@ -7,16 +7,13 @@ extern "C" {
#include "../../base/base.h"
typedef u64 splitmix64_state;
typedef void* splitmix64_statePtr;
splitmix64_statePtr splitmix64_init(u64 seed);
static inline splitmix64_statePtr splitmix64_initFromTime(void) { return splitmix64_init(time(NULL)); }
u64 splitmix64_next(splitmix64_statePtr);
static inline void splitmix64_free(splitmix64_statePtr state) {
free(state);
static inline void splitmix64_construct(splitmix64_state* state, u64 seed){
*state=seed;
}
u64 splitmix64_next(splitmix64_state* state_ptr);
#if __cplusplus
}
#endif

20
src/random/xoroshiro/32bitValue/xoroshiro64.h
View File

@@ -4,31 +4,17 @@
extern "C" {
#endif
#include "../../../base/std.h"
#include "../../splitmix64/splitmix64.h"
typedef union {
u64 merged;
u32 s[2];
} xoroshiro64_state;
typedef void* xoroshiro64_statePtr;
xoroshiro64_statePtr xoroshiro64_init(u64 seed);
#define xoroshiro64star_init xoroshiro64_init
#define xoroshiro64starstar_init xoroshiro64_init
void xoroshiro64_construct(xoroshiro64_state* state_ptr, u64 seed);
static inline xoroshiro64_statePtr xoroshiro64_initFromTime(void) { return xoroshiro64_init(time(NULL)); }
#define xoroshiro64star_initFromTime xoroshiro64_initFromTime
#define xoroshiro64starstar_initFromTime xoroshiro64_initFromTime
u32 xoroshiro64star_next(xoroshiro64_statePtr);
u32 xoroshiro64starstar_next(xoroshiro64_statePtr);
static inline void xoroshiro64_free(xoroshiro64_statePtr state) {
free(state);
}
#define xoroshiro64star_free xoroshiro64_free
#define xoroshiro64starstar_free xoroshiro64_free
u32 xoroshiro64star_next(xoroshiro64_state*);
u32 xoroshiro64starstar_next(xoroshiro64_state*);
#if __cplusplus
}

13
src/random/xoroshiro/32bitValue/xoroshiro64star.c
View File

@@ -27,8 +27,7 @@ static inline u32 rotl(const u32 x, i32 k) {
return (x << k) | (x >> (32 - k));
}
u32 xoroshiro64star_next(void* _state) {
xoroshiro64_state* state=_state;
u32 xoroshiro64star_next(xoroshiro64_state* state) {
const u32 s0 = state->s[0];
u32 s1 = state->s[1];
const u32 result = s0 * 0x9E3779BB;
@@ -40,10 +39,8 @@ u32 xoroshiro64star_next(void* _state) {
return result;
}
void* xoroshiro64_init(u64 seed){
xoroshiro64_state* state=malloc(sizeof(xoroshiro64_state));
splitmix64_state* splitmix=splitmix64_init(seed);
state->merged=splitmix64_next(splitmix);
splitmix64_free(splitmix);
return state;
void xoroshiro64_construct(xoroshiro64_state* state, u64 seed){
splitmix64_state sm_state;
splitmix64_construct(&sm_state, seed);
state->merged=splitmix64_next(&sm_state);
}

3
src/random/xoroshiro/32bitValue/xoroshiro64starstar.c
View File

@@ -23,8 +23,7 @@ static inline u32 rotl(const u32 x, i32 k) {
return (x << k) | (x >> (32 - k));
}
u32 xoroshiro64starstar_next(void* _state) {
xoroshiro64_state* state=_state;
u32 xoroshiro64starstar_next(xoroshiro64_state* state) {
const u32 s0 = state->s[0];
u32 s1 = state->s[1];
const u32 result = rotl(s0 * 0x9E3779BB, 5) * 5;

26
src/random/xoroshiro/64bitValue/xoroshiro128.h
View File

@@ -4,35 +4,17 @@
extern "C" {
#endif
#include "../../../base/std.h"
#include "../../splitmix64/splitmix64.h"
typedef union {
u32 s[2];
} xoroshiro128_state;
typedef void* xoroshiro128_statePtr;
xoroshiro128_statePtr xoroshiro128_init(u64 seed);
#define xoroshiro128plus_init xoroshiro128_init
#define xoroshiro128plusplus_init xoroshiro128_init
#define xoroshiro128starstar_init xoroshiro128_init
void xoroshiro128_construct(xoroshiro128_state* state, u64 seed);
static inline xoroshiro128_statePtr xoroshiro128_initFromTime(void) { return xoroshiro128_init(time(NULL)); }
#define xoroshiro128plus_initFromTime xoroshiro128_initFromTime
#define xoroshiro128plusplus_initFromTime xoroshiro128_initFromTime
#define xoroshiro128starstar_initFromTime xoroshiro128_initFromTime
u64 xoroshiro128plus_next(xoroshiro128_statePtr);
u64 xoroshiro128plusplus_next(xoroshiro128_statePtr);
u64 xoroshiro128starstar_next(xoroshiro128_statePtr);
static inline void xoroshiro128_free(xoroshiro128_statePtr state) {
free(state);
}
#define xoroshiro128plus_free xoroshiro128_free
#define xoroshiro128plusplus_free xoroshiro128_free
#define xoroshiro128starstar_free xoroshiro128_free
u64 xoroshiro128plus_next(xoroshiro128_state*);
u64 xoroshiro128plusplus_next(xoroshiro128_state*);
u64 xoroshiro128starstar_next(xoroshiro128_state*);
#if __cplusplus
}

15
src/random/xoroshiro/64bitValue/xoroshiro128plus.c
View File

@@ -36,8 +36,7 @@ static inline u64 rotl(const u64 x, i32 k) {
return (x << k) | (x >> (64 - k));
}
u64 xoroshiro128plus_next(void* _state){
xoroshiro128_state* state=_state;
u64 xoroshiro128plus_next(xoroshiro128_state* state){
const u64 s0 = state->s[0];
u64 s1 = state->s[1];
const u64 result = s0 + s1;
@@ -49,11 +48,9 @@ u64 xoroshiro128plus_next(void* _state){
return result;
}
void* xoroshiro128_init(u64 seed){
xoroshiro128_state* state=malloc(sizeof(xoroshiro128_state));
splitmix64_state* splitmix=splitmix64_init(seed);
state->s[0]=splitmix64_next(splitmix);
state->s[1]=splitmix64_next(splitmix);
splitmix64_free(splitmix);
return state;
void xoroshiro128_construct(xoroshiro128_state* state, u64 seed){
splitmix64_state sm_state;
splitmix64_construct(&sm_state, seed);
state->s[0]=splitmix64_next(&sm_state);
state->s[1]=splitmix64_next(&sm_state);
}

3
src/random/xoroshiro/64bitValue/xoroshiro128plusplus.c
View File

@@ -25,8 +25,7 @@ static inline u64 rotl(const u64 x, i32 k) {
return (x << k) | (x >> (64 - k));
}
u64 xoroshiro128plusplus_next(void* _state){
xoroshiro128_state* state=_state;
u64 xoroshiro128plusplus_next(xoroshiro128_state* state){
const u64 s0 = state->s[0];
u64 s1 = state->s[1];
const u64 result = rotl(s0 + s1, 17) + s0;

Some files were not shown because too many files have changed in this diff Show More