Compare commits
5 Commits
v2.1.1
..
f23f85e305
| Author | SHA1 | Date | |
|---|---|---|---|
 Abdelrahman Said
|
f23f85e305 | ||
|
Abdelrahman Said
|
751192173f | ||
|
Abdelrahman Said
|
1108ed686e | ||
 abdelrahman
|
36e88ba84d | ||
|
abdelrahman
|
0617ca2316 |
@@ -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/*
|
||||
+1
-4
@@ -1,6 +1,5 @@
|
||||
.cache
|
||||
.vscode
|
||||
.venv
|
||||
test
|
||||
test.*
|
||||
*.dSYM
|
||||
@@ -9,6 +8,4 @@ test.*
|
||||
*.obj
|
||||
compile_commands.json
|
||||
libwapp-build
|
||||
dist
|
||||
*.vs
|
||||
__pycache__
|
||||
libwapp.so
|
||||
|
||||
@@ -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.
|
||||
@@ -1,180 +0,0 @@
|
||||
.PHONY: help full base os prng testing uuid all clean builddir build-test run-test install build-lib
|
||||
|
||||
# External variables
|
||||
CC = clang
|
||||
CXX = clang++
|
||||
AR = ar
|
||||
BUILD_TYPE = Debug
|
||||
BUILD_DIR = libwapp-build/$(PLATFORM)-$(BUILD_TYPE)
|
||||
INSTALL_PREFIX = dist
|
||||
RUNTIME_ASSERT = true
|
||||
|
||||
# Internal variables
|
||||
override CFLAGS = -Wall -Wextra -Werror -pedantic -Isrc
|
||||
override LIBFLAGS = -fPIC
|
||||
override CSTD := -std=gnu11
|
||||
override CXXSTD := -std=gnu++11
|
||||
override KERNEL := $(shell uname -s)
|
||||
override MACHINE := $(shell uname -m)
|
||||
override PLATFORM := $(KERNEL)_$(MACHINE)
|
||||
override TEST_INCLUDE := -Isrc $(shell find tests -type d | xargs -I{} echo -n "-I{} ")
|
||||
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 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 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
|
||||
else ifeq ($(BUILD_TYPE),RelWithDebInfo)
|
||||
BUILD_FLAGS += -g -O2 -fsanitize=address,undefined -DWP_DEBUG_ASSERT
|
||||
else ifeq ($(BUILD_TYPE),Release)
|
||||
BUILD_FLAGS += -O3
|
||||
else
|
||||
$(error Invalid BUILD type '$(BUILD_TYPE)'. Use 'Debug', 'RelWithDebInfo' or 'Release')
|
||||
endif
|
||||
endif
|
||||
|
||||
# Disable runtime asserts
|
||||
ifeq ($(RUNTIME_ASSERT), false)
|
||||
override BUILD_FLAGS += -DWP_NO_RUNTIME_ASSERT
|
||||
endif
|
||||
|
||||
ifeq ($(CC),gcc)
|
||||
# Used to disable the "ASan runtime does not come first in initial library list" error when compiling with gcc
|
||||
export ASAN_OPTIONS=verify_asan_link_order=0
|
||||
endif
|
||||
|
||||
# Escape sequences
|
||||
BOLD = \033[1m
|
||||
BLACK = \033[30m
|
||||
BG_BLACK = \033[40m
|
||||
RED = \033[31m
|
||||
BG_RED = \033[41m
|
||||
GREEN = \033[32m
|
||||
BG_GREEN = \033[42m
|
||||
YELLOW = \033[33m
|
||||
BG_YELLOW = \033[43m
|
||||
BLUE = \033[34m
|
||||
BG_BLUE = \033[44m
|
||||
MAGENTA = \033[35m
|
||||
BG_MAGENTA = \033[45m
|
||||
CYAN = \033[36m
|
||||
BG_CYAN = \033[46m
|
||||
WHITE = \033[37m
|
||||
BG_WHITE = \033[47m
|
||||
GRAY = \033[90m
|
||||
BG_GRAY = \033[100m
|
||||
BRIGHT_RED = \033[91m
|
||||
BG_BRIGHT_RED = \033[101m
|
||||
BRIGHT_GREEN = \033[92m
|
||||
BG_BRIGHT_GREEN = \033[102m
|
||||
BRIGHT_YELLOW = \033[93m
|
||||
BG_BRIGHT_YELLOW = \033[103m
|
||||
BRIGHT_BLUE = \033[94m
|
||||
BG_BRIGHT_BLUE = \033[104m
|
||||
BRIGHT_MAGENTA = \033[95m
|
||||
BG_BRIGHT_MAGENTA = \033[105m
|
||||
BRIGHT_CYAN = \033[96m
|
||||
BG_BRIGHT_CYAN = \033[106m
|
||||
BRIGHT_WHITE = \033[97m
|
||||
BG_BRIGHT_WHITE = \033[107m
|
||||
RESET = \033[0m
|
||||
|
||||
ECHO_E = echo -e
|
||||
ifeq ($(KERNEL), Darwin)
|
||||
ECHO_E = echo
|
||||
endif
|
||||
|
||||
all: clean builddir run-c-test full run-cc-test
|
||||
|
||||
help:
|
||||
@$(ECHO_E) "$(BOLD)$(BLUE)Available build variables:$(RESET)"
|
||||
@$(ECHO_E) " $(GREEN)CC$(RESET) C compiler to use $(YELLOW)(Default: clang)$(RESET)."
|
||||
@$(ECHO_E) " $(GREEN)CXX$(RESET) C++ compiler to use $(YELLOW)(Default: clang++)$(RESET)."
|
||||
@$(ECHO_E) " $(GREEN)AR$(RESET) Archiving utility to use for building static libraries $(YELLOW)(Default: ar)$(RESET)."
|
||||
@$(ECHO_E) " $(GREEN)BUILD_TYPE$(RESET) Build type $(MAGENTA)[Debug | RelWithDebInfo | Release] $(YELLOW)(Default: Debug)$(RESET)."
|
||||
@$(ECHO_E) " $(GREEN)BUILD_DIR$(RESET) Directory where build files will be written."
|
||||
@$(ECHO_E) " $(GREEN)INSTALL_PREFIX$(RESET) Prefix where library and include files will be installed."
|
||||
@$(ECHO_E) " $(GREEN)RUNTIME_ASSERT$(RESET) Whether runtime asserts are enabled $(MAGENTA)[true | false] $(YELLOW)(Default: true)$(RESET)."
|
||||
@$(ECHO_E) " $(GREEN)$(RESET) $(BOLD)$(BG_RED)DISCLAIMER:$(RESET) Using this flag is not recommended as it disables safety checks"
|
||||
@$(ECHO_E) " $(GREEN)$(RESET) potentially leading to Undefined Behaviour."
|
||||
@$(ECHO_E)
|
||||
@$(ECHO_E) "$(BOLD)$(BLUE)Available targets:$(RESET)"
|
||||
@$(ECHO_E) " $(GREEN)make$(RESET) Build, install and test the full wapp library."
|
||||
@$(ECHO_E) " $(GREEN)make full$(RESET) Build and install the full wapp library."
|
||||
@$(ECHO_E) " $(GREEN)make base$(RESET) Build and install only the $(CYAN)base$(RESET) component of the wapp library with all its dependencies."
|
||||
@$(ECHO_E) " $(GREEN)make os$(RESET) Build and install only the $(CYAN)os$(RESET) component of the wapp library with all its dependencies."
|
||||
@$(ECHO_E) " $(GREEN)make prng$(RESET) Build and install only the $(CYAN)prng$(RESET) component of the wapp library with all its dependencies."
|
||||
@$(ECHO_E) " $(GREEN)make uuid$(RESET) Build and install only the $(CYAN)uuid$(RESET) component of the wapp library with all its dependencies."
|
||||
@$(ECHO_E) " $(GREEN)make testing$(RESET) Build and install only the $(CYAN)testing$(RESET) component of the wapp library with all its dependencies."
|
||||
@$(ECHO_E) " $(GREEN)make clean$(RESET) Clean the build directory."
|
||||
@$(ECHO_E) " $(GREEN)make help$(RESET) Print this help message and exit."
|
||||
|
||||
full: LIB_SRC = src/wapp.c
|
||||
full: INCLUDES = common os base prng testing uuid
|
||||
full: install
|
||||
|
||||
base: LIB_SRC = src/base/wapp_base.c
|
||||
base: INCLUDES = common base
|
||||
base: install
|
||||
|
||||
os: LIB_SRC = src/os/wapp_os.c
|
||||
os: INCLUDES = common os base
|
||||
os: install
|
||||
|
||||
prng: LIB_SRC = src/prng/wapp_prng.c
|
||||
prng: INCLUDES = common prng
|
||||
prng: install
|
||||
|
||||
testing: LIB_SRC = src/testing/wapp_testing.c
|
||||
testing: INCLUDES = common os testing
|
||||
testing: install
|
||||
|
||||
uuid: LIB_SRC = src/uuid/wapp_uuid.c
|
||||
uuid: INCLUDES = common base prng
|
||||
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)"
|
||||
|
||||
run-c-test: build-c-test
|
||||
@echo -e "\n\033[34;1mRUNNING C TESTS\033[0m"
|
||||
@"$(TEST_C_OUT)"
|
||||
@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)"
|
||||
|
||||
run-cc-test: build-cc-test
|
||||
@echo -e "\n\033[34;1mRUNNING C++ TESTS\033[0m"
|
||||
@export LD_LIBRARY_PATH=$$LD_LIBRARY_PATH:"$(BUILD_DIR)" && "$(TEST_CXX_OUT)"
|
||||
@rm "$(TEST_CXX_OUT)"
|
||||
|
||||
install: build-lib
|
||||
@mkdir -p "$(LIB_INSTALL)"
|
||||
@cp -v "$(LIB_OUT)" "$(LIB_INSTALL)"
|
||||
@mkdir -p "$(INCLUDE_INSTALL)"
|
||||
@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)"
|
||||
$(AR) r "$(LIB_OUT)" "$(OBJ_OUT)"
|
||||
@rm "$(OBJ_OUT)"
|
||||
@@ -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 collection of useful C/C++ utilities for my projects
|
||||
|
||||
@@ -1,58 +1,3 @@
|
||||
#!/bin/bash
|
||||
|
||||
# Colors
|
||||
RED="\033[0;31m"
|
||||
BOLD="\033[1m"
|
||||
NC="\033[0m" # No Color
|
||||
|
||||
BUILD_TYPE="Debug"
|
||||
ACCEPTED_BUILD_TYPES=("Debug" "RelWithDebInfo" "Release")
|
||||
KERNEL="$(uname -s)"
|
||||
ARGS=""
|
||||
|
||||
join_array_elements() {
|
||||
local IFS=","
|
||||
echo "$*"
|
||||
}
|
||||
|
||||
contains() {
|
||||
local item="$1"; shift
|
||||
local e
|
||||
for e; do
|
||||
[[ "$e" == "$item" ]] && return 0
|
||||
done
|
||||
return 1
|
||||
}
|
||||
|
||||
print_usage() {
|
||||
echo -e "Usage: build [-b build_type] ..."
|
||||
echo -e " Options:"
|
||||
echo -e " -b, --build-type Choose from $(join_array_elements ${ACCEPTED_BUILD_TYPES[*]}) (Default: Debug)."
|
||||
echo -e " -h, --help Print this message and exit"
|
||||
}
|
||||
|
||||
while [[ $# > 0 ]];do
|
||||
case $1 in
|
||||
-b|--build-type)
|
||||
BUILD_TYPE="$2"
|
||||
shift 2
|
||||
;;
|
||||
-h|--help)
|
||||
print_usage
|
||||
exit 0
|
||||
;;
|
||||
*|-*|--*)
|
||||
rest=("$@")
|
||||
ARGS+=" ${rest[0]}"
|
||||
shift
|
||||
;;
|
||||
esac
|
||||
done
|
||||
|
||||
if ! contains ${BUILD_TYPE} "${ACCEPTED_BUILD_TYPES[@]}"; then
|
||||
echo -e "${RED}${BOLD}Unknown build type: ${BUILD_TYPE}${NC}\n"
|
||||
print_usage
|
||||
exit 1
|
||||
fi
|
||||
|
||||
make BUILD_TYPE=$BUILD_TYPE $ARGS
|
||||
bear -- ./compile $@
|
||||
|
||||
@@ -3,46 +3,35 @@ Param(
|
||||
)
|
||||
|
||||
$Compiler = "cl.exe"
|
||||
$Linker = "lib.exe"
|
||||
|
||||
$GeneralFlags = "/Wall /WX /wd4996 /wd4464 /wd5105 /EHs"
|
||||
$CStd = "/std:c11"
|
||||
$CppStd = "/std:c++14"
|
||||
$LibraryFlags = "/c"
|
||||
$GeneralFlags = "/Wall /WX /wd4996"
|
||||
$LibraryFlags = "/LD"
|
||||
|
||||
$Kernel = (Get-ChildItem Env:OS).Value
|
||||
$Machine = (Get-ChildItem Env:PROCESSOR_ARCHITECTURE).Value
|
||||
$Platform = "${Kernel}_${Machine}"
|
||||
|
||||
$IncludeDirs = "/I src"
|
||||
$SrcFiles = "src/wapp.c"
|
||||
$IncludeDirs = Get-ChildItem -Path src -Recurse -Directory -ErrorAction SilentlyContinue -Force | %{$("/I " + '"' + $_.FullName + '"')}
|
||||
$SrcFiles = Get-ChildItem -Path src -Recurse -Filter *.c -ErrorAction SilentlyContinue -Force | %{$('"' + $_.FullName + '"')}
|
||||
|
||||
$TestIncludeDirs = Get-ChildItem -Path tests -Recurse -Directory -ErrorAction SilentlyContinue -Force | %{$("/I " + '"' + $_.FullName + '"')}
|
||||
$TestCSrcFiles = Get-ChildItem -Path tests -Recurse -Filter *.c -ErrorAction SilentlyContinue -Force | %{$('"' + $_.FullName + '"')}
|
||||
$TestCppSrcFiles = Get-ChildItem -Path tests -Recurse -Filter *.cc -ErrorAction SilentlyContinue -Force | %{$('"' + $_.FullName + '"')}
|
||||
$TestSrcFiles = Get-ChildItem -Path tests -Recurse -Filter *.c -ErrorAction SilentlyContinue -Force | %{$('"' + $_.FullName + '"')}
|
||||
|
||||
If ($Release -eq $True) {
|
||||
$GeneralFlags += " /O2 /Og"
|
||||
$BuildType = "Release"
|
||||
$BuildType = "release"
|
||||
} Else {
|
||||
$GeneralFlags += " /Zi /Od /fsanitize=address"
|
||||
$BuildType = "Debug"
|
||||
$BuildType = "debug"
|
||||
}
|
||||
|
||||
$BuildDir = "./libwapp-build/${Platform}-${BuildType}"
|
||||
$BuildDir = "./libwapp-build/windows-$BuildType"
|
||||
$ObjDir = "$BuildDir/objects"
|
||||
$OutDir = "$BuildDir/output"
|
||||
$TestsDir = "$BuildDir/tests"
|
||||
|
||||
$LibOutput = "$OutDir/libwapp.lib"
|
||||
$OutBasename = "libwapp"
|
||||
$Objects = "/Fo:$ObjDir/"
|
||||
$LibOutputFlags = "/OUT:$LibOutput"
|
||||
$Outputs = "/Fd:$OutDir/$OutBasename /Fe:$OutDir/$OutBasename"
|
||||
|
||||
$TestCOutputBasename = "wapptest"
|
||||
$TestCOutputFlags = "/Fo:$TestsDir/ /Fe:$TestsDir/$TestCOutputBasename"
|
||||
|
||||
$TestCppOutputBasename = "wapptestcc"
|
||||
$TestCppOutputFlags = "/Fo:$TestsDir/ /Fe:$TestsDir/$TestCppOutputBasename"
|
||||
$TestOutBasename = "wapptest"
|
||||
$TestOutputs = "/Fo:$TestsDir/ /Fe:$TestsDir/$TestOutBasename"
|
||||
|
||||
If (Test-Path $BuildDir) {
|
||||
Remove-Item $BuildDir -Recurse -Force
|
||||
@@ -52,23 +41,18 @@ mkdir -p $ObjDir > $null
|
||||
mkdir -p $OutDir > $null
|
||||
mkdir -p $TestsDir > $null
|
||||
|
||||
# Build and run C tests
|
||||
Invoke-Expression "$Compiler $GeneralFlags $CStd $IncludeDirs $TestIncludeDirs $SrcFiles $TestCSrcFiles $TestCOutputFlags" -ErrorAction Stop
|
||||
Invoke-Expression "$TestsDir/$TestCOutputBasename.exe"
|
||||
# Build and run tests
|
||||
Invoke-Expression "$Compiler $GeneralFlags $IncludeDirs $TestIncludeDirs $SrcFiles $TestSrcFiles $TestOutputs" -ErrorAction Stop
|
||||
|
||||
Invoke-Expression "$TestsDir/$TestOutBasename.exe"
|
||||
$Status = $LASTEXITCODE
|
||||
If ($Status -ne 0) {
|
||||
|
||||
Remove-Item $TestsDir -Recurse -Force
|
||||
|
||||
If ($Status -ne 0) {
|
||||
Write-Error "Tests failed"
|
||||
Exit 1
|
||||
}
|
||||
|
||||
# Build library
|
||||
Invoke-Expression "$Compiler $GeneralFlags $CStd $LibraryFlags $SrcFiles $Objects"
|
||||
Invoke-Expression "$Linker $ObjDir/*.obj $LibOutputFlags"
|
||||
|
||||
# Build and run C++ tests
|
||||
Invoke-Expression "$Compiler $GeneralFlags $CppStd $IncludeDirs $TestIncludeDirs $LibOutput $TestCppSrcFiles $TestCppOutputFlags" -ErrorAction Stop
|
||||
Invoke-Expression "$TestsDir/$TestCppOutputBasename.exe"
|
||||
|
||||
Remove-Item $TestsDir -Recurse -Force
|
||||
Invoke-Expression "$Compiler $GeneralFlags $LibraryFlags $IncludeDirs $SrcFiles $Objects $Outputs"
|
||||
|
||||
@@ -0,0 +1,61 @@
|
||||
#!/bin/bash
|
||||
|
||||
BUILD_TYPE="debug"
|
||||
|
||||
while [[ $# > 0 ]];do
|
||||
case $1 in
|
||||
--release)
|
||||
BUILD_TYPE="release"
|
||||
shift
|
||||
;;
|
||||
*|-*|--*)
|
||||
echo "Unknown option $1"
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
done
|
||||
|
||||
CC=clang
|
||||
CFLAGS="-Wall -Werror -pedantic"
|
||||
LIBFLAGS="-fPIC -shared"
|
||||
|
||||
INCLUDE="$(find src -type d | xargs -I{} echo -n "-I{} ")"
|
||||
SRC="$(find src -type f -name "*.c" | xargs -I{} echo -n "{} ")"
|
||||
|
||||
TEST_INCLUDE="$(find tests -type d | xargs -I{} echo -n "-I{} ")"
|
||||
TEST_SRC="$(find tests -type f -name "*.c" | xargs -I{} echo -n "{} ")"
|
||||
|
||||
BUILD_DIR="libwapp-build/posix-$BUILD_TYPE"
|
||||
if [[ -d $BUILD_DIR ]]; then
|
||||
rm -rf $BUILD_DIR
|
||||
fi
|
||||
mkdir -p $BUILD_DIR
|
||||
|
||||
if [[ $BUILD_TYPE == "release" ]]; then
|
||||
CFLAGS+=" -O3"
|
||||
else
|
||||
CFLAGS+=" -g -fsanitize=address -fsanitize=undefined"
|
||||
fi
|
||||
|
||||
OUT="$BUILD_DIR/libwapp.so"
|
||||
TEST_OUT="$BUILD_DIR/wapptest"
|
||||
|
||||
# Compile tests
|
||||
if [[ $(echo $TEST_SRC | xargs) != "" ]]; then
|
||||
(set -x ; $CC $CFLAGS $INCLUDE $TEST_INCLUDE $SRC $TEST_SRC -o $TEST_OUT)
|
||||
fi
|
||||
|
||||
# Run tests and exit on failure
|
||||
if [[ -f $TEST_OUT ]]; then
|
||||
$TEST_OUT
|
||||
STATUS="$?"
|
||||
|
||||
rm $TEST_OUT
|
||||
|
||||
if [[ $STATUS != "0" ]]; then
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
|
||||
# Compile library
|
||||
(set -x ; $CC $CFLAGS $LIBFLAGS $INCLUDE $SRC -o $OUT)
|
||||
@@ -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
|
||||
@@ -1,21 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
SCRIPT_DIR="$(dirname $0)"
|
||||
LIB_SRC="$1"
|
||||
INSTALL_PREFIX="$2"
|
||||
shift 2
|
||||
INCLUDES="$@"
|
||||
|
||||
mkdir -p "$INSTALL_PREFIX"
|
||||
|
||||
BASE_INCLUDE_DIR="$(dirname "$LIB_SRC")"
|
||||
find $BASE_INCLUDE_DIR -maxdepth 1 -type f -name "*.h" -exec cp -v {} "$INSTALL_PREFIX" \;
|
||||
|
||||
cd "$SCRIPT_DIR/../src"
|
||||
for INCLUDE in $INCLUDES; do
|
||||
for f in $(find "$INCLUDE" -type f -name "*.h"); do
|
||||
DST="$INSTALL_PREFIX/$(dirname $f)"
|
||||
mkdir -p "$DST"
|
||||
cp -v "$f" "$DST"
|
||||
done
|
||||
done
|
||||
@@ -1,266 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#include "./array.h"
|
||||
#include "../../common/assert/assert.h"
|
||||
#include "../mem/allocator/mem_allocator.h"
|
||||
#include "../../common/misc/misc_utils.h"
|
||||
#include "../../common/aliases/aliases.h"
|
||||
#include <stddef.h>
|
||||
|
||||
#define _array_header(ARRAY) (WpArrayHeader *)(wpMiscUtilsOffsetPointer(ARRAY, (i64)sizeof(WpArrayHeader) * -1))
|
||||
|
||||
wp_persist inline void _array_validate(const WpArray array, u64 item_size);
|
||||
|
||||
u64 _arrayCount(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->count;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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");
|
||||
_array_validate(array, item_size);
|
||||
|
||||
WpArrayHeader *header = _array_header(array);
|
||||
wpRuntimeAssert(index < header->count, "`index` is out of bounds");
|
||||
|
||||
return wpMiscUtilsOffsetPointer(array, header->item_size * index);
|
||||
}
|
||||
|
||||
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");
|
||||
_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 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;
|
||||
}
|
||||
|
||||
void _arrayCopyCapped(WpArray dst, const WpArray src, u64 item_size) {
|
||||
wpRuntimeAssert(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;
|
||||
}
|
||||
|
||||
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");
|
||||
_array_validate(array, item_size);
|
||||
|
||||
WpArray 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 (!output) {
|
||||
output = array;
|
||||
goto RETURN_ARRAY_APPEND_ALLOC;
|
||||
}
|
||||
_arrayCopyCapped(output, array, item_size);
|
||||
}
|
||||
|
||||
_arrayAppendCapped(output, value, item_size);
|
||||
|
||||
if ((flags & WP_ARRAY_INIT_FILLED) == WP_ARRAY_INIT_FILLED) {
|
||||
_arraySetCount(output, _arrayCapacity(output));
|
||||
}
|
||||
|
||||
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");
|
||||
_array_validate(dst, item_size);
|
||||
_array_validate(src, item_size);
|
||||
|
||||
WpArray 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);
|
||||
if (!output) {
|
||||
output = dst;
|
||||
goto RETURN_ARRAY_EXTEND_ALLOC;
|
||||
}
|
||||
_arrayCopyCapped(output, dst, item_size);
|
||||
}
|
||||
|
||||
_arrayExtendCappend(output, src, item_size);
|
||||
|
||||
if ((flags & WP_ARRAY_INIT_FILLED) == WP_ARRAY_INIT_FILLED) {
|
||||
_arraySetCount(output, _arrayCapacity(output));
|
||||
}
|
||||
|
||||
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");
|
||||
_array_validate(dst, item_size);
|
||||
_array_validate(src, item_size);
|
||||
|
||||
WpArray 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 (!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));
|
||||
}
|
||||
|
||||
RETURN_ARRAY_COPY_ALLOC:
|
||||
return output;
|
||||
}
|
||||
|
||||
void *_arrayPop(WpArray array, u64 item_size) {
|
||||
wpRuntimeAssert(array != NULL, "`array` should not be NULL");
|
||||
_array_validate(array, item_size);
|
||||
|
||||
WpArrayHeader *header = _array_header(array);
|
||||
if (header->count == 0) { return NULL; }
|
||||
|
||||
u64 index = header->count - 1;
|
||||
void *out = _arrayGet(array, index, item_size);
|
||||
--(header->count);
|
||||
return out;
|
||||
}
|
||||
|
||||
void _arrayClear(WpArray array, u64 item_size) {
|
||||
wpRuntimeAssert(array != NULL, "`array` should not be NULL");
|
||||
_array_validate(array, item_size);
|
||||
|
||||
WpArrayHeader *header = _array_header(array);
|
||||
header->count = 0;
|
||||
}
|
||||
|
||||
u64 _arrayCalcAllocSize(u64 capacity, u64 item_size) {
|
||||
return sizeof(WpArrayHeader) + item_size * capacity;
|
||||
}
|
||||
|
||||
WpArray _arrayAllocCapacity(const WpAllocator *allocator, u64 capacity, WpArrayInitFlags flags,
|
||||
u64 item_size) {
|
||||
wpRuntimeAssert(allocator != NULL, "`allocator` should not be NULL");
|
||||
|
||||
WpArray output = NULL;
|
||||
|
||||
u64 allocation_size = _arrayCalcAllocSize(capacity, item_size);
|
||||
void *buffer = wpMemAllocatorAlloc(allocator, allocation_size);
|
||||
if (!buffer) {
|
||||
goto RETURN_ARRAY_ALLOC;
|
||||
}
|
||||
|
||||
output = _arrayFromPreallocatedBuffer(buffer, allocation_size, flags, item_size);
|
||||
|
||||
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");
|
||||
}
|
||||
@@ -1,216 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef ARRAY_H
|
||||
#define ARRAY_H
|
||||
|
||||
#include "../mem/allocator/mem_allocator.h"
|
||||
#include "../../common/misc/misc_utils.h"
|
||||
#include "../../common/aliases/aliases.h"
|
||||
#include "../../common/platform/platform.h"
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#define WP_ARRAY_MAGIC (u64)0x57415f415252
|
||||
|
||||
#define _calcArrayCount(TYPE, ...) wpMiscUtilsVaArgsCount(TYPE, __VA_ARGS__)
|
||||
#define _calcArrayCapacity(TYPE, ...) wpMiscUtilsU64RoundUpPow2(_calcArrayCount(TYPE, __VA_ARGS__) * 2)
|
||||
|
||||
typedef struct WpStr8 WpStr8;
|
||||
|
||||
// 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;
|
||||
|
||||
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__); \
|
||||
\
|
||||
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; \
|
||||
}())
|
||||
#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); \
|
||||
\
|
||||
return (TYPE *)(header + 1); \
|
||||
}())
|
||||
#define wpArrayPop(TYPE, ARRAY) ([&]() { \
|
||||
if (ARRAY == NULL || _arrayCount((WpArray)ARRAY) == 0) { \
|
||||
TYPE result{}; \
|
||||
return result; \
|
||||
} \
|
||||
\
|
||||
return *((TYPE *)_arrayPop((WpArray)ARRAY, sizeof(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, \
|
||||
.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))) \
|
||||
)
|
||||
#endif // !WP_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)))
|
||||
|
||||
|
||||
typedef struct WpArrayHeader WpArrayHeader;
|
||||
struct WpArrayHeader {
|
||||
u64 magic;
|
||||
u64 count;
|
||||
u64 capacity;
|
||||
u64 item_size;
|
||||
};
|
||||
|
||||
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);
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
END_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#endif // !ARRAY_H
|
||||
@@ -1,259 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#include "./dbl_list.h"
|
||||
#include "../mem/allocator/mem_allocator.h"
|
||||
#include "../../common/assert/assert.h"
|
||||
#include "../../common/aliases/aliases.h"
|
||||
#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);
|
||||
|
||||
WpDblList *_dblListAlloc(const WpAllocator *allocator, u64 item_size) {
|
||||
wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
|
||||
|
||||
WpDblList *list = wpMemAllocatorAlloc(allocator, sizeof(WpDblList));
|
||||
if (!list) { goto DBL_LIST_ALLOC_RETURN; }
|
||||
|
||||
memset((void *)list, 0, sizeof(WpDblList));
|
||||
list->magic = WP_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");
|
||||
|
||||
WpDblNode *node = wpMemAllocatorAlloc(allocator, sizeof(WpDblNode));
|
||||
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;
|
||||
|
||||
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");
|
||||
|
||||
WpDblNode *output = NULL;
|
||||
WpDblNode *current = list->first;
|
||||
for (u64 i = 1; i <= index; ++i) {
|
||||
current = current->header.next;
|
||||
}
|
||||
|
||||
output = current;
|
||||
|
||||
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);
|
||||
|
||||
WpDblList node_list = _node_to_list(node, item_size);
|
||||
|
||||
if (list->node_count == 0) {
|
||||
*list = node_list;
|
||||
return;
|
||||
}
|
||||
|
||||
list->node_count += node_list.node_count;
|
||||
|
||||
WpDblNode *first = list->first;
|
||||
if (first) {
|
||||
first->header.prev = node_list.last;
|
||||
}
|
||||
|
||||
list->first = node_list.first;
|
||||
node_list.last->header.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);
|
||||
|
||||
WpDblList node_list = _node_to_list(node, item_size);
|
||||
|
||||
if (list->node_count == 0) {
|
||||
*list = node_list;
|
||||
return;
|
||||
}
|
||||
|
||||
list->node_count += node_list.node_count;
|
||||
|
||||
WpDblNode *last = list->last;
|
||||
if (last) {
|
||||
last->header.next = node_list.first;
|
||||
}
|
||||
|
||||
list->last = node_list.last;
|
||||
node_list.first->header.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);
|
||||
|
||||
if (index == 0) {
|
||||
_dblListPushFront(list, node, item_size);
|
||||
return;
|
||||
} else if (index == list->node_count) {
|
||||
_dblListPushBack(list, node, item_size);
|
||||
return;
|
||||
}
|
||||
|
||||
WpDblNode *dst_node = _dblListGet(list, index, item_size);
|
||||
if (!dst_node) {
|
||||
return;
|
||||
}
|
||||
|
||||
WpDblList node_list = _node_to_list(node, item_size);
|
||||
|
||||
list->node_count += node_list.node_count;
|
||||
|
||||
WpDblNode *prev = dst_node->header.prev;
|
||||
|
||||
dst_node->header.prev = node_list.last;
|
||||
prev->header.next = node_list.first;
|
||||
|
||||
node_list.first->header.prev = prev;
|
||||
node_list.last->header.next = dst_node;
|
||||
}
|
||||
|
||||
WpDblNode *_dblListPopFront(WpDblList *list, u64 item_size) {
|
||||
wpDebugAssert(list != NULL, "`list` should not be NULL");
|
||||
_dblListValidate(list, item_size);
|
||||
|
||||
WpDblNode *output = NULL;
|
||||
|
||||
if (list->node_count == 0) {
|
||||
goto RETURN_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->node_count);
|
||||
list->first = output->header.next;
|
||||
|
||||
output->header.prev = output->header.next = NULL;
|
||||
|
||||
RETURN_LIST_POP_FRONT:
|
||||
return output;
|
||||
}
|
||||
|
||||
WpDblNode *_dblListPopBack(WpDblList *list, u64 item_size) {
|
||||
wpDebugAssert(list != NULL, "`list` should not be NULL");
|
||||
_dblListValidate(list, item_size);
|
||||
|
||||
WpDblNode *output = NULL;
|
||||
|
||||
if (list->node_count == 0) {
|
||||
goto RETURN_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->node_count);
|
||||
list->last = output->header.prev;
|
||||
|
||||
output->header.prev = output->header.next = NULL;
|
||||
|
||||
RETURN_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);
|
||||
|
||||
WpDblNode *output = NULL;
|
||||
|
||||
if (index == 0) {
|
||||
output = _dblListPopFront(list, item_size);
|
||||
goto RETURN_LIST_REMOVE;
|
||||
} else if (index == list->node_count) {
|
||||
output = _dblListPopBack(list, item_size);
|
||||
goto RETURN_LIST_REMOVE;
|
||||
}
|
||||
|
||||
output = _dblListGet(list, index, item_size);
|
||||
if (!output) {
|
||||
goto RETURN_LIST_REMOVE;
|
||||
}
|
||||
|
||||
output->header.prev->header.next = output->header.next;
|
||||
output->header.next->header.prev = output->header.prev;
|
||||
|
||||
--(list->node_count);
|
||||
|
||||
output->header.prev = output->header.next = NULL;
|
||||
|
||||
RETURN_LIST_REMOVE:
|
||||
return output;
|
||||
}
|
||||
|
||||
void _dblListEmpty(WpDblList *list, u64 item_size) {
|
||||
wpDebugAssert(list != NULL, "`list` should not be NULL");
|
||||
_dblListValidate(list, item_size);
|
||||
|
||||
u64 count = list->node_count;
|
||||
for (u64 i = 0; i < count; ++i) {
|
||||
_dblListPopBack(list, item_size);
|
||||
}
|
||||
}
|
||||
|
||||
wp_intern WpDblList _node_to_list(WpDblNode *node, u64 item_size) {
|
||||
WpDblList output = {
|
||||
.magic = WP_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;
|
||||
++(output.node_count);
|
||||
}
|
||||
|
||||
while (output.last->header.next != NULL) {
|
||||
output.last = output.last->header.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");
|
||||
}
|
||||
|
||||
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");
|
||||
}
|
||||
@@ -1,184 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef DBL_LIST_H
|
||||
#define DBL_LIST_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
|
||||
|
||||
#define WP_DBL_LIST_MAGIC (u64)0x57415f444c5354
|
||||
#define WP_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, \
|
||||
}; \
|
||||
\
|
||||
return &node; \
|
||||
}())
|
||||
#else
|
||||
#define wpDblList(TYPE) ( \
|
||||
(WpDblList){.magic = WP_DBL_LIST_MAGIC, .item_size = sizeof(TYPE)} \
|
||||
)
|
||||
#define _dblListNode(TYPE, ITEM_PTR) ( \
|
||||
&((WpDblNode){.header = {.magic = WP_DBL_NODE_MAGIC, .item_size = sizeof(TYPE)}, \
|
||||
.item = ITEM_PTR}) \
|
||||
)
|
||||
#endif // !WP_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)))
|
||||
|
||||
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);
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
END_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#endif // !DBL_LIST_H
|
||||
@@ -1,78 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#include "mem_allocator.h"
|
||||
#include "../../../common/aliases/aliases.h"
|
||||
#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");
|
||||
|
||||
if (!wpMemAllocatorOpSupported(allocator, WP_MEM_OP_ALLOC)) {
|
||||
return 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");
|
||||
|
||||
if (!wpMemAllocatorOpSupported(allocator, WP_MEM_OP_ALLOC_ALIGNED)) {
|
||||
return 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");
|
||||
|
||||
if (!wpMemAllocatorOpSupported(allocator, WP_MEM_OP_REALLOC)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return allocator->realloc(ptr, old_size, new_size, allocator->obj);
|
||||
}
|
||||
|
||||
void *wpMemAllocatorReallocAligned(const WpAllocator *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");
|
||||
|
||||
if (!wpMemAllocatorOpSupported(allocator, WP_MEM_OP_REALLOC_ALIGNED)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return allocator->realloc_aligned(ptr, old_size, new_size, alignment, allocator->obj);
|
||||
}
|
||||
|
||||
void wpMemAllocatorFree(const WpAllocator *allocator, void **ptr, u64 size) {
|
||||
wpDebugAssert(allocator != NULL && (allocator->free) != NULL, "`allocator` and `allocator->free` should not be NULL");
|
||||
|
||||
if (!wpMemAllocatorOpSupported(allocator, WP_MEM_OP_FREE)) {
|
||||
return;
|
||||
}
|
||||
|
||||
allocator->free(ptr, size, allocator->obj);
|
||||
}
|
||||
|
||||
b8 wpMemAllocatorOpSupported(const WpAllocator *allocator, WpMemOp op) {
|
||||
wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
|
||||
|
||||
switch (op) {
|
||||
case WP_MEM_OP_ALLOC:
|
||||
return allocator->alloc != NULL;
|
||||
case WP_MEM_OP_ALLOC_ALIGNED:
|
||||
return allocator->alloc_aligned != NULL;
|
||||
case WP_MEM_OP_REALLOC:
|
||||
return allocator->realloc != NULL;
|
||||
case WP_MEM_OP_REALLOC_ALIGNED:
|
||||
return allocator->realloc_aligned != NULL;
|
||||
case WP_MEM_OP_FREE:
|
||||
return allocator->free != NULL;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
@@ -1,61 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef MEM_ALLOCATOR_H
|
||||
#define MEM_ALLOCATOR_H
|
||||
|
||||
#include "../../../common/aliases/aliases.h"
|
||||
#include "../../../common/platform/platform.h"
|
||||
#include <string.h>
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
typedef enum {
|
||||
WP_MEM_OP_ALLOC,
|
||||
WP_MEM_OP_ALLOC_ALIGNED,
|
||||
WP_MEM_OP_REALLOC,
|
||||
WP_MEM_OP_REALLOC_ALIGNED,
|
||||
WP_MEM_OP_FREE,
|
||||
|
||||
COUNT_MEM_OPS
|
||||
} WpMemOp;
|
||||
|
||||
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 struct WpAllocator WpAllocator;
|
||||
struct WpAllocator {
|
||||
void *obj;
|
||||
WpMemAllocFunc *alloc;
|
||||
WpMemAllocAlignedFunc *alloc_aligned;
|
||||
WpMemReallocFunc *realloc;
|
||||
WpMemReallocAlignedFunc *realloc_aligned;
|
||||
WpMemFreeFunc *free;
|
||||
};
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
#define wpMemAllocatorInvalid(ALLOCATOR) ([&]() { \
|
||||
WpAllocator alloc{}; \
|
||||
return memcmp(ALLOCATOR, &alloc, sizeof(WpAllocator)) == 0; \
|
||||
}())
|
||||
#else
|
||||
#define wpMemAllocatorInvalid(ALLOCATOR) (memcmp(ALLOCATOR, &((WpAllocator){0}), sizeof(WpAllocator)) == 0)
|
||||
#endif // !WP_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,
|
||||
u64 new_size, u64 alignment);
|
||||
void wpMemAllocatorFree(const WpAllocator *allocator, void **ptr, u64 size);
|
||||
b8 wpMemAllocatorOpSupported(const WpAllocator *allocator, WpMemOp op);
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
END_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#endif // !MEM_ALLOCATOR_H
|
||||
@@ -1,25 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#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");
|
||||
|
||||
uptr p = (uptr)ptr;
|
||||
uptr align = (uptr)alignment;
|
||||
|
||||
// Similar to p % align, but it's a faster implementation that works fine
|
||||
// because align is guaranteed to be a power of 2
|
||||
uptr modulo = p & (align - 1);
|
||||
|
||||
if (modulo != 0) {
|
||||
p += align - modulo;
|
||||
}
|
||||
|
||||
return (void *)p;
|
||||
}
|
||||
@@ -1,19 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef MEM_UTILS_H
|
||||
#define MEM_UTILS_H
|
||||
|
||||
#include "../../../common/aliases/aliases.h"
|
||||
#include "../../../common/platform/platform.h"
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
void *wpMemUtilAlignForward(void *ptr, u64 alignment);
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
END_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#endif // !MEM_UTILS_H
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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
|
||||
@@ -1,480 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#include "str8.h"
|
||||
#include "../../array/array.h"
|
||||
#include "../../mem/allocator/mem_allocator.h"
|
||||
#include "../../../common/aliases/aliases.h"
|
||||
#include "../../../common/assert/assert.h"
|
||||
#include <ctype.h>
|
||||
#include <stdarg.h>
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#define STR8_BUF_ALLOC_SIZE(CAPACITY) (sizeof(WpStr8) + sizeof(c8) * CAPACITY)
|
||||
|
||||
WpStr8 *wpStr8AllocBuf(const WpAllocator *allocator, u64 capacity) {
|
||||
wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
|
||||
|
||||
WpStr8 *str = wpMemAllocatorAlloc(allocator, STR8_BUF_ALLOC_SIZE(capacity));
|
||||
if (!str) {
|
||||
goto RETURN_STR8;
|
||||
}
|
||||
|
||||
str->buf = (u8 *)str + sizeof(WpStr8);
|
||||
str->size = 0;
|
||||
str->capacity = capacity;
|
||||
|
||||
RETURN_STR8:
|
||||
return str;
|
||||
}
|
||||
|
||||
WpStr8 *wpStr8AllocAndFillBuf(const WpAllocator *allocator, u64 capacity) {
|
||||
WpStr8 *out = wpStr8AllocBuf(allocator, capacity);
|
||||
if (out) {
|
||||
memset(out->buf, 0, capacity);
|
||||
out->size = capacity;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
WpStr8 *wpStr8AllocCstr(const WpAllocator *allocator, const char *str) {
|
||||
wpDebugAssert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
|
||||
|
||||
u64 length = strlen(str);
|
||||
WpStr8 *output = wpStr8AllocBuf(allocator, length * 2);
|
||||
if (!output) {
|
||||
goto RETURN_ALLOC_CSTR;
|
||||
}
|
||||
|
||||
output->size = length;
|
||||
memcpy(output->buf, str, length);
|
||||
|
||||
RETURN_ALLOC_CSTR:
|
||||
return output;
|
||||
}
|
||||
|
||||
WpStr8 *wpStr8AllocStr8(const WpAllocator *allocator, WpStr8RO *str) {
|
||||
wpDebugAssert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
|
||||
|
||||
WpStr8 *output = wpStr8AllocBuf(allocator, str->capacity);
|
||||
if (!output) {
|
||||
goto RETURN_ALLOC_STR8;
|
||||
}
|
||||
|
||||
output->size = str->size;
|
||||
memcpy(output->buf, str->buf, str->size);
|
||||
|
||||
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");
|
||||
|
||||
WpStr8 *output = NULL;
|
||||
|
||||
if (start >= str->size || start >= end) {
|
||||
goto RETURN_ALLOC_SUBSTR;
|
||||
}
|
||||
|
||||
if (end > str->size) {
|
||||
end = str->size;
|
||||
}
|
||||
|
||||
output = wpStr8AllocBuf(allocator, str->capacity);
|
||||
if (!output) {
|
||||
goto RETURN_ALLOC_SUBSTR;
|
||||
}
|
||||
|
||||
output->size = end - start;
|
||||
memcpy(output->buf, str->buf + start, output->size);
|
||||
|
||||
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));
|
||||
}
|
||||
|
||||
c8 wpStr8Get(const WpStr8 *str, u64 index) {
|
||||
if (index >= str->size) {
|
||||
return '\0';
|
||||
}
|
||||
|
||||
return str->buf[index];
|
||||
}
|
||||
|
||||
void wpStr8Set(WpStr8 *str, u64 index, c8 c) {
|
||||
if (index >= str->size) {
|
||||
return;
|
||||
}
|
||||
|
||||
str->buf[index] = c;
|
||||
}
|
||||
|
||||
void wpStr8PushBack(WpStr8 *str, c8 c) {
|
||||
if (!(str->size < str->capacity)) {
|
||||
return;
|
||||
}
|
||||
|
||||
u64 index = (str->size)++;
|
||||
wpStr8Set(str, index, c);
|
||||
}
|
||||
|
||||
b8 wpStr8Equal(WpStr8RO *s1, WpStr8RO *s2) {
|
||||
if (s1->size != s2->size) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return wpStr8EqualToCount(s1, s2, s1->size);
|
||||
}
|
||||
|
||||
b8 wpStr8EqualToCount(WpStr8RO* s1, WpStr8RO* s2, u64 count) {
|
||||
if (!s1 || !s2) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return memcmp(s1->buf, s2->buf, count) == 0;
|
||||
}
|
||||
|
||||
WpStr8 wpStr8Slice(WpStr8RO *str, u64 start, u64 end) {
|
||||
if (start >= str->size || start >= end) {
|
||||
start = str->size;
|
||||
end = str->size;
|
||||
}
|
||||
|
||||
if (end > str->size) {
|
||||
end = str->size;
|
||||
}
|
||||
|
||||
return (WpStr8RO){
|
||||
.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");
|
||||
|
||||
WpStr8 *output = NULL;
|
||||
u64 remaining = dst->capacity - dst->size;
|
||||
if (src->size <= remaining) {
|
||||
output = dst;
|
||||
goto SOURCE_STRING_STR8_CONCAT;
|
||||
}
|
||||
|
||||
u64 capacity = dst->capacity + src->size;
|
||||
|
||||
output = wpStr8AllocBuf(allocator, capacity);
|
||||
if (!output) {
|
||||
goto RETURN_STR8_CONCAT;
|
||||
}
|
||||
|
||||
wpStr8ConcatCapped(output, dst);
|
||||
|
||||
SOURCE_STRING_STR8_CONCAT:
|
||||
wpStr8ConcatCapped(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");
|
||||
|
||||
u64 remaining = dst->capacity - dst->size;
|
||||
u64 to_copy = remaining < src->size ? remaining : src->size;
|
||||
|
||||
memcpy(dst->buf + dst->size, src->buf, to_copy);
|
||||
dst->size += to_copy;
|
||||
}
|
||||
|
||||
void wpStr8CopyCstrCapped(WpStr8 *dst, const char *src) {
|
||||
wpDebugAssert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
|
||||
|
||||
u64 length = strlen(src);
|
||||
u64 to_copy = length <= dst->capacity ? length : dst->capacity;
|
||||
|
||||
memset(dst->buf, 0, dst->size);
|
||||
memcpy(dst->buf, src, to_copy);
|
||||
dst->size = to_copy;
|
||||
}
|
||||
|
||||
void wpStr8CopyStr8Capped(WpStr8 *dst, WpStr8RO *src) {
|
||||
wpDebugAssert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
|
||||
|
||||
u64 to_copy = src->size <= dst->capacity ? src->size : dst->capacity;
|
||||
|
||||
memset(dst->buf, 0, dst->size);
|
||||
memcpy(dst->buf, src->buf, to_copy);
|
||||
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");
|
||||
|
||||
u64 to_copy = src->size < dst_capacity ? src->size : dst_capacity - 1;
|
||||
|
||||
memset(dst, 0, 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");
|
||||
|
||||
va_list args1;
|
||||
va_list args2;
|
||||
|
||||
va_start(args1, format);
|
||||
va_copy(args2, args1);
|
||||
|
||||
u64 total_size = vsnprintf(NULL, 0, format, args1);
|
||||
dst->size = total_size <= dst->capacity ? total_size : dst->capacity;
|
||||
|
||||
vsnprintf((char *)(dst->buf), dst->capacity, format, args2);
|
||||
|
||||
va_end(args1);
|
||||
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");
|
||||
|
||||
dst->size = src->size;
|
||||
|
||||
// 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) {
|
||||
wpStr8Set(dst, index, (u8)tolower(wpStr8Get(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");
|
||||
|
||||
dst->size = src->size;
|
||||
|
||||
// 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) {
|
||||
wpStr8Set(dst, index, (u8)toupper(wpStr8Get(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");
|
||||
|
||||
u64 size = wpArrayCount(src) * wpArrayItemSize(src);
|
||||
|
||||
wpDebugAssert(dst->capacity >= size, "`dst` does not have enough capacity");
|
||||
|
||||
dst->size = size;
|
||||
memcpy(dst->buf, src, size);
|
||||
}
|
||||
|
||||
i64 wpStr8Find(WpStr8RO *str, WpStr8RO substr) {
|
||||
if (!str || substr.size > str->size) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
|
||||
// MSVC Spectre mitigation warnings
|
||||
u64 char_index = 0;
|
||||
b8 running = char_index < str->size;
|
||||
while (running) {
|
||||
const c8 *sub = str->buf + char_index;
|
||||
if (memcmp(sub, substr.buf, substr.size) == 0) {
|
||||
return char_index;
|
||||
}
|
||||
|
||||
++char_index;
|
||||
running = char_index < str->size;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
i64 wpStr8Rfind(WpStr8RO *str, WpStr8RO substr) {
|
||||
if (!str || substr.size > str->size) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
|
||||
// MSVC Spectre mitigation warnings
|
||||
i64 char_index = str->size - substr.size;
|
||||
b8 running = char_index >= 0;
|
||||
while (running) {
|
||||
const c8 *sub = str->buf + char_index;
|
||||
if (memcmp(sub, substr.buf, substr.size) == 0) {
|
||||
return char_index;
|
||||
}
|
||||
|
||||
--char_index;
|
||||
running = char_index >= 0;
|
||||
}
|
||||
|
||||
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");
|
||||
|
||||
WpStr8List *output = wpDblListAlloc(WpStr8, allocator);
|
||||
|
||||
if (delimiter->size > str->size) {
|
||||
WpStr8 *full = wpStr8AllocStr8(allocator, str);
|
||||
if (full) {
|
||||
wpDblListPushBackAlloc(WpStr8, allocator, output, full);
|
||||
}
|
||||
|
||||
goto RETURN_STR8_SPLIT;
|
||||
}
|
||||
|
||||
i64 start = 0;
|
||||
i64 end = 0;
|
||||
i64 splits = 0;
|
||||
WpStr8 *rest = wpStr8AllocStr8(allocator, str);
|
||||
WpStr8 *before_str;
|
||||
|
||||
while ((end = wpStr8Find(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);
|
||||
}
|
||||
|
||||
wpMemAllocatorFree(allocator, (void **)&rest, sizeof(WpStr8));
|
||||
rest = wpStr8AllocSubstr(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);
|
||||
}
|
||||
|
||||
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");
|
||||
|
||||
WpStr8List *output = wpDblListAlloc(WpStr8, allocator);
|
||||
|
||||
if (delimiter->size > str->size) {
|
||||
WpStr8 *full = wpStr8AllocStr8(allocator, str);
|
||||
if (full) {
|
||||
wpDblListPushBackAlloc(WpStr8, allocator, output, full);
|
||||
}
|
||||
|
||||
goto RETURN_STR8_SPLIT;
|
||||
}
|
||||
|
||||
i64 end = 0;
|
||||
i64 splits = 0;
|
||||
WpStr8 *rest = wpStr8AllocStr8(allocator, str);
|
||||
WpStr8 *after_str;
|
||||
|
||||
while ((end = wpStr8Rfind(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);
|
||||
}
|
||||
|
||||
wpMemAllocatorFree(allocator, (void **)&rest, sizeof(WpStr8));
|
||||
rest = wpStr8AllocSubstr(allocator, rest, 0, end);
|
||||
|
||||
++splits;
|
||||
}
|
||||
|
||||
rest = wpStr8AllocSubstr(allocator, str, 0, rest->size);
|
||||
if (rest) {
|
||||
wpDblListPushFrontAlloc(WpStr8, allocator, output, rest);
|
||||
}
|
||||
|
||||
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");
|
||||
|
||||
u64 capacity = wpStr8ListTotalSize(list) + (delimiter->size * (list->node_count - 1));
|
||||
WpStr8 *output = wpStr8AllocBuf(allocator, capacity * 2);
|
||||
|
||||
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
|
||||
// MSVC Spectre mitigation warnings
|
||||
WpStr8 *node;
|
||||
u64 node_index = 0;
|
||||
b8 running = node_index < list->node_count;
|
||||
while (running) {
|
||||
node = wpDblListGet(WpStr8, list, node_index);
|
||||
if (!node) {
|
||||
break;
|
||||
}
|
||||
|
||||
wpStr8ConcatCapped(output, node);
|
||||
|
||||
// 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);
|
||||
}
|
||||
|
||||
++node_index;
|
||||
running = node_index < list->node_count;
|
||||
}
|
||||
|
||||
return output;
|
||||
}
|
||||
|
||||
u64 wpStr8ListTotalSize(const WpStr8List *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;
|
||||
u64 node_index = 0;
|
||||
u64 output = 0;
|
||||
b8 running = node_index < list->node_count;
|
||||
while (running) {
|
||||
node = wpDblListGet(WpStr8, list, node_index);
|
||||
if (!node) {
|
||||
break;
|
||||
}
|
||||
|
||||
output += node->size;
|
||||
++node_index;
|
||||
running = node_index < list->node_count;
|
||||
}
|
||||
|
||||
return output;
|
||||
}
|
||||
@@ -1,130 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef STR8_H
|
||||
#define STR8_H
|
||||
|
||||
#include "../../../common/aliases/aliases.h"
|
||||
#include "../../../common/assert/assert.h"
|
||||
#include "../../../common/platform/platform.h"
|
||||
#include "../../array/array.h"
|
||||
#include "../../dbl_list/dbl_list.h"
|
||||
#include "../../mem/allocator/mem_allocator.h"
|
||||
#include <string.h>
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
typedef struct WpStr8 WpStr8;
|
||||
struct WpStr8 {
|
||||
u64 capacity;
|
||||
u64 size;
|
||||
c8 *buf;
|
||||
};
|
||||
|
||||
typedef const WpStr8 WpStr8RO;
|
||||
|
||||
/**
|
||||
* Utilities to be used with printf functions
|
||||
*/
|
||||
#define WP_STR8_SPEC "%.*s"
|
||||
#define wpStr8Varg(STRING) (int)((STRING).size), (STRING).buf
|
||||
|
||||
/**
|
||||
* WpStr8 stack buffers
|
||||
*/
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
// Uses a lambda to achieve the same behaviour achieved by the C macro
|
||||
#define wpStr8Buf(CAPACITY) ([&](){ \
|
||||
wp_persist c8 buf[CAPACITY] = {}; \
|
||||
memset(buf, 0, CAPACITY); \
|
||||
return WpStr8{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] = {}; \
|
||||
memcpy(buf, STRING, sizeof(STRING)); \
|
||||
return WpStr8{(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}
|
||||
#else
|
||||
#define wpStr8Buf(CAPACITY) ((WpStr8){.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, \
|
||||
.size = sizeof(STRING) - 1, \
|
||||
.buf = memcpy(&((c8 [sizeof(STRING) * 2]){0}), \
|
||||
STRING, \
|
||||
sizeof(STRING))})
|
||||
#define wpStr8LitRo(STRING) ((WpStr8RO){.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, \
|
||||
.size = sizeof(STRING) - 1, \
|
||||
.buf = (c8 *)STRING}
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
/**
|
||||
* WpStr8 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);
|
||||
// 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);
|
||||
|
||||
/**
|
||||
* WpStr8 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);
|
||||
|
||||
/**
|
||||
* WpStr8 find functions
|
||||
*/
|
||||
i64 wpStr8Find(WpStr8RO *str, WpStr8RO substr);
|
||||
i64 wpStr8Rfind(WpStr8RO *str, WpStr8RO substr);
|
||||
|
||||
/**
|
||||
* WpStr8 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);
|
||||
|
||||
/**
|
||||
* WpStr8 list utilities
|
||||
*/
|
||||
u64 wpStr8ListTotalSize(const WpStr8List *list);
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
END_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#endif // !STR8_H
|
||||
@@ -1,14 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef WAPP_BASE_C
|
||||
#define WAPP_BASE_C
|
||||
|
||||
#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"
|
||||
|
||||
#endif // !WAPP_BASE_C
|
||||
@@ -1,14 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef WAPP_BASE_H
|
||||
#define WAPP_BASE_H
|
||||
|
||||
#include "array/array.h"
|
||||
#include "dbl_list/dbl_list.h"
|
||||
#include "queue/queue.h"
|
||||
#include "mem/allocator/mem_allocator.h"
|
||||
#include "mem/utils/mem_utils.h"
|
||||
#include "strings/str8/str8.h"
|
||||
#include "../common/wapp_common.h"
|
||||
|
||||
#endif // !WAPP_BASE_H
|
||||
@@ -1,67 +1,33 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef ALIASES_H
|
||||
#define ALIASES_H
|
||||
|
||||
#include "../platform/platform.h"
|
||||
#include <stdint.h>
|
||||
|
||||
#if defined(WP_PLATFORM_C) && WP_PLATFORM_C_VERSION >= WP_PLATFORM_C11_VERSION && !defined(WP_PLATFORM_APPLE)
|
||||
#include <uchar.h>
|
||||
#define u8 uint8_t
|
||||
#define u16 uint16_t
|
||||
#define u32 uint32_t
|
||||
#define u64 uint64_t
|
||||
|
||||
#if WP_PLATFORM_C_VERSION >= WP_PLATFORM_C23_VERSION
|
||||
typedef char8_t c8;
|
||||
#else
|
||||
typedef uint8_t c8;
|
||||
#endif // !WP_PLATFORM_C23_VERSION
|
||||
#define i8 int8_t
|
||||
#define i16 int16_t
|
||||
#define i32 int32_t
|
||||
#define i64 int64_t
|
||||
|
||||
typedef char16_t c16;
|
||||
typedef char32_t c32;
|
||||
#else
|
||||
typedef uint8_t c8;
|
||||
typedef uint16_t c16;
|
||||
typedef uint32_t c32;
|
||||
#endif // !WP_PLATFORM_C
|
||||
#define f32 float
|
||||
#define f64 double
|
||||
#define f128 long double
|
||||
|
||||
typedef uint8_t u8;
|
||||
typedef uint16_t u16;
|
||||
typedef uint32_t u32;
|
||||
typedef uint64_t u64;
|
||||
#define uptr uintptr_t
|
||||
#define iptr intptr_t
|
||||
|
||||
typedef uint8_t b8;
|
||||
#define external extern
|
||||
#define internal static
|
||||
#define persistent static
|
||||
|
||||
#ifndef WP_PLATFORM_CPP
|
||||
|
||||
#ifndef false
|
||||
#define false (b8)0
|
||||
#endif // !false
|
||||
|
||||
#ifndef true
|
||||
#define true (b8)1
|
||||
#endif // !true
|
||||
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
typedef int8_t i8;
|
||||
typedef int16_t i16;
|
||||
typedef int32_t i32;
|
||||
typedef int64_t i64;
|
||||
|
||||
typedef float f32;
|
||||
typedef double f64;
|
||||
typedef long double f128;
|
||||
|
||||
typedef uintptr_t uptr;
|
||||
typedef intptr_t iptr;
|
||||
|
||||
#define wp_extern extern
|
||||
#define wp_intern static
|
||||
#define wp_persist static
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
#define wp_class_mem static
|
||||
#define BEGIN_C_LINKAGE wp_extern "C" {
|
||||
#ifdef __cplusplus
|
||||
#define class_mem static
|
||||
#define BEGIN_C_LINKAGE extern "C" {
|
||||
#define END_C_LINKAGE }
|
||||
#endif // WP_PLATFORM_CPP
|
||||
#endif // __cplusplus
|
||||
|
||||
#endif // !ALIASES_H
|
||||
|
||||
@@ -1,61 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef WAPP_ASSERT_H
|
||||
#define WAPP_ASSERT_H
|
||||
|
||||
#include "../aliases/aliases.h"
|
||||
#include "../platform/platform.h"
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <inttypes.h>
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#define wpStaticAssert(EXPR, MSG) wp_extern char ASSERTION_FAILED[EXPR ? 1 : -1]
|
||||
|
||||
#ifndef WP_NO_RUNTIME_ASSERT
|
||||
#define wpRuntimeAssert(EXPR, MSG) _runtimeAssert(EXPR, MSG)
|
||||
#else
|
||||
#define wpRuntimeAssert(EXPR, MSG)
|
||||
#endif
|
||||
|
||||
#ifdef WP_DEBUG_ASSERT
|
||||
#define wpDebugAssert(EXPR, MSG) wpRuntimeAssert(EXPR, MSG)
|
||||
#else
|
||||
#define wpDebugAssert(EXPR, MSG)
|
||||
#endif
|
||||
|
||||
#ifdef WP_PLATFORM_WINDOWS
|
||||
#define _runtimeAssert(EXPR, MSG) do { \
|
||||
__pragma(warning(push)) \
|
||||
__pragma(warning(disable:4127)) \
|
||||
if (!(EXPR)) { \
|
||||
__pragma(warning(pop)) \
|
||||
_runtimeAssertFailed(EXPR, MSG); \
|
||||
} \
|
||||
} while(false)
|
||||
#else
|
||||
#define _runtimeAssert(EXPR, MSG) do { \
|
||||
if (!(EXPR)) { \
|
||||
_runtimeAssertFailed(EXPR, MSG); \
|
||||
} \
|
||||
} while(false)
|
||||
#endif // !WP_PLATFORM_WINDOWS
|
||||
|
||||
#define _runtimeAssertFailed(EXPR, MSG) do { \
|
||||
fprintf( \
|
||||
stderr, \
|
||||
"%s:%d (In function `%s`): Assertion failed (%" PRIu32 ")\nDiagnostic: %s\n\n", \
|
||||
__FILE__, __LINE__, __func__, \
|
||||
EXPR, MSG \
|
||||
); \
|
||||
abort(); \
|
||||
} while(false)
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
END_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#endif // !WAPP_ASSERT_H
|
||||
@@ -1,63 +1,13 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef MISC_UTILS_H
|
||||
#define MISC_UTILS_H
|
||||
|
||||
#include "../aliases/aliases.h"
|
||||
#include "aliases.h"
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
#define KB(SIZE) (SIZE * 1024ull)
|
||||
#define MB(SIZE) (KB(SIZE) * 1024)
|
||||
#define GB(SIZE) (MB(SIZE) * 1024)
|
||||
#define TB(SIZE) (GB(SIZE) * 1024)
|
||||
|
||||
#define KiB(SIZE) (((u64)SIZE) << 10)
|
||||
#define MiB(SIZE) (((u64)SIZE) << 20)
|
||||
#define GiB(SIZE) (((u64)SIZE) << 30)
|
||||
#define TiB(SIZE) (((u64)SIZE) << 40)
|
||||
#define PiB(SIZE) (((u64)SIZE) << 50)
|
||||
#define EiB(SIZE) (((u64)SIZE) << 60)
|
||||
|
||||
#define KB(SIZE) (((u64)SIZE) * 1000llu)
|
||||
#define MB(SIZE) (KB(SIZE) * 1000llu)
|
||||
#define GB(SIZE) (MB(SIZE) * 1000llu)
|
||||
#define TB(SIZE) (GB(SIZE) * 1000llu)
|
||||
#define PB(SIZE) (TB(SIZE) * 1000llu)
|
||||
#define EB(SIZE) (PB(SIZE) * 1000llu)
|
||||
|
||||
#define wpMiscUtilsReservePadding(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))
|
||||
#define U64_RSHIFT_OR_4(X) (((u64)X) | (((u64)X) >> 4))
|
||||
#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) ( \
|
||||
( \
|
||||
U64_RSHIFT_OR_32( \
|
||||
U64_RSHIFT_OR_16( \
|
||||
U64_RSHIFT_OR_8( \
|
||||
U64_RSHIFT_OR_4( \
|
||||
U64_RSHIFT_OR_2( \
|
||||
U64_RSHIFT_OR_1(X - 1) \
|
||||
) \
|
||||
) \
|
||||
) \
|
||||
) \
|
||||
) \
|
||||
) + 1 \
|
||||
)
|
||||
|
||||
#define wpMiscUtilsIsPowerOfTwo(NUM) ((NUM & (NUM - 1)) == 0)
|
||||
#define wpMiscUtilsOffsetPointer(PTR, OFFSET) ((void *)((uptr)(PTR) + (OFFSET)))
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
END_C_LINKAGE
|
||||
|
||||
#include <tuple>
|
||||
|
||||
#define wpMiscUtilsVaArgsCount(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_padding_size(SIZE) u8 reserved_padding[sizeof(void *) - ((SIZE) % sizeof(void *))]
|
||||
|
||||
#endif // !MISC_UTILS_H
|
||||
|
||||
@@ -1,114 +1,61 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef PLATFORM_H
|
||||
#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
|
||||
|
||||
#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
|
||||
#else
|
||||
#error "Unrecognised C++ version"
|
||||
#endif
|
||||
#else
|
||||
#define WP_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
|
||||
|
||||
#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
|
||||
#else
|
||||
#error "Unrecognised C version"
|
||||
#endif
|
||||
#else
|
||||
#define WP_PLATFORM_C89
|
||||
#endif
|
||||
#endif // !__cplusplus
|
||||
|
||||
#endif // !PLATFORM_H
|
||||
|
||||
@@ -1,11 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef WAPP_COMMON_H
|
||||
#define WAPP_COMMON_H
|
||||
|
||||
#include "aliases/aliases.h"
|
||||
#include "assert/assert.h"
|
||||
#include "misc/misc_utils.h"
|
||||
#include "platform/platform.h"
|
||||
|
||||
#endif // !WAPP_COMMON_H
|
||||
@@ -0,0 +1,49 @@
|
||||
#include "mem_allocator.h"
|
||||
#include <stdlib.h>
|
||||
|
||||
/***************************************************************************/ //
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
////// Allocator API definitions
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/***************************************************************************/ //
|
||||
|
||||
void *wapp_mem_allocator_alloc(const Allocator *allocator, u64 size) {
|
||||
if (!allocator || !(allocator->alloc)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return allocator->alloc(size, allocator->obj);
|
||||
}
|
||||
|
||||
void *wapp_mem_allocator_alloc_aligned(const Allocator *allocator, u64 size, u64 alignment) {
|
||||
if (!allocator || !(allocator->alloc_aligned)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return allocator->alloc_aligned(size, alignment, allocator->obj);
|
||||
}
|
||||
|
||||
void *wapp_mem_allocator_realloc(const Allocator *allocator, void *ptr, u64 old_size, u64 new_size) {
|
||||
if (!allocator || !(allocator->realloc)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return allocator->realloc(ptr, old_size, new_size, allocator->obj);
|
||||
}
|
||||
|
||||
void *wapp_mem_allocator_realloc_aligned(const Allocator *allocator, void *ptr, u64 old_size,
|
||||
u64 new_size, u64 alignment) {
|
||||
if (!allocator || !(allocator->realloc_aligned)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return allocator->realloc_aligned(ptr, old_size, new_size, alignment, allocator->obj);
|
||||
}
|
||||
|
||||
void wapp_mem_allocator_free(const Allocator *allocator, void **ptr) {
|
||||
if (!allocator || !(allocator->free)) {
|
||||
return;
|
||||
}
|
||||
|
||||
allocator->free(ptr, allocator->obj);
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
#ifndef MEM_ALLOCATOR_H
|
||||
#define MEM_ALLOCATOR_H
|
||||
|
||||
#include "aliases.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // __cplusplus
|
||||
|
||||
/***************************************************************************/ //
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
////// Allocator function pointer types
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/***************************************************************************/ //
|
||||
|
||||
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, void *alloc_obj);
|
||||
|
||||
/***************************************************************************/ //
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
////// Allocator type
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/***************************************************************************/ //
|
||||
|
||||
typedef struct allocator Allocator;
|
||||
struct allocator {
|
||||
void *obj;
|
||||
MemAllocFunc *alloc;
|
||||
MemAllocAlignedFunc *alloc_aligned;
|
||||
MemReallocFunc *realloc;
|
||||
MemReallocAlignedFunc *realloc_aligned;
|
||||
MemFreeFunc *free;
|
||||
};
|
||||
|
||||
/***************************************************************************/ //
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
////// Allocator API declarations
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/***************************************************************************/ //
|
||||
|
||||
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 wapp_mem_allocator_free(const Allocator *allocator, void **ptr);
|
||||
|
||||
#ifdef __cplusplus
|
||||
END_C_LINKAGE
|
||||
#endif // __cplusplus
|
||||
|
||||
#endif // !MEM_ALLOCATOR_H
|
||||
@@ -0,0 +1,145 @@
|
||||
#include "mem_arena.h"
|
||||
#include "aliases.h"
|
||||
#include "misc_utils.h"
|
||||
#include "mem_utils.h"
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#ifndef DEFAULT_ALIGNMENT
|
||||
// Why 2 * sizeof(void *) instead of sizeof(void *)
|
||||
// https://handmade.network/forums/t/6860-alignment_arena_allocator
|
||||
#define DEFAULT_ALIGNMENT (2 * sizeof(void *))
|
||||
#endif /* ifndef DEFAULT_ALIGNMENT */
|
||||
|
||||
#define ARENA_MINIMUM_CAPACITY KB(16) // Allocate minimum of 4 pages
|
||||
|
||||
struct arena {
|
||||
u8 *buf;
|
||||
u8 *offset;
|
||||
u64 capacity;
|
||||
bool committed;
|
||||
|
||||
#ifdef WAPP_PLATFORM_WINDOWS
|
||||
wapp_misc_utils_padding_size(sizeof(u8 *) * 2 + sizeof(u64) + sizeof(bool));
|
||||
#endif // ifdef WAPP_PLATFORM_WINDOWS
|
||||
};
|
||||
|
||||
bool wapp_mem_arena_init_custom(Arena **arena, u64 base_capacity, MemAllocFlags flags, bool zero_buffer) {
|
||||
if (!arena || *arena || base_capacity == 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
*arena = (Arena *)calloc(1, sizeof(Arena));
|
||||
Arena *arena_ptr = *arena;
|
||||
if (!arena_ptr) {
|
||||
return false;
|
||||
}
|
||||
|
||||
u64 arena_capacity = base_capacity >= ARENA_MINIMUM_CAPACITY ? base_capacity : ARENA_MINIMUM_CAPACITY;
|
||||
|
||||
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 (!(arena_ptr->buf)) {
|
||||
wapp_mem_arena_destroy(arena);
|
||||
return false;
|
||||
}
|
||||
|
||||
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 *wapp_mem_arena_alloc(Arena *arena, u64 size) {
|
||||
return wapp_mem_arena_alloc_aligned(arena, size, DEFAULT_ALIGNMENT);
|
||||
}
|
||||
|
||||
void *wapp_mem_arena_alloc_aligned(Arena *arena, u64 size, u64 alignment) {
|
||||
if (!arena) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
u8 *alloc_start = arena->offset;
|
||||
|
||||
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 WAPP_PLATFORM_WINDOWS
|
||||
if (!(arena->committed)) {
|
||||
output = (u8 *)wapp_mem_util_alloc(alloc_start, (uptr)(arena->offset) - (uptr)(alloc_start),
|
||||
WAPP_MEM_ACCESS_READ_WRITE, WAPP_MEM_ALLOC_COMMIT,
|
||||
WAPP_MEM_INIT_INITIALISED);
|
||||
}
|
||||
#else
|
||||
memset(output, 0, size);
|
||||
#endif // ifdef WAPP_PLATFORM_WINDOWS
|
||||
|
||||
return (void *)output;
|
||||
}
|
||||
|
||||
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 = wapp_mem_arena_alloc(arena, new_size);
|
||||
if (!new_ptr) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
u64 copy_size = new_size <= old_size ? new_size : old_size;
|
||||
memcpy(new_ptr, ptr, copy_size);
|
||||
|
||||
return new_ptr;
|
||||
}
|
||||
|
||||
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 = wapp_mem_arena_alloc_aligned(arena, new_size, alignment);
|
||||
if (!new_ptr) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
u64 copy_size = new_size <= old_size ? new_size : old_size;
|
||||
memcpy(new_ptr, ptr, copy_size);
|
||||
|
||||
return new_ptr;
|
||||
}
|
||||
|
||||
void wapp_mem_arena_clear(Arena *arena) {
|
||||
if (!arena) {
|
||||
return;
|
||||
}
|
||||
|
||||
memset(arena->buf, 0, arena->offset - arena->buf);
|
||||
arena->offset = arena->buf;
|
||||
}
|
||||
|
||||
void wapp_mem_arena_destroy(Arena **arena) {
|
||||
if (!arena) {
|
||||
return;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
#ifndef MEM_ARENA_H
|
||||
#define MEM_ARENA_H
|
||||
|
||||
#include "aliases.h"
|
||||
#include "mem_utils.h"
|
||||
#include <stdbool.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // __cplusplus
|
||||
|
||||
typedef struct arena Arena;
|
||||
|
||||
#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))
|
||||
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
bool wapp_mem_arena_init_custom(Arena **arena, u64 base_capacity, MemAllocFlags flags, bool 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 __cplusplus
|
||||
END_C_LINKAGE
|
||||
#endif // __cplusplus
|
||||
|
||||
#endif // !MEM_ARENA_H
|
||||
@@ -0,0 +1,71 @@
|
||||
#include "mem_arena_allocator.h"
|
||||
#include "mem_arena.h"
|
||||
|
||||
/***************************************************************************/ //
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
////// Arena Allocator wrappers declarations
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/***************************************************************************/ //
|
||||
|
||||
internal inline void *mem_arena_alloc(u64 size, void *alloc_obj);
|
||||
internal inline void *mem_arena_alloc_aligned(u64 size, u64 alignment, void *alloc_obj);
|
||||
internal inline void *mem_arena_realloc(void *ptr, u64 old_size, u64 new_size, void *alloc_obj);
|
||||
internal inline void *mem_arena_realloc_aligned(void *ptr, u64 old_size, u64 new_size, u64 alignment,
|
||||
void *alloc_obj);
|
||||
|
||||
/***************************************************************************/ //
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
////// Arena Allocator API definitions
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/***************************************************************************/ //
|
||||
|
||||
Allocator wapp_mem_arena_allocator_init_custom(u64 base_capacity, MemAllocFlags flags, bool zero_buffer) {
|
||||
Allocator allocator = {0};
|
||||
bool initialised = wapp_mem_arena_init_custom((Arena **)(&allocator.obj), base_capacity, flags, zero_buffer);
|
||||
if (!initialised) {
|
||||
return 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;
|
||||
}
|
||||
|
||||
void wapp_mem_arena_allocator_clear(Allocator *allocator) {
|
||||
wapp_mem_arena_clear((Arena *)(allocator->obj));
|
||||
}
|
||||
|
||||
void wapp_mem_arena_allocator_destroy(Allocator *allocator) {
|
||||
wapp_mem_arena_destroy((Arena **)(&(allocator->obj)));
|
||||
*allocator = (Allocator){0};
|
||||
}
|
||||
|
||||
/***************************************************************************/ //
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
////// Arena Allocator wrappers definitions
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/***************************************************************************/ //
|
||||
|
||||
internal inline void *mem_arena_alloc(u64 size, void *alloc_obj) {
|
||||
Arena *arena = (Arena *)alloc_obj;
|
||||
return wapp_mem_arena_alloc(arena, size);
|
||||
}
|
||||
|
||||
internal 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);
|
||||
}
|
||||
|
||||
internal 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);
|
||||
}
|
||||
|
||||
internal inline void *mem_arena_realloc_aligned(void *ptr, u64 old_size, u64 new_size, u64 alignment,
|
||||
void *alloc_obj) {
|
||||
Arena *arena = (Arena *)alloc_obj;
|
||||
return wapp_mem_arena_realloc_aligned(arena, ptr, old_size, new_size, alignment);
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
#ifndef MEM_ARENA_ALLOCATOR_H
|
||||
#define MEM_ARENA_ALLOCATOR_H
|
||||
|
||||
#include "aliases.h"
|
||||
#include "mem_utils.h"
|
||||
#include "mem_allocator.h"
|
||||
#include <stdbool.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // __cplusplus
|
||||
|
||||
#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 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
|
||||
* Allocator.
|
||||
*
|
||||
* An Arena allocator only supports normal allocation and aligned allocation.
|
||||
* Reallocation, aligned reallocation and freeing aren't implemented.
|
||||
*
|
||||
* The `wapp_mem_arena_allocator_init_custom` provides the most control over how
|
||||
* the Arena is initialised. Wrapper macros are provided for easier use.
|
||||
*/
|
||||
Allocator wapp_mem_arena_allocator_init_custom(u64 base_capacity, MemAllocFlags flags, bool zero_buffer);
|
||||
void wapp_mem_arena_allocator_clear(Allocator *allocator);
|
||||
void wapp_mem_arena_allocator_destroy(Allocator *allocator);
|
||||
|
||||
#ifdef __cplusplus
|
||||
END_C_LINKAGE
|
||||
#endif // __cplusplus
|
||||
|
||||
#endif // !MEM_ARENA_ALLOCATOR_H
|
||||
@@ -0,0 +1,62 @@
|
||||
#include "mem_libc_allocator.h"
|
||||
#include "aliases.h"
|
||||
#include "mem_allocator.h"
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
internal inline void *mem_libc_alloc(u64 size, void *alloc_obj);
|
||||
// TODO (Abdelrahman): aligned_alloc isn't implemented on Windows. Revisit later
|
||||
#if 0
|
||||
internal inline void *mem_libc_alloc_aligned(u64 size, u64 alignment, void *alloc_obj);
|
||||
#endif
|
||||
internal inline void *mem_libc_realloc(void *ptr, u64 old_size, u64 new_size, void *alloc_obj);
|
||||
internal inline void mem_libc_free(void **ptr, void *alloc_obj);
|
||||
|
||||
Allocator wapp_mem_libc_allocator(void) {
|
||||
return (Allocator){
|
||||
.obj = NULL,
|
||||
.alloc = mem_libc_alloc,
|
||||
.alloc_aligned = NULL,
|
||||
.realloc = mem_libc_realloc,
|
||||
.realloc_aligned = NULL,
|
||||
.free = mem_libc_free,
|
||||
};
|
||||
}
|
||||
|
||||
internal inline void *mem_libc_alloc(u64 size, void *alloc_obj) {
|
||||
(void)alloc_obj; // Silence unused warnings
|
||||
return calloc(1, size);
|
||||
}
|
||||
|
||||
#if 0
|
||||
internal inline void *mem_libc_alloc_aligned(u64 size, u64 alignment,
|
||||
void *alloc_obj) {
|
||||
(void)alloc_obj; // Silence unused warnings
|
||||
|
||||
void *output = aligned_alloc(alignment, size);
|
||||
if (output) {
|
||||
memset(output, 0, size);
|
||||
}
|
||||
|
||||
return output;
|
||||
}
|
||||
#endif
|
||||
|
||||
internal inline void *mem_libc_realloc(void *ptr, u64 old_size, u64 new_size, void *alloc_obj) {
|
||||
// Silence unused warnings
|
||||
(void)alloc_obj;
|
||||
(void)new_size;
|
||||
|
||||
return realloc(ptr, old_size);
|
||||
}
|
||||
|
||||
internal inline void mem_libc_free(void **ptr, void *alloc_obj) {
|
||||
(void)alloc_obj; // Silence unused warnings
|
||||
|
||||
if (!ptr || !(*ptr)) {
|
||||
return;
|
||||
}
|
||||
|
||||
free(*ptr);
|
||||
*ptr = NULL;
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
#ifndef MEM_LIBC_H
|
||||
#define MEM_LIBC_H
|
||||
|
||||
#include "mem_allocator.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // __cplusplus
|
||||
|
||||
Allocator wapp_mem_libc_allocator(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
END_C_LINKAGE
|
||||
#endif // __cplusplus
|
||||
|
||||
#endif // !MEM_LIBC_H
|
||||
@@ -0,0 +1,27 @@
|
||||
#include "str8.h"
|
||||
#include <string.h>
|
||||
|
||||
Str8 wapp_str8_lit(char *str) {
|
||||
if (!str) {
|
||||
return (Str8){.capacity = 0, .size = 0, .buf = (u8 *)""};
|
||||
}
|
||||
|
||||
u64 size = strlen(str);
|
||||
return (Str8){.capacity = size, .size = size, .buf = (u8 *)str};
|
||||
}
|
||||
|
||||
char wapp_str8_get(const Str8 *str, u64 index) {
|
||||
if (index >= str->size) {
|
||||
return '\0';
|
||||
}
|
||||
|
||||
return (char)(str->buf[index]);
|
||||
}
|
||||
|
||||
void wapp_str8_set(Str8 *str, u64 index, char c) {
|
||||
if (index >= str->size) {
|
||||
return;
|
||||
}
|
||||
|
||||
str->buf[index] = (u8)c;
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
#ifndef STR8_H
|
||||
#define STR8_H
|
||||
|
||||
#include "aliases.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !__cplusplus
|
||||
|
||||
typedef struct str8 Str8;
|
||||
struct str8 {
|
||||
u64 capacity;
|
||||
u64 size;
|
||||
u8 *buf;
|
||||
};
|
||||
|
||||
Str8 wapp_str8_lit(char *str);
|
||||
char wapp_str8_get(const Str8 *str, u64 index);
|
||||
void wapp_str8_set(Str8 *str, u64 index, char c);
|
||||
|
||||
#ifdef __cplusplus
|
||||
END_C_LINKAGE
|
||||
#endif // !__cplusplus
|
||||
|
||||
#endif // !STR8_H
|
||||
-137
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
-597
@@ -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
|
||||
@@ -1,192 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#include "mem_arena.h"
|
||||
#include "../../mem/mem_os.h"
|
||||
#include "../../../common/aliases/aliases.h"
|
||||
#include "../../../common/assert/assert.h"
|
||||
#include "../../../common/misc/misc_utils.h"
|
||||
#include "../../../base/mem/utils/mem_utils.h"
|
||||
#include <string.h>
|
||||
|
||||
#ifndef DEFAULT_ALIGNMENT
|
||||
// Why 2 * sizeof(void *) instead of sizeof(void *)
|
||||
// https://handmade.network/forums/t/6860-alignment_arena_allocator
|
||||
#define DEFAULT_ALIGNMENT (2 * sizeof(void *))
|
||||
#endif /* ifndef DEFAULT_ALIGNMENT */
|
||||
|
||||
#define ARENA_MINIMUM_CAPACITY KiB(16) // Allocate minimum of 4 pages
|
||||
|
||||
typedef enum {
|
||||
ARENA_STORAGE_TYPE_ALLOCATED,
|
||||
ARENA_STORAGE_TYPE_BUFFER,
|
||||
} ArenaStorageType;
|
||||
|
||||
struct WpArena {
|
||||
u8 *buf;
|
||||
u8 *offset;
|
||||
u8 *prev_offset;
|
||||
u64 capacity;
|
||||
ArenaStorageType type;
|
||||
b8 committed;
|
||||
|
||||
wpMiscUtilsReservePadding(sizeof(u8 *) * 3 + sizeof(u64) + sizeof(ArenaStorageType) + sizeof(b8));
|
||||
};
|
||||
|
||||
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) {
|
||||
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) {
|
||||
return false;
|
||||
}
|
||||
|
||||
b8 committed = (flags & WP_MEM_ALLOC_COMMIT) == WP_MEM_ALLOC_COMMIT;
|
||||
|
||||
#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
|
||||
|
||||
if (!wpMemArenaInitBuffer(arena, allocated, alloc_size)) {
|
||||
wpMemArenaDestroy(arena);
|
||||
return false;
|
||||
}
|
||||
|
||||
WpArena *arena_ptr = *arena;
|
||||
arena_ptr->type = ARENA_STORAGE_TYPE_ALLOCATED;
|
||||
arena_ptr->committed = committed;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void *wpMemArenaAlloc(WpArena *arena, u64 size) {
|
||||
return wpMemArenaAllocAligned(arena, size, DEFAULT_ALIGNMENT);
|
||||
}
|
||||
|
||||
void *wpMemArenaAllocAligned(WpArena *arena, u64 size, u64 alignment) {
|
||||
wpDebugAssert(arena != NULL, "`arena` should not be NULL");
|
||||
|
||||
u8 *alloc_start = arena->offset;
|
||||
|
||||
u8 *output = wpMemUtilAlignForward((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);
|
||||
}
|
||||
#endif // ifdef WP_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");
|
||||
|
||||
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);
|
||||
if (!new_ptr) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
u64 copy_size = new_size <= old_size ? new_size : old_size;
|
||||
memcpy(new_ptr, ptr, copy_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");
|
||||
|
||||
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);
|
||||
if (!new_ptr) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
u64 copy_size = new_size <= old_size ? new_size : old_size;
|
||||
memcpy(new_ptr, ptr, copy_size);
|
||||
|
||||
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");
|
||||
|
||||
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");
|
||||
|
||||
WpArena *arena_ptr = *arena;
|
||||
|
||||
if (arena_ptr->type == ARENA_STORAGE_TYPE_ALLOCATED) {
|
||||
wpOsMemFree(*arena, sizeof(WpArena) + arena_ptr->capacity);
|
||||
}
|
||||
|
||||
*arena = NULL;
|
||||
}
|
||||
@@ -1,45 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef MEM_ARENA_H
|
||||
#define MEM_ARENA_H
|
||||
|
||||
#include "../../mem/mem_os.h"
|
||||
#include "../../../common/aliases/aliases.h"
|
||||
#include "../../../common/platform/platform.h"
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
typedef struct WpArena WpArena;
|
||||
|
||||
#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))
|
||||
|
||||
/**
|
||||
* WpArena initialisation function. `wpMemArenaInitAllocatedCustom` provides the most
|
||||
* control over how the WpArena 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);
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
END_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#endif // !MEM_ARENA_H
|
||||
@@ -1,87 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#include "mem_arena_allocator.h"
|
||||
#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,
|
||||
void *alloc_obj);
|
||||
|
||||
WpAllocator wpMemArenaAllocatorInitWithBuffer(u8 *buffer, u64 buffer_size) {
|
||||
WpAllocator allocator = {0};
|
||||
b8 initialised = wpMemArenaInitBuffer((WpArena **)(&allocator.obj), buffer, buffer_size);
|
||||
if (!initialised) {
|
||||
return allocator;
|
||||
}
|
||||
|
||||
initialise_arena_allocator(&allocator);
|
||||
|
||||
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 wpMemArenaAllocatorTempBegin(const WpAllocator *allocator) {
|
||||
wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
|
||||
wpMemArenaTempBegin((WpArena *)(allocator->obj));
|
||||
}
|
||||
|
||||
void wpMemArenaAllocatorTempEnd(const WpAllocator *allocator) {
|
||||
wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
|
||||
wpMemArenaTempEnd((WpArena *)(allocator->obj));
|
||||
}
|
||||
|
||||
void wpMemArenaAllocatorClear(WpAllocator *allocator) {
|
||||
wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
|
||||
wpMemArenaClear((WpArena *)(allocator->obj));
|
||||
}
|
||||
|
||||
void wpMemArenaAllocatorDestroy(WpAllocator *allocator) {
|
||||
wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
|
||||
wpMemArenaDestroy((WpArena **)(&(allocator->obj)));
|
||||
*allocator = (WpAllocator){0};
|
||||
}
|
||||
|
||||
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,
|
||||
void *alloc_obj) {
|
||||
WpArena *arena = (WpArena *)alloc_obj;
|
||||
return wpMemArenaReallocAligned(arena, ptr, old_size, new_size, alignment);
|
||||
}
|
||||
@@ -1,46 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef MEM_ARENA_ALLOCATOR_H
|
||||
#define MEM_ARENA_ALLOCATOR_H
|
||||
|
||||
#include "../../mem/mem_os.h"
|
||||
#include "../../../common/aliases/aliases.h"
|
||||
#include "../../../common/platform/platform.h"
|
||||
#include "../../../base/mem/allocator/mem_allocator.h"
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WP_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))
|
||||
|
||||
/**
|
||||
* Wraps a WpArena in a WpAllocator object. It attempts to initialise the WpArena
|
||||
* and, if successful, defines the operations supported by it to be used by the
|
||||
* WpAllocator.
|
||||
*
|
||||
* An WpArena 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.
|
||||
*/
|
||||
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);
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
END_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#endif // !MEM_ARENA_ALLOCATOR_H
|
||||
+68
-110
@@ -1,134 +1,92 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#include "cpath.h"
|
||||
#include "../allocators/arena/mem_arena_allocator.h"
|
||||
#include "../../common/aliases/aliases.h"
|
||||
#include "../../common/misc/misc_utils.h"
|
||||
#include "../../base/dbl_list/dbl_list.h"
|
||||
#include "../../base/mem/allocator/mem_allocator.h"
|
||||
#include "../../base/strings/str8/str8.h"
|
||||
#include "aliases.h"
|
||||
#include <stdarg.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
u32 wpCpathJoinPath(WpStr8 *dst, const WpStr8List *parts) {
|
||||
if (!dst || !parts) {
|
||||
return WP_CPATH_JOIN_RESULT_INVALID_ARGS;
|
||||
void join_root_and_leaf(const char *root, const char *leaf, char *dst);
|
||||
|
||||
void join_path(char *dst, u64 count, ...) {
|
||||
va_list args;
|
||||
|
||||
va_start(args, count);
|
||||
|
||||
for (u64 i = 0; i < count; ++i) {
|
||||
join_root_and_leaf(dst, va_arg(args, const char *), dst);
|
||||
}
|
||||
|
||||
if (parts->node_count == 0) {
|
||||
return WP_CPATH_JOIN_RESULT_EMPTY_PARTS;
|
||||
}
|
||||
|
||||
WpStr8 separator = wpStr8Buf(4);
|
||||
wpStr8PushBack(&separator, WP_PATH_SEP);
|
||||
|
||||
u64 required_capacity = parts->node_count * separator.size + wpStr8ListTotalSize(parts);
|
||||
if (dst->capacity < required_capacity) {
|
||||
return WP_CPATH_JOIN_RESULT_INSUFFICIENT_DST_CAPACITY;
|
||||
}
|
||||
|
||||
// Handle first node
|
||||
WpStr8 *first_node = wpDblListGet(WpStr8, parts, 0);
|
||||
wpStr8CopyStr8Capped(dst, first_node);
|
||||
|
||||
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
|
||||
// MSVC Spectre mitigation warnings
|
||||
WpStr8 *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;
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
if (add_path_sep) {
|
||||
wpStr8ConcatCapped(dst, &separator);
|
||||
}
|
||||
}
|
||||
|
||||
wpStr8ConcatCapped(dst, node);
|
||||
|
||||
CPATH_JOIN_LOOP_END:
|
||||
++node_index;
|
||||
running = node_index < parts->node_count;
|
||||
}
|
||||
|
||||
return WP_CPATH_JOIN_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
WpStr8 *_dirup(const WpAllocator *allocator, WpStr8RO *path, u64 levels) {
|
||||
WpStr8 *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);
|
||||
|
||||
if (path->size == 0) {
|
||||
output = wpStr8AllocBuf(allocator, 16);
|
||||
if (!output) {
|
||||
goto RETURN_DIRUP;
|
||||
}
|
||||
|
||||
wpStr8PushBack(output, absolute ? WP_PATH_SEP : '.');
|
||||
goto RETURN_DIRUP;
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
void dirup(char *dst, u64 levels, const char *path) {
|
||||
if (levels < 1) {
|
||||
output = wpStr8AllocStr8(allocator, path);
|
||||
goto RETURN_DIRUP;
|
||||
return;
|
||||
}
|
||||
|
||||
WpAllocator tmp_arena = wpMemArenaAllocatorInit(MiB(8));
|
||||
if (wpMemAllocatorInvalid(&tmp_arena)) {
|
||||
goto RETURN_DIRUP;
|
||||
u64 copy_count = 0;
|
||||
u64 sep_count = 0;
|
||||
|
||||
u64 full_length;
|
||||
u64 length;
|
||||
length = full_length = strlen(path);
|
||||
|
||||
if (length > 1 && path[length - 1] == PATH_SEP) {
|
||||
--length;
|
||||
}
|
||||
|
||||
WpStr8List *parts = wpStr8Split(&tmp_arena, path, &separator);
|
||||
if (!parts) {
|
||||
goto RETURN_DIRUP;
|
||||
for (i64 i = length - 1; i >= 0; --i) {
|
||||
if (path[i] == PATH_SEP) {
|
||||
++sep_count;
|
||||
copy_count = i + 1;
|
||||
|
||||
if (sep_count == levels) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (levels >= parts->node_count) {
|
||||
output = wpStr8AllocBuf(allocator, 16);
|
||||
if (!output) {
|
||||
goto LIST_CLEANUP_DIRUP;
|
||||
char tmp[256];
|
||||
snprintf(tmp, 2, "%c", PATH_SEP);
|
||||
// NOTE (Abdelrahman): Conditions stored in variables to silence MSVC warning C5045
|
||||
bool insufficient_levels = sep_count < levels;
|
||||
bool path_to_copy_is_separator = strncmp(path, tmp, copy_count) != 0;
|
||||
if (insufficient_levels && path_to_copy_is_separator) {
|
||||
copy_count = 0;
|
||||
}
|
||||
|
||||
wpStr8PushBack(output, absolute ? WP_PATH_SEP : '.');
|
||||
if (dst == path) {
|
||||
memset(&dst[copy_count], 0, full_length - copy_count);
|
||||
} else {
|
||||
for (u64 i = 0; i < levels; ++i) {
|
||||
wpDblListPopBack(WpStr8, parts);
|
||||
u64 dst_length = strlen(dst);
|
||||
memset(dst, 0, dst_length);
|
||||
strncpy(dst, path, copy_count);
|
||||
}
|
||||
|
||||
u64 alignment = sizeof(void *) * 2;
|
||||
u64 alloc_size = wpStr8ListTotalSize(parts) + parts->node_count * separator.size;
|
||||
u64 modulo = alloc_size & (alignment - 1);
|
||||
alloc_size += alignment - modulo;
|
||||
|
||||
output = wpStr8AllocBuf(allocator, alloc_size);
|
||||
if (output) {
|
||||
if (absolute) {
|
||||
wpStr8PushBack(output, WP_PATH_SEP);
|
||||
}
|
||||
|
||||
WpStr8 *joined = wpStr8Join(&tmp_arena, parts, &separator);
|
||||
if (joined) {
|
||||
wpStr8ConcatCapped(output, joined);
|
||||
}
|
||||
u64 final_length = strlen(dst);
|
||||
if (final_length > 1) {
|
||||
dst[final_length - 1] = '\0';
|
||||
} else if (final_length == 0) {
|
||||
dst[0] = '.';
|
||||
}
|
||||
}
|
||||
|
||||
LIST_CLEANUP_DIRUP:
|
||||
wpMemArenaAllocatorDestroy(&tmp_arena);
|
||||
void join_root_and_leaf(const char *root, const char *leaf, char *dst) {
|
||||
u64 root_length = strlen(root);
|
||||
u64 leaf_length = strlen(leaf);
|
||||
|
||||
RETURN_DIRUP:
|
||||
return output;
|
||||
memcpy(dst, root, root_length);
|
||||
|
||||
if (leaf_length == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
u64 copy_start = root_length;
|
||||
|
||||
if (root_length > 0 && root[root_length - 1] != PATH_SEP && leaf[0] != PATH_SEP) {
|
||||
dst[root_length] = PATH_SEP;
|
||||
++copy_start;
|
||||
}
|
||||
|
||||
memcpy(&(dst[copy_start]), leaf, leaf_length);
|
||||
}
|
||||
|
||||
+16
-29
@@ -1,45 +1,32 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef CPATH_H
|
||||
#define CPATH_H
|
||||
|
||||
#include "../../common/aliases/aliases.h"
|
||||
#include "../../common/platform/platform.h"
|
||||
#include "../../base/mem/allocator/mem_allocator.h"
|
||||
#include "../../base/strings/str8/str8.h"
|
||||
#include "aliases.h"
|
||||
#include "platform.h"
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
#ifdef __cplusplus
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
#endif // __cplusplus
|
||||
|
||||
#ifdef WP_PLATFORM_POSIX
|
||||
#include <limits.h>
|
||||
#define WP_PATH_SEP '/'
|
||||
#define WP_PATH_MAX PATH_MAX
|
||||
#elif defined(WP_PLATFORM_WINDOWS)
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#include <Windows.h>
|
||||
#define WP_PATH_SEP '\\'
|
||||
#define WP_PATH_MAX MAX_PATH
|
||||
#ifdef WAPP_PLATFORM_POSIX
|
||||
#define PATH_SEP '/'
|
||||
#elif defined(WAPP_PLATFORM_WINDOWS)
|
||||
#define PATH_SEP '\\'
|
||||
#else
|
||||
#error "Unrecognised platform"
|
||||
#endif
|
||||
|
||||
#define wpCpathDirname(ALLOCATOR, PATH) _dirup(ALLOCATOR, PATH, 1)
|
||||
#define wpCpathDirup(ALLOCATOR, PATH, COUNT) _dirup(ALLOCATOR, PATH, COUNT)
|
||||
#define NUMPARTS(...) (sizeof((const char *[]){"", __VA_ARGS__}) / sizeof(const char *) - 1)
|
||||
|
||||
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;
|
||||
#define wapp_cpath_join_path(DST, ...) join_path(DST, NUMPARTS(__VA_ARGS__), __VA_ARGS__)
|
||||
#define wapp_cpath_dirname(DST, PATH) dirup(DST, 1, PATH)
|
||||
#define wapp_cpath_dirup(DST, COUNT, PATH) dirup(DST, COUNT, PATH)
|
||||
|
||||
WpCpathJoinResult wpCpathJoinPath(WpStr8 *dst, const WpStr8List *parts);
|
||||
WpStr8 *_dirup(const WpAllocator *allocator, WpStr8RO *path, u64 levels);
|
||||
void join_path(char *dst, u64 count, ...);
|
||||
void dirup(char *dst, u64 levels, const char *path);
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
#ifdef __cplusplus
|
||||
END_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
#endif // __cplusplus
|
||||
|
||||
#endif // !CPATH_H
|
||||
|
||||
@@ -1,139 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#include "file.h"
|
||||
#include "../cpath/cpath.h"
|
||||
#include "../../common/assert/assert.h"
|
||||
#include "../../common/aliases/aliases.h"
|
||||
#include "../../base/array/array.h"
|
||||
#include "../../base/strings/str8/str8.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);
|
||||
}
|
||||
|
||||
i64 wpFileGetCurrentPosition(WpFile *file) {
|
||||
wpDebugAssert(file != NULL, "`file` should not be NULL.");
|
||||
return _fileSeek(file, 0, WP_SEEK_CURRENT);
|
||||
}
|
||||
|
||||
i64 wpFileSeek(WpFile *file, i64 offset, WpFileSeekOrigin origin) {
|
||||
wpDebugAssert(file != NULL, "`file` should not be NULL.");
|
||||
return _fileSeek(file, offset, origin);
|
||||
}
|
||||
|
||||
i64 wpFileGetLength(WpFile *file) {
|
||||
wpDebugAssert(file != NULL, "`file` should not be NULL.");
|
||||
|
||||
i64 current = wpFileGetCurrentPosition(file);
|
||||
|
||||
_fileSeek(file, 0, WP_SEEK_END);
|
||||
|
||||
i64 output = wpFileGetCurrentPosition(file);
|
||||
|
||||
// Restore position
|
||||
_fileSeek(file, current, WP_SEEK_START);
|
||||
|
||||
return output;
|
||||
}
|
||||
|
||||
u64 wpFileRead(void *dst_buf, WpFile *file, u64 byte_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;
|
||||
}
|
||||
|
||||
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 req_byte_count = item_count * item_size;
|
||||
u64 copy_byte_count = 0;
|
||||
|
||||
if (req_byte_count <= file_length && req_byte_count <= dst_byte_capacity) {
|
||||
copy_byte_count = req_byte_count;
|
||||
} else {
|
||||
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;
|
||||
}
|
||||
|
||||
wpArraySetCount(dst_buf, byte_count / item_size);
|
||||
|
||||
return wpArrayCount(dst_buf);
|
||||
}
|
||||
|
||||
i64 wpFileWriteArray(const WpArray src_buf, WpFile *file, u64 item_count) {
|
||||
wpDebugAssert(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 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;
|
||||
}
|
||||
|
||||
i32 wpFileFlush(WpFile *file) {
|
||||
wpDebugAssert(file != NULL, "`file` should not be NULL.");
|
||||
return _fileFlush(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);
|
||||
}
|
||||
@@ -1,77 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef FILE_H
|
||||
#define FILE_H
|
||||
|
||||
#include "../../base/mem/allocator/mem_allocator.h"
|
||||
#include "../../common/aliases/aliases.h"
|
||||
#include "../../base/strings/str8/str8.h"
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
typedef struct WpFile WpFile;
|
||||
|
||||
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+
|
||||
|
||||
COUNT_FILE_ACCESS_MODE,
|
||||
} WpFileAccessMode;
|
||||
|
||||
typedef enum {
|
||||
WP_SEEK_START,
|
||||
WP_SEEK_CURRENT,
|
||||
WP_SEEK_END,
|
||||
|
||||
COUNT_FILE_SEEK_ORIGIN,
|
||||
} WpFileSeekOrigin;
|
||||
|
||||
// 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
|
||||
END_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#endif // !FILE_H
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -1,30 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#include "mem_os.h"
|
||||
#include "mem_os_ops.h"
|
||||
#include "../../common/aliases/aliases.h"
|
||||
#include "../../common/platform/platform.h"
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
|
||||
#if defined(WP_PLATFORM_WINDOWS)
|
||||
#include "win/mem_os_win.h"
|
||||
#elif defined(WP_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);
|
||||
|
||||
if (type == WP_MEM_INIT_INITIALISED) {
|
||||
memset(output, 0, size);
|
||||
}
|
||||
|
||||
return output;
|
||||
}
|
||||
|
||||
void wpOsMemFree(void *ptr, u64 size) {
|
||||
_osMemFree(ptr, size);
|
||||
}
|
||||
@@ -1,33 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef MEM_OS_H
|
||||
#define MEM_OS_H
|
||||
|
||||
#include "../../common/aliases/aliases.h"
|
||||
#include "../../common/platform/platform.h"
|
||||
|
||||
#include "mem_os_ops.h"
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#if defined(WP_PLATFORM_WINDOWS)
|
||||
#include "win/mem_os_win.h"
|
||||
#elif defined(WP_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);
|
||||
|
||||
wp_extern void *_osMemAllocate(void *addr, u64 size, WpMemAccess access, WpMemAllocFlags flags, WpMemInitType type);
|
||||
wp_extern void _osMemFree(void *ptr, u64 size);
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
END_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#endif // !MEM_OS_H
|
||||
@@ -1,30 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef MEM_OS_OPS_H
|
||||
#define MEM_OS_OPS_H
|
||||
|
||||
#include "../../common/platform/platform.h"
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WP_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 {
|
||||
WP_MEM_INIT_UNINITIALISED,
|
||||
WP_MEM_INIT_INITIALISED,
|
||||
} WpMemInitType;
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
END_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#endif // !MEM_OS_OPS_H
|
||||
@@ -0,0 +1,53 @@
|
||||
#include "mem_utils.h"
|
||||
#include "mem_utils_ops.h"
|
||||
#include "aliases.h"
|
||||
#include "platform.h"
|
||||
#include <assert.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#if defined(WAPP_PLATFORM_WINDOWS)
|
||||
#include "mem_utils_win.h"
|
||||
#elif defined(WAPP_PLATFORM_POSIX)
|
||||
#include "mem_utils_posix.h"
|
||||
#else
|
||||
#error "Unrecognised platform"
|
||||
#endif
|
||||
|
||||
internal bool is_power_of_two(u64 num) { return (num & (num - 1)) == 0; }
|
||||
|
||||
void *wapp_mem_util_align_forward(void *ptr, u64 alignment) {
|
||||
if (!ptr) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
assert(is_power_of_two(alignment));
|
||||
|
||||
uptr p = (uptr)ptr;
|
||||
uptr align = (uptr)alignment;
|
||||
|
||||
// Similar to p % align, but it's a faster implementation that works fine
|
||||
// because align is guaranteed to be a power of 2
|
||||
uptr modulo = p & (align - 1);
|
||||
|
||||
if (modulo != 0) {
|
||||
p += align - modulo;
|
||||
}
|
||||
|
||||
return (void *)p;
|
||||
}
|
||||
|
||||
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 == WAPP_MEM_INIT_INITIALISED) {
|
||||
memset(output, 0, size);
|
||||
}
|
||||
|
||||
return output;
|
||||
}
|
||||
|
||||
void wapp_mem_util_free(void *ptr, u64 size) {
|
||||
mem_util_free(ptr, size);
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
#ifndef MEM_UTILS_H
|
||||
#define MEM_UTILS_H
|
||||
|
||||
#include "aliases.h"
|
||||
#include "platform.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // __cplusplus
|
||||
|
||||
#include "mem_utils_ops.h"
|
||||
|
||||
#if defined(WAPP_PLATFORM_WINDOWS)
|
||||
#include "mem_utils_win.h"
|
||||
#elif defined(WAPP_PLATFORM_POSIX)
|
||||
#include "mem_utils_posix.h"
|
||||
#else
|
||||
#error "Unrecognised platform"
|
||||
#endif
|
||||
|
||||
void *wapp_mem_util_align_forward(void *ptr, u64 alignment);
|
||||
void *wapp_mem_util_alloc(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type);
|
||||
void wapp_mem_util_free(void *ptr, u64 size);
|
||||
|
||||
external void *mem_util_allocate(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type);
|
||||
external void mem_util_free(void *ptr, u64 size);
|
||||
|
||||
#ifdef __cplusplus
|
||||
END_C_LINKAGE
|
||||
#endif // __cplusplus
|
||||
|
||||
#endif // !MEM_UTILS_H
|
||||
@@ -0,0 +1,26 @@
|
||||
#ifndef MEM_UTILS_OPS_H
|
||||
#define MEM_UTILS_OPS_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // __cplusplus
|
||||
|
||||
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 mem_init_type {
|
||||
WAPP_MEM_INIT_UNINITIALISED,
|
||||
WAPP_MEM_INIT_INITIALISED,
|
||||
} MemInitType;
|
||||
|
||||
#ifdef __cplusplus
|
||||
END_C_LINKAGE
|
||||
#endif // __cplusplus
|
||||
|
||||
#endif // !MEM_UTILS_OPS_H
|
||||
@@ -1,36 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#include "../../../common/aliases/aliases.h"
|
||||
#include "../../../common/platform/platform.h"
|
||||
|
||||
#ifdef WP_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,
|
||||
};
|
||||
|
||||
void *_osMemAllocate(void *addr, u64 size, WpMemAccess access, WpMemAllocFlags flags, WpMemInitType 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)
|
||||
alloc_flags |= MAP_NORESERVE;
|
||||
#endif
|
||||
|
||||
return mmap(addr, size, access_types[access], alloc_flags, -1, 0);
|
||||
}
|
||||
|
||||
void _osMemFree(void *ptr, u64 size) {
|
||||
munmap(ptr, size);
|
||||
}
|
||||
|
||||
#endif // !WP_PLATFORM_POSIX
|
||||
@@ -1,35 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef MEM_OS_POSIX_H
|
||||
#define MEM_OS_POSIX_H
|
||||
|
||||
#include "../../../common/platform/platform.h"
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#ifdef WP_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,
|
||||
#endif
|
||||
} WpMemAllocFlags;
|
||||
|
||||
#endif // !WP_PLATFORM_POSIX
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
END_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#endif // !MEM_OS_POSIX_H
|
||||
@@ -0,0 +1,33 @@
|
||||
#include "aliases.h"
|
||||
#include "platform.h"
|
||||
|
||||
#ifdef WAPP_PLATFORM_POSIX
|
||||
|
||||
#include "mem_utils_ops.h"
|
||||
#include "mem_utils_posix.h"
|
||||
#include <sys/mman.h>
|
||||
|
||||
internal 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 *mem_util_allocate(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type) {
|
||||
i32 alloc_flags = flags | MAP_ANON | MAP_PRIVATE;
|
||||
|
||||
#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 mem_util_free(void *ptr, u64 size) {
|
||||
munmap(ptr, size);
|
||||
}
|
||||
|
||||
#endif // !WAPP_PLATFORM_POSIX
|
||||
@@ -0,0 +1,33 @@
|
||||
#ifndef MEM_UTILS_POSIX_H
|
||||
#define MEM_UTILS_POSIX_H
|
||||
|
||||
#include "platform.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !__cplusplus
|
||||
|
||||
#ifdef WAPP_PLATFORM_POSIX
|
||||
|
||||
#include <sys/mman.h>
|
||||
|
||||
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
|
||||
} MemAllocFlags;
|
||||
|
||||
#endif // !WAPP_PLATFORM_POSIX
|
||||
|
||||
#ifdef __cplusplus
|
||||
END_C_LINKAGE
|
||||
#endif // !__cplusplus
|
||||
|
||||
#endif // !MEM_UTILS_POSIX_H
|
||||
@@ -1,37 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#include "../../../common/aliases/aliases.h"
|
||||
#include "../../../common/platform/platform.h"
|
||||
|
||||
#ifdef WP_PLATFORM_WINDOWS
|
||||
|
||||
#include "mem_os_win.h"
|
||||
#include "../mem_os_ops.h"
|
||||
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#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,
|
||||
};
|
||||
|
||||
void *_osMemAllocate(void *addr, u64 size, WpMemAccess access, WpMemAllocFlags flags, WpMemInitType type) {
|
||||
// Ensure memory is committed if it's meant to be initialised
|
||||
if (type == WP_MEM_INIT_INITIALISED) {
|
||||
flags |= WP_MEM_ALLOC_COMMIT;
|
||||
}
|
||||
|
||||
return VirtualAlloc(addr, (SIZE_T)size, flags, access_types[access]);
|
||||
}
|
||||
|
||||
void _osMemFree(void *ptr, u64 size) {
|
||||
VirtualFree(ptr, size, MEM_RELEASE);
|
||||
}
|
||||
|
||||
#endif // !WP_PLATFORM_WINDOWS
|
||||
@@ -1,29 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef MEM_OS_WIN_H
|
||||
#define MEM_OS_WIN_H
|
||||
|
||||
#include "../../../common/platform/platform.h"
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#ifdef WP_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;
|
||||
|
||||
#endif // !WP_PLATFORM_WINDOWS
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
END_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#endif // !MEM_OS_WIN_H
|
||||
@@ -0,0 +1,35 @@
|
||||
#include "aliases.h"
|
||||
#include "platform.h"
|
||||
|
||||
#ifdef WAPP_PLATFORM_WINDOWS
|
||||
|
||||
#include "mem_utils_ops.h"
|
||||
#include "mem_utils_win.h"
|
||||
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#include <Windows.h>
|
||||
#include <memoryapi.h>
|
||||
|
||||
internal 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 *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 == WAPP_MEM_INIT_INITIALISED) {
|
||||
flags |= WAPP_MEM_ALLOC_COMMIT;
|
||||
}
|
||||
|
||||
return VirtualAlloc(addr, (SIZE_T)size, flags, access_types[access]);
|
||||
}
|
||||
|
||||
void mem_util_free(void *ptr, u64 size) {
|
||||
VirtualFree(ptr, size, MEM_RELEASE);
|
||||
}
|
||||
|
||||
#endif // !WAPP_PLATFORM_WINDOWS
|
||||
@@ -0,0 +1,27 @@
|
||||
#ifndef MEM_UTILS_WIN_H
|
||||
#define MEM_UTILS_WIN_H
|
||||
|
||||
#include "platform.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !__cplusplus
|
||||
|
||||
#ifdef WAPP_PLATFORM_WINDOWS
|
||||
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#include <Windows.h>
|
||||
#include <memoryapi.h>
|
||||
|
||||
typedef enum mem_alloc_flags {
|
||||
WAPP_MEM_ALLOC_RESERVE = MEM_RESERVE,
|
||||
WAPP_MEM_ALLOC_COMMIT = MEM_COMMIT,
|
||||
} MemAllocFlags;
|
||||
|
||||
#endif // !WAPP_PLATFORM_WINDOWS
|
||||
|
||||
#ifdef __cplusplus
|
||||
END_C_LINKAGE
|
||||
#endif // !__cplusplus
|
||||
|
||||
#endif // !MEM_UTILS_WIN_H
|
||||
@@ -1,15 +1,8 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#include "commander.h"
|
||||
#include "commander_output.h"
|
||||
#include "../utils/shell_utils.h"
|
||||
#include "../../allocators/arena/mem_arena_allocator.h"
|
||||
#include "../../../common/aliases/aliases.h"
|
||||
#include "../../../common/misc/misc_utils.h"
|
||||
#include "../../../base/dbl_list/dbl_list.h"
|
||||
#include "../../../base/mem/allocator/mem_allocator.h"
|
||||
#include "../../../base/strings/str8/str8.h"
|
||||
#include "aliases.h"
|
||||
#include "shell_utils.h"
|
||||
#include <stdarg.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
@@ -17,85 +10,109 @@
|
||||
#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);
|
||||
internal inline CMDError build_command_from_args(char *cmd, u64 buf_len, va_list args);
|
||||
internal inline CMDResult execute_command(const char *cmd, CMDOutHandling out_handling, char *out_buf,
|
||||
u64 buf_size);
|
||||
internal inline CMDError get_command_output(FILE *fp, CMDOutHandling out_handling, char *out_buf,
|
||||
u64 buf_size);
|
||||
|
||||
WpCmdResult wpShellCommanderExecute(WpCmdOutHandling out_handling, WpStr8 *out_buf, const WpStr8List *cmd) {
|
||||
if (!cmd) {
|
||||
return wpCmdNoExit(WP_SHELL_ERR_INVALID_ARGS);
|
||||
CMDResult run_command(CMDOutHandling out_handling, char *out_buf, u64 buf_size, ...) {
|
||||
va_list args;
|
||||
va_start(args, buf_size);
|
||||
|
||||
char cmd[CMD_BUF_LEN] = {0};
|
||||
CMDError err = build_command_from_args(cmd, CMD_BUF_LEN, args);
|
||||
if (err > SHELL_ERR_NO_ERROR) {
|
||||
va_end(args);
|
||||
return CMD_NO_EXIT(err);
|
||||
}
|
||||
|
||||
WpAllocator arena = wpMemArenaAllocatorInit(KiB(500));
|
||||
va_end(args);
|
||||
|
||||
WpStr8 *cmd_str = wpStr8Join(&arena, cmd, &wpStr8LitRo(" "));
|
||||
if (!cmd_str) {
|
||||
wpMemArenaAllocatorDestroy(&arena);
|
||||
return wpCmdNoExit(WP_SHELL_ERR_ALLOCATION_FAIL);
|
||||
return execute_command(cmd, out_handling, out_buf, buf_size);
|
||||
}
|
||||
|
||||
// Redirect output
|
||||
cmd_str = wpStr8AllocConcat(&arena, cmd_str, &wpStr8LitRo(" 2>&1"));
|
||||
internal inline CMDError build_command_from_args(char *cmd, u64 buf_len,
|
||||
va_list args) {
|
||||
u64 size = 0;
|
||||
u64 arg_len = 0;
|
||||
|
||||
WpCmdResult output = executeCommand(cmd_str, out_handling, out_buf);
|
||||
|
||||
wpMemArenaAllocatorDestroy(&arena);
|
||||
|
||||
return output;
|
||||
const char *arg = va_arg(args, const char *);
|
||||
while (arg) {
|
||||
arg_len = strlen(arg);
|
||||
if (arg_len >= buf_len - size) {
|
||||
return SHELL_ERR_CMD_BUF_FULL;
|
||||
}
|
||||
|
||||
wp_intern WpCmdResult executeCommand(WpStr8RO *cmd, WpCmdOutHandling out_handling, WpStr8 *out_buf) {
|
||||
char cmd_buf[CMD_BUF_LEN] = {0};
|
||||
wpStr8CopyToCstr(cmd_buf, cmd, CMD_BUF_LEN);
|
||||
strcat(cmd, arg);
|
||||
cmd[size + arg_len] = ' ';
|
||||
|
||||
FILE *fp = wpShellUtilsPopen(cmd_buf, "r");
|
||||
size += arg_len + 1;
|
||||
|
||||
arg = va_arg(args, const char *);
|
||||
}
|
||||
|
||||
return SHELL_ERR_NO_ERROR;
|
||||
}
|
||||
|
||||
internal inline CMDResult execute_command(const char *cmd,
|
||||
CMDOutHandling out_handling,
|
||||
char *out_buf, u64 buf_size) {
|
||||
FILE *fp = wapp_shell_utils_popen(cmd, "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, buf_size);
|
||||
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);
|
||||
internal inline CMDError get_command_output(FILE *fp,
|
||||
CMDOutHandling out_handling,
|
||||
char *out_buf, u64 buf_size) {
|
||||
char out[OUT_BUF_LEN] = {0};
|
||||
u64 max_out_length = OUT_BUF_LEN - 1;
|
||||
|
||||
out.size = fread((void *)out.buf, sizeof(c8), out.capacity, fp);
|
||||
if (out_handling == WP_SHELL_OUTPUT_CAPTURE && out_buf != NULL) {
|
||||
if (out.size >= out_buf->capacity) {
|
||||
return WP_SHELL_ERR_OUT_BUF_FULL;
|
||||
u64 buf_filled = 0;
|
||||
while (fgets(out, (i32)max_out_length, fp)) {
|
||||
if (out_handling == SHELL_OUTPUT_CAPTURE && out_buf != NULL) {
|
||||
buf_filled += strlen(out);
|
||||
if (buf_filled >= buf_size) {
|
||||
return SHELL_ERR_OUT_BUF_FULL;
|
||||
}
|
||||
|
||||
wpStr8ConcatCapped(out_buf, &out);
|
||||
} else if (out_handling == WP_SHELL_OUTPUT_PRINT) {
|
||||
printf(WP_STR8_SPEC, wpStr8Varg(out));
|
||||
strcat(out_buf, out);
|
||||
} else if (out_handling == SHELL_OUTPUT_PRINT) {
|
||||
printf("%s", out);
|
||||
}
|
||||
}
|
||||
|
||||
return WP_SHELL_ERR_NO_ERROR;
|
||||
return SHELL_ERR_NO_ERROR;
|
||||
}
|
||||
|
||||
@@ -1,29 +1,26 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef COMMANDER_H
|
||||
#define COMMANDER_H
|
||||
|
||||
#include "aliases.h"
|
||||
#include "commander_output.h"
|
||||
#include "../../../common/aliases/aliases.h"
|
||||
#include "../../../common/platform/platform.h"
|
||||
#include "../../../base/strings/str8/str8.h"
|
||||
#include <stdbool.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
// TODO (Abdelrahman): This module needs rethinking
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
#ifdef __cplusplus
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
#endif // __cplusplus
|
||||
|
||||
#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})
|
||||
#define wapp_shell_commander_execute(HANDLE_OUTPUT, OUT_BUF, BUF_SIZE, ...) \
|
||||
run_command(HANDLE_OUTPUT, OUT_BUF, BUF_SIZE, __VA_ARGS__, "2>&1", NULL)
|
||||
|
||||
WpCmdResult wpShellCommanderExecute(WpCmdOutHandling out_handling, WpStr8 *out_buf, const WpStr8List *cmd);
|
||||
CMDResult run_command(CMDOutHandling out_handling, char *out_buf, u64 buf_size, ...);
|
||||
|
||||
wp_extern WpCmdError _getOutputStatus(FILE *fp, i32 *status_out);
|
||||
external CMDError get_output_status(FILE *fp, i32 *status_out);
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
#ifdef __cplusplus
|
||||
END_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
#endif // __cplusplus
|
||||
|
||||
#endif // !COMMANDER_H
|
||||
|
||||
@@ -1,42 +1,42 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef COMMANDER_OUTPUT_H
|
||||
#define COMMANDER_OUTPUT_H
|
||||
|
||||
#include "../../../common/aliases/aliases.h"
|
||||
#include "../../../common/platform/platform.h"
|
||||
#include "../../../common/misc/misc_utils.h"
|
||||
#include "aliases.h"
|
||||
#include "platform.h"
|
||||
#include <stdbool.h>
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
#ifdef __cplusplus
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
#endif // __cplusplus
|
||||
|
||||
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_CMD_BUF_FULL,
|
||||
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;
|
||||
b8 exited;
|
||||
CMDError error;
|
||||
bool exited;
|
||||
|
||||
wpMiscUtilsReservePadding(sizeof(b8) + sizeof(i32) + sizeof(WpCmdError));
|
||||
#ifdef WAPP_PLATFORM_WINDOWS
|
||||
#include "misc_utils.h"
|
||||
wapp_misc_utils_padding_size(sizeof(bool) + sizeof(i32) + sizeof(CMDError));
|
||||
#endif // !WAPP_PLATFORM_WINDOWS
|
||||
};
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
#ifdef __cplusplus
|
||||
END_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
#endif // __cplusplus
|
||||
|
||||
#endif // !COMMANDER_OUTPUT_H
|
||||
|
||||
@@ -1,25 +1,23 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
#include "aliases.h"
|
||||
#include "platform.h"
|
||||
|
||||
#include "../../../../common/aliases/aliases.h"
|
||||
#include "../../../../common/platform/platform.h"
|
||||
#ifdef WAPP_PLATFORM_POSIX
|
||||
|
||||
#ifdef WP_PLATFORM_POSIX
|
||||
|
||||
#include "../commander_output.h"
|
||||
#include "../../utils/shell_utils.h"
|
||||
#include "commander_output.h"
|
||||
#include "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
|
||||
|
||||
@@ -1,24 +1,22 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
#include "aliases.h"
|
||||
#include "platform.h"
|
||||
|
||||
#include "../../../../common/aliases/aliases.h"
|
||||
#include "../../../../common/platform/platform.h"
|
||||
#ifdef WAPP_PLATFORM_WINDOWS
|
||||
|
||||
#ifdef WP_PLATFORM_WINDOWS
|
||||
|
||||
#include "../commander_output.h"
|
||||
#include "../../utils/shell_utils.h"
|
||||
#include "commander_output.h"
|
||||
#include "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
|
||||
|
||||
@@ -1,36 +1,33 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
#include "aliases.h"
|
||||
#include "platform.h"
|
||||
|
||||
#include "../../../../common/aliases/aliases.h"
|
||||
#include "../../../../common/platform/platform.h"
|
||||
#include "../../../../base/strings/str8/str8.h"
|
||||
#ifdef WAPP_PLATFORM_POSIX
|
||||
|
||||
#ifdef WP_PLATFORM_POSIX
|
||||
|
||||
#include "../terminal_colours.h"
|
||||
#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"),
|
||||
internal const char *colours[COUNT_TERM_COLOUR] = {
|
||||
[WAPP_TERM_COLOUR_FG_BLACK] = "\033[30m",
|
||||
[WAPP_TERM_COLOUR_FG_RED] = "\033[31m",
|
||||
[WAPP_TERM_COLOUR_FG_GREEN] = "\033[32m",
|
||||
[WAPP_TERM_COLOUR_FG_BLUE] = "\033[34m",
|
||||
[WAPP_TERM_COLOUR_FG_CYAN] = "\033[36m",
|
||||
[WAPP_TERM_COLOUR_FG_MAGENTA] = "\033[35m",
|
||||
[WAPP_TERM_COLOUR_FG_YELLOW] = "\033[33m",
|
||||
[WAPP_TERM_COLOUR_FG_WHITE] = "\033[37m",
|
||||
[WAPP_TERM_COLOUR_FG_BR_BLACK] = "\033[90m",
|
||||
[WAPP_TERM_COLOUR_FG_BR_RED] = "\033[91m",
|
||||
[WAPP_TERM_COLOUR_FG_BR_GREEN] = "\033[92m",
|
||||
[WAPP_TERM_COLOUR_FG_BR_BLUE] = "\033[94m",
|
||||
[WAPP_TERM_COLOUR_FG_BR_CYAN] = "\033[96m",
|
||||
[WAPP_TERM_COLOUR_FG_BR_MAGENTA] = "\033[95m",
|
||||
[WAPP_TERM_COLOUR_FG_BR_YELLOW] = "\033[93m",
|
||||
[WAPP_TERM_COLOUR_FG_BR_WHITE] = "\033[97m",
|
||||
[WAPP_TERM_COLOUR_CLEAR] = "\033[0m",
|
||||
};
|
||||
|
||||
void _printColouredText(WpStr8RO *text, WpTerminalColour colour) {
|
||||
printf(WP_STR8_SPEC WP_STR8_SPEC, wpStr8Varg(colours[colour]), wpStr8Varg((*text)));
|
||||
void print_coloured_text(const char *text, TerminalColour colour) {
|
||||
printf("%s%s", colours[colour], text);
|
||||
}
|
||||
|
||||
#endif // !WP_PLATFORM_POSIX
|
||||
#endif // !WAPP_PLATFORM_POSIX
|
||||
|
||||
@@ -1,18 +1,14 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#include "termcolour.h"
|
||||
#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(const char *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) {
|
||||
print_coloured_text("", WAPP_TERM_COLOUR_CLEAR);
|
||||
}
|
||||
|
||||
@@ -1,26 +1,20 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef TERM_COLOUR_H
|
||||
#define TERM_COLOUR_H
|
||||
|
||||
#include "aliases.h"
|
||||
#include "terminal_colours.h"
|
||||
#include "../../../common/aliases/aliases.h"
|
||||
#include "../../../common/platform/platform.h"
|
||||
#include "../../../base/strings/str8/str8.h"
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
#ifdef __cplusplus
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
#endif // __cplusplus
|
||||
|
||||
// TODO (Abdelrahman): Look into moving away from stdio in the implementation
|
||||
void wapp_shell_termcolour_print_text(const char *text, TerminalColour colour);
|
||||
void wapp_shell_termcolour_clear_colour(void);
|
||||
|
||||
void wpShellTermcolourPrintText(WpStr8RO *text, WpTerminalColour colour);
|
||||
void wpShellTermcolourClearColour(void);
|
||||
external void print_coloured_text(const char *text, TerminalColour colour);
|
||||
|
||||
wp_extern void _printColouredText(WpStr8RO *text, WpTerminalColour colour);
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
#ifdef __cplusplus
|
||||
END_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
#endif // __cplusplus
|
||||
|
||||
#endif // !TERM_COLOUR_H
|
||||
|
||||
@@ -1,39 +1,34 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef TERMINAL_COLOURS_H
|
||||
#define TERMINAL_COLOURS_H
|
||||
|
||||
#include "../../../common/aliases/aliases.h"
|
||||
#include "../../../common/platform/platform.h"
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
#ifdef __cplusplus
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
#endif // __cplusplus
|
||||
|
||||
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 __cplusplus
|
||||
END_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
#endif // __cplusplus
|
||||
|
||||
#endif // !TERMINAL_COLOURS_H
|
||||
|
||||
@@ -1,65 +1,62 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
#include "aliases.h"
|
||||
#include "platform.h"
|
||||
|
||||
#include "../../../../common/aliases/aliases.h"
|
||||
#include "../../../../common/platform/platform.h"
|
||||
#include "../../../../base/strings/str8/str8.h"
|
||||
#ifdef WAPP_PLATFORM_WINDOWS
|
||||
|
||||
#ifdef WP_PLATFORM_WINDOWS
|
||||
|
||||
#include "../terminal_colours.h"
|
||||
#include "../../../../common/misc/misc_utils.h"
|
||||
#include "misc_utils.h"
|
||||
#include "terminal_colours.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);
|
||||
internal 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,
|
||||
internal 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(const char *text, TerminalColour colour) {
|
||||
persistent 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("%s", text);
|
||||
}
|
||||
|
||||
wp_intern void init_data(TermcolourData *data) {
|
||||
internal void init_data(TermcolourData *data) {
|
||||
// create handle
|
||||
data->handle = GetStdHandle(STD_OUTPUT_HANDLE);
|
||||
|
||||
@@ -70,4 +67,4 @@ wp_intern void init_data(TermcolourData *data) {
|
||||
data->current_colour = data->default_colour;
|
||||
}
|
||||
|
||||
#endif // !WP_PLATFORM_WINDOWS
|
||||
#endif // !WAPP_PLATFORM_WINDOWS
|
||||
|
||||
@@ -1,26 +1,15 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef SHELL_UTILS_H
|
||||
#define SHELL_UTILS_H
|
||||
|
||||
#include "../../../common/aliases/aliases.h"
|
||||
#include "../../../common/platform/platform.h"
|
||||
#include "platform.h"
|
||||
#include <stdio.h>
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WP_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 */
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
END_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
#define wapp_shell_utils_popen popen
|
||||
#define wapp_shell_utils_pclose pclose
|
||||
#endif /* ifdef WAPP_PLATFORM_WINDOWS */
|
||||
|
||||
#endif // !SHELL_UTILS_H
|
||||
|
||||
@@ -1,24 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef WAPP_OS_C
|
||||
#define WAPP_OS_C
|
||||
|
||||
#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"
|
||||
#include "shell/commander/posix/commander_posix.c"
|
||||
#include "shell/commander/win/commander_win.c"
|
||||
#include "shell/commander/commander.c"
|
||||
#include "cpath/cpath.c"
|
||||
#include "allocators/arena/mem_arena.c"
|
||||
#include "allocators/arena/mem_arena_allocator.c"
|
||||
#include "mem/posix/mem_os_posix.c"
|
||||
#include "mem/win/mem_os_win.c"
|
||||
#include "mem/mem_os.c"
|
||||
#include "../base/wapp_base.c"
|
||||
|
||||
#endif // !WAPP_OS_C
|
||||
@@ -1,24 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef WAPP_CORE_H
|
||||
#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"
|
||||
#include "shell/commander/commander_output.h"
|
||||
#include "shell/utils/shell_utils.h"
|
||||
#include "cpath/cpath.h"
|
||||
#include "allocators/arena/mem_arena.h"
|
||||
#include "allocators/arena/mem_arena_allocator.h"
|
||||
#include "mem/posix/mem_os_posix.h"
|
||||
#include "mem/win/mem_os_win.h"
|
||||
#include "mem/mem_os_ops.h"
|
||||
#include "mem/mem_os.h"
|
||||
#include "../common/wapp_common.h"
|
||||
#include "../base/wapp_base.h"
|
||||
|
||||
#endif // !WAPP_CORE_H
|
||||
@@ -1,8 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef WAPP_PRNG_C
|
||||
#define WAPP_PRNG_C
|
||||
|
||||
#include "xorshift/xorshift.c"
|
||||
|
||||
#endif // !WAPP_PRNG_C
|
||||
@@ -1,9 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef WAPP_PRNG_H
|
||||
#define WAPP_PRNG_H
|
||||
|
||||
#include "xorshift/xorshift.h"
|
||||
#include "../common/wapp_common.h"
|
||||
|
||||
#endif // !WAPP_PRNG_H
|
||||
@@ -1,135 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#include "xorshift.h"
|
||||
#include "../../common/aliases/aliases.h"
|
||||
#include "../../common/assert/assert.h"
|
||||
#include "../../common/platform/platform.h"
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
|
||||
typedef struct SplitMix64State SplitMix64State;
|
||||
struct SplitMix64State {
|
||||
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);
|
||||
|
||||
WpXor256State wpPrngXorshiftInit(void) {
|
||||
wp_persist b8 seeded = false;
|
||||
if (!seeded) {
|
||||
seeded = true;
|
||||
seed_os_generator();
|
||||
}
|
||||
|
||||
SplitMix64State sm64 = {.seed = generate_random_number()};
|
||||
|
||||
return (WpXor256State){
|
||||
.x = split_mix_64(&sm64),
|
||||
.y = split_mix_64(&sm64),
|
||||
.z = split_mix_64(&sm64),
|
||||
.w = split_mix_64(&sm64),
|
||||
};
|
||||
}
|
||||
|
||||
u64 wpPrngXorshift256(WpXor256State *state) {
|
||||
u64 t = state->x ^ (state->x << 11);
|
||||
|
||||
state->x = state->y;
|
||||
state->y = state->z;
|
||||
state->z = state->w;
|
||||
state->w = (state->w ^ (state->w >> 19)) ^ (t ^ (t >> 8));
|
||||
|
||||
return state->w;
|
||||
}
|
||||
|
||||
u64 wpPrngXorshift256ss(WpXor256State *state) {
|
||||
const u64 result = rol64(state->z * 5, 7) * 9;
|
||||
const u64 t = state->z << 17;
|
||||
|
||||
state->y ^= state->w;
|
||||
state->x ^= state->z;
|
||||
state->z ^= state->y;
|
||||
state->w ^= state->x;
|
||||
|
||||
state->y ^= t;
|
||||
state->x = rol64(state->x, 45);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
u64 wpPrngXorshift256p(WpXor256State *state) {
|
||||
const u64 result = state->w + state->x;
|
||||
const u64 t = state->z << 17;
|
||||
|
||||
state->y ^= state->w;
|
||||
state->x ^= state->z;
|
||||
state->z ^= state->y;
|
||||
state->w ^= state->x;
|
||||
|
||||
state->y ^= t;
|
||||
state->x = rol64(state->x, 45);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
wp_intern u64 rol64(u64 x, u64 bits) {
|
||||
return (x << bits) | (x >> (64 - bits));
|
||||
}
|
||||
|
||||
wp_intern u64 split_mix_64(SplitMix64State *state) {
|
||||
state->seed += 0x9E3779B97f4A7C15;
|
||||
|
||||
u64 result = state->seed;
|
||||
result = (result ^ (result >> 30)) * 0xBF58476D1CE4E5B9;
|
||||
result = (result ^ (result >> 27)) * 0x94D049BB133111EB;
|
||||
|
||||
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) {
|
||||
struct timespec ts = {0};
|
||||
int result = clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
|
||||
wpRuntimeAssert(result == 0, "Invalid seed value");
|
||||
|
||||
srand48(ts.tv_nsec);
|
||||
}
|
||||
|
||||
wp_intern u64 generate_random_number(void) {
|
||||
return lrand48();
|
||||
}
|
||||
#else
|
||||
wp_intern void seed_os_generator(void) {
|
||||
struct timespec ts = {0};
|
||||
int result = timespec_get(&ts, TIME_UTC);
|
||||
wpRuntimeAssert(result != 0, "Invalid seed value");
|
||||
|
||||
srand(ts.tv_nsec);
|
||||
}
|
||||
|
||||
wp_intern u64 generate_random_number(void) {
|
||||
i32 n1 = rand();
|
||||
i32 n2 = rand();
|
||||
|
||||
return (((u64)n1) << 32 | (u64)n2);
|
||||
}
|
||||
#endif // !WP_PLATFORM_POSIX
|
||||
#else
|
||||
wp_intern void seed_os_generator(void) {
|
||||
time_t result = time(NULL);
|
||||
wpRuntimeAssert(result != (time_t)(-1), "Invalid seed value");
|
||||
|
||||
srand(result);
|
||||
}
|
||||
|
||||
wp_intern u64 generate_random_number(void) {
|
||||
i32 n1 = rand();
|
||||
i32 n2 = rand();
|
||||
|
||||
return (((u64)n1) << 32 | (u64)n2);
|
||||
}
|
||||
#endif // !WP_PLATFORM_C
|
||||
@@ -1,30 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef XORSHIFT_H
|
||||
#define XORSHIFT_H
|
||||
|
||||
#include "../../common/aliases/aliases.h"
|
||||
#include "../../common/platform/platform.h"
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
typedef struct WpXor256State WpXor256State;
|
||||
struct WpXor256State {
|
||||
u64 x;
|
||||
u64 y;
|
||||
u64 z;
|
||||
u64 w;
|
||||
};
|
||||
|
||||
WpXor256State wpPrngXorshiftInit(void);
|
||||
u64 wpPrngXorshift256(WpXor256State *state);
|
||||
u64 wpPrngXorshift256ss(WpXor256State *state);
|
||||
u64 wpPrngXorshift256p(WpXor256State *state);
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
END_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#endif // !XORSHIFT_H
|
||||
@@ -0,0 +1,52 @@
|
||||
#include "tester.h"
|
||||
#include "aliases.h"
|
||||
#include "termcolour.h"
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
internal void handle_test_result(TestFuncResult result);
|
||||
|
||||
void run_tests(TestFunc *func1, ...) {
|
||||
printf("\n");
|
||||
|
||||
handle_test_result(func1());
|
||||
|
||||
va_list args;
|
||||
va_start(args, func1);
|
||||
|
||||
TestFunc *func = va_arg(args, TestFunc *);
|
||||
|
||||
while (func) {
|
||||
TestFuncResult result = func();
|
||||
handle_test_result(result);
|
||||
|
||||
func = va_arg(args, TestFunc *);
|
||||
}
|
||||
|
||||
va_end(args);
|
||||
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
internal void handle_test_result(TestFuncResult result) {
|
||||
TerminalColour colour;
|
||||
const char *result_text;
|
||||
|
||||
if (result.passed) {
|
||||
colour = WAPP_TERM_COLOUR_FG_BR_GREEN;
|
||||
result_text = "PASSED";
|
||||
} else {
|
||||
colour = WAPP_TERM_COLOUR_FG_BR_RED;
|
||||
result_text = "FAILED";
|
||||
}
|
||||
|
||||
printf("[");
|
||||
wapp_shell_termcolour_print_text(result_text, colour);
|
||||
wapp_shell_termcolour_clear_colour();
|
||||
printf("] %s\n", result.name);
|
||||
|
||||
if (!result.passed) {
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
#ifndef TESTER_H
|
||||
#define TESTER_H
|
||||
|
||||
#include "misc_utils.h"
|
||||
#include "platform.h"
|
||||
#include <stdbool.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // __cplusplus
|
||||
|
||||
#define wapp_tester_result(PASSED) ((TestFuncResult){.name = __func__, .passed = PASSED})
|
||||
#define wapp_tester_run_tests(...) run_tests(__VA_ARGS__, NULL)
|
||||
|
||||
typedef struct test_func_result TestFuncResult;
|
||||
struct test_func_result {
|
||||
const char *name;
|
||||
bool passed;
|
||||
|
||||
#ifdef WAPP_PLATFORM_WINDOWS
|
||||
wapp_misc_utils_padding_size(sizeof(const char *) + sizeof(bool));
|
||||
#endif // WAPP_PLATFORM_WINDOWS
|
||||
};
|
||||
|
||||
typedef TestFuncResult(TestFunc)(void);
|
||||
|
||||
void run_tests(TestFunc *func1, ...);
|
||||
|
||||
#ifdef __cplusplus
|
||||
END_C_LINKAGE
|
||||
#endif // __cplusplus
|
||||
|
||||
#endif // !TESTER_H
|
||||
@@ -1,55 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#include "tester.h"
|
||||
#include "../../common/aliases/aliases.h"
|
||||
#include "../../os/shell/termcolour/termcolour.h"
|
||||
#include "../../base/strings/str8/str8.h"
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
wp_intern void handleTestResult(WpTestFuncResult result);
|
||||
|
||||
void _runTests(WpTestFunc *func1, ...) {
|
||||
printf("\n");
|
||||
|
||||
handleTestResult(func1());
|
||||
|
||||
va_list args;
|
||||
va_start(args, func1);
|
||||
|
||||
WpTestFunc *func = va_arg(args, WpTestFunc *);
|
||||
|
||||
while (func) {
|
||||
WpTestFuncResult result = func();
|
||||
handleTestResult(result);
|
||||
|
||||
func = va_arg(args, WpTestFunc *);
|
||||
}
|
||||
|
||||
va_end(args);
|
||||
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
wp_intern void handleTestResult(WpTestFuncResult result) {
|
||||
WpTerminalColour colour;
|
||||
WpStr8 result_text = wpStr8Buf(64);
|
||||
|
||||
if (result.passed) {
|
||||
colour = WP_TERM_COLOUR_FG_BR_GREEN;
|
||||
wpStr8CopyCstrCapped(&result_text, "PASSED");
|
||||
} else {
|
||||
colour = WP_TERM_COLOUR_FG_BR_RED;
|
||||
wpStr8CopyCstrCapped(&result_text, "FAILED");
|
||||
}
|
||||
|
||||
printf("[");
|
||||
wpShellTermcolourPrintText(&result_text, colour);
|
||||
wpShellTermcolourClearColour();
|
||||
printf("] " WP_STR8_SPEC "\n", wpStr8Varg(result.name));
|
||||
|
||||
if (!result.passed) {
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
}
|
||||
@@ -1,36 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef TESTER_H
|
||||
#define TESTER_H
|
||||
|
||||
#include "../../common/misc/misc_utils.h"
|
||||
#include "../../common/platform/platform.h"
|
||||
#include "../../base/strings/str8/str8.h"
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
BEGIN_C_LINKAGE
|
||||
|
||||
#define wpTesterResult(PASSED) (WpTestFuncResult{wpStr8LitRo(__func__), PASSED, {}})
|
||||
#else
|
||||
#define wpTesterResult(PASSED) ((WpTestFuncResult){.name = wpStr8LitRo(__func__), .passed = PASSED})
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#define wpTesterRun(...) _runTests(__VA_ARGS__, NULL)
|
||||
|
||||
typedef struct WpTestFuncResult WpTestFuncResult;
|
||||
struct WpTestFuncResult {
|
||||
WpStr8 name;
|
||||
b8 passed;
|
||||
|
||||
wpMiscUtilsReservePadding(sizeof(WpStr8) + sizeof(b8));
|
||||
};
|
||||
|
||||
typedef WpTestFuncResult(WpTestFunc)(void);
|
||||
|
||||
void _runTests(WpTestFunc *func1, ...);
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
END_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#endif // !TESTER_H
|
||||
@@ -1,10 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef WAPP_TESTING_C
|
||||
#define WAPP_TESTING_C
|
||||
|
||||
#include "wapp_testing.h"
|
||||
#include "tester/tester.c"
|
||||
#include "../os/wapp_os.c"
|
||||
|
||||
#endif // !WAPP_TESTING_C
|
||||
@@ -1,10 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef WAPP_TESTING_H
|
||||
#define WAPP_TESTING_H
|
||||
|
||||
#include "tester/tester.h"
|
||||
#include "../common/wapp_common.h"
|
||||
#include "../os/wapp_os.h"
|
||||
|
||||
#endif // !WAPP_TESTING_H
|
||||
@@ -1,58 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#include "uuid.h"
|
||||
#include "../common/aliases/aliases.h"
|
||||
#include "../common/assert/assert.h"
|
||||
#include "../base/strings/str8/str8.h"
|
||||
#include "../prng/xorshift/xorshift.h"
|
||||
#include <inttypes.h>
|
||||
|
||||
#define UUID_STR_FORMAT ("%.8" PRIx64 "-%.4" PRIx64 "-%.4" PRIx64 "-%.4" PRIx64 "-%.12" PRIx64)
|
||||
|
||||
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);
|
||||
|
||||
WpUuid *wpUuidInitUuid4(WpUuid *uuid) {
|
||||
wpDebugAssert(uuid != NULL, "`uuid` should not be NULL");
|
||||
|
||||
UUID4 uuid4 = generate_uuid4();
|
||||
uuid4_to_uuid(&uuid4, uuid);
|
||||
|
||||
return uuid;
|
||||
}
|
||||
|
||||
wp_intern UUID4 generate_uuid4(void) {
|
||||
wp_persist WpXor256State state = {0};
|
||||
wp_persist b8 initialised = false;
|
||||
|
||||
if (!initialised) {
|
||||
initialised = true;
|
||||
state = wpPrngXorshiftInit();
|
||||
}
|
||||
|
||||
UUID4 uuid = (UUID4){
|
||||
.high = wpPrngXorshift256(&state),
|
||||
.low = wpPrngXorshift256(&state),
|
||||
};
|
||||
|
||||
uuid.high = (uuid.high & 0xffffffffffff0fff) | 0x0000000000004000;
|
||||
uuid.low = (uuid.low & 0x3fffffffffffffff) | 0x8000000000000000;
|
||||
|
||||
return uuid;
|
||||
}
|
||||
|
||||
wp_intern void uuid4_to_uuid(const UUID4* uuid4, WpUuid *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);
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef UUID_H
|
||||
#define UUID_H
|
||||
|
||||
#include "../common/aliases/aliases.h"
|
||||
#include "../common/platform/platform.h"
|
||||
#include "../base/strings/str8/str8.h"
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#define WP_UUID_BUF_LENGTH 48
|
||||
#define WP_UUID_SPEC WP_STR8_SPEC
|
||||
#define wpUuidVarg(WpUuid) wpStr8Varg((WpUuid).uuid)
|
||||
|
||||
typedef struct WpUuid WpUuid;
|
||||
struct WpUuid {
|
||||
WpStr8 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
|
||||
|
||||
/* 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
|
||||
|
||||
// Just returns the same pointer that was passed in with the UUID initialised.
|
||||
// Fails when passed a NULL pointer.
|
||||
WpUuid *wpUuidInitUuid4(WpUuid *uuid);
|
||||
|
||||
#ifdef WP_PLATFORM_CPP
|
||||
END_C_LINKAGE
|
||||
#endif // !WP_PLATFORM_CPP
|
||||
|
||||
#endif // !UUID_H
|
||||
@@ -1,10 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef WAPP_UUID_C
|
||||
#define WAPP_UUID_C
|
||||
|
||||
#include "uuid.c"
|
||||
#include "../base/wapp_base.c"
|
||||
#include "../prng/wapp_prng.c"
|
||||
|
||||
#endif // !WAPP_UUID_C
|
||||
@@ -1,11 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef WAPP_UUID_H
|
||||
#define WAPP_UUID_H
|
||||
|
||||
#include "uuid.h"
|
||||
#include "../common/wapp_common.h"
|
||||
#include "../base/wapp_base.h"
|
||||
#include "../prng/wapp_prng.h"
|
||||
|
||||
#endif // !WAPP_UUID_H
|
||||
-14
@@ -1,14 +0,0 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef WAPP_C
|
||||
#define WAPP_C
|
||||
|
||||
#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 "testing/wapp_testing.c"
|
||||
|
||||
#endif // !WAPP_C
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user