From 78782490ad7c6eeb5bd6a9d52f7ea510dec02375 Mon Sep 17 00:00:00 2001 From: HO-COOH Date: Wed, 28 Apr 2021 10:21:41 +0800 Subject: [PATCH 1/6] Add cmake support --- .gitignore | 3 ++ CMakeLists.txt | 141 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 144 insertions(+) create mode 100644 CMakeLists.txt diff --git a/.gitignore b/.gitignore index d6bbe5ca..13e12f5d 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,6 @@ test a.out *.asm +.vscode/settings.json +build/ +Uninstall.cmake \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 00000000..4d4e52c3 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,141 @@ +cmake_minimum_required(VERSION 3.10) + +project(ctl + VERSION 3.0 + HOMEPAGE_URL "https://github.com/glouw/ctl" + DESCRIPTION "CTL is a fast compiling, type safe, header only, template-like library for ISO C99/C11." +) + +# Globals +set(CMAKE_C_STANDARD 11) +set(CMAKE_C_STANDARD_REQUIRED ON) +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +option(LONG OFF) +option(SANITIZE OFF) +option(SRAND ON) + +set(OptimizationLevel Debug 0 1 2 3 Fast Size) +set(Optimization Debug CACHE STRING "Level of optimization") +set_property(CACHE Optimization PROPERTY STRINGS ${OptimizationLevel}) + +if(MSVC) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W3") +else() + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wpedantic -Wfatal-errors -Wshadow -march=native -g") +endif() + +macro(AddFlag MSVCFlag GCCFlag) + if(MSVC) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${MSVCFlag}") + else() + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${GCCFlag}") + endif() +endmacro() + +if(Optimization STREQUAL 0) + AddFlag(/Od -O0) +elseif(Optimization STREQUAL 1) + AddFlag(/Ox -O1) +elseif(Optimization STREQUAL 2) + AddFlag(/O1 -O2) +elseif(Opmitization STREQUAL 3) + AddFlag(/O2 -O3) +endif() + +include_directories(ctl) + +function(AddExecutableInDir dir target sourceFileNoExtension) + find_file(${sourceFileNoExtension}.c ${sourceFileNoExtension}.c ${CMAKE_SOURCE_DIR}/${dir}) + if(${sourceFileNoExtension}.c) + message("Found ${sourceFileNoExtension}.c") + add_executable(${sourceFileNoExtension} "${dir}/${sourceFileNoExtension}.c") + else() + message("Found ${sourceFileNoExtension}.cc") + add_executable(${sourceFileNoExtension} "${dir}/${sourceFileNoExtension}.cc") + endif() + add_dependencies(${target} ${sourceFileNoExtension}) +endfunction() + + + +# TESTS +set(testFileDir tests/func) +function(AddTest sourceFileNoExtension) + AddExecutableInDir(${testFileDir} tests ${sourceFileNoExtension}) +endfunction() + +add_custom_target(tests) +AddTest(test_c11) +AddTest(test_container_composing) +AddTest(test_deq) +AddTest(test_lst) +AddTest(test_str) +AddTest(test_pqu) +AddTest(test_que) +AddTest(test_set) +AddTest(test_ust) +AddTest(test_stk) +AddTest(test_vec_capacity) +AddTest(test_vec) + +# Examples +set(exampleFileDir examples) +function(AddExample sourceFileNoExtension) + AddExecutableInDir(${exampleFileDir} examples ${sourceFileNoExtension}) +endfunction() + +add_custom_target(examples) +AddExample(astar) +AddExample(postfix) +AddExample(json) +AddExample(snow) +AddExample(6502) + +# Package to a library +add_library(ctl INTERFACE) +set(ctlIncludeDir ${CMAKE_SOURCE_DIR}/ctl) +target_include_directories(ctl INTERFACE ${ctlIncludeDir}) + +# Install +include(GNUInstallDirs) +include(CMakePackageConfigHelpers) + +set(ctlDir ctl-${PROJECT_VERSION}) +message(${ctlDir}) +message(${CMAKE_INSTALL_FULL_INCLUDEDIR}) + +install( + TARGETS ctl + EXPORT ctlTarget + INCLUDES DESTINATION ${CMAKE_INSTALL_FULL_INCLUDEDIR} +) + +set(versionFile ctlConfigVersion.cmake) +write_basic_package_version_file( + ${versionFile} + VERSION ${CMAKE_PROJECT_VERSION} + COMPATIBILITY AnyNewerVersion + ARCH_INDEPENDENT +) +install( + FILES ${PROJECT_BINARY_DIR}/${versionFile} + DESTINATION ${CMAKE_INSTALL_PREFIX} +) + +install( + DIRECTORY ${ctlIncludeDir} + DESTINATION ${CMAKE_INSTALL_FULL_INCLUDEDIR} +) + +# Uninstall +file( + WRITE Uninstall.cmake + "message(\"Removing ${CMAKE_INSTALL_PREFIX}\") + file(REMOVE_RECURSE \"${CMAKE_INSTALL_PREFIX}\")" +) +add_custom_target( + Uninstall + COMMAND cmake -P Uninstall.cmake +) From 6ab433d568e96b429e22a781819c114060290064 Mon Sep 17 00:00:00 2001 From: HO-COOH Date: Wed, 28 Apr 2021 11:07:11 +0800 Subject: [PATCH 2/6] Fix test target populated in external projects --- CMakeLists.txt | 163 +++++++++++++++++++++++++------------------------ 1 file changed, 83 insertions(+), 80 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 4d4e52c3..d5eaae2b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,92 +6,95 @@ project(ctl DESCRIPTION "CTL is a fast compiling, type safe, header only, template-like library for ISO C99/C11." ) -# Globals -set(CMAKE_C_STANDARD 11) -set(CMAKE_C_STANDARD_REQUIRED ON) -set(CMAKE_CXX_STANDARD 17) -set(CMAKE_CXX_STANDARD_REQUIRED ON) - -option(LONG OFF) -option(SANITIZE OFF) -option(SRAND ON) - -set(OptimizationLevel Debug 0 1 2 3 Fast Size) -set(Optimization Debug CACHE STRING "Level of optimization") -set_property(CACHE Optimization PROPERTY STRINGS ${OptimizationLevel}) - -if(MSVC) - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W3") -else() - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wpedantic -Wfatal-errors -Wshadow -march=native -g") -endif() +if(${PROJECT_NAME} STREQUAL ctl) + # Globals + set(CMAKE_C_STANDARD 11) + set(CMAKE_C_STANDARD_REQUIRED ON) + set(CMAKE_CXX_STANDARD 17) + set(CMAKE_CXX_STANDARD_REQUIRED ON) + + option(LONG OFF) + option(SANITIZE OFF) + option(SRAND ON) + + set(OptimizationLevel Debug 0 1 2 3 Fast Size) + set(Optimization Debug CACHE STRING "Level of optimization") + set_property(CACHE Optimization PROPERTY STRINGS ${OptimizationLevel}) -macro(AddFlag MSVCFlag GCCFlag) if(MSVC) - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${MSVCFlag}") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W3") else() - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${GCCFlag}") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wpedantic -Wfatal-errors -Wshadow -march=native -g") endif() -endmacro() - -if(Optimization STREQUAL 0) - AddFlag(/Od -O0) -elseif(Optimization STREQUAL 1) - AddFlag(/Ox -O1) -elseif(Optimization STREQUAL 2) - AddFlag(/O1 -O2) -elseif(Opmitization STREQUAL 3) - AddFlag(/O2 -O3) -endif() - -include_directories(ctl) -function(AddExecutableInDir dir target sourceFileNoExtension) - find_file(${sourceFileNoExtension}.c ${sourceFileNoExtension}.c ${CMAKE_SOURCE_DIR}/${dir}) - if(${sourceFileNoExtension}.c) - message("Found ${sourceFileNoExtension}.c") - add_executable(${sourceFileNoExtension} "${dir}/${sourceFileNoExtension}.c") - else() - message("Found ${sourceFileNoExtension}.cc") - add_executable(${sourceFileNoExtension} "${dir}/${sourceFileNoExtension}.cc") + macro(AddFlag MSVCFlag GCCFlag) + if(MSVC) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${MSVCFlag}") + else() + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${GCCFlag}") + endif() + endmacro() + + if(Optimization STREQUAL 0) + AddFlag(/Od -O0) + elseif(Optimization STREQUAL 1) + AddFlag(/Ox -O1) + elseif(Optimization STREQUAL 2) + AddFlag(/O1 -O2) + elseif(Opmitization STREQUAL 3) + AddFlag(/O2 -O3) endif() - add_dependencies(${target} ${sourceFileNoExtension}) -endfunction() - - - -# TESTS -set(testFileDir tests/func) -function(AddTest sourceFileNoExtension) - AddExecutableInDir(${testFileDir} tests ${sourceFileNoExtension}) -endfunction() - -add_custom_target(tests) -AddTest(test_c11) -AddTest(test_container_composing) -AddTest(test_deq) -AddTest(test_lst) -AddTest(test_str) -AddTest(test_pqu) -AddTest(test_que) -AddTest(test_set) -AddTest(test_ust) -AddTest(test_stk) -AddTest(test_vec_capacity) -AddTest(test_vec) - -# Examples -set(exampleFileDir examples) -function(AddExample sourceFileNoExtension) - AddExecutableInDir(${exampleFileDir} examples ${sourceFileNoExtension}) -endfunction() - -add_custom_target(examples) -AddExample(astar) -AddExample(postfix) -AddExample(json) -AddExample(snow) -AddExample(6502) + + include_directories(ctl) + + function(AddExecutableInDir dir target sourceFileNoExtension) + find_file(${sourceFileNoExtension}.c ${sourceFileNoExtension}.c ${CMAKE_SOURCE_DIR}/${dir}) + if(${sourceFileNoExtension}.c) + message("Found ${sourceFileNoExtension}.c") + add_executable(${sourceFileNoExtension} "${dir}/${sourceFileNoExtension}.c") + else() + message("Found ${sourceFileNoExtension}.cc") + add_executable(${sourceFileNoExtension} "${dir}/${sourceFileNoExtension}.cc") + endif() + add_dependencies(${target} ${sourceFileNoExtension}) + endfunction() + + + + # TESTS + set(testFileDir tests/func) + function(AddTest sourceFileNoExtension) + AddExecutableInDir(${testFileDir} tests ${sourceFileNoExtension}) + endfunction() + + add_custom_target(tests) + AddTest(test_c11) + AddTest(test_container_composing) + AddTest(test_deq) + AddTest(test_lst) + AddTest(test_str) + AddTest(test_pqu) + AddTest(test_que) + AddTest(test_set) + AddTest(test_ust) + AddTest(test_stk) + AddTest(test_vec_capacity) + AddTest(test_vec) + + # Examples + set(exampleFileDir examples) + function(AddExample sourceFileNoExtension) + AddExecutableInDir(${exampleFileDir} examples ${sourceFileNoExtension}) + endfunction() + + add_custom_target(examples) + AddExample(astar) + AddExample(postfix) + AddExample(json) + AddExample(snow) + AddExample(6502) + +endif() # Package to a library add_library(ctl INTERFACE) From d2190783ebfcd901a9f221fd71a056ed5dd40b36 Mon Sep 17 00:00:00 2001 From: HO-COOH Date: Thu, 29 Apr 2021 06:24:17 +0800 Subject: [PATCH 3/6] cmake support for linux finished --- CMakeLists.txt | 199 ++++--------- common.cmake | 56 ++++ ctl/deq.h | 289 +++++++++--------- ctl/lst.h | 313 +++++++++++--------- ctl/pqu.h | 101 ++++--- ctl/que.h | 36 +-- ctl/set.h | 637 +++++++++++++++++++++------------------- ctl/stk.h | 40 +-- ctl/str.h | 96 +++--- ctl/ust.h | 549 +++++++++++++++++++++++----------- ctl/vec.h | 258 ++++++++-------- examples/CMakeLists.txt | 19 ++ tests/CMakeLists.txt | 35 +++ 13 files changed, 1492 insertions(+), 1136 deletions(-) create mode 100644 common.cmake create mode 100644 examples/CMakeLists.txt create mode 100644 tests/CMakeLists.txt diff --git a/CMakeLists.txt b/CMakeLists.txt index d5eaae2b..0a0cf484 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,144 +1,55 @@ -cmake_minimum_required(VERSION 3.10) - -project(ctl - VERSION 3.0 - HOMEPAGE_URL "https://github.com/glouw/ctl" - DESCRIPTION "CTL is a fast compiling, type safe, header only, template-like library for ISO C99/C11." -) - -if(${PROJECT_NAME} STREQUAL ctl) - # Globals - set(CMAKE_C_STANDARD 11) - set(CMAKE_C_STANDARD_REQUIRED ON) - set(CMAKE_CXX_STANDARD 17) - set(CMAKE_CXX_STANDARD_REQUIRED ON) - - option(LONG OFF) - option(SANITIZE OFF) - option(SRAND ON) - - set(OptimizationLevel Debug 0 1 2 3 Fast Size) - set(Optimization Debug CACHE STRING "Level of optimization") - set_property(CACHE Optimization PROPERTY STRINGS ${OptimizationLevel}) - - if(MSVC) - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W3") - else() - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wpedantic -Wfatal-errors -Wshadow -march=native -g") - endif() - - macro(AddFlag MSVCFlag GCCFlag) - if(MSVC) - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${MSVCFlag}") - else() - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${GCCFlag}") - endif() - endmacro() - - if(Optimization STREQUAL 0) - AddFlag(/Od -O0) - elseif(Optimization STREQUAL 1) - AddFlag(/Ox -O1) - elseif(Optimization STREQUAL 2) - AddFlag(/O1 -O2) - elseif(Opmitization STREQUAL 3) - AddFlag(/O2 -O3) - endif() - - include_directories(ctl) - - function(AddExecutableInDir dir target sourceFileNoExtension) - find_file(${sourceFileNoExtension}.c ${sourceFileNoExtension}.c ${CMAKE_SOURCE_DIR}/${dir}) - if(${sourceFileNoExtension}.c) - message("Found ${sourceFileNoExtension}.c") - add_executable(${sourceFileNoExtension} "${dir}/${sourceFileNoExtension}.c") - else() - message("Found ${sourceFileNoExtension}.cc") - add_executable(${sourceFileNoExtension} "${dir}/${sourceFileNoExtension}.cc") - endif() - add_dependencies(${target} ${sourceFileNoExtension}) - endfunction() - - - - # TESTS - set(testFileDir tests/func) - function(AddTest sourceFileNoExtension) - AddExecutableInDir(${testFileDir} tests ${sourceFileNoExtension}) - endfunction() - - add_custom_target(tests) - AddTest(test_c11) - AddTest(test_container_composing) - AddTest(test_deq) - AddTest(test_lst) - AddTest(test_str) - AddTest(test_pqu) - AddTest(test_que) - AddTest(test_set) - AddTest(test_ust) - AddTest(test_stk) - AddTest(test_vec_capacity) - AddTest(test_vec) - - # Examples - set(exampleFileDir examples) - function(AddExample sourceFileNoExtension) - AddExecutableInDir(${exampleFileDir} examples ${sourceFileNoExtension}) - endfunction() - - add_custom_target(examples) - AddExample(astar) - AddExample(postfix) - AddExample(json) - AddExample(snow) - AddExample(6502) - -endif() - -# Package to a library -add_library(ctl INTERFACE) -set(ctlIncludeDir ${CMAKE_SOURCE_DIR}/ctl) -target_include_directories(ctl INTERFACE ${ctlIncludeDir}) - -# Install -include(GNUInstallDirs) -include(CMakePackageConfigHelpers) - -set(ctlDir ctl-${PROJECT_VERSION}) -message(${ctlDir}) -message(${CMAKE_INSTALL_FULL_INCLUDEDIR}) - -install( - TARGETS ctl - EXPORT ctlTarget - INCLUDES DESTINATION ${CMAKE_INSTALL_FULL_INCLUDEDIR} -) - -set(versionFile ctlConfigVersion.cmake) -write_basic_package_version_file( - ${versionFile} - VERSION ${CMAKE_PROJECT_VERSION} - COMPATIBILITY AnyNewerVersion - ARCH_INDEPENDENT -) -install( - FILES ${PROJECT_BINARY_DIR}/${versionFile} - DESTINATION ${CMAKE_INSTALL_PREFIX} -) - -install( - DIRECTORY ${ctlIncludeDir} - DESTINATION ${CMAKE_INSTALL_FULL_INCLUDEDIR} -) - -# Uninstall -file( - WRITE Uninstall.cmake - "message(\"Removing ${CMAKE_INSTALL_PREFIX}\") - file(REMOVE_RECURSE \"${CMAKE_INSTALL_PREFIX}\")" -) -add_custom_target( - Uninstall - COMMAND cmake -P Uninstall.cmake -) +cmake_minimum_required(VERSION 3.10) + +project( + ctl + VERSION 3.0 + HOMEPAGE_URL "https://github.com/glouw/ctl" + DESCRIPTION "CTL is a fast compiling, type safe, header only, template-like library for ISO C99/C11." +) + + +# Package to a library +add_library(ctl INTERFACE) +set(ctlIncludeDir ${PROJECT_SOURCE_DIR}/ctl) +target_include_directories(ctl INTERFACE $) + +# Install +include(GNUInstallDirs) +include(CMakePackageConfigHelpers) + + +install( + TARGETS ctl + EXPORT ctlTargets + INCLUDES DESTINATION ${CMAKE_INSTALL_FULL_INCLUDEDIR} +) + +set(versionFile ctlConfigVersion.cmake) +write_basic_package_version_file( + ${versionFile} + VERSION ${CMAKE_PROJECT_VERSION} + COMPATIBILITY AnyNewerVersion + ARCH_INDEPENDENT +) +install( + EXPORT ctlTargets + FILE ctlConfig.cmake + DESTINATION ${CMAKE_INSTALL_PREFIX} +) +install( + FILES ${PROJECT_BINARY_DIR}/${versionFile} + DESTINATION ${CMAKE_INSTALL_PREFIX} +) + +install( + DIRECTORY ${ctlIncludeDir} + DESTINATION ${CMAKE_INSTALL_FULL_INCLUDEDIR} +) + +# Uninstall +add_custom_target( + Uninstall + COMMAND cmake -E rm -rf ${CMAKE_INSTALL_PREFIX}/ctl + ${CMAKE_INSTALL_PREFIX}/ctlConfig.cmake + ${CMAKE_INSTALL_PREFIX}/${versionFile} +) diff --git a/common.cmake b/common.cmake new file mode 100644 index 00000000..d1e8903b --- /dev/null +++ b/common.cmake @@ -0,0 +1,56 @@ +# Global settings for Tests and Examples + +set(CMAKE_C_STANDARD 11) +set(CMAKE_C_STANDARD_REQUIRED ON) +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +option(LONG OFF) +option(SANITIZE OFF) +option(SRAND ON) + +set(OptimizationLevel Debug 0 1 2 3 Fast Size) +set(Optimization Debug CACHE STRING "Level of optimization") +set_property(CACHE Optimization PROPERTY STRINGS ${OptimizationLevel}) + +macro(AddFlag MSVCFlag GCCFlag) + if(MSVC) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${MSVCFlag}") + else() + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${GCCFlag}") + endif() +endmacro() + +AddFlag("${CMAKE_C_FLAGS} /W3 /sdl-" "${CMAKE_C_FLAGS} -Wall -Wextra -Wpedantic -Wfatal-errors -Wshadow -march=native -g") + +if(${Optimization} STREQUAL 0) + AddFlag(/Od -O0) +elseif(${Optimization} STREQUAL 1) + AddFlag(/Ox -O1) +elseif(${Optimization} STREQUAL 2) + AddFlag(/O1 -O2) +elseif(${Optimization} STREQUAL 3) + AddFlag(/O2 -O3) +elseif(${Optimization} STREQUAL Debug) + AddFlag("" -Og) +elseif(${Optimization} STREQUAL Fast) + AddFlag("/O2 /Ot" -Ofast) +elseif(${Optimization} STREQUAL Size) + AddFlag("/O1 /Os" -Os) +endif() + +if(${LONG}) + add_compile_definitions(LONG) +endif() + +if(${SANITIZE}) + AddFlag("/fsanitize=address" "-fsanitize=address -fsanitize=undefined") +endif() + +if(${SRAND}) + add_compile_definitions(SRAND) +endif() + +message("Using flag: ${CMAKE_C_FLAGS}") + +include_directories(../ctl) # A dirty solution, but works for tests and examples diff --git a/ctl/deq.h b/ctl/deq.h index abe45086..efc400a4 100644 --- a/ctl/deq.h +++ b/ctl/deq.h @@ -6,7 +6,7 @@ #error "Template type T undefined for " #endif -#include +#include "ctl.h" #define A JOIN(deq, T) #define B JOIN(A, bucket) @@ -19,90 +19,88 @@ typedef struct B T value[DEQ_BUCKET_SIZE]; int16_t a; int16_t b; -} -B; +} B; typedef struct A { - void (*free)(T*); - T (*copy)(T*); - B** pages; + void (*free)(T *); + T (*copy) + (T *); + B **pages; size_t mark_a; size_t mark_b; size_t capacity; size_t size; -} -A; +} A; typedef struct I { - void (*step)(struct I*); - A* container; - T* ref; + void (*step)(struct I *); + A *container; + T *ref; size_t index; size_t index_next; size_t index_last; int done; -} -I; +} I; -static inline B** -JOIN(A, first)(A* self) +static inline B ** + JOIN(A, first)(A *self) { return &self->pages[self->mark_a]; } -static inline B** -JOIN(A, last)(A* self) +static inline B ** + JOIN(A, last)(A *self) { return &self->pages[self->mark_b - 1]; } -static inline T* -JOIN(A, at)(A* self, size_t index) +static inline T * + JOIN(A, at)(A *self, size_t index) { - if(self->size == 0) + if (self->size == 0) return NULL; else { - B* first = *JOIN(A, first)(self); + B *first = *JOIN(A, first)(self); size_t actual = index + first->a; size_t q = actual / DEQ_BUCKET_SIZE; size_t r = actual % DEQ_BUCKET_SIZE; - B* page = self->pages[self->mark_a + q]; + B *page = self->pages[self->mark_a + q]; return &page->value[r]; } } -static inline T* -JOIN(A, front)(A* self) +static inline T * + JOIN(A, front)(A *self) { return JOIN(A, at)(self, 0); } -static inline T* -JOIN(A, back)(A* self) +static inline T * + JOIN(A, back)(A *self) { return JOIN(A, at)(self, self->size - 1); } -static inline T* -JOIN(A, begin)(A* self) +static inline T * + JOIN(A, begin)(A *self) { return JOIN(A, front)(self); } -static inline T* -JOIN(A, end)(A* self) +static inline T * + JOIN(A, end)(A *self) { return JOIN(A, back)(self) + 1; } static inline void -JOIN(I, step)(I* self) + JOIN(I, step)(I *self) { self->index = self->index_next; - if(self->index == self->index_last) + if (self->index == self->index_last) self->done = 1; else { @@ -112,11 +110,11 @@ JOIN(I, step)(I* self) } static inline I -JOIN(I, range)(A* container, T* begin, T* end) + JOIN(I, range)(A *container, T *begin, T *end) { static I zero; I self = zero; - if(begin && end) + if (begin && end) { self.container = container; self.step = JOIN(I, step); @@ -131,35 +129,35 @@ JOIN(I, range)(A* container, T* begin, T* end) } static inline int -JOIN(A, empty)(A* self) + JOIN(A, empty)(A *self) { return self->size == 0; } static inline I -JOIN(I, each)(A* a) + JOIN(I, each)(A *a) { return JOIN(A, empty)(a) - ? JOIN(I, range)(a, NULL, NULL) - : JOIN(I, range)(a, JOIN(A, begin)(a), JOIN(A, end)(a)); + ? JOIN(I, range)(a, NULL, NULL) + : JOIN(I, range)(a, JOIN(A, begin)(a), JOIN(A, end)(a)); } static inline T -JOIN(A, implicit_copy)(T* self) + JOIN(A, implicit_copy)(T *self) { return *self; } static inline int -JOIN(A, equal)(A* self, A* other, int _equal(T*, T*)) + JOIN(A, equal)(A *self, A *other, int _equal(T *, T *)) { - if(self->size != other->size) + if (self->size != other->size) return 0; I a = JOIN(I, each)(self); I b = JOIN(I, each)(other); - while(!a.done && !b.done) + while (!a.done && !b.done) { - if(!_equal(a.ref, b.ref)) + if (!_equal(a.ref, b.ref)) return 0; a.step(&a); b.step(&b); @@ -168,7 +166,7 @@ JOIN(A, equal)(A* self, A* other, int _equal(T*, T*)) } static inline void -JOIN(A, swap)(A* self, A* other) + JOIN(A, swap)(A *self, A *other) { A temp = *self; *self = *other; @@ -176,7 +174,7 @@ JOIN(A, swap)(A* self, A* other) } static inline A -JOIN(A, init)(void) + JOIN(A, init)(void) { static A zero; A self = zero; @@ -190,31 +188,31 @@ JOIN(A, init)(void) return self; } -static inline B* -JOIN(B, init)(size_t cut) +static inline B * + JOIN(B, init)(size_t cut) { - B* self = (B*) malloc(sizeof(B)); + B *self = (B *)malloc(sizeof(B)); self->a = self->b = cut; return self; } static inline void -JOIN(A, set)(A* self, size_t index, T value) + JOIN(A, set)(A *self, size_t index, T value) { - T* ref = JOIN(A, at)(self, index); - if(self->free) + T *ref = JOIN(A, at)(self, index); + if (self->free) self->free(ref); *ref = value; } static inline void -JOIN(A, alloc)(A* self, size_t capacity, size_t shift_from) + JOIN(A, alloc)(A *self, size_t capacity, size_t shift_from) { self->capacity = capacity; - self->pages = (B**) realloc(self->pages, capacity * sizeof(B*)); + self->pages = (B **)realloc(self->pages, capacity * sizeof(B *)); size_t shift = (self->capacity - shift_from) / 2; size_t i = self->mark_b; - while(i != 0) + while (i != 0) { i -= 1; self->pages[i + shift] = self->pages[i]; @@ -224,44 +222,46 @@ JOIN(A, alloc)(A* self, size_t capacity, size_t shift_from) } static inline void -JOIN(A, push_front)(A* self, T value) + JOIN(A, push_front)(A *self, T value) { - if(JOIN(A, empty)(self)) + if (JOIN(A, empty)(self)) { self->mark_a = 0; self->mark_b = 1; - JOIN(A, alloc)(self, 1, 0); + JOIN(A, alloc) + (self, 1, 0); *JOIN(A, last)(self) = JOIN(B, init)(DEQ_BUCKET_SIZE); } else { - B* page = *JOIN(A, first)(self); - if(page->a == 0) + B *page = *JOIN(A, first)(self); + if (page->a == 0) { - if(self->mark_a == 0) - JOIN(A, alloc)(self, 2 * self->capacity, self->mark_a); + if (self->mark_a == 0) + JOIN(A, alloc) + (self, 2 * self->capacity, self->mark_a); self->mark_a -= 1; *JOIN(A, first)(self) = JOIN(B, init)(DEQ_BUCKET_SIZE); } } - B* page = *JOIN(A, first)(self); + B *page = *JOIN(A, first)(self); page->a -= 1; self->size += 1; page->value[page->a] = value; } static inline void -JOIN(A, pop_front)(A* self) + JOIN(A, pop_front)(A *self) { - B* page = *JOIN(A, first)(self); - if(self->free) + B *page = *JOIN(A, first)(self); + if (self->free) { - T* ref = &page->value[page->a]; + T *ref = &page->value[page->a]; self->free(ref); } page->a += 1; self->size -= 1; - if(page->a == page->b) + if (page->a == page->b) { free(page); self->mark_a += 1; @@ -269,44 +269,46 @@ JOIN(A, pop_front)(A* self) } static inline void -JOIN(A, push_back)(A* self, T value) + JOIN(A, push_back)(A *self, T value) { - if(JOIN(A, empty)(self)) + if (JOIN(A, empty)(self)) { self->mark_a = 0; self->mark_b = 1; - JOIN(A, alloc)(self, 1, 0); + JOIN(A, alloc) + (self, 1, 0); *JOIN(A, last)(self) = JOIN(B, init)(0); } else { - B* page = *JOIN(A, last)(self); - if(page->b == DEQ_BUCKET_SIZE) + B *page = *JOIN(A, last)(self); + if (page->b == DEQ_BUCKET_SIZE) { - if(self->mark_b == self->capacity) - JOIN(A, alloc)(self, 2 * self->capacity, self->mark_b); + if (self->mark_b == self->capacity) + JOIN(A, alloc) + (self, 2 * self->capacity, self->mark_b); self->mark_b += 1; *JOIN(A, last)(self) = JOIN(B, init)(0); } } - B* page = *JOIN(A, last)(self); + B *page = *JOIN(A, last)(self); page->value[page->b] = value; page->b += 1; self->size += 1; } static inline void -JOIN(A, pop_back)(A* self) + JOIN(A, pop_back)(A *self) { - B* page = *JOIN(A, last)(self); + B *page = *JOIN(A, last)(self); page->b -= 1; self->size -= 1; - if(self->free) + if (self->free) { - T* ref = &page->value[page->b]; + T *ref = &page->value[page->b]; self->free(ref); } - if(page->b == page->a) + if (page->b == page->a) { free(page); self->mark_b -= 1; @@ -314,138 +316,155 @@ JOIN(A, pop_back)(A* self) } static inline void -JOIN(A, erase)(A* self, size_t index) + JOIN(A, erase)(A *self, size_t index) { static T zero; - JOIN(A, set)(self, index, zero); - void (*saved)(T*) = self->free; + JOIN(A, set) + (self, index, zero); + void (*saved)(T *) = self->free; self->free = NULL; - if(index < self->size / 2) + if (index < self->size / 2) { - for(size_t i = index; i > 0; i--) + for (size_t i = index; i > 0; i--) *JOIN(A, at)(self, i) = *JOIN(A, at)(self, i - 1); - JOIN(A, pop_front)(self); + JOIN(A, pop_front) + (self); } else { - for(size_t i = index; i < self->size - 1; i++) + for (size_t i = index; i < self->size - 1; i++) *JOIN(A, at)(self, i) = *JOIN(A, at)(self, i + 1); - JOIN(A, pop_back)(self); + JOIN(A, pop_back) + (self); } self->free = saved; } static inline void -JOIN(A, insert)(A* self, size_t index, T value) + JOIN(A, insert)(A *self, size_t index, T value) { - if(self->size > 0) + if (self->size > 0) { - void (*saved)(T*) = self->free; + void (*saved)(T *) = self->free; self->free = NULL; - if(index < self->size / 2) + if (index < self->size / 2) { - JOIN(A, push_front)(self, *JOIN(A, at)(self, 0)); - for(size_t i = 0; i < index; i++) + JOIN(A, push_front) + (self, *JOIN(A, at)(self, 0)); + for (size_t i = 0; i < index; i++) *JOIN(A, at)(self, i) = *JOIN(A, at)(self, i + 1); } else { - JOIN(A, push_back)(self, *JOIN(A, at)(self, self->size - 1)); - for(size_t i = self->size - 1; i > index; i--) + JOIN(A, push_back) + (self, *JOIN(A, at)(self, self->size - 1)); + for (size_t i = self->size - 1; i > index; i--) *JOIN(A, at)(self, i) = *JOIN(A, at)(self, i - 1); } *JOIN(A, at)(self, index) = value; self->free = saved; } else - JOIN(A, push_back)(self, value); + JOIN(A, push_back) + (self, value); } static inline void -JOIN(A, resize)(A* self, size_t size, T value) + JOIN(A, resize)(A *self, size_t size, T value) { - if(size != self->size) + if (size != self->size) { - while(size != self->size) - if(size < self->size) - JOIN(A, pop_back)(self); + while (size != self->size) + if (size < self->size) + JOIN(A, pop_back) + (self); else - JOIN(A, push_back)(self, self->copy(&value)); + JOIN(A, push_back) + (self, self->copy(&value)); } - if(self->free) + if (self->free) self->free(&value); } static inline void -JOIN(A, assign)(A* self, size_t size, T value) -{ - JOIN(A, resize)(self, size, self->copy(&value)); - for(size_t i = 0; i < size; i++) - JOIN(A, set)(self, i, self->copy(&value)); - if(self->free) + JOIN(A, assign)(A *self, size_t size, T value) +{ + JOIN(A, resize) + (self, size, self->copy(&value)); + for (size_t i = 0; i < size; i++) + JOIN(A, set) + (self, i, self->copy(&value)); + if (self->free) self->free(&value); } static inline void -JOIN(A, clear)(A* self) + JOIN(A, clear)(A *self) { - while(!JOIN(A, empty)(self)) - JOIN(A, pop_back)(self); + while (!JOIN(A, empty)(self)) + JOIN(A, pop_back) + (self); } static inline void -JOIN(A, free)(A* self) + JOIN(A, free)(A *self) { - JOIN(A, clear)(self); + JOIN(A, clear) + (self); free(self->pages); *self = JOIN(A, init)(); } static inline A -JOIN(A, copy)(A* self) + JOIN(A, copy)(A *self) { A other = JOIN(A, init)(); - while(other.size < self->size) + while (other.size < self->size) { - T* value = JOIN(A, at)(self, other.size); - JOIN(A, push_back)(&other, other.copy(value)); + T *value = JOIN(A, at)(self, other.size); + JOIN(A, push_back) + (&other, other.copy(value)); } return other; } static inline void -JOIN(A, ranged_sort)(A* self, int64_t a, int64_t b, int _compare(T*, T*)) + JOIN(A, ranged_sort)(A *self, int64_t a, int64_t b, int _compare(T *, T *)) { - if(a >= b) + if (a >= b) return; int64_t mid = (a + b) / 2; SWAP(T, JOIN(A, at)(self, a), JOIN(A, at)(self, mid)); int64_t z = a; - for(int64_t i = a + 1; i <= b; i++) - if(_compare(JOIN(A, at)(self, a), JOIN(A, at)(self, i))) + for (int64_t i = a + 1; i <= b; i++) + if (_compare(JOIN(A, at)(self, a), JOIN(A, at)(self, i))) { z += 1; SWAP(T, JOIN(A, at)(self, z), JOIN(A, at)(self, i)); } SWAP(T, JOIN(A, at)(self, a), JOIN(A, at)(self, z)); - JOIN(A, ranged_sort)(self, a, z - 1, _compare); - JOIN(A, ranged_sort)(self, z + 1, b, _compare); + JOIN(A, ranged_sort) + (self, a, z - 1, _compare); + JOIN(A, ranged_sort) + (self, z + 1, b, _compare); } static inline void -JOIN(A, sort)(A* self, int _compare(T*, T*)) + JOIN(A, sort)(A *self, int _compare(T *, T *)) { - JOIN(A, ranged_sort)(self, 0, self->size - 1, _compare); + JOIN(A, ranged_sort) + (self, 0, self->size - 1, _compare); } static inline size_t -JOIN(A, remove_if)(A* self, int _match(T*)) + JOIN(A, remove_if)(A *self, int _match(T *)) { size_t erases = 0; - foreach(A, self, it) - if(_match(it.ref)) + foreach (A, self, it) + if (_match(it.ref)) { - JOIN(A, erase)(self, it.index); + JOIN(A, erase) + (self, it.index); it.index_next = it.index; it.index_last -= 1; erases += 1; @@ -453,11 +472,11 @@ JOIN(A, remove_if)(A* self, int _match(T*)) return erases; } -static inline T* -JOIN(A, find)(A* self, T key, int _equal(T*, T*)) +static inline T * + JOIN(A, find)(A *self, T key, int _equal(T *, T *)) { - foreach(A, self, it) - if(_equal(it.ref, &key)) + foreach (A, self, it) + if (_equal(it.ref, &key)) return it.ref; return NULL; } diff --git a/ctl/lst.h b/ctl/lst.h index 24e92db3..17503703 100644 --- a/ctl/lst.h +++ b/ctl/lst.h @@ -6,7 +6,7 @@ #error "Template type T undefined for " #endif -#include +#include "ctl.h" #define A JOIN(lst, T) #define B JOIN(A, node) @@ -14,63 +14,61 @@ typedef struct B { - struct B* prev; - struct B* next; + struct B *prev; + struct B *next; T value; -} -B; +} B; typedef struct A { - void (*free)(T*); - T (*copy)(T*); - B* head; - B* tail; + void (*free)(T *); + T (*copy) + (T *); + B *head; + B *tail; size_t size; -} -A; +} A; typedef struct I { - void (*step)(struct I*); - T* ref; - B* begin; - B* node; - B* next; - B* end; + void (*step)(struct I *); + T *ref; + B *begin; + B *node; + B *next; + B *end; int done; -} -I; +} I; -static inline T* -JOIN(A, front)(A* self) +static inline T * + JOIN(A, front)(A *self) { return &self->head->value; } -static inline T* -JOIN(A, back)(A* self) +static inline T * + JOIN(A, back)(A *self) { return &self->tail->value; } -static inline B* -JOIN(A, begin)(A* self) +static inline B * + JOIN(A, begin)(A *self) { return self->head; } -static inline B* -JOIN(A, end)(A* self) +static inline B * + JOIN(A, end)(A *self) { - (void) self; + (void)self; return NULL; } static inline void -JOIN(I, step)(I* self) + JOIN(I, step)(I *self) { - if(self->next == self->end) + if (self->next == self->end) self->done = 1; else { @@ -81,12 +79,12 @@ JOIN(I, step)(I* self) } static inline I -JOIN(I, range)(A* container, B* begin, B* end) + JOIN(I, range)(A *container, B *begin, B *end) { - (void) container; + (void)container; static I zero; I self = zero; - if(begin) + if (begin) { self.step = JOIN(I, step); self.begin = begin; @@ -101,35 +99,35 @@ JOIN(I, range)(A* container, B* begin, B* end) } static inline int -JOIN(A, empty)(A* self) + JOIN(A, empty)(A *self) { return self->size == 0; } static inline I -JOIN(I, each)(A* a) + JOIN(I, each)(A *a) { return JOIN(A, empty)(a) - ? JOIN(I, range)(a, NULL, NULL) - : JOIN(I, range)(a, JOIN(A, begin)(a), JOIN(A, end)(a)); + ? JOIN(I, range)(a, NULL, NULL) + : JOIN(I, range)(a, JOIN(A, begin)(a), JOIN(A, end)(a)); } static inline T -JOIN(A, implicit_copy)(T* self) + JOIN(A, implicit_copy)(T *self) { return *self; } static inline int -JOIN(A, equal)(A* self, A* other, int _equal(T*, T*)) + JOIN(A, equal)(A *self, A *other, int _equal(T *, T *)) { - if(self->size != other->size) + if (self->size != other->size) return 0; I a = JOIN(I, each)(self); I b = JOIN(I, each)(other); - while(!a.done && !b.done) + while (!a.done && !b.done) { - if(!_equal(a.ref, b.ref)) + if (!_equal(a.ref, b.ref)) return 0; a.step(&a); b.step(&b); @@ -138,7 +136,7 @@ JOIN(A, equal)(A* self, A* other, int _equal(T*, T*)) } static inline void -JOIN(A, swap)(A* self, A* other) + JOIN(A, swap)(A *self, A *other) { A temp = *self; *self = *other; @@ -146,7 +144,7 @@ JOIN(A, swap)(A* self, A* other) } static inline A -JOIN(A, init)(void) + JOIN(A, init)(void) { static A zero; A self = zero; @@ -160,253 +158,280 @@ JOIN(A, init)(void) return self; } -static inline B* -JOIN(B, init)(T value) +static inline B * + JOIN(B, init)(T value) { - B* self = (B*) malloc(sizeof(B)); + B *self = (B *)malloc(sizeof(B)); self->prev = self->next = NULL; self->value = value; return self; } static inline void -JOIN(A, disconnect)(A* self, B* node) -{ - if(node == self->tail) self->tail = self->tail->prev; - if(node == self->head) self->head = self->head->next; - if(node->prev) node->prev->next = node->next; - if(node->next) node->next->prev = node->prev; + JOIN(A, disconnect)(A *self, B *node) +{ + if (node == self->tail) + self->tail = self->tail->prev; + if (node == self->head) + self->head = self->head->next; + if (node->prev) + node->prev->next = node->next; + if (node->next) + node->next->prev = node->prev; node->prev = node->next = NULL; self->size -= 1; } static inline void -JOIN(A, connect)(A* self, B* position, B* node, int before) + JOIN(A, connect)(A *self, B *position, B *node, int before) { - if(JOIN(A, empty)(self)) + if (JOIN(A, empty)(self)) self->head = self->tail = node; - else - if(before) + else if (before) { node->next = position; node->prev = position->prev; - if(position->prev) + if (position->prev) position->prev->next = node; position->prev = node; - if(position == self->head) + if (position == self->head) self->head = node; } else { node->prev = position; node->next = position->next; - if(position->next) + if (position->next) position->next->prev = node; position->next = node; - if(position == self->tail) + if (position == self->tail) self->tail = node; } self->size += 1; } static inline void -JOIN(A, push_back)(A* self, T value) + JOIN(A, push_back)(A *self, T value) { - B* node = JOIN(B, init)(value); - JOIN(A, connect)(self, self->tail, node, 0); + B *node = JOIN(B, init)(value); + JOIN(A, connect) + (self, self->tail, node, 0); } static inline void -JOIN(A, push_front)(A* self, T value) + JOIN(A, push_front)(A *self, T value) { - B* node = JOIN(B, init)(value); - JOIN(A, connect)(self, self->head, node, 1); + B *node = JOIN(B, init)(value); + JOIN(A, connect) + (self, self->head, node, 1); } static inline void -JOIN(A, transfer)(A* self, A* other, B* position, B* node, int before) + JOIN(A, transfer)(A *self, A *other, B *position, B *node, int before) { - JOIN(A, disconnect)(other, node); - JOIN(A, connect)(self, position, node, before); + JOIN(A, disconnect) + (other, node); + JOIN(A, connect) + (self, position, node, before); } static inline void -JOIN(A, erase)(A* self, B* node) + JOIN(A, erase)(A *self, B *node) { - JOIN(A, disconnect)(self, node); - if(self->free) + JOIN(A, disconnect) + (self, node); + if (self->free) self->free(&node->value); free(node); } static inline void -JOIN(A, pop_back)(A* self) + JOIN(A, pop_back)(A *self) { - JOIN(A, erase)(self, self->tail); + JOIN(A, erase) + (self, self->tail); } static inline void -JOIN(A, pop_front)(A* self) + JOIN(A, pop_front)(A *self) { - JOIN(A, erase)(self, self->head); + JOIN(A, erase) + (self, self->head); } static inline void -JOIN(A, insert)(A* self, B* position, T value) + JOIN(A, insert)(A *self, B *position, T value) { - B* node = JOIN(B, init)(value); - JOIN(A, connect)(self, position, node, 1); + B *node = JOIN(B, init)(value); + JOIN(A, connect) + (self, position, node, 1); } static inline void -JOIN(A, clear)(A* self) + JOIN(A, clear)(A *self) { - while(!JOIN(A, empty)(self)) - JOIN(A, pop_back)(self); + while (!JOIN(A, empty)(self)) + JOIN(A, pop_back) + (self); } static inline void -JOIN(A, free)(A* self) + JOIN(A, free)(A *self) { - JOIN(A, clear)(self); + JOIN(A, clear) + (self); *self = JOIN(A, init)(); } static inline void -JOIN(A, resize)(A* self, size_t size, T value) + JOIN(A, resize)(A *self, size_t size, T value) { - if(size != self->size) - for(size_t i = 0; size != self->size; i++) + if (size != self->size) + for (size_t i = 0; size != self->size; i++) (size < self->size) ? JOIN(A, pop_back)(self) : JOIN(A, push_back)(self, self->copy(&value)); - if(self->free) + if (self->free) self->free(&value); } static inline A -JOIN(A, copy)(A* self) + JOIN(A, copy)(A *self) { A other = JOIN(A, init)(); - for(B* node = self->head; node; node = node->next) - JOIN(A, push_back)(&other, self->copy(&node->value)); + for (B *node = self->head; node; node = node->next) + JOIN(A, push_back) + (&other, self->copy(&node->value)); return other; } static inline void -JOIN(A, assign)(A* self, size_t size, T value) + JOIN(A, assign)(A *self, size_t size, T value) { - JOIN(A, resize)(self, size, self->copy(&value)); + JOIN(A, resize) + (self, size, self->copy(&value)); size_t i = 0; - foreach(A, self, it) + foreach (A, self, it) { - if(self->free) + if (self->free) self->free(it.ref); *it.ref = self->copy(&value); i += 1; } - if(self->free) + if (self->free) self->free(&value); } static inline void -JOIN(A, reverse)(A* self) + JOIN(A, reverse)(A *self) { - foreach(A, self, it) + foreach (A, self, it) { - B* next = it.node->next; - B* prev = it.node->prev; + B *next = it.node->next; + B *prev = it.node->prev; it.node->prev = next; it.node->next = prev; } - B* tail = self->tail; - B* head = self->head; + B *tail = self->tail; + B *head = self->head; self->tail = head; self->head = tail; } static inline size_t -JOIN(A, remove_if)(A* self, int _equal(T*)) + JOIN(A, remove_if)(A *self, int _equal(T *)) { size_t erases = 0; - foreach(A, self, it) - if(_equal(it.ref)) + foreach (A, self, it) + if (_equal(it.ref)) { - JOIN(A, erase)(self, it.node); + JOIN(A, erase) + (self, it.node); erases += 1; } return erases; } static inline void -JOIN(A, splice)(A* self, B* position, A* other) + JOIN(A, splice)(A *self, B *position, A *other) { - if(self->size == 0 && position == NULL) - JOIN(A, swap)(self, other); + if (self->size == 0 && position == NULL) + JOIN(A, swap) + (self, other); else - foreach(A, other, it) - JOIN(A, transfer)(self, other, position, it.node, 1); + foreach (A, other, it) + JOIN(A, transfer) + (self, other, position, it.node, 1); } static inline void -JOIN(A, merge)(A* self, A* other, int _compare(T*, T*)) + JOIN(A, merge)(A *self, A *other, int _compare(T *, T *)) { - if(JOIN(A, empty)(self)) - JOIN(A, swap)(self, other); + if (JOIN(A, empty)(self)) + JOIN(A, swap) + (self, other); else { - for(B* node = self->head; node; node = node->next) - while(!JOIN(A, empty)(other) && _compare(&node->value, &other->head->value)) - JOIN(A, transfer)(self, other, node, other->head, 1); + for (B *node = self->head; node; node = node->next) + while (!JOIN(A, empty)(other) && _compare(&node->value, &other->head->value)) + JOIN(A, transfer) + (self, other, node, other->head, 1); // Remainder. - while(!JOIN(A, empty)(other)) - JOIN(A, transfer)(self, other, self->tail, other->head, 0); + while (!JOIN(A, empty)(other)) + JOIN(A, transfer) + (self, other, self->tail, other->head, 0); } } static inline void -JOIN(A, sort)(A* self, int _compare(T*, T*)) + JOIN(A, sort)(A *self, int _compare(T *, T *)) { - if(self->size > 1) + if (self->size > 1) { A carry = JOIN(A, init)(); A temp[64]; - for(size_t i = 0; i < len(temp); i++) + for (size_t i = 0; i < len(temp); i++) temp[i] = JOIN(A, init)(); - A* fill = temp; - A* counter = NULL; + A *fill = temp; + A *counter = NULL; do { - JOIN(A, transfer)(&carry, self, carry.head, self->head, 1); - for(counter = temp; counter != fill && !JOIN(A, empty)(counter); counter++) + JOIN(A, transfer) + (&carry, self, carry.head, self->head, 1); + for (counter = temp; counter != fill && !JOIN(A, empty)(counter); counter++) { - JOIN(A, merge)(counter, &carry, _compare); - JOIN(A, swap)(&carry, counter); + JOIN(A, merge) + (counter, &carry, _compare); + JOIN(A, swap) + (&carry, counter); } - JOIN(A, swap)(&carry, counter); - if(counter == fill) + JOIN(A, swap) + (&carry, counter); + if (counter == fill) fill++; - } - while(!JOIN(A, empty)(self)); - for(counter = temp + 1; counter != fill; counter++) - JOIN(A, merge)(counter, counter - 1, _compare); - JOIN(A, swap)(self, fill - 1); + } while (!JOIN(A, empty)(self)); + for (counter = temp + 1; counter != fill; counter++) + JOIN(A, merge) + (counter, counter - 1, _compare); + JOIN(A, swap) + (self, fill - 1); } } static inline void -JOIN(A, unique)(A* self, int _equal(T*, T*)) + JOIN(A, unique)(A *self, int _equal(T *, T *)) { - foreach(A, self, it) - if(it.next && _equal(it.ref, &it.next->value)) - JOIN(A, erase)(self, it.node); + foreach (A, self, it) + if (it.next && _equal(it.ref, &it.next->value)) + JOIN(A, erase) + (self, it.node); } -static inline B* -JOIN(A, find)(A* self, T key, int _equal(T*, T*)) +static inline B * + JOIN(A, find)(A *self, T key, int _equal(T *, T *)) { - foreach(A, self, it) - if(_equal(it.ref, &key)) + foreach (A, self, it) + if (_equal(it.ref, &key)) return it.node; return NULL; } diff --git a/ctl/pqu.h b/ctl/pqu.h index c5f6ca12..961fc816 100644 --- a/ctl/pqu.h +++ b/ctl/pqu.h @@ -6,42 +6,42 @@ #error "Template type T undefined for " #endif -#define front top -#define at __AT -#define back __BACK -#define begin __BEGIN -#define end __END -#define set __SET -#define pop_back __POP_BACK -#define wipe __WIPE -#define clear __CLEAR -#define fit __FIT -#define reserve __RESERVE -#define push_back __PUSH_BACK -#define resize __RESIZE -#define assign __ASSIGN +#define front top +#define at __AT +#define back __BACK +#define begin __BEGIN +#define end __END +#define set __SET +#define pop_back __POP_BACK +#define wipe __WIPE +#define clear __CLEAR +#define fit __FIT +#define reserve __RESERVE +#define push_back __PUSH_BACK +#define resize __RESIZE +#define assign __ASSIGN #define shrink_to_fit __SHRINK_TO_FIT -#define data __DATA -#define insert __INSERT -#define erase __ERASE -#define sort __SORT -#define step __STEP -#define range __RANGE -#define each __EACH -#define remove_if __REMOVE_IF +#define data __DATA +#define insert __INSERT +#define erase __ERASE +#define sort __SORT +#define step __STEP +#define range __RANGE +#define each __EACH +#define remove_if __REMOVE_IF #define vec pqu #define HOLD #define COMPARE #define init __INIT -#include +#include "vec.h" #undef init #undef vec #define A JOIN(pqu, T) static inline A -JOIN(A, init)(int _compare(T*, T*)) + JOIN(A, init)(int _compare(T *, T *)) { A self = JOIN(A, __INIT)(); self.compare = _compare; @@ -49,66 +49,71 @@ JOIN(A, init)(int _compare(T*, T*)) } static inline void -JOIN(A, up)(A* self, size_t n) + JOIN(A, up)(A *self, size_t n) { - if(n > 0) + if (n > 0) { size_t p = (n - 1) / 2; - T* x = &self->value[n]; - T* y = &self->value[p]; - if(self->compare(x, y)) + T *x = &self->value[n]; + T *y = &self->value[p]; + if (self->compare(x, y)) { SWAP(T, x, y); - JOIN(A, up)(self, p); + JOIN(A, up) + (self, p); } } } static inline void -JOIN(A, down)(A* self, size_t n) + JOIN(A, down)(A *self, size_t n) { size_t min = 2; - if(self->size < min) + if (self->size < min) return; - else - if(self->size == min) + else if (self->size == min) { - T* a = &self->value[0]; - T* b = &self->value[1]; - if(!self->compare(a, b)) + T *a = &self->value[0]; + T *b = &self->value[1]; + if (!self->compare(a, b)) SWAP(T, a, b); } else { size_t l = 2 * n + 1; size_t r = 2 * n + 2; - if(r < self->size) + if (r < self->size) { size_t index = self->compare(&self->value[r], &self->value[l]) ? r : l; - T* x = &self->value[index]; - T* y = &self->value[n]; - if(self->compare(x, y)) + T *x = &self->value[index]; + T *y = &self->value[n]; + if (self->compare(x, y)) { SWAP(T, x, y); - JOIN(A, down)(self, index); + JOIN(A, down) + (self, index); } } } } static inline void -JOIN(A, push)(A* self, T value) + JOIN(A, push)(A *self, T value) { - JOIN(A, push_back)(self, value); - JOIN(A, up)(self, self->size - 1); + JOIN(A, push_back) + (self, value); + JOIN(A, up) + (self, self->size - 1); } static inline void -JOIN(A, pop)(A* self) + JOIN(A, pop)(A *self) { SWAP(T, JOIN(A, front)(self), JOIN(A, back)(self)); - JOIN(A, pop_back)(self); - JOIN(A, down)(self, 0); + JOIN(A, pop_back) + (self); + JOIN(A, down) + (self, 0); } #undef front diff --git a/ctl/que.h b/ctl/que.h index c013c066..753a7321 100644 --- a/ctl/que.h +++ b/ctl/que.h @@ -6,27 +6,27 @@ #error "Template type T undefined for " #endif -#define push_back push -#define pop_front pop -#define at __AT -#define begin __BEGIN -#define end __END -#define push_front __PUSH_FRONT -#define pop_back __PUSH_BACK -#define erase __ERASE -#define insert __INSERT -#define resize __RESIZE -#define assign __ASSIGN -#define clear __CLEAR +#define push_back push +#define pop_front pop +#define at __AT +#define begin __BEGIN +#define end __END +#define push_front __PUSH_FRONT +#define pop_back __PUSH_BACK +#define erase __ERASE +#define insert __INSERT +#define resize __RESIZE +#define assign __ASSIGN +#define clear __CLEAR #define ranged_sort __RANGED_SORT -#define sort __SORT -#define range __RANGE -#define each __each -#define step __STEP -#define remove_if __REMOVE_IF +#define sort __SORT +#define range __RANGE +#define each __each +#define step __STEP +#define remove_if __REMOVE_IF #define deq que -#include +#include "deq.h" #undef deq #undef push_back diff --git a/ctl/set.h b/ctl/set.h index 19244c9c..0d713f47 100644 --- a/ctl/set.h +++ b/ctl/set.h @@ -6,7 +6,7 @@ #error "Template type T undefined for " #endif -#include +#include "ctl.h" #define A JOIN(set, T) #define B JOIN(A, node) @@ -14,77 +14,75 @@ typedef struct B { - struct B* l; - struct B* r; - struct B* p; + struct B *l; + struct B *r; + struct B *p; T key; int color; // Red = 0, Black = 1 -} -B; +} B; typedef struct A { - B* root; - int (*compare)(T*, T*); - void (*free)(T*); - T (*copy)(T*); + B *root; + int (*compare)(T *, T *); + void (*free)(T *); + T (*copy) + (T *); size_t size; -} -A; +} A; typedef struct I { - void (*step)(struct I*); - B* end; - B* node; - T* ref; - B* next; + void (*step)(struct I *); + B *end; + B *node; + T *ref; + B *next; int done; -} -I; +} I; -static inline B* -JOIN(A, begin)(A* self) +static inline B * + JOIN(A, begin)(A *self) { return self->root; } -static inline B* -JOIN(A, end)(A* self) +static inline B * + JOIN(A, end)(A *self) { - (void) self; + (void)self; return NULL; } -static inline B* -JOIN(B, min)(B* self) +static inline B * + JOIN(B, min)(B *self) { - while(self->l) + while (self->l) self = self->l; return self; } -static inline B* -JOIN(B, max)(B* self) +static inline B * + JOIN(B, max)(B *self) { - while(self->r) + while (self->r) self = self->r; return self; } -static inline B* -JOIN(B, next)(B* self) +static inline B * + JOIN(B, next)(B *self) { - if(self->r) + if (self->r) { self = self->r; - while(self->l) + while (self->l) self = self->l; } else { - B* parent = self->p; - while(parent && self == parent->r) + B *parent = self->p; + while (parent && self == parent->r) { self = parent; parent = parent->p; @@ -95,9 +93,9 @@ JOIN(B, next)(B* self) } static inline void -JOIN(I, step)(I* self) + JOIN(I, step)(I *self) { - if(self->next == self->end) + if (self->next == self->end) self->done = 1; else { @@ -108,12 +106,12 @@ JOIN(I, step)(I* self) } static inline I -JOIN(I, range)(A* container, B* begin, B* end) + JOIN(I, range)(A *container, B *begin, B *end) { - (void) container; + (void)container; static I zero; I self = zero; - if(begin) + if (begin) { self.step = JOIN(I, step); self.node = JOIN(B, min)(begin); @@ -127,35 +125,35 @@ JOIN(I, range)(A* container, B* begin, B* end) } static inline int -JOIN(A, empty)(A* self) + JOIN(A, empty)(A *self) { return self->size == 0; } static inline I -JOIN(I, each)(A* a) + JOIN(I, each)(A *a) { return JOIN(A, empty)(a) - ? JOIN(I, range)(a, NULL, NULL) - : JOIN(I, range)(a, JOIN(A, begin)(a), JOIN(A, end)(a)); + ? JOIN(I, range)(a, NULL, NULL) + : JOIN(I, range)(a, JOIN(A, begin)(a), JOIN(A, end)(a)); } static inline T -JOIN(A, implicit_copy)(T* self) + JOIN(A, implicit_copy)(T *self) { return *self; } static inline int -JOIN(A, equal)(A* self, A* other, int _equal(T*, T*)) + JOIN(A, equal)(A *self, A *other, int _equal(T *, T *)) { - if(self->size != other->size) + if (self->size != other->size) return 0; I a = JOIN(I, each)(self); I b = JOIN(I, each)(other); - while(!a.done && !b.done) + while (!a.done && !b.done) { - if(!_equal(a.ref, b.ref)) + if (!_equal(a.ref, b.ref)) return 0; a.step(&a); b.step(&b); @@ -164,7 +162,7 @@ JOIN(A, equal)(A* self, A* other, int _equal(T*, T*)) } static inline void -JOIN(A, swap)(A* self, A* other) + JOIN(A, swap)(A *self, A *other) { A temp = *self; *self = *other; @@ -172,7 +170,7 @@ JOIN(A, swap)(A* self, A* other) } static inline A -JOIN(A, init)(int _compare(T*, T*)) + JOIN(A, init)(int _compare(T *, T *)) { static A zero; A self = zero; @@ -188,71 +186,71 @@ JOIN(A, init)(int _compare(T*, T*)) } static inline void -JOIN(A, free_node)(A* self, B* node) + JOIN(A, free_node)(A *self, B *node) { - if(self->free) + if (self->free) self->free(&node->key); free(node); } static inline int -JOIN(B, color)(B* self) + JOIN(B, color)(B *self) { return self ? self->color : 1; } static inline int -JOIN(B, is_blk)(B* self) + JOIN(B, is_blk)(B *self) { return JOIN(B, color)(self) == 1; } static inline int -JOIN(B, is_red)(B* self) + JOIN(B, is_red)(B *self) { return JOIN(B, color)(self) == 0; } -static inline B* -JOIN(B, grandfather)(B* self) +static inline B * + JOIN(B, grandfather)(B *self) { return self->p->p; } -static inline B* -JOIN(B, sibling)(B* self) +static inline B * + JOIN(B, sibling)(B *self) { - if(self == self->p->l) + if (self == self->p->l) return self->p->r; else return self->p->l; } -static inline B* -JOIN(B, uncle)(B* self) +static inline B * + JOIN(B, uncle)(B *self) { return JOIN(B, sibling)(self->p); } -static inline B* -JOIN(B, init)(T key, int color) +static inline B * + JOIN(B, init)(T key, int color) { - B* self = (B*) malloc(sizeof(B)); + B *self = (B *)malloc(sizeof(B)); self->key = key; self->color = color; self->l = self->r = self->p = NULL; return self; } -static inline B* -JOIN(A, lower_bound)(A* self, T key) +static inline B * + JOIN(A, lower_bound)(A *self, T key) { - B* node = self->root; - B* result = NULL; - while(node) + B *node = self->root; + B *result = NULL; + while (node) { int diff = self->compare(&key, &node->key); - if(diff <= 0) + if (diff <= 0) { result = node; node = node->l; @@ -263,15 +261,15 @@ JOIN(A, lower_bound)(A* self, T key) return result; } -static inline B* -JOIN(A, upper_bound)(A* self, T key) +static inline B * + JOIN(A, upper_bound)(A *self, T key) { - B* node = self->root; - B* result = NULL; - while(node) + B *node = self->root; + B *result = NULL; + while (node) { int diff = self->compare(&key, &node->key); - if(diff < 0) + if (diff < 0) { result = node; node = node->l; @@ -282,17 +280,16 @@ JOIN(A, upper_bound)(A* self, T key) return result; } -static inline B* -JOIN(A, find)(A* self, T key) +static inline B * + JOIN(A, find)(A *self, T key) { - B* node = self->root; - while(node) + B *node = self->root; + while (node) { int diff = self->compare(&key, &node->key); - if(diff == 0) + if (diff == 0) return node; - else - if(diff < 0) + else if (diff < 0) node = node->l; else node = node->r; @@ -301,152 +298,165 @@ JOIN(A, find)(A* self, T key) } static inline int -JOIN(A, count)(A* self, T key) + JOIN(A, count)(A *self, T key) { return JOIN(A, find)(self, key) ? 1 : 0; } static inline void -JOIN(B, replace)(A* self, B* a, B* b) + JOIN(B, replace)(A *self, B *a, B *b) { - if(a->p) + if (a->p) { - if(a == a->p->l) + if (a == a->p->l) a->p->l = b; else a->p->r = b; } else self->root = b; - if(b) + if (b) b->p = a->p; } #ifdef USE_INTERNAL_VERIFY - #include +#include - static inline void - JOIN(B, verify_property_1)(B* self) +static inline void + JOIN(B, verify_property_1)(B *self) +{ + assert(JOIN(B, is_red)(self) || JOIN(B, is_blk)(self)); + if (self) { - assert(JOIN(B, is_red)(self) || JOIN(B, is_blk)(self)); - if(self) - { - JOIN(B, verify_property_1)(self->l); - JOIN(B, verify_property_1)(self->r); - } + JOIN(B, verify_property_1) + (self->l); + JOIN(B, verify_property_1) + (self->r); } +} - static inline void - JOIN(B, verify_property_2)(B* self) - { - assert(JOIN(B, is_blk)(self)); - } +static inline void + JOIN(B, verify_property_2)(B *self) +{ + assert(JOIN(B, is_blk)(self)); +} - static inline void - JOIN(B, verify_property_4)(B* self) +static inline void + JOIN(B, verify_property_4)(B *self) +{ + if (JOIN(B, is_red)(self)) { - if(JOIN(B, is_red)(self)) - { - assert(JOIN(B, is_blk)(self->l)); - assert(JOIN(B, is_blk)(self->r)); - assert(JOIN(B, is_blk)(self->p)); - } - if(self) - { - JOIN(B, verify_property_4)(self->l); - JOIN(B, verify_property_4)(self->r); - } + assert(JOIN(B, is_blk)(self->l)); + assert(JOIN(B, is_blk)(self->r)); + assert(JOIN(B, is_blk)(self->p)); } - - static inline void - JOIN(B, count_blk)(B* self, int nodes, int* in_path) + if (self) { - if(JOIN(B, is_blk)(self)) - nodes += 1; - if(self) - { - JOIN(B, count_blk)(self->l, nodes, in_path); - JOIN(B, count_blk)(self->r, nodes, in_path); - } - else - { - if(*in_path == -1) - *in_path = nodes; - else - assert(nodes == *in_path); - } + JOIN(B, verify_property_4) + (self->l); + JOIN(B, verify_property_4) + (self->r); } +} - static inline void - JOIN(B, verify_property_5)(B* self) +static inline void + JOIN(B, count_blk)(B *self, int nodes, int *in_path) +{ + if (JOIN(B, is_blk)(self)) + nodes += 1; + if (self) { - int in_path = -1; - JOIN(B, count_blk)(self, 0, &in_path); + JOIN(B, count_blk) + (self->l, nodes, in_path); + JOIN(B, count_blk) + (self->r, nodes, in_path); } - - static inline void - JOIN(A, verify)(A* self) + else { - JOIN(B, verify_property_1)(self->root); // Property 1: Each node is either red or black. - JOIN(B, verify_property_2)(self->root); // Property 2: The root node is black. - /* Implicit */ // Property 3: Leaves are colored black - JOIN(B, verify_property_4)(self->root); // Property 4: Every red node has two black ndoes. - JOIN(B, verify_property_5)(self->root); // Property 5: All paths from a node have the same number of black nodes. + if (*in_path == -1) + *in_path = nodes; + else + assert(nodes == *in_path); } +} + +static inline void + JOIN(B, verify_property_5)(B *self) +{ + int in_path = -1; + JOIN(B, count_blk) + (self, 0, &in_path); +} + +static inline void + JOIN(A, verify)(A *self) +{ + JOIN(B, verify_property_1) + (self->root); // Property 1: Each node is either red or black. + JOIN(B, verify_property_2) + (self->root); // Property 2: The root node is black. + /* Implicit */ // Property 3: Leaves are colored black + JOIN(B, verify_property_4) + (self->root); // Property 4: Every red node has two black ndoes. + JOIN(B, verify_property_5) + (self->root); // Property 5: All paths from a node have the same number of black nodes. +} #endif static inline void -JOIN(A, rotate_l)(A* self, B* node) + JOIN(A, rotate_l)(A *self, B *node) { - B* r = node->r; - JOIN(B, replace)(self, node, r); + B *r = node->r; + JOIN(B, replace) + (self, node, r); node->r = r->l; - if(r->l) + if (r->l) r->l->p = node; r->l = node; node->p = r; } static inline void -JOIN(A, rotate_r)(A* self, B* node) + JOIN(A, rotate_r)(A *self, B *node) { - B* l = node->l; - JOIN(B, replace)(self, node, l); + B *l = node->l; + JOIN(B, replace) + (self, node, l); node->l = l->r; - if(l->r) + if (l->r) l->r->p = node; l->r = node; node->p = l; } static inline void -JOIN(A, insert_1)(A*, B*), -JOIN(A, insert_2)(A*, B*), -JOIN(A, insert_3)(A*, B*), -JOIN(A, insert_4)(A*, B*), -JOIN(A, insert_5)(A*, B*); + JOIN(A, insert_1)(A *, B *), + JOIN(A, insert_2)(A *, B *), + JOIN(A, insert_3)(A *, B *), + JOIN(A, insert_4)(A *, B *), + JOIN(A, insert_5)(A *, B *); -static inline B* -JOIN(A, insert)(A* self, T key) +static inline B * + JOIN(A, insert)(A *self, T key) { - B* insert = JOIN(B, init)(key, 0); - if(self->root) + B *insert = JOIN(B, init)(key, 0); + if (self->root) { - B* node = self->root; - while(1) + B *node = self->root; + while (1) { int diff = self->compare(&key, &node->key); - if(diff == 0) + if (diff == 0) { - JOIN(A, free_node)(self, insert); + JOIN(A, free_node) + (self, insert); return node; } - else - if(diff < 0) + else if (diff < 0) { - if(node->l) + if (node->l) node = node->l; else { @@ -456,7 +466,7 @@ JOIN(A, insert)(A* self, T key) } else { - if(node->r) + if (node->r) node = node->r; else { @@ -469,285 +479,324 @@ JOIN(A, insert)(A* self, T key) } else self->root = insert; - JOIN(A, insert_1)(self, insert); + JOIN(A, insert_1) + (self, insert); self->size += 1; #ifdef USE_INTERNAL_VERIFY - JOIN(A, verify)(self); + JOIN(A, verify) + (self); #endif return insert; } static inline void -JOIN(A, insert_1)(A* self, B* node) + JOIN(A, insert_1)(A *self, B *node) { - if(node->p) - JOIN(A, insert_2)(self, node); + if (node->p) + JOIN(A, insert_2) + (self, node); else node->color = 1; } static inline void -JOIN(A, insert_2)(A* self, B* node) + JOIN(A, insert_2)(A *self, B *node) { - if(JOIN(B, is_blk)(node->p)) + if (JOIN(B, is_blk)(node->p)) return; else - JOIN(A, insert_3)(self, node); + JOIN(A, insert_3) + (self, node); } static inline void -JOIN(A, insert_3)(A* self, B* node) + JOIN(A, insert_3)(A *self, B *node) { - if(JOIN(B, is_red)(JOIN(B, uncle)(node))) + if (JOIN(B, is_red)(JOIN(B, uncle)(node))) { node->p->color = 1; - JOIN(B, uncle)(node)->color = 1; - JOIN(B, grandfather)(node)->color = 0; - JOIN(A, insert_1)(self, JOIN(B, grandfather)(node)); + JOIN(B, uncle) + (node)->color = 1; + JOIN(B, grandfather) + (node)->color = 0; + JOIN(A, insert_1) + (self, JOIN(B, grandfather)(node)); } else - JOIN(A, insert_4)(self, node); + JOIN(A, insert_4) + (self, node); } static inline void -JOIN(A, insert_4)(A* self, B* node) + JOIN(A, insert_4)(A *self, B *node) { - if(node == node->p->r && node->p == JOIN(B, grandfather)(node)->l) + if (node == node->p->r && node->p == JOIN(B, grandfather)(node)->l) { - JOIN(A, rotate_l)(self, node->p); + JOIN(A, rotate_l) + (self, node->p); node = node->l; } - else - if(node == node->p->l && node->p == JOIN(B, grandfather)(node)->r) + else if (node == node->p->l && node->p == JOIN(B, grandfather)(node)->r) { - JOIN(A, rotate_r)(self, node->p); + JOIN(A, rotate_r) + (self, node->p); node = node->r; } - JOIN(A, insert_5)(self, node); + JOIN(A, insert_5) + (self, node); } static inline void -JOIN(A, insert_5)(A* self, B* node) + JOIN(A, insert_5)(A *self, B *node) { node->p->color = 1; - JOIN(B, grandfather)(node)->color = 0; - if(node == node->p->l && node->p == JOIN(B, grandfather)(node)->l) - JOIN(A, rotate_r)(self, JOIN(B, grandfather)(node)); + JOIN(B, grandfather) + (node)->color = 0; + if (node == node->p->l && node->p == JOIN(B, grandfather)(node)->l) + JOIN(A, rotate_r) + (self, JOIN(B, grandfather)(node)); else - JOIN(A, rotate_l)(self, JOIN(B, grandfather)(node)); + JOIN(A, rotate_l) + (self, JOIN(B, grandfather)(node)); } static inline void -JOIN(A, erase_1)(A*, B*), -JOIN(A, erase_2)(A*, B*), -JOIN(A, erase_3)(A*, B*), -JOIN(A, erase_4)(A*, B*), -JOIN(A, erase_5)(A*, B*), -JOIN(A, erase_6)(A*, B*); + JOIN(A, erase_1)(A *, B *), + JOIN(A, erase_2)(A *, B *), + JOIN(A, erase_3)(A *, B *), + JOIN(A, erase_4)(A *, B *), + JOIN(A, erase_5)(A *, B *), + JOIN(A, erase_6)(A *, B *); static inline void -JOIN(A, erase_node)(A* self, B* node) + JOIN(A, erase_node)(A *self, B *node) { - if(node->l && node->r) + if (node->l && node->r) { - B* pred = JOIN(B, max)(node->l); + B *pred = JOIN(B, max)(node->l); SWAP(T, &node->key, &pred->key); node = pred; } - B* child = node->r ? node->r : node->l; - if(JOIN(B, is_blk)(node)) + B *child = node->r ? node->r : node->l; + if (JOIN(B, is_blk)(node)) { node->color = JOIN(B, color)(child); - JOIN(A, erase_1)(self, node); + JOIN(A, erase_1) + (self, node); } - JOIN(B, replace)(self, node, child); - if(node->p == NULL && child) + JOIN(B, replace) + (self, node, child); + if (node->p == NULL && child) child->color = 1; - JOIN(A, free_node)(self, node); + JOIN(A, free_node) + (self, node); self->size -= 1; #ifdef USE_INTERNAL_VERIFY - JOIN(A, verify)(self); + JOIN(A, verify) + (self); #endif } static inline void -JOIN(A, erase)(A* self, T key) + JOIN(A, erase)(A *self, T key) { - B* node = JOIN(A, find)(self, key); - if(node) - JOIN(A, erase_node)(self, node); + B *node = JOIN(A, find)(self, key); + if (node) + JOIN(A, erase_node) + (self, node); } static inline void -JOIN(A, erase_1)(A* self, B* node) + JOIN(A, erase_1)(A *self, B *node) { - if(node->p) - JOIN(A, erase_2)(self, node); + if (node->p) + JOIN(A, erase_2) + (self, node); } static inline void -JOIN(A, erase_2)(A* self, B* node) + JOIN(A, erase_2)(A *self, B *node) { - if(JOIN(B, is_red)(JOIN(B, sibling)(node))) + if (JOIN(B, is_red)(JOIN(B, sibling)(node))) { node->p->color = 0; - JOIN(B, sibling)(node)->color = 1; - if(node == node->p->l) - JOIN(A, rotate_l)(self, node->p); + JOIN(B, sibling) + (node)->color = 1; + if (node == node->p->l) + JOIN(A, rotate_l) + (self, node->p); else - JOIN(A, rotate_r)(self, node->p); + JOIN(A, rotate_r) + (self, node->p); } - JOIN(A, erase_3)(self, node); + JOIN(A, erase_3) + (self, node); } static inline void -JOIN(A, erase_3)(A* self, B* node) + JOIN(A, erase_3)(A *self, B *node) { - if(JOIN(B, is_blk)(node->p) - && JOIN(B, is_blk)(JOIN(B, sibling)(node)) - && JOIN(B, is_blk)(JOIN(B, sibling)(node)->l) - && JOIN(B, is_blk)(JOIN(B, sibling)(node)->r)) + if (JOIN(B, is_blk)(node->p) && JOIN(B, is_blk)(JOIN(B, sibling)(node)) && JOIN(B, is_blk)(JOIN(B, sibling)(node)->l) && JOIN(B, is_blk)(JOIN(B, sibling)(node)->r)) { - JOIN(B, sibling)(node)->color = 0; - JOIN(A, erase_1)(self, node->p); + JOIN(B, sibling) + (node)->color = 0; + JOIN(A, erase_1) + (self, node->p); } else - JOIN(A, erase_4)(self, node); + JOIN(A, erase_4) + (self, node); } static inline void -JOIN(A, erase_4)(A* self, B* node) + JOIN(A, erase_4)(A *self, B *node) { - if(JOIN(B, is_red)(node->p) - && JOIN(B, is_blk)(JOIN(B, sibling)(node)) - && JOIN(B, is_blk)(JOIN(B, sibling)(node)->l) - && JOIN(B, is_blk)(JOIN(B, sibling)(node)->r)) + if (JOIN(B, is_red)(node->p) && JOIN(B, is_blk)(JOIN(B, sibling)(node)) && JOIN(B, is_blk)(JOIN(B, sibling)(node)->l) && JOIN(B, is_blk)(JOIN(B, sibling)(node)->r)) { - JOIN(B, sibling)(node)->color = 0; + JOIN(B, sibling) + (node)->color = 0; node->p->color = 1; } else - JOIN(A, erase_5)(self, node); + JOIN(A, erase_5) + (self, node); } static inline void -JOIN(A, erase_5)(A* self, B* node) + JOIN(A, erase_5)(A *self, B *node) { - if(node == node->p->l - && JOIN(B, is_blk)(JOIN(B, sibling)(node)) - && JOIN(B, is_red)(JOIN(B, sibling)(node)->l) - && JOIN(B, is_blk)(JOIN(B, sibling)(node)->r)) + if (node == node->p->l && JOIN(B, is_blk)(JOIN(B, sibling)(node)) && JOIN(B, is_red)(JOIN(B, sibling)(node)->l) && JOIN(B, is_blk)(JOIN(B, sibling)(node)->r)) { - JOIN(B, sibling)(node)->color = 0; - JOIN(B, sibling)(node)->l->color = 1; - JOIN(A, rotate_r)(self, JOIN(B, sibling)(node)); + JOIN(B, sibling) + (node)->color = 0; + JOIN(B, sibling) + (node)->l->color = 1; + JOIN(A, rotate_r) + (self, JOIN(B, sibling)(node)); } - else - if(node == node->p->r - && JOIN(B, is_blk)(JOIN(B, sibling)(node)) - && JOIN(B, is_red)(JOIN(B, sibling)(node)->r) - && JOIN(B, is_blk)(JOIN(B, sibling)(node)->l)) + else if (node == node->p->r && JOIN(B, is_blk)(JOIN(B, sibling)(node)) && JOIN(B, is_red)(JOIN(B, sibling)(node)->r) && JOIN(B, is_blk)(JOIN(B, sibling)(node)->l)) { - JOIN(B, sibling)(node)->color = 0; - JOIN(B, sibling)(node)->r->color = 1; - JOIN(A, rotate_l)(self, JOIN(B, sibling)(node)); + JOIN(B, sibling) + (node)->color = 0; + JOIN(B, sibling) + (node)->r->color = 1; + JOIN(A, rotate_l) + (self, JOIN(B, sibling)(node)); } - JOIN(A, erase_6)(self, node); + JOIN(A, erase_6) + (self, node); } static inline void -JOIN(A, erase_6)(A* self, B* node) + JOIN(A, erase_6)(A *self, B *node) { - JOIN(B, sibling)(node)->color = JOIN(B, color)(node->p); + JOIN(B, sibling) + (node)->color = JOIN(B, color)(node->p); node->p->color = 1; - if(node == node->p->l) + if (node == node->p->l) { - JOIN(B, sibling)(node)->r->color = 1; - JOIN(A, rotate_l)(self, node->p); + JOIN(B, sibling) + (node)->r->color = 1; + JOIN(A, rotate_l) + (self, node->p); } else { - JOIN(B, sibling)(node)->l->color = 1; - JOIN(A, rotate_r)(self, node->p); + JOIN(B, sibling) + (node)->l->color = 1; + JOIN(A, rotate_r) + (self, node->p); } } static inline void -JOIN(A, clear)(A* self) + JOIN(A, clear)(A *self) { - while(!JOIN(A, empty)(self)) - JOIN(A, erase)(self, self->root->key); + while (!JOIN(A, empty)(self)) + JOIN(A, erase) + (self, self->root->key); } static inline void -JOIN(A, free)(A* self) + JOIN(A, free)(A *self) { - JOIN(A, clear)(self); + JOIN(A, clear) + (self); *self = JOIN(A, init)(self->compare); } static inline A -JOIN(A, copy)(A* self) + JOIN(A, copy)(A *self) { I it = JOIN(I, each)(self); - A copy = JOIN(A, init)(self->compare); - while(!it.done) + A copy = JOIN(A, init)(self->compare); + while (!it.done) { - JOIN(A, insert)(©, self->copy(&it.node->key)); + JOIN(A, insert) + (©, self->copy(&it.node->key)); it.step(&it); } return copy; } static inline size_t -JOIN(A, remove_if)(A* self, int _match(T*)) + JOIN(A, remove_if)(A *self, int _match(T *)) { size_t erases = 0; - foreach(A, self, it) - if(_match(&it.node->key)) + foreach (A, self, it) + if (_match(&it.node->key)) { - JOIN(A, erase_node)(self, it.node); + JOIN(A, erase_node) + (self, it.node); erases += 1; } return erases; } static inline A -JOIN(A, intersection)(A* a, A* b) + JOIN(A, intersection)(A *a, A *b) { A self = JOIN(A, init)(a->compare); - foreach(A, a, i) - if(JOIN(A, find)(b, *i.ref)) - JOIN(A, insert)(&self, self.copy(i.ref)); + foreach (A, a, i) + if (JOIN(A, find)(b, *i.ref)) + JOIN(A, insert) + (&self, self.copy(i.ref)); return self; } static inline A -JOIN(A, union)(A* a, A* b) + JOIN(A, union)(A *a, A *b) { A self = JOIN(A, init)(a->compare); - foreach(A, a, i) JOIN(A, insert)(&self, self.copy(i.ref)); - foreach(A, b, i) JOIN(A, insert)(&self, self.copy(i.ref)); + foreach (A, a, i) + JOIN(A, insert) + (&self, self.copy(i.ref)); + foreach (A, b, i) + JOIN(A, insert) + (&self, self.copy(i.ref)); return self; } static inline A -JOIN(A, difference)(A* a, A* b) + JOIN(A, difference)(A *a, A *b) { A self = JOIN(A, copy)(a); - foreach(A, b, i) - JOIN(A, erase)(&self, *i.ref); + foreach (A, b, i) + JOIN(A, erase) + (&self, *i.ref); return self; } static inline A -JOIN(A, symmetric_difference)(A* a, A* b) + JOIN(A, symmetric_difference)(A *a, A *b) { A self = JOIN(A, union)(a, b); A intersection = JOIN(A, intersection)(a, b); - foreach(A, &intersection, i) - JOIN(A, erase)(&self, *i.ref); - JOIN(A, free)(&intersection); + foreach (A, &intersection, i) + JOIN(A, erase) + (&self, *i.ref); + JOIN(A, free) + (&intersection); return self; } diff --git a/ctl/stk.h b/ctl/stk.h index aaf285fb..f3f204ae 100644 --- a/ctl/stk.h +++ b/ctl/stk.h @@ -6,29 +6,29 @@ #error "Template type T undefined for " #endif -#define push_back push -#define pop_back pop -#define back top -#define at __AT -#define front __FRONT -#define begin __BEGIN -#define end __END -#define push_front __PUSH_FRONT -#define pop_front __POP_FRONT -#define erase __ERASE -#define insert __INSERT -#define resize __RESIZE -#define assign __ASSIGN -#define clear __CLEAR +#define push_back push +#define pop_back pop +#define back top +#define at __AT +#define front __FRONT +#define begin __BEGIN +#define end __END +#define push_front __PUSH_FRONT +#define pop_front __POP_FRONT +#define erase __ERASE +#define insert __INSERT +#define resize __RESIZE +#define assign __ASSIGN +#define clear __CLEAR #define ranged_sort __RANGED_SORT -#define sort __SORT -#define range __RANGE -#define each __EACH -#define step __STEP -#define remove_if __REMOVE_IF +#define sort __SORT +#define range __RANGE +#define each __EACH +#define step __STEP +#define remove_if __REMOVE_IF #define deq stk -#include +#include "deq.h" #undef deq #undef push_back diff --git a/ctl/str.h b/ctl/str.h index acc9840e..fb914321 100644 --- a/ctl/str.h +++ b/ctl/str.h @@ -15,7 +15,7 @@ #define str_init str___INIT #define str_equal str___EQUAL #define str_find str___FIND -#include +#include "vec.h" #undef str_init #undef str_equal #undef str_find @@ -25,35 +25,35 @@ #include static inline str -str_init(const char* c_str) +str_init(const char *c_str) { str self = str___INIT(); size_t len = strlen(c_str); size_t min = 15; str_reserve(&self, len < min ? min : len); - for(const char* s = c_str; *s; s++) + for (const char *s = c_str; *s; s++) str_push_back(&self, *s); return self; } static inline void -str_append(str* self, const char* s) +str_append(str *self, const char *s) { size_t start = self->size; size_t len = strlen(s); str_resize(self, self->size + len, '\0'); - for(size_t i = 0; i < len; i++) + for (size_t i = 0; i < len; i++) self->value[start + i] = s[i]; } static inline void -str_insert_str(str* self, size_t index, const char* s) +str_insert_str(str *self, size_t index, const char *s) { size_t start = self->size; size_t len = strlen(s); str_resize(self, self->size + len, '\0'); self->size = start; - while(len != 0) + while (len != 0) { len -= 1; str_insert(self, index, s[len]); @@ -61,123 +61,123 @@ str_insert_str(str* self, size_t index, const char* s) } static inline void -str_replace(str* self, size_t index, size_t size, const char* s) +str_replace(str *self, size_t index, size_t size, const char *s) { size_t end = index + size; - if(end >= self->size) + if (end >= self->size) end = self->size; - for(size_t i = index; i < end; i++) + for (size_t i = index; i < end; i++) str_erase(self, index); str_insert_str(self, index, s); } -static inline char* -str_c_str(str* self) +static inline char * +str_c_str(str *self) { return str_data(self); } static inline size_t -str_find(str* self, const char* s) +str_find(str *self, const char *s) { - char* c_str = self->value; - char* found = strstr(c_str, s); - if(found) + char *c_str = self->value; + char *found = strstr(c_str, s); + if (found) return found - c_str; return SIZE_MAX; } static inline int -str_count(str* self, char c) +str_count(str *self, char c) { size_t count = 0; - for(size_t i = 0; i < self->size; i++) - if(self->value[i] == c) + for (size_t i = 0; i < self->size; i++) + if (self->value[i] == c) count += 1; return count; } static inline size_t -str_rfind(str* self, const char* s) +str_rfind(str *self, const char *s) { - char* c_str = self->value; - for(size_t i = self->size; i != SIZE_MAX; i--) + char *c_str = self->value; + for (size_t i = self->size; i != SIZE_MAX; i--) { - char* found = strstr(&c_str[i], s); - if(found) + char *found = strstr(&c_str[i], s); + if (found) return found - c_str; } return SIZE_MAX; } static inline size_t -str_find_first_of(str* self, const char* s) +str_find_first_of(str *self, const char *s) { - for(size_t i = 0; i < self->size; i++) - for(const char* p = s; *p; p++) - if(self->value[i] == *p) - return i; + for (size_t i = 0; i < self->size; i++) + for (const char *p = s; *p; p++) + if (self->value[i] == *p) + return i; return SIZE_MAX; } static inline size_t -str_find_last_of(str* self, const char* s) +str_find_last_of(str *self, const char *s) { - for(size_t i = self->size; i != SIZE_MAX; i--) - for(const char* p = s; *p; p++) - if(self->value[i] == *p) - return i; + for (size_t i = self->size; i != SIZE_MAX; i--) + for (const char *p = s; *p; p++) + if (self->value[i] == *p) + return i; return SIZE_MAX; } static inline size_t -str_find_first_not_of(str* self, const char* s) +str_find_first_not_of(str *self, const char *s) { - for(size_t i = 0; i < self->size; i++) + for (size_t i = 0; i < self->size; i++) { size_t count = 0; - for(const char* p = s; *p; p++) - if(self->value[i] == *p) + for (const char *p = s; *p; p++) + if (self->value[i] == *p) count += 1; - if(count == 0) + if (count == 0) return i; } return SIZE_MAX; } static inline size_t -str_find_last_not_of(str* self, const char* s) +str_find_last_not_of(str *self, const char *s) { - for(size_t i = self->size - 1; i != SIZE_MAX; i--) + for (size_t i = self->size - 1; i != SIZE_MAX; i--) { size_t count = 0; - for(const char* p = s; *p; p++) - if(self->value[i] == *p) + for (const char *p = s; *p; p++) + if (self->value[i] == *p) count += 1; - if(count == 0) + if (count == 0) return i; } return SIZE_MAX; } static inline str -str_substr(str* self, size_t index, size_t size) +str_substr(str *self, size_t index, size_t size) { str substr = str_init(""); str_resize(&substr, size, '\0'); - for(size_t i = 0; i < size; i++) + for (size_t i = 0; i < size; i++) substr.value[i] = self->value[index + i]; return substr; } static inline int -str_compare(str* self, const char* s) +str_compare(str *self, const char *s) { return strcmp(self->value, s); } static inline int -str_key_compare(str* self, str* s) +str_key_compare(str *self, str *s) { return strcmp(self->value, s->value); } diff --git a/ctl/ust.h b/ctl/ust.h index b59989c5..33878945 100644 --- a/ctl/ust.h +++ b/ctl/ust.h @@ -6,7 +6,7 @@ #error "Template type T undefined for " #endif -#include +#include "ctl.h" #define A JOIN(ust, T) #define B JOIN(A, node) @@ -15,62 +15,60 @@ typedef struct B { T key; - struct B* next; -} -B; + struct B *next; +} B; typedef struct A { - void (*free)(T*); - T (*copy)(T*); - size_t (*hash)(T*); - int (*equal)(T*, T*); - B** bucket; + void (*free)(T *); + T (*copy) + (T *); + size_t (*hash)(T *); + int (*equal)(T *, T *); + B **bucket; size_t size; size_t bucket_count; -} -A; +} A; typedef struct I { - void (*step)(struct I*); - B* end; - B* node; - T* ref; - B* next; - A* container; + void (*step)(struct I *); + B *end; + B *node; + T *ref; + B *next; + A *container; size_t index; int done; -} -I; +} I; -static inline B* -JOIN(A, begin)(A* self) +static inline B * + JOIN(A, begin)(A *self) { - for(size_t i = 0; i < self->bucket_count; i++) + for (size_t i = 0; i < self->bucket_count; i++) { - B* node = self->bucket[i]; - if(node) + B *node = self->bucket[i]; + if (node) return node; } return NULL; } -static inline B* -JOIN(A, end)(A* self) +static inline B * + JOIN(A, end)(A *self) { - (void) self; + (void)self; return NULL; } static inline size_t -JOIN(I, index)(A* self, T value) + JOIN(I, index)(A *self, T value) { return self->hash(&value) % self->bucket_count; } static inline void -JOIN(I, update)(I* self) + JOIN(I, update)(I *self) { self->node = self->next; self->ref = &self->node->key; @@ -78,15 +76,16 @@ JOIN(I, update)(I* self) } static inline int -JOIN(I, scan)(I* self) + JOIN(I, scan)(I *self) { - for(size_t i = self->index + 1; i < self->container->bucket_count; i++) + for (size_t i = self->index + 1; i < self->container->bucket_count; i++) { self->next = self->container->bucket[i]; - if(self->next) + if (self->next) { self->index = i; - JOIN(I, update)(self); + JOIN(I, update) + (self); return 1; } } @@ -94,23 +93,24 @@ JOIN(I, scan)(I* self) } static inline void -JOIN(I, step)(I* self) + JOIN(I, step)(I *self) { - if(self->next == JOIN(A, end)(self->container)) + if (self->next == JOIN(A, end)(self->container)) { - if(!JOIN(I, scan)(self)) + if (!JOIN(I, scan)(self)) self->done = 1; } else - JOIN(I, update)(self); + JOIN(I, update) + (self); } static inline I -JOIN(I, range)(A* container, B* begin, B* end) + JOIN(I, range)(A *container, B *begin, B *end) { static I zero; I self = zero; - if(begin) + if (begin) { self.step = JOIN(I, step); self.node = begin; @@ -125,58 +125,62 @@ JOIN(I, range)(A* container, B* begin, B* end) return self; } -static inline B** -JOIN(A, bucket)(A* self, T value) +static inline B ** + JOIN(A, bucket)(A *self, T value) { size_t index = JOIN(I, index)(self, value); return &self->bucket[index]; } static inline int -JOIN(A, empty)(A* self) + JOIN(A, empty)(A *self) { return self->size == 0; } static inline I -JOIN(I, each)(A* a) + JOIN(I, each)(A *a) { return JOIN(A, empty)(a) - ? JOIN(I, range)(a, NULL, NULL) - : JOIN(I, range)(a, JOIN(A, begin)(a), JOIN(A, end)(a)); + ? JOIN(I, range)(a, NULL, NULL) + : JOIN(I, range)(a, JOIN(A, begin)(a), JOIN(A, end)(a)); } static inline T -JOIN(A, implicit_copy)(T* self) + JOIN(A, implicit_copy)(T *self) { return *self; } -static inline B* -JOIN(A, find)(A* self, T value) +static inline B * + JOIN(A, find)(A *self, T value) { - if(!JOIN(A, empty)(self)) + if (!JOIN(A, empty)(self)) { - B** bucket = JOIN(A, bucket)(self, value); - for(B* n = *bucket; n; n = n->next) - if(self->equal(&value, &n->key)) + B **bucket = JOIN(A, bucket)(self, value); + for (B *n = *bucket; n; n = n->next) + if (self->equal(&value, &n->key)) return n; } return NULL; } static inline int -JOIN(A, equal)(A* a, A* b) + JOIN(A, equal)(A *a, A *b) { size_t count_a = 0; size_t count_b = 0; - foreach(A, a, it) if(JOIN(A, find)(b, *it.ref)) count_a += 1; - foreach(A, b, it) if(JOIN(A, find)(a, *it.ref)) count_b += 1; + foreach (A, a, it) + if (JOIN(A, find)(b, *it.ref)) + count_a += 1; + foreach (A, b, it) + if (JOIN(A, find)(a, *it.ref)) + count_b += 1; return count_a == count_b; } static inline void -JOIN(A, swap)(A* self, A* other) + JOIN(A, swap)(A *self, A *other) { A temp = *self; *self = *other; @@ -184,76 +188,279 @@ JOIN(A, swap)(A* self, A* other) } static inline size_t -JOIN(A, closest_prime)(size_t number) + JOIN(A, closest_prime)(size_t number) { static uint32_t primes[] = { - 2, 3, 5, 7, 11, - 13, 17, 19, 23, 29, 31, - 37, 41, 43, 47, 53, 59, - 61, 67, 71, 73, 79, 83, - 89, 97, 103, 109, 113, 127, - 137, 139, 149, 157, 167, 179, - 193, 199, 211, 227, 241, 257, - 277, 293, 313, 337, 359, 383, - 409, 439, 467, 503, 541, 577, - 619, 661, 709, 761, 823, 887, - 953, 1031, 1109, 1193, 1289, 1381, - 1493, 1613, 1741, 1879, 2029, 2179, - 2357, 2549, 2753, 2971, 3209, 3469, - 3739, 4027, 4349, 4703, 5087, 5503, - 5953, 6427, 6949, 7517, 8123, 8783, - 9497, 10273, 11113, 12011, 12983, 14033, - 15173, 16411, 17749, 19183, 20753, 22447, - 24281, 26267, 28411, 30727, 33223, 35933, - 38873, 42043, 45481, 49201, 53201, 57557, - 62233, 67307, 72817, 78779, 85229, 92203, - 99733, 107897, 116731, 126271, 136607, 147793, - 159871, 172933, 187091, 202409, 218971, 236897, - 256279, 277261, 299951, 324503, 351061, 379787, - 410857, 444487, 480881, 520241, 562841, 608903, - 658753, 712697, 771049, 834181, 902483, 976369, - 1056323, 1142821, 1236397, 1337629, 1447153, 1565659, - 1693859, 1832561, 1982627, 2144977, 2320627, 2510653, - 2716249, 2938679, 3179303, 3439651, 3721303, 4026031, - 4355707, 4712381, 5098259, 5515729, 5967347, 6456007, - 6984629, 7556579, 8175383, 8844859, 9569143, 10352717, - 11200489, 12117689, 13109983, 14183539, 15345007, 16601593, - 17961079, 19431899, 21023161, 22744717, 24607243, 26622317, - 28802401, 31160981, 33712729, 36473443, 39460231, 42691603, - 46187573, 49969847, 54061849, 58488943, 63278561, 68460391, - 74066549, 80131819, 86693767, 93793069, 101473717, 109783337, - 118773397, 128499677, 139022417, 150406843, 162723577, 176048909, - 190465427, 206062531, 222936881, 241193053, 260944219, 282312799, - 305431229, 330442829, 357502601, 386778277, 418451333, 452718089, - 489790921, 529899637, 573292817, 620239453, 671030513, 725980837, - 785430967, 849749479, 919334987, 994618837, 1076067617, 1164186217, - 1259520799, 1362662261, 1474249943, 1594975441, 1725587117, + 2, + 3, + 5, + 7, + 11, + 13, + 17, + 19, + 23, + 29, + 31, + 37, + 41, + 43, + 47, + 53, + 59, + 61, + 67, + 71, + 73, + 79, + 83, + 89, + 97, + 103, + 109, + 113, + 127, + 137, + 139, + 149, + 157, + 167, + 179, + 193, + 199, + 211, + 227, + 241, + 257, + 277, + 293, + 313, + 337, + 359, + 383, + 409, + 439, + 467, + 503, + 541, + 577, + 619, + 661, + 709, + 761, + 823, + 887, + 953, + 1031, + 1109, + 1193, + 1289, + 1381, + 1493, + 1613, + 1741, + 1879, + 2029, + 2179, + 2357, + 2549, + 2753, + 2971, + 3209, + 3469, + 3739, + 4027, + 4349, + 4703, + 5087, + 5503, + 5953, + 6427, + 6949, + 7517, + 8123, + 8783, + 9497, + 10273, + 11113, + 12011, + 12983, + 14033, + 15173, + 16411, + 17749, + 19183, + 20753, + 22447, + 24281, + 26267, + 28411, + 30727, + 33223, + 35933, + 38873, + 42043, + 45481, + 49201, + 53201, + 57557, + 62233, + 67307, + 72817, + 78779, + 85229, + 92203, + 99733, + 107897, + 116731, + 126271, + 136607, + 147793, + 159871, + 172933, + 187091, + 202409, + 218971, + 236897, + 256279, + 277261, + 299951, + 324503, + 351061, + 379787, + 410857, + 444487, + 480881, + 520241, + 562841, + 608903, + 658753, + 712697, + 771049, + 834181, + 902483, + 976369, + 1056323, + 1142821, + 1236397, + 1337629, + 1447153, + 1565659, + 1693859, + 1832561, + 1982627, + 2144977, + 2320627, + 2510653, + 2716249, + 2938679, + 3179303, + 3439651, + 3721303, + 4026031, + 4355707, + 4712381, + 5098259, + 5515729, + 5967347, + 6456007, + 6984629, + 7556579, + 8175383, + 8844859, + 9569143, + 10352717, + 11200489, + 12117689, + 13109983, + 14183539, + 15345007, + 16601593, + 17961079, + 19431899, + 21023161, + 22744717, + 24607243, + 26622317, + 28802401, + 31160981, + 33712729, + 36473443, + 39460231, + 42691603, + 46187573, + 49969847, + 54061849, + 58488943, + 63278561, + 68460391, + 74066549, + 80131819, + 86693767, + 93793069, + 101473717, + 109783337, + 118773397, + 128499677, + 139022417, + 150406843, + 162723577, + 176048909, + 190465427, + 206062531, + 222936881, + 241193053, + 260944219, + 282312799, + 305431229, + 330442829, + 357502601, + 386778277, + 418451333, + 452718089, + 489790921, + 529899637, + 573292817, + 620239453, + 671030513, + 725980837, + 785430967, + 849749479, + 919334987, + 994618837, + 1076067617, + 1164186217, + 1259520799, + 1362662261, + 1474249943, + 1594975441, + 1725587117, }; size_t min = primes[0]; - if(number < min) + if (number < min) return min; size_t size = len(primes); - for(size_t i = 0; i < size - 1; i++) + for (size_t i = 0; i < size - 1; i++) { size_t a = primes[i + 0]; size_t b = primes[i + 1]; - if(number >= a && number <= b) + if (number >= a && number <= b) return number == a ? a : b; } return primes[size - 1]; } -static inline B* -JOIN(B, init)(T value) +static inline B * + JOIN(B, init)(T value) { - B* n = (B*) malloc(sizeof(B)); + B *n = (B *)malloc(sizeof(B)); n->key = value; n->next = NULL; return n; } static inline void -JOIN(B, push)(A* self, B** bucket, B* n) + JOIN(B, push)(A *self, B **bucket, B *n) { n->next = *bucket; self->size += 1; @@ -261,22 +468,22 @@ JOIN(B, push)(A* self, B** bucket, B* n) } static inline size_t -JOIN(A, bucket_size)(A* self, size_t index) + JOIN(A, bucket_size)(A *self, size_t index) { size_t size = 0; - for(B* n = self->bucket[index]; n; n = n->next) + for (B *n = self->bucket[index]; n; n = n->next) size += 1; return size; } static inline float -JOIN(A, load_factor)(A* self) + JOIN(A, load_factor)(A *self) { - return (float) self->size / (float) self->bucket_count; + return (float)self->size / (float)self->bucket_count; } static inline A -JOIN(A, init)(size_t _hash(T*), int _equal(T*, T*)) + JOIN(A, init)(size_t _hash(T *), int _equal(T *, T *)) { static A zero; A self = zero; @@ -293,18 +500,19 @@ JOIN(A, init)(size_t _hash(T*), int _equal(T*, T*)) } static inline void -JOIN(A, rehash)(A* self, size_t desired_count); + JOIN(A, rehash)(A *self, size_t desired_count); static inline void -JOIN(A, reserve)(A* self, size_t desired_count) + JOIN(A, reserve)(A *self, size_t desired_count) { - if(self->size > 0) - JOIN(A, rehash)(self, desired_count); + if (self->size > 0) + JOIN(A, rehash) + (self, desired_count); else { size_t bucket_count = JOIN(A, closest_prime)(desired_count); - B** temp = (B**) calloc(bucket_count, sizeof(B*)); - for(size_t i = 0; i < self->bucket_count; i++) + B **temp = (B **)calloc(bucket_count, sizeof(B *)); + for (size_t i = 0; i < self->bucket_count; i++) temp[i] = self->bucket[i]; free(self->bucket); self->bucket = temp; @@ -313,19 +521,21 @@ JOIN(A, reserve)(A* self, size_t desired_count) } static inline void -JOIN(A, rehash)(A* self, size_t desired_count) + JOIN(A, rehash)(A *self, size_t desired_count) { - if(desired_count <= self->size) + if (desired_count <= self->size) desired_count = self->size + 1; size_t expected = JOIN(A, closest_prime)(desired_count); - if(expected != self->bucket_count) + if (expected != self->bucket_count) { A rehashed = JOIN(A, init)(self->hash, self->equal); - JOIN(A, reserve)(&rehashed, desired_count); - foreach(A, self, it) + JOIN(A, reserve) + (&rehashed, desired_count); + foreach (A, self, it) { - B** bucket = JOIN(A, bucket)(&rehashed, it.node->key); - JOIN(B, push)(&rehashed, bucket, it.node); + B **bucket = JOIN(A, bucket)(&rehashed, it.node->key); + JOIN(B, push) + (&rehashed, bucket, it.node); } free(self->bucket); *self = rehashed; @@ -333,79 +543,86 @@ JOIN(A, rehash)(A* self, size_t desired_count) } static inline void -JOIN(A, free_node)(A* self, B* n) + JOIN(A, free_node)(A *self, B *n) { - if(self->free) + if (self->free) self->free(&n->key); free(n); self->size -= 1; } static inline void -JOIN(A, clear)(A* self) + JOIN(A, clear)(A *self) { - foreach(A, self, it) - JOIN(A, free_node)(self, it.node); - for(size_t i = 0; i < self->bucket_count; i++) + foreach (A, self, it) + JOIN(A, free_node) + (self, it.node); + for (size_t i = 0; i < self->bucket_count; i++) self->bucket[i] = NULL; } static inline void -JOIN(A, free)(A* self) + JOIN(A, free)(A *self) { - JOIN(A, clear)(self); + JOIN(A, clear) + (self); free(self->bucket); } static inline void -JOIN(A, insert)(A* self, T value) + JOIN(A, insert)(A *self, T value) { - if(JOIN(A, empty)(self)) - JOIN(A, rehash)(self, 12); - if(JOIN(A, find)(self, value)) + if (JOIN(A, empty)(self)) + JOIN(A, rehash) + (self, 12); + if (JOIN(A, find)(self, value)) { - if(self->free) + if (self->free) self->free(&value); } else { - B** bucket = JOIN(A, bucket)(self, value); - JOIN(B, push)(self, bucket, JOIN(B, init)(value)); - if(self->size > self->bucket_count) - JOIN(A, rehash)(self, 2 * self->bucket_count); + B **bucket = JOIN(A, bucket)(self, value); + JOIN(B, push) + (self, bucket, JOIN(B, init)(value)); + if (self->size > self->bucket_count) + JOIN(A, rehash) + (self, 2 * self->bucket_count); } } static inline size_t -JOIN(A, count)(A* self, T value) + JOIN(A, count)(A *self, T value) { return JOIN(A, find)(self, value) ? 1 : 0; } static inline void -JOIN(A, linked_erase)(A* self, B** bucket, B* n, B* prev, B* next) + JOIN(A, linked_erase)(A *self, B **bucket, B *n, B *prev, B *next) { - JOIN(A, free_node)(self, n); - if(prev) + JOIN(A, free_node) + (self, n); + if (prev) prev->next = next; else *bucket = next; } static inline void -JOIN(A, erase)(A* self, T value) + JOIN(A, erase)(A *self, T value) { - if(!JOIN(A, empty)(self)) + if (!JOIN(A, empty)(self)) { - B** bucket = JOIN(A, bucket)(self, value); - B* prev = NULL; - B* n = *bucket; - while(n) + B **bucket = JOIN(A, bucket)(self, value); + B *prev = NULL; + B *n = *bucket; + while (n) { - B* next = n->next; - if(self->equal(&n->key, &value)) + B *next = n->next; + if (self->equal(&n->key, &value)) { - JOIN(A, linked_erase)(self, bucket, n, prev, next); + JOIN(A, linked_erase) + (self, bucket, n, prev, next); break; } else @@ -416,20 +633,21 @@ JOIN(A, erase)(A* self, T value) } static inline size_t -JOIN(A, remove_if)(A* self, int _match(T*)) + JOIN(A, remove_if)(A *self, int _match(T *)) { size_t erases = 0; - for(size_t i = 0; i < self->bucket_count; i++) + for (size_t i = 0; i < self->bucket_count; i++) { - B** bucket = &self->bucket[i]; - B* prev = NULL; - B* n = *bucket; - while(n) + B **bucket = &self->bucket[i]; + B *prev = NULL; + B *n = *bucket; + while (n) { - B* next = n->next; - if(_match(&n->key)) + B *next = n->next; + if (_match(&n->key)) { - JOIN(A, linked_erase)(self, bucket, n, prev, next); + JOIN(A, linked_erase) + (self, bucket, n, prev, next); erases += 1; } else @@ -441,11 +659,12 @@ JOIN(A, remove_if)(A* self, int _match(T*)) } static inline A -JOIN(A, copy)(A* self) + JOIN(A, copy)(A *self) { A other = JOIN(A, init)(self->hash, self->equal); - foreach(A, self, it) - JOIN(A, insert)(&other, self->copy(it.ref)); + foreach (A, self, it) + JOIN(A, insert) + (&other, self->copy(it.ref)); return other; } diff --git a/ctl/vec.h b/ctl/vec.h index 97d0db1a..a037a87d 100644 --- a/ctl/vec.h +++ b/ctl/vec.h @@ -6,7 +6,7 @@ #error "Template type T undefined for " #endif -#include +#include "ctl.h" #define A JOIN(vec, T) #define I JOIN(A, it) @@ -15,62 +15,61 @@ typedef struct A { - T* value; - void (*free)(T*); + T *value; + void (*free)(T *); #ifdef COMPARE - int (*compare)(T*, T*); + int (*compare)(T *, T *); #endif - T (*copy)(T*); + T (*copy) + (T *); size_t size; size_t capacity; -} -A; +} A; typedef struct I { - void (*step)(struct I*); - T* ref; - T* begin; - T* end; - T* next; + void (*step)(struct I *); + T *ref; + T *begin; + T *end; + T *next; int done; -} -I; +} I; -static inline T* -JOIN(A, at)(A* self, size_t index) +static inline T * + JOIN(A, at)(A *self, size_t index) { return &self->value[index]; } -static inline T* -JOIN(A, front)(A* self) +static inline T * + JOIN(A, front)(A *self) { return JOIN(A, at)(self, 0); } -static inline T* -JOIN(A, back)(A* self) +static inline T * + JOIN(A, back)(A *self) { return JOIN(A, at)(self, self->size - 1); } -static inline T* -JOIN(A, begin)(A* self) +static inline T * + JOIN(A, begin)(A *self) { return JOIN(A, front)(self); } -static inline T* -JOIN(A, end)(A* self) +static inline T * + JOIN(A, end)(A *self) { return JOIN(A, back)(self) + 1; } static inline void -JOIN(I, step)(I* self) + JOIN(I, step)(I *self) { - if(self->next >= self->end) + if (self->next >= self->end) self->done = 1; else { @@ -80,12 +79,12 @@ JOIN(I, step)(I* self) } static inline I -JOIN(I, range)(A* container, T* begin, T* end) + JOIN(I, range)(A *container, T *begin, T *end) { - (void) container; + (void)container; static I zero; I self = zero; - if(begin && end) + if (begin && end) { self.step = JOIN(I, step); self.begin = begin; @@ -99,35 +98,35 @@ JOIN(I, range)(A* container, T* begin, T* end) } static inline int -JOIN(A, empty)(A* self) + JOIN(A, empty)(A *self) { return self->size == 0; } static inline I -JOIN(I, each)(A* a) + JOIN(I, each)(A *a) { return JOIN(A, empty)(a) - ? JOIN(I, range)(a, NULL, NULL) - : JOIN(I, range)(a, JOIN(A, begin)(a), JOIN(A, end)(a)); + ? JOIN(I, range)(a, NULL, NULL) + : JOIN(I, range)(a, JOIN(A, begin)(a), JOIN(A, end)(a)); } static inline T -JOIN(A, implicit_copy)(T* self) + JOIN(A, implicit_copy)(T *self) { return *self; } static inline int -JOIN(A, equal)(A* self, A* other, int _equal(T*, T*)) + JOIN(A, equal)(A *self, A *other, int _equal(T *, T *)) { - if(self->size != other->size) + if (self->size != other->size) return 0; I a = JOIN(I, each)(self); I b = JOIN(I, each)(other); - while(!a.done && !b.done) + while (!a.done && !b.done) { - if(!_equal(a.ref, b.ref)) + if (!_equal(a.ref, b.ref)) return 0; a.step(&a); b.step(&b); @@ -136,7 +135,7 @@ JOIN(A, equal)(A* self, A* other, int _equal(T*, T*)) } static inline void -JOIN(A, swap)(A* self, A* other) + JOIN(A, swap)(A *self, A *other) { A temp = *self; *self = *other; @@ -144,7 +143,7 @@ JOIN(A, swap)(A* self, A* other) } static inline A -JOIN(A, init)(void) + JOIN(A, init)(void) { static A zero; A self = zero; @@ -159,165 +158,178 @@ JOIN(A, init)(void) } static inline void -JOIN(A, set)(A* self, size_t index, T value) + JOIN(A, set)(A *self, size_t index, T value) { - T* ref = JOIN(A, at)(self, index); - if(self->free) + T *ref = JOIN(A, at)(self, index); + if (self->free) self->free(ref); *ref = value; } static inline void -JOIN(A, pop_back)(A* self) + JOIN(A, pop_back)(A *self) { static T zero; self->size -= 1; - JOIN(A, set)(self, self->size, zero); + JOIN(A, set) + (self, self->size, zero); } static inline void -JOIN(A, wipe)(A* self, size_t n) + JOIN(A, wipe)(A *self, size_t n) { - while(n != 0) + while (n != 0) { - JOIN(A, pop_back)(self); + JOIN(A, pop_back) + (self); n -= 1; } } static inline void -JOIN(A, clear)(A* self) + JOIN(A, clear)(A *self) { - if(self->size > 0) - JOIN(A, wipe)(self, self->size); + if (self->size > 0) + JOIN(A, wipe) + (self, self->size); } static inline void -JOIN(A, free)(A* self) + JOIN(A, free)(A *self) { - JOIN(A, clear)(self); + JOIN(A, clear) + (self); free(self->value); *self = JOIN(A, init)(); } static inline void -JOIN(A, fit)(A* self, size_t capacity) + JOIN(A, fit)(A *self, size_t capacity) { static T zero; size_t overall = capacity; - if(MUST_ALIGN_16(T)) + if (MUST_ALIGN_16(T)) overall += 1; - self->value = (T*) realloc(self->value, overall * sizeof(T)); - if(MUST_ALIGN_16(T)) - for(size_t i = self->capacity; i < overall; i++) + self->value = (T *)realloc(self->value, overall * sizeof(T)); + if (MUST_ALIGN_16(T)) + for (size_t i = self->capacity; i < overall; i++) self->value[i] = zero; self->capacity = capacity; } static inline void -JOIN(A, reserve)(A* self, const size_t capacity) + JOIN(A, reserve)(A *self, const size_t capacity) { - if(capacity != self->capacity) + if (capacity != self->capacity) { size_t actual = 0; - if(MUST_ALIGN_16(T)) + if (MUST_ALIGN_16(T)) { - if(capacity <= self->size) + if (capacity <= self->size) actual = self->size; - else - if(capacity > self->size && capacity < self->capacity) + else if (capacity > self->size && capacity < self->capacity) actual = capacity; else { actual = 2 * self->capacity; - if(capacity > actual) + if (capacity > actual) actual = capacity; } } - else - if(capacity > self->capacity) + else if (capacity > self->capacity) actual = capacity; - if(actual > 0) - JOIN(A, fit)(self, actual); + if (actual > 0) + JOIN(A, fit) + (self, actual); } } static inline void -JOIN(A, push_back)(A* self, T value) + JOIN(A, push_back)(A *self, T value) { - if(self->size == self->capacity) - JOIN(A, reserve)(self, self->capacity == 0 ? 1 : 2 * self->capacity); + if (self->size == self->capacity) + JOIN(A, reserve) + (self, self->capacity == 0 ? 1 : 2 * self->capacity); *JOIN(A, at)(self, self->size) = value; self->size += 1; } static inline void -JOIN(A, resize)(A* self, size_t size, T value) + JOIN(A, resize)(A *self, size_t size, T value) { - if(size < self->size) + if (size < self->size) { int64_t less = self->size - size; - if(less > 0) - JOIN(A, wipe)(self, less); + if (less > 0) + JOIN(A, wipe) + (self, less); } else { - if(size > self->capacity) + if (size > self->capacity) { size_t capacity = 2 * self->size; - if(size > capacity) + if (size > capacity) capacity = size; - JOIN(A, reserve)(self, capacity); + JOIN(A, reserve) + (self, capacity); } - for(size_t i = 0; self->size < size; i++) - JOIN(A, push_back)(self, self->copy(&value)); + for (size_t i = 0; self->size < size; i++) + JOIN(A, push_back) + (self, self->copy(&value)); } - if(self->free) + if (self->free) self->free(&value); } static inline void -JOIN(A, assign)(A* self, size_t size, T value) -{ - JOIN(A, resize)(self, size, self->copy(&value)); - for(size_t i = 0; i < size; i++) - JOIN(A, set)(self, i, self->copy(&value)); - if(self->free) + JOIN(A, assign)(A *self, size_t size, T value) +{ + JOIN(A, resize) + (self, size, self->copy(&value)); + for (size_t i = 0; i < size; i++) + JOIN(A, set) + (self, i, self->copy(&value)); + if (self->free) self->free(&value); } static inline void -JOIN(A, shrink_to_fit)(A* self) + JOIN(A, shrink_to_fit)(A *self) { - JOIN(A, fit)(self, self->size); + JOIN(A, fit) + (self, self->size); } -static inline T* -JOIN(A, data)(A* self) +static inline T * + JOIN(A, data)(A *self) { return JOIN(A, front)(self); } static inline void -JOIN(A, insert)(A* self, size_t index, T value) + JOIN(A, insert)(A *self, size_t index, T value) { - if(self->size > 0) + if (self->size > 0) { - JOIN(A, push_back)(self, *JOIN(A, back)(self)); - for(size_t i = self->size - 2; i > index; i--) + JOIN(A, push_back) + (self, *JOIN(A, back)(self)); + for (size_t i = self->size - 2; i > index; i--) self->value[i] = self->value[i - 1]; self->value[index] = value; } else - JOIN(A, push_back)(self, value); + JOIN(A, push_back) + (self, value); } static inline void -JOIN(A, erase)(A* self, size_t index) + JOIN(A, erase)(A *self, size_t index) { static T zero; - JOIN(A, set)(self, index, zero); - for(size_t i = index; i < self->size - 1; i++) + JOIN(A, set) + (self, index, zero); + for (size_t i = index; i < self->size - 1; i++) { self->value[i] = self->value[i + 1]; self->value[i + 1] = zero; @@ -326,53 +338,59 @@ JOIN(A, erase)(A* self, size_t index) } static inline void -JOIN(A, ranged_sort)(A* self, int64_t a, int64_t b, int _compare(T*, T*)) + JOIN(A, ranged_sort)(A *self, int64_t a, int64_t b, int _compare(T *, T *)) { - if(a >= b) + if (a >= b) return; int64_t mid = (a + b) / 2; SWAP(T, &self->value[a], &self->value[mid]); int64_t z = a; - for(int64_t i = a + 1; i <= b; i++) - if(_compare(&self->value[a], &self->value[i])) + for (int64_t i = a + 1; i <= b; i++) + if (_compare(&self->value[a], &self->value[i])) { z += 1; SWAP(T, &self->value[z], &self->value[i]); } SWAP(T, &self->value[a], &self->value[z]); - JOIN(A, ranged_sort)(self, a, z - 1, _compare); - JOIN(A, ranged_sort)(self, z + 1, b, _compare); + JOIN(A, ranged_sort) + (self, a, z - 1, _compare); + JOIN(A, ranged_sort) + (self, z + 1, b, _compare); } static inline void -JOIN(A, sort)(A* self, int _compare(T*, T*)) + JOIN(A, sort)(A *self, int _compare(T *, T *)) { - JOIN(A, ranged_sort)(self, 0, self->size - 1, _compare); + JOIN(A, ranged_sort) + (self, 0, self->size - 1, _compare); } static inline A -JOIN(A, copy)(A* self) + JOIN(A, copy)(A *self) { A other = JOIN(A, init)(); #ifdef COMPARE other.compare = self->compare; #endif - JOIN(A, reserve)(&other, self->size); - while(other.size < self->size) - JOIN(A, push_back)(&other, other.copy(&self->value[other.size])); + JOIN(A, reserve) + (&other, self->size); + while (other.size < self->size) + JOIN(A, push_back) + (&other, other.copy(&self->value[other.size])); return other; } static inline size_t -JOIN(A, remove_if)(A* self, int _match(T*)) + JOIN(A, remove_if)(A *self, int _match(T *)) { size_t erases = 0; - foreach(A, self, it) + foreach (A, self, it) { - if(_match(it.ref)) + if (_match(it.ref)) { size_t index = it.ref - JOIN(A, begin)(self); - JOIN(A, erase)(self, index); + JOIN(A, erase) + (self, index); it.end = JOIN(A, end)(self); it.next = it.ref; erases += 1; @@ -381,11 +399,11 @@ JOIN(A, remove_if)(A* self, int _match(T*)) return erases; } -static inline T* -JOIN(A, find)(A* self, T key, int _equal(T*, T*)) +static inline T * + JOIN(A, find)(A *self, T key, int _equal(T *, T *)) { - foreach(A, self, it) - if(_equal(it.ref, &key)) + foreach (A, self, it) + if (_equal(it.ref, &key)) return it.ref; return NULL; } diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt new file mode 100644 index 00000000..c7007f3c --- /dev/null +++ b/examples/CMakeLists.txt @@ -0,0 +1,19 @@ +cmake_minimum_required(VERSION 3.10) + +project(ctlExamples) + +# Set up the global common compiler settings +include(../common.cmake) + +# Add examples +add_custom_target(examples) +function(AddExample sourceFileNoExtension) + add_executable(${sourceFileNoExtension} "${sourceFileNoExtension}.c") + add_dependencies(examples ${sourceFileNoExtension}) +endfunction() + +AddExample(astar) +AddExample(postfix) +AddExample(json) +AddExample(snow) +AddExample(6502) diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt new file mode 100644 index 00000000..a7b39eb8 --- /dev/null +++ b/tests/CMakeLists.txt @@ -0,0 +1,35 @@ +cmake_minimum_required(VERSION 3.10) + +project(ctlTest) + +# Set up the global common compiler settings +include(../common.cmake) + +# Add tests +add_custom_target(tests) +set(testFileDir func) + +function(AddTest sourceFileNoExtension) + find_file(${sourceFileNoExtension}.c ${sourceFileNoExtension}.c ${testFileDir}) + if(${sourceFileNoExtension}.c) + message("Found ${sourceFileNoExtension}.c") + add_executable(${sourceFileNoExtension} "${testFileDir}/${sourceFileNoExtension}.c") + else() + message("Found ${sourceFileNoExtension}.cc") + add_executable(${sourceFileNoExtension} "${testFileDir}/${sourceFileNoExtension}.cc") + endif() + add_dependencies(tests ${sourceFileNoExtension}) +endfunction() + +AddTest(test_c11) +AddTest(test_container_composing) +AddTest(test_deq) +AddTest(test_lst) +AddTest(test_str) +AddTest(test_pqu) +AddTest(test_que) +AddTest(test_set) +AddTest(test_ust) +AddTest(test_stk) +AddTest(test_vec_capacity) +AddTest(test_vec) From 27cf387a1b380a3abda86d5a507bee22a1b59e38 Mon Sep 17 00:00:00 2001 From: HO-COOH Date: Thu, 29 Apr 2021 07:03:49 +0800 Subject: [PATCH 4/6] Add cmake section in README.md --- README.md | 67 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) diff --git a/README.md b/README.md index c297ab7e..1ed3c90f 100644 --- a/README.md +++ b/README.md @@ -58,6 +58,73 @@ gcc main.c -I ctl For a much more thorough getting started guide, see the wiki: https://github.com/glouw/ctl/wiki +## CMake Support +### Install +1. Clone this repo by +``` +git clone https://github.com/glouw/ctl +``` +2. Configure +``` +cd ctl +mkdir build +cd build +cmake .. +``` +3. Install +- Linux: +``` +sudo cmake --install . +``` + +- Windows: Open a shell with administrator +``` +cmake --install . +``` + +### Use ctl CMake packages +Add the following line to your `CMakeLists.txt` +```cmake +find_package(ctl REQUIRED CONFIG) +#... Add your executable or target +target_link_libraries( PRIVATE ctl) +``` + +Include the header using `#include `, for example: +```c +#include + +#define P +#define T int +#include + +int compare(int* a, int* b) { return *b < *a; } + +int main(void) +{ + vec_int a = vec_int_init(); + vec_int_push_back(&a, 9); + vec_int_push_back(&a, 1); + vec_int_push_back(&a, 8); + vec_int_push_back(&a, 3); + vec_int_push_back(&a, 4); + vec_int_sort(&a, compare); + foreach(vec_int, &a, it) + printf("%d\n", *it.ref); + vec_int_free(&a); +} +``` + +### Uninstall +`cd` into `ctl/build` directory +- Linux: +``` +sudo cmake --build . --target Uninstall +``` +- Windows: Open a shell with administrator +``` +cmake --build . --target Uninstall +``` ## Memory Ownership Types with memory ownership require definition `P` be omitted, and require From 7ab30ca06f83d5f74c40a2b0d20d3a1b689300a2 Mon Sep 17 00:00:00 2001 From: HO-COOH Date: Thu, 29 Apr 2021 07:12:37 +0800 Subject: [PATCH 5/6] Restore format --- ctl/deq.h | 289 ++++++++++++------------- ctl/lst.h | 313 ++++++++++++--------------- ctl/pqu.h | 101 ++++----- ctl/que.h | 36 +-- ctl/set.h | 637 +++++++++++++++++++++++++----------------------------- ctl/stk.h | 40 ++-- ctl/str.h | 96 ++++---- ctl/ust.h | 549 ++++++++++++++-------------------------------- ctl/vec.h | 258 ++++++++++------------ 9 files changed, 992 insertions(+), 1327 deletions(-) diff --git a/ctl/deq.h b/ctl/deq.h index efc400a4..abe45086 100644 --- a/ctl/deq.h +++ b/ctl/deq.h @@ -6,7 +6,7 @@ #error "Template type T undefined for " #endif -#include "ctl.h" +#include #define A JOIN(deq, T) #define B JOIN(A, bucket) @@ -19,88 +19,90 @@ typedef struct B T value[DEQ_BUCKET_SIZE]; int16_t a; int16_t b; -} B; +} +B; typedef struct A { - void (*free)(T *); - T (*copy) - (T *); - B **pages; + void (*free)(T*); + T (*copy)(T*); + B** pages; size_t mark_a; size_t mark_b; size_t capacity; size_t size; -} A; +} +A; typedef struct I { - void (*step)(struct I *); - A *container; - T *ref; + void (*step)(struct I*); + A* container; + T* ref; size_t index; size_t index_next; size_t index_last; int done; -} I; +} +I; -static inline B ** - JOIN(A, first)(A *self) +static inline B** +JOIN(A, first)(A* self) { return &self->pages[self->mark_a]; } -static inline B ** - JOIN(A, last)(A *self) +static inline B** +JOIN(A, last)(A* self) { return &self->pages[self->mark_b - 1]; } -static inline T * - JOIN(A, at)(A *self, size_t index) +static inline T* +JOIN(A, at)(A* self, size_t index) { - if (self->size == 0) + if(self->size == 0) return NULL; else { - B *first = *JOIN(A, first)(self); + B* first = *JOIN(A, first)(self); size_t actual = index + first->a; size_t q = actual / DEQ_BUCKET_SIZE; size_t r = actual % DEQ_BUCKET_SIZE; - B *page = self->pages[self->mark_a + q]; + B* page = self->pages[self->mark_a + q]; return &page->value[r]; } } -static inline T * - JOIN(A, front)(A *self) +static inline T* +JOIN(A, front)(A* self) { return JOIN(A, at)(self, 0); } -static inline T * - JOIN(A, back)(A *self) +static inline T* +JOIN(A, back)(A* self) { return JOIN(A, at)(self, self->size - 1); } -static inline T * - JOIN(A, begin)(A *self) +static inline T* +JOIN(A, begin)(A* self) { return JOIN(A, front)(self); } -static inline T * - JOIN(A, end)(A *self) +static inline T* +JOIN(A, end)(A* self) { return JOIN(A, back)(self) + 1; } static inline void - JOIN(I, step)(I *self) +JOIN(I, step)(I* self) { self->index = self->index_next; - if (self->index == self->index_last) + if(self->index == self->index_last) self->done = 1; else { @@ -110,11 +112,11 @@ static inline void } static inline I - JOIN(I, range)(A *container, T *begin, T *end) +JOIN(I, range)(A* container, T* begin, T* end) { static I zero; I self = zero; - if (begin && end) + if(begin && end) { self.container = container; self.step = JOIN(I, step); @@ -129,35 +131,35 @@ static inline I } static inline int - JOIN(A, empty)(A *self) +JOIN(A, empty)(A* self) { return self->size == 0; } static inline I - JOIN(I, each)(A *a) +JOIN(I, each)(A* a) { return JOIN(A, empty)(a) - ? JOIN(I, range)(a, NULL, NULL) - : JOIN(I, range)(a, JOIN(A, begin)(a), JOIN(A, end)(a)); + ? JOIN(I, range)(a, NULL, NULL) + : JOIN(I, range)(a, JOIN(A, begin)(a), JOIN(A, end)(a)); } static inline T - JOIN(A, implicit_copy)(T *self) +JOIN(A, implicit_copy)(T* self) { return *self; } static inline int - JOIN(A, equal)(A *self, A *other, int _equal(T *, T *)) +JOIN(A, equal)(A* self, A* other, int _equal(T*, T*)) { - if (self->size != other->size) + if(self->size != other->size) return 0; I a = JOIN(I, each)(self); I b = JOIN(I, each)(other); - while (!a.done && !b.done) + while(!a.done && !b.done) { - if (!_equal(a.ref, b.ref)) + if(!_equal(a.ref, b.ref)) return 0; a.step(&a); b.step(&b); @@ -166,7 +168,7 @@ static inline int } static inline void - JOIN(A, swap)(A *self, A *other) +JOIN(A, swap)(A* self, A* other) { A temp = *self; *self = *other; @@ -174,7 +176,7 @@ static inline void } static inline A - JOIN(A, init)(void) +JOIN(A, init)(void) { static A zero; A self = zero; @@ -188,31 +190,31 @@ static inline A return self; } -static inline B * - JOIN(B, init)(size_t cut) +static inline B* +JOIN(B, init)(size_t cut) { - B *self = (B *)malloc(sizeof(B)); + B* self = (B*) malloc(sizeof(B)); self->a = self->b = cut; return self; } static inline void - JOIN(A, set)(A *self, size_t index, T value) +JOIN(A, set)(A* self, size_t index, T value) { - T *ref = JOIN(A, at)(self, index); - if (self->free) + T* ref = JOIN(A, at)(self, index); + if(self->free) self->free(ref); *ref = value; } static inline void - JOIN(A, alloc)(A *self, size_t capacity, size_t shift_from) +JOIN(A, alloc)(A* self, size_t capacity, size_t shift_from) { self->capacity = capacity; - self->pages = (B **)realloc(self->pages, capacity * sizeof(B *)); + self->pages = (B**) realloc(self->pages, capacity * sizeof(B*)); size_t shift = (self->capacity - shift_from) / 2; size_t i = self->mark_b; - while (i != 0) + while(i != 0) { i -= 1; self->pages[i + shift] = self->pages[i]; @@ -222,46 +224,44 @@ static inline void } static inline void - JOIN(A, push_front)(A *self, T value) +JOIN(A, push_front)(A* self, T value) { - if (JOIN(A, empty)(self)) + if(JOIN(A, empty)(self)) { self->mark_a = 0; self->mark_b = 1; - JOIN(A, alloc) - (self, 1, 0); + JOIN(A, alloc)(self, 1, 0); *JOIN(A, last)(self) = JOIN(B, init)(DEQ_BUCKET_SIZE); } else { - B *page = *JOIN(A, first)(self); - if (page->a == 0) + B* page = *JOIN(A, first)(self); + if(page->a == 0) { - if (self->mark_a == 0) - JOIN(A, alloc) - (self, 2 * self->capacity, self->mark_a); + if(self->mark_a == 0) + JOIN(A, alloc)(self, 2 * self->capacity, self->mark_a); self->mark_a -= 1; *JOIN(A, first)(self) = JOIN(B, init)(DEQ_BUCKET_SIZE); } } - B *page = *JOIN(A, first)(self); + B* page = *JOIN(A, first)(self); page->a -= 1; self->size += 1; page->value[page->a] = value; } static inline void - JOIN(A, pop_front)(A *self) +JOIN(A, pop_front)(A* self) { - B *page = *JOIN(A, first)(self); - if (self->free) + B* page = *JOIN(A, first)(self); + if(self->free) { - T *ref = &page->value[page->a]; + T* ref = &page->value[page->a]; self->free(ref); } page->a += 1; self->size -= 1; - if (page->a == page->b) + if(page->a == page->b) { free(page); self->mark_a += 1; @@ -269,46 +269,44 @@ static inline void } static inline void - JOIN(A, push_back)(A *self, T value) +JOIN(A, push_back)(A* self, T value) { - if (JOIN(A, empty)(self)) + if(JOIN(A, empty)(self)) { self->mark_a = 0; self->mark_b = 1; - JOIN(A, alloc) - (self, 1, 0); + JOIN(A, alloc)(self, 1, 0); *JOIN(A, last)(self) = JOIN(B, init)(0); } else { - B *page = *JOIN(A, last)(self); - if (page->b == DEQ_BUCKET_SIZE) + B* page = *JOIN(A, last)(self); + if(page->b == DEQ_BUCKET_SIZE) { - if (self->mark_b == self->capacity) - JOIN(A, alloc) - (self, 2 * self->capacity, self->mark_b); + if(self->mark_b == self->capacity) + JOIN(A, alloc)(self, 2 * self->capacity, self->mark_b); self->mark_b += 1; *JOIN(A, last)(self) = JOIN(B, init)(0); } } - B *page = *JOIN(A, last)(self); + B* page = *JOIN(A, last)(self); page->value[page->b] = value; page->b += 1; self->size += 1; } static inline void - JOIN(A, pop_back)(A *self) +JOIN(A, pop_back)(A* self) { - B *page = *JOIN(A, last)(self); + B* page = *JOIN(A, last)(self); page->b -= 1; self->size -= 1; - if (self->free) + if(self->free) { - T *ref = &page->value[page->b]; + T* ref = &page->value[page->b]; self->free(ref); } - if (page->b == page->a) + if(page->b == page->a) { free(page); self->mark_b -= 1; @@ -316,155 +314,138 @@ static inline void } static inline void - JOIN(A, erase)(A *self, size_t index) +JOIN(A, erase)(A* self, size_t index) { static T zero; - JOIN(A, set) - (self, index, zero); - void (*saved)(T *) = self->free; + JOIN(A, set)(self, index, zero); + void (*saved)(T*) = self->free; self->free = NULL; - if (index < self->size / 2) + if(index < self->size / 2) { - for (size_t i = index; i > 0; i--) + for(size_t i = index; i > 0; i--) *JOIN(A, at)(self, i) = *JOIN(A, at)(self, i - 1); - JOIN(A, pop_front) - (self); + JOIN(A, pop_front)(self); } else { - for (size_t i = index; i < self->size - 1; i++) + for(size_t i = index; i < self->size - 1; i++) *JOIN(A, at)(self, i) = *JOIN(A, at)(self, i + 1); - JOIN(A, pop_back) - (self); + JOIN(A, pop_back)(self); } self->free = saved; } static inline void - JOIN(A, insert)(A *self, size_t index, T value) +JOIN(A, insert)(A* self, size_t index, T value) { - if (self->size > 0) + if(self->size > 0) { - void (*saved)(T *) = self->free; + void (*saved)(T*) = self->free; self->free = NULL; - if (index < self->size / 2) + if(index < self->size / 2) { - JOIN(A, push_front) - (self, *JOIN(A, at)(self, 0)); - for (size_t i = 0; i < index; i++) + JOIN(A, push_front)(self, *JOIN(A, at)(self, 0)); + for(size_t i = 0; i < index; i++) *JOIN(A, at)(self, i) = *JOIN(A, at)(self, i + 1); } else { - JOIN(A, push_back) - (self, *JOIN(A, at)(self, self->size - 1)); - for (size_t i = self->size - 1; i > index; i--) + JOIN(A, push_back)(self, *JOIN(A, at)(self, self->size - 1)); + for(size_t i = self->size - 1; i > index; i--) *JOIN(A, at)(self, i) = *JOIN(A, at)(self, i - 1); } *JOIN(A, at)(self, index) = value; self->free = saved; } else - JOIN(A, push_back) - (self, value); + JOIN(A, push_back)(self, value); } static inline void - JOIN(A, resize)(A *self, size_t size, T value) +JOIN(A, resize)(A* self, size_t size, T value) { - if (size != self->size) + if(size != self->size) { - while (size != self->size) - if (size < self->size) - JOIN(A, pop_back) - (self); + while(size != self->size) + if(size < self->size) + JOIN(A, pop_back)(self); else - JOIN(A, push_back) - (self, self->copy(&value)); + JOIN(A, push_back)(self, self->copy(&value)); } - if (self->free) + if(self->free) self->free(&value); } static inline void - JOIN(A, assign)(A *self, size_t size, T value) -{ - JOIN(A, resize) - (self, size, self->copy(&value)); - for (size_t i = 0; i < size; i++) - JOIN(A, set) - (self, i, self->copy(&value)); - if (self->free) +JOIN(A, assign)(A* self, size_t size, T value) +{ + JOIN(A, resize)(self, size, self->copy(&value)); + for(size_t i = 0; i < size; i++) + JOIN(A, set)(self, i, self->copy(&value)); + if(self->free) self->free(&value); } static inline void - JOIN(A, clear)(A *self) +JOIN(A, clear)(A* self) { - while (!JOIN(A, empty)(self)) - JOIN(A, pop_back) - (self); + while(!JOIN(A, empty)(self)) + JOIN(A, pop_back)(self); } static inline void - JOIN(A, free)(A *self) +JOIN(A, free)(A* self) { - JOIN(A, clear) - (self); + JOIN(A, clear)(self); free(self->pages); *self = JOIN(A, init)(); } static inline A - JOIN(A, copy)(A *self) +JOIN(A, copy)(A* self) { A other = JOIN(A, init)(); - while (other.size < self->size) + while(other.size < self->size) { - T *value = JOIN(A, at)(self, other.size); - JOIN(A, push_back) - (&other, other.copy(value)); + T* value = JOIN(A, at)(self, other.size); + JOIN(A, push_back)(&other, other.copy(value)); } return other; } static inline void - JOIN(A, ranged_sort)(A *self, int64_t a, int64_t b, int _compare(T *, T *)) +JOIN(A, ranged_sort)(A* self, int64_t a, int64_t b, int _compare(T*, T*)) { - if (a >= b) + if(a >= b) return; int64_t mid = (a + b) / 2; SWAP(T, JOIN(A, at)(self, a), JOIN(A, at)(self, mid)); int64_t z = a; - for (int64_t i = a + 1; i <= b; i++) - if (_compare(JOIN(A, at)(self, a), JOIN(A, at)(self, i))) + for(int64_t i = a + 1; i <= b; i++) + if(_compare(JOIN(A, at)(self, a), JOIN(A, at)(self, i))) { z += 1; SWAP(T, JOIN(A, at)(self, z), JOIN(A, at)(self, i)); } SWAP(T, JOIN(A, at)(self, a), JOIN(A, at)(self, z)); - JOIN(A, ranged_sort) - (self, a, z - 1, _compare); - JOIN(A, ranged_sort) - (self, z + 1, b, _compare); + JOIN(A, ranged_sort)(self, a, z - 1, _compare); + JOIN(A, ranged_sort)(self, z + 1, b, _compare); } static inline void - JOIN(A, sort)(A *self, int _compare(T *, T *)) +JOIN(A, sort)(A* self, int _compare(T*, T*)) { - JOIN(A, ranged_sort) - (self, 0, self->size - 1, _compare); + JOIN(A, ranged_sort)(self, 0, self->size - 1, _compare); } static inline size_t - JOIN(A, remove_if)(A *self, int _match(T *)) +JOIN(A, remove_if)(A* self, int _match(T*)) { size_t erases = 0; - foreach (A, self, it) - if (_match(it.ref)) + foreach(A, self, it) + if(_match(it.ref)) { - JOIN(A, erase) - (self, it.index); + JOIN(A, erase)(self, it.index); it.index_next = it.index; it.index_last -= 1; erases += 1; @@ -472,11 +453,11 @@ static inline size_t return erases; } -static inline T * - JOIN(A, find)(A *self, T key, int _equal(T *, T *)) +static inline T* +JOIN(A, find)(A* self, T key, int _equal(T*, T*)) { - foreach (A, self, it) - if (_equal(it.ref, &key)) + foreach(A, self, it) + if(_equal(it.ref, &key)) return it.ref; return NULL; } diff --git a/ctl/lst.h b/ctl/lst.h index 17503703..24e92db3 100644 --- a/ctl/lst.h +++ b/ctl/lst.h @@ -6,7 +6,7 @@ #error "Template type T undefined for " #endif -#include "ctl.h" +#include #define A JOIN(lst, T) #define B JOIN(A, node) @@ -14,61 +14,63 @@ typedef struct B { - struct B *prev; - struct B *next; + struct B* prev; + struct B* next; T value; -} B; +} +B; typedef struct A { - void (*free)(T *); - T (*copy) - (T *); - B *head; - B *tail; + void (*free)(T*); + T (*copy)(T*); + B* head; + B* tail; size_t size; -} A; +} +A; typedef struct I { - void (*step)(struct I *); - T *ref; - B *begin; - B *node; - B *next; - B *end; + void (*step)(struct I*); + T* ref; + B* begin; + B* node; + B* next; + B* end; int done; -} I; +} +I; -static inline T * - JOIN(A, front)(A *self) +static inline T* +JOIN(A, front)(A* self) { return &self->head->value; } -static inline T * - JOIN(A, back)(A *self) +static inline T* +JOIN(A, back)(A* self) { return &self->tail->value; } -static inline B * - JOIN(A, begin)(A *self) +static inline B* +JOIN(A, begin)(A* self) { return self->head; } -static inline B * - JOIN(A, end)(A *self) +static inline B* +JOIN(A, end)(A* self) { - (void)self; + (void) self; return NULL; } static inline void - JOIN(I, step)(I *self) +JOIN(I, step)(I* self) { - if (self->next == self->end) + if(self->next == self->end) self->done = 1; else { @@ -79,12 +81,12 @@ static inline void } static inline I - JOIN(I, range)(A *container, B *begin, B *end) +JOIN(I, range)(A* container, B* begin, B* end) { - (void)container; + (void) container; static I zero; I self = zero; - if (begin) + if(begin) { self.step = JOIN(I, step); self.begin = begin; @@ -99,35 +101,35 @@ static inline I } static inline int - JOIN(A, empty)(A *self) +JOIN(A, empty)(A* self) { return self->size == 0; } static inline I - JOIN(I, each)(A *a) +JOIN(I, each)(A* a) { return JOIN(A, empty)(a) - ? JOIN(I, range)(a, NULL, NULL) - : JOIN(I, range)(a, JOIN(A, begin)(a), JOIN(A, end)(a)); + ? JOIN(I, range)(a, NULL, NULL) + : JOIN(I, range)(a, JOIN(A, begin)(a), JOIN(A, end)(a)); } static inline T - JOIN(A, implicit_copy)(T *self) +JOIN(A, implicit_copy)(T* self) { return *self; } static inline int - JOIN(A, equal)(A *self, A *other, int _equal(T *, T *)) +JOIN(A, equal)(A* self, A* other, int _equal(T*, T*)) { - if (self->size != other->size) + if(self->size != other->size) return 0; I a = JOIN(I, each)(self); I b = JOIN(I, each)(other); - while (!a.done && !b.done) + while(!a.done && !b.done) { - if (!_equal(a.ref, b.ref)) + if(!_equal(a.ref, b.ref)) return 0; a.step(&a); b.step(&b); @@ -136,7 +138,7 @@ static inline int } static inline void - JOIN(A, swap)(A *self, A *other) +JOIN(A, swap)(A* self, A* other) { A temp = *self; *self = *other; @@ -144,7 +146,7 @@ static inline void } static inline A - JOIN(A, init)(void) +JOIN(A, init)(void) { static A zero; A self = zero; @@ -158,280 +160,253 @@ static inline A return self; } -static inline B * - JOIN(B, init)(T value) +static inline B* +JOIN(B, init)(T value) { - B *self = (B *)malloc(sizeof(B)); + B* self = (B*) malloc(sizeof(B)); self->prev = self->next = NULL; self->value = value; return self; } static inline void - JOIN(A, disconnect)(A *self, B *node) -{ - if (node == self->tail) - self->tail = self->tail->prev; - if (node == self->head) - self->head = self->head->next; - if (node->prev) - node->prev->next = node->next; - if (node->next) - node->next->prev = node->prev; +JOIN(A, disconnect)(A* self, B* node) +{ + if(node == self->tail) self->tail = self->tail->prev; + if(node == self->head) self->head = self->head->next; + if(node->prev) node->prev->next = node->next; + if(node->next) node->next->prev = node->prev; node->prev = node->next = NULL; self->size -= 1; } static inline void - JOIN(A, connect)(A *self, B *position, B *node, int before) +JOIN(A, connect)(A* self, B* position, B* node, int before) { - if (JOIN(A, empty)(self)) + if(JOIN(A, empty)(self)) self->head = self->tail = node; - else if (before) + else + if(before) { node->next = position; node->prev = position->prev; - if (position->prev) + if(position->prev) position->prev->next = node; position->prev = node; - if (position == self->head) + if(position == self->head) self->head = node; } else { node->prev = position; node->next = position->next; - if (position->next) + if(position->next) position->next->prev = node; position->next = node; - if (position == self->tail) + if(position == self->tail) self->tail = node; } self->size += 1; } static inline void - JOIN(A, push_back)(A *self, T value) +JOIN(A, push_back)(A* self, T value) { - B *node = JOIN(B, init)(value); - JOIN(A, connect) - (self, self->tail, node, 0); + B* node = JOIN(B, init)(value); + JOIN(A, connect)(self, self->tail, node, 0); } static inline void - JOIN(A, push_front)(A *self, T value) +JOIN(A, push_front)(A* self, T value) { - B *node = JOIN(B, init)(value); - JOIN(A, connect) - (self, self->head, node, 1); + B* node = JOIN(B, init)(value); + JOIN(A, connect)(self, self->head, node, 1); } static inline void - JOIN(A, transfer)(A *self, A *other, B *position, B *node, int before) +JOIN(A, transfer)(A* self, A* other, B* position, B* node, int before) { - JOIN(A, disconnect) - (other, node); - JOIN(A, connect) - (self, position, node, before); + JOIN(A, disconnect)(other, node); + JOIN(A, connect)(self, position, node, before); } static inline void - JOIN(A, erase)(A *self, B *node) +JOIN(A, erase)(A* self, B* node) { - JOIN(A, disconnect) - (self, node); - if (self->free) + JOIN(A, disconnect)(self, node); + if(self->free) self->free(&node->value); free(node); } static inline void - JOIN(A, pop_back)(A *self) +JOIN(A, pop_back)(A* self) { - JOIN(A, erase) - (self, self->tail); + JOIN(A, erase)(self, self->tail); } static inline void - JOIN(A, pop_front)(A *self) +JOIN(A, pop_front)(A* self) { - JOIN(A, erase) - (self, self->head); + JOIN(A, erase)(self, self->head); } static inline void - JOIN(A, insert)(A *self, B *position, T value) +JOIN(A, insert)(A* self, B* position, T value) { - B *node = JOIN(B, init)(value); - JOIN(A, connect) - (self, position, node, 1); + B* node = JOIN(B, init)(value); + JOIN(A, connect)(self, position, node, 1); } static inline void - JOIN(A, clear)(A *self) +JOIN(A, clear)(A* self) { - while (!JOIN(A, empty)(self)) - JOIN(A, pop_back) - (self); + while(!JOIN(A, empty)(self)) + JOIN(A, pop_back)(self); } static inline void - JOIN(A, free)(A *self) +JOIN(A, free)(A* self) { - JOIN(A, clear) - (self); + JOIN(A, clear)(self); *self = JOIN(A, init)(); } static inline void - JOIN(A, resize)(A *self, size_t size, T value) +JOIN(A, resize)(A* self, size_t size, T value) { - if (size != self->size) - for (size_t i = 0; size != self->size; i++) + if(size != self->size) + for(size_t i = 0; size != self->size; i++) (size < self->size) ? JOIN(A, pop_back)(self) : JOIN(A, push_back)(self, self->copy(&value)); - if (self->free) + if(self->free) self->free(&value); } static inline A - JOIN(A, copy)(A *self) +JOIN(A, copy)(A* self) { A other = JOIN(A, init)(); - for (B *node = self->head; node; node = node->next) - JOIN(A, push_back) - (&other, self->copy(&node->value)); + for(B* node = self->head; node; node = node->next) + JOIN(A, push_back)(&other, self->copy(&node->value)); return other; } static inline void - JOIN(A, assign)(A *self, size_t size, T value) +JOIN(A, assign)(A* self, size_t size, T value) { - JOIN(A, resize) - (self, size, self->copy(&value)); + JOIN(A, resize)(self, size, self->copy(&value)); size_t i = 0; - foreach (A, self, it) + foreach(A, self, it) { - if (self->free) + if(self->free) self->free(it.ref); *it.ref = self->copy(&value); i += 1; } - if (self->free) + if(self->free) self->free(&value); } static inline void - JOIN(A, reverse)(A *self) +JOIN(A, reverse)(A* self) { - foreach (A, self, it) + foreach(A, self, it) { - B *next = it.node->next; - B *prev = it.node->prev; + B* next = it.node->next; + B* prev = it.node->prev; it.node->prev = next; it.node->next = prev; } - B *tail = self->tail; - B *head = self->head; + B* tail = self->tail; + B* head = self->head; self->tail = head; self->head = tail; } static inline size_t - JOIN(A, remove_if)(A *self, int _equal(T *)) +JOIN(A, remove_if)(A* self, int _equal(T*)) { size_t erases = 0; - foreach (A, self, it) - if (_equal(it.ref)) + foreach(A, self, it) + if(_equal(it.ref)) { - JOIN(A, erase) - (self, it.node); + JOIN(A, erase)(self, it.node); erases += 1; } return erases; } static inline void - JOIN(A, splice)(A *self, B *position, A *other) +JOIN(A, splice)(A* self, B* position, A* other) { - if (self->size == 0 && position == NULL) - JOIN(A, swap) - (self, other); + if(self->size == 0 && position == NULL) + JOIN(A, swap)(self, other); else - foreach (A, other, it) - JOIN(A, transfer) - (self, other, position, it.node, 1); + foreach(A, other, it) + JOIN(A, transfer)(self, other, position, it.node, 1); } static inline void - JOIN(A, merge)(A *self, A *other, int _compare(T *, T *)) +JOIN(A, merge)(A* self, A* other, int _compare(T*, T*)) { - if (JOIN(A, empty)(self)) - JOIN(A, swap) - (self, other); + if(JOIN(A, empty)(self)) + JOIN(A, swap)(self, other); else { - for (B *node = self->head; node; node = node->next) - while (!JOIN(A, empty)(other) && _compare(&node->value, &other->head->value)) - JOIN(A, transfer) - (self, other, node, other->head, 1); + for(B* node = self->head; node; node = node->next) + while(!JOIN(A, empty)(other) && _compare(&node->value, &other->head->value)) + JOIN(A, transfer)(self, other, node, other->head, 1); // Remainder. - while (!JOIN(A, empty)(other)) - JOIN(A, transfer) - (self, other, self->tail, other->head, 0); + while(!JOIN(A, empty)(other)) + JOIN(A, transfer)(self, other, self->tail, other->head, 0); } } static inline void - JOIN(A, sort)(A *self, int _compare(T *, T *)) +JOIN(A, sort)(A* self, int _compare(T*, T*)) { - if (self->size > 1) + if(self->size > 1) { A carry = JOIN(A, init)(); A temp[64]; - for (size_t i = 0; i < len(temp); i++) + for(size_t i = 0; i < len(temp); i++) temp[i] = JOIN(A, init)(); - A *fill = temp; - A *counter = NULL; + A* fill = temp; + A* counter = NULL; do { - JOIN(A, transfer) - (&carry, self, carry.head, self->head, 1); - for (counter = temp; counter != fill && !JOIN(A, empty)(counter); counter++) + JOIN(A, transfer)(&carry, self, carry.head, self->head, 1); + for(counter = temp; counter != fill && !JOIN(A, empty)(counter); counter++) { - JOIN(A, merge) - (counter, &carry, _compare); - JOIN(A, swap) - (&carry, counter); + JOIN(A, merge)(counter, &carry, _compare); + JOIN(A, swap)(&carry, counter); } - JOIN(A, swap) - (&carry, counter); - if (counter == fill) + JOIN(A, swap)(&carry, counter); + if(counter == fill) fill++; - } while (!JOIN(A, empty)(self)); - for (counter = temp + 1; counter != fill; counter++) - JOIN(A, merge) - (counter, counter - 1, _compare); - JOIN(A, swap) - (self, fill - 1); + } + while(!JOIN(A, empty)(self)); + for(counter = temp + 1; counter != fill; counter++) + JOIN(A, merge)(counter, counter - 1, _compare); + JOIN(A, swap)(self, fill - 1); } } static inline void - JOIN(A, unique)(A *self, int _equal(T *, T *)) +JOIN(A, unique)(A* self, int _equal(T*, T*)) { - foreach (A, self, it) - if (it.next && _equal(it.ref, &it.next->value)) - JOIN(A, erase) - (self, it.node); + foreach(A, self, it) + if(it.next && _equal(it.ref, &it.next->value)) + JOIN(A, erase)(self, it.node); } -static inline B * - JOIN(A, find)(A *self, T key, int _equal(T *, T *)) +static inline B* +JOIN(A, find)(A* self, T key, int _equal(T*, T*)) { - foreach (A, self, it) - if (_equal(it.ref, &key)) + foreach(A, self, it) + if(_equal(it.ref, &key)) return it.node; return NULL; } diff --git a/ctl/pqu.h b/ctl/pqu.h index 961fc816..c5f6ca12 100644 --- a/ctl/pqu.h +++ b/ctl/pqu.h @@ -6,42 +6,42 @@ #error "Template type T undefined for " #endif -#define front top -#define at __AT -#define back __BACK -#define begin __BEGIN -#define end __END -#define set __SET -#define pop_back __POP_BACK -#define wipe __WIPE -#define clear __CLEAR -#define fit __FIT -#define reserve __RESERVE -#define push_back __PUSH_BACK -#define resize __RESIZE -#define assign __ASSIGN +#define front top +#define at __AT +#define back __BACK +#define begin __BEGIN +#define end __END +#define set __SET +#define pop_back __POP_BACK +#define wipe __WIPE +#define clear __CLEAR +#define fit __FIT +#define reserve __RESERVE +#define push_back __PUSH_BACK +#define resize __RESIZE +#define assign __ASSIGN #define shrink_to_fit __SHRINK_TO_FIT -#define data __DATA -#define insert __INSERT -#define erase __ERASE -#define sort __SORT -#define step __STEP -#define range __RANGE -#define each __EACH -#define remove_if __REMOVE_IF +#define data __DATA +#define insert __INSERT +#define erase __ERASE +#define sort __SORT +#define step __STEP +#define range __RANGE +#define each __EACH +#define remove_if __REMOVE_IF #define vec pqu #define HOLD #define COMPARE #define init __INIT -#include "vec.h" +#include #undef init #undef vec #define A JOIN(pqu, T) static inline A - JOIN(A, init)(int _compare(T *, T *)) +JOIN(A, init)(int _compare(T*, T*)) { A self = JOIN(A, __INIT)(); self.compare = _compare; @@ -49,71 +49,66 @@ static inline A } static inline void - JOIN(A, up)(A *self, size_t n) +JOIN(A, up)(A* self, size_t n) { - if (n > 0) + if(n > 0) { size_t p = (n - 1) / 2; - T *x = &self->value[n]; - T *y = &self->value[p]; - if (self->compare(x, y)) + T* x = &self->value[n]; + T* y = &self->value[p]; + if(self->compare(x, y)) { SWAP(T, x, y); - JOIN(A, up) - (self, p); + JOIN(A, up)(self, p); } } } static inline void - JOIN(A, down)(A *self, size_t n) +JOIN(A, down)(A* self, size_t n) { size_t min = 2; - if (self->size < min) + if(self->size < min) return; - else if (self->size == min) + else + if(self->size == min) { - T *a = &self->value[0]; - T *b = &self->value[1]; - if (!self->compare(a, b)) + T* a = &self->value[0]; + T* b = &self->value[1]; + if(!self->compare(a, b)) SWAP(T, a, b); } else { size_t l = 2 * n + 1; size_t r = 2 * n + 2; - if (r < self->size) + if(r < self->size) { size_t index = self->compare(&self->value[r], &self->value[l]) ? r : l; - T *x = &self->value[index]; - T *y = &self->value[n]; - if (self->compare(x, y)) + T* x = &self->value[index]; + T* y = &self->value[n]; + if(self->compare(x, y)) { SWAP(T, x, y); - JOIN(A, down) - (self, index); + JOIN(A, down)(self, index); } } } } static inline void - JOIN(A, push)(A *self, T value) +JOIN(A, push)(A* self, T value) { - JOIN(A, push_back) - (self, value); - JOIN(A, up) - (self, self->size - 1); + JOIN(A, push_back)(self, value); + JOIN(A, up)(self, self->size - 1); } static inline void - JOIN(A, pop)(A *self) +JOIN(A, pop)(A* self) { SWAP(T, JOIN(A, front)(self), JOIN(A, back)(self)); - JOIN(A, pop_back) - (self); - JOIN(A, down) - (self, 0); + JOIN(A, pop_back)(self); + JOIN(A, down)(self, 0); } #undef front diff --git a/ctl/que.h b/ctl/que.h index 753a7321..c013c066 100644 --- a/ctl/que.h +++ b/ctl/que.h @@ -6,27 +6,27 @@ #error "Template type T undefined for " #endif -#define push_back push -#define pop_front pop -#define at __AT -#define begin __BEGIN -#define end __END -#define push_front __PUSH_FRONT -#define pop_back __PUSH_BACK -#define erase __ERASE -#define insert __INSERT -#define resize __RESIZE -#define assign __ASSIGN -#define clear __CLEAR +#define push_back push +#define pop_front pop +#define at __AT +#define begin __BEGIN +#define end __END +#define push_front __PUSH_FRONT +#define pop_back __PUSH_BACK +#define erase __ERASE +#define insert __INSERT +#define resize __RESIZE +#define assign __ASSIGN +#define clear __CLEAR #define ranged_sort __RANGED_SORT -#define sort __SORT -#define range __RANGE -#define each __each -#define step __STEP -#define remove_if __REMOVE_IF +#define sort __SORT +#define range __RANGE +#define each __each +#define step __STEP +#define remove_if __REMOVE_IF #define deq que -#include "deq.h" +#include #undef deq #undef push_back diff --git a/ctl/set.h b/ctl/set.h index 0d713f47..19244c9c 100644 --- a/ctl/set.h +++ b/ctl/set.h @@ -6,7 +6,7 @@ #error "Template type T undefined for " #endif -#include "ctl.h" +#include #define A JOIN(set, T) #define B JOIN(A, node) @@ -14,75 +14,77 @@ typedef struct B { - struct B *l; - struct B *r; - struct B *p; + struct B* l; + struct B* r; + struct B* p; T key; int color; // Red = 0, Black = 1 -} B; +} +B; typedef struct A { - B *root; - int (*compare)(T *, T *); - void (*free)(T *); - T (*copy) - (T *); + B* root; + int (*compare)(T*, T*); + void (*free)(T*); + T (*copy)(T*); size_t size; -} A; +} +A; typedef struct I { - void (*step)(struct I *); - B *end; - B *node; - T *ref; - B *next; + void (*step)(struct I*); + B* end; + B* node; + T* ref; + B* next; int done; -} I; +} +I; -static inline B * - JOIN(A, begin)(A *self) +static inline B* +JOIN(A, begin)(A* self) { return self->root; } -static inline B * - JOIN(A, end)(A *self) +static inline B* +JOIN(A, end)(A* self) { - (void)self; + (void) self; return NULL; } -static inline B * - JOIN(B, min)(B *self) +static inline B* +JOIN(B, min)(B* self) { - while (self->l) + while(self->l) self = self->l; return self; } -static inline B * - JOIN(B, max)(B *self) +static inline B* +JOIN(B, max)(B* self) { - while (self->r) + while(self->r) self = self->r; return self; } -static inline B * - JOIN(B, next)(B *self) +static inline B* +JOIN(B, next)(B* self) { - if (self->r) + if(self->r) { self = self->r; - while (self->l) + while(self->l) self = self->l; } else { - B *parent = self->p; - while (parent && self == parent->r) + B* parent = self->p; + while(parent && self == parent->r) { self = parent; parent = parent->p; @@ -93,9 +95,9 @@ static inline B * } static inline void - JOIN(I, step)(I *self) +JOIN(I, step)(I* self) { - if (self->next == self->end) + if(self->next == self->end) self->done = 1; else { @@ -106,12 +108,12 @@ static inline void } static inline I - JOIN(I, range)(A *container, B *begin, B *end) +JOIN(I, range)(A* container, B* begin, B* end) { - (void)container; + (void) container; static I zero; I self = zero; - if (begin) + if(begin) { self.step = JOIN(I, step); self.node = JOIN(B, min)(begin); @@ -125,35 +127,35 @@ static inline I } static inline int - JOIN(A, empty)(A *self) +JOIN(A, empty)(A* self) { return self->size == 0; } static inline I - JOIN(I, each)(A *a) +JOIN(I, each)(A* a) { return JOIN(A, empty)(a) - ? JOIN(I, range)(a, NULL, NULL) - : JOIN(I, range)(a, JOIN(A, begin)(a), JOIN(A, end)(a)); + ? JOIN(I, range)(a, NULL, NULL) + : JOIN(I, range)(a, JOIN(A, begin)(a), JOIN(A, end)(a)); } static inline T - JOIN(A, implicit_copy)(T *self) +JOIN(A, implicit_copy)(T* self) { return *self; } static inline int - JOIN(A, equal)(A *self, A *other, int _equal(T *, T *)) +JOIN(A, equal)(A* self, A* other, int _equal(T*, T*)) { - if (self->size != other->size) + if(self->size != other->size) return 0; I a = JOIN(I, each)(self); I b = JOIN(I, each)(other); - while (!a.done && !b.done) + while(!a.done && !b.done) { - if (!_equal(a.ref, b.ref)) + if(!_equal(a.ref, b.ref)) return 0; a.step(&a); b.step(&b); @@ -162,7 +164,7 @@ static inline int } static inline void - JOIN(A, swap)(A *self, A *other) +JOIN(A, swap)(A* self, A* other) { A temp = *self; *self = *other; @@ -170,7 +172,7 @@ static inline void } static inline A - JOIN(A, init)(int _compare(T *, T *)) +JOIN(A, init)(int _compare(T*, T*)) { static A zero; A self = zero; @@ -186,71 +188,71 @@ static inline A } static inline void - JOIN(A, free_node)(A *self, B *node) +JOIN(A, free_node)(A* self, B* node) { - if (self->free) + if(self->free) self->free(&node->key); free(node); } static inline int - JOIN(B, color)(B *self) +JOIN(B, color)(B* self) { return self ? self->color : 1; } static inline int - JOIN(B, is_blk)(B *self) +JOIN(B, is_blk)(B* self) { return JOIN(B, color)(self) == 1; } static inline int - JOIN(B, is_red)(B *self) +JOIN(B, is_red)(B* self) { return JOIN(B, color)(self) == 0; } -static inline B * - JOIN(B, grandfather)(B *self) +static inline B* +JOIN(B, grandfather)(B* self) { return self->p->p; } -static inline B * - JOIN(B, sibling)(B *self) +static inline B* +JOIN(B, sibling)(B* self) { - if (self == self->p->l) + if(self == self->p->l) return self->p->r; else return self->p->l; } -static inline B * - JOIN(B, uncle)(B *self) +static inline B* +JOIN(B, uncle)(B* self) { return JOIN(B, sibling)(self->p); } -static inline B * - JOIN(B, init)(T key, int color) +static inline B* +JOIN(B, init)(T key, int color) { - B *self = (B *)malloc(sizeof(B)); + B* self = (B*) malloc(sizeof(B)); self->key = key; self->color = color; self->l = self->r = self->p = NULL; return self; } -static inline B * - JOIN(A, lower_bound)(A *self, T key) +static inline B* +JOIN(A, lower_bound)(A* self, T key) { - B *node = self->root; - B *result = NULL; - while (node) + B* node = self->root; + B* result = NULL; + while(node) { int diff = self->compare(&key, &node->key); - if (diff <= 0) + if(diff <= 0) { result = node; node = node->l; @@ -261,15 +263,15 @@ static inline B * return result; } -static inline B * - JOIN(A, upper_bound)(A *self, T key) +static inline B* +JOIN(A, upper_bound)(A* self, T key) { - B *node = self->root; - B *result = NULL; - while (node) + B* node = self->root; + B* result = NULL; + while(node) { int diff = self->compare(&key, &node->key); - if (diff < 0) + if(diff < 0) { result = node; node = node->l; @@ -280,16 +282,17 @@ static inline B * return result; } -static inline B * - JOIN(A, find)(A *self, T key) +static inline B* +JOIN(A, find)(A* self, T key) { - B *node = self->root; - while (node) + B* node = self->root; + while(node) { int diff = self->compare(&key, &node->key); - if (diff == 0) + if(diff == 0) return node; - else if (diff < 0) + else + if(diff < 0) node = node->l; else node = node->r; @@ -298,165 +301,152 @@ static inline B * } static inline int - JOIN(A, count)(A *self, T key) +JOIN(A, count)(A* self, T key) { return JOIN(A, find)(self, key) ? 1 : 0; } static inline void - JOIN(B, replace)(A *self, B *a, B *b) +JOIN(B, replace)(A* self, B* a, B* b) { - if (a->p) + if(a->p) { - if (a == a->p->l) + if(a == a->p->l) a->p->l = b; else a->p->r = b; } else self->root = b; - if (b) + if(b) b->p = a->p; } #ifdef USE_INTERNAL_VERIFY -#include + #include -static inline void - JOIN(B, verify_property_1)(B *self) -{ - assert(JOIN(B, is_red)(self) || JOIN(B, is_blk)(self)); - if (self) + static inline void + JOIN(B, verify_property_1)(B* self) { - JOIN(B, verify_property_1) - (self->l); - JOIN(B, verify_property_1) - (self->r); + assert(JOIN(B, is_red)(self) || JOIN(B, is_blk)(self)); + if(self) + { + JOIN(B, verify_property_1)(self->l); + JOIN(B, verify_property_1)(self->r); + } } -} -static inline void - JOIN(B, verify_property_2)(B *self) -{ - assert(JOIN(B, is_blk)(self)); -} - -static inline void - JOIN(B, verify_property_4)(B *self) -{ - if (JOIN(B, is_red)(self)) + static inline void + JOIN(B, verify_property_2)(B* self) { - assert(JOIN(B, is_blk)(self->l)); - assert(JOIN(B, is_blk)(self->r)); - assert(JOIN(B, is_blk)(self->p)); + assert(JOIN(B, is_blk)(self)); } - if (self) - { - JOIN(B, verify_property_4) - (self->l); - JOIN(B, verify_property_4) - (self->r); - } -} -static inline void - JOIN(B, count_blk)(B *self, int nodes, int *in_path) -{ - if (JOIN(B, is_blk)(self)) - nodes += 1; - if (self) + static inline void + JOIN(B, verify_property_4)(B* self) { - JOIN(B, count_blk) - (self->l, nodes, in_path); - JOIN(B, count_blk) - (self->r, nodes, in_path); + if(JOIN(B, is_red)(self)) + { + assert(JOIN(B, is_blk)(self->l)); + assert(JOIN(B, is_blk)(self->r)); + assert(JOIN(B, is_blk)(self->p)); + } + if(self) + { + JOIN(B, verify_property_4)(self->l); + JOIN(B, verify_property_4)(self->r); + } } - else + + static inline void + JOIN(B, count_blk)(B* self, int nodes, int* in_path) { - if (*in_path == -1) - *in_path = nodes; + if(JOIN(B, is_blk)(self)) + nodes += 1; + if(self) + { + JOIN(B, count_blk)(self->l, nodes, in_path); + JOIN(B, count_blk)(self->r, nodes, in_path); + } else - assert(nodes == *in_path); + { + if(*in_path == -1) + *in_path = nodes; + else + assert(nodes == *in_path); + } } -} -static inline void - JOIN(B, verify_property_5)(B *self) -{ - int in_path = -1; - JOIN(B, count_blk) - (self, 0, &in_path); -} + static inline void + JOIN(B, verify_property_5)(B* self) + { + int in_path = -1; + JOIN(B, count_blk)(self, 0, &in_path); + } -static inline void - JOIN(A, verify)(A *self) -{ - JOIN(B, verify_property_1) - (self->root); // Property 1: Each node is either red or black. - JOIN(B, verify_property_2) - (self->root); // Property 2: The root node is black. - /* Implicit */ // Property 3: Leaves are colored black - JOIN(B, verify_property_4) - (self->root); // Property 4: Every red node has two black ndoes. - JOIN(B, verify_property_5) - (self->root); // Property 5: All paths from a node have the same number of black nodes. -} + static inline void + JOIN(A, verify)(A* self) + { + JOIN(B, verify_property_1)(self->root); // Property 1: Each node is either red or black. + JOIN(B, verify_property_2)(self->root); // Property 2: The root node is black. + /* Implicit */ // Property 3: Leaves are colored black + JOIN(B, verify_property_4)(self->root); // Property 4: Every red node has two black ndoes. + JOIN(B, verify_property_5)(self->root); // Property 5: All paths from a node have the same number of black nodes. + } #endif static inline void - JOIN(A, rotate_l)(A *self, B *node) +JOIN(A, rotate_l)(A* self, B* node) { - B *r = node->r; - JOIN(B, replace) - (self, node, r); + B* r = node->r; + JOIN(B, replace)(self, node, r); node->r = r->l; - if (r->l) + if(r->l) r->l->p = node; r->l = node; node->p = r; } static inline void - JOIN(A, rotate_r)(A *self, B *node) +JOIN(A, rotate_r)(A* self, B* node) { - B *l = node->l; - JOIN(B, replace) - (self, node, l); + B* l = node->l; + JOIN(B, replace)(self, node, l); node->l = l->r; - if (l->r) + if(l->r) l->r->p = node; l->r = node; node->p = l; } static inline void - JOIN(A, insert_1)(A *, B *), - JOIN(A, insert_2)(A *, B *), - JOIN(A, insert_3)(A *, B *), - JOIN(A, insert_4)(A *, B *), - JOIN(A, insert_5)(A *, B *); +JOIN(A, insert_1)(A*, B*), +JOIN(A, insert_2)(A*, B*), +JOIN(A, insert_3)(A*, B*), +JOIN(A, insert_4)(A*, B*), +JOIN(A, insert_5)(A*, B*); -static inline B * - JOIN(A, insert)(A *self, T key) +static inline B* +JOIN(A, insert)(A* self, T key) { - B *insert = JOIN(B, init)(key, 0); - if (self->root) + B* insert = JOIN(B, init)(key, 0); + if(self->root) { - B *node = self->root; - while (1) + B* node = self->root; + while(1) { int diff = self->compare(&key, &node->key); - if (diff == 0) + if(diff == 0) { - JOIN(A, free_node) - (self, insert); + JOIN(A, free_node)(self, insert); return node; } - else if (diff < 0) + else + if(diff < 0) { - if (node->l) + if(node->l) node = node->l; else { @@ -466,7 +456,7 @@ static inline B * } else { - if (node->r) + if(node->r) node = node->r; else { @@ -479,324 +469,285 @@ static inline B * } else self->root = insert; - JOIN(A, insert_1) - (self, insert); + JOIN(A, insert_1)(self, insert); self->size += 1; #ifdef USE_INTERNAL_VERIFY - JOIN(A, verify) - (self); + JOIN(A, verify)(self); #endif return insert; } static inline void - JOIN(A, insert_1)(A *self, B *node) +JOIN(A, insert_1)(A* self, B* node) { - if (node->p) - JOIN(A, insert_2) - (self, node); + if(node->p) + JOIN(A, insert_2)(self, node); else node->color = 1; } static inline void - JOIN(A, insert_2)(A *self, B *node) +JOIN(A, insert_2)(A* self, B* node) { - if (JOIN(B, is_blk)(node->p)) + if(JOIN(B, is_blk)(node->p)) return; else - JOIN(A, insert_3) - (self, node); + JOIN(A, insert_3)(self, node); } static inline void - JOIN(A, insert_3)(A *self, B *node) +JOIN(A, insert_3)(A* self, B* node) { - if (JOIN(B, is_red)(JOIN(B, uncle)(node))) + if(JOIN(B, is_red)(JOIN(B, uncle)(node))) { node->p->color = 1; - JOIN(B, uncle) - (node)->color = 1; - JOIN(B, grandfather) - (node)->color = 0; - JOIN(A, insert_1) - (self, JOIN(B, grandfather)(node)); + JOIN(B, uncle)(node)->color = 1; + JOIN(B, grandfather)(node)->color = 0; + JOIN(A, insert_1)(self, JOIN(B, grandfather)(node)); } else - JOIN(A, insert_4) - (self, node); + JOIN(A, insert_4)(self, node); } static inline void - JOIN(A, insert_4)(A *self, B *node) +JOIN(A, insert_4)(A* self, B* node) { - if (node == node->p->r && node->p == JOIN(B, grandfather)(node)->l) + if(node == node->p->r && node->p == JOIN(B, grandfather)(node)->l) { - JOIN(A, rotate_l) - (self, node->p); + JOIN(A, rotate_l)(self, node->p); node = node->l; } - else if (node == node->p->l && node->p == JOIN(B, grandfather)(node)->r) + else + if(node == node->p->l && node->p == JOIN(B, grandfather)(node)->r) { - JOIN(A, rotate_r) - (self, node->p); + JOIN(A, rotate_r)(self, node->p); node = node->r; } - JOIN(A, insert_5) - (self, node); + JOIN(A, insert_5)(self, node); } static inline void - JOIN(A, insert_5)(A *self, B *node) +JOIN(A, insert_5)(A* self, B* node) { node->p->color = 1; - JOIN(B, grandfather) - (node)->color = 0; - if (node == node->p->l && node->p == JOIN(B, grandfather)(node)->l) - JOIN(A, rotate_r) - (self, JOIN(B, grandfather)(node)); + JOIN(B, grandfather)(node)->color = 0; + if(node == node->p->l && node->p == JOIN(B, grandfather)(node)->l) + JOIN(A, rotate_r)(self, JOIN(B, grandfather)(node)); else - JOIN(A, rotate_l) - (self, JOIN(B, grandfather)(node)); + JOIN(A, rotate_l)(self, JOIN(B, grandfather)(node)); } static inline void - JOIN(A, erase_1)(A *, B *), - JOIN(A, erase_2)(A *, B *), - JOIN(A, erase_3)(A *, B *), - JOIN(A, erase_4)(A *, B *), - JOIN(A, erase_5)(A *, B *), - JOIN(A, erase_6)(A *, B *); +JOIN(A, erase_1)(A*, B*), +JOIN(A, erase_2)(A*, B*), +JOIN(A, erase_3)(A*, B*), +JOIN(A, erase_4)(A*, B*), +JOIN(A, erase_5)(A*, B*), +JOIN(A, erase_6)(A*, B*); static inline void - JOIN(A, erase_node)(A *self, B *node) +JOIN(A, erase_node)(A* self, B* node) { - if (node->l && node->r) + if(node->l && node->r) { - B *pred = JOIN(B, max)(node->l); + B* pred = JOIN(B, max)(node->l); SWAP(T, &node->key, &pred->key); node = pred; } - B *child = node->r ? node->r : node->l; - if (JOIN(B, is_blk)(node)) + B* child = node->r ? node->r : node->l; + if(JOIN(B, is_blk)(node)) { node->color = JOIN(B, color)(child); - JOIN(A, erase_1) - (self, node); + JOIN(A, erase_1)(self, node); } - JOIN(B, replace) - (self, node, child); - if (node->p == NULL && child) + JOIN(B, replace)(self, node, child); + if(node->p == NULL && child) child->color = 1; - JOIN(A, free_node) - (self, node); + JOIN(A, free_node)(self, node); self->size -= 1; #ifdef USE_INTERNAL_VERIFY - JOIN(A, verify) - (self); + JOIN(A, verify)(self); #endif } static inline void - JOIN(A, erase)(A *self, T key) +JOIN(A, erase)(A* self, T key) { - B *node = JOIN(A, find)(self, key); - if (node) - JOIN(A, erase_node) - (self, node); + B* node = JOIN(A, find)(self, key); + if(node) + JOIN(A, erase_node)(self, node); } static inline void - JOIN(A, erase_1)(A *self, B *node) +JOIN(A, erase_1)(A* self, B* node) { - if (node->p) - JOIN(A, erase_2) - (self, node); + if(node->p) + JOIN(A, erase_2)(self, node); } static inline void - JOIN(A, erase_2)(A *self, B *node) +JOIN(A, erase_2)(A* self, B* node) { - if (JOIN(B, is_red)(JOIN(B, sibling)(node))) + if(JOIN(B, is_red)(JOIN(B, sibling)(node))) { node->p->color = 0; - JOIN(B, sibling) - (node)->color = 1; - if (node == node->p->l) - JOIN(A, rotate_l) - (self, node->p); + JOIN(B, sibling)(node)->color = 1; + if(node == node->p->l) + JOIN(A, rotate_l)(self, node->p); else - JOIN(A, rotate_r) - (self, node->p); + JOIN(A, rotate_r)(self, node->p); } - JOIN(A, erase_3) - (self, node); + JOIN(A, erase_3)(self, node); } static inline void - JOIN(A, erase_3)(A *self, B *node) +JOIN(A, erase_3)(A* self, B* node) { - if (JOIN(B, is_blk)(node->p) && JOIN(B, is_blk)(JOIN(B, sibling)(node)) && JOIN(B, is_blk)(JOIN(B, sibling)(node)->l) && JOIN(B, is_blk)(JOIN(B, sibling)(node)->r)) + if(JOIN(B, is_blk)(node->p) + && JOIN(B, is_blk)(JOIN(B, sibling)(node)) + && JOIN(B, is_blk)(JOIN(B, sibling)(node)->l) + && JOIN(B, is_blk)(JOIN(B, sibling)(node)->r)) { - JOIN(B, sibling) - (node)->color = 0; - JOIN(A, erase_1) - (self, node->p); + JOIN(B, sibling)(node)->color = 0; + JOIN(A, erase_1)(self, node->p); } else - JOIN(A, erase_4) - (self, node); + JOIN(A, erase_4)(self, node); } static inline void - JOIN(A, erase_4)(A *self, B *node) +JOIN(A, erase_4)(A* self, B* node) { - if (JOIN(B, is_red)(node->p) && JOIN(B, is_blk)(JOIN(B, sibling)(node)) && JOIN(B, is_blk)(JOIN(B, sibling)(node)->l) && JOIN(B, is_blk)(JOIN(B, sibling)(node)->r)) + if(JOIN(B, is_red)(node->p) + && JOIN(B, is_blk)(JOIN(B, sibling)(node)) + && JOIN(B, is_blk)(JOIN(B, sibling)(node)->l) + && JOIN(B, is_blk)(JOIN(B, sibling)(node)->r)) { - JOIN(B, sibling) - (node)->color = 0; + JOIN(B, sibling)(node)->color = 0; node->p->color = 1; } else - JOIN(A, erase_5) - (self, node); + JOIN(A, erase_5)(self, node); } static inline void - JOIN(A, erase_5)(A *self, B *node) +JOIN(A, erase_5)(A* self, B* node) { - if (node == node->p->l && JOIN(B, is_blk)(JOIN(B, sibling)(node)) && JOIN(B, is_red)(JOIN(B, sibling)(node)->l) && JOIN(B, is_blk)(JOIN(B, sibling)(node)->r)) + if(node == node->p->l + && JOIN(B, is_blk)(JOIN(B, sibling)(node)) + && JOIN(B, is_red)(JOIN(B, sibling)(node)->l) + && JOIN(B, is_blk)(JOIN(B, sibling)(node)->r)) { - JOIN(B, sibling) - (node)->color = 0; - JOIN(B, sibling) - (node)->l->color = 1; - JOIN(A, rotate_r) - (self, JOIN(B, sibling)(node)); + JOIN(B, sibling)(node)->color = 0; + JOIN(B, sibling)(node)->l->color = 1; + JOIN(A, rotate_r)(self, JOIN(B, sibling)(node)); } - else if (node == node->p->r && JOIN(B, is_blk)(JOIN(B, sibling)(node)) && JOIN(B, is_red)(JOIN(B, sibling)(node)->r) && JOIN(B, is_blk)(JOIN(B, sibling)(node)->l)) + else + if(node == node->p->r + && JOIN(B, is_blk)(JOIN(B, sibling)(node)) + && JOIN(B, is_red)(JOIN(B, sibling)(node)->r) + && JOIN(B, is_blk)(JOIN(B, sibling)(node)->l)) { - JOIN(B, sibling) - (node)->color = 0; - JOIN(B, sibling) - (node)->r->color = 1; - JOIN(A, rotate_l) - (self, JOIN(B, sibling)(node)); + JOIN(B, sibling)(node)->color = 0; + JOIN(B, sibling)(node)->r->color = 1; + JOIN(A, rotate_l)(self, JOIN(B, sibling)(node)); } - JOIN(A, erase_6) - (self, node); + JOIN(A, erase_6)(self, node); } static inline void - JOIN(A, erase_6)(A *self, B *node) +JOIN(A, erase_6)(A* self, B* node) { - JOIN(B, sibling) - (node)->color = JOIN(B, color)(node->p); + JOIN(B, sibling)(node)->color = JOIN(B, color)(node->p); node->p->color = 1; - if (node == node->p->l) + if(node == node->p->l) { - JOIN(B, sibling) - (node)->r->color = 1; - JOIN(A, rotate_l) - (self, node->p); + JOIN(B, sibling)(node)->r->color = 1; + JOIN(A, rotate_l)(self, node->p); } else { - JOIN(B, sibling) - (node)->l->color = 1; - JOIN(A, rotate_r) - (self, node->p); + JOIN(B, sibling)(node)->l->color = 1; + JOIN(A, rotate_r)(self, node->p); } } static inline void - JOIN(A, clear)(A *self) +JOIN(A, clear)(A* self) { - while (!JOIN(A, empty)(self)) - JOIN(A, erase) - (self, self->root->key); + while(!JOIN(A, empty)(self)) + JOIN(A, erase)(self, self->root->key); } static inline void - JOIN(A, free)(A *self) +JOIN(A, free)(A* self) { - JOIN(A, clear) - (self); + JOIN(A, clear)(self); *self = JOIN(A, init)(self->compare); } static inline A - JOIN(A, copy)(A *self) +JOIN(A, copy)(A* self) { I it = JOIN(I, each)(self); - A copy = JOIN(A, init)(self->compare); - while (!it.done) + A copy = JOIN(A, init)(self->compare); + while(!it.done) { - JOIN(A, insert) - (©, self->copy(&it.node->key)); + JOIN(A, insert)(©, self->copy(&it.node->key)); it.step(&it); } return copy; } static inline size_t - JOIN(A, remove_if)(A *self, int _match(T *)) +JOIN(A, remove_if)(A* self, int _match(T*)) { size_t erases = 0; - foreach (A, self, it) - if (_match(&it.node->key)) + foreach(A, self, it) + if(_match(&it.node->key)) { - JOIN(A, erase_node) - (self, it.node); + JOIN(A, erase_node)(self, it.node); erases += 1; } return erases; } static inline A - JOIN(A, intersection)(A *a, A *b) +JOIN(A, intersection)(A* a, A* b) { A self = JOIN(A, init)(a->compare); - foreach (A, a, i) - if (JOIN(A, find)(b, *i.ref)) - JOIN(A, insert) - (&self, self.copy(i.ref)); + foreach(A, a, i) + if(JOIN(A, find)(b, *i.ref)) + JOIN(A, insert)(&self, self.copy(i.ref)); return self; } static inline A - JOIN(A, union)(A *a, A *b) +JOIN(A, union)(A* a, A* b) { A self = JOIN(A, init)(a->compare); - foreach (A, a, i) - JOIN(A, insert) - (&self, self.copy(i.ref)); - foreach (A, b, i) - JOIN(A, insert) - (&self, self.copy(i.ref)); + foreach(A, a, i) JOIN(A, insert)(&self, self.copy(i.ref)); + foreach(A, b, i) JOIN(A, insert)(&self, self.copy(i.ref)); return self; } static inline A - JOIN(A, difference)(A *a, A *b) +JOIN(A, difference)(A* a, A* b) { A self = JOIN(A, copy)(a); - foreach (A, b, i) - JOIN(A, erase) - (&self, *i.ref); + foreach(A, b, i) + JOIN(A, erase)(&self, *i.ref); return self; } static inline A - JOIN(A, symmetric_difference)(A *a, A *b) +JOIN(A, symmetric_difference)(A* a, A* b) { A self = JOIN(A, union)(a, b); A intersection = JOIN(A, intersection)(a, b); - foreach (A, &intersection, i) - JOIN(A, erase) - (&self, *i.ref); - JOIN(A, free) - (&intersection); + foreach(A, &intersection, i) + JOIN(A, erase)(&self, *i.ref); + JOIN(A, free)(&intersection); return self; } diff --git a/ctl/stk.h b/ctl/stk.h index f3f204ae..aaf285fb 100644 --- a/ctl/stk.h +++ b/ctl/stk.h @@ -6,29 +6,29 @@ #error "Template type T undefined for " #endif -#define push_back push -#define pop_back pop -#define back top -#define at __AT -#define front __FRONT -#define begin __BEGIN -#define end __END -#define push_front __PUSH_FRONT -#define pop_front __POP_FRONT -#define erase __ERASE -#define insert __INSERT -#define resize __RESIZE -#define assign __ASSIGN -#define clear __CLEAR +#define push_back push +#define pop_back pop +#define back top +#define at __AT +#define front __FRONT +#define begin __BEGIN +#define end __END +#define push_front __PUSH_FRONT +#define pop_front __POP_FRONT +#define erase __ERASE +#define insert __INSERT +#define resize __RESIZE +#define assign __ASSIGN +#define clear __CLEAR #define ranged_sort __RANGED_SORT -#define sort __SORT -#define range __RANGE -#define each __EACH -#define step __STEP -#define remove_if __REMOVE_IF +#define sort __SORT +#define range __RANGE +#define each __EACH +#define step __STEP +#define remove_if __REMOVE_IF #define deq stk -#include "deq.h" +#include #undef deq #undef push_back diff --git a/ctl/str.h b/ctl/str.h index fb914321..acc9840e 100644 --- a/ctl/str.h +++ b/ctl/str.h @@ -15,7 +15,7 @@ #define str_init str___INIT #define str_equal str___EQUAL #define str_find str___FIND -#include "vec.h" +#include #undef str_init #undef str_equal #undef str_find @@ -25,35 +25,35 @@ #include static inline str -str_init(const char *c_str) +str_init(const char* c_str) { str self = str___INIT(); size_t len = strlen(c_str); size_t min = 15; str_reserve(&self, len < min ? min : len); - for (const char *s = c_str; *s; s++) + for(const char* s = c_str; *s; s++) str_push_back(&self, *s); return self; } static inline void -str_append(str *self, const char *s) +str_append(str* self, const char* s) { size_t start = self->size; size_t len = strlen(s); str_resize(self, self->size + len, '\0'); - for (size_t i = 0; i < len; i++) + for(size_t i = 0; i < len; i++) self->value[start + i] = s[i]; } static inline void -str_insert_str(str *self, size_t index, const char *s) +str_insert_str(str* self, size_t index, const char* s) { size_t start = self->size; size_t len = strlen(s); str_resize(self, self->size + len, '\0'); self->size = start; - while (len != 0) + while(len != 0) { len -= 1; str_insert(self, index, s[len]); @@ -61,123 +61,123 @@ str_insert_str(str *self, size_t index, const char *s) } static inline void -str_replace(str *self, size_t index, size_t size, const char *s) +str_replace(str* self, size_t index, size_t size, const char* s) { size_t end = index + size; - if (end >= self->size) + if(end >= self->size) end = self->size; - for (size_t i = index; i < end; i++) + for(size_t i = index; i < end; i++) str_erase(self, index); str_insert_str(self, index, s); } -static inline char * -str_c_str(str *self) +static inline char* +str_c_str(str* self) { return str_data(self); } static inline size_t -str_find(str *self, const char *s) +str_find(str* self, const char* s) { - char *c_str = self->value; - char *found = strstr(c_str, s); - if (found) + char* c_str = self->value; + char* found = strstr(c_str, s); + if(found) return found - c_str; return SIZE_MAX; } static inline int -str_count(str *self, char c) +str_count(str* self, char c) { size_t count = 0; - for (size_t i = 0; i < self->size; i++) - if (self->value[i] == c) + for(size_t i = 0; i < self->size; i++) + if(self->value[i] == c) count += 1; return count; } static inline size_t -str_rfind(str *self, const char *s) +str_rfind(str* self, const char* s) { - char *c_str = self->value; - for (size_t i = self->size; i != SIZE_MAX; i--) + char* c_str = self->value; + for(size_t i = self->size; i != SIZE_MAX; i--) { - char *found = strstr(&c_str[i], s); - if (found) + char* found = strstr(&c_str[i], s); + if(found) return found - c_str; } return SIZE_MAX; } static inline size_t -str_find_first_of(str *self, const char *s) +str_find_first_of(str* self, const char* s) { - for (size_t i = 0; i < self->size; i++) - for (const char *p = s; *p; p++) - if (self->value[i] == *p) - return i; + for(size_t i = 0; i < self->size; i++) + for(const char* p = s; *p; p++) + if(self->value[i] == *p) + return i; return SIZE_MAX; } static inline size_t -str_find_last_of(str *self, const char *s) +str_find_last_of(str* self, const char* s) { - for (size_t i = self->size; i != SIZE_MAX; i--) - for (const char *p = s; *p; p++) - if (self->value[i] == *p) - return i; + for(size_t i = self->size; i != SIZE_MAX; i--) + for(const char* p = s; *p; p++) + if(self->value[i] == *p) + return i; return SIZE_MAX; } static inline size_t -str_find_first_not_of(str *self, const char *s) +str_find_first_not_of(str* self, const char* s) { - for (size_t i = 0; i < self->size; i++) + for(size_t i = 0; i < self->size; i++) { size_t count = 0; - for (const char *p = s; *p; p++) - if (self->value[i] == *p) + for(const char* p = s; *p; p++) + if(self->value[i] == *p) count += 1; - if (count == 0) + if(count == 0) return i; } return SIZE_MAX; } static inline size_t -str_find_last_not_of(str *self, const char *s) +str_find_last_not_of(str* self, const char* s) { - for (size_t i = self->size - 1; i != SIZE_MAX; i--) + for(size_t i = self->size - 1; i != SIZE_MAX; i--) { size_t count = 0; - for (const char *p = s; *p; p++) - if (self->value[i] == *p) + for(const char* p = s; *p; p++) + if(self->value[i] == *p) count += 1; - if (count == 0) + if(count == 0) return i; } return SIZE_MAX; } static inline str -str_substr(str *self, size_t index, size_t size) +str_substr(str* self, size_t index, size_t size) { str substr = str_init(""); str_resize(&substr, size, '\0'); - for (size_t i = 0; i < size; i++) + for(size_t i = 0; i < size; i++) substr.value[i] = self->value[index + i]; return substr; } static inline int -str_compare(str *self, const char *s) +str_compare(str* self, const char* s) { return strcmp(self->value, s); } static inline int -str_key_compare(str *self, str *s) +str_key_compare(str* self, str* s) { return strcmp(self->value, s->value); } diff --git a/ctl/ust.h b/ctl/ust.h index 33878945..b59989c5 100644 --- a/ctl/ust.h +++ b/ctl/ust.h @@ -6,7 +6,7 @@ #error "Template type T undefined for " #endif -#include "ctl.h" +#include #define A JOIN(ust, T) #define B JOIN(A, node) @@ -15,60 +15,62 @@ typedef struct B { T key; - struct B *next; -} B; + struct B* next; +} +B; typedef struct A { - void (*free)(T *); - T (*copy) - (T *); - size_t (*hash)(T *); - int (*equal)(T *, T *); - B **bucket; + void (*free)(T*); + T (*copy)(T*); + size_t (*hash)(T*); + int (*equal)(T*, T*); + B** bucket; size_t size; size_t bucket_count; -} A; +} +A; typedef struct I { - void (*step)(struct I *); - B *end; - B *node; - T *ref; - B *next; - A *container; + void (*step)(struct I*); + B* end; + B* node; + T* ref; + B* next; + A* container; size_t index; int done; -} I; +} +I; -static inline B * - JOIN(A, begin)(A *self) +static inline B* +JOIN(A, begin)(A* self) { - for (size_t i = 0; i < self->bucket_count; i++) + for(size_t i = 0; i < self->bucket_count; i++) { - B *node = self->bucket[i]; - if (node) + B* node = self->bucket[i]; + if(node) return node; } return NULL; } -static inline B * - JOIN(A, end)(A *self) +static inline B* +JOIN(A, end)(A* self) { - (void)self; + (void) self; return NULL; } static inline size_t - JOIN(I, index)(A *self, T value) +JOIN(I, index)(A* self, T value) { return self->hash(&value) % self->bucket_count; } static inline void - JOIN(I, update)(I *self) +JOIN(I, update)(I* self) { self->node = self->next; self->ref = &self->node->key; @@ -76,16 +78,15 @@ static inline void } static inline int - JOIN(I, scan)(I *self) +JOIN(I, scan)(I* self) { - for (size_t i = self->index + 1; i < self->container->bucket_count; i++) + for(size_t i = self->index + 1; i < self->container->bucket_count; i++) { self->next = self->container->bucket[i]; - if (self->next) + if(self->next) { self->index = i; - JOIN(I, update) - (self); + JOIN(I, update)(self); return 1; } } @@ -93,24 +94,23 @@ static inline int } static inline void - JOIN(I, step)(I *self) +JOIN(I, step)(I* self) { - if (self->next == JOIN(A, end)(self->container)) + if(self->next == JOIN(A, end)(self->container)) { - if (!JOIN(I, scan)(self)) + if(!JOIN(I, scan)(self)) self->done = 1; } else - JOIN(I, update) - (self); + JOIN(I, update)(self); } static inline I - JOIN(I, range)(A *container, B *begin, B *end) +JOIN(I, range)(A* container, B* begin, B* end) { static I zero; I self = zero; - if (begin) + if(begin) { self.step = JOIN(I, step); self.node = begin; @@ -125,62 +125,58 @@ static inline I return self; } -static inline B ** - JOIN(A, bucket)(A *self, T value) +static inline B** +JOIN(A, bucket)(A* self, T value) { size_t index = JOIN(I, index)(self, value); return &self->bucket[index]; } static inline int - JOIN(A, empty)(A *self) +JOIN(A, empty)(A* self) { return self->size == 0; } static inline I - JOIN(I, each)(A *a) +JOIN(I, each)(A* a) { return JOIN(A, empty)(a) - ? JOIN(I, range)(a, NULL, NULL) - : JOIN(I, range)(a, JOIN(A, begin)(a), JOIN(A, end)(a)); + ? JOIN(I, range)(a, NULL, NULL) + : JOIN(I, range)(a, JOIN(A, begin)(a), JOIN(A, end)(a)); } static inline T - JOIN(A, implicit_copy)(T *self) +JOIN(A, implicit_copy)(T* self) { return *self; } -static inline B * - JOIN(A, find)(A *self, T value) +static inline B* +JOIN(A, find)(A* self, T value) { - if (!JOIN(A, empty)(self)) + if(!JOIN(A, empty)(self)) { - B **bucket = JOIN(A, bucket)(self, value); - for (B *n = *bucket; n; n = n->next) - if (self->equal(&value, &n->key)) + B** bucket = JOIN(A, bucket)(self, value); + for(B* n = *bucket; n; n = n->next) + if(self->equal(&value, &n->key)) return n; } return NULL; } static inline int - JOIN(A, equal)(A *a, A *b) +JOIN(A, equal)(A* a, A* b) { size_t count_a = 0; size_t count_b = 0; - foreach (A, a, it) - if (JOIN(A, find)(b, *it.ref)) - count_a += 1; - foreach (A, b, it) - if (JOIN(A, find)(a, *it.ref)) - count_b += 1; + foreach(A, a, it) if(JOIN(A, find)(b, *it.ref)) count_a += 1; + foreach(A, b, it) if(JOIN(A, find)(a, *it.ref)) count_b += 1; return count_a == count_b; } static inline void - JOIN(A, swap)(A *self, A *other) +JOIN(A, swap)(A* self, A* other) { A temp = *self; *self = *other; @@ -188,279 +184,76 @@ static inline void } static inline size_t - JOIN(A, closest_prime)(size_t number) +JOIN(A, closest_prime)(size_t number) { static uint32_t primes[] = { - 2, - 3, - 5, - 7, - 11, - 13, - 17, - 19, - 23, - 29, - 31, - 37, - 41, - 43, - 47, - 53, - 59, - 61, - 67, - 71, - 73, - 79, - 83, - 89, - 97, - 103, - 109, - 113, - 127, - 137, - 139, - 149, - 157, - 167, - 179, - 193, - 199, - 211, - 227, - 241, - 257, - 277, - 293, - 313, - 337, - 359, - 383, - 409, - 439, - 467, - 503, - 541, - 577, - 619, - 661, - 709, - 761, - 823, - 887, - 953, - 1031, - 1109, - 1193, - 1289, - 1381, - 1493, - 1613, - 1741, - 1879, - 2029, - 2179, - 2357, - 2549, - 2753, - 2971, - 3209, - 3469, - 3739, - 4027, - 4349, - 4703, - 5087, - 5503, - 5953, - 6427, - 6949, - 7517, - 8123, - 8783, - 9497, - 10273, - 11113, - 12011, - 12983, - 14033, - 15173, - 16411, - 17749, - 19183, - 20753, - 22447, - 24281, - 26267, - 28411, - 30727, - 33223, - 35933, - 38873, - 42043, - 45481, - 49201, - 53201, - 57557, - 62233, - 67307, - 72817, - 78779, - 85229, - 92203, - 99733, - 107897, - 116731, - 126271, - 136607, - 147793, - 159871, - 172933, - 187091, - 202409, - 218971, - 236897, - 256279, - 277261, - 299951, - 324503, - 351061, - 379787, - 410857, - 444487, - 480881, - 520241, - 562841, - 608903, - 658753, - 712697, - 771049, - 834181, - 902483, - 976369, - 1056323, - 1142821, - 1236397, - 1337629, - 1447153, - 1565659, - 1693859, - 1832561, - 1982627, - 2144977, - 2320627, - 2510653, - 2716249, - 2938679, - 3179303, - 3439651, - 3721303, - 4026031, - 4355707, - 4712381, - 5098259, - 5515729, - 5967347, - 6456007, - 6984629, - 7556579, - 8175383, - 8844859, - 9569143, - 10352717, - 11200489, - 12117689, - 13109983, - 14183539, - 15345007, - 16601593, - 17961079, - 19431899, - 21023161, - 22744717, - 24607243, - 26622317, - 28802401, - 31160981, - 33712729, - 36473443, - 39460231, - 42691603, - 46187573, - 49969847, - 54061849, - 58488943, - 63278561, - 68460391, - 74066549, - 80131819, - 86693767, - 93793069, - 101473717, - 109783337, - 118773397, - 128499677, - 139022417, - 150406843, - 162723577, - 176048909, - 190465427, - 206062531, - 222936881, - 241193053, - 260944219, - 282312799, - 305431229, - 330442829, - 357502601, - 386778277, - 418451333, - 452718089, - 489790921, - 529899637, - 573292817, - 620239453, - 671030513, - 725980837, - 785430967, - 849749479, - 919334987, - 994618837, - 1076067617, - 1164186217, - 1259520799, - 1362662261, - 1474249943, - 1594975441, - 1725587117, + 2, 3, 5, 7, 11, + 13, 17, 19, 23, 29, 31, + 37, 41, 43, 47, 53, 59, + 61, 67, 71, 73, 79, 83, + 89, 97, 103, 109, 113, 127, + 137, 139, 149, 157, 167, 179, + 193, 199, 211, 227, 241, 257, + 277, 293, 313, 337, 359, 383, + 409, 439, 467, 503, 541, 577, + 619, 661, 709, 761, 823, 887, + 953, 1031, 1109, 1193, 1289, 1381, + 1493, 1613, 1741, 1879, 2029, 2179, + 2357, 2549, 2753, 2971, 3209, 3469, + 3739, 4027, 4349, 4703, 5087, 5503, + 5953, 6427, 6949, 7517, 8123, 8783, + 9497, 10273, 11113, 12011, 12983, 14033, + 15173, 16411, 17749, 19183, 20753, 22447, + 24281, 26267, 28411, 30727, 33223, 35933, + 38873, 42043, 45481, 49201, 53201, 57557, + 62233, 67307, 72817, 78779, 85229, 92203, + 99733, 107897, 116731, 126271, 136607, 147793, + 159871, 172933, 187091, 202409, 218971, 236897, + 256279, 277261, 299951, 324503, 351061, 379787, + 410857, 444487, 480881, 520241, 562841, 608903, + 658753, 712697, 771049, 834181, 902483, 976369, + 1056323, 1142821, 1236397, 1337629, 1447153, 1565659, + 1693859, 1832561, 1982627, 2144977, 2320627, 2510653, + 2716249, 2938679, 3179303, 3439651, 3721303, 4026031, + 4355707, 4712381, 5098259, 5515729, 5967347, 6456007, + 6984629, 7556579, 8175383, 8844859, 9569143, 10352717, + 11200489, 12117689, 13109983, 14183539, 15345007, 16601593, + 17961079, 19431899, 21023161, 22744717, 24607243, 26622317, + 28802401, 31160981, 33712729, 36473443, 39460231, 42691603, + 46187573, 49969847, 54061849, 58488943, 63278561, 68460391, + 74066549, 80131819, 86693767, 93793069, 101473717, 109783337, + 118773397, 128499677, 139022417, 150406843, 162723577, 176048909, + 190465427, 206062531, 222936881, 241193053, 260944219, 282312799, + 305431229, 330442829, 357502601, 386778277, 418451333, 452718089, + 489790921, 529899637, 573292817, 620239453, 671030513, 725980837, + 785430967, 849749479, 919334987, 994618837, 1076067617, 1164186217, + 1259520799, 1362662261, 1474249943, 1594975441, 1725587117, }; size_t min = primes[0]; - if (number < min) + if(number < min) return min; size_t size = len(primes); - for (size_t i = 0; i < size - 1; i++) + for(size_t i = 0; i < size - 1; i++) { size_t a = primes[i + 0]; size_t b = primes[i + 1]; - if (number >= a && number <= b) + if(number >= a && number <= b) return number == a ? a : b; } return primes[size - 1]; } -static inline B * - JOIN(B, init)(T value) +static inline B* +JOIN(B, init)(T value) { - B *n = (B *)malloc(sizeof(B)); + B* n = (B*) malloc(sizeof(B)); n->key = value; n->next = NULL; return n; } static inline void - JOIN(B, push)(A *self, B **bucket, B *n) +JOIN(B, push)(A* self, B** bucket, B* n) { n->next = *bucket; self->size += 1; @@ -468,22 +261,22 @@ static inline void } static inline size_t - JOIN(A, bucket_size)(A *self, size_t index) +JOIN(A, bucket_size)(A* self, size_t index) { size_t size = 0; - for (B *n = self->bucket[index]; n; n = n->next) + for(B* n = self->bucket[index]; n; n = n->next) size += 1; return size; } static inline float - JOIN(A, load_factor)(A *self) +JOIN(A, load_factor)(A* self) { - return (float)self->size / (float)self->bucket_count; + return (float) self->size / (float) self->bucket_count; } static inline A - JOIN(A, init)(size_t _hash(T *), int _equal(T *, T *)) +JOIN(A, init)(size_t _hash(T*), int _equal(T*, T*)) { static A zero; A self = zero; @@ -500,19 +293,18 @@ static inline A } static inline void - JOIN(A, rehash)(A *self, size_t desired_count); +JOIN(A, rehash)(A* self, size_t desired_count); static inline void - JOIN(A, reserve)(A *self, size_t desired_count) +JOIN(A, reserve)(A* self, size_t desired_count) { - if (self->size > 0) - JOIN(A, rehash) - (self, desired_count); + if(self->size > 0) + JOIN(A, rehash)(self, desired_count); else { size_t bucket_count = JOIN(A, closest_prime)(desired_count); - B **temp = (B **)calloc(bucket_count, sizeof(B *)); - for (size_t i = 0; i < self->bucket_count; i++) + B** temp = (B**) calloc(bucket_count, sizeof(B*)); + for(size_t i = 0; i < self->bucket_count; i++) temp[i] = self->bucket[i]; free(self->bucket); self->bucket = temp; @@ -521,21 +313,19 @@ static inline void } static inline void - JOIN(A, rehash)(A *self, size_t desired_count) +JOIN(A, rehash)(A* self, size_t desired_count) { - if (desired_count <= self->size) + if(desired_count <= self->size) desired_count = self->size + 1; size_t expected = JOIN(A, closest_prime)(desired_count); - if (expected != self->bucket_count) + if(expected != self->bucket_count) { A rehashed = JOIN(A, init)(self->hash, self->equal); - JOIN(A, reserve) - (&rehashed, desired_count); - foreach (A, self, it) + JOIN(A, reserve)(&rehashed, desired_count); + foreach(A, self, it) { - B **bucket = JOIN(A, bucket)(&rehashed, it.node->key); - JOIN(B, push) - (&rehashed, bucket, it.node); + B** bucket = JOIN(A, bucket)(&rehashed, it.node->key); + JOIN(B, push)(&rehashed, bucket, it.node); } free(self->bucket); *self = rehashed; @@ -543,86 +333,79 @@ static inline void } static inline void - JOIN(A, free_node)(A *self, B *n) +JOIN(A, free_node)(A* self, B* n) { - if (self->free) + if(self->free) self->free(&n->key); free(n); self->size -= 1; } static inline void - JOIN(A, clear)(A *self) +JOIN(A, clear)(A* self) { - foreach (A, self, it) - JOIN(A, free_node) - (self, it.node); - for (size_t i = 0; i < self->bucket_count; i++) + foreach(A, self, it) + JOIN(A, free_node)(self, it.node); + for(size_t i = 0; i < self->bucket_count; i++) self->bucket[i] = NULL; } static inline void - JOIN(A, free)(A *self) +JOIN(A, free)(A* self) { - JOIN(A, clear) - (self); + JOIN(A, clear)(self); free(self->bucket); } static inline void - JOIN(A, insert)(A *self, T value) +JOIN(A, insert)(A* self, T value) { - if (JOIN(A, empty)(self)) - JOIN(A, rehash) - (self, 12); - if (JOIN(A, find)(self, value)) + if(JOIN(A, empty)(self)) + JOIN(A, rehash)(self, 12); + if(JOIN(A, find)(self, value)) { - if (self->free) + if(self->free) self->free(&value); } else { - B **bucket = JOIN(A, bucket)(self, value); - JOIN(B, push) - (self, bucket, JOIN(B, init)(value)); - if (self->size > self->bucket_count) - JOIN(A, rehash) - (self, 2 * self->bucket_count); + B** bucket = JOIN(A, bucket)(self, value); + JOIN(B, push)(self, bucket, JOIN(B, init)(value)); + if(self->size > self->bucket_count) + JOIN(A, rehash)(self, 2 * self->bucket_count); } } static inline size_t - JOIN(A, count)(A *self, T value) +JOIN(A, count)(A* self, T value) { return JOIN(A, find)(self, value) ? 1 : 0; } static inline void - JOIN(A, linked_erase)(A *self, B **bucket, B *n, B *prev, B *next) +JOIN(A, linked_erase)(A* self, B** bucket, B* n, B* prev, B* next) { - JOIN(A, free_node) - (self, n); - if (prev) + JOIN(A, free_node)(self, n); + if(prev) prev->next = next; else *bucket = next; } static inline void - JOIN(A, erase)(A *self, T value) +JOIN(A, erase)(A* self, T value) { - if (!JOIN(A, empty)(self)) + if(!JOIN(A, empty)(self)) { - B **bucket = JOIN(A, bucket)(self, value); - B *prev = NULL; - B *n = *bucket; - while (n) + B** bucket = JOIN(A, bucket)(self, value); + B* prev = NULL; + B* n = *bucket; + while(n) { - B *next = n->next; - if (self->equal(&n->key, &value)) + B* next = n->next; + if(self->equal(&n->key, &value)) { - JOIN(A, linked_erase) - (self, bucket, n, prev, next); + JOIN(A, linked_erase)(self, bucket, n, prev, next); break; } else @@ -633,21 +416,20 @@ static inline void } static inline size_t - JOIN(A, remove_if)(A *self, int _match(T *)) +JOIN(A, remove_if)(A* self, int _match(T*)) { size_t erases = 0; - for (size_t i = 0; i < self->bucket_count; i++) + for(size_t i = 0; i < self->bucket_count; i++) { - B **bucket = &self->bucket[i]; - B *prev = NULL; - B *n = *bucket; - while (n) + B** bucket = &self->bucket[i]; + B* prev = NULL; + B* n = *bucket; + while(n) { - B *next = n->next; - if (_match(&n->key)) + B* next = n->next; + if(_match(&n->key)) { - JOIN(A, linked_erase) - (self, bucket, n, prev, next); + JOIN(A, linked_erase)(self, bucket, n, prev, next); erases += 1; } else @@ -659,12 +441,11 @@ static inline size_t } static inline A - JOIN(A, copy)(A *self) +JOIN(A, copy)(A* self) { A other = JOIN(A, init)(self->hash, self->equal); - foreach (A, self, it) - JOIN(A, insert) - (&other, self->copy(it.ref)); + foreach(A, self, it) + JOIN(A, insert)(&other, self->copy(it.ref)); return other; } diff --git a/ctl/vec.h b/ctl/vec.h index a037a87d..97d0db1a 100644 --- a/ctl/vec.h +++ b/ctl/vec.h @@ -6,7 +6,7 @@ #error "Template type T undefined for " #endif -#include "ctl.h" +#include #define A JOIN(vec, T) #define I JOIN(A, it) @@ -15,61 +15,62 @@ typedef struct A { - T *value; - void (*free)(T *); + T* value; + void (*free)(T*); #ifdef COMPARE - int (*compare)(T *, T *); + int (*compare)(T*, T*); #endif - T (*copy) - (T *); + T (*copy)(T*); size_t size; size_t capacity; -} A; +} +A; typedef struct I { - void (*step)(struct I *); - T *ref; - T *begin; - T *end; - T *next; + void (*step)(struct I*); + T* ref; + T* begin; + T* end; + T* next; int done; -} I; +} +I; -static inline T * - JOIN(A, at)(A *self, size_t index) +static inline T* +JOIN(A, at)(A* self, size_t index) { return &self->value[index]; } -static inline T * - JOIN(A, front)(A *self) +static inline T* +JOIN(A, front)(A* self) { return JOIN(A, at)(self, 0); } -static inline T * - JOIN(A, back)(A *self) +static inline T* +JOIN(A, back)(A* self) { return JOIN(A, at)(self, self->size - 1); } -static inline T * - JOIN(A, begin)(A *self) +static inline T* +JOIN(A, begin)(A* self) { return JOIN(A, front)(self); } -static inline T * - JOIN(A, end)(A *self) +static inline T* +JOIN(A, end)(A* self) { return JOIN(A, back)(self) + 1; } static inline void - JOIN(I, step)(I *self) +JOIN(I, step)(I* self) { - if (self->next >= self->end) + if(self->next >= self->end) self->done = 1; else { @@ -79,12 +80,12 @@ static inline void } static inline I - JOIN(I, range)(A *container, T *begin, T *end) +JOIN(I, range)(A* container, T* begin, T* end) { - (void)container; + (void) container; static I zero; I self = zero; - if (begin && end) + if(begin && end) { self.step = JOIN(I, step); self.begin = begin; @@ -98,35 +99,35 @@ static inline I } static inline int - JOIN(A, empty)(A *self) +JOIN(A, empty)(A* self) { return self->size == 0; } static inline I - JOIN(I, each)(A *a) +JOIN(I, each)(A* a) { return JOIN(A, empty)(a) - ? JOIN(I, range)(a, NULL, NULL) - : JOIN(I, range)(a, JOIN(A, begin)(a), JOIN(A, end)(a)); + ? JOIN(I, range)(a, NULL, NULL) + : JOIN(I, range)(a, JOIN(A, begin)(a), JOIN(A, end)(a)); } static inline T - JOIN(A, implicit_copy)(T *self) +JOIN(A, implicit_copy)(T* self) { return *self; } static inline int - JOIN(A, equal)(A *self, A *other, int _equal(T *, T *)) +JOIN(A, equal)(A* self, A* other, int _equal(T*, T*)) { - if (self->size != other->size) + if(self->size != other->size) return 0; I a = JOIN(I, each)(self); I b = JOIN(I, each)(other); - while (!a.done && !b.done) + while(!a.done && !b.done) { - if (!_equal(a.ref, b.ref)) + if(!_equal(a.ref, b.ref)) return 0; a.step(&a); b.step(&b); @@ -135,7 +136,7 @@ static inline int } static inline void - JOIN(A, swap)(A *self, A *other) +JOIN(A, swap)(A* self, A* other) { A temp = *self; *self = *other; @@ -143,7 +144,7 @@ static inline void } static inline A - JOIN(A, init)(void) +JOIN(A, init)(void) { static A zero; A self = zero; @@ -158,178 +159,165 @@ static inline A } static inline void - JOIN(A, set)(A *self, size_t index, T value) +JOIN(A, set)(A* self, size_t index, T value) { - T *ref = JOIN(A, at)(self, index); - if (self->free) + T* ref = JOIN(A, at)(self, index); + if(self->free) self->free(ref); *ref = value; } static inline void - JOIN(A, pop_back)(A *self) +JOIN(A, pop_back)(A* self) { static T zero; self->size -= 1; - JOIN(A, set) - (self, self->size, zero); + JOIN(A, set)(self, self->size, zero); } static inline void - JOIN(A, wipe)(A *self, size_t n) +JOIN(A, wipe)(A* self, size_t n) { - while (n != 0) + while(n != 0) { - JOIN(A, pop_back) - (self); + JOIN(A, pop_back)(self); n -= 1; } } static inline void - JOIN(A, clear)(A *self) +JOIN(A, clear)(A* self) { - if (self->size > 0) - JOIN(A, wipe) - (self, self->size); + if(self->size > 0) + JOIN(A, wipe)(self, self->size); } static inline void - JOIN(A, free)(A *self) +JOIN(A, free)(A* self) { - JOIN(A, clear) - (self); + JOIN(A, clear)(self); free(self->value); *self = JOIN(A, init)(); } static inline void - JOIN(A, fit)(A *self, size_t capacity) +JOIN(A, fit)(A* self, size_t capacity) { static T zero; size_t overall = capacity; - if (MUST_ALIGN_16(T)) + if(MUST_ALIGN_16(T)) overall += 1; - self->value = (T *)realloc(self->value, overall * sizeof(T)); - if (MUST_ALIGN_16(T)) - for (size_t i = self->capacity; i < overall; i++) + self->value = (T*) realloc(self->value, overall * sizeof(T)); + if(MUST_ALIGN_16(T)) + for(size_t i = self->capacity; i < overall; i++) self->value[i] = zero; self->capacity = capacity; } static inline void - JOIN(A, reserve)(A *self, const size_t capacity) +JOIN(A, reserve)(A* self, const size_t capacity) { - if (capacity != self->capacity) + if(capacity != self->capacity) { size_t actual = 0; - if (MUST_ALIGN_16(T)) + if(MUST_ALIGN_16(T)) { - if (capacity <= self->size) + if(capacity <= self->size) actual = self->size; - else if (capacity > self->size && capacity < self->capacity) + else + if(capacity > self->size && capacity < self->capacity) actual = capacity; else { actual = 2 * self->capacity; - if (capacity > actual) + if(capacity > actual) actual = capacity; } } - else if (capacity > self->capacity) + else + if(capacity > self->capacity) actual = capacity; - if (actual > 0) - JOIN(A, fit) - (self, actual); + if(actual > 0) + JOIN(A, fit)(self, actual); } } static inline void - JOIN(A, push_back)(A *self, T value) +JOIN(A, push_back)(A* self, T value) { - if (self->size == self->capacity) - JOIN(A, reserve) - (self, self->capacity == 0 ? 1 : 2 * self->capacity); + if(self->size == self->capacity) + JOIN(A, reserve)(self, self->capacity == 0 ? 1 : 2 * self->capacity); *JOIN(A, at)(self, self->size) = value; self->size += 1; } static inline void - JOIN(A, resize)(A *self, size_t size, T value) +JOIN(A, resize)(A* self, size_t size, T value) { - if (size < self->size) + if(size < self->size) { int64_t less = self->size - size; - if (less > 0) - JOIN(A, wipe) - (self, less); + if(less > 0) + JOIN(A, wipe)(self, less); } else { - if (size > self->capacity) + if(size > self->capacity) { size_t capacity = 2 * self->size; - if (size > capacity) + if(size > capacity) capacity = size; - JOIN(A, reserve) - (self, capacity); + JOIN(A, reserve)(self, capacity); } - for (size_t i = 0; self->size < size; i++) - JOIN(A, push_back) - (self, self->copy(&value)); + for(size_t i = 0; self->size < size; i++) + JOIN(A, push_back)(self, self->copy(&value)); } - if (self->free) + if(self->free) self->free(&value); } static inline void - JOIN(A, assign)(A *self, size_t size, T value) -{ - JOIN(A, resize) - (self, size, self->copy(&value)); - for (size_t i = 0; i < size; i++) - JOIN(A, set) - (self, i, self->copy(&value)); - if (self->free) +JOIN(A, assign)(A* self, size_t size, T value) +{ + JOIN(A, resize)(self, size, self->copy(&value)); + for(size_t i = 0; i < size; i++) + JOIN(A, set)(self, i, self->copy(&value)); + if(self->free) self->free(&value); } static inline void - JOIN(A, shrink_to_fit)(A *self) +JOIN(A, shrink_to_fit)(A* self) { - JOIN(A, fit) - (self, self->size); + JOIN(A, fit)(self, self->size); } -static inline T * - JOIN(A, data)(A *self) +static inline T* +JOIN(A, data)(A* self) { return JOIN(A, front)(self); } static inline void - JOIN(A, insert)(A *self, size_t index, T value) +JOIN(A, insert)(A* self, size_t index, T value) { - if (self->size > 0) + if(self->size > 0) { - JOIN(A, push_back) - (self, *JOIN(A, back)(self)); - for (size_t i = self->size - 2; i > index; i--) + JOIN(A, push_back)(self, *JOIN(A, back)(self)); + for(size_t i = self->size - 2; i > index; i--) self->value[i] = self->value[i - 1]; self->value[index] = value; } else - JOIN(A, push_back) - (self, value); + JOIN(A, push_back)(self, value); } static inline void - JOIN(A, erase)(A *self, size_t index) +JOIN(A, erase)(A* self, size_t index) { static T zero; - JOIN(A, set) - (self, index, zero); - for (size_t i = index; i < self->size - 1; i++) + JOIN(A, set)(self, index, zero); + for(size_t i = index; i < self->size - 1; i++) { self->value[i] = self->value[i + 1]; self->value[i + 1] = zero; @@ -338,59 +326,53 @@ static inline void } static inline void - JOIN(A, ranged_sort)(A *self, int64_t a, int64_t b, int _compare(T *, T *)) +JOIN(A, ranged_sort)(A* self, int64_t a, int64_t b, int _compare(T*, T*)) { - if (a >= b) + if(a >= b) return; int64_t mid = (a + b) / 2; SWAP(T, &self->value[a], &self->value[mid]); int64_t z = a; - for (int64_t i = a + 1; i <= b; i++) - if (_compare(&self->value[a], &self->value[i])) + for(int64_t i = a + 1; i <= b; i++) + if(_compare(&self->value[a], &self->value[i])) { z += 1; SWAP(T, &self->value[z], &self->value[i]); } SWAP(T, &self->value[a], &self->value[z]); - JOIN(A, ranged_sort) - (self, a, z - 1, _compare); - JOIN(A, ranged_sort) - (self, z + 1, b, _compare); + JOIN(A, ranged_sort)(self, a, z - 1, _compare); + JOIN(A, ranged_sort)(self, z + 1, b, _compare); } static inline void - JOIN(A, sort)(A *self, int _compare(T *, T *)) +JOIN(A, sort)(A* self, int _compare(T*, T*)) { - JOIN(A, ranged_sort) - (self, 0, self->size - 1, _compare); + JOIN(A, ranged_sort)(self, 0, self->size - 1, _compare); } static inline A - JOIN(A, copy)(A *self) +JOIN(A, copy)(A* self) { A other = JOIN(A, init)(); #ifdef COMPARE other.compare = self->compare; #endif - JOIN(A, reserve) - (&other, self->size); - while (other.size < self->size) - JOIN(A, push_back) - (&other, other.copy(&self->value[other.size])); + JOIN(A, reserve)(&other, self->size); + while(other.size < self->size) + JOIN(A, push_back)(&other, other.copy(&self->value[other.size])); return other; } static inline size_t - JOIN(A, remove_if)(A *self, int _match(T *)) +JOIN(A, remove_if)(A* self, int _match(T*)) { size_t erases = 0; - foreach (A, self, it) + foreach(A, self, it) { - if (_match(it.ref)) + if(_match(it.ref)) { size_t index = it.ref - JOIN(A, begin)(self); - JOIN(A, erase) - (self, index); + JOIN(A, erase)(self, index); it.end = JOIN(A, end)(self); it.next = it.ref; erases += 1; @@ -399,11 +381,11 @@ static inline size_t return erases; } -static inline T * - JOIN(A, find)(A *self, T key, int _equal(T *, T *)) +static inline T* +JOIN(A, find)(A* self, T key, int _equal(T*, T*)) { - foreach (A, self, it) - if (_equal(it.ref, &key)) + foreach(A, self, it) + if(_equal(it.ref, &key)) return it.ref; return NULL; } From ee59654b5015f2c4ea9d8fd28b7865a45386cbfe Mon Sep 17 00:00:00 2001 From: HO-COOH Date: Thu, 29 Apr 2021 07:13:02 +0800 Subject: [PATCH 6/6] Restore format 2 --- ctl/deq.h | 2 +- ctl/lst.h | 2 +- ctl/pqu.h | 2 +- ctl/que.h | 2 +- ctl/set.h | 2 +- ctl/stk.h | 2 +- ctl/str.h | 2 +- ctl/ust.h | 2 +- ctl/vec.h | 2 +- 9 files changed, 9 insertions(+), 9 deletions(-) diff --git a/ctl/deq.h b/ctl/deq.h index abe45086..c21f9892 100644 --- a/ctl/deq.h +++ b/ctl/deq.h @@ -6,7 +6,7 @@ #error "Template type T undefined for " #endif -#include +#include "ctl.h" #define A JOIN(deq, T) #define B JOIN(A, bucket) diff --git a/ctl/lst.h b/ctl/lst.h index 24e92db3..010982cd 100644 --- a/ctl/lst.h +++ b/ctl/lst.h @@ -6,7 +6,7 @@ #error "Template type T undefined for " #endif -#include +#include "ctl.h" #define A JOIN(lst, T) #define B JOIN(A, node) diff --git a/ctl/pqu.h b/ctl/pqu.h index c5f6ca12..eaa92aa4 100644 --- a/ctl/pqu.h +++ b/ctl/pqu.h @@ -34,7 +34,7 @@ #define HOLD #define COMPARE #define init __INIT -#include +#include "vec.h" #undef init #undef vec diff --git a/ctl/que.h b/ctl/que.h index c013c066..0fdedffc 100644 --- a/ctl/que.h +++ b/ctl/que.h @@ -26,7 +26,7 @@ #define remove_if __REMOVE_IF #define deq que -#include +#include "deq.h" #undef deq #undef push_back diff --git a/ctl/set.h b/ctl/set.h index 19244c9c..3d7b2931 100644 --- a/ctl/set.h +++ b/ctl/set.h @@ -6,7 +6,7 @@ #error "Template type T undefined for " #endif -#include +#include "ctl.h" #define A JOIN(set, T) #define B JOIN(A, node) diff --git a/ctl/stk.h b/ctl/stk.h index aaf285fb..6f51ac50 100644 --- a/ctl/stk.h +++ b/ctl/stk.h @@ -28,7 +28,7 @@ #define remove_if __REMOVE_IF #define deq stk -#include +#include "deq.h" #undef deq #undef push_back diff --git a/ctl/str.h b/ctl/str.h index acc9840e..e4858882 100644 --- a/ctl/str.h +++ b/ctl/str.h @@ -15,7 +15,7 @@ #define str_init str___INIT #define str_equal str___EQUAL #define str_find str___FIND -#include +#include "vec.h" #undef str_init #undef str_equal #undef str_find diff --git a/ctl/ust.h b/ctl/ust.h index b59989c5..afa260db 100644 --- a/ctl/ust.h +++ b/ctl/ust.h @@ -6,7 +6,7 @@ #error "Template type T undefined for " #endif -#include +#include "ctl.h" #define A JOIN(ust, T) #define B JOIN(A, node) diff --git a/ctl/vec.h b/ctl/vec.h index 97d0db1a..2caaffda 100644 --- a/ctl/vec.h +++ b/ctl/vec.h @@ -6,7 +6,7 @@ #error "Template type T undefined for " #endif -#include +#include "ctl.h" #define A JOIN(vec, T) #define I JOIN(A, it)