commit 06e37e71447fac13a38ab591f4e374a03d32aa7b
parent c91e415ab6e930d482aed37866c7816c365ae23a
Author: lash <dev@holbrook.no>
Date: Fri, 28 Mar 2025 14:35:34 +0000
Add cwalk in aux with make
Diffstat:
79 files changed, 9838 insertions(+), 2 deletions(-)
diff --git a/src/aux/Makefile b/src/aux/Makefile
@@ -1,10 +1,16 @@
DESTDIR := `realpath .`
export DESTDIR
-install: hashmap
+install: cwalk hashmap
make DESTDIR=`realpath .` -C liblash install
install -m0644 -v hashmap.c/*.h -t $(DESTDIR)/include
+cwalk:
+ make -C cwalk all
+ install -vm0644 cwalk/build/usr/local/lib/*.so -t $(DESTDIR)/lib/
+ install -vm0644 cwalk/build/usr/local/lib/*.a -t $(DESTDIR)/lib/
+ install -vm0644 cwalk/build/usr/local/include/*.h -t $(DESTDIR)/include/
+
hashmap:
install -m0755 -v -d $(DESTDIR)/lib
$(CC) $(CFLAGS) -c hashmap.c/hashmap.c -o hashmap.c/hashmap.o
diff --git a/src/aux/cwalk/.clang-format b/src/aux/cwalk/.clang-format
@@ -0,0 +1,17 @@
+---
+BasedOnStyle: LLVM
+AlignAfterOpenBracket: DontAlign
+BinPackArguments: true
+BinPackParameters: true
+BreakBeforeBraces: Mozilla
+IndentWidth: 2
+ContinuationIndentWidth: 2
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowAllArgumentsOnNextLine: false
+AllowShortBlocksOnASingleLine: 'Never'
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: 'None'
+AllowShortIfStatementsOnASingleLine: 'false'
+AllowShortLoopsOnASingleLine: false
+PenaltyBreakAssignment: 10000
+PenaltyBreakBeforeFirstCallParameter: 100000
+\ No newline at end of file
diff --git a/src/aux/cwalk/.codecov.yml b/src/aux/cwalk/.codecov.yml
@@ -0,0 +1,2 @@
+ignore:
+ - "test"
+\ No newline at end of file
diff --git a/src/aux/cwalk/.github/workflows/build-freebsd.yml b/src/aux/cwalk/.github/workflows/build-freebsd.yml
@@ -0,0 +1,22 @@
+name: Build on FreeBSD
+on:
+ push:
+ branches: [ "**" ]
+ pull_request:
+ branches: [ "**" ]
+jobs:
+ build:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - name: build
+ id: test
+ uses: vmactions/freebsd-vm@v1
+ with:
+ usesh: true
+ prepare: |
+ pkg install -y cmake
+ run: |
+ cmake -B build -S ${{github.workspace}} -DENABLE_TESTS=1
+ cmake --build build
+ ctest --test-dir build
diff --git a/src/aux/cwalk/.github/workflows/build-linux.yml b/src/aux/cwalk/.github/workflows/build-linux.yml
@@ -0,0 +1,42 @@
+name: Build on Linux
+on:
+ push:
+ branches: [ "**" ]
+ pull_request:
+ branches: [ "**" ]
+jobs:
+ build:
+ runs-on: ${{ matrix.os }}
+ strategy:
+ fail-fast: false
+ matrix:
+ os: [ubuntu-22.04, ubuntu-20.04]
+ build_type: [Release]
+ c_compiler: [gcc, clang]
+ sanitizers: [address, OFF]
+ steps:
+ - uses: actions/checkout@v3
+ - name: Set reusable strings
+ id: strings
+ shell: bash
+ run: |
+ echo "build-output-dir=${{ github.workspace }}/build" >> "$GITHUB_OUTPUT"
+ - name: Configure CMake
+ run: >
+ cmake -B ${{ steps.strings.outputs.build-output-dir }}
+ -DCMAKE_CXX_COMPILER=${{ matrix.cpp_compiler }}
+ -DCMAKE_C_COMPILER=${{ matrix.c_compiler }}
+ -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
+ -DENABLE_TESTS=1
+ -DENABLE_COVERAGE=1
+ -DENABLE_SANITIZER=${{ matrix.sanitizers }}
+ -S ${{ github.workspace }}
+ - name: Build
+ run: cmake --build ${{ steps.strings.outputs.build-output-dir }} --config ${{ matrix.build_type }}
+ - name: Test
+ working-directory: ${{ steps.strings.outputs.build-output-dir }}
+ run: ctest --build-config ${{ matrix.build_type }}
+ - name: Coverage
+ if: ${{ matrix.c_compiler == 'gcc' && matrix.sanitizers == 'OFF' }}
+ working-directory: ${{ steps.strings.outputs.build-output-dir }}
+ run: bash <(curl -s https://codecov.io/bash)
diff --git a/src/aux/cwalk/.github/workflows/build-macos.yml b/src/aux/cwalk/.github/workflows/build-macos.yml
@@ -0,0 +1,35 @@
+name: Build on macOS
+on:
+ push:
+ branches: [ "**" ]
+ pull_request:
+ branches: [ "**" ]
+jobs:
+ build:
+ runs-on: ${{ matrix.os }}
+ strategy:
+ fail-fast: false
+ matrix:
+ os: [macos-12, macos-11]
+ build_type: [Release]
+ c_compiler: [gcc, clang]
+ steps:
+ - uses: actions/checkout@v3
+ - name: Set reusable strings
+ id: strings
+ shell: bash
+ run: |
+ echo "build-output-dir=${{ github.workspace }}/build" >> "$GITHUB_OUTPUT"
+ - name: Configure CMake
+ run: >
+ cmake -B ${{ steps.strings.outputs.build-output-dir }}
+ -DCMAKE_CXX_COMPILER=${{ matrix.cpp_compiler }}
+ -DCMAKE_C_COMPILER=${{ matrix.c_compiler }}
+ -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
+ -DENABLE_TESTS=1
+ -S ${{ github.workspace }}
+ - name: Build
+ run: cmake --build ${{ steps.strings.outputs.build-output-dir }} --config ${{ matrix.build_type }}
+ - name: Test
+ working-directory: ${{ steps.strings.outputs.build-output-dir }}
+ run: ctest --build-config ${{ matrix.build_type }}
diff --git a/src/aux/cwalk/.github/workflows/build-win.yml b/src/aux/cwalk/.github/workflows/build-win.yml
@@ -0,0 +1,36 @@
+name: Build on Windows
+on:
+ push:
+ branches: [ "**" ]
+ pull_request:
+ branches: [ "**" ]
+jobs:
+ build:
+ runs-on: ${{ matrix.os }}
+ strategy:
+ fail-fast: false
+ matrix:
+ os: [windows-2019, windows-2022]
+ build_type: [Release]
+ c_compiler: [cl]
+ steps:
+ - uses: actions/checkout@v3
+ - name: Set reusable strings
+ id: strings
+ shell: bash
+ run: |
+ echo "build-output-dir=${{ github.workspace }}/build" >> "$GITHUB_OUTPUT"
+ - name: Configure CMake
+ run: >
+ cmake -B ${{ steps.strings.outputs.build-output-dir }}
+ -DCMAKE_CXX_COMPILER=${{ matrix.cpp_compiler }}
+ -DCMAKE_C_COMPILER=${{ matrix.c_compiler }}
+ -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
+ -DCMAKE_C_FLAGS=/wd5105
+ -DENABLE_TESTS=1
+ -S ${{ github.workspace }}
+ - name: Build
+ run: cmake --build ${{ steps.strings.outputs.build-output-dir }} --config ${{ matrix.build_type }}
+ - name: Test
+ working-directory: ${{ steps.strings.outputs.build-output-dir }}
+ run: ctest --build-config ${{ matrix.build_type }}
diff --git a/src/aux/cwalk/.gitignore b/src/aux/cwalk/.gitignore
@@ -0,0 +1,12 @@
+src/constants.h
+test/tests.h
+.idea
+cmake-build-debug
+cmake-build-release
+build
+build.win
+builddir
+.vs
+.vscode
+docs/_site
+docs/.jekyll-cache
diff --git a/src/aux/cwalk/CMakeLists.txt b/src/aux/cwalk/CMakeLists.txt
@@ -0,0 +1,285 @@
+cmake_minimum_required(VERSION 3.9.2)
+
+# set project name
+project(cwalk
+ VERSION 1.2.9
+ DESCRIPTION "A simple path library"
+ HOMEPAGE_URL "https://likle.github.io/cwalk/"
+ LANGUAGES C)
+
+# include utilities
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+include(EnableWarnings)
+include(CTest)
+include(CreateTestList)
+include(CMakePackageConfigHelpers)
+include(GNUInstallDirs)
+
+# configure requirements
+set(CMAKE_C_STANDARD 11)
+
+# setup target and directory names
+set(INCLUDE_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include")
+set(SOURCE_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/src")
+set(TEST_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/test")
+
+# enable coverage if requested
+if(ENABLE_COVERAGE)
+ message("-- Coverage enabled")
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fprofile-arcs -ftest-coverage")
+ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
+endif()
+
+# enable sanitizer
+if(ENABLE_SANITIZER)
+ message("-- Sanitizer enabled")
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-omit-frame-pointer -fsanitize=${ENABLE_SANITIZER}")
+ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fno-omit-frame-pointer -fsanitize=${ENABLE_SANITIZER}")
+endif()
+
+# add the main executable
+add_library(cwalk
+ "${INCLUDE_DIRECTORY}/cwalk.h"
+ "${SOURCE_DIRECTORY}/cwalk.c")
+enable_warnings(cwalk)
+target_include_directories(cwalk PUBLIC
+ $<BUILD_INTERFACE:${INCLUDE_DIRECTORY}>
+ $<INSTALL_INTERFACE:include>
+)
+set_target_properties(cwalk PROPERTIES PUBLIC_HEADER "${INCLUDE_DIRECTORY}/cwalk.h")
+set_target_properties(cwalk PROPERTIES DEFINE_SYMBOL CWK_EXPORTS)
+
+# add shared library macro
+if(BUILD_SHARED_LIBS)
+ target_compile_definitions(cwalk PUBLIC CWK_SHARED)
+endif()
+
+# enable tests
+if(ENABLE_TESTS)
+ message("-- Tests enabled")
+ enable_testing()
+
+ create_test_list(DEFAULT cwalktest)
+ create_test(DEFAULT absolute simple)
+ create_test(DEFAULT absolute absolute_path)
+ create_test(DEFAULT absolute unix_relative_base)
+ create_test(DEFAULT absolute windows_relative_base)
+ create_test(DEFAULT absolute mixed)
+ create_test(DEFAULT absolute normalization)
+ create_test(DEFAULT absolute too_far)
+ create_test(DEFAULT absolute check)
+ create_test(DEFAULT absolute buffer_reuse)
+ create_test(DEFAULT basename simple)
+ create_test(DEFAULT basename empty)
+ create_test(DEFAULT basename trailing_separator)
+ create_test(DEFAULT basename trailing_separators)
+ create_test(DEFAULT basename no_separators)
+ create_test(DEFAULT basename special_directories)
+ create_test(DEFAULT basename root)
+ create_test(DEFAULT basename windows)
+ create_test(DEFAULT basename change_simple)
+ create_test(DEFAULT basename change_empty_path)
+ create_test(DEFAULT basename change_only_root)
+ create_test(DEFAULT basename change_empty_basename)
+ create_test(DEFAULT basename change_relative)
+ create_test(DEFAULT basename change_trim)
+ create_test(DEFAULT basename change_trim_only_root)
+ create_test(DEFAULT dirname simple)
+ create_test(DEFAULT dirname empty)
+ create_test(DEFAULT dirname trailing_separator)
+ create_test(DEFAULT dirname trailing_separators)
+ create_test(DEFAULT dirname no_separators)
+ create_test(DEFAULT dirname special_directories)
+ create_test(DEFAULT dirname root)
+ create_test(DEFAULT dirname three_segments)
+ create_test(DEFAULT dirname relative)
+ create_test(DEFAULT extension get_simple)
+ create_test(DEFAULT extension get_without)
+ create_test(DEFAULT extension get_first)
+ create_test(DEFAULT extension get_last)
+ create_test(DEFAULT extension get_multiple)
+ create_test(DEFAULT extension check_simple)
+ create_test(DEFAULT extension check_empty)
+ create_test(DEFAULT extension check_without)
+ create_test(DEFAULT extension change_simple)
+ create_test(DEFAULT extension change_no_basename)
+ create_test(DEFAULT extension change_no_extension)
+ create_test(DEFAULT extension change_with_dot)
+ create_test(DEFAULT extension change_overlap)
+ create_test(DEFAULT extension change_overlap_long)
+ create_test(DEFAULT extension change_hidden_file)
+ create_test(DEFAULT extension change_with_trailing_slash)
+ create_test(DEFAULT guess empty_string)
+ create_test(DEFAULT guess windows_root)
+ create_test(DEFAULT guess unix_root)
+ create_test(DEFAULT guess windows_separator)
+ create_test(DEFAULT guess unix_separator)
+ create_test(DEFAULT guess hidden_file)
+ create_test(DEFAULT guess extension)
+ create_test(DEFAULT guess unguessable)
+ create_test(DEFAULT intersection simple)
+ create_test(DEFAULT intersection trailing_separator)
+ create_test(DEFAULT intersection double_separator)
+ create_test(DEFAULT intersection empty)
+ create_test(DEFAULT intersection unequal_roots)
+ create_test(DEFAULT intersection relative_absolute_mix)
+ create_test(DEFAULT intersection same_roots)
+ create_test(DEFAULT intersection one_root_only)
+ create_test(DEFAULT intersection relative_base)
+ create_test(DEFAULT intersection relative_other)
+ create_test(DEFAULT intersection skipped_end)
+ create_test(DEFAULT is_absolute absolute)
+ create_test(DEFAULT is_absolute unc)
+ create_test(DEFAULT is_absolute device_unc)
+ create_test(DEFAULT is_absolute device_dot)
+ create_test(DEFAULT is_absolute device_question_mark)
+ create_test(DEFAULT is_absolute relative)
+ create_test(DEFAULT is_absolute windows_backslash)
+ create_test(DEFAULT is_absolute windows_slash)
+ create_test(DEFAULT is_absolute unix_backslash)
+ create_test(DEFAULT is_absolute unix_drive)
+ create_test(DEFAULT is_absolute absolute_drive)
+ create_test(DEFAULT is_absolute relative_drive)
+ create_test(DEFAULT is_absolute relative_windows)
+ create_test(DEFAULT is_absolute root)
+ create_test(DEFAULT is_absolute dir)
+ create_test(DEFAULT is_relative absolute)
+ create_test(DEFAULT is_relative unc)
+ create_test(DEFAULT is_relative device_unc)
+ create_test(DEFAULT is_relative device_dot)
+ create_test(DEFAULT is_relative device_question_mark)
+ create_test(DEFAULT is_relative relative)
+ create_test(DEFAULT is_relative windows_backslash)
+ create_test(DEFAULT is_relative windows_slash)
+ create_test(DEFAULT is_relative unix_backslash)
+ create_test(DEFAULT is_relative unix_drive)
+ create_test(DEFAULT is_relative absolute_drive)
+ create_test(DEFAULT is_relative relative_drive)
+ create_test(DEFAULT is_relative relative_windows)
+ create_test(DEFAULT join simple)
+ create_test(DEFAULT join navigate_back)
+ create_test(DEFAULT join empty)
+ create_test(DEFAULT join two_absolute)
+ create_test(DEFAULT join two_unc)
+ create_test(DEFAULT join with_two_roots)
+ create_test(DEFAULT join back_after_root)
+ create_test(DEFAULT join relative_back_after_root)
+ create_test(DEFAULT join multiple)
+ create_test(DEFAULT normalize do_nothing)
+ create_test(DEFAULT normalize navigate_back)
+ create_test(DEFAULT normalize relative_too_far)
+ create_test(DEFAULT normalize absolute_too_far)
+ create_test(DEFAULT normalize terminated)
+ create_test(DEFAULT normalize double_separator)
+ create_test(DEFAULT normalize remove_current)
+ create_test(DEFAULT normalize mixed)
+ create_test(DEFAULT normalize overlap)
+ create_test(DEFAULT normalize empty)
+ create_test(DEFAULT normalize only_separators)
+ create_test(DEFAULT normalize back_after_root)
+ create_test(DEFAULT normalize forward_slashes)
+ create_test(DEFAULT relative simple)
+ create_test(DEFAULT relative relative)
+ create_test(DEFAULT relative long_base)
+ create_test(DEFAULT relative long_target)
+ create_test(DEFAULT relative equal)
+ create_test(DEFAULT relative same_base)
+ create_test(DEFAULT relative base_skipped_end)
+ create_test(DEFAULT relative target_skipped_end)
+ create_test(DEFAULT relative base_div_skipped_end)
+ create_test(DEFAULT relative target_div_skipped_end)
+ create_test(DEFAULT relative skip_all)
+ create_test(DEFAULT relative different_roots)
+ create_test(DEFAULT relative relative_and_absolute)
+ create_test(DEFAULT relative check)
+ create_test(DEFAULT relative root_path_unix)
+ create_test(DEFAULT relative root_path_windows)
+ create_test(DEFAULT relative root_forward_slashes)
+ create_test(DEFAULT root absolute)
+ create_test(DEFAULT root unc)
+ create_test(DEFAULT root device_unc)
+ create_test(DEFAULT root device_dot)
+ create_test(DEFAULT root device_question_mark)
+ create_test(DEFAULT root relative)
+ create_test(DEFAULT root windows_backslash)
+ create_test(DEFAULT root windows_slash)
+ create_test(DEFAULT root unix_backslash)
+ create_test(DEFAULT root unix_drive)
+ create_test(DEFAULT root absolute_drive)
+ create_test(DEFAULT root relative_drive)
+ create_test(DEFAULT root relative_windows)
+ create_test(DEFAULT root change_simple)
+ create_test(DEFAULT root change_empty)
+ create_test(DEFAULT root change_separators)
+ create_test(DEFAULT root change_overlapping)
+ create_test(DEFAULT root change_without_root)
+ create_test(DEFAULT segment first)
+ create_test(DEFAULT segment last)
+ create_test(DEFAULT segment next)
+ create_test(DEFAULT segment next_too_far)
+ create_test(DEFAULT segment previous_absolute)
+ create_test(DEFAULT segment previous_relative)
+ create_test(DEFAULT segment previous_absolute_one_char_first)
+ create_test(DEFAULT segment previous_relative_one_char_first)
+ create_test(DEFAULT segment previous_too_far)
+ create_test(DEFAULT segment previous_too_far_root)
+ create_test(DEFAULT segment type)
+ create_test(DEFAULT segment back_with_root)
+ create_test(DEFAULT segment change_simple)
+ create_test(DEFAULT segment change_first)
+ create_test(DEFAULT segment change_last)
+ create_test(DEFAULT segment change_trim)
+ create_test(DEFAULT segment change_empty)
+ create_test(DEFAULT segment change_with_separator)
+ create_test(DEFAULT segment change_overlap)
+ create_test(DEFAULT windows change_style)
+ create_test(DEFAULT windows get_root)
+ create_test(DEFAULT windows get_unc_root)
+ create_test(DEFAULT windows get_root_separator)
+ create_test(DEFAULT windows get_root_relative)
+ create_test(DEFAULT windows intersection_case)
+ create_test(DEFAULT windows root_backslash)
+ create_test(DEFAULT windows root_empty)
+ write_test_file(DEFAULT "${TEST_DIRECTORY}/tests.h")
+
+ add_executable(cwalktest
+ "${TEST_DIRECTORY}/main.c"
+ "${TEST_DIRECTORY}/absolute_test.c"
+ "${TEST_DIRECTORY}/basename_test.c"
+ "${TEST_DIRECTORY}/dirname_test.c"
+ "${TEST_DIRECTORY}/extension_test.c"
+ "${TEST_DIRECTORY}/guess_test.c"
+ "${TEST_DIRECTORY}/intersection_test.c"
+ "${TEST_DIRECTORY}/is_absolute_test.c"
+ "${TEST_DIRECTORY}/is_relative_test.c"
+ "${TEST_DIRECTORY}/join_test.c"
+ "${TEST_DIRECTORY}/normalize_test.c"
+ "${TEST_DIRECTORY}/relative_test.c"
+ "${TEST_DIRECTORY}/root_test.c"
+ "${TEST_DIRECTORY}/segment_test.c"
+ "${TEST_DIRECTORY}/windows_test.c")
+ enable_warnings(cwalktest)
+
+ target_link_libraries(cwalktest PRIVATE cwalk)
+endif()
+
+write_basic_package_version_file("CwalkConfigVersion.cmake"
+ VERSION ${cwalk_VERSION}
+ COMPATIBILITY SameMajorVersion)
+
+configure_file(cwalk.pc.in ${PROJECT_BINARY_DIR}/cwalk.pc @ONLY)
+
+install(TARGETS cwalk
+ EXPORT CwalkTargets)
+
+install(FILES
+ "${CMAKE_CURRENT_SOURCE_DIR}/cmake/CwalkConfig.cmake"
+ DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/cwalk)
+
+install(FILES
+ ${PROJECT_BINARY_DIR}/cwalk.pc
+ DESTINATION lib/pkgconfig/)
+
+install(EXPORT CwalkTargets
+ FILE CwalkTargets.cmake
+ DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/cwalk)
diff --git a/src/aux/cwalk/CONTRIBUTING.md b/src/aux/cwalk/CONTRIBUTING.md
@@ -0,0 +1,30 @@
+# Contributing
+All your contributions to **cwalk** are very welcome! **cwalk** is especially happy to
+receive contributions like:
+
+ * general **bugfixes**
+ * simple **bug reports**
+ * **proposing new features**
+ * **questions** (there are no dumb questions)
+
+## License
+**Any contributions you make will be under the MIT Software License.**
+
+In short, when you submit code changes, your submissions are understood to be
+under the same MIT License that covers the project. Feel free to contact the
+maintainers if that's a concern.
+
+## How to report a bug?
+You can just use the issue tracker to do so.
+
+## How to propose a new feature?
+You can just use the issue tracker to do so.
+
+## How to submit a bug fix?
+Just submit a pull-request! Try to make sure that the code style fits the
+surrounding code.
+
+## How to submit a new feature?
+You probably want to create an issue first to discuss the change. All
+pull-requests will be considered though! Just try to make sure that the code
+style fits the surrounding code.
+\ No newline at end of file
diff --git a/src/aux/cwalk/LICENSE.md b/src/aux/cwalk/LICENSE.md
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Leonard Iklé
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/src/aux/cwalk/Makefile b/src/aux/cwalk/Makefile
@@ -0,0 +1,5 @@
+all:
+ mkdir -vp build
+ cd build && cmake -DBUILD_SHARED_LIBS=1 ..
+ cd build && make -j8
+ cd build && make install DESTDIR=.
diff --git a/src/aux/cwalk/README.md b/src/aux/cwalk/README.md
@@ -0,0 +1,36 @@
+<img style="width:100%;" src="/banner.png">
+
+[](https://github.com/likle/cwalk/actions/workflows/build-linux.yml)
+[](https://github.com/likle/cwalk/actions/workflows/build-freebsd.yml)
+[](https://github.com/likle/cwalk/actions/workflows/build-macos.yml)
+[](https://github.com/likle/cwalk/actions/workflows/build-win.yml)
+[](https://codecov.io/gh/likle/cwalk)
+
+# libcwalk - path library for C/C++
+This is a lighweight C path manipulation library. It is currently compiled and
+tested under **Linux**, **FreeBSD**, **Windows** and **MacOS**. It supports UNIX and Windows
+path styles on all platforms.
+
+## Features
+Please have a look at the
+**[reference](https://likle.github.io/cwalk/reference/)** for detailed
+information. Some features this library includes:
+
+ * **cross-platform** on Linux, FreeBSD, Windows and MacOS
+ * **simple interface** - just one header
+ * **combine paths** together
+ * **basename, dirname and extension** parsing
+ * **normalize and cleanup** paths
+ * **resolve and generate relative** paths
+ * **iterate segments** of the path
+ * **and more** things...
+
+ ## Building
+ **[Building](https://likle.github.io/cwalk/build.html)**,
+ **[embedding](https://likle.github.io/cwalk/embed.html)** and
+ **[testing](https://likle.github.io/cwalk/build.html)** instructions are
+ available in the documentation (it's very easy).
+
+ ## Docs
+ All the documentation is available in the
+ **[the github page](https://likle.github.io/cwalk/)** of this repository.
diff --git a/src/aux/cwalk/banner.png b/src/aux/cwalk/banner.png
Binary files differ.
diff --git a/src/aux/cwalk/banner.svg b/src/aux/cwalk/banner.svg
@@ -0,0 +1,874 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+ xmlns:dc="http://purl.org/dc/elements/1.1/"
+ xmlns:cc="http://creativecommons.org/ns#"
+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+ xmlns:svg="http://www.w3.org/2000/svg"
+ xmlns="http://www.w3.org/2000/svg"
+ xmlns:xlink="http://www.w3.org/1999/xlink"
+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+ width="1000"
+ height="250"
+ viewBox="0 0 264.58333 66.145833"
+ version="1.1"
+ id="svg8"
+ inkscape:version="0.92.3 (2405546, 2018-03-11)"
+ sodipodi:docname="banner.svg"
+ inkscape:export-filename="C:\Users\Leonard\Codes\cwalk\banner.png"
+ inkscape:export-xdpi="96"
+ inkscape:export-ydpi="96">
+ <defs
+ id="defs2">
+ <linearGradient
+ inkscape:collect="always"
+ id="linearGradient1735">
+ <stop
+ style="stop-color:#37c871;stop-opacity:1;"
+ offset="0"
+ id="stop1731" />
+ <stop
+ style="stop-color:#37c871;stop-opacity:0;"
+ offset="1"
+ id="stop1733" />
+ </linearGradient>
+ <linearGradient
+ inkscape:collect="always"
+ id="linearGradient1725">
+ <stop
+ style="stop-color:#37c871;stop-opacity:1;"
+ offset="0"
+ id="stop1721" />
+ <stop
+ style="stop-color:#37c871;stop-opacity:0;"
+ offset="1"
+ id="stop1723" />
+ </linearGradient>
+ <linearGradient
+ inkscape:collect="always"
+ id="linearGradient1715">
+ <stop
+ style="stop-color:#217844;stop-opacity:1;"
+ offset="0"
+ id="stop1711" />
+ <stop
+ style="stop-color:#217844;stop-opacity:0;"
+ offset="1"
+ id="stop1713" />
+ </linearGradient>
+ <inkscape:path-effect
+ effect="spiro"
+ id="path-effect1114"
+ is_visible="true" />
+ <inkscape:path-effect
+ effect="simplify"
+ id="path-effect1112"
+ is_visible="true"
+ steps="1"
+ threshold="0.00707113"
+ smooth_angles="360"
+ helper_size="0"
+ simplify_individual_paths="false"
+ simplify_just_coalesce="false"
+ simplifyindividualpaths="false"
+ simplifyJustCoalesce="false" />
+ <inkscape:path-effect
+ effect="spiro"
+ id="path-effect1106"
+ is_visible="true" />
+ <inkscape:path-effect
+ effect="simplify"
+ id="path-effect1104"
+ is_visible="true"
+ steps="1"
+ threshold="0.00707113"
+ smooth_angles="360"
+ helper_size="0"
+ simplify_individual_paths="false"
+ simplify_just_coalesce="false"
+ simplifyindividualpaths="false"
+ simplifyJustCoalesce="false" />
+ <inkscape:path-effect
+ effect="powerstroke"
+ id="path-effect1100"
+ is_visible="true"
+ offset_points="0,0.13229166"
+ sort_points="true"
+ interpolator_type="CubicBezierJohan"
+ interpolator_beta="0.2"
+ start_linecap_type="zerowidth"
+ linejoin_type="extrp_arc"
+ miter_limit="4"
+ end_linecap_type="zerowidth" />
+ <inkscape:path-effect
+ effect="spiro"
+ id="path-effect1098"
+ is_visible="true" />
+ <inkscape:path-effect
+ effect="simplify"
+ id="path-effect1096"
+ is_visible="true"
+ steps="1"
+ threshold="0.00707113"
+ smooth_angles="360"
+ helper_size="0"
+ simplify_individual_paths="false"
+ simplify_just_coalesce="false"
+ simplifyindividualpaths="false"
+ simplifyJustCoalesce="false" />
+ <inkscape:path-effect
+ is_visible="true"
+ id="path-effect1053"
+ effect="spiro" />
+ <inkscape:path-effect
+ simplifyJustCoalesce="false"
+ simplifyindividualpaths="false"
+ simplify_just_coalesce="false"
+ simplify_individual_paths="false"
+ helper_size="0"
+ smooth_angles="360"
+ threshold="0.00707113"
+ steps="1"
+ is_visible="true"
+ id="path-effect1051"
+ effect="simplify" />
+ <inkscape:path-effect
+ effect="powerstroke"
+ id="path-effect1046"
+ is_visible="true"
+ offset_points="0.02061853,3.6674234"
+ sort_points="true"
+ interpolator_type="CubicBezierJohan"
+ interpolator_beta="0.2"
+ start_linecap_type="zerowidth"
+ linejoin_type="extrp_arc"
+ miter_limit="4"
+ end_linecap_type="zerowidth" />
+ <inkscape:path-effect
+ effect="spiro"
+ id="path-effect1044"
+ is_visible="true" />
+ <inkscape:path-effect
+ effect="simplify"
+ id="path-effect1042"
+ is_visible="true"
+ steps="1"
+ threshold="0.00707113"
+ smooth_angles="360"
+ helper_size="0"
+ simplify_individual_paths="false"
+ simplify_just_coalesce="false"
+ simplifyindividualpaths="false"
+ simplifyJustCoalesce="false" />
+ <inkscape:path-effect
+ effect="powerstroke"
+ id="path-effect1022"
+ is_visible="true"
+ offset_points="0.044873473,2.9526656"
+ sort_points="true"
+ interpolator_type="CubicBezierJohan"
+ interpolator_beta="0.2"
+ start_linecap_type="zerowidth"
+ linejoin_type="extrp_arc"
+ miter_limit="4"
+ end_linecap_type="zerowidth" />
+ <inkscape:path-effect
+ effect="spiro"
+ id="path-effect1020"
+ is_visible="true" />
+ <inkscape:path-effect
+ effect="simplify"
+ id="path-effect1018"
+ is_visible="true"
+ steps="1"
+ threshold="0.00707113"
+ smooth_angles="360"
+ helper_size="0"
+ simplify_individual_paths="false"
+ simplify_just_coalesce="false"
+ simplifyindividualpaths="false"
+ simplifyJustCoalesce="false" />
+ <inkscape:path-effect
+ is_visible="true"
+ id="path-effect1005"
+ effect="spiro" />
+ <inkscape:path-effect
+ simplifyJustCoalesce="false"
+ simplifyindividualpaths="false"
+ simplify_just_coalesce="false"
+ simplify_individual_paths="false"
+ helper_size="0"
+ smooth_angles="360"
+ threshold="0.00707113"
+ steps="1"
+ is_visible="true"
+ id="path-effect1003"
+ effect="simplify" />
+ <inkscape:path-effect
+ is_visible="true"
+ id="path-effect999"
+ effect="spiro" />
+ <inkscape:path-effect
+ simplifyJustCoalesce="false"
+ simplifyindividualpaths="false"
+ simplify_just_coalesce="false"
+ simplify_individual_paths="false"
+ helper_size="0"
+ smooth_angles="360"
+ threshold="0.00707113"
+ steps="1"
+ is_visible="true"
+ id="path-effect997"
+ effect="simplify" />
+ <inkscape:path-effect
+ effect="powerstroke"
+ id="path-effect992"
+ is_visible="true"
+ offset_points="0,3.403562"
+ sort_points="true"
+ interpolator_type="CubicBezierJohan"
+ interpolator_beta="0.2"
+ start_linecap_type="zerowidth"
+ linejoin_type="extrp_arc"
+ miter_limit="4"
+ end_linecap_type="zerowidth" />
+ <inkscape:path-effect
+ effect="powerstroke"
+ id="path-effect988"
+ is_visible="true"
+ offset_points="5.733602,-3.0355079"
+ sort_points="true"
+ interpolator_type="CubicBezierJohan"
+ interpolator_beta="0.2"
+ start_linecap_type="zerowidth"
+ linejoin_type="extrp_arc"
+ miter_limit="4"
+ end_linecap_type="zerowidth" />
+ <inkscape:path-effect
+ effect="powerstroke"
+ id="path-effect984"
+ is_visible="true"
+ offset_points="0.024414269,2.8559392"
+ sort_points="true"
+ interpolator_type="CubicBezierJohan"
+ interpolator_beta="0.2"
+ start_linecap_type="zerowidth"
+ linejoin_type="extrp_arc"
+ miter_limit="4"
+ end_linecap_type="zerowidth" />
+ <inkscape:path-effect
+ effect="powerstroke"
+ id="path-effect980"
+ is_visible="true"
+ offset_points="0.0021265983,4.4764937"
+ sort_points="true"
+ interpolator_type="CubicBezierJohan"
+ interpolator_beta="0.2"
+ start_linecap_type="zerowidth"
+ linejoin_type="extrp_arc"
+ miter_limit="4"
+ end_linecap_type="zerowidth" />
+ <inkscape:path-effect
+ effect="powerstroke"
+ id="path-effect976"
+ is_visible="true"
+ offset_points="0,10"
+ sort_points="true"
+ interpolator_type="CubicBezierJohan"
+ interpolator_beta="0.2"
+ start_linecap_type="zerowidth"
+ linejoin_type="extrp_arc"
+ miter_limit="4"
+ end_linecap_type="zerowidth" />
+ <inkscape:path-effect
+ effect="powerstroke"
+ id="path-effect972"
+ is_visible="true"
+ offset_points="1.7295347,-1.6578583"
+ sort_points="true"
+ interpolator_type="CubicBezierJohan"
+ interpolator_beta="0.2"
+ start_linecap_type="zerowidth"
+ linejoin_type="extrp_arc"
+ miter_limit="4"
+ end_linecap_type="zerowidth" />
+ <inkscape:path-effect
+ effect="powerstroke"
+ id="path-effect968"
+ is_visible="true"
+ offset_points="0,10"
+ sort_points="true"
+ interpolator_type="CubicBezierJohan"
+ interpolator_beta="0.2"
+ start_linecap_type="zerowidth"
+ linejoin_type="extrp_arc"
+ miter_limit="4"
+ end_linecap_type="zerowidth" />
+ <inkscape:path-effect
+ effect="powerstroke"
+ id="path-effect964"
+ is_visible="true"
+ offset_points="1.7303179,2.227678"
+ sort_points="true"
+ interpolator_type="CubicBezierJohan"
+ interpolator_beta="0.2"
+ start_linecap_type="zerowidth"
+ linejoin_type="extrp_arc"
+ miter_limit="4"
+ end_linecap_type="zerowidth" />
+ <inkscape:path-effect
+ effect="powerstroke"
+ id="path-effect960"
+ is_visible="true"
+ offset_points="0.047006865,3.0257746"
+ sort_points="true"
+ interpolator_type="CubicBezierJohan"
+ interpolator_beta="0.2"
+ start_linecap_type="zerowidth"
+ linejoin_type="extrp_arc"
+ miter_limit="4"
+ end_linecap_type="zerowidth" />
+ <inkscape:path-effect
+ effect="powerstroke"
+ id="path-effect956"
+ is_visible="true"
+ offset_points="2,10"
+ sort_points="true"
+ interpolator_type="CubicBezierJohan"
+ interpolator_beta="0.2"
+ start_linecap_type="zerowidth"
+ linejoin_type="extrp_arc"
+ miter_limit="4"
+ end_linecap_type="zerowidth" />
+ <inkscape:path-effect
+ effect="powerstroke"
+ id="path-effect952"
+ is_visible="true"
+ offset_points="2,10"
+ sort_points="true"
+ interpolator_type="CubicBezierJohan"
+ interpolator_beta="0.2"
+ start_linecap_type="zerowidth"
+ linejoin_type="extrp_arc"
+ miter_limit="4"
+ end_linecap_type="zerowidth" />
+ <inkscape:path-effect
+ effect="powerstroke"
+ id="path-effect946"
+ is_visible="true"
+ offset_points="0,2.830761"
+ sort_points="true"
+ interpolator_type="CubicBezierJohan"
+ interpolator_beta="0.2"
+ start_linecap_type="zerowidth"
+ linejoin_type="extrp_arc"
+ miter_limit="4"
+ end_linecap_type="zerowidth" />
+ <inkscape:path-effect
+ effect="spiro"
+ id="path-effect944"
+ is_visible="true" />
+ <inkscape:path-effect
+ effect="simplify"
+ id="path-effect942"
+ is_visible="true"
+ steps="1"
+ threshold="0.00337705"
+ smooth_angles="360"
+ helper_size="0"
+ simplify_individual_paths="false"
+ simplify_just_coalesce="false"
+ simplifyindividualpaths="false"
+ simplifyJustCoalesce="false" />
+ <inkscape:path-effect
+ is_visible="true"
+ id="path-effect929"
+ effect="spiro" />
+ <inkscape:path-effect
+ simplifyJustCoalesce="false"
+ simplifyindividualpaths="false"
+ simplify_just_coalesce="false"
+ simplify_individual_paths="false"
+ helper_size="0"
+ smooth_angles="360"
+ threshold="0.00707113"
+ steps="1"
+ is_visible="true"
+ id="path-effect927"
+ effect="simplify" />
+ <inkscape:path-effect
+ effect="spiro"
+ id="path-effect923"
+ is_visible="true" />
+ <inkscape:path-effect
+ effect="simplify"
+ id="path-effect921"
+ is_visible="true"
+ steps="1"
+ threshold="0.00337705"
+ smooth_angles="360"
+ helper_size="0"
+ simplify_individual_paths="false"
+ simplify_just_coalesce="false"
+ simplifyindividualpaths="false"
+ simplifyJustCoalesce="false" />
+ <inkscape:path-effect
+ effect="spiro"
+ id="path-effect917"
+ is_visible="true" />
+ <inkscape:path-effect
+ effect="simplify"
+ id="path-effect915"
+ is_visible="true"
+ steps="1"
+ threshold="0.00337705"
+ smooth_angles="360"
+ helper_size="0"
+ simplify_individual_paths="false"
+ simplify_just_coalesce="false"
+ simplifyindividualpaths="false"
+ simplifyJustCoalesce="false" />
+ <inkscape:path-effect
+ effect="spiro"
+ id="path-effect911"
+ is_visible="true" />
+ <inkscape:path-effect
+ effect="simplify"
+ id="path-effect909"
+ is_visible="true"
+ steps="1"
+ threshold="0.00707113"
+ smooth_angles="360"
+ helper_size="0"
+ simplify_individual_paths="false"
+ simplify_just_coalesce="false"
+ simplifyindividualpaths="false"
+ simplifyJustCoalesce="false" />
+ <inkscape:path-effect
+ is_visible="true"
+ id="path-effect904"
+ effect="spiro" />
+ <inkscape:path-effect
+ simplifyJustCoalesce="false"
+ simplifyindividualpaths="false"
+ simplify_just_coalesce="false"
+ simplify_individual_paths="false"
+ helper_size="0"
+ smooth_angles="360"
+ threshold="0.00707113"
+ steps="1"
+ is_visible="true"
+ id="path-effect902"
+ effect="simplify" />
+ <inkscape:path-effect
+ effect="spiro"
+ id="path-effect898"
+ is_visible="true" />
+ <inkscape:path-effect
+ effect="simplify"
+ id="path-effect896"
+ is_visible="true"
+ steps="1"
+ threshold="0.00707113"
+ smooth_angles="360"
+ helper_size="0"
+ simplify_individual_paths="false"
+ simplify_just_coalesce="false"
+ simplifyindividualpaths="false"
+ simplifyJustCoalesce="false" />
+ <inkscape:path-effect
+ effect="spiro"
+ id="path-effect892"
+ is_visible="true" />
+ <inkscape:path-effect
+ effect="simplify"
+ id="path-effect890"
+ is_visible="true"
+ steps="1"
+ threshold="0.00707113"
+ smooth_angles="360"
+ helper_size="0"
+ simplify_individual_paths="false"
+ simplify_just_coalesce="false"
+ simplifyindividualpaths="false"
+ simplifyJustCoalesce="false" />
+ <inkscape:path-effect
+ effect="spiro"
+ id="path-effect886"
+ is_visible="true" />
+ <inkscape:path-effect
+ effect="simplify"
+ id="path-effect884"
+ is_visible="true"
+ steps="1"
+ threshold="0.00707113"
+ smooth_angles="360"
+ helper_size="0"
+ simplify_individual_paths="false"
+ simplify_just_coalesce="false"
+ simplifyindividualpaths="false"
+ simplifyJustCoalesce="false" />
+ <inkscape:path-effect
+ is_visible="true"
+ id="path-effect879"
+ effect="spiro" />
+ <inkscape:path-effect
+ simplifyJustCoalesce="false"
+ simplifyindividualpaths="false"
+ simplify_just_coalesce="false"
+ simplify_individual_paths="false"
+ helper_size="0"
+ smooth_angles="360"
+ threshold="0.00707113"
+ steps="1"
+ is_visible="true"
+ id="path-effect877"
+ effect="simplify" />
+ <inkscape:path-effect
+ effect="spiro"
+ id="path-effect873"
+ is_visible="true" />
+ <inkscape:path-effect
+ effect="simplify"
+ id="path-effect871"
+ is_visible="true"
+ steps="1"
+ threshold="0.00707113"
+ smooth_angles="360"
+ helper_size="0"
+ simplify_individual_paths="false"
+ simplify_just_coalesce="false"
+ simplifyindividualpaths="false"
+ simplifyJustCoalesce="false" />
+ <inkscape:path-effect
+ effect="spiro"
+ id="path-effect861"
+ is_visible="true" />
+ <inkscape:path-effect
+ effect="simplify"
+ id="path-effect859"
+ is_visible="true"
+ steps="1"
+ threshold="0.00707113"
+ smooth_angles="360"
+ helper_size="0"
+ simplify_individual_paths="false"
+ simplify_just_coalesce="false"
+ simplifyindividualpaths="false"
+ simplifyJustCoalesce="false" />
+ <inkscape:path-effect
+ effect="spiro"
+ id="path-effect855"
+ is_visible="true" />
+ <inkscape:path-effect
+ effect="simplify"
+ id="path-effect853"
+ is_visible="true"
+ steps="1"
+ threshold="0.00707113"
+ smooth_angles="360"
+ helper_size="0"
+ simplify_individual_paths="false"
+ simplify_just_coalesce="false"
+ simplifyindividualpaths="false"
+ simplifyJustCoalesce="false" />
+ <inkscape:path-effect
+ effect="spiro"
+ id="path-effect849"
+ is_visible="true" />
+ <inkscape:path-effect
+ effect="simplify"
+ id="path-effect847"
+ is_visible="true"
+ steps="1"
+ threshold="0.00707113"
+ smooth_angles="360"
+ helper_size="0"
+ simplify_individual_paths="false"
+ simplify_just_coalesce="false"
+ simplifyindividualpaths="false"
+ simplifyJustCoalesce="false" />
+ <inkscape:path-effect
+ effect="spiro"
+ id="path-effect843"
+ is_visible="true" />
+ <inkscape:path-effect
+ effect="simplify"
+ id="path-effect841"
+ is_visible="true"
+ steps="1"
+ threshold="0.00707113"
+ smooth_angles="360"
+ helper_size="0"
+ simplify_individual_paths="false"
+ simplify_just_coalesce="false"
+ simplifyindividualpaths="false"
+ simplifyJustCoalesce="false" />
+ <inkscape:path-effect
+ effect="spiro"
+ id="path-effect837"
+ is_visible="true" />
+ <inkscape:path-effect
+ effect="simplify"
+ id="path-effect835"
+ is_visible="true"
+ steps="1"
+ threshold="0.00707113"
+ smooth_angles="360"
+ helper_size="0"
+ simplify_individual_paths="false"
+ simplify_just_coalesce="false"
+ simplifyindividualpaths="false"
+ simplifyJustCoalesce="false" />
+ <inkscape:path-effect
+ effect="spiro"
+ id="path-effect831"
+ is_visible="true" />
+ <inkscape:path-effect
+ effect="simplify"
+ id="path-effect829"
+ is_visible="true"
+ steps="1"
+ threshold="0.00707113"
+ smooth_angles="360"
+ helper_size="0"
+ simplify_individual_paths="false"
+ simplify_just_coalesce="false"
+ simplifyindividualpaths="false"
+ simplifyJustCoalesce="false" />
+ <linearGradient
+ inkscape:collect="always"
+ xlink:href="#linearGradient1715"
+ id="linearGradient1717"
+ x1="133.10023"
+ y1="262.58905"
+ x2="139.32178"
+ y2="286.24243"
+ gradientUnits="userSpaceOnUse"
+ gradientTransform="translate(-0.13363476,0.40090429)" />
+ <linearGradient
+ inkscape:collect="always"
+ xlink:href="#linearGradient1725"
+ id="linearGradient1727"
+ x1="32.316963"
+ y1="280.55804"
+ x2="22.111607"
+ y2="293.9762"
+ gradientUnits="userSpaceOnUse" />
+ <linearGradient
+ inkscape:collect="always"
+ xlink:href="#linearGradient1735"
+ id="linearGradient1737"
+ x1="170.84523"
+ y1="267.32886"
+ x2="191.44495"
+ y2="279.04614"
+ gradientUnits="userSpaceOnUse" />
+ <linearGradient
+ inkscape:collect="always"
+ xlink:href="#linearGradient1735"
+ id="linearGradient1747"
+ x1="220.17114"
+ y1="275.07736"
+ x2="238.69197"
+ y2="290.7634"
+ gradientUnits="userSpaceOnUse" />
+ <linearGradient
+ inkscape:collect="always"
+ xlink:href="#linearGradient1735"
+ id="linearGradient1759"
+ gradientUnits="userSpaceOnUse"
+ x1="29.800552"
+ y1="267.53354"
+ x2="20.245667"
+ y2="271.94348" />
+ <linearGradient
+ inkscape:collect="always"
+ xlink:href="#linearGradient1735"
+ id="linearGradient1771"
+ gradientUnits="userSpaceOnUse"
+ x1="101.56242"
+ y1="263.32407"
+ x2="99.891983"
+ y2="269.20398" />
+ </defs>
+ <sodipodi:namedview
+ id="base"
+ pagecolor="#ffffff"
+ bordercolor="#666666"
+ borderopacity="1.0"
+ inkscape:pageopacity="0.0"
+ inkscape:pageshadow="2"
+ inkscape:zoom="0.98994949"
+ inkscape:cx="563.6607"
+ inkscape:cy="49.289126"
+ inkscape:document-units="mm"
+ inkscape:current-layer="layer1"
+ showgrid="false"
+ units="px"
+ width="1000px"
+ inkscape:snap-global="false"
+ inkscape:snap-bbox="true"
+ inkscape:snap-page="true"
+ inkscape:window-width="1600"
+ inkscape:window-height="847"
+ inkscape:window-x="-8"
+ inkscape:window-y="-8"
+ inkscape:window-maximized="1" />
+ <metadata
+ id="metadata5">
+ <rdf:RDF>
+ <cc:Work
+ rdf:about="">
+ <dc:format>image/svg+xml</dc:format>
+ <dc:type
+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+ <dc:title></dc:title>
+ </cc:Work>
+ </rdf:RDF>
+ </metadata>
+ <g
+ inkscape:label="Layer 1"
+ inkscape:groupmode="layer"
+ id="layer1"
+ transform="translate(0,-230.85417)">
+ <rect
+ style="opacity:1;fill:#d5f6ff;fill-opacity:1;stroke:none;stroke-width:20;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:normal"
+ id="rect1060"
+ width="264.58334"
+ height="66.145836"
+ x="0"
+ y="230.85417" />
+ <circle
+ r="29.628252"
+ cy="264.79401"
+ cx="111.0505"
+ id="circle1081"
+ style="opacity:1;fill:#ffe680;fill-opacity:0.19607843;stroke:none;stroke-width:38.89661026;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:normal" />
+ <circle
+ style="opacity:1;fill:#ffe680;fill-opacity:0.19607843;stroke:none;stroke-width:33.68634796;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:normal"
+ id="circle1775"
+ cx="111.0505"
+ cy="264.79401"
+ r="25.659502" />
+ <circle
+ style="opacity:1;fill:#ffe680;fill-opacity:1;stroke:none;stroke-width:26.4912281;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:normal"
+ id="path1067"
+ cx="111.0505"
+ cy="264.79401"
+ r="20.178848" />
+ <path
+ style="fill:#aaffcc;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:0.99999994px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+ d="M 152.04688 31.642578 C 113.22311 31.525841 76.032837 47.379942 40.855469 64.09375 C 27.150545 70.605365 13.532817 77.299981 0 84.162109 L 0 171.82031 L 636.22266 250 L 996.20703 250 C 962.13136 232.38114 924.56891 221.47896 889.13867 206.3125 C 824.77904 178.76237 765.74356 136.40936 697.00977 123.11133 C 651.7256 114.35013 605.03695 118.83865 559.19727 123.95117 C 513.35758 129.06369 466.96169 134.76786 421.28516 128.35938 C 375.24785 121.90027 331.75483 103.35079 290.52344 81.876953 C 269.07104 70.70427 248.02256 58.674898 225.80859 49.105469 C 203.59463 39.536039 179.98529 32.425326 155.80859 31.703125 C 154.55283 31.665613 153.29925 31.646344 152.04688 31.642578 z "
+ transform="matrix(0.26458333,0,0,0.26458333,0,230.85417)"
+ id="path833" />
+ <path
+ style="opacity:1;fill:#d5ffe6;fill-opacity:1;stroke:none;stroke-width:3.77952766;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:normal"
+ d="M 152.04688 31.642578 C 150.71467 31.638572 149.38498 31.656459 148.05664 31.689453 C 157.99413 54.877868 203.8084 135.75946 194.45312 145.44922 L 224.25391 141.91406 C 224.62512 131.57505 179.1284 55.348352 158.27539 31.816406 C 157.45308 31.777128 156.63226 31.727729 155.80859 31.703125 C 154.55283 31.665613 153.29924 31.646344 152.04688 31.642578 z "
+ transform="matrix(0.26458333,0,0,0.26458333,0,230.85417)"
+ id="path1779" />
+ <path
+ style="fill:#80ffb3;fill-rule:evenodd;stroke:none;stroke-width:0.99999994px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+ d="M 402.25781 120.0918 C 398.81967 120.06453 395.37155 120.19007 391.91992 120.47852 C 366.72686 122.58386 343.07296 133.10175 318.39062 138.57031 C 289.08359 145.0635 258.62259 144.35916 228.77539 141.16406 C 195.30031 137.58058 162.07239 130.90629 128.41016 130.38086 C 84.272134 129.6919 40.236986 139.76619 0 157.99805 L 0 239.64453 L 79.587891 250 L 588.75586 250 C 585.78955 246.78656 582.84644 243.55497 579.92969 240.31055 C 552.98948 210.34384 527.12525 178.84961 494.75586 154.84961 C 467.86012 134.90801 435.49319 120.3554 402.25781 120.0918 z "
+ transform="matrix(0.26458333,0,0,0.26458333,0,230.85417)"
+ id="path839" />
+ <path
+ style="fill:#d5ffe6;fill-rule:evenodd;stroke:none;stroke-width:0.99999994px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+ d="M 220.67383 140.23438 C 220.69645 140.5497 220.72373 140.86491 220.76562 141.17773 C 221.17291 144.21915 222.40727 147.07567 223.31836 150.00586 C 225.03432 155.52462 225.61018 161.3955 225 167.14258 C 225.80582 167.53714 226.64557 167.86125 227.50781 168.10938 C 230.62754 169.00712 233.94554 168.895 237.17578 168.57227 C 240.40602 168.24953 243.63194 167.72228 246.87695 167.81445 C 250.83593 167.92691 254.739 168.95962 258.69922 168.90625 C 260.67933 168.87957 262.67821 168.57421 264.49023 167.77539 C 266.30226 166.97657 267.92175 165.65782 268.87109 163.91992 C 269.74669 162.31704 270.01749 160.42556 269.82422 158.60938 C 269.45315 155.12248 267.47213 152.01323 265.22852 149.31836 C 263.55141 147.30394 261.693 145.42821 260.0625 143.38281 C 249.60898 143.0719 239.15494 142.27518 228.77539 141.16406 C 226.07314 140.87479 223.37322 140.55906 220.67383 140.23438 z "
+ transform="matrix(0.26458333,0,0,0.26458333,0,230.85417)"
+ id="path894" />
+ <path
+ style="fill:#55ff99;fill-rule:evenodd;stroke:none;stroke-width:0.99999994px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;opacity:0.99"
+ d="m 958.31641,144.00643 c -19.65771,-0.15764 -28.45981,6.53953 -96.42057,12.08982 -111.97115,-7.41017 -135.9315,-26.2555 -205.66272,-26.46226 -93.13254,0.97941 -116.14473,24.59859 -230.49679,24.02226 -47.00462,-0.14837 -94.18114,3.00302 -141.15235,5.55078 -46.85681,2.54158 -93.8962,4.4921 -140.13086,12.51563 C 98.218479,179.74618 52.469773,194.10969 13.132812,219.69531 8.6578098,222.60595 4.2833725,225.66991 0,228.85547 V 250 H 446.88086 1000 v -98.15958 c -4.86627,-2.07903 -9.94307,-3.68365 -15.10156,-4.875 -8.7651,-2.02431 -17.64671,-2.88733 -26.58203,-2.95899 z"
+ transform="matrix(0.26458333,0,0,0.26458333,0,230.85417)"
+ id="path851"
+ inkscape:connector-curvature="0"
+ sodipodi:nodetypes="scccssscccccss" />
+ <path
+ style="opacity:1;fill:url(#linearGradient1717);fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:normal"
+ d="m 132.96659,279.89475 7.62275,7.05972 13.51054,-0.84374 -11.64522,-6.08235 z"
+ id="path1709"
+ inkscape:connector-curvature="0"
+ sodipodi:nodetypes="ccccc" />
+ <path
+ style="fill:#d5ffe6;fill-rule:evenodd;stroke:none;stroke-width:0.99999994px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+ d="M 338.51367 156.24609 C 320.52095 157.17835 302.53758 158.23321 284.58398 159.20703 C 280.67469 159.41908 276.76087 159.63413 272.84961 159.8418 C 274.58361 161.33262 276.63728 162.45945 278.75977 163.33594 C 281.52242 164.47678 284.42428 165.23364 287.27539 166.13086 C 303.67675 171.2922 318.21387 180.97074 332.625 190.34961 C 347.65654 200.13225 362.83144 209.72719 378.62305 218.22852 C 400.06115 229.7696 422.57097 239.2574 445.57031 247.24609 C 448.27682 248.18618 450.99234 249.10158 453.71289 250 L 700.14648 250 C 692.65099 243.44984 682.95691 237.68449 670.7207 235.18164 C 634.26681 227.72519 632.52444 228.03944 613.14258 226.36914 C 593.22662 224.65281 573.31639 222.73723 553.55078 219.75195 C 538.33408 217.45372 523.21936 214.52285 508.0293 212.05469 C 491.01079 209.28943 473.89646 207.10451 456.94922 203.93164 C 426.24849 198.18384 395.97549 189.12064 368.32617 174.5918 C 357.98878 169.15983 348.06185 162.9736 338.51367 156.24609 z "
+ transform="matrix(0.26458333,0,0,0.26458333,0,230.85417)"
+ id="path869" />
+ <text
+ xml:space="preserve"
+ style="font-style:normal;font-weight:normal;font-size:3.70416665px;line-height:125%;font-family:Pacifico;-inkscape-font-specification:Pacifico;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+ x="261.41824"
+ y="250.22784"
+ id="text1122"><tspan
+ sodipodi:role="line"
+ id="tspan1120"
+ x="261.41824"
+ y="250.22784"
+ style="font-style:normal;font-variant:normal;font-weight:900;font-stretch:normal;font-size:22.57777786px;font-family:'Montserrat Alternates';-inkscape-font-specification:'Montserrat Alternates Heavy';text-align:end;text-anchor:end;fill:#216778;stroke-width:0.26458332px"><tspan
+ style="fill:#55ff99;fill-opacity:1"
+ id="tspan1784"><tspan
+ style="fill:#37c871;fill-opacity:1"
+ id="tspan1786">c</tspan>walk</tspan></tspan></text>
+ <path
+ style="opacity:1;fill:#37c871;fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:normal"
+ d="m 24.321527,286.84376 4.625731,-8.012 4.633571,8.02558 z"
+ id="path1697"
+ inkscape:connector-curvature="0" />
+ <path
+ style="opacity:1;fill:#37c871;fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:normal"
+ d="m 171.8543,274.28209 6.18395,-10.71091 6.00093,10.39391 z"
+ id="path1699"
+ inkscape:connector-curvature="0" />
+ <path
+ style="opacity:1;fill:#37c871;fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:normal"
+ d="m 98.622455,265.72947 2.039045,-3.53173 2.18642,3.78701 z"
+ id="path1701"
+ inkscape:connector-curvature="0" />
+ <path
+ style="opacity:1;fill:#37c871;fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:normal"
+ d="m 24.588796,269.73851 1.807581,-3.13082 2.11961,3.67127 z"
+ id="path1703"
+ inkscape:connector-curvature="0" />
+ <path
+ style="opacity:1;fill:#37c871;fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:normal"
+ d="m 219.16101,283.10199 6.44642,-11.16553 6.6488,11.51606 z"
+ id="path1707"
+ inkscape:connector-curvature="0" />
+ <path
+ style="opacity:1;fill:#37c871;fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:normal"
+ d="m 133.10022,280.42929 5.58739,-9.67764 4.75761,9.71743 z"
+ id="path1705"
+ inkscape:connector-curvature="0"
+ sodipodi:nodetypes="cccc" />
+ <path
+ style="opacity:1;fill:url(#linearGradient1727);fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:normal"
+ d="m 24.75744,286.22768 -11.339285,4.34673 13.418154,3.96875 6.614583,-8.12649 z"
+ id="path1719"
+ inkscape:connector-curvature="0" />
+ <path
+ style="opacity:1;fill:url(#linearGradient1737);fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:normal"
+ d="m 172.00111,274.1439 15.28609,5.84718 c 0,0 14.93006,-2.26786 13.79613,-2.07888 -1.13393,0.18899 -17.95387,-4.34672 -17.95387,-4.34672 z"
+ id="path1729"
+ inkscape:connector-curvature="0"
+ sodipodi:nodetypes="ccccc" />
+ <path
+ style="opacity:1;fill:url(#linearGradient1747);fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:normal"
+ d="m 219.17894,283.06214 26.69457,9.21316 2.83482,-7.37053 -17.76488,-2.26786 z"
+ id="path1739"
+ inkscape:connector-curvature="0"
+ sodipodi:nodetypes="ccccc" />
+ <path
+ style="opacity:1;fill:url(#linearGradient1759);fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:normal"
+ d="m 25.123335,269.27079 -8.285355,1.60362 1.002261,2.80633 10.557146,-3.60814 z"
+ id="path1749"
+ inkscape:connector-curvature="0" />
+ <path
+ style="opacity:1;fill:url(#linearGradient1771);fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:normal"
+ d="m 98.689273,265.66265 -0.935445,4.07586 3.207232,0.40091 1.73726,-4.27632 z"
+ id="path1761"
+ inkscape:connector-curvature="0" />
+ </g>
+</svg>
diff --git a/src/aux/cwalk/clib.json b/src/aux/cwalk/clib.json
@@ -0,0 +1,10 @@
+{
+ "name": "cwalk",
+ "repo": "likle/cwalk",
+ "version": "v1.2.9",
+ "decription": "libcwalk - path library for C/C++",
+ "src": [
+ "src/cwalk.c",
+ "include/cwalk.h"
+ ]
+}
diff --git a/src/aux/cwalk/cmake/CreateTestList.cmake b/src/aux/cwalk/cmake/CreateTestList.cmake
@@ -0,0 +1,15 @@
+function(create_test_list list_name target)
+ set("TEST_LIST_TARGET_${list_name}" ${target} PARENT_SCOPE)
+endfunction()
+
+function(write_test_file list_name file)
+ set("TEST_LIST_FILE_${list_name}" ${file} PARENT_SCOPE)
+ file(WRITE ${file} "#define UNIT_TESTS(XX) \\\n")
+ file(APPEND ${file} ${TEST_LIST_CONTENT_${list_name}})
+ file(APPEND ${file} "\n")
+endfunction()
+
+function(create_test list_name unit_name test_name)
+ set(TEST_LIST_CONTENT_${list_name} "${TEST_LIST_CONTENT_${list_name}} XX(${unit_name},${test_name}) \\\n" PARENT_SCOPE)
+ add_test(NAME "${unit_name}_${test_name}" COMMAND ${TEST_LIST_TARGET_${list_name}} ${unit_name} ${test_name})
+endfunction()
diff --git a/src/aux/cwalk/cmake/CwalkConfig.cmake b/src/aux/cwalk/cmake/CwalkConfig.cmake
@@ -0,0 +1 @@
+include("${CMAKE_CURRENT_LIST_DIR}/CwalkTargets.cmake")
diff --git a/src/aux/cwalk/cmake/EnableWarnings.cmake b/src/aux/cwalk/cmake/EnableWarnings.cmake
@@ -0,0 +1,25 @@
+# enable warnings
+function(enable_warnings target)
+ if(MSVC)
+ target_compile_definitions(${target} PRIVATE _CRT_SECURE_NO_WARNINGS)
+ target_compile_options(${target} PRIVATE /W4)
+ if (NOT IGNORE_WARNINGS)
+ target_compile_options(${target} PRIVATE /WX)
+ endif()
+ elseif("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
+ target_compile_options(${target} PRIVATE -Wall)
+ target_compile_options(${target} PRIVATE -Wextra)
+ target_compile_options(${target} PRIVATE -Wpedantic)
+ target_compile_options(${target} PRIVATE -Wno-gnu-zero-variadic-macro-arguments)
+ if (NOT IGNORE_WARNINGS)
+ target_compile_options(${target} PRIVATE -Werror)
+ endif()
+ elseif("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU")
+ target_compile_options(${target} PRIVATE -Wall)
+ target_compile_options(${target} PRIVATE -Wextra)
+ target_compile_options(${target} PRIVATE -Wpedantic)
+ if (NOT IGNORE_WARNINGS)
+ target_compile_options(${target} PRIVATE -Werror)
+ endif()
+ endif()
+endfunction()
diff --git a/src/aux/cwalk/cwalk.pc.in b/src/aux/cwalk/cwalk.pc.in
@@ -0,0 +1,11 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+
+Name: @PROJECT_NAME@
+Description: @CMAKE_PROJECT_DESCRIPTION@
+URL: @CMAKE_PROJECT_HOMEPAGE_URL@
+Version: @PROJECT_VERSION@
+Cflags: -I"${includedir}"
+Libs: -L"${libdir}" -lcwalk
diff --git a/src/aux/cwalk/docs/_config.yml b/src/aux/cwalk/docs/_config.yml
@@ -0,0 +1,6 @@
+defaults:
+ -
+ scope:
+ path: "" # an empty string here means all files in the project
+ values:
+ layout: "default"
+\ No newline at end of file
diff --git a/src/aux/cwalk/docs/_layouts/default.html b/src/aux/cwalk/docs/_layouts/default.html
@@ -0,0 +1,42 @@
+<!doctype html>
+<html>
+ <head>
+ <meta charset="utf-8">
+ <title>{{ page.title }} - cwalk</title>
+ <meta name="description" content="{{ page.description }}" />
+ <meta name="viewport" content="width=device-width, initial-scale=1">
+ <link href="https://fonts.googleapis.com/css?family=Ubuntu+Mono" rel="stylesheet">
+ <link href="{{ site.baseurl }}/assets/css/default.css?v4" rel="stylesheet" type="text/css">
+ <link href="{{ site.baseurl }}/assets/css/monakai.css" rel="stylesheet" type="text/css">
+ <link rel="shortcut icon" href="{{ site.baseurl }}/assets/img/favicon.png">
+ <script async src="https://www.googletagmanager.com/gtag/js?id=UA-127837944-1"></script>
+ <script>
+ window.dataLayer = window.dataLayer || [];
+ function gtag(){dataLayer.push(arguments);}
+ gtag('js', new Date());
+
+ gtag('config', 'UA-127837944-1');
+ </script>
+ </head>
+ <body>
+ <header>
+ <div class="inner">
+ <a href="{{ site.baseurl }}{% link index.md %}" class="logo">cwalk</a>
+ <nav>
+ <a href="{{ site.baseurl }}{% link build.md %}">build</a>
+ <a href="{{ site.baseurl }}{% link embed.md %}">embed</a>
+ <a href="{{ site.baseurl }}{% link reference/index.md %}">reference</a>
+ </nav>
+ </div>
+ </header>
+ <div class="main">
+ <div class="content">
+ <h1>{{ page.title }}</h1>
+ {{ content }}
+ </div>
+ </div>
+ </body>
+ <footer>
+ find this repository on <a href="https://github.com/likle/cwalk/tree/master">github</a>
+ </footer>
+</html>
diff --git a/src/aux/cwalk/docs/assets/css/default.css b/src/aux/cwalk/docs/assets/css/default.css
@@ -0,0 +1,126 @@
+html,
+body {
+ height: 100%;
+}
+
+body {
+ font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, Cantarell, "Fira Sans", "Droid Sans", "Helvetica Neue", Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
+ margin: auto;
+ padding: 20px;
+ background: #FAFAFA;
+ padding: 0;
+ display: flex;
+ flex-flow: column;
+}
+
+header {
+ text-align: right;
+ margin-bottom: 20px;
+ padding: 20px 20px;
+ font-family: 'Ubuntu Mono';
+ background: #55FF99;
+ color: #D5FFE6;
+ border-bottom: 10px solid #37C871;
+}
+
+header .inner {
+ max-width: 800px;
+ margin: auto;
+}
+
+header .logo {
+ float: left;
+ vertical-align: middle;
+ display: inline-block;
+ font-weight: bold;
+ font-size: 32pt;
+ padding: 0;
+ margin-left: 10px;
+ line-height: 50px;
+}
+
+header nav {
+ line-height: 50px;
+}
+
+header a {
+ padding: 10px;
+ text-decoration: none;
+ font-weight: bold;
+ font-size: 18pt;
+ overflow: auto;
+ color: #078e3d;;
+}
+
+.main {
+ flex: 1;
+}
+
+footer {
+ text-align: center;
+ margin-top: 50px;
+ padding: 40px 20px;
+ font-family: 'Ubuntu Mono';
+ background: #49483e;
+ color: #e6db74;
+}
+
+
+a {
+ color: #37C871;
+}
+
+h1, h2 {
+ font-family: 'Ubuntu Mono';
+ padding-bottom: 5px;
+ border-bottom: 1px solid rgba(255,255,255,.2);
+}
+
+.content {
+ color: #49483e;
+ padding-top: 20px;
+ max-width: 800px;
+ margin: auto;
+}
+
+.highlight {
+ padding: 10px;
+ margin: 0;
+ overflow: auto;
+ white-space: pre-wrap;
+}
+
+.highlighter-rouge {
+ background: rgba(0,0,0,0.1);
+}
+
+table {
+ border-collapse: collapse;
+}
+
+table td,
+table th {
+ border: 1px solid #DDDDDD;
+ background: #ffffff;
+ padding: 5px 8px;
+}
+
+table tr:nth-child(even) td {
+ background: #f8f9fb;
+}
+
+@media (max-width: 1000px) {
+ header {
+ text-align: center;
+ }
+
+ header .logo {
+ display: block;
+ float: none;
+ margin-bottom: 10px;
+ }
+
+ .content {
+ padding: 0 20px;
+ }
+}
diff --git a/src/aux/cwalk/docs/assets/css/github.css b/src/aux/cwalk/docs/assets/css/github.css
@@ -0,0 +1,209 @@
+.highlight table td { padding: 5px; }
+.highlight table pre { margin: 0; }
+.highlight .cm {
+ color: #999988;
+ font-style: italic;
+}
+.highlight .cp {
+ color: #999999;
+ font-weight: bold;
+}
+.highlight .c1 {
+ color: #999988;
+ font-style: italic;
+}
+.highlight .cs {
+ color: #999999;
+ font-weight: bold;
+ font-style: italic;
+}
+.highlight .c, .highlight .cd {
+ color: #999988;
+ font-style: italic;
+}
+.highlight .err {
+ color: #a61717;
+ background-color: #e3d2d2;
+}
+.highlight .gd {
+ color: #000000;
+ background-color: #ffdddd;
+}
+.highlight .ge {
+ color: #000000;
+ font-style: italic;
+}
+.highlight .gr {
+ color: #aa0000;
+}
+.highlight .gh {
+ color: #999999;
+}
+.highlight .gi {
+ color: #000000;
+ background-color: #ddffdd;
+}
+.highlight .go {
+ color: #888888;
+}
+.highlight .gp {
+ color: #555555;
+}
+.highlight .gs {
+ font-weight: bold;
+}
+.highlight .gu {
+ color: #aaaaaa;
+}
+.highlight .gt {
+ color: #aa0000;
+}
+.highlight .kc {
+ color: #000000;
+ font-weight: bold;
+}
+.highlight .kd {
+ color: #000000;
+ font-weight: bold;
+}
+.highlight .kn {
+ color: #000000;
+ font-weight: bold;
+}
+.highlight .kp {
+ color: #000000;
+ font-weight: bold;
+}
+.highlight .kr {
+ color: #000000;
+ font-weight: bold;
+}
+.highlight .kt {
+ color: #445588;
+ font-weight: bold;
+}
+.highlight .k, .highlight .kv {
+ color: #000000;
+ font-weight: bold;
+}
+.highlight .mf {
+ color: #009999;
+}
+.highlight .mh {
+ color: #009999;
+}
+.highlight .il {
+ color: #009999;
+}
+.highlight .mi {
+ color: #009999;
+}
+.highlight .mo {
+ color: #009999;
+}
+.highlight .m, .highlight .mb, .highlight .mx {
+ color: #009999;
+}
+.highlight .sb {
+ color: #d14;
+}
+.highlight .sc {
+ color: #d14;
+}
+.highlight .sd {
+ color: #d14;
+}
+.highlight .s2 {
+ color: #d14;
+}
+.highlight .se {
+ color: #d14;
+}
+.highlight .sh {
+ color: #d14;
+}
+.highlight .si {
+ color: #d14;
+}
+.highlight .sx {
+ color: #d14;
+}
+.highlight .sr {
+ color: #009926;
+}
+.highlight .s1 {
+ color: #d14;
+}
+.highlight .ss {
+ color: #990073;
+}
+.highlight .s {
+ color: #d14;
+}
+.highlight .na {
+ color: #008080;
+}
+.highlight .bp {
+ color: #999999;
+}
+.highlight .nb {
+ color: #0086B3;
+}
+.highlight .nc {
+ color: #445588;
+ font-weight: bold;
+}
+.highlight .no {
+ color: #008080;
+}
+.highlight .nd {
+ color: #3c5d5d;
+ font-weight: bold;
+}
+.highlight .ni {
+ color: #800080;
+}
+.highlight .ne {
+ color: #990000;
+ font-weight: bold;
+}
+.highlight .nf {
+ color: #990000;
+ font-weight: bold;
+}
+.highlight .nl {
+ color: #990000;
+ font-weight: bold;
+}
+.highlight .nn {
+ color: #555555;
+}
+.highlight .nt {
+ color: #000080;
+}
+.highlight .vc {
+ color: #008080;
+}
+.highlight .vg {
+ color: #008080;
+}
+.highlight .vi {
+ color: #008080;
+}
+.highlight .nv {
+ color: #008080;
+}
+.highlight .ow {
+ color: #000000;
+ font-weight: bold;
+}
+.highlight .o {
+ color: #000000;
+ font-weight: bold;
+}
+.highlight .w {
+ color: #bbbbbb;
+}
+.highlight {
+ background-color: #f8f8f8;
+}
diff --git a/src/aux/cwalk/docs/assets/css/monakai.css b/src/aux/cwalk/docs/assets/css/monakai.css
@@ -0,0 +1,210 @@
+.highlight table td { padding: 5px; }
+.highlight table pre { margin: 0; }
+.highlight .c, .highlight .cd {
+ color: #75715e;
+ font-style: italic;
+}
+.highlight .cm {
+ color: #75715e;
+ font-style: italic;
+}
+.highlight .c1 {
+ color: #75715e;
+ font-style: italic;
+}
+.highlight .cp {
+ color: #75715e;
+ font-weight: bold;
+}
+.highlight .cs {
+ color: #75715e;
+ font-weight: bold;
+ font-style: italic;
+}
+.highlight .err {
+ color: #960050;
+ background-color: #1e0010;
+}
+.highlight .gi {
+ color: #ffffff;
+ background-color: #324932;
+}
+.highlight .gd {
+ color: #ffffff;
+ background-color: #493131;
+}
+.highlight .ge {
+ color: #000000;
+ font-style: italic;
+}
+.highlight .gr {
+ color: #aa0000;
+}
+.highlight .gt {
+ color: #aa0000;
+}
+.highlight .gh {
+ color: #999999;
+}
+.highlight .go {
+ color: #888888;
+}
+.highlight .gp {
+ color: #555555;
+}
+.highlight .gs {
+ font-weight: bold;
+}
+.highlight .gu {
+ color: #aaaaaa;
+}
+.highlight .k, .highlight .kv {
+ color: #66d9ef;
+ font-weight: bold;
+}
+.highlight .kc {
+ color: #66d9ef;
+ font-weight: bold;
+}
+.highlight .kd {
+ color: #66d9ef;
+ font-weight: bold;
+}
+.highlight .kp {
+ color: #66d9ef;
+ font-weight: bold;
+}
+.highlight .kr {
+ color: #66d9ef;
+ font-weight: bold;
+}
+.highlight .kt {
+ color: #66d9ef;
+ font-weight: bold;
+}
+.highlight .kn {
+ color: #f92672;
+ font-weight: bold;
+}
+.highlight .ow {
+ color: #f92672;
+ font-weight: bold;
+}
+.highlight .o {
+ color: #f92672;
+ font-weight: bold;
+}
+.highlight .mf {
+ color: #ae81ff;
+}
+.highlight .mh {
+ color: #ae81ff;
+}
+.highlight .il {
+ color: #ae81ff;
+}
+.highlight .mi {
+ color: #ae81ff;
+}
+.highlight .mo {
+ color: #ae81ff;
+}
+.highlight .m, .highlight .mb, .highlight .mx {
+ color: #ae81ff;
+}
+.highlight .se {
+ color: #ae81ff;
+}
+.highlight .sb {
+ color: #e6db74;
+}
+.highlight .sc {
+ color: #e6db74;
+}
+.highlight .sd {
+ color: #e6db74;
+}
+.highlight .s2 {
+ color: #e6db74;
+}
+.highlight .sh {
+ color: #e6db74;
+}
+.highlight .si {
+ color: #e6db74;
+}
+.highlight .sx {
+ color: #e6db74;
+}
+.highlight .sr {
+ color: #e6db74;
+}
+.highlight .s1 {
+ color: #e6db74;
+}
+.highlight .ss {
+ color: #e6db74;
+}
+.highlight .s {
+ color: #e6db74;
+}
+.highlight .na {
+ color: #a6e22e;
+}
+.highlight .nc {
+ color: #a6e22e;
+ font-weight: bold;
+}
+.highlight .nd {
+ color: #a6e22e;
+ font-weight: bold;
+}
+.highlight .ne {
+ color: #a6e22e;
+ font-weight: bold;
+}
+.highlight .nf {
+ color: #a6e22e;
+ font-weight: bold;
+}
+.highlight .no {
+ color: #66d9ef;
+}
+.highlight .bp {
+ color: #f8f8f2;
+}
+.highlight .nb {
+ color: #f8f8f2;
+}
+.highlight .ni {
+ color: #f8f8f2;
+}
+.highlight .nn {
+ color: #f8f8f2;
+}
+.highlight .vc {
+ color: #f8f8f2;
+}
+.highlight .vg {
+ color: #f8f8f2;
+}
+.highlight .vi {
+ color: #f8f8f2;
+}
+.highlight .nv {
+ color: #f8f8f2;
+}
+.highlight .w {
+ color: #f8f8f2;
+}
+.highlight .nl {
+ color: #f8f8f2;
+ font-weight: bold;
+}
+.highlight .nt {
+ color: #f92672;
+}
+.highlight {
+ color: #f8f8f2;
+ background-color: #49483e;
+}
diff --git a/src/aux/cwalk/docs/assets/css/trac.css b/src/aux/cwalk/docs/assets/css/trac.css
@@ -0,0 +1,210 @@
+.highlight table td { padding: 5px; }
+.highlight table pre { margin: 0; }
+.highlight .c, .highlight .cd {
+ color: #75715e;
+ font-style: italic;
+}
+.highlight .cm {
+ color: #75715e;
+ font-style: italic;
+}
+.highlight .c1 {
+ color: #75715e;
+ font-style: italic;
+}
+.highlight .cp {
+ color: #75715e;
+ font-weight: bold;
+}
+.highlight .cs {
+ color: #75715e;
+ font-weight: bold;
+ font-style: italic;
+}
+.highlight .err {
+ color: #960050;
+ background-color: #1e0010;
+}
+.highlight .gi {
+ color: #ffffff;
+ background-color: #324932;
+}
+.highlight .gd {
+ color: #ffffff;
+ background-color: #493131;
+}
+.highlight .ge {
+ color: #000000;
+ font-style: italic;
+}
+.highlight .gr {
+ color: #aa0000;
+}
+.highlight .gt {
+ color: #aa0000;
+}
+.highlight .gh {
+ color: #999999;
+}
+.highlight .go {
+ color: #888888;
+}
+.highlight .gp {
+ color: #555555;
+}
+.highlight .gs {
+ font-weight: bold;
+}
+.highlight .gu {
+ color: #aaaaaa;
+}
+.highlight .k, .highlight .kv {
+ color: #66d9ef;
+ font-weight: bold;
+}
+.highlight .kc {
+ color: #66d9ef;
+ font-weight: bold;
+}
+.highlight .kd {
+ color: #66d9ef;
+ font-weight: bold;
+}
+.highlight .kp {
+ color: #66d9ef;
+ font-weight: bold;
+}
+.highlight .kr {
+ color: #66d9ef;
+ font-weight: bold;
+}
+.highlight .kt {
+ color: #66d9ef;
+ font-weight: bold;
+}
+.highlight .kn {
+ color: #f92672;
+ font-weight: bold;
+}
+.highlight .ow {
+ color: #f92672;
+ font-weight: bold;
+}
+.highlight .o {
+ color: #f92672;
+ font-weight: bold;
+}
+.highlight .mf {
+ color: #ae81ff;
+}
+.highlight .mh {
+ color: #ae81ff;
+}
+.highlight .il {
+ color: #ae81ff;
+}
+.highlight .mi {
+ color: #ae81ff;
+}
+.highlight .mo {
+ color: #ae81ff;
+}
+.highlight .m, .highlight .mb, .highlight .mx {
+ color: #ae81ff;
+}
+.highlight .se {
+ color: #ae81ff;
+}
+.highlight .sb {
+ color: #e6db74;
+}
+.highlight .sc {
+ color: #e6db74;
+}
+.highlight .sd {
+ color: #e6db74;
+}
+.highlight .s2 {
+ color: #e6db74;
+}
+.highlight .sh {
+ color: #e6db74;
+}
+.highlight .si {
+ color: #e6db74;
+}
+.highlight .sx {
+ color: #e6db74;
+}
+.highlight .sr {
+ color: #e6db74;
+}
+.highlight .s1 {
+ color: #e6db74;
+}
+.highlight .ss {
+ color: #e6db74;
+}
+.highlight .s {
+ color: #e6db74;
+}
+.highlight .na {
+ color: #a6e22e;
+}
+.highlight .nc {
+ color: #a6e22e;
+ font-weight: bold;
+}
+.highlight .nd {
+ color: #a6e22e;
+ font-weight: bold;
+}
+.highlight .ne {
+ color: #a6e22e;
+ font-weight: bold;
+}
+.highlight .nf {
+ color: #a6e22e;
+ font-weight: bold;
+}
+.highlight .no {
+ color: #66d9ef;
+}
+.highlight .bp {
+ color: #f8f8f2;
+}
+.highlight .nb {
+ color: #f8f8f2;
+}
+.highlight .ni {
+ color: #f8f8f2;
+}
+.highlight .nn {
+ color: #f8f8f2;
+}
+.highlight .vc {
+ color: #f8f8f2;
+}
+.highlight .vg {
+ color: #f8f8f2;
+}
+.highlight .vi {
+ color: #f8f8f2;
+}
+.highlight .nv {
+ color: #f8f8f2;
+}
+.highlight .w {
+ color: #f8f8f2;
+}
+.highlight .nl {
+ color: #f8f8f2;
+ font-weight: bold;
+}
+.highlight .nt {
+ color: #f92672;
+}
+.highlight {
+ color: #f8f8f2;
+ background-color: #49483e;
+}
diff --git a/src/aux/cwalk/docs/assets/css/vim.css b/src/aux/cwalk/docs/assets/css/vim.css
@@ -0,0 +1 @@
+unknown theme: vim
diff --git a/src/aux/cwalk/docs/assets/img/favicon.png b/src/aux/cwalk/docs/assets/img/favicon.png
Binary files differ.
diff --git a/src/aux/cwalk/docs/assets/img/favicon.svg b/src/aux/cwalk/docs/assets/img/favicon.svg
@@ -0,0 +1,125 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+ xmlns:dc="http://purl.org/dc/elements/1.1/"
+ xmlns:cc="http://creativecommons.org/ns#"
+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+ xmlns:svg="http://www.w3.org/2000/svg"
+ xmlns="http://www.w3.org/2000/svg"
+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+ width="48"
+ height="48"
+ viewBox="0 0 12.7 12.7"
+ version="1.1"
+ id="svg8"
+ inkscape:version="0.92.3 (2405546, 2018-03-11)"
+ sodipodi:docname="favicon.svg">
+ <defs
+ id="defs2">
+ <inkscape:path-effect
+ effect="powerstroke"
+ id="path-effect845"
+ is_visible="true"
+ offset_points="0,0.13229166"
+ sort_points="true"
+ interpolator_type="CubicBezierJohan"
+ interpolator_beta="0.2"
+ start_linecap_type="zerowidth"
+ linejoin_type="extrp_arc"
+ miter_limit="4"
+ end_linecap_type="zerowidth" />
+ <inkscape:path-effect
+ effect="spiro"
+ id="path-effect843"
+ is_visible="true" />
+ <inkscape:path-effect
+ effect="simplify"
+ id="path-effect841"
+ is_visible="true"
+ steps="1"
+ threshold="0.00707113"
+ smooth_angles="360"
+ helper_size="0"
+ simplify_individual_paths="false"
+ simplify_just_coalesce="false"
+ simplifyindividualpaths="false"
+ simplifyJustCoalesce="false" />
+ <inkscape:path-effect
+ effect="spiro"
+ id="path-effect837"
+ is_visible="true" />
+ <inkscape:path-effect
+ effect="simplify"
+ id="path-effect835"
+ is_visible="true"
+ steps="1"
+ threshold="0.00707113"
+ smooth_angles="360"
+ helper_size="0"
+ simplify_individual_paths="false"
+ simplify_just_coalesce="false"
+ simplifyindividualpaths="false"
+ simplifyJustCoalesce="false" />
+ </defs>
+ <sodipodi:namedview
+ id="base"
+ pagecolor="#ffffff"
+ bordercolor="#666666"
+ borderopacity="1.0"
+ inkscape:pageopacity="0.0"
+ inkscape:pageshadow="2"
+ inkscape:zoom="7.9195959"
+ inkscape:cx="40.669189"
+ inkscape:cy="15.472538"
+ inkscape:document-units="mm"
+ inkscape:current-layer="layer1"
+ showgrid="false"
+ units="px"
+ inkscape:window-width="1600"
+ inkscape:window-height="847"
+ inkscape:window-x="-8"
+ inkscape:window-y="-8"
+ inkscape:window-maximized="1" />
+ <metadata
+ id="metadata5">
+ <rdf:RDF>
+ <cc:Work
+ rdf:about="">
+ <dc:format>image/svg+xml</dc:format>
+ <dc:type
+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+ <dc:title></dc:title>
+ </cc:Work>
+ </rdf:RDF>
+ </metadata>
+ <g
+ inkscape:label="Layer 1"
+ inkscape:groupmode="layer"
+ id="layer1"
+ transform="translate(0,-284.3)">
+ <circle
+ style="opacity:0.98999999;fill:#646464;fill-opacity:1;stroke:none;stroke-width:0.99925655;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:normal"
+ id="path815"
+ cx="6.3499999"
+ cy="290.64999"
+ r="6.3499999" />
+ <path
+ style="opacity:0.98999999;fill:#464646;fill-opacity:1;stroke:none;stroke-width:11.34266472;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:normal"
+ d="M 45.214844 12.810547 C 39.930389 15.838245 31.937362 19.593748 21.265625 22.328125 C 13.923958 24.209271 11.586387 22.779846 5.6914062 16.884766 C 4.3495394 15.542904 2.7438777 15.778452 1.0644531 16.9375 A 24 24 0 0 0 0 24 A 24 24 0 0 0 4.546875 38.005859 C 7.0755777 33.407331 11.162743 28.341891 15.195312 34.054688 C 19.611697 40.311272 36.484577 25.785901 46.623047 16.070312 A 24 24 0 0 0 45.214844 12.810547 z "
+ transform="matrix(0.26458333,0,0,0.26458333,0,284.3)"
+ id="path821" />
+ <text
+ xml:space="preserve"
+ style="font-style:normal;font-weight:normal;font-size:3.70416665px;line-height:125%;font-family:Pacifico;-inkscape-font-specification:Pacifico;letter-spacing:0px;word-spacing:0px;fill:#f6b27f;fill-opacity:1;stroke:#f6b27f;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+ x="2.915477"
+ y="294.59277"
+ id="text819"><tspan
+ sodipodi:role="line"
+ id="tspan817"
+ x="2.915477"
+ y="294.59277"
+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.69999981px;font-family:'Ubuntu Mono';-inkscape-font-specification:'Ubuntu Mono Bold';fill:#f6b27f;fill-opacity:1;stroke:#f6b27f;stroke-width:0.26458332px;stroke-opacity:1">C</tspan></text>
+ </g>
+</svg>
diff --git a/src/aux/cwalk/docs/build.md b/src/aux/cwalk/docs/build.md
@@ -0,0 +1,53 @@
+---
+title: Building
+description: A guide on how to build the cwalk path library for C/C++.
+---
+
+In order to build the source, you will have to download it. You can do so using git (or download it from [here](https://github.com/likle/cwalk/archive/stable.zip)).
+```bash
+git clone -b stable git@github.com:likle/cwalk.git
+```
+
+**Note**: The *stable* branch points to the latest stable version. You should
+always use a stable version in production code.
+
+## Using Windows
+Visual Studio 2017 is recommended, then you can just open the source using ``File -> Open -> CMake...``. You can use Visual Studio to compile the source and debug the code. Make sure you have the CMake and C/C++ features enabled.
+
+## Using Ubuntu
+You will need [CMake](https://cmake.org/download/) and either gcc or clang installed. On Ubuntu you can use the following to compile **cwalk**:
+```bash
+sudo apt-get install build-essential cmake
+mkdir cwalk/build
+cd cwalk/build
+cmake ..
+make
+```
+
+## Using MacOS
+You will need [CMake](https://cmake.org/download/) and either gcc or clang installed. On MacOS you can use the following to compile **cwalk**:
+```
+brew install cmake gcc
+mkdir cwalk/build
+cd cwalk/build
+cmake ..
+make
+```
+# Running Tests
+In order to run tests, cwalk needs to be built with tests enabled. There is a ``ENABLE_TESTS`` flag for that. It can be passed to the cmake command like this:
+```
+cmake .. -DENABLE_TESTS=1
+```
+
+After building **cwalk** you can run tests to ensure everything is fine. In order to do that, make sure that you are in the build folder and then execute the test program:
+```bash
+./cwalktest
+```
+
+That's it!
+
+You can even specify which tests to execute by optionally specifying the category and test name:
+```bash
+# ./cwalktest [category] [test]
+./cwalktest normalize mixed
+```
diff --git a/src/aux/cwalk/docs/embed.md b/src/aux/cwalk/docs/embed.md
@@ -0,0 +1,47 @@
+---
+title: Embedding
+description: A guide on how to embed the cwalk path library for C/C++.
+---
+
+
+In order to embed **cwalk**, you will have to download it.
+You can do so using git (or download it from [here](https://github.com/likle/cwalk/archive/stable.zip)).
+
+```bash
+git clone -b stable git@github.com:likle/cwalk.git
+```
+**Note**: The *stable* branch points to the latest stable version. You should
+always use a stable version in production code.
+
+## Using CMake to embed cwalk
+If you are using CMake it is fairly easy to embed **cwalk**.
+This only requires two lines, you don't even have to specify the include directories.
+The following example shows how to do so:
+```cmake
+# Some basics you will need in your cmake file.
+cmake_minimum_required(VERSION 3.9.2)
+project(example C)
+add_executable(example_target main.c)
+
+# Replace your_path_to_cwalk with the path to your cwalk copy.
+# This could be something like "${CMAKE_CURRENT_SOURCE_DIR}/lib/cwalk".
+add_subdirectory(your_path_to_cwalk)
+
+# Replace example_target with the target name which requires cwalk.
+# After this, there is no need to specify any include directories.
+target_link_libraries(example_target cwalk)
+```
+
+After that, you should be able to use cwalk in your source code:
+```c
+#include <cwalk.h>
+```
+
+## Directly embed cwalk in your source
+If you don't use CMake and would like to embed **cwalk** directly, you could
+just add the two files ``src/cwalk.c`` and ``ìnclude/cwalk.h`` to your project.
+The folder containing ``cwalk.h`` has to be in your include directories
+([Visual Studio](https://docs.microsoft.com/en-us/cpp/ide/vcpp-directories-property-page?view=vs-2017),
+[Eclipse](https://help.eclipse.org/mars/index.jsp?topic=%2Forg.eclipse.cdt.doc.user%2Freference%2Fcdt_u_prop_general_pns_inc.htm),
+[gcc](https://www.rapidtables.com/code/linux/gcc/gcc-i.html),
+[clang](https://clang.llvm.org/docs/ClangCommandLineReference.html#include-path-management)).
+\ No newline at end of file
diff --git a/src/aux/cwalk/docs/index.md b/src/aux/cwalk/docs/index.md
@@ -0,0 +1,33 @@
+---
+title: C/C++ Path Library - Cross-Platform
+description: cwalk is a lightweight C/C++ Path Library which focuses on file path manipulations. Using cwalk you can easily do things like combine paths, resolve relative paths, create relative paths based on absolute paths, canonicalize paths or read extension information from paths.
+---
+
+## What is cwalk?
+**cwalk** is a lightweight C/C++ library which focuses on file path manipulations. Using **cwalk** you can easily do things like combine paths, resolve relative paths, create relative paths based on absolute paths, canonicalize paths or read extension information from paths.
+
+## Example
+Here is a simple example of one thing (normalization) cwalk can do for you. However, there are more features available.
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ char result[FILENAME_MAX];
+
+ // The following function cleans up the input path and writes it
+ // to the result buffer.
+ cwk_path_normalize( "/var/log/weird/////path/.././..///", result,
+ sizeof(result));
+
+ printf("%s\n", result);
+ return EXIT_SUCCESS;
+}
+```
+
+Output:
+```
+/var/log
+```
+\ No newline at end of file
diff --git a/src/aux/cwalk/docs/reference/cwk_path_change_basename.md b/src/aux/cwalk/docs/reference/cwk_path_change_basename.md
@@ -0,0 +1,69 @@
+---
+title: cwk_path_change_basename
+description: Changes the basename of a file path.
+---
+
+_(since v1.2.0)_
+Changes the basename of a file path.
+
+## Description
+```c
+size_t cwk_path_change_basename(const char *path, const char *new_basename,
+ char *buffer, size_t buffer_size);
+```
+
+This function changes the basename of a file path. This function will not
+write out more than the specified buffer can contain. However, the generated
+string is always null-terminated - even if not the whole path is written out.
+The function returns the total number of characters the complete buffer would
+have, even if it was not written out completely. The path may be the same
+memory address as the buffer.
+
+**Note:** This function does not normalize the resulting path. You can use
+**[cwk_path_normalize]({{ site.baseurl }}{% link reference/cwk_path_normalize.md %})**
+to do so. Separators before and after the submitted basename will be trimmed,
+but not removed from the source path. The value may contain separators which
+will introduce new segments. If the submitted path does not have any segments,
+the basename will be appended as a new segment.
+
+## Parameters
+ * **path**: The original path which will be used for the modified path.
+ * **new_basename**: The new basename which will replace the old one.
+ * **buffer**: The buffer where the changed path will be written to.
+ * **buffer_size**: The size of the result buffer where the changed path is written to.
+
+## Return Value
+Returns the size which the complete new path would have if it was not truncated.
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ char buffer[FILENAME_MAX];
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ cwk_path_change_basename("C:\\test.txt", "another.txt", buffer,
+ sizeof(buffer));
+
+ printf("The new path: '%s'", buffer);
+
+ return EXIT_SUCCESS;
+}
+```
+
+Ouput:
+```
+The new path: 'C:\another.txt'
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.2.0** | The function is introduced. |
+\ No newline at end of file
diff --git a/src/aux/cwalk/docs/reference/cwk_path_change_extension.md b/src/aux/cwalk/docs/reference/cwk_path_change_extension.md
@@ -0,0 +1,71 @@
+---
+title: cwk_path_change_extension
+description: Changes the extension of a file path.
+---
+
+_(since v1.2.0)_
+Changes the extension of a file path.
+
+## Description
+```c
+size_t cwk_path_change_extension(const char *path, const char *new_extension,
+ char *buffer, size_t buffer_size);
+```
+
+This function changes the extension of a file name. The function will append
+an extension if the basename does not have an extension, or use the extension
+as a basename if the path does not have a basename. This function will not
+write out more than the specified buffer can contain. However, the generated
+string is always null-terminated - even if not the whole path is written out.
+The function returns the total number of characters the complete buffer would
+have, even if it was not written out completely. The path may be the same
+memory address as the buffer.
+
+**Note:** This function does not normalize the resulting path. You can use
+**[cwk_path_normalize]({{ site.baseurl }}{% link reference/cwk_path_normalize.md %})**
+to do so.
+
+**Note:** If the ``new_extension`` parameter starts with a dot, the first dot will
+be ignored when the new extension is appended.
+
+## Parameters
+ * **path**: The path which will be used to make the change.
+ * **new_extension**: The extension which will be placed within the new path.
+ * **buffer**: The output buffer where the result will be written to.
+ * **buffer_size**: The size of the output buffer where the result will be written to.
+
+## Return Value
+Returns the total size which the output would have if it was not truncated.
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ char buffer[FILENAME_MAX];
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ cwk_path_change_extension("C:\\test.txt", "md", buffer,
+ sizeof(buffer));
+
+ printf("The new path: '%s'", buffer);
+
+ return EXIT_SUCCESS;
+}
+```
+
+Ouput:
+```
+The new path: 'C:\test.md'
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.2.0** | The function is introduced. |
diff --git a/src/aux/cwalk/docs/reference/cwk_path_change_root.md b/src/aux/cwalk/docs/reference/cwk_path_change_root.md
@@ -0,0 +1,69 @@
+---
+title: cwk_path_change_root
+description: Changes the root of a path.
+---
+
+_(since v1.2.0)_
+Changes the root of a path.
+
+## Description
+```c
+size_t cwk_path_change_root(const char *path, const char *new_root,
+ char *buffer, size_t buffer_size);
+```
+
+This function changes the root of a path. It does not normalize the result.
+The result will be written to a buffer, which might be truncated if the
+buffer is not large enough to hold the full path. However, the truncated
+result will always be null-terminated. The returned value is the amount of
+characters which the resulting path would take if it was not truncated
+(excluding the null-terminating character).
+
+**Note:** This function does not normalize the resulting path. You can use
+**[cwk_path_normalize]({{ site.baseurl }}{% link reference/cwk_path_normalize.md %})**
+to do so. The new root may contain separators which will introduce new segments.
+If the submitted path does not have any root, the new root will be prepended to
+the path.
+
+## Parameters
+ * **path**: The original path which will get a new root.
+ * **new_root**: The new root which will be placed in the path.
+ * **buffer**: The output buffer where the result is written to.
+ * **buffer_size**: The size of the output buffer where the result is written
+ to.
+
+## Return Value
+Returns the total amount of characters of the new path.
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ char buffer[FILENAME_MAX];
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ cwk_path_change_root("C:\\test.txt", "D:\\", buffer,
+ sizeof(buffer));
+
+ printf("The new path: '%s'", buffer);
+
+ return EXIT_SUCCESS;
+}
+```
+
+Ouput:
+```
+The new path: 'D:\another.txt'
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.2.0** | The function is introduced. |
+\ No newline at end of file
diff --git a/src/aux/cwalk/docs/reference/cwk_path_change_segment.md b/src/aux/cwalk/docs/reference/cwk_path_change_segment.md
@@ -0,0 +1,72 @@
+---
+title: cwk_path_change_segment
+description: Changes the content of a segment.
+---
+
+_(since v1.2.0)_
+Changes the content of a segment.
+
+## Description
+```c
+size_t cwk_path_change_segment(struct cwk_segment *segment, const char *value,
+ char *buffer, size_t buffer_size);
+```
+
+This function overrides the content of a segment to the submitted value and
+outputs the whole new path to the submitted buffer. The result might require
+less or more space than before if the new value length differs from the
+original length. The output is truncated if the new path is larger than the
+submitted buffer size, but it is always null-terminated. The source of the
+segment and the submitted buffer may be the same.
+
+**Note:** This function does not normalize the resulting path. You can use
+**[cwk_path_normalize]({{ site.baseurl }}{% link reference/cwk_path_normalize.md %})**
+to do so. Separators before and after the value will be trimmed. The value may
+contain separators which will introduce new segments.
+
+## Parameters
+ * **segment**: The segment which will be modifier.
+ * **value**: The new content of the segment.
+ * **buffer**: The buffer where the modified path will be written to.
+ * **buffer_size**: The size of the output buffer.
+
+## Return Value
+Returns the total size which would have been written if the output was not
+truncated.
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ const char *path;
+ char buffer[FILENAME_MAX];
+ struct cwk_segment segment;
+
+ path = "/this/cool/path/";
+ if (!cwk_path_get_first_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ cwk_path_change_segment(&segment, "other", buffer, sizeof(buffer));
+
+ printf("The new path: '%s'", buffer);
+
+ return EXIT_SUCCESS;
+}
+```
+
+Ouput:
+```
+The new path: '/other/cool/path/'
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.2.0** | The function is introduced. |
diff --git a/src/aux/cwalk/docs/reference/cwk_path_get_absolute.md b/src/aux/cwalk/docs/reference/cwk_path_get_absolute.md
@@ -0,0 +1,66 @@
+---
+title: cwk_path_get_absolute
+description: Generates an absolute path based on a base.
+---
+
+_(since v1.0.0)_
+Generates an absolute path based on a base.
+
+## Description
+```c
+size_t cwk_path_get_absolute(const char *base, const char *path, char *buffer,
+ size_t buffer_size);
+```
+
+This function generates an absolute path based on a base path and another path. It is guaranteed to return an absolute path. If the second submitted path is absolute, it will override the base path. The result will be written to a buffer, which might be truncated if the buffer is not large enough to hold the full path. However, the truncated result will always be null-terminated. The returned value is the amount of characters which the resulting path would take if it was not truncated (excluding the null-terminating character).
+
+## Parameters
+ * **base**: The absolute base path on which the relative path will be applied.
+ * **path**: The relative path which will be applied on the base path.
+ * **buffer**: The buffer where the result will be written to.
+ * **buffer_size**: The size of the result buffer.
+
+## Return Value
+Returns the total amount of characters of the new absolute path.
+
+## Outcomes
+
+| Base | Path | Result |
+|----------------------|---------------------|-----------------------|
+| ``/hello/there`` | ``../../../../../`` | ``/`` |
+| ``/hello//../there`` | ``test//thing`` | ``/there/test/thing`` |
+| ``hello/there`` | ``/test`` | ``/test`` |
+| ``hello/there`` | ``test`` | ``/hello/there/test`` |
+| ``/hello/there`` | ``/test`` | ``/test`` |
+| ``/hello/there`` | ``..`` | ``/hello`` |
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ char buffer[FILENAME_MAX];
+
+ cwk_path_get_absolute("/hello/there", "./world", buffer, sizeof(buffer));
+ printf("The absolute path is: %s", buffer);
+
+ return EXIT_SUCCESS;
+}
+```
+
+Ouput:
+```
+The absolute path is: /hello/there/world
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.2.4** | Fix for relative base path fallback on windows. |
+| **v1.2.3** | Fix for path generation when reusing buffers. |
+| **v1.0.0** | The function is introduced. |
diff --git a/src/aux/cwalk/docs/reference/cwk_path_get_basename.md b/src/aux/cwalk/docs/reference/cwk_path_get_basename.md
@@ -0,0 +1,62 @@
+---
+title: cwk_path_get_basename
+description: Gets the basename of a file path.
+---
+
+_(since v1.0.0)_
+Gets the basename of a file path.
+
+## Description
+```c
+void cwk_path_get_basename(const char *path, const char **basename,
+ size_t *length);
+```
+
+This function gets the basename of a file path. The basename is the last segment of a path. For instance, ``logs`` is the basename of the path ``/var/logs``. A pointer to the beginning of the basename will be returned through the basename parameter. This pointer will be positioned on the first letter after the separator. The length of the file path will be returned through the length parameter. The length will be set to zero and the basename to NULL if there is no basename available.
+
+## Parameters
+ * **path**: The path which will be inspected.
+ * **basename**: The output of the basename pointer.
+ * **length**: The output of the length of the basename.
+
+## Outcomes
+
+| Path | Basename |
+|----------------------|---------------|
+| ``/my/path.txt`` | ``path.txt`` |
+| ``/my/path.txt/`` | ``path.txt`` |
+| ``/my/path.txt////`` | ``path.txt`` |
+| ``file_name`` | ``file_name`` |
+| ``..`` | ``..`` |
+| ``.`` | ``.`` |
+| ``/`` | `` `` |
+| ``C:\path\test.txt`` | ``test.txt`` |
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ const char *basename;
+ size_t length;
+
+ cwk_path_get_basename("/my/path.txt", &basename, &length);
+ printf("The basename is: '%.*s'", length, basename);
+
+ return EXIT_SUCCESS;
+}
+```
+Ouput:
+```
+The basename is: 'path.txt'
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.0.0** | The function is introduced. |
+\ No newline at end of file
diff --git a/src/aux/cwalk/docs/reference/cwk_path_get_dirname.md b/src/aux/cwalk/docs/reference/cwk_path_get_dirname.md
@@ -0,0 +1,64 @@
+---
+title: cwk_path_get_dirname
+description: Gets the dirname of a file path.
+---
+
+_(since v1.0.0)_
+Gets the dirname of a file path.
+
+## Description
+```c
+void cwk_path_get_dirname(const char *path, size_t *length);
+```
+
+This function determines the dirname of a file path and returns the length up to which character is considered to be part of it. The dirname is the part of the path up to the last segment. For instance, `/var/` is the dirname of `/var/logs`. If no dirname is found, the length will be set to zero. The beginning of the dirname is always equal to the submitted path pointer.
+
+## Parameters
+ * **path**: The path which will be inspected.
+ * **length**: The length of the dirname.
+
+## Outcomes
+
+| Path | Basename |
+|------------------------|---------------|
+| ``/my/path.txt`` | ``/my/`` |
+| ``/one/two/three.txt`` | ``/one/two/`` |
+| ``../one/two.txt`` | ``../one/`` |
+| `` `` | `` `` |
+| ``/my/path.txt/`` | ``/my/`` |
+| ``/my/path.txt////`` | ``/my/`` |
+| ``file_name`` | `` `` |
+| ``..`` | `` `` |
+| ``.`` | `` `` |
+| ``/`` | `` `` |
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ const char *path;
+ size_t length;
+
+ path = "/my/path.txt";
+ cwk_path_get_dirname(path, &length);
+ printf("The dirname is: '%.*s'", length, path);
+
+ return EXIT_SUCCESS;
+}
+```
+
+Ouput:
+```
+The dirname is: '/my/'
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.0.0** | The function is introduced. |
+\ No newline at end of file
diff --git a/src/aux/cwalk/docs/reference/cwk_path_get_extension.md b/src/aux/cwalk/docs/reference/cwk_path_get_extension.md
@@ -0,0 +1,60 @@
+---
+title: cwk_path_get_extension
+description: Gets the extension of a file path.
+---
+
+_(since v1.0.0)_
+Gets the extension of a file path.
+
+## Description
+```c
+bool cwk_path_get_extension(const char *path, const char **extension, size_t *length);
+```
+
+This function extracts the extension portion of a file path. A pointer to the beginning of the extension will be returned through the extension parameter if an extension is found and true is returned. This pointer will be positioned on the dot. The length of the extension name will be returned through the length parameter. If no extension is found both parameters won't be touched and false will be returned.
+
+## Parameters
+ * **path**: The path which will be inspected.
+ * **extension**: The output of the extension pointer.
+ * **length**: The output of the length of the extension.
+
+## Outcomes
+
+| Path | Result |
+|----------------------------|------------|
+| ``/my/path.txt`` | ``.txt`` |
+| ``/my/path`` | `` `` |
+| ``/my/.path`` | ``.path`` |
+| ``/my/path.`` | ``.`` |
+| ``/my/path.abc.txt.tests`` | ``.tests`` |
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ const char *path, *extension;
+ size_t length;
+
+ path = "/my/path.txt";
+ cwk_path_get_extension(path, &extension, &length);
+ printf("The extension is: '%.*s'", length, path);
+
+ return EXIT_SUCCESS;
+}
+```
+
+Ouput:
+```
+The extension is: '.txt'
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.0.0** | The function is introduced. |
+\ No newline at end of file
diff --git a/src/aux/cwalk/docs/reference/cwk_path_get_first_segment.md b/src/aux/cwalk/docs/reference/cwk_path_get_first_segment.md
@@ -0,0 +1,56 @@
+---
+title: cwk_path_get_first_segment
+description: Gets the first segment of a path.
+---
+
+_(since v1.0.0)_
+Gets the first segment of a path.
+
+## Description
+```c
+bool cwk_path_get_first_segment(const char *path, struct cwk_segment *segment);
+```
+
+## Description
+This function finds the first segment of a path. The position of the segment is set to the first character after the separator, and the length counts all characters until the next separator (excluding the separator).
+
+## Parameters
+ * **path**: The path which will be inspected.
+ * **segment**: The segment which will be extracted.
+
+## Return Value
+Returns ``true`` if there is a segment or ``false`` if there is none.
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ struct cwk_segment segment;
+
+ if(!cwk_path_get_first_segment("/my/path.txt", &segment)) {
+ printf("Path doesn't have any segments.");
+ }
+
+ printf("Segment length is '%zu'.\n", segment.size);
+ printf("The segment is '%.*s'.", (int)segment.size, segment.begin);
+
+ return EXIT_SUCCESS;
+}
+```
+
+Ouput:
+```
+Segment length is '2'.
+The segment is 'my'.
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.0.0** | The function is introduced. |
diff --git a/src/aux/cwalk/docs/reference/cwk_path_get_last_segment.md b/src/aux/cwalk/docs/reference/cwk_path_get_last_segment.md
@@ -0,0 +1,55 @@
+---
+title: cwk_path_get_last_segment
+description: Gets the last segment of the path.
+---
+
+_(since v1.0.0)_
+Gets the last segment of the path.
+
+## Description
+```c
+bool cwk_path_get_last_segment(const char *path, struct cwk_segment *segment);
+```
+
+This function gets the last segment of a path. This function may return false if the path doesn't contain any segments, in which case the submitted segment parameter is not modified. The position of the segment is set to the first character after the separator, and the length counts all characters until the end of the path (excluding the separator).
+
+## Parameters
+ * **path**: The path which will be inspected.
+ * **segment**: The segment which will be extracted.
+
+## Return Value
+Returns ``true`` if there is a segment or ``false`` if there is none.
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ struct cwk_segment segment;
+
+ if(!cwk_path_get_last_segment("/my/test/path.txt", &segment)) {
+ printf("Path doesn't have any segments.");
+ }
+
+ printf("Segment length is '%zu'.\n", segment.size);
+ printf("The segment is '%.*s'.", (int)segment.size, segment.begin);
+
+ return EXIT_SUCCESS;
+}
+```
+
+Ouput:
+```
+Segment length is '8'.
+The segment is 'path.txt'.
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.0.0** | The function is introduced. |
diff --git a/src/aux/cwalk/docs/reference/cwk_path_get_next_segment.md b/src/aux/cwalk/docs/reference/cwk_path_get_next_segment.md
@@ -0,0 +1,58 @@
+---
+title: cwk_path_get_next_segment
+description: Advances to the next segment.
+---
+
+_(since v1.0.0)_
+Advances to the next segment.
+
+## Description
+```c
+bool cwk_path_get_next_segment(struct cwk_segment *segment);
+```
+
+This function advances the current segment to the next segment. If there are no more segments left, the submitted segment structure will stay unchanged and false is returned. The segment should be either initialized using **[cwk_path_get_first_segment]({{ site.baseurl }}{% link reference/cwk_path_get_first_segment.md %})** or **[cwk_path_get_last_segment]({{ site.baseurl }}{% link reference/cwk_path_get_last_segment.md %})**.
+
+## Parameters
+ * **segment**: The current segment which will be advanced to the next one.
+
+## Return Value
+Returns ``true`` if another segment was found or ``false`` otherwise.
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ struct cwk_segment segment;
+
+ if(!cwk_path_get_first_segment("/my/funny/test/path.txt", &segment)) {
+ printf("Path doesn't have any segments.");
+ return EXIT_FAILURE;
+ }
+
+ do {
+ printf("Current segment is '%.*s'.\n", (int)segment.size, segment.begin);
+ } while(cwk_path_get_next_segment(&segment));
+
+ return EXIT_SUCCESS;
+}
+```
+
+Ouput:
+```
+Current segment is 'my'.
+Current segment is 'funny'.
+Current segment is 'test'.
+Current segment is 'path.txt'.
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.0.0** | The function is introduced. |
diff --git a/src/aux/cwalk/docs/reference/cwk_path_get_previous_segment.md b/src/aux/cwalk/docs/reference/cwk_path_get_previous_segment.md
@@ -0,0 +1,59 @@
+---
+title: cwk_path_get_previous_segment
+description: Moves to the previous segment.
+---
+
+_(since v1.0.0)_
+Moves to the previous segment.
+
+## Description
+```c
+bool cwk_path_get_previous_segment(struct cwk_segment *segment);
+```
+
+This function moves the current segment to the previous segment. If the current segment is the first one, the submitted segment structure will stay unchanged and false is returned. The segment should be either initialized using **[cwk_path_get_first_segment]({{ site.baseurl }}{% link reference/cwk_path_get_first_segment.md %})** or **[cwk_path_get_last_segment]({{ site.baseurl }}{% link reference/cwk_path_get_last_segment.md %})**.
+
+## Parameters
+ * **segment**: The current segment which will be moved to the previous one.
+
+## Return Value
+Returns ``true`` if there is a segment before this one or ``false`` otherwise.
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ struct cwk_segment segment;
+
+ if(!cwk_path_get_last_segment("/my/funny/test/path.txt", &segment)) {
+ printf("Path doesn't have any segments.\n");
+ return EXIT_FAILURE;
+ }
+
+ do {
+ printf("Current segment is '%.*s'.\n", (int)segment.size, segment.begin);
+ } while(cwk_path_get_previous_segment(&segment));
+
+ return EXIT_SUCCESS;
+}
+```
+
+Ouput:
+```
+Current segment is 'path.txt'.
+Current segment is 'test'.
+Current segment is 'funny'.
+Current segment is 'my'.
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.2.4** | Bugfix for single char segments. |
+| **v1.0.0** | The function is introduced. |
diff --git a/src/aux/cwalk/docs/reference/cwk_path_get_relative.md b/src/aux/cwalk/docs/reference/cwk_path_get_relative.md
@@ -0,0 +1,72 @@
+---
+title: cwk_path_get_relative
+description: Generates a relative path based on a base.
+---
+
+_(since v1.0.0)_
+Generates a relative path based on a base.
+
+## Description
+```c
+size_t cwk_path_get_relative(const char *base_directory, const char *path,
+ char *buffer, size_t buffer_size);
+```
+
+This function generates a relative path based on a base path and another path. It determines how to get to the submitted path, starting from the base directory. The result will be written to a buffer, which might be truncated if the buffer is not large enough to hold the full path. However, the truncated result will always be null-terminated. The returned value is the amount of characters which the resulting path would take if it was not truncated (excluding the null-terminating character).
+
+## Parameters
+ * **base_directory**: The base path from which the relative path will start.
+ * **path**: The target path where the relative path will point to.
+ * **buffer**: The buffer where the result will be written to.
+ * **buffer_size**: The size of the result buffer.
+
+## Return Value
+Returns the total amount of characters of the full path.
+
+## Outcomes
+
+| Style | Base | Path | Result |
+|---------|--------------------------|--------------------------|-----------------|
+| UNIX | ``/../../`` | ``/../../`` | ``.`` |
+| UNIX | ``/path/same`` | ``/path/not_same/ho/..`` | ``../not_same`` |
+| UNIX | ``/path/not_same/ho/..`` | ``/path/same`` | ``../same`` |
+| UNIX | ``/path/same`` | ``/path/same/ho/..`` | ``.`` |
+| UNIX | ``/path/same/ho/..`` | ``/path/same`` | ``.`` |
+| UNIX | ``/path/same`` | ``/path/same`` | ``.`` |
+| UNIX | ``/path/long/one`` | ``/path/long/one/two`` | ``two`` |
+| UNIX | ``/path/long/one/two`` | ``/path/long/one`` | ``..`` |
+| UNIX | ``./this/is/path_one`` | ``./this/is/path_two`` | ``../path_two`` |
+| UNIX | ``/this/is/path_one`` | ``/this/is/path_two`` | ``../path_two`` |
+| WINDOWS | ``C:/path/same`` | ``D:/path/same`` | `` `` |
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ char buffer[FILENAME_MAX];
+
+ cwk_path_get_relative("/hello/there/", "/hello/world", buffer, sizeof(buffer));
+ printf("The relative path is: %s", buffer);
+
+ return EXIT_SUCCESS;
+}
+```
+
+Ouput:
+```
+The relative path is: ../world
+```
+
+## Changelog
+
+| Version | Description |
+|------------|---------------------------------------------------|
+| **v1.2.7** | Fixed windows paths with forward slashes in root. |
+| **v1.2.5** | Fixed calls with path without segments. |
+| **v1.2.5** | Fixed calls with unequal roots in paths. |
+| **v1.0.0** | The function is introduced. |
diff --git a/src/aux/cwalk/docs/reference/cwk_path_get_root.md b/src/aux/cwalk/docs/reference/cwk_path_get_root.md
@@ -0,0 +1,72 @@
+---
+title: cwk_path_get_root
+description: Determines the root of a path.
+---
+
+_(since v1.0.0)_
+Determines the root of a path.
+
+## Description
+```c
+void cwk_path_get_root(const char *path, size_t *length);
+```
+This function determines the root of a path by finding it's length. The root comes before the first segment of the path. For example, ``C:\`` is the root of ``C:\folder\file.txt``. It always starts at the submitted path. If the path has no root, the length will be set to zero.
+
+## Parameters
+ * **path**: The path which will be inspected.
+ * **length**: The output of the root length.
+
+## Outcomes
+
+| Style | Path | Root |
+|---------|--------------------------|----------------------|
+| UNIX | ``/test/`` | ``/`` |
+| UNIX | ``test.txt`` | `` `` |
+| UNIX | ``C:\test.txt`` | `` `` |
+| UNIX | ``\folder\`` | `` `` |
+| WINDOWS | ``/test.txt`` | ``/`` |
+| WINDOWS | ``\test.txt`` | ``\`` |
+| WINDOWS | ``C:\test.txt`` | ``C:\`` |
+| WINDOWS | ``\\server\folder\data`` | ``\\server\folder\`` |
+| WINDOWS | ``\\.\folder\data`` | ``\\.\`` |
+| WINDOWS | ``\\?\folder\data`` | ``\\?\`` |
+| WINDOWS | ``C:test.txt`` | ``C:`` |
+| WINDOWS | ``..\hello\world.txt`` | `` `` |
+
+### Note
+The style is automatically chosen during compile time, which is
+UNIX for macOS and linux and WINDOWS for windows. You can change the style
+using [cwk_path_set_style]({{ site.baseurl }}{% link reference/cwk_path_set_style.md %}).
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ const char *path;
+ size_t length;
+
+ path = "/my/path.txt";
+ cwk_path_get_root(path, &length);
+ printf("The root is: '%.*s'", length, path);
+
+ return EXIT_SUCCESS;
+}
+```
+
+Ouput:
+```
+The root is: '/'
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.1.0** | The UNC path root now includes the shared folder name. |
+| **v1.1.0** | Fixed false root detection on relative windows paths. |
+| **v1.0.0** | The function is introduced. |
+\ No newline at end of file
diff --git a/src/aux/cwalk/docs/reference/cwk_path_get_segment_type.md b/src/aux/cwalk/docs/reference/cwk_path_get_segment_type.md
@@ -0,0 +1,55 @@
+---
+title: cwk_path_get_segment_type
+description: Gets the type of the submitted path segment.
+---
+
+_(since v1.0.0)_
+Gets the type of the submitted path segment.
+
+## Description
+```c
+enum cwk_segment_type cwk_path_get_segment_type(const struct cwk_segment *segment);
+```
+
+This function inspects the contents of the segment and determines the type of it. Currently, there are three types ``CWK_NORMAL``, ``CWK_CURRENT`` and ``CWK_BACK``. A ``CWK_NORMAL`` segment is a normal folder or file entry. A ``CWK_CURRENT`` is a "./" and a ``CWK_BACK`` a "../" segment.
+
+## Parameters
+ * **segment**: The segment which will be inspected.
+
+## Return Value
+Returns the type of the segment.
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ struct cwk_segment segment;
+
+ if(!cwk_path_get_first_segment("/../funny/test/path.txt", &segment)) {
+ printf("Path doesn't have any segments.");
+ return EXIT_FAILURE;
+ }
+
+ if(cwk_path_get_segment_type(&segment) == CWK_BACK) {
+ printf("The segment type is CWK_BACK.");
+ }
+
+ return EXIT_SUCCESS;
+}
+```
+
+Ouput:
+```
+The segment type is CWK_BACK.
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.0.0** | The function is introduced. |
+\ No newline at end of file
diff --git a/src/aux/cwalk/docs/reference/cwk_path_get_style.md b/src/aux/cwalk/docs/reference/cwk_path_get_style.md
@@ -0,0 +1,51 @@
+---
+title: cwk_path_get_style
+description: Gets the path style configuration..
+---
+
+_(since v1.0.0)_
+Gets the path style configuration..
+
+## Description
+```c
+enum cwk_path_style cwk_path_get_style(void);
+```
+
+## Description
+This function gets the style configuration which is currently used for the paths. This configuration determines how paths are parsed and generated.
+
+ * ``CWK_STYLE_WINDOWS``: Use backslashes as a separator and volume for the root.
+ * ``CWK_STYLE_UNIX``: Use slashes as a separator and a slash for the root.
+
+## Return Value
+Returns the current path style configuration.
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ if(cwk_path_get_style() == CWK_STYLE_WINDOWS) {
+ printf("It's the WINDOWS style.");
+ } else {
+ printf("It's the UNIX style.");
+ }
+
+ return EXIT_SUCCESS;
+}
+```
+
+Example Ouput:
+```
+It's the UNIX style.
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.0.0** | The function is introduced. |
+\ No newline at end of file
diff --git a/src/aux/cwalk/docs/reference/cwk_path_guess_style.md b/src/aux/cwalk/docs/reference/cwk_path_guess_style.md
@@ -0,0 +1,78 @@
+---
+title: cwk_path_guess_style
+description: Guesses the path style.
+---
+
+_(since v1.2.0)_
+Guesses the path style.
+
+## Description
+```c
+enum cwk_path_style cwk_path_guess_style(const char *path);
+```
+
+This function guesses the path style based on a submitted path-string. The guessing will look at the root and the type of slashes contained in the path and return the style which is more likely used in the path.
+The algorithm checks the following:
+ 1. If the root is longer than 1 character -> ``CWK_STYLE_WINDOWS``
+ 1. If the first separator is a backslash -> ``CWK_STYLE_WINDOWS``
+ 1. If the first separator is a slash -> ``CWK_STYLE_UNIX``
+ 1. If the last segment starts with a dot -> ``CWK_STYLE_UNIX``
+ 1. If the last segment contains a dot -> ``CWK_STYLE_WINDOWS``
+ 1. If nothing was found to determine the style -> ``CWK_STYLE_UNIX``
+
+## Parameters
+ * **path**: The path which will be inspected.
+
+## Return Value
+Returns the style which is most likely used for the path.
+
+## Outcomes
+
+| Path | Result |
+|-----------------------------|-----------------------|
+| ``C:\\test`` | ``CWK_STYLE_WINDOWS`` |
+| ``C:/test`` | ``CWK_STYLE_WINDOWS`` |
+| ``C:test`` | ``CWK_STYLE_WINDOWS`` |
+| ``C:/.test`` | ``CWK_STYLE_WINDOWS`` |
+| ``C:/folder/.test`` | ``CWK_STYLE_WINDOWS`` |
+| ``\directory\other`` | ``CWK_STYLE_WINDOWS`` |
+| ``\directory\.other`` | ``CWK_STYLE_WINDOWS`` |
+| ``myfile.txt`` | ``CWK_STYLE_WINDOWS`` |
+| ``/directory`` | ``CWK_STYLE_UNIX`` |
+| ``/directory/other`` | ``CWK_STYLE_UNIX`` |
+| ``/directory/other.txt`` | ``CWK_STYLE_UNIX`` |
+| ``.my_hidden_file`` | ``CWK_STYLE_UNIX`` |
+| ``.my_hidden_file.txt`` | ``CWK_STYLE_UNIX`` |
+| ``/a/directory/myfile.txt`` | ``CWK_STYLE_UNIX`` |
+| ``myfile`` | ``CWK_STYLE_UNIX`` |
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ if (cwk_path_guess_style("C:\\myfile") == CWK_STYLE_UNIX) {
+ printf("UNIX.");
+ } else {
+ printf("WINDOWS.");
+ }
+
+ return EXIT_SUCCESS;
+}
+```
+
+Ouput:
+```
+WINDOWS.
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.2.1** | Fixed crash on call with empty string. |
+| **v1.2.0** | The function is introduced. |
diff --git a/src/aux/cwalk/docs/reference/cwk_path_has_extension.md b/src/aux/cwalk/docs/reference/cwk_path_has_extension.md
@@ -0,0 +1,62 @@
+---
+title: cwk_path_has_extension
+description: Determines whether the file path has an extension.
+---
+
+_(since v1.0.0)_
+Determines whether the file path has an extension.
+
+## Description
+```c
+bool cwk_path_has_extension(const char *path);
+```
+
+This function determines whether the submitted file path has an extension. This
+will evaluate to true if the last segment of the path contains a dot. In order
+to read more information about the extension see **[cwk_path_get_extension]({{ site.baseurl }}{% link reference/cwk_path_get_extension.md %})**.
+
+## Parameters
+ * **path**: The path which will be inspected.
+
+## Return Value
+Returns ``true`` if the path has an extension or ``false`` otherwise.
+
+## Outcomes
+
+| Path | Result |
+|----------------------------|------------|
+| ``/my/path.txt`` | ``true`` |
+| ``/my/path`` | ``false`` |
+| ``/my/.path`` | ``true`` |
+| ``/my/path.`` | ``true`` |
+| ``/my/path.abc.txt.tests`` | ``true`` |
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ if (cwk_path_has_extension("/my/path.txt")) {
+ printf("yes.");
+ } else {
+ printf("no.");
+ }
+
+ return EXIT_SUCCESS;
+}
+```
+
+Ouput:
+```
+yes.
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.0.0** | The function is introduced. |
diff --git a/src/aux/cwalk/docs/reference/cwk_path_intersection.md b/src/aux/cwalk/docs/reference/cwk_path_intersection.md
@@ -0,0 +1,69 @@
+---
+title: cwk_path_get_intersection
+description: Finds common portions in two paths.
+---
+
+_(since v1.0.0)_
+Finds common portions in two paths.
+
+## Signature
+```c
+size_t cwk_path_get_intersection(const char *path_base, const char *path_other);
+```
+
+## Description
+This function finds common portions in two paths and returns the number characters from the beginning of the base path which are equal to the other path.
+
+## Parameters
+ * **path_base**: The base path which will be compared with the other path.
+ * **path_other**: The other path which will compared with the base path.
+
+## Return Value
+Returns the number of characters which are common in the base path.
+
+## Outcomes
+
+| Style | Base | Other | Ret. | Result |
+|-------------|--------------------------|--------------------------|--------|----------------------|
+| ``UNIX`` | ``/test/abc/../foo/bar`` | ``/test/foo/har`` | 16 | ``/test/abc/../foo`` |
+| ``UNIX`` | ``/test/foo/har`` | ``/test/abc/../foo/bar`` | 9 | ``/test/foo`` |
+| ``UNIX`` | ``/test/abc.txt`` | ``test/abc.txt`` | 0 | `` `` |
+| ``UNIX`` | ``/`` | `` `` | 0 | `` `` |
+| ``UNIX`` | ``/this///is/a//test`` | ``/this//is/a///file`` | 12 | ``/this///is/a`` |
+| ``UNIX`` | ``/this/is/a/test`` | ``/this/is/a/`` | 10 | ``/this/is/a`` |
+| ``UNIX`` | ``/this/is/a/test`` | ``/this/is/a`` | 10 | ``/this/is/a`` |
+| ``UNIX`` | ``/this/is/a/test`` | ``/this/is/a/string`` | 10 | ``/this/is/a`` |
+| ``WINDOWS`` | ``C:/abc/test.txt`` | ``C:/`` | 3 | ``C:/`` |
+| ``WINDOWS`` | ``C:/abc/test.txt`` | ``C:/def/test.txt`` | 3 | ``C:/`` |
+| ``WINDOWS`` | ``C:/test/abc.txt`` | ``D:/test/abc.txt`` | 0 | `` `` |
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ const char *path;
+ size_t length;
+
+ path = "/this/is/a/test";
+ length = cwk_path_get_intersection(path, "/this/is/a/string");
+ printf("The common portion is: '%.*s'", length, path);
+
+ return EXIT_SUCCESS;
+}
+```
+
+Ouput:
+```
+The common portion is: '/this/is/a'
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.0.0** | The function is introduced. |
diff --git a/src/aux/cwalk/docs/reference/cwk_path_is_absolute.md b/src/aux/cwalk/docs/reference/cwk_path_is_absolute.md
@@ -0,0 +1,66 @@
+---
+title: cwk_path_is_absolute
+description: Determine whether the path is absolute or not.
+---
+
+_(since v1.0.0)_
+Determine whether the path is absolute or not.
+
+## Description
+```c
+bool cwk_path_is_absolute(const char *path);
+```
+This function checks whether the path is an absolute (fully qualified) path or not. A path is considered to be absolute if the root ends with a separator.
+
+## Parameters
+ * **path**: The path which will be checked.
+
+## Return Value
+Returns ``true`` if the path is absolute or ``false`` otherwise.
+
+## Outcomes
+
+| Style | Path | Result |
+|---------|--------------------------|-----------|
+| UNIX | ``/test/`` | ``true`` |
+| UNIX | ``test.txt`` | ``false`` |
+| UNIX | ``C:\test.txt`` | ``false`` |
+| UNIX | ``\folder\`` | ``false`` |
+| WINDOWS | ``/test.txt`` | ``true`` |
+| WINDOWS | ``\test.txt`` | ``true`` |
+| WINDOWS | ``C:\test.txt`` | ``true`` |
+| WINDOWS | ``\\server\folder\data`` | ``true`` |
+| WINDOWS | ``\\.\folder\data`` | ``true`` |
+| WINDOWS | ``\\?\folder\data`` | ``true`` |
+| WINDOWS | ``C:test.txt`` | ``false`` |
+| WINDOWS | ``..\hello\world.txt`` | ``false`` |
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ if(cwk_path_is_absolute("/my/path.txt")) {
+ printf("The root is absolute.");
+ } else {
+ printf("The root is relative.");
+ }
+
+ return EXIT_SUCCESS;
+}
+```
+
+Ouput:
+```
+The root is absolute.
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.0.0** | The function is introduced. |
+\ No newline at end of file
diff --git a/src/aux/cwalk/docs/reference/cwk_path_is_relative.md b/src/aux/cwalk/docs/reference/cwk_path_is_relative.md
@@ -0,0 +1,67 @@
+---
+title: cwk_path_is_relative
+description: Determine whether the path is relative or not.
+---
+
+_(since v1.0.0)_
+Determine whether the path is relative or not.
+
+## Description
+```c
+bool cwk_path_is_relative(const char *path);
+```
+
+This function checks whether the path is a relative path or not. A path is considered to be relative if the root does not end with a separator.
+
+## Parameters
+ * **path**: The path which will be checked.
+
+## Return Value
+Returns ``true`` if the path is relative or ``false`` otherwise.
+
+## Outcomes
+
+| Style | Path | Result |
+|---------|--------------------------|-----------|
+| UNIX | ``/test/`` | ``false`` |
+| UNIX | ``test.txt`` | ``true`` |
+| UNIX | ``C:\test.txt`` | ``true`` |
+| UNIX | ``\folder\`` | ``true`` |
+| WINDOWS | ``/test.txt`` | ``false`` |
+| WINDOWS | ``\test.txt`` | ``false`` |
+| WINDOWS | ``C:\test.txt`` | ``false`` |
+| WINDOWS | ``\\server\folder\data`` | ``false`` |
+| WINDOWS | ``\\.\folder\data`` | ``false`` |
+| WINDOWS | ``\\?\folder\data`` | ``false`` |
+| WINDOWS | ``C:test.txt`` | ``true`` |
+| WINDOWS | ``..\hello\world.txt`` | ``true`` |
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ if(cwk_path_is_relative("my/path.txt")) {
+ printf("The root is absolute.");
+ } else {
+ printf("The root is relative.");
+ }
+
+ return EXIT_SUCCESS;
+}
+```
+
+Ouput:
+```
+The root is relative.
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.0.0** | The function is introduced. |
+\ No newline at end of file
diff --git a/src/aux/cwalk/docs/reference/cwk_path_join.md b/src/aux/cwalk/docs/reference/cwk_path_join.md
@@ -0,0 +1,77 @@
+---
+title: cwk_path_join
+description: Joins two paths together.
+---
+
+_(since v1.0.0)_
+Joins two paths together.
+
+## Description
+```c
+size_t cwk_path_join(const char *path_a, const char *path_b, char *buffer,
+ size_t buffer_size);
+```
+
+This function generates a new path by combining the two submitted paths. It will remove double separators, and unlike [cwk_path_get_absolute]({{ site.baseurl }}{% link reference/cwk_path_get_absolute.md %}) it permits the use of two relative paths to combine. The result will be written to a buffer, which might be truncated if the buffer is not large enough to hold the full path. However, the truncated result will always be null-terminated. The returned value is the amount of characters which the resulting path would take if it was not truncated (excluding the null-terminating character).
+
+## Parameters
+ * **path_a**: The first path which comes first.
+ * **path_b**: The second path which comes after the first.
+ * **buffer**: The buffer where the result will be written to.
+ * **buffer_size**: The size of the result buffer.
+
+## Return Value
+Returns the total amount of characters of the full, combined path.
+
+## Outcomes
+
+| Style | Path A | Path B | Result |
+|---------|-----------------------|-------------------------|----------------------------------------|
+| UNIX | ``hello/there`` | ``../world`` | ``hello/world`` |
+| UNIX | ``/first`` | ``/second`` | ``/first/second`` |
+| UNIX | ``hello`` | ``..`` | ``.`` |
+| UNIX | ``hello/there`` | ``..`` | ``hello`` |
+| UNIX | ``hello`` | ``there`` | ``hello/there`` |
+| WINDOWS | ``this\`` | ``C:\..\..\is\a\test\`` | ``is\a\test`` |
+| WINDOWS | ``C:\this\path`` | ``C:\is\a\test\`` | ``C:\this\path\C:\is\a\test`` |
+| WINDOWS | ``C:\this\path`` | ``C:\..\is\a\test\`` | ``C:\this\path\is\a\test`` |
+| WINDOWS | ``\\s1\unc\path`` | ``\\s2\unc\pa`` | ``\\s1\unc\pa\s2\unc\path`` |
+
+### Style
+The style is automatically chosen during compile time, which is
+UNIX for macOS and linux and WINDOWS for windows. You can change the style
+using [cwk_path_set_style]({{ site.baseurl }}{% link reference/cwk_path_set_style.md %}).
+
+### Result
+The **path_b** parameter will always be treated as a relative path, so even if
+a driver letter is submitted on a windows style path, it will be treated as a
+folder.
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ char buffer[FILENAME_MAX];
+
+ cwk_path_join("hello/there", "../world", buffer, sizeof(buffer));
+ printf("The combined path is: %s", buffer);
+
+ return EXIT_SUCCESS;
+}
+```
+
+Ouput:
+```
+The combined path is: hello/world
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.0.0** | The function is introduced. |
diff --git a/src/aux/cwalk/docs/reference/cwk_path_join_multiple.md b/src/aux/cwalk/docs/reference/cwk_path_join_multiple.md
@@ -0,0 +1,58 @@
+---
+title: cwk_path_join_multiple
+description: Joins multiple paths together.
+---
+
+_(since v1.1.0)_
+Joins multiple paths together.
+
+## Description
+```c
+size_t cwk_path_join_multiple(const char **paths, char *buffer,
+ size_t buffer_size);
+```
+This function generates a new path by joining multiple paths together. It will remove double separators, and unlike [cwk_path_get_absolute]({{ site.baseurl }}{% link reference/cwk_path_get_absolute.md %}) it permits the use of multiple relative paths to combine. The last path of the submitted string array must be set to NULL. The result will be written to a buffer, which might be truncated if the buffer is not large enough to hold the full path. However, the truncated result will always be null-terminated. The returned value is the amount of characters which the resulting path would take if it was not truncated (excluding the null-terminating character).
+
+## Parameters
+ * **paths**: An array of paths which will be joined.
+ * **buffer**: The buffer where the result will be written to.
+ * **buffer_size**: The size of the result buffer.
+
+## Return Value
+Returns the total amount of characters of the full, combined path.
+
+## Outcomes
+See [cwk_path_join]({{ site.baseurl }}{% link reference/cwk_path_join.md %}) for examples how paths are joined together.
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ char buffer[FILENAME_MAX];
+ char paths[3];
+
+ paths[0] = "hello/there";
+ paths[1] = "../world";
+ paths[2] = NULL;
+ cwk_path_join_multiple(paths, buffer, sizeof(buffer));
+ printf("The combined path is: %s", buffer);
+
+ return EXIT_SUCCESS;
+}
+```
+
+Ouput:
+```
+The combined path is: hello/world
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.1.0** | The function is introduced. |
+\ No newline at end of file
diff --git a/src/aux/cwalk/docs/reference/cwk_path_normalize.md b/src/aux/cwalk/docs/reference/cwk_path_normalize.md
@@ -0,0 +1,74 @@
+---
+title: cwk_path_normalize
+description: Creates a normalized version of the path.
+---
+
+_(since v1.0.0)_
+Creates a normalized version of the path.
+
+## Description
+```c
+size_t cwk_path_normalize(const char *path, char *buffer, size_t buffer_size);
+```
+
+This function creates a normalized version of the path within the specified buffer. This function will not write out more than the specified buffer can contain. However, the generated string is always null-terminated - even if not the whole path is written out. The function returns the total number of characters the complete buffer would have, even if it was not written out completely. The path may be the same memory address as the buffer.
+
+The following will be true for the normalized path:
+ * "../" will be resolved.
+ * "./" will be removed.
+ * double separators will be fixed with a single separator.
+ * separator suffixes will be removed.
+
+## Parameters
+ * **path**: The path which will be normalized.
+ * **buffer**: The buffer where the new path is written to.
+ * **buffer_size**: The size of the buffer.
+
+## Return Value
+The size which the complete normalized path has if it was not truncated.
+
+## Outcomes
+
+| Input | Output |
+|-------------------------------------|------------------|
+| `/var` | `/var` |
+| `/var/logs/test/../../` | `/var` |
+| `/var/logs/test/../../../../../../` | `/` |
+| `rel/../../` | `..` |
+| `/var////logs//test/` | `/var/logs/test` |
+| `/var/././././` | `/var` |
+| `/var/./logs/.//test/..//..//////` | `/var` |
+
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ char result[FILENAME_MAX];
+
+ // The following function cleans up the input path and writes it
+ // to the result buffer.
+ cwk_path_normalize("/var/log/weird/////path/.././..///", result,
+ sizeof(result));
+
+ printf("%s\n", result);
+ return EXIT_SUCCESS;
+}
+```
+
+Output:
+```
+/var/log
+```
+
+## Changelog
+
+| Version | Description |
+|------------|---------------------------------------------------|
+| **v1.2.7** | Fixed windows paths with forward slashes in root. |
+| **v1.0.0** | The function is introduced. |
+\ No newline at end of file
diff --git a/src/aux/cwalk/docs/reference/cwk_path_set_style.md b/src/aux/cwalk/docs/reference/cwk_path_set_style.md
@@ -0,0 +1,50 @@
+---
+title: cwk_path_set_style
+description: Configures which path style is used.
+---
+
+_(since v1.0.0)_
+Configures which path style is used.
+
+## Description
+```c
+void cwk_path_set_style(enum cwk_path_style style);
+```
+
+## Description
+This function configures which path style is used. A call to this function is only required if a non-native behaviour is required. The style defaults to ``CWK_STYLE_WINDOWS`` on windows builds and to ``CWK_STYLE_UNIX`` otherwise. The following styles are currently supported.
+
+ * ``CWK_STYLE_WINDOWS``: Use backslashes as a separator and volume for the root.
+ * ``CWK_STYLE_UNIX``: Use slashes as a separator and a slash for the root.
+
+## Parameters
+ * **style**: The style which will be used from now on.
+
+## Example
+```c
+#include <cwalk.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ cwk_path_get_root("C:\\test.txt", &length);
+ printf("The root length is '%zu'.", length);
+ return EXIT_SUCCESS;
+}
+```
+
+Ouput:
+```
+The root length is '3'.
+```
+
+## Changelog
+
+| Version | Description |
+|------------|--------------------------------------------------------|
+| **v1.0.0** | The function is introduced. |
+\ No newline at end of file
diff --git a/src/aux/cwalk/docs/reference/index.md b/src/aux/cwalk/docs/reference/index.md
@@ -0,0 +1,99 @@
+---
+title: Reference
+description: A complete reference of the cwalk path library for C/C++.
+---
+
+## Basics
+These are some basic, helpful functions available in the library. The basename is the last portion of the path which determines the name of the file or folder which is being pointed to. For instance, the path ``/var/log/test.txt`` would have the basename ``test.txt``. The dirname is the opposite - the path up to the basename. In that example the dirname would be ``/var/log``.
+
+### Functions
+* **[cwk_path_get_basename]({{ site.baseurl }}{% link reference/cwk_path_get_basename.md %})**
+Gets the basename of a file path.
+
+* **[cwk_path_change_basename]({{ site.baseurl }}{% link reference/cwk_path_change_basename.md %})**
+Changes the basename of a file path.
+
+* **[cwk_path_get_dirname]({{ site.baseurl }}{% link reference/cwk_path_get_dirname.md %})**
+Gets the dirname of a file path.
+
+* **[cwk_path_get_root]({{ site.baseurl }}{% link reference/cwk_path_get_root.md %})**
+Determines the root of a path.
+
+* **[cwk_path_change_root]({{ site.baseurl }}{% link reference/cwk_path_change_root.md %})**
+Changes the root of a path.
+
+* **[cwk_path_is_absolute]({{ site.baseurl }}{% link reference/cwk_path_is_absolute.md %})**
+Determine whether the path is absolute or not.
+
+* **[cwk_path_is_relative]({{ site.baseurl }}{% link reference/cwk_path_is_relative.md %})**
+Determine whether the path is relative or not.
+
+* **[cwk_path_join]({{ site.baseurl }}{% link reference/cwk_path_join.md %})**
+Joins two paths together.
+
+* **[cwk_path_join_multiple]({{ site.baseurl }}{% link reference/cwk_path_join_multiple.md %})**
+Joins multiple paths together.
+
+* **[cwk_path_normalize]({{ site.baseurl }}{% link reference/cwk_path_normalize.md %})**
+Creates a normalized version of the path.
+
+* **[cwk_path_intersection]({{ site.baseurl }}{% link reference/cwk_path_intersection.md %})**
+Finds common portions in two paths.
+
+## Navigation
+One might specify paths containing relative components ``../``. These functions help to resolve or create relative paths based on a base path.
+
+### Functions
+* **[cwk_path_get_absolute]({{ site.baseurl }}{% link reference/cwk_path_get_absolute.md %})**
+Generates an absolute path based on a base.
+
+* **[cwk_path_get_relative]({{ site.baseurl }}{% link reference/cwk_path_get_relative.md %})**
+Generates a relative path based on a base.
+
+## Extensions
+Extensions are the portion of a path which come after a `.`. For instance, the file extension of the ``/var/log/test.txt`` would be ``.txt`` - which indicates that the content is text.
+
+### Functions
+* **[cwk_path_get_extension]({{ site.baseurl }}{% link reference/cwk_path_get_extension.md %})**
+Gets the extension of a file path.
+
+* **[cwk_path_has_extension]({{ site.baseurl }}{% link reference/cwk_path_has_extension.md %})**
+Determines whether the file path has an extension.
+
+* **[cwk_path_change_extension]({{ site.baseurl }}{% link reference/cwk_path_change_extension.md %})**
+Changes the extension of a file path.
+
+## Segments
+A segment represents a single component of a path. For instance, on linux a path might look like this ``/var/log/``, which consists of two segments ``var`` and ``log``.
+
+### Functions
+* **[cwk_path_get_first_segment]({{ site.baseurl }}{% link reference/cwk_path_get_first_segment.md %})**
+Gets the first segment of a path.
+
+* **[cwk_path_get_last_segment]({{ site.baseurl }}{% link reference/cwk_path_get_last_segment.md %})**
+Gets the last segment of the path.
+
+* **[cwk_path_get_next_segment]({{ site.baseurl }}{% link reference/cwk_path_get_next_segment.md %})**
+Advances to the next segment.
+
+* **[cwk_path_get_previous_segment]({{ site.baseurl }}{% link reference/cwk_path_get_previous_segment.md %})**
+Moves to the previous segment.
+
+* **[cwk_path_get_segment_type]({{ site.baseurl }}{% link reference/cwk_path_get_segment_type.md %})**
+Gets the type of the submitted path segment.
+
+* **[cwk_path_change_segment]({{ site.baseurl }}{% link reference/cwk_path_change_segment.md %})**
+Changes the content of a segment.
+
+## Style
+The path style describes how paths are generated and parsed. **cwalk** currently supports two path styles, ``CWK_STYLE_WINDOWS`` and ``CWK_STYLE_UNIX``.
+
+### Functions
+* **[cwk_path_guess_style]({{ site.baseurl }}{% link reference/cwk_path_guess_style.md %})**
+Guesses the path style.
+
+* **[cwk_path_set_style]({{ site.baseurl }}{% link reference/cwk_path_set_style.md %})**
+Configures which path style is used.
+
+* **[cwk_path_get_style]({{ site.baseurl }}{% link reference/cwk_path_get_style.md %})**
+Gets the path style configuration.
+\ No newline at end of file
diff --git a/src/aux/cwalk/include/cwalk.h b/src/aux/cwalk/include/cwalk.h
@@ -0,0 +1,498 @@
+#pragma once
+
+#ifndef CWK_LIBRARY_H
+#define CWK_LIBRARY_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+#define CWK_EXPORT __declspec(dllexport)
+#define CWK_IMPORT __declspec(dllimport)
+#elif __GNUC__ >= 4
+#define CWK_EXPORT __attribute__((visibility("default")))
+#define CWK_IMPORT __attribute__((visibility("default")))
+#else
+#define CWK_EXPORT
+#define CWK_IMPORT
+#endif
+
+#if defined(CWK_SHARED)
+#if defined(CWK_EXPORTS)
+#define CWK_PUBLIC CWK_EXPORT
+#else
+#define CWK_PUBLIC CWK_IMPORT
+#endif
+#else
+#define CWK_PUBLIC
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**
+ * A segment represents a single component of a path. For instance, on linux a
+ * path might look like this "/var/log/", which consists of two segments "var"
+ * and "log".
+ */
+struct cwk_segment
+{
+ const char *path;
+ const char *segments;
+ const char *begin;
+ const char *end;
+ size_t size;
+};
+
+/**
+ * The segment type can be used to identify whether a segment is a special
+ * segment or not.
+ *
+ * CWK_NORMAL - normal folder or file segment
+ * CWK_CURRENT - "./" current folder segment
+ * CWK_BACK - "../" relative back navigation segment
+ */
+enum cwk_segment_type
+{
+ CWK_NORMAL,
+ CWK_CURRENT,
+ CWK_BACK
+};
+
+/**
+ * @brief Determines the style which is used for the path parsing and
+ * generation.
+ */
+enum cwk_path_style
+{
+ CWK_STYLE_WINDOWS,
+ CWK_STYLE_UNIX
+};
+
+/**
+ * @brief Generates an absolute path based on a base.
+ *
+ * This function generates an absolute path based on a base path and another
+ * path. It is guaranteed to return an absolute path. If the second submitted
+ * path is absolute, it will override the base path. The result will be
+ * written to a buffer, which might be truncated if the buffer is not large
+ * enough to hold the full path. However, the truncated result will always be
+ * null-terminated. The returned value is the amount of characters which the
+ * resulting path would take if it was not truncated (excluding the
+ * null-terminating character).
+ *
+ * @param base The absolute base path on which the relative path will be
+ * applied.
+ * @param path The relative path which will be applied on the base path.
+ * @param buffer The buffer where the result will be written to.
+ * @param buffer_size The size of the result buffer.
+ * @return Returns the total amount of characters of the new absolute path.
+ */
+CWK_PUBLIC size_t cwk_path_get_absolute(const char *base, const char *path,
+ char *buffer, size_t buffer_size);
+
+/**
+ * @brief Generates a relative path based on a base.
+ *
+ * This function generates a relative path based on a base path and another
+ * path. It determines how to get to the submitted path, starting from the
+ * base directory. The result will be written to a buffer, which might be
+ * truncated if the buffer is not large enough to hold the full path. However,
+ * the truncated result will always be null-terminated. The returned value is
+ * the amount of characters which the resulting path would take if it was not
+ * truncated (excluding the null-terminating character).
+ *
+ * @param base_directory The base path from which the relative path will
+ * start.
+ * @param path The target path where the relative path will point to.
+ * @param buffer The buffer where the result will be written to.
+ * @param buffer_size The size of the result buffer.
+ * @return Returns the total amount of characters of the full path.
+ */
+CWK_PUBLIC size_t cwk_path_get_relative(const char *base_directory,
+ const char *path, char *buffer, size_t buffer_size);
+
+/**
+ * @brief Joins two paths together.
+ *
+ * This function generates a new path by combining the two submitted paths. It
+ * will remove double separators, and unlike cwk_path_get_absolute it permits
+ * the use of two relative paths to combine. The result will be written to a
+ * buffer, which might be truncated if the buffer is not large enough to hold
+ * the full path. However, the truncated result will always be
+ * null-terminated. The returned value is the amount of characters which the
+ * resulting path would take if it was not truncated (excluding the
+ * null-terminating character).
+ *
+ * @param path_a The first path which comes first.
+ * @param path_b The second path which comes after the first.
+ * @param buffer The buffer where the result will be written to.
+ * @param buffer_size The size of the result buffer.
+ * @return Returns the total amount of characters of the full, combined path.
+ */
+CWK_PUBLIC size_t cwk_path_join(const char *path_a, const char *path_b,
+ char *buffer, size_t buffer_size);
+
+/**
+ * @brief Joins multiple paths together.
+ *
+ * This function generates a new path by joining multiple paths together. It
+ * will remove double separators, and unlike cwk_path_get_absolute it permits
+ * the use of multiple relative paths to combine. The last path of the
+ * submitted string array must be set to NULL. The result will be written to a
+ * buffer, which might be truncated if the buffer is not large enough to hold
+ * the full path. However, the truncated result will always be
+ * null-terminated. The returned value is the amount of characters which the
+ * resulting path would take if it was not truncated (excluding the
+ * null-terminating character).
+ *
+ * @param paths An array of paths which will be joined.
+ * @param buffer The buffer where the result will be written to.
+ * @param buffer_size The size of the result buffer.
+ * @return Returns the total amount of characters of the full, combined path.
+ */
+CWK_PUBLIC size_t cwk_path_join_multiple(const char **paths, char *buffer,
+ size_t buffer_size);
+
+/**
+ * @brief Determines the root of a path.
+ *
+ * This function determines the root of a path by finding its length. The
+ * root always starts at the submitted path. If the path has no root, the
+ * length will be set to zero.
+ *
+ * @param path The path which will be inspected.
+ * @param length The output of the root length.
+ */
+CWK_PUBLIC void cwk_path_get_root(const char *path, size_t *length);
+
+/**
+ * @brief Changes the root of a path.
+ *
+ * This function changes the root of a path. It does not normalize the result.
+ * The result will be written to a buffer, which might be truncated if the
+ * buffer is not large enough to hold the full path. However, the truncated
+ * result will always be null-terminated. The returned value is the amount of
+ * characters which the resulting path would take if it was not truncated
+ * (excluding the null-terminating character).
+ *
+ * @param path The original path which will get a new root.
+ * @param new_root The new root which will be placed in the path.
+ * @param buffer The output buffer where the result is written to.
+ * @param buffer_size The size of the output buffer where the result is
+ * written to.
+ * @return Returns the total amount of characters of the new path.
+ */
+CWK_PUBLIC size_t cwk_path_change_root(const char *path, const char *new_root,
+ char *buffer, size_t buffer_size);
+
+/**
+ * @brief Determine whether the path is absolute or not.
+ *
+ * This function checks whether the path is an absolute path or not. A path is
+ * considered to be absolute if the root ends with a separator.
+ *
+ * @param path The path which will be checked.
+ * @return Returns true if the path is absolute or false otherwise.
+ */
+CWK_PUBLIC bool cwk_path_is_absolute(const char *path);
+
+/**
+ * @brief Determine whether the path is relative or not.
+ *
+ * This function checks whether the path is a relative path or not. A path is
+ * considered to be relative if the root does not end with a separator.
+ *
+ * @param path The path which will be checked.
+ * @return Returns true if the path is relative or false otherwise.
+ */
+CWK_PUBLIC bool cwk_path_is_relative(const char *path);
+
+/**
+ * @brief Gets the basename of a file path.
+ *
+ * This function gets the basename of a file path. A pointer to the beginning
+ * of the basename will be returned through the basename parameter. This
+ * pointer will be positioned on the first letter after the separator. The
+ * length of the file path will be returned through the length parameter. The
+ * length will be set to zero and the basename to NULL if there is no basename
+ * available.
+ *
+ * @param path The path which will be inspected.
+ * @param basename The output of the basename pointer.
+ * @param length The output of the length of the basename. This may be
+ * null if not required.
+ */
+CWK_PUBLIC void cwk_path_get_basename(const char *path, const char **basename,
+ size_t *length);
+
+/**
+ * @brief Changes the basename of a file path.
+ *
+ * This function changes the basename of a file path. This function will not
+ * write out more than the specified buffer can contain. However, the
+ * generated string is always null-terminated - even if not the whole path is
+ * written out. The function returns the total number of characters the
+ * complete buffer would have, even if it was not written out completely. The
+ * path may be the same memory address as the buffer.
+ *
+ * @param path The original path which will be used for the modified path.
+ * @param new_basename The new basename which will replace the old one.
+ * @param buffer The buffer where the changed path will be written to.
+ * @param buffer_size The size of the result buffer where the changed path is
+ * written to.
+ * @return Returns the size which the complete new path would have if it was
+ * not truncated.
+ */
+CWK_PUBLIC size_t cwk_path_change_basename(const char *path,
+ const char *new_basename, char *buffer, size_t buffer_size);
+
+/**
+ * @brief Gets the dirname of a file path.
+ *
+ * This function determines the dirname of a file path and returns the length
+ * up to which character is considered to be part of it. If no dirname is
+ * found, the length will be set to zero. The beginning of the dirname is
+ * always equal to the submitted path pointer.
+ *
+ * @param path The path which will be inspected.
+ * @param length The length of the dirname.
+ */
+CWK_PUBLIC void cwk_path_get_dirname(const char *path, size_t *length);
+
+/**
+ * @brief Gets the extension of a file path.
+ *
+ * This function extracts the extension portion of a file path. A pointer to
+ * the beginning of the extension will be returned through the extension
+ * parameter if an extension is found and true is returned. This pointer will
+ * be positioned on the dot. The length of the extension name will be returned
+ * through the length parameter. If no extension is found both parameters
+ * won't be touched and false will be returned.
+ *
+ * @param path The path which will be inspected.
+ * @param extension The output of the extension pointer.
+ * @param length The output of the length of the extension.
+ * @return Returns true if an extension is found or false otherwise.
+ */
+CWK_PUBLIC bool cwk_path_get_extension(const char *path, const char **extension,
+ size_t *length);
+
+/**
+ * @brief Determines whether the file path has an extension.
+ *
+ * This function determines whether the submitted file path has an extension.
+ * This will evaluate to true if the last segment of the path contains a dot.
+ *
+ * @param path The path which will be inspected.
+ * @return Returns true if the path has an extension or false otherwise.
+ */
+CWK_PUBLIC bool cwk_path_has_extension(const char *path);
+
+/**
+ * @brief Changes the extension of a file path.
+ *
+ * This function changes the extension of a file name. The function will
+ * append an extension if the basename does not have an extension, or use the
+ * extension as a basename if the path does not have a basename. This function
+ * will not write out more than the specified buffer can contain. However, the
+ * generated string is always null-terminated - even if not the whole path is
+ * written out. The function returns the total number of characters the
+ * complete buffer would have, even if it was not written out completely. The
+ * path may be the same memory address as the buffer.
+ *
+ * @param path The path which will be used to make the change.
+ * @param new_extension The extension which will be placed within the new
+ * path.
+ * @param buffer The output buffer where the result will be written to.
+ * @param buffer_size The size of the output buffer where the result will be
+ * written to.
+ * @return Returns the total size which the output would have if it was not
+ * truncated.
+ */
+CWK_PUBLIC size_t cwk_path_change_extension(const char *path,
+ const char *new_extension, char *buffer, size_t buffer_size);
+
+/**
+ * @brief Creates a normalized version of the path.
+ *
+ * This function creates a normalized version of the path within the specified
+ * buffer. This function will not write out more than the specified buffer can
+ * contain. However, the generated string is always null-terminated - even if
+ * not the whole path is written out. The function returns the total number of
+ * characters the complete buffer would have, even if it was not written out
+ * completely. The path may be the same memory address as the buffer.
+ *
+ * The following will be true for the normalized path:
+ * 1) "../" will be resolved.
+ * 2) "./" will be removed.
+ * 3) double separators will be fixed with a single separator.
+ * 4) separator suffixes will be removed.
+ *
+ * @param path The path which will be normalized.
+ * @param buffer The buffer where the new path is written to.
+ * @param buffer_size The size of the buffer.
+ * @return The size which the complete normalized path has if it was not
+ * truncated.
+ */
+CWK_PUBLIC size_t cwk_path_normalize(const char *path, char *buffer,
+ size_t buffer_size);
+
+/**
+ * @brief Finds common portions in two paths.
+ *
+ * This function finds common portions in two paths and returns the number
+ * characters from the beginning of the base path which are equal to the other
+ * path.
+ *
+ * @param path_base The base path which will be compared with the other path.
+ * @param path_other The other path which will compared with the base path.
+ * @return Returns the number of characters which are common in the base path.
+ */
+CWK_PUBLIC size_t cwk_path_get_intersection(const char *path_base,
+ const char *path_other);
+
+/**
+ * @brief Gets the first segment of a path.
+ *
+ * This function finds the first segment of a path. The position of the
+ * segment is set to the first character after the separator, and the length
+ * counts all characters until the next separator (excluding the separator).
+ *
+ * @param path The path which will be inspected.
+ * @param segment The segment which will be extracted.
+ * @return Returns true if there is a segment or false if there is none.
+ */
+CWK_PUBLIC bool cwk_path_get_first_segment(const char *path,
+ struct cwk_segment *segment);
+
+/**
+ * @brief Gets the last segment of the path.
+ *
+ * This function gets the last segment of a path. This function may return
+ * false if the path doesn't contain any segments, in which case the submitted
+ * segment parameter is not modified. The position of the segment is set to
+ * the first character after the separator, and the length counts all
+ * characters until the end of the path (excluding the separator).
+ *
+ * @param path The path which will be inspected.
+ * @param segment The segment which will be extracted.
+ * @return Returns true if there is a segment or false if there is none.
+ */
+CWK_PUBLIC bool cwk_path_get_last_segment(const char *path,
+ struct cwk_segment *segment);
+
+/**
+ * @brief Advances to the next segment.
+ *
+ * This function advances the current segment to the next segment. If there
+ * are no more segments left, the submitted segment structure will stay
+ * unchanged and false is returned.
+ *
+ * @param segment The current segment which will be advanced to the next one.
+ * @return Returns true if another segment was found or false otherwise.
+ */
+CWK_PUBLIC bool cwk_path_get_next_segment(struct cwk_segment *segment);
+
+/**
+ * @brief Moves to the previous segment.
+ *
+ * This function moves the current segment to the previous segment. If the
+ * current segment is the first one, the submitted segment structure will stay
+ * unchanged and false is returned.
+ *
+ * @param segment The current segment which will be moved to the previous one.
+ * @return Returns true if there is a segment before this one or false
+ * otherwise.
+ */
+CWK_PUBLIC bool cwk_path_get_previous_segment(struct cwk_segment *segment);
+
+/**
+ * @brief Gets the type of the submitted path segment.
+ *
+ * This function inspects the contents of the segment and determines the type
+ * of it. Currently, there are three types CWK_NORMAL, CWK_CURRENT and
+ * CWK_BACK. A CWK_NORMAL segment is a normal folder or file entry. A
+ * CWK_CURRENT is a "./" and a CWK_BACK a "../" segment.
+ *
+ * @param segment The segment which will be inspected.
+ * @return Returns the type of the segment.
+ */
+CWK_PUBLIC enum cwk_segment_type cwk_path_get_segment_type(
+ const struct cwk_segment *segment);
+
+/**
+ * @brief Changes the content of a segment.
+ *
+ * This function overrides the content of a segment to the submitted value and
+ * outputs the whole new path to the submitted buffer. The result might
+ * require less or more space than before if the new value length differs from
+ * the original length. The output is truncated if the new path is larger than
+ * the submitted buffer size, but it is always null-terminated. The source of
+ * the segment and the submitted buffer may be the same.
+ *
+ * @param segment The segment which will be modifier.
+ * @param value The new content of the segment.
+ * @param buffer The buffer where the modified path will be written to.
+ * @param buffer_size The size of the output buffer.
+ * @return Returns the total size which would have been written if the output
+ * was not truncated.
+ */
+CWK_PUBLIC size_t cwk_path_change_segment(struct cwk_segment *segment,
+ const char *value, char *buffer, size_t buffer_size);
+
+/**
+ * @brief Checks whether the submitted pointer points to a separator.
+ *
+ * This function simply checks whether the submitted pointer points to a
+ * separator, which has to be null-terminated (but not necessarily after the
+ * separator). The function will return true if it is a separator, or false
+ * otherwise.
+ *
+ * @param symbol A pointer to a string.
+ * @return Returns true if it is a separator, or false otherwise.
+ */
+CWK_PUBLIC bool cwk_path_is_separator(const char *str);
+
+/**
+ * @brief Guesses the path style.
+ *
+ * This function guesses the path style based on a submitted path-string. The
+ * guessing will look at the root and the type of slashes contained in the
+ * path and return the style which is more likely used in the path.
+ *
+ * @param path The path which will be inspected.
+ * @return Returns the style which is most likely used for the path.
+ */
+CWK_PUBLIC enum cwk_path_style cwk_path_guess_style(const char *path);
+
+/**
+ * @brief Configures which path style is used.
+ *
+ * This function configures which path style is used. The following styles are
+ * currently supported.
+ *
+ * CWK_STYLE_WINDOWS: Use backslashes as a separator and volume for the root.
+ * CWK_STYLE_UNIX: Use slashes as a separator and a slash for the root.
+ *
+ * @param style The style which will be used from now on.
+ */
+CWK_PUBLIC void cwk_path_set_style(enum cwk_path_style style);
+
+/**
+ * @brief Gets the path style configuration.
+ *
+ * This function gets the style configuration which is currently used for the
+ * paths. This configuration determines how paths are parsed and generated.
+ *
+ * @return Returns the current path style configuration.
+ */
+CWK_PUBLIC enum cwk_path_style cwk_path_get_style(void);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif
diff --git a/src/aux/cwalk/meson.build b/src/aux/cwalk/meson.build
@@ -0,0 +1,20 @@
+project('cwalk', 'c',
+ license: 'MIT',
+ version: '1.2.9',
+ meson_version: '>= 0.57.0'
+)
+
+cwalk_inc = include_directories('include')
+
+cwalk = library('cwalk', 'src/cwalk.c',
+ install: true,
+ include_directories: cwalk_inc
+)
+
+install_headers('include/cwalk.h')
+
+cwalk_dep = declare_dependency(include_directories: 'include', link_with: cwalk)
+
+if get_option('ENABLE_TESTS')
+ subdir('test')
+endif
diff --git a/src/aux/cwalk/meson_options.txt b/src/aux/cwalk/meson_options.txt
@@ -0,0 +1 @@
+option('ENABLE_TESTS', type: 'boolean', value: false, description: 'Enables building test executables')
diff --git a/src/aux/cwalk/src/cwalk.c b/src/aux/cwalk/src/cwalk.c
@@ -0,0 +1,1479 @@
+#include <assert.h>
+#include <ctype.h>
+#include <cwalk.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+
+/**
+ * We try to default to a different path style depending on the operating
+ * system. So this should detect whether we should use windows or unix paths.
+ */
+#if defined(WIN32) || defined(_WIN32) || \
+ defined(__WIN32) && !defined(__CYGWIN__)
+static enum cwk_path_style path_style = CWK_STYLE_WINDOWS;
+#else
+static enum cwk_path_style path_style = CWK_STYLE_UNIX;
+#endif
+
+/**
+ * This is a list of separators used in different styles. Windows can read
+ * multiple separators, but it generally outputs just a backslash. The output
+ * will always use the first character for the output.
+ */
+static const char *separators[] = {
+ "\\/", // CWK_STYLE_WINDOWS
+ "/" // CWK_STYLE_UNIX
+};
+
+/**
+ * A joined path represents multiple path strings which are concatenated, but
+ * not (necessarily) stored in contiguous memory. The joined path allows to
+ * iterate over the segments as if it was one piece of path.
+ */
+struct cwk_segment_joined
+{
+ struct cwk_segment segment;
+ const char **paths;
+ size_t path_index;
+};
+
+static size_t cwk_path_output_sized(char *buffer, size_t buffer_size,
+ size_t position, const char *str, size_t length)
+{
+ size_t amount_written;
+
+ // First we determine the amount which we can write to the buffer. There are
+ // three cases. In the first case we have enough to store the whole string in
+ // it. In the second one we can only store a part of it, and in the third we
+ // have no space left.
+ if (buffer_size > position + length) {
+ amount_written = length;
+ } else if (buffer_size > position) {
+ amount_written = buffer_size - position;
+ } else {
+ amount_written = 0;
+ }
+
+ // If we actually want to write out something we will do that here. We will
+ // always append a '\0', this way we are guaranteed to have a valid string at
+ // all times.
+ if (amount_written > 0) {
+ memmove(&buffer[position], str, amount_written);
+ }
+
+ // Return the theoretical length which would have been written when everything
+ // would have fit in the buffer.
+ return length;
+}
+
+static size_t cwk_path_output_current(char *buffer, size_t buffer_size,
+ size_t position)
+{
+ // We output a "current" directory, which is a single character. This
+ // character is currently not style dependant.
+ return cwk_path_output_sized(buffer, buffer_size, position, ".", 1);
+}
+
+static size_t cwk_path_output_back(char *buffer, size_t buffer_size,
+ size_t position)
+{
+ // We output a "back" directory, which ahs two characters. This
+ // character is currently not style dependant.
+ return cwk_path_output_sized(buffer, buffer_size, position, "..", 2);
+}
+
+static size_t cwk_path_output_separator(char *buffer, size_t buffer_size,
+ size_t position)
+{
+ // We output a separator, which is a single character.
+ return cwk_path_output_sized(buffer, buffer_size, position,
+ separators[path_style], 1);
+}
+
+static size_t cwk_path_output_dot(char *buffer, size_t buffer_size,
+ size_t position)
+{
+ // We output a dot, which is a single character. This is used for extensions.
+ return cwk_path_output_sized(buffer, buffer_size, position, ".", 1);
+}
+
+static size_t cwk_path_output(char *buffer, size_t buffer_size, size_t position,
+ const char *str)
+{
+ size_t length;
+
+ // This just does a sized output internally, but first measuring the
+ // null-terminated string.
+ length = strlen(str);
+ return cwk_path_output_sized(buffer, buffer_size, position, str, length);
+}
+
+static void cwk_path_terminate_output(char *buffer, size_t buffer_size,
+ size_t pos)
+{
+ if (buffer_size > 0) {
+ if (pos >= buffer_size) {
+ buffer[buffer_size - 1] = '\0';
+ } else {
+ buffer[pos] = '\0';
+ }
+ }
+}
+
+static bool cwk_path_is_string_equal(const char *first, const char *second,
+ size_t first_size, size_t second_size)
+{
+ bool are_both_separators;
+
+ // The two strings are not equal if the sizes are not equal.
+ if (first_size != second_size) {
+ return false;
+ }
+
+ // If the path style is UNIX, we will compare case sensitively. This can be
+ // done easily using strncmp.
+ if (path_style == CWK_STYLE_UNIX) {
+ return strncmp(first, second, first_size) == 0;
+ }
+
+ // However, if this is windows we will have to compare case insensitively.
+ // Since there is no standard method to do that we will have to do it on our
+ // own.
+ while (*first && *second && first_size > 0) {
+ // We can consider the string to be not equal if the two lowercase
+ // characters are not equal. The two chars may also be separators, which
+ // means they would be equal.
+ are_both_separators = strchr(separators[path_style], *first) != NULL &&
+ strchr(separators[path_style], *second) != NULL;
+
+ if (tolower(*first) != tolower(*second) && !are_both_separators) {
+ return false;
+ }
+
+ first++;
+ second++;
+
+ --first_size;
+ }
+
+ // The string must be equal since they both have the same length and all the
+ // characters are the same.
+ return true;
+}
+
+static const char *cwk_path_find_next_stop(const char *c)
+{
+ // We just move forward until we find a '\0' or a separator, which will be our
+ // next "stop".
+ while (*c != '\0' && !cwk_path_is_separator(c)) {
+ ++c;
+ }
+
+ // Return the pointer of the next stop.
+ return c;
+}
+
+static const char *cwk_path_find_previous_stop(const char *begin, const char *c)
+{
+ // We just move back until we find a separator or reach the beginning of the
+ // path, which will be our previous "stop".
+ while (c > begin && !cwk_path_is_separator(c)) {
+ --c;
+ }
+
+ // Return the pointer to the previous stop. We have to return the first
+ // character after the separator, not on the separator itself.
+ if (cwk_path_is_separator(c)) {
+ return c + 1;
+ } else {
+ return c;
+ }
+}
+
+static bool cwk_path_get_first_segment_without_root(const char *path,
+ const char *segments, struct cwk_segment *segment)
+{
+ // Let's remember the path. We will move the path pointer afterwards, that's
+ // why this has to be done first.
+ segment->path = path;
+ segment->segments = segments;
+ segment->begin = segments;
+ segment->end = segments;
+ segment->size = 0;
+
+ // Now let's check whether this is an empty string. An empty string has no
+ // segment it could use.
+ if (*segments == '\0') {
+ return false;
+ }
+
+ // If the string starts with separators, we will jump over those. If there is
+ // only a slash and a '\0' after it, we can't determine the first segment
+ // since there is none.
+ while (cwk_path_is_separator(segments)) {
+ ++segments;
+ if (*segments == '\0') {
+ return false;
+ }
+ }
+
+ // So this is the beginning of our segment.
+ segment->begin = segments;
+
+ // Now let's determine the end of the segment, which we do by moving the path
+ // pointer further until we find a separator.
+ segments = cwk_path_find_next_stop(segments);
+
+ // And finally, calculate the size of the segment by subtracting the position
+ // from the end.
+ segment->size = (size_t)(segments - segment->begin);
+ segment->end = segments;
+
+ // Tell the caller that we found a segment.
+ return true;
+}
+
+static bool cwk_path_get_last_segment_without_root(const char *path,
+ struct cwk_segment *segment)
+{
+ // Now this is fairly similar to the normal algorithm, however, it will assume
+ // that there is no root in the path. So we grab the first segment at this
+ // position, assuming there is no root.
+ if (!cwk_path_get_first_segment_without_root(path, path, segment)) {
+ return false;
+ }
+
+ // Now we find our last segment. The segment struct of the caller
+ // will contain the last segment, since the function we call here will not
+ // change the segment struct when it reaches the end.
+ while (cwk_path_get_next_segment(segment)) {
+ // We just loop until there is no other segment left.
+ }
+
+ return true;
+}
+
+static bool cwk_path_get_first_segment_joined(const char **paths,
+ struct cwk_segment_joined *sj)
+{
+ bool result;
+
+ // Prepare the first segment. We position the joined segment on the first path
+ // and assign the path array to the struct.
+ sj->path_index = 0;
+ sj->paths = paths;
+
+ // We loop through all paths until we find one which has a segment. The result
+ // is stored in a variable, so we can let the caller know whether we found one
+ // or not.
+ result = false;
+ while (paths[sj->path_index] != NULL &&
+ (result = cwk_path_get_first_segment(paths[sj->path_index],
+ &sj->segment)) == false) {
+ ++sj->path_index;
+ }
+
+ return result;
+}
+
+static bool cwk_path_get_next_segment_joined(struct cwk_segment_joined *sj)
+{
+ bool result;
+
+ if (sj->paths[sj->path_index] == NULL) {
+ // We reached already the end of all paths, so there is no other segment
+ // left.
+ return false;
+ } else if (cwk_path_get_next_segment(&sj->segment)) {
+ // There was another segment on the current path, so we are good to
+ // continue.
+ return true;
+ }
+
+ // We try to move to the next path which has a segment available. We must at
+ // least move one further since the current path reached the end.
+ result = false;
+
+ do {
+ ++sj->path_index;
+
+ // And we obviously have to stop this loop if there are no more paths left.
+ if (sj->paths[sj->path_index] == NULL) {
+ break;
+ }
+
+ // Grab the first segment of the next path and determine whether this path
+ // has anything useful in it. There is one more thing we have to consider
+ // here - for the first time we do this we want to skip the root, but
+ // afterwards we will consider that to be part of the segments.
+ result = cwk_path_get_first_segment_without_root(sj->paths[sj->path_index],
+ sj->paths[sj->path_index], &sj->segment);
+
+ } while (!result);
+
+ // Finally, report the result back to the caller.
+ return result;
+}
+
+static bool cwk_path_get_previous_segment_joined(struct cwk_segment_joined *sj)
+{
+ bool result;
+
+ if (*sj->paths == NULL) {
+ // It's possible that there is no initialized segment available in the
+ // struct since there are no paths. In that case we can return false, since
+ // there is no previous segment.
+ return false;
+ } else if (cwk_path_get_previous_segment(&sj->segment)) {
+ // Now we try to get the previous segment from the current path. If we can
+ // do that successfully, we can let the caller know that we found one.
+ return true;
+ }
+
+ result = false;
+
+ do {
+ // We are done once we reached index 0. In that case there are no more
+ // segments left.
+ if (sj->path_index == 0) {
+ break;
+ }
+
+ // There is another path which we have to inspect. So we decrease the path
+ // index.
+ --sj->path_index;
+
+ // If this is the first path we will have to consider that this path might
+ // include a root, otherwise we just treat is as a segment.
+ if (sj->path_index == 0) {
+ result = cwk_path_get_last_segment(sj->paths[sj->path_index],
+ &sj->segment);
+ } else {
+ result = cwk_path_get_last_segment_without_root(sj->paths[sj->path_index],
+ &sj->segment);
+ }
+
+ } while (!result);
+
+ return result;
+}
+
+static bool cwk_path_segment_back_will_be_removed(struct cwk_segment_joined *sj)
+{
+ enum cwk_segment_type type;
+ int counter;
+
+ // We are handling back segments here. We must verify how many back segments
+ // and how many normal segments come before this one to decide whether we keep
+ // or remove it.
+
+ // The counter determines how many normal segments are our current segment,
+ // which will popped off before us. If the counter goes above zero it means
+ // that our segment will be popped as well.
+ counter = 0;
+
+ // We loop over all previous segments until we either reach the beginning,
+ // which means our segment will not be dropped or the counter goes above zero.
+ while (cwk_path_get_previous_segment_joined(sj)) {
+
+ // Now grab the type. The type determines whether we will increase or
+ // decrease the counter. We don't handle a CWK_CURRENT frame here since it
+ // has no influence.
+ type = cwk_path_get_segment_type(&sj->segment);
+ if (type == CWK_NORMAL) {
+ // This is a normal segment. The normal segment will increase the counter
+ // since it neutralizes one back segment. If we go above zero we can
+ // return immediately.
+ ++counter;
+ if (counter > 0) {
+ return true;
+ }
+ } else if (type == CWK_BACK) {
+ // A CWK_BACK segment will reduce the counter by one. We can not remove a
+ // back segment as long we are not above zero since we don't have the
+ // opposite normal segment which we would remove.
+ --counter;
+ }
+ }
+
+ // We never got a count larger than zero, so we will keep this segment alive.
+ return false;
+}
+
+static bool cwk_path_segment_normal_will_be_removed(
+ struct cwk_segment_joined *sj)
+{
+ enum cwk_segment_type type;
+ int counter;
+
+ // The counter determines how many segments are above our current segment,
+ // which will popped off before us. If the counter goes below zero it means
+ // that our segment will be popped as well.
+ counter = 0;
+
+ // We loop over all following segments until we either reach the end, which
+ // means our segment will not be dropped or the counter goes below zero.
+ while (cwk_path_get_next_segment_joined(sj)) {
+
+ // First, grab the type. The type determines whether we will increase or
+ // decrease the counter. We don't handle a CWK_CURRENT frame here since it
+ // has no influence.
+ type = cwk_path_get_segment_type(&sj->segment);
+ if (type == CWK_NORMAL) {
+ // This is a normal segment. The normal segment will increase the counter
+ // since it will be removed by a "../" before us.
+ ++counter;
+ } else if (type == CWK_BACK) {
+ // A CWK_BACK segment will reduce the counter by one. If we are below zero
+ // we can return immediately.
+ --counter;
+ if (counter < 0) {
+ return true;
+ }
+ }
+ }
+
+ // We never got a negative count, so we will keep this segment alive.
+ return false;
+}
+
+static bool
+cwk_path_segment_will_be_removed(const struct cwk_segment_joined *sj,
+ bool absolute)
+{
+ enum cwk_segment_type type;
+ struct cwk_segment_joined sjc;
+
+ // We copy the joined path so we don't need to modify it.
+ sjc = *sj;
+
+ // First we check whether this is a CWK_CURRENT or CWK_BACK segment, since
+ // those will always be dropped.
+ type = cwk_path_get_segment_type(&sj->segment);
+ if (type == CWK_CURRENT || (type == CWK_BACK && absolute)) {
+ return true;
+ } else if (type == CWK_BACK) {
+ return cwk_path_segment_back_will_be_removed(&sjc);
+ } else {
+ return cwk_path_segment_normal_will_be_removed(&sjc);
+ }
+}
+
+static bool
+cwk_path_segment_joined_skip_invisible(struct cwk_segment_joined *sj,
+ bool absolute)
+{
+ while (cwk_path_segment_will_be_removed(sj, absolute)) {
+ if (!cwk_path_get_next_segment_joined(sj)) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+static void cwk_path_get_root_windows(const char *path, size_t *length)
+{
+ const char *c;
+ bool is_device_path;
+
+ // We can not determine the root if this is an empty string. So we set the
+ // root to NULL and the length to zero and cancel the whole thing.
+ c = path;
+ *length = 0;
+ if (!*c) {
+ return;
+ }
+
+ // Now we have to verify whether this is a windows network path (UNC), which
+ // we will consider our root.
+ if (cwk_path_is_separator(c)) {
+ ++c;
+
+ // Check whether the path starts with a single backslash, which means this
+ // is not a network path - just a normal path starting with a backslash.
+ if (!cwk_path_is_separator(c)) {
+ // Okay, this is not a network path but we still use the backslash as a
+ // root.
+ ++(*length);
+ return;
+ }
+
+ // A device path is a path which starts with "\\." or "\\?". A device path
+ // can be a UNC path as well, in which case it will take up one more
+ // segment. So, this is a network or device path. Skip the previous
+ // separator. Now we need to determine whether this is a device path. We
+ // might advance one character here if the server name starts with a '?' or
+ // a '.', but that's fine since we will search for a separator afterwards
+ // anyway.
+ ++c;
+ is_device_path = (*c == '?' || *c == '.') && cwk_path_is_separator(++c);
+ if (is_device_path) {
+ // That's a device path, and the root must be either "\\.\" or "\\?\"
+ // which is 4 characters long. (at least that's how Windows
+ // GetFullPathName behaves.)
+ *length = 4;
+ return;
+ }
+
+ // We will grab anything up to the next stop. The next stop might be a '\0'
+ // or another separator. That will be the server name.
+ c = cwk_path_find_next_stop(c);
+
+ // If this is a separator and not the end of a string we wil have to include
+ // it. However, if this is a '\0' we must not skip it.
+ while (cwk_path_is_separator(c)) {
+ ++c;
+ }
+
+ // We are now skipping the shared folder name, which will end after the
+ // next stop.
+ c = cwk_path_find_next_stop(c);
+
+ // Then there might be a separator at the end. We will include that as well,
+ // it will mark the path as absolute.
+ if (cwk_path_is_separator(c)) {
+ ++c;
+ }
+
+ // Finally, calculate the size of the root.
+ *length = (size_t)(c - path);
+ return;
+ }
+
+ // Move to the next and check whether this is a colon.
+ if (*++c == ':') {
+ *length = 2;
+
+ // Now check whether this is a backslash (or slash). If it is not, we could
+ // assume that the next character is a '\0' if it is a valid path. However,
+ // we will not assume that - since ':' is not valid in a path it must be a
+ // mistake by the caller than. We will try to understand it anyway.
+ if (cwk_path_is_separator(++c)) {
+ *length = 3;
+ }
+ }
+}
+
+static void cwk_path_get_root_unix(const char *path, size_t *length)
+{
+ // The slash of the unix path represents the root. There is no root if there
+ // is no slash.
+ if (cwk_path_is_separator(path)) {
+ *length = 1;
+ } else {
+ *length = 0;
+ }
+}
+
+static bool cwk_path_is_root_absolute(const char *path, size_t length)
+{
+ // This is definitely not absolute if there is no root.
+ if (length == 0) {
+ return false;
+ }
+
+ // If there is a separator at the end of the root, we can safely consider this
+ // to be an absolute path.
+ return cwk_path_is_separator(&path[length - 1]);
+}
+
+static void cwk_path_fix_root(char *buffer, size_t buffer_size, size_t length)
+{
+ size_t i;
+
+ // This only affects windows.
+ if (path_style != CWK_STYLE_WINDOWS) {
+ return;
+ }
+
+ // Make sure we are not writing further than we are actually allowed to.
+ if (length > buffer_size) {
+ length = buffer_size;
+ }
+
+ // Replace all forward slashes with backwards slashes. Since this is windows
+ // we can't have any forward slashes in the root.
+ for (i = 0; i < length; ++i) {
+ if (cwk_path_is_separator(&buffer[i])) {
+ buffer[i] = *separators[CWK_STYLE_WINDOWS];
+ }
+ }
+}
+
+static size_t cwk_path_join_and_normalize_multiple(const char **paths,
+ char *buffer, size_t buffer_size)
+{
+ size_t pos;
+ bool absolute, has_segment_output;
+ struct cwk_segment_joined sj;
+
+ // We initialize the position after the root, which should get us started.
+ cwk_path_get_root(paths[0], &pos);
+
+ // Determine whether the path is absolute or not. We need that to determine
+ // later on whether we can remove superfluous "../" or not.
+ absolute = cwk_path_is_root_absolute(paths[0], pos);
+
+ // First copy the root to the output. After copying, we will normalize the
+ // root.
+ cwk_path_output_sized(buffer, buffer_size, 0, paths[0], pos);
+ cwk_path_fix_root(buffer, buffer_size, pos);
+
+ // So we just grab the first segment. If there is no segment we will always
+ // output a "/", since we currently only support absolute paths here.
+ if (!cwk_path_get_first_segment_joined(paths, &sj)) {
+ goto done;
+ }
+
+ // Let's assume that we don't have any segment output for now. We will toggle
+ // this flag once there is some output.
+ has_segment_output = false;
+
+ do {
+ // Check whether we have to drop this segment because of resolving a
+ // relative path or because it is a CWK_CURRENT segment.
+ if (cwk_path_segment_will_be_removed(&sj, absolute)) {
+ continue;
+ }
+
+ // We add a separator if we previously wrote a segment. The last segment
+ // must not have a trailing separator. This must happen before the segment
+ // output, since we would override the null terminating character with
+ // reused buffers if this was done afterwards.
+ if (has_segment_output) {
+ pos += cwk_path_output_separator(buffer, buffer_size, pos);
+ }
+
+ // Remember that we have segment output, so we can handle the trailing slash
+ // later on. This is necessary since we might have segments but they are all
+ // removed.
+ has_segment_output = true;
+
+ // Write out the segment but keep in mind that we need to follow the
+ // buffer size limitations. That's why we use the path output functions
+ // here.
+ pos += cwk_path_output_sized(buffer, buffer_size, pos, sj.segment.begin,
+ sj.segment.size);
+ } while (cwk_path_get_next_segment_joined(&sj));
+
+ // Remove the trailing slash, but only if we have segment output. We don't
+ // want to remove anything from the root.
+ if (!has_segment_output && pos == 0) {
+ // This may happen if the path is absolute and all segments have been
+ // removed. We can not have an empty output - and empty output means we stay
+ // in the current directory. So we will output a ".".
+ assert(absolute == false);
+ pos += cwk_path_output_current(buffer, buffer_size, pos);
+ }
+
+ // We must append a '\0' in any case, unless the buffer size is zero. If the
+ // buffer size is zero, which means we can not.
+done:
+ cwk_path_terminate_output(buffer, buffer_size, pos);
+
+ // And finally let our caller know about the total size of the normalized
+ // path.
+ return pos;
+}
+
+size_t cwk_path_get_absolute(const char *base, const char *path, char *buffer,
+ size_t buffer_size)
+{
+ size_t i;
+ const char *paths[4];
+
+ // The basename should be an absolute path if the caller is using the API
+ // correctly. However, he might not and in that case we will append a fake
+ // root at the beginning.
+ if (cwk_path_is_absolute(base)) {
+ i = 0;
+ } else if (path_style == CWK_STYLE_WINDOWS) {
+ paths[0] = "\\";
+ i = 1;
+ } else {
+ paths[0] = "/";
+ i = 1;
+ }
+
+ if (cwk_path_is_absolute(path)) {
+ // If the submitted path is not relative the base path becomes irrelevant.
+ // We will only normalize the submitted path instead.
+ paths[i++] = path;
+ paths[i] = NULL;
+ } else {
+ // Otherwise we append the relative path to the base path and normalize it.
+ // The result will be a new absolute path.
+ paths[i++] = base;
+ paths[i++] = path;
+ paths[i] = NULL;
+ }
+
+ // Finally join everything together and normalize it.
+ return cwk_path_join_and_normalize_multiple(paths, buffer, buffer_size);
+}
+
+static void cwk_path_skip_segments_until_diverge(struct cwk_segment_joined *bsj,
+ struct cwk_segment_joined *osj, bool absolute, bool *base_available,
+ bool *other_available)
+{
+ // Now looping over all segments until they start to diverge. A path may
+ // diverge if two segments are not equal or if one path reaches the end.
+ do {
+
+ // Check whether there is anything available after we skip everything which
+ // is invisible. We do that for both paths, since we want to let the caller
+ // know which path has some trailing segments after they diverge.
+ *base_available = cwk_path_segment_joined_skip_invisible(bsj, absolute);
+ *other_available = cwk_path_segment_joined_skip_invisible(osj, absolute);
+
+ // We are done if one or both of those paths reached the end. They either
+ // diverge or both reached the end - but in both cases we can not continue
+ // here.
+ if (!*base_available || !*other_available) {
+ break;
+ }
+
+ // Compare the content of both segments. We are done if they are not equal,
+ // since they diverge.
+ if (!cwk_path_is_string_equal(bsj->segment.begin, osj->segment.begin,
+ bsj->segment.size, osj->segment.size)) {
+ break;
+ }
+
+ // We keep going until one of those segments reached the end. The next
+ // segment might be invisible, but we will check for that in the beginning
+ // of the loop once again.
+ *base_available = cwk_path_get_next_segment_joined(bsj);
+ *other_available = cwk_path_get_next_segment_joined(osj);
+ } while (*base_available && *other_available);
+}
+
+size_t cwk_path_get_relative(const char *base_directory, const char *path,
+ char *buffer, size_t buffer_size)
+{
+ size_t pos, base_root_length, path_root_length;
+ bool absolute, base_available, other_available, has_output;
+ const char *base_paths[2], *other_paths[2];
+ struct cwk_segment_joined bsj, osj;
+
+ pos = 0;
+
+ // First we compare the roots of those two paths. If the roots are not equal
+ // we can't continue, since there is no way to get a relative path from
+ // different roots.
+ cwk_path_get_root(base_directory, &base_root_length);
+ cwk_path_get_root(path, &path_root_length);
+ if (base_root_length != path_root_length ||
+ !cwk_path_is_string_equal(base_directory, path, base_root_length,
+ path_root_length)) {
+ cwk_path_terminate_output(buffer, buffer_size, pos);
+ return pos;
+ }
+
+ // Verify whether this is an absolute path. We need to know that since we can
+ // remove all back-segments if it is.
+ absolute = cwk_path_is_root_absolute(base_directory, base_root_length);
+
+ // Initialize our joined segments. This will allow us to use the internal
+ // functions to skip until diverge and invisible. We only have one path in
+ // them though.
+ base_paths[0] = base_directory;
+ base_paths[1] = NULL;
+ other_paths[0] = path;
+ other_paths[1] = NULL;
+ cwk_path_get_first_segment_joined(base_paths, &bsj);
+ cwk_path_get_first_segment_joined(other_paths, &osj);
+
+ // Okay, now we skip until the segments diverge. We don't have anything to do
+ // with the segments which are equal.
+ cwk_path_skip_segments_until_diverge(&bsj, &osj, absolute, &base_available,
+ &other_available);
+
+ // Assume there is no output until we have got some. We will need this
+ // information later on to remove trailing slashes or alternatively output a
+ // current-segment.
+ has_output = false;
+
+ // So if we still have some segments left in the base path we will now output
+ // a back segment for all of them.
+ if (base_available) {
+ do {
+ // Skip any invisible segment. We don't care about those and we don't need
+ // to navigate back because of them.
+ if (!cwk_path_segment_joined_skip_invisible(&bsj, absolute)) {
+ break;
+ }
+
+ // Toggle the flag if we have output. We need to remember that, since we
+ // want to remove the trailing slash.
+ has_output = true;
+
+ // Output the back segment and a separator. No need to worry about the
+ // superfluous segment since it will be removed later on.
+ pos += cwk_path_output_back(buffer, buffer_size, pos);
+ pos += cwk_path_output_separator(buffer, buffer_size, pos);
+ } while (cwk_path_get_next_segment_joined(&bsj));
+ }
+
+ // And if we have some segments available of the target path we will output
+ // all of those.
+ if (other_available) {
+ do {
+ // Again, skip any invisible segments since we don't need to navigate into
+ // them.
+ if (!cwk_path_segment_joined_skip_invisible(&osj, absolute)) {
+ break;
+ }
+
+ // Toggle the flag if we have output. We need to remember that, since we
+ // want to remove the trailing slash.
+ has_output = true;
+
+ // Output the current segment and a separator. No need to worry about the
+ // superfluous segment since it will be removed later on.
+ pos += cwk_path_output_sized(buffer, buffer_size, pos, osj.segment.begin,
+ osj.segment.size);
+ pos += cwk_path_output_separator(buffer, buffer_size, pos);
+ } while (cwk_path_get_next_segment_joined(&osj));
+ }
+
+ // If we have some output by now we will have to remove the trailing slash. We
+ // simply do that by moving back one character. The terminate output function
+ // will then place the '\0' on this position. Otherwise, if there is no
+ // output, we will have to output a "current directory", since the target path
+ // points to the base path.
+ if (has_output) {
+ --pos;
+ } else {
+ pos += cwk_path_output_current(buffer, buffer_size, pos);
+ }
+
+ // Finally, we can terminate the output - which means we place a '\0' at the
+ // current position or at the end of the buffer.
+ cwk_path_terminate_output(buffer, buffer_size, pos);
+
+ return pos;
+}
+
+size_t cwk_path_join(const char *path_a, const char *path_b, char *buffer,
+ size_t buffer_size)
+{
+ const char *paths[3];
+
+ // This is simple. We will just create an array with the two paths which we
+ // wish to join.
+ paths[0] = path_a;
+ paths[1] = path_b;
+ paths[2] = NULL;
+
+ // And then call the join and normalize function which will do the hard work
+ // for us.
+ return cwk_path_join_and_normalize_multiple(paths, buffer, buffer_size);
+}
+
+size_t cwk_path_join_multiple(const char **paths, char *buffer,
+ size_t buffer_size)
+{
+ // We can just call the internal join and normalize function for this one,
+ // since it will handle everything.
+ return cwk_path_join_and_normalize_multiple(paths, buffer, buffer_size);
+}
+
+void cwk_path_get_root(const char *path, size_t *length)
+{
+ // We use a different implementation here based on the configuration of the
+ // library.
+ if (path_style == CWK_STYLE_WINDOWS) {
+ cwk_path_get_root_windows(path, length);
+ } else {
+ cwk_path_get_root_unix(path, length);
+ }
+}
+
+size_t cwk_path_change_root(const char *path, const char *new_root,
+ char *buffer, size_t buffer_size)
+{
+ const char *tail;
+ size_t root_length, path_length, tail_length, new_root_length, new_path_size;
+
+ // First we need to determine the actual size of the root which we will
+ // change.
+ cwk_path_get_root(path, &root_length);
+
+ // Now we determine the sizes of the new root and the path. We need that to
+ // determine the size of the part after the root (the tail).
+ new_root_length = strlen(new_root);
+ path_length = strlen(path);
+
+ // Okay, now we calculate the position of the tail and the length of it.
+ tail = path + root_length;
+ tail_length = path_length - root_length;
+
+ // We first output the tail and then the new root, that's because the source
+ // path and the buffer may be overlapping. This way the root will not
+ // overwrite the tail.
+ cwk_path_output_sized(buffer, buffer_size, new_root_length, tail,
+ tail_length);
+ cwk_path_output_sized(buffer, buffer_size, 0, new_root, new_root_length);
+
+ // Finally we calculate the size o the new path and terminate the output with
+ // a '\0'.
+ new_path_size = tail_length + new_root_length;
+ cwk_path_terminate_output(buffer, buffer_size, new_path_size);
+
+ return new_path_size;
+}
+
+bool cwk_path_is_absolute(const char *path)
+{
+ size_t length;
+
+ // We grab the root of the path. This root does not include the first
+ // separator of a path.
+ cwk_path_get_root(path, &length);
+
+ // Now we can determine whether the root is absolute or not.
+ return cwk_path_is_root_absolute(path, length);
+}
+
+bool cwk_path_is_relative(const char *path)
+{
+ // The path is relative if it is not absolute.
+ return !cwk_path_is_absolute(path);
+}
+
+void cwk_path_get_basename(const char *path, const char **basename,
+ size_t *length)
+{
+ struct cwk_segment segment;
+
+ // We get the last segment of the path. The last segment will contain the
+ // basename if there is any. If there are no segments we will set the basename
+ // to NULL and the length to 0.
+ if (!cwk_path_get_last_segment(path, &segment)) {
+ *basename = NULL;
+ if (length) {
+ *length = 0;
+ }
+ return;
+ }
+
+ // Now we can just output the segment contents, since that's our basename.
+ // There might be trailing separators after the basename, but the size does
+ // not include those.
+ *basename = segment.begin;
+ if (length) {
+ *length = segment.size;
+ }
+}
+
+size_t cwk_path_change_basename(const char *path, const char *new_basename,
+ char *buffer, size_t buffer_size)
+{
+ struct cwk_segment segment;
+ size_t pos, root_size, new_basename_size;
+
+ // First we try to get the last segment. We may only have a root without any
+ // segments, in which case we will create one.
+ if (!cwk_path_get_last_segment(path, &segment)) {
+
+ // So there is no segment in this path. First we grab the root and output
+ // that. We are not going to modify the root in any way.
+ cwk_path_get_root(path, &root_size);
+ pos = cwk_path_output_sized(buffer, buffer_size, 0, path, root_size);
+
+ // We have to trim the separators from the beginning of the new basename.
+ // This is quite easy to do.
+ while (cwk_path_is_separator(new_basename)) {
+ ++new_basename;
+ }
+
+ // Now we measure the length of the new basename, this is a two step
+ // process. First we find the '\0' character at the end of the string.
+ new_basename_size = 0;
+ while (new_basename[new_basename_size]) {
+ ++new_basename_size;
+ }
+
+ // And then we trim the separators at the end of the basename until we reach
+ // the first valid character.
+ while (new_basename_size > 0 &&
+ cwk_path_is_separator(&new_basename[new_basename_size - 1])) {
+ --new_basename_size;
+ }
+
+ // Now we will output the new basename after the root.
+ pos += cwk_path_output_sized(buffer, buffer_size, pos, new_basename,
+ new_basename_size);
+
+ // And finally terminate the output and return the total size of the path.
+ cwk_path_terminate_output(buffer, buffer_size, pos);
+ return pos;
+ }
+
+ // If there is a last segment we can just forward this call, which is fairly
+ // easy.
+ return cwk_path_change_segment(&segment, new_basename, buffer, buffer_size);
+}
+
+void cwk_path_get_dirname(const char *path, size_t *length)
+{
+ struct cwk_segment segment;
+
+ // We get the last segment of the path. The last segment will contain the
+ // basename if there is any. If there are no segments we will set the length
+ // to 0.
+ if (!cwk_path_get_last_segment(path, &segment)) {
+ *length = 0;
+ return;
+ }
+
+ // We can now return the length from the beginning of the string up to the
+ // beginning of the last segment.
+ *length = (size_t)(segment.begin - path);
+}
+
+bool cwk_path_get_extension(const char *path, const char **extension,
+ size_t *length)
+{
+ struct cwk_segment segment;
+ const char *c;
+
+ // We get the last segment of the path. The last segment will contain the
+ // extension if there is any.
+ if (!cwk_path_get_last_segment(path, &segment)) {
+ return false;
+ }
+
+ // Now we search for a dot within the segment. If there is a dot, we consider
+ // the rest of the segment the extension. We do this from the end towards the
+ // beginning, since we want to find the last dot.
+ for (c = segment.end; c >= segment.begin; --c) {
+ if (*c == '.') {
+ // Okay, we found an extension. We can stop looking now.
+ *extension = c;
+ *length = (size_t)(segment.end - c);
+ return true;
+ }
+ }
+
+ // We couldn't find any extension.
+ return false;
+}
+
+bool cwk_path_has_extension(const char *path)
+{
+ const char *extension;
+ size_t length;
+
+ // We just wrap the get_extension call which will then do the work for us.
+ return cwk_path_get_extension(path, &extension, &length);
+}
+
+size_t cwk_path_change_extension(const char *path, const char *new_extension,
+ char *buffer, size_t buffer_size)
+{
+ struct cwk_segment segment;
+ const char *c, *old_extension;
+ size_t pos, root_size, trail_size, new_extension_size;
+
+ // First we try to get the last segment. We may only have a root without any
+ // segments, in which case we will create one.
+ if (!cwk_path_get_last_segment(path, &segment)) {
+
+ // So there is no segment in this path. First we grab the root and output
+ // that. We are not going to modify the root in any way. If there is no
+ // root, this will end up with a root size 0, and nothing will be written.
+ cwk_path_get_root(path, &root_size);
+ pos = cwk_path_output_sized(buffer, buffer_size, 0, path, root_size);
+
+ // Add a dot if the submitted value doesn't have any.
+ if (*new_extension != '.') {
+ pos += cwk_path_output_dot(buffer, buffer_size, pos);
+ }
+
+ // And finally terminate the output and return the total size of the path.
+ pos += cwk_path_output(buffer, buffer_size, pos, new_extension);
+ cwk_path_terminate_output(buffer, buffer_size, pos);
+ return pos;
+ }
+
+ // Now we seek the old extension in the last segment, which we will replace
+ // with the new one. If there is no old extension, it will point to the end of
+ // the segment.
+ old_extension = segment.end;
+ for (c = segment.begin; c < segment.end; ++c) {
+ if (*c == '.') {
+ old_extension = c;
+ }
+ }
+
+ pos = cwk_path_output_sized(buffer, buffer_size, 0, segment.path,
+ (size_t)(old_extension - segment.path));
+
+ // If the new extension starts with a dot, we will skip that dot. We always
+ // output exactly one dot before the extension. If the extension contains
+ // multiple dots, we will output those as part of the extension.
+ if (*new_extension == '.') {
+ ++new_extension;
+ }
+
+ // We calculate the size of the new extension, including the dot, in order to
+ // output the trail - which is any part of the path coming after the
+ // extension. We must output this first, since the buffer may overlap with the
+ // submitted path - and it would be overridden by longer extensions.
+ new_extension_size = strlen(new_extension) + 1;
+ trail_size = cwk_path_output(buffer, buffer_size, pos + new_extension_size,
+ segment.end);
+
+ // Finally we output the dot and the new extension. The new extension itself
+ // doesn't contain the dot anymore, so we must output that first.
+ pos += cwk_path_output_dot(buffer, buffer_size, pos);
+ pos += cwk_path_output(buffer, buffer_size, pos, new_extension);
+
+ // Now we terminate the output with a null-terminating character, but before
+ // we do that we must add the size of the trail to the position which we
+ // output before.
+ pos += trail_size;
+ cwk_path_terminate_output(buffer, buffer_size, pos);
+
+ // And the position is our output size now.
+ return pos;
+}
+
+size_t cwk_path_normalize(const char *path, char *buffer, size_t buffer_size)
+{
+ const char *paths[2];
+
+ // Now we initialize the paths which we will normalize. Since this function
+ // only supports submitting a single path, we will only add that one.
+ paths[0] = path;
+ paths[1] = NULL;
+
+ return cwk_path_join_and_normalize_multiple(paths, buffer, buffer_size);
+}
+
+size_t cwk_path_get_intersection(const char *path_base, const char *path_other)
+{
+ bool absolute;
+ size_t base_root_length, other_root_length;
+ const char *end;
+ const char *paths_base[2], *paths_other[2];
+ struct cwk_segment_joined base, other;
+
+ // We first compare the two roots. We just return zero if they are not equal.
+ // This will also happen to return zero if the paths are mixed relative and
+ // absolute.
+ cwk_path_get_root(path_base, &base_root_length);
+ cwk_path_get_root(path_other, &other_root_length);
+ if (!cwk_path_is_string_equal(path_base, path_other, base_root_length,
+ other_root_length)) {
+ return 0;
+ }
+
+ // Configure our paths. We just have a single path in here for now.
+ paths_base[0] = path_base;
+ paths_base[1] = NULL;
+ paths_other[0] = path_other;
+ paths_other[1] = NULL;
+
+ // So we get the first segment of both paths. If one of those paths don't have
+ // any segment, we will return 0.
+ if (!cwk_path_get_first_segment_joined(paths_base, &base) ||
+ !cwk_path_get_first_segment_joined(paths_other, &other)) {
+ return base_root_length;
+ }
+
+ // We now determine whether the path is absolute or not. This is required
+ // because if will ignore removed segments, and this behaves differently if
+ // the path is absolute. However, we only need to check the base path because
+ // we are guaranteed that both paths are either relative or absolute.
+ absolute = cwk_path_is_root_absolute(path_base, base_root_length);
+
+ // We must keep track of the end of the previous segment. Initially, this is
+ // set to the beginning of the path. This means that 0 is returned if the
+ // first segment is not equal.
+ end = path_base + base_root_length;
+
+ // Now we loop over both segments until one of them reaches the end or their
+ // contents are not equal.
+ do {
+ // We skip all segments which will be removed in each path, since we want to
+ // know about the true path.
+ if (!cwk_path_segment_joined_skip_invisible(&base, absolute) ||
+ !cwk_path_segment_joined_skip_invisible(&other, absolute)) {
+ break;
+ }
+
+ if (!cwk_path_is_string_equal(base.segment.begin, other.segment.begin,
+ base.segment.size, other.segment.size)) {
+ // So the content of those two segments are not equal. We will return the
+ // size up to the beginning.
+ return (size_t)(end - path_base);
+ }
+
+ // Remember the end of the previous segment before we go to the next one.
+ end = base.segment.end;
+ } while (cwk_path_get_next_segment_joined(&base) &&
+ cwk_path_get_next_segment_joined(&other));
+
+ // Now we calculate the length up to the last point where our paths pointed to
+ // the same place.
+ return (size_t)(end - path_base);
+}
+
+bool cwk_path_get_first_segment(const char *path, struct cwk_segment *segment)
+{
+ size_t length;
+ const char *segments;
+
+ // We skip the root since that's not part of the first segment. The root is
+ // treated as a separate entity.
+ cwk_path_get_root(path, &length);
+ segments = path + length;
+
+ // Now, after we skipped the root we can continue and find the actual segment
+ // content.
+ return cwk_path_get_first_segment_without_root(path, segments, segment);
+}
+
+bool cwk_path_get_last_segment(const char *path, struct cwk_segment *segment)
+{
+ // We first grab the first segment. This might be our last segment as well,
+ // but we don't know yet. There is no last segment if there is no first
+ // segment, so we return false in that case.
+ if (!cwk_path_get_first_segment(path, segment)) {
+ return false;
+ }
+
+ // Now we find our last segment. The segment struct of the caller
+ // will contain the last segment, since the function we call here will not
+ // change the segment struct when it reaches the end.
+ while (cwk_path_get_next_segment(segment)) {
+ // We just loop until there is no other segment left.
+ }
+
+ return true;
+}
+
+bool cwk_path_get_next_segment(struct cwk_segment *segment)
+{
+ const char *c;
+
+ // First we jump to the end of the previous segment. The first character must
+ // be either a '\0' or a separator.
+ c = segment->begin + segment->size;
+ if (*c == '\0') {
+ return false;
+ }
+
+ // Now we skip all separator until we reach something else. We are not yet
+ // guaranteed to have a segment, since the string could just end afterwards.
+ assert(cwk_path_is_separator(c));
+ do {
+ ++c;
+ } while (cwk_path_is_separator(c));
+
+ // If the string ends here, we can safely assume that there is no other
+ // segment after this one.
+ if (*c == '\0') {
+ return false;
+ }
+
+ // Now we are safe to assume there is a segment. We store the beginning of
+ // this segment in the segment struct of the caller.
+ segment->begin = c;
+
+ // And now determine the size of this segment, and store it in the struct of
+ // the caller as well.
+ c = cwk_path_find_next_stop(c);
+ segment->end = c;
+ segment->size = (size_t)(c - segment->begin);
+
+ // Tell the caller that we found a segment.
+ return true;
+}
+
+bool cwk_path_get_previous_segment(struct cwk_segment *segment)
+{
+ const char *c;
+
+ // The current position might point to the first character of the path, which
+ // means there are no previous segments available.
+ c = segment->begin;
+ if (c <= segment->segments) {
+ return false;
+ }
+
+ // We move towards the beginning of the path until we either reached the
+ // beginning or the character is no separator anymore.
+ do {
+ --c;
+ if (c < segment->segments) {
+ // So we reached the beginning here and there is no segment. So we return
+ // false and don't change the segment structure submitted by the caller.
+ return false;
+ }
+ } while (cwk_path_is_separator(c));
+
+ // We are guaranteed now that there is another segment, since we moved before
+ // the previous separator and did not reach the segment path beginning.
+ segment->end = c + 1;
+ segment->begin = cwk_path_find_previous_stop(segment->segments, c);
+ segment->size = (size_t)(segment->end - segment->begin);
+
+ return true;
+}
+
+enum cwk_segment_type cwk_path_get_segment_type(
+ const struct cwk_segment *segment)
+{
+ // We just make a string comparison with the segment contents and return the
+ // appropriate type.
+ if (strncmp(segment->begin, ".", segment->size) == 0) {
+ return CWK_CURRENT;
+ } else if (strncmp(segment->begin, "..", segment->size) == 0) {
+ return CWK_BACK;
+ }
+
+ return CWK_NORMAL;
+}
+
+bool cwk_path_is_separator(const char *str)
+{
+ const char *c;
+
+ // We loop over all characters in the read symbols.
+ c = separators[path_style];
+ while (*c) {
+ if (*c == *str) {
+ return true;
+ }
+
+ ++c;
+ }
+
+ return false;
+}
+
+size_t cwk_path_change_segment(struct cwk_segment *segment, const char *value,
+ char *buffer, size_t buffer_size)
+{
+ size_t pos, value_size, tail_size;
+
+ // First we have to output the head, which is the whole string up to the
+ // beginning of the segment. This part of the path will just stay the same.
+ pos = cwk_path_output_sized(buffer, buffer_size, 0, segment->path,
+ (size_t)(segment->begin - segment->path));
+
+ // In order to trip the submitted value, we will skip any separator at the
+ // beginning of it and behave as if it was never there.
+ while (cwk_path_is_separator(value)) {
+ ++value;
+ }
+
+ // Now we determine the length of the value. In order to do that we first
+ // locate the '\0'.
+ value_size = 0;
+ while (value[value_size]) {
+ ++value_size;
+ }
+
+ // Since we trim separators at the beginning and in the end of the value we
+ // have to subtract from the size until there are either no more characters
+ // left or the last character is no separator.
+ while (value_size > 0 && cwk_path_is_separator(&value[value_size - 1])) {
+ --value_size;
+ }
+
+ // We also have to determine the tail size, which is the part of the string
+ // following the current segment. This part will not change.
+ tail_size = strlen(segment->end);
+
+ // Now we output the tail. We have to do that, because if the buffer and the
+ // source are overlapping we would override the tail if the value is
+ // increasing in length.
+ cwk_path_output_sized(buffer, buffer_size, pos + value_size, segment->end,
+ tail_size);
+
+ // Finally we can output the value in the middle of the head and the tail,
+ // where we have enough space to fit the whole trimmed value.
+ pos += cwk_path_output_sized(buffer, buffer_size, pos, value, value_size);
+
+ // Now we add the tail size to the current position and terminate the output -
+ // basically, ensure that there is a '\0' at the end of the buffer.
+ pos += tail_size;
+ cwk_path_terminate_output(buffer, buffer_size, pos);
+
+ // And now tell the caller how long the whole path would be.
+ return pos;
+}
+
+enum cwk_path_style cwk_path_guess_style(const char *path)
+{
+ const char *c;
+ size_t root_length;
+ struct cwk_segment segment;
+
+ // First we determine the root. Only windows roots can be longer than a single
+ // slash, so if we can determine that it starts with something like "C:", we
+ // know that this is a windows path.
+ cwk_path_get_root_windows(path, &root_length);
+ if (root_length > 1) {
+ return CWK_STYLE_WINDOWS;
+ }
+
+ // Next we check for slashes. Windows uses backslashes, while unix uses
+ // forward slashes. Windows actually supports both, but our best guess is to
+ // assume windows with backslashes and unix with forward slashes.
+ for (c = path; *c; ++c) {
+ if (*c == *separators[CWK_STYLE_UNIX]) {
+ return CWK_STYLE_UNIX;
+ } else if (*c == *separators[CWK_STYLE_WINDOWS]) {
+ return CWK_STYLE_WINDOWS;
+ }
+ }
+
+ // This path does not have any slashes. We grab the last segment (which
+ // actually must be the first one), and determine whether the segment starts
+ // with a dot. A dot is a hidden folder or file in the UNIX world, in that
+ // case we assume the path to have UNIX style.
+ if (!cwk_path_get_last_segment(path, &segment)) {
+ // We couldn't find any segments, so we default to a UNIX path style since
+ // there is no way to make any assumptions.
+ return CWK_STYLE_UNIX;
+ }
+
+ if (*segment.begin == '.') {
+ return CWK_STYLE_UNIX;
+ }
+
+ // And finally we check whether the last segment contains a dot. If it
+ // contains a dot, that might be an extension. Windows is more likely to have
+ // file names with extensions, so our guess would be windows.
+ for (c = segment.begin; *c; ++c) {
+ if (*c == '.') {
+ return CWK_STYLE_WINDOWS;
+ }
+ }
+
+ // All our checks failed, so we will return a default value which is currently
+ // UNIX.
+ return CWK_STYLE_UNIX;
+}
+
+void cwk_path_set_style(enum cwk_path_style style)
+{
+ // We can just set the global path style variable and then the behaviour for
+ // all functions will change accordingly.
+ assert(style == CWK_STYLE_UNIX || style == CWK_STYLE_WINDOWS);
+ path_style = style;
+}
+
+enum cwk_path_style cwk_path_get_style(void)
+{
+ // Simply return the path style which we store in a global variable.
+ return path_style;
+}
diff --git a/src/aux/cwalk/test/absolute_test.c b/src/aux/cwalk/test/absolute_test.c
@@ -0,0 +1,206 @@
+#include <cwalk.h>
+#include <memory.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+
+int absolute_check(void)
+{
+ const char *relative_paths[] = {"..", "test", "test/test", "../another_test",
+ "./simple", ".././simple"};
+ const char *absolute_paths[] = {"/", "/test", "/../test/", "/../another_test",
+ "/./simple", "/.././simple"};
+ size_t i;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ for (i = 0; i < ARRAY_SIZE(relative_paths); ++i) {
+ if (cwk_path_is_absolute(relative_paths[i])) {
+ return EXIT_FAILURE;
+ }
+ }
+
+ for (i = 0; i < ARRAY_SIZE(absolute_paths); ++i) {
+ if (!cwk_path_is_absolute(absolute_paths[i])) {
+ return EXIT_FAILURE;
+ }
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int absolute_too_far(void)
+{
+ char buffer[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ length = cwk_path_get_absolute("/hello/there", "../../../../../", buffer,
+ sizeof(buffer));
+
+ if (length != 1) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "/") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int absolute_normalization(void)
+{
+ char buffer[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ length = cwk_path_get_absolute("/hello//../there", "test//thing", buffer,
+ sizeof(buffer));
+
+ if (length != 17) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "/there/test/thing") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int absolute_mixed(void)
+{
+ char buffer[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ length = cwk_path_get_absolute("hello/there", "/test", buffer,
+ sizeof(buffer));
+
+ if (length != 5) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "/test") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int absolute_unix_relative_base(void)
+{
+ char buffer[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ length = cwk_path_get_absolute("hello/there", "test", buffer, sizeof(buffer));
+
+ if (length != 17) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "/hello/there/test") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int absolute_windows_relative_base(void)
+{
+ char buffer[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ length = cwk_path_get_absolute("hello\\there", "test", buffer, sizeof(buffer));
+
+ if (length != 17) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "\\hello\\there\\test") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int absolute_absolute_path(void)
+{
+ char buffer[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ length = cwk_path_get_absolute("/hello/there", "/test", buffer,
+ sizeof(buffer));
+
+ if (length != 5) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "/test") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int absolute_simple(void)
+{
+ char buffer[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ length = cwk_path_get_absolute("/hello/there", "..", buffer, sizeof(buffer));
+
+ if (length != 6) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "/hello") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+
+int absolute_buffer_reuse(void)
+{
+ char path[FILENAME_MAX];
+
+ memset(path, 1, FILENAME_MAX);
+ path[0] = '\0';
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ cwk_path_get_absolute(path, "/", path, FILENAME_MAX);
+ if (strcmp(path, "/") != 0) {
+ return EXIT_FAILURE;
+ }
+ cwk_path_get_absolute(path, "see", path, FILENAME_MAX);
+ if (strcmp(path, "/see") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ cwk_path_get_absolute(path, "dog", path, FILENAME_MAX);
+ if (strcmp(path, "/see/dog") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ cwk_path_get_absolute(path, "..", path, FILENAME_MAX);
+ if (strcmp(path, "/see") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ cwk_path_get_absolute(path, "cat", path, FILENAME_MAX);
+ if (strcmp(path, "/see/cat") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
diff --git a/src/aux/cwalk/test/basename_test.c b/src/aux/cwalk/test/basename_test.c
@@ -0,0 +1,313 @@
+#include <cwalk.h>
+#include <memory.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int basename_change_trim_only_root(void)
+{
+ size_t n;
+ char buffer[FILENAME_MAX];
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ n = cwk_path_change_basename("/", "///another.txt///", buffer,
+ sizeof(buffer));
+ if (n != 12) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "/another.txt") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int basename_change_trim(void)
+{
+ size_t n;
+ char buffer[FILENAME_MAX];
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ n = cwk_path_change_basename("/test.txt", "///another.txt///", buffer,
+ sizeof(buffer));
+ if (n != 12) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "/another.txt") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int basename_change_relative(void)
+{
+ size_t n;
+ char buffer[FILENAME_MAX];
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ n = cwk_path_change_basename("../test.txt", "another.txt", buffer,
+ sizeof(buffer));
+ if (n != 14) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "../another.txt") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int basename_change_empty_basename(void)
+{
+ size_t n;
+ char buffer[FILENAME_MAX];
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ n = cwk_path_change_basename("C:\\test.txt", "", buffer, sizeof(buffer));
+ if (n != 3) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "C:\\") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int basename_change_only_root(void)
+{
+ size_t n;
+ char buffer[FILENAME_MAX];
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ n = cwk_path_change_basename("C:\\", "another.txt", buffer, sizeof(buffer));
+ if (n != 14) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "C:\\another.txt") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int basename_change_empty_path(void)
+{
+ size_t n;
+ char buffer[FILENAME_MAX];
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ n = cwk_path_change_basename("", "another.txt", buffer, sizeof(buffer));
+ if (n != 11) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "another.txt") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int basename_change_simple(void)
+{
+ size_t n;
+ char buffer[FILENAME_MAX];
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ n = cwk_path_change_basename("C:\\test.txt", "another.txt", buffer,
+ sizeof(buffer));
+ if (n != 14) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "C:\\another.txt") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int basename_windows(void)
+{
+ const char *path, *basename;
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ path = "C:\\path\\test.txt";
+ cwk_path_get_basename(path, &basename, &length);
+
+ if (length != 8) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(basename, "test.txt") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int basename_root(void)
+{
+ const char *path, *basename;
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ path = "/";
+ cwk_path_get_basename(path, &basename, &length);
+
+ if (length != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (basename != NULL) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int basename_special_directories(void)
+{
+ const char *path, *basename;
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ path = "..";
+ cwk_path_get_basename(path, &basename, &length);
+
+ if (length != 2) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(basename, "..", length) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ path = ".";
+ cwk_path_get_basename(path, &basename, &length);
+
+ if (length != 1) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(basename, ".", length) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int basename_no_separators(void)
+{
+ const char *path, *basename;
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ path = "file_name";
+ cwk_path_get_basename(path, &basename, &length);
+
+ if (length != 9) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(basename, "file_name", length) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int basename_trailing_separators(void)
+{
+ const char *path, *basename;
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ path = "/my/path.txt////";
+ cwk_path_get_basename(path, &basename, &length);
+
+ if (length != 8) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(basename, "path.txt", length) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int basename_trailing_separator(void)
+{
+ const char *path, *basename;
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ path = "/my/path.txt/";
+ cwk_path_get_basename(path, &basename, &length);
+
+ if (length != 8) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(basename, "path.txt", length) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int basename_empty(void)
+{
+ const char *path, *basename;
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ path = "";
+ cwk_path_get_basename(path, &basename, &length);
+
+ if (length != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (basename != NULL) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int basename_simple(void)
+{
+ const char *path, *basename;
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ path = "/my/path.txt";
+ cwk_path_get_basename(path, &basename, &length);
+
+ if (length != 8) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(basename, "path.txt", length) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
diff --git a/src/aux/cwalk/test/dirname_test.c b/src/aux/cwalk/test/dirname_test.c
@@ -0,0 +1,154 @@
+#include <cwalk.h>
+#include <memory.h>
+#include <stdlib.h>
+
+int dirname_relative(void)
+{
+ const char *path;
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ path = "../one/two.txt";
+ cwk_path_get_dirname(path, &length);
+
+ if (length != 7) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int dirname_three_segments(void)
+{
+ const char *path;
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ path = "/one/two/three.txt";
+ cwk_path_get_dirname(path, &length);
+
+ if (length != 9) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int dirname_root(void)
+{
+ const char *path;
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ path = "/";
+ cwk_path_get_dirname(path, &length);
+
+ if (length != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int dirname_special_directories(void)
+{
+ const char *path;
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ path = "..";
+ cwk_path_get_dirname(path, &length);
+
+ if (length != 0) {
+ return EXIT_FAILURE;
+ }
+
+ path = ".";
+ cwk_path_get_dirname(path, &length);
+
+ if (length != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int dirname_no_separators(void)
+{
+ const char *path;
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ path = "file_name";
+ cwk_path_get_dirname(path, &length);
+
+ if (length != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int dirname_trailing_separators(void)
+{
+ const char *path;
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ path = "/my/path.txt////";
+ cwk_path_get_dirname(path, &length);
+
+ if (length != 4) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int dirname_trailing_separator(void)
+{
+ const char *path;
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ path = "/my/path.txt/";
+ cwk_path_get_dirname(path, &length);
+
+ if (length != 4) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int dirname_empty(void)
+{
+ const char *path;
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ path = "";
+ cwk_path_get_dirname(path, &length);
+
+ if (length != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int dirname_simple(void)
+{
+ const char *path;
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ path = "/my/path.txt";
+ cwk_path_get_dirname(path, &length);
+
+ if (length != 4) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
diff --git a/src/aux/cwalk/test/extension_test.c b/src/aux/cwalk/test/extension_test.c
@@ -0,0 +1,308 @@
+#include <cwalk.h>
+#include <memory.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int extension_change_with_trailing_slash(void)
+{
+ char buffer[FILENAME_MAX] = "/folder/file.txt/";
+ size_t n;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ n = cwk_path_change_extension(buffer, ".md", buffer, sizeof(buffer));
+ if (n != 16) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp("/folder/file.md/", buffer) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int extension_change_hidden_file(void)
+{
+ char buffer[FILENAME_MAX] = "/folder/.hidden_file.txt";
+ size_t n;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ n = cwk_path_change_extension(buffer, ".md", buffer, sizeof(buffer));
+ if (n != 23) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp("/folder/.hidden_file.md", buffer) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int extension_change_overlap_long(void)
+{
+ char buffer[FILENAME_MAX] = "/test.txt/";
+ size_t n;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ n = cwk_path_change_extension(buffer, ".text", buffer, sizeof(buffer));
+ if (n != 11) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp("/test.text/", buffer) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int extension_change_overlap(void)
+{
+ char buffer[FILENAME_MAX] = "/test.txt/";
+ size_t n;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ n = cwk_path_change_extension(buffer, ".md", buffer, sizeof(buffer));
+ if (n != 9) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp("/test.md/", buffer) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int extension_change_with_dot(void)
+{
+ char buffer[FILENAME_MAX];
+ size_t n;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ n = cwk_path_change_extension("/test.txt", ".md", buffer, sizeof(buffer));
+ if (n != 8) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp("/test.md", buffer) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int extension_change_remove(void)
+{
+ char buffer[FILENAME_MAX];
+ size_t n;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ n = cwk_path_change_extension("/test.txt", "", buffer, sizeof(buffer));
+ if (n != 5) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp("/test", buffer) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int extension_change_no_extension(void)
+{
+ char buffer[FILENAME_MAX] = "C:\\file";
+ size_t n;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ n = cwk_path_change_extension(buffer, ".md", buffer, sizeof(buffer));
+ if (n != 10) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp("C:\\file.md", buffer) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int extension_change_no_basename(void)
+{
+ char buffer[FILENAME_MAX] = "C:\\";
+ size_t n;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ n = cwk_path_change_extension(buffer, ".md", buffer, sizeof(buffer));
+ if (n != 6) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp("C:\\.md", buffer) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int extension_change_simple(void)
+{
+ char buffer[FILENAME_MAX];
+ size_t n;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ n = cwk_path_change_extension("/test.txt", "md", buffer, sizeof(buffer));
+ if (n != 8) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp("/test.md", buffer) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int extension_check_without(void)
+{
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ if (cwk_path_has_extension("/my/path")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int extension_check_empty(void)
+{
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ if (cwk_path_has_extension("")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int extension_check_simple(void)
+{
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ if (!cwk_path_has_extension("/my/path.txt")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int extension_get_multiple(void)
+{
+ const char *path, *extension;
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ path = "/my/path.abc.txt.tests";
+ if (!cwk_path_get_extension(path, &extension, &length)) {
+ return EXIT_FAILURE;
+ }
+
+ if (length != 6) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(extension, ".tests", length) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int extension_get_last(void)
+{
+ const char *path, *extension;
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ path = "/my/path.";
+ if (!cwk_path_get_extension(path, &extension, &length)) {
+ return EXIT_FAILURE;
+ }
+
+ if (length != 1) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(extension, ".", length) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int extension_get_first(void)
+{
+ const char *path, *extension;
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ path = "/my/.path";
+ if (!cwk_path_get_extension(path, &extension, &length)) {
+ return EXIT_FAILURE;
+ }
+
+ if (length != 5) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(extension, ".path", length) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int extension_get_without(void)
+{
+ const char *path, *extension;
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ path = "/my/path";
+ if (cwk_path_get_extension(path, &extension, &length)) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int extension_get_simple(void)
+{
+ const char *path, *extension;
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ path = "/my/path.txt";
+ if (!cwk_path_get_extension(path, &extension, &length)) {
+ return EXIT_FAILURE;
+ }
+
+ if (length != 4) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(extension, ".txt", length) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
diff --git a/src/aux/cwalk/test/guess_test.c b/src/aux/cwalk/test/guess_test.c
@@ -0,0 +1,105 @@
+#include <cwalk.h>
+#include <stdlib.h>
+
+int guess_empty_string(void)
+{
+ if (cwk_path_guess_style("") != CWK_STYLE_UNIX) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int guess_unguessable(void)
+{
+ if (cwk_path_guess_style("myfile") != CWK_STYLE_UNIX) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int guess_extension(void)
+{
+ if (cwk_path_guess_style("myfile.txt") != CWK_STYLE_WINDOWS) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_guess_style("/a/directory/myfile.txt") != CWK_STYLE_UNIX) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int guess_hidden_file(void)
+{
+ if (cwk_path_guess_style(".my_hidden_file") != CWK_STYLE_UNIX) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_guess_style(".my_hidden_file.txt") != CWK_STYLE_UNIX) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int guess_unix_separator(void)
+{
+ if (cwk_path_guess_style("/directory/other") != CWK_STYLE_UNIX) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_guess_style("/directory/other.txt") != CWK_STYLE_UNIX) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int guess_windows_separator(void)
+{
+ if (cwk_path_guess_style("\\directory\\other") != CWK_STYLE_WINDOWS) {
+ return EXIT_FAILURE;
+ }
+ if (cwk_path_guess_style("\\directory\\.other") != CWK_STYLE_WINDOWS) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int guess_unix_root(void)
+{
+ if (cwk_path_guess_style("/directory") != CWK_STYLE_UNIX) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int guess_windows_root(void)
+{
+ if (cwk_path_guess_style("C:\\test") != CWK_STYLE_WINDOWS) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_guess_style("C:/test") != CWK_STYLE_WINDOWS) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_guess_style("C:test") != CWK_STYLE_WINDOWS) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_guess_style("C:/.test") != CWK_STYLE_WINDOWS) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_guess_style("C:/folder/.test") != CWK_STYLE_WINDOWS) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
diff --git a/src/aux/cwalk/test/intersection_test.c b/src/aux/cwalk/test/intersection_test.c
@@ -0,0 +1,132 @@
+#include <cwalk.h>
+#include <stdlib.h>
+
+int intersection_skipped_end(void)
+{
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ if (cwk_path_get_intersection("/test/foo/har/../", "/test/foo/ho") != 9) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int intersection_relative_other(void)
+{
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ if (cwk_path_get_intersection("/test/foo/har", "/test/abc/../foo/bar") != 9) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int intersection_relative_base(void)
+{
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ if (cwk_path_get_intersection("/test/abc/../foo/bar", "/test/foo/har") !=
+ 16) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int intersection_one_root_only(void)
+{
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ if (cwk_path_get_intersection("C:/abc/test.txt", "C:/") != 3) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int intersection_same_roots(void)
+{
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ if (cwk_path_get_intersection("C:/abc/test.txt", "C:/def/test.txt") != 3) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int intersection_relative_absolute_mix(void)
+{
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ if (cwk_path_get_intersection("/test/abc.txt", "test/abc.txt") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int intersection_unequal_roots(void)
+{
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ if (cwk_path_get_intersection("C:/test/abc.txt", "D:/test/abc.txt") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int intersection_empty(void)
+{
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ if (cwk_path_get_intersection("/", "") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int intersection_double_separator(void)
+{
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ if (cwk_path_get_intersection("/this///is/a//test", "/this//is/a///file") !=
+ 12) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int intersection_trailing_separator(void)
+{
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ if (cwk_path_get_intersection("/this/is/a/test", "/this/is/a/") != 10) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int intersection_truncated(void)
+{
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ if (cwk_path_get_intersection("/this/is/a/test", "/this/is/a") != 10) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int intersection_simple(void)
+{
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ if (cwk_path_get_intersection("/this/is/a/test", "/this/is/a/string") != 10) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
diff --git a/src/aux/cwalk/test/is_absolute_test.c b/src/aux/cwalk/test/is_absolute_test.c
@@ -0,0 +1,165 @@
+#include <cwalk.h>
+#include <stdlib.h>
+
+int is_absolute_relative_windows(void)
+{
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ if (cwk_path_is_absolute("..\\hello\\world.txt")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_absolute_relative_drive(void)
+{
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ if (cwk_path_is_absolute("C:test.txt")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_absolute_device_question_mark(void)
+{
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ if (!cwk_path_is_absolute("\\\\?\\mydevice\\test")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_absolute_device_dot(void)
+{
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ cwk_path_is_absolute("\\\\.\\mydevice\\test");
+
+ if (!cwk_path_is_absolute("\\\\.\\mydevice\\test")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_absolute_device_unc(void)
+{
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ if (!cwk_path_is_absolute("\\\\.\\UNC\\LOCALHOST\\c$\\temp\\test-file.txt")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_absolute_unc(void)
+{
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ if (!cwk_path_is_absolute("\\\\server\\folder\\data")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_absolute_absolute_drive(void)
+{
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ if (!cwk_path_is_absolute("C:\\test.txt")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_absolute_unix_drive(void)
+{
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ if (cwk_path_is_absolute("C:\\test.txt")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_absolute_unix_backslash(void)
+{
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ if (cwk_path_is_absolute("\\folder\\")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_absolute_windows_slash(void)
+{
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ if (!cwk_path_is_absolute("/test.txt")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_absolute_windows_backslash(void)
+{
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ if (!cwk_path_is_absolute("\\test.txt")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_absolute_relative(void)
+{
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ if (cwk_path_is_absolute("test.txt")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_absolute_absolute(void)
+{
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ if (!cwk_path_is_absolute("/test.txt")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_absolute_root(void)
+{
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ if (!cwk_path_is_absolute("/")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_absolute_dir(void)
+{
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ if (!cwk_path_is_absolute("/dir")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
diff --git a/src/aux/cwalk/test/is_relative_test.c b/src/aux/cwalk/test/is_relative_test.c
@@ -0,0 +1,145 @@
+#include <cwalk.h>
+#include <stdlib.h>
+
+int is_relative_relative_windows(void)
+{
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ if (!cwk_path_is_relative("..\\hello\\world.txt")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_relative_relative_drive(void)
+{
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ if (!cwk_path_is_relative("C:test.txt")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_relative_device_question_mark(void)
+{
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ if (cwk_path_is_relative("\\\\?\\mydevice\\test")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_relative_device_dot(void)
+{
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ cwk_path_is_absolute("\\\\.\\mydevice\\test");
+
+ if (cwk_path_is_relative("\\\\.\\mydevice\\test")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_relative_device_unc(void)
+{
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ if (cwk_path_is_relative("\\\\.\\UNC\\LOCALHOST\\c$\\temp\\test-file.txt")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_relative_unc(void)
+{
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ if (cwk_path_is_relative("\\\\server\\folder\\data")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_relative_absolute_drive(void)
+{
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ if (cwk_path_is_relative("C:\\test.txt")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_relative_unix_drive(void)
+{
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ if (!cwk_path_is_relative("C:\\test.txt")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_relative_unix_backslash(void)
+{
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ if (!cwk_path_is_relative("\\folder\\")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_relative_windows_slash(void)
+{
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ if (cwk_path_is_relative("/test.txt")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_relative_windows_backslash(void)
+{
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ if (cwk_path_is_relative("\\test.txt")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_relative_relative(void)
+{
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ if (!cwk_path_is_relative("test.txt")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int is_relative_absolute(void)
+{
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ if (cwk_path_is_relative("/test.txt")) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
diff --git a/src/aux/cwalk/test/join_test.c b/src/aux/cwalk/test/join_test.c
@@ -0,0 +1,186 @@
+#include <cwalk.h>
+#include <memory.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int join_multiple(void)
+{
+ char buffer[FILENAME_MAX];
+ const char *paths[3];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ paths[0] = "hello/there";
+ paths[1] = "../world";
+ paths[2] = NULL;
+
+ length = cwk_path_join_multiple(paths, buffer, sizeof(buffer));
+
+ if (length != 11) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "hello/world") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int join_relative_back_after_root(void)
+{
+ char buffer[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ length = cwk_path_join("this\\", "C:\\..\\..\\is\\a\\test\\", buffer,
+ sizeof(buffer));
+
+ if (length != 9) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "is\\a\\test") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int join_back_after_root(void)
+{
+ char buffer[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ length = cwk_path_join("C:\\this\\path", "C:\\..\\is\\a\\test\\", buffer,
+ sizeof(buffer));
+
+ if (length != 22) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "C:\\this\\path\\is\\a\\test") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int join_with_two_roots(void)
+{
+ char buffer[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ length = cwk_path_join("C:\\this\\path", "C:\\is\\a\\test\\", buffer,
+ sizeof(buffer));
+
+ if (length != 25) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "C:\\this\\path\\C:\\is\\a\\test") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int join_two_unc(void)
+{
+ char buffer[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ length = cwk_path_join("\\\\server\\unc\\path", "\\\\server2\\unc\\path",
+ buffer, sizeof(buffer));
+
+ if (length != 34) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "\\\\server\\unc\\path\\server2\\unc\\path") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int join_two_absolute(void)
+{
+ char buffer[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ length = cwk_path_join("/first", "/second", buffer, sizeof(buffer));
+
+ if (length != 13) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "/first/second") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int join_empty(void)
+{
+ char buffer[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ length = cwk_path_join("hello", "..", buffer, sizeof(buffer));
+
+ if (length != 1) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, ".") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int join_navigate_back(void)
+{
+ char buffer[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ length = cwk_path_join("hello/there", "..", buffer, sizeof(buffer));
+
+ if (length != 5) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "hello") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int join_simple(void)
+{
+ char buffer[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ length = cwk_path_join("hello", "there", buffer, sizeof(buffer));
+
+ if (length != 11) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "hello/there") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
diff --git a/src/aux/cwalk/test/main.c b/src/aux/cwalk/test/main.c
@@ -0,0 +1,113 @@
+#include "tests.h"
+#include <memory.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/**
+ * This is just a small macro which calculates the size of an array.
+ */
+#define CWK_ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+
+struct cwk_test
+{
+ const char *unit_name;
+ const char *test_name;
+ const char *full_name;
+ int (*fn)(void);
+};
+
+#define XX(u, t) extern int u##_##t(void);
+UNIT_TESTS(XX)
+#undef XX
+
+static struct cwk_test tests[] = {
+#define XX(u, t) \
+ {.unit_name = #u, .test_name = #t, .full_name = #u "/" #t, .fn = u##_##t},
+ UNIT_TESTS(XX)
+#undef XX
+};
+
+static int call_test(struct cwk_test *test)
+{
+ size_t i;
+
+ printf(" Running '%s' ", test->full_name);
+ for (i = strlen(test->full_name); i < 45; ++i) {
+ fputs(".", stdout);
+ }
+
+ if (test->fn() == EXIT_FAILURE) {
+ fputs(" FAILURE\n", stdout);
+ return EXIT_FAILURE;
+ }
+
+ fputs(" SUCCESS\n", stdout);
+ return EXIT_SUCCESS;
+}
+
+int main(int argc, char *argv[])
+{
+ size_t i, count, failed, succeeded;
+ const char *requested_unit_name, *requested_test_name;
+ struct cwk_test *test;
+ double rate;
+
+ count = 0;
+ failed = 0;
+ if (argc < 2) {
+ fputs("No unit specified. Running all tests.\n\n", stdout);
+ for (i = 0; i < CWK_ARRAY_SIZE(tests); ++i) {
+ test = &tests[i];
+ ++count;
+ if (call_test(test) == EXIT_FAILURE) {
+ ++failed;
+ }
+ }
+ } else if (argc < 3) {
+ requested_unit_name = argv[1];
+ printf("Running all unit tests of '%s'.\n\n", requested_unit_name);
+ for (i = 0; i < CWK_ARRAY_SIZE(tests); ++i) {
+ test = &tests[i];
+ if (strcmp(test->unit_name, requested_unit_name) == 0) {
+ ++count;
+ if (call_test(test) == EXIT_FAILURE) {
+ ++failed;
+ }
+ }
+ }
+ } else {
+ requested_unit_name = argv[1];
+ requested_test_name = argv[2];
+ printf("Running a single test '%s/%s'.\n\n", requested_unit_name,
+ requested_test_name);
+ for (i = 0; i < CWK_ARRAY_SIZE(tests); ++i) {
+ test = &tests[i];
+ if (strcmp(test->unit_name, requested_unit_name) == 0 &&
+ strcmp(test->test_name, requested_test_name) == 0) {
+ ++count;
+ if (call_test(test) == EXIT_FAILURE) {
+ ++failed;
+ }
+ }
+ }
+ }
+
+ if (count == 1) {
+ fputs("\nThe test has been executed.\n", stdout);
+ } else if (count > 0) {
+ succeeded = count - failed;
+ rate = (double)succeeded / (double)count * 100;
+ printf("\n%zu/%zu (%.2f%%) of those tests succeeded.\n", succeeded, count,
+ rate);
+ } else {
+ printf("\nNo tests found.\n");
+ return EXIT_FAILURE;
+ }
+
+ if (failed > 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
diff --git a/src/aux/cwalk/test/meson.build b/src/aux/cwalk/test/meson.build
@@ -0,0 +1,23 @@
+cwalktest_sources = files(
+ 'main.c',
+ 'absolute_test.c',
+ 'basename_test.c',
+ 'dirname_test.c',
+ 'extension_test.c',
+ 'guess_test.c',
+ 'intersection_test.c',
+ 'is_absolute_test.c',
+ 'is_relative_test.c',
+ 'join_test.c',
+ 'normalize_test.c',
+ 'relative_test.c',
+ 'root_test.c',
+ 'segment_test.c',
+ 'windows_test.c',
+)
+
+cwalktest = executable('cwalktest',
+ sources: cwalktest_sources,
+ dependencies: cwalk_dep,
+)
+test('cwalktest', cwalktest)
diff --git a/src/aux/cwalk/test/normalize_test.c b/src/aux/cwalk/test/normalize_test.c
@@ -0,0 +1,261 @@
+#include <cwalk.h>
+#include <limits.h>
+#include <memory.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int normalize_forward_slashes(void)
+{
+ size_t count;
+ char result[FILENAME_MAX];
+ char *input, *expected;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ input = "C:/this/is/a/test/path";
+ strcpy(result, input);
+ expected = "C:\\this\\is\\a\\test\\path";
+ count = cwk_path_normalize(result, result, sizeof(result));
+ if (count != strlen(expected) || strcmp(result, expected) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int normalize_back_after_root(void)
+{
+ size_t count;
+ char result[FILENAME_MAX];
+ char *input, *expected;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ input = "C:\\..\\this\\is\\a\\test\\path";
+ strcpy(result, input);
+ expected = "C:\\this\\is\\a\\test\\path";
+ count = cwk_path_normalize(result, result, sizeof(result));
+ if (count != strlen(expected) || strcmp(result, expected) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int normalize_only_separators(void)
+{
+ size_t count;
+ char result[FILENAME_MAX];
+ char *input, *expected;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ input = "////";
+ strcpy(result, input);
+ expected = "/";
+ count = cwk_path_normalize(result, result, sizeof(result));
+ if (count != strlen(expected) || strcmp(result, expected) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int normalize_empty(void)
+{
+ size_t count;
+ char result[FILENAME_MAX];
+ char *input, *expected;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ input = "test/..";
+ strcpy(result, input);
+ expected = ".";
+ count = cwk_path_normalize(result, result, sizeof(result));
+ if (count != strlen(expected) || strcmp(result, expected) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int normalize_overlap(void)
+{
+ size_t count;
+ char result[FILENAME_MAX];
+ char *input, *expected;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ input = "/var/./logs/.//test/..//..//////";
+ strcpy(result, input);
+ expected = "/var";
+ count = cwk_path_normalize(result, result, sizeof(result));
+ if (count != strlen(expected) || strcmp(result, expected) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int normalize_mixed(void)
+{
+ size_t count;
+ char result[FILENAME_MAX];
+ char *input, *expected;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ input = "/var/./logs/.//test/..//..//////";
+ expected = "/var";
+ count = cwk_path_normalize(input, result, sizeof(result));
+ if (count != strlen(expected) || strcmp(result, expected) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int normalize_remove_current(void)
+{
+ size_t count;
+ char result[FILENAME_MAX];
+ char *input, *expected;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ input = "/var/././././";
+ expected = "/var";
+ count = cwk_path_normalize(input, result, sizeof(result));
+ if (count != strlen(expected) || strcmp(result, expected) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int normalize_double_separator(void)
+{
+ size_t count;
+ char result[FILENAME_MAX];
+ char *input, *expected;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ input = "/var////logs//test/";
+ expected = "/var/logs/test";
+ count = cwk_path_normalize(input, result, sizeof(result));
+ if (count != strlen(expected) || strcmp(result, expected) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int normalize_terminated(void)
+{
+ size_t count;
+ char result[FILENAME_MAX];
+ char *input, *expected;
+ size_t i, expected_size, n;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ input = "/var/logs/test/../../";
+ expected = "/var";
+ expected_size = strlen(expected);
+
+ memset(result, 1, sizeof(result));
+
+ for (i = 0; i < 7; ++i) {
+ count = cwk_path_normalize(input, result, i);
+
+ if (i != 0 && expected_size < i) {
+ n = expected_size;
+ } else {
+ n = i - 1;
+ }
+
+ if (count != strlen(expected) ||
+ (i > 0 && (strncmp(result, expected, n) != 0 || result[n] != '\0'))) {
+ return EXIT_FAILURE;
+ }
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int normalize_relative_too_far(void)
+{
+ size_t count;
+ char result[FILENAME_MAX];
+ char *input, *expected;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ input = "rel/../../";
+ expected = "..";
+ count = cwk_path_normalize(input, result, sizeof(result));
+ if (count != strlen(expected) || strcmp(result, expected) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int normalize_absolute_too_far(void)
+{
+ size_t count;
+ char result[FILENAME_MAX];
+ char *input, *expected;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ input = "/var/logs/test/../../../../../../";
+ expected = "/";
+ count = cwk_path_normalize(input, result, sizeof(result));
+ if (count != strlen(expected) || strcmp(result, expected) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int normalize_navigate_back(void)
+{
+ size_t count;
+ char result[FILENAME_MAX];
+ char *input, *expected;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ input = "/var/logs/test/../../";
+ expected = "/var";
+ count = cwk_path_normalize(input, result, sizeof(result));
+ if (count != strlen(expected) || strcmp(result, expected) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int normalize_do_nothing(void)
+{
+ size_t count;
+ char result[FILENAME_MAX];
+ char *input, *expected;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ input = "/var";
+ expected = "/var";
+ count = cwk_path_normalize(input, result, sizeof(result));
+ if (count != strlen(expected) || strcmp(result, expected) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
diff --git a/src/aux/cwalk/test/relative_test.c b/src/aux/cwalk/test/relative_test.c
@@ -0,0 +1,356 @@
+#include <cwalk.h>
+#include <memory.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+
+int relative_root_forward_slashes(void)
+{
+ char result[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ length = cwk_path_get_relative("C:\\foo\\bar\\baz\\", "C:/foo/bar/file.txt",
+ result, sizeof(result));
+ if (length != 11) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(result, "..\\file.txt") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int relative_root_path_windows(void)
+{
+ char result[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ length = cwk_path_get_relative("C:\\this\\is\\path_one", "C:\\", result,
+ sizeof(result));
+ if (length != 8) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(result, "..\\..\\..") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int relative_root_path_unix(void)
+{
+ char result[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ length = cwk_path_get_relative("/this/is/path_one", "/", result,
+ sizeof(result));
+ if (length != 8) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(result, "../../..") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int relative_check(void)
+{
+ const char *relative_paths[] = {"..", "test", "test/test", "../another_test",
+ "./simple", ".././simple"};
+ const char *absolute_paths[] = {"/", "/test", "/../test/", "/../another_test",
+ "/./simple", "/.././simple"};
+ size_t i;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ for (i = 0; i < ARRAY_SIZE(relative_paths); ++i) {
+ if (!cwk_path_is_relative(relative_paths[i])) {
+ return EXIT_FAILURE;
+ }
+ }
+
+ for (i = 0; i < ARRAY_SIZE(absolute_paths); ++i) {
+ if (cwk_path_is_relative(absolute_paths[i])) {
+ return EXIT_FAILURE;
+ }
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int relative_relative_and_absolute(void)
+{
+ char result[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ *result = 1;
+
+ length = cwk_path_get_relative("./foo", "/bar", result, sizeof(result));
+
+ if (length != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (*result != '\0') {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int relative_different_roots(void)
+{
+ char result[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ *result = 1;
+
+ length = cwk_path_get_relative("C:/path/same", "D:/path/same", result,
+ sizeof(result));
+
+ if (length != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (*result != '\0') {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int relative_skip_all(void)
+{
+ char result[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ length = cwk_path_get_relative("/../../", "/../../", result, sizeof(result));
+ if (length != 1) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(result, ".") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int relative_target_div_skipped_end(void)
+{
+ char result[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ length = cwk_path_get_relative("/path/same", "/path/not_same/ho/..", result,
+ sizeof(result));
+ if (length != 11) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(result, "../not_same") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int relative_base_div_skipped_end(void)
+{
+ char result[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ length = cwk_path_get_relative("/path/not_same/ho/..", "/path/same", result,
+ sizeof(result));
+ if (length != 7) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(result, "../same") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int relative_target_skipped_end(void)
+{
+ char result[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ length = cwk_path_get_relative("/path/same", "/path/same/ho/..", result,
+ sizeof(result));
+ if (length != 1) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(result, ".") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int relative_base_skipped_end(void)
+{
+ char result[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ length = cwk_path_get_relative("/path/same/ho/..", "/path/same", result,
+ sizeof(result));
+ if (length != 1) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(result, ".") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int relative_equal(void)
+{
+ char result[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ length = cwk_path_get_relative("/path/same", "/path/same", result,
+ sizeof(result));
+ if (length != 1) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(result, ".") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int relative_same_base(void)
+{
+ char result[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ length = cwk_path_get_relative("/dir/dir", "/dir/dir3/file", result,
+ sizeof(result));
+ if (length != 12) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(result, "../dir3/file") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int relative_long_target(void)
+{
+ char result[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ length = cwk_path_get_relative("/path/long/one", "/path/long/one/two", result,
+ sizeof(result));
+ if (length != 3) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(result, "two") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int relative_long_base(void)
+{
+ char result[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ length = cwk_path_get_relative("/path/long/one/two", "/path/long/one", result,
+ sizeof(result));
+ if (length != 2) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(result, "..") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int relative_relative(void)
+{
+ char result[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ length = cwk_path_get_relative("./this/is/path_one", "./this/is/path_two",
+ result, sizeof(result));
+ if (length != 11) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(result, "../path_two") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int relative_simple(void)
+{
+ char result[FILENAME_MAX];
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ length = cwk_path_get_relative("/this/is/path_one", "/this/is/path_two",
+ result, sizeof(result));
+ if (length != 11) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(result, "../path_two") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
diff --git a/src/aux/cwalk/test/root_test.c b/src/aux/cwalk/test/root_test.c
@@ -0,0 +1,287 @@
+#include <cwalk.h>
+#include <memory.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int root_change_without_root(void)
+{
+ size_t length;
+ char buffer[FILENAME_MAX] = "hello\\world.txt";
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ length = cwk_path_change_root(buffer, "D:\\", buffer,
+ sizeof(buffer));
+
+ if (length != 18) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "D:\\hello\\world.txt") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int root_change_overlapping(void)
+{
+ size_t length;
+ char buffer[FILENAME_MAX] = "C:\\hello\\world.txt";
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ length = cwk_path_change_root(buffer, "D:\\path\\", buffer,
+ sizeof(buffer));
+
+ if (length != 23) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "D:\\path\\hello\\world.txt") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int root_change_separators(void)
+{
+ size_t length;
+ char buffer[FILENAME_MAX];
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ length = cwk_path_change_root("C:\\hello\\world.txt", "D:\\path\\", buffer,
+ sizeof(buffer));
+
+ if (length != 23) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "D:\\path\\hello\\world.txt") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int root_change_empty(void)
+{
+ size_t length;
+ char buffer[FILENAME_MAX];
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ length = cwk_path_change_root("C:\\hello\\world.txt", "", buffer,
+ sizeof(buffer));
+
+ if (length != 15) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "hello\\world.txt") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int root_change_simple(void)
+{
+ size_t length;
+ char buffer[FILENAME_MAX];
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ length = cwk_path_change_root("C:\\hello\\world.txt", "D:\\", buffer,
+ sizeof(buffer));
+
+ if (length != 18) {
+ return EXIT_FAILURE;
+ }
+
+ if (strcmp(buffer, "D:\\hello\\world.txt") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int root_relative_windows(void)
+{
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ cwk_path_get_root("..\\hello\\world.txt", &length);
+
+ if (length != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int root_relative_drive(void)
+{
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ cwk_path_get_root("C:test.txt", &length);
+
+ if (length != 2) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int root_device_question_mark(void)
+{
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ cwk_path_get_root("\\\\?\\mydevice\\test", &length);
+
+ if (length != 4) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int root_device_dot(void)
+{
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ cwk_path_get_root("\\\\.\\mydevice\\test", &length);
+
+ if (length != 4) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int root_device_unc(void)
+{
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ cwk_path_get_root("\\\\.\\UNC\\LOCALHOST\\c$\\temp\\test-file.txt", &length);
+
+ if (length != 4) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int root_unc(void)
+{
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ cwk_path_get_root("\\\\server\\folder\\data", &length);
+
+ if (length != 16) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int root_absolute_drive(void)
+{
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ cwk_path_get_root("C:\\test.txt", &length);
+
+ if (length != 3) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int root_unix_drive(void)
+{
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ cwk_path_get_root("C:\\test.txt", &length);
+
+ if (length != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int root_unix_backslash(void)
+{
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ cwk_path_get_root("\\folder\\", &length);
+
+ if (length != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int root_windows_slash(void)
+{
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ cwk_path_get_root("/test.txt", &length);
+
+ if (length != 1) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int root_windows_backslash(void)
+{
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ cwk_path_get_root("\\test.txt", &length);
+
+ if (length != 1) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int root_relative(void)
+{
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ cwk_path_get_root("test.txt", &length);
+
+ if (length != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int root_absolute(void)
+{
+ size_t length;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ cwk_path_get_root("/test.txt", &length);
+
+ if (length != 1) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
diff --git a/src/aux/cwalk/test/segment_test.c b/src/aux/cwalk/test/segment_test.c
@@ -0,0 +1,690 @@
+#include <cwalk.h>
+#include <memory.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int segment_change_overlap(void)
+{
+ char buffer[FILENAME_MAX] = "C:\\this\\cool\\path\\";
+ struct cwk_segment segment;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ if (!cwk_path_get_first_segment(buffer, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_next_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ cwk_path_change_segment(&segment, "longer_segment", buffer, sizeof(buffer));
+
+ if (strcmp(buffer, "C:\\this\\longer_segment\\path\\") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int segment_change_with_separator(void)
+{
+ const char *path;
+ char buffer[FILENAME_MAX];
+ struct cwk_segment segment;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ path = "C:\\this\\cool\\path\\";
+ if (!cwk_path_get_first_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_next_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ cwk_path_change_segment(&segment, "other\\fancy", buffer, sizeof(buffer));
+
+ if (strcmp(buffer, "C:\\this\\other\\fancy\\path\\") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int segment_change_empty(void)
+{
+ const char *path;
+ char buffer[FILENAME_MAX];
+ struct cwk_segment segment;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ path = "C:\\this\\cool\\path\\";
+ if (!cwk_path_get_first_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_next_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ cwk_path_change_segment(&segment, "", buffer, sizeof(buffer));
+
+ if (strcmp(buffer, "C:\\this\\\\path\\") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int segment_change_trim(void)
+{
+ const char *path;
+ char buffer[FILENAME_MAX];
+ struct cwk_segment segment;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ path = "C:\\this\\cool\\path\\";
+ if (!cwk_path_get_first_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_next_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ cwk_path_change_segment(&segment, "//other/\\\\", buffer, sizeof(buffer));
+
+ if (strcmp(buffer, "C:\\this\\other\\path\\") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int segment_change_last(void)
+{
+ const char *path;
+ char buffer[FILENAME_MAX];
+ struct cwk_segment segment;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ path = "C:\\this\\cool\\path\\";
+ if (!cwk_path_get_last_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ cwk_path_change_segment(&segment, "other", buffer, sizeof(buffer));
+
+ if (strcmp(buffer, "C:\\this\\cool\\other\\") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ path = "C:\\this\\cool\\path";
+ if (!cwk_path_get_last_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ cwk_path_change_segment(&segment, "other", buffer, sizeof(buffer));
+
+ if (strcmp(buffer, "C:\\this\\cool\\other") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int segment_change_first(void)
+{
+ const char *path;
+ char buffer[FILENAME_MAX];
+ struct cwk_segment segment;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ path = "C:\\this\\cool\\path\\";
+ if (!cwk_path_get_first_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ cwk_path_change_segment(&segment, "other", buffer, sizeof(buffer));
+
+ if (strcmp(buffer, "C:\\other\\cool\\path\\") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ path = "this\\cool\\path\\";
+ if (!cwk_path_get_first_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ cwk_path_change_segment(&segment, "other", buffer, sizeof(buffer));
+
+ if (strcmp(buffer, "other\\cool\\path\\") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int segment_change_simple(void)
+{
+ const char *path;
+ char buffer[FILENAME_MAX];
+ struct cwk_segment segment;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ path = "C:\\this\\cool\\path\\";
+ if (!cwk_path_get_first_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_next_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ cwk_path_change_segment(&segment, "other", buffer, sizeof(buffer));
+
+ if (strcmp(buffer, "C:\\this\\other\\path\\") != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int segment_back_with_root(void)
+{
+ const char *path;
+ struct cwk_segment segment;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ path = "C:\\this\\path";
+ if (!cwk_path_get_last_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "path", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "this", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int segment_type(void)
+{
+ const char *path;
+ struct cwk_segment segment;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ path = "/a/./../.folder/..folder";
+
+ if (!cwk_path_get_first_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_get_segment_type(&segment) != CWK_NORMAL) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_next_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_get_segment_type(&segment) != CWK_CURRENT) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_next_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_get_segment_type(&segment) != CWK_BACK) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_next_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_get_segment_type(&segment) != CWK_NORMAL) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_next_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_get_segment_type(&segment) != CWK_NORMAL) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int segment_previous_too_far_root(void)
+{
+ const char *path;
+ struct cwk_segment segment;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ path = "//now/hello_world/abc/";
+
+ if (!cwk_path_get_last_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int segment_previous_too_far(void)
+{
+ const char *path;
+ struct cwk_segment segment;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ path = "//now/hello_world/abc/";
+
+ if (!cwk_path_get_last_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int segment_previous_relative(void)
+{
+ const char *path;
+ struct cwk_segment segment;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ path = "now/hello_world/abc/";
+
+ if (!cwk_path_get_last_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "abc", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "hello_world", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "now", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int segment_previous_absolute(void)
+{
+ const char *path;
+ struct cwk_segment segment;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ path = "/now/hello_world/abc/";
+
+ if (!cwk_path_get_last_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "abc", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "hello_world", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "now", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int segment_previous_relative_one_char_first(void)
+{
+ const char *path;
+ struct cwk_segment segment;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ path = "n/hello_world/abc/";
+
+ if (!cwk_path_get_last_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "abc", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "hello_world", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "n", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ path = "t\\cool\\path\\";
+
+ if (!cwk_path_get_last_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "path", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "cool", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "t", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int segment_previous_absolute_one_char_first(void)
+{
+ const char *path;
+ struct cwk_segment segment;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ path = "/n/hello_world/abc/";
+
+ if (!cwk_path_get_last_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "abc", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "hello_world", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "n", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ path = "C:\\t\\cool\\path\\";
+
+ if (!cwk_path_get_last_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "path", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "cool", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "t", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_get_previous_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int segment_next_too_far(void)
+{
+ const char *path;
+ struct cwk_segment segment;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ path = "/hello_world/abc/";
+
+ if (!cwk_path_get_first_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_next_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_get_next_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_get_next_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int segment_next(void)
+{
+ const char *path;
+ struct cwk_segment segment;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ path = "/hello_world/abc/";
+
+ if (!cwk_path_get_first_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "hello_world", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (!cwk_path_get_next_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "abc", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ if (cwk_path_get_next_segment(&segment)) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int segment_last(void)
+{
+ const char *path;
+ struct cwk_segment segment;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ path = "/hello_world/abc";
+
+ if (!cwk_path_get_last_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "abc", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ path = "hello_world/abc";
+
+ if (!cwk_path_get_last_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "abc", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int segment_first(void)
+{
+ const char *path;
+ struct cwk_segment segment;
+
+ cwk_path_set_style(CWK_STYLE_UNIX);
+
+ path = "/hello_world/abc";
+
+ if (!cwk_path_get_first_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "hello_world", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ path = "hello_world/abc";
+
+ if (!cwk_path_get_first_segment(path, &segment)) {
+ return EXIT_FAILURE;
+ }
+
+ if (strncmp(segment.begin, "hello_world", segment.size) != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
diff --git a/src/aux/cwalk/test/windows_test.c b/src/aux/cwalk/test/windows_test.c
@@ -0,0 +1,116 @@
+#include <cwalk.h>
+#include <memory.h>
+#include <stdlib.h>
+#include <string.h>
+
+int windows_root_empty(void)
+{
+ size_t size;
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ cwk_path_get_root("", &size);
+ if (size != 0) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int windows_root_backslash(void)
+{
+ size_t size;
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ cwk_path_get_root("\\no_network_path\\hello", &size);
+ if (size != 1) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int windows_intersection_case(void)
+{
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+
+ if (cwk_path_get_intersection("C:\\MYFOLDER\\MYILE.TXT",
+ "c:\\myfolder\\myile.txt") != 21) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int windows_get_root_relative(void)
+{
+ size_t size;
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ cwk_path_get_root("C:file.txt", &size);
+
+ if (size != 2) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int windows_get_root_separator(void)
+{
+ size_t size;
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ cwk_path_get_root("C:/this/is/a/test", &size);
+
+ if (size != 3) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int windows_get_unc_root(void)
+{
+ size_t size;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ cwk_path_get_root("\\\\server\\share\\test.txt", &size);
+
+ if (size != 15) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int windows_get_root(void)
+{
+ size_t size;
+
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ cwk_path_get_root("C:\\test.txt", &size);
+
+ if (size != 3) {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+int windows_change_style(void)
+{
+ enum cwk_path_style style;
+
+ style = cwk_path_get_style();
+ if (style == CWK_STYLE_WINDOWS) {
+ cwk_path_set_style(CWK_STYLE_UNIX);
+ if (cwk_path_get_style() != CWK_STYLE_UNIX) {
+ return EXIT_FAILURE;
+ }
+ } else {
+ cwk_path_set_style(CWK_STYLE_WINDOWS);
+ if (cwk_path_get_style() != CWK_STYLE_WINDOWS) {
+ return EXIT_FAILURE;
+ }
+ }
+
+ return EXIT_SUCCESS;
+}
diff --git a/src/aux/liblash/src/Makefile b/src/aux/liblash/src/Makefile
@@ -31,7 +31,7 @@ shared: all
$(CC) $(CFLAGS) -shared -o liblash.so endian/strip.so.o endian/endian.so.o hex/hex.so.o llog/llog.so.o rerr/rerr.so.o case/case.so.o
install: shared
- cat -v endian/*.h >> $(DESTDIR)/include/lash.h
+ cat -v endian/*.h > $(DESTDIR)/include/lash.h
install -m0644 -v endian/*.h -t $(DESTDIR)/include
cat -v hex/*.h >> $(DESTDIR)/include/lash.h
install -m0644 -v hex/*.h -t $(DESTDIR)/include
