abdelrahman/wizapp-stdlib
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 11 Wiki Activity

Compare commits

base: abdelrahman/wizapp-stdlib:v2.0.0
Branches Tags
abdelrahman/wizapp-stdlib:main abdelrahman/wizapp-stdlib:growing_arena abdelrahman/wizapp-stdlib:mem_context_and_allocator
abdelrahman/wizapp-stdlib:v2.0.1 abdelrahman/wizapp-stdlib:v2.0.0 abdelrahman/wizapp-stdlib:v1.2.0 abdelrahman/wizapp-stdlib:v1.1.2 abdelrahman/wizapp-stdlib:v1.1.1 abdelrahman/wizapp-stdlib:v1.1.0 abdelrahman/wizapp-stdlib:v1.0.4 abdelrahman/wizapp-stdlib:v1.0.3 abdelrahman/wizapp-stdlib:v1.0.2 abdelrahman/wizapp-stdlib:v1.0.1 abdelrahman/wizapp-stdlib:v1.0.0
..
compare: abdelrahman/wizapp-stdlib:31a22b74e943f82542c1ab923d91b8eb6c3d4505
Branches Tags
abdelrahman/wizapp-stdlib:main abdelrahman/wizapp-stdlib:growing_arena abdelrahman/wizapp-stdlib:mem_context_and_allocator
abdelrahman/wizapp-stdlib:v2.0.1 abdelrahman/wizapp-stdlib:v2.0.0 abdelrahman/wizapp-stdlib:v1.2.0 abdelrahman/wizapp-stdlib:v1.1.2 abdelrahman/wizapp-stdlib:v1.1.1 abdelrahman/wizapp-stdlib:v1.1.0 abdelrahman/wizapp-stdlib:v1.0.4 abdelrahman/wizapp-stdlib:v1.0.3 abdelrahman/wizapp-stdlib:v1.0.2 abdelrahman/wizapp-stdlib:v1.0.1 abdelrahman/wizapp-stdlib:v1.0.0

2 Commits
v2.0.0 .. 31a22b74e9

Author SHA1 Message Date
abdelrahman 31a22b74e9 Reformat base 2025-12-29 21:21:09 +00:00
abdelrahman a32ef94522 Test replacing spaces with tabs 2025-12-29 15:59:50 +00:00
103 changed files with 4159 additions and 6834 deletions
Expand all files Collapse all files
.gitea/workflows/release.yml
-81
View File
@@ -1,81 +0,0 @@
name: Release
on:
push:
branches:
- main # or your default branch
jobs:
release:
runs-on: self-hosted
steps:
- name: Checkout repository
uses: actions/checkout@v4
with:
fetch-depth: 0 # fetch full history
tags: true # fetch all tags
- name: Check/Create Tag
id: tag
run: |
VERSION=$(cat VERSION | tr -d '[:space:]') # read version and trim whitespace
echo "Version: $VERSION"
if git rev-parse "v$VERSION" >/dev/null 2>&1; then
echo "Tag v$VERSION already exists. Skipping release."
exit 0
fi
# Tag does not exist → create it
echo "Creating tag v$VERSION"
git tag "v$VERSION"
git push origin "v$VERSION"
echo "version=$VERSION" >> $GITHUB_OUTPUT
- name: Build Artifacts
if: steps.tag.outputs.version
run: |
chmod +x ./package
./package
ls -l dist/
- name: Create Release
if: steps.tag.outputs.version
id: create_release
run: |
VERSION="${{ steps.tag.outputs.version }}"
RESPONSE=$(curl -s -X POST \
-H "Authorization: token ${{ secrets.GITEA_TOKEN }}" \
-H "Content-Type: application/json" \
"https://git.thewizardapprentice.com/api/v1/repos/${{ gitea.repository }}/releases" \
-d '{
"tag_name": "v'"$VERSION"'",
"name": "wapp-v'"$VERSION"'",
"body": "Automated release for wapp-v'"$VERSION"'",
"draft": false,
"prerelease": false
}')
echo "$RESPONSE"
RELEASE_ID=$(echo $RESPONSE | jq -r '.id')
echo "release_id=$RELEASE_ID" >> $GITHUB_OUTPUT
- name: Upload Artifacts
if: steps.tag.outputs.version
run: |
RELEASE_ID="${{ steps.create_release.outputs.release_id }}"
for FILE in dist/*; do
FILENAME=$(basename "$FILE")
echo "Uploading $FILENAME"
curl -X POST \
-H "Authorization: token ${{ secrets.GITEA_TOKEN }}" \
-H "Content-Type: application/octet-stream" \
--data-binary @"$FILE" \
"https://git.thewizardapprentice.com/api/v1/repos/${{ gitea.repository }}/releases/$RELEASE_ID/assets?name=$FILENAME"
done
- name: Cleanup
if: steps.tag.outputs.version
run: rm -rf dist/*
LICENSE
-201
View File
@@ -1,201 +0,0 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [2026] [Abdelrahman Said]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Makefile
+10 -13
View File
@@ -21,22 +21,21 @@ override TEST_INCLUDE := -Isrc $(shell find tests -type d | xargs -I{} ech
override TEST_SRC := $(shell find tests -type f -name "*.c" | xargs -I{} echo -n "{} ")
override TEST_C_SRC := src/wapp.c $(TEST_SRC)
override TEST_CXX_SRC := $(shell find tests -type f -name "*.cc" | xargs -I{} echo -n "{} ")
override LIB_BASENAME := wapp
override OBJ_OUT := $(BUILD_DIR)/$(LIB_BASENAME).o
override LIB_STATIC_NAME := lib$(LIB_BASENAME).a
override LIB_OUT := $(BUILD_DIR)/$(LIB_STATIC_NAME)
override LIB_NAME := wapp
override OBJ_OUT := $(BUILD_DIR)/$(LIB_NAME).o
override LIB_OUT := $(BUILD_DIR)/lib$(LIB_NAME).a
override TEST_C_OUT := $(BUILD_DIR)/wapptest
override TEST_CXX_OUT := $(BUILD_DIR)/wapptestcc
override ABS_INSTALL_PREFIX := $(shell mkdir -p $(INSTALL_PREFIX) && realpath $(INSTALL_PREFIX))
override INCLUDE_INSTALL := $(ABS_INSTALL_PREFIX)/include/$(LIB_BASENAME)
override INCLUDE_INSTALL := $(ABS_INSTALL_PREFIX)/include/$(LIB_NAME)
override LIB_INSTALL := $(ABS_INSTALL_PREFIX)/lib
override HEADER_INSTALL_CMD := scripts/header_install.sh
ifeq ($(origin BUILD_FLAGS), undefined)
ifeq ($(BUILD_TYPE),Debug)
BUILD_FLAGS += -g -fsanitize=address,undefined -DWP_DEBUG_ASSERT
BUILD_FLAGS += -g -fsanitize=address,undefined -DWAPP_DEBUG_ASSERT
else ifeq ($(BUILD_TYPE),RelWithDebInfo)
BUILD_FLAGS += -g -O2 -fsanitize=address,undefined -DWP_DEBUG_ASSERT
BUILD_FLAGS += -g -O2 -fsanitize=address,undefined -DWAPP_DEBUG_ASSERT
else ifeq ($(BUILD_TYPE),Release)
BUILD_FLAGS += -O3
else
@@ -46,7 +45,7 @@ endif
# Disable runtime asserts
ifeq ($(RUNTIME_ASSERT), false)
override BUILD_FLAGS += -DWP_NO_RUNTIME_ASSERT
override BUILD_FLAGS += WAPP_NO_RUNTIME_ASSERT
endif
ifeq ($(CC),gcc)
@@ -146,14 +145,12 @@ uuid: install
clean:
@rm -rf "$(BUILD_DIR)"
@rm -rf "$(INCLUDE_INSTALL)"
@rm -f "$(LIB_INSTALL)/$(LIB_STATIC_NAME)"
builddir:
@mkdir -p "$(BUILD_DIR)"
build-c-test:
bear -- $(CC) $(CSTD) $(CFLAGS) $(BUILD_FLAGS) $(TEST_INCLUDE) $(TEST_C_SRC) -o "$(TEST_C_OUT)"
$(CC) $(CSTD) $(CFLAGS) $(BUILD_FLAGS) $(TEST_INCLUDE) $(TEST_C_SRC) -o "$(TEST_C_OUT)"
run-c-test: build-c-test
@echo -e "\n\033[34;1mRUNNING C TESTS\033[0m"
@@ -161,7 +158,7 @@ run-c-test: build-c-test
@rm "$(TEST_C_OUT)"
build-cc-test:
bear -a -- $(CXX) $(CXXSTD) $(CFLAGS) $(BUILD_FLAGS) $(TEST_INCLUDE) $(TEST_CXX_SRC) "$(LIB_OUT)" -o "$(TEST_CXX_OUT)"
$(CXX) $(CXXSTD) $(CFLAGS) $(BUILD_FLAGS) $(TEST_INCLUDE) $(TEST_CXX_SRC) "$(LIB_OUT)" -o "$(TEST_CXX_OUT)"
run-cc-test: build-cc-test
@echo -e "\n\033[34;1mRUNNING C++ TESTS\033[0m"
@@ -175,6 +172,6 @@ install: build-lib
@bash $(HEADER_INSTALL_CMD) $(LIB_SRC) "$(INCLUDE_INSTALL)" $(INCLUDES)
build-lib: builddir
bear -a -- $(CC) -c $(CSTD) $(CFLAGS) $(BUILD_FLAGS) $(LIBFLAGS) $(LIB_SRC) -o "$(OBJ_OUT)"
$(CC) -c $(CSTD) $(CFLAGS) $(BUILD_FLAGS) $(LIBFLAGS) $(LIB_SRC) -o "$(OBJ_OUT)"
$(AR) r "$(LIB_OUT)" "$(OBJ_OUT)"
@rm "$(OBJ_OUT)"
README.md
+1 -3
View File
@@ -1,5 +1,3 @@
# Wizard Apprentice Standard Library
**Wizard Apprentice Standard Library** (`wapp`) is a lightweight collection of reusable utilities for **C and C++** projects.
For more information about the library and how to use it, check the [wiki](https://git.thewizardapprentice.com/abdelrahman/wizapp-stdlib/wiki).
A group of utilities for C/C++ projects
VERSION
-1
View File
@@ -1 +0,0 @@
2.0.0
build
+1 -1
View File
@@ -55,4 +55,4 @@ if ! contains ${BUILD_TYPE} "${ACCEPTED_BUILD_TYPES[@]}"; then
exit 1
fi
make BUILD_TYPE=$BUILD_TYPE $ARGS
bear -- make BUILD_TYPE=$BUILD_TYPE $ARGS
build.ps1
+3
View File
@@ -52,6 +52,9 @@ mkdir -p $ObjDir > $null
mkdir -p $OutDir > $null
mkdir -p $TestsDir > $null
# Run code generation
Invoke-Expression "python -m codegen"
# Build and run C tests
Invoke-Expression "$Compiler $GeneralFlags $CStd $IncludeDirs $TestIncludeDirs $SrcFiles $TestCSrcFiles $TestCOutputFlags" -ErrorAction Stop
Invoke-Expression "$TestsDir/$TestCOutputBasename.exe"
package
-11
View File
@@ -1,11 +0,0 @@
#!/bin/bash
cp -r src wapp
mkdir -p dist
ARCHIVE_NAME="wapp-v$(cat VERSION)"
tar -czvf dist/$ARCHIVE_NAME.tar.gz wapp
zip -r dist/$ARCHIVE_NAME.zip wapp
rm -rf wapp
src/base/array/array.c
+75 -168
View File
@@ -7,260 +7,167 @@
#include "../../common/aliases/aliases.h"
#include <stddef.h>
#define _array_header(ARRAY) (WpArrayHeader *)(wpMiscUtilsOffsetPointer(ARRAY, (i64)sizeof(WpArrayHeader) * -1))
#define _offset_pointer(PTR, OFFSET) ((void *)((uptr)(PTR) + (OFFSET)))
wp_persist inline void _array_validate(const WpArray array, u64 item_size);
wapp_persist inline void _array_validate(const GenericArray *array, u64 item_size);
u64 _arrayCount(WpArray array) {
wpDebugAssert(array != NULL, "`array` should not be NULL");
void *_array_get(GenericArray *array, u64 index, u64 item_size) {
wapp_runtime_assert(array != NULL, "`array` should not be NULL");
_array_validate(array, item_size);
wapp_runtime_assert(index < array->count, "`index` is out of bounds");
WpArrayHeader *header = _array_header(array);
wpRuntimeAssert(WP_ARRAY_MAGIC == header->magic, "`array` is not a valid wapp array");
return header->count;
return _offset_pointer(array->items, array->item_size * index);
}
u64 _arrayCapacity(WpArray array) {
wpDebugAssert(array != NULL, "`array` should not be NULL");
WpArrayHeader *header = _array_header(array);
wpRuntimeAssert(WP_ARRAY_MAGIC == header->magic, "`array` is not a valid wapp array");
return header->capacity;
void _array_set(GenericArray *array, u64 index, void *value, u64 item_size) {
void *item = _array_get(array, index, item_size);
memcpy(item, value, array->item_size);
}
u64 _arrayItemSize(WpArray array) {
wpDebugAssert(array != NULL, "`array` should not be NULL");
WpArrayHeader *header = _array_header(array);
wpRuntimeAssert(WP_ARRAY_MAGIC == header->magic, "`array` is not a valid wapp array");
return header->item_size;
}
void _arraySetCount(WpArray array, u64 count) {
wpDebugAssert(array != NULL, "`array` should not be NULL");
WpArrayHeader *header = _array_header(array);
wpRuntimeAssert(WP_ARRAY_MAGIC == header->magic, "`array` is not a valid wapp array");
header->count = count;
}
void *_arrayGet(WpArray array, u64 index, u64 item_size) {
wpRuntimeAssert(array != NULL, "`array` should not be NULL");
void _array_append_capped(GenericArray *array, void *value, u64 item_size) {
wapp_runtime_assert(array != NULL, "`array` should not be NULL");
_array_validate(array, item_size);
WpArrayHeader *header = _array_header(array);
wpRuntimeAssert(index < header->count, "`index` is out of bounds");
if (array->count >= array->capacity) { return; }
return wpMiscUtilsOffsetPointer(array, header->item_size * index);
u64 index = (array->count)++;
_array_set(array, index, value, item_size);
}
void _arraySet(WpArray array, u64 index, void *value, u64 item_size) {
void *item = _arrayGet(array, index, item_size);
WpArrayHeader *header = _array_header(array);
memcpy(item, value, header->item_size);
}
void _arrayAppendCapped(WpArray array, void *value, u64 item_size) {
wpRuntimeAssert(array != NULL, "`array` should not be NULL");
_array_validate(array, item_size);
WpArrayHeader *header = _array_header(array);
if (header->count >= header->capacity) { return; }
u64 index = (header->count)++;
_arraySet(array, index, value, item_size);
}
void _arrayExtendCappend(WpArray dst, const WpArray src, u64 item_size) {
wpRuntimeAssert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
void _array_extend_capped(GenericArray *dst, const GenericArray *src, u64 item_size) {
wapp_runtime_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
_array_validate(dst, item_size);
_array_validate(src, item_size);
WpArrayHeader *src_header = _array_header(src);
WpArrayHeader *dst_header = _array_header(dst);
u64 remaining_capacity = dst_header->capacity - dst_header->count;
u64 remaining_capacity = dst->capacity - dst->count;
u64 copy_count = src_header->count < remaining_capacity ? src_header->count : remaining_capacity;
void *dst_ptr = wpMiscUtilsOffsetPointer(dst, dst_header->count * dst_header->item_size);
memcpy(dst_ptr, src, copy_count * src_header->item_size);
dst_header->count += copy_count;
u64 copy_count = src->count < remaining_capacity ? src->count : remaining_capacity;
void *dst_ptr = _offset_pointer(dst->items, dst->count * dst->item_size);
memcpy(dst_ptr, src->items, copy_count * src->item_size);
dst->count += copy_count;
}
void _arrayCopyCapped(WpArray dst, const WpArray src, u64 item_size) {
wpRuntimeAssert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
void _array_copy_capped(GenericArray *dst, const GenericArray *src, u64 item_size) {
wapp_runtime_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
_array_validate(dst, item_size);
_array_validate(src, item_size);
_arrayClear(dst, item_size);
WpArrayHeader *src_header = _array_header(src);
WpArrayHeader *dst_header = _array_header(dst);
u64 copy_count = src_header->count < dst_header->capacity ? src_header->count : dst_header->capacity;
memcpy((void *)dst, (void *)src, copy_count * src_header->item_size);
dst_header->count = copy_count;
_array_clear(dst, item_size);
u64 copy_count = src->count < dst->capacity ? src->count : dst->capacity;
memcpy(dst->items, src->items, copy_count * src->item_size);
dst->count = copy_count;
}
WpArray _arrayAppendAlloc(const WpAllocator *allocator, WpArray array, void *value,
WpArrayInitFlags flags, u64 item_size) {
wpRuntimeAssert(allocator != NULL && array != NULL, "`allocator` and `array` should not be NULL");
GenericArray *_array_append_alloc(const Allocator *allocator, GenericArray *array, void *value, u64 item_size) {
wapp_runtime_assert(allocator != NULL && array != NULL, "`allocator` and `array` should not be NULL");
_array_validate(array, item_size);
WpArray output = array;
GenericArray *output = array;
WpArrayHeader *header = _array_header(array);
if (header->count >= header->capacity) {
u64 new_capacity = wpMiscUtilsU64RoundUpPow2(header->capacity * 2);
output = (WpArray )_arrayAllocCapacity(allocator, new_capacity, flags,
header->item_size);
if (array->count >= array->capacity) {
u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2);
output = (GenericArray *)_array_alloc_capacity(allocator, new_capacity, array->item_size, false);
if (!output) {
output = array;
goto RETURN_ARRAY_APPEND_ALLOC;
}
_arrayCopyCapped(output, array, item_size);
_array_copy_capped(output, array, item_size);
}
_arrayAppendCapped(output, value, item_size);
if ((flags & WP_ARRAY_INIT_FILLED) == WP_ARRAY_INIT_FILLED) {
_arraySetCount(output, _arrayCapacity(output));
}
_array_append_capped(output, value, item_size);
RETURN_ARRAY_APPEND_ALLOC:
return output;
}
WpArray _arrayExtendAlloc(const WpAllocator *allocator, WpArray dst, const WpArray src,
WpArrayInitFlags flags, u64 item_size) {
wpRuntimeAssert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL");
GenericArray *_array_extend_alloc(const Allocator *allocator, GenericArray *dst, const GenericArray *src, u64 item_size) {
wapp_runtime_assert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL");
_array_validate(dst, item_size);
_array_validate(src, item_size);
WpArray output = dst;
GenericArray *output = dst;
WpArrayHeader *src_header = _array_header(src);
WpArrayHeader *dst_header = _array_header(dst);
u64 remaining_capacity = dst_header->capacity - dst_header->count;
if (src_header->count >= remaining_capacity) {
u64 new_capacity = wpMiscUtilsU64RoundUpPow2(dst_header->capacity * 2);
output = (WpArray )_arrayAllocCapacity(allocator, new_capacity,
flags, dst_header->item_size);
u64 remaining_capacity = dst->capacity - dst->count;
if (src->count >= remaining_capacity) {
u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2);
output = (GenericArray *)_array_alloc_capacity(allocator, new_capacity, dst->item_size, false);
if (!output) {
output = dst;
goto RETURN_ARRAY_EXTEND_ALLOC;
}
_arrayCopyCapped(output, dst, item_size);
_array_copy_capped(output, dst, item_size);
}
_arrayExtendCappend(output, src, item_size);
if ((flags & WP_ARRAY_INIT_FILLED) == WP_ARRAY_INIT_FILLED) {
_arraySetCount(output, _arrayCapacity(output));
}
_array_extend_capped(output, src, item_size);
RETURN_ARRAY_EXTEND_ALLOC:
return output;
}
WpArray _arrayCopyAlloc(const WpAllocator *allocator, WpArray dst, const WpArray src,
WpArrayInitFlags flags, u64 item_size) {
wpRuntimeAssert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL");
GenericArray *_array_copy_alloc(const Allocator *allocator, GenericArray *dst, const GenericArray *src, u64 item_size) {
wapp_runtime_assert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL");
_array_validate(dst, item_size);
_array_validate(src, item_size);
WpArray output = dst;
GenericArray *output = dst;
WpArrayHeader *src_header = _array_header(src);
WpArrayHeader *dst_header = _array_header(dst);
if (src_header->count >= dst_header->capacity) {
u64 new_capacity = wpMiscUtilsU64RoundUpPow2(dst_header->capacity * 2);
output = (WpArray )_arrayAllocCapacity(allocator, new_capacity,
flags, src_header->item_size);
if (src->count >= dst->capacity) {
u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2);
output = (GenericArray *)_array_alloc_capacity(allocator, new_capacity, src->item_size, false);
if (!output) {
output = dst;
goto RETURN_ARRAY_COPY_ALLOC;
}
}
_arrayCopyCapped(output, src, item_size);
if ((flags & WP_ARRAY_INIT_FILLED) == WP_ARRAY_INIT_FILLED) {
_arraySetCount(output, _arrayCapacity(output));
}
_array_copy_capped(output, src, item_size);
RETURN_ARRAY_COPY_ALLOC:
return output;
}
void *_arrayPop(WpArray array, u64 item_size) {
wpRuntimeAssert(array != NULL, "`array` should not be NULL");
void *_array_pop(GenericArray *array, u64 item_size) {
wapp_runtime_assert(array != NULL, "`array` should not be NULL");
_array_validate(array, item_size);
WpArrayHeader *header = _array_header(array);
if (header->count == 0) { return NULL; }
if (array->count == 0) { return NULL; }
u64 index = header->count - 1;
void *out = _arrayGet(array, index, item_size);
--(header->count);
u64 index = array->count - 1;
void *out = _array_get(array, index, item_size);
--(array->count);
return out;
}
void _arrayClear(WpArray array, u64 item_size) {
wpRuntimeAssert(array != NULL, "`array` should not be NULL");
void _array_clear(GenericArray *array, u64 item_size) {
wapp_runtime_assert(array != NULL, "`array` should not be NULL");
_array_validate(array, item_size);
WpArrayHeader *header = _array_header(array);
header->count = 0;
array->count = 0;
}
u64 _arrayCalcAllocSize(u64 capacity, u64 item_size) {
return sizeof(WpArrayHeader) + item_size * capacity;
}
GenericArray *_array_alloc_capacity(const Allocator *allocator, u64 capacity, u64 item_size, b8 fill) {
wapp_runtime_assert(allocator != NULL, "`allocator` should not be NULL");
WpArray _arrayAllocCapacity(const WpAllocator *allocator, u64 capacity, WpArrayInitFlags flags,
u64 item_size) {
wpRuntimeAssert(allocator != NULL, "`allocator` should not be NULL");
GenericArray *output = NULL;
WpArray output = NULL;
u64 allocation_size = sizeof(GenericArray) + item_size * capacity;
u64 allocation_size = _arrayCalcAllocSize(capacity, item_size);
void *buffer = wpMemAllocatorAlloc(allocator, allocation_size);
if (!buffer) {
output = wapp_mem_allocator_alloc(allocator, allocation_size);
if (!output) {
goto RETURN_ARRAY_ALLOC;
}
output = _arrayFromPreallocatedBuffer(buffer, allocation_size, flags, item_size);
output->magic = WAPP_ARRAY_MAGIC;
output->count = fill ? capacity : 0;
output->capacity = capacity;
output->item_size = item_size;
output->items = (void *)(output + 1);
RETURN_ARRAY_ALLOC:
return output;
}
WpArray _arrayFromPreallocatedBuffer(void *buffer, u64 buffer_size, WpArrayInitFlags flags,
u64 item_size) {
wpRuntimeAssert(buffer != NULL, "`buffer` should not be NULL");
i64 data_buffer_size = (i64)buffer_size - (i64)(sizeof(WpArrayHeader));
if (data_buffer_size <= 0) {
return NULL;
}
u64 item_capacity = (u64)data_buffer_size / item_size;
WpArrayHeader *header = (WpArrayHeader *)buffer;
WpArray output = (u8 *)(header + 1);
header->magic = WP_ARRAY_MAGIC;
header->count = flags & WP_ARRAY_INIT_FILLED ? item_capacity : 0;
header->capacity = item_capacity;
header->item_size = item_size;
return output;
}
wp_persist inline void _array_validate(const WpArray array, u64 item_size) {
WpArrayHeader *header = _array_header(array);
wpRuntimeAssert(WP_ARRAY_MAGIC == header->magic, "`array` is not a valid wapp array");
wpRuntimeAssert(item_size == header->item_size, "Invalid item type provided");
wapp_persist inline void _array_validate(const GenericArray *array, u64 item_size) {
wapp_runtime_assert(WAPP_ARRAY_MAGIC == array->magic, "`array` is not a valid wapp array");
wapp_runtime_assert(item_size == array->item_size, "Invalid item type provided");
}
src/base/array/array.h
+128 -181
View File
@@ -8,209 +8,156 @@
#include "../../common/aliases/aliases.h"
#include "../../common/platform/platform.h"
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#define WP_ARRAY_MAGIC (u64)0x57415f415252
#define WAPP_ARRAY_MAGIC (u64)0x57415f415252
#define _calcArrayCount(TYPE, ...) wpMiscUtilsVaArgsCount(TYPE, __VA_ARGS__)
#define _calcArrayCapacity(TYPE, ...) wpMiscUtilsU64RoundUpPow2(_calcArrayCount(TYPE, __VA_ARGS__) * 2)
#define _calc_array_count(TYPE, ...) wapp_misc_utils_va_args_count(TYPE, __VA_ARGS__)
#define _calc_array_capacity(TYPE, ...) wapp_misc_utils_u64_round_up_pow2(_calc_array_count(TYPE, __VA_ARGS__) * 2)
typedef struct WpStr8 WpStr8;
#define wapp_array_alloc_capacity(ELEM_TYPE, ARRAY_TYPE, ALLOCATOR_PTR, CAPACITY, FILL) \
((ARRAY_TYPE *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(ELEM_TYPE), FILL))
// NOTE (Abdelrahman): Typedefs to distinguish arrays from regular pointers
typedef void *WpArray;
typedef void **WpVoidPtrArray;
typedef c8 *WpC8Array;
typedef c16 *WpC16Array;
typedef c32 *WpC32Array;
typedef u8 *WpU8Array;
typedef u16 *WpU16Array;
typedef u32 *WpU32Array;
typedef u64 *WpU64Array;
typedef b8 *WpB8Array;
typedef i8 *WpI8Array;
typedef i16 *WpI16Array;
typedef i32 *WpI32Array;
typedef i64 *WpI64Array;
typedef f32 *WpF32Array;
typedef f64 *WpF64Array;
typedef f128 *WpF128Array;
typedef uptr *WpUptrArray;
typedef iptr *WpIptrArray;
typedef WpStr8 *WpStr8Array;
#define WAPP_DEF_ARRAY_TYPE(T, NAME) \
typedef struct { \
u64 magic; \
u64 count; \
u64 capacity; \
u64 item_size; \
T *items; \
} NAME
typedef enum {
WP_ARRAY_INIT_NONE = 0,
WP_ARRAY_INIT_FILLED = 1 << 1,
} WpArrayInitFlags;
#ifdef WP_PLATFORM_CPP
#define wpArray(TYPE, ...) ([&]() { \
u64 capacity = _calcArrayCapacity(TYPE, __VA_ARGS__); \
#ifdef WAPP_PLATFORM_CPP
#define wapp_array(ELEM_TYPE, ARRAY_TYPE, ...) ([&]() { \
wapp_persist ELEM_TYPE items[sizeof(ELEM_TYPE) == sizeof(*((ARRAY_TYPE{}).items)) ? \
_calc_array_capacity(ELEM_TYPE, __VA_ARGS__) : -1 \
] = {__VA_ARGS__}; \
\
TYPE items[_calcArrayCapacity(TYPE, __VA_ARGS__)] = {__VA_ARGS__}; \
\
wp_persist u8 array[ \
sizeof(WpArrayHeader) + _calcArrayCapacity(TYPE, __VA_ARGS__) * sizeof(TYPE) \
] = {0}; \
WpArrayHeader *header = (WpArrayHeader *)array; \
header->magic = WP_ARRAY_MAGIC; \
header->count = _calcArrayCount(TYPE, __VA_ARGS__); \
header->capacity = _calcArrayCapacity(TYPE, __VA_ARGS__); \
header->item_size = sizeof(TYPE); \
\
u8 *buf = (u8 *)(header + 1); \
memcpy(buf, items, capacity * sizeof(TYPE)); \
return (TYPE *)buf; \
return ARRAY_TYPE{ \
WAPP_ARRAY_MAGIC, \
_calc_array_count(ELEM_TYPE, __VA_ARGS__), \
_calc_array_capacity(ELEM_TYPE, __VA_ARGS__), \
sizeof(ELEM_TYPE), \
items, \
}; \
}())
#define wpArrayWithCapacity(TYPE, CAPACITY, FLAGS) ([&]() { \
wp_persist u8 array[ \
sizeof(WpArrayHeader) + CAPACITY * sizeof(TYPE) \
] = {0}; \
WpArrayHeader *header = (WpArrayHeader *)array; \
header->magic = WP_ARRAY_MAGIC; \
header->count = (FLAGS & WP_ARRAY_INIT_FILLED) ? CAPACITY : 0; \
header->capacity = CAPACITY; \
header->item_size = sizeof(TYPE); \
#define wapp_array_with_capacity(ELEM_TYPE, ARRAY_TYPE, CAPACITY, FILL) ([&]() { \
wapp_persist ELEM_TYPE items[sizeof(ELEM_TYPE) == sizeof(*((ARRAY_TYPE{}).items)) ? \
CAPACITY : -1] = {}; \
\
return (TYPE *)(header + 1); \
return ARRAY_TYPE{ \
WAPP_ARRAY_MAGIC, \
FILL ? CAPACITY : 0, \
CAPACITY, \
sizeof(ELEM_TYPE), \
items, \
}; \
}())
#define wpArrayPop(TYPE, ARRAY) ([&]() { \
if (ARRAY == NULL || _arrayCount((WpArray)ARRAY) == 0) { \
TYPE result{}; \
#define wapp_array_pop(ELEM_TYPE, ARRAY_PTR) ([&]() { \
if (ARRAY_PTR == NULL || (ARRAY_PTR)->count == 0) { \
ELEM_TYPE result{}; \
return result; \
} \
\
return *((TYPE *)_arrayPop((WpArray)ARRAY, sizeof(TYPE))); \
return *((ELEM_TYPE *)_array_pop((GenericArray *)ARRAY_PTR, sizeof(ELEM_TYPE))); \
}())
#else
#define _stackArray(TYPE, SIZE) struct {WpArrayHeader header; \
TYPE items[SIZE]; \
wpMiscUtilsReservePadding(sizeof(WpArrayHeader) + \
sizeof(TYPE) * SIZE);}
#define wpArray(TYPE, ...) \
((TYPE *)( \
(_stackArray(TYPE, _calcArrayCapacity(TYPE, __VA_ARGS__))){ \
.header = { \
.magic = WP_ARRAY_MAGIC, \
.count = _calcArrayCount(TYPE, __VA_ARGS__), \
.capacity = _calcArrayCapacity(TYPE, __VA_ARGS__), \
.item_size = sizeof(TYPE), \
}, \
.items = {__VA_ARGS__}, \
}.items \
))
#define wpArrayWithCapacity(TYPE, CAPACITY, FLAGS) \
((TYPE *)( \
(_stackArray(TYPE, CAPACITY)){ \
.header = { \
.magic = WP_ARRAY_MAGIC, \
.count = (FLAGS & WP_ARRAY_INIT_FILLED) ? CAPACITY : 0, \
#define wapp_array(ELEM_TYPE, ARRAY_TYPE, ...) \
((ARRAY_TYPE){ \
.magic = WAPP_ARRAY_MAGIC, \
.count = _calc_array_count(ELEM_TYPE, __VA_ARGS__), \
.capacity = _calc_array_capacity(ELEM_TYPE, __VA_ARGS__), \
.item_size = sizeof(ELEM_TYPE), \
.items = (ELEM_TYPE[sizeof(ELEM_TYPE) == sizeof(*((ARRAY_TYPE){0}.items)) ? \
_calc_array_capacity(ELEM_TYPE, __VA_ARGS__) : \
-1]){__VA_ARGS__} \
})
#define wapp_array_with_capacity(ELEM_TYPE, ARRAY_TYPE, CAPACITY, FILL) \
((ARRAY_TYPE){ \
.magic = WAPP_ARRAY_MAGIC, \
.count = FILL ? CAPACITY : 0, \
.capacity = CAPACITY, \
.item_size = sizeof(TYPE), \
}, \
.items = {0}, \
}.items \
))
#define wpArrayPop(TYPE, ARRAY) \
(ARRAY == NULL || _arrayCount((WpArray)ARRAY) == 0 ? \
(TYPE){0} : \
*((TYPE *)_arrayPop((WpArray)ARRAY, sizeof(TYPE))) \
.item_size = sizeof(ELEM_TYPE), \
.items = (ELEM_TYPE[sizeof(ELEM_TYPE) == sizeof(*((ARRAY_TYPE){0}.items)) ? \
CAPACITY : -1]){0} \
})
#define wapp_array_pop(ELEM_TYPE, ARRAY_PTR) \
(ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
*((ELEM_TYPE *)_array_pop((GenericArray *)ARRAY_PTR, sizeof(ELEM_TYPE))) : \
(ELEM_TYPE){0} \
)
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#define wpArrayCount(ARRAY) \
(_arrayCount((WpArray)ARRAY))
#define wpArrayCapacity(ARRAY) \
(_arrayCapacity((WpArray)ARRAY))
#define wpArrayItemSize(ARRAY) \
(_arrayItemSize((WpArray)ARRAY))
#define wpArraySetCount(ARRAY, COUNT) \
(_arraySetCount((WpArray)ARRAY, COUNT))
#define wpArrayGet(TYPE, ARRAY, INDEX) \
((TYPE *)_arrayGet((WpArray)ARRAY, \
INDEX, \
sizeof(TYPE)))
#define wpArraySet(TYPE, ARRAY, INDEX, VALUE_PTR) \
(_arraySet((WpArray)ARRAY, \
INDEX, \
(u8 *)VALUE_PTR, \
sizeof(TYPE)))
#define wpArrayAppendCapped(TYPE, ARRAY, VALUE_PTR) \
(_arrayAppendCapped((WpArray)ARRAY, \
(u8 *)VALUE_PTR, \
sizeof(TYPE)))
#define wpArrayExtendCapped(TYPE, DST_ARRAY, SRC_ARRAY) \
(_arrayExtendCappend((WpArray)DST_ARRAY, \
(WpArray)SRC_ARRAY, \
sizeof(TYPE)))
#define wpArrayCopyCapped(TYPE, DST_ARRAY, SRC_ARRAY) \
(_arrayCopyCapped((WpArray)DST_ARRAY, \
(WpArray)SRC_ARRAY, \
sizeof(TYPE)))
#define wpArrayAppendAlloc(TYPE, ALLOCATOR_PTR, ARRAY, VALUE_PTR, FLAGS) \
((TYPE *)_arrayAppendAlloc(ALLOCATOR_PTR, \
(WpArray)ARRAY, \
(u8 *)VALUE_PTR, \
FLAGS, \
sizeof(TYPE)))
#define wpArrayExtendAlloc(TYPE, ALLOCATOR_PTR, DST_ARRAY, SRC_ARRAY, FLAGS) \
((TYPE *)_arrayExtendAlloc(ALLOCATOR_PTR, \
(WpArray)DST_ARRAY, \
(WpArray)SRC_ARRAY, \
FLAGS, \
sizeof(TYPE)))
#define wpArrayCopyAlloc(TYPE, ALLOCATOR_PTR, DST_ARRAY, SRC_ARRAY, FLAGS) \
((TYPE *)_arrayCopyAlloc(ALLOCATOR_PTR, \
(WpArray)DST_ARRAY, \
(WpArray)SRC_ARRAY, \
FLAGS, \
sizeof(TYPE)))
#define wpArrayClear(TYPE, ARRAY) \
(_arrayClear((WpArray)ARRAY, \
sizeof(TYPE)))
#define wpArrayCalcAllocSize(TYPE, CAPACITY) _arrayCalcAllocSize(CAPACITY, sizeof(TYPE))
#define wpArrayAllocCapacity(TYPE, ALLOCATOR_PTR, CAPACITY, FLAGS) \
((TYPE *)_arrayAllocCapacity(ALLOCATOR_PTR, CAPACITY, FLAGS, sizeof(TYPE)))
#define wpArrayFromPreallcatedBuffer(TYPE, BUFFER, BUFFER_SIZE) \
((TYPE *)_array_from_preallcated_buffer(BUFFER, BUFFER_SIZE, sizeof(TYPE)))
#define wapp_array_get(ELEM_TYPE, ARRAY_PTR, INDEX) \
((ELEM_TYPE *)_array_get((GenericArray *)ARRAY_PTR, INDEX, sizeof(ELEM_TYPE)))
#define wapp_array_set(ELEM_TYPE, ARRAY_PTR, INDEX, VALUE_PTR) \
_array_set((GenericArray *)ARRAY_PTR, INDEX, (void *)VALUE_PTR, sizeof(ELEM_TYPE))
#define wapp_array_append_capped(ELEM_TYPE, ARRAY_PTR, VALUE_PTR) \
_array_append_capped((GenericArray *)ARRAY_PTR, (void *)VALUE_PTR, sizeof(ELEM_TYPE))
#define wapp_array_extend_capped(ELEM_TYPE, DST_ARRAY_PTR, SRC_ARRAY_PTR) \
_array_extend_capped( \
(GenericArray *)DST_ARRAY_PTR, (GenericArray *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE) \
)
#define wapp_array_copy_capped(ELEM_TYPE, DST_ARRAY_PTR, SRC_ARRAY_PTR) \
_array_copy_capped( \
(GenericArray *)DST_ARRAY_PTR, (GenericArray *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE) \
)
#define wapp_array_append_alloc(ELEM_TYPE, ARRAY_TYPE, ALLOCATOR_PTR, ARRAY_PTR, VALUE_PTR) \
(ARRAY_TYPE *)_array_append_alloc( \
ALLOCATOR_PTR, (GenericArray *)ARRAY_PTR, (void *)VALUE_PTR, sizeof(ELEM_TYPE) \
)
#define wapp_array_extend_alloc(ELEM_TYPE, ARRAY_TYPE, ALLOCATOR_PTR, DST_ARRAY_PTR, SRC_ARRAY_PTR) \
(ARRAY_TYPE *)_array_extend_alloc( \
ALLOCATOR_PTR, (GenericArray *)DST_ARRAY_PTR, (GenericArray *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE) \
)
#define wapp_array_copy_alloc(ELEM_TYPE, ARRAY_TYPE, ALLOCATOR_PTR, DST_ARRAY_PTR, SRC_ARRAY_PTR) \
(ARRAY_TYPE *)_array_copy_alloc( \
ALLOCATOR_PTR, (GenericArray *)DST_ARRAY_PTR, (GenericArray *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE) \
)
#define wapp_array_clear(ELEM_TYPE, ARRAY_PTR) \
_array_clear((GenericArray *)ARRAY_PTR, sizeof(ELEM_TYPE))
WAPP_DEF_ARRAY_TYPE(void, GenericArray);
typedef struct WpArrayHeader WpArrayHeader;
struct WpArrayHeader {
u64 magic;
u64 count;
u64 capacity;
u64 item_size;
};
void *_array_get(GenericArray *array, u64 index, u64 item_size);
void _array_set(GenericArray *array, u64 index, void *value, u64 item_size);
void _array_append_capped(GenericArray *array, void *value, u64 item_size);
void _array_extend_capped(GenericArray *dst, const GenericArray *src, u64 item_size);
void _array_copy_capped(GenericArray *dst, const GenericArray *src, u64 item_size);
GenericArray *_array_append_alloc(const Allocator *allocator, GenericArray *array, void *value, u64 item_size);
GenericArray *_array_extend_alloc(const Allocator *allocator, GenericArray *dst, const GenericArray *src, u64 item_size);
GenericArray *_array_copy_alloc(const Allocator *allocator, GenericArray *dst, const GenericArray *src, u64 item_size);
void *_array_pop(GenericArray *array, u64 item_size);
void _array_clear(GenericArray *array, u64 item_size);
GenericArray *_array_alloc_capacity(const Allocator *allocator, u64 capacity, u64 item_size, b8 fill);
u64 _arrayCount(WpArray array);
u64 _arrayCapacity(WpArray array);
u64 _arrayItemSize(WpArray array);
void _arraySetCount(WpArray array, u64 count);
void *_arrayGet(WpArray array, u64 index, u64 item_size);
void _arraySet(WpArray array, u64 index, void *value, u64 item_size);
void _arrayAppendCapped(WpArray array, void *value, u64 item_size);
void _arrayExtendCappend(WpArray dst, const WpArray src, u64 item_size);
void _arrayCopyCapped(WpArray dst, const WpArray src, u64 item_size);
WpArray _arrayAppendAlloc(const WpAllocator *allocator, WpArray array, void *value,
WpArrayInitFlags flags, u64 item_size);
WpArray _arrayExtendAlloc(const WpAllocator *allocator, WpArray dst, const WpArray src,
WpArrayInitFlags flags, u64 item_size);
WpArray _arrayCopyAlloc(const WpAllocator *allocator, WpArray dst, const WpArray src,
WpArrayInitFlags flags, u64 item_size);
void *_arrayPop(WpArray array, u64 item_size);
void _arrayClear(WpArray array, u64 item_size);
u64 _arrayCalcAllocSize(u64 capacity, u64 item_size);
WpArray _arrayAllocCapacity(const WpAllocator *allocator, u64 capacity, WpArrayInitFlags flags,
u64 item_size);
WpArray _arrayFromPreallocatedBuffer(void *buffer, u64 buffer_size, WpArrayInitFlags flags,
u64 item_size);
// Base array types
typedef struct str8 Str8;
#ifdef WP_PLATFORM_CPP
WAPP_DEF_ARRAY_TYPE(void *, VoidPtrArray);
WAPP_DEF_ARRAY_TYPE(c8 , C8Array);
WAPP_DEF_ARRAY_TYPE(c16 , C16Array);
WAPP_DEF_ARRAY_TYPE(c32 , C32Array);
WAPP_DEF_ARRAY_TYPE(u8 , U8Array);
WAPP_DEF_ARRAY_TYPE(u16 , U16Array);
WAPP_DEF_ARRAY_TYPE(u32 , U32Array);
WAPP_DEF_ARRAY_TYPE(u64 , U64Array);
WAPP_DEF_ARRAY_TYPE(b8 , B8Array);
WAPP_DEF_ARRAY_TYPE(i8 , I8Array);
WAPP_DEF_ARRAY_TYPE(i16 , I16Array);
WAPP_DEF_ARRAY_TYPE(i32 , I32Array);
WAPP_DEF_ARRAY_TYPE(i64 , I64Array);
WAPP_DEF_ARRAY_TYPE(f32 , F32Array);
WAPP_DEF_ARRAY_TYPE(f64 , F64Array);
WAPP_DEF_ARRAY_TYPE(f128 , F128Array);
WAPP_DEF_ARRAY_TYPE(uptr , UptrArray);
WAPP_DEF_ARRAY_TYPE(iptr , IptrArray);
WAPP_DEF_ARRAY_TYPE(Str8 , Str8Array);
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#endif // !ARRAY_H
src/base/dbl_list/dbl_list.c
+102 -103
View File
@@ -7,48 +7,47 @@
#include "../../common/platform/platform.h"
#include <stddef.h>
wp_intern WpDblList _node_to_list(WpDblNode *node, u64 item_size);
wp_intern inline void _dblListValidate(const WpDblList *list, u64 item_size);
wp_intern inline void _dblListNodeValidate(const WpDblList *list, const WpDblNode *node, u64 item_size);
wapp_intern inline GenericList _node_to_list(GenericNode *node, u64 item_size);
wapp_intern inline void _dbl_list_validate(const GenericList *list, u64 item_size);
wapp_intern inline void _dbl_list_node_validate(const GenericList *list, const GenericNode *node, u64 item_size);
WpDblList *_dblListAlloc(const WpAllocator *allocator, u64 item_size) {
wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
GenericList *_dbl_list_alloc(const Allocator *allocator, u64 item_size) {
wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL");
WpDblList *list = wpMemAllocatorAlloc(allocator, sizeof(WpDblList));
GenericList *list = wapp_mem_allocator_alloc(allocator, sizeof(GenericList));
if (!list) { goto DBL_LIST_ALLOC_RETURN; }
memset((void *)list, 0, sizeof(WpDblList));
list->magic = WP_DBL_LIST_MAGIC;
memset((void *)list, 0, sizeof(GenericList));
list->magic = WAPP_DBL_LIST_MAGIC;
list->item_size = item_size;
DBL_LIST_ALLOC_RETURN:
return list;
}
WpDblNode *_dblListNodeAlloc(const WpAllocator *allocator, void *item, u64 item_size) {
wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
GenericNode *_dbl_list_node_alloc(const Allocator *allocator, u64 item_size) {
wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL");
WpDblNode *node = wpMemAllocatorAlloc(allocator, sizeof(WpDblNode));
GenericNode *node = wapp_mem_allocator_alloc(allocator, sizeof(GenericNode));
if (!node) { goto DBL_LIST_NODE_ALLOC_RETURN; }
memset((void *)node, 0, sizeof(WpDblNode));
node->item = item;
node->header.magic = WP_DBL_NODE_MAGIC;
node->header.item_size = item_size;
memset((void *)node, 0, sizeof(GenericNode));
node->magic = WAPP_DBL_NODE_MAGIC;
node->item_size = item_size;
DBL_LIST_NODE_ALLOC_RETURN:
return node;
}
WpDblNode *_dblListGet(const WpDblList *list, u64 index, u64 item_size) {
wpDebugAssert(list != NULL, "`list` should not be NULL");
_dblListValidate(list, item_size);
wpRuntimeAssert(index < list->node_count, "`index` is out of bounds");
GenericNode *_dbl_list_get(const GenericList *list, u64 index, u64 item_size) {
wapp_debug_assert(list != NULL, "`list` should not be NULL");
_dbl_list_validate(list, item_size);
wapp_runtime_assert(index < list->node_count, "`index` is out of bounds");
WpDblNode *output = NULL;
WpDblNode *current = list->first;
GenericNode *output = NULL;
GenericNode *current = list->first;
for (u64 i = 1; i <= index; ++i) {
current = current->header.next;
current = current->next;
}
output = current;
@@ -56,12 +55,12 @@ WpDblNode *_dblListGet(const WpDblList *list, u64 index, u64 item_size) {
return output;
}
void _dblListPushFront(WpDblList *list, WpDblNode *node, u64 item_size) {
wpDebugAssert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL");
_dblListValidate(list, item_size);
_dblListNodeValidate(list, node, item_size);
void _dbl_list_push_front(GenericList *list, GenericNode *node, u64 item_size) {
wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL");
_dbl_list_validate(list, item_size);
_dbl_list_node_validate(list, node, item_size);
WpDblList node_list = _node_to_list(node, item_size);
GenericList node_list = _node_to_list(node, item_size);
if (list->node_count == 0) {
*list = node_list;
@@ -70,21 +69,21 @@ void _dblListPushFront(WpDblList *list, WpDblNode *node, u64 item_size) {
list->node_count += node_list.node_count;
WpDblNode *first = list->first;
GenericNode *first = list->first;
if (first) {
first->header.prev = node_list.last;
first->prev = node_list.last;
}
list->first = node_list.first;
node_list.last->header.next = first;
node_list.last->next = first;
}
void _dblListPushBack(WpDblList *list, WpDblNode *node, u64 item_size) {
wpDebugAssert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL");
_dblListValidate(list, item_size);
_dblListNodeValidate(list, node, item_size);
void _dbl_list_push_back(GenericList *list, GenericNode *node, u64 item_size) {
wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL");
_dbl_list_validate(list, item_size);
_dbl_list_node_validate(list, node, item_size);
WpDblList node_list = _node_to_list(node, item_size);
GenericList node_list = _node_to_list(node, item_size);
if (list->node_count == 0) {
*list = node_list;
@@ -93,167 +92,167 @@ void _dblListPushBack(WpDblList *list, WpDblNode *node, u64 item_size) {
list->node_count += node_list.node_count;
WpDblNode *last = list->last;
GenericNode *last = list->last;
if (last) {
last->header.next = node_list.first;
last->next = node_list.first;
}
list->last = node_list.last;
node_list.first->header.prev = last;
node_list.first->prev = last;
}
void _dblListInsert(WpDblList *list, WpDblNode *node, u64 index, u64 item_size) {
wpDebugAssert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL");
_dblListValidate(list, item_size);
_dblListNodeValidate(list, node, item_size);
void _dbl_list_insert(GenericList *list, GenericNode *node, u64 index, u64 item_size) {
wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL");
_dbl_list_validate(list, item_size);
_dbl_list_node_validate(list, node, item_size);
if (index == 0) {
_dblListPushFront(list, node, item_size);
_dbl_list_push_front(list, node, item_size);
return;
} else if (index == list->node_count) {
_dblListPushBack(list, node, item_size);
_dbl_list_push_back(list, node, item_size);
return;
}
WpDblNode *dst_node = _dblListGet(list, index, item_size);
GenericNode *dst_node = _dbl_list_get(list, index, item_size);
if (!dst_node) {
return;
}
WpDblList node_list = _node_to_list(node, item_size);
GenericList node_list = _node_to_list(node, item_size);
list->node_count += node_list.node_count;
WpDblNode *prev = dst_node->header.prev;
GenericNode *prev = dst_node->prev;
dst_node->header.prev = node_list.last;
prev->header.next = node_list.first;
dst_node->prev = node_list.last;
prev->next = node_list.first;
node_list.first->header.prev = prev;
node_list.last->header.next = dst_node;
node_list.first->prev = prev;
node_list.last->next = dst_node;
}
WpDblNode *_dblListPopFront(WpDblList *list, u64 item_size) {
wpDebugAssert(list != NULL, "`list` should not be NULL");
_dblListValidate(list, item_size);
GenericNode *_dbl_list_pop_front(GenericList *list, u64 item_size) {
wapp_debug_assert(list != NULL, "`list` should not be NULL");
_dbl_list_validate(list, item_size);
WpDblNode *output = NULL;
GenericNode *output = NULL;
if (list->node_count == 0) {
goto RETURN_LIST_POP_FRONT;
goto RETURN_I32_LIST_POP_FRONT;
}
output = list->first;
if (list->node_count == 1) {
*list = (WpDblList){.magic = WP_DBL_LIST_MAGIC, .item_size = item_size};
goto RETURN_LIST_POP_FRONT;
*list = (GenericList){.magic = WAPP_DBL_LIST_MAGIC, .item_size = item_size};
goto RETURN_I32_LIST_POP_FRONT;
}
--(list->node_count);
list->first = output->header.next;
list->first = output->next;
output->header.prev = output->header.next = NULL;
output->prev = output->next = NULL;
RETURN_LIST_POP_FRONT:
RETURN_I32_LIST_POP_FRONT:
return output;
}
WpDblNode *_dblListPopBack(WpDblList *list, u64 item_size) {
wpDebugAssert(list != NULL, "`list` should not be NULL");
_dblListValidate(list, item_size);
GenericNode *_dbl_list_pop_back(GenericList *list, u64 item_size) {
wapp_debug_assert(list != NULL, "`list` should not be NULL");
_dbl_list_validate(list, item_size);
WpDblNode *output = NULL;
GenericNode *output = NULL;
if (list->node_count == 0) {
goto RETURN_LIST_POP_BACK;
goto RETURN_I32_LIST_POP_BACK;
}
output = list->last;
if (list->node_count == 1) {
*list = (WpDblList){.magic = WP_DBL_LIST_MAGIC, .item_size = item_size};
goto RETURN_LIST_POP_BACK;
*list = (GenericList){.magic = WAPP_DBL_LIST_MAGIC, .item_size = item_size};
goto RETURN_I32_LIST_POP_BACK;
}
--(list->node_count);
list->last = output->header.prev;
list->last = output->prev;
output->header.prev = output->header.next = NULL;
output->prev = output->next = NULL;
RETURN_LIST_POP_BACK:
RETURN_I32_LIST_POP_BACK:
return output;
}
WpDblNode *_dblListRemove(WpDblList *list, u64 index, u64 item_size) {
wpDebugAssert(list != NULL, "`list` should not be NULL");
_dblListValidate(list, item_size);
GenericNode *_dbl_list_remove(GenericList *list, u64 index, u64 item_size) {
wapp_debug_assert(list != NULL, "`list` should not be NULL");
_dbl_list_validate(list, item_size);
WpDblNode *output = NULL;
GenericNode *output = NULL;
if (index == 0) {
output = _dblListPopFront(list, item_size);
goto RETURN_LIST_REMOVE;
output = _dbl_list_pop_front(list, item_size);
goto RETURN_I32_LIST_REMOVE;
} else if (index == list->node_count) {
output = _dblListPopBack(list, item_size);
goto RETURN_LIST_REMOVE;
output = _dbl_list_pop_back(list, item_size);
goto RETURN_I32_LIST_REMOVE;
}
output = _dblListGet(list, index, item_size);
output = _dbl_list_get(list, index, item_size);
if (!output) {
goto RETURN_LIST_REMOVE;
goto RETURN_I32_LIST_REMOVE;
}
output->header.prev->header.next = output->header.next;
output->header.next->header.prev = output->header.prev;
output->prev->next = output->next;
output->next->prev = output->prev;
--(list->node_count);
output->header.prev = output->header.next = NULL;
output->prev = output->next = NULL;
RETURN_LIST_REMOVE:
RETURN_I32_LIST_REMOVE:
return output;
}
void _dblListEmpty(WpDblList *list, u64 item_size) {
wpDebugAssert(list != NULL, "`list` should not be NULL");
_dblListValidate(list, item_size);
void _dbl_list_empty(GenericList *list, u64 item_size) {
wapp_debug_assert(list != NULL, "`list` should not be NULL");
_dbl_list_validate(list, item_size);
u64 count = list->node_count;
for (u64 i = 0; i < count; ++i) {
_dblListPopBack(list, item_size);
_dbl_list_pop_back(list, item_size);
}
}
wp_intern WpDblList _node_to_list(WpDblNode *node, u64 item_size) {
WpDblList output = {
.magic = WP_DBL_LIST_MAGIC,
wapp_intern GenericList _node_to_list(GenericNode *node, u64 item_size) {
GenericList output = {
.magic = WAPP_DBL_LIST_MAGIC,
.first = node,
.last = node,
.node_count = 1,
.item_size = item_size,
};
while (output.first->header.prev != NULL) {
output.first = output.first->header.prev;
while (output.first->prev != NULL) {
output.first = output.first->prev;
++(output.node_count);
}
while (output.last->header.next != NULL) {
output.last = output.last->header.next;
while (output.last->next != NULL) {
output.last = output.last->next;
++(output.node_count);
}
return output;
}
wp_intern inline void _dblListValidate(const WpDblList *list, u64 item_size) {
wpRuntimeAssert(list->magic == WP_DBL_LIST_MAGIC, "`list` isn't a valid wp list type");
wpRuntimeAssert(list->item_size == item_size, "Invalid item provided");
wapp_intern void _dbl_list_validate(const GenericList *list, u64 item_size) {
wapp_runtime_assert(list->magic == WAPP_DBL_LIST_MAGIC, "`list` isn't a valid wapp list type");
wapp_runtime_assert(list->item_size == item_size, "Invalid item provided");
}
wp_intern inline void _dblListNodeValidate(const WpDblList *list, const WpDblNode *node, u64 item_size) {
wpRuntimeAssert(node->header.magic == WP_DBL_NODE_MAGIC, "`node` isn't a valid wp node type");
wpRuntimeAssert(list->item_size == node->header.item_size, "Mismatched `list` and `node` types");
wpRuntimeAssert(node->header.item_size == item_size, "Invalid item provided");
wapp_intern void _dbl_list_node_validate(const GenericList *list, const GenericNode *node, u64 item_size) {
wapp_runtime_assert(node->magic == WAPP_DBL_NODE_MAGIC, "`node` isn't a valid wapp node type");
wapp_runtime_assert(list->item_size == node->item_size, "Mismatched `list` and `node` types");
wapp_runtime_assert(node->item_size == item_size, "Invalid item provided");
}
src/base/dbl_list/dbl_list.h
+87 -161
View File
@@ -7,178 +7,104 @@
#include "../../common/aliases/aliases.h"
#include "../../common/platform/platform.h"
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#define WP_DBL_LIST_MAGIC (u64)0x57415f444c5354
#define WP_DBL_NODE_MAGIC (u64)0x57415f444e44
#define WAPP_DBL_LIST_MAGIC (u64)0x57415f444c5354
#define WAPP_DBL_NODE_MAGIC (u64)0x57415f444e44
typedef struct WpDblNode WpDblNode;
typedef struct {
u64 magic;
u64 item_size;
WpDblNode *prev;
WpDblNode *next;
} WpDblNodeHeader;
struct WpDblNode {
WpDblNodeHeader header;
void *item;
};
typedef struct {
u64 magic;
u64 node_count;
u64 item_size;
WpDblNode *first;
WpDblNode *last;
} WpDblList;
// NOTE (Abdelrahman): WpDblList typedefs for readability
typedef WpDblList WpVoidPtrList;
typedef WpDblList WpC8List;
typedef WpDblList WpC16List;
typedef WpDblList WpC32List;
typedef WpDblList WpU8List;
typedef WpDblList WpU16List;
typedef WpDblList WpU32List;
typedef WpDblList WpU64List;
typedef WpDblList WpB8List;
typedef WpDblList WpI8List;
typedef WpDblList WpI16List;
typedef WpDblList WpI32List;
typedef WpDblList WpI64List;
typedef WpDblList WpF32List;
typedef WpDblList WpF64List;
typedef WpDblList WpF128List;
typedef WpDblList WpUptrList;
typedef WpDblList WpIptrList;
typedef WpDblList WpStr8List;
// NOTE (Abdelrahman): WpDblNode typedefs for readability
typedef WpDblNode WpVoidPtrNode;
typedef WpDblNode WpC8Node;
typedef WpDblNode WpC16Node;
typedef WpDblNode WpC32Node;
typedef WpDblNode WpU8Node;
typedef WpDblNode WpU16Node;
typedef WpDblNode WpU32Node;
typedef WpDblNode WpU64Node;
typedef WpDblNode WpB8Node;
typedef WpDblNode WpI8Node;
typedef WpDblNode WpI16Node;
typedef WpDblNode WpI32Node;
typedef WpDblNode WpI64Node;
typedef WpDblNode WpF32Node;
typedef WpDblNode WpF64Node;
typedef WpDblNode WpF128Node;
typedef WpDblNode WpUptrNode;
typedef WpDblNode WpIptrNode;
typedef WpDblNode WpStr8Node;
#ifdef WP_PLATFORM_CPP
#define wpDblList(TYPE) \
WpDblList{WP_DBL_LIST_MAGIC, 0, sizeof(TYPE), nullptr, nullptr}
#define _dblListNode(TYPE, ITEM_PTR) ([&]() { \
wp_persist WpDblNode node = { \
WpDblNodeHeader{WP_DBL_NODE_MAGIC, sizeof(TYPE), nullptr, nullptr}, \
ITEM_PTR, \
#define WAPP_DEF_DBL_LIST_TYPE(T, NODE_NAME, LIST_NAME) \
typedef struct NODE_NAME NODE_NAME; \
struct NODE_NAME { \
u64 magic; \
T *item; \
NODE_NAME *prev; \
NODE_NAME *next; \
u64 item_size; \
}; \
\
return &node; \
}())
typedef struct { \
u64 magic; \
NODE_NAME *first; \
NODE_NAME *last; \
u64 node_count; \
u64 item_size; \
} LIST_NAME
#ifdef WAPP_PLATFORM_CPP
#define wapp_dbl_list(ELEM_TYPE, LIST_TYPE) \
LIST_TYPE{WAPP_DBL_LIST_MAGIC, nullptr, nullptr, 0, sizeof(ELEM_TYPE)}
#define wapp_dbl_list_node(ELEM_TYPE, NODE_TYPE, ELEM_PTR) \
NODE_TYPE{WAPP_DBL_NODE_MAGIC, ELEM_PTR, nullptr, nullptr, sizeof(ELEM_TYPE)}
#else
#define wpDblList(TYPE) ( \
(WpDblList){.magic = WP_DBL_LIST_MAGIC, .item_size = sizeof(TYPE)} \
#define wapp_dbl_list(ELEM_TYPE, LIST_TYPE) ( \
(LIST_TYPE){.magic = WAPP_DBL_LIST_MAGIC, .item_size = sizeof(ELEM_TYPE)} \
)
#define _dblListNode(TYPE, ITEM_PTR) ( \
&((WpDblNode){.header = {.magic = WP_DBL_NODE_MAGIC, .item_size = sizeof(TYPE)}, \
.item = ITEM_PTR}) \
#define wapp_dbl_list_node(ELEM_TYPE, NODE_TYPE, ELEM_PTR) ( \
(NODE_TYPE){.magic = WAPP_DBL_NODE_MAGIC, .item = ELEM_PTR, .item_size = sizeof(ELEM_TYPE)} \
)
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#define wpDblListAlloc(TYPE, ALLOCATOR) \
(_dblListAlloc(ALLOCATOR, sizeof(TYPE)))
#define wpDblListGet(TYPE, LIST_PTR, ITEM_INDEX) \
((TYPE *)(_dblListGet(LIST_PTR, ITEM_INDEX, sizeof(TYPE))->item))
#define wpDblListGetNode(TYPE, LIST_PTR, ITEM_INDEX) \
(_dblListGet(LIST_PTR, ITEM_INDEX, sizeof(TYPE)))
#define wpDblListGetNodeItem(TYPE, NODE_PTR) \
((TYPE *)( \
(NODE_PTR == NULL) ? \
NULL : \
(NODE_PTR)->item \
))
#define wpDblListPushFront(TYPE, LIST_PTR, ITEM_PTR) \
(_dblListPushFront(LIST_PTR, _dblListNode(TYPE, ITEM_PTR), sizeof(TYPE)))
#define wpDblListPushBack(TYPE, LIST_PTR, ITEM_PTR) \
(_dblListPushBack(LIST_PTR, _dblListNode(TYPE, ITEM_PTR), sizeof(TYPE)))
#define wpDblListInsert(TYPE, LIST_PTR, ITEM_PTR, ITEM_INDEX) \
(_dblListInsert(LIST_PTR, _dblListNode(TYPE, ITEM_PTR), \
ITEM_INDEX, sizeof(TYPE)))
#define wpDblListPushFrontAlloc(TYPE, ALLOCATOR, LIST_PTR, ITEM_PTR) \
(_dblListPushFront(LIST_PTR, _dblListNodeAlloc(ALLOCATOR, ITEM_PTR, sizeof(TYPE)), \
sizeof(TYPE)))
#define wpDblListPushBackAlloc(TYPE, ALLOCATOR, LIST_PTR, ITEM_PTR) \
(_dblListPushBack(LIST_PTR, _dblListNodeAlloc(ALLOCATOR, ITEM_PTR, sizeof(TYPE)), \
sizeof(TYPE)))
#define wpDblListInsertAlloc(TYPE, ALLOCATOR, LIST_PTR, ITEM_PTR, ITEM_INDEX) \
(_dblListInsert(LIST_PTR, _dblListNodeAlloc(ALLOCATOR, ITEM_PTR, sizeof(TYPE)), \
ITEM_INDEX, sizeof(TYPE)))
#define wpDblListPopFront(TYPE, LIST_PTR) \
((TYPE *)( \
(LIST_PTR == NULL || (LIST_PTR)->node_count == 0) ? \
NULL : \
_dblListPopFront(LIST_PTR, sizeof(TYPE))->item \
))
#define wpDblListPopBack(TYPE, LIST_PTR) \
((TYPE *)( \
(LIST_PTR == NULL || (LIST_PTR)->node_count == 0) ? \
NULL : \
_dblListPopBack(LIST_PTR, sizeof(TYPE))->item \
))
#define wpDblListRemove(TYPE, LIST_PTR, ITEM_INDEX) \
((TYPE *)( \
(LIST_PTR == NULL || (LIST_PTR)->node_count == 0 || ITEM_INDEX >= (LIST_PTR)->node_count) ? \
NULL : \
_dblListRemove(LIST_PTR, ITEM_INDEX, sizeof(TYPE))->item \
))
#define wpDblListPopFrontNode(TYPE, LIST_PTR) \
( \
(LIST_PTR == NULL || (LIST_PTR)->node_count == 0) ? \
NULL : \
_dblListPopFront(LIST_PTR, sizeof(TYPE)) \
)
#define wpDblListPopBackNode(TYPE, LIST_PTR) \
( \
(LIST_PTR == NULL || (LIST_PTR)->node_count == 0) ? \
NULL : \
_dblListPopBack(LIST_PTR, sizeof(TYPE)) \
)
#define wpDblListRemoveNode(TYPE, LIST_PTR, ITEM_INDEX) \
( \
(LIST_PTR == NULL || (LIST_PTR)->node_count == 0 || ITEM_INDEX >= (LIST_PTR)->node_count) ? \
NULL : \
_dblListRemove(LIST_PTR, ITEM_INDEX, sizeof(TYPE)) \
)
#define wpDblListEmpty(TYPE, LIST_PTR) \
(_dblListEmpty(LIST_PTR, sizeof(TYPE)))
#define wapp_dbl_list_alloc(ELEM_TYPE, LIST_TYPE, ALLOCATOR) \
(LIST_TYPE *)_dbl_list_alloc(ALLOCATOR, sizeof(ELEM_TYPE))
#define wapp_dbl_list_node_alloc(ELEM_TYPE, NODE_TYPE, ALLOCATOR) \
(NODE_TYPE *)_dbl_list_node_alloc(ALLOCATOR, sizeof(ELEM_TYPE))
#define wapp_dbl_list_get(ELEM_TYPE, NODE_TYPE, LIST_PTR, ELEM_INDEX) \
(NODE_TYPE *)_dbl_list_get((GenericList *)LIST_PTR, ELEM_INDEX, sizeof(ELEM_TYPE))
#define wapp_dbl_list_push_front(ELEM_TYPE, LIST_PTR, NODE_PTR) \
_dbl_list_push_front((GenericList *)LIST_PTR, (GenericNode *)NODE_PTR, sizeof(ELEM_TYPE))
#define wapp_dbl_list_push_back(ELEM_TYPE, LIST_PTR, NODE_PTR) \
_dbl_list_push_back((GenericList *)LIST_PTR, (GenericNode *)NODE_PTR, sizeof(ELEM_TYPE))
#define wapp_dbl_list_insert(ELEM_TYPE, LIST_PTR, NODE_PTR, ELEM_INDEX) \
_dbl_list_insert((GenericList *)LIST_PTR, (GenericNode *)NODE_PTR, ELEM_INDEX, sizeof(ELEM_TYPE))
#define wapp_dbl_list_pop_front(ELEM_TYPE, NODE_TYPE, LIST_PTR) \
(NODE_TYPE *)_dbl_list_pop_front((GenericList *)LIST_PTR, sizeof(ELEM_TYPE))
#define wapp_dbl_list_pop_back(ELEM_TYPE, NODE_TYPE, LIST_PTR) \
(NODE_TYPE *)_dbl_list_pop_back((GenericList *)LIST_PTR, sizeof(ELEM_TYPE))
#define wapp_dbl_list_remove(ELEM_TYPE, NODE_TYPE, LIST_PTR, ELEM_INDEX) \
(NODE_TYPE *)_dbl_list_remove((GenericList *)LIST_PTR, ELEM_INDEX, sizeof(ELEM_TYPE))
#define wapp_dbl_list_empty(ELEM_TYPE, LIST_PTR) \
_dbl_list_empty((GenericList *)LIST_PTR, sizeof(ELEM_TYPE))
WpDblList *_dblListAlloc(const WpAllocator *allocator, u64 item_size);
WpDblNode *_dblListNodeAlloc(const WpAllocator *allocator, void *item, u64 item_size);
WpDblNode *_dblListGet(const WpDblList *list, u64 index, u64 item_size);
void _dblListPushFront(WpDblList *list, WpDblNode *node, u64 item_size);
void _dblListPushBack(WpDblList *list, WpDblNode *node, u64 item_size);
void _dblListInsert(WpDblList *list, WpDblNode *node, u64 index, u64 item_size);
WpDblNode *_dblListPopFront(WpDblList *list, u64 item_size);
WpDblNode *_dblListPopBack(WpDblList *list, u64 item_size);
WpDblNode *_dblListRemove(WpDblList *list, u64 index, u64 item_size);
void _dblListEmpty(WpDblList *list, u64 item_size);
WAPP_DEF_DBL_LIST_TYPE(void, GenericNode, GenericList);
#ifdef WP_PLATFORM_CPP
GenericList *_dbl_list_alloc(const Allocator *allocator, u64 item_size);
GenericNode *_dbl_list_node_alloc(const Allocator *allocator, u64 item_size);
GenericNode *_dbl_list_get(const GenericList *list, u64 index, u64 item_size);
void _dbl_list_push_front(GenericList *list, GenericNode *node, u64 item_size);
void _dbl_list_push_back(GenericList *list, GenericNode *node, u64 item_size);
void _dbl_list_insert(GenericList *list, GenericNode *node, u64 index, u64 item_size);
GenericNode *_dbl_list_pop_front(GenericList *list, u64 item_size);
GenericNode *_dbl_list_pop_back(GenericList *list, u64 item_size);
GenericNode *_dbl_list_remove(GenericList *list, u64 index, u64 item_size);
void _dbl_list_empty(GenericList *list, u64 item_size);
// Base list types
typedef struct str8 Str8;
WAPP_DEF_DBL_LIST_TYPE(void * , VoidPtrNode , VoidPtrList);
WAPP_DEF_DBL_LIST_TYPE(c8 , C8Node , C8List);
WAPP_DEF_DBL_LIST_TYPE(c16 , C16Node , C16List);
WAPP_DEF_DBL_LIST_TYPE(c32 , C32Node , C32List);
WAPP_DEF_DBL_LIST_TYPE(u8 , U8Node , U8List);
WAPP_DEF_DBL_LIST_TYPE(u16 , U16Node , U16List);
WAPP_DEF_DBL_LIST_TYPE(u32 , U32Node , U32List);
WAPP_DEF_DBL_LIST_TYPE(u64 , U64Node , U64List);
WAPP_DEF_DBL_LIST_TYPE(b8 , B8Node , B8List);
WAPP_DEF_DBL_LIST_TYPE(i8 , I8Node , I8List);
WAPP_DEF_DBL_LIST_TYPE(i16 , I16Node , I16List);
WAPP_DEF_DBL_LIST_TYPE(i32 , I32Node , I32List);
WAPP_DEF_DBL_LIST_TYPE(i64 , I64Node , I64List);
WAPP_DEF_DBL_LIST_TYPE(f32 , F32Node , F32List);
WAPP_DEF_DBL_LIST_TYPE(f64 , F64Node , F64List);
WAPP_DEF_DBL_LIST_TYPE(f128 , F128Node , F128List);
WAPP_DEF_DBL_LIST_TYPE(uptr , UptrNode , UptrList);
WAPP_DEF_DBL_LIST_TYPE(iptr , IptrNode , IptrList);
WAPP_DEF_DBL_LIST_TYPE(Str8 , Str8Node , Str8List);
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#endif // !DBL_LIST_H
src/base/mem/allocator/mem_allocator.c
+9 -9
View File
@@ -5,28 +5,28 @@
#include "../../../common/assert/assert.h"
#include <stdlib.h>
void *wpMemAllocatorAlloc(const WpAllocator *allocator, u64 size) {
wpDebugAssert(allocator != NULL && (allocator->alloc) != NULL, "`allocator` and `allocator->alloc` should not be NULL");
void *wapp_mem_allocator_alloc(const Allocator *allocator, u64 size) {
wapp_debug_assert(allocator != NULL && (allocator->alloc) != NULL, "`allocator` and `allocator->alloc` should not be NULL");
return allocator->alloc(size, allocator->obj);
}
void *wpMemAllocatorAllocAligned(const WpAllocator *allocator, u64 size, u64 alignment) {
wpDebugAssert(allocator != NULL && (allocator->alloc_aligned) != NULL, "`allocator` and `allocator->alloc_aligned` should not be NULL");
void *wapp_mem_allocator_alloc_aligned(const Allocator *allocator, u64 size, u64 alignment) {
wapp_debug_assert(allocator != NULL && (allocator->alloc_aligned) != NULL, "`allocator` and `allocator->alloc_aligned` should not be NULL");
return allocator->alloc_aligned(size, alignment, allocator->obj);
}
void *wpMemAllocatorRealloc(const WpAllocator *allocator, void *ptr, u64 old_size, u64 new_size) {
wpDebugAssert(allocator != NULL && (allocator->realloc) != NULL, "`allocator` and `allocator->realloc` should not be NULL");
void *wapp_mem_allocator_realloc(const Allocator *allocator, void *ptr, u64 old_size, u64 new_size) {
wapp_debug_assert(allocator != NULL && (allocator->realloc) != NULL, "`allocator` and `allocator->realloc` should not be NULL");
return allocator->realloc(ptr, old_size, new_size, allocator->obj);
}
void *wpMemAllocatorReallocAligned(const WpAllocator *allocator, void *ptr, u64 old_size,
void *wapp_mem_allocator_realloc_aligned(const Allocator *allocator, void *ptr, u64 old_size,
u64 new_size, u64 alignment) {
wpDebugAssert(allocator != NULL && (allocator->realloc_aligned) != NULL, "`allocator` and `allocator->realloc_aligned` should not be NULL");
wapp_debug_assert(allocator != NULL && (allocator->realloc_aligned) != NULL, "`allocator` and `allocator->realloc_aligned` should not be NULL");
return allocator->realloc_aligned(ptr, old_size, new_size, alignment, allocator->obj);
}
void wpMemAllocatorFree(const WpAllocator *allocator, void **ptr, u64 size) {
void wapp_mem_allocator_free(const Allocator *allocator, void **ptr, u64 size) {
if (!allocator || !(allocator->free)) {
return;
}
src/base/mem/allocator/mem_allocator.h
+27 -27
View File
@@ -7,44 +7,44 @@
#include "../../../common/platform/platform.h"
#include <string.h>
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
typedef void *(WpMemAllocFunc)(u64 size, void *alloc_obj);
typedef void *(WpMemAllocAlignedFunc)(u64 size, u64 alignment, void *alloc_obj);
typedef void *(WpMemReallocFunc)(void *ptr, u64 old_size, u64 new_size, void *alloc_obj);
typedef void *(WpMemReallocAlignedFunc)(void *ptr, u64 old_size, u64 new_size, u64 alignment, void *alloc_obj);
typedef void (WpMemFreeFunc)(void **ptr, u64 size, void *alloc_obj);
typedef void *(MemAllocFunc)(u64 size, void *alloc_obj);
typedef void *(MemAllocAlignedFunc)(u64 size, u64 alignment, void *alloc_obj);
typedef void *(MemReallocFunc)(void *ptr, u64 old_size, u64 new_size, void *alloc_obj);
typedef void *(MemReallocAlignedFunc)(void *ptr, u64 old_size, u64 new_size, u64 alignment, void *alloc_obj);
typedef void (MemFreeFunc)(void **ptr, u64 size, void *alloc_obj);
typedef struct WpAllocator WpAllocator;
struct WpAllocator {
typedef struct allocator Allocator;
struct allocator {
void *obj;
WpMemAllocFunc *alloc;
WpMemAllocAlignedFunc *alloc_aligned;
WpMemReallocFunc *realloc;
WpMemReallocAlignedFunc *realloc_aligned;
WpMemFreeFunc *free;
MemAllocFunc *alloc;
MemAllocAlignedFunc *alloc_aligned;
MemReallocFunc *realloc;
MemReallocAlignedFunc *realloc_aligned;
MemFreeFunc *free;
};
#ifdef WP_PLATFORM_CPP
#define wpMemAllocatorInvalid(ALLOCATOR) ([&]() { \
WpAllocator alloc{}; \
return memcmp(ALLOCATOR, &alloc, sizeof(WpAllocator)) == 0; \
#ifdef WAPP_PLATFORM_CPP
#define wapp_mem_allocator_invalid(ALLOCATOR) ([&]() { \
Allocator alloc{}; \
return memcmp(ALLOCATOR, &alloc, sizeof(Allocator)) == 0; \
}())
#else
#define wpMemAllocatorInvalid(ALLOCATOR) (memcmp(ALLOCATOR, &((WpAllocator){0}), sizeof(WpAllocator)) == 0)
#endif // !WP_PLATFORM_CPP
#define wapp_mem_allocator_invalid(ALLOCATOR) (memcmp(ALLOCATOR, &((Allocator){0}), sizeof(Allocator)) == 0)
#endif // !WAPP_PLATFORM_CPP
void *wpMemAllocatorAlloc(const WpAllocator *allocator, u64 size);
void *wpMemAllocatorAllocAligned(const WpAllocator *allocator, u64 size, u64 alignment);
void *wpMemAllocatorRealloc(const WpAllocator *allocator, void *ptr, u64 old_size, u64 new_size);
void *wpMemAllocatorReallocAligned(const WpAllocator *allocator, void *ptr, u64 old_size,
void *wapp_mem_allocator_alloc(const Allocator *allocator, u64 size);
void *wapp_mem_allocator_alloc_aligned(const Allocator *allocator, u64 size, u64 alignment);
void *wapp_mem_allocator_realloc(const Allocator *allocator, void *ptr, u64 old_size, u64 new_size);
void *wapp_mem_allocator_realloc_aligned(const Allocator *allocator, void *ptr, u64 old_size,
u64 new_size, u64 alignment);
void wpMemAllocatorFree(const WpAllocator *allocator, void **ptr, u64 size);
void wapp_mem_allocator_free(const Allocator *allocator, void **ptr, u64 size);
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#endif // !MEM_ALLOCATOR_H
src/base/mem/utils/mem_utils.c
+5 -4
View File
@@ -3,12 +3,13 @@
#include "mem_utils.h"
#include "../../../common/aliases/aliases.h"
#include "../../../common/assert/assert.h"
#include "../../../common/misc/misc_utils.h"
#include <stddef.h>
void *wpMemUtilAlignForward(void *ptr, u64 alignment) {
wpDebugAssert(ptr != NULL, "`ptr` should not be NULL");
wpRuntimeAssert(wpMiscUtilsIsPowerOfTwo(alignment), "`alignment` value is not a power of two");
wapp_intern b8 is_power_of_two(u64 num) { return (num & (num - 1)) == 0; }
void *wapp_mem_util_align_forward(void *ptr, u64 alignment) {
wapp_debug_assert(ptr != NULL, "`ptr` should not be NULL");
wapp_runtime_assert(is_power_of_two(alignment), "`alignment` value is not a power of two");
uptr p = (uptr)ptr;
uptr align = (uptr)alignment;
src/base/mem/utils/mem_utils.h
+5 -5
View File
@@ -6,14 +6,14 @@
#include "../../../common/aliases/aliases.h"
#include "../../../common/platform/platform.h"
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
void *wpMemUtilAlignForward(void *ptr, u64 alignment);
void *wapp_mem_util_align_forward(void *ptr, u64 alignment);
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#endif // !MEM_UTILS_H
src/base/queue/queue.c
-108
View File
@@ -1,108 +0,0 @@
// vim:fileencoding=utf-8:foldmethod=marker
#include "queue.h"
#include "../array/array.h"
#include "../../common/assert/assert.h"
#include "../../common/misc/misc_utils.h"
#include <string.h>
void _queuePush(WpQueue *queue, void *item, u64 item_size) {
wpDebugAssert(queue != NULL, "`queue` should not be NULL");
wpRuntimeAssert(item_size == wpArrayItemSize(queue->items), "Invalid type");
u64 capacity = wpArrayCapacity(queue->items);
if (queue->count >= capacity) { return; }
u64 index = (queue->back)++;
_arraySet(queue->items, index, item, item_size);
++(queue->count);
if (queue->back >= capacity) {
queue->back = 0;
}
}
WpQueue *_queuePushAlloc(const WpAllocator *allocator, WpQueue *queue, void *item, u64 item_size) {
wpDebugAssert(allocator != NULL && queue != NULL && item != NULL,
"`allocator`, `queue` and `item` should not be NULL");
wpRuntimeAssert(item_size == wpArrayItemSize(queue->items), "Invalid type");
WpQueue *output = queue;
u64 capacity = wpArrayCapacity(queue->items);
// NOTE (Abdelrahman): Extracted into variable to fix MSVC error
b8 queue_full = queue->count >= capacity;
if (queue_full) {
u64 new_capacity = wpMiscUtilsU64RoundUpPow2(capacity * 2);
u64 array_size = _arrayCalcAllocSize(new_capacity, item_size);
u64 alloc_size = sizeof(WpQueue) + array_size;
void *buffer = wpMemAllocatorAlloc(allocator, alloc_size);
if (!buffer) {
goto RETURN_QUEUE_PUSH_ALLOC;
}
memset((void *)buffer, 0, alloc_size);
output = (WpQueue *)buffer;
output->items = _arrayFromPreallocatedBuffer((void *)(output + 1), array_size, WP_ARRAY_INIT_FILLED, item_size);
// NOTE (Abdelrahman): When the queue is full, the front and back indices should
// always be the same
u64 front_count = capacity - queue->front;
u64 back_count = queue->back;
void *copy_boundary = (void *)((uptr)(queue->items) + (queue->front * item_size));
memcpy(output->items, copy_boundary, front_count * item_size);
/**
* NOTE (Abdelrahman): Since this is a ring buffer, the elements at the beginning of the array
* aren't always the ones at the front of the queue. When that's the case, the memcpy above
* will only copy a subset of the elements. This is why we need to copy the remaining ones.
*
* Example: Take a queue that looks like this with a capacity of 5 elements
*
* 0 1 | 2 3 4
* ---------------|-----------------------
* | * | * | * | * | * |
* ---------------|-----------------------
* |
* queue_front = 2
* queue_back = 2
*
* In this case, the first memcpy will only copy elements 2-4. The memcpy below will be
* responsible for copying elements 0-1.
*/
b8 items_left_to_copy = back_count > 0;
if (items_left_to_copy) {
void *back_copy_dst = (void *)((uptr)(output->items) + (front_count * item_size));
memcpy(back_copy_dst, queue->items, back_count * item_size);
}
output->front = 0;
output->back = front_count + back_count;
output->count = queue->count;
}
_queuePush(output, item, item_size);
RETURN_QUEUE_PUSH_ALLOC:
return output;
}
void *_queuePop(WpQueue *queue, u64 item_size) {
wpDebugAssert(queue != NULL, "`queue` should not be NULL");
wpRuntimeAssert(item_size == wpArrayItemSize(queue->items), "Invalid type");
if (queue->count == 0) { return NULL; }
u64 index = (queue->front)++;
--(queue->count);
u64 capacity = wpArrayCapacity(queue->items);
if (queue->front >= capacity) {
queue->front = 0;
}
return _arrayGet(queue->items, index, item_size);
}
src/base/queue/queue.h
-100
View File
@@ -1,100 +0,0 @@
// vim:fileencoding=utf-8:foldmethod=marker
#ifndef QUEUE_H
#define QUEUE_H
#include "../array/array.h"
#include "../mem/allocator/mem_allocator.h"
#include "../../common/aliases/aliases.h"
#include "../../common/platform/platform.h"
#ifdef WP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
typedef struct {
WpArray items;
u64 front;
u64 back;
u64 count;
} WpQueue;
// NOTE (Abdelrahman): WpQueue typedefs for readability
typedef WpQueue WpVoidPtrQueue;
typedef WpQueue WpC8Queue;
typedef WpQueue WpC16Queue;
typedef WpQueue WpC32Queue;
typedef WpQueue WpU8Queue;
typedef WpQueue WpU16Queue;
typedef WpQueue WpU32Queue;
typedef WpQueue WpU64Queue;
typedef WpQueue WpB8Queue;
typedef WpQueue WpI8Queue;
typedef WpQueue WpI16Queue;
typedef WpQueue WpI32Queue;
typedef WpQueue WpI64Queue;
typedef WpQueue WpF32Queue;
typedef WpQueue WpF64Queue;
typedef WpQueue WpF128Queue;
typedef WpQueue WpUptrQueue;
typedef WpQueue WpIptrQueue;
typedef WpQueue WpStr8Queue;
#ifdef WP_PLATFORM_CPP
#define wpQueue(TYPE, CAPACITY) ([&]() { \
wp_persist WpArray arr = wpArrayWithCapacity(TYPE, CAPACITY, WP_ARRAY_INIT_FILLED); \
wp_persist WpQueue queue = { \
arr, \
0, \
0, \
0, \
}; \
\
return queue; \
}())
#define wpQueueAlloc(TYPE, ALLOCATOR_PTR, CAPACITY) ([&]() { \
wp_persist WpQueue queue = { \
wpArrayAllocCapacity(TYPE, ALLOCATOR_PTR, CAPACITY, WP_ARRAY_INIT_FILLED), \
0, \
0, \
0, \
}; \
\
return queue; \
}())
#else
#define wpQueue(TYPE, CAPACITY) ((WpQueue){ \
.items = wpArrayWithCapacity(TYPE, CAPACITY, WP_ARRAY_INIT_FILLED), \
.front = 0, \
.back = 0, \
.count = 0, \
})
#define wpQueueAlloc(TYPE, ALLOCATOR_PTR, CAPACITY) ((WpQueue){ \
.items = wpArrayAllocCapacity(TYPE, ALLOCATOR_PTR, CAPACITY, WP_ARRAY_INIT_FILLED), \
.front = 0, \
.back = 0, \
.count = 0, \
})
#endif // !WP_PLATFORM_CPP
#define wpQueueCapacity(QUEUE_PTR) (wpArrayCapacity((QUEUE_PTR)->items))
#define wpQueueItemSize(QUEUE_PTR) (wpArrayItemSize((QUEUE_PTR)->items))
#define wpQueuePush(TYPE, QUEUE_PTR, VALUE_PTR) ( \
_queuePush(QUEUE_PTR, VALUE_PTR, sizeof(TYPE)) \
)
#define wpQueuePushAlloc(TYPE, ALLOCATOR_PTR, QUEUE_PTR, VALUE_PTR) ( \
_queuePushAlloc(ALLOCATOR_PTR, QUEUE_PTR, VALUE_PTR, sizeof(TYPE)) \
)
#define wpQueuePop(TYPE, QUEUE_PTR) ( \
(TYPE *)_queuePop(QUEUE_PTR, sizeof(TYPE)) \
)
void _queuePush(WpQueue *queue, void *item, u64 item_size);
WpQueue *_queuePushAlloc(const WpAllocator *allocator, WpQueue *queue, void *item, u64 item_size);
void *_queuePop(WpQueue *queue, u64 item_size);
#ifdef WP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !QUEUE_H
src/base/strings/str8/str8.c
+118 -106
View File
@@ -11,17 +11,17 @@
#include <stdio.h>
#include <string.h>
#define STR8_BUF_ALLOC_SIZE(CAPACITY) (sizeof(WpStr8) + sizeof(c8) * CAPACITY)
#define STR8_BUF_ALLOC_SIZE(CAPACITY) (sizeof(Str8) + sizeof(c8) * CAPACITY)
WpStr8 *wpStr8AllocBuf(const WpAllocator *allocator, u64 capacity) {
wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
Str8 *wapp_str8_alloc_buf(const Allocator *allocator, u64 capacity) {
wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL");
WpStr8 *str = wpMemAllocatorAlloc(allocator, STR8_BUF_ALLOC_SIZE(capacity));
Str8 *str = wapp_mem_allocator_alloc(allocator, STR8_BUF_ALLOC_SIZE(capacity));
if (!str) {
goto RETURN_STR8;
}
str->buf = (u8 *)str + sizeof(WpStr8);
str->buf = (u8 *)str + sizeof(Str8);
str->size = 0;
str->capacity = capacity;
@@ -29,8 +29,8 @@ RETURN_STR8:
return str;
}
WpStr8 *wpStr8AllocAndFillBuf(const WpAllocator *allocator, u64 capacity) {
WpStr8 *out = wpStr8AllocBuf(allocator, capacity);
Str8 *wapp_str8_alloc_and_fill_buf(const Allocator *allocator, u64 capacity) {
Str8 *out = wapp_str8_alloc_buf(allocator, capacity);
if (out) {
memset(out->buf, 0, capacity);
out->size = capacity;
@@ -38,11 +38,11 @@ WpStr8 *wpStr8AllocAndFillBuf(const WpAllocator *allocator, u64 capacity) {
return out;
}
WpStr8 *wpStr8AllocCstr(const WpAllocator *allocator, const char *str) {
wpDebugAssert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
Str8 *wapp_str8_alloc_cstr(const Allocator *allocator, const char *str) {
wapp_debug_assert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
u64 length = strlen(str);
WpStr8 *output = wpStr8AllocBuf(allocator, length * 2);
Str8 *output = wapp_str8_alloc_buf(allocator, length * 2);
if (!output) {
goto RETURN_ALLOC_CSTR;
}
@@ -54,10 +54,10 @@ RETURN_ALLOC_CSTR:
return output;
}
WpStr8 *wpStr8AllocStr8(const WpAllocator *allocator, WpStr8RO *str) {
wpDebugAssert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
Str8 *wapp_str8_alloc_str8(const Allocator *allocator, Str8RO *str) {
wapp_debug_assert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
WpStr8 *output = wpStr8AllocBuf(allocator, str->capacity);
Str8 *output = wapp_str8_alloc_buf(allocator, str->capacity);
if (!output) {
goto RETURN_ALLOC_STR8;
}
@@ -69,10 +69,10 @@ RETURN_ALLOC_STR8:
return output;
}
WpStr8 *wpStr8AllocSubstr(const WpAllocator *allocator, WpStr8RO *str, u64 start, u64 end) {
wpDebugAssert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
Str8 *wapp_str8_alloc_substr(const Allocator *allocator, Str8RO *str, u64 start, u64 end) {
wapp_debug_assert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
WpStr8 *output = NULL;
Str8 *output = NULL;
if (start >= str->size || start >= end) {
goto RETURN_ALLOC_SUBSTR;
@@ -82,7 +82,7 @@ WpStr8 *wpStr8AllocSubstr(const WpAllocator *allocator, WpStr8RO *str, u64 start
end = str->size;
}
output = wpStr8AllocBuf(allocator, str->capacity);
output = wapp_str8_alloc_buf(allocator, str->capacity);
if (!output) {
goto RETURN_ALLOC_SUBSTR;
}
@@ -94,12 +94,12 @@ RETURN_ALLOC_SUBSTR:
return output;
}
void wpStr8DeallocBuf(const WpAllocator *allocator, WpStr8 **str) {
wpDebugAssert(allocator != NULL && str != NULL && (*str) != NULL, "Either `allocator` is NULL or `str` is an invalid double pointer");
wpMemAllocatorFree(allocator, (void **)str, STR8_BUF_ALLOC_SIZE((*str)->capacity));
void wapp_str8_dealloc_buf(const Allocator *allocator, Str8 **str) {
wapp_debug_assert(allocator != NULL && str != NULL && (*str) != NULL, "Either `allocator` is NULL or `str` is an invalid double pointer");
wapp_mem_allocator_free(allocator, (void **)str, STR8_BUF_ALLOC_SIZE((*str)->capacity));
}
c8 wpStr8Get(const WpStr8 *str, u64 index) {
c8 wapp_str8_get(const Str8 *str, u64 index) {
if (index >= str->size) {
return '\0';
}
@@ -107,7 +107,7 @@ c8 wpStr8Get(const WpStr8 *str, u64 index) {
return str->buf[index];
}
void wpStr8Set(WpStr8 *str, u64 index, c8 c) {
void wapp_str8_set(Str8 *str, u64 index, c8 c) {
if (index >= str->size) {
return;
}
@@ -115,24 +115,24 @@ void wpStr8Set(WpStr8 *str, u64 index, c8 c) {
str->buf[index] = c;
}
void wpStr8PushBack(WpStr8 *str, c8 c) {
void wapp_str8_push_back(Str8 *str, c8 c) {
if (!(str->size < str->capacity)) {
return;
}
u64 index = (str->size)++;
wpStr8Set(str, index, c);
wapp_str8_set(str, index, c);
}
b8 wpStr8Equal(WpStr8RO *s1, WpStr8RO *s2) {
b8 wapp_str8_equal(Str8RO *s1, Str8RO *s2) {
if (s1->size != s2->size) {
return false;
}
return wpStr8EqualToCount(s1, s2, s1->size);
return wapp_str8_equal_to_count(s1, s2, s1->size);
}
b8 wpStr8EqualToCount(WpStr8RO* s1, WpStr8RO* s2, u64 count) {
b8 wapp_str8_equal_to_count(Str8RO* s1, Str8RO* s2, u64 count) {
if (!s1 || !s2) {
return false;
}
@@ -140,7 +140,7 @@ b8 wpStr8EqualToCount(WpStr8RO* s1, WpStr8RO* s2, u64 count) {
return memcmp(s1->buf, s2->buf, count) == 0;
}
WpStr8 wpStr8Slice(WpStr8RO *str, u64 start, u64 end) {
Str8 wapp_str8_slice(Str8RO *str, u64 start, u64 end) {
if (start >= str->size || start >= end) {
start = str->size;
end = str->size;
@@ -150,17 +150,17 @@ WpStr8 wpStr8Slice(WpStr8RO *str, u64 start, u64 end) {
end = str->size;
}
return (WpStr8RO){
return (Str8RO){
.capacity = end - start,
.size = end - start,
.buf = str->buf + start,
};
}
WpStr8 *wpStr8AllocConcat(const WpAllocator *allocator, WpStr8 *dst, WpStr8RO *src) {
wpDebugAssert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL");
Str8 *wapp_str8_alloc_concat(const Allocator *allocator, Str8 *dst, Str8RO *src) {
wapp_debug_assert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL");
WpStr8 *output = NULL;
Str8 *output = NULL;
u64 remaining = dst->capacity - dst->size;
if (src->size <= remaining) {
output = dst;
@@ -169,22 +169,22 @@ WpStr8 *wpStr8AllocConcat(const WpAllocator *allocator, WpStr8 *dst, WpStr8RO *s
u64 capacity = dst->capacity + src->size;
output = wpStr8AllocBuf(allocator, capacity);
output = wapp_str8_alloc_buf(allocator, capacity);
if (!output) {
goto RETURN_STR8_CONCAT;
}
wpStr8ConcatCapped(output, dst);
wapp_str8_concat_capped(output, dst);
SOURCE_STRING_STR8_CONCAT:
wpStr8ConcatCapped(output, src);
wapp_str8_concat_capped(output, src);
RETURN_STR8_CONCAT:
return output;
}
void wpStr8ConcatCapped(WpStr8 *dst, WpStr8RO *src) {
wpDebugAssert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
void wapp_str8_concat_capped(Str8 *dst, Str8RO *src) {
wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
u64 remaining = dst->capacity - dst->size;
u64 to_copy = remaining < src->size ? remaining : src->size;
@@ -193,8 +193,8 @@ void wpStr8ConcatCapped(WpStr8 *dst, WpStr8RO *src) {
dst->size += to_copy;
}
void wpStr8CopyCstrCapped(WpStr8 *dst, const char *src) {
wpDebugAssert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
void wapp_str8_copy_cstr_capped(Str8 *dst, const char *src) {
wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
u64 length = strlen(src);
u64 to_copy = length <= dst->capacity ? length : dst->capacity;
@@ -204,8 +204,8 @@ void wpStr8CopyCstrCapped(WpStr8 *dst, const char *src) {
dst->size = to_copy;
}
void wpStr8CopyStr8Capped(WpStr8 *dst, WpStr8RO *src) {
wpDebugAssert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
void wapp_str8_copy_str8_capped(Str8 *dst, Str8RO *src) {
wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
u64 to_copy = src->size <= dst->capacity ? src->size : dst->capacity;
@@ -214,8 +214,8 @@ void wpStr8CopyStr8Capped(WpStr8 *dst, WpStr8RO *src) {
dst->size = to_copy;
}
void wpStr8CopyToCstr(char *dst, WpStr8RO *src, u64 dst_capacity) {
wpDebugAssert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
void wapp_str8_copy_to_cstr(char *dst, Str8RO *src, u64 dst_capacity) {
wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
u64 to_copy = src->size < dst_capacity ? src->size : dst_capacity - 1;
@@ -223,8 +223,8 @@ void wpStr8CopyToCstr(char *dst, WpStr8RO *src, u64 dst_capacity) {
memcpy(dst, src->buf, to_copy);
}
void wpStr8Format(WpStr8 *dst, const char *format, ...) {
wpDebugAssert(dst != NULL && format != NULL, "`dst` and `format` should not be NULL");
void wapp_str8_format(Str8 *dst, const char *format, ...) {
wapp_debug_assert(dst != NULL && format != NULL, "`dst` and `format` should not be NULL");
va_list args1;
va_list args2;
@@ -241,9 +241,9 @@ void wpStr8Format(WpStr8 *dst, const char *format, ...) {
va_end(args2);
}
void wpStr8ToLower(WpStr8 *dst, WpStr8RO *src) {
wpDebugAssert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL");
wpDebugAssert(dst->capacity >= src->capacity, "`dst` does not have enough capacity");
void wapp_str8_to_lower(Str8 *dst, Str8RO *src) {
wapp_debug_assert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL");
wapp_debug_assert(dst->capacity >= src->capacity, "`dst` does not have enough capacity");
dst->size = src->size;
@@ -252,15 +252,15 @@ void wpStr8ToLower(WpStr8 *dst, WpStr8RO *src) {
u64 index = 0;
b8 running = true;
while (running) {
wpStr8Set(dst, index, (u8)tolower(wpStr8Get(src, index)));
wapp_str8_set(dst, index, (u8)tolower(wapp_str8_get(src, index)));
++index;
running = index < src->size;
}
}
void wpStr8ToUpper(WpStr8 *dst, WpStr8RO *src) {
wpDebugAssert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL");
wpDebugAssert(dst->capacity >= src->capacity, "`dst` does not have enough capacity");
void wapp_str8_to_upper(Str8 *dst, Str8RO *src) {
wapp_debug_assert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL");
wapp_debug_assert(dst->capacity >= src->capacity, "`dst` does not have enough capacity");
dst->size = src->size;
@@ -269,24 +269,24 @@ void wpStr8ToUpper(WpStr8 *dst, WpStr8RO *src) {
u64 index = 0;
b8 running = true;
while (running) {
wpStr8Set(dst, index, (u8)toupper(wpStr8Get(src, index)));
wapp_str8_set(dst, index, (u8)toupper(wapp_str8_get(src, index)));
++index;
running = index < src->size;
}
}
void wpStr8FromBytes(WpStr8 *dst, const WpU8Array src) {
wpDebugAssert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL");
void wapp_str8_from_bytes(Str8 *dst, const U8Array *src) {
wapp_debug_assert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL");
u64 size = wpArrayCount(src) * wpArrayItemSize(src);
u64 size = src->count * src->item_size;
wpDebugAssert(dst->capacity >= size, "`dst` does not have enough capacity");
wapp_debug_assert(dst->capacity >= size, "`dst` does not have enough capacity");
dst->size = size;
memcpy(dst->buf, src, size);
memcpy(dst->buf, src->items, size);
}
i64 wpStr8Find(WpStr8RO *str, WpStr8RO substr) {
i64 wapp_str8_find(Str8RO *str, Str8RO substr) {
if (!str || substr.size > str->size) {
return -1;
}
@@ -308,7 +308,7 @@ i64 wpStr8Find(WpStr8RO *str, WpStr8RO substr) {
return -1;
}
i64 wpStr8Rfind(WpStr8RO *str, WpStr8RO substr) {
i64 wapp_str8_rfind(Str8RO *str, Str8RO substr) {
if (!str || substr.size > str->size) {
return -1;
}
@@ -330,15 +330,17 @@ i64 wpStr8Rfind(WpStr8RO *str, WpStr8RO substr) {
return -1;
}
WpStr8List *wpStr8SplitWithMax(const WpAllocator *allocator, WpStr8RO *str, WpStr8RO *delimiter, i64 max_splits) {
wpDebugAssert(allocator != NULL && str != NULL && delimiter != NULL, "`allocator`, `str` and `delimiter` should not be NULL");
Str8List *wapp_str8_split_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits) {
wapp_debug_assert(allocator != NULL && str != NULL && delimiter != NULL, "`allocator`, `str` and `delimiter` should not be NULL");
WpStr8List *output = wpDblListAlloc(WpStr8, allocator);
Str8List *output = wapp_dbl_list_alloc(Str8, Str8List, allocator);
if (delimiter->size > str->size) {
WpStr8 *full = wpStr8AllocStr8(allocator, str);
if (full) {
wpDblListPushBackAlloc(WpStr8, allocator, output, full);
Str8 *full = wapp_str8_alloc_str8(allocator, str);
Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator);
if (node) {
node->item = full;
wapp_dbl_list_push_back(Str8, output, node);
}
goto RETURN_STR8_SPLIT;
@@ -347,45 +349,51 @@ WpStr8List *wpStr8SplitWithMax(const WpAllocator *allocator, WpStr8RO *str, WpSt
i64 start = 0;
i64 end = 0;
i64 splits = 0;
WpStr8 *rest = wpStr8AllocStr8(allocator, str);
WpStr8 *before_str;
Str8 *rest = wapp_str8_alloc_str8(allocator, str);
Str8 *before_str;
while ((end = wpStr8Find(rest, *delimiter)) != -1) {
while ((end = wapp_str8_find(rest, *delimiter)) != -1) {
if (max_splits > 0 && splits >= max_splits) {
break;
}
before_str = wpStr8AllocSubstr(allocator, str, start, start + end);
if (before_str) {
wpDblListPushBackAlloc(WpStr8, allocator, output, before_str);
before_str = wapp_str8_alloc_substr(allocator, str, start, start + end);
Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator);
if (node && before_str) {
node->item = before_str;
wapp_dbl_list_push_back(Str8, output, node);
}
wpMemAllocatorFree(allocator, (void **)&rest, sizeof(WpStr8));
rest = wpStr8AllocSubstr(allocator, str, start + end + delimiter->size, str->size);
wapp_mem_allocator_free(allocator, (void **)&rest, sizeof(Str8));
rest = wapp_str8_alloc_substr(allocator, str, start + end + delimiter->size, str->size);
start += end + delimiter->size;
++splits;
}
// Ensure the last part of the string after the delimiter is added to the list
rest = wpStr8AllocSubstr(allocator, str, start, str->size);
if (rest) {
wpDblListPushBackAlloc(WpStr8, allocator, output, rest);
rest = wapp_str8_alloc_substr(allocator, str, start, str->size);
Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator);
if (node && rest) {
node->item = rest;
wapp_dbl_list_push_back(Str8, output, node);
}
RETURN_STR8_SPLIT:
return output;
}
WpStr8List *wpStr8RsplitWithMax(const WpAllocator *allocator, WpStr8RO *str, WpStr8RO *delimiter, i64 max_splits) {
wpDebugAssert(allocator != NULL && str != NULL && delimiter != NULL, "`allocator`, `str` and `delimiter` should not be NULL");
Str8List *wapp_str8_rsplit_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits) {
wapp_debug_assert(allocator != NULL && str != NULL && delimiter != NULL, "`allocator`, `str` and `delimiter` should not be NULL");
WpStr8List *output = wpDblListAlloc(WpStr8, allocator);
Str8List *output = wapp_dbl_list_alloc(Str8, Str8List, allocator);
if (delimiter->size > str->size) {
WpStr8 *full = wpStr8AllocStr8(allocator, str);
if (full) {
wpDblListPushBackAlloc(WpStr8, allocator, output, full);
Str8 *full = wapp_str8_alloc_str8(allocator, str);
Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator);
if (node && full) {
node->item = full;
wapp_dbl_list_push_back(Str8, output, node);
}
goto RETURN_STR8_SPLIT;
@@ -393,58 +401,62 @@ WpStr8List *wpStr8RsplitWithMax(const WpAllocator *allocator, WpStr8RO *str, WpS
i64 end = 0;
i64 splits = 0;
WpStr8 *rest = wpStr8AllocStr8(allocator, str);
WpStr8 *after_str;
Str8 *rest = wapp_str8_alloc_str8(allocator, str);
Str8 *after_str;
while ((end = wpStr8Rfind(rest, *delimiter)) != -1) {
while ((end = wapp_str8_rfind(rest, *delimiter)) != -1) {
if (max_splits > 0 && splits >= max_splits) {
break;
}
after_str = wpStr8AllocSubstr(allocator, rest, end + delimiter->size, str->size);
if (after_str) {
wpDblListPushFrontAlloc(WpStr8, allocator, output, after_str);
after_str = wapp_str8_alloc_substr(allocator, rest, end + delimiter->size, str->size);
Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator);
if (node) {
node->item = after_str;
wapp_dbl_list_push_front(Str8, output, node);
}
wpMemAllocatorFree(allocator, (void **)&rest, sizeof(WpStr8));
rest = wpStr8AllocSubstr(allocator, rest, 0, end);
wapp_mem_allocator_free(allocator, (void **)&rest, sizeof(Str8));
rest = wapp_str8_alloc_substr(allocator, rest, 0, end);
++splits;
}
rest = wpStr8AllocSubstr(allocator, str, 0, rest->size);
if (rest) {
wpDblListPushFrontAlloc(WpStr8, allocator, output, rest);
rest = wapp_str8_alloc_substr(allocator, str, 0, rest->size);
Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator);
if (node && rest) {
node->item = rest;
wapp_dbl_list_push_front(Str8, output, node);
}
RETURN_STR8_SPLIT:
return output;
}
WpStr8 *wpStr8Join(const WpAllocator *allocator, const WpStr8List *list, WpStr8RO *delimiter) {
wpDebugAssert(allocator != NULL && list != NULL && delimiter != NULL, "`allocator`, `list` and `delimiter` should not be NULL");
Str8 *wapp_str8_join(const Allocator *allocator, const Str8List *list, Str8RO *delimiter) {
wapp_debug_assert(allocator != NULL && list != NULL && delimiter != NULL, "`allocator`, `list` and `delimiter` should not be NULL");
u64 capacity = wpStr8ListTotalSize(list) + (delimiter->size * (list->node_count - 1));
WpStr8 *output = wpStr8AllocBuf(allocator, capacity * 2);
u64 capacity = wapp_str8_list_total_size(list) + (delimiter->size * (list->node_count - 1));
Str8 *output = wapp_str8_alloc_buf(allocator, capacity * 2);
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
WpStr8 *node;
Str8Node *node;
u64 node_index = 0;
b8 running = node_index < list->node_count;
while (running) {
node = wpDblListGet(WpStr8, list, node_index);
node = wapp_dbl_list_get(Str8, Str8Node, list, node_index);
if (!node) {
break;
}
wpStr8ConcatCapped(output, node);
wapp_str8_concat_capped(output, node->item);
// NOTE (Abdelrahman): Comparison extracted to variable to silence
// MSVC Spectre mitigation warnings
b8 not_last = node_index + 1 < list->node_count;
if (not_last) {
wpStr8ConcatCapped(output, delimiter);
wapp_str8_concat_capped(output, delimiter);
}
++node_index;
@@ -454,24 +466,24 @@ WpStr8 *wpStr8Join(const WpAllocator *allocator, const WpStr8List *list, WpStr8R
return output;
}
u64 wpStr8ListTotalSize(const WpStr8List *list) {
u64 wapp_str8_list_total_size(const Str8List *list) {
if (!list) {
return 0;
}
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
WpStr8 *node;
Str8Node* node;
u64 node_index = 0;
u64 output = 0;
b8 running = node_index < list->node_count;
while (running) {
node = wpDblListGet(WpStr8, list, node_index);
node = wapp_dbl_list_get(Str8, Str8Node, list, node_index);
if (!node) {
break;
}
output += node->size;
output += node->item->size;
++node_index;
running = node_index < list->node_count;
}
src/base/strings/str8/str8.h
+82 -63
View File
@@ -11,120 +11,139 @@
#include "../../mem/allocator/mem_allocator.h"
#include <string.h>
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
typedef struct WpStr8 WpStr8;
struct WpStr8 {
typedef struct str8 Str8;
struct str8 {
u64 capacity;
u64 size;
c8 *buf;
};
typedef const WpStr8 WpStr8RO;
typedef const Str8 Str8RO;
/**
* Utilities to be used with printf functions
*/
#define WP_STR8_SPEC "%.*s"
#define wpStr8Varg(STRING) (int)((STRING).size), (STRING).buf
#define WAPP_STR8_SPEC "%.*s"
#define wapp_str8_varg(STRING) (int)((STRING).size), (STRING).buf
/**
* WpStr8 stack buffers
* Str8 stack buffers
*/
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
// Uses a lambda to achieve the same behaviour achieved by the C macro
#define wpStr8Buf(CAPACITY) ([&](){ \
wp_persist c8 buf[CAPACITY] = {}; \
#define wapp_str8_buf(CAPACITY) ([&](){ \
wapp_persist c8 buf[CAPACITY] = {}; \
memset(buf, 0, CAPACITY); \
return WpStr8{CAPACITY, 0, buf}; \
return Str8{CAPACITY, 0, buf}; \
}())
// Uses a lambda to achieve the same behaviour achieved by the C macro
#define wpStr8Lit(STRING) ([&]() { \
wp_persist c8 buf[sizeof(STRING) * 2] = {}; \
#define wapp_str8_lit(STRING) ([&]() { \
wapp_persist c8 buf[sizeof(STRING) * 2] = {}; \
memcpy(buf, STRING, sizeof(STRING)); \
return WpStr8{(sizeof(STRING) - 1) * 2, sizeof(STRING) - 1, buf}; \
return Str8{(sizeof(STRING) - 1) * 2, sizeof(STRING) - 1, buf}; \
}())
#define wpStr8LitRo(STRING) WpStr8RO{sizeof(STRING) - 1, sizeof(STRING) - 1, (c8 *)STRING}
#define wpStr8LitRoInitialiserList(STRING) {sizeof(STRING) - 1, sizeof(STRING) - 1, (c8 *)STRING}
#define wapp_str8_lit_ro(STRING) Str8RO{sizeof(STRING) - 1, sizeof(STRING) - 1, (c8 *)STRING}
#define wapp_str8_lit_ro_initialiser_list(STRING) {sizeof(STRING) - 1, sizeof(STRING) - 1, (c8 *)STRING}
#else
#define wpStr8Buf(CAPACITY) ((WpStr8){.capacity = CAPACITY, .size = 0, .buf = (c8[CAPACITY]){0}})
#define wapp_str8_buf(CAPACITY) ((Str8){.capacity = CAPACITY, .size = 0, .buf = (c8[CAPACITY]){0}})
// Utilises the fact that memcpy returns pointer to dest buffer and that getting
// address of compound literals is valid in C to create a string on the stack
#define wpStr8Lit(STRING) ((WpStr8){.capacity = (sizeof(STRING) - 1) * 2, \
#define wapp_str8_lit(STRING) ((Str8){.capacity = (sizeof(STRING) - 1) * 2, \
.size = sizeof(STRING) - 1, \
.buf = memcpy(&((c8 [sizeof(STRING) * 2]){0}), \
STRING, \
sizeof(STRING))})
#define wpStr8LitRo(STRING) ((WpStr8RO){.capacity = sizeof(STRING) - 1, \
.buf = memcpy(&((c8 [sizeof(STRING) * 2]){0}), STRING, sizeof(STRING))})
#define wapp_str8_lit_ro(STRING) ((Str8RO){.capacity = sizeof(STRING) - 1, \
.size = sizeof(STRING) - 1, \
.buf = (c8 *)STRING})
// To be used only when initialising a static storage variable in compilers that don't support
// initialisers with the syntax of wpStr8LitRo (e.g. gcc). Should only be used when necessary
// and only be assigned to a WpStr8RO variable to avoid any attempt at modifying the string
#define wpStr8LitRoInitialiserList(STRING) {.capacity = sizeof(STRING) - 1, \
// initialisers with the syntax of wapp_str8_lit_ro (e.g. gcc). Should only be used when necessary
// and only be assigned to a Str8RO variable to avoid any attempt at modifying the string
#define wapp_str8_lit_ro_initialiser_list(STRING) {.capacity = sizeof(STRING) - 1, \
.size = sizeof(STRING) - 1, \
.buf = (c8 *)STRING}
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
/**
* WpStr8 allocated buffers
* Str8 allocated buffers
*/
WpStr8 *wpStr8AllocBuf(const WpAllocator *allocator, u64 capacity);
WpStr8 *wpStr8AllocAndFillBuf(const WpAllocator *allocator, u64 capacity);
WpStr8 *wpStr8AllocCstr(const WpAllocator *allocator, const char *str);
WpStr8 *wpStr8AllocStr8(const WpAllocator *allocator, WpStr8RO *str);
WpStr8 *wpStr8AllocSubstr(const WpAllocator *allocator, WpStr8RO *str, u64 start, u64 end);
WpStr8 *wpStr8AllocConcat(const WpAllocator *allocator, WpStr8 *dst, WpStr8RO *src);
Str8 *wapp_str8_alloc_buf(const Allocator *allocator, u64 capacity);
Str8 *wapp_str8_alloc_and_fill_buf(const Allocator *allocator, u64 capacity);
Str8 *wapp_str8_alloc_cstr(const Allocator *allocator, const char *str);
Str8 *wapp_str8_alloc_str8(const Allocator *allocator, Str8RO *str);
Str8 *wapp_str8_alloc_substr(const Allocator *allocator, Str8RO *str, u64 start, u64 end);
Str8 *wapp_str8_alloc_concat(const Allocator *allocator, Str8 *dst, Str8RO *src);
// Only needed for allocators like malloc where each allocation has to be freed on its own.
// No need to use it for allocators like Arena.
void wpStr8DeallocBuf(const WpAllocator *allocator, WpStr8 **str);
void wapp_str8_dealloc_buf(const Allocator *allocator, Str8 **str);
/**
* WpStr8 utilities
* Str8 utilities
*/
c8 wpStr8Get(WpStr8RO *str, u64 index);
void wpStr8Set(WpStr8 *str, u64 index, c8 c);
void wpStr8PushBack(WpStr8 *str, c8 c);
b8 wpStr8Equal(WpStr8RO *s1, WpStr8RO *s2);
b8 wpStr8EqualToCount(WpStr8RO* s1, WpStr8RO* s2, u64 count);
WpStr8 wpStr8Slice(WpStr8RO *str, u64 start, u64 end);
void wpStr8ConcatCapped(WpStr8 *dst, WpStr8RO *src);
void wpStr8CopyCstrCapped(WpStr8 *dst, const char *src);
void wpStr8CopyStr8Capped(WpStr8 *dst, WpStr8RO *src);
void wpStr8CopyToCstr(char *dst, WpStr8RO *src, u64 dst_capacity);
void wpStr8Format(WpStr8 *dst, const char *format, ...);
void wpStr8ToLower(WpStr8 *dst, WpStr8RO *src);
void wpStr8ToUpper(WpStr8 *dst, WpStr8RO *src);
void wpStr8FromBytes(WpStr8 *dst, const WpU8Array src);
c8 wapp_str8_get(Str8RO *str, u64 index);
void wapp_str8_set(Str8 *str, u64 index, c8 c);
void wapp_str8_push_back(Str8 *str, c8 c);
b8 wapp_str8_equal(Str8RO *s1, Str8RO *s2);
b8 wapp_str8_equal_to_count(Str8RO* s1, Str8RO* s2, u64 count);
Str8 wapp_str8_slice(Str8RO *str, u64 start, u64 end);
void wapp_str8_concat_capped(Str8 *dst, Str8RO *src);
void wapp_str8_copy_cstr_capped(Str8 *dst, const char *src);
void wapp_str8_copy_str8_capped(Str8 *dst, Str8RO *src);
void wapp_str8_copy_to_cstr(char *dst, Str8RO *src, u64 dst_capacity);
void wapp_str8_format(Str8 *dst, const char *format, ...);
void wapp_str8_to_lower(Str8 *dst, Str8RO *src);
void wapp_str8_to_upper(Str8 *dst, Str8RO *src);
void wapp_str8_from_bytes(Str8 *dst, const U8Array *src);
/**
* WpStr8 find functions
* Str8 find functions
*/
i64 wpStr8Find(WpStr8RO *str, WpStr8RO substr);
i64 wpStr8Rfind(WpStr8RO *str, WpStr8RO substr);
i64 wapp_str8_find(Str8RO *str, Str8RO substr);
i64 wapp_str8_rfind(Str8RO *str, Str8RO substr);
/**
* WpStr8 split and join
* Str8 split and join
*/
#define wpStr8Split(ALLOCATOR, STR, DELIMITER) wpStr8SplitWithMax(ALLOCATOR, STR, DELIMITER, -1)
#define wpStr8Rsplit(ALLOCATOR, STR, DELIMITER) wpStr8RsplitWithMax(ALLOCATOR, STR, DELIMITER, -1)
WpStr8List *wpStr8SplitWithMax(const WpAllocator *allocator, WpStr8RO *str, WpStr8RO *delimiter, i64 max_splits);
WpStr8List *wpStr8RsplitWithMax(const WpAllocator *allocator, WpStr8RO *str, WpStr8RO *delimiter, i64 max_splits);
WpStr8 *wpStr8Join(const WpAllocator *allocator, const WpStr8List *list, WpStr8RO *delimiter);
#define wapp_str8_split(ALLOCATOR, STR, DELIMITER) wapp_str8_split_with_max(ALLOCATOR, STR, DELIMITER, -1)
#define wapp_str8_rsplit(ALLOCATOR, STR, DELIMITER) wapp_str8_rsplit_with_max(ALLOCATOR, STR, DELIMITER, -1)
Str8List *wapp_str8_split_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits);
Str8List *wapp_str8_rsplit_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits);
Str8 *wapp_str8_join(const Allocator *allocator, const Str8List *list, Str8RO *delimiter);
/**
* WpStr8 list utilities
* Str8 list utilities
*/
u64 wpStr8ListTotalSize(const WpStr8List *list);
u64 wapp_str8_list_total_size(const Str8List *list);
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#include <type_traits>
template <typename T>
constexpr bool is_lvalue(T&&) {
return std::is_lvalue_reference<T>{};
}
#define wapp_str8_node_from_cstr(STRING) wapp_dbl_list_node(Str8, Str8Node, [&]() { \
wapp_persist Str8 str = wapp_str8_lit(STRING); \
return &str; \
}())
#define wapp_str8_node_from_str8(STRING) wapp_dbl_list_node(Str8, Str8Node, [&]() { \
if (is_lvalue(STRING)) { return &STRING; } \
\
wapp_persist Str8 str = STRING; \
return &str; \
}())
#else
#define wapp_str8_node_from_cstr(STRING) wapp_dbl_list_node(Str8, Str8Node, &wapp_str8_lit(STRING))
#define wapp_str8_node_from_str8(STRING) wapp_dbl_list_node(Str8, Str8Node, &(STRING))
#endif // !WAPP_PLATFORM_CPP
#endif // !STR8_H
src/base/wapp_base.c
-1
View File
@@ -6,7 +6,6 @@
#include "wapp_base.h"
#include "array/array.c"
#include "dbl_list/dbl_list.c"
#include "queue/queue.c"
#include "mem/allocator/mem_allocator.c"
#include "mem/utils/mem_utils.c"
#include "strings/str8/str8.c"
src/base/wapp_base.h
+1 -2
View File
@@ -3,9 +3,8 @@
#ifndef WAPP_BASE_H
#define WAPP_BASE_H
#include "array/array.h"
#include "dbl_list/dbl_list.h"
#include "queue/queue.h"
#include "array/array.h"
#include "mem/allocator/mem_allocator.h"
#include "mem/utils/mem_utils.h"
#include "strings/str8/str8.h"
src/common/aliases/aliases.h
+34 -34
View File
@@ -6,31 +6,31 @@
#include "../platform/platform.h"
#include <stdint.h>
#if defined(WP_PLATFORM_C) && WP_PLATFORM_C_VERSION >= WP_PLATFORM_C11_VERSION && !defined(WP_PLATFORM_APPLE)
#if defined(WAPP_PLATFORM_C) && WAPP_PLATFORM_C_VERSION >= WAPP_PLATFORM_C11_VERSION && !defined(WAPP_PLATFORM_APPLE)
#include <uchar.h>
#if WP_PLATFORM_C_VERSION >= WP_PLATFORM_C23_VERSION
typedef char8_t c8;
#if WAPP_PLATFORM_C_VERSION >= WAPP_PLATFORM_C23_VERSION
#define c8 char8_t
#else
typedef uint8_t c8;
#endif // !WP_PLATFORM_C23_VERSION
#define c8 uint8_t
#endif // !WAPP_PLATFORM_C23_VERSION
typedef char16_t c16;
typedef char32_t c32;
#define c16 char16_t
#define c32 char32_t
#else
typedef uint8_t c8;
typedef uint16_t c16;
typedef uint32_t c32;
#endif // !WP_PLATFORM_C
#define c8 uint8_t
#define c16 uint16_t
#define c32 uint32_t
#endif // !WAPP_PLATFORM_C
typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;
#define u8 uint8_t
#define u16 uint16_t
#define u32 uint32_t
#define u64 uint64_t
typedef uint8_t b8;
#define b8 uint8_t
#ifndef WP_PLATFORM_CPP
#ifndef WAPP_PLATFORM_CPP
#ifndef false
#define false (b8)0
@@ -40,28 +40,28 @@ typedef uint8_t b8;
#define true (b8)1
#endif // !true
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
typedef int8_t i8;
typedef int16_t i16;
typedef int32_t i32;
typedef int64_t i64;
#define i8 int8_t
#define i16 int16_t
#define i32 int32_t
#define i64 int64_t
typedef float f32;
typedef double f64;
typedef long double f128;
#define f32 float
#define f64 double
#define f128 long double
typedef uintptr_t uptr;
typedef intptr_t iptr;
#define uptr uintptr_t
#define iptr intptr_t
#define wp_extern extern
#define wp_intern static
#define wp_persist static
#define wapp_extern extern
#define wapp_intern static
#define wapp_persist static
#ifdef WP_PLATFORM_CPP
#define wp_class_mem static
#define BEGIN_C_LINKAGE wp_extern "C" {
#ifdef WAPP_PLATFORM_CPP
#define wapp_class_mem static
#define BEGIN_C_LINKAGE extern "C" {
#define END_C_LINKAGE }
#endif // WP_PLATFORM_CPP
#endif // WAPP_PLATFORM_CPP
#endif // !ALIASES_H
src/common/assert/assert.h
+18 -18
View File
@@ -9,42 +9,42 @@
#include <stdlib.h>
#include <inttypes.h>
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#define wpStaticAssert(EXPR, MSG) wp_extern char ASSERTION_FAILED[EXPR ? 1 : -1]
#define wapp_static_assert(EXPR, MSG) extern char ASSERTION_FAILED[EXPR ? 1 : -1]
#ifndef WP_NO_RUNTIME_ASSERT
#define wpRuntimeAssert(EXPR, MSG) _runtimeAssert(EXPR, MSG)
#ifndef WAPP_NO_RUNTIME_ASSERT
#define wapp_runtime_assert(EXPR, MSG) __wapp_runtime_assert(EXPR, MSG)
#else
#define wpRuntimeAssert(EXPR, MSG)
#define wapp_runtime_assert(EXPR, MSG)
#endif
#ifdef WP_DEBUG_ASSERT
#define wpDebugAssert(EXPR, MSG) wpRuntimeAssert(EXPR, MSG)
#ifdef WAPP_DEBUG_ASSERT
#define wapp_debug_assert(EXPR, MSG) wapp_runtime_assert(EXPR, MSG)
#else
#define wpDebugAssert(EXPR, MSG)
#define wapp_debug_assert(EXPR, MSG)
#endif
#ifdef WP_PLATFORM_WINDOWS
#define _runtimeAssert(EXPR, MSG) do { \
#ifdef WAPP_PLATFORM_WINDOWS
#define __wapp_runtime_assert(EXPR, MSG) do { \
__pragma(warning(push)) \
__pragma(warning(disable:4127)) \
if (!(EXPR)) { \
__pragma(warning(pop)) \
_runtimeAssertFailed(EXPR, MSG); \
__runtime_assert_failed(EXPR, MSG); \
} \
} while(false)
#else
#define _runtimeAssert(EXPR, MSG) do { \
#define __wapp_runtime_assert(EXPR, MSG) do { \
if (!(EXPR)) { \
_runtimeAssertFailed(EXPR, MSG); \
__runtime_assert_failed(EXPR, MSG); \
} \
} while(false)
#endif // !WP_PLATFORM_WINDOWS
#endif // !WAPP_PLATFORM_WINDOWS
#define _runtimeAssertFailed(EXPR, MSG) do { \
#define __runtime_assert_failed(EXPR, MSG) do { \
fprintf( \
stderr, \
"%s:%d (In function `%s`): Assertion failed (%" PRIu32 ")\nDiagnostic: %s\n\n", \
@@ -54,8 +54,8 @@ BEGIN_C_LINKAGE
abort(); \
} while(false)
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#endif // !WAPP_ASSERT_H
src/common/misc/misc_utils.h
+8 -11
View File
@@ -5,9 +5,9 @@
#include "../aliases/aliases.h"
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#define KiB(SIZE) (((u64)SIZE) << 10)
#define MiB(SIZE) (((u64)SIZE) << 20)
@@ -23,7 +23,7 @@ BEGIN_C_LINKAGE
#define PB(SIZE) (TB(SIZE) * 1000llu)
#define EB(SIZE) (PB(SIZE) * 1000llu)
#define wpMiscUtilsReservePadding(SIZE) u8 reserved_padding[sizeof(void *) - ((SIZE) % sizeof(void *))]
#define wapp_misc_utils_padding_size(SIZE) u8 reserved_padding[sizeof(void *) - ((SIZE) % sizeof(void *))]
#define U64_RSHIFT_OR_1(X) (((u64)X) | (((u64)X) >> 1))
#define U64_RSHIFT_OR_2(X) (((u64)X) | (((u64)X) >> 2))
@@ -31,7 +31,7 @@ BEGIN_C_LINKAGE
#define U64_RSHIFT_OR_8(X) (((u64)X) | (((u64)X) >> 8))
#define U64_RSHIFT_OR_16(X) (((u64)X) | (((u64)X) >> 16))
#define U64_RSHIFT_OR_32(X) (((u64)X) | (((u64)X) >> 32))
#define wpMiscUtilsU64RoundUpPow2(X) ( \
#define wapp_misc_utils_u64_round_up_pow2(X) ( \
( \
U64_RSHIFT_OR_32( \
U64_RSHIFT_OR_16( \
@@ -47,17 +47,14 @@ BEGIN_C_LINKAGE
) + 1 \
)
#define wpMiscUtilsIsPowerOfTwo(NUM) ((NUM & (NUM - 1)) == 0)
#define wpMiscUtilsOffsetPointer(PTR, OFFSET) ((void *)((uptr)(PTR) + (OFFSET)))
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#include <tuple>
#define wpMiscUtilsVaArgsCount(T, ...) (std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value)
#define wapp_misc_utils_va_args_count(T, ...) (std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value)
#else
#define wpMiscUtilsVaArgsCount(T, ...) (sizeof((T[]){__VA_ARGS__})/sizeof(T))
#endif // !WP_PLATFORM_CPP
#define wapp_misc_utils_va_args_count(T, ...) (sizeof((T[]){__VA_ARGS__})/sizeof(T))
#endif // !WAPP_PLATFORM_CPP
#endif // !MISC_UTILS_H
src/common/platform/platform.h
+69 -69
View File
@@ -4,110 +4,110 @@
#define PLATFORM_H
#if defined(__ANDROID__)
#define WP_PLATFORM_ANDROID
#define WP_PLATFORM_POSIX
#define WAPP_PLATFORM_ANDROID
#define WAPP_PLATFORM_POSIX
#elif defined(__FreeBSD__)
#define WP_PLATFORM_FREE_BSD
#define WP_PLATFORM_BSD
#define WP_PLATFORM_POSIX
#define WAPP_PLATFORM_FREE_BSD
#define WAPP_PLATFORM_BSD
#define WAPP_PLATFORM_POSIX
#elif defined(__NetBSD__)
#define WP_PLATFORM_NET_BSD
#define WP_PLATFORM_BSD
#define WP_PLATFORM_POSIX
#define WAPP_PLATFORM_NET_BSD
#define WAPP_PLATFORM_BSD
#define WAPP_PLATFORM_POSIX
#elif defined(__OpenBSD__)
#define WP_PLATFORM_OPEN_BSD
#define WP_PLATFORM_BSD
#define WP_PLATFORM_POSIX
#define WAPP_PLATFORM_OPEN_BSD
#define WAPP_PLATFORM_BSD
#define WAPP_PLATFORM_POSIX
#elif defined(__DragonFly__)
#define WP_PLATFORM_DRAGON_FLY
#define WP_PLATFORM_BSD
#define WP_PLATFORM_POSIX
#define WAPP_PLATFORM_DRAGON_FLY
#define WAPP_PLATFORM_BSD
#define WAPP_PLATFORM_POSIX
#elif defined(__bsdi__)
#define WP_PLATFORM_BSD
#define WP_PLATFORM_POSIX
#define WAPP_PLATFORM_BSD
#define WAPP_PLATFORM_POSIX
#elif defined(__linux__) || defined(linux) || defined(__linux) || defined(__gnu_linux__)
#define WP_PLATFORM_LINUX
#define WP_PLATFORM_POSIX
#define WAPP_PLATFORM_LINUX
#define WAPP_PLATFORM_POSIX
#elif defined(__GNU__) || defined(__gnu_hurd__)
#define WP_PLATFORM_GNU
#define WP_PLATFORM_POSIX
#define WAPP_PLATFORM_GNU
#define WAPP_PLATFORM_POSIX
#elif defined(__APPLE__) || defined(__MACH__)
#include <TargetConditionals.h>
#if TARGET_OS_IPHONE
#define WP_PLATFORM_IOS
#define WP_PLATFORM_APPLE
#define WP_PLATFORM_POSIX
#define WAPP_PLATFORM_IOS
#define WAPP_PLATFORM_APPLE
#define WAPP_PLATFORM_POSIX
#elif TARGET_OS_MAC
#define WP_PLATFORM_MACOS
#define WP_PLATFORM_APPLE
#define WP_PLATFORM_POSIX
#define WAPP_PLATFORM_MACOS
#define WAPP_PLATFORM_APPLE
#define WAPP_PLATFORM_POSIX
#else
#error "Unrecognised Apple platform"
#endif
#elif defined(_WIN64)
#define WP_PLATFORM_WINDOWS64
#define WP_PLATFORM_WINDOWS
#define WAPP_PLATFORM_WINDOWS64
#define WAPP_PLATFORM_WINDOWS
#elif defined(_WIN32)
#define WP_PLATFORM_WINDOWS32
#define WP_PLATFORM_WINDOWS
#define WAPP_PLATFORM_WINDOWS32
#define WAPP_PLATFORM_WINDOWS
#elif defined(__CYGWIN__)
#define WP_PLATFORM_CYGWIN
#define WP_PLATFORM_WINDOWS
#define WAPP_PLATFORM_CYGWIN
#define WAPP_PLATFORM_WINDOWS
#elif defined(__unix__) || defined(__unix)
#define WP_PLATFORM_UNIX
#define WP_PLATFORM_POSIX
#define WAPP_PLATFORM_UNIX
#define WAPP_PLATFORM_POSIX
#else
#error "Unrecognised platform"
#endif
#ifdef __cplusplus
#define WP_PLATFORM_CPP
#define WP_PLATFORM_CPP_VERSION __cplusplus
#define WP_PLATFORM_CPP98_VERSION 199711L
#define WP_PLATFORM_CPP11_VERSION 201103L
#define WP_PLATFORM_CPP14_VERSION 201402L
#define WP_PLATFORM_CPP17_VERSION 201703L
#define WP_PLATFORM_CPP20_VERSION 202002L
#define WP_PLATFORM_CPP23_VERSION 202302L
#define WAPP_PLATFORM_CPP
#define WAPP_PLATFORM_CPP_VERSION __cplusplus
#define WAPP_PLATFORM_CPP98_VERSION 199711L
#define WAPP_PLATFORM_CPP11_VERSION 201103L
#define WAPP_PLATFORM_CPP14_VERSION 201402L
#define WAPP_PLATFORM_CPP17_VERSION 201703L
#define WAPP_PLATFORM_CPP20_VERSION 202002L
#define WAPP_PLATFORM_CPP23_VERSION 202302L
#if WP_PLATFORM_CPP_VERSION == WP_PLATFORM_CPP98_VERSION
#define WP_PLATFORM_CPP98
#elif WP_PLATFORM_CPP_VERSION == WP_PLATFORM_CPP11_VERSION
#define WP_PLATFORM_CPP11
#elif WP_PLATFORM_CPP_VERSION == WP_PLATFORM_CPP14_VERSION
#define WP_PLATFORM_CPP14
#elif WP_PLATFORM_CPP_VERSION == WP_PLATFORM_CPP17_VERSION
#define WP_PLATFORM_CPP17
#elif WP_PLATFORM_CPP_VERSION == WP_PLATFORM_CPP20_VERSION
#define WP_PLATFORM_CPP20
#elif WP_PLATFORM_CPP_VERSION == WP_PLATFORM_CPP23_VERSION
#define WP_PLATFORM_CPP23
#if WAPP_PLATFORM_CPP_VERSION == WAPP_PLATFORM_CPP98_VERSION
#define WAPP_PLATFORM_CPP98
#elif WAPP_PLATFORM_CPP_VERSION == WAPP_PLATFORM_CPP11_VERSION
#define WAPP_PLATFORM_CPP11
#elif WAPP_PLATFORM_CPP_VERSION == WAPP_PLATFORM_CPP14_VERSION
#define WAPP_PLATFORM_CPP14
#elif WAPP_PLATFORM_CPP_VERSION == WAPP_PLATFORM_CPP17_VERSION
#define WAPP_PLATFORM_CPP17
#elif WAPP_PLATFORM_CPP_VERSION == WAPP_PLATFORM_CPP20_VERSION
#define WAPP_PLATFORM_CPP20
#elif WAPP_PLATFORM_CPP_VERSION == WAPP_PLATFORM_CPP23_VERSION
#define WAPP_PLATFORM_CPP23
#else
#error "Unrecognised C++ version"
#endif
#else
#define WP_PLATFORM_C
#define WAPP_PLATFORM_C
#if defined(__STDC_VERSION__)
#define WP_PLATFORM_C_VERSION __STDC_VERSION__
#define WP_PLATFORM_C99_VERSION 199901L
#define WP_PLATFORM_C11_VERSION 201112L
#define WP_PLATFORM_C17_VERSION 201710L
#define WP_PLATFORM_C23_VERSION 202311L
#define WAPP_PLATFORM_C_VERSION __STDC_VERSION__
#define WAPP_PLATFORM_C99_VERSION 199901L
#define WAPP_PLATFORM_C11_VERSION 201112L
#define WAPP_PLATFORM_C17_VERSION 201710L
#define WAPP_PLATFORM_C23_VERSION 202311L
#if WP_PLATFORM_C_VERSION == WP_PLATFORM_C99_VERSION
#define WP_PLATFORM_C99
#elif WP_PLATFORM_C_VERSION == WP_PLATFORM_C11_VERSION
#define WP_PLATFORM_C11
#elif WP_PLATFORM_C_VERSION == WP_PLATFORM_C17_VERSION
#define WP_PLATFORM_C17
#elif WP_PLATFORM_C_VERSION == WP_PLATFORM_C23_VERSION
#define WP_PLATFORM_C23
#if WAPP_PLATFORM_C_VERSION == WAPP_PLATFORM_C99_VERSION
#define WAPP_PLATFORM_C99
#elif WAPP_PLATFORM_C_VERSION == WAPP_PLATFORM_C11_VERSION
#define WAPP_PLATFORM_C11
#elif WAPP_PLATFORM_C_VERSION == WAPP_PLATFORM_C17_VERSION
#define WAPP_PLATFORM_C17
#elif WAPP_PLATFORM_C_VERSION == WAPP_PLATFORM_C23_VERSION
#define WAPP_PLATFORM_C23
#else
#error "Unrecognised C version"
#endif
#else
#define WP_PLATFORM_C89
#define WAPP_PLATFORM_C89
#endif
#endif // !__cplusplus
src/log/log.c
-137
View File
@@ -1,137 +0,0 @@
// vim:fileencoding=utf-8:foldmethod=marker
#include "log.h"
#include "../base/strings/str8/str8.h"
#include "../common/aliases/aliases.h"
#include "../common/assert/assert.h"
#include "../common/misc/misc_utils.h"
#include "../os/file/file.h"
#include <time.h>
#define MIN_LOG_MSG_LENGTH 32
#define TIME_BUF_CAPACITY 70
wp_intern WpStr8RO L_BRACKET = wpStr8LitRo("[");
wp_intern WpStr8RO R_BRACKET_SPACE = wpStr8LitRo("] ");
wp_intern WpStr8RO R_BRACKET_NEWLINE = wpStr8LitRo("]\n");
typedef struct {
WpFile *outlog;
WpFile *errlog;
WpLogLevel level;
wpMiscUtilsReservePadding(2 * sizeof(WpFile *) + sizeof(WpLogLevel));
} LogConfig;
wp_intern LogConfig LOG_CONFIG = {
.level = WP_LOG_LEVEL_DEBUG,
};
wp_intern WpStr8RO LOG_LEVEL_STRINGS[COUNT_LOG_LEVEL] = {
[WP_LOG_LEVEL_FATAL] = wpStr8LitRoInitialiserList("fatal "),
[WP_LOG_LEVEL_CRITICAL] = wpStr8LitRoInitialiserList("critical "),
[WP_LOG_LEVEL_ERROR] = wpStr8LitRoInitialiserList("error "),
[WP_LOG_LEVEL_WARNING] = wpStr8LitRoInitialiserList("warning "),
[WP_LOG_LEVEL_INFO] = wpStr8LitRoInitialiserList("info "),
[WP_LOG_LEVEL_DEBUG] = wpStr8LitRoInitialiserList("debug "),
};
wp_intern void _get_current_time_string(WpStr8 *dst);
wp_intern void _write_log_line(WpFile *fp, const WpLogger *logger, WpStr8 msg, WpLogLevel level);
void wpLogSetLevel(WpLogLevel level) {
LOG_CONFIG.level = level;
}
void wpLogConfigure(WpFile *outlog, WpFile *errlog, WpLogLevel level) {
LOG_CONFIG.outlog = outlog;
LOG_CONFIG.errlog = errlog;
LOG_CONFIG.level = level;
}
WpLogger wpLogMakeLogger(WpStr8 name) {
return (WpLogger){ .name = name };
}
void wpLogDebug(const WpLogger *logger, WpStr8 msg) {
wpDebugAssert(logger != NULL, "`logger` should not be NULL");
if (LOG_CONFIG.level < WP_LOG_LEVEL_DEBUG) { return; }
WpFile *fp = LOG_CONFIG.outlog != NULL ? LOG_CONFIG.outlog : wpFileStdout();
_write_log_line(fp, logger, msg, WP_LOG_LEVEL_DEBUG);
}
void wpLogInfo(const WpLogger *logger, WpStr8 msg) {
wpDebugAssert(logger != NULL, "`logger` should not be NULL");
if (LOG_CONFIG.level < WP_LOG_LEVEL_INFO) { return; }
WpFile *fp = LOG_CONFIG.outlog != NULL ? LOG_CONFIG.outlog : wpFileStdout();
_write_log_line(fp, logger, msg, WP_LOG_LEVEL_INFO);
}
void wpLogWarning(const WpLogger *logger, WpStr8 msg) {
wpDebugAssert(logger != NULL, "`logger` should not be NULL");
if (LOG_CONFIG.level < WP_LOG_LEVEL_WARNING) { return; }
WpFile *fp = LOG_CONFIG.outlog != NULL ? LOG_CONFIG.outlog : wpFileStdout();
_write_log_line(fp, logger, msg, WP_LOG_LEVEL_WARNING);
}
void wpLogError(const WpLogger *logger, WpStr8 msg) {
wpDebugAssert(logger != NULL, "`logger` should not be NULL");
if (LOG_CONFIG.level < WP_LOG_LEVEL_ERROR) { return; }
WpFile *fp = LOG_CONFIG.errlog != NULL ? LOG_CONFIG.errlog : wpFileStderr();
_write_log_line(fp, logger, msg, WP_LOG_LEVEL_ERROR);
}
void wpLogCritical(const WpLogger *logger, WpStr8 msg) {
wpDebugAssert(logger != NULL, "`logger` should not be NULL");
if (LOG_CONFIG.level < WP_LOG_LEVEL_CRITICAL) { return; }
WpFile *fp = LOG_CONFIG.errlog != NULL ? LOG_CONFIG.errlog : wpFileStderr();
_write_log_line(fp, logger, msg, WP_LOG_LEVEL_CRITICAL);
}
void wpLogFatal(const WpLogger *logger, WpStr8 msg) {
wpDebugAssert(logger != NULL, "`logger` should not be NULL");
if (LOG_CONFIG.level < WP_LOG_LEVEL_FATAL) { return; }
WpFile *fp = LOG_CONFIG.errlog != NULL ? LOG_CONFIG.errlog : wpFileStderr();
_write_log_line(fp, logger, msg, WP_LOG_LEVEL_FATAL);
}
wp_intern void _get_current_time_string(WpStr8 *dst) {
// TODO (Abdelrahman): Replace with proper date/time utilities
char buf[TIME_BUF_CAPACITY];
time_t now = time(NULL);
struct tm utc;
gmtime_r(&now, &utc);
strftime(buf, sizeof(buf), "%FT%TZ ", &utc);
wpStr8CopyCstrCapped(dst, buf);
}
wp_intern void _write_log_line(WpFile *fp, const WpLogger *logger, WpStr8 msg, WpLogLevel level) {
WpStr8 padding = wpStr8Buf(MIN_LOG_MSG_LENGTH);
u32 padding_size = msg.size < MIN_LOG_MSG_LENGTH ? MIN_LOG_MSG_LENGTH - msg.size + 1 : 0;
wpStr8Format(&padding, "%-*s", padding_size, " ");
WpStr8 time_str = wpStr8Buf(TIME_BUF_CAPACITY);
_get_current_time_string(&time_str);
WpStr8RO **strings = wpArray(
WpStr8RO *,
&time_str,
&L_BRACKET,
&LOG_LEVEL_STRINGS[level],
&R_BRACKET_SPACE,
&msg,
&padding,
&L_BRACKET,
&logger->name,
&R_BRACKET_NEWLINE
);
for (u64 i = 0; i < wpArrayCount(strings); ++i) {
wpFileWriteStr8(strings[i], fp);
}
}
src/log/log.h
-34
View File
@@ -1,34 +0,0 @@
// vim:fileencoding=utf-8:foldmethod=marker
#ifndef LOG_H
#define LOG_H
#include "../os/file/file.h"
#include "../base/strings/str8/str8.h"
typedef enum {
WP_LOG_LEVEL_FATAL,
WP_LOG_LEVEL_CRITICAL,
WP_LOG_LEVEL_ERROR,
WP_LOG_LEVEL_WARNING,
WP_LOG_LEVEL_INFO,
WP_LOG_LEVEL_DEBUG,
COUNT_LOG_LEVEL,
} WpLogLevel;
typedef struct {
WpStr8 name;
} WpLogger;
void wpLogSetLevel(WpLogLevel level);
void wpLogConfigure(WpFile *outlog, WpFile *errlog, WpLogLevel level);
WpLogger wpLogMakeLogger(WpStr8 name);
void wpLogDebug(const WpLogger *logger, WpStr8 msg);
void wpLogInfo(const WpLogger *logger, WpStr8 msg);
void wpLogWarning(const WpLogger *logger, WpStr8 msg);
void wpLogError(const WpLogger *logger, WpStr8 msg);
void wpLogCritical(const WpLogger *logger, WpStr8 msg);
void wpLogFatal(const WpLogger *logger, WpStr8 msg);
#endif // !LOG_H
src/log/wapp_log.c
-10
View File
@@ -1,10 +0,0 @@
// vim:fileencoding=utf-8:foldmethod=marker
#ifndef WAPP_LOG_C
#define WAPP_LOG_C
#include "log.c"
#include "../base/wapp_base.c"
#include "../os/wapp_os.c"
#endif // !WAPP_LOG_C
src/log/wapp_log.h
-11
View File
@@ -1,11 +0,0 @@
// vim:fileencoding=utf-8:foldmethod=marker
#ifndef WAPP_LOG_H
#define WAPP_LOG_H
#include "log.h"
#include "../common/wapp_common.h"
#include "../base/wapp_base.h"
#include "../os/wapp_os.h"
#endif // !WAPP_LOG_H
src/oldnames.h
-597
View File
@@ -1,597 +0,0 @@
// vim:fileencoding=utf-8:foldmethod=marker
//
// oldnames.h — backward-compatible #define mappings for renames in the
// wizapp-stdlib naming-conventions branch.
//
// Every public API symbol that was renamed is mapped from its old name to
// its new name so that existing code continues to compile without changes.
//
// Rename patterns applied across all modules:
// wapp_xxx() → wpXxx()
// WAPP_XXX → WP_XXX
// GenericXxx → WpXxx
// SHELL_XXX → WP_SHELL_XXX
// _xxx_yyy() → _xxxYyy()
//
// Sections: Constants → Types → Functions
#ifndef OLDNAMES_H
#define OLDNAMES_H
// ============================================================================
// ===== Constants =====
// ============================================================================
// --- Aliases ---
#define WAPP_PLATFORM_CPP WP_PLATFORM_CPP
#define WAPP_PLATFORM_C WP_PLATFORM_C
// --- Arena ---
#define WAPP_MEM_ALLOC_RESERVE WP_MEM_ALLOC_RESERVE
#define WAPP_MEM_ALLOC_COMMIT WP_MEM_ALLOC_COMMIT
// --- Array ---
#define WAPP_ARRAY_MAGIC WP_ARRAY_MAGIC
#define ARRAY_INIT_NONE WP_ARRAY_INIT_NONE
#define ARRAY_INIT_FILLED WP_ARRAY_INIT_FILLED
// --- Assert ---
#define WAPP_NO_RUNTIME_ASSERT WP_NO_RUNTIME_ASSERT
#define WAPP_DEBUG_ASSERT WP_DEBUG_ASSERT
// --- CPath ---
#define WAPP_PATH_SEP WP_PATH_SEP
#define WAPP_PATH_MAX WP_PATH_MAX
#define CPATH_JOIN_SUCCESS WP_CPATH_JOIN_RESULT_SUCCESS
#define CPATH_JOIN_INVALID_ARGS WP_CPATH_JOIN_RESULT_INVALID_ARGS
#define CPATH_JOIN_EMPTY_PARTS WP_CPATH_JOIN_RESULT_EMPTY_PARTS
#define CPATH_JOIN_INSUFFICIENT_DST_CAPACITY WP_CPATH_JOIN_RESULT_INSUFFICIENT_DST_CAPACITY
// --- DblList ---
#define WAPP_DBL_LIST_MAGIC WP_DBL_LIST_MAGIC
#define WAPP_DBL_NODE_MAGIC WP_DBL_NODE_MAGIC
// --- File ---
#define WAPP_ACCESS_READ WP_ACCESS_READ
#define WAPP_ACCESS_WRITE WP_ACCESS_WRITE
#define WAPP_ACCESS_APPEND WP_ACCESS_APPEND
#define WAPP_ACCESS_READ_EX WP_ACCESS_READ_EX
#define WAPP_ACCESS_WRITE_EX WP_ACCESS_WRITE_EX
#define WAPP_ACCESS_APPEND_EX WP_ACCESS_APPEND_EX
#define WAPP_ACCESS_WRITE_FAIL_ON_EXIST WP_ACCESS_WRITE_FAIL_ON_EXIST
#define WAPP_ACCESS_WRITE_FAIL_ON_EXIST_EX WP_ACCESS_WRITE_FAIL_ON_EXIST_EX
#define WAPP_SEEK_START WP_SEEK_START
#define WAPP_SEEK_CURRENT WP_SEEK_CURRENT
#define WAPP_SEEK_END WP_SEEK_END
#define END_OF_LINE WP_END_OF_LINE
// --- Log ---
#define WAPP_LOG_FATAL WP_LOG_LEVEL_FATAL
#define WAPP_LOG_CRITICAL WP_LOG_LEVEL_CRITICAL
#define WAPP_LOG_ERROR WP_LOG_LEVEL_ERROR
#define WAPP_LOG_WARNING WP_LOG_LEVEL_WARNING
#define WAPP_LOG_INFO WP_LOG_LEVEL_INFO
#define WAPP_LOG_DEBUG WP_LOG_LEVEL_DEBUG
// --- Mem Os ---
#define WAPP_MEM_ACCESS_NONE WP_MEM_ACCESS_NONE
#define WAPP_MEM_ACCESS_READ_ONLY WP_MEM_ACCESS_READ_ONLY
#define WAPP_MEM_ACCESS_EXEC_ONLY WP_MEM_ACCESS_EXEC_ONLY
#define WAPP_MEM_ACCESS_READ_WRITE WP_MEM_ACCESS_READ_WRITE
#define WAPP_MEM_ACCESS_READ_EXEC WP_MEM_ACCESS_READ_EXEC
#define WAPP_MEM_ACCESS_READ_WRITE_EXEC WP_MEM_ACCESS_READ_WRITE_EXEC
#define WAPP_MEM_INIT_UNINITIALISED WP_MEM_INIT_UNINITIALISED
#define WAPP_MEM_INIT_INITIALISED WP_MEM_INIT_INITIALISED
// --- Platform ---
#define WAPP_PLATFORM_ANDROID WP_PLATFORM_ANDROID
#define WAPP_PLATFORM_FREE_BSD WP_PLATFORM_FREE_BSD
#define WAPP_PLATFORM_NET_BSD WP_PLATFORM_NET_BSD
#define WAPP_PLATFORM_OPEN_BSD WP_PLATFORM_OPEN_BSD
#define WAPP_PLATFORM_DRAGON_FLY WP_PLATFORM_DRAGON_FLY
#define WAPP_PLATFORM_BSD WP_PLATFORM_BSD
#define WAPP_PLATFORM_POSIX WP_PLATFORM_POSIX
#define WAPP_PLATFORM_LINUX WP_PLATFORM_LINUX
#define WAPP_PLATFORM_GNU WP_PLATFORM_GNU
#define WAPP_PLATFORM_IOS WP_PLATFORM_IOS
#define WAPP_PLATFORM_APPLE WP_PLATFORM_APPLE
#define WAPP_PLATFORM_MACOS WP_PLATFORM_MACOS
#define WAPP_PLATFORM_WINDOWS64 WP_PLATFORM_WINDOWS64
#define WAPP_PLATFORM_WINDOWS32 WP_PLATFORM_WINDOWS32
#define WAPP_PLATFORM_WINDOWS WP_PLATFORM_WINDOWS
#define WAPP_PLATFORM_CYGWIN WP_PLATFORM_CYGWIN
#define WAPP_PLATFORM_UNIX WP_PLATFORM_UNIX
#define WAPP_PLATFORM_CPP_VERSION WP_PLATFORM_CPP_VERSION
#define WAPP_PLATFORM_CPP98_VERSION WP_PLATFORM_CPP98_VERSION
#define WAPP_PLATFORM_CPP11_VERSION WP_PLATFORM_CPP11_VERSION
#define WAPP_PLATFORM_CPP14_VERSION WP_PLATFORM_CPP14_VERSION
#define WAPP_PLATFORM_CPP17_VERSION WP_PLATFORM_CPP17_VERSION
#define WAPP_PLATFORM_CPP20_VERSION WP_PLATFORM_CPP20_VERSION
#define WAPP_PLATFORM_CPP23_VERSION WP_PLATFORM_CPP23_VERSION
#define WAPP_PLATFORM_CPP98 WP_PLATFORM_CPP98
#define WAPP_PLATFORM_CPP11 WP_PLATFORM_CPP11
#define WAPP_PLATFORM_CPP14 WP_PLATFORM_CPP14
#define WAPP_PLATFORM_CPP17 WP_PLATFORM_CPP17
#define WAPP_PLATFORM_CPP20 WP_PLATFORM_CPP20
#define WAPP_PLATFORM_CPP23 WP_PLATFORM_CPP23
#define WAPP_PLATFORM_C_VERSION WP_PLATFORM_C_VERSION
#define WAPP_PLATFORM_C99_VERSION WP_PLATFORM_C99_VERSION
#define WAPP_PLATFORM_C11_VERSION WP_PLATFORM_C11_VERSION
#define WAPP_PLATFORM_C17_VERSION WP_PLATFORM_C17_VERSION
#define WAPP_PLATFORM_C23_VERSION WP_PLATFORM_C23_VERSION
#define WAPP_PLATFORM_C99 WP_PLATFORM_C99
#define WAPP_PLATFORM_C11 WP_PLATFORM_C11
#define WAPP_PLATFORM_C17 WP_PLATFORM_C17
#define WAPP_PLATFORM_C23 WP_PLATFORM_C23
#define WAPP_PLATFORM_C89 WP_PLATFORM_C89
// --- Shell Commander ---
#define SHELL_OUTPUT_DISCARD WP_SHELL_OUTPUT_DISCARD
#define SHELL_OUTPUT_PRINT WP_SHELL_OUTPUT_PRINT
#define SHELL_OUTPUT_CAPTURE WP_SHELL_OUTPUT_CAPTURE
#define SHELL_ERR_NO_ERROR WP_SHELL_ERR_NO_ERROR
#define SHELL_ERR_INVALID_ARGS WP_SHELL_ERR_INVALID_ARGS
#define SHELL_ERR_ALLOCATION_FAIL WP_SHELL_ERR_ALLOCATION_FAIL
#define SHELL_ERR_PROC_START_FAIL WP_SHELL_ERR_PROC_START_FAIL
#define SHELL_ERR_OUT_BUF_FULL WP_SHELL_ERR_OUT_BUF_FULL
#define SHELL_ERR_PROC_EXIT_FAIL WP_SHELL_ERR_PROC_EXIT_FAIL
// --- Shell Termcolour ---
#define WAPP_TERM_COLOUR_FG_BLACK WP_TERM_COLOUR_FG_BLACK
#define WAPP_TERM_COLOUR_FG_RED WP_TERM_COLOUR_FG_RED
#define WAPP_TERM_COLOUR_FG_GREEN WP_TERM_COLOUR_FG_GREEN
#define WAPP_TERM_COLOUR_FG_BLUE WP_TERM_COLOUR_FG_BLUE
#define WAPP_TERM_COLOUR_FG_CYAN WP_TERM_COLOUR_FG_CYAN
#define WAPP_TERM_COLOUR_FG_MAGENTA WP_TERM_COLOUR_FG_MAGENTA
#define WAPP_TERM_COLOUR_FG_YELLOW WP_TERM_COLOUR_FG_YELLOW
#define WAPP_TERM_COLOUR_FG_WHITE WP_TERM_COLOUR_FG_WHITE
#define WAPP_TERM_COLOUR_FG_BR_BLACK WP_TERM_COLOUR_FG_BR_BLACK
#define WAPP_TERM_COLOUR_FG_BR_RED WP_TERM_COLOUR_FG_BR_RED
#define WAPP_TERM_COLOUR_FG_BR_GREEN WP_TERM_COLOUR_FG_BR_GREEN
#define WAPP_TERM_COLOUR_FG_BR_BLUE WP_TERM_COLOUR_FG_BR_BLUE
#define WAPP_TERM_COLOUR_FG_BR_CYAN WP_TERM_COLOUR_FG_BR_CYAN
#define WAPP_TERM_COLOUR_FG_BR_MAGENTA WP_TERM_COLOUR_FG_BR_MAGENTA
#define WAPP_TERM_COLOUR_FG_BR_YELLOW WP_TERM_COLOUR_FG_BR_YELLOW
#define WAPP_TERM_COLOUR_FG_BR_WHITE WP_TERM_COLOUR_FG_BR_WHITE
#define WAPP_TERM_COLOUR_CLEAR WP_TERM_COLOUR_CLEAR
// --- Str8 ---
#define WAPP_STR8_SPEC WP_STR8_SPEC
// --- UUID ---
#define UUID_BUF_LENGTH WP_UUID_BUF_LENGTH
#define WAPP_UUID_SPEC WP_UUID_SPEC
// ============================================================================
// ===== Types =====
// ============================================================================
// --- Aliases ---
#define wapp_extern wp_extern
#define wapp_intern wp_intern
#define wapp_persist wp_persist
#define wapp_class_mem wp_class_mem
// --- Arena ---
#define Arena WpArena
// --- Array ---
#define GenericArray WpArray
#define VoidPtrArray WpVoidPtrArray
#define C8Array WpC8Array
#define C16Array WpC16Array
#define C32Array WpC32Array
#define U8Array WpU8Array
#define U16Array WpU16Array
#define U32Array WpU32Array
#define U64Array WpU64Array
#define B8Array WpB8Array
#define I8Array WpI8Array
#define I16Array WpI16Array
#define I32Array WpI32Array
#define I64Array WpI64Array
#define F32Array WpF32Array
#define F64Array WpF64Array
#define F128Array WpF128Array
#define UptrArray WpUptrArray
#define IptrArray WpIptrArray
#define Str8Array WpStr8Array
#define ArrayHeader WpArrayHeader
#define ArrayInitFlags WpArrayInitFlags
// --- DblList ---
#define GenericNode WpDblNode
#define NodeHeader WpDblNodeHeader
#define GenericList WpDblList
#define VoidPtrList WpVoidPtrList
#define C8List WpC8List
#define C16List WpC16List
#define C32List WpC32List
#define U8List WpU8List
#define U16List WpU16List
#define U32List WpU32List
#define U64List WpU64List
#define B8List WpB8List
#define I8List WpI8List
#define I16List WpI16List
#define I32List WpI32List
#define I64List WpI64List
#define F32List WpF32List
#define F64List WpF64List
#define F128List WpF128List
#define UptrList WpUptrList
#define IptrList WpIptrList
#define Str8List WpStr8List
#define VoidPtrNode WpVoidPtrNode
#define C8Node WpC8Node
#define C16Node WpC16Node
#define C32Node WpC32Node
#define U8Node WpU8Node
#define U16Node WpU16Node
#define U32Node WpU32Node
#define U64Node WpU64Node
#define B8Node WpB8Node
#define I8Node WpI8Node
#define I16Node WpI16Node
#define I32Node WpI32Node
#define I64Node WpI64Node
#define F32Node WpF32Node
#define F64Node WpF64Node
#define F128Node WpF128Node
#define UptrNode WpUptrNode
#define IptrNode WpIptrNode
#define Str8Node WpStr8Node
// --- File ---
#define WFile WpFile
#define FileAccessMode WpFileAccessMode
#define FileSeekOrigin WpFileSeekOrigin
// --- Log ---
#define LogLevel WpLogLevel
#define Logger WpLogger
// --- Mem Allocator ---
#define Allocator WpAllocator
#define MemAllocFunc WpMemAllocFunc
#define MemAllocAlignedFunc WpMemAllocAlignedFunc
#define MemReallocFunc WpMemReallocFunc
#define MemReallocAlignedFunc WpMemReallocAlignedFunc
#define MemFreeFunc WpMemFreeFunc
// --- Mem Os ---
#define MemAccess WpMemAccess
#define MemInitType WpMemInitType
#define MemAllocFlags WpMemAllocFlags
// --- PRNG Xorshift ---
#define XOR256State WpXor256State
// --- Queue ---
#define GenericQueue WpQueue
#define VoidPtrQueue WpVoidPtrQueue
#define C8Queue WpC8Queue
#define C16Queue WpC16Queue
#define C32Queue WpC32Queue
#define U8Queue WpU8Queue
#define U16Queue WpU16Queue
#define U32Queue WpU32Queue
#define U64Queue WpU64Queue
#define B8Queue WpB8Queue
#define I8Queue WpI8Queue
#define I16Queue WpI16Queue
#define I32Queue WpI32Queue
#define I64Queue WpI64Queue
#define F32Queue WpF32Queue
#define F64Queue WpF64Queue
#define F128Queue WpF128Queue
#define UptrQueue WpUptrQueue
#define IptrQueue WpIptrQueue
#define Str8Queue WpStr8Queue
// --- Shell Commander ---
#define CMDResult WpCmdResult
#define CMDOutHandling WpCmdOutHandling
#define CMDError WpCmdError
// --- Shell Termcolour ---
#define TerminalColour WpTerminalColour
// --- Str8 ---
#define Str8 WpStr8
#define Str8RO WpStr8RO
// --- Tester ---
#define TestFuncResult WpTestFuncResult
#define TestFunc WpTestFunc
// --- UUID ---
#define WUUID WpUuid
// ============================================================================
// ===== Functions =====
// ============================================================================
// --- Arena ---
#define wapp_mem_arena_init_allocated wpMemArenaInitAllocated
#define wapp_mem_arena_init_allocated_commit wpMemArenaInitAllocatedCommit
#define wapp_mem_arena_init_allocated_zero wpMemArenaInitAllocatedZero
#define wapp_mem_arena_init_allocated_commit_and_zero wpMemArenaInitAllocatedCommitAndZero
#define wapp_mem_arena_init_allocated_custom wpMemArenaInitAllocatedCustom
#define wapp_mem_arena_init_buffer wpMemArenaInitBuffer
#define wapp_mem_arena_alloc wpMemArenaAlloc
#define wapp_mem_arena_alloc_aligned wpMemArenaAllocAligned
#define wapp_mem_arena_realloc wpMemArenaRealloc
#define wapp_mem_arena_realloc_aligned wpMemArenaReallocAligned
#define wapp_mem_arena_temp_begin wpMemArenaTempBegin
#define wapp_mem_arena_temp_end wpMemArenaTempEnd
#define wapp_mem_arena_clear wpMemArenaClear
#define wapp_mem_arena_destroy wpMemArenaDestroy
#define wapp_mem_arena_allocator_init wpMemArenaAllocatorInit
#define wapp_mem_arena_allocator_init_commit wpMemArenaAllocatorInitCommit
#define wapp_mem_arena_allocator_init_zero wpMemArenaAllocatorInitZero
#define wapp_mem_arena_allocator_init_commit_and_zero wpMemArenaAllocatorInitCommitAndZero
#define wapp_mem_arena_allocator_init_custom wpMemArenaAllocatorInitCustom
#define wapp_mem_arena_allocator_init_with_buffer wpMemArenaAllocatorInitWithBuffer
#define wapp_mem_arena_allocator_temp_begin wpMemArenaAllocatorTempBegin
#define wapp_mem_arena_allocator_temp_end wpMemArenaAllocatorTempEnd
#define wapp_mem_arena_allocator_clear wpMemArenaAllocatorClear
#define wapp_mem_arena_allocator_destroy wpMemArenaAllocatorDestroy
// --- Array ---
#define wapp_array wpArray
#define wapp_array_with_capacity wpArrayWithCapacity
#define wapp_array_pop wpArrayPop
#define wapp_array_count wpArrayCount
#define wapp_array_capacity wpArrayCapacity
#define wapp_array_item_size wpArrayItemSize
#define wapp_array_set_count wpArraySetCount
#define wapp_array_get wpArrayGet
#define wapp_array_set wpArraySet
#define wapp_array_append_capped wpArrayAppendCapped
#define wapp_array_extend_capped wpArrayExtendCapped
#define wapp_array_copy_capped wpArrayCopyCapped
#define wapp_array_append_alloc wpArrayAppendAlloc
#define wapp_array_extend_alloc wpArrayExtendAlloc
#define wapp_array_copy_alloc wpArrayCopyAlloc
#define wapp_array_clear wpArrayClear
#define wapp_array_calc_alloc_size wpArrayCalcAllocSize
#define wapp_array_alloc_capacity wpArrayAllocCapacity
#define wapp_array_from_preallcated_buffer wpArrayFromPreallcatedBuffer
// --- Assert ---
#define wapp_static_assert wpStaticAssert
#define wapp_runtime_assert wpRuntimeAssert
#define wapp_debug_assert wpDebugAssert
// --- CPath ---
#define wapp_cpath_dirname wpCpathDirname
#define wapp_cpath_dirup wpCpathDirup
#define wapp_cpath_join_path wpCpathJoinPath
#define dirup _dirup
// --- DblList ---
#define wapp_dbl_list wpDblList
#define wapp_dbl_list_alloc wpDblListAlloc
#define wapp_dbl_list_get wpDblListGet
#define wapp_dbl_list_get_node wpDblListGetNode
#define wapp_dbl_list_get_node_item wpDblListGetNodeItem
#define wapp_dbl_list_push_front wpDblListPushFront
#define wapp_dbl_list_push_back wpDblListPushBack
#define wapp_dbl_list_insert wpDblListInsert
#define wapp_dbl_list_push_front_alloc wpDblListPushFrontAlloc
#define wapp_dbl_list_push_back_alloc wpDblListPushBackAlloc
#define wapp_dbl_list_insert_alloc wpDblListInsertAlloc
#define wapp_dbl_list_pop_front wpDblListPopFront
#define wapp_dbl_list_pop_back wpDblListPopBack
#define wapp_dbl_list_remove wpDblListRemove
#define wapp_dbl_list_pop_front_node wpDblListPopFrontNode
#define wapp_dbl_list_pop_back_node wpDblListPopBackNode
#define wapp_dbl_list_remove_node wpDblListRemoveNode
#define wapp_dbl_list_empty wpDblListEmpty
#define _dbl_list_alloc _dblListAlloc
#define _dbl_list_node_alloc _dblListNodeAlloc
#define _dbl_list_get _dblListGet
#define _dbl_list_push_front _dblListPushFront
#define _dbl_list_push_back _dblListPushBack
#define _dbl_list_insert _dblListInsert
#define _dbl_list_pop_front _dblListPopFront
#define _dbl_list_pop_back _dblListPopBack
#define _dbl_list_remove _dblListRemove
#define _dbl_list_empty _dblListEmpty
// --- File ---
#define wapp_file_stdin wpFileStdin
#define wapp_file_stdout wpFileStdout
#define wapp_file_stderr wpFileStderr
#define wapp_file_open wpFileOpen
#define wapp_file_get_current_position wpFileGetCurrentPosition
#define wapp_file_seek wpFileSeek
#define wapp_file_get_length wpFileGetLength
#define wapp_file_read wpFileRead
#define wapp_file_write wpFileWrite
#define wapp_file_read_str8 wpFileReadStr8
#define wapp_file_write_str8 wpFileWriteStr8
#define wapp_file_read_array wpFileReadArray
#define wapp_file_write_array wpFileWriteArray
#define wapp_file_flush wpFileFlush
#define wapp_file_close wpFileClose
#define wapp_file_rename wpFileRename
#define wapp_file_remove wpFileRemove
#define _file_open _fileOpen
#define _file_seek _fileSeek
#define _file_read _fileRead
#define _file_write _fileWrite
#define _file_flush _fileFlush
#define _file_close _fileClose
#define _file_rename _fileRename
#define _file_remove _fileRemove
// --- Log ---
#define wapp_log_set_level wpLogSetLevel
#define wapp_log_configure wpLogConfigure
#define wapp_log_make_logger wpLogMakeLogger
#define wapp_log_debug wpLogDebug
#define wapp_log_info wpLogInfo
#define wapp_log_warning wpLogWarning
#define wapp_log_error wpLogError
#define wapp_log_critical wpLogCritical
#define wapp_log_fatal wpLogFatal
// --- Mem Allocator ---
#define wapp_mem_allocator_invalid wpMemAllocatorInvalid
#define wapp_mem_allocator_alloc wpMemAllocatorAlloc
#define wapp_mem_allocator_alloc_aligned wpMemAllocatorAllocAligned
#define wapp_mem_allocator_realloc wpMemAllocatorRealloc
#define wapp_mem_allocator_realloc_aligned wpMemAllocatorReallocAligned
#define wapp_mem_allocator_free wpMemAllocatorFree
// --- Mem Os ---
#define wapp_os_mem_alloc wpOsMemAlloc
#define wapp_os_mem_free wpOsMemFree
#define os_mem_allocate _osMemAllocate
#define os_mem_free _osMemFree
// --- Mem Utils ---
#define wapp_mem_util_align_forward wpMemUtilAlignForward
// --- Misc Utils ---
#define wapp_misc_utils_reserve_padding wpMiscUtilsReservePadding
#define wapp_misc_utils_u64_round_up_pow2 wpMiscUtilsU64RoundUpPow2
#define wapp_is_power_of_two wpMiscUtilsIsPowerOfTwo
#define wapp_pointer_offset wpMiscUtilsOffsetPointer
#define wapp_misc_utils_va_args_count wpMiscUtilsVaArgsCount
// --- PRNG Xorshift ---
#define wapp_prng_xorshift_init_state wpPrngXorshiftInit
#define wapp_prng_xorshift_256 wpPrngXorshift256
#define wapp_prng_xorshift_256ss wpPrngXorshift256ss
#define wapp_prng_xorshift_256p wpPrngXorshift256p
// --- Queue ---
#define wapp_queue wpQueue
#define wapp_queue_alloc wpQueueAlloc
#define wapp_queue_capacity wpQueueCapacity
#define wapp_queue_item_size wpQueueItemSize
#define wapp_queue_push wpQueuePush
#define wapp_queue_push_alloc wpQueuePushAlloc
#define wapp_queue_pop wpQueuePop
#define _queue_push _queuePush
#define _queue_push_alloc _queuePushAlloc
#define _queue_pop _queuePop
// --- Shell Commander ---
#define CMD_NO_EXIT wpCmdNoExit
#define wapp_shell_commander_execute wpShellCommanderExecute
#define get_output_status _getOutputStatus
// --- Shell Termcolour ---
#define wapp_shell_termcolour_print_text wpShellTermcolourPrintText
#define wapp_shell_termcolour_clear_colour wpShellTermcolourClearColour
#define print_coloured_text _printColouredText
// --- Shell Utils ---
#define wapp_shell_utils_popen wpShellUtilsPopen
#define wapp_shell_utils_pclose wpShellUtilsPclose
// --- Str8 ---
#define wapp_str8_varg wpStr8Varg
#define wapp_str8_buf wpStr8Buf
#define wapp_str8_lit wpStr8Lit
#define wapp_str8_lit_ro wpStr8LitRo
#define wapp_str8_lit_ro_initialiser_list wpStr8LitRoInitialiserList
#define wapp_str8_alloc_buf wpStr8AllocBuf
#define wapp_str8_alloc_and_fill_buf wpStr8AllocAndFillBuf
#define wapp_str8_alloc_cstr wpStr8AllocCstr
#define wapp_str8_alloc_str8 wpStr8AllocStr8
#define wapp_str8_alloc_substr wpStr8AllocSubstr
#define wapp_str8_alloc_concat wpStr8AllocConcat
#define wapp_str8_dealloc_buf wpStr8DeallocBuf
#define wapp_str8_get wpStr8Get
#define wapp_str8_set wpStr8Set
#define wapp_str8_push_back wpStr8PushBack
#define wapp_str8_equal wpStr8Equal
#define wapp_str8_equal_to_count wpStr8EqualToCount
#define wapp_str8_slice wpStr8Slice
#define wapp_str8_concat_capped wpStr8ConcatCapped
#define wapp_str8_copy_cstr_capped wpStr8CopyCstrCapped
#define wapp_str8_copy_str8_capped wpStr8CopyStr8Capped
#define wapp_str8_copy_to_cstr wpStr8CopyToCstr
#define wapp_str8_format wpStr8Format
#define wapp_str8_to_lower wpStr8ToLower
#define wapp_str8_to_upper wpStr8ToUpper
#define wapp_str8_from_bytes wpStr8FromBytes
#define wapp_str8_find wpStr8Find
#define wapp_str8_rfind wpStr8Rfind
#define wapp_str8_split wpStr8Split
#define wapp_str8_rsplit wpStr8Rsplit
#define wapp_str8_split_with_max wpStr8SplitWithMax
#define wapp_str8_rsplit_with_max wpStr8RsplitWithMax
#define wapp_str8_join wpStr8Join
#define wapp_str8_list_total_size wpStr8ListTotalSize
// --- Tester ---
#define wapp_tester_result wpTesterResult
#define wapp_tester_run wpTesterRun
#define run_tests _runTests
// --- UUID ---
#define wapp_uuid_varg wpUuidVarg
#define wapp_uuid_gen_uuid4 wpUuidGenUuid4
#define wapp_uuid_create wpUuidCreate
#define wapp_uuid_init_uuid4 wpUuidInitUuid4
#endif // !OLDNAMES_H
src/os/allocators/arena/mem_arena.c
+47 -93
View File
@@ -6,6 +6,7 @@
#include "../../../common/assert/assert.h"
#include "../../../common/misc/misc_utils.h"
#include "../../../base/mem/utils/mem_utils.h"
#include <stdlib.h>
#include <string.h>
#ifndef DEFAULT_ALIGNMENT
@@ -16,112 +17,85 @@
#define ARENA_MINIMUM_CAPACITY KiB(16) // Allocate minimum of 4 pages
typedef enum {
ARENA_STORAGE_TYPE_ALLOCATED,
ARENA_STORAGE_TYPE_BUFFER,
} ArenaStorageType;
struct WpArena {
struct arena {
u8 *buf;
u8 *offset;
u8 *prev_offset;
u64 capacity;
ArenaStorageType type;
b8 committed;
wpMiscUtilsReservePadding(sizeof(u8 *) * 3 + sizeof(u64) + sizeof(ArenaStorageType) + sizeof(b8));
#ifdef WAPP_PLATFORM_WINDOWS
wapp_misc_utils_padding_size(sizeof(u8 *) * 2 + sizeof(u64) + sizeof(b8));
#endif // ifdef WAPP_PLATFORM_WINDOWS
};
b8 wpMemArenaInitBuffer(WpArena **arena, u8 *buffer, u64 buffer_size) {
if (!arena || *arena || buffer_size < sizeof(WpArena)) {
return false;
}
*arena = (WpArena *)buffer;
WpArena *arena_ptr = *arena;
arena_ptr->buf = (u8 *)(arena_ptr + 1);
arena_ptr->offset = arena_ptr->buf;
arena_ptr->prev_offset = NULL;
arena_ptr->capacity = buffer_size - sizeof(WpArena);
arena_ptr->type = ARENA_STORAGE_TYPE_BUFFER;
arena_ptr->committed = true;
return true;
}
b8 wpMemArenaInitAllocatedCustom(WpArena **arena, u64 base_capacity, WpMemAllocFlags flags, b8 zero_buffer) {
b8 wapp_mem_arena_init_custom(Arena **arena, u64 base_capacity, MemAllocFlags flags, b8 zero_buffer) {
if (!arena || *arena || base_capacity == 0) {
return false;
}
u64 size = sizeof(WpArena) + (base_capacity >= ARENA_MINIMUM_CAPACITY ? base_capacity : ARENA_MINIMUM_CAPACITY);
u64 alloc_size = wpMiscUtilsU64RoundUpPow2(size);
u8 *allocated = (u8 *)wpOsMemAlloc(NULL, alloc_size, WP_MEM_ACCESS_READ_WRITE, flags,
zero_buffer ? WP_MEM_INIT_INITIALISED : WP_MEM_INIT_UNINITIALISED);
if (!allocated) {
*arena = (Arena *)calloc(1, sizeof(Arena));
Arena *arena_ptr = *arena;
if (!arena_ptr) {
return false;
}
b8 committed = (flags & WP_MEM_ALLOC_COMMIT) == WP_MEM_ALLOC_COMMIT;
u64 arena_capacity = wapp_misc_utils_u64_round_up_pow2(
base_capacity >= ARENA_MINIMUM_CAPACITY ?
base_capacity :
ARENA_MINIMUM_CAPACITY
);
#ifdef WP_PLATFORM_WINDOWS
if (!committed) {
wpOsMemAlloc(allocated, sizeof(WpArena), WP_MEM_ACCESS_READ_WRITE, WP_MEM_ALLOC_COMMIT,
WP_MEM_INIT_INITIALISED);
}
#endif // ifdef WP_PLATFORM_WINDOWS
arena_ptr->buf = (u8 *)wapp_mem_util_alloc(NULL, arena_capacity, WAPP_MEM_ACCESS_READ_WRITE, flags,
zero_buffer ? WAPP_MEM_INIT_INITIALISED : WAPP_MEM_INIT_UNINITIALISED);
if (!wpMemArenaInitBuffer(arena, allocated, alloc_size)) {
wpMemArenaDestroy(arena);
if (!(arena_ptr->buf)) {
wapp_mem_arena_destroy(arena);
return false;
}
WpArena *arena_ptr = *arena;
arena_ptr->type = ARENA_STORAGE_TYPE_ALLOCATED;
arena_ptr->committed = committed;
arena_ptr->capacity = arena_capacity;
arena_ptr->offset = arena_ptr->buf;
arena_ptr->committed = (flags & WAPP_MEM_ALLOC_COMMIT) == WAPP_MEM_ALLOC_COMMIT;
return true;
}
void *wpMemArenaAlloc(WpArena *arena, u64 size) {
return wpMemArenaAllocAligned(arena, size, DEFAULT_ALIGNMENT);
void *wapp_mem_arena_alloc(Arena *arena, u64 size) {
return wapp_mem_arena_alloc_aligned(arena, size, DEFAULT_ALIGNMENT);
}
void *wpMemArenaAllocAligned(WpArena *arena, u64 size, u64 alignment) {
wpDebugAssert(arena != NULL, "`arena` should not be NULL");
void *wapp_mem_arena_alloc_aligned(Arena *arena, u64 size, u64 alignment) {
wapp_debug_assert(arena != NULL, "`arena` should not be NULL");
u8 *alloc_start = arena->offset;
u8 *output = wpMemUtilAlignForward((void *)alloc_start, alignment);
u8 *output = wapp_mem_util_align_forward((void *)alloc_start, alignment);
if (output + size >= arena->buf + arena->capacity) {
return NULL;
}
arena->offset = output + size;
#ifdef WP_PLATFORM_WINDOWS
if (arena->type == ARENA_STORAGE_TYPE_ALLOCATED && !(arena->committed)) {
wpOsMemAlloc(alloc_start, (uptr)(arena->offset) - (uptr)(alloc_start),
WP_MEM_ACCESS_READ_WRITE, WP_MEM_ALLOC_COMMIT,
WP_MEM_INIT_UNINITIALISED);
#ifdef WAPP_PLATFORM_WINDOWS
if (!(arena->committed)) {
wapp_mem_util_alloc(alloc_start, (uptr)(arena->offset) - (uptr)(alloc_start),
WAPP_MEM_ACCESS_READ_WRITE, WAPP_MEM_ALLOC_COMMIT,
WAPP_MEM_INIT_UNINITIALISED);
}
#endif // ifdef WP_PLATFORM_WINDOWS
#endif // ifdef WAPP_PLATFORM_WINDOWS
memset(output, 0, size);
return (void *)output;
}
void *wpMemArenaRealloc(WpArena *arena, void *ptr, u64 old_size, u64 new_size) {
wpDebugAssert(arena != NULL, "`arena` should not be NULL");
void *wapp_mem_arena_realloc(Arena *arena, void *ptr, u64 old_size, u64 new_size) {
if ((u8*)ptr < arena->buf || (u8*)ptr > arena->offset ||
arena->offset + new_size >= arena->buf + arena->capacity) {
return NULL;
}
void *new_ptr = wpMemArenaAlloc(arena, new_size);
void *new_ptr = wapp_mem_arena_alloc(arena, new_size);
if (!new_ptr) {
return NULL;
}
@@ -132,15 +106,13 @@ void *wpMemArenaRealloc(WpArena *arena, void *ptr, u64 old_size, u64 new_size) {
return new_ptr;
}
void *wpMemArenaReallocAligned(WpArena *arena, void *ptr, u64 old_size, u64 new_size, u64 alignment) {
wpDebugAssert(arena != NULL, "`arena` should not be NULL");
void *wapp_mem_arena_realloc_aligned(Arena *arena, void *ptr, u64 old_size, u64 new_size, u64 alignment) {
if ((u8*)ptr < arena->buf || (u8*)ptr > arena->offset ||
arena->offset + new_size >= arena->buf + arena->capacity) {
return NULL;
}
void *new_ptr = wpMemArenaAllocAligned(arena, new_size, alignment);
void *new_ptr = wapp_mem_arena_alloc_aligned(arena, new_size, alignment);
if (!new_ptr) {
return NULL;
}
@@ -151,42 +123,24 @@ void *wpMemArenaReallocAligned(WpArena *arena, void *ptr, u64 old_size, u64 new_
return new_ptr;
}
void wpMemArenaTempBegin(WpArena *arena) {
wpDebugAssert(arena != NULL, "`arena` should not be NULL");
if (arena->prev_offset != NULL) {
return;
}
arena->prev_offset = arena->offset;
}
void wpMemArenaTempEnd(WpArena *arena) {
wpDebugAssert(arena != NULL, "`arena` should not be NULL");
if (arena->prev_offset == NULL) {
return;
}
arena->offset = arena->prev_offset;
arena->prev_offset = NULL;
}
void wpMemArenaClear(WpArena *arena) {
wpDebugAssert(arena != NULL, "`arena` should not be NULL");
void wapp_mem_arena_clear(Arena *arena) {
wapp_debug_assert(arena != NULL, "`arena` should not be NULL");
memset(arena->buf, 0, arena->offset - arena->buf);
arena->offset = arena->buf;
}
void wpMemArenaDestroy(WpArena **arena) {
wpDebugAssert(arena != NULL && (*arena) != NULL, "`arena` double pointer is not valid");
void wapp_mem_arena_destroy(Arena **arena) {
wapp_debug_assert(arena != NULL && (*arena) != NULL, "`arena` double pointer is not valid");
WpArena *arena_ptr = *arena;
if (arena_ptr->type == ARENA_STORAGE_TYPE_ALLOCATED) {
wpOsMemFree(*arena, sizeof(WpArena) + arena_ptr->capacity);
Arena *arena_ptr = *arena;
if (arena_ptr->buf) {
wapp_mem_util_free(arena_ptr->buf, arena_ptr->capacity);
}
arena_ptr->buf = arena_ptr->offset = NULL;
arena_ptr->capacity = 0;
free(*arena);
*arena = NULL;
}
src/os/allocators/arena/mem_arena.h
+22 -25
View File
@@ -7,39 +7,36 @@
#include "../../../common/aliases/aliases.h"
#include "../../../common/platform/platform.h"
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
typedef struct WpArena WpArena;
typedef struct arena Arena;
#define wpMemArenaInitAllocated(arena_dptr, base_capacity) \
(wpMemArenaInitAllocatedCustom(arena_dptr, base_capacity, WP_MEM_ALLOC_RESERVE, false))
#define wpMemArenaInitAllocatedCommit(arena_dptr, base_capacity) \
(wpMemArenaInitAllocatedCustom(arena_dptr, base_capacity, WP_MEM_ALLOC_RESERVE | WP_MEM_ALLOC_COMMIT, false))
#define wpMemArenaInitAllocatedZero(arena_dptr, base_capacity) \
(wpMemArenaInitAllocatedCustom(arena_dptr, base_capacity, WP_MEM_ALLOC_RESERVE, true))
#define wpMemArenaInitAllocatedCommitAndZero(arena_dptr, base_capacity) \
(wpMemArenaInitAllocatedCustom(arena_dptr, base_capacity, WP_MEM_ALLOC_RESERVE | WP_MEM_ALLOC_COMMIT, true))
#define wapp_mem_arena_init(arena_dptr, base_capacity) \
(wapp_mem_arena_init_custom(arena_dptr, base_capacity, WAPP_MEM_ALLOC_RESERVE, false))
#define wapp_mem_arena_init_commit(arena_dptr, base_capacity) \
(wapp_mem_arena_init_custom(arena_dptr, base_capacity, WAPP_MEM_ALLOC_RESERVE | WAPP_MEM_ALLOC_COMMIT, false))
#define wapp_mem_arena_init_zero(arena_dptr, base_capacity) \
(wapp_mem_arena_init_custom(arena_dptr, base_capacity, WAPP_MEM_ALLOC_RESERVE, true))
#define wapp_mem_arena_init_commit_and_zero(arena_dptr, base_capacity) \
(wapp_mem_arena_init_custom(arena_dptr, base_capacity, WAPP_MEM_ALLOC_RESERVE | WAPP_MEM_ALLOC_COMMIT, true))
/**
* WpArena initialisation function. `wpMemArenaInitAllocatedCustom` provides the most
* control over how the WpArena is initialised. Wrapper macros are provided for
* Arena initialisation function. `wapp_mem_arena_init_custom` provides the most
* control over how the Arena is initialised. Wrapper macros are provided for
* easier use.
*/
b8 wpMemArenaInitAllocatedCustom(WpArena **arena, u64 base_capacity, WpMemAllocFlags flags, b8 zero_buffer);
b8 wpMemArenaInitBuffer(WpArena **arena, u8 *buffer, u64 buffer_size);
void *wpMemArenaAlloc(WpArena *arena, u64 size);
void *wpMemArenaAllocAligned(WpArena *arena, u64 size, u64 alignment);
void *wpMemArenaRealloc(WpArena *arena, void *ptr, u64 old_size, u64 new_size);
void *wpMemArenaReallocAligned(WpArena *arena, void *ptr, u64 old_size, u64 new_size, u64 alignment);
void wpMemArenaTempBegin(WpArena *arena);
void wpMemArenaTempEnd(WpArena *arena);
void wpMemArenaClear(WpArena *arena);
void wpMemArenaDestroy(WpArena **arena);
b8 wapp_mem_arena_init_custom(Arena **arena, u64 base_capacity, MemAllocFlags flags, b8 zero_buffer);
void *wapp_mem_arena_alloc(Arena *arena, u64 size);
void *wapp_mem_arena_alloc_aligned(Arena *arena, u64 size, u64 alignment);
void *wapp_mem_arena_realloc(Arena *arena, void *ptr, u64 old_size, u64 new_size);
void *wapp_mem_arena_realloc_aligned(Arena *arena, void *ptr, u64 old_size, u64 new_size, u64 alignment);
void wapp_mem_arena_clear(Arena *arena);
void wapp_mem_arena_destroy(Arena **arena);
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#endif // !MEM_ARENA_H
src/os/allocators/arena/mem_arena_allocator.c
+30 -58
View File
@@ -4,84 +4,56 @@
#include "mem_arena.h"
#include "../../mem/mem_os.h"
#include "../../../common/aliases/aliases.h"
#include "../../../common/assert/assert.h"
wp_intern void initialise_arena_allocator(WpAllocator *allocator);
wp_intern void *mem_arena_alloc(u64 size, void *alloc_obj);
wp_intern void *mem_arena_alloc_aligned(u64 size, u64 alignment, void *alloc_obj);
wp_intern void *mem_arena_realloc(void *ptr, u64 old_size, u64 new_size, void *alloc_obj);
wp_intern void *mem_arena_realloc_aligned(void *ptr, u64 old_size, u64 new_size, u64 alignment,
wapp_intern inline void *mem_arena_alloc(u64 size, void *alloc_obj);
wapp_intern inline void *mem_arena_alloc_aligned(u64 size, u64 alignment, void *alloc_obj);
wapp_intern inline void *mem_arena_realloc(void *ptr, u64 old_size, u64 new_size, void *alloc_obj);
wapp_intern inline void *mem_arena_realloc_aligned(void *ptr, u64 old_size, u64 new_size, u64 alignment,
void *alloc_obj);
WpAllocator wpMemArenaAllocatorInitWithBuffer(u8 *buffer, u64 buffer_size) {
WpAllocator allocator = {0};
b8 initialised = wpMemArenaInitBuffer((WpArena **)(&allocator.obj), buffer, buffer_size);
Allocator wapp_mem_arena_allocator_init_custom(u64 base_capacity, MemAllocFlags flags, b8 zero_buffer) {
Allocator allocator = {0};
b8 initialised = wapp_mem_arena_init_custom((Arena **)(&allocator.obj), base_capacity, flags, zero_buffer);
if (!initialised) {
return allocator;
}
initialise_arena_allocator(&allocator);
allocator.alloc = mem_arena_alloc;
allocator.alloc_aligned = mem_arena_alloc_aligned;
allocator.realloc = mem_arena_realloc;
allocator.realloc_aligned = mem_arena_realloc_aligned;
return allocator;
}
WpAllocator wpMemArenaAllocatorInitCustom(u64 base_capacity, WpMemAllocFlags flags, b8 zero_buffer) {
WpAllocator allocator = {0};
b8 initialised = wpMemArenaInitAllocatedCustom((WpArena **)(&allocator.obj), base_capacity, flags, zero_buffer);
if (!initialised) {
return allocator;
}
initialise_arena_allocator(&allocator);
return allocator;
void wapp_mem_arena_allocator_clear(Allocator *allocator) {
wapp_mem_arena_clear((Arena *)(allocator->obj));
}
void wpMemArenaAllocatorTempBegin(const WpAllocator *allocator) {
wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
wpMemArenaTempBegin((WpArena *)(allocator->obj));
void wapp_mem_arena_allocator_destroy(Allocator *allocator) {
wapp_mem_arena_destroy((Arena **)(&(allocator->obj)));
*allocator = (Allocator){0};
}
void wpMemArenaAllocatorTempEnd(const WpAllocator *allocator) {
wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
wpMemArenaTempEnd((WpArena *)(allocator->obj));
wapp_intern inline void *mem_arena_alloc(u64 size, void *alloc_obj) {
Arena *arena = (Arena *)alloc_obj;
return wapp_mem_arena_alloc(arena, size);
}
void wpMemArenaAllocatorClear(WpAllocator *allocator) {
wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
wpMemArenaClear((WpArena *)(allocator->obj));
wapp_intern inline void *mem_arena_alloc_aligned(u64 size, u64 alignment, void *alloc_obj) {
Arena *arena = (Arena *)alloc_obj;
return wapp_mem_arena_alloc_aligned(arena, size, alignment);
}
void wpMemArenaAllocatorDestroy(WpAllocator *allocator) {
wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
wpMemArenaDestroy((WpArena **)(&(allocator->obj)));
*allocator = (WpAllocator){0};
wapp_intern inline void *mem_arena_realloc(void *ptr, u64 old_size, u64 new_size, void *alloc_obj) {
Arena *arena = (Arena *)alloc_obj;
return wapp_mem_arena_realloc(arena, ptr, old_size, new_size);
}
wp_intern void initialise_arena_allocator(WpAllocator *allocator) {
allocator->alloc = mem_arena_alloc;
allocator->alloc_aligned = mem_arena_alloc_aligned;
allocator->realloc = mem_arena_realloc;
allocator->realloc_aligned = mem_arena_realloc_aligned;
}
wp_intern void *mem_arena_alloc(u64 size, void *alloc_obj) {
WpArena *arena = (WpArena *)alloc_obj;
return wpMemArenaAlloc(arena, size);
}
wp_intern void *mem_arena_alloc_aligned(u64 size, u64 alignment, void *alloc_obj) {
WpArena *arena = (WpArena *)alloc_obj;
return wpMemArenaAllocAligned(arena, size, alignment);
}
wp_intern void *mem_arena_realloc(void *ptr, u64 old_size, u64 new_size, void *alloc_obj) {
WpArena *arena = (WpArena *)alloc_obj;
return wpMemArenaRealloc(arena, ptr, old_size, new_size);
}
wp_intern void *mem_arena_realloc_aligned(void *ptr, u64 old_size, u64 new_size, u64 alignment,
wapp_intern inline void *mem_arena_realloc_aligned(void *ptr, u64 old_size, u64 new_size, u64 alignment,
void *alloc_obj) {
WpArena *arena = (WpArena *)alloc_obj;
return wpMemArenaReallocAligned(arena, ptr, old_size, new_size, alignment);
Arena *arena = (Arena *)alloc_obj;
return wapp_mem_arena_realloc_aligned(arena, ptr, old_size, new_size, alignment);
}
src/os/allocators/arena/mem_arena_allocator.h
+20 -23
View File
@@ -8,39 +8,36 @@
#include "../../../common/platform/platform.h"
#include "../../../base/mem/allocator/mem_allocator.h"
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#define wpMemArenaAllocatorInit(base_capacity) \
(wpMemArenaAllocatorInitCustom(base_capacity, WP_MEM_ALLOC_RESERVE, false))
#define wpMemArenaAllocatorInitCommit(base_capacity) \
(wpMemArenaAllocatorInitCustom(base_capacity, WP_MEM_ALLOC_RESERVE | WP_MEM_ALLOC_COMMIT, false))
#define wpMemArenaAllocatorInitZero(base_capacity) \
(wpMemArenaAllocatorInitCustom(base_capacity, WP_MEM_ALLOC_RESERVE, true))
#define wpMemArenaAllocatorInitCommitAndZero(base_capacity) \
(wpMemArenaAllocatorInitCustom(base_capacity, WP_MEM_ALLOC_RESERVE | WP_MEM_ALLOC_COMMIT, true))
#define wapp_mem_arena_allocator_init(base_capacity) \
(wapp_mem_arena_allocator_init_custom(base_capacity, WAPP_MEM_ALLOC_RESERVE, false))
#define wapp_mem_arena_allocator_init_commit(base_capacity) \
(wapp_mem_arena_allocator_init_custom(base_capacity, WAPP_MEM_ALLOC_RESERVE | WAPP_MEM_ALLOC_COMMIT, false))
#define wapp_mem_arena_allocator_init_zero(base_capacity) \
(wapp_mem_arena_allocator_init_custom(base_capacity, WAPP_MEM_ALLOC_RESERVE, true))
#define wapp_mem_arena_allocator_init_commit_and_zero(base_capacity) \
(wapp_mem_arena_allocator_init_custom(base_capacity, WAPP_MEM_ALLOC_RESERVE | WAPP_MEM_ALLOC_COMMIT, true))
/**
* Wraps a WpArena in a WpAllocator object. It attempts to initialise the WpArena
* Wraps an Arena in an Allocator object. It attempts to initialise the Arena
* and, if successful, defines the operations supported by it to be used by the
* WpAllocator.
* Allocator.
*
* An WpArena allocator only supports normal allocation and aligned allocation.
* An Arena allocator only supports normal allocation and aligned allocation.
* Reallocation, aligned reallocation and freeing aren't implemented.
*
* The `wpMemArenaAllocatorInitCustom` provides the most control over how
* the WpArena is initialised. Wrapper macros are provided for easier use.
* The `wapp_mem_arena_allocator_init_custom` provides the most control over how
* the Arena is initialised. Wrapper macros are provided for easier use.
*/
WpAllocator wpMemArenaAllocatorInitCustom(u64 base_capacity, WpMemAllocFlags flags, b8 zero_buffer);
WpAllocator wpMemArenaAllocatorInitWithBuffer(u8 *buffer, u64 buffer_size);
void wpMemArenaAllocatorTempBegin(const WpAllocator *allocator);
void wpMemArenaAllocatorTempEnd(const WpAllocator *allocator);
void wpMemArenaAllocatorClear(WpAllocator *allocator);
void wpMemArenaAllocatorDestroy(WpAllocator *allocator);
Allocator wapp_mem_arena_allocator_init_custom(u64 base_capacity, MemAllocFlags flags, b8 zero_buffer);
void wapp_mem_arena_allocator_clear(Allocator *allocator);
void wapp_mem_arena_allocator_destroy(Allocator *allocator);
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#endif // !MEM_ARENA_ALLOCATOR_H
src/os/cpath/cpath.c
+42 -41
View File
@@ -8,126 +8,127 @@
#include "../../base/mem/allocator/mem_allocator.h"
#include "../../base/strings/str8/str8.h"
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
u32 wpCpathJoinPath(WpStr8 *dst, const WpStr8List *parts) {
u32 wapp_cpath_join_path(Str8 *dst, const Str8List *parts) {
if (!dst || !parts) {
return WP_CPATH_JOIN_RESULT_INVALID_ARGS;
return CPATH_JOIN_INVALID_ARGS;
}
if (parts->node_count == 0) {
return WP_CPATH_JOIN_RESULT_EMPTY_PARTS;
return CPATH_JOIN_EMPTY_PARTS;
}
WpStr8 separator = wpStr8Buf(4);
wpStr8PushBack(&separator, WP_PATH_SEP);
Str8 separator = wapp_str8_buf(4);
wapp_str8_push_back(&separator, WAPP_PATH_SEP);
u64 required_capacity = parts->node_count * separator.size + wpStr8ListTotalSize(parts);
u64 required_capacity = parts->node_count * separator.size + wapp_str8_list_total_size(parts);
if (dst->capacity < required_capacity) {
return WP_CPATH_JOIN_RESULT_INSUFFICIENT_DST_CAPACITY;
return CPATH_JOIN_INSUFFICIENT_DST_CAPACITY;
}
// Handle first node
WpStr8 *first_node = wpDblListGet(WpStr8, parts, 0);
wpStr8CopyStr8Capped(dst, first_node);
const Str8Node *first_node = wapp_dbl_list_get(Str8, Str8Node, parts, 0);
wapp_str8_copy_str8_capped(dst, first_node->item);
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
WpStr8 *node = first_node;
const Str8Node *node = first_node;
u64 node_index = 1;
b8 running = node_index < parts->node_count;
while (running) {
node = wpDblListGet(WpStr8, parts, node_index);
if (node->size == 0) {
goto CPATH_JOIN_LOOP_END;
while (running && node->next) {
node = node->next;
if (node->item->size == 0) {
continue;
}
if (dst->size > 0) {
char dst_last = wpStr8Get(dst, dst->size - 1);
char node_start = wpStr8Get(node, 0);
b8 add_path_sep = dst_last != WP_PATH_SEP && node_start != WP_PATH_SEP;
char dst_last = wapp_str8_get(dst, dst->size - 1);
char node_start = wapp_str8_get(node->item, 0);
b8 add_path_sep = dst_last != WAPP_PATH_SEP && node_start != WAPP_PATH_SEP;
if (add_path_sep) {
wpStr8ConcatCapped(dst, &separator);
wapp_str8_concat_capped(dst, &separator);
}
}
wpStr8ConcatCapped(dst, node);
wapp_str8_concat_capped(dst, node->item);
CPATH_JOIN_LOOP_END:
++node_index;
running = node_index < parts->node_count;
}
return WP_CPATH_JOIN_RESULT_SUCCESS;
return CPATH_JOIN_SUCCESS;
}
WpStr8 *_dirup(const WpAllocator *allocator, WpStr8RO *path, u64 levels) {
WpStr8 *output = NULL;
Str8 *dirup(const Allocator *allocator, Str8RO *path, u64 levels) {
Str8 *output = NULL;
if (!allocator || !path) {
goto RETURN_DIRUP;
}
b8 absolute = wpStr8Get(path, 0) == WP_PATH_SEP;
WpStr8 separator = wpStr8Buf(4);
wpStr8PushBack(&separator, WP_PATH_SEP);
b8 absolute = wapp_str8_get(path, 0) == WAPP_PATH_SEP;
Str8 separator = wapp_str8_buf(4);
wapp_str8_push_back(&separator, WAPP_PATH_SEP);
if (path->size == 0) {
output = wpStr8AllocBuf(allocator, 16);
output = wapp_str8_alloc_buf(allocator, 16);
if (!output) {
goto RETURN_DIRUP;
}
wpStr8PushBack(output, absolute ? WP_PATH_SEP : '.');
wapp_str8_push_back(output, absolute ? WAPP_PATH_SEP : '.');
goto RETURN_DIRUP;
}
if (levels < 1) {
output = wpStr8AllocStr8(allocator, path);
output = wapp_str8_alloc_str8(allocator, path);
goto RETURN_DIRUP;
}
WpAllocator tmp_arena = wpMemArenaAllocatorInit(MiB(8));
if (wpMemAllocatorInvalid(&tmp_arena)) {
Allocator tmp_arena = wapp_mem_arena_allocator_init(MiB(8));
if (wapp_mem_allocator_invalid(&tmp_arena)) {
goto RETURN_DIRUP;
}
WpStr8List *parts = wpStr8Split(&tmp_arena, path, &separator);
Str8List *parts = wapp_str8_split(&tmp_arena, path, &separator);
if (!parts) {
goto RETURN_DIRUP;
}
if (levels >= parts->node_count) {
output = wpStr8AllocBuf(allocator, 16);
output = wapp_str8_alloc_buf(allocator, 16);
if (!output) {
goto LIST_CLEANUP_DIRUP;
}
wpStr8PushBack(output, absolute ? WP_PATH_SEP : '.');
wapp_str8_push_back(output, absolute ? WAPP_PATH_SEP : '.');
} else {
for (u64 i = 0; i < levels; ++i) {
wpDblListPopBack(WpStr8, parts);
wapp_dbl_list_pop_back(Str8, Str8Node, parts);
}
u64 alignment = sizeof(void *) * 2;
u64 alloc_size = wpStr8ListTotalSize(parts) + parts->node_count * separator.size;
u64 alloc_size = wapp_str8_list_total_size(parts) + parts->node_count * separator.size;
u64 modulo = alloc_size & (alignment - 1);
alloc_size += alignment - modulo;
output = wpStr8AllocBuf(allocator, alloc_size);
output = wapp_str8_alloc_buf(allocator, alloc_size);
if (output) {
if (absolute) {
wpStr8PushBack(output, WP_PATH_SEP);
wapp_str8_push_back(output, WAPP_PATH_SEP);
}
WpStr8 *joined = wpStr8Join(&tmp_arena, parts, &separator);
Str8 *joined = wapp_str8_join(&tmp_arena, parts, &separator);
if (joined) {
wpStr8ConcatCapped(output, joined);
wapp_str8_concat_capped(output, joined);
}
}
}
LIST_CLEANUP_DIRUP:
wpMemArenaAllocatorDestroy(&tmp_arena);
wapp_mem_arena_allocator_destroy(&tmp_arena);
RETURN_DIRUP:
return output;
src/os/cpath/cpath.h
+21 -21
View File
@@ -8,38 +8,38 @@
#include "../../base/mem/allocator/mem_allocator.h"
#include "../../base/strings/str8/str8.h"
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_POSIX
#ifdef WAPP_PLATFORM_POSIX
#include <limits.h>
#define WP_PATH_SEP '/'
#define WP_PATH_MAX PATH_MAX
#elif defined(WP_PLATFORM_WINDOWS)
#define WAPP_PATH_SEP '/'
#define WAPP_PATH_MAX PATH_MAX
#elif defined(WAPP_PLATFORM_WINDOWS)
#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
#define WP_PATH_SEP '\\'
#define WP_PATH_MAX MAX_PATH
#include <windows.h>
#define WAPP_PATH_SEP '\\'
#define WAPP_PATH_MAX MAX_PATH
#else
#error "Unrecognised platform"
#endif
#define wpCpathDirname(ALLOCATOR, PATH) _dirup(ALLOCATOR, PATH, 1)
#define wpCpathDirup(ALLOCATOR, PATH, COUNT) _dirup(ALLOCATOR, PATH, COUNT)
#define wapp_cpath_dirname(ALLOCATOR, PATH) dirup(ALLOCATOR, PATH, 1)
#define wapp_cpath_dirup(ALLOCATOR, PATH, COUNT) dirup(ALLOCATOR, PATH, COUNT)
typedef enum {
WP_CPATH_JOIN_RESULT_SUCCESS = 0,
WP_CPATH_JOIN_RESULT_INVALID_ARGS,
WP_CPATH_JOIN_RESULT_EMPTY_PARTS,
WP_CPATH_JOIN_RESULT_INSUFFICIENT_DST_CAPACITY,
} WpCpathJoinResult;
enum {
CPATH_JOIN_SUCCESS = 0,
CPATH_JOIN_INVALID_ARGS,
CPATH_JOIN_EMPTY_PARTS,
CPATH_JOIN_INSUFFICIENT_DST_CAPACITY,
};
WpCpathJoinResult wpCpathJoinPath(WpStr8 *dst, const WpStr8List *parts);
WpStr8 *_dirup(const WpAllocator *allocator, WpStr8RO *path, u64 levels);
u32 wapp_cpath_join_path(Str8 *dst, const Str8List *parts);
Str8 *dirup(const Allocator *allocator, Str8RO *path, u64 levels);
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#endif // !CPATH_H
src/os/file/file.c
+60 -90
View File
@@ -6,78 +6,69 @@
#include "../../common/aliases/aliases.h"
#include "../../base/array/array.h"
#include "../../base/strings/str8/str8.h"
#include <stdio.h>
WpFile *wpFileOpen(const WpAllocator *allocator, WpStr8RO *filepath, WpFileAccessMode mode) {
wpDebugAssert(allocator != NULL && filepath != NULL, "`allocator` and `filepath` should not be NULL");
wpDebugAssert(filepath->size < WP_PATH_MAX, "`filepath` exceeds max path limit.");
return _fileOpen(allocator, filepath, mode);
File *wapp_file_open(Str8RO *filepath, FileAccessMode mode) {
wapp_persist const char *modes[FILE_ACCESS_MODE_COUNT] = {
[WAPP_FA_MODE_R] = "r",
[WAPP_FA_MODE_W] = "w",
[WAPP_FA_MODE_A] = "a",
[WAPP_FA_MODE_R_EX] = "r+",
[WAPP_FA_MODE_W_EX] = "w+",
[WAPP_FA_MODE_A_EX] = "a+",
[WAPP_FA_MODE_RB] = "rb",
[WAPP_FA_MODE_WB] = "wb",
[WAPP_FA_MODE_AB] = "ab",
[WAPP_FA_MODE_RB_EX] = "rb+",
[WAPP_FA_MODE_WB_EX] = "wb+",
[WAPP_FA_MODE_AB_EX] = "ab+",
[WAPP_FA_MODE_WX] = "wx",
[WAPP_FA_MODE_WX_EX] = "wx+",
[WAPP_FA_MODE_WBX] = "wbx",
[WAPP_FA_MODE_WBX_EX] = "wbx+",
};
wapp_persist c8 tmp[WAPP_PATH_MAX] = {0};
wapp_debug_assert(filepath->size < WAPP_PATH_MAX, "`filepath` exceeds max path limit.");
memset(tmp, 0, WAPP_PATH_MAX);
memcpy(tmp, filepath->buf, filepath->size);
return fopen((const char *)tmp, modes[mode]);
}
i64 wpFileGetCurrentPosition(WpFile *file) {
wpDebugAssert(file != NULL, "`file` should not be NULL.");
return _fileSeek(file, 0, WP_SEEK_CURRENT);
u64 wapp_file_get_current_position(File *file) {
wapp_debug_assert(file != NULL, "`file` should not be NULL.");
return (u64)ftell(file);
}
i64 wpFileSeek(WpFile *file, i64 offset, WpFileSeekOrigin origin) {
wpDebugAssert(file != NULL, "`file` should not be NULL.");
return _fileSeek(file, offset, origin);
i32 wapp_file_seek(File *file, u64 offset, FileSeekOrigin origin) {
wapp_debug_assert(file != NULL, "`file` should not be NULL.");
// TODO (Abdelrahman): Revisit conversion to long
return fseek(file, (long)offset, origin);
}
i64 wpFileGetLength(WpFile *file) {
wpDebugAssert(file != NULL, "`file` should not be NULL.");
u64 wapp_file_get_length(File *file) {
wapp_debug_assert(file != NULL, "`file` should not be NULL.");
i64 current = wpFileGetCurrentPosition(file);
u64 current = wapp_file_get_current_position(file);
_fileSeek(file, 0, WP_SEEK_END);
wapp_file_seek(file, 0, WAPP_SEEK_END);
i64 output = wpFileGetCurrentPosition(file);
u64 output = ftell(file);
// Restore position
_fileSeek(file, current, WP_SEEK_START);
wapp_file_seek(file, current, WAPP_SEEK_START);
return output;
}
u64 wpFileRead(void *dst_buf, WpFile *file, u64 byte_count) {
wpDebugAssert(dst_buf != NULL && file != NULL,
u64 wapp_file_read(GenericArray *dst_buf, File *file, u64 item_count) {
wapp_debug_assert(dst_buf != NULL && file != NULL,
"`dst_buf` and `file` should not be NULL.");
i64 file_length = wpFileGetLength(file);
if (file_length < 0) {
return 0;
}
return _fileRead(dst_buf, byte_count, file, file_length);
}
i64 wpFileWrite(const void *src_buf, WpFile *file, u64 byte_count) {
wpDebugAssert(src_buf != NULL && file != NULL,
"`src_buf` and `file` should not be NULL.");
return _fileWrite(src_buf, file, byte_count);
}
u64 wpFileReadStr8(WpStr8 *str, WpFile *file) {
wpDebugAssert(str != NULL, "`str` should not be NULL.");
return wpFileRead((void *)(str->buf), file, str->size);
}
i64 wpFileWriteStr8(WpStr8RO *str, WpFile *file) {
wpDebugAssert(str != NULL, "`str` should not be NULL.");
return wpFileWrite((void *)(str->buf), file, str->size);
}
u64 wpFileReadArray(WpArray dst_buf, WpFile *file, u64 item_count) {
wpDebugAssert(dst_buf != NULL && file != NULL,
"`dst_buf` and `file` should not be NULL.");
i64 _file_length = wpFileGetLength(file);
if (_file_length < 0) {
return 0;
}
u64 file_length = (u64)_file_length;
u64 item_size = wpArrayItemSize(dst_buf);
u64 dst_byte_capacity = wpArrayCapacity(dst_buf) * item_size;
u64 file_length = wapp_file_get_length(file);
u64 item_size = dst_buf->item_size;
u64 dst_byte_capacity = dst_buf->capacity * item_size;
u64 req_byte_count = item_count * item_size;
u64 copy_byte_count = 0;
@@ -87,53 +78,32 @@ u64 wpFileReadArray(WpArray dst_buf, WpFile *file, u64 item_count) {
copy_byte_count = file_length <= dst_byte_capacity ? file_length : dst_byte_capacity;
}
u64 byte_count = _fileRead(dst_buf, copy_byte_count, file, file_length);
if (byte_count == 0) {
return 0;
}
u64 count = fread(dst_buf->items, sizeof(u8), copy_byte_count, file);
if (ferror(file)) { return 0; }
wpArraySetCount(dst_buf, byte_count / item_size);
dst_buf->count = count / item_size;
return wpArrayCount(dst_buf);
return dst_buf->count;
}
i64 wpFileWriteArray(const WpArray src_buf, WpFile *file, u64 item_count) {
wpDebugAssert(src_buf != NULL && file != NULL,
u64 wapp_file_write(const GenericArray *src_buf, File *file, u64 item_count) {
wapp_debug_assert(src_buf != NULL && file != NULL,
"`src_buf` and `file` should not be NULL.");
u64 item_size = wpArrayItemSize(src_buf);
u64 src_byte_count = wpArrayCount(src_buf) * item_size;
u64 item_size = src_buf->item_size;
u64 src_byte_count = src_buf->count * item_size;
u64 req_byte_count = item_count * item_size;
u64 to_copy = req_byte_count <= src_byte_count ? req_byte_count : src_byte_count;
i64 bytes_written = _fileWrite(src_buf, file, to_copy);
if (bytes_written < 0) {
return 0;
}
return (u64)bytes_written / item_size;
return fwrite(src_buf->items, sizeof(u8), to_copy, file);
}
i32 wpFileFlush(WpFile *file) {
wpDebugAssert(file != NULL, "`file` should not be NULL.");
return _fileFlush(file);
i32 wapp_file_flush(File *file) {
wapp_debug_assert(file != NULL, "`file` should not be NULL.");
return fflush(file);
}
i32 wpFileClose(WpFile *file) {
wpDebugAssert(file != NULL, "`file` should not be NULL.");
return _fileClose(file);
}
i32 wpFileRename(WpStr8RO *old_filepath, WpStr8RO *new_filepath) {
wpDebugAssert(old_filepath != NULL && new_filepath != NULL,
"`old_filepath` and `new_filepath` should not be NULL");
wpDebugAssert(old_filepath->size < WP_PATH_MAX, "`old_filepath` exceeds max path limit.");
wpDebugAssert(new_filepath->size < WP_PATH_MAX, "`new_filepath` exceeds max path limit.");
return _fileRename(old_filepath, new_filepath);
}
i32 wpFileRemove(WpStr8RO *filepath) {
wpDebugAssert(filepath != NULL, "`filepath` should not be NULL");
wpDebugAssert(filepath->size < WP_PATH_MAX, "`filepath` exceeds max path limit.");
return _fileRemove(filepath);
i32 wapp_file_close(File *file) {
wapp_debug_assert(file != NULL, "`file` should not be NULL.");
return fclose(file);
}
src/os/file/file.h
+36 -57
View File
@@ -3,75 +3,54 @@
#ifndef FILE_H
#define FILE_H
#include "../../base/mem/allocator/mem_allocator.h"
#include "../../common/aliases/aliases.h"
#include "../../base/strings/str8/str8.h"
#include <stdio.h>
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
typedef struct WpFile WpFile;
typedef FILE File;
typedef enum {
WP_ACCESS_READ, // Equivalent to r
WP_ACCESS_WRITE, // Equivalent to w
WP_ACCESS_APPEND, // Equivalent to a
WP_ACCESS_READ_EX, // Equivalent to r+
WP_ACCESS_WRITE_EX, // Equivalent to w+
WP_ACCESS_APPEND_EX, // Equivalent to a+
WP_ACCESS_WRITE_FAIL_ON_EXIST, // Equivalent to wx
WP_ACCESS_WRITE_FAIL_ON_EXIST_EX, // Equivalent to wx+
WAPP_FA_MODE_R, // Equivalent to r
WAPP_FA_MODE_W, // Equivalent to w
WAPP_FA_MODE_A, // Equivalent to a
WAPP_FA_MODE_R_EX, // Equivalent to r+
WAPP_FA_MODE_W_EX, // Equivalent to w+
WAPP_FA_MODE_A_EX, // Equivalent to a+
WAPP_FA_MODE_RB, // Equivalent to rb
WAPP_FA_MODE_WB, // Equivalent to wb
WAPP_FA_MODE_AB, // Equivalent to ab
WAPP_FA_MODE_RB_EX, // Equivalent to rb+
WAPP_FA_MODE_WB_EX, // Equivalent to wb+
WAPP_FA_MODE_AB_EX, // Equivalent to ab+
WAPP_FA_MODE_WX, // Equivalent to wx
WAPP_FA_MODE_WX_EX, // Equivalent to wx+
WAPP_FA_MODE_WBX, // Equivalent to wbx
WAPP_FA_MODE_WBX_EX, // Equivalent to wbx+
COUNT_FILE_ACCESS_MODE,
} WpFileAccessMode;
FILE_ACCESS_MODE_COUNT,
} FileAccessMode;
typedef enum {
WP_SEEK_START,
WP_SEEK_CURRENT,
WP_SEEK_END,
WAPP_SEEK_START = SEEK_SET,
WAPP_SEEK_CURRENT = SEEK_CUR,
WAPP_SEEK_END = SEEK_END,
} FileSeekOrigin;
COUNT_FILE_SEEK_ORIGIN,
} WpFileSeekOrigin;
File *wapp_file_open(Str8RO *filename, FileAccessMode mode);
u64 wapp_file_get_current_position(File *file);
i32 wapp_file_seek(File *file, u64 offset, FileSeekOrigin origin);
u64 wapp_file_get_length(File *file);
u64 wapp_file_read(GenericArray *dst_buf, File *file, u64 item_count);
u64 wapp_file_write(const GenericArray *src_buf, File *file, u64 item_count);
i32 wapp_file_flush(File *file);
i32 wapp_file_close(File *file);
// Return value should not be cached as it's not guaranteed to remain the same. Always call
// wpFileStdin to get the standard input stream
wp_extern WpFile *wpFileStdin(void);
// Return value should not be cached as it's not guaranteed to remain the same. Always call
// wpFileStdout to get the standard output stream
wp_extern WpFile *wpFileStdout(void);
// Return value should not be cached as it's not guaranteed to remain the same. Always call
// wpFileStderr to get the standard error stream
wp_extern WpFile *wpFileStderr(void);
WpFile *wpFileOpen(const WpAllocator *allocator, WpStr8RO *filepath, WpFileAccessMode mode);
i64 wpFileGetCurrentPosition(WpFile *file);
i64 wpFileSeek(WpFile *file, i64 offset, WpFileSeekOrigin origin);
i64 wpFileGetLength(WpFile *file);
u64 wpFileRead(void *dst_buf, WpFile *file, u64 byte_count);
i64 wpFileWrite(const void *src_buf, WpFile *file, u64 byte_count);
u64 wpFileReadStr8(WpStr8 *str, WpFile *file);
i64 wpFileWriteStr8(WpStr8RO *str, WpFile *file);
u64 wpFileReadArray(WpArray dst_buf, WpFile *file, u64 item_count);
i64 wpFileWriteArray(const WpArray src_buf, WpFile *file, u64 item_count);
i32 wpFileFlush(WpFile *file);
i32 wpFileClose(WpFile *file);
i32 wpFileRename(WpStr8RO *old_filepath, WpStr8RO *new_filepath);
i32 wpFileRemove(WpStr8RO *filepath);
wp_extern WpFile *_fileOpen(const WpAllocator *allocator, WpStr8RO *filepath, WpFileAccessMode mode);
wp_extern i64 _fileSeek(WpFile *file, i64 offset, WpFileSeekOrigin origin);
wp_extern u64 _fileRead(void *dst_buf, u64 byte_count, WpFile *file, u64 file_length);
wp_extern i64 _fileWrite(const void *src_buf, WpFile *file, u64 byte_count);
wp_extern i32 _fileFlush(WpFile *file);
wp_extern i32 _fileClose(WpFile *file);
wp_extern i32 _fileRename(WpStr8RO *old_filepath, WpStr8RO *new_filepath);
wp_extern i32 _fileRemove(WpStr8RO *filepath);
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#endif // !FILE_H
src/os/file/posix/file_posix.c
-134
View File
@@ -1,134 +0,0 @@
// vim:fileencoding=utf-8:foldmethod=marker
#include "file_posix.h"
#include "../../../common/platform/platform.h"
#ifdef WP_PLATFORM_POSIX
#include "../file.h"
#include "../../cpath/cpath.h"
#include "../../../common/aliases/aliases.h"
#include "../../../base/array/array.h"
#include "../../../base/strings/str8/str8.h"
#ifdef WP_PLATFORM_APPLE
#define _FILE_OFFSET_BITS 64
#define lseek64 lseek
#endif // !WP_PLATFORM_APPLE
#define __USE_LARGEFILE64
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
wp_intern i32 file_flags[COUNT_FILE_ACCESS_MODE] = {
[WP_ACCESS_READ] = O_RDONLY,
[WP_ACCESS_WRITE] = O_WRONLY | O_CREAT,
[WP_ACCESS_APPEND] = O_WRONLY | O_APPEND | O_CREAT,
[WP_ACCESS_READ_EX] = O_RDWR,
[WP_ACCESS_WRITE_EX] = O_RDWR | O_CREAT,
[WP_ACCESS_APPEND_EX] = O_RDWR | O_APPEND | O_CREAT,
[WP_ACCESS_WRITE_FAIL_ON_EXIST] = O_WRONLY | O_CREAT | O_EXCL,
[WP_ACCESS_WRITE_FAIL_ON_EXIST_EX] = O_RDWR | O_CREAT | O_EXCL,
};
wp_intern mode_t file_modes[COUNT_FILE_ACCESS_MODE] = {
[WP_ACCESS_READ] = 0,
[WP_ACCESS_WRITE] = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
[WP_ACCESS_APPEND] = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
[WP_ACCESS_READ_EX] = 0,
[WP_ACCESS_WRITE_EX] = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
[WP_ACCESS_APPEND_EX] = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
[WP_ACCESS_WRITE_FAIL_ON_EXIST] = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
[WP_ACCESS_WRITE_FAIL_ON_EXIST_EX] = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
};
wp_intern i32 file_seek_origins[COUNT_FILE_SEEK_ORIGIN] = {
[WP_SEEK_START] = SEEK_SET,
[WP_SEEK_CURRENT] = SEEK_CUR,
[WP_SEEK_END] = SEEK_END,
};
WpFile *wpFileStdin(void) {
wp_persist WpFile _stdin = { .fd = STDIN_FILENO };
return &_stdin;
}
WpFile *wpFileStdout(void) {
wp_persist WpFile _stdout = { .fd = STDOUT_FILENO };
return &_stdout;
}
WpFile *wpFileStderr(void) {
wp_persist WpFile _stderr = { .fd = STDERR_FILENO };
return &_stderr;
}
WpFile *_fileOpen(const WpAllocator *allocator, WpStr8RO *filepath, WpFileAccessMode mode) {
wp_persist c8 tmp[WP_PATH_MAX] = {0};
memset(tmp, 0, WP_PATH_MAX);
memcpy(tmp, filepath->buf, filepath->size);
i32 fd = open((const char *)tmp, file_flags[mode], file_modes[mode]);
if (fd < 0) {
return NULL;
}
WpFile *output = wpMemAllocatorAlloc(allocator, sizeof(WpFile));
if (output) {
output->fd = fd;
}
return output;
}
i64 _fileSeek(WpFile *file, i64 offset, WpFileSeekOrigin origin) {
return lseek64(file->fd, offset, file_seek_origins[origin]);
}
u64 _fileRead(void *dst_buf, u64 byte_count, WpFile *file, u64 file_length) {
u64 copy_byte_count = file_length <= byte_count ? file_length : byte_count;
i64 count = read(file->fd, dst_buf, copy_byte_count);
if (count < 0) { return 0; }
return count;
}
i64 _fileWrite(const void *src_buf, WpFile *file, u64 byte_count) {
return write(file->fd, src_buf, byte_count);
}
i32 _fileFlush(WpFile *file) {
return fsync(file->fd);
}
i32 _fileClose(WpFile *file) {
return close(file->fd);
}
i32 _fileRename(WpStr8RO *old_filepath, WpStr8RO *new_filepath) {
wp_persist c8 old_tmp[WP_PATH_MAX] = {0};
wp_persist c8 new_tmp[WP_PATH_MAX] = {0};
memset(old_tmp, 0, WP_PATH_MAX);
memcpy(old_tmp, old_filepath->buf, old_filepath->size);
memset(new_tmp, 0, WP_PATH_MAX);
memcpy(new_tmp, new_filepath->buf, new_filepath->size);
i32 link_result = link((const char *)old_tmp, (const char *)new_tmp);
if (link_result == 0) {
_fileRemove(old_filepath);
}
return link_result;
}
i32 _fileRemove(WpStr8RO *filepath) {
wp_persist c8 tmp[WP_PATH_MAX] = {0};
memset(tmp, 0, WP_PATH_MAX);
memcpy(tmp, filepath->buf, filepath->size);
return unlink((const char *)tmp);
}
#endif // !WP_PLATFORM_POSIX
src/os/file/posix/file_posix.h
-27
View File
@@ -1,27 +0,0 @@
// vim:fileencoding=utf-8:foldmethod=marker
#ifndef FILE_POSIX_H
#define FILE_POSIX_H
#include "../../../common/aliases/aliases.h"
#include "../../../common/platform/platform.h"
#ifdef WP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#ifdef WP_PLATFORM_POSIX
#define WP_END_OF_LINE "\n"
struct WpFile {
i32 fd;
};
#endif // !WP_PLATFORM_POSIX
#ifdef WP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !FILE_POSIX_H
src/os/file/win/file_win.c
-177
View File
@@ -1,177 +0,0 @@
// vim:fileencoding=utf-8:foldmethod=marker
#include "file_win.h"
#include "../../../common/platform/platform.h"
#ifdef WP_PLATFORM_WINDOWS
#include "../file.h"
#include "../../cpath/cpath.h"
#include "../../../common/aliases/aliases.h"
#include "../../../base/array/array.h"
#include "../../../base/strings/str8/str8.h"
#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
#include <fileapi.h>
#include <intsafe.h>
wp_intern DWORD file_accesses[COUNT_FILE_ACCESS_MODE] = {
[WP_ACCESS_READ] = FILE_READ_DATA,
[WP_ACCESS_WRITE] = FILE_WRITE_DATA,
[WP_ACCESS_APPEND] = FILE_APPEND_DATA,
[WP_ACCESS_READ_EX] = FILE_READ_DATA | FILE_WRITE_DATA,
[WP_ACCESS_WRITE_EX] = FILE_READ_DATA | FILE_WRITE_DATA,
[WP_ACCESS_APPEND_EX] = FILE_READ_DATA | FILE_APPEND_DATA,
[WP_ACCESS_WRITE_FAIL_ON_EXIST] = FILE_WRITE_DATA,
[WP_ACCESS_WRITE_FAIL_ON_EXIST_EX] = FILE_READ_DATA | FILE_WRITE_DATA,
};
wp_intern DWORD creation_dispositions[COUNT_FILE_ACCESS_MODE] = {
[WP_ACCESS_READ] = OPEN_EXISTING,
[WP_ACCESS_WRITE] = CREATE_ALWAYS,
[WP_ACCESS_APPEND] = OPEN_ALWAYS,
[WP_ACCESS_READ_EX] = OPEN_EXISTING,
[WP_ACCESS_WRITE_EX] = CREATE_ALWAYS,
[WP_ACCESS_APPEND_EX] = OPEN_ALWAYS,
[WP_ACCESS_WRITE_FAIL_ON_EXIST] = CREATE_NEW,
[WP_ACCESS_WRITE_FAIL_ON_EXIST_EX] = CREATE_NEW,
};
wp_intern DWORD sharing_modes[COUNT_FILE_ACCESS_MODE] = {
[WP_ACCESS_READ] = FILE_SHARE_READ | FILE_SHARE_WRITE,
[WP_ACCESS_WRITE] = FILE_SHARE_READ,
[WP_ACCESS_APPEND] = FILE_SHARE_READ,
[WP_ACCESS_READ_EX] = FILE_SHARE_READ | FILE_SHARE_WRITE,
[WP_ACCESS_WRITE_EX] = FILE_SHARE_READ,
[WP_ACCESS_APPEND_EX] = FILE_SHARE_READ,
[WP_ACCESS_WRITE_FAIL_ON_EXIST] = FILE_SHARE_READ,
[WP_ACCESS_WRITE_FAIL_ON_EXIST_EX] = FILE_SHARE_READ,
};
wp_intern DWORD file_seek_origins[COUNT_FILE_SEEK_ORIGIN] = {
[WP_SEEK_START] = FILE_BEGIN,
[WP_SEEK_CURRENT] = FILE_CURRENT,
[WP_SEEK_END] = FILE_END,
};
WpFile *wpFileStdin(void) {
wp_persist WpFile _stdin = { .fh = INVALID_HANDLE_VALUE };
_stdin.fh = GetStdHandle(STD_INPUT_HANDLE);
return &_stdin;
}
WpFile *wpFileStdout(void) {
wp_persist WpFile _stdout = { .fh = INVALID_HANDLE_VALUE };
_stdout.fh = GetStdHandle(STD_OUTPUT_HANDLE);
return &_stdout;
}
WpFile *wpFileStderr(void) {
wp_persist WpFile _stderr = { .fh = INVALID_HANDLE_VALUE };
_stderr.fh = GetStdHandle(STD_ERROR_HANDLE);
return &_stderr;
}
WpFile *_fileOpen(const WpAllocator *allocator, WpStr8RO *filepath, WpFileAccessMode mode) {
wp_persist c8 tmp[WP_PATH_MAX] = {0};
memset(tmp, 0, WP_PATH_MAX);
memcpy(tmp, filepath->buf, filepath->size);
HANDLE fh = CreateFileA((LPCSTR)tmp,
file_accesses[mode],
sharing_modes[mode],
NULL,
creation_dispositions[mode],
FILE_ATTRIBUTE_NORMAL,
NULL);
if (fh == INVALID_HANDLE_VALUE) {
return NULL;
}
WpFile *output = wpMemAllocatorAlloc(allocator, sizeof(WpFile));
if (output) {
output->fh = fh;
}
return output;
}
i64 _fileSeek(WpFile *file, i64 offset, WpFileSeekOrigin origin) {
LARGE_INTEGER distance = {0};
LARGE_INTEGER output = {0};
distance.QuadPart = offset;
if (!SetFilePointerEx(file->fh, distance, &output, file_seek_origins[origin])) {
return -1;
}
return output.QuadPart;
}
u64 _fileRead(void* dst_buf, u64 byte_count, WpFile* file, u64 file_length) {
u64 copy_byte_count = file_length <= byte_count ? file_length : byte_count;
wpDebugAssert(copy_byte_count <= DWORD_MAX, "Attempting to read large number of bytes at once");
DWORD read_count = 0;
if (!ReadFile(file->fh, dst_buf, (DWORD)copy_byte_count, &read_count, NULL)) {
return 0;
}
return (u64)read_count;
}
i64 _fileWrite(const void *src_buf, WpFile *file, u64 byte_count) {
wpDebugAssert(byte_count <= DWORD_MAX, "Attempting to write large number of bytes at once");
DWORD write_count = 0;
if (!WriteFile(file->fh, src_buf, (DWORD)byte_count, &write_count, NULL)) {
return 0;
}
return (i64)write_count;
}
i32 _fileFlush(WpFile *file) {
if (!FlushFileBuffers(file->fh)) {
return -1;
}
return 0;
}
i32 _fileClose(WpFile *file) {
if (!CloseHandle(file->fh)) {
return -1;
}
return 0;
}
i32 _fileRename(WpStr8RO *old_filepath, WpStr8RO *new_filepath) {
wp_persist c8 old_tmp[WP_PATH_MAX] = {0};
wp_persist c8 new_tmp[WP_PATH_MAX] = {0};
memset(old_tmp, 0, WP_PATH_MAX);
memcpy(old_tmp, old_filepath->buf, old_filepath->size);
memset(new_tmp, 0, WP_PATH_MAX);
memcpy(new_tmp, new_filepath->buf, new_filepath->size);
if (!MoveFile((LPCSTR)old_tmp, (LPCSTR)new_tmp)) {
return -1;
}
return 0;
}
i32 _fileRemove(WpStr8RO *filepath) {
wp_persist c8 tmp[WP_PATH_MAX] = {0};
memset(tmp, 0, WP_PATH_MAX);
memcpy(tmp, filepath->buf, filepath->size);
if (!DeleteFile((LPCSTR)tmp)) {
return -1;
}
return 0;
}
#endif // !WP_PLATFORM_WINDOWS
src/os/file/win/file_win.h
-31
View File
@@ -1,31 +0,0 @@
// vim:fileencoding=utf-8:foldmethod=marker
#ifndef FILE_WIN_H
#define FILE_WIN_H
#include "../../../common/aliases/aliases.h"
#include "../../../common/platform/platform.h"
#ifdef WP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#ifdef WP_PLATFORM_WINDOWS
#define WP_END_OF_LINE "\r\n"
#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
#include <fileapi.h>
struct WpFile {
HANDLE fh;
};
#endif // !WP_PLATFORM_WINDOWS
#ifdef WP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !FILE_WIN_H
src/os/mem/mem_os.c
+7 -7
View File
@@ -7,24 +7,24 @@
#include <assert.h>
#include <string.h>
#if defined(WP_PLATFORM_WINDOWS)
#if defined(WAPP_PLATFORM_WINDOWS)
#include "win/mem_os_win.h"
#elif defined(WP_PLATFORM_POSIX)
#elif defined(WAPP_PLATFORM_POSIX)
#include "posix/mem_os_posix.h"
#else
#error "Unrecognised platform"
#endif
void *wpOsMemAlloc(void *addr, u64 size, WpMemAccess access, WpMemAllocFlags flags, WpMemInitType type) {
void *output = _osMemAllocate(addr, size, access, flags, type);
void *wapp_mem_util_alloc(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type) {
void *output = mem_util_allocate(addr, size, access, flags, type);
if (type == WP_MEM_INIT_INITIALISED) {
if (type == WAPP_MEM_INIT_INITIALISED) {
memset(output, 0, size);
}
return output;
}
void wpOsMemFree(void *ptr, u64 size) {
_osMemFree(ptr, size);
void wapp_mem_util_free(void *ptr, u64 size) {
mem_util_free(ptr, size);
}
src/os/mem/mem_os.h
+10 -10
View File
@@ -8,26 +8,26 @@
#include "mem_os_ops.h"
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#if defined(WP_PLATFORM_WINDOWS)
#if defined(WAPP_PLATFORM_WINDOWS)
#include "win/mem_os_win.h"
#elif defined(WP_PLATFORM_POSIX)
#elif defined(WAPP_PLATFORM_POSIX)
#include "posix/mem_os_posix.h"
#else
#error "Unrecognised platform"
#endif
void *wpOsMemAlloc(void *addr, u64 size, WpMemAccess access, WpMemAllocFlags flags, WpMemInitType type);
void wpOsMemFree(void *ptr, u64 size);
void *wapp_mem_util_alloc(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type);
void wapp_mem_util_free(void *ptr, u64 size);
wp_extern void *_osMemAllocate(void *addr, u64 size, WpMemAccess access, WpMemAllocFlags flags, WpMemInitType type);
wp_extern void _osMemFree(void *ptr, u64 size);
wapp_extern void *mem_util_allocate(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type);
wapp_extern void mem_util_free(void *ptr, u64 size);
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#endif // !MEM_OS_H
src/os/mem/mem_os_ops.h
+16 -16
View File
@@ -5,26 +5,26 @@
#include "../../common/platform/platform.h"
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
typedef enum {
WP_MEM_ACCESS_NONE,
WP_MEM_ACCESS_READ_ONLY,
WP_MEM_ACCESS_EXEC_ONLY,
WP_MEM_ACCESS_READ_WRITE,
WP_MEM_ACCESS_READ_EXEC,
WP_MEM_ACCESS_READ_WRITE_EXEC,
} WpMemAccess;
typedef enum mem_access {
WAPP_MEM_ACCESS_NONE,
WAPP_MEM_ACCESS_READ_ONLY,
WAPP_MEM_ACCESS_EXEC_ONLY,
WAPP_MEM_ACCESS_READ_WRITE,
WAPP_MEM_ACCESS_READ_EXEC,
WAPP_MEM_ACCESS_READ_WRITE_EXEC,
} MemAccess;
typedef enum {
WP_MEM_INIT_UNINITIALISED,
WP_MEM_INIT_INITIALISED,
} WpMemInitType;
typedef enum mem_init_type {
WAPP_MEM_INIT_UNINITIALISED,
WAPP_MEM_INIT_INITIALISED,
} MemInitType;
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#endif // !MEM_OS_OPS_H
src/os/mem/posix/mem_os_posix.c
+12 -12
View File
@@ -3,34 +3,34 @@
#include "../../../common/aliases/aliases.h"
#include "../../../common/platform/platform.h"
#ifdef WP_PLATFORM_POSIX
#ifdef WAPP_PLATFORM_POSIX
#include "mem_os_posix.h"
#include "../mem_os_ops.h"
#include <sys/mman.h>
wp_intern const i32 access_types[] = {
[WP_MEM_ACCESS_NONE] = PROT_NONE,
[WP_MEM_ACCESS_READ_ONLY] = PROT_READ,
[WP_MEM_ACCESS_EXEC_ONLY] = PROT_EXEC,
[WP_MEM_ACCESS_READ_WRITE] = PROT_READ | PROT_WRITE,
[WP_MEM_ACCESS_READ_EXEC] = PROT_READ | PROT_EXEC,
[WP_MEM_ACCESS_READ_WRITE_EXEC] = PROT_READ | PROT_WRITE | PROT_EXEC,
wapp_intern const i32 access_types[] = {
[WAPP_MEM_ACCESS_NONE] = PROT_NONE,
[WAPP_MEM_ACCESS_READ_ONLY] = PROT_READ,
[WAPP_MEM_ACCESS_EXEC_ONLY] = PROT_EXEC,
[WAPP_MEM_ACCESS_READ_WRITE] = PROT_READ | PROT_WRITE,
[WAPP_MEM_ACCESS_READ_EXEC] = PROT_READ | PROT_EXEC,
[WAPP_MEM_ACCESS_READ_WRITE_EXEC] = PROT_READ | PROT_WRITE | PROT_EXEC,
};
void *_osMemAllocate(void *addr, u64 size, WpMemAccess access, WpMemAllocFlags flags, WpMemInitType type) {
void *mem_util_allocate(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type) {
(void)type;
i32 alloc_flags = flags | MAP_ANON | MAP_PRIVATE;
#if defined(WP_PLATFORM_LINUX) || defined(WP_PLATFORM_GNU) || defined(WP_PLATFORM_NET_BSD)
#if defined(WAPP_PLATFORM_LINUX) || defined(WAPP_PLATFORM_GNU) || defined(WAPP_PLATFORM_NET_BSD)
alloc_flags |= MAP_NORESERVE;
#endif
return mmap(addr, size, access_types[access], alloc_flags, -1, 0);
}
void _osMemFree(void *ptr, u64 size) {
void mem_util_free(void *ptr, u64 size) {
munmap(ptr, size);
}
#endif // !WP_PLATFORM_POSIX
#endif // !WAPP_PLATFORM_POSIX
src/os/mem/posix/mem_os_posix.h
+17 -17
View File
@@ -5,31 +5,31 @@
#include "../../../common/platform/platform.h"
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_POSIX
#ifdef WAPP_PLATFORM_POSIX
#include <sys/mman.h>
typedef enum {
#if defined(WP_PLATFORM_LINUX) || defined(WP_PLATFORM_GNU)
WP_MEM_ALLOC_RESERVE = 0,
WP_MEM_ALLOC_COMMIT = MAP_POPULATE,
#elif defined(WP_PLATFORM_FREE_BSD)
WP_MEM_ALLOC_RESERVE = 0,
WP_MEM_ALLOC_COMMIT = MAP_PREFAULT_READ,
#elif defined(WP_PLATFORM_BSD) || defined(WP_PLATFORM_UNIX) || defined(WP_PLATFORM_APPLE)
WP_MEM_ALLOC_RESERVE = 0,
WP_MEM_ALLOC_COMMIT = 0,
typedef enum mem_alloc_flags {
#if defined(WAPP_PLATFORM_LINUX) || defined(WAPP_PLATFORM_GNU)
WAPP_MEM_ALLOC_RESERVE = 0,
WAPP_MEM_ALLOC_COMMIT = MAP_POPULATE,
#elif defined(WAPP_PLATFORM_FREE_BSD)
WAPP_MEM_ALLOC_RESERVE = 0,
WAPP_MEM_ALLOC_COMMIT = MAP_PREFAULT_READ,
#elif defined(WAPP_PLATFORM_BSD) || defined(WAPP_PLATFORM_UNIX) || defined(WAPP_PLATFORM_APPLE)
WAPP_MEM_ALLOC_RESERVE = 0,
WAPP_MEM_ALLOC_COMMIT = 0,
#endif
} WpMemAllocFlags;
} MemAllocFlags;
#endif // !WP_PLATFORM_POSIX
#endif // !WAPP_PLATFORM_POSIX
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#endif // !MEM_OS_POSIX_H
src/os/mem/win/mem_os_win.c
+13 -13
View File
@@ -3,7 +3,7 @@
#include "../../../common/aliases/aliases.h"
#include "../../../common/platform/platform.h"
#ifdef WP_PLATFORM_WINDOWS
#ifdef WAPP_PLATFORM_WINDOWS
#include "mem_os_win.h"
#include "../mem_os_ops.h"
@@ -12,26 +12,26 @@
#include <Windows.h>
#include <memoryapi.h>
wp_intern const i32 access_types[] = {
[WP_MEM_ACCESS_NONE] = PAGE_NOACCESS,
[WP_MEM_ACCESS_READ_ONLY] = PAGE_READONLY,
[WP_MEM_ACCESS_EXEC_ONLY] = PAGE_EXECUTE,
[WP_MEM_ACCESS_READ_WRITE] = PAGE_READWRITE,
[WP_MEM_ACCESS_READ_EXEC] = PAGE_EXECUTE_READ,
[WP_MEM_ACCESS_READ_WRITE_EXEC] = PAGE_EXECUTE_READWRITE,
wapp_intern const i32 access_types[] = {
[WAPP_MEM_ACCESS_NONE] = PAGE_NOACCESS,
[WAPP_MEM_ACCESS_READ_ONLY] = PAGE_READONLY,
[WAPP_MEM_ACCESS_EXEC_ONLY] = PAGE_EXECUTE,
[WAPP_MEM_ACCESS_READ_WRITE] = PAGE_READWRITE,
[WAPP_MEM_ACCESS_READ_EXEC] = PAGE_EXECUTE_READ,
[WAPP_MEM_ACCESS_READ_WRITE_EXEC] = PAGE_EXECUTE_READWRITE,
};
void *_osMemAllocate(void *addr, u64 size, WpMemAccess access, WpMemAllocFlags flags, WpMemInitType type) {
void *mem_util_allocate(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type) {
// Ensure memory is committed if it's meant to be initialised
if (type == WP_MEM_INIT_INITIALISED) {
flags |= WP_MEM_ALLOC_COMMIT;
if (type == WAPP_MEM_INIT_INITIALISED) {
flags |= WAPP_MEM_ALLOC_COMMIT;
}
return VirtualAlloc(addr, (SIZE_T)size, flags, access_types[access]);
}
void _osMemFree(void *ptr, u64 size) {
void mem_util_free(void *ptr, u64 size) {
VirtualFree(ptr, size, MEM_RELEASE);
}
#endif // !WP_PLATFORM_WINDOWS
#endif // !WAPP_PLATFORM_WINDOWS
src/os/mem/win/mem_os_win.h
+10 -10
View File
@@ -5,25 +5,25 @@
#include "../../../common/platform/platform.h"
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_WINDOWS
#ifdef WAPP_PLATFORM_WINDOWS
#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
#include <memoryapi.h>
typedef enum {
WP_MEM_ALLOC_RESERVE = MEM_RESERVE,
WP_MEM_ALLOC_COMMIT = MEM_COMMIT,
} WpMemAllocFlags;
typedef enum mem_alloc_flags {
WAPP_MEM_ALLOC_RESERVE = MEM_RESERVE,
WAPP_MEM_ALLOC_COMMIT = MEM_COMMIT,
} MemAllocFlags;
#endif // !WP_PLATFORM_WINDOWS
#endif // !WAPP_PLATFORM_WINDOWS
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#endif // !MEM_OS_WIN_H
src/os/shell/commander/commander.c
+38 -38
View File
@@ -17,85 +17,85 @@
#define CMD_BUF_LEN 8192
#define OUT_BUF_LEN 4096
wp_intern WpCmdResult executeCommand(WpStr8RO *cmd, WpCmdOutHandling out_handling, WpStr8 *out_buf);
wp_intern WpCmdError getCommandOutput(FILE *fp, WpCmdOutHandling out_handling, WpStr8 *out_buf);
wapp_intern inline CMDResult execute_command(Str8RO *cmd, CMDOutHandling out_handling, Str8 *out_buf);
wapp_intern inline CMDError get_command_output(FILE *fp, CMDOutHandling out_handling, Str8 *out_buf);
WpCmdResult wpShellCommanderExecute(WpCmdOutHandling out_handling, WpStr8 *out_buf, const WpStr8List *cmd) {
CMDResult wapp_shell_commander_execute(CMDOutHandling out_handling, Str8 *out_buf, const Str8List *cmd) {
if (!cmd) {
return wpCmdNoExit(WP_SHELL_ERR_INVALID_ARGS);
return CMD_NO_EXIT(SHELL_ERR_INVALID_ARGS);
}
WpAllocator arena = wpMemArenaAllocatorInit(KiB(500));
Allocator arena = wapp_mem_arena_allocator_init(KiB(500));
WpStr8 *cmd_str = wpStr8Join(&arena, cmd, &wpStr8LitRo(" "));
Str8 *cmd_str = wapp_str8_join(&arena, cmd, &wapp_str8_lit_ro(" "));
if (!cmd_str) {
wpMemArenaAllocatorDestroy(&arena);
return wpCmdNoExit(WP_SHELL_ERR_ALLOCATION_FAIL);
wapp_mem_arena_allocator_destroy(&arena);
return CMD_NO_EXIT(SHELL_ERR_ALLOCATION_FAIL);
}
// Redirect output
cmd_str = wpStr8AllocConcat(&arena, cmd_str, &wpStr8LitRo(" 2>&1"));
cmd_str = wapp_str8_alloc_concat(&arena, cmd_str, &wapp_str8_lit_ro(" 2>&1"));
WpCmdResult output = executeCommand(cmd_str, out_handling, out_buf);
CMDResult output = execute_command(cmd_str, out_handling, out_buf);
wpMemArenaAllocatorDestroy(&arena);
wapp_mem_arena_allocator_destroy(&arena);
return output;
}
wp_intern WpCmdResult executeCommand(WpStr8RO *cmd, WpCmdOutHandling out_handling, WpStr8 *out_buf) {
wapp_intern inline CMDResult execute_command(Str8RO *cmd, CMDOutHandling out_handling, Str8 *out_buf) {
char cmd_buf[CMD_BUF_LEN] = {0};
wpStr8CopyToCstr(cmd_buf, cmd, CMD_BUF_LEN);
wapp_str8_copy_to_cstr(cmd_buf, cmd, CMD_BUF_LEN);
FILE *fp = wpShellUtilsPopen(cmd_buf, "r");
FILE *fp = wapp_shell_utils_popen(cmd_buf, "r");
if (!fp) {
return wpCmdNoExit(WP_SHELL_ERR_PROC_START_FAIL);
return CMD_NO_EXIT(SHELL_ERR_PROC_START_FAIL);
}
WpCmdResult output;
CMDResult output;
WpCmdError err = getCommandOutput(fp, out_handling, out_buf);
if (err > WP_SHELL_ERR_NO_ERROR) {
output = wpCmdNoExit(err);
goto executeCommand_CLOSE;
CMDError err = get_command_output(fp, out_handling, out_buf);
if (err > SHELL_ERR_NO_ERROR) {
output = CMD_NO_EXIT(err);
goto EXECUTE_COMMAND_CLOSE;
}
i32 st = EXIT_SUCCESS;
err = _getOutputStatus(fp, &st);
if (err > WP_SHELL_ERR_NO_ERROR) {
output = wpCmdNoExit(err);
goto executeCommand_CLOSE;
err = get_output_status(fp, &st);
if (err > SHELL_ERR_NO_ERROR) {
output = CMD_NO_EXIT(err);
goto EXECUTE_COMMAND_CLOSE;
}
// Process is already closed in _getOutputStatus
// Process is already closed in get_output_status
fp = NULL;
output = (WpCmdResult){
output = (CMDResult){
.exited = true,
.exit_code = st,
.error = WP_SHELL_ERR_NO_ERROR,
.error = SHELL_ERR_NO_ERROR,
};
executeCommand_CLOSE:
EXECUTE_COMMAND_CLOSE:
if (fp) {
wpShellUtilsPclose(fp);
wapp_shell_utils_pclose(fp);
}
return output;
}
wp_intern WpCmdError getCommandOutput(FILE *fp, WpCmdOutHandling out_handling, WpStr8 *out_buf) {
WpStr8 out = wpStr8Buf(OUT_BUF_LEN);
wapp_intern inline CMDError get_command_output(FILE *fp, CMDOutHandling out_handling, Str8 *out_buf) {
Str8 out = wapp_str8_buf(OUT_BUF_LEN);
out.size = fread((void *)out.buf, sizeof(c8), out.capacity, fp);
if (out_handling == WP_SHELL_OUTPUT_CAPTURE && out_buf != NULL) {
out.size = fread((void *)out.buf, sizeof(u8), out.capacity, fp);
if (out_handling == SHELL_OUTPUT_CAPTURE && out_buf != NULL) {
if (out.size >= out_buf->capacity) {
return WP_SHELL_ERR_OUT_BUF_FULL;
return SHELL_ERR_OUT_BUF_FULL;
}
wpStr8ConcatCapped(out_buf, &out);
} else if (out_handling == WP_SHELL_OUTPUT_PRINT) {
printf(WP_STR8_SPEC, wpStr8Varg(out));
wapp_str8_concat_capped(out_buf, &out);
} else if (out_handling == SHELL_OUTPUT_PRINT) {
printf(WAPP_STR8_SPEC, wapp_str8_varg(out));
}
return WP_SHELL_ERR_NO_ERROR;
return SHELL_ERR_NO_ERROR;
}
src/os/shell/commander/commander.h
+7 -9
View File
@@ -10,20 +10,18 @@
#include <stdio.h>
#include <stdlib.h>
// TODO (Abdelrahman): This module needs rethinking
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#define wpCmdNoExit(ERR) ((WpCmdResult){.exited = false, .exit_code = EXIT_FAILURE, .error = ERR})
#define CMD_NO_EXIT(ERR) ((CMDResult){.exited = false, .exit_code = EXIT_FAILURE, .error = ERR})
WpCmdResult wpShellCommanderExecute(WpCmdOutHandling out_handling, WpStr8 *out_buf, const WpStr8List *cmd);
CMDResult wapp_shell_commander_execute(CMDOutHandling out_handling, Str8 *out_buf, const Str8List *cmd);
wp_extern WpCmdError _getOutputStatus(FILE *fp, i32 *status_out);
wapp_extern CMDError get_output_status(FILE *fp, i32 *status_out);
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#endif // !COMMANDER_H
src/os/shell/commander/commander_output.h
+22 -20
View File
@@ -5,38 +5,40 @@
#include "../../../common/aliases/aliases.h"
#include "../../../common/platform/platform.h"
#include "../../../common/misc/misc_utils.h"
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
typedef enum {
WP_SHELL_OUTPUT_DISCARD,
WP_SHELL_OUTPUT_PRINT,
WP_SHELL_OUTPUT_CAPTURE,
} WpCmdOutHandling;
SHELL_OUTPUT_DISCARD,
SHELL_OUTPUT_PRINT,
SHELL_OUTPUT_CAPTURE,
} CMDOutHandling;
typedef enum {
WP_SHELL_ERR_NO_ERROR,
WP_SHELL_ERR_INVALID_ARGS,
WP_SHELL_ERR_ALLOCATION_FAIL,
WP_SHELL_ERR_PROC_START_FAIL,
WP_SHELL_ERR_OUT_BUF_FULL,
WP_SHELL_ERR_PROC_EXIT_FAIL,
} WpCmdError;
SHELL_ERR_NO_ERROR,
SHELL_ERR_INVALID_ARGS,
SHELL_ERR_ALLOCATION_FAIL,
SHELL_ERR_PROC_START_FAIL,
SHELL_ERR_OUT_BUF_FULL,
SHELL_ERR_PROC_EXIT_FAIL,
} CMDError;
typedef struct WpCmdResult WpCmdResult;
struct WpCmdResult {
typedef struct commander_result CMDResult;
struct commander_result {
i32 exit_code;
WpCmdError error;
CMDError error;
b8 exited;
wpMiscUtilsReservePadding(sizeof(b8) + sizeof(i32) + sizeof(WpCmdError));
#ifdef WAPP_PLATFORM_WINDOWS
#include "../../../../common/misc/misc_utils.h"
wapp_misc_utils_padding_size(sizeof(b8) + sizeof(i32) + sizeof(CMDError));
#endif // !WAPP_PLATFORM_WINDOWS
};
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#endif // !COMMANDER_OUTPUT_H
src/os/shell/commander/posix/commander_posix.c
+6 -6
View File
@@ -3,23 +3,23 @@
#include "../../../../common/aliases/aliases.h"
#include "../../../../common/platform/platform.h"
#ifdef WP_PLATFORM_POSIX
#ifdef WAPP_PLATFORM_POSIX
#include "../commander_output.h"
#include "../../utils/shell_utils.h"
#include <stdio.h>
#include <stdlib.h>
WpCmdError _getOutputStatus(FILE *fp, i32 *status_out) {
*status_out = wpShellUtilsPclose(fp);
CMDError get_output_status(FILE *fp, i32 *status_out) {
*status_out = wapp_shell_utils_pclose(fp);
if (!WIFEXITED(*status_out)) {
return WP_SHELL_ERR_PROC_EXIT_FAIL;
return SHELL_ERR_PROC_EXIT_FAIL;
}
*status_out = WEXITSTATUS(*status_out);
return WP_SHELL_ERR_NO_ERROR;
return SHELL_ERR_NO_ERROR;
}
#endif // !WP_PLATFORM_POSIX
#endif // !WAPP_PLATFORM_POSIX
src/os/shell/commander/win/commander_win.c
+7 -7
View File
@@ -3,22 +3,22 @@
#include "../../../../common/aliases/aliases.h"
#include "../../../../common/platform/platform.h"
#ifdef WP_PLATFORM_WINDOWS
#ifdef WAPP_PLATFORM_WINDOWS
#include "../commander_output.h"
#include "../../utils/shell_utils.h"
#include <stdio.h>
WpCmdError _getOutputStatus(FILE *fp, i32 *status_out) {
CMDError get_output_status(FILE *fp, i32 *status_out) {
if (!feof(fp)) {
// Ensure process is closed on failure
wpShellUtilsPclose(fp);
return WP_SHELL_ERR_PROC_EXIT_FAIL;
wapp_shell_utils_pclose(fp);
return SHELL_ERR_PROC_EXIT_FAIL;
}
*status_out = wpShellUtilsPclose(fp);
*status_out = wapp_shell_utils_pclose(fp);
return WP_SHELL_ERR_NO_ERROR;
return SHELL_ERR_NO_ERROR;
}
#endif // !WP_PLATFORM_WINDOWS
#endif // !WAPP_PLATFORM_WINDOWS
src/os/shell/termcolour/posix/termcolour_posix.c
+22 -22
View File
@@ -4,33 +4,33 @@
#include "../../../../common/platform/platform.h"
#include "../../../../base/strings/str8/str8.h"
#ifdef WP_PLATFORM_POSIX
#ifdef WAPP_PLATFORM_POSIX
#include "../terminal_colours.h"
#include <stdio.h>
wp_intern WpStr8RO colours[COUNT_TERM_COLOUR] = {
[WP_TERM_COLOUR_FG_BLACK] = wpStr8LitRoInitialiserList("\033[30m"),
[WP_TERM_COLOUR_FG_RED] = wpStr8LitRoInitialiserList("\033[31m"),
[WP_TERM_COLOUR_FG_GREEN] = wpStr8LitRoInitialiserList("\033[32m"),
[WP_TERM_COLOUR_FG_BLUE] = wpStr8LitRoInitialiserList("\033[34m"),
[WP_TERM_COLOUR_FG_CYAN] = wpStr8LitRoInitialiserList("\033[36m"),
[WP_TERM_COLOUR_FG_MAGENTA] = wpStr8LitRoInitialiserList("\033[35m"),
[WP_TERM_COLOUR_FG_YELLOW] = wpStr8LitRoInitialiserList("\033[33m"),
[WP_TERM_COLOUR_FG_WHITE] = wpStr8LitRoInitialiserList("\033[37m"),
[WP_TERM_COLOUR_FG_BR_BLACK] = wpStr8LitRoInitialiserList("\033[90m"),
[WP_TERM_COLOUR_FG_BR_RED] = wpStr8LitRoInitialiserList("\033[91m"),
[WP_TERM_COLOUR_FG_BR_GREEN] = wpStr8LitRoInitialiserList("\033[92m"),
[WP_TERM_COLOUR_FG_BR_BLUE] = wpStr8LitRoInitialiserList("\033[94m"),
[WP_TERM_COLOUR_FG_BR_CYAN] = wpStr8LitRoInitialiserList("\033[96m"),
[WP_TERM_COLOUR_FG_BR_MAGENTA] = wpStr8LitRoInitialiserList("\033[95m"),
[WP_TERM_COLOUR_FG_BR_YELLOW] = wpStr8LitRoInitialiserList("\033[93m"),
[WP_TERM_COLOUR_FG_BR_WHITE] = wpStr8LitRoInitialiserList("\033[97m"),
[WP_TERM_COLOUR_CLEAR] = wpStr8LitRoInitialiserList("\033[0m"),
wapp_intern Str8RO colours[COUNT_TERM_COLOUR] = {
[WAPP_TERM_COLOUR_FG_BLACK] = wapp_str8_lit_ro_initialiser_list("\033[30m"),
[WAPP_TERM_COLOUR_FG_RED] = wapp_str8_lit_ro_initialiser_list("\033[31m"),
[WAPP_TERM_COLOUR_FG_GREEN] = wapp_str8_lit_ro_initialiser_list("\033[32m"),
[WAPP_TERM_COLOUR_FG_BLUE] = wapp_str8_lit_ro_initialiser_list("\033[34m"),
[WAPP_TERM_COLOUR_FG_CYAN] = wapp_str8_lit_ro_initialiser_list("\033[36m"),
[WAPP_TERM_COLOUR_FG_MAGENTA] = wapp_str8_lit_ro_initialiser_list("\033[35m"),
[WAPP_TERM_COLOUR_FG_YELLOW] = wapp_str8_lit_ro_initialiser_list("\033[33m"),
[WAPP_TERM_COLOUR_FG_WHITE] = wapp_str8_lit_ro_initialiser_list("\033[37m"),
[WAPP_TERM_COLOUR_FG_BR_BLACK] = wapp_str8_lit_ro_initialiser_list("\033[90m"),
[WAPP_TERM_COLOUR_FG_BR_RED] = wapp_str8_lit_ro_initialiser_list("\033[91m"),
[WAPP_TERM_COLOUR_FG_BR_GREEN] = wapp_str8_lit_ro_initialiser_list("\033[92m"),
[WAPP_TERM_COLOUR_FG_BR_BLUE] = wapp_str8_lit_ro_initialiser_list("\033[94m"),
[WAPP_TERM_COLOUR_FG_BR_CYAN] = wapp_str8_lit_ro_initialiser_list("\033[96m"),
[WAPP_TERM_COLOUR_FG_BR_MAGENTA] = wapp_str8_lit_ro_initialiser_list("\033[95m"),
[WAPP_TERM_COLOUR_FG_BR_YELLOW] = wapp_str8_lit_ro_initialiser_list("\033[93m"),
[WAPP_TERM_COLOUR_FG_BR_WHITE] = wapp_str8_lit_ro_initialiser_list("\033[97m"),
[WAPP_TERM_COLOUR_CLEAR] = wapp_str8_lit_ro_initialiser_list("\033[0m"),
};
void _printColouredText(WpStr8RO *text, WpTerminalColour colour) {
printf(WP_STR8_SPEC WP_STR8_SPEC, wpStr8Varg(colours[colour]), wpStr8Varg((*text)));
void print_coloured_text(Str8RO *text, TerminalColour colour) {
printf(WAPP_STR8_SPEC WAPP_STR8_SPEC, wapp_str8_varg(colours[colour]), wapp_str8_varg((*text)));
}
#endif // !WP_PLATFORM_POSIX
#endif // !WAPP_PLATFORM_POSIX
src/os/shell/termcolour/termcolour.c
+6 -6
View File
@@ -4,15 +4,15 @@
#include "terminal_colours.h"
#include "../../../base/strings/str8/str8.h"
void wpShellTermcolourPrintText(WpStr8RO *text, WpTerminalColour colour) {
if (colour < WP_TERM_COLOUR_FG_BLACK || colour > WP_TERM_COLOUR_FG_BR_WHITE) {
void wapp_shell_termcolour_print_text(Str8RO *text, TerminalColour colour) {
if (colour < WAPP_TERM_COLOUR_FG_BLACK || colour > WAPP_TERM_COLOUR_FG_BR_WHITE) {
return;
}
_printColouredText(text, colour);
print_coloured_text(text, colour);
}
void wpShellTermcolourClearColour(void) {
WpStr8RO empty = wpStr8LitRo("");
_printColouredText(&empty, WP_TERM_COLOUR_CLEAR);
void wapp_shell_termcolour_clear_colour(void) {
Str8RO empty = wapp_str8_lit_ro("");
print_coloured_text(&empty, WAPP_TERM_COLOUR_CLEAR);
}
src/os/shell/termcolour/termcolour.h
+7 -9
View File
@@ -8,19 +8,17 @@
#include "../../../common/platform/platform.h"
#include "../../../base/strings/str8/str8.h"
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
// TODO (Abdelrahman): Look into moving away from stdio in the implementation
void wapp_shell_termcolour_print_text(Str8RO *text, TerminalColour colour);
void wapp_shell_termcolour_clear_colour(void);
void wpShellTermcolourPrintText(WpStr8RO *text, WpTerminalColour colour);
void wpShellTermcolourClearColour(void);
wapp_extern void print_coloured_text(Str8RO *text, TerminalColour colour);
wp_extern void _printColouredText(WpStr8RO *text, WpTerminalColour colour);
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#endif // !TERM_COLOUR_H
src/os/shell/termcolour/terminal_colours.h
+22 -22
View File
@@ -6,34 +6,34 @@
#include "../../../common/aliases/aliases.h"
#include "../../../common/platform/platform.h"
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
typedef enum {
WP_TERM_COLOUR_FG_BLACK,
WP_TERM_COLOUR_FG_RED,
WP_TERM_COLOUR_FG_GREEN,
WP_TERM_COLOUR_FG_BLUE,
WP_TERM_COLOUR_FG_CYAN,
WP_TERM_COLOUR_FG_MAGENTA,
WP_TERM_COLOUR_FG_YELLOW,
WP_TERM_COLOUR_FG_WHITE,
WP_TERM_COLOUR_FG_BR_BLACK,
WP_TERM_COLOUR_FG_BR_RED,
WP_TERM_COLOUR_FG_BR_GREEN,
WP_TERM_COLOUR_FG_BR_BLUE,
WP_TERM_COLOUR_FG_BR_CYAN,
WP_TERM_COLOUR_FG_BR_MAGENTA,
WP_TERM_COLOUR_FG_BR_YELLOW,
WP_TERM_COLOUR_FG_BR_WHITE,
WP_TERM_COLOUR_CLEAR,
WAPP_TERM_COLOUR_FG_BLACK,
WAPP_TERM_COLOUR_FG_RED,
WAPP_TERM_COLOUR_FG_GREEN,
WAPP_TERM_COLOUR_FG_BLUE,
WAPP_TERM_COLOUR_FG_CYAN,
WAPP_TERM_COLOUR_FG_MAGENTA,
WAPP_TERM_COLOUR_FG_YELLOW,
WAPP_TERM_COLOUR_FG_WHITE,
WAPP_TERM_COLOUR_FG_BR_BLACK,
WAPP_TERM_COLOUR_FG_BR_RED,
WAPP_TERM_COLOUR_FG_BR_GREEN,
WAPP_TERM_COLOUR_FG_BR_BLUE,
WAPP_TERM_COLOUR_FG_BR_CYAN,
WAPP_TERM_COLOUR_FG_BR_MAGENTA,
WAPP_TERM_COLOUR_FG_BR_YELLOW,
WAPP_TERM_COLOUR_FG_BR_WHITE,
WAPP_TERM_COLOUR_CLEAR,
COUNT_TERM_COLOUR,
} WpTerminalColour;
} TerminalColour;
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#endif // !TERMINAL_COLOURS_H
src/os/shell/termcolour/win/termcolour_win.c
+29 -29
View File
@@ -4,62 +4,62 @@
#include "../../../../common/platform/platform.h"
#include "../../../../base/strings/str8/str8.h"
#ifdef WP_PLATFORM_WINDOWS
#ifdef WAPP_PLATFORM_WINDOWS
#include "../terminal_colours.h"
#include "../../../../common/misc/misc_utils.h"
#include "../../../../../common/misc/misc_utils.h"
#include <stdio.h>
#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
typedef struct TermcolourData TermcolourData;
struct TermcolourData {
typedef struct termcolour_data TermcolourData;
struct termcolour_data {
HANDLE handle;
WORD default_colour;
WORD current_colour;
wpMiscUtilsReservePadding(sizeof(HANDLE) + sizeof(WORD) + sizeof(WORD));
wapp_misc_utils_padding_size(sizeof(HANDLE) + sizeof(WORD) + sizeof(WORD));
};
wp_intern void init_data(TermcolourData *data);
wapp_intern void init_data(TermcolourData *data);
wp_intern WORD colours[COUNT_TERM_COLOUR] = {
[WP_TERM_COLOUR_FG_BLACK] = 0,
[WP_TERM_COLOUR_FG_RED] = FOREGROUND_RED,
[WP_TERM_COLOUR_FG_GREEN] = FOREGROUND_GREEN,
[WP_TERM_COLOUR_FG_BLUE] = FOREGROUND_BLUE,
[WP_TERM_COLOUR_FG_CYAN] = FOREGROUND_GREEN | FOREGROUND_BLUE,
[WP_TERM_COLOUR_FG_MAGENTA] = FOREGROUND_RED | FOREGROUND_BLUE,
[WP_TERM_COLOUR_FG_YELLOW] = FOREGROUND_RED | FOREGROUND_GREEN,
[WP_TERM_COLOUR_FG_WHITE] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE,
[WP_TERM_COLOUR_FG_BR_BLACK] = FOREGROUND_INTENSITY,
[WP_TERM_COLOUR_FG_BR_RED] = FOREGROUND_RED | FOREGROUND_INTENSITY,
[WP_TERM_COLOUR_FG_BR_GREEN] = FOREGROUND_GREEN | FOREGROUND_INTENSITY,
[WP_TERM_COLOUR_FG_BR_BLUE] = FOREGROUND_BLUE | FOREGROUND_INTENSITY,
[WP_TERM_COLOUR_FG_BR_CYAN] = FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY,
[WP_TERM_COLOUR_FG_BR_MAGENTA] = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY,
[WP_TERM_COLOUR_FG_BR_YELLOW] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY,
[WP_TERM_COLOUR_FG_BR_WHITE] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY,
wapp_intern WORD colours[COUNT_TERM_COLOUR] = {
[WAPP_TERM_COLOUR_FG_BLACK] = 0,
[WAPP_TERM_COLOUR_FG_RED] = FOREGROUND_RED,
[WAPP_TERM_COLOUR_FG_GREEN] = FOREGROUND_GREEN,
[WAPP_TERM_COLOUR_FG_BLUE] = FOREGROUND_BLUE,
[WAPP_TERM_COLOUR_FG_CYAN] = FOREGROUND_GREEN | FOREGROUND_BLUE,
[WAPP_TERM_COLOUR_FG_MAGENTA] = FOREGROUND_RED | FOREGROUND_BLUE,
[WAPP_TERM_COLOUR_FG_YELLOW] = FOREGROUND_RED | FOREGROUND_GREEN,
[WAPP_TERM_COLOUR_FG_WHITE] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE,
[WAPP_TERM_COLOUR_FG_BR_BLACK] = FOREGROUND_INTENSITY,
[WAPP_TERM_COLOUR_FG_BR_RED] = FOREGROUND_RED | FOREGROUND_INTENSITY,
[WAPP_TERM_COLOUR_FG_BR_GREEN] = FOREGROUND_GREEN | FOREGROUND_INTENSITY,
[WAPP_TERM_COLOUR_FG_BR_BLUE] = FOREGROUND_BLUE | FOREGROUND_INTENSITY,
[WAPP_TERM_COLOUR_FG_BR_CYAN] = FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY,
[WAPP_TERM_COLOUR_FG_BR_MAGENTA] = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY,
[WAPP_TERM_COLOUR_FG_BR_YELLOW] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY,
[WAPP_TERM_COLOUR_FG_BR_WHITE] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY,
};
void _printColouredText(WpStr8RO *text, WpTerminalColour colour) {
wp_persist TermcolourData data = {0};
void print_coloured_text(Str8RO *text, TerminalColour colour) {
wapp_persist TermcolourData data = {0};
if (data.handle == 0) {
init_data(&data);
}
if (colour == WP_TERM_COLOUR_CLEAR) {
if (colour == WAPP_TERM_COLOUR_CLEAR) {
data.current_colour = data.default_colour;
} else {
data.current_colour = colours[colour];
}
SetConsoleTextAttribute(data.handle, data.current_colour);
printf(WP_STR8_SPEC, wpStr8Varg((*text)));
printf(WAPP_STR8_SPEC, wapp_str8_varg((*text)));
}
wp_intern void init_data(TermcolourData *data) {
wapp_intern void init_data(TermcolourData *data) {
// create handle
data->handle = GetStdHandle(STD_OUTPUT_HANDLE);
@@ -70,4 +70,4 @@ wp_intern void init_data(TermcolourData *data) {
data->current_colour = data->default_colour;
}
#endif // !WP_PLATFORM_WINDOWS
#endif // !WAPP_PLATFORM_WINDOWS
src/os/shell/utils/shell_utils.h
+10 -10
View File
@@ -7,20 +7,20 @@
#include "../../../common/platform/platform.h"
#include <stdio.h>
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_WINDOWS
#define wpShellUtilsPopen _popen
#define wpShellUtilsPclose _pclose
#ifdef WAPP_PLATFORM_WINDOWS
#define wapp_shell_utils_popen _popen
#define wapp_shell_utils_pclose _pclose
#else
#define wpShellUtilsPopen popen
#define wpShellUtilsPclose pclose
#endif /* ifdef WP_PLATFORM_WINDOWS */
#define wapp_shell_utils_popen popen
#define wapp_shell_utils_pclose pclose
#endif /* ifdef WAPP_PLATFORM_WINDOWS */
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#endif // !SHELL_UTILS_H
src/os/wapp_os.c
-2
View File
@@ -5,8 +5,6 @@
#include "wapp_os.h"
#include "file/file.c"
#include "file/posix/file_posix.c"
#include "file/win/file_win.c"
#include "shell/termcolour/posix/termcolour_posix.c"
#include "shell/termcolour/win/termcolour_win.c"
#include "shell/termcolour/termcolour.c"
src/os/wapp_os.h
-2
View File
@@ -4,8 +4,6 @@
#define WAPP_CORE_H
#include "file/file.h"
#include "file/posix/file_posix.h"
#include "file/win/file_win.h"
#include "shell/termcolour/termcolour.h"
#include "shell/termcolour/terminal_colours.h"
#include "shell/commander/commander.h"
src/prng/xorshift/xorshift.c
+27 -27
View File
@@ -7,18 +7,18 @@
#include <stdlib.h>
#include <time.h>
typedef struct SplitMix64State SplitMix64State;
struct SplitMix64State {
typedef struct split_mix_64_state SplitMix64State;
struct split_mix_64_state {
u64 seed;
};
wp_intern u64 rol64(u64 x, u64 bits);
wp_intern u64 split_mix_64(SplitMix64State *state);
wp_intern void seed_os_generator(void);
wp_intern u64 generate_random_number(void);
wapp_intern u64 rol64(u64 x, u64 bits);
wapp_intern u64 split_mix_64(SplitMix64State *state);
wapp_intern void seed_os_generator(void);
wapp_intern u64 generate_random_number(void);
WpXor256State wpPrngXorshiftInit(void) {
wp_persist b8 seeded = false;
XOR256State wapp_prng_xorshift_init_state(void) {
wapp_persist b8 seeded = false;
if (!seeded) {
seeded = true;
seed_os_generator();
@@ -26,7 +26,7 @@ WpXor256State wpPrngXorshiftInit(void) {
SplitMix64State sm64 = {.seed = generate_random_number()};
return (WpXor256State){
return (XOR256State){
.x = split_mix_64(&sm64),
.y = split_mix_64(&sm64),
.z = split_mix_64(&sm64),
@@ -34,7 +34,7 @@ WpXor256State wpPrngXorshiftInit(void) {
};
}
u64 wpPrngXorshift256(WpXor256State *state) {
u64 wapp_prng_xorshift_256(XOR256State *state) {
u64 t = state->x ^ (state->x << 11);
state->x = state->y;
@@ -45,7 +45,7 @@ u64 wpPrngXorshift256(WpXor256State *state) {
return state->w;
}
u64 wpPrngXorshift256ss(WpXor256State *state) {
u64 wapp_prng_xorshift_256ss(XOR256State *state) {
const u64 result = rol64(state->z * 5, 7) * 9;
const u64 t = state->z << 17;
@@ -60,7 +60,7 @@ u64 wpPrngXorshift256ss(WpXor256State *state) {
return result;
}
u64 wpPrngXorshift256p(WpXor256State *state) {
u64 wapp_prng_xorshift_256p(XOR256State *state) {
const u64 result = state->w + state->x;
const u64 t = state->z << 17;
@@ -75,11 +75,11 @@ u64 wpPrngXorshift256p(WpXor256State *state) {
return result;
}
wp_intern u64 rol64(u64 x, u64 bits) {
wapp_intern u64 rol64(u64 x, u64 bits) {
return (x << bits) | (x >> (64 - bits));
}
wp_intern u64 split_mix_64(SplitMix64State *state) {
wapp_intern u64 split_mix_64(SplitMix64State *state) {
state->seed += 0x9E3779B97f4A7C15;
u64 result = state->seed;
@@ -89,47 +89,47 @@ wp_intern u64 split_mix_64(SplitMix64State *state) {
return result ^ (result >> 31);
}
#if defined(WP_PLATFORM_C) && WP_PLATFORM_C_VERSION >= WP_PLATFORM_C11_VERSION
#ifdef WP_PLATFORM_POSIX
wp_intern void seed_os_generator(void) {
#if defined(WAPP_PLATFORM_C) && WAPP_PLATFORM_C_VERSION >= WAPP_PLATFORM_C11_VERSION
#ifdef WAPP_PLATFORM_POSIX
wapp_intern void seed_os_generator(void) {
struct timespec ts = {0};
int result = clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
wpRuntimeAssert(result == 0, "Invalid seed value");
wapp_runtime_assert(result == 0, "Invalid seed value");
srand48(ts.tv_nsec);
}
wp_intern u64 generate_random_number(void) {
wapp_intern u64 generate_random_number(void) {
return lrand48();
}
#else
wp_intern void seed_os_generator(void) {
wapp_intern void seed_os_generator(void) {
struct timespec ts = {0};
int result = timespec_get(&ts, TIME_UTC);
wpRuntimeAssert(result != 0, "Invalid seed value");
wapp_runtime_assert(result != 0, "Invalid seed value");
srand(ts.tv_nsec);
}
wp_intern u64 generate_random_number(void) {
wapp_intern u64 generate_random_number(void) {
i32 n1 = rand();
i32 n2 = rand();
return (((u64)n1) << 32 | (u64)n2);
}
#endif // !WP_PLATFORM_POSIX
#endif // !WAPP_PLATFORM_POSIX
#else
wp_intern void seed_os_generator(void) {
wapp_intern void seed_os_generator(void) {
time_t result = time(NULL);
wpRuntimeAssert(result != (time_t)(-1), "Invalid seed value");
wapp_runtime_assert(result != (time_t)(-1), "Invalid seed value");
srand(result);
}
wp_intern u64 generate_random_number(void) {
wapp_intern u64 generate_random_number(void) {
i32 n1 = rand();
i32 n2 = rand();
return (((u64)n1) << 32 | (u64)n2);
}
#endif // !WP_PLATFORM_C
#endif // !WAPP_PLATFORM_C
src/prng/xorshift/xorshift.h
+10 -10
View File
@@ -6,25 +6,25 @@
#include "../../common/aliases/aliases.h"
#include "../../common/platform/platform.h"
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
typedef struct WpXor256State WpXor256State;
struct WpXor256State {
typedef struct xor_256_state XOR256State;
struct xor_256_state {
u64 x;
u64 y;
u64 z;
u64 w;
};
WpXor256State wpPrngXorshiftInit(void);
u64 wpPrngXorshift256(WpXor256State *state);
u64 wpPrngXorshift256ss(WpXor256State *state);
u64 wpPrngXorshift256p(WpXor256State *state);
XOR256State wapp_prng_xorshift_init_state(void);
u64 wapp_prng_xorshift_256(XOR256State *state);
u64 wapp_prng_xorshift_256ss(XOR256State *state);
u64 wapp_prng_xorshift_256p(XOR256State *state);
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#endif // !XORSHIFT_H
src/testing/tester/tester.c
+17 -17
View File
@@ -8,23 +8,23 @@
#include <stdio.h>
#include <stdlib.h>
wp_intern void handleTestResult(WpTestFuncResult result);
wapp_intern void handle_test_result(TestFuncResult result);
void _runTests(WpTestFunc *func1, ...) {
void run_tests(TestFunc *func1, ...) {
printf("\n");
handleTestResult(func1());
handle_test_result(func1());
va_list args;
va_start(args, func1);
WpTestFunc *func = va_arg(args, WpTestFunc *);
TestFunc *func = va_arg(args, TestFunc *);
while (func) {
WpTestFuncResult result = func();
handleTestResult(result);
TestFuncResult result = func();
handle_test_result(result);
func = va_arg(args, WpTestFunc *);
func = va_arg(args, TestFunc *);
}
va_end(args);
@@ -32,22 +32,22 @@ void _runTests(WpTestFunc *func1, ...) {
printf("\n");
}
wp_intern void handleTestResult(WpTestFuncResult result) {
WpTerminalColour colour;
WpStr8 result_text = wpStr8Buf(64);
wapp_intern void handle_test_result(TestFuncResult result) {
TerminalColour colour;
Str8 result_text = wapp_str8_buf(64);
if (result.passed) {
colour = WP_TERM_COLOUR_FG_BR_GREEN;
wpStr8CopyCstrCapped(&result_text, "PASSED");
colour = WAPP_TERM_COLOUR_FG_BR_GREEN;
wapp_str8_copy_cstr_capped(&result_text, "PASSED");
} else {
colour = WP_TERM_COLOUR_FG_BR_RED;
wpStr8CopyCstrCapped(&result_text, "FAILED");
colour = WAPP_TERM_COLOUR_FG_BR_RED;
wapp_str8_copy_cstr_capped(&result_text, "FAILED");
}
printf("[");
wpShellTermcolourPrintText(&result_text, colour);
wpShellTermcolourClearColour();
printf("] " WP_STR8_SPEC "\n", wpStr8Varg(result.name));
wapp_shell_termcolour_print_text(&result_text, colour);
wapp_shell_termcolour_clear_colour();
printf("] " WAPP_STR8_SPEC "\n", wapp_str8_varg(result.name));
if (!result.passed) {
exit(EXIT_FAILURE);
src/testing/tester/tester.h
+15 -13
View File
@@ -7,30 +7,32 @@
#include "../../common/platform/platform.h"
#include "../../base/strings/str8/str8.h"
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#define wpTesterResult(PASSED) (WpTestFuncResult{wpStr8LitRo(__func__), PASSED, {}})
#define wapp_tester_result(PASSED) (TestFuncResult{wapp_str8_lit_ro(__func__), PASSED})
#else
#define wpTesterResult(PASSED) ((WpTestFuncResult){.name = wpStr8LitRo(__func__), .passed = PASSED})
#endif // !WP_PLATFORM_CPP
#define wapp_tester_result(PASSED) ((TestFuncResult){.name = wapp_str8_lit_ro(__func__), .passed = PASSED})
#endif // !WAPP_PLATFORM_CPP
#define wpTesterRun(...) _runTests(__VA_ARGS__, NULL)
#define wapp_tester_run_tests(...) run_tests(__VA_ARGS__, NULL)
typedef struct WpTestFuncResult WpTestFuncResult;
struct WpTestFuncResult {
WpStr8 name;
typedef struct test_func_result TestFuncResult;
struct test_func_result {
Str8 name;
b8 passed;
wpMiscUtilsReservePadding(sizeof(WpStr8) + sizeof(b8));
#ifdef WAPP_PLATFORM_WINDOWS
wapp_misc_utils_padding_size(sizeof(Str8RO) + sizeof(b8));
#endif // WAPP_PLATFORM_WINDOWS
};
typedef WpTestFuncResult(WpTestFunc)(void);
typedef TestFuncResult(TestFunc)(void);
void _runTests(WpTestFunc *func1, ...);
void run_tests(TestFunc *func1, ...);
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#endif // !TESTER_H
src/uuid/uuid.c
+14 -14
View File
@@ -9,17 +9,17 @@
#define UUID_STR_FORMAT ("%.8" PRIx64 "-%.4" PRIx64 "-%.4" PRIx64 "-%.4" PRIx64 "-%.12" PRIx64)
typedef struct UUID4 UUID4;
struct UUID4 {
typedef struct uuid4 UUID4;
struct uuid4 {
u64 high;
u64 low;
};
wp_intern UUID4 generate_uuid4(void);
wp_intern void uuid4_to_uuid(const UUID4* uuid4, WpUuid *uuid);
wapp_intern UUID4 generate_uuid4(void);
wapp_intern void uuid4_to_uuid(const UUID4* uuid4, WUUID *uuid);
WpUuid *wpUuidInitUuid4(WpUuid *uuid) {
wpDebugAssert(uuid != NULL, "`uuid` should not be NULL");
WUUID *wapp_uuid_init_uuid4(WUUID *uuid) {
wapp_debug_assert(uuid != NULL, "`uuid` should not be NULL");
UUID4 uuid4 = generate_uuid4();
uuid4_to_uuid(&uuid4, uuid);
@@ -27,18 +27,18 @@ WpUuid *wpUuidInitUuid4(WpUuid *uuid) {
return uuid;
}
wp_intern UUID4 generate_uuid4(void) {
wp_persist WpXor256State state = {0};
wp_persist b8 initialised = false;
wapp_intern UUID4 generate_uuid4(void) {
wapp_persist XOR256State state = {0};
wapp_persist b8 initialised = false;
if (!initialised) {
initialised = true;
state = wpPrngXorshiftInit();
state = wapp_prng_xorshift_init_state();
}
UUID4 uuid = (UUID4){
.high = wpPrngXorshift256(&state),
.low = wpPrngXorshift256(&state),
.high = wapp_prng_xorshift_256(&state),
.low = wapp_prng_xorshift_256(&state),
};
uuid.high = (uuid.high & 0xffffffffffff0fff) | 0x0000000000004000;
@@ -47,12 +47,12 @@ wp_intern UUID4 generate_uuid4(void) {
return uuid;
}
wp_intern void uuid4_to_uuid(const UUID4* uuid4, WpUuid *uuid) {
wapp_intern void uuid4_to_uuid(const UUID4* uuid4, WUUID *uuid) {
u64 group1 = uuid4->high >> 32;
u64 group2 = (uuid4->high << 32) >> 48;
u64 group3 = (uuid4->high << 48) >> 48;
u64 group4 = uuid4->low >> 48;
u64 group5 = (uuid4->low << 16) >> 16;
wpStr8Format(&(uuid->uuid), UUID_STR_FORMAT, group1, group2, group3, group4, group5);
wapp_str8_format(&(uuid->uuid), UUID_STR_FORMAT, group1, group2, group3, group4, group5);
}
src/uuid/uuid.h
+13 -26
View File
@@ -7,44 +7,31 @@
#include "../common/platform/platform.h"
#include "../base/strings/str8/str8.h"
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#define WP_UUID_BUF_LENGTH 48
#define WP_UUID_SPEC WP_STR8_SPEC
#define wpUuidVarg(WpUuid) wpStr8Varg((WpUuid).uuid)
#define UUID_BUF_LENGTH 48
#define WAPP_UUID_SPEC WAPP_STR8_SPEC
#define wapp_uuid_varg(WUUID) wapp_str8_varg((WUUID).uuid)
typedef struct WpUuid WpUuid;
struct WpUuid {
WpStr8 uuid;
typedef struct wapp_uuid WUUID;
struct wapp_uuid {
Str8 uuid;
};
// TODO (Abdelrahman): Update UUID implementation to work properly with C++ and tests for validation
#ifdef WP_PLATFORM_CPP
#define wpUuidGenUuid4() ([&](){ \
wp_persist WpUuid uuid = wpUuidCreate(); \
return *(wpUuidInitUuid4(&uuid)); \
}())
#else
#define wpUuidGenUuid4() *(wpUuidInitUuid4(&wpUuidCreate()))
#endif
#define wapp_uuid_gen_uuid4() *(wapp_uuid_init_uuid4(&wapp_uuid_create()))
/* Low level UUID API */
#ifdef WP_PLATFORM_CPP
#define wpUuidCreate() ([&](){ return WpUuid{wpStr8Buf(WP_UUID_BUF_LENGTH)}; }())
#else
#define wpUuidCreate() ((WpUuid){.uuid = wpStr8Buf(WP_UUID_BUF_LENGTH)})
#endif
#define wapp_uuid_create() ((WUUID){.uuid = wapp_str8_buf(UUID_BUF_LENGTH)})
// Just returns the same pointer that was passed in with the UUID initialised.
// Fails when passed a NULL pointer.
WpUuid *wpUuidInitUuid4(WpUuid *uuid);
WUUID *wapp_uuid_init_uuid4(WUUID *uuid);
#ifdef WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WP_PLATFORM_CPP
#endif // !WAPP_PLATFORM_CPP
#endif // !UUID_H
src/wapp.c
+1 -2
View File
@@ -6,9 +6,8 @@
#include "wapp.h"
#include "base/wapp_base.c"
#include "os/wapp_os.c"
#include "log/wapp_log.c"
#include "prng/wapp_prng.c"
#include "uuid/wapp_uuid.c"
#include "uuid/uuid.c"
#include "testing/wapp_testing.c"
#endif // !WAPP_C
src/wapp.h
-1
View File
@@ -6,7 +6,6 @@
#include "common/wapp_common.h"
#include "base/wapp_base.h"
#include "os/wapp_os.h"
#include "log/wapp_log.h"
#include "prng/wapp_prng.h"
#include "uuid/wapp_uuid.h"
#include "testing/wapp_testing.h"
tests/allocator/test_allocator.c
+5 -55
View File
@@ -2,66 +2,16 @@
#include "wapp.h"
#include <stdlib.h>
// NOTE (Abdelrahman): Cannot query size of Arena here so it's hardcoded. Similarly, since arena
// allocation are aligned to power of 2 boundaries, the number of i32 values needed is hardcoded.
#define TEMP_BUF_SIZE (40 + sizeof(i32) * 8)
wp_intern u8 temp_buf[TEMP_BUF_SIZE] = {0};
wp_intern WpAllocator temp_allocator = {0};
WpTestFuncResult test_arena_allocator(void) {
WpAllocator allocator = wpMemArenaAllocatorInit(4096);
TestFuncResult test_arena_allocator(void) {
Allocator allocator = wapp_mem_arena_allocator_init(4096);
b8 result = allocator.obj != NULL && allocator.alloc != NULL &&
allocator.alloc_aligned != NULL &&
allocator.realloc != NULL && allocator.realloc_aligned != NULL &&
allocator.free == NULL;
void *ptr = wpMemAllocatorAlloc(&allocator, 20);
void *ptr = wapp_mem_allocator_alloc(&allocator, 20);
result = result && (ptr != NULL);
wpMemArenaAllocatorDestroy(&allocator);
wapp_mem_arena_allocator_destroy(&allocator);
return wpTesterResult(result);
}
WpTestFuncResult test_arena_allocator_with_buffer(void) {
u8 buffer[KiB(4)] = {0};
WpAllocator allocator = wpMemArenaAllocatorInitWithBuffer(buffer, KiB(4));
b8 result = allocator.obj != NULL && allocator.alloc != NULL &&
allocator.alloc_aligned != NULL &&
allocator.realloc != NULL && allocator.realloc_aligned != NULL &&
allocator.free == NULL;
void *ptr = wpMemAllocatorAlloc(&allocator, 20);
result = result && (ptr != NULL);
wpMemArenaAllocatorDestroy(&allocator);
return wpTesterResult(result);
}
WpTestFuncResult test_arena_allocator_temp_begin(void) {
temp_allocator = wpMemArenaAllocatorInitWithBuffer(temp_buf, TEMP_BUF_SIZE);
i32 *num1 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32));
b8 result = num1 != NULL;
wpMemArenaAllocatorTempBegin(&temp_allocator);
i32 *num2 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32));
result = result && num2 != NULL;
i32 *num3 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32));
result = result && num3 == NULL;
return wpTesterResult(result);
}
WpTestFuncResult test_arena_allocator_temp_end(void) {
wpMemArenaAllocatorTempEnd(&temp_allocator);
i32 *num1 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32));
b8 result = num1 != NULL;
i32 *num2 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32));
result = result && num2 == NULL;
wpMemArenaAllocatorDestroy(&temp_allocator);
return wpTesterResult(result);
return wapp_tester_result(result);
}
tests/allocator/test_allocator.cc
+5 -55
View File
@@ -2,66 +2,16 @@
#include "wapp.h"
#include <stdlib.h>
// NOTE (Abdelrahman): Cannot query size of Arena here so it's hardcoded. Similarly, since arena
// allocation are aligned to power of 2 boundaries, the number of i32 values needed is hardcoded.
#define TEMP_BUF_SIZE (40 + sizeof(i32) * 8)
wp_intern u8 temp_buf[TEMP_BUF_SIZE] = {};
wp_intern WpAllocator temp_allocator = {};
WpTestFuncResult test_arena_allocator(void) {
WpAllocator allocator = wpMemArenaAllocatorInit(4096);
TestFuncResult test_arena_allocator(void) {
Allocator allocator = wapp_mem_arena_allocator_init(4096);
b8 result = allocator.obj != nullptr && allocator.alloc != nullptr &&
allocator.alloc_aligned != nullptr &&
allocator.realloc != nullptr && allocator.realloc_aligned != nullptr &&
allocator.free == nullptr;
void *ptr = wpMemAllocatorAlloc(&allocator, 20);
void *ptr = wapp_mem_allocator_alloc(&allocator, 20);
result = result && (ptr != nullptr);
wpMemArenaAllocatorDestroy(&allocator);
wapp_mem_arena_allocator_destroy(&allocator);
return wpTesterResult(result);
}
WpTestFuncResult test_arena_allocator_with_buffer(void) {
u8 buffer[KiB(4)] = {0};
WpAllocator allocator = wpMemArenaAllocatorInitWithBuffer(buffer, KiB(4));
b8 result = allocator.obj != NULL && allocator.alloc != NULL &&
allocator.alloc_aligned != NULL &&
allocator.realloc != NULL && allocator.realloc_aligned != NULL &&
allocator.free == NULL;
void *ptr = wpMemAllocatorAlloc(&allocator, 20);
result = result && (ptr != NULL);
wpMemArenaAllocatorDestroy(&allocator);
return wpTesterResult(result);
}
WpTestFuncResult test_arena_allocator_temp_begin(void) {
temp_allocator = wpMemArenaAllocatorInitWithBuffer(temp_buf, TEMP_BUF_SIZE);
i32 *num1 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32));
b8 result = num1 != NULL;
wpMemArenaAllocatorTempBegin(&temp_allocator);
i32 *num2 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32));
result = result && num2 != NULL;
i32 *num3 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32));
result = result && num3 == NULL;
return wpTesterResult(result);
}
WpTestFuncResult test_arena_allocator_temp_end(void) {
wpMemArenaAllocatorTempEnd(&temp_allocator);
i32 *num1 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32));
b8 result = num1 != NULL;
i32 *num2 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32));
result = result && num2 == NULL;
wpMemArenaAllocatorDestroy(&temp_allocator);
return wpTesterResult(result);
return wapp_tester_result(result);
}
tests/allocator/test_allocator.h
+1 -4
View File
@@ -3,9 +3,6 @@
#include "wapp.h"
WpTestFuncResult test_arena_allocator(void);
WpTestFuncResult test_arena_allocator_with_buffer(void);
WpTestFuncResult test_arena_allocator_temp_begin(void);
WpTestFuncResult test_arena_allocator_temp_end(void);
TestFuncResult test_arena_allocator(void);
#endif // !TEST_ALLOCATOR_H
tests/arena/test_arena.c
+36 -93
View File
@@ -3,144 +3,94 @@
#include <stdlib.h>
#define ARENA_CAPACITY KiB(16)
#define ARENA_BUF_SIZE KiB(4)
// NOTE (Abdelrahman): Cannot query size of WpArena here so it's hardcoded. Similarly, since arena
// allocation are aligned to power of 2 boundaries, the number of i32 values needed is hardcoded.
#define TEMP_BUF_SIZE (40 + sizeof(i32) * 8)
wp_intern WpArena *arena = NULL;
wp_intern i32 count = 20;
wp_intern i32 *array = NULL;
wp_intern WpArena *buf_arena = NULL;
wp_intern u8 buf[ARENA_BUF_SIZE] = {0};
wp_intern WpArena *temp_arena = NULL;
wp_intern u8 temp_buf[TEMP_BUF_SIZE] = {0};
wapp_intern Arena *arena = NULL;
wapp_intern i32 count = 20;
wapp_intern i32 *array = NULL;
WpTestFuncResult test_arena_init_buffer(void) {
b8 result = wpMemArenaInitBuffer(&buf_arena, buf, ARENA_BUF_SIZE);
return wpTesterResult(result);
TestFuncResult test_arena_init(void) {
b8 result = wapp_mem_arena_init(&arena, ARENA_CAPACITY);
return wapp_tester_result(result);
}
WpTestFuncResult test_arena_init_allocated(void) {
b8 result = wpMemArenaInitAllocated(&arena, ARENA_CAPACITY);
return wpTesterResult(result);
}
WpTestFuncResult test_arena_init_succeeds_when_reserving_very_large_size(void) {
WpArena *large_arena = NULL;
TestFuncResult test_arena_init_succeeds_when_reserving_very_large_size(void) {
Arena *large_arena = NULL;
u64 capacity = GiB(512);
b8 result = wpMemArenaInitAllocated(&large_arena, capacity);
b8 result = wapp_mem_arena_init(&large_arena, capacity);
if (result) {
wpMemArenaDestroy(&large_arena);
wapp_mem_arena_destroy(&large_arena);
}
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_arena_alloc_with_buffer(void) {
i32 *arr = (i32 *)wpMemArenaAlloc(arena, count * sizeof(i32));
b8 result = arr != NULL;
for (i32 i = 0; i < count; ++i) {
arr[i] = i * 10;
}
return wpTesterResult(result);
}
WpTestFuncResult test_arena_alloc_succeeds_when_within_capacity(void) {
array = wpMemArenaAlloc(arena, count * sizeof(i32));
TestFuncResult test_arena_alloc_succeeds_when_within_capacity(void) {
array = wapp_mem_arena_alloc(arena, count * sizeof(i32));
b8 result = array != NULL;
for (i32 i = 0; i < count; ++i) {
array[i] = i * 10;
}
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_arena_alloc_fails_when_over_capacity(void) {
u8 *bytes = wpMemArenaAlloc(arena, ARENA_CAPACITY * 2);
TestFuncResult test_arena_alloc_fails_when_over_capacity(void) {
u8 *bytes = wapp_mem_arena_alloc(arena, ARENA_CAPACITY * 2);
b8 result = bytes == NULL;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_arena_realloc_bigger_size(void) {
TestFuncResult test_arena_realloc_bigger_size(void) {
u64 old_count = 10;
u64 new_count = 20;
i32 *bytes = wpMemArenaAlloc(arena, old_count * sizeof(i32));
i32 *bytes = wapp_mem_arena_alloc(arena, old_count * sizeof(i32));
for (u64 i = 0; i < old_count; ++i) {
bytes[i] = (i32)i;
}
i32 *new_bytes = wpMemArenaRealloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32));
i32 *new_bytes = wapp_mem_arena_realloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32));
if (!new_bytes) {
return wpTesterResult(false);
return wapp_tester_result(false);
}
for (u64 i = 0; i < new_count; ++i) {
if (i < old_count && new_bytes[i] != bytes[i]) {
return wpTesterResult(false);
return wapp_tester_result(false);
}
}
return wpTesterResult(true);
return wapp_tester_result(true);
}
WpTestFuncResult test_arena_realloc_smaller_size(void) {
TestFuncResult test_arena_realloc_smaller_size(void) {
u64 old_count = 10;
u64 new_count = 5;
i32 *bytes = wpMemArenaAlloc(arena, old_count * sizeof(i32));
i32 *bytes = wapp_mem_arena_alloc(arena, old_count * sizeof(i32));
for (u64 i = 0; i < old_count; ++i) {
bytes[i] = (i32)i;
}
i32 *new_bytes = wpMemArenaRealloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32));
i32 *new_bytes = wapp_mem_arena_realloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32));
if (!new_bytes) {
return wpTesterResult(false);
return wapp_tester_result(false);
}
for (u64 i = 0; i < new_count; ++i) {
if (i < new_count && new_bytes[i] != bytes[i]) {
return wpTesterResult(false);
return wapp_tester_result(false);
}
}
return wpTesterResult(true);
return wapp_tester_result(true);
}
WpTestFuncResult test_arena_temp_begin(void) {
b8 result = wpMemArenaInitBuffer(&temp_arena, temp_buf, TEMP_BUF_SIZE);
i32 *num1 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32));
result = result && num1 != NULL;
wpMemArenaTempBegin(temp_arena);
i32 *num2 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32));
result = result && num2 != NULL;
i32 *num3 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32));
result = result && num3 == NULL;
return wpTesterResult(result);
}
WpTestFuncResult test_arena_temp_end(void) {
wpMemArenaTempEnd(temp_arena);
i32 *num1 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32));
b8 result = num1 != NULL;
i32 *num2 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32));
result = result && num2 == NULL;
wpMemArenaDestroy(&temp_arena);
return wpTesterResult(result);
}
WpTestFuncResult test_arena_clear(void) {
wpMemArenaClear(arena);
TestFuncResult test_arena_clear(void) {
wapp_mem_arena_clear(arena);
b8 result = true;
for (i32 i = 0; i < count; ++i) {
@@ -150,19 +100,12 @@ WpTestFuncResult test_arena_clear(void) {
}
}
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_arena_destroy_buffer(void) {
wpMemArenaDestroy(&buf_arena);
b8 result = buf_arena == NULL;
return wpTesterResult(result);
}
WpTestFuncResult test_arena_destroy_allocated(void) {
wpMemArenaDestroy(&arena);
TestFuncResult test_arena_destroy(void) {
wapp_mem_arena_destroy(&arena);
b8 result = arena == NULL;
return wpTesterResult(result);
return wapp_tester_result(result);
}
tests/arena/test_arena.cc
+36 -93
View File
@@ -3,144 +3,94 @@
#include <stdlib.h>
#define ARENA_CAPACITY KiB(16)
#define ARENA_BUF_SIZE KiB(4)
// NOTE (Abdelrahman): Cannot query size of WpArena here so it's hardcoded. Similarly, since arena
// allocation are aligned to power of 2 boundaries, the number of i32 values needed is hardcoded.
#define TEMP_BUF_SIZE (40 + sizeof(i32) * 8)
wp_intern WpArena *arena = NULL;
wp_intern i32 count = 20;
wp_intern i32 *array = NULL;
wp_intern WpArena *buf_arena = NULL;
wp_intern u8 buf[ARENA_BUF_SIZE] = {};
wp_intern WpArena *temp_arena = NULL;
wp_intern u8 temp_buf[TEMP_BUF_SIZE] = {};
wapp_intern Arena *arena = nullptr;
wapp_intern i32 count = 20;
wapp_intern i32 *array = nullptr;
WpTestFuncResult test_arena_init_buffer(void) {
b8 result = wpMemArenaInitBuffer(&buf_arena, buf, ARENA_BUF_SIZE);
return wpTesterResult(result);
TestFuncResult test_arena_init(void) {
b8 result = wapp_mem_arena_init(&arena, ARENA_CAPACITY);
return wapp_tester_result(result);
}
WpTestFuncResult test_arena_init_allocated(void) {
b8 result = wpMemArenaInitAllocated(&arena, ARENA_CAPACITY);
return wpTesterResult(result);
}
WpTestFuncResult test_arena_init_succeeds_when_reserving_very_large_size(void) {
WpArena *large_arena = nullptr;
TestFuncResult test_arena_init_succeeds_when_reserving_very_large_size(void) {
Arena *large_arena = nullptr;
u64 capacity = GiB(512);
b8 result = wpMemArenaInitAllocated(&large_arena, capacity);
b8 result = wapp_mem_arena_init(&large_arena, capacity);
if (result) {
wpMemArenaDestroy(&large_arena);
wapp_mem_arena_destroy(&large_arena);
}
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_arena_alloc_with_buffer(void) {
i32 *arr = (i32 *)wpMemArenaAlloc(arena, count * sizeof(i32));
b8 result = arr != NULL;
for (i32 i = 0; i < count; ++i) {
arr[i] = i * 10;
}
return wpTesterResult(result);
}
WpTestFuncResult test_arena_alloc_succeeds_when_within_capacity(void) {
array = (i32 *)wpMemArenaAlloc(arena, count * sizeof(i32));
TestFuncResult test_arena_alloc_succeeds_when_within_capacity(void) {
array = (i32 *)wapp_mem_arena_alloc(arena, count * sizeof(i32));
b8 result = array != nullptr;
for (i32 i = 0; i < count; ++i) {
array[i] = i * 10;
}
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_arena_alloc_fails_when_over_capacity(void) {
u8 *bytes = (u8 *)wpMemArenaAlloc(arena, ARENA_CAPACITY * 2);
TestFuncResult test_arena_alloc_fails_when_over_capacity(void) {
u8 *bytes = (u8 *)wapp_mem_arena_alloc(arena, ARENA_CAPACITY * 2);
b8 result = bytes == nullptr;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_arena_realloc_bigger_size(void) {
TestFuncResult test_arena_realloc_bigger_size(void) {
u64 old_count = 10;
u64 new_count = 20;
i32 *bytes = (i32 *)wpMemArenaAlloc(arena, old_count * sizeof(i32));
i32 *bytes = (i32 *)wapp_mem_arena_alloc(arena, old_count * sizeof(i32));
for (u64 i = 0; i < old_count; ++i) {
bytes[i] = (i32)i;
}
i32 *new_bytes = (i32 *)wpMemArenaRealloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32));
i32 *new_bytes = (i32 *)wapp_mem_arena_realloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32));
if (!new_bytes) {
return wpTesterResult(false);
return wapp_tester_result(false);
}
for (u64 i = 0; i < new_count; ++i) {
if (i < old_count && new_bytes[i] != bytes[i]) {
return wpTesterResult(false);
return wapp_tester_result(false);
}
}
return wpTesterResult(true);
return wapp_tester_result(true);
}
WpTestFuncResult test_arena_realloc_smaller_size(void) {
TestFuncResult test_arena_realloc_smaller_size(void) {
u64 old_count = 10;
u64 new_count = 5;
i32 *bytes = (i32 *)wpMemArenaAlloc(arena, old_count * sizeof(i32));
i32 *bytes = (i32 *)wapp_mem_arena_alloc(arena, old_count * sizeof(i32));
for (u64 i = 0; i < old_count; ++i) {
bytes[i] = (i32)i;
}
i32 *new_bytes = (i32 *)wpMemArenaRealloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32));
i32 *new_bytes = (i32 *)wapp_mem_arena_realloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32));
if (!new_bytes) {
return wpTesterResult(false);
return wapp_tester_result(false);
}
for (u64 i = 0; i < new_count; ++i) {
if (i < new_count && new_bytes[i] != bytes[i]) {
return wpTesterResult(false);
return wapp_tester_result(false);
}
}
return wpTesterResult(true);
return wapp_tester_result(true);
}
WpTestFuncResult test_arena_temp_begin(void) {
b8 result = wpMemArenaInitBuffer(&temp_arena, temp_buf, TEMP_BUF_SIZE);
i32 *num1 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32));
result = result && num1 != NULL;
wpMemArenaTempBegin(temp_arena);
i32 *num2 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32));
result = result && num2 != NULL;
i32 *num3 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32));
result = result && num3 == NULL;
return wpTesterResult(result);
}
WpTestFuncResult test_arena_temp_end(void) {
wpMemArenaTempEnd(temp_arena);
i32 *num1 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32));
b8 result = num1 != NULL;
i32 *num2 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32));
result = result && num2 == NULL;
wpMemArenaDestroy(&temp_arena);
return wpTesterResult(result);
}
WpTestFuncResult test_arena_clear(void) {
wpMemArenaClear(arena);
TestFuncResult test_arena_clear(void) {
wapp_mem_arena_clear(arena);
b8 result = true;
for (i32 i = 0; i < count; ++i) {
@@ -150,19 +100,12 @@ WpTestFuncResult test_arena_clear(void) {
}
}
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_arena_destroy_buffer(void) {
wpMemArenaDestroy(&buf_arena);
b8 result = buf_arena == NULL;
return wpTesterResult(result);
}
WpTestFuncResult test_arena_destroy_allocated(void) {
wpMemArenaDestroy(&arena);
TestFuncResult test_arena_destroy(void) {
wapp_mem_arena_destroy(&arena);
b8 result = arena == nullptr;
return wpTesterResult(result);
return wapp_tester_result(result);
}
tests/arena/test_arena.h
+8 -13
View File
@@ -3,18 +3,13 @@
#include "wapp.h"
WpTestFuncResult test_arena_init_buffer(void);
WpTestFuncResult test_arena_init_allocated(void);
WpTestFuncResult test_arena_init_succeeds_when_reserving_very_large_size(void);
WpTestFuncResult test_arena_alloc_with_buffer(void);
WpTestFuncResult test_arena_alloc_succeeds_when_within_capacity(void);
WpTestFuncResult test_arena_alloc_fails_when_over_capacity(void);
WpTestFuncResult test_arena_realloc_bigger_size(void);
WpTestFuncResult test_arena_realloc_smaller_size(void);
WpTestFuncResult test_arena_clear(void);
WpTestFuncResult test_arena_temp_begin(void);
WpTestFuncResult test_arena_temp_end(void);
WpTestFuncResult test_arena_destroy_buffer(void);
WpTestFuncResult test_arena_destroy_allocated(void);
TestFuncResult test_arena_init(void);
TestFuncResult test_arena_init_succeeds_when_reserving_very_large_size(void);
TestFuncResult test_arena_alloc_succeeds_when_within_capacity(void);
TestFuncResult test_arena_alloc_fails_when_over_capacity(void);
TestFuncResult test_arena_realloc_bigger_size(void);
TestFuncResult test_arena_realloc_smaller_size(void);
TestFuncResult test_arena_clear(void);
TestFuncResult test_arena_destroy(void);
#endif // !TEST_ARENA_H
tests/array/test_i32_array.c
+103 -103
View File
@@ -1,273 +1,273 @@
#include "test_i32_array.h"
#include "wapp.h"
WpTestFuncResult test_i32_array(void) {
TestFuncResult test_i32_array(void) {
b8 result;
WpI32Array array = wpArray(i32, 1, 2, 3, 4, 5, 6, 7);
result = wpArrayCount(array) == 7 && wpArrayCapacity(array) == 16;
I32Array array = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7);
result = array.count == 7 && array.capacity == 16;
i32 *item;
u64 count = wpArrayCount(array);
u64 count = array.count;
u64 index = 0;
b8 running = true;
while (running) {
item = wpArrayGet(i32, array, index);
item = wapp_array_get(i32, &array, index);
result = result && item && *item == (i32)(index + 1);
++index;
running = index < count;
}
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_with_capacity(void) {
TestFuncResult test_i32_array_with_capacity(void) {
b8 result;
WpI32Array array1 = wpArrayWithCapacity(i32, 64, WP_ARRAY_INIT_NONE);
result = wpArrayCount(array1) == 0 && wpArrayCapacity(array1) == 64;
I32Array array1 = wapp_array_with_capacity(i32, I32Array, 64, false);
result = array1.count == 0 && array1.capacity == 64;
WpI32Array array2 = wpArrayWithCapacity(i32, 64, WP_ARRAY_INIT_FILLED);
result = wpArrayCount(array2) == 64 && wpArrayCapacity(array2) == 64;
I32Array array2 = wapp_array_with_capacity(i32, I32Array, 64, true);
result = array2.count == 64 && array2.capacity == 64;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_get(void) {
TestFuncResult test_i32_array_get(void) {
b8 result = true;
WpI32Array array = wpArray(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8);
I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8);
i32 *item;
u64 count = wpArrayCount(array);
u64 count = array.count;
u64 index = 0;
b8 running = true;
while (running) {
item = wpArrayGet(i32, array, index);
item = wapp_array_get(i32, &array, index);
result = result && item && *item == (i32)index;
++index;
running = index < count;
}
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_set(void) {
TestFuncResult test_i32_array_set(void) {
b8 result = true;
WpI32Array array = wpArray(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8);
I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8);
i32 *item;
u64 count = wpArrayCount(array);
u64 count = array.count;
u64 index = 0;
b8 running = true;
while (running) {
i32 num = (i32)(index * 2);
wpArraySet(i32, array, index, &num);
item = wpArrayGet(i32, array, index);
wapp_array_set(i32, &array, index, &num);
item = wapp_array_get(i32, &array, index);
result = result && item && *item == (i32)(index * 2);
++index;
running = index < count;
}
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_append_capped(void) {
TestFuncResult test_i32_array_append_capped(void) {
b8 result;
WpI32Array array = wpArrayWithCapacity(i32, 64, WP_ARRAY_INIT_NONE);
wpArrayAppendCapped(i32, array, &((i32){10}));
I32Array array = wapp_array_with_capacity(i32, I32Array, 64, false);
wapp_array_append_capped(i32, &array, &((i32){10}));
result = wpArrayCount(array) == 1;
i32 *item = wpArrayGet(i32, array, 0);
result = array.count == 1;
i32 *item = wapp_array_get(i32, &array, 0);
result = result && item && *item == 10;
array = wpArray(i32, 1);
wpArrayAppendCapped(i32, array, &((i32){10}));
array = wapp_array(i32, I32Array, 1);
wapp_array_append_capped(i32, &array, &((i32){10}));
result = result && wpArrayCount(array) == 2;
result = result && array.count == 2;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_extend_capped(void) {
TestFuncResult test_i32_array_extend_capped(void) {
b8 result;
WpI32Array array1 = wpArray(i32, 1, 2, 3, 4);
WpI32Array array2 = wpArray(i32, 10, 20);
I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4);
I32Array array2 = wapp_array(i32, I32Array, 10, 20);
result = wpArrayCount(array1) == 4 && wpArrayCount(array2) == 2;
result = array1.count == 4 && array2.count == 2;
wpArrayExtendCapped(i32, array1, array2);
wapp_array_extend_capped(i32, &array1, &array2);
result = result && wpArrayCount(array1) == 6;
result = result && array1.count == 6;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_copy_capped(void) {
TestFuncResult test_i32_array_copy_capped(void) {
b8 result;
WpI32Array src = wpArray(i32, 1, 2, 3, 4, 5);
WpI32Array dst1 = wpArray(i32, 1, 2, 3, 4, 5, 6);
WpI32Array dst2 = wpArray(i32, 1, 2);
I32Array src = wapp_array(i32, I32Array, 1, 2, 3, 4, 5);
I32Array dst1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6);
I32Array dst2 = wapp_array(i32, I32Array, 1, 2);
u64 expected_count = 5;
wpArrayCopyCapped(i32, dst1, src);
result = wpArrayCount(dst1) == expected_count;
wapp_array_copy_capped(i32, &dst1, &src);
result = dst1.count == expected_count;
u64 index = 0;
b8 running = true;
while (running) {
result = result && *wpArrayGet(i32, src, index) == *wpArrayGet(i32, dst1, index);
result = result && *wapp_array_get(i32, &src, index) == *wapp_array_get(i32, &dst1, index);
++index;
running = index < expected_count;
}
expected_count = 4;
wpArrayCopyCapped(i32, dst2, src);
result = result && wpArrayCount(dst2) == expected_count;
wapp_array_copy_capped(i32, &dst2, &src);
result = result && dst2.count == expected_count;
index = 0;
running = true;
while (running) {
result = result && *wpArrayGet(i32, src, index) == *wpArrayGet(i32, dst2, index);
result = result && *wapp_array_get(i32, &src, index) == *wapp_array_get(i32, &dst2, index);
++index;
running = index < expected_count;
}
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_alloc_capacity(void) {
TestFuncResult test_i32_array_alloc_capacity(void) {
b8 result;
WpAllocator allocator = wpMemArenaAllocatorInit(MiB(4));
Allocator allocator = wapp_mem_arena_allocator_init(MiB(4));
u64 capacity = 32;
WpI32Array array = wpArrayAllocCapacity(i32, &allocator, capacity, WP_ARRAY_INIT_NONE);
I32Array *array = wapp_array_alloc_capacity(i32, I32Array, &allocator, capacity, false);
result = array && wpArrayCapacity(array) == capacity;
result = array && array->capacity == capacity;
wpMemArenaAllocatorDestroy(&allocator);
wapp_mem_arena_allocator_destroy(&allocator);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_append_alloc(void) {
TestFuncResult test_i32_array_append_alloc(void) {
b8 result;
WpAllocator allocator = wpMemArenaAllocatorInit(MiB(4));
WpI32Array array1 = wpArray(i32, 1, 2, 3, 4, 5, 6, 7, 8);
WpI32Array array2 = wpArray(i32, 1, 2);
Allocator allocator = wapp_mem_arena_allocator_init(MiB(4));
I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7, 8);
I32Array array2 = wapp_array(i32, I32Array, 1, 2);
WpI32Array arr_ptr = wpArrayAppendAlloc(i32, &allocator, array1, &((i32){10}), WP_ARRAY_INIT_NONE);
result = arr_ptr == array1;
I32Array *arr_ptr = wapp_array_append_alloc(i32, I32Array, &allocator, &array1, &((i32){10}));
result = arr_ptr == &array1;
u64 count = 4;
u64 index = 0;
b8 running = true;
while (running) {
i32 num = (i32)index;
arr_ptr = wpArrayAppendAlloc(i32, &allocator, array2, &num, WP_ARRAY_INIT_NONE);
arr_ptr = wapp_array_append_alloc(i32, I32Array, &allocator, &array2, &num);
++index;
running = index < count;
}
result = result && arr_ptr != array2;
result = result && arr_ptr != &array2;
wpMemArenaAllocatorDestroy(&allocator);
wapp_mem_arena_allocator_destroy(&allocator);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_extend_alloc(void) {
TestFuncResult test_i32_array_extend_alloc(void) {
b8 result;
WpAllocator allocator = wpMemArenaAllocatorInit(MiB(4));
WpI32Array array1 = wpArray(i32, 1, 2, 3, 4, 5, 6, 7, 8);
WpI32Array array2 = wpArray(i32, 1, 2);
WpI32Array array3 = wpArray(i32, 1, 2, 3, 4);
Allocator allocator = wapp_mem_arena_allocator_init(MiB(4));
I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7, 8);
I32Array array2 = wapp_array(i32, I32Array, 1, 2);
I32Array array3 = wapp_array(i32, I32Array, 1, 2, 3, 4);
WpI32Array arr_ptr = wpArrayExtendAlloc(i32, &allocator, array1, array3, WP_ARRAY_INIT_NONE);
result = arr_ptr == array1;
I32Array *arr_ptr = wapp_array_extend_alloc(i32, I32Array, &allocator, &array1, &array3);
result = arr_ptr == &array1;
arr_ptr = wpArrayExtendAlloc(i32, &allocator, array2, array3, WP_ARRAY_INIT_NONE);
result = result && arr_ptr != array2;
arr_ptr = wapp_array_extend_alloc(i32, I32Array, &allocator, &array2, &array3);
result = result && arr_ptr != &array2;
wpMemArenaAllocatorDestroy(&allocator);
wapp_mem_arena_allocator_destroy(&allocator);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_copy_alloc(void) {
TestFuncResult test_i32_array_copy_alloc(void) {
b8 result;
WpAllocator allocator = wpMemArenaAllocatorInit(MiB(4));
WpI32Array src = wpArray(i32, 1, 2, 3, 4, 5);
WpI32Array dst1 = wpArray(i32, 1, 2, 3, 4, 5, 6);
WpI32Array dst2 = wpArray(i32, 1, 2);
WpI32Array array = NULL;
Allocator allocator = wapp_mem_arena_allocator_init(MiB(4));
I32Array src = wapp_array(i32, I32Array, 1, 2, 3, 4, 5);
I32Array dst1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6);
I32Array dst2 = wapp_array(i32, I32Array, 1, 2);
I32Array *array_ptr = NULL;
u64 expected_count = 5;
array = wpArrayCopyAlloc(i32, &allocator, dst1, src, WP_ARRAY_INIT_NONE);
result = wpArrayCount(array) == expected_count && array == dst1;
array_ptr = wapp_array_copy_alloc(i32, I32Array, &allocator, &dst1, &src);
result = array_ptr->count == expected_count && array_ptr == &dst1;
u64 index = 0;
b8 running = true;
while (running) {
result = result && *wpArrayGet(i32, src, index) == *wpArrayGet(i32, array, index);
result = result && *wapp_array_get(i32, &src, index) == *wapp_array_get(i32, array_ptr, index);
++index;
running = index < expected_count;
}
expected_count = 5;
array = wpArrayCopyAlloc(i32, &allocator, dst2, src, WP_ARRAY_INIT_NONE);
result = result && wpArrayCount(array) == expected_count && array != dst2;
array_ptr = wapp_array_copy_alloc(i32, I32Array, &allocator, &dst2, &src);
result = result && array_ptr->count == expected_count && array_ptr != &dst2;
index = 0;
running = true;
while (running) {
result = result && *wpArrayGet(i32, src, index) == *wpArrayGet(i32, array, index);
result = result && *wapp_array_get(i32, &src, index) == *wapp_array_get(i32, array_ptr, index);
++index;
running = index < expected_count;
}
wpMemArenaAllocatorDestroy(&allocator);
wapp_mem_arena_allocator_destroy(&allocator);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_pop(void) {
TestFuncResult test_i32_array_pop(void) {
b8 result;
WpI32Array array1 = wpArray(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8);
WpI32Array array2 = wpArrayWithCapacity(i32, 32, WP_ARRAY_INIT_NONE);
I32Array array1 = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8);
I32Array array2 = wapp_array_with_capacity(i32, I32Array, 32, false);
i32 item1 = wpArrayPop(i32, array1);
i32 item2 = wpArrayPop(i32, array2);
i32 item1 = wapp_array_pop(i32, &array1);
i32 item2 = wapp_array_pop(i32, &array2);
result = item1 == 8 && item2 == 0;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_clear(void) {
TestFuncResult test_i32_array_clear(void) {
b8 result;
WpI32Array array = wpArray(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8);
result = wpArrayCount(array) == 9;
I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8);
result = array.count == 9;
wpArrayClear(i32, array);
wapp_array_clear(i32, &array);
result = result && wpArrayCount(array) == 0;
result = result && array.count == 0;
return wpTesterResult(result);
return wapp_tester_result(result);
}
tests/array/test_i32_array.cc
+103 -103
View File
@@ -1,276 +1,276 @@
#include "test_i32_array.h"
#include "wapp.h"
WpTestFuncResult test_i32_array(void) {
TestFuncResult test_i32_array(void) {
b8 result;
WpI32Array array = wpArray(i32, 1, 2, 3, 4, 5, 6, 7);
result = wpArrayCount(array) == 7 && wpArrayCapacity(array) == 16;
I32Array array = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7);
result = array.count == 7 && array.capacity == 16;
i32 *item;
u64 count = wpArrayCount(array);
u64 count = array.count;
u64 index = 0;
b8 running = true;
while (running) {
item = wpArrayGet(i32, array, index);
item = wapp_array_get(i32, &array, index);
result = result && item && (*item == (i32)(index + 1));
++index;
running = index < count;
}
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_with_capacity(void) {
TestFuncResult test_i32_array_with_capacity(void) {
b8 result;
WpI32Array array1 = wpArrayWithCapacity(i32, 64, WP_ARRAY_INIT_NONE);
result = wpArrayCount(array1) == 0 && wpArrayCapacity(array1) == 64;
I32Array array1 = wapp_array_with_capacity(i32, I32Array, 64, false);
result = array1.count == 0 && array1.capacity == 64;
WpI32Array array2 = wpArrayWithCapacity(i32, 64, WP_ARRAY_INIT_FILLED);
result = wpArrayCount(array2) == 64 && wpArrayCapacity(array2) == 64;
I32Array array2 = wapp_array_with_capacity(i32, I32Array, 64, true);
result = array2.count == 64 && array2.capacity == 64;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_get(void) {
TestFuncResult test_i32_array_get(void) {
b8 result = true;
WpI32Array array = wpArray(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8);
I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8);
i32 *item;
u64 count = wpArrayCount(array);
u64 count = array.count;
u64 index = 0;
b8 running = true;
while (running) {
item = wpArrayGet(i32, array, index);
item = wapp_array_get(i32, &array, index);
result = result && item && (*item == (i32)index);
++index;
running = index < count;
}
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_set(void) {
TestFuncResult test_i32_array_set(void) {
b8 result = true;
WpI32Array array = wpArray(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8);
I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8);
i32 *item;
u64 count = wpArrayCount(array);
u64 count = array.count;
u64 index = 0;
b8 running = true;
while (running) {
i32 num = (i32)(index * 2);
wpArraySet(i32, array, index, &num);
item = wpArrayGet(i32, array, index);
wapp_array_set(i32, &array, index, &num);
item = wapp_array_get(i32, &array, index);
result = result && item && (*item == (i32)(index * 2));
++index;
running = index < count;
}
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_append_capped(void) {
TestFuncResult test_i32_array_append_capped(void) {
b8 result;
WpI32Array array = wpArrayWithCapacity(i32, 64, WP_ARRAY_INIT_NONE);
I32Array array = wapp_array_with_capacity(i32, I32Array, 64, false);
i32 item1 = 10;
wpArrayAppendCapped(i32, array, &item1);
wapp_array_append_capped(i32, &array, &item1);
result = wpArrayCount(array) == 1;
i32 *item = wpArrayGet(i32, array, 0);
result = array.count == 1;
i32 *item = wapp_array_get(i32, &array, 0);
result = result && item && *item == 10;
array = wpArray(i32, 1);
array = wapp_array(i32, I32Array, 1);
i32 item2 = 10;
wpArrayAppendCapped(i32, array, &item2);
wapp_array_append_capped(i32, &array, &item2);
result = result && wpArrayCount(array) == 2;
result = result && array.count == 2;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_extend_capped(void) {
TestFuncResult test_i32_array_extend_capped(void) {
b8 result;
WpI32Array array1 = wpArray(i32, 1, 2, 3, 4);
WpI32Array array2 = wpArray(i32, 10, 20);
I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4);
I32Array array2 = wapp_array(i32, I32Array, 10, 20);
result = wpArrayCount(array1) == 4 && wpArrayCount(array2) == 2;
result = array1.count == 4 && array2.count == 2;
wpArrayExtendCapped(i32, array1, array2);
wapp_array_extend_capped(i32, &array1, &array2);
result = result && wpArrayCount(array1) == 6;
result = result && array1.count == 6;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_copy_capped(void) {
TestFuncResult test_i32_array_copy_capped(void) {
b8 result;
WpI32Array src = wpArray(i32, 1, 2, 3, 4, 5);
WpI32Array dst1 = wpArray(i32, 1, 2, 3, 4, 5, 6);
WpI32Array dst2 = wpArray(i32, 1, 2);
I32Array src = wapp_array(i32, I32Array, 1, 2, 3, 4, 5);
I32Array dst1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6);
I32Array dst2 = wapp_array(i32, I32Array, 1, 2);
u64 expected_count = 5;
wpArrayCopyCapped(i32, dst1, src);
result = wpArrayCount(dst1) == expected_count;
wapp_array_copy_capped(i32, &dst1, &src);
result = dst1.count == expected_count;
u64 index = 0;
b8 running = true;
while (running) {
result = result && (*wpArrayGet(i32, src, index) == *wpArrayGet(i32, dst1, index));
result = result && (*wapp_array_get(i32, &src, index) == *wapp_array_get(i32, &dst1, index));
++index;
running = index < expected_count;
}
expected_count = 4;
wpArrayCopyCapped(i32, dst2, src);
result = result && wpArrayCount(dst2) == expected_count;
wapp_array_copy_capped(i32, &dst2, &src);
result = result && dst2.count == expected_count;
index = 0;
running = true;
while (running) {
result = result && (*wpArrayGet(i32, src, index) == *wpArrayGet(i32, dst2, index));
result = result && (*wapp_array_get(i32, &src, index) == *wapp_array_get(i32, &dst2, index));
++index;
running = index < expected_count;
}
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_alloc_capacity(void) {
TestFuncResult test_i32_array_alloc_capacity(void) {
b8 result;
WpAllocator allocator = wpMemArenaAllocatorInit(MiB(4));
Allocator allocator = wapp_mem_arena_allocator_init(MiB(4));
u64 capacity = 32;
WpI32Array array = wpArrayAllocCapacity(i32, &allocator, capacity, WP_ARRAY_INIT_NONE);
I32Array *array = wapp_array_alloc_capacity(i32, I32Array, &allocator, capacity, false);
result = array && wpArrayCapacity(array) == capacity;
result = array && array->capacity == capacity;
wpMemArenaAllocatorDestroy(&allocator);
wapp_mem_arena_allocator_destroy(&allocator);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_append_alloc(void) {
TestFuncResult test_i32_array_append_alloc(void) {
b8 result;
WpAllocator allocator = wpMemArenaAllocatorInit(MiB(4));
WpI32Array array1 = wpArray(i32, 1, 2, 3, 4, 5, 6, 7, 8);
WpI32Array array2 = wpArray(i32, 1, 2);
Allocator allocator = wapp_mem_arena_allocator_init(MiB(4));
I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7, 8);
I32Array array2 = wapp_array(i32, I32Array, 1, 2);
i32 num = 10;
WpI32Array arr_ptr = wpArrayAppendAlloc(i32, &allocator, array1, &num, WP_ARRAY_INIT_NONE);
result = arr_ptr == array1;
I32Array *arr_ptr = wapp_array_append_alloc(i32, I32Array, &allocator, &array1, &num);
result = arr_ptr == &array1;
u64 count = 4;
u64 index = 0;
b8 running = true;
while (running) {
num = (i32)index;
arr_ptr = wpArrayAppendAlloc(i32, &allocator, array2, &num, WP_ARRAY_INIT_NONE);
arr_ptr = wapp_array_append_alloc(i32, I32Array, &allocator, &array2, &num);
++index;
running = index < count;
}
result = result && arr_ptr != array2;
result = result && arr_ptr != &array2;
wpMemArenaAllocatorDestroy(&allocator);
wapp_mem_arena_allocator_destroy(&allocator);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_extend_alloc(void) {
TestFuncResult test_i32_array_extend_alloc(void) {
b8 result;
WpAllocator allocator = wpMemArenaAllocatorInit(MiB(4));
WpI32Array array1 = wpArray(i32, 1, 2, 3, 4, 5, 6, 7, 8);
WpI32Array array2 = wpArray(i32, 1, 2);
WpI32Array array3 = wpArray(i32, 1, 2, 3, 4);
Allocator allocator = wapp_mem_arena_allocator_init(MiB(4));
I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7, 8);
I32Array array2 = wapp_array(i32, I32Array, 1, 2);
I32Array array3 = wapp_array(i32, I32Array, 1, 2, 3, 4);
WpI32Array array = wpArrayExtendAlloc(i32, &allocator, array1, array3, WP_ARRAY_INIT_NONE);
result = array == array1;
I32Array *arr_ptr = wapp_array_extend_alloc(i32, I32Array, &allocator, &array1, &array3);
result = arr_ptr == &array1;
array = wpArrayExtendAlloc(i32, &allocator, array2, array3, WP_ARRAY_INIT_NONE);
result = result && array != array2;
arr_ptr = wapp_array_extend_alloc(i32, I32Array, &allocator, &array2, &array3);
result = result && arr_ptr != &array2;
wpMemArenaAllocatorDestroy(&allocator);
wapp_mem_arena_allocator_destroy(&allocator);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_copy_alloc(void) {
TestFuncResult test_i32_array_copy_alloc(void) {
b8 result;
WpAllocator allocator = wpMemArenaAllocatorInit(MiB(4));
WpI32Array src = wpArray(i32, 1, 2, 3, 4, 5);
WpI32Array dst1 = wpArray(i32, 1, 2, 3, 4, 5, 6);
WpI32Array dst2 = wpArray(i32, 1, 2);
WpI32Array array = nullptr;
Allocator allocator = wapp_mem_arena_allocator_init(MiB(4));
I32Array src = wapp_array(i32, I32Array, 1, 2, 3, 4, 5);
I32Array dst1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6);
I32Array dst2 = wapp_array(i32, I32Array, 1, 2);
I32Array *array_ptr = nullptr;
u64 expected_count = 5;
array = wpArrayCopyAlloc(i32, &allocator, dst1, src, WP_ARRAY_INIT_NONE);
result = wpArrayCount(array) == expected_count && array == dst1;
array_ptr = wapp_array_copy_alloc(i32, I32Array, &allocator, &dst1, &src);
result = array_ptr->count == expected_count && array_ptr == &dst1;
u64 index = 0;
b8 running = true;
while (running) {
result = result && (*wpArrayGet(i32, src, index) == *wpArrayGet(i32, array, index));
result = result && (*wapp_array_get(i32, &src, index) == *wapp_array_get(i32, array_ptr, index));
++index;
running = index < expected_count;
}
expected_count = 5;
array = wpArrayCopyAlloc(i32, &allocator, dst2, src, WP_ARRAY_INIT_NONE);
result = result && wpArrayCount(array) == expected_count && array != dst2;
array_ptr = wapp_array_copy_alloc(i32, I32Array, &allocator, &dst2, &src);
result = result && array_ptr->count == expected_count && array_ptr != &dst2;
index = 0;
running = true;
while (running) {
result = result && (*wpArrayGet(i32, src, index) == *wpArrayGet(i32, array, index));
result = result && (*wapp_array_get(i32, &src, index) == *wapp_array_get(i32, array_ptr, index));
++index;
running = index < expected_count;
}
wpMemArenaAllocatorDestroy(&allocator);
wapp_mem_arena_allocator_destroy(&allocator);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_clear(void) {
TestFuncResult test_i32_array_clear(void) {
b8 result;
WpI32Array array = wpArray(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8);
result = wpArrayCount(array) == 9;
I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8);
result = array.count == 9;
wpArrayClear(i32, array);
wapp_array_clear(i32, &array);
result = result && wpArrayCount(array) == 0;
result = result && array.count == 0;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_i32_array_pop(void) {
TestFuncResult test_i32_array_pop(void) {
b8 result;
WpI32Array array1 = wpArray(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8);
WpI32Array array2 = wpArrayWithCapacity(i32, 32, WP_ARRAY_INIT_NONE);
I32Array array1 = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8);
I32Array array2 = wapp_array_with_capacity(i32, I32Array, 32, false);
i32 item1 = wpArrayPop(i32, array1);
i32 item2 = wpArrayPop(i32, array2);
i32 item1 = wapp_array_pop(i32, &array1);
i32 item2 = wapp_array_pop(i32, &array2);
result = item1 == 8 && item2 == 0;
return wpTesterResult(result);
return wapp_tester_result(result);
}
tests/array/test_i32_array.h
+13 -13
View File
@@ -3,18 +3,18 @@
#include "wapp.h"
WpTestFuncResult test_i32_array(void);
WpTestFuncResult test_i32_array_with_capacity(void);
WpTestFuncResult test_i32_array_get(void);
WpTestFuncResult test_i32_array_set(void);
WpTestFuncResult test_i32_array_append_capped(void);
WpTestFuncResult test_i32_array_extend_capped(void);
WpTestFuncResult test_i32_array_copy_capped(void);
WpTestFuncResult test_i32_array_alloc_capacity(void);
WpTestFuncResult test_i32_array_append_alloc(void);
WpTestFuncResult test_i32_array_extend_alloc(void);
WpTestFuncResult test_i32_array_copy_alloc(void);
WpTestFuncResult test_i32_array_pop(void);
WpTestFuncResult test_i32_array_clear(void);
TestFuncResult test_i32_array(void);
TestFuncResult test_i32_array_with_capacity(void);
TestFuncResult test_i32_array_get(void);
TestFuncResult test_i32_array_set(void);
TestFuncResult test_i32_array_append_capped(void);
TestFuncResult test_i32_array_extend_capped(void);
TestFuncResult test_i32_array_copy_capped(void);
TestFuncResult test_i32_array_alloc_capacity(void);
TestFuncResult test_i32_array_append_alloc(void);
TestFuncResult test_i32_array_extend_alloc(void);
TestFuncResult test_i32_array_copy_alloc(void);
TestFuncResult test_i32_array_pop(void);
TestFuncResult test_i32_array_clear(void);
#endif // !TEST_INT_ARRAY_H
tests/array/test_str8_array.c
+9 -9
View File
@@ -2,24 +2,24 @@
#include "test_str8_array.h"
WpTestFuncResult test_str8_array(void) {
TestFuncResult test_str8_array(void) {
b8 result;
WpStr8 expected[] = {wpStr8Lit("Hello"), wpStr8Lit("Hi"), wpStr8Lit("Bye")};
WpStr8Array array = wpArray(WpStr8, wpStr8Lit("Hello"), wpStr8Lit("Hi"), wpStr8Lit("Bye"));
result = wpArrayCount(array) == 3 && wpArrayCapacity(array) == 8;
Str8 expected[] = {wapp_str8_lit("Hello"), wapp_str8_lit("Hi"), wapp_str8_lit("Bye")};
Str8Array array = wapp_array(Str8, Str8Array, wapp_str8_lit("Hello"), wapp_str8_lit("Hi"), wapp_str8_lit("Bye"));
result = array.count == 3 && array.capacity == 8;
WpStr8 *item;
u64 count = wpArrayCount(array);
Str8 *item;
u64 count = array.count;
u64 index = 0;
b8 running = true;
while (running) {
item = wpArrayGet(WpStr8, array, index);
result = result && item && (wpStr8Equal(item, &expected[index]));
item = wapp_array_get(Str8, &array, index);
result = result && item && (wapp_str8_equal(item, &expected[index]));
++index;
running = index < count;
}
return wpTesterResult(result);
return wapp_tester_result(result);
}
tests/array/test_str8_array.cc
+12 -12
View File
@@ -2,29 +2,29 @@
#include "test_str8_array.h"
WpTestFuncResult test_str8_array(void) {
TestFuncResult test_str8_array(void) {
b8 result;
WpStr8 expected[] = {wpStr8Lit("Hello"), wpStr8Lit("Hi"), wpStr8Lit("Bye")};
Str8 expected[] = {wapp_str8_lit("Hello"), wapp_str8_lit("Hi"), wapp_str8_lit("Bye")};
WpStr8 str1 = wpStr8Lit("Hello");
WpStr8 str2 = wpStr8Lit("Hi");
WpStr8 str3 = wpStr8Lit("Bye");
WpStr8Array array = wpArray(WpStr8, str1, str2, str3);
Str8 str1 = wapp_str8_lit("Hello");
Str8 str2 = wapp_str8_lit("Hi");
Str8 str3 = wapp_str8_lit("Bye");
Str8Array array = wapp_array(Str8, Str8Array, str1, str2, str3);
result = wpArrayCount(array) == 3 && wpArrayCapacity(array) == 8;
result = array.count == 3 && array.capacity == 8;
WpStr8 *item;
u64 count = wpArrayCount(array);
Str8 *item;
u64 count = array.count;
u64 index = 0;
b8 running = true;
while (running) {
item = wpArrayGet(WpStr8, array, index);
result = result && item && (wpStr8Equal(item, &expected[index]));
item = wapp_array_get(Str8, &array, index);
result = result && item && (wapp_str8_equal(item, &expected[index]));
++index;
running = index < count;
}
return wpTesterResult(result);
return wapp_tester_result(result);
}
tests/array/test_str8_array.h
+1 -1
View File
@@ -5,6 +5,6 @@
#include "wapp.h"
WpTestFuncResult test_str8_array(void);
TestFuncResult test_str8_array(void);
#endif // !TEST_STR8_ARRAY_H
tests/cpath/test_cpath.c
+102 -102
View File
@@ -6,176 +6,176 @@
#define MAIN_BUF_SIZE 4096
#define TMP_BUF_SIZE 1024
WpTestFuncResult test_cpath_join_path(void) {
TestFuncResult test_cpath_join_path(void) {
b8 result;
WpStr8 expected = wpStr8Buf(MAIN_BUF_SIZE);
WpStr8 out = wpStr8Buf(MAIN_BUF_SIZE);
WpStr8 tmp = wpStr8Buf(TMP_BUF_SIZE);
Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE);
Str8 out = wapp_str8_buf(MAIN_BUF_SIZE);
Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE);
wpStr8Format(&expected, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP);
wpStr8Format(&tmp, "%c", WP_PATH_SEP);
wapp_str8_format(&expected, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
wapp_str8_format(&tmp, "%c", WAPP_PATH_SEP);
WpStr8List parts = wpDblList(WpStr8);
wpDblListPushBack(WpStr8, &parts, &tmp);
wpDblListPushBack(WpStr8, &parts, &wpStr8Lit("home"));
wpDblListPushBack(WpStr8, &parts, &wpStr8Lit("abdelrahman"));
wpDblListPushBack(WpStr8, &parts, &wpStr8Lit("Documents"));
Str8List parts = wapp_dbl_list(Str8, Str8List);
wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_str8(tmp));
wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr("home"));
wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr("abdelrahman"));
wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr("Documents"));
wpCpathJoinPath(&out, &parts);
result = wpStr8Equal(&out, &expected);
wapp_cpath_join_path(&out, &parts);
result = wapp_str8_equal(&out, &expected);
wpDblListPopFront(WpStr8, &parts);
wapp_dbl_list_pop_front(Str8, Str8Node, &parts);
wpStr8Format(&expected, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP);
wapp_str8_format(&expected, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP);
wpCpathJoinPath(&out, &parts);
result = result && wpStr8Equal(&out, &expected);
wapp_cpath_join_path(&out, &parts);
result = result && wapp_str8_equal(&out, &expected);
wpStr8ConcatCapped(&tmp, &wpStr8LitRo("home"));
wpDblListPopFront(WpStr8, &parts);
wpDblListPushFront(WpStr8, &parts, &tmp);
wapp_str8_concat_capped(&tmp, &wapp_str8_lit_ro("home"));
wapp_dbl_list_pop_front(Str8, Str8Node, &parts);
wapp_dbl_list_push_front(Str8, &parts, &wapp_str8_node_from_str8(tmp));
wpStr8Format(&expected, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP);
wapp_str8_format(&expected, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
wpCpathJoinPath(&out, &parts);
result = result && wpStr8Equal(&out, &expected);
wapp_cpath_join_path(&out, &parts);
result = result && wapp_str8_equal(&out, &expected);
wpStr8Format(&tmp, "home%c", WP_PATH_SEP);
wpDblListPopFront(WpStr8, &parts);
wpDblListPushFront(WpStr8, &parts, &wpStr8Lit("home"));
wapp_str8_format(&tmp, "home%c", WAPP_PATH_SEP);
wapp_dbl_list_pop_front(Str8, Str8Node, &parts);
wapp_dbl_list_push_front(Str8, &parts, &wapp_str8_node_from_cstr("home"));
wpStr8Format(&expected, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP);
wapp_str8_format(&expected, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP);
wpCpathJoinPath(&out, &parts);
result = result && wpStr8Equal(&out, &expected);
wapp_cpath_join_path(&out, &parts);
result = result && wapp_str8_equal(&out, &expected);
wpDblListEmpty(WpStr8, &parts);
wapp_dbl_list_empty(Str8, &parts);
wpStr8Format(&tmp, "%chome", WP_PATH_SEP);
wpDblListPushBack(WpStr8, &parts, &tmp);
wpDblListPushBack(WpStr8, &parts, &wpStr8Lit(""));
wapp_str8_format(&tmp, "%chome", WAPP_PATH_SEP);
wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_str8(tmp));
wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr(""));
wpStr8Format(&expected, "%chome", WP_PATH_SEP);
wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP);
wpCpathJoinPath(&out, &parts);
result = result && wpStr8Equal(&out, &expected);
wapp_cpath_join_path(&out, &parts);
result = result && wapp_str8_equal(&out, &expected);
wpDblListPopFront(WpStr8, &parts);
wpDblListPushBack(WpStr8, &parts, &wpStr8Lit(""));
wapp_dbl_list_pop_front(Str8, Str8Node, &parts);
wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr(""));
wpStr8Format(&expected, "%s", "");
wapp_str8_format(&expected, "%s", "");
wpCpathJoinPath(&out, &parts);
result = result && wpStr8Equal(&out, &expected);
wapp_cpath_join_path(&out, &parts);
result = result && wapp_str8_equal(&out, &expected);
wpDblListPopBack(WpStr8, &parts);
wpDblListPushBack(WpStr8, &parts, &wpStr8Lit("home"));
wapp_dbl_list_pop_back(Str8, Str8Node, &parts);
wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr("home"));
wpStr8CopyCstrCapped(&expected, "home");
wapp_str8_copy_cstr_capped(&expected, "home");
wpCpathJoinPath(&out, &parts);
result = result && wpStr8Equal(&out, &expected);
wapp_cpath_join_path(&out, &parts);
result = result && wapp_str8_equal(&out, &expected);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_cpath_dirname(void) {
WpAllocator arena = wpMemArenaAllocatorInit(MiB(8));
if (wpMemAllocatorInvalid(&arena)) {
return wpTesterResult(false);
TestFuncResult test_cpath_dirname(void) {
Allocator arena = wapp_mem_arena_allocator_init(MiB(8));
if (wapp_mem_allocator_invalid(&arena)) {
return wapp_tester_result(false);
}
b8 result;
WpStr8 *output = NULL;
Str8 *output = NULL;
WpStr8 expected = wpStr8Buf(MAIN_BUF_SIZE);
WpStr8 tmp = wpStr8Buf(TMP_BUF_SIZE);
Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE);
Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE);
// CASE 1
wpStr8Format(&tmp, "%c", WP_PATH_SEP);
wpStr8Format(&expected, "%c", WP_PATH_SEP);
wapp_str8_format(&tmp, "%c", WAPP_PATH_SEP);
wapp_str8_format(&expected, "%c", WAPP_PATH_SEP);
output = wpCpathDirname(&arena, &tmp);
result = output != NULL && wpStr8Equal(output, &expected);
output = wapp_cpath_dirname(&arena, &tmp);
result = output != NULL && wapp_str8_equal(output, &expected);
// CASE 2
wpStr8Format(&expected, "%s", ".");
wapp_str8_format(&expected, "%s", ".");
output = wpCpathDirname(&arena, &wpStr8Lit("home"));
result = result && output != NULL && wpStr8Equal(output, &expected);
output = wapp_cpath_dirname(&arena, &wapp_str8_lit("home"));
result = result && output != NULL && wapp_str8_equal(output, &expected);
// CASE 3
output = wpCpathDirname(&arena, &wpStr8Lit(""));
result = result && output != NULL && wpStr8Equal(output, &expected);
output = wapp_cpath_dirname(&arena, &wapp_str8_lit(""));
result = result && output != NULL && wapp_str8_equal(output, &expected);
// CASE 4
wpStr8Format(&tmp, "%chome%ctest", WP_PATH_SEP, WP_PATH_SEP);
wpStr8Format(&expected, "%chome", WP_PATH_SEP);
wapp_str8_format(&tmp, "%chome%ctest", WAPP_PATH_SEP, WAPP_PATH_SEP);
wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP);
output = wpCpathDirname(&arena, &tmp);
result = result && output != NULL && wpStr8Equal(output, &expected);
output = wapp_cpath_dirname(&arena, &tmp);
result = result && output != NULL && wapp_str8_equal(output, &expected);
// CASE 5
wpStr8Format(&tmp, "%chome%ctest%c", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP);
wpStr8Format(&expected, "%chome", WP_PATH_SEP);
wapp_str8_format(&tmp, "%chome%ctest%c", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP);
output = wpCpathDirname(&arena, &tmp);
result = result && output != NULL && wpStr8Equal(output, &expected);
output = wapp_cpath_dirname(&arena, &tmp);
result = result && output != NULL && wapp_str8_equal(output, &expected);
wpMemArenaAllocatorDestroy(&arena);
wapp_mem_arena_allocator_destroy(&arena);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_cpath_dirup(void) {
WpAllocator arena = wpMemArenaAllocatorInit(MiB(8));
if (wpMemAllocatorInvalid(&arena)) {
return wpTesterResult(false);
TestFuncResult test_cpath_dirup(void) {
Allocator arena = wapp_mem_arena_allocator_init(MiB(8));
if (wapp_mem_allocator_invalid(&arena)) {
return wapp_tester_result(false);
}
b8 result;
WpStr8 *output = NULL;
Str8 *output = NULL;
WpStr8 expected = wpStr8Buf(MAIN_BUF_SIZE);
WpStr8 tmp = wpStr8Buf(TMP_BUF_SIZE);
Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE);
Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE);
// CASE 1
wpStr8Format(&tmp, "%c", WP_PATH_SEP);
wpStr8Format(&expected, "%c", WP_PATH_SEP);
wapp_str8_format(&tmp, "%c", WAPP_PATH_SEP);
wapp_str8_format(&expected, "%c", WAPP_PATH_SEP);
output = wpCpathDirup(&arena, &tmp, 3);
result = output != NULL && wpStr8Equal(output, &expected);
output = wapp_cpath_dirup(&arena, &tmp, 3);
result = output != NULL && wapp_str8_equal(output, &expected);
// CASE 2
wpStr8Format(&tmp, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP);
wpStr8Format(&expected, "%c", WP_PATH_SEP);
wapp_str8_format(&tmp, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
wapp_str8_format(&expected, "%c", WAPP_PATH_SEP);
output = wpCpathDirup(&arena, &tmp, 3);
result = result && output != NULL && wpStr8Equal(output, &expected);
output = wapp_cpath_dirup(&arena, &tmp, 3);
result = result && output != NULL && wapp_str8_equal(output, &expected);
// CASE 3
wpStr8Format(&tmp, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP);
wpStr8CopyCstrCapped(&expected, ".");
wapp_str8_format(&tmp, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP);
wapp_str8_copy_cstr_capped(&expected, ".");
output = wpCpathDirup(&arena, &tmp, 3);
result = result && output != NULL && wpStr8Equal(output, &expected);
output = wapp_cpath_dirup(&arena, &tmp, 3);
result = result && output != NULL && wapp_str8_equal(output, &expected);
// CASE 4
wpStr8Format(&tmp, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP);
wpStr8Format(&expected, "%chome", WP_PATH_SEP);
wapp_str8_format(&tmp, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP);
output = wpCpathDirup(&arena, &tmp, 2);
result = result && output != NULL && wpStr8Equal(output, &expected);
output = wapp_cpath_dirup(&arena, &tmp, 2);
result = result && output != NULL && wapp_str8_equal(output, &expected);
// CASE 5
wpStr8Format(&tmp, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP);
wpStr8CopyCstrCapped(&expected, "home");
wapp_str8_format(&tmp, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP);
wapp_str8_copy_cstr_capped(&expected, "home");
output = wpCpathDirup(&arena, &tmp, 2);
result = result && output != NULL && wpStr8Equal(output, &expected);
output = wapp_cpath_dirup(&arena, &tmp, 2);
result = result && output != NULL && wapp_str8_equal(output, &expected);
wpMemArenaAllocatorDestroy(&arena);
wapp_mem_arena_allocator_destroy(&arena);
return wpTesterResult(result);
return wapp_tester_result(result);
}
tests/cpath/test_cpath.cc
+115 -112
View File
@@ -6,196 +6,199 @@
#define MAIN_BUF_SIZE 4096
#define TMP_BUF_SIZE 1024
WpTestFuncResult test_cpath_join_path(void) {
TestFuncResult test_cpath_join_path(void) {
b8 result;
WpStr8 expected = wpStr8Buf(MAIN_BUF_SIZE);
WpStr8 out = wpStr8Buf(MAIN_BUF_SIZE);
WpStr8 tmp = wpStr8Buf(TMP_BUF_SIZE);
Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE);
Str8 out = wapp_str8_buf(MAIN_BUF_SIZE);
Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE);
wpStr8Format(&expected, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP);
wpStr8Format(&tmp, "%c", WP_PATH_SEP);
wapp_str8_format(&expected, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
wapp_str8_format(&tmp, "%c", WAPP_PATH_SEP);
WpStr8List parts = wpDblList(WpStr8);
Str8List parts = wapp_dbl_list(Str8, Str8List);
wpDblListPushBack(WpStr8, &parts, &tmp);
Str8Node tmp_node = wapp_str8_node_from_str8(tmp);
wapp_dbl_list_push_back(Str8, &parts, &tmp_node);
WpStr8 home = wpStr8Lit("home");
wpDblListPushBack(WpStr8, &parts, &home);
Str8Node home_node = wapp_str8_node_from_cstr("home");
wapp_dbl_list_push_back(Str8, &parts, &home_node);
WpStr8 user = wpStr8Lit("abdelrahman");
wpDblListPushBack(WpStr8, &parts, &user);
Str8Node user_node = wapp_str8_node_from_cstr("abdelrahman");
wapp_dbl_list_push_back(Str8, &parts, &user_node);
WpStr8 docs = wpStr8Lit("Documents");
wpDblListPushBack(WpStr8, &parts, &docs);
Str8Node docs_node = wapp_str8_node_from_cstr("Documents");
wapp_dbl_list_push_back(Str8, &parts, &docs_node);
wpCpathJoinPath(&out, &parts);
result = wpStr8Equal(&out, &expected);
wapp_cpath_join_path(&out, &parts);
result = wapp_str8_equal(&out, &expected);
wpDblListPopFront(WpStr8, &parts);
wapp_dbl_list_pop_front(Str8, Str8Node, &parts);
wpStr8Format(&expected, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP);
wapp_str8_format(&expected, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP);
wpCpathJoinPath(&out, &parts);
result = result && wpStr8Equal(&out, &expected);
wapp_cpath_join_path(&out, &parts);
result = result && wapp_str8_equal(&out, &expected);
WpStr8RO str = wpStr8LitRo("home");
wpStr8ConcatCapped(&tmp, &str);
wpDblListPopFront(WpStr8, &parts);
Str8RO str = wapp_str8_lit_ro("home");
wapp_str8_concat_capped(&tmp, &str);
wapp_dbl_list_pop_front(Str8, Str8Node, &parts);
wpDblListPushFront(WpStr8, &parts, &tmp);
Str8Node tmp_node_2 = wapp_str8_node_from_str8(tmp);
wapp_dbl_list_push_front(Str8, &parts, &tmp_node_2);
wpStr8Format(&expected, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP);
wapp_str8_format(&expected, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
wpCpathJoinPath(&out, &parts);
result = result && wpStr8Equal(&out, &expected);
wapp_cpath_join_path(&out, &parts);
result = result && wapp_str8_equal(&out, &expected);
wpStr8Format(&tmp, "home%c", WP_PATH_SEP);
wpDblListPopFront(WpStr8, &parts);
wapp_str8_format(&tmp, "home%c", WAPP_PATH_SEP);
wapp_dbl_list_pop_front(Str8, Str8Node, &parts);
WpStr8 home_2 = wpStr8Lit("home");
wpDblListPushFront(WpStr8, &parts, &home_2);
Str8Node home_node_2 = wapp_str8_node_from_cstr("home");
wapp_dbl_list_push_front(Str8, &parts, &home_node_2);
wpStr8Format(&expected, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP);
wapp_str8_format(&expected, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP);
wpCpathJoinPath(&out, &parts);
result = result && wpStr8Equal(&out, &expected);
wapp_cpath_join_path(&out, &parts);
result = result && wapp_str8_equal(&out, &expected);
wpDblListEmpty(WpStr8, &parts);
wapp_dbl_list_empty(Str8, &parts);
wpStr8Format(&tmp, "%chome", WP_PATH_SEP);
wapp_str8_format(&tmp, "%chome", WAPP_PATH_SEP);
wpDblListPushBack(WpStr8, &parts, &tmp);
Str8Node tmp_node_3 = wapp_str8_node_from_str8(tmp);
wapp_dbl_list_push_back(Str8, &parts, &tmp_node_3);
WpStr8 empty = wpStr8Lit("");
wpDblListPushBack(WpStr8, &parts, &empty);
Str8Node empty_node = wapp_str8_node_from_cstr("");
wapp_dbl_list_push_back(Str8, &parts, &empty_node);
wpStr8Format(&expected, "%chome", WP_PATH_SEP);
wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP);
wpCpathJoinPath(&out, &parts);
result = result && wpStr8Equal(&out, &expected);
wapp_cpath_join_path(&out, &parts);
result = result && wapp_str8_equal(&out, &expected);
wpDblListPopFront(WpStr8, &parts);
wapp_dbl_list_pop_front(Str8, Str8Node, &parts);
WpStr8 empty_2 = wpStr8Lit("");
wpDblListPushBack(WpStr8, &parts, &empty_2);
Str8Node empty_node_2 = wapp_str8_node_from_cstr("");
wapp_dbl_list_push_back(Str8, &parts, &empty_node_2);
wpStr8Format(&expected, "%s", "");
wapp_str8_format(&expected, "%s", "");
wpCpathJoinPath(&out, &parts);
result = result && wpStr8Equal(&out, &expected);
wapp_cpath_join_path(&out, &parts);
result = result && wapp_str8_equal(&out, &expected);
wpDblListPopBack(WpStr8, &parts);
wapp_dbl_list_pop_back(Str8, Str8Node, &parts);
WpStr8 home_3 = wpStr8Lit("home");
wpDblListPushBack(WpStr8, &parts, &home_3);
Str8Node home_node_3 = wapp_str8_node_from_cstr("home");
wapp_dbl_list_push_back(Str8, &parts, &home_node_3);
wpStr8CopyCstrCapped(&expected, "home");
wapp_str8_copy_cstr_capped(&expected, "home");
wpCpathJoinPath(&out, &parts);
result = result && wpStr8Equal(&out, &expected);
wapp_cpath_join_path(&out, &parts);
result = result && wapp_str8_equal(&out, &expected);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_cpath_dirname(void) {
WpAllocator arena = wpMemArenaAllocatorInit(MiB(8));
if (wpMemAllocatorInvalid(&arena)) {
return wpTesterResult(false);
TestFuncResult test_cpath_dirname(void) {
Allocator arena = wapp_mem_arena_allocator_init(MiB(8));
if (wapp_mem_allocator_invalid(&arena)) {
return wapp_tester_result(false);
}
b8 result;
WpStr8 *output = nullptr;
Str8 *output = nullptr;
WpStr8 expected = wpStr8Buf(MAIN_BUF_SIZE);
WpStr8 tmp = wpStr8Buf(TMP_BUF_SIZE);
Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE);
Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE);
// CASE 1
wpStr8Format(&tmp, "%c", WP_PATH_SEP);
wpStr8Format(&expected, "%c", WP_PATH_SEP);
wapp_str8_format(&tmp, "%c", WAPP_PATH_SEP);
wapp_str8_format(&expected, "%c", WAPP_PATH_SEP);
output = wpCpathDirname(&arena, &tmp);
result = output != nullptr && wpStr8Equal(output, &expected);
output = wapp_cpath_dirname(&arena, &tmp);
result = output != nullptr && wapp_str8_equal(output, &expected);
// CASE 2
wpStr8Format(&expected, "%s", ".");
wapp_str8_format(&expected, "%s", ".");
WpStr8 path = wpStr8Lit("home");
output = wpCpathDirname(&arena, &path);
result = result && output != nullptr && wpStr8Equal(output, &expected);
Str8 path = wapp_str8_lit("home");
output = wapp_cpath_dirname(&arena, &path);
result = result && output != nullptr && wapp_str8_equal(output, &expected);
// CASE 3
path = wpStr8Lit("");
output = wpCpathDirname(&arena, &path);
result = result && output != nullptr && wpStr8Equal(output, &expected);
path = wapp_str8_lit("");
output = wapp_cpath_dirname(&arena, &path);
result = result && output != nullptr && wapp_str8_equal(output, &expected);
// CASE 4
wpStr8Format(&tmp, "%chome%ctest", WP_PATH_SEP, WP_PATH_SEP);
wpStr8Format(&expected, "%chome", WP_PATH_SEP);
wapp_str8_format(&tmp, "%chome%ctest", WAPP_PATH_SEP, WAPP_PATH_SEP);
wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP);
output = wpCpathDirname(&arena, &tmp);
result = result && output != nullptr && wpStr8Equal(output, &expected);
output = wapp_cpath_dirname(&arena, &tmp);
result = result && output != nullptr && wapp_str8_equal(output, &expected);
// CASE 5
wpStr8Format(&tmp, "%chome%ctest%c", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP);
wpStr8Format(&expected, "%chome", WP_PATH_SEP);
wapp_str8_format(&tmp, "%chome%ctest%c", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP);
output = wpCpathDirname(&arena, &tmp);
result = result && output != nullptr && wpStr8Equal(output, &expected);
output = wapp_cpath_dirname(&arena, &tmp);
result = result && output != nullptr && wapp_str8_equal(output, &expected);
wpMemArenaAllocatorDestroy(&arena);
wapp_mem_arena_allocator_destroy(&arena);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_cpath_dirup(void) {
WpAllocator arena = wpMemArenaAllocatorInit(MiB(8));
if (wpMemAllocatorInvalid(&arena)) {
return wpTesterResult(false);
TestFuncResult test_cpath_dirup(void) {
Allocator arena = wapp_mem_arena_allocator_init(MiB(8));
if (wapp_mem_allocator_invalid(&arena)) {
return wapp_tester_result(false);
}
b8 result;
WpStr8 *output = nullptr;
Str8 *output = nullptr;
WpStr8 expected = wpStr8Buf(MAIN_BUF_SIZE);
WpStr8 tmp = wpStr8Buf(TMP_BUF_SIZE);
Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE);
Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE);
// CASE 1
wpStr8Format(&tmp, "%c", WP_PATH_SEP);
wpStr8Format(&expected, "%c", WP_PATH_SEP);
wapp_str8_format(&tmp, "%c", WAPP_PATH_SEP);
wapp_str8_format(&expected, "%c", WAPP_PATH_SEP);
output = wpCpathDirup(&arena, &tmp, 3);
result = output != nullptr && wpStr8Equal(output, &expected);
output = wapp_cpath_dirup(&arena, &tmp, 3);
result = output != nullptr && wapp_str8_equal(output, &expected);
// CASE 2
wpStr8Format(&tmp, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP);
wpStr8Format(&expected, "%c", WP_PATH_SEP);
wapp_str8_format(&tmp, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
wapp_str8_format(&expected, "%c", WAPP_PATH_SEP);
output = wpCpathDirup(&arena, &tmp, 3);
result = result && output != nullptr && wpStr8Equal(output, &expected);
output = wapp_cpath_dirup(&arena, &tmp, 3);
result = result && output != nullptr && wapp_str8_equal(output, &expected);
// CASE 3
wpStr8Format(&tmp, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP);
wpStr8CopyCstrCapped(&expected, ".");
wapp_str8_format(&tmp, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP);
wapp_str8_copy_cstr_capped(&expected, ".");
output = wpCpathDirup(&arena, &tmp, 3);
result = result && output != nullptr && wpStr8Equal(output, &expected);
output = wapp_cpath_dirup(&arena, &tmp, 3);
result = result && output != nullptr && wapp_str8_equal(output, &expected);
// CASE 4
wpStr8Format(&tmp, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP);
wpStr8Format(&expected, "%chome", WP_PATH_SEP);
wapp_str8_format(&tmp, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP);
output = wpCpathDirup(&arena, &tmp, 2);
result = result && output != nullptr && wpStr8Equal(output, &expected);
output = wapp_cpath_dirup(&arena, &tmp, 2);
result = result && output != nullptr && wapp_str8_equal(output, &expected);
// CASE 5
wpStr8Format(&tmp, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP);
wpStr8CopyCstrCapped(&expected, "home");
wapp_str8_format(&tmp, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP);
wapp_str8_copy_cstr_capped(&expected, "home");
output = wpCpathDirup(&arena, &tmp, 2);
result = result && output != nullptr && wpStr8Equal(output, &expected);
output = wapp_cpath_dirup(&arena, &tmp, 2);
result = result && output != nullptr && wapp_str8_equal(output, &expected);
wpMemArenaAllocatorDestroy(&arena);
wapp_mem_arena_allocator_destroy(&arena);
return wpTesterResult(result);
return wapp_tester_result(result);
}
tests/cpath/test_cpath.h
+3 -3
View File
@@ -3,8 +3,8 @@
#include "wapp.h"
WpTestFuncResult test_cpath_join_path(void);
WpTestFuncResult test_cpath_dirname(void);
WpTestFuncResult test_cpath_dirup(void);
TestFuncResult test_cpath_join_path(void);
TestFuncResult test_cpath_dirname(void);
TestFuncResult test_cpath_dirup(void);
#endif // !TEST_CPATH_H
tests/file/test_file.c
-118
View File
@@ -1,118 +0,0 @@
// vim:fileencoding=utf-8:foldmethod=marker
#include "test_file.h"
#define DST_CAPACITY 5
wp_intern WpAllocator arena = {0};
wp_intern WpStr8RO test_filename = wpStr8LitRoInitialiserList("wapptest.bin");
wp_intern WpStr8RO new_filename = wpStr8LitRoInitialiserList("wapptest2.bin");
wp_intern WpFile *test_fp = NULL;
wp_intern WpI32Array src_array1 = wpArray(i32, 0, 1, 2, 3, 4);
wp_intern WpI32Array src_array2 = wpArray(i32, 5, 6, 7, 8, 9);
wp_intern WpI32Array src_array3 = wpArray(i32, 10, 11, 12, 13, 14);
wp_intern WpI32Array dst_array = wpArrayWithCapacity(i32, DST_CAPACITY, false);
wp_intern i32 dst_buf[DST_CAPACITY] = {0};
WpTestFuncResult test_wapp_file_open(void) {
arena = wpMemArenaAllocatorInit(KiB(16));
test_fp = wpFileOpen(&arena, &test_filename, WP_ACCESS_WRITE_EX);
return wpTesterResult(test_fp != NULL);
}
WpTestFuncResult test_wapp_file_get_current_position(void) {
i64 pos = wpFileGetCurrentPosition(test_fp);
return wpTesterResult(pos == 0);
}
WpTestFuncResult test_wapp_file_seek(void) {
wpFileWriteArray((WpArray)src_array1, test_fp, wpArrayCount(src_array1));
i64 seek_result = wpFileSeek(test_fp, 0, WP_SEEK_END);
b8 result = seek_result == (i64)(wpArrayCount(src_array1) * wpArrayItemSize(src_array1));
wpFileSeek(test_fp, 0, WP_SEEK_START);
return wpTesterResult(result);
}
WpTestFuncResult test_wapp_file_get_length(void) {
i64 length = wpFileGetLength(test_fp);
return wpTesterResult(length == (i64)(wpArrayCount(src_array1) * wpArrayItemSize(src_array1)));
}
WpTestFuncResult test_wapp_file_read(void) {
wpFileSeek(test_fp, 0, WP_SEEK_START);
u64 byte_count = DST_CAPACITY * sizeof(i32);
u64 count = wpFileRead((void *)dst_buf, test_fp, byte_count);
b8 result = count == byte_count;
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
u64 index = 0;
b8 running = true;
while (running) {
result = result && (dst_buf[index] == *wpArrayGet(i32, src_array1, index));
++index;
running = index < DST_CAPACITY;
}
return wpTesterResult(result);
}
WpTestFuncResult test_wapp_file_write(void) {
wpFileSeek(test_fp, 0, WP_SEEK_END);
u64 expected_count = wpArrayCount(src_array2) * wpArrayItemSize(src_array2);
i64 count = wpFileWrite((void *)src_array2, test_fp, expected_count);
return wpTesterResult(count >= 0 && (u64)count == expected_count);
}
WpTestFuncResult test_wapp_file_read_array(void) {
wpFileSeek(test_fp, 0, WP_SEEK_START);
u64 count = wpFileReadArray((WpArray)dst_array, test_fp, wpArrayCount(src_array1));
b8 result = count == wpArrayCount(src_array1) &&
wpArrayCount(dst_array) == wpArrayCount(src_array1);
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
u64 index = 0;
b8 running = true;
while (running) {
result = result && (*wpArrayGet(i32, dst_array, index) == *wpArrayGet(i32, src_array1, index));
++index;
running = index < wpArrayCount(dst_array);
}
return wpTesterResult(result);
}
WpTestFuncResult test_wapp_file_write_array(void) {
wpFileSeek(test_fp, 0, WP_SEEK_END);
i64 count = wpFileWriteArray((WpArray)src_array3, test_fp, wpArrayCount(src_array3));
return wpTesterResult(count >= 0 && (u64)count == wpArrayCount(src_array3));
}
WpTestFuncResult test_wapp_file_flush(void) {
i32 flush_result = wpFileFlush(test_fp);
return wpTesterResult(flush_result == 0);
}
WpTestFuncResult test_wapp_file_close(void) {
i32 close_result = wpFileClose(test_fp);
return wpTesterResult(close_result == 0);
}
WpTestFuncResult test_wapp_file_rename(void) {
i32 rename_result = wpFileRename(&test_filename, &new_filename);
return wpTesterResult(rename_result == 0);
}
WpTestFuncResult test_wapp_file_remove(void) {
i32 remove_result = wpFileRemove(&new_filename);
return wpTesterResult(remove_result == 0);
}
tests/file/test_file.cc
-122
View File
@@ -1,122 +0,0 @@
// vim:fileencoding=utf-8:foldmethod=marker
#include "test_file.h"
#define DST_CAPACITY 5
wp_intern WpAllocator arena = {};
wp_intern WpStr8RO test_filename = wpStr8LitRoInitialiserList("wapptest.bin");
wp_intern WpStr8RO new_filename = wpStr8LitRoInitialiserList("wapptest2.bin");
wp_intern WpFile *test_fp = NULL;
wp_intern i32 dst_buf[DST_CAPACITY] = {0};
wp_intern WpI32Array src_array1;
wp_intern WpI32Array src_array2;
wp_intern WpI32Array src_array3;
wp_intern WpI32Array dst_array ;
WpTestFuncResult test_wapp_file_open(void) {
arena = wpMemArenaAllocatorInit(KiB(16));
src_array1 = wpArray(i32, 0, 1, 2, 3, 4);
src_array2 = wpArray(i32, 5, 6, 7, 8, 9);
src_array3 = wpArray(i32, 10, 11, 12, 13, 14);
dst_array = wpArrayWithCapacity(i32, DST_CAPACITY, false);
test_fp = wpFileOpen(&arena, &test_filename, WP_ACCESS_WRITE_EX);
return wpTesterResult(test_fp != NULL);
}
WpTestFuncResult test_wapp_file_get_current_position(void) {
i64 pos = wpFileGetCurrentPosition(test_fp);
return wpTesterResult(pos == 0);
}
WpTestFuncResult test_wapp_file_seek(void) {
wpFileWriteArray((WpArray)src_array1, test_fp, wpArrayCount(src_array1));
i64 seek_result = wpFileSeek(test_fp, 0, WP_SEEK_END);
b8 result = seek_result == (i64)(wpArrayCount(src_array1) * wpArrayItemSize(src_array1));
wpFileSeek(test_fp, 0, WP_SEEK_START);
return wpTesterResult(result);
}
WpTestFuncResult test_wapp_file_get_length(void) {
i64 length = wpFileGetLength(test_fp);
return wpTesterResult(length == (i64)(wpArrayCount(src_array1) * wpArrayItemSize(src_array1)));
}
WpTestFuncResult test_wapp_file_read(void) {
wpFileSeek(test_fp, 0, WP_SEEK_START);
u64 byte_count = DST_CAPACITY * sizeof(i32);
u64 count = wpFileRead((void *)dst_buf, test_fp, byte_count);
b8 result = count == byte_count;
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
u64 index = 0;
b8 running = true;
while (running) {
result = result && (dst_buf[index] == *wpArrayGet(i32, src_array1, index));
++index;
running = index < DST_CAPACITY;
}
return wpTesterResult(result);
}
WpTestFuncResult test_wapp_file_write(void) {
wpFileSeek(test_fp, 0, WP_SEEK_END);
u64 expected_count = wpArrayCount(src_array2) * wpArrayItemSize(src_array2);
i64 count = wpFileWrite((void *)src_array2, test_fp, expected_count);
return wpTesterResult(count >= 0 && (u64)count == expected_count);
}
WpTestFuncResult test_wapp_file_read_array(void) {
wpFileSeek(test_fp, 0, WP_SEEK_START);
u64 count = wpFileReadArray((WpArray)dst_array, test_fp, wpArrayCount(src_array1));
b8 result = count == wpArrayCount(src_array1) &&
wpArrayCount(dst_array) == wpArrayCount(src_array1);
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
u64 index = 0;
b8 running = true;
while (running) {
result = result && (*wpArrayGet(i32, dst_array, index) == *wpArrayGet(i32, src_array1, index));
++index;
running = index < wpArrayCount(dst_array);
}
return wpTesterResult(result);
}
WpTestFuncResult test_wapp_file_write_array(void) {
wpFileSeek(test_fp, 0, WP_SEEK_END);
i64 count = wpFileWriteArray((WpArray)src_array3, test_fp, wpArrayCount(src_array3));
return wpTesterResult(count >= 0 && (u64)count == wpArrayCount(src_array3));
}
WpTestFuncResult test_wapp_file_flush(void) {
i32 flush_result = wpFileFlush(test_fp);
return wpTesterResult(flush_result == 0);
}
WpTestFuncResult test_wapp_file_close(void) {
i32 close_result = wpFileClose(test_fp);
return wpTesterResult(close_result == 0);
}
WpTestFuncResult test_wapp_file_rename(void) {
i32 rename_result = wpFileRename(&test_filename, &new_filename);
return wpTesterResult(rename_result == 0);
}
WpTestFuncResult test_wapp_file_remove(void) {
i32 remove_result = wpFileRemove(&new_filename);
return wpTesterResult(remove_result == 0);
}
tests/file/test_file.h
-21
View File
@@ -1,21 +0,0 @@
// vim:fileencoding=utf-8:foldmethod=marker
#ifndef TEST_FILE_H
#define TEST_FILE_H
#include "wapp.h"
WpTestFuncResult test_wapp_file_open(void);
WpTestFuncResult test_wapp_file_get_current_position(void);
WpTestFuncResult test_wapp_file_seek(void);
WpTestFuncResult test_wapp_file_get_length(void);
WpTestFuncResult test_wapp_file_read(void);
WpTestFuncResult test_wapp_file_write(void);
WpTestFuncResult test_wapp_file_read_array(void);
WpTestFuncResult test_wapp_file_write_array(void);
WpTestFuncResult test_wapp_file_flush(void);
WpTestFuncResult test_wapp_file_close(void);
WpTestFuncResult test_wapp_file_rename(void);
WpTestFuncResult test_wapp_file_remove(void);
#endif // !TEST_FILE_H
tests/queue/test_queue.c
-98
View File
@@ -1,98 +0,0 @@
// vim:fileencoding=utf-8:foldmethod=marker
#include "wapp.h"
#include "test_queue.h"
#define CAPACITY 8
WpTestFuncResult test_queue_push(void) {
WpI32Queue queue = wpQueue(i32, CAPACITY);
for (u64 i = 0; i < CAPACITY; ++i) {
i32 item = (i32)i;
wpQueuePush(i32, &queue, &item);
}
b8 result = true;
for (u64 i = 0; i < CAPACITY; ++i) {
i32 *value = ((i32 *)(queue.items)) + i;
result = result && value != NULL && *value == (i32)i;
}
return wpTesterResult(result);
}
WpTestFuncResult test_queue_push_alloc(void) {
WpAllocator arena = wpMemArenaAllocatorInit(MiB(64));
WpI32Queue queue = wpQueue(i32, CAPACITY);
for (u64 i = 0; i < CAPACITY; ++i) {
i32 item = (i32)i;
wpQueuePush(i32, &queue, &item);
}
b8 result = true;
i32 item = 8;
u64 new_capacity = CAPACITY * 2;
WpI32Queue *new_queue = wpQueuePushAlloc(i32, &arena, &queue, &item);
if (new_queue && new_queue != &queue) {
queue = *new_queue;
}
u64 capacity = wpQueueCapacity(&queue);
result = result && capacity == new_capacity;
for (u64 i = 0; i < 2; ++i) {
wpQueuePop(i32, &queue);
}
u64 remaining = wpQueueCapacity(&queue) - queue.count;
for (u64 i = 0; i < remaining; ++i) {
item = (i32)(remaining + i);
wpQueuePush(i32, &queue, &item);
}
++item;
new_queue = wpQueuePushAlloc(i32, &arena, &queue, &item);
if (new_queue && new_queue != &queue) {
queue = *new_queue;
}
result = result && wpQueueCapacity(&queue) == new_capacity * 2;
i32 *arr = (i32 *)queue.items;
for (u64 i = 0; i < queue.count; ++i) {
// NOTE (Abdelrahman): First queue value is currently 2
result = result && arr[i] == (i32)(2 + i);
}
wpMemArenaAllocatorDestroy(&arena);
return wpTesterResult(result);
}
WpTestFuncResult test_queue_pop(void) {
WpI32Queue queue = wpQueue(i32, CAPACITY);
for (u64 i = 0; i < CAPACITY; ++i) {
i32 item = (i32)i;
wpQueuePush(i32, &queue, &item);
}
b8 result = true;
u64 half_count = queue.count / 2;
for (u64 i = 0; i < half_count; ++i) {
i32 *value = wpQueuePop(i32, &queue);
result = result && value != NULL && *value == (i32)i;
}
for (u64 i = 0; i < half_count; ++i) {
i32 item = (i32)i + CAPACITY;
wpQueuePush(i32, &queue, &item);
}
for (u64 i = 0; i < CAPACITY; ++i) {
i32 *value = wpQueuePop(i32, &queue);
result = result && value != NULL && *value == (i32)half_count + (i32)i;
}
return wpTesterResult(result);
}
tests/queue/test_queue.cc
-96
View File
@@ -1,96 +0,0 @@
#include "wapp.h"
#include "test_queue.h"
#define CAPACITY 8
WpTestFuncResult test_queue_push(void) {
WpI32Queue queue = wpQueue(i32, CAPACITY);
for (u64 i = 0; i < CAPACITY; ++i) {
i32 item = (i32)i;
wpQueuePush(i32, &queue, &item);
}
b8 result = true;
for (u64 i = 0; i < CAPACITY; ++i) {
i32 *value = ((i32 *)(queue.items)) + i;
result = result && value != NULL && *value == (i32)i;
}
return wpTesterResult(result);
}
WpTestFuncResult test_queue_push_alloc(void) {
WpAllocator arena = wpMemArenaAllocatorInit(MiB(64));
WpI32Queue queue = wpQueue(i32, CAPACITY);
for (u64 i = 0; i < CAPACITY; ++i) {
i32 item = (i32)i;
wpQueuePush(i32, &queue, &item);
}
b8 result = true;
i32 item = 8;
u64 new_capacity = CAPACITY * 2;
WpI32Queue *new_queue = wpQueuePushAlloc(i32, &arena, &queue, &item);
if (new_queue && new_queue != &queue) {
queue = *new_queue;
}
u64 capacity = wpQueueCapacity(&queue);
result = result && capacity == new_capacity;
for (u64 i = 0; i < 2; ++i) {
wpQueuePop(i32, &queue);
}
u64 remaining = wpQueueCapacity(&queue) - queue.count;
for (u64 i = 0; i < remaining; ++i) {
item = (i32)(remaining + i);
wpQueuePush(i32, &queue, &item);
}
++item;
new_queue = wpQueuePushAlloc(i32, &arena, &queue, &item);
if (new_queue && new_queue != &queue) {
queue = *new_queue;
}
result = result && wpQueueCapacity(&queue) == new_capacity * 2;
i32 *arr = (i32 *)queue.items;
for (u64 i = 0; i < queue.count; ++i) {
// NOTE (Abdelrahman): First queue value is currently 2
result = result && arr[i] == (i32)(2 + i);
}
wpMemArenaAllocatorDestroy(&arena);
return wpTesterResult(result);
}
WpTestFuncResult test_queue_pop(void) {
WpI32Queue queue = wpQueue(i32, CAPACITY);
for (u64 i = 0; i < CAPACITY; ++i) {
i32 item = (i32)i;
wpQueuePush(i32, &queue, &item);
}
b8 result = true;
u64 half_count = queue.count / 2;
for (u64 i = 0; i < half_count; ++i) {
i32 *value = wpQueuePop(i32, &queue);
result = result && value != NULL && *value == (i32)i;
}
for (u64 i = 0; i < half_count; ++i) {
i32 item = (i32)i + CAPACITY;
wpQueuePush(i32, &queue, &item);
}
for (u64 i = 0; i < CAPACITY; ++i) {
i32 *value = wpQueuePop(i32, &queue);
result = result && value != NULL && *value == (i32)half_count + (i32)i;
}
return wpTesterResult(result);
}
tests/queue/test_queue.h
-12
View File
@@ -1,12 +0,0 @@
// vim:fileencoding=utf-8:foldmethod=marker
#ifndef TEST_QUEUE_H
#define TEST_QUEUE_H
#include "wapp.h"
WpTestFuncResult test_queue_push(void);
WpTestFuncResult test_queue_push_alloc(void);
WpTestFuncResult test_queue_pop(void);
#endif // !TEST_QUEUE_H
tests/shell_commander/test_shell_commander.c
+33 -33
View File
@@ -4,59 +4,59 @@
#include <stdlib.h>
#include <string.h>
WpTestFuncResult test_commander_cmd_success(void) {
WpStr8List cmd = wpDblList(WpStr8);
wpDblListPushBack(WpStr8, &cmd, &wpStr8Lit("echo"));
wpDblListPushBack(WpStr8, &cmd, &wpStr8Lit("hello world"));
TestFuncResult test_commander_cmd_success(void) {
Str8List cmd = wapp_dbl_list(Str8, Str8List);
wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr("echo"));
wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr("hello world"));
WpCmdResult result = wpShellCommanderExecute(WP_SHELL_OUTPUT_DISCARD, NULL, &cmd);
CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, NULL, &cmd);
b8 succeeded = result.exited && result.exit_code == EXIT_SUCCESS &&
result.error == WP_SHELL_ERR_NO_ERROR;
result.error == SHELL_ERR_NO_ERROR;
return wpTesterResult(succeeded);
return wapp_tester_result(succeeded);
}
WpTestFuncResult test_commander_cmd_failure(void) {
WpStr8List cmd = wpDblList(WpStr8);
wpDblListPushBack(WpStr8, &cmd, &wpStr8Lit("grep"));
TestFuncResult test_commander_cmd_failure(void) {
Str8List cmd = wapp_dbl_list(Str8, Str8List);
wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr("grep"));
WpCmdResult result = wpShellCommanderExecute(WP_SHELL_OUTPUT_DISCARD, NULL, &cmd);
CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, NULL, &cmd);
b8 failed = result.exited && result.exit_code != EXIT_SUCCESS &&
result.error == WP_SHELL_ERR_NO_ERROR;
result.error == SHELL_ERR_NO_ERROR;
return wpTesterResult(failed);
return wapp_tester_result(failed);
}
WpTestFuncResult test_commander_cmd_out_buf_success(void) {
WpStr8 buf = wpStr8Buf(64);
WpStr8 expected = wpStr8Buf(64);
TestFuncResult test_commander_cmd_out_buf_success(void) {
Str8 buf = wapp_str8_buf(64);
Str8 expected = wapp_str8_buf(64);
char msg[] = "hello world";
wpStr8CopyCstrCapped(&expected, msg);
wapp_str8_copy_cstr_capped(&expected, msg);
WpStr8List cmd = wpDblList(WpStr8);
wpDblListPushBack(WpStr8, &cmd, &wpStr8Lit("echo"));
wpDblListPushBack(WpStr8, &cmd, &wpStr8Lit(msg));
Str8List cmd = wapp_dbl_list(Str8, Str8List);
wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr("echo"));
wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr(msg));
WpCmdResult result = wpShellCommanderExecute(WP_SHELL_OUTPUT_CAPTURE, &buf, &cmd);
CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd);
b8 succeeded = result.exited && result.exit_code == EXIT_SUCCESS &&
result.error == WP_SHELL_ERR_NO_ERROR && wpStr8EqualToCount(&buf, &expected, strlen(msg));
result.error == SHELL_ERR_NO_ERROR && wapp_str8_equal_to_count(&buf, &expected, strlen(msg));
return wpTesterResult(succeeded);
return wapp_tester_result(succeeded);
}
WpTestFuncResult test_commander_cmd_out_buf_failure(void) {
WpStr8 buf = wpStr8Buf(4);
WpStr8 expected = wpStr8Buf(64);
TestFuncResult test_commander_cmd_out_buf_failure(void) {
Str8 buf = wapp_str8_buf(4);
Str8 expected = wapp_str8_buf(64);
char msg[] = "hello world";
wpStr8CopyCstrCapped(&expected, msg);
wapp_str8_copy_cstr_capped(&expected, msg);
WpStr8List cmd = wpDblList(WpStr8);
wpDblListPushBack(WpStr8, &cmd, &wpStr8Lit("echo"));
wpDblListPushBack(WpStr8, &cmd, &wpStr8Lit(msg));
Str8List cmd = wapp_dbl_list(Str8, Str8List);
wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr("echo"));
wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr(msg));
WpCmdResult result = wpShellCommanderExecute(WP_SHELL_OUTPUT_CAPTURE, &buf, &cmd);
CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd);
b8 failed = !result.exited && result.exit_code != EXIT_SUCCESS &&
result.error == WP_SHELL_ERR_OUT_BUF_FULL && !wpStr8Equal(&buf, &expected);
result.error == SHELL_ERR_OUT_BUF_FULL && !wapp_str8_equal(&buf, &expected);
return wpTesterResult(failed);
return wapp_tester_result(failed);
}
tests/shell_commander/test_shell_commander.cc
+40 -40
View File
@@ -4,66 +4,66 @@
#include <stdlib.h>
#include <string.h>
WpTestFuncResult test_commander_cmd_success(void) {
WpStr8List cmd = wpDblList(WpStr8);
WpStr8 echo = wpStr8Lit("echo");
WpStr8 msg = wpStr8Lit("hello world");
wpDblListPushBack(WpStr8, &cmd, &echo);
wpDblListPushBack(WpStr8, &cmd, &msg);
TestFuncResult test_commander_cmd_success(void) {
Str8List cmd = wapp_dbl_list(Str8, Str8List);
Str8Node echo = wapp_str8_node_from_cstr("echo");
Str8Node msg = wapp_str8_node_from_cstr("hello world");
wapp_dbl_list_push_back(Str8, &cmd, &echo);
wapp_dbl_list_push_back(Str8, &cmd, &msg);
WpCmdResult result = wpShellCommanderExecute(WP_SHELL_OUTPUT_DISCARD, nullptr, &cmd);
CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, nullptr, &cmd);
b8 succeeded = result.exited && result.exit_code == EXIT_SUCCESS &&
result.error == WP_SHELL_ERR_NO_ERROR;
result.error == SHELL_ERR_NO_ERROR;
return wpTesterResult(succeeded);
return wapp_tester_result(succeeded);
}
WpTestFuncResult test_commander_cmd_failure(void) {
WpStr8List cmd = wpDblList(WpStr8);
WpStr8 grep = wpStr8Lit("grep");
wpDblListPushBack(WpStr8, &cmd, &grep);
TestFuncResult test_commander_cmd_failure(void) {
Str8List cmd = wapp_dbl_list(Str8, Str8List);
Str8Node grep = wapp_str8_node_from_cstr("grep");
wapp_dbl_list_push_back(Str8, &cmd, &grep);
WpCmdResult result = wpShellCommanderExecute(WP_SHELL_OUTPUT_DISCARD, nullptr, &cmd);
CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, nullptr, &cmd);
b8 failed = result.exited && result.exit_code != EXIT_SUCCESS &&
result.error == WP_SHELL_ERR_NO_ERROR;
result.error == SHELL_ERR_NO_ERROR;
return wpTesterResult(failed);
return wapp_tester_result(failed);
}
WpTestFuncResult test_commander_cmd_out_buf_success(void) {
WpStr8 buf = wpStr8Buf(64);
WpStr8 expected = wpStr8Buf(64);
TestFuncResult test_commander_cmd_out_buf_success(void) {
Str8 buf = wapp_str8_buf(64);
Str8 expected = wapp_str8_buf(64);
char msg[] = "hello world";
wpStr8CopyCstrCapped(&expected, msg);
wapp_str8_copy_cstr_capped(&expected, msg);
WpStr8List cmd = wpDblList(WpStr8);
WpStr8 echo = wpStr8Lit("echo");
WpStr8 arg = wpStr8Lit(msg);
wpDblListPushBack(WpStr8, &cmd, &echo);
wpDblListPushBack(WpStr8, &cmd, &arg);
Str8List cmd = wapp_dbl_list(Str8, Str8List);
Str8Node echo = wapp_str8_node_from_cstr("echo");
Str8Node arg = wapp_str8_node_from_cstr(msg);
wapp_dbl_list_push_back(Str8, &cmd, &echo);
wapp_dbl_list_push_back(Str8, &cmd, &arg);
WpCmdResult result = wpShellCommanderExecute(WP_SHELL_OUTPUT_CAPTURE, &buf, &cmd);
CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd);
b8 succeeded = result.exited && result.exit_code == EXIT_SUCCESS &&
result.error == WP_SHELL_ERR_NO_ERROR && wpStr8EqualToCount(&buf, &expected, strlen(msg));
result.error == SHELL_ERR_NO_ERROR && wapp_str8_equal_to_count(&buf, &expected, strlen(msg));
return wpTesterResult(succeeded);
return wapp_tester_result(succeeded);
}
WpTestFuncResult test_commander_cmd_out_buf_failure(void) {
WpStr8 buf = wpStr8Buf(4);
WpStr8 expected = wpStr8Buf(64);
TestFuncResult test_commander_cmd_out_buf_failure(void) {
Str8 buf = wapp_str8_buf(4);
Str8 expected = wapp_str8_buf(64);
char msg[] = "hello world";
wpStr8CopyCstrCapped(&expected, msg);
wapp_str8_copy_cstr_capped(&expected, msg);
WpStr8List cmd = wpDblList(WpStr8);
WpStr8 echo = wpStr8Lit("echo");
WpStr8 arg = wpStr8Lit(msg);
wpDblListPushBack(WpStr8, &cmd, &echo);
wpDblListPushBack(WpStr8, &cmd, &arg);
Str8List cmd = wapp_dbl_list(Str8, Str8List);
Str8Node echo = wapp_str8_node_from_cstr("echo");
Str8Node arg = wapp_str8_node_from_cstr(msg);
wapp_dbl_list_push_back(Str8, &cmd, &echo);
wapp_dbl_list_push_back(Str8, &cmd, &arg);
WpCmdResult result = wpShellCommanderExecute(WP_SHELL_OUTPUT_CAPTURE, &buf, &cmd);
CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd);
b8 failed = !result.exited && result.exit_code != EXIT_SUCCESS &&
result.error == WP_SHELL_ERR_OUT_BUF_FULL && !wpStr8Equal(&buf, &expected);
result.error == SHELL_ERR_OUT_BUF_FULL && !wapp_str8_equal(&buf, &expected);
return wpTesterResult(failed);
return wapp_tester_result(failed);
}
tests/shell_commander/test_shell_commander.h
+4 -4
View File
@@ -3,9 +3,9 @@
#include "wapp.h"
WpTestFuncResult test_commander_cmd_success(void);
WpTestFuncResult test_commander_cmd_failure(void);
WpTestFuncResult test_commander_cmd_out_buf_success(void);
WpTestFuncResult test_commander_cmd_out_buf_failure(void);
TestFuncResult test_commander_cmd_success(void);
TestFuncResult test_commander_cmd_failure(void);
TestFuncResult test_commander_cmd_out_buf_success(void);
TestFuncResult test_commander_cmd_out_buf_failure(void);
#endif // !TEST_SHELL_COMMANDER_H
tests/str8/test_str8.c
+298 -298
View File
@@ -3,88 +3,88 @@
#define ARRLEN(ARR) (sizeof(ARR) / sizeof(ARR[0]))
WpTestFuncResult test_str8_lit(void) {
TestFuncResult test_str8_lit(void) {
b8 result;
WpStr8 s1 = wpStr8Lit("Hello world");
Str8 s1 = wapp_str8_lit("Hello world");
result = s1.capacity == 22 && s1.capacity != s1.size;
WpStr8 s2 = wpStr8Lit("Different strokes for different folks");
Str8 s2 = wapp_str8_lit("Different strokes for different folks");
result = result && s2.capacity == 74 && s2.capacity != s2.size;
WpStr8 s3 = wpStr8Lit("Discretion is the better part of valour");
Str8 s3 = wapp_str8_lit("Discretion is the better part of valour");
result = result && s3.capacity == 78 && s3.capacity != s3.size;
WpStr8 s4 = wpStr8Lit("Distance lends enchantment to the view");
Str8 s4 = wapp_str8_lit("Distance lends enchantment to the view");
result = result && s4.capacity == 76 && s4.capacity != s4.size;
WpStr8 s5 = wpStr8Lit("Do as I say, not as I do");
Str8 s5 = wapp_str8_lit("Do as I say, not as I do");
result = result && s5.capacity == 48 && s5.capacity != s5.size;
WpStr8 s6 = wpStr8Lit("Do as you would be done by");
Str8 s6 = wapp_str8_lit("Do as you would be done by");
result = result && s6.capacity == 52 && s6.capacity != s6.size;
WpStr8 s7 = wpStr8Lit("Do unto others as you would have them do to you");
Str8 s7 = wapp_str8_lit("Do unto others as you would have them do to you");
result = result && s7.capacity == 94 && s7.capacity != s7.size;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_lit_ro(void) {
TestFuncResult test_str8_lit_ro(void) {
b8 result;
WpStr8RO s1 = wpStr8LitRo("Hello world");
Str8RO s1 = wapp_str8_lit_ro("Hello world");
result = s1.capacity == 11 && s1.capacity == s1.size;
WpStr8RO s2 = wpStr8LitRo("Different strokes for different folks");
Str8RO s2 = wapp_str8_lit_ro("Different strokes for different folks");
result = result && s2.capacity == 37 && s2.capacity == s2.size;
WpStr8RO s3 = wpStr8LitRo("Discretion is the better part of valour");
Str8RO s3 = wapp_str8_lit_ro("Discretion is the better part of valour");
result = result && s3.capacity == 39 && s3.capacity == s3.size;
WpStr8RO s4 = wpStr8LitRo("Distance lends enchantment to the view");
Str8RO s4 = wapp_str8_lit_ro("Distance lends enchantment to the view");
result = result && s4.capacity == 38 && s4.capacity == s4.size;
WpStr8RO s5 = wpStr8LitRo("Do as I say, not as I do");
Str8RO s5 = wapp_str8_lit_ro("Do as I say, not as I do");
result = result && s5.capacity == 24 && s5.capacity == s5.size;
WpStr8RO s6 = wpStr8LitRo("Do as you would be done by");
Str8RO s6 = wapp_str8_lit_ro("Do as you would be done by");
result = result && s6.capacity == 26 && s6.capacity == s6.size;
WpStr8RO s7 = wpStr8LitRo("Do unto others as you would have them do to you");
Str8RO s7 = wapp_str8_lit_ro("Do unto others as you would have them do to you");
result = result && s7.capacity == 47 && s7.capacity == s7.size;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_buf(void) {
TestFuncResult test_str8_buf(void) {
b8 result;
WpStr8 s1 = wpStr8Buf(1024);
Str8 s1 = wapp_str8_buf(1024);
result = s1.capacity == 1024 && s1.size == 0;
WpStr8 s2 = wpStr8Buf(2048);
Str8 s2 = wapp_str8_buf(2048);
result = result && s2.capacity == 2048 && s2.size == 0;
WpStr8 s3 = wpStr8Buf(4096);
Str8 s3 = wapp_str8_buf(4096);
result = result && s3.capacity == 4096 && s3.size == 0;
WpStr8 s4 = wpStr8Buf(8192);
Str8 s4 = wapp_str8_buf(8192);
result = result && s4.capacity == 8192 && s4.size == 0;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_alloc_buf(void) {
TestFuncResult test_str8_alloc_buf(void) {
b8 result;
WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100));
if (wpMemAllocatorInvalid(&allocator)) {
return wpTesterResult(false);
Allocator allocator = wapp_mem_arena_allocator_init(KiB(100));
if (wapp_mem_allocator_invalid(&allocator)) {
return wapp_tester_result(false);
}
u64 capacity = 4096;
WpStr8 *s = wpStr8AllocBuf(&allocator, capacity);
Str8 *s = wapp_str8_alloc_buf(&allocator, capacity);
if (!s) {
result = false;
goto TEST_ALLOC_BUF_CLEANUP;
@@ -93,340 +93,340 @@ WpTestFuncResult test_str8_alloc_buf(void) {
result = s->capacity == capacity;
const char *cstr = "My name is Abdelrahman";
wpStr8CopyCstrCapped(s, cstr);
wapp_str8_copy_cstr_capped(s, cstr);
result = result && s->capacity == capacity && s->size == strlen(cstr) && memcmp(s->buf, cstr, s->size) == 0;
TEST_ALLOC_BUF_CLEANUP:
wpMemArenaAllocatorDestroy(&allocator);
wapp_mem_arena_allocator_destroy(&allocator);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_alloc_cstr(void) {
TestFuncResult test_str8_alloc_cstr(void) {
b8 result;
WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100));
if (wpMemAllocatorInvalid(&allocator)) {
return wpTesterResult(false);
Allocator allocator = wapp_mem_arena_allocator_init(KiB(100));
if (wapp_mem_allocator_invalid(&allocator)) {
return wapp_tester_result(false);
}
char *str = "Abdelrahman";
u64 length = strlen(str);
WpStr8 *s = wpStr8AllocCstr(&allocator, str);
Str8 *s = wapp_str8_alloc_cstr(&allocator, str);
if (!s) {
return wpTesterResult(false);
return wapp_tester_result(false);
}
result = s->size == length && memcmp(s->buf, str, length) == 0;
wpMemArenaAllocatorDestroy(&allocator);
wapp_mem_arena_allocator_destroy(&allocator);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_alloc_str8(void) {
TestFuncResult test_str8_alloc_str8(void) {
b8 result;
WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100));
if (wpMemAllocatorInvalid(&allocator)) {
return wpTesterResult(false);
Allocator allocator = wapp_mem_arena_allocator_init(KiB(100));
if (wapp_mem_allocator_invalid(&allocator)) {
return wapp_tester_result(false);
}
WpStr8 str = wpStr8Lit("Abdelrahman");
WpStr8 *s = wpStr8AllocStr8(&allocator, &str);
Str8 str = wapp_str8_lit("Abdelrahman");
Str8 *s = wapp_str8_alloc_str8(&allocator, &str);
if (!s) {
return wpTesterResult(false);
return wapp_tester_result(false);
}
result = wpStr8Equal(s, &str);
result = wapp_str8_equal(s, &str);
wpMemArenaAllocatorDestroy(&allocator);
wapp_mem_arena_allocator_destroy(&allocator);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_alloc_substr(void) {
TestFuncResult test_str8_alloc_substr(void) {
b8 result;
WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100));
if (wpMemAllocatorInvalid(&allocator)) {
return wpTesterResult(false);
Allocator allocator = wapp_mem_arena_allocator_init(KiB(100));
if (wapp_mem_allocator_invalid(&allocator)) {
return wapp_tester_result(false);
}
WpStr8 str = wpStr8Lit("Abdelrahman");
WpStr8 *s = wpStr8AllocSubstr(&allocator, &str, 3, 8);
Str8 str = wapp_str8_lit("Abdelrahman");
Str8 *s = wapp_str8_alloc_substr(&allocator, &str, 3, 8);
if (!s) {
return wpTesterResult(false);
return wapp_tester_result(false);
}
result = s->size == 5 && memcmp(s->buf, "elrah", s->size) == 0;
wpMemArenaAllocatorDestroy(&allocator);
wapp_mem_arena_allocator_destroy(&allocator);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_get_index_within_bounds(void) {
TestFuncResult test_str8_get_index_within_bounds(void) {
b8 result;
WpStr8RO s1 = wpStr8LitRo("Hello world");
result = wpStr8Get(&s1, 4) == 'o';
Str8RO s1 = wapp_str8_lit_ro("Hello world");
result = wapp_str8_get(&s1, 4) == 'o';
WpStr8RO s2 = wpStr8LitRo("Different strokes for different folks");
result = result && wpStr8Get(&s2, 0) == 'D';
Str8RO s2 = wapp_str8_lit_ro("Different strokes for different folks");
result = result && wapp_str8_get(&s2, 0) == 'D';
WpStr8RO s3 = wpStr8LitRo("Discretion is the better part of valour");
result = result && wpStr8Get(&s3, 13) == ' ';
Str8RO s3 = wapp_str8_lit_ro("Discretion is the better part of valour");
result = result && wapp_str8_get(&s3, 13) == ' ';
WpStr8RO s4 = wpStr8LitRo("Distance lends enchantment to the view");
result = result && wpStr8Get(&s4, 20) == 'n';
Str8RO s4 = wapp_str8_lit_ro("Distance lends enchantment to the view");
result = result && wapp_str8_get(&s4, 20) == 'n';
WpStr8RO s5 = wpStr8LitRo("Do as I say, not as I do");
result = result && wpStr8Get(&s5, 11) == ',';
Str8RO s5 = wapp_str8_lit_ro("Do as I say, not as I do");
result = result && wapp_str8_get(&s5, 11) == ',';
WpStr8RO s6 = wpStr8LitRo("Do as you would be done by");
result = result && wpStr8Get(&s6, 25) == 'y';
Str8RO s6 = wapp_str8_lit_ro("Do as you would be done by");
result = result && wapp_str8_get(&s6, 25) == 'y';
WpStr8RO s7 = wpStr8LitRo("Do unto others as you would have them do to you");
result = result && wpStr8Get(&s7, 16) == 's';
Str8RO s7 = wapp_str8_lit_ro("Do unto others as you would have them do to you");
result = result && wapp_str8_get(&s7, 16) == 's';
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_get_index_out_of_bounds(void) {
WpStr8 s1 = wpStr8Lit("Hello world");
b8 result = wpStr8Get(&s1, 20) == '\0';
return wpTesterResult(result);
TestFuncResult test_str8_get_index_out_of_bounds(void) {
Str8 s1 = wapp_str8_lit("Hello world");
b8 result = wapp_str8_get(&s1, 20) == '\0';
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_set(void) {
TestFuncResult test_str8_set(void) {
b8 result;
WpStr8 s1 = wpStr8Lit("Hello world");
wpStr8Set(&s1, 4, 'f');
result = wpStr8Get(&s1, 4) == 'f';
Str8 s1 = wapp_str8_lit("Hello world");
wapp_str8_set(&s1, 4, 'f');
result = wapp_str8_get(&s1, 4) == 'f';
WpStr8 s2 = wpStr8Lit("Different strokes for different folks");
wpStr8Set(&s2, 0, 'A');
result = result && wpStr8Get(&s2, 0) == 'A';
Str8 s2 = wapp_str8_lit("Different strokes for different folks");
wapp_str8_set(&s2, 0, 'A');
result = result && wapp_str8_get(&s2, 0) == 'A';
WpStr8 s3 = wpStr8Lit("Discretion is the better part of valour");
wpStr8Set(&s3, 13, 'u');
result = result && wpStr8Get(&s3, 13) == 'u';
Str8 s3 = wapp_str8_lit("Discretion is the better part of valour");
wapp_str8_set(&s3, 13, 'u');
result = result && wapp_str8_get(&s3, 13) == 'u';
WpStr8 s4 = wpStr8Lit("Distance lends enchantment to the view");
wpStr8Set(&s4, 20, 'R');
result = result && wpStr8Get(&s4, 20) == 'R';
Str8 s4 = wapp_str8_lit("Distance lends enchantment to the view");
wapp_str8_set(&s4, 20, 'R');
result = result && wapp_str8_get(&s4, 20) == 'R';
WpStr8 s5 = wpStr8Lit("Do as I say, not as I do");
wpStr8Set(&s5, 11, '.');
result = result && wpStr8Get(&s5, 11) == '.';
Str8 s5 = wapp_str8_lit("Do as I say, not as I do");
wapp_str8_set(&s5, 11, '.');
result = result && wapp_str8_get(&s5, 11) == '.';
WpStr8 s6 = wpStr8Lit("Do as you would be done by");
wpStr8Set(&s6, 25, 'w');
result = result && wpStr8Get(&s6, 25) == 'w';
Str8 s6 = wapp_str8_lit("Do as you would be done by");
wapp_str8_set(&s6, 25, 'w');
result = result && wapp_str8_get(&s6, 25) == 'w';
WpStr8 s7 = wpStr8Lit("Do unto others as you would have them do to you");
wpStr8Set(&s7, 16, 'i');
result = result && wpStr8Get(&s7, 16) == 'i';
Str8 s7 = wapp_str8_lit("Do unto others as you would have them do to you");
wapp_str8_set(&s7, 16, 'i');
result = result && wapp_str8_get(&s7, 16) == 'i';
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_push_back(void) {
TestFuncResult test_str8_push_back(void) {
b8 result;
WpStr8 expected = wpStr8Lit("Abdelrahman");
WpStr8 buf = wpStr8Buf(64);
wpStr8PushBack(&buf, 'A');
wpStr8PushBack(&buf, 'b');
wpStr8PushBack(&buf, 'd');
wpStr8PushBack(&buf, 'e');
wpStr8PushBack(&buf, 'l');
wpStr8PushBack(&buf, 'r');
wpStr8PushBack(&buf, 'a');
wpStr8PushBack(&buf, 'h');
wpStr8PushBack(&buf, 'm');
wpStr8PushBack(&buf, 'a');
wpStr8PushBack(&buf, 'n');
Str8 expected = wapp_str8_lit("Abdelrahman");
Str8 buf = wapp_str8_buf(64);
wapp_str8_push_back(&buf, 'A');
wapp_str8_push_back(&buf, 'b');
wapp_str8_push_back(&buf, 'd');
wapp_str8_push_back(&buf, 'e');
wapp_str8_push_back(&buf, 'l');
wapp_str8_push_back(&buf, 'r');
wapp_str8_push_back(&buf, 'a');
wapp_str8_push_back(&buf, 'h');
wapp_str8_push_back(&buf, 'm');
wapp_str8_push_back(&buf, 'a');
wapp_str8_push_back(&buf, 'n');
result = wpStr8Equal(&buf, &expected);
result = wapp_str8_equal(&buf, &expected);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_equal(void) {
TestFuncResult test_str8_equal(void) {
b8 result;
WpStr8RO s1 = wpStr8LitRo("hello");
WpStr8RO s2 = wpStr8LitRo("hell");
WpStr8RO s3 = wpStr8LitRo("hello");
WpStr8RO s4 = wpStr8LitRo("goodbye");
Str8RO s1 = wapp_str8_lit_ro("hello");
Str8RO s2 = wapp_str8_lit_ro("hell");
Str8RO s3 = wapp_str8_lit_ro("hello");
Str8RO s4 = wapp_str8_lit_ro("goodbye");
result = wpStr8Equal(&s1, &s2) == false;
result = result && wpStr8Equal(&s1, &s3) == true;
result = result && wpStr8Equal(&s1, &s4) == false;
result = wapp_str8_equal(&s1, &s2) == false;
result = result && wapp_str8_equal(&s1, &s3) == true;
result = result && wapp_str8_equal(&s1, &s4) == false;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_slice(void) {
TestFuncResult test_str8_slice(void) {
b8 result;
WpStr8 s = wpStr8Lit("Different strokes for different folks");
Str8 s = wapp_str8_lit("Different strokes for different folks");
WpStr8RO sub1 = wpStr8Slice(&s, 3, 9);
Str8RO sub1 = wapp_str8_slice(&s, 3, 9);
result = sub1.size == 6 && sub1.capacity == 6;
WpStr8RO sub2 = wpStr8Slice(&s, 18, 21);
Str8RO sub2 = wapp_str8_slice(&s, 18, 21);
result = result && sub2.size == 3 && sub2.capacity == 3;
WpStr8RO sub3 = wpStr8Slice(&s, 5, 1);
Str8RO sub3 = wapp_str8_slice(&s, 5, 1);
result = result && sub3.size == 0 && sub3.capacity == 0;
WpStr8RO sub4 = wpStr8Slice(&s, 70, 80);
Str8RO sub4 = wapp_str8_slice(&s, 70, 80);
result = result && sub4.size == 0 && sub4.capacity == 0;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_alloc_concat(void) {
TestFuncResult test_str8_alloc_concat(void) {
b8 result;
WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
Allocator arena = wapp_mem_arena_allocator_init(KiB(100));
WpStr8 str = wpStr8Lit("Hello world");
WpStr8 suffix1 = wpStr8Lit(" from me.");
WpStr8 suffix2 = wpStr8Lit(" This is my code.");
WpStr8 concat1 = wpStr8Lit("Hello world from me.");
WpStr8 concat2 = wpStr8Lit("Hello world from me. This is my code.");
Str8 str = wapp_str8_lit("Hello world");
Str8 suffix1 = wapp_str8_lit(" from me.");
Str8 suffix2 = wapp_str8_lit(" This is my code.");
Str8 concat1 = wapp_str8_lit("Hello world from me.");
Str8 concat2 = wapp_str8_lit("Hello world from me. This is my code.");
WpStr8 *output;
Str8 *output;
output = wpStr8AllocConcat(&arena, &str, &suffix1);
result = output->size == concat1.size && wpStr8Equal(output, &concat1);
output = wapp_str8_alloc_concat(&arena, &str, &suffix1);
result = output->size == concat1.size && wapp_str8_equal(output, &concat1);
output = wpStr8AllocConcat(&arena, output, &suffix2);
result = result && output->size == concat2.size && wpStr8Equal(output, &concat2);
output = wapp_str8_alloc_concat(&arena, output, &suffix2);
result = result && output->size == concat2.size && wapp_str8_equal(output, &concat2);
wpMemArenaAllocatorDestroy(&arena);
wapp_mem_arena_allocator_destroy(&arena);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_concat_capped(void) {
TestFuncResult test_str8_concat_capped(void) {
b8 result;
WpStr8 str = wpStr8Lit("Hello world");
WpStr8 suffix1 = wpStr8Lit(" from me.");
WpStr8 suffix2 = wpStr8Lit(" This is my code.");
WpStr8 concat1 = wpStr8Lit("Hello world from me.");
WpStr8 concat2 = wpStr8Lit("Hello world from me. T");
Str8 str = wapp_str8_lit("Hello world");
Str8 suffix1 = wapp_str8_lit(" from me.");
Str8 suffix2 = wapp_str8_lit(" This is my code.");
Str8 concat1 = wapp_str8_lit("Hello world from me.");
Str8 concat2 = wapp_str8_lit("Hello world from me. T");
wpStr8ConcatCapped(&str, &suffix1);
result = str.size == concat1.size && wpStr8Equal(&str, &concat1);
wapp_str8_concat_capped(&str, &suffix1);
result = str.size == concat1.size && wapp_str8_equal(&str, &concat1);
wpStr8ConcatCapped(&str, &suffix2);
result = result && str.size == concat2.size && wpStr8Equal(&str, &concat2);
wapp_str8_concat_capped(&str, &suffix2);
result = result && str.size == concat2.size && wapp_str8_equal(&str, &concat2);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_copy_cstr_capped(void) {
TestFuncResult test_str8_copy_cstr_capped(void) {
b8 result;
WpStr8 buf = wpStr8Buf(32);
Str8 buf = wapp_str8_buf(32);
const char *src1 = "Hello world";
const char *src2 = "Hello world from the Wizard Apprentice standard library";
WpStr8RO src1_cp = wpStr8LitRo("Hello world");
WpStr8RO src2_cp = wpStr8LitRo("Hello world from the Wizard Appr");
Str8RO src1_cp = wapp_str8_lit_ro("Hello world");
Str8RO src2_cp = wapp_str8_lit_ro("Hello world from the Wizard Appr");
wpStr8CopyCstrCapped(&buf, src1);
result = buf.size == src1_cp.size && wpStr8Equal(&buf, &src1_cp);
wapp_str8_copy_cstr_capped(&buf, src1);
result = buf.size == src1_cp.size && wapp_str8_equal(&buf, &src1_cp);
wpStr8CopyCstrCapped(&buf, src2);
result = result && buf.size == src2_cp.size && buf.size == buf.capacity && wpStr8Equal(&buf, &src2_cp);
wapp_str8_copy_cstr_capped(&buf, src2);
result = result && buf.size == src2_cp.size && buf.size == buf.capacity && wapp_str8_equal(&buf, &src2_cp);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_copy_str8_capped(void) {
TestFuncResult test_str8_copy_str8_capped(void) {
b8 result;
WpStr8 buf = wpStr8Buf(32);
WpStr8RO src1 = wpStr8LitRo("Hello world");
WpStr8RO src2 = wpStr8LitRo("Hello world from the Wizard Apprentice standard library");
WpStr8RO src2_cp = wpStr8LitRo("Hello world from the Wizard Appr");
Str8 buf = wapp_str8_buf(32);
Str8RO src1 = wapp_str8_lit_ro("Hello world");
Str8RO src2 = wapp_str8_lit_ro("Hello world from the Wizard Apprentice standard library");
Str8RO src2_cp = wapp_str8_lit_ro("Hello world from the Wizard Appr");
wpStr8CopyStr8Capped(&buf, &src1);
result = buf.size == src1.size && wpStr8Equal(&buf, &src1);
wapp_str8_copy_str8_capped(&buf, &src1);
result = buf.size == src1.size && wapp_str8_equal(&buf, &src1);
wpStr8CopyStr8Capped(&buf, &src2);
result = result && buf.size < src2.size && buf.size == buf.capacity && wpStr8Equal(&buf, &src2_cp);
wapp_str8_copy_str8_capped(&buf, &src2);
result = result && buf.size < src2.size && buf.size == buf.capacity && wapp_str8_equal(&buf, &src2_cp);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_format(void) {
TestFuncResult test_str8_format(void) {
b8 result;
WpStr8 buf = wpStr8Buf(128);
WpStr8 expected = wpStr8Lit("My name is Abdelrahman and I am 35 years old");
Str8 buf = wapp_str8_buf(128);
Str8 expected = wapp_str8_lit("My name is Abdelrahman and I am 35 years old");
wpStr8Format(&buf, "My name is %s and I am %u years old", "Abdelrahman", 35);
wapp_str8_format(&buf, "My name is %s and I am %u years old", "Abdelrahman", 35);
result = wpStr8Equal(&buf, &expected);
result = wapp_str8_equal(&buf, &expected);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_find(void) {
TestFuncResult test_str8_find(void) {
b8 result;
WpStr8RO s = wpStr8Lit("Do as I say, not as I do");
Str8RO s = wapp_str8_lit("Do as I say, not as I do");
result = wpStr8Find(&s, wpStr8LitRo("d")) != -1;
result = result && (wpStr8Find(&s, wpStr8LitRo("not")) != -1);
result = result && (wpStr8Find(&s, wpStr8LitRo("as I say")) != -1);
result = wapp_str8_find(&s, wapp_str8_lit_ro("d")) != -1;
result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("not")) != -1);
result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("as I say")) != -1);
result = result && (wpStr8Find(&s, wpStr8LitRo("f")) == -1);
result = result && (wpStr8Find(&s, wpStr8LitRo("hello")) == -1);
result = result && (wpStr8Find(&s, wpStr8LitRo("not sa I")) == -1);
result = result && (wpStr8Find(&s, wpStr8LitRo("Do unto others as you would have them do to you")) == -1);
result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("f")) == -1);
result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("hello")) == -1);
result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("not sa I")) == -1);
result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("Do unto others as you would have them do to you")) == -1);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_rfind(void) {
TestFuncResult test_str8_rfind(void) {
b8 result;
WpStr8RO s = wpStr8Lit("Do as I say, not as I do");
Str8RO s = wapp_str8_lit("Do as I say, not as I do");
result = wpStr8Rfind(&s, wpStr8LitRo("d")) != -1;
result = result && (wpStr8Rfind(&s, wpStr8LitRo("not")) != -1);
result = result && (wpStr8Rfind(&s, wpStr8LitRo("as I say")) != -1);
result = wapp_str8_rfind(&s, wapp_str8_lit_ro("d")) != -1;
result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("not")) != -1);
result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("as I say")) != -1);
result = result && (wpStr8Rfind(&s, wpStr8LitRo("f")) == -1);
result = result && (wpStr8Rfind(&s, wpStr8LitRo("hello")) == -1);
result = result && (wpStr8Rfind(&s, wpStr8LitRo("not sa I")) == -1);
result = result && (wpStr8Rfind(&s, wpStr8LitRo("Do unto others as you would have them do to you")) == -1);
result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("f")) == -1);
result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("hello")) == -1);
result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("not sa I")) == -1);
result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("Do unto others as you would have them do to you")) == -1);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_split(void) {
TestFuncResult test_str8_split(void) {
b8 result;
WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
Allocator arena = wapp_mem_arena_allocator_init(KiB(100));
WpStr8 str = wpStr8Lit("hello world from me");
WpStr8 delim1 = wpStr8Lit(" ");
WpStr8 delim2 = wpStr8Lit("from");
WpStr8List *list1 = wpStr8Split(&arena, &str, &delim1);
WpStr8List *list2 = wpStr8Split(&arena, &str, &delim2);
Str8 str = wapp_str8_lit("hello world from me");
Str8 delim1 = wapp_str8_lit(" ");
Str8 delim2 = wapp_str8_lit("from");
Str8List *list1 = wapp_str8_split(&arena, &str, &delim1);
Str8List *list2 = wapp_str8_split(&arena, &str, &delim2);
WpStr8RO splits1[] = {
wpStr8Slice(&str, 0, 5),
wpStr8Slice(&str, 6, 11),
wpStr8Slice(&str, 12, 16),
wpStr8Slice(&str, 17, 19),
Str8RO splits1[] = {
wapp_str8_slice(&str, 0, 5),
wapp_str8_slice(&str, 6, 11),
wapp_str8_slice(&str, 12, 16),
wapp_str8_slice(&str, 17, 19),
};
WpStr8RO splits2[] = {
wpStr8Slice(&str, 0, 12),
wpStr8Slice(&str, 16, 19),
Str8RO splits2[] = {
wapp_str8_slice(&str, 0, 12),
wapp_str8_slice(&str, 16, 19),
};
u64 index1 = 0;
@@ -437,14 +437,14 @@ WpTestFuncResult test_str8_split(void) {
u64 count2 = ARRLEN(splits2);
b8 running2 = true;
result = list1->node_count == count1 && wpStr8ListTotalSize(list1) == str.size - 3;
result = result && list2->node_count == count2 && wpStr8ListTotalSize(list2) == str.size - 4;
result = list1->node_count == count1 && wapp_str8_list_total_size(list1) == str.size - 3;
result = result && list2->node_count == count2 && wapp_str8_list_total_size(list2) == str.size - 4;
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
while (running1) {
WpStr8 *node = wpDblListGet(WpStr8, list1, index1);
result = result && wpStr8Equal(node, &(splits1[index1]));
Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list1, index1);
result = result && wapp_str8_equal(node->item, &(splits1[index1]));
++index1;
running1 = index1 < count1;
@@ -453,72 +453,72 @@ WpTestFuncResult test_str8_split(void) {
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
while (running2) {
WpStr8 *node = wpDblListGet(WpStr8, list2, index2);
result = result && wpStr8Equal(node, &(splits2[index2]));
Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list2, index2);
result = result && wapp_str8_equal(node->item, &(splits2[index2]));
++index2;
running2 = index2 < count2;
}
wpMemArenaAllocatorDestroy(&arena);
wapp_mem_arena_allocator_destroy(&arena);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_split_with_max(void) {
TestFuncResult test_str8_split_with_max(void) {
b8 result;
WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
Allocator arena = wapp_mem_arena_allocator_init(KiB(100));
WpStr8 str = wpStr8Lit("hello world from me");
WpStr8 delim = wpStr8Lit(" ");
WpStr8List *list = wpStr8SplitWithMax(&arena, &str, &delim, 2);
Str8 str = wapp_str8_lit("hello world from me");
Str8 delim = wapp_str8_lit(" ");
Str8List *list = wapp_str8_split_with_max(&arena, &str, &delim, 2);
WpStr8RO splits[] = {
wpStr8Slice(&str, 0, 5),
wpStr8Slice(&str, 6, 11),
wpStr8Slice(&str, 12, 19),
Str8RO splits[] = {
wapp_str8_slice(&str, 0, 5),
wapp_str8_slice(&str, 6, 11),
wapp_str8_slice(&str, 12, 19),
};
u64 index = 0;
u64 count = ARRLEN(splits);
b8 running = true;
result = list->node_count == count && wpStr8ListTotalSize(list) == str.size - 2;
result = list->node_count == count && wapp_str8_list_total_size(list) == str.size - 2;
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
while (running) {
WpStr8 *node = wpDblListGet(WpStr8, list, index);
result = result && wpStr8Equal(node, &(splits[index]));
Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list, index);
result = result && wapp_str8_equal(node->item, &(splits[index]));
++index;
running = index < count;
}
wpMemArenaAllocatorDestroy(&arena);
wapp_mem_arena_allocator_destroy(&arena);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_rsplit(void) {
TestFuncResult test_str8_rsplit(void) {
b8 result;
WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
Allocator arena = wapp_mem_arena_allocator_init(KiB(100));
WpStr8 str = wpStr8Lit("hello world from me");
WpStr8 delim1 = wpStr8Lit(" ");
WpStr8 delim2 = wpStr8Lit("from");
WpStr8List *list1 = wpStr8Rsplit(&arena, &str, &delim1);
WpStr8List *list2 = wpStr8Rsplit(&arena, &str, &delim2);
Str8 str = wapp_str8_lit("hello world from me");
Str8 delim1 = wapp_str8_lit(" ");
Str8 delim2 = wapp_str8_lit("from");
Str8List *list1 = wapp_str8_rsplit(&arena, &str, &delim1);
Str8List *list2 = wapp_str8_rsplit(&arena, &str, &delim2);
WpStr8RO splits1[] = {
wpStr8Slice(&str, 0, 5),
wpStr8Slice(&str, 6, 11),
wpStr8Slice(&str, 12, 16),
wpStr8Slice(&str, 17, 19),
Str8RO splits1[] = {
wapp_str8_slice(&str, 0, 5),
wapp_str8_slice(&str, 6, 11),
wapp_str8_slice(&str, 12, 16),
wapp_str8_slice(&str, 17, 19),
};
WpStr8RO splits2[] = {
wpStr8Slice(&str, 0, 12),
wpStr8Slice(&str, 16, 19),
Str8RO splits2[] = {
wapp_str8_slice(&str, 0, 12),
wapp_str8_slice(&str, 16, 19),
};
u64 index1 = 0;
@@ -529,14 +529,14 @@ WpTestFuncResult test_str8_rsplit(void) {
u64 count2 = ARRLEN(splits2);
b8 running2 = true;
result = list1->node_count == count1 && wpStr8ListTotalSize(list1) == str.size - 3;
result = result && list2->node_count == count2 && wpStr8ListTotalSize(list2) == str.size - 4;
result = list1->node_count == count1 && wapp_str8_list_total_size(list1) == str.size - 3;
result = result && list2->node_count == count2 && wapp_str8_list_total_size(list2) == str.size - 4;
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
while (running1) {
WpStr8 *node = wpDblListGet(WpStr8, list1, index1);
result = result && wpStr8Equal(node, &(splits1[index1]));
Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list1, index1);
result = result && wapp_str8_equal(node->item, &(splits1[index1]));
++index1;
running1 = index1 < count1;
@@ -545,82 +545,82 @@ WpTestFuncResult test_str8_rsplit(void) {
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
while (running2) {
WpStr8 *node = wpDblListGet(WpStr8, list2, index2);
result = result && wpStr8Equal(node, &(splits2[index2]));
Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list2, index2);
result = result && wapp_str8_equal(node->item, &(splits2[index2]));
++index2;
running2 = index2 < count2;
}
wpMemArenaAllocatorDestroy(&arena);
wapp_mem_arena_allocator_destroy(&arena);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_rsplit_with_max(void) {
TestFuncResult test_str8_rsplit_with_max(void) {
b8 result;
WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
Allocator arena = wapp_mem_arena_allocator_init(KiB(100));
WpStr8 str = wpStr8Lit("hello world from me");
WpStr8 delim = wpStr8Lit(" ");
WpStr8List *list = wpStr8RsplitWithMax(&arena, &str, &delim, 2);
Str8 str = wapp_str8_lit("hello world from me");
Str8 delim = wapp_str8_lit(" ");
Str8List *list = wapp_str8_rsplit_with_max(&arena, &str, &delim, 2);
WpStr8RO splits[] = {
wpStr8Slice(&str, 0, 11),
wpStr8Slice(&str, 12, 16),
wpStr8Slice(&str, 17, 19),
Str8RO splits[] = {
wapp_str8_slice(&str, 0, 11),
wapp_str8_slice(&str, 12, 16),
wapp_str8_slice(&str, 17, 19),
};
u64 index = 0;
u64 count = ARRLEN(splits);
b8 running = true;
result = list->node_count == count && wpStr8ListTotalSize(list) == str.size - 2;
result = list->node_count == count && wapp_str8_list_total_size(list) == str.size - 2;
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
while (running) {
WpStr8 *node = wpDblListGet(WpStr8, list, index);
result = result && wpStr8Equal(node, &(splits[index]));
Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list, index);
result = result && wapp_str8_equal(node->item, &(splits[index]));
++index;
running = index < count;
}
wpMemArenaAllocatorDestroy(&arena);
wapp_mem_arena_allocator_destroy(&arena);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_join(void) {
TestFuncResult test_str8_join(void) {
b8 result;
WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
Allocator arena = wapp_mem_arena_allocator_init(KiB(100));
WpStr8 str = wpStr8Lit("hello world from me");
WpStr8 delim1 = wpStr8Lit(" ");
WpStr8 delim2 = wpStr8Lit("from");
WpStr8List *list1 = wpStr8Rsplit(&arena, &str, &delim1);
WpStr8List *list2 = wpStr8Rsplit(&arena, &str, &delim2);
WpStr8 *join1 = wpStr8Join(&arena, list1, &delim1);
WpStr8 *join2 = wpStr8Join(&arena, list2, &delim2);
Str8 str = wapp_str8_lit("hello world from me");
Str8 delim1 = wapp_str8_lit(" ");
Str8 delim2 = wapp_str8_lit("from");
Str8List *list1 = wapp_str8_rsplit(&arena, &str, &delim1);
Str8List *list2 = wapp_str8_rsplit(&arena, &str, &delim2);
Str8 *join1 = wapp_str8_join(&arena, list1, &delim1);
Str8 *join2 = wapp_str8_join(&arena, list2, &delim2);
result = join1->size == str.size && wpStr8Equal(join1, &str);
result = result && join2->size == str.size && wpStr8Equal(join2, &str);
result = join1->size == str.size && wapp_str8_equal(join1, &str);
result = result && join2->size == str.size && wapp_str8_equal(join2, &str);
wpMemArenaAllocatorDestroy(&arena);
wapp_mem_arena_allocator_destroy(&arena);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_from_bytes(void) {
TestFuncResult test_str8_from_bytes(void) {
b8 result;
WpStr8 str = wpStr8Buf(1024);
WpU8Array bytes = wpArray(u8, 'W', 'A', 'P', 'P');
wpStr8FromBytes(&str, bytes);
Str8 str = wapp_str8_buf(1024);
U8Array bytes = wapp_array(u8, U8Array, 'W', 'A', 'P', 'P');
wapp_str8_from_bytes(&str, &bytes);
result = str.size == wpArrayCount(bytes) * wpArrayItemSize(bytes);
result = result && wpStr8Equal(&str, &wpStr8LitRo("WAPP"));
result = str.size == bytes.count * bytes.item_size;
result = result && wapp_str8_equal(&str, &wapp_str8_lit_ro("WAPP"));
return wpTesterResult(result);
return wapp_tester_result(result);
}
tests/str8/test_str8.cc
+301 -301
View File
@@ -3,430 +3,430 @@
#define ARRLEN(ARR) (sizeof(ARR) / sizeof(ARR[0]))
WpTestFuncResult test_str8_lit(void) {
TestFuncResult test_str8_lit(void) {
b8 result;
WpStr8 s1 = wpStr8Lit("Hello world");
Str8 s1 = wapp_str8_lit("Hello world");
result = s1.capacity == 22 && s1.capacity != s1.size;
WpStr8 s2 = wpStr8Lit("Different strokes for different folks");
Str8 s2 = wapp_str8_lit("Different strokes for different folks");
result = result && s2.capacity == 74 && s2.capacity != s2.size;
WpStr8 s3 = wpStr8Lit("Discretion is the better part of valour");
Str8 s3 = wapp_str8_lit("Discretion is the better part of valour");
result = result && s3.capacity == 78 && s3.capacity != s3.size;
WpStr8 s4 = wpStr8Lit("Distance lends enchantment to the view");
Str8 s4 = wapp_str8_lit("Distance lends enchantment to the view");
result = result && s4.capacity == 76 && s4.capacity != s4.size;
WpStr8 s5 = wpStr8Lit("Do as I say, not as I do");
Str8 s5 = wapp_str8_lit("Do as I say, not as I do");
result = result && s5.capacity == 48 && s5.capacity != s5.size;
WpStr8 s6 = wpStr8Lit("Do as you would be done by");
Str8 s6 = wapp_str8_lit("Do as you would be done by");
result = result && s6.capacity == 52 && s6.capacity != s6.size;
WpStr8 s7 = wpStr8Lit("Do unto others as you would have them do to you");
Str8 s7 = wapp_str8_lit("Do unto others as you would have them do to you");
result = result && s7.capacity == 94 && s7.capacity != s7.size;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_lit_ro(void) {
TestFuncResult test_str8_lit_ro(void) {
b8 result;
WpStr8RO s1 = wpStr8LitRo("Hello world");
Str8RO s1 = wapp_str8_lit_ro("Hello world");
result = s1.capacity == 11 && s1.capacity == s1.size;
WpStr8RO s2 = wpStr8LitRo("Different strokes for different folks");
Str8RO s2 = wapp_str8_lit_ro("Different strokes for different folks");
result = result && s2.capacity == 37 && s2.capacity == s2.size;
WpStr8RO s3 = wpStr8LitRo("Discretion is the better part of valour");
Str8RO s3 = wapp_str8_lit_ro("Discretion is the better part of valour");
result = result && s3.capacity == 39 && s3.capacity == s3.size;
WpStr8RO s4 = wpStr8LitRo("Distance lends enchantment to the view");
Str8RO s4 = wapp_str8_lit_ro("Distance lends enchantment to the view");
result = result && s4.capacity == 38 && s4.capacity == s4.size;
WpStr8RO s5 = wpStr8LitRo("Do as I say, not as I do");
Str8RO s5 = wapp_str8_lit_ro("Do as I say, not as I do");
result = result && s5.capacity == 24 && s5.capacity == s5.size;
WpStr8RO s6 = wpStr8LitRo("Do as you would be done by");
Str8RO s6 = wapp_str8_lit_ro("Do as you would be done by");
result = result && s6.capacity == 26 && s6.capacity == s6.size;
WpStr8RO s7 = wpStr8LitRo("Do unto others as you would have them do to you");
Str8RO s7 = wapp_str8_lit_ro("Do unto others as you would have them do to you");
result = result && s7.capacity == 47 && s7.capacity == s7.size;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_buf(void) {
TestFuncResult test_str8_buf(void) {
b8 result;
WpStr8 s1 = wpStr8Buf(1024);
Str8 s1 = wapp_str8_buf(1024);
result = s1.capacity == 1024 && s1.size == 0;
WpStr8 s2 = wpStr8Buf(2048);
Str8 s2 = wapp_str8_buf(2048);
result = result && s2.capacity == 2048 && s2.size == 0;
WpStr8 s3 = wpStr8Buf(4096);
Str8 s3 = wapp_str8_buf(4096);
result = result && s3.capacity == 4096 && s3.size == 0;
WpStr8 s4 = wpStr8Buf(8192);
Str8 s4 = wapp_str8_buf(8192);
result = result && s4.capacity == 8192 && s4.size == 0;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_alloc_buf(void) {
TestFuncResult test_str8_alloc_buf(void) {
b8 result;
WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100));
if (wpMemAllocatorInvalid(&allocator)) {
return wpTesterResult(false);
Allocator allocator = wapp_mem_arena_allocator_init(KiB(100));
if (wapp_mem_allocator_invalid(&allocator)) {
return wapp_tester_result(false);
}
u64 capacity = 4096;
WpStr8 *s = wpStr8AllocBuf(&allocator, capacity);
Str8 *s = wapp_str8_alloc_buf(&allocator, capacity);
if (!s) {
result = false;
wpMemArenaAllocatorDestroy(&allocator);
return wpTesterResult(result);
wapp_mem_arena_allocator_destroy(&allocator);
return wapp_tester_result(result);
}
result = s->capacity == capacity;
const char *cstr = "My name is Abdelrahman";
wpStr8CopyCstrCapped(s, cstr);
wapp_str8_copy_cstr_capped(s, cstr);
result = result && s->capacity == capacity && s->size == strlen(cstr) && memcmp(s->buf, cstr, s->size) == 0;
wpMemArenaAllocatorDestroy(&allocator);
wapp_mem_arena_allocator_destroy(&allocator);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_alloc_cstr(void) {
TestFuncResult test_str8_alloc_cstr(void) {
b8 result;
WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100));
if (wpMemAllocatorInvalid(&allocator)) {
return wpTesterResult(false);
Allocator allocator = wapp_mem_arena_allocator_init(KiB(100));
if (wapp_mem_allocator_invalid(&allocator)) {
return wapp_tester_result(false);
}
const char *str = "Abdelrahman";
u64 length = strlen(str);
WpStr8 *s = wpStr8AllocCstr(&allocator, str);
Str8 *s = wapp_str8_alloc_cstr(&allocator, str);
if (!s) {
return wpTesterResult(false);
return wapp_tester_result(false);
}
result = s->size == length && memcmp(s->buf, str, length) == 0;
wpMemArenaAllocatorDestroy(&allocator);
wapp_mem_arena_allocator_destroy(&allocator);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_alloc_str8(void) {
TestFuncResult test_str8_alloc_str8(void) {
b8 result;
WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100));
if (wpMemAllocatorInvalid(&allocator)) {
return wpTesterResult(false);
Allocator allocator = wapp_mem_arena_allocator_init(KiB(100));
if (wapp_mem_allocator_invalid(&allocator)) {
return wapp_tester_result(false);
}
WpStr8 str = wpStr8Lit("Abdelrahman");
WpStr8 *s = wpStr8AllocStr8(&allocator, &str);
Str8 str = wapp_str8_lit("Abdelrahman");
Str8 *s = wapp_str8_alloc_str8(&allocator, &str);
if (!s) {
return wpTesterResult(false);
return wapp_tester_result(false);
}
result = wpStr8Equal(s, &str);
result = wapp_str8_equal(s, &str);
wpMemArenaAllocatorDestroy(&allocator);
wapp_mem_arena_allocator_destroy(&allocator);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_alloc_substr(void) {
TestFuncResult test_str8_alloc_substr(void) {
b8 result;
WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100));
if (wpMemAllocatorInvalid(&allocator)) {
return wpTesterResult(false);
Allocator allocator = wapp_mem_arena_allocator_init(KiB(100));
if (wapp_mem_allocator_invalid(&allocator)) {
return wapp_tester_result(false);
}
WpStr8 str = wpStr8Lit("Abdelrahman");
WpStr8 *s = wpStr8AllocSubstr(&allocator, &str, 3, 8);
Str8 str = wapp_str8_lit("Abdelrahman");
Str8 *s = wapp_str8_alloc_substr(&allocator, &str, 3, 8);
if (!s) {
return wpTesterResult(false);
return wapp_tester_result(false);
}
result = s->size == 5 && memcmp(s->buf, "elrah", s->size) == 0;
wpMemArenaAllocatorDestroy(&allocator);
wapp_mem_arena_allocator_destroy(&allocator);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_get_index_within_bounds(void) {
TestFuncResult test_str8_get_index_within_bounds(void) {
b8 result;
WpStr8RO s1 = wpStr8LitRo("Hello world");
result = wpStr8Get(&s1, 4) == 'o';
Str8RO s1 = wapp_str8_lit_ro("Hello world");
result = wapp_str8_get(&s1, 4) == 'o';
WpStr8RO s2 = wpStr8LitRo("Different strokes for different folks");
result = result && wpStr8Get(&s2, 0) == 'D';
Str8RO s2 = wapp_str8_lit_ro("Different strokes for different folks");
result = result && wapp_str8_get(&s2, 0) == 'D';
WpStr8RO s3 = wpStr8LitRo("Discretion is the better part of valour");
result = result && wpStr8Get(&s3, 13) == ' ';
Str8RO s3 = wapp_str8_lit_ro("Discretion is the better part of valour");
result = result && wapp_str8_get(&s3, 13) == ' ';
WpStr8RO s4 = wpStr8LitRo("Distance lends enchantment to the view");
result = result && wpStr8Get(&s4, 20) == 'n';
Str8RO s4 = wapp_str8_lit_ro("Distance lends enchantment to the view");
result = result && wapp_str8_get(&s4, 20) == 'n';
WpStr8RO s5 = wpStr8LitRo("Do as I say, not as I do");
result = result && wpStr8Get(&s5, 11) == ',';
Str8RO s5 = wapp_str8_lit_ro("Do as I say, not as I do");
result = result && wapp_str8_get(&s5, 11) == ',';
WpStr8RO s6 = wpStr8LitRo("Do as you would be done by");
result = result && wpStr8Get(&s6, 25) == 'y';
Str8RO s6 = wapp_str8_lit_ro("Do as you would be done by");
result = result && wapp_str8_get(&s6, 25) == 'y';
WpStr8RO s7 = wpStr8LitRo("Do unto others as you would have them do to you");
result = result && wpStr8Get(&s7, 16) == 's';
Str8RO s7 = wapp_str8_lit_ro("Do unto others as you would have them do to you");
result = result && wapp_str8_get(&s7, 16) == 's';
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_get_index_out_of_bounds(void) {
WpStr8 s1 = wpStr8Lit("Hello world");
b8 result = wpStr8Get(&s1, 20) == '\0';
return wpTesterResult(result);
TestFuncResult test_str8_get_index_out_of_bounds(void) {
Str8 s1 = wapp_str8_lit("Hello world");
b8 result = wapp_str8_get(&s1, 20) == '\0';
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_set(void) {
TestFuncResult test_str8_set(void) {
b8 result;
WpStr8 s1 = wpStr8Lit("Hello world");
wpStr8Set(&s1, 4, 'f');
result = wpStr8Get(&s1, 4) == 'f';
Str8 s1 = wapp_str8_lit("Hello world");
wapp_str8_set(&s1, 4, 'f');
result = wapp_str8_get(&s1, 4) == 'f';
WpStr8 s2 = wpStr8Lit("Different strokes for different folks");
wpStr8Set(&s2, 0, 'A');
result = result && wpStr8Get(&s2, 0) == 'A';
Str8 s2 = wapp_str8_lit("Different strokes for different folks");
wapp_str8_set(&s2, 0, 'A');
result = result && wapp_str8_get(&s2, 0) == 'A';
WpStr8 s3 = wpStr8Lit("Discretion is the better part of valour");
wpStr8Set(&s3, 13, 'u');
result = result && wpStr8Get(&s3, 13) == 'u';
Str8 s3 = wapp_str8_lit("Discretion is the better part of valour");
wapp_str8_set(&s3, 13, 'u');
result = result && wapp_str8_get(&s3, 13) == 'u';
WpStr8 s4 = wpStr8Lit("Distance lends enchantment to the view");
wpStr8Set(&s4, 20, 'R');
result = result && wpStr8Get(&s4, 20) == 'R';
Str8 s4 = wapp_str8_lit("Distance lends enchantment to the view");
wapp_str8_set(&s4, 20, 'R');
result = result && wapp_str8_get(&s4, 20) == 'R';
WpStr8 s5 = wpStr8Lit("Do as I say, not as I do");
wpStr8Set(&s5, 11, '.');
result = result && wpStr8Get(&s5, 11) == '.';
Str8 s5 = wapp_str8_lit("Do as I say, not as I do");
wapp_str8_set(&s5, 11, '.');
result = result && wapp_str8_get(&s5, 11) == '.';
WpStr8 s6 = wpStr8Lit("Do as you would be done by");
wpStr8Set(&s6, 25, 'w');
result = result && wpStr8Get(&s6, 25) == 'w';
Str8 s6 = wapp_str8_lit("Do as you would be done by");
wapp_str8_set(&s6, 25, 'w');
result = result && wapp_str8_get(&s6, 25) == 'w';
WpStr8 s7 = wpStr8Lit("Do unto others as you would have them do to you");
wpStr8Set(&s7, 16, 'i');
result = result && wpStr8Get(&s7, 16) == 'i';
Str8 s7 = wapp_str8_lit("Do unto others as you would have them do to you");
wapp_str8_set(&s7, 16, 'i');
result = result && wapp_str8_get(&s7, 16) == 'i';
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_push_back(void) {
TestFuncResult test_str8_push_back(void) {
b8 result;
WpStr8 expected = wpStr8Lit("Abdelrahman");
WpStr8 buf = wpStr8Buf(64);
wpStr8PushBack(&buf, 'A');
wpStr8PushBack(&buf, 'b');
wpStr8PushBack(&buf, 'd');
wpStr8PushBack(&buf, 'e');
wpStr8PushBack(&buf, 'l');
wpStr8PushBack(&buf, 'r');
wpStr8PushBack(&buf, 'a');
wpStr8PushBack(&buf, 'h');
wpStr8PushBack(&buf, 'm');
wpStr8PushBack(&buf, 'a');
wpStr8PushBack(&buf, 'n');
Str8 expected = wapp_str8_lit("Abdelrahman");
Str8 buf = wapp_str8_buf(64);
wapp_str8_push_back(&buf, 'A');
wapp_str8_push_back(&buf, 'b');
wapp_str8_push_back(&buf, 'd');
wapp_str8_push_back(&buf, 'e');
wapp_str8_push_back(&buf, 'l');
wapp_str8_push_back(&buf, 'r');
wapp_str8_push_back(&buf, 'a');
wapp_str8_push_back(&buf, 'h');
wapp_str8_push_back(&buf, 'm');
wapp_str8_push_back(&buf, 'a');
wapp_str8_push_back(&buf, 'n');
result = wpStr8Equal(&buf, &expected);
result = wapp_str8_equal(&buf, &expected);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_equal(void) {
TestFuncResult test_str8_equal(void) {
b8 result;
WpStr8RO s1 = wpStr8LitRo("hello");
WpStr8RO s2 = wpStr8LitRo("hell");
WpStr8RO s3 = wpStr8LitRo("hello");
WpStr8RO s4 = wpStr8LitRo("goodbye");
Str8RO s1 = wapp_str8_lit_ro("hello");
Str8RO s2 = wapp_str8_lit_ro("hell");
Str8RO s3 = wapp_str8_lit_ro("hello");
Str8RO s4 = wapp_str8_lit_ro("goodbye");
result = wpStr8Equal(&s1, &s2) == false;
result = result && wpStr8Equal(&s1, &s3) == (b8)true;
result = result && wpStr8Equal(&s1, &s4) == (b8)false;
result = wapp_str8_equal(&s1, &s2) == false;
result = result && wapp_str8_equal(&s1, &s3) == (b8)true;
result = result && wapp_str8_equal(&s1, &s4) == (b8)false;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_slice(void) {
TestFuncResult test_str8_slice(void) {
b8 result;
WpStr8 s = wpStr8Lit("Different strokes for different folks");
Str8 s = wapp_str8_lit("Different strokes for different folks");
WpStr8RO sub1 = wpStr8Slice(&s, 3, 9);
Str8RO sub1 = wapp_str8_slice(&s, 3, 9);
result = sub1.size == 6 && sub1.capacity == 6;
WpStr8RO sub2 = wpStr8Slice(&s, 18, 21);
Str8RO sub2 = wapp_str8_slice(&s, 18, 21);
result = result && sub2.size == 3 && sub2.capacity == 3;
WpStr8RO sub3 = wpStr8Slice(&s, 5, 1);
Str8RO sub3 = wapp_str8_slice(&s, 5, 1);
result = result && sub3.size == 0 && sub3.capacity == 0;
WpStr8RO sub4 = wpStr8Slice(&s, 70, 80);
Str8RO sub4 = wapp_str8_slice(&s, 70, 80);
result = result && sub4.size == 0 && sub4.capacity == 0;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_alloc_concat(void) {
TestFuncResult test_str8_alloc_concat(void) {
b8 result;
WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
Allocator arena = wapp_mem_arena_allocator_init(KiB(100));
WpStr8 str = wpStr8Lit("Hello world");
WpStr8 suffix1 = wpStr8Lit(" from me.");
WpStr8 suffix2 = wpStr8Lit(" This is my code.");
WpStr8 concat1 = wpStr8Lit("Hello world from me.");
WpStr8 concat2 = wpStr8Lit("Hello world from me. This is my code.");
Str8 str = wapp_str8_lit("Hello world");
Str8 suffix1 = wapp_str8_lit(" from me.");
Str8 suffix2 = wapp_str8_lit(" This is my code.");
Str8 concat1 = wapp_str8_lit("Hello world from me.");
Str8 concat2 = wapp_str8_lit("Hello world from me. This is my code.");
WpStr8 *output;
Str8 *output;
output = wpStr8AllocConcat(&arena, &str, &suffix1);
result = output->size == concat1.size && wpStr8Equal(output, &concat1);
output = wapp_str8_alloc_concat(&arena, &str, &suffix1);
result = output->size == concat1.size && wapp_str8_equal(output, &concat1);
output = wpStr8AllocConcat(&arena, output, &suffix2);
result = result && output->size == concat2.size && wpStr8Equal(output, &concat2);
output = wapp_str8_alloc_concat(&arena, output, &suffix2);
result = result && output->size == concat2.size && wapp_str8_equal(output, &concat2);
wpMemArenaAllocatorDestroy(&arena);
wapp_mem_arena_allocator_destroy(&arena);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_concat_capped(void) {
TestFuncResult test_str8_concat_capped(void) {
b8 result;
WpStr8 str = wpStr8Lit("Hello world");
WpStr8 suffix1 = wpStr8Lit(" from me.");
WpStr8 suffix2 = wpStr8Lit(" This is my code.");
WpStr8 concat1 = wpStr8Lit("Hello world from me.");
WpStr8 concat2 = wpStr8Lit("Hello world from me. T");
Str8 str = wapp_str8_lit("Hello world");
Str8 suffix1 = wapp_str8_lit(" from me.");
Str8 suffix2 = wapp_str8_lit(" This is my code.");
Str8 concat1 = wapp_str8_lit("Hello world from me.");
Str8 concat2 = wapp_str8_lit("Hello world from me. T");
wpStr8ConcatCapped(&str, &suffix1);
result = str.size == concat1.size && wpStr8Equal(&str, &concat1);
wapp_str8_concat_capped(&str, &suffix1);
result = str.size == concat1.size && wapp_str8_equal(&str, &concat1);
wpStr8ConcatCapped(&str, &suffix2);
result = result && str.size == concat2.size && wpStr8Equal(&str, &concat2);
wapp_str8_concat_capped(&str, &suffix2);
result = result && str.size == concat2.size && wapp_str8_equal(&str, &concat2);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_copy_cstr_capped(void) {
TestFuncResult test_str8_copy_cstr_capped(void) {
b8 result;
WpStr8 buf = wpStr8Buf(32);
Str8 buf = wapp_str8_buf(32);
const char *src1 = "Hello world";
const char *src2 = "Hello world from the Wizard Apprentice standard library";
WpStr8RO src1_cp = wpStr8LitRo("Hello world");
WpStr8RO src2_cp = wpStr8LitRo("Hello world from the Wizard Appr");
Str8RO src1_cp = wapp_str8_lit_ro("Hello world");
Str8RO src2_cp = wapp_str8_lit_ro("Hello world from the Wizard Appr");
wpStr8CopyCstrCapped(&buf, src1);
result = buf.size == src1_cp.size && wpStr8Equal(&buf, &src1_cp);
wapp_str8_copy_cstr_capped(&buf, src1);
result = buf.size == src1_cp.size && wapp_str8_equal(&buf, &src1_cp);
wpStr8CopyCstrCapped(&buf, src2);
result = result && buf.size == src2_cp.size && buf.size == buf.capacity && wpStr8Equal(&buf, &src2_cp);
wapp_str8_copy_cstr_capped(&buf, src2);
result = result && buf.size == src2_cp.size && buf.size == buf.capacity && wapp_str8_equal(&buf, &src2_cp);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_copy_str8_capped(void) {
TestFuncResult test_str8_copy_str8_capped(void) {
b8 result;
WpStr8 buf = wpStr8Buf(32);
WpStr8RO src1 = wpStr8LitRo("Hello world");
WpStr8RO src2 = wpStr8LitRo("Hello world from the Wizard Apprentice standard library");
WpStr8RO src2_cp = wpStr8LitRo("Hello world from the Wizard Appr");
Str8 buf = wapp_str8_buf(32);
Str8RO src1 = wapp_str8_lit_ro("Hello world");
Str8RO src2 = wapp_str8_lit_ro("Hello world from the Wizard Apprentice standard library");
Str8RO src2_cp = wapp_str8_lit_ro("Hello world from the Wizard Appr");
wpStr8CopyStr8Capped(&buf, &src1);
result = buf.size == src1.size && wpStr8Equal(&buf, &src1);
wapp_str8_copy_str8_capped(&buf, &src1);
result = buf.size == src1.size && wapp_str8_equal(&buf, &src1);
wpStr8CopyStr8Capped(&buf, &src2);
result = result && buf.size < src2.size && buf.size == buf.capacity && wpStr8Equal(&buf, &src2_cp);
wapp_str8_copy_str8_capped(&buf, &src2);
result = result && buf.size < src2.size && buf.size == buf.capacity && wapp_str8_equal(&buf, &src2_cp);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_format(void) {
TestFuncResult test_str8_format(void) {
b8 result;
WpStr8 buf = wpStr8Buf(128);
WpStr8 expected = wpStr8Lit("My name is Abdelrahman and I am 35 years old");
Str8 buf = wapp_str8_buf(128);
Str8 expected = wapp_str8_lit("My name is Abdelrahman and I am 35 years old");
wpStr8Format(&buf, "My name is %s and I am %u years old", "Abdelrahman", 35);
wapp_str8_format(&buf, "My name is %s and I am %u years old", "Abdelrahman", 35);
result = wpStr8Equal(&buf, &expected);
result = wapp_str8_equal(&buf, &expected);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_find(void) {
TestFuncResult test_str8_find(void) {
b8 result;
WpStr8RO s = wpStr8Lit("Do as I say, not as I do");
Str8RO s = wapp_str8_lit("Do as I say, not as I do");
result = wpStr8Find(&s, wpStr8LitRo("d")) != -1;
result = result && (wpStr8Find(&s, wpStr8LitRo("not")) != -1);
result = result && (wpStr8Find(&s, wpStr8LitRo("as I say")) != -1);
result = wapp_str8_find(&s, wapp_str8_lit_ro("d")) != -1;
result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("not")) != -1);
result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("as I say")) != -1);
result = result && (wpStr8Find(&s, wpStr8LitRo("f")) == -1);
result = result && (wpStr8Find(&s, wpStr8LitRo("hello")) == -1);
result = result && (wpStr8Find(&s, wpStr8LitRo("not sa I")) == -1);
result = result && (wpStr8Find(&s, wpStr8LitRo("Do unto others as you would have them do to you")) == -1);
result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("f")) == -1);
result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("hello")) == -1);
result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("not sa I")) == -1);
result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("Do unto others as you would have them do to you")) == -1);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_rfind(void) {
TestFuncResult test_str8_rfind(void) {
b8 result;
WpStr8RO s = wpStr8Lit("Do as I say, not as I do");
Str8RO s = wapp_str8_lit("Do as I say, not as I do");
result = wpStr8Rfind(&s, wpStr8LitRo("d")) != -1;
result = result && (wpStr8Rfind(&s, wpStr8LitRo("not")) != -1);
result = result && (wpStr8Rfind(&s, wpStr8LitRo("as I say")) != -1);
result = wapp_str8_rfind(&s, wapp_str8_lit_ro("d")) != -1;
result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("not")) != -1);
result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("as I say")) != -1);
result = result && (wpStr8Rfind(&s, wpStr8LitRo("f")) == -1);
result = result && (wpStr8Rfind(&s, wpStr8LitRo("hello")) == -1);
result = result && (wpStr8Rfind(&s, wpStr8LitRo("not sa I")) == -1);
result = result && (wpStr8Rfind(&s, wpStr8LitRo("Do unto others as you would have them do to you")) == -1);
result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("f")) == -1);
result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("hello")) == -1);
result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("not sa I")) == -1);
result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("Do unto others as you would have them do to you")) == -1);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_split(void) {
TestFuncResult test_str8_split(void) {
b8 result;
WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
Allocator arena = wapp_mem_arena_allocator_init(KiB(100));
WpStr8 str = wpStr8Lit("hello world from me");
WpStr8 delim1 = wpStr8Lit(" ");
WpStr8 delim2 = wpStr8Lit("from");
WpStr8List *list1 = wpStr8Split(&arena, &str, &delim1);
WpStr8List *list2 = wpStr8Split(&arena, &str, &delim2);
Str8 str = wapp_str8_lit("hello world from me");
Str8 delim1 = wapp_str8_lit(" ");
Str8 delim2 = wapp_str8_lit("from");
Str8List *list1 = wapp_str8_split(&arena, &str, &delim1);
Str8List *list2 = wapp_str8_split(&arena, &str, &delim2);
WpStr8RO splits1[] = {
wpStr8Slice(&str, 0, 5),
wpStr8Slice(&str, 6, 11),
wpStr8Slice(&str, 12, 16),
wpStr8Slice(&str, 17, 19),
Str8RO splits1[] = {
wapp_str8_slice(&str, 0, 5),
wapp_str8_slice(&str, 6, 11),
wapp_str8_slice(&str, 12, 16),
wapp_str8_slice(&str, 17, 19),
};
WpStr8RO splits2[] = {
wpStr8Slice(&str, 0, 12),
wpStr8Slice(&str, 16, 19),
Str8RO splits2[] = {
wapp_str8_slice(&str, 0, 12),
wapp_str8_slice(&str, 16, 19),
};
u64 index1 = 0;
@@ -437,14 +437,14 @@ WpTestFuncResult test_str8_split(void) {
u64 count2 = ARRLEN(splits2);
b8 running2 = true;
result = list1->node_count == count1 && wpStr8ListTotalSize(list1) == str.size - 3;
result = result && list2->node_count == count2 && wpStr8ListTotalSize(list2) == str.size - 4;
result = list1->node_count == count1 && wapp_str8_list_total_size(list1) == str.size - 3;
result = result && list2->node_count == count2 && wapp_str8_list_total_size(list2) == str.size - 4;
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
while (running1) {
WpStr8 *node = wpDblListGet(WpStr8, list1, index1);
result = result && wpStr8Equal(node, &(splits1[index1]));
Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list1, index1);
result = result && wapp_str8_equal(node->item, &(splits1[index1]));
++index1;
running1 = index1 < count1;
@@ -453,72 +453,72 @@ WpTestFuncResult test_str8_split(void) {
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
while (running2) {
WpStr8 *node = wpDblListGet(WpStr8, list2, index2);
result = result && wpStr8Equal(node, &(splits2[index2]));
Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list2, index2);
result = result && wapp_str8_equal(node->item, &(splits2[index2]));
++index2;
running2 = index2 < count2;
}
wpMemArenaAllocatorDestroy(&arena);
wapp_mem_arena_allocator_destroy(&arena);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_split_with_max(void) {
TestFuncResult test_str8_split_with_max(void) {
b8 result;
WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
Allocator arena = wapp_mem_arena_allocator_init(KiB(100));
WpStr8 str = wpStr8Lit("hello world from me");
WpStr8 delim = wpStr8Lit(" ");
WpStr8List *list = wpStr8SplitWithMax(&arena, &str, &delim, 2);
Str8 str = wapp_str8_lit("hello world from me");
Str8 delim = wapp_str8_lit(" ");
Str8List *list = wapp_str8_split_with_max(&arena, &str, &delim, 2);
WpStr8RO splits[] = {
wpStr8Slice(&str, 0, 5),
wpStr8Slice(&str, 6, 11),
wpStr8Slice(&str, 12, 19),
Str8RO splits[] = {
wapp_str8_slice(&str, 0, 5),
wapp_str8_slice(&str, 6, 11),
wapp_str8_slice(&str, 12, 19),
};
u64 index = 0;
u64 count = ARRLEN(splits);
b8 running = true;
result = list->node_count == count && wpStr8ListTotalSize(list) == str.size - 2;
result = list->node_count == count && wapp_str8_list_total_size(list) == str.size - 2;
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
while (running) {
WpStr8 *node = wpDblListGet(WpStr8, list, index);
result = result && wpStr8Equal(node, &(splits[index]));
Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list, index);
result = result && wapp_str8_equal(node->item, &(splits[index]));
++index;
running = index < count;
}
wpMemArenaAllocatorDestroy(&arena);
wapp_mem_arena_allocator_destroy(&arena);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_rsplit(void) {
TestFuncResult test_str8_rsplit(void) {
b8 result;
WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
Allocator arena = wapp_mem_arena_allocator_init(KiB(100));
WpStr8 str = wpStr8Lit("hello world from me");
WpStr8 delim1 = wpStr8Lit(" ");
WpStr8 delim2 = wpStr8Lit("from");
WpStr8List *list1 = wpStr8Rsplit(&arena, &str, &delim1);
WpStr8List *list2 = wpStr8Rsplit(&arena, &str, &delim2);
Str8 str = wapp_str8_lit("hello world from me");
Str8 delim1 = wapp_str8_lit(" ");
Str8 delim2 = wapp_str8_lit("from");
Str8List *list1 = wapp_str8_rsplit(&arena, &str, &delim1);
Str8List *list2 = wapp_str8_rsplit(&arena, &str, &delim2);
WpStr8RO splits1[] = {
wpStr8Slice(&str, 0, 5),
wpStr8Slice(&str, 6, 11),
wpStr8Slice(&str, 12, 16),
wpStr8Slice(&str, 17, 19),
Str8RO splits1[] = {
wapp_str8_slice(&str, 0, 5),
wapp_str8_slice(&str, 6, 11),
wapp_str8_slice(&str, 12, 16),
wapp_str8_slice(&str, 17, 19),
};
WpStr8RO splits2[] = {
wpStr8Slice(&str, 0, 12),
wpStr8Slice(&str, 16, 19),
Str8RO splits2[] = {
wapp_str8_slice(&str, 0, 12),
wapp_str8_slice(&str, 16, 19),
};
u64 index1 = 0;
@@ -529,14 +529,14 @@ WpTestFuncResult test_str8_rsplit(void) {
u64 count2 = ARRLEN(splits2);
b8 running2 = true;
result = list1->node_count == count1 && wpStr8ListTotalSize(list1) == str.size - 3;
result = result && list2->node_count == count2 && wpStr8ListTotalSize(list2) == str.size - 4;
result = list1->node_count == count1 && wapp_str8_list_total_size(list1) == str.size - 3;
result = result && list2->node_count == count2 && wapp_str8_list_total_size(list2) == str.size - 4;
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
while (running1) {
WpStr8 *node = wpDblListGet(WpStr8, list1, index1);
result = result && wpStr8Equal(node, &(splits1[index1]));
Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list1, index1);
result = result && wapp_str8_equal(node->item, &(splits1[index1]));
++index1;
running1 = index1 < count1;
@@ -545,83 +545,83 @@ WpTestFuncResult test_str8_rsplit(void) {
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
while (running2) {
WpStr8 *node = wpDblListGet(WpStr8, list2, index2);
result = result && wpStr8Equal(node, &(splits2[index2]));
Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list2, index2);
result = result && wapp_str8_equal(node->item, &(splits2[index2]));
++index2;
running2 = index2 < count2;
}
wpMemArenaAllocatorDestroy(&arena);
wapp_mem_arena_allocator_destroy(&arena);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_rsplit_with_max(void) {
TestFuncResult test_str8_rsplit_with_max(void) {
b8 result;
WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
Allocator arena = wapp_mem_arena_allocator_init(KiB(100));
WpStr8 str = wpStr8Lit("hello world from me");
WpStr8 delim = wpStr8Lit(" ");
WpStr8List *list = wpStr8RsplitWithMax(&arena, &str, &delim, 2);
Str8 str = wapp_str8_lit("hello world from me");
Str8 delim = wapp_str8_lit(" ");
Str8List *list = wapp_str8_rsplit_with_max(&arena, &str, &delim, 2);
WpStr8RO splits[] = {
wpStr8Slice(&str, 0, 11),
wpStr8Slice(&str, 12, 16),
wpStr8Slice(&str, 17, 19),
Str8RO splits[] = {
wapp_str8_slice(&str, 0, 11),
wapp_str8_slice(&str, 12, 16),
wapp_str8_slice(&str, 17, 19),
};
u64 index = 0;
u64 count = ARRLEN(splits);
b8 running = true;
result = list->node_count == count && wpStr8ListTotalSize(list) == str.size - 2;
result = list->node_count == count && wapp_str8_list_total_size(list) == str.size - 2;
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
while (running) {
WpStr8 *node = wpDblListGet(WpStr8, list, index);
result = result && wpStr8Equal(node, &(splits[index]));
Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list, index);
result = result && wapp_str8_equal(node->item, &(splits[index]));
++index;
running = index < count;
}
wpMemArenaAllocatorDestroy(&arena);
wapp_mem_arena_allocator_destroy(&arena);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_join(void) {
TestFuncResult test_str8_join(void) {
b8 result;
WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
Allocator arena = wapp_mem_arena_allocator_init(KiB(100));
WpStr8 str = wpStr8Lit("hello world from me");
WpStr8 delim1 = wpStr8Lit(" ");
WpStr8 delim2 = wpStr8Lit("from");
WpStr8List *list1 = wpStr8Rsplit(&arena, &str, &delim1);
WpStr8List *list2 = wpStr8Rsplit(&arena, &str, &delim2);
WpStr8 *join1 = wpStr8Join(&arena, list1, &delim1);
WpStr8 *join2 = wpStr8Join(&arena, list2, &delim2);
Str8 str = wapp_str8_lit("hello world from me");
Str8 delim1 = wapp_str8_lit(" ");
Str8 delim2 = wapp_str8_lit("from");
Str8List *list1 = wapp_str8_rsplit(&arena, &str, &delim1);
Str8List *list2 = wapp_str8_rsplit(&arena, &str, &delim2);
Str8 *join1 = wapp_str8_join(&arena, list1, &delim1);
Str8 *join2 = wapp_str8_join(&arena, list2, &delim2);
result = join1->size == str.size && wpStr8Equal(join1, &str);
result = result && join2->size == str.size && wpStr8Equal(join2, &str);
result = join1->size == str.size && wapp_str8_equal(join1, &str);
result = result && join2->size == str.size && wapp_str8_equal(join2, &str);
wpMemArenaAllocatorDestroy(&arena);
wapp_mem_arena_allocator_destroy(&arena);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_from_bytes(void) {
TestFuncResult test_str8_from_bytes(void) {
b8 result;
WpStr8 str = wpStr8Buf(1024);
WpStr8 expected = wpStr8LitRo("WAPP");
WpU8Array bytes = wpArray(u8, 'W', 'A', 'P', 'P');
wpStr8FromBytes(&str, bytes);
Str8 str = wapp_str8_buf(1024);
Str8 expected = wapp_str8_lit_ro("WAPP");
U8Array bytes = wapp_array(u8, U8Array, 'W', 'A', 'P', 'P');
wapp_str8_from_bytes(&str, &bytes);
result = str.size == wpArrayCount(bytes) * wpArrayItemSize(bytes);
result = result && wpStr8Equal(&str, &expected);
result = str.size == bytes.count * bytes.item_size;
result = result && wapp_str8_equal(&str, &expected);
return wpTesterResult(result);
return wapp_tester_result(result);
}
tests/str8/test_str8.h
+26 -26
View File
@@ -3,31 +3,31 @@
#include "wapp.h"
WpTestFuncResult test_str8_lit(void);
WpTestFuncResult test_str8_lit_ro(void);
WpTestFuncResult test_str8_buf(void);
WpTestFuncResult test_str8_alloc_buf(void);
WpTestFuncResult test_str8_alloc_cstr(void);
WpTestFuncResult test_str8_alloc_str8(void);
WpTestFuncResult test_str8_alloc_substr(void);
WpTestFuncResult test_str8_alloc_concat(void);
WpTestFuncResult test_str8_get_index_within_bounds(void);
WpTestFuncResult test_str8_get_index_out_of_bounds(void);
WpTestFuncResult test_str8_set(void);
WpTestFuncResult test_str8_push_back(void);
WpTestFuncResult test_str8_equal(void);
WpTestFuncResult test_str8_slice(void);
WpTestFuncResult test_str8_concat_capped(void);
WpTestFuncResult test_str8_copy_cstr_capped(void);
WpTestFuncResult test_str8_copy_str8_capped(void);
WpTestFuncResult test_str8_format(void);
WpTestFuncResult test_str8_find(void);
WpTestFuncResult test_str8_rfind(void);
WpTestFuncResult test_str8_split(void);
WpTestFuncResult test_str8_split_with_max(void);
WpTestFuncResult test_str8_rsplit(void);
WpTestFuncResult test_str8_rsplit_with_max(void);
WpTestFuncResult test_str8_join(void);
WpTestFuncResult test_str8_from_bytes(void);
TestFuncResult test_str8_lit(void);
TestFuncResult test_str8_lit_ro(void);
TestFuncResult test_str8_buf(void);
TestFuncResult test_str8_alloc_buf(void);
TestFuncResult test_str8_alloc_cstr(void);
TestFuncResult test_str8_alloc_str8(void);
TestFuncResult test_str8_alloc_substr(void);
TestFuncResult test_str8_alloc_concat(void);
TestFuncResult test_str8_get_index_within_bounds(void);
TestFuncResult test_str8_get_index_out_of_bounds(void);
TestFuncResult test_str8_set(void);
TestFuncResult test_str8_push_back(void);
TestFuncResult test_str8_equal(void);
TestFuncResult test_str8_slice(void);
TestFuncResult test_str8_concat_capped(void);
TestFuncResult test_str8_copy_cstr_capped(void);
TestFuncResult test_str8_copy_str8_capped(void);
TestFuncResult test_str8_format(void);
TestFuncResult test_str8_find(void);
TestFuncResult test_str8_rfind(void);
TestFuncResult test_str8_split(void);
TestFuncResult test_str8_split_with_max(void);
TestFuncResult test_str8_rsplit(void);
TestFuncResult test_str8_rsplit_with_max(void);
TestFuncResult test_str8_join(void);
TestFuncResult test_str8_from_bytes(void);
#endif // !TEST_STR8_H
tests/str8/test_str8_list.c
+180 -147
View File
@@ -1,230 +1,263 @@
#include "test_str8_list.h"
#include "wapp.h"
WpTestFuncResult test_str8_list_get(void) {
TestFuncResult test_str8_list_get(void) {
b8 result;
WpStr8 s1 = wpStr8Lit("1");
WpStr8 s2 = wpStr8Lit("2");
WpStr8 s3 = wpStr8Lit("3");
WpStr8 s4 = wpStr8Lit("4");
WpStr8 s5 = wpStr8Lit("5");
Str8 s1 = wapp_str8_lit("1");
Str8 s2 = wapp_str8_lit("2");
Str8 s3 = wapp_str8_lit("3");
Str8 s4 = wapp_str8_lit("4");
Str8 s5 = wapp_str8_lit("5");
WpStr8List list = wpDblList(WpStr8);
Str8List list = wapp_dbl_list(Str8, Str8List);
Str8Node n1 = wapp_str8_node_from_str8(s1);
Str8Node n2 = wapp_str8_node_from_str8(s2);
Str8Node n3 = wapp_str8_node_from_str8(s3);
Str8Node n4 = wapp_str8_node_from_str8(s4);
Str8Node n5 = wapp_str8_node_from_str8(s5);
wpDblListPushBack(WpStr8, &list, &s1);
wpDblListPushBack(WpStr8, &list, &s2);
wpDblListPushBack(WpStr8, &list, &s3);
wpDblListPushBack(WpStr8, &list, &s4);
wpDblListPushBack(WpStr8, &list, &s5);
wapp_dbl_list_push_back(Str8, &list, &n1);
wapp_dbl_list_push_back(Str8, &list, &n2);
wapp_dbl_list_push_back(Str8, &list, &n3);
wapp_dbl_list_push_back(Str8, &list, &n4);
wapp_dbl_list_push_back(Str8, &list, &n5);
WpStr8 *node = wpDblListGet(WpStr8, &list, 0);
result = node == &s1 && wpStr8Equal(node, &s1);
Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, &list, 0);
result = node->item == &s1 && wapp_str8_equal(node->item, &s1);
node = wpDblListGet(WpStr8, &list, 1);
result = result && node == &s2 && wpStr8Equal(node, &s2);
node = wapp_dbl_list_get(Str8, Str8Node, &list, 1);
result = result && node->item == &s2 && wapp_str8_equal(node->item, &s2);
node = wpDblListGet(WpStr8, &list, 2);
result = result && node == &s3 && wpStr8Equal(node, &s3);
node = wapp_dbl_list_get(Str8, Str8Node, &list, 2);
result = result && node->item == &s3 && wapp_str8_equal(node->item, &s3);
node = wpDblListGet(WpStr8, &list, 3);
result = result && node == &s4 && wpStr8Equal(node, &s4);
node = wapp_dbl_list_get(Str8, Str8Node, &list, 3);
result = result && node->item == &s4 && wapp_str8_equal(node->item, &s4);
node = wpDblListGet(WpStr8, &list, 4);
result = result && node == &s5 && wpStr8Equal(node, &s5);
node = wapp_dbl_list_get(Str8, Str8Node, &list, 4);
result = result && node->item == &s5 && wapp_str8_equal(node->item, &s5);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_list_push_front(void) {
TestFuncResult test_str8_list_push_front(void) {
b8 result;
WpStr8 s1 = wpStr8Lit("1");
WpStr8 s2 = wpStr8Lit("2");
WpStr8 s3 = wpStr8Lit("3");
Str8 s1 = wapp_str8_lit("1");
Str8 s2 = wapp_str8_lit("2");
Str8 s3 = wapp_str8_lit("3");
WpStr8List list = wpDblList(WpStr8);
Str8List list = wapp_dbl_list(Str8, Str8List);
Str8Node n1 = wapp_str8_node_from_str8(s1);
Str8Node n2 = wapp_str8_node_from_str8(s2);
Str8Node n3 = wapp_str8_node_from_str8(s3);
wpDblListPushFront(WpStr8, &list, &s1);
result = list.first == list.last && list.first->item == &s1 && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1;
wapp_dbl_list_push_front(Str8, &list, &n1);
result = list.first == list.last && list.first == &n1 && list.first->item == &s1 && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1;
wpDblListPushFront(WpStr8, &list, &s2);
result = result && list.first->item == &s2 && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2;
wapp_dbl_list_push_front(Str8, &list, &n2);
result = result && list.first == &n2 && list.first->item == &s2 && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2;
wpDblListPushFront(WpStr8, &list, &s3);
result = result && list.first->item == &s3 && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3;
wapp_dbl_list_push_front(Str8, &list, &n3);
result = result && list.first == &n3 && list.first->item == &s3 && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_list_push_back(void) {
TestFuncResult test_str8_list_push_back(void) {
b8 result;
WpStr8 s1 = wpStr8Lit("1");
WpStr8 s2 = wpStr8Lit("2");
WpStr8 s3 = wpStr8Lit("3");
Str8 s1 = wapp_str8_lit("1");
Str8 s2 = wapp_str8_lit("2");
Str8 s3 = wapp_str8_lit("3");
WpStr8List list = wpDblList(WpStr8);
Str8List list = wapp_dbl_list(Str8, Str8List);
Str8Node n1 = wapp_str8_node_from_str8(s1);
Str8Node n2 = wapp_str8_node_from_str8(s2);
Str8Node n3 = wapp_str8_node_from_str8(s3);
wpDblListPushBack(WpStr8, &list, &s1);
result = list.first == list.last && list.last->item == &s1 && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1;
wapp_dbl_list_push_back(Str8, &list, &n1);
result = list.first == list.last && list.last == &n1 && list.last->item == &s1 && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1;
wpDblListPushBack(WpStr8, &list, &s2);
result = result && list.last->item == &s2 && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2;
wapp_dbl_list_push_back(Str8, &list, &n2);
result = result && list.last == &n2 && list.last->item == &s2 && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2;
wpDblListPushBack(WpStr8, &list, &s3);
result = result && list.last->item == &s3 && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3;
wapp_dbl_list_push_back(Str8, &list, &n3);
result = result && list.last == &n3 && list.last->item == &s3 && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_list_insert(void) {
TestFuncResult test_str8_list_insert(void) {
b8 result;
WpStr8 s1 = wpStr8Lit("1");
WpStr8 s2 = wpStr8Lit("2");
WpStr8 s3 = wpStr8Lit("3");
WpStr8 s4 = wpStr8Lit("4");
WpStr8 s5 = wpStr8Lit("5");
WpStr8 s6 = wpStr8Lit("6");
WpStr8 s7 = wpStr8Lit("7");
Str8 s1 = wapp_str8_lit("1");
Str8 s2 = wapp_str8_lit("2");
Str8 s3 = wapp_str8_lit("3");
Str8 s4 = wapp_str8_lit("4");
Str8 s5 = wapp_str8_lit("5");
Str8 s6 = wapp_str8_lit("6");
Str8 s7 = wapp_str8_lit("7");
WpStr8List list = wpDblList(WpStr8);
Str8List list = wapp_dbl_list(Str8, Str8List);
Str8Node n1 = wapp_str8_node_from_str8(s1);
Str8Node n2 = wapp_str8_node_from_str8(s2);
Str8Node n3 = wapp_str8_node_from_str8(s3);
Str8Node n4 = wapp_str8_node_from_str8(s4);
Str8Node n5 = wapp_str8_node_from_str8(s5);
Str8Node n6 = wapp_str8_node_from_str8(s6);
Str8Node n7 = wapp_str8_node_from_str8(s7);
wpDblListPushBack(WpStr8, &list, &s1);
wpDblListPushBack(WpStr8, &list, &s2);
wpDblListPushBack(WpStr8, &list, &s3);
wpDblListPushBack(WpStr8, &list, &s4);
wpDblListPushBack(WpStr8, &list, &s5);
wapp_dbl_list_push_back(Str8, &list, &n1);
wapp_dbl_list_push_back(Str8, &list, &n2);
wapp_dbl_list_push_back(Str8, &list, &n3);
wapp_dbl_list_push_back(Str8, &list, &n4);
wapp_dbl_list_push_back(Str8, &list, &n5);
WpStr8 *node;
wpDblListInsert(WpStr8, &list, &s6, 2);
node = wpDblListGet(WpStr8, &list, 2);
result = node != NULL && node == &s6 && wpStr8ListTotalSize(&list) == 6 && list.node_count == 6;
wpDblListInsert(WpStr8, &list, &s7, 5);
node = wpDblListGet(WpStr8, &list, 5);
result = result && node != NULL && node == &s7 && wpStr8ListTotalSize(&list) == 7 && list.node_count == 7;
Str8Node *node;
wapp_dbl_list_insert(Str8, &list, &n6, 2);
node = wapp_dbl_list_get(Str8, Str8Node, &list, 2);
result = node != NULL && node->item == &s6 && wapp_str8_list_total_size(&list) == 6 && list.node_count == 6;
wapp_dbl_list_insert(Str8, &list, &n7, 5);
node = wapp_dbl_list_get(Str8, Str8Node, &list, 5);
result = result && node != NULL && node->item == &s7 && wapp_str8_list_total_size(&list) == 7 && list.node_count == 7;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_list_pop_front(void) {
TestFuncResult test_str8_list_pop_front(void) {
b8 result;
WpStr8 s1 = wpStr8Lit("1");
WpStr8 s2 = wpStr8Lit("2");
WpStr8 s3 = wpStr8Lit("3");
WpStr8 s4 = wpStr8Lit("4");
WpStr8 s5 = wpStr8Lit("5");
Str8 s1 = wapp_str8_lit("1");
Str8 s2 = wapp_str8_lit("2");
Str8 s3 = wapp_str8_lit("3");
Str8 s4 = wapp_str8_lit("4");
Str8 s5 = wapp_str8_lit("5");
WpStr8List list = wpDblList(WpStr8);
Str8List list = wapp_dbl_list(Str8, Str8List);
Str8Node n1 = wapp_str8_node_from_str8(s1);
Str8Node n2 = wapp_str8_node_from_str8(s2);
Str8Node n3 = wapp_str8_node_from_str8(s3);
Str8Node n4 = wapp_str8_node_from_str8(s4);
Str8Node n5 = wapp_str8_node_from_str8(s5);
wpDblListPushBack(WpStr8, &list, &s1);
wpDblListPushBack(WpStr8, &list, &s2);
wpDblListPushBack(WpStr8, &list, &s3);
wpDblListPushBack(WpStr8, &list, &s4);
wpDblListPushBack(WpStr8, &list, &s5);
wapp_dbl_list_push_back(Str8, &list, &n1);
wapp_dbl_list_push_back(Str8, &list, &n2);
wapp_dbl_list_push_back(Str8, &list, &n3);
wapp_dbl_list_push_back(Str8, &list, &n4);
wapp_dbl_list_push_back(Str8, &list, &n5);
WpStr8 *node = wpDblListPopFront(WpStr8, &list);
result = node == &s1 && wpStr8Equal(node, &s1) && wpStr8ListTotalSize(&list) == 4 && list.node_count == 4;
Str8Node *node = wapp_dbl_list_pop_front(Str8, Str8Node, &list);
result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4;
node = wpDblListPopFront(WpStr8, &list);
result = result && node == &s2 && wpStr8Equal(node, &s2) && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3;
node = wapp_dbl_list_pop_front(Str8, Str8Node, &list);
result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3;
node = wpDblListPopFront(WpStr8, &list);
result = result && node == &s3 && wpStr8Equal(node, &s3) && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2;
node = wapp_dbl_list_pop_front(Str8, Str8Node, &list);
result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2;
node = wpDblListPopFront(WpStr8, &list);
result = result && node == &s4 && wpStr8Equal(node, &s4) && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1;
node = wapp_dbl_list_pop_front(Str8, Str8Node, &list);
result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1;
node = wpDblListPopFront(WpStr8, &list);
result = result && node == &s5 && wpStr8Equal(node, &s5) && wpStr8ListTotalSize(&list) == 0 && list.node_count == 0;
node = wapp_dbl_list_pop_front(Str8, Str8Node, &list);
result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_list_pop_back(void) {
TestFuncResult test_str8_list_pop_back(void) {
b8 result;
WpStr8 s1 = wpStr8Lit("1");
WpStr8 s2 = wpStr8Lit("2");
WpStr8 s3 = wpStr8Lit("3");
WpStr8 s4 = wpStr8Lit("4");
WpStr8 s5 = wpStr8Lit("5");
Str8 s1 = wapp_str8_lit("1");
Str8 s2 = wapp_str8_lit("2");
Str8 s3 = wapp_str8_lit("3");
Str8 s4 = wapp_str8_lit("4");
Str8 s5 = wapp_str8_lit("5");
WpStr8List list = wpDblList(WpStr8);
Str8List list = wapp_dbl_list(Str8, Str8List);
Str8Node n1 = wapp_str8_node_from_str8(s1);
Str8Node n2 = wapp_str8_node_from_str8(s2);
Str8Node n3 = wapp_str8_node_from_str8(s3);
Str8Node n4 = wapp_str8_node_from_str8(s4);
Str8Node n5 = wapp_str8_node_from_str8(s5);
wpDblListPushFront(WpStr8, &list, &s1);
wpDblListPushFront(WpStr8, &list, &s2);
wpDblListPushFront(WpStr8, &list, &s3);
wpDblListPushFront(WpStr8, &list, &s4);
wpDblListPushFront(WpStr8, &list, &s5);
wapp_dbl_list_push_front(Str8, &list, &n1);
wapp_dbl_list_push_front(Str8, &list, &n2);
wapp_dbl_list_push_front(Str8, &list, &n3);
wapp_dbl_list_push_front(Str8, &list, &n4);
wapp_dbl_list_push_front(Str8, &list, &n5);
WpStr8 *node = wpDblListPopBack(WpStr8, &list);
result = node == &s1 && wpStr8Equal(node, &s1) && wpStr8ListTotalSize(&list) == 4 && list.node_count == 4;
Str8Node *node = wapp_dbl_list_pop_back(Str8, Str8Node, &list);
result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4;
node = wpDblListPopBack(WpStr8, &list);
result = result && node == &s2 && wpStr8Equal(node, &s2) && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3;
node = wapp_dbl_list_pop_back(Str8, Str8Node, &list);
result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3;
node = wpDblListPopBack(WpStr8, &list);
result = result && node == &s3 && wpStr8Equal(node, &s3) && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2;
node = wapp_dbl_list_pop_back(Str8, Str8Node, &list);
result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2;
node = wpDblListPopBack(WpStr8, &list);
result = result && node == &s4 && wpStr8Equal(node, &s4) && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1;
node = wapp_dbl_list_pop_back(Str8, Str8Node, &list);
result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1;
node = wpDblListPopBack(WpStr8, &list);
result = result && node == &s5 && wpStr8Equal(node, &s5) && wpStr8ListTotalSize(&list) == 0 && list.node_count == 0;
node = wapp_dbl_list_pop_back(Str8, Str8Node, &list);
result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_list_remove(void) {
TestFuncResult test_str8_list_remove(void) {
b8 result;
WpStr8 s1 = wpStr8Lit("1");
WpStr8 s2 = wpStr8Lit("2");
WpStr8 s3 = wpStr8Lit("3");
WpStr8 s4 = wpStr8Lit("4");
WpStr8 s5 = wpStr8Lit("5");
Str8 s1 = wapp_str8_lit("1");
Str8 s2 = wapp_str8_lit("2");
Str8 s3 = wapp_str8_lit("3");
Str8 s4 = wapp_str8_lit("4");
Str8 s5 = wapp_str8_lit("5");
WpStr8List list = wpDblList(WpStr8);
Str8List list = wapp_dbl_list(Str8, Str8List);
Str8Node n1 = wapp_str8_node_from_str8(s1);
Str8Node n2 = wapp_str8_node_from_str8(s2);
Str8Node n3 = wapp_str8_node_from_str8(s3);
Str8Node n4 = wapp_str8_node_from_str8(s4);
Str8Node n5 = wapp_str8_node_from_str8(s5);
wpDblListPushBack(WpStr8, &list, &s1);
wpDblListPushBack(WpStr8, &list, &s2);
wpDblListPushBack(WpStr8, &list, &s3);
wpDblListPushBack(WpStr8, &list, &s4);
wpDblListPushBack(WpStr8, &list, &s5);
wapp_dbl_list_push_back(Str8, &list, &n1);
wapp_dbl_list_push_back(Str8, &list, &n2);
wapp_dbl_list_push_back(Str8, &list, &n3);
wapp_dbl_list_push_back(Str8, &list, &n4);
wapp_dbl_list_push_back(Str8, &list, &n5);
WpStr8 *node = wpDblListRemove(WpStr8, &list, 0);
result = node == &s1 && wpStr8Equal(node, &s1) && wpStr8ListTotalSize(&list) == 4 && list.node_count == 4;
Str8Node *node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0);
result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4;
node = wpDblListRemove(WpStr8, &list, 0);
result = result && node == &s2 && wpStr8Equal(node, &s2) && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3;
node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0);
result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3;
node = wpDblListRemove(WpStr8, &list, 0);
result = result && node == &s3 && wpStr8Equal(node, &s3) && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2;
node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0);
result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2;
node = wpDblListRemove(WpStr8, &list, 0);
result = result && node == &s4 && wpStr8Equal(node, &s4) && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1;
node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0);
result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1;
node = wpDblListRemove(WpStr8, &list, 0);
result = result && node == &s5 && wpStr8Equal(node, &s5) && wpStr8ListTotalSize(&list) == 0 && list.node_count == 0;
node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0);
result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_list_empty(void) {
TestFuncResult test_str8_list_empty(void) {
b8 result;
WpStr8List list = wpDblList(WpStr8);
wpDblListPushBack(WpStr8, &list, &wpStr8Lit("Hello"));
wpDblListPushBack(WpStr8, &list, &wpStr8Lit("from"));
wpDblListPushBack(WpStr8, &list, &wpStr8Lit("wizapp"));
wpDblListPushBack(WpStr8, &list, &wpStr8Lit("stdlib"));
Str8List list = wapp_dbl_list(Str8, Str8List);
wapp_dbl_list_push_back(Str8, &list, &wapp_str8_node_from_cstr("Hello"));
wapp_dbl_list_push_back(Str8, &list, &wapp_str8_node_from_cstr("from"));
wapp_dbl_list_push_back(Str8, &list, &wapp_str8_node_from_cstr("wizapp"));
wapp_dbl_list_push_back(Str8, &list, &wapp_str8_node_from_cstr("stdlib"));
wpDblListEmpty(WpStr8, &list);
wapp_dbl_list_empty(Str8, &list);
result = list.first == NULL && list.last == NULL && list.node_count == 0 && wpStr8ListTotalSize(&list) == 0;
result = list.first == NULL && list.last == NULL && list.node_count == 0 && wapp_str8_list_total_size(&list) == 0;
return wpTesterResult(result);
return wapp_tester_result(result);
}
tests/str8/test_str8_list.cc
+184 -151
View File
@@ -1,238 +1,271 @@
#include "test_str8_list.h"
#include "wapp.h"
WpTestFuncResult test_str8_list_get(void) {
TestFuncResult test_str8_list_get(void) {
b8 result;
WpStr8 s1 = wpStr8Lit("1");
WpStr8 s2 = wpStr8Lit("2");
WpStr8 s3 = wpStr8Lit("3");
WpStr8 s4 = wpStr8Lit("4");
WpStr8 s5 = wpStr8Lit("5");
Str8 s1 = wapp_str8_lit("1");
Str8 s2 = wapp_str8_lit("2");
Str8 s3 = wapp_str8_lit("3");
Str8 s4 = wapp_str8_lit("4");
Str8 s5 = wapp_str8_lit("5");
WpStr8List list = wpDblList(WpStr8);
Str8List list = wapp_dbl_list(Str8, Str8List);
Str8Node n1 = wapp_str8_node_from_str8(s1);
Str8Node n2 = wapp_str8_node_from_str8(s2);
Str8Node n3 = wapp_str8_node_from_str8(s3);
Str8Node n4 = wapp_str8_node_from_str8(s4);
Str8Node n5 = wapp_str8_node_from_str8(s5);
wpDblListPushBack(WpStr8, &list, &s1);
wpDblListPushBack(WpStr8, &list, &s2);
wpDblListPushBack(WpStr8, &list, &s3);
wpDblListPushBack(WpStr8, &list, &s4);
wpDblListPushBack(WpStr8, &list, &s5);
wapp_dbl_list_push_back(Str8, &list, &n1);
wapp_dbl_list_push_back(Str8, &list, &n2);
wapp_dbl_list_push_back(Str8, &list, &n3);
wapp_dbl_list_push_back(Str8, &list, &n4);
wapp_dbl_list_push_back(Str8, &list, &n5);
WpStr8 *node = wpDblListGet(WpStr8, &list, 0);
result = node == &s1 && wpStr8Equal(node, &s1);
Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, &list, 0);
result = node->item == &s1 && wapp_str8_equal(node->item, &s1);
node = wpDblListGet(WpStr8, &list, 1);
result = result && node == &s2 && wpStr8Equal(node, &s2);
node = wapp_dbl_list_get(Str8, Str8Node, &list, 1);
result = result && node->item == &s2 && wapp_str8_equal(node->item, &s2);
node = wpDblListGet(WpStr8, &list, 2);
result = result && node == &s3 && wpStr8Equal(node, &s3);
node = wapp_dbl_list_get(Str8, Str8Node, &list, 2);
result = result && node->item == &s3 && wapp_str8_equal(node->item, &s3);
node = wpDblListGet(WpStr8, &list, 3);
result = result && node == &s4 && wpStr8Equal(node, &s4);
node = wapp_dbl_list_get(Str8, Str8Node, &list, 3);
result = result && node->item == &s4 && wapp_str8_equal(node->item, &s4);
node = wpDblListGet(WpStr8, &list, 4);
result = result && node == &s5 && wpStr8Equal(node, &s5);
node = wapp_dbl_list_get(Str8, Str8Node, &list, 4);
result = result && node->item == &s5 && wapp_str8_equal(node->item, &s5);
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_list_push_front(void) {
TestFuncResult test_str8_list_push_front(void) {
b8 result;
WpStr8 s1 = wpStr8Lit("1");
WpStr8 s2 = wpStr8Lit("2");
WpStr8 s3 = wpStr8Lit("3");
Str8 s1 = wapp_str8_lit("1");
Str8 s2 = wapp_str8_lit("2");
Str8 s3 = wapp_str8_lit("3");
WpStr8List list = wpDblList(WpStr8);
Str8List list = wapp_dbl_list(Str8, Str8List);
Str8Node n1 = wapp_str8_node_from_str8(s1);
Str8Node n2 = wapp_str8_node_from_str8(s2);
Str8Node n3 = wapp_str8_node_from_str8(s3);
wpDblListPushFront(WpStr8, &list, &s1);
result = list.first == list.last && list.first->item == &s1 && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1;
wapp_dbl_list_push_front(Str8, &list, &n1);
result = list.first == list.last && list.first == &n1 && list.first->item == &s1 && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1;
wpDblListPushFront(WpStr8, &list, &s2);
result = result && list.first->item == &s2 && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2;
wapp_dbl_list_push_front(Str8, &list, &n2);
result = result && list.first == &n2 && list.first->item == &s2 && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2;
wpDblListPushFront(WpStr8, &list, &s3);
result = result && list.first->item == &s3 && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3;
wapp_dbl_list_push_front(Str8, &list, &n3);
result = result && list.first == &n3 && list.first->item == &s3 && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_list_push_back(void) {
TestFuncResult test_str8_list_push_back(void) {
b8 result;
WpStr8 s1 = wpStr8Lit("1");
WpStr8 s2 = wpStr8Lit("2");
WpStr8 s3 = wpStr8Lit("3");
Str8 s1 = wapp_str8_lit("1");
Str8 s2 = wapp_str8_lit("2");
Str8 s3 = wapp_str8_lit("3");
WpStr8List list = wpDblList(WpStr8);
Str8List list = wapp_dbl_list(Str8, Str8List);
Str8Node n1 = wapp_str8_node_from_str8(s1);
Str8Node n2 = wapp_str8_node_from_str8(s2);
Str8Node n3 = wapp_str8_node_from_str8(s3);
wpDblListPushBack(WpStr8, &list, &s1);
result = list.first == list.last && list.last->item == &s1 && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1;
wapp_dbl_list_push_back(Str8, &list, &n1);
result = list.first == list.last && list.last == &n1 && list.last->item == &s1 && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1;
wpDblListPushBack(WpStr8, &list, &s2);
result = result && list.last->item == &s2 && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2;
wapp_dbl_list_push_back(Str8, &list, &n2);
result = result && list.last == &n2 && list.last->item == &s2 && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2;
wpDblListPushBack(WpStr8, &list, &s3);
result = result && list.last->item == &s3 && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3;
wapp_dbl_list_push_back(Str8, &list, &n3);
result = result && list.last == &n3 && list.last->item == &s3 && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_list_insert(void) {
TestFuncResult test_str8_list_insert(void) {
b8 result;
WpStr8 s1 = wpStr8Lit("1");
WpStr8 s2 = wpStr8Lit("2");
WpStr8 s3 = wpStr8Lit("3");
WpStr8 s4 = wpStr8Lit("4");
WpStr8 s5 = wpStr8Lit("5");
WpStr8 s6 = wpStr8Lit("6");
WpStr8 s7 = wpStr8Lit("7");
Str8 s1 = wapp_str8_lit("1");
Str8 s2 = wapp_str8_lit("2");
Str8 s3 = wapp_str8_lit("3");
Str8 s4 = wapp_str8_lit("4");
Str8 s5 = wapp_str8_lit("5");
Str8 s6 = wapp_str8_lit("6");
Str8 s7 = wapp_str8_lit("7");
WpStr8List list = wpDblList(WpStr8);
Str8List list = wapp_dbl_list(Str8, Str8List);
Str8Node n1 = wapp_str8_node_from_str8(s1);
Str8Node n2 = wapp_str8_node_from_str8(s2);
Str8Node n3 = wapp_str8_node_from_str8(s3);
Str8Node n4 = wapp_str8_node_from_str8(s4);
Str8Node n5 = wapp_str8_node_from_str8(s5);
Str8Node n6 = wapp_str8_node_from_str8(s6);
Str8Node n7 = wapp_str8_node_from_str8(s7);
wpDblListPushBack(WpStr8, &list, &s1);
wpDblListPushBack(WpStr8, &list, &s2);
wpDblListPushBack(WpStr8, &list, &s3);
wpDblListPushBack(WpStr8, &list, &s4);
wpDblListPushBack(WpStr8, &list, &s5);
wapp_dbl_list_push_back(Str8, &list, &n1);
wapp_dbl_list_push_back(Str8, &list, &n2);
wapp_dbl_list_push_back(Str8, &list, &n3);
wapp_dbl_list_push_back(Str8, &list, &n4);
wapp_dbl_list_push_back(Str8, &list, &n5);
WpStr8 *node;
wpDblListInsert(WpStr8, &list, &s6, 2);
node = wpDblListGet(WpStr8, &list, 2);
result = node != NULL && node == &s6 && wpStr8ListTotalSize(&list) == 6 && list.node_count == 6;
wpDblListInsert(WpStr8, &list, &s7, 5);
node = wpDblListGet(WpStr8, &list, 5);
result = result && node != NULL && node == &s7 && wpStr8ListTotalSize(&list) == 7 && list.node_count == 7;
Str8Node *node;
wapp_dbl_list_insert(Str8, &list, &n6, 2);
node = wapp_dbl_list_get(Str8, Str8Node, &list, 2);
result = node != NULL && node->item == &s6 && wapp_str8_list_total_size(&list) == 6 && list.node_count == 6;
wapp_dbl_list_insert(Str8, &list, &n7, 5);
node = wapp_dbl_list_get(Str8, Str8Node, &list, 5);
result = result && node != NULL && node->item == &s7 && wapp_str8_list_total_size(&list) == 7 && list.node_count == 7;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_list_pop_front(void) {
TestFuncResult test_str8_list_pop_front(void) {
b8 result;
WpStr8 s1 = wpStr8Lit("1");
WpStr8 s2 = wpStr8Lit("2");
WpStr8 s3 = wpStr8Lit("3");
WpStr8 s4 = wpStr8Lit("4");
WpStr8 s5 = wpStr8Lit("5");
Str8 s1 = wapp_str8_lit("1");
Str8 s2 = wapp_str8_lit("2");
Str8 s3 = wapp_str8_lit("3");
Str8 s4 = wapp_str8_lit("4");
Str8 s5 = wapp_str8_lit("5");
WpStr8List list = wpDblList(WpStr8);
Str8List list = wapp_dbl_list(Str8, Str8List);
Str8Node n1 = wapp_str8_node_from_str8(s1);
Str8Node n2 = wapp_str8_node_from_str8(s2);
Str8Node n3 = wapp_str8_node_from_str8(s3);
Str8Node n4 = wapp_str8_node_from_str8(s4);
Str8Node n5 = wapp_str8_node_from_str8(s5);
wpDblListPushBack(WpStr8, &list, &s1);
wpDblListPushBack(WpStr8, &list, &s2);
wpDblListPushBack(WpStr8, &list, &s3);
wpDblListPushBack(WpStr8, &list, &s4);
wpDblListPushBack(WpStr8, &list, &s5);
wapp_dbl_list_push_back(Str8, &list, &n1);
wapp_dbl_list_push_back(Str8, &list, &n2);
wapp_dbl_list_push_back(Str8, &list, &n3);
wapp_dbl_list_push_back(Str8, &list, &n4);
wapp_dbl_list_push_back(Str8, &list, &n5);
WpStr8 *node = wpDblListPopFront(WpStr8, &list);
result = node == &s1 && wpStr8Equal(node, &s1) && wpStr8ListTotalSize(&list) == 4 && list.node_count == 4;
Str8Node *node = wapp_dbl_list_pop_front(Str8, Str8Node, &list);
result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4;
node = wpDblListPopFront(WpStr8, &list);
result = result && node == &s2 && wpStr8Equal(node, &s2) && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3;
node = wapp_dbl_list_pop_front(Str8, Str8Node, &list);
result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3;
node = wpDblListPopFront(WpStr8, &list);
result = result && node == &s3 && wpStr8Equal(node, &s3) && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2;
node = wapp_dbl_list_pop_front(Str8, Str8Node, &list);
result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2;
node = wpDblListPopFront(WpStr8, &list);
result = result && node == &s4 && wpStr8Equal(node, &s4) && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1;
node = wapp_dbl_list_pop_front(Str8, Str8Node, &list);
result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1;
node = wpDblListPopFront(WpStr8, &list);
result = result && node == &s5 && wpStr8Equal(node, &s5) && wpStr8ListTotalSize(&list) == 0 && list.node_count == 0;
node = wapp_dbl_list_pop_front(Str8, Str8Node, &list);
result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_list_pop_back(void) {
TestFuncResult test_str8_list_pop_back(void) {
b8 result;
WpStr8 s1 = wpStr8Lit("1");
WpStr8 s2 = wpStr8Lit("2");
WpStr8 s3 = wpStr8Lit("3");
WpStr8 s4 = wpStr8Lit("4");
WpStr8 s5 = wpStr8Lit("5");
Str8 s1 = wapp_str8_lit("1");
Str8 s2 = wapp_str8_lit("2");
Str8 s3 = wapp_str8_lit("3");
Str8 s4 = wapp_str8_lit("4");
Str8 s5 = wapp_str8_lit("5");
WpStr8List list = wpDblList(WpStr8);
Str8List list = wapp_dbl_list(Str8, Str8List);
Str8Node n1 = wapp_str8_node_from_str8(s1);
Str8Node n2 = wapp_str8_node_from_str8(s2);
Str8Node n3 = wapp_str8_node_from_str8(s3);
Str8Node n4 = wapp_str8_node_from_str8(s4);
Str8Node n5 = wapp_str8_node_from_str8(s5);
wpDblListPushFront(WpStr8, &list, &s1);
wpDblListPushFront(WpStr8, &list, &s2);
wpDblListPushFront(WpStr8, &list, &s3);
wpDblListPushFront(WpStr8, &list, &s4);
wpDblListPushFront(WpStr8, &list, &s5);
wapp_dbl_list_push_front(Str8, &list, &n1);
wapp_dbl_list_push_front(Str8, &list, &n2);
wapp_dbl_list_push_front(Str8, &list, &n3);
wapp_dbl_list_push_front(Str8, &list, &n4);
wapp_dbl_list_push_front(Str8, &list, &n5);
WpStr8 *node = wpDblListPopBack(WpStr8, &list);
result = node == &s1 && wpStr8Equal(node, &s1) && wpStr8ListTotalSize(&list) == 4 && list.node_count == 4;
Str8Node *node = wapp_dbl_list_pop_back(Str8, Str8Node, &list);
result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4;
node = wpDblListPopBack(WpStr8, &list);
result = result && node == &s2 && wpStr8Equal(node, &s2) && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3;
node = wapp_dbl_list_pop_back(Str8, Str8Node, &list);
result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3;
node = wpDblListPopBack(WpStr8, &list);
result = result && node == &s3 && wpStr8Equal(node, &s3) && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2;
node = wapp_dbl_list_pop_back(Str8, Str8Node, &list);
result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2;
node = wpDblListPopBack(WpStr8, &list);
result = result && node == &s4 && wpStr8Equal(node, &s4) && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1;
node = wapp_dbl_list_pop_back(Str8, Str8Node, &list);
result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1;
node = wpDblListPopBack(WpStr8, &list);
result = result && node == &s5 && wpStr8Equal(node, &s5) && wpStr8ListTotalSize(&list) == 0 && list.node_count == 0;
node = wapp_dbl_list_pop_back(Str8, Str8Node, &list);
result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_list_remove(void) {
TestFuncResult test_str8_list_remove(void) {
b8 result;
WpStr8 s1 = wpStr8Lit("1");
WpStr8 s2 = wpStr8Lit("2");
WpStr8 s3 = wpStr8Lit("3");
WpStr8 s4 = wpStr8Lit("4");
WpStr8 s5 = wpStr8Lit("5");
Str8 s1 = wapp_str8_lit("1");
Str8 s2 = wapp_str8_lit("2");
Str8 s3 = wapp_str8_lit("3");
Str8 s4 = wapp_str8_lit("4");
Str8 s5 = wapp_str8_lit("5");
WpStr8List list = wpDblList(WpStr8);
Str8List list = wapp_dbl_list(Str8, Str8List);
Str8Node n1 = wapp_str8_node_from_str8(s1);
Str8Node n2 = wapp_str8_node_from_str8(s2);
Str8Node n3 = wapp_str8_node_from_str8(s3);
Str8Node n4 = wapp_str8_node_from_str8(s4);
Str8Node n5 = wapp_str8_node_from_str8(s5);
wpDblListPushBack(WpStr8, &list, &s1);
wpDblListPushBack(WpStr8, &list, &s2);
wpDblListPushBack(WpStr8, &list, &s3);
wpDblListPushBack(WpStr8, &list, &s4);
wpDblListPushBack(WpStr8, &list, &s5);
wapp_dbl_list_push_back(Str8, &list, &n1);
wapp_dbl_list_push_back(Str8, &list, &n2);
wapp_dbl_list_push_back(Str8, &list, &n3);
wapp_dbl_list_push_back(Str8, &list, &n4);
wapp_dbl_list_push_back(Str8, &list, &n5);
WpStr8 *node = wpDblListRemove(WpStr8, &list, 0);
result = node == &s1 && wpStr8Equal(node, &s1) && wpStr8ListTotalSize(&list) == 4 && list.node_count == 4;
Str8Node *node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0);
result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4;
node = wpDblListRemove(WpStr8, &list, 0);
result = result && node == &s2 && wpStr8Equal(node, &s2) && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3;
node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0);
result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3;
node = wpDblListRemove(WpStr8, &list, 0);
result = result && node == &s3 && wpStr8Equal(node, &s3) && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2;
node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0);
result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2;
node = wpDblListRemove(WpStr8, &list, 0);
result = result && node == &s4 && wpStr8Equal(node, &s4) && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1;
node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0);
result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1;
node = wpDblListRemove(WpStr8, &list, 0);
result = result && node == &s5 && wpStr8Equal(node, &s5) && wpStr8ListTotalSize(&list) == 0 && list.node_count == 0;
node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0);
result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0;
return wpTesterResult(result);
return wapp_tester_result(result);
}
WpTestFuncResult test_str8_list_empty(void) {
TestFuncResult test_str8_list_empty(void) {
b8 result;
WpStr8List list = wpDblList(WpStr8);
Str8List list = wapp_dbl_list(Str8, Str8List);
WpStr8 hello = wpStr8Lit("Hello");
wpDblListPushBack(WpStr8, &list, &hello);
Str8Node hello = wapp_str8_node_from_cstr("Hello");
wapp_dbl_list_push_back(Str8, &list, &hello);
WpStr8 from = wpStr8Lit("from");
wpDblListPushBack(WpStr8, &list, &from);
Str8Node from = wapp_str8_node_from_cstr("from");
wapp_dbl_list_push_back(Str8, &list, &from);
WpStr8 wizapp = wpStr8Lit("wizapp");
wpDblListPushBack(WpStr8, &list, &wizapp);
Str8Node wizapp = wapp_str8_node_from_cstr("wizapp");
wapp_dbl_list_push_back(Str8, &list, &wizapp);
WpStr8 stdlib = wpStr8Lit("stdlib");
wpDblListPushBack(WpStr8, &list, &stdlib);
Str8Node stdlib = wapp_str8_node_from_cstr("stdlib");
wapp_dbl_list_push_back(Str8, &list, &stdlib);
wpDblListEmpty(WpStr8, &list);
wapp_dbl_list_empty(Str8, &list);
result = list.first == NULL && list.last == NULL && list.node_count == 0 && wpStr8ListTotalSize(&list) == 0;
result = list.first == NULL && list.last == NULL && list.node_count == 0 && wapp_str8_list_total_size(&list) == 0;
return wpTesterResult(result);
return wapp_tester_result(result);
}

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