Add WIP prototype for separate generation of declarations and body

instead of just static inline functions. Implemented for list only (and not for emplace generations)
Provide a way to alter the standard naming convention for the functions
2023-04-22 13:14:37 +02:00 · 2023-04-22 09:33:08 +02:00 · 2023-04-22 09:23:18 +02:00 · 2023-04-21 22:44:34 +02:00 · 2023-04-21 22:44:23 +02:00 · 2023-04-19 23:06:23 +02:00
158 changed files with 26651 additions and 12034 deletions
@@ -10,37 +10,49 @@ jobs:
    runs-on: ${{ matrix.platform }}
    
    steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v3
+    - name: CPU Information
+      run:  lscpu || sysctl -a|grep cpu || echo "CPU information not available"
    - name: make check C99
-      run: make clean check CC="cc -std=c99 -Wno-unknown-warning-option -Werror"
+      run: make clean && make check -j 2 CC="cc -std=c99 -Wno-unknown-warning-option -Werror"
    - name: make check C11
      working-directory: ./tests
-      run: make clean check CC="cc -std=c11 -Wno-unknown-warning-option -Werror"
+      run: make clean && make check -j 2 CC="cc -std=c11 -Wno-unknown-warning-option -Werror"
    - name: make check C++
      working-directory: ./tests
-      run: make clean check CC="c++ -std=c++11"
+      run: make clean && make check -j 2 CC="c++ -std=c++11"

  build_linux32:
    runs-on: ubuntu-latest
    
    steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v3
    - name: update package list
      run: sudo apt-get update
    - name: install multilib
-      run: sudo apt-get install gcc-multilib
+      run: sudo apt-get install gcc-multilib g++-multilib
+    - name: CPU Information
+      run:  lscpu || echo "CPU information not available"
    - name: make check C99 (32bits)
      working-directory: ./tests
-      run: make clean check CC="gcc -m32 -std=c99 -Wno-unknown-warning-option -Werror"
+      run: make clean && make check -j 2 CC="gcc -m32 -std=c99 -Wno-unknown-warning-option -Werror"
    - name: make check C11 (32bits)
      working-directory: ./tests
-      run: make clean check CC="gcc -m32 -std=c11 -Wno-unknown-warning-option -Werror"
+      run: make clean && make check -j 2 CC="gcc -m32 -std=c11 -Wno-unknown-warning-option -Werror"
+    - name: make check C++ (32 bits)
+      working-directory: ./tests
+      run: make clean && make check -j 2 CC="g++ -m32 -std=c++11 -Wno-unknown-warning-option "
+    - name: make check against C++ STL
+      working-directory: ./tests
+      run: make clean && make check-stl -j 2
 
  build_linux_tcc:
    runs-on: ubuntu-latest
    
    steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v3
+    - name: CPU Information
+      run:  lscpu || echo "CPU information not available"
    - name: Clone TCC
      shell: bash
      run:  git clone https://repo.or.cz/tinycc.git
@@ -54,14 +66,23 @@ jobs:
      shell: bash
      run: make CC="/tmp/tcc/bin/tcc -std=c99" check

+  build_linux_sanitize:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - uses: actions/checkout@v3
+    - name: make sanitize
+      working-directory: ./tests
+      run: make sanitize -j 2
+
  build_windows_mingw:
    runs-on: windows-latest
    
    steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v3
    - name: make check
      shell: bash
-      run: mingw32-make CC="gcc -std=c99 -D__USE_MINGW_ANSI_STDIO=1" check
+      run: mingw32-make -j 2 CC="gcc -std=c99 -D__USE_MINGW_ANSI_STDIO=1" check

  build_windows_msys2:
    runs-on: windows-latest
@@ -69,20 +90,20 @@ jobs:
      run:
        shell: msys2 {0}    
    steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
    - uses: msys2/setup-msys2@v2
      with:
          msystem: MINGW64
          update: true
          install: git mingw-w64-x86_64-toolchain make
    - name: make check
-      run: make CC="gcc -std=c99 -D__USE_MINGW_ANSI_STDIO=1" check
+      run: make -j 2 CC="gcc -std=c99 -D__USE_MINGW_ANSI_STDIO=1" check

  build_windows_visual:
    runs-on: windows-latest
    
    steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v3
    - name: make check
      shell: cmd
      working-directory: ./tests
@@ -92,9 +113,41 @@ jobs:
    runs-on: windows-latest
    
    steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v3
    - name: make check
      shell: cmd
      working-directory: ./tests
      run: Make-check-cl.bat clang-cl

+  build_freebsd:
+    runs-on: macos-12
+    steps:
+    - uses: actions/checkout@v3
+    - name: Test in FreeBSD
+      id: test
+      uses: vmactions/freebsd-vm@v0
+      with:
+        usesh: true
+        run: |
+             freebsd-version
+             cd tests
+             make check -j 2 CC="cc -std=c99 -Wno-unknown-warning-option -Werror" && make clean && make check -j 2 CC="cc -std=c11 -Wno-unknown-warning-option -Werror" LDFLAGS="-lstdthreads" && make clean
+
+    # The host should always be linux
+  build_aarch64:
+    runs-on: ubuntu-latest
+    name: Build on aarch64
+    steps:
+      - uses: actions/checkout@v3
+      - uses: uraimo/run-on-arch-action@v2.5.0
+        name: Run commands on aarch64
+        id: make
+        with:
+          arch: aarch64
+          distro: bullseye
+          shell: /bin/sh
+          run: |
+            apt-get update -q -y
+            apt-get install -q -y  build-essential git gcc
+            lscpu
+            cd tests && make check -j 2 && make clean
@@ -28,20 +28,15 @@ jobs:

    steps:
    - name: Checkout repository
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
      with:
        # We must fetch at least the immediate parents so that if this is
        # a pull request then we can checkout the head.
        fetch-depth: 2

-    # If this run was triggered by a pull request event, then checkout
-    # the head of the pull request instead of the merge commit.
-    - run: git checkout HEAD^2
-      if: ${{ github.event_name == 'pull_request' }}
-
    # Initializes the CodeQL tools for scanning.
    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
+      uses: github/codeql-action/init@v2
      with:
        languages: ${{ matrix.language }}
        # If you wish to specify custom queries, you can do so here or in a config file.
@@ -55,4 +50,4 @@ jobs:
      run:  make exe

    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1
+      uses: github/codeql-action/analyze@v2
@@ -42,3 +42,8 @@ config
 .vscode
 .vs
 tmp-serial.*
+*~
+*.gcda
+*.gcno
+*.gcov
+*.synt
@@ -1,6 +1,6 @@
 BSD 2-Clause License

-Copyright (c) 2017-2021, Patrick Pelissier
+Copyright (c) 2017-2023, Patrick Pelissier
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2021, Patrick Pelissier
+# Copyright (c) 2017-2023, Patrick Pelissier
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without
@@ -34,14 +34,14 @@ DESTDIR=

 # Package name & version.
 PACKAGE=m_lib-$(VERSION)
-VERSION=0.5.0
+VERSION=0.7.1

 # Define the contain of the distribution tarball
-HEADER=m-algo.h m-array.h m-atomic.h m-bitset.h m-bptree.h m-buffer.h m-c-mempool.h m-concurrent.h m-core.h m-deque.h m-dict.h m-funcobj.h m-genint.h m-i-list.h m-i-shared.h m-list.h m-mempool.h m-mutex.h m-prioqueue.h m-rbtree.h m-serial-bin.h m-serial-json.h m-shared.h m-snapshot.h m-string.h m-tuple.h m-variant.h m-worker.h
+HEADER=m-algo.h m-array.h m-atomic.h m-bitset.h m-bptree.h m-buffer.h m-c-mempool.h m-concurrent.h m-core.h m-deque.h m-dict.h m-funcobj.h m-genint.h m-i-list.h m-i-shared.h m-list.h m-mempool.h m-thread.h m-mutex.h m-prioqueue.h m-rbtree.h m-serial-bin.h m-serial-json.h m-shared.h m-snapshot.h m-string.h m-tree.h m-try.h m-tuple.h m-variant.h m-worker.h
 DOC1=LICENSE README.md
 DOC2=doc/API.txt doc/Container.html doc/Container.ods doc/depend.png doc/DEV.md doc/ISSUES.org doc/oplist.odp doc/oplist.png
-EXAMPLE=example/ex11-algo01.c example/ex11-algo02.c example/ex11-json01.c example/ex11-section.c example/ex-algo02.c example/ex-algo03.c example/ex-algo04.c example/ex-array00.c example/ex-array01.c example/ex-array02.c example/ex-array03.c example/ex-array04.c example/ex-array05.c example/ex-bptree01.c example/ex-buffer01.c example/ex-dict01.c example/ex-dict02.c example/ex-dict03.c example/ex-dict04.c example/ex-grep01.c example/ex-list01.c example/ex-mph.c example/ex-multi01.c example/ex-multi02.c example/ex-multi03.c example/ex-multi04.c example/ex-multi05.c example/ex-rbtree01.c example/ex11-algo02.json example/ex11-json01.json example/Makefile
-TEST=tests/test-malgo.c tests/test-marray.c tests/test-mbitset.c tests/test-mbptree.c tests/test-mbuffer.c tests/test-mcmempool.c tests/test-mconcurrent.c tests/test-mcore.c tests/test-mdeque.c tests/test-mdict.c tests/test-mfuncobj.c tests/test-mgenint.c tests/test-milist.c tests/test-mlist.c tests/test-mmempool.c tests/test-mmutex.c tests/test-mprioqueue.c tests/test-mrbtree.c tests/test-mserial-bin.c tests/test-mserial-json.c tests/test-mshared.c tests/test-msnapshot.c tests/test-mstring.c tests/test-mtuple.c tests/test-mvariant.c tests/test-mworker.c tests/tgen-bitset.c tests/tgen-marray.c tests/tgen-mdict.c tests/tgen-mlist.c tests/tgen-mstring.c tests/tgen-openmp.c tests/tgen-queue.c tests/tgen-shared.c tests/Makefile tests/coverage.h tests/test-obj.h tests/dict.txt
+EXAMPLE=example/ex11-algo01.c example/ex11-algo02.c example/ex11-json01.c example/ex11-section.c example/ex-algo02.c example/ex-algo03.c example/ex-algo04.c example/ex-array00.c example/ex-array01.c example/ex-array02.c example/ex-array03.c example/ex-array04.c example/ex-array05.c example/ex-bptree01.c example/ex-buffer01.c example/ex-dict01.c example/ex-dict02.c example/ex-dict03.c example/ex-dict04.c example/ex-grep01.c example/ex-list01.c example/ex-mph.c example/ex-multi01.c example/ex11-multi02.c example/ex-multi03.c example/ex-multi04.c example/ex-multi05.c example/ex-rbtree01.c example/ex11-algo02.json example/ex11-json01.json example/Makefile example/ex-defer01.c example/ex-string01.c example/ex-string02.c example/ex-astar.c example/ex-string03.c example/ex11-tstc.c example/ex-no-stdio.c example/ex11-count-lines.c example/ex11-json-net.c example/ex11-rbtree02.c
+TEST=tests/test-malgo.c tests/test-marray.c tests/test-mbitset.c tests/test-mbptree.c tests/test-mbuffer.c tests/test-mcmempool.c tests/test-mconcurrent.c tests/test-mcore.c tests/test-mdeque.c tests/test-mdict.c tests/test-mfuncobj.c tests/test-mgenint.c tests/test-milist.c tests/test-mlist.c tests/test-mmempool.c tests/test-mmutex.c tests/test-mprioqueue.c tests/test-mrbtree.c tests/test-mserial-bin.c tests/test-mserial-json.c tests/test-mshared.c tests/test-msnapshot.c tests/test-mstring.c tests/test-mtuple.c tests/test-mvariant.c tests/test-mworker.c tests/tgen-bitset.c tests/tgen-marray.c tests/tgen-mdict.c tests/tgen-mlist.c tests/tgen-mstring.c tests/tgen-openmp.c tests/tgen-queue.c tests/tgen-shared.c tests/tgen-mserial.c tests/Makefile tests/coverage.h tests/test-obj.h tests/dict.txt tests/fail-chain-oplist.c  tests/fail-incompatible.c  tests/fail-no-oplist.c tests/test-mishared.c tests/check-array.cpp tests/check-deque.cpp tests/check-dplist.cpp tests/check-list.cpp tests/check-rbtree.cpp tests/check-uset.cpp tests/check-generic.hpp tests/test-mtree.c tests/check-bptree-map.cpp tests/check-bptree-set.cpp tests/check-prioqueue.cpp tests/check-umap.cpp

 .PHONY: all test check doc clean distclean depend install uninstall dist

@@ -58,17 +58,18 @@ checkall:
 	cd tests && $(MAKE) checkall
 	cd example && $(MAKE) all

-html:	doc
-doc:	README.md doc/depend.png
+html:	README.md
 	markdown < README.md > README.html

+doc:	html doc/depend.png
+
 clean:
 	cd tests && $(MAKE) clean
 	cd example && $(MAKE) clean
 	cd bench && $(MAKE) clean
 	$(RM) README.html depend.dot
-	$(RM) -r 'm*lib-$(VERSION)'
-	$(RM) 'm*lib-$(VERSION).tar.bz2'
+	$(RM) -r 'm_lib-$(VERSION)'
+	$(RM) 'm_lib-$(VERSION).tar.bz2'

 distclean: clean
 	cd tests && $(MAKE) distclean
@@ -81,7 +82,7 @@ doc/depend.png: $(HEADER)
 	dot -Tpng depend.dot -o doc/depend.png
 	optipng -o7 doc/depend.png

-dist: $(HEADER) $(DOC1) $(DOC2) $(EXAMPLE) $(TEST) Makefile clean
+dist: $(HEADER) $(DOC1) $(DOC2) $(EXAMPLE) $(TEST) Makefile clean versioncheck
 	$(MKDIR) '$(PACKAGE)'
 	$(MKDIR) '$(PACKAGE)/doc'
 	$(MKDIR) '$(PACKAGE)/tests'
@@ -96,6 +97,14 @@ dist: $(HEADER) $(DOC1) $(DOC2) $(EXAMPLE) $(TEST) Makefile clean
 distcheck: dist
 	cd '$(PACKAGE)' && make check

+versioncheck:
+	@if test "$(VERSION)." != `grep M_CORE_VERSION m-core.h |awk '{printf "%d.",$$3 } END {printf "\n"}'` ; then echo "ERROR: Version mismatch between Makefile & HEADERS" ; exit 2 ; fi
+	@for i in *.h ; do echo $(HEADER) | grep -q $$i ; if test $$? -ne 0 ; then echo "ERROR: Missing header $$i in Makefile" ; exit 3 ; fi ; done
+	@for i in doc/* ; do echo $(DOC2) | grep -q $$i ; if test $$? -ne 0 ; then echo "ERROR: Missing document $$i in Makefile" ; exit 4 ; fi ; done
+	@for i in tests/*.c tests/*.txt tests/*.h ; do echo $(TEST) | grep -q $$i ; if test $$? -ne 0 ; then echo "ERROR: Missing test $$i in Makefile" ; exit 5 ; fi ; done
+	@for i in example/*.c example/*.json ; do echo $(EXAMPLE) | grep -q $$i ; if test $$? -ne 0 ; then echo "ERROR: Missing example $$i in Makefile" ; exit 6 ; fi ; done
+	@for i in tests/*.cpp tests/*.hpp ; do echo $(TEST) | grep -q $$i ; if test $$? -ne 0 ; then echo "ERROR: Missing test $$i in Makefile" ; exit 7 ; fi ; done
+
 install:
 	$(MKDIR) $(DESTDIR)$(PREFIX)/include/m-lib
 	$(INSTALL_DATA) $(HEADER) $(DESTDIR)$(PREFIX)/include/m-lib
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2021, Patrick Pelissier
+# Copyright (c) 2017-2023, Patrick Pelissier
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without
@@ -29,7 +29,7 @@ N=4
 BENCH_DEF=
 RM=rm -rf

-.PHONY: all pgo container queue mempool string plain bench-mlib bench-mlib-mempool bench-stl bench-qt bench-glib bench-klib bench-libdynamic bench-sparsepp bench-collectionc bench-tommyds bench-flathashmap bench-emilib bench-hopscotchmap bench-mlib-thread bench-liblfds bench-concurrentqueue bench-boost bench-mempool bench-string bench-plain bench-rigtorp-mpmc-queue bench-cmc
+.PHONY: all pgo container queue mempool string plain bench-mlib bench-mlib-mempool bench-stl bench-qt bench-glib bench-klib bench-libdynamic bench-sparsepp bench-collectionc bench-tommyds bench-flathashmap bench-emilib bench-emhash bench-hopscotchmap bench-mlib-thread bench-liblfds bench-concurrentqueue bench-boost bench-mempool bench-string bench-plain bench-rigtorp-mpmc-queue bench-cmc

 all: container queue mempool string plain

@@ -39,7 +39,7 @@ pgo:

 #########################################################################

-container: bench-mlib bench-mlib-mempool bench-stl bench-qt bench-glib bench-klib bench-libdynamic bench-cmc bench-sparsepp bench-densehashmap bench-collectionc bench-tommyds bench-flathashmap bench-emilib bench-hopscotchmap bench-uthash bench-qlibc bench-libsrt bench-nedtries bench-rigtorp-hashmap
+container: bench-mlib bench-mlib-mempool bench-stl bench-qt bench-glib bench-klib bench-libdynamic bench-cmc bench-sparsepp bench-densehashmap bench-collectionc bench-tommyds bench-flathashmap bench-emilib bench-emhash bench-hopscotchmap bench-uthash bench-qlibc bench-libsrt bench-nedtries bench-rigtorp-hashmap bench-ctl bench-stc bench-pottery bench-CC
 	@echo "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"

 queue: bench-mlib-thread bench-liblfds bench-concurrentqueue bench-boost bench-rigtorp-mpmc-queue
@@ -118,7 +118,7 @@ bench-stl:
 bench-qt:
 	@if test -n "$${QT}" ; then $(MAKE) bench-qt0 ; else echo "Nothing to be done for QT." ; fi
 bench-qt0:
-	$(CXX) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -fPIC `PKG_CONFIG_PATH="$${QT}" pkg-config --libs --cflags Qt5Core` bench-qt.cpp common.c -o bench-qt.exe
+	$(CXX) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -fPIC bench-qt.cpp common.c -o bench-qt.exe `PKG_CONFIG_PATH="$${QT}" pkg-config --libs --cflags Qt5Core`
 	@./bench-qt.exe 10
 	@./bench-qt.exe 20
 	@./bench-qt.exe 30
@@ -162,12 +162,12 @@ bench-cmc0:
 	@./bench-cmc.exe 30
 	@./bench-cmc.exe 40

-# LIBDYNAMIC shall point to the the directory containing the file libdynamic.pc
+# LIBDYNAMIC shall point to the the source directory where the source is built
 bench-libdynamic:
 	@if test -n "$${LIBDYNAMIC}" ; then $(MAKE) bench-libdynamic0 ; else echo "Nothing to be done for LIBDYNAMIC." ; fi

 bench-libdynamic0:
-	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) bench-libdynamic.c common.c -o bench-libdynamic.exe `PKG_CONFIG_PATH="$${LIBDYNAMIC}" pkg-config --libs --cflags libdynamic` 
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) bench-libdynamic.c common.c -o bench-libdynamic.exe -I$${LIBDYNAMIC}/src $${LIBDYNAMIC}/.libs/libdynamic.a
 	@./bench-libdynamic.exe 20
 	@./bench-libdynamic.exe 40
 	@./bench-libdynamic.exe 41
@@ -239,6 +239,17 @@ bench-emilib0:
 	@./bench-emilib.exe 46
 	@./bench-emilib.exe 43

+# EMHASh shall point to the directory where the headers are
+bench-emhash:
+	@if test -n "$${EMHASH}" ; then $(MAKE) bench-emhash0 ; else echo "Nothing to be done for EMHASH." ; fi
+
+bench-emhash0:
+	$(CXX) -std=c++14 $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${EMHASH}" bench-emhash.cpp common.c -o bench-emhash.exe
+	@./bench-emhash.exe 41
+	@./bench-emhash.exe 42
+	@./bench-emhash.exe 46
+	@./bench-emhash.exe 43
+
 # HOPSCOTCHMAP shall point to the directory where the source are
 bench-hopscotchmap:
 	@if test -n "$${HOPSCOTCHMAP}" ; then $(MAKE) bench-hopscotchmap0 ; else echo "Nothing to be done for HOPSCOTCHMAP." ; fi
@@ -276,7 +287,7 @@ bench-libsrt:
 	@if test -n "$${LIBSRT}" ; then $(MAKE) bench-libsrt0 ; else echo "Nothing to be done for LIBSRT." ; fi

 bench-libsrt0:
-	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${LIBSRT}/include/libsrt" bench-libsrt.c common.c -o bench-libsrt.exe $${LIBSRT}/lib/libsrt.a 
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${LIBSRT}/src" bench-libsrt.c common.c -o bench-libsrt.exe $${LIBSRT}/src/.libs/libsrt.a 
 	@./bench-libsrt.exe 20
 	@./bench-libsrt.exe 50

@@ -339,6 +350,55 @@ bench-rigtorp-mpmc-queue0:
 	$(CXX) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${RIGTORP_MPMC_QUEUE}" bench-rigtorp-mpmcqueue.cpp common.c -DMULTI_THREAD_MEASURE -o bench-mpmcqueue.exe -lpthread
 	@./bench-mpmcqueue.exe 60

+# CTL shall point to the source directory (not where the headers are)
+bench-ctl:
+	@if test -n "$${CTL}" ; then $(MAKE) bench-ctl0 ; else echo "Nothing to be done for CTL." ; fi
+
+bench-ctl0:
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I $${CTL} bench-ctl.c common.c -o bench-ctl.exe
+	@./bench-ctl.exe 10
+	@./bench-ctl.exe 20
+	@./bench-ctl.exe 30
+	@./bench-ctl.exe 40
+	@./bench-ctl.exe 50
+
+# STC shall point to the source directory (not where the headers are)
+bench-stc:
+	@if test -n "$${STC}" ; then $(MAKE) bench-stc0 ; else echo "Nothing to be done for STC." ; fi
+
+bench-stc0:
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I $${STC}/include bench-stc.c common.c -o bench-stc.exe
+	@./bench-stc.exe 10
+	@./bench-stc.exe 20
+	@./bench-stc.exe 30
+	@./bench-stc.exe 40
+	@./bench-stc.exe 41
+	@./bench-stc.exe 50
+
+# POTTERY shall point to the source directory (not where the headers are)
+bench-pottery:
+	@if test -n "$${POTTERY}" ; then $(MAKE) bench-pottery0 ; else echo "Nothing to be done for POTTERY." ; fi
+
+bench-pottery0:
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -DPOTTERY_AVAILABLE=1 -I $${POTTERY}/include bench-pottery.c common.c -o bench-pottery.exe
+	@./bench-pottery.exe 10
+	@./bench-pottery.exe 20
+	@./bench-pottery.exe 30
+	@./bench-pottery.exe 40
+	@./bench-pottery.exe 41
+	@./bench-pottery.exe 50
+
+# CCLIB shall point to the source directory of CC (where the headers are)
+bench-CC:
+	@if test -n "$${CCLIB}" ; then $(MAKE) bench-CC0 ; else echo "Nothing to be done for CC." ; fi
+
+bench-CC0:
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I $${CCLIB}/ bench-CC.c common.c -o bench-CC.exe
+	@./bench-CC.exe 10
+	@./bench-CC.exe 20
+	@./bench-CC.exe 40
+	@./bench-CC.exe 41
+
 ############################################################################

 bench-mlib-json: bench-mlib
@@ -377,12 +437,12 @@ bench-maxdict:
 ############################################################################

 # BSTRLIB shall point to the BSTRLIB sources
-# LIBSRT shall point to the LIBSRT install directory
+# LIBSRT shall point to the LIBSRT sources
 bench-string:
 	@if test -n "$${BSTRLIB}" ; then $(MAKE) bench-string-step1 BENCH_DEF="-DBENCH_CAN_USE_BSTRLIB -I ${BSTRLIB} $${BSTRLIB}/obj/bstrlib.o $${BSTRLIB}/obj/bstraux.o $${BSTRLIB}/obj/bstrwrap.o" ; else $(MAKE) bench-string-step1 ; fi

 bench-string-step1:
-	@if test -n "$${LIBSRT}" ; then $(MAKE) bench-string-step2 BENCH_DEF="$(BENCH_DEF) -DBENCH_CAN_USE_LIBSRT -I$${LIBSRT}/include/libsrt $${LIBSRT}/lib/libsrt.a" ; else $(MAKE) bench-string-step2 BENCH_DEF="$(BENCH_DEF)"; fi
+	@if test -n "$${LIBSRT}" ; then $(MAKE) bench-string-step2 BENCH_DEF="$(BENCH_DEF) -DBENCH_CAN_USE_LIBSRT -I$${LIBSRT}/src $${LIBSRT}/src/.libs/libsrt.a" ; else $(MAKE) bench-string-step2 BENCH_DEF="$(BENCH_DEF)"; fi

 #NOTE: Need to build by hand sds.o since it is not build by default and sds.c is not compatible with C++
 bench-string-step2:
@@ -392,6 +452,9 @@ bench-string-step4:
 	@if test -n "$${GLIB}" ; then $(MAKE) bench-string-step5 BENCH_DEF="$(BENCH_DEF) -DBENCH_CAN_USE_GLIB $$(pkg-config --cflags --libs glib-2.0)" ; else $(MAKE) bench-string-step5 BENCH_DEF="$(BENCH_DEF)"; fi

 bench-string-step5:
+	@if test -n "$${POTTERY}" ; then $(MAKE) bench-string-step6 BENCH_DEF="$(BENCH_DEF) -DBENCH_CAN_USE_POTTERY -I$${POTTERY}/include -I$${POTTERY}/util/ $${POTTERY}/util/pottery/string/string.c" ; else $(MAKE) bench-string-step6 BENCH_DEF="$(BENCH_DEF)"; fi
+
+bench-string-step6:
 	$(CXX) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -DBENCH_CAN_USE_STL -DBENCH_CAN_USE_MSTARLIB bench-string.cpp common.c $(BENCH_DEF) -o bench-string.exe 
 	$(CXX) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -DBENCH_CAN_USE_STL -DBENCH_CAN_USE_MSTARLIB bench-string-2.cpp common.c $(BENCH_DEF) -o bench-string-2.exe 
 	@./bench-string.exe
@@ -399,6 +462,7 @@ bench-string-step5:
 	@./bench-string-2.exe  2000000 1
 	@./bench-string-2.exe  2000000 2
 	@./bench-string-2.exe  2000000 4
+	@./bench-string-2.exe  2000000 5

 bench-string-pgo:
 	$(MAKE) bench-string XCFLAGS="-fprofile-generate=pgo"
@@ -0,0 +1,140 @@
+#define NDEBUG
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+#include "common.h"
+
+#include "cc.h"
+
+/********************************************************************************************/
+
+static void test_array(size_t n)
+{
+  vec( unsigned int ) a1, a2;
+  init(&a1);
+  init(&a2);
+  
+  for(size_t i = 0; i < n; i++) {
+    push(&a1, rand_get() );
+    push(&a2, rand_get() );
+  }
+  unsigned int s = 0;
+  for(unsigned long i = 0; i < n; i++) {
+    s += *get(&a1, i ) * *get(&a2, i );
+  }
+  g_result = s;
+
+  cleanup(&a1);
+  cleanup(&a2);
+}
+
+/********************************************************************************************/
+
+static void test_list(size_t n)
+{
+  list( unsigned int ) a1, a2;
+  init(&a1);
+  init(&a2);
+  
+  for(size_t i = 0; i < n; i++) {
+    push(&a1, rand_get() );
+    push(&a2, rand_get() );
+  }
+  unsigned int s = 0;
+  for(unsigned *it1 = first( &a1 ), *it2 = first( &a2 ); it1 != end( &a1 ); it1 = next( &a1, it1 ), it2 = next(&a2, it2) ) {
+    s += *it1 * *it2;
+  }
+  g_result = s;
+
+  cleanup(&a1);
+  cleanup(&a2);
+}
+
+/********************************************************************************************/
+
+static void
+test_dict(size_t  n)
+{
+  map( unsigned long, unsigned long ) dict;
+  init(&dict);
+  
+  for (size_t i = 0; i < n; i++) {
+    unsigned long value = rand_get();
+    unsigned long key = rand_get();
+    insert(&dict, key, value);
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    unsigned long key = rand_get();
+    const unsigned long *val = get(&dict, key);
+    if (val != NULL)
+      s += *val;
+  }
+  g_result = s;
+  
+  cleanup(&dict);
+}
+
+/********************************************************************************************/
+typedef struct {
+  char a[256];
+} char_array_t;
+static inline void char_init (char_array_t *a) { a->a[0] = 0; }
+static inline void char_set (char_array_t *a, const char_array_t b) { strcpy(a->a, b.a); }
+static inline bool char_equal_p (const char_array_t *a, const char_array_t *b) { return strcmp(a->a,b->a)==0; }
+static inline bool char_cmp (const char_array_t *a, const char_array_t *b) { return strcmp(a->a,b->a); }
+static inline void char_clear (char_array_t *a) { (void)a; }
+static inline size_t char_hash(const char_array_t *a) {
+  size_t hash = 0;
+  const char *s = a->a;
+  while (*s) hash = hash * 31421 + (*s++) + 6927;
+  return hash;
+}
+#define CC_DTOR char_array_t, { char_clear(&val); }
+#define CC_CMPR char_array_t, { return char_cmp(&val_1, &val_2); }
+#define CC_HASH char_array_t, { return char_hash(&val); }
+#include "cc.h"
+
+static void
+test_dict_big(size_t  n)
+{
+  map( char_array_t, char_array_t) dict;
+  init(&dict);
+  
+  for (size_t i = 0; i < n; i++) {
+    char_array_t s1, s2;
+    sprintf(s1.a, "%u", rand_get());
+    sprintf(s2.a, "%u", rand_get());
+    insert(&dict, s1, s2);
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    char_array_t s1;
+    sprintf(s1.a, "%u", rand_get());
+    const char_array_t *val = get(&dict, s1);
+    if (val != NULL)
+      s ++;
+  }
+  g_result = s;
+  
+  cleanup(&dict);
+}
+
+/********************************************************************************************/
+
+const config_func_t table[] = {
+  { 10,    "List", 10000000, 0, test_list, 0},
+  { 20,   "Array", 100000000, 0, test_array, 0},
+  { 40,    "dict", 1000000, 0, test_dict, 0},
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0},
+};
+
+int main(int argc, const char *argv[])
+{
+  test("CC", numberof(table), table, argc, argv);
+  exit(0);
+}
@@ -0,0 +1,183 @@
+#define NDEBUG
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+#include "m-core.h"
+#include "common.h"
+
+typedef unsigned int uint;
+typedef unsigned long ulong;
+
+/********************************************************************************************/
+#define POD
+#define T uint
+#include "ctl/vector.h"
+
+static void test_array(size_t n)
+{
+  vec_uint a1 = vec_uint_init();
+  vec_uint a2 = vec_uint_init();
+  
+  for(size_t i = 0; i < n; i++) {
+    vec_uint_push_back(&a1, rand_get() );
+    vec_uint_push_back(&a2, rand_get() );
+  }
+  unsigned int s = 0;
+  for(unsigned long i = 0; i < n; i++) {
+    s += *vec_uint_at(&a1, i ) * *vec_uint_at(&a2, i );
+  }
+  g_result = s;
+
+  vec_uint_free(&a1);
+  vec_uint_free(&a2);
+}
+
+/********************************************************************************************/
+
+#define POD
+#define T uint
+#include "ctl/forward_list.h"
+
+static void test_list (size_t n)
+{
+  slist_uint a1 = slist_uint_init();
+  slist_uint a2 = slist_uint_init();
+
+  for(size_t i = 0; i < n; i++) {
+    slist_uint_push_front(&a1, rand_get());
+    slist_uint_push_front(&a2, rand_get());
+  }
+  unsigned int s = 0;
+  slist_uint_it it1 = slist_uint_begin(&a1);
+  slist_uint_it it2 = slist_uint_begin(&a2);
+  for( ; !slist_uint_it_done(&it1) ;
+       slist_uint_it_next(&it1), slist_uint_it_next(&it2)) {
+    s += *slist_uint_it_ref(&it1) * *slist_uint_it_ref(&it2);
+  }
+  g_result = s;
+
+  slist_uint_free(&a1);
+  slist_uint_free(&a2);
+}
+
+/********************************************************************************************/
+
+#define POD
+#define T ulong
+#include "ctl/set.h"
+
+static inline int
+int_cmp(ulong *a, ulong *b) {
+  return *a < *b;
+}
+
+static void test_rbtree(size_t n)
+{
+  set_ulong tree = set_ulong_init (int_cmp);
+  
+  for (size_t i = 0; i < n; i++) {
+    set_ulong_insert (&tree, rand_get() );
+  }
+    
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    unsigned long j = rand_get();
+    if (set_ulong_find_node(&tree, j) != NULL)
+      s+= j;
+  }
+  g_result = s;
+  set_ulong_free(&tree);
+}
+
+/********************************************************************************************/
+
+typedef struct {
+  unsigned long key;
+  unsigned long value;
+} pair_ulong;
+
+// Use of M*LIB hash function
+static inline size_t
+pair_ulong_hash(pair_ulong *a)
+{
+  return M_HASH_DEFAULT(a->key);
+}
+
+static inline int
+pair_ulong_equal(pair_ulong *a, pair_ulong *b)
+{
+  return a->key == b->key;
+}
+
+static inline void
+pair_ulong_free(pair_ulong *a) {
+  (void) a;
+}
+
+static inline pair_ulong
+pair_ulong_copy(pair_ulong *self) {
+  return (pair_ulong) { .key = self->key, .value = self->value };
+}
+
+#define T pair_ulong
+#include <ctl/unordered_map.h>
+
+static void
+test_dict(size_t  n)
+{
+  umap_pair_ulong dict = umap_pair_ulong_init(pair_ulong_hash, pair_ulong_equal);
+  
+  for (size_t i = 0; i < n; i++) {
+    unsigned long value = rand_get();
+    unsigned long key = rand_get();
+    umap_pair_ulong_insert(&dict, (pair_ulong) { key, value });
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    umap_pair_ulong_it it = umap_pair_ulong_find(&dict, (pair_ulong) { rand_get() , 0 } );
+    if (!umap_pair_ulong_it_done(&it) )
+      s += it.ref->value;
+  }
+  g_result = s;
+
+  umap_pair_ulong_free(&dict);
+}
+
+/********************************************************************************************/
+
+#define POD
+#define T float
+#include "ctl/vector.h"
+
+static void test_sort(size_t n)
+{
+  vec_float a1 = vec_float_init();
+
+  for(size_t i = 0; i < n; i++) {
+    vec_float_push_back(&a1, rand_get());
+  }
+  vec_float_sort(&a1);
+  g_result = *vec_float_at(&a1, 0);
+  vec_float_free(&a1);
+}
+
+/********************************************************************************************/
+
+const config_func_t table[] = {
+  { 10,    "List",  10000000, 0, test_list, 0},
+  { 20,   "Array", 100000000, 0, test_array, 0},
+  { 30,  "Rbtree",   1000000, 0, test_rbtree, 0},
+  { 40,    "dict",   1000000, 0, test_dict, 0},
+  { 50,    "Sort",  10000000, 0, test_sort, 0},
+};
+
+int main(int argc, const char *argv[])
+{
+  test("CTL", numberof(table), table, argc, argv);
+  exit(0);
+}
+
@@ -0,0 +1,138 @@
+#define NDEBUG
+
+#include <vector>
+#include <list>
+#include <iterator>
+#include <map>
+#include <set>
+#include <unordered_map>
+#include <algorithm>
+#include <string>
+#include <sstream>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include "hash_table7.hpp"
+
+using namespace emhash7;
+using namespace std;
+
+#include "common.h"
+
+/********************************************************************************************/
+
+static void
+test_dict2(size_t  n)
+{
+  HashMap<unsigned long, unsigned long> dict;
+  for (size_t i = 0; i < n; i++) {
+    dict[rand_get()] = rand_get();
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    HashMap<unsigned long, unsigned long>::iterator it = dict.find(rand_get());
+    if (it != dict.end())
+      s += it->second;
+  }
+  g_result = s;
+}
+
+static void
+test_dict2_linear(size_t  n)
+{
+  HashMap<unsigned long, unsigned long> dict;
+  for (size_t i = 0; i < n; i++) {
+    dict[i] = rand_get();
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    HashMap<unsigned long, unsigned long>::iterator it = dict.find(i);
+    if (it != dict.end())
+      s += it->second;
+  }
+  g_result = s;
+}
+
+/********************************************************************************************/
+struct char_array_s {
+  char a[256];
+  char_array_s () { a[0] = 0 ; }
+  char_array_s ( const char_array_s & other) { strcpy(a, other.a); }
+  bool operator==(const char_array_s &other) const { return strcmp(a, other.a) == 0; }
+};
+
+namespace std {
+  template <> struct hash<char_array_s> {
+    std::size_t operator()(const char_array_s &k) const {
+      size_t hash = 0;
+      const char *s = k.a;
+      while (*s) hash = hash * 31421 + (*s++) + 6927;
+      return hash;
+    };
+  };
+}
+
+static void
+test_dict_big(size_t  n)
+{
+  HashMap<char_array_s, char_array_s> dict;
+
+  for (size_t i = 0; i < n; i++) {
+    char_array_s s1, s2;
+    sprintf(s1.a, "%u", rand_get());
+    sprintf(s2.a, "%u", rand_get());
+    dict[s1] = s2;
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    char_array_s s1;
+    sprintf(s1.a, "%u", rand_get());
+    HashMap<char_array_s, char_array_s>::iterator it = dict.find(s1);
+    if (it != dict.end())
+      s ++;
+  }
+  g_result = s;
+}
+
+/********************************************************************************************/
+static void
+test_dict_str(size_t  n)
+{
+  HashMap<string, string> dict;
+
+  for (size_t i = 0; i < n; i++) {
+    string s1 = static_cast<ostringstream*>( &(ostringstream() << rand_get()) )->str();
+    string s2 = static_cast<ostringstream*>( &(ostringstream() << rand_get()) )->str();
+    dict[s1] = s2;
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    string s1 = static_cast<ostringstream*>( &(ostringstream() << rand_get()) )->str();
+    HashMap<string, string>::iterator it = dict.find(s1);
+    if (it != dict.end())
+      s ++;
+  }
+  g_result = s;
+}
+
+/********************************************************************************************/
+
+const config_func_t table[] = {
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0},
+  { 42,"dict", 1000000, 0, test_dict2, 0},
+  { 43,    "DictStr", 1000000, 0, test_dict_str, 0},
+  { 46,    "DictLinear", 1000000, 0, test_dict2_linear, 0}
+};
+
+int main(int argc, const char *argv[])
+{
+  test("EMHASH", numberof(table), table, argc, argv);
+  exit(0);
+}
@@ -14,7 +14,7 @@
 #include "m-mempool.h"
 #include "m-string.h"
 #include "m-buffer.h"
-#include "m-mutex.h"
+#include "m-thread.h"
 #include "m-deque.h"
 #include "m-concurrent.h"
 #include "m-tuple.h"
@@ -55,12 +55,8 @@ static void test_deque(size_t n)
    }
    unsigned int s = 0;
    deque_uint_it_t it1, it2;
-    deque_uint_it(it1, a1);
-    deque_uint_it(it2, a2);
-    while (!deque_uint_end_p(it1)) {
+    for(deque_uint_it(it1, a1), deque_uint_it(it2, a2) ; !deque_uint_end_p(it1) ; deque_uint_next(it1), deque_uint_next(it2)) {
      s += *deque_uint_cref(it1 ) * *deque_uint_cref(it2 );
-      deque_uint_next(it1);
-      deque_uint_next(it2);
    }
    g_result = s;
  }
@@ -876,8 +872,8 @@ bench_vector_string_init(size_t n)
 {
    vector_string_init(vstring);
    for(size_t i = 0; i < n; i++)
-    {
-        M_LET( (s, "%zu", i, i, i, i), string_t) {
+      {
+        M_LET( (s, "%zu", i), string_t) {
            vector_string_push_back(vstring, s);
        }
    }
@@ -901,8 +897,8 @@ static void
 bench_vector_string_bin_run(size_t n)
 {
    if (vector_string_size(vstring) != n) {
-        printf("Size are different!\n");
-        abort();
+      fprintf(stderr, "ERROR: Size are different (%zu vs %zu)!\n", n, vector_string_size(vstring));
+      abort();
    }

    FILE *f = fopen("tmp-serial.dat", "wb");
@@ -920,8 +916,8 @@ bench_vector_string_bin_run(size_t n)
    fclose(f);

    if (vector_string_size(vstring2) != n) {
-        printf("Size are different!\n");
-        abort();
+      fprintf(stderr, "ERROR: Size are different (%zu vs %zu)!\n", n, vector_string_size(vstring2));
+      abort();
    }
 }

@@ -929,8 +925,8 @@ static void
 bench_vector_string_json_run(size_t n)
 {
    if (vector_string_size(vstring) != n) {
-        printf("Size are different!\n");
-        abort();
+      fprintf(stderr, "ERROR: Size are different (%zu vs %zu)!\n", n, vector_string_size(vstring));
+      abort();
    }

    FILE *f = fopen("tmp-serial.json", "wt");
@@ -948,8 +944,8 @@ bench_vector_string_json_run(size_t n)
    fclose(f);

    if (vector_string_size(vstring2) != n) {
-        printf("Size are different!\n");
-        abort();
+      fprintf(stderr, "ERROR: Size are different (%zu vs %zu)!\n", n, vector_string_size(vstring2));
+      abort();
    }
 }

@@ -957,8 +953,8 @@ static void
 bench_vector_string_clear(void)
 {
    if (!vector_string_equal_p(vstring, vstring2)) {
-        printf("Array are different!\n");
-        abort();
+      fprintf(stderr, "ERROR: Array are different after deserialization!\n");
+      abort();
    }
    vector_string_clear(vstring);
    vector_string_clear(vstring2);
@@ -986,8 +982,8 @@ static void
 bench_vector_ulong_bin_run(size_t n)
 {
    if (vector_ulong_size(vulong) != n) {
-        printf("Size are different!\n");
-        abort();
+      fprintf(stderr, "ERROR: Size are different!\n");
+      abort();
    }

    FILE *f = fopen("tmp-serial.dat", "wb");
@@ -1005,8 +1001,8 @@ bench_vector_ulong_bin_run(size_t n)
    fclose(f);

    if (vector_ulong_size(vulong2) != n) {
-        printf("Size are different!\n");
-        abort();
+      fprintf(stderr, "ERROR: Size are different!\n");
+      abort();
    }
 }

@@ -1014,8 +1010,8 @@ static void
 bench_vector_ulong_json_run(size_t n)
 {
    if (vector_ulong_size(vulong) != n) {
-        printf("Size are different!\n");
-        abort();
+      fprintf(stderr, "ERROR: Size are different!\n");
+      abort();
    }

    FILE *f = fopen("tmp-serial.json", "wt");
@@ -1033,8 +1029,8 @@ bench_vector_ulong_json_run(size_t n)
    fclose(f);

    if (vector_ulong_size(vulong2) != n) {
-        printf("Size are different!\n");
-        abort();
+      fprintf(stderr, "ERROR: Size are different!\n");
+      abort();
    }
 }

@@ -1042,8 +1038,8 @@ static void
 bench_vector_ulong_clear(void)
 {
    if (!vector_ulong_equal_p(vulong, vulong2)) {
-        printf("Array are different!\n");
-        abort();
+      fprintf(stderr, "ERROR: Array are different after deserialization!\n");
+      abort();
    }
    vector_ulong_clear(vulong);
    vector_ulong_clear(vulong2);
@@ -1085,6 +1081,6 @@ const config_func_t table[] = {

 int main(int argc, const char *argv[])
 {
-  test("M-LIB", numberof(table), table, argc, argv);
+  test("M*LIB", numberof(table), table, argc, argv);
  exit(0);
 }
@@ -32,7 +32,7 @@ struct Pixel
  unsigned char r, g, b;
 };

-ARRAY_DEF(array_pixel, struct Pixel, (INIT(M_NOTHING_DEFAULT)) )
+ARRAY_DEF(array_pixel, struct Pixel, (INIT(M_NOTHING_DEFAULT), INIT_SET(M_MEMCPY_DEFAULT) ))

 void UseMlib(void)
 {
@@ -0,0 +1,269 @@
+#define NDEBUG
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+#include "common.h"
+
+/********************************************************************************************/
+
+#define POTTERY_VECTOR_PREFIX vec_uint
+#define POTTERY_VECTOR_VALUE_TYPE unsigned int
+#define POTTERY_VECTOR_LIFECYCLE_BY_VALUE 1
+#include "pottery/vector/pottery_vector_static.t.h"
+
+static void test_array(size_t n)
+{
+  vec_uint_t a1, a2;
+
+  vec_uint_init(&a1);
+  vec_uint_init(&a2);
+  
+  for(size_t i = 0; i < n; i++) {
+    vec_uint_insert_last(&a1, rand_get() );
+    vec_uint_insert_last(&a2, rand_get() );
+  }
+  unsigned int s = 0;
+  for(unsigned long i = 0; i < n; i++) {
+    s += *vec_uint_at(&a1, i ) * *vec_uint_at(&a2, i );
+  }
+  g_result = s;
+
+  vec_uint_destroy(&a1);
+  vec_uint_destroy(&a2);
+}
+
+/********************************************************************************************/
+
+typedef struct foo_s {
+  struct foo_s* next;
+  struct foo_s* previous;
+  int data;
+} foo_t;
+
+#define POTTERY_DOUBLY_LINKED_LIST_PREFIX foo_list
+#define POTTERY_DOUBLY_LINKED_LIST_VALUE_TYPE foo_t
+#include "pottery/doubly_linked_list/pottery_doubly_linked_list_static.t.h"
+
+static void test_list(size_t n)
+{
+  foo_list_t a1, a2;
+  foo_list_init(&a1);
+  foo_list_init(&a2);
+  for(size_t i = 0; i < n; i++) {
+    foo_t *tmp = malloc(sizeof (foo_t));
+    if (tmp == NULL) abort();
+    tmp->data = rand_get();
+    foo_list_link_last(&a1, tmp);
+
+    tmp = malloc(sizeof (foo_t));
+    if (tmp == NULL) abort();
+    tmp->data = rand_get();
+    foo_list_link_last(&a2, tmp);
+  }
+  unsigned int s = 0;
+  for(foo_t *it1 = foo_list_first(&a1), *it2 = foo_list_first(&a2) ;
+      foo_list_entry_exists(&a1, it1) ;
+      it1 = foo_list_next(&a1, it1), it2 = foo_list_next(&a2, it2)) {
+    s += it1->data * it2->data;
+  }
+  g_result = s;
+
+  for(foo_t *it1 = foo_list_first(&a1);
+      foo_list_entry_exists(&a1, it1) ;
+      ) {
+    foo_t *tmp = it1;
+    it1 = foo_list_next(&a1, it1);
+    free(tmp);
+  }
+
+  for(foo_t *it1 = foo_list_first(&a2);
+      foo_list_entry_exists(&a2, it1) ;
+      ) {
+    foo_t *tmp = it1;
+    it1 = foo_list_next(&a2, it1);
+    free(tmp);
+  }
+
+}
+
+/********************************************************************************************/
+
+// ERROR: it returns the wrong result.
+#define POTTERY_TREE_MAP_PREFIX set_ulong
+#define POTTERY_TREE_MAP_VALUE_TYPE unsigned long
+#define POTTERY_TREE_MAP_LIFECYCLE_MOVE_BY_VALUE 1
+#define POTTERY_TREE_MAP_COMPARE_THREE_WAY(a,b) ((a) < (b) ? -1 : (a) > (b))
+#define POTTERY_TREE_MAP_LIFECYCLE_DESTROY(a) (void) a
+#include "pottery/tree_map/pottery_tree_map_static.t.h"
+
+static void test_rbtree(size_t n)
+{
+  set_ulong_t tree;
+  set_ulong_init(&tree);
+  
+  for (size_t i = 0; i < n; i++) {
+    set_ulong_insert(&tree, rand_get() );
+  }
+    
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    unsigned long j = rand_get();
+    if (set_ulong_find(&tree, &j ) != NULL)
+      s += j;
+  }
+  g_result = s;
+  set_ulong_destroy(&tree);
+}
+
+
+/********************************************************************************************/
+
+#include "m-core.h"  // For M_HASH_DEFAULT
+typedef struct bar_s {
+  unsigned long key;
+  unsigned long value;
+} bar_t;
+
+#define POTTERY_OPEN_HASH_MAP_PREFIX map_ulong
+
+#define POTTERY_OPEN_HASH_MAP_VALUE_TYPE bar_t
+#define POTTERY_OPEN_HASH_MAP_KEY_TYPE unsigned long
+#define POTTERY_OPEN_HASH_MAP_REF_KEY(v) v->key
+#define POTTERY_OPEN_HASH_MAP_KEY_HASH(x) M_HASH_DEFAULT(x)
+#define POTTERY_OPEN_HASH_MAP_KEY_EQUAL(x, y) x == y
+#define POTTERY_OPEN_HASH_MAP_LIFECYCLE_MOVE(p,q) memcpy(p, q, sizeof (bar_t))
+
+#include "pottery/open_hash_map/pottery_open_hash_map_static.t.h"
+
+static void
+test_dict(size_t  n)
+{
+  map_ulong_t dict;
+  map_ulong_init(&dict);
+  
+  for (size_t i = 0; i < n; i++) {
+    unsigned long value = rand_get();
+    unsigned long key = rand_get();
+    bar_t * kyle = pottery_null;
+    map_ulong_emplace_key(&dict, key, &kyle, pottery_null);
+    kyle->key = key;
+    kyle->value = value;
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    bar_t *kyle = map_ulong_find(&dict, rand_get());
+    if (kyle != NULL)
+      s += kyle->value;
+  }
+  g_result = s;
+  
+  map_ulong_destroy(&dict);
+}
+
+/********************************************************************************************/
+
+typedef struct {
+  char a[256];
+} char_array_t;
+static inline void char_init (char_array_t *a) { a->a[0] = 0; }
+static inline void char_set (char_array_t *a, const char_array_t b) { strcpy(a->a, b.a); }
+static inline bool char_equal_p (const char_array_t a, const char_array_t b) { return strcmp(a.a,b.a)==0; }
+static inline void char_clear (char_array_t *a) { (void)a; }
+static inline size_t char_hash(const char_array_t *a) {
+  size_t hash = 0;
+  const char *s = a->a;
+  while (*s) hash = hash * 31421 + (*s++) + 6927;
+  return hash;
+}
+
+typedef struct bars_s {
+  char_array_t key;
+  char_array_t value;
+} bars_t;
+
+#define POTTERY_OPEN_HASH_MAP_PREFIX map_achar
+
+#define POTTERY_OPEN_HASH_MAP_VALUE_TYPE bars_t
+#define POTTERY_OPEN_HASH_MAP_KEY_TYPE char_array_t
+#define POTTERY_OPEN_HASH_MAP_REF_KEY(v) v->key
+#define POTTERY_OPEN_HASH_MAP_KEY_HASH(x) char_hash(&x)
+#define POTTERY_OPEN_HASH_MAP_KEY_EQUAL(x, y) char_equal_p(x, y)
+#define POTTERY_OPEN_HASH_MAP_LIFECYCLE_MOVE(p,q) memcpy(p, q, sizeof (bars_t))
+
+#include "pottery/open_hash_map/pottery_open_hash_map_static.t.h"
+
+static void
+test_dict_big(size_t  n)
+{
+  map_achar_t dict;
+  map_achar_init(&dict);
+
+  for (size_t i = 0; i < n; i++) {
+    char_array_t s1, s2;
+    sprintf(s1.a, "%u", rand_get());
+    sprintf(s2.a, "%u", rand_get());
+    bars_t * kyle = pottery_null;
+    map_achar_emplace_key(&dict, s1, &kyle, pottery_null);
+    char_set(&kyle->key, s1);
+    char_set(&kyle->value, s2);
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    char_array_t s1;
+    sprintf(s1.a, "%u", rand_get());
+    bars_t *kyle = map_achar_find(&dict, s1);
+    if (kyle != NULL)
+      s ++;
+  }
+  g_result = s;
+
+  map_achar_destroy(&dict);
+}
+
+/********************************************************************************************/
+
+#define POTTERY_VECTOR_PREFIX vec_float
+#define POTTERY_VECTOR_VALUE_TYPE float
+#define POTTERY_VECTOR_LIFECYCLE_BY_VALUE 1
+#include "pottery/vector/pottery_vector_static.t.h"
+
+#define POTTERY_INTRO_SORT_PREFIX sort_float
+#define POTTERY_INTRO_SORT_VALUE_TYPE float
+#define POTTERY_INTRO_SORT_LIFECYCLE_MOVE_BY_VALUE 1
+#define POTTERY_INTRO_SORT_COMPARE_THREE_WAY(x, y) ( *x < *y ? -1 : *x > *y)
+#include "pottery/intro_sort/pottery_intro_sort_static.t.h"
+
+static void test_sort(size_t n)
+{
+  vec_float_t a1;
+  vec_float_init(&a1);
+
+  for(size_t i = 0; i < n; i++) {
+    vec_float_insert_last(&a1, rand_get() );
+  }
+  sort_float(vec_float_at(&a1, 0), n);
+  g_result = *vec_float_at(&a1, 0);
+  vec_float_destroy(&a1);
+}
+
+/********************************************************************************************/
+
+const config_func_t table[] = {
+  { 10,    "List", 10000000, 0, test_list, 0},
+  { 20,   "Array", 100000000, 0, test_array, 0},
+  { 30,  "Rbtree", 1000000, 0, test_rbtree, 0},
+  { 40,    "dict", 1000000, 0, test_dict, 0},
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0},
+  { 50,    "Sort",10000000, 0, test_sort, 0},
+};
+
+int main(int argc, const char *argv[])
+{
+  test("POTTERY", numberof(table), table, argc, argv);
+  exit(0);
+}
@@ -0,0 +1,193 @@
+#define NDEBUG
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+#include "common.h"
+
+/********************************************************************************************/
+
+#define i_val unsigned int
+#define i_tag uint
+#include <stc/cvec.h>
+
+static void test_array(size_t n)
+{
+  cvec_uint a1 = cvec_uint_init(), a2 = cvec_uint_init();
+  
+  for(size_t i = 0; i < n; i++) {
+    cvec_uint_push_back(&a1, rand_get() );
+    cvec_uint_push_back(&a2, rand_get() );
+  }
+  unsigned int s = 0;
+  for(unsigned long i = 0; i < n; i++) {
+    s += *cvec_uint_at(&a1, i ) * *cvec_uint_at(&a2, i );
+  }
+  g_result = s;
+
+  cvec_uint_drop(&a1);
+  cvec_uint_drop(&a2);
+}
+
+/********************************************************************************************/
+#define i_val unsigned int
+#define i_tag uint
+#include <stc/clist.h>
+
+static void test_list(size_t n)
+{
+  clist_uint a1 = clist_uint_init(), a2 = clist_uint_init();
+  
+  for(size_t i = 0; i < n; i++) {
+    clist_uint_push_front(&a1, rand_get() );
+    clist_uint_push_front(&a2, rand_get() );
+  }
+  unsigned int s = 0;
+  for(clist_uint_iter it1 = clist_uint_begin(&a1), it2 = clist_uint_begin(&a2) ;
+      it1.ref != clist_uint_end(&a1).ref ;
+      clist_uint_next(&it1), clist_uint_next(&it2) ) {
+    s += *it1.ref * *it2.ref;
+  }
+  g_result = s;
+
+  clist_uint_drop(&a1);
+  clist_uint_drop(&a2);
+}
+
+/********************************************************************************************/
+
+#define i_tag ulong
+#define i_key unsigned long
+#include <stc/csset.h>
+
+static void test_rbtree(size_t n)
+{
+  csset_ulong tree = csset_ulong_init();
+  
+  for (size_t i = 0; i < n; i++) {
+    csset_ulong_insert(&tree, rand_get() );
+  }
+    
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    unsigned long j = rand_get();
+    if (csset_ulong_get(&tree, j ) != NULL)
+      s+= j;
+  }
+  g_result = s;
+  csset_ulong_drop(&tree);
+}
+
+/********************************************************************************************/
+
+#define i_tag ulong
+#define i_key unsigned long
+#define i_val unsigned long
+#include <stc/cmap.h>
+
+static void
+test_dict(size_t  n)
+{
+  cmap_ulong dict = cmap_ulong_init();
+  
+  for (size_t i = 0; i < n; i++) {
+    unsigned long value = rand_get();
+    unsigned long key = rand_get();
+    cmap_ulong_insert_or_assign(&dict, key, value);
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    const cmap_ulong_value*val = cmap_ulong_get(&dict, rand_get());
+    if (val != NULL)
+      s += val->second;
+  }
+  g_result = s;
+  
+  cmap_ulong_drop(&dict);
+}
+
+/********************************************************************************************/
+
+typedef struct {
+  char a[256];
+} char_array_t;
+static inline void char_init (char_array_t *a) { a->a[0] = 0; }
+static inline void char_set (char_array_t *a, const char_array_t b) { strcpy(a->a, b.a); }
+static inline bool char_equal_p (const char_array_t *a, const char_array_t *b) { return strcmp(a->a,b->a)==0; }
+static inline void char_clear (char_array_t *a) { (void)a; }
+static inline size_t char_hash(const char_array_t *a) {
+  size_t hash = 0;
+  const char *s = a->a;
+  while (*s) hash = hash * 31421 + (*s++) + 6927;
+  return hash;
+}
+
+#define i_tag       achar
+#define i_key       char_array_t
+#define i_val       char_array_t
+#define i_hash      char_hash
+#define i_eq        char_equal_p
+#include <stc/cmap.h>
+
+static void
+test_dict_big(size_t  n)
+{
+  cmap_achar dict = cmap_achar_init();
+
+  for (size_t i = 0; i < n; i++) {
+    char_array_t s1, s2;
+    sprintf(s1.a, "%u", rand_get());
+    sprintf(s2.a, "%u", rand_get());
+    cmap_achar_insert_or_assign(&dict, s1, s2);
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    char_array_t s1;
+    sprintf(s1.a, "%u", rand_get());
+    const cmap_achar_value*val = cmap_achar_get(&dict, s1);
+    if (val != NULL)
+      s ++;
+  }
+  g_result = s;
+
+  cmap_achar_drop(&dict);
+}
+
+/********************************************************************************************/
+
+#define i_val float
+#define i_tag float
+#include <stc/cvec.h>
+
+static void test_sort(size_t n)
+{
+  cvec_float a1 = cvec_float_init();
+
+  for(size_t i = 0; i < n; i++) {
+    cvec_float_push_back(&a1, rand_get() );
+  }
+  cvec_float_sort(&a1);
+  g_result = *cvec_float_at(&a1, 0);
+  cvec_float_drop(&a1);
+}
+
+/********************************************************************************************/
+
+const config_func_t table[] = {
+  { 10,    "List", 10000000, 0, test_list, 0},
+  { 20,   "Array", 100000000, 0, test_array, 0},
+  { 30,  "Rbtree", 1000000, 0, test_rbtree, 0},
+  { 40,    "dict", 1000000, 0, test_dict, 0},
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0},
+  { 50,    "Sort",10000000, 0, test_sort, 0},
+};
+
+int main(int argc, const char *argv[])
+{
+  test("STC", numberof(table), table, argc, argv);
+  exit(0);
+}
@@ -1,7 +1,7 @@
 /*
 * M*LIB - String Bench
 *
- * Copyright (c) 2017-2021, Patrick Pelissier
+ * Copyright (c) 2017-2023, Patrick Pelissier
 * All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
@@ -22,11 +22,14 @@
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
+#define NDEBUG
+
 #include <string>
 #include <sstream>
 #include <string>
 #include <vector>

+#define M_USE_SMALL_NAME 0
 #include "common.h"

 #include "m-string.h"
@@ -43,6 +46,10 @@ extern "C" {
 #include "bstraux.h"
 #endif

+#if defined(BENCH_CAN_USE_POTTERY)
+#include "pottery/string/string.h"
+#endif
+
 /*
 * BENCH
 * 2000000
@@ -104,27 +111,28 @@ size_t bench_stl(unsigned n)

 size_t bench_mlib(unsigned n)
 {
-  string_t *tab = (string_t*) malloc (n * sizeof (string_t));
+  m_string_t *tab = (m_string_t*) malloc (n * sizeof (m_string_t));
  assert (tab != 0);
  // P1
  for(unsigned i = 0; i < n; i++) {
-    string_init(tab[i]);
-    string_printf(tab[i], "%u", rand_get());
+    m_string_init(tab[i]);
+    m_string_set_ui(tab[i], rand_get());
  }
  // P2
-  string_t str;
-  string_init(str);
+  m_string_t str;
+  m_string_init(str);
  for(unsigned i = 0; i < n; i++) {
-    string_cat(str, tab[permutation_tab[i]]);
+    m_string_cat(str, tab[permutation_tab[i]]);
  }
  // P3
-  string_replace_all_str(str, "1234", "WELL");
-  string_replace_all_str(str, "56789", "DONE");
-  size_t length = string_size(str);
+  m_string_replace_all_cstr(str, "1234", "WELL");
+  m_string_replace_all_cstr(str, "56789", "DONE");
+  size_t length = m_string_size(str);
+
  // Clean
-  string_clear(str);
+  m_string_clear(str);
  for(unsigned i = 0; i < n; i++) {
-    string_clear(tab[i]);
+    m_string_clear(tab[i]);
  }
  free(tab);
  return length;
@@ -217,6 +225,57 @@ size_t bench_sds(unsigned n)
 }
 #endif

+#if defined(BENCH_CAN_USE_POTTERY)
+
+size_t pottery_find_cstr(string_t *b, size_t index, const char *pattern)
+{
+  // I cannot find such function in the API
+  const char *s = string_cstr(b);
+  const char *r = strstr(&s[index], pattern);
+  return r == NULL ? SIZE_MAX : r - s;
+}
+
+void pottery_replace_all_str(string_t *str, const char *s, const char *d)
+{
+  size_t i = 0;
+  while (true) {
+    i = pottery_find_cstr(str, i, s);
+    if (i==SIZE_MAX) return;
+    string_remove(str, i, strlen(s));
+    string_insert_cstr(str, i, d);
+  }
+}
+
+size_t bench_pottery(unsigned n)
+{
+  string_t *tab = (string_t*) malloc (n * sizeof (string_t));
+  assert (tab != 0);
+  // P1
+  for(unsigned i = 0; i < n; i++) {
+    string_init(&tab[i]);
+    string_append_format(&tab[i], "%u", rand_get());
+  }
+  // P2
+  string_t str;
+  string_init(&str);
+  for(unsigned i = 0; i < n; i++) {
+    string_append_string(&str, &tab[permutation_tab[i]]);
+  }
+  // P3
+  
+  pottery_replace_all_str(&str, "1234", "WELL");
+  pottery_replace_all_str(&str, "56789", "DONE");
+  size_t length = string_length(&str);
+
+  // Clean
+  string_clear(&str);
+  for(unsigned i = 0; i < n; i++) {
+    string_clear(&tab[i]);
+  }
+  free(tab);
+  return length;
+}
+#endif

 int main(int argc, const char *argv[])
 {
@@ -247,6 +306,12 @@ int main(int argc, const char *argv[])
    length = bench_bstrlib(n);
    name = "BSTRLIB";
    break;
+#endif
+#if defined(BENCH_CAN_USE_POTTERY)
+  case 5:
+    length = bench_pottery(n);
+    name = "POTTERY";
+    break;
 #endif
  default:
    exit(0);
@@ -35,8 +35,8 @@
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

-/* Update of integrating M*LIB, LIBSRT, SDS & GLIB
-   Copyright (c) 2018-2021 Patrick Pelissier
+/* Update of integrating M*LIB, LIBSRT, SDS, GLIB & POTTERY
+   Copyright (c) 2018-2023 Patrick Pelissier
 */

 /*
@@ -48,11 +48,13 @@
 *
 */

+#define NDEBUG
+
 #include <stdio.h>
 #include <time.h>
 #include <limits.h>

-#define NDEBUG
+#define M_USE_SMALL_NAME 0
 #include "common.h"

 #ifdef BENCH_CAN_USE_MSTARLIB
@@ -83,6 +85,10 @@ extern "C" {
 #include "gmodule.h"
 #endif

+#if defined(BENCH_CAN_USE_POTTERY)
+#include "pottery/string/string.h"
+#endif
+
 /* Time of a test */
 #define TEST_SECONDS (5)

@@ -433,11 +439,11 @@ int testSRT_concat (int count) {
 int testMLIB_emptyCtor (int count) {
  int i, c = 0;
  for (c=i=0; i < count; i++) {
-    string_t b;
-    string_init(b);
+    m_string_t b;
+    m_string_init(b);
    BARRIER(&b);
-    c += string_size(b) ^i;
-    string_clear(b);
+    c += m_string_size(b) ^i;
+    m_string_clear(b);
  }
  return c;
 }
@@ -445,11 +451,11 @@ int testMLIB_emptyCtor (int count) {
 int testMLIB_nonemptyCtor (int count) {
  int i, c = 0;
  for (c=i=0; i < count; i++) {
-    string_t b;
-    string_init_set_str(b, TESTSTRING1);
+    m_string_t b;
+    m_string_init_set_cstr(b, TESTSTRING1);
    BARRIER(&b);
-    c += string_size(b) ^i;
-    string_clear(b);
+    c += m_string_size(b) ^i;
+    m_string_clear(b);
  }
  return c;
 }
@@ -457,93 +463,93 @@ int testMLIB_nonemptyCtor (int count) {
 int testMLIB_smallnonemptyCtor (int count) {
  int i, c = 0;
  for (c=i=0; i < count; i++) {
-    string_t b;
-    string_init_set_str(b, SMALLTESTSTRING1);
+    m_string_t b;
+    m_string_init_set_cstr(b, SMALLTESTSTRING1);
    BARRIER(&b);
-    c += string_size(b) ^i;
-    string_clear(b);
+    c += m_string_size(b) ^i;
+    m_string_clear(b);
  }
  return c;
 }

 int testMLIB_cstrAssignment (int count) {
  int i, c = 0;
-  string_t b;
-  string_init(b);
+  m_string_t b;
+  m_string_init(b);
  for (c=i=0; i < count; i++) {
-    string_set_str(b, TESTSTRING1);
+    m_string_set_cstr(b, TESTSTRING1);
    BARRIER(&b);
-    c += string_size(b) ^i;
+    c += m_string_size(b) ^i;
  }
-  string_clear(b);
+  m_string_clear(b);
  return c;
 }

 int testMLIB_extraction (int count) {
  int i, c = 0;

-  string_t b;
-  string_init_set_str(b, TESTSTRING1);
+  m_string_t b;
+  m_string_init_set_cstr(b, TESTSTRING1);
  
  for (c=i=0; i < count; i++) {
-    c += string_get_char(b, (i & 7));
-    c += string_get_char(b, (i & 7) ^ 8);
-    c += string_get_char(b, (i & 7) ^ 4) ^i;
+    c += m_string_get_char(b, (i & 7));
+    c += m_string_get_char(b, (i & 7) ^ 8);
+    c += m_string_get_char(b, (i & 7) ^ 4) ^i;
    BARRIER(&b);
  }
-  string_clear(b);
+  m_string_clear(b);
  return c;
 }

 int testMLIB_scan (int count) {
  int i, c = 0;
-  string_t b;
-  string_init_set_str(b, "Dot. 123. Some more data.");
+  m_string_t b;
+  m_string_init_set_cstr(b, "Dot. 123. Some more data.");

  for (c=i=0; i < count; i++) {
-    c += string_search_char (b, '.');
-    c += string_search_str (b, "123");
-    c += string_search_pbrk (b, "sm") ^i;
+    c += m_string_search_char (b, '.');
+    c += m_string_search_cstr (b, "123");
+    c += m_string_search_pbrk (b, "sm") ^i;
    BARRIER(&b);
  }
-  string_clear(b);
+  m_string_clear(b);
  return c;
 }

 int testMLIB_concat (int count) {
  int i, j, c = 0;
-  string_t a, accum;
-  string_init_set_str(a, TESTSTRING1);
-  string_init (accum);
+  m_string_t a, accum;
+  m_string_init_set_cstr(a, TESTSTRING1);
+  m_string_init (accum);

  for (j=0; j < count; j++) {
-    string_set_str(accum, "");
+    m_string_set_cstr(accum, "");
    for (i=0; i < 250; i++) {
-      string_cat(accum, a);
-      string_cat_str(accum, "!!");
+      m_string_cat(accum, a);
+      m_string_cat_cstr(accum, "!!");
      BARRIER(&accum);
-      c += string_size(accum) ^i;
+      c += m_string_size(accum) ^i;
    }
  }
-  string_clear(a);
-  string_clear(accum);
+  m_string_clear(a);
+  m_string_clear(accum);
  return c;
 }

 int testMLIB_replace (int count) {
  int j, c = 0;
-  string_t a;
-  string_init_set_str(a, TESTSTRING1);
+  m_string_t a;
+  m_string_init_set_cstr(a, TESTSTRING1);
  
  for (j=0; j < count; j++) {
-    string_replace_at(a, 11, 4, "XXXXXX");
-    string_replace_at(a, 23, 2, "XXXXXX");
-    string_replace_at(a, 4, 8, "XX");
+    m_string_replace_at(a, 11, 4, "XXXXXX");
+    m_string_replace_at(a, 23, 2, "XXXXXX");
+    m_string_replace_at(a, 4, 8, "XX");
    BARRIER(&a);
-    c += string_size(a) ^j;
+    c += m_string_size(a) ^j;
  }
  
-  string_clear(a);
+  m_string_clear(a);
  return c;
 }
 #endif
@@ -774,6 +780,118 @@ int testGLIB_concat (int count) {
 //int testGLIB_replace (int count): not available
 #endif

+#ifdef BENCH_CAN_USE_POTTERY
+int testPOTTERY_emptyCtor (int count) {
+  int i, c = 0;
+  for (c=i=0; i < count; i++) {
+    string_t b;
+    string_init(&b);
+    BARRIER(&b);
+    c += string_length(&b) ^i;
+    string_clear(&b);
+  }
+  return c;
+}
+
+int testPOTTERY_nonemptyCtor (int count) {
+  int i, c = 0;
+  for (c=i=0; i < count; i++) {
+    string_t b;
+    string_init_cstr(&b, TESTSTRING1);
+    BARRIER(&b);
+    c += string_length(&b) ^i;
+    string_clear(&b);
+  }
+  return c;
+}
+
+int testPOTTERY_smallnonemptyCtor (int count) {
+  int i, c = 0;
+  for (c=i=0; i < count; i++) {
+    string_t b;
+    string_init_cstr(&b, SMALLTESTSTRING1);
+    BARRIER(&b);
+    c += string_length(&b) ^i;
+    string_clear(&b);
+  }
+  return c;
+}
+
+int testPOTTERY_cstrAssignment (int count) {
+  int i, c = 0;
+  string_t b;
+  string_init(&b);
+  for (c=i=0; i < count; i++) {
+    string_set_cstr(&b, TESTSTRING1);
+    BARRIER(&b);
+    c += string_length(&b) ^i;
+  }
+  string_clear(&b);
+  return c;
+}
+
+int testPOTTERY_extraction (int count) {
+  int i, c = 0;
+
+  string_t b;
+  string_init_cstr(&b, TESTSTRING1);
+  
+  for (c=i=0; i < count; i++) {
+    c += string_cstr(&b)[(i & 7)];
+    c += string_cstr(&b)[(i & 7) ^ 8];
+    c += string_cstr(&b)[(i & 7) ^ 4] ^i;
+    BARRIER(&b);
+  }
+  string_clear(&b);
+  return c;
+}
+
+size_t pottery_find_cstr(string_t *b, const char *pattern)
+{
+  // I cannot find such function in the API
+  const char *s = string_cstr(b);
+  const char *r = strstr(s, pattern);
+  return r == NULL ? SIZE_MAX : r - s;
+}
+
+int testPOTTERY_scan (int count) {
+  int i, c = 0;
+  string_t b;
+  string_init_cstr(&b, "Dot. 123. Some more data.");
+
+  for (c=i=0; i < count; i++) {
+    c += string_find_char (&b, 0, '.');
+    c += pottery_find_cstr (&b, "123");
+    c += string_find_chars_cstr (&b, 0, "sm") ^i;
+    BARRIER(&b);
+  }
+  string_clear(&b);
+  return c;
+}
+
+int testPOTTERY_concat (int count) {
+  int i, j, c = 0;
+  string_t a, accum;
+  string_init_cstr(&a, TESTSTRING1);
+  string_init (&accum);
+
+  for (j=0; j < count; j++) {
+    string_set_cstr(&accum, "");
+    for (i=0; i < 250; i++) {
+      string_append_string(&accum, &a);
+      string_append_cstr(&accum, "!!");
+      BARRIER(&accum);
+      c += string_length(&accum) ^i;
+    }
+  }
+  string_clear(&a);
+  string_clear(&accum);
+  return c;
+}
+
+// No replace function available
+#endif
+

 #define NTESTS 8
 struct flags {
@@ -999,6 +1117,37 @@ int benchTest (const struct flags * runflags) {
  }
 #endif

+#ifdef BENCH_CAN_USE_POTTERY
+  if (runflags->runtest[0]) {
+    c += timeTest (cps, testPOTTERY_emptyCtor, 100000);
+    print ("POTTERY", "empty constructor", cps);
+  }
+  if (runflags->runtest[1]) {
+    c += timeTest (cps, testPOTTERY_nonemptyCtor, 100000);
+    print ("POTTERY", "non-empty constructor", cps);
+  }
+  if (runflags->runtest[2]) {
+    c += timeTest (cps, testPOTTERY_smallnonemptyCtor, 100000);
+    print ("POTTERY", "small non-empty constructor", cps);
+  }
+  if (runflags->runtest[3]) {
+    c += timeTest (cps, testPOTTERY_cstrAssignment, 100000);
+    print ("POTTERY", "Char * assignment", cps);
+  }
+  if (runflags->runtest[4]) {
+    c += timeTest (cps, testPOTTERY_extraction, 100000);
+    print ("POTTERY", "char extraction", cps);
+  }
+  if (runflags->runtest[5]) {
+    c += timeTest (cps, testPOTTERY_scan, 100000);
+    print ("POTTERY", "scan", cps);
+  }
+  if (runflags->runtest[6]) {
+    c += timeTest (cps, testPOTTERY_concat, 10);
+    print ("POTTERY", "concatenation", cps * 250);
+  }
+#endif
+
  return c;
 }

@@ -1,7 +1,7 @@
 /*
 * M*LIB - common functions for bench module
 *
- * Copyright (c) 2017-2021, Patrick Pelissier
+ * Copyright (c) 2017-2023, Patrick Pelissier
 * All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
@@ -147,7 +147,7 @@ select_config(int func, size_t n, const config_func_t functions[])
    fprintf(stderr, "  %d: %s\n", functions[i].num, functions[i].funcname);
  }
  fprintf(stderr,
-	  "USAGE: FUNC_NUMBER [--from number --to number (--grow number | --step number)] [--grapĥ]\n"
+	  "USAGE: FUNC_NUMBER [--from number --to number (--grow number | --step number)] [--graph]\n"
 	  "[--repeat number] [--best|--average|--best-within] [--quiet]\n");
  exit(-1);
 }
@@ -235,7 +235,7 @@ test(const char library[], size_t n, const config_func_t functions[], int argc,
    sprintf(filename, "plot-%s-%d.dat", library, arg.test_function);
    graph_file = fopen(filename, "wt");
    if (!graph_file) {
-      fprintf(stderr, "ERROR: Cannot create plot.dat\n");
+      fprintf(stderr, "ERROR: Cannot create the file '%s'\n", filename);
      exit(-2);
    }
    fprintf(graph_file, "# plotting %s-%d : %s\n# N T", library, arg.test_function, functions[i].funcname);
@@ -271,6 +271,8 @@ test(const char library[], size_t n, const config_func_t functions[], int argc,
 	avg /= arg.repeat;
 	variance = (variance - arg.repeat * avg * avg) / (arg.repeat - 1);
 	ba = get_best_within(arg.repeat, measure, 1. + arg.within);
+      } else {
+        ba = avg;
      }
      
      // The average value shall be around best_within (and greater)
@@ -1,7 +1,7 @@
 /*
 * M*LIB - common functions for bench module
 *
- * Copyright (c) 2017-2021, Patrick Pelissier
+ * Copyright (c) 2017-2023, Patrick Pelissier
 * All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
@@ -31,7 +31,7 @@

 // Needed for M_THREAD_ATTR
 #if defined(MULTI_THREAD_MEASURE)
-#include "m-mutex.h"
+#include "m-thread.h"
 #endif

 #if defined(_WIN32)
@@ -55,7 +55,7 @@
 // Number of elements of a table
 #define numberof(x) (sizeof(x)/sizeof(x[0]))

-/* Get the current CPU time. */
+/* Get the current CPU time in microsecond. */
 #if defined(_WIN32)
 /* WINDOWS variant */
 static inline unsigned long long
@@ -119,9 +119,8 @@ test_function(const char *str, size_t n, void (*func)(size_t))
  (*func)(n);
  end = cputime();
  result = (double)(end-start) / 1000.0;
-  end = (end - start) / 1000U;
  if (str != NULL) {
-    printf ("%20.20s time %lu ms for n = %lu [r=%lu]\n", str, (unsigned long) end, (unsigned long) n, g_result);
+    printf ("%20.20s time %.2f ms for n = %lu [r=%lu]\n", str, result, (unsigned long) n, g_result);
  }
  return result;
 }
@@ -1,7 +1,7 @@
 /*
 * MLIB - TEST module
 *
- * Copyright (c) 2017-2021, Patrick Pelissier
+ * Copyright (c) 2017-2023, Patrick Pelissier
 * All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
@@ -35,10 +35,9 @@ static inline size_t my_hash(uint64_t key)
 {
  return ((key) ^ (key)>>7);
 }
-static inline void update_val(uint32_t *p, uint32_t v) { *p += v;}
 DICT_OA_DEF2(dict_oligonucleotide,
             uint64_t, M_OPEXTEND(M_DEFAULT_OPLIST, HASH(my_hash), OOR_EQUAL(my_oor_equal_p), OOR_SET(my_oor_set M_IPTR)),
-             uint32_t, M_OPEXTEND(M_DEFAULT_OPLIST, UPDATE(update_val M_IPTR)))
+             uint32_t, M_DEFAULT_OPLIST)
 #define M_OPL_dict_oligonucleotide_t() DICT_OPLIST(dict_oligonucleotide, M_OPEXTEND(M_DEFAULT_OPLIST, HASH(my_hash), OOR_EQUAL(my_oor_equal_p), OOR_SET(my_oor_set M_IPTR)), M_DEFAULT_OPLIST)

 // Define a B*TREE-21 of uint32_t --> uint64_t and register its oplist
@@ -1,5 +1,5 @@
 #include "../common.c"
-#define DICTI_OA_PROBING(s) 1
+#define M_USE_DICT_OA_PROBING(s) 1
 #include "m-dict.h"

 static inline bool oor_equal_p(unsigned int k, unsigned char n)
@@ -57,3 +57,28 @@ V0.4.*: * The order of a list initialized using M_LET is reversed
        * Rename TUPLE _init_set2 in _init_emplace & _set2 in _emplace.
        * Rename Priority Queue method _update_further in _update.
        
+V0.5.*: * M_INVERT is renamed into M_REVERSE to be more coherent with the REVERSE operator.
+          M_INVERT is marked as obsolete.
+        * Remove _it_to_p method of B+TREE / RB-TREE as it has been deprecated.
+        * Remove ALGO_INIT_VA & M_ALG0_LET_INIT_VAI of m-algo as it has been deprecated (Use of M_LET instead).
+        * Some Internal name of user modifiable macros have been renamed to be properly 
+        customizable by the user.
+        * Rename M_HASH_SEED into M_USE_HASH_SEED (as it is a user macro).
+        * M_LET: for initialization of variable with arguments, if there is only one argument, 
+        it will default to use INIT_SET instead of INIT_WITH.
+        ==> Encapsulate the argument between () to force use of INIT_WITH.
+        * Remove of UPDATE operator. Use of SET for RBTREE or ADD for DICT instead.
+        * Make the _clean suffix for reseting the container to empty deprecated. Use new _reset suffix instead.
+        * Make the _get_at suffix for always getting a value deprecated. Use new _safe_get suffix instead.
+	* Rename CLEAN operator in RESET operator.
+	* Rename GET_SET_KEY operator in SAFE_GET_KEY operator.
+	
+V0.6.*: * Rename M_DEFAULT_OPLIST in M_BASIC_OPLIST
+        * Remove experimental macro M_IF_DEFAULT1.
+        * Remove M_INVERT
+        * String functions with _str suffix for C strings have been renamed with _cstr suffix (like string_cat_str ==> m_string_cat_cstr)
+        Note: the compatible layer still keeps the old naming,
+        so except if you are using the prefixed version of the strings
+        or the bounded strings API, you won't need to upgrade your code.
+        
+V0.7.*: * Rename m-mutex.h header in m-thread.h
@@ -17,23 +17,31 @@ How to make a release?
 In case of problem, open a problem report.


-List of tested systems
-=======================
+List of automatically tested systems
+====================================

-* gcc 4.9, 7 & 8 on linux/x86-64
-* clang 3.5, 4 & 6 on linux/x86-64
-* g++ 7 & 8 on linux/x86-64
+* gcc on linux/x86-64 (32 bits and 64 bits)
+* g++ on linux/x86-64 (32 bits and 64 bits)
+* clang on macos/x86-64
+* clang++ on macos/x86-64
 * tcc on linux/x86-64
-* gcc 7 on windows/x86-64
-* gcc 4.9 on linux/powerpc
-* gcc 6 on linux/armv7l
-* clang 3.8 on linux/armv7l
+* gcc on windows/x86-64 (mingw)
+* msvc on windows/x86-64
+* clang on windows/x86-64

+List of manually tested systems
+===============================
+
+* clang on linux/x86-64
+* clang on linux/armv7l
+* gcc on linux/powerpc
+* gcc on linux/armv7l

 Atomic library
 ==============

-For target, armel m68k mips mipsel powerpc powerpcspe sh4, you may need to run the test suite:
+For the targets armel, m68k, mips, mipsel, powerpc, powerpcspe or sh4,
+you may need to run the test suite by adding the atomic library:

 make check LDFLAGS="-pthread -latomic"

@@ -45,7 +53,7 @@ Cross compilation

 There is no need to cross compile the library as it is a header only library.

-However if you want to run the test with a cross-compiler, do like the following
+However if you want to run the tests with a cross-compiler, do like the following
 command. It performs a cross-compilation of the test suite from linux to windows
 and run the test suite with wine:

@@ -57,9 +65,8 @@ Handling issues

 Issues are opened in the bug tracker of the project (typically https://github.com/P-p-H-d/mlib/issues )

-If the issue cannot be closed and taken into account in less than (typically) one month,
-or before a release,
-it shall be moved into the long term issues included in the repository:
+If the issue cannot be taken into account quickly and are long term,
+it should be moved into the long term issues included in the repository:
 https://github.com/P-p-H-d/mlib/blob/master/doc/ISSUES.org
 This is a file in ORG mode: the issues are created with the proper tags.

@@ -75,7 +82,7 @@ its state shall be changed to DONE (the issue shall not be removed).


 Debugging
-===============
+=========

 Debugging the library can be quite difficult
 as it performs heavy preprocessing expansion
@@ -86,7 +93,7 @@ Different strategy for debugging the library itself are still possible:
 Add printf of interresting values in the debugged function.


-2) Preprocess the library and then compile the preprocessed file:
+2) Preprocess the library and then compile the preprocessed file like this:

          cc -std=c99 -E test-file.c > test-file.i
          perl -pi -e 's/;/;\n/g' test-file.i
@@ -109,3 +116,41 @@ Run the wave driver:
    	 ./wave ex-array01.c -I .. --c99 -t test.trace

 The different expansion performed by the library are described in test.trace
+
+Coding rules
+============
+
+* Use of non standard C shall be protected under a specific compiler test,
+  so that the library remains compatible with a strict C99 compiler.
+
+* C11 features shall be optional.
+
+* Use 'make format' to format the header files properly.
+
+* External types shall be suffixed by _t and in lower case
+  but shall be optional if the user doesn't want then.
+
+* Internal types shall be suffixed by _ct and in lower case
+  (as confidential types)
+
+* External / Internal functions shall be in lower case.
+
+* External / Internal macros shall be in upper case.
+
+* Internal macros / functions shall be prefixed by m_<container>
+  with container is the name of the container with one letter transformed:
+      o --> 0
+      e --> 3
+      i --> 1
+      y --> 4
+  This prevents the automatic completion to work when the user starts writing its function.
+
+* Test functions shall be predicated and be suffixed by '_p'
+
+
+Misc
+====
+
+To put a breakpoint for the thread sanitizer in case of error, in gdb add:
+
+$ set env TSAN_OPTIONS=halt_on_error=1,abort_on_error=1
@@ -1,23 +1,61 @@
 *Long term issues*
 ------------------

+* TODO #28 : Separate generation of interface to implementation :ENHANCEMENT:
+
+Enable support for generating an interface only for the headers
+and an implementation only for the source code.
+
+Try to keep API compatibility
+==> Only modify renamed macro with M_ prefix by giving a new mandatory
+argument for such generation.
+ 
+* TODO #27 : Uniformization of m-buffer interface               :ENHANCEMENT:
+
+The m-buffer interface requires special argument to work:
+- size & policy for BUFFER,
+- policy only for the others.
+This is not uniform with the others generation macros and not uniform with each other.
+Moreover the others are the only one which can be used in a shared memory, so
+a fixed size will be good to have too for such interface.
+
+==> Uniformize the interface. How?
+==> Provide static size for all QUEUE.
+
 * TODO #26 : Hash-Map for huge objects                          :ENHANCEMENT:

 Specialize Hashmap for huge objects on supported hardware:

-based on OA hash map with taggued pointer (needs space for tagging):
-low bits = low bits of hash
+Based on OA hash map with taggued pointer (needs space for tagging):
+low bits = high bits of hash
 pointer to object { key, hash, value }

-Can detect collision without dereferencing object with 1/2^lowbits chances.
+Can solve collision without dereferencing object with 1/2^lowbits chances.
+NB: hash may be uneeded due to the small chances of collision.
 Reduce cache usage ==> Should be faster.
+Increase cache usage for very small object (integer).

 Use of pointer to avoid moving object on GC.

 On AMD64, only 48 bits of 64 bits are really used for addressing data.
+==> lowbits= 16
+Empty representation= 0 (hash can be 0. pointer cannot be it).
+Deleted representation = 1 (pointer cannot be zero)

+<---- PTR ----><-HASH->

-* TODO #25 : Support of error code model for error handling.    :ENHANCEMENT:
+#+BEGIN_SRC C
+#define LOW_BITS 16
+#define ALIGNED_BITS 2
+void *get_ptr(int64_t x) { 
+  return (void*) ((x >> LOW_BITS) << ALIGNED_BITS);
+}         
+unsigned get_small_hash(int64_t x) {
+  return x & ((1<<LOW_BITS)-1);
+}
+#+END_SRC
+
+* TODO #25 : Support of error return model for error handling.  :ENHANCEMENT:

 Find a way to support error return code for the API in case of allocation
 failure.
@@ -85,7 +123,7 @@ Open points:
 - What about M_LET/ M_EACH?


-* TODO #24 : Add MIN-MAX-HEAP container                         :ENHANCEMENT:
+* TODO #24 : New: Add MIN-MAX-HEAP container                    :ENHANCEMENT:

 See https://en.wikipedia.org/wiki/Min-max_heap
 as DPRIORITY_QUEUE_DEF ?
@@ -93,7 +131,7 @@ as DPRIORITY_QUEUE_DEF ?
 NOTE: Needs for such container?


-* TODO #23: Force MOVE semantic                                 :ENHANCEMENT:
+* TODO #23: Strict MOVE semantic to clarify                     :ENHANCEMENT:

 Some type may need to have a force MOVE semantic (for example, they can store
 pointer to themselves). Currently the INIT_MOVE & MOVE operators are more
@@ -128,7 +166,22 @@ operators as it uses MOVE_DEFAULT which is not (fully compatible).
 ==> Analyse limitation and possible constraint usages.


-* TODO #20: Bucket priority queue                               :ENHANCEMENT:
+Being able to define a correct default for INIT_MOVE will be really good
+(compatible with trivial move copy).
+In such case, all INIT_MOVE & MOVE operators can be removed from oplist
+to only use the default, and theses operators can be disabled or defined
+only when really needed in the oplist.
+However creating a default INIT_MOVE macro seems problematic.
+If the type is typedef T t[1] then passing such an argument to a function, 
+will transform the argument to T*, and the type of the argument doesn't match
+what is expecting resulting in a move of the pointers, not a move of the design data.
+
+Defining a TYPE to this macro seems mandatory, but within restricting to C11
+(by using _Generic to detect such case),
+I don't see any way to define the macro.
+
+
+* TODO #20: New: Bucket priority queue                          :ENHANCEMENT:

 Add a new kind of priority queue. 
 See https://en.wikipedia.org/wiki/Bucket_queue
@@ -145,7 +198,7 @@ Check if we can use BITSET, or introduce fixed size BITSET or use ad-hock
 implementation.


-* TODO #19: Intrusive Red Black Tree                            :ENHANCEMENT:
+* TODO #19: New: Intrusive Red Black Tree                       :ENHANCEMENT:

 Add intrusive red black tree. 
 Look also for AVL tree (NOTE: Is there a performance difference between the two?)
@@ -158,9 +211,9 @@ See the cells in yellow here:
 http://htmlpreview.github.io/?https://github.com/P-p-H-d/mlib/blob/master/doc/Container.html


-* TODO #17: Ressource handler                                   :ENHANCEMENT:
+* TODO #17: New: Ressource handler                              :ENHANCEMENT:

- A ressouce handler which shall associated a unique handle to a ressource.
+ A global 'ressouce handler' which shall associated a unique handle to a ressource.
 The handle shall be unique for the ressource and shall not be reused.
 It is typically a 64 bits integers always incremented (even if the program
 creates one billion ressources per second, the counter won't overflow
@@ -189,7 +242,7 @@ http://htmlpreview.github.io/?https://github.com/P-p-H-d/mlib/blob/master/doc/Co
 * embedded the type in the ressource handler: more work, API more complex. Memory usage seems better.


-* TODO #16: Lock Free List                                      :ENHANCEMENT:
+* TODO #16: New: Lock Free List                                 :ENHANCEMENT:

 Implement a lock free list. Most of the difficulty is the memory reclamation part.
 Typically this lock free list shall be compatible with RCU method.
@@ -213,29 +266,6 @@ http://htmlpreview.github.io/?https://github.com/P-p-H-d/mlib/blob/master/doc/Co
   (NULL if not logically deleted) ? TBC


-* TODO #15: Prologue / Epilogue for Constructor / Destructor for error handling :ENHANCEMENT:
-
-Constructor (and destructor) need to use user-defined prologue / epilogue.
-This is in order to register the constructed object into a proper Exception
-Handling Stack so that throwing exceptions may work reliably.
-
-Proposal:
-
- M_CONSTRUCTOR_PROLOGUE(object, oplist);
- M_CONSTRUCTOR_EPILOGUE(object, oplist);
- M_DESTRUCTOR_PROLOGUE(object, oplist);
- M_DESTRUCTOR_EPILOGUE(object, oplist);
-
-Object creation will need to add all sub-objects into the stack, 
-then unstack all to push instead the root object (which recursively remove them).
-
-See also http://freetype.sourceforge.net/david/reliable-c.html#cseh
-
- How to handle like allocation of the object?
- How to avoid calling the destructor multiple times? (It is needed?)
- How the code can be factorized with RETCODE needs?
-
-
 * TODO #14: Memory allocation enhancement                       :ENHANCEMENT:

 Enhancement of the memory allocation scheme to find way to deal properly with advanced allocators:
@@ -271,7 +301,7 @@ Needs some formal operator in the oplist to support it fully and an example.
 It is a kind of object  inheritance where the container inherits some extra data from its base.


-* TODO #12: Atomic shared pointer                               :ENHANCEMENT:
+* TODO #12: New: Atomic shared pointer                          :ENHANCEMENT:

 Add an extension to the SHARED_PTR API:

@@ -347,11 +377,14 @@ Other implementation seems to have it hard to be lock-free: cf. https://github.c



-* TODO #5: Concurrent dictionary Container                      :ENHANCEMENT:
+* TODO #5: New: Concurrent dictionary Container                 :ENHANCEMENT:

 Implement a more efficient dictionary than lock + std dictionary for all operations when dealing with threads.
 See https://msdn.microsoft.com/en-us/library/dd287191(v=vs.110).aspx

+The best parallel algorithm is still when there is as few synchronization as possible. A concurrent dictionary will fail at this and will result in average performance at best.
+The typical best case will be in RCU context (a lot of readers, few writers), so the interface shall be compatible with such structure.
+
 ** Multiple locks within the dictionnary

 A potential implementation may be to request at initialization time the number of concurrent thread N.
@@ -372,33 +405,25 @@ See also https://github.com/simonhf/sharedhashfile
 ** Lock Free dictionnary 

 Evaluate also lock-free dictionary (easier with open addressing). 
-It needs a complete rewrite of the inner loop through. The hard part is the dynamic resizing of the internal array (see http://preshing.com/20160222/a-resizable-concurrent-map/ for a potential solution and http://www.cs.toronto.edu/~tomhart/papers/tomhart_thesis.pdf for memory reclamation techniques). See also https://www.research.ibm.com/people/m/michael/spaa-2002.pdf
-https://www.kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.2017.11.22a.pdf persents different techniques used by linux kernel.
+It needs a complete rewrite of the inner loop through. The hard part is the dynamic resizing of the internal array.
+Ssee http://preshing.com/20160222/a-resizable-concurrent-map/ for a potential solution
+ and http://www.cs.toronto.edu/~tomhart/papers/tomhart_thesis.pdf for memory reclamation techniques). 
+ and https://www.research.ibm.com/people/m/michael/spaa-2002.pdf
+https://www.kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.2017.11.22a.pdf presents different techniques used by linux kernel.
 It needs before lock-free list: http://www.cse.yorku.ca/~ruppert/papers/lfll.pdf http://www.cse.yorku.ca/~ruppert/Mikhail.pdf

-** Context
-
-The best parallel algorithm is still when there is as few synchronization as possible. A concurrent dictionary will fail at this and will result in average performance at best.
-The typical best case will be in RCU context (a lot of readers, few writers), so the interface shall be compatible with such structure.
-
-** Linked list 
-
-Another solution is to create a huge list of items which is:
-
-    atomically updated,
-    in reverse order of the hash (bit 0 is highest bit, Bit 63 is the lowest bit).
-
-Hash table will only give quick access to items to this list. Expanding the table won't change the order of the list (so the items will remain at the same place and always accessible by other threads) but just add sentinel in the sentinel at the right place (there won't be any reallocation of the list). Inserting will need to insert an item at the right place.
-Not sure it will really help. To analyse.
-
- Concurrent dictionary is possible now with CONCURRENT_DEF + DICT_DEF.
- But it uses a global lock for all dictionary access.
-
-** Open Addressing Indirect Table with a lock free node pool used as transaction pool.
-
 A good way maybe Open Addessing table used only for indirection and a freelist memory reclamation container for handle the entries
 (like a transaction).

+ Solution?
+ --------
+ 
+ Use of the concurrent pool (m-c-mempool) to allocate items.
+ The big table will only store pointers (+ part of hash in unused bits?) to such allocate items.
+ Atomic update is done by allocating a new node, update it, and atomicaly store it in the dict, putting the old one as logically deleted and to reclaim later.
+ (Other threads may still read its data so we cannot free immediatly). 
+ 
+
 * DONE #22: Enhanced services for SPSC Queue                    :ENHANCEMENT:

 Add services:
@@ -436,6 +461,27 @@ push always succeed and the queue always keep the youngest element.
   To simplify it, this interface could only support one kind of import/export
   per compilation unit.

+* DONE #15: Prologue / Epilogue for Constructor / Destructor for error handling :ENHANCEMENT:
+  
+Constructor (and destructor) need to use user-defined prologue / epilogue.
+This is in order to register the constructed object into a proper Exception
+Handling Stack so that throwing exceptions may work reliably.
+
+Proposal:
+
+- M_CONSTRUCTOR_PROLOGUE(object, oplist);
+- M_CONSTRUCTOR_EPILOGUE(object, oplist);
+- M_DESTRUCTOR_PROLOGUE(object, oplist);
+- M_DESTRUCTOR_EPILOGUE(object, oplist);
+
+Object creation will need to add all sub-objects into the stack, 
+then unstack all to push instead the root object (which recursively remove them).
+
+See also http://freetype.sourceforge.net/david/reliable-c.html#cseh
+
+- How to handle like allocation of the object?
+- How to avoid calling the destructor multiple times? (It is needed?)
+- How the code can be factorized with RETCODE needs?



@@ -0,0 +1,16 @@
+#!/bin/sh
+mkdir -p /tmp/prepro-$USER
+name=/tmp/prepro-$USER/$$.c
+param1=""
+param2=""
+while test $# -gt 0 ; do
+    case $1 in
+        -c) param2="$param2 -c" ;;
+        *\.c)  param1="$param1 $1" ;;
+        *) param1="$param1 $1" ; param2="$param2 $1" ;;
+     esac
+    shift
+done
+cc $param1 -E |grep -v '^#' > ${name}      \
+    && perl -pi -e  's/\;/\;\n/g' ${name}    \
+    && cc $param2 ${name}
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2021, Patrick Pelissier
+# Copyright (c) 2017-2023, Patrick Pelissier
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without
@@ -23,6 +23,7 @@
 CC=cc -std=c99
 CFLAGS=-Wall -W -pedantic -Wshadow -Wpointer-arith -Wcast-qual -Wstrict-prototypes -Wmissing-prototypes -Wswitch-default -Wswitch-enum -Wcast-align -Wpointer-arith -Wbad-function-cast -Wstrict-overflow=5 -Wstrict-prototypes -Winline -Wundef -Wnested-externs -Wcast-qual -Wshadow -Wunreachable-code -Wlogical-op -Wstrict-aliasing=2 -Wredundant-decls -Wold-style-definition -Wno-unused-function -g
 GMP_DIR=
+MPFR_DIR=$(GMP_DIR)
 CPPFLAGS=-I..
 LDFLAGS=-pthread
 RM=rm -f
@@ -30,7 +31,7 @@ RM=rm -f
 .SUFFIXES: .c .exe

 .c.exe:
-	$(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) `cat config` $< -o $@
+	$(CC) $(CFLAGS) $(CPPFLAGS) $< -o $@ `cat config` $(LDFLAGS)

 all: config
 	$(MAKE) `ls ex-*.c|sed -e 's/\.c/\.exe/g'`
@@ -38,7 +39,9 @@ all: config

 config:
 	printf "#include <gmp.h>\nint main(void){mpz_t z; mpz_init(z); return 0;}\n" > config-test.c
-	$(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS)  -I$(GMP_DIR)/include -L$(GMP_DIR)/lib -lgmp config-test.c -o config-test.exe 2> /dev/null && echo "-DHAVE_GMP=1  -I$(GMP_DIR)/include -L$(GMP_DIR)/lib -lgmp" > config || echo "-DHAVE_GMP=0" > config
+	$(CC) $(CFLAGS) $(CPPFLAGS) -I$(GMP_DIR)/include -L$(GMP_DIR)/lib config-test.c -lgmp -o config-test.exe $(LDFLAGS) 2> /dev/null && echo "-DHAVE_GMP=1 -DHAVE_MPFR=0 -I$(GMP_DIR)/include -L$(GMP_DIR)/lib -lgmp" > config || echo "-DHAVE_GMP=0 -DHAVE_MPFR=0 " > config
+	printf "#include <mpfr.h>\nint main(void){mpfr_t z; mpfr_init(z); return 0;}\n" > config-test.c
+	$(CC) $(CFLAGS) $(CPPFLAGS) -I$(GMP_DIR)/include -I$(MPFR_DIR)/include -L$(GMP_DIR)/lib -L$(MPFR_DIR)/lib config-test.c -lmpfr -lgmp -o config-test.exe $(LDFLAGS) 2> /dev/null && echo "-DHAVE_GMP=1 -DHAVE_MPFR=1  -I$(GMP_DIR)/include -L$(GMP_DIR)/lib -I$(MPFR_DIR)/include -L$(MPFR_DIR)/lib -lmpfr -lgmp" > config || echo "MPFR not available"
 	$(RM) config-test.c config-test.exe

 clean:
@@ -10,7 +10,7 @@ ARRAY_DEF(vector_int, int)
 ALGO_DEF(vector_int, vector_int_t)

 /* Define a dynamic array of bool */ 
-ARRAY_DEF(vector_bool, bool, M_BOOL_OPLIST)
+ARRAY_DEF(vector_bool, bool)
 /* Register the oplist of this dynamic array globally */
 #define M_OPL_vector_bool_t() ARRAY_OPLIST(vector_bool, M_BOOL_OPLIST)
 /* Define some standards algorithms on this dynamic array */
@@ -3,11 +3,11 @@
 #include "m-algo.h"
 #include "m-string.h"

-/* Define a dictionnary (or hash_map or undordered_map)
+/* Define a dictionnary (or hash_map or unordered_map)
 * from a string_t to int */
 DICT_DEF2(dict, string_t, int)
 /* Register the oplist of this dictionnary globally */
-#define M_OPL_dict_t() DICT_OPLIST(dict, STRING_OPLIST, M_DEFAULT_OPLIST)
+#define M_OPL_dict_t() DICT_OPLIST(dict, STRING_OPLIST, M_BASIC_OPLIST)

 /* Define an array of integer */
 ARRAY_DEF(vector_int, int)
@@ -23,7 +23,7 @@ ARRAY_DEF(vector_int, int)

 int main(void)
 {
-  int s;
+  int s = 0;
  // Init keys as a vector_int_t, initialize it (and prepare its destruction)
  M_LET(keys, vector_int_t)
    // Initialize m as a dictionnary and initialize it with the given database
@@ -7,28 +7,31 @@ ARRAY_DEF(vector_int, int)
 /* Register the oplist of this array of int globally */
 #define M_OPL_vector_int_t() ARRAY_OPLIST(vector_int)

-/* Set s (string_t) to the integer i */
-#define str_ui(s, i) string_printf(s, "%d", i)
-
 /* Concat two strings by insertion a '-' within them */
 #define str_cat(s1, s2) (string_cat_str(s1, "-"), string_cat(s1, s2))

 int main(void)
 {
-  // Let s be a string_t and initilize it.
+  // Let 's' be a string_t and initialize it.
  M_LET(s, string_t)
-    // Let v be a vector of integer and initialize it.
+    // Let 'v' be a vector of integer and initialize it.
    M_LET( (v, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10), vector_int_t) {
-    int sum, product;
+    int sum = 0, product = 0;
    
    // Compute the sum of theses integers.
+    // 'add' is a registered keyword, recognized by M*LIB to perform a sum.
    ALGO_REDUCE(sum, v, vector_int_t, add);

    // Compute the product of theses integers.
+    // 'mul' is a registered keyword, recognized by M*LIB to perform a product.
    ALGO_REDUCE(product, v, vector_int_t, mul);

-    /* Example of reduction with a transformation of the type from int to string_t */
-    ALGO_REDUCE( (s, string_t), v, vector_int_t, str_cat, str_ui);
+    /* Example of reduction with a transformation of the type from int to string_t
+       By default, the result ("s") should be of the same type as the base type
+       of the container. This is not the case here, we want to transform the
+       type. As such, we add the precision of the type 'string_t' to 's'.
+       The transformation from string to integer is done by string_set_si */
+    ALGO_REDUCE( (s, string_t), v, vector_int_t, str_cat, string_set_si);

    printf ("sum: %d\n"
            "product: %d\n"
@@ -24,7 +24,8 @@
 /* Generate prototypes and inline functions
   for basic types.
   For integer and floats, there is no need to specify
-   an oplist. M_DEFAULT_OPLIST will be used.
+   an oplist. M_BASIC_OPLIST will be used.
+   For bool, M_BOOL_OPLIST will be used.
 */
 ARRAY_DEF(r_bool, bool)

@@ -105,7 +106,7 @@ test_int(int n)
   But with an explicit oplist.
   This generates exactly the same code than r_int
 */
-ARRAY_DEF(r_int2, signed int, M_DEFAULT_OPLIST)
+ARRAY_DEF(r_int2, signed int, M_BASIC_OPLIST)

 static int
 test_int2(int n)
@@ -180,7 +181,7 @@ test_float(int n)


 /* Same with type double and an explicit oplist*/
-ARRAY_DEF(r_double, double, M_DEFAULT_OPLIST)
+ARRAY_DEF(r_double, double, M_BASIC_OPLIST)

 static int
 test_double(int n)
@@ -214,9 +215,9 @@ static char *my_strdup(const char *p)
  return d;
 }

-/* Same with type const char *, representing a contant string.
+/* Same with type const char *, representing a contant C string.
   We *** need *** an explicit oplist to tell M*LIB
-   to consider the type as a constant string.
+   to consider the type as a constant C string.
   The oplist to use is M_CSTR_OPLIST.
   We could have used M_PTR_OPLIST too,
   but in this case, we won't get proper string order or
@@ -231,7 +232,7 @@ test_cstring(int n)

  r_cstring_init(array);
  for(int i = 0; i < n; i++) {
-    char buffer[10];
+    char buffer[16];
    // Create a string from the integer
    sprintf(buffer, "%d", i);
    // We need to make an explicit copy of the string
@@ -245,13 +246,13 @@ test_cstring(int n)
  for(int i = 0; i < n; i++) {
    // Get back the string
    const char *p = *r_cstring_get(array, i);
-    // Convert it to integer
+    // Convert it to an integer
    int j = atoi(p);
    s += j;
  }

  // We also need a special unalloc pass
-  // to free all constant strings we have allocated.
+  // to free all constant strings we have allocated using my_strdup
  for(int i = 0; i < n; i++) {
    const char *p = *r_cstring_get(array, i);
    free((void*)(uintptr_t)p);
@@ -264,7 +265,7 @@ test_cstring(int n)



-/* Same with type string_t of M*LIB, representing a variable string.
+/* Same with type string_t of M*LIB, representing a dynamic string.
   We don't need explicit oplist to tell M*LIB!
   The oplist to use is STRING_OPLIST,
   but it has been registered globaly, so we don't need to explicit
@@ -282,7 +283,7 @@ test_string(int n)
  
  for(int i = 0; i < n; i++) {
    // create a string from an integer
-    string_printf(str, "%d", i);
+    string_set_si(str, i);
    // No need to make a copy in the container!
    r_string_push_back(array, str);
  }
@@ -294,7 +295,7 @@ test_string(int n)
    s += j;
  }

-  // No need to explicit dealloc !
+  // No need to explicit free each term of the array
  string_clear(str);
  r_string_clear(array);

@@ -304,7 +305,7 @@ test_string(int n)


 /* Same with type string_t of M*LIB, representing a variable string
-   and its explicit oplist. And said above, it generates exactly the
+   and its explicit oplist. As said above, it generates exactly the
   same code. */
 ARRAY_DEF(r_string2, string_t, STRING_OPLIST)

@@ -340,6 +341,9 @@ test_vintptr(int n)
  int s = 0;
  for(int i = 0; i < n; i++) {
    // Get the pointer to the integer.
+    // As the basic type of the container is a pointer,
+    // and r_vintptr_get return a pointer to the basic type
+    // we need to dereference its return value to get the pointer value.
    volatile unsigned *p = *r_vintptr_get(array, i);
    s += *p;
  }
@@ -374,6 +378,7 @@ test_rockme(int n)
  for(int i = 0; i < n; i++) {
    struct rock_me_out rock;
    rock.n = i*i - i;
+    rock.other = 0.0f;
    // Push the struct in the array
    r_rockme_push_back(array, rock);
  }
@@ -414,6 +419,7 @@ test_rockme2(int n)
  for(int i = 0; i < n; i++) {
    rock_me_in rock;
    rock->n = i*i - i;
+    rock->other = 0.0f;
    r_rockme2_push_back(array, rock);
  }

@@ -458,6 +464,7 @@ test_rockme2b(int n)
  for(int i = 0; i < n; i++) {
    rock_me_in rock;
    rock->n = i*i - i;
+    rock->other = 0.0f;
    r_rockme2b_push_back(array, rock);
  }

@@ -478,15 +485,18 @@ test_rockme2b(int n)
 /* Same with a structure type defined as a tuple.

   We first define a tuple. No need to specify the oplist as it uses basic C types
-   so M_DEFAULT_OPLIST is used.
+   so M_BASIC_OPLIST is used by default.

   Then we define the array, giving it the oplist definition of the tuple:
   the macro TUPLE_OPLIST is used to build it based on the tuple name,
   and the oplists of the tuple.
+
+   The main advantage of a tuple over a classic structure is that you get
+   free classic methods of your structure.
 */
 TUPLE_DEF2(rock_you, (n, int), (other, float))

-ARRAY_DEF(r_rockme3, rock_you_t, TUPLE_OPLIST(rock_you, M_DEFAULT_OPLIST, M_DEFAULT_OPLIST))
+ARRAY_DEF(r_rockme3, rock_you_t, TUPLE_OPLIST(rock_you, M_BASIC_OPLIST, M_BASIC_OPLIST))

 static int
 test_rockme3(int n)
@@ -520,7 +530,7 @@ test_rockme3(int n)
 /* Same with a structure type defined as a tuple using global registeration.

   We first define a tuple. No need to specify the oplist as it uses basic C types
-   so M_DEFAULT_OPLIST is used.
+   so M_BASIC_OPLIST is used.

   Then we register the oplist of rock_us_t by defining a macro based
   on M_OPL_ + type name + () which expands with the oplist of the type.
@@ -533,7 +543,7 @@ test_rockme3(int n)
 */
 TUPLE_DEF2(rock_us, (n, int), (other, float))

-#define M_OPL_rock_us_t() TUPLE_OPLIST(rock_us, M_DEFAULT_OPLIST, M_DEFAULT_OPLIST)
+#define M_OPL_rock_us_t() TUPLE_OPLIST(rock_us, M_BASIC_OPLIST, M_BASIC_OPLIST)

 ARRAY_DEF(r_rockme4, rock_us_t)

@@ -612,7 +622,7 @@ int main (int argc, const char *argv[])
  s = test_rockme3(n);
  printf ("S[rockme3] = %d\n", s);

-  s = test_rockme3(n);
+  s = test_rockme4(n);
  printf ("S[rockme4] = %d\n", s);

  exit(0);
@@ -96,6 +96,7 @@ static void data_node_clear(data_node *obj)
   and gives the minimum oplist allowing M*LIB to handle
   properly the object 'data_node' with the API convention
   to respect for calling the methods.
+   The Manual defines the different supported API.
 */
 ARRAY_DEF(/* the array prefix */ array_data_node,
 	  /* the object type */ data_node,
@@ -0,0 +1,119 @@
+//
+// -- An A* pathfinder inspired by the tutorial at Red Blob Games --
+//     https://www.redblobgames.com/pathfinding/a-star/introduction.html
+// Code based on:
+//     https://github.com/glouw/ctl/blob/master/examples/astar.c
+
+#include <stdio.h>
+#include "m-array.h"
+#include "m-string.h"
+#include "m-tuple.h"
+#include "m-prioqueue.h"
+#include "m-dict.h"
+
+// Create a tuple of point, but don't use its priority field for comparison.
+TUPLE_DEF2( point, (x, int), (y, int), (priority, int, M_OPEXTEND( M_OPL_int(), CMP(0), HASH(0), EQUAL(0) ) ) )
+#define M_OPL_point_t() TUPLE_OPLIST(point, M_OPL_int(), M_OPL_int(), M_OPL_int())
+static inline int point_cmp_prio(const point_t a, const point_t b)
+{
+  return a->priority < b->priority ? -1 : a->priority > b->priority;
+}
+PRIOQUEUE_DEF(prio_point, point_t, M_OPEXTEND(M_OPL_point_t(), CMP(point_cmp_prio) ) )
+#define M_OPL_prio_point_t() PRIOQUEUE_OPLIST(prio_point, M_OPL_point_t() )
+ARRAY_DEF(array_point, point_t)
+#define M_OPL_array_point_t() ARRAY_OPLIST(array_point, M_OPL_point_t() )
+DICT_DEF2(cost_point, point_t, int)
+#define M_OPL_cost_point_t() DICT_OPLIST(cost_point, M_OPL_point_t(), M_OPL_int())
+DICT_DEF2(step_point, point_t, point_t)
+#define M_OPL_step_point_t() DICT_OPLIST(step_point, M_OPL_point_t(), M_OPL_point_t())
+
+static inline int point_index(const point_t p, int width)
+{
+  return p->x + width * p->y;
+}
+
+static inline void point_set_from(point_t p, const string_t maze, int width, const char pattern[])
+{
+  size_t s = string_search_str(maze, pattern);
+  point_emplace(p, s % width, s / width , 0);
+}
+
+static void astar(array_point_t path, const string_t maze, int width)
+{
+  M_LET(front, prio_point_t)
+    M_LET(from, step_point_t)
+    M_LET(costs, cost_point_t)
+    M_LET(start, goal, current, next, point_t)
+    {
+      point_set_from(start, maze, width, "@");
+      point_set_from(goal, maze, width, "!");
+      cost_point_set_at(costs, start, 0);
+      prio_point_push(front, start);
+      while (!prio_point_empty_p(front)) {
+        prio_point_pop(&current, front);
+        if (point_equal_p(current, goal))
+          break;
+        const struct { int x; int y; } deltas[] = {
+          { -1, +1 }, { 0, +1 }, { 1, +1 },
+          { -1,  0 }, /* ~ ~ */  { 1,  0 },
+          { -1, -1 }, { 0, -1 }, { 1, -1 },
+        };
+        for (size_t i = 0; i < 8; i++) {
+          point_emplace(next, current->x + deltas[i].x, current->y + deltas[i].y, 0);
+          if (string_get_char(maze, point_index(next, width)) != '#') {
+            int *new_cost = cost_point_get(costs, current);
+            int *cost     = cost_point_get(costs, next);
+            if (cost == NULL || *new_cost < *cost) {
+              cost_point_set_at(costs, next, *new_cost);
+              next->priority = *new_cost + abs(goal->x - next->x) + abs(goal->y - next->y);
+              prio_point_push(front, next);
+              step_point_set_at(from, next, current);
+            }
+          }
+        }
+      }     
+      point_set(current, goal);
+      while (!point_equal_p(current, start)) {
+        array_point_push_back(path, current);
+        point_set(current, *step_point_get(from, current));
+      }
+      array_point_push_back(path, start);
+    }
+}
+
+int main(void)
+{
+  M_LET( (maze, 
+          ("#########################################################################\n"
+           "#   #               #               #           #                   #   #\n"
+           "#   #   #########   #   #####   #########   #####   #####   #####   # ! #\n"
+           "#               #       #   #           #           #   #   #       #   #\n"
+           "#########   #   #########   #########   #####   #   #   #   #########   #\n"
+           "#       #   #               #           #   #   #   #   #           #   #\n"
+           "#   #   #############   #   #   #########   #####   #   #########   #   #\n"
+           "#   #               #   #   #       #           #           #       #   #\n"
+           "#   #############   #####   #####   #   #####   #########   #   #####   #\n"
+           "#           #       #   #       #   #       #           #   #           #\n"
+           "#   #####   #####   #   #####   #   #########   #   #   #   #############\n"
+           "#       #       #   #   #       #       #       #   #   #       #       #\n"
+           "#############   #   #   #   #########   #   #####   #   #####   #####   #\n"
+           "#           #   #           #       #   #       #   #       #           #\n"
+           "#   #####   #   #########   #####   #   #####   #####   #############   #\n"
+           "#   #       #           #           #       #   #   #               #   #\n"
+           "#   #   #########   #   #####   #########   #   #   #############   #   #\n"
+           "#   #           #   #   #   #   #           #               #   #       #\n"
+           "#   #########   #   #   #   #####   #########   #########   #   #########\n"
+           "#   #       #   #   #           #           #   #       #               #\n"
+           "# @ #   #####   #####   #####   #########   #####   #   #########   #   #\n"
+           "#   #                   #           #               #               #   #\n"
+           "#########################################################################\n")), string_t)
+    M_LET(path, array_point_t)
+    {
+      int width = string_search_str(maze, "\n") + 1;
+      astar(path, maze, width);
+      for M_EACH(it, path, array_point_t) {
+          string_set_char(maze, point_index(*it, width), 'x');
+        }
+      printf("%s", string_get_cstr(maze));
+    }
+}
@@ -5,13 +5,13 @@
 // The number 5 is the number of elements in a node of the B+TREE
 BPTREE_DEF2(map_employee_id, 5, int, string_t)
 // Register the oplist of this map globally.
-#define M_OPL_map_employee_id_t() BPTREE_OPLIST2(map_employee_id, M_DEFAULT_OPLIST, STRING_OPLIST)
+#define M_OPL_map_employee_id_t() BPTREE_OPLIST2(map_employee_id, M_BASIC_OPLIST, STRING_OPLIST)

 // Define a map string -> int named map_employee_name
 // The number 5 is the number of elements in a node of the B+TREE
 BPTREE_DEF2(map_employee_name, 5, string_t, int)
 // Register the oplist of this map globally.
-#define M_OPL_map_employee_name_t() BPTREE_OPLIST2(map_employee_name, STRING_OPLIST, M_DEFAULT_OPLIST)
+#define M_OPL_map_employee_name_t() BPTREE_OPLIST2(map_employee_name, STRING_OPLIST, M_BASIC_OPLIST)

 int main(void)
 {
@@ -25,7 +25,9 @@ int main(void)
  map_employee_id_set_at(Employees, 11632, STRING_CTE("John Do"));
  map_employee_id_set_at(Employees, 852, STRING_CTE("Peter"));
  map_employee_id_set_at(Employees, 530, STRING_CTE("Amanda"));
-  map_employee_id_set_at(Employees, 4258, STRING_CTE("Elisabeth"));
+
+  // You can also emplace the structure
+  map_employee_id_emplace_val(Employees, 4258, "Elisabeth");

  printf("Number of employees: %zu\n", map_employee_id_size(Employees));

@@ -60,6 +62,7 @@ int main(void)
    printf("\nElisabeth has id = %d\n", *map_employee_name_get(Employees_r, STRING_CTE("Elisabeth")));    
  } /* Employees_r is cleared beyond this point */

+  // But employee is not
  map_employee_id_clear(Employees);
  return 0;
 }
@@ -2,7 +2,7 @@

 #include "m-buffer.h"
 #include "m-shared.h"
-#include "m-mutex.h"
+#include "m-thread.h"

 /* Global variable to stop scheduling */
 atomic_bool             continue_threading_g;
@@ -1,5 +1,10 @@
 #include "m-core.h"

+/* This example show how to use the M_LET_IF macro
+   that enables to construct an object and continue
+   if the construction succeeds.
+*/
+
 // Stubs defined for the example. Real code will use soundio library.
 struct SoundIo { int x; };
 struct SoundIoDevice { int x; };
@@ -6,7 +6,7 @@

 // Define a dictionnary of string --> int
 // named 'dict_str'
-DICT_DEF2(dict_str, string_t, STRING_OPLIST, int, M_DEFAULT_OPLIST)
+DICT_DEF2(dict_str, string_t, STRING_OPLIST, int, M_BASIC_OPLIST)

 int main(void)
 {
@@ -1,10 +1,10 @@
 #include "m-dict.h"

 // Let's define a dictionary of 'unsigned int' --> 'char
-DICT_DEF2(dict_m32, unsigned int, M_DEFAULT_OPLIST, char, M_DEFAULT_OPLIST)
+DICT_DEF2(dict_m32, unsigned int, M_BASIC_OPLIST, char, M_BASIC_OPLIST)

 // Let's create a synonym for its oplist.
-#define M32_OPLIST DICT_OPLIST(dict_m32, M_DEFAULT_OPLIST, M_DEFAULT_OPLIST)
+#define M32_OPLIST DICT_OPLIST(dict_m32, M_BASIC_OPLIST, M_BASIC_OPLIST)

 #if 1 // Non macro version.

@@ -14,7 +14,7 @@ int main(void) {
  dict_m32_set_at (h, 5, 10);               // h[5] = 10
  char *k = dict_m32_get(h, 10);            // No 10 in h, so k == NULL
  int is_missing = (k != NULL);             // true
-  assert (is_missing);
+  assert (is_missing); (void) is_missing;
  dict_m32_erase(h, 5);                    // h is now empty
  dict_m32_it_t it;                         // iterate over all dictionnary
  for (dict_m32_it (it, h) ; !dict_m32_end_p (it); dict_m32_next(it)) {
@@ -0,0 +1,56 @@
+#include <stdio.h>
+#include "m-dict.h"
+
+/*
+ * Provide OOR methods for OA Hashmap.
+ * See documentation for definition of OOR
+ * OOR values are represented as: 
+ * empty (0) is INT_MIN
+ * deleted (1) is INT_MIN + 1
+ * So valid range for integers are [INT_MIN+2, INT_MAX]
+ */
+static inline bool oor_equal_p(int k, char n)
+{
+  return k == INT_MIN + n;
+}
+
+static inline int  oor_set(char n)
+{
+  return INT_MIN + n;
+}
+
+/*
+ * Provide a custom hash function (optional for OA)
+ */
+static inline size_t hash(int n)
+{
+  return (size_t) n; // Identity hash!
+}
+
+/* Define an OA dictionnay which performs a hashmap between an int to an int */
+DICT_OA_DEF2(dict_oa,
+	     int, M_OPEXTEND(M_BASIC_OPLIST, OOR_EQUAL(oor_equal_p), OOR_SET(API_4(oor_set)), HASH(hash)),
+	     int, M_BASIC_OPLIST)
+
+int main(void)
+{
+  dict_oa_t d;
+  dict_oa_init(d);
+
+  for(int i = 0; i < 10; i++) {
+    dict_oa_set_at(d, i*i, 4*i);
+  }
+  dict_oa_set_at(d, 3, -17);
+  
+  printf("DICT[3] = %d\n", *dict_oa_get(d, 3));
+
+  dict_oa_it_t it;
+  printf("DICT=");
+  for(dict_oa_it(it, d); !dict_oa_end_p(it); dict_oa_next(it)) {
+    printf("%d:%d, ", dict_oa_cref(it)->key, dict_oa_cref(it)->value);
+  }
+  printf("\n");
+  
+  dict_oa_clear(d);
+  return 0;
+}
@@ -0,0 +1,64 @@
+#include <stdio.h>
+#include "m-dict.h"
+
+/*
+ * Provide OOR methods for OA Hashmap.
+ * See documentation for definition of OOR
+ * OOR values are represented as: 
+ * empty (0) is "EMPTY"
+ * deleted (1) is "DELETED"
+ */
+static const char empty_str[] = "EMPTY";
+static const char deleted_str[] = "DELETED";
+static const char *oor_table[] = { empty_str, deleted_str };
+
+static inline bool oor_equal_p(const char *k, int n)
+{
+  return k == oor_table[n];
+}
+
+static inline const char *oor_set(int n)
+{
+  return oor_table[n];
+}
+
+/*
+ * Provide a custom hash function (optional for OA)
+ */
+static inline size_t hash(const char *k)
+{
+  size_t r = 17;
+  while (*k) {
+    r = *k * 33 + r;
+    k++;
+  }
+  return r;
+}
+
+/* Define an OA dictionnay which performs a hashmap between a CSTR to an int */
+DICT_OA_DEF2(dict_oa,
+	     const char *, M_OPEXTEND(M_CSTR_OPLIST, OOR_EQUAL(oor_equal_p), OOR_SET(API_4(oor_set)), HASH(hash)),
+	     int, M_BASIC_OPLIST)
+
+int main(void)
+{
+  dict_oa_t d;
+  dict_oa_init(d);
+
+  dict_oa_set_at(d, "THIS", -17);
+  dict_oa_set_at(d, "IS", -170);
+  dict_oa_set_at(d, "AN", 7);
+  dict_oa_set_at(d, "EXAMPLE", 77);
+  
+  printf("DICT[\"AN\"] = %d\n", *dict_oa_get(d, "AN"));
+
+  dict_oa_it_t it;
+  printf("DICT=");
+  for(dict_oa_it(it, d); !dict_oa_end_p(it); dict_oa_next(it)) {
+    printf("%s:%d, ", dict_oa_cref(it)->key, dict_oa_cref(it)->value);
+  }
+  printf("\n");
+  
+  dict_oa_clear(d);
+  return 0;
+}
@@ -34,7 +34,7 @@ int main(int argc, const char *argv[])
      // While it reads some word from the file
      while (string_fget_word(word, " \t\n\r\"(),=", f)) {
         // Get the reference to the array of this word in the dictionnary (or create it if needed)
-         array_size_t *array = map_pos_get_at(positions, word);
+         array_size_t *array = map_pos_safe_get(positions, word);
         // Push the new offset to this word in the associated array
         array_size_push_back(*array, (size_t)ftell(f) - string_size(word));
      }
@@ -8,43 +8,50 @@
 #include "m-string.h"
 #include "m-algo.h"

-// Let's create a list of string.
+// Let's create a list of string by using the M*LIB dynamic string.
 LIST_DEF(list_string, string_t)

-// Let's register the oplist globally so that other m*lib macros
+// Let's register the oplist globally so that other M*LIB macros
 // can get the oplist without us giving it explictly to them.
+// An oplist is the association of operators to the provided methods
+// so that generic code can use correctly an object of such type.
 #define M_OPL_list_string_t() LIST_OPLIST(list_string, STRING_OPLIST)

 // Let's define some basic algorithms over this list of string.
-ALGO_DEF(astring, M_OPL_list_string_t())
+// We reuse the prefix of the list to simplify usage, but algorithms can use separate namespace.
+ALGO_DEF(list_string, M_OPL_list_string_t())

 int main(void)
 {
-  // Let's create a variable named 'grow' which is a list of string_t
+  // Let's create a variable named 'list' which is a list of string_t
  // This variable is only defined within the associated '{' '}' block.
  // The constructor/destructor of the variable will be called within this block
  // You can also define the variable (list_string_t) and use explicitly
  // its constructor (list_string_init) / destructor (list_string_clear).
-  M_LET (grow, list_string_t)
+  M_LET (list, list_string_t)
    M_LET (tmpstr, string_t) { // And let's create also a string_t

-    // add string elements to the list
-    list_string_push_back (grow, STRING_CTE("AB"));
+    // add string elements to the list in different ways
+    // First is pushing a const string.
+    // The macro STRING_CTE creates a const string_t based on the given const char * string.
+    list_string_push_back (list, STRING_CTE("AB"));
+    // Second is creating a separate string_t and then pushing it in the list
    string_printf(tmpstr, "%d", 12);
-    list_string_push_back (grow, tmpstr);
-    list_string_push_back (grow, STRING_CTE("CD"));
+    list_string_push_back (list, tmpstr);
+    // Third is to emplace directly in the list by constructing a new string_t based on the given const char * 
+    list_string_emplace_back (list, "CD");

    // Serialize the list of string into a big string.
-    list_string_get_str (tmpstr, grow, false);
+    list_string_get_str (tmpstr, list, false);

-    // print out
-    printf("Number of elements = %zu\n", list_string_size(grow));
+    // print it
+    printf("Number of elements = %zu\n", list_string_size(list));
    printf("Final string = %s\n", string_get_cstr(tmpstr));

    // Let's iterate over each element of the list
    // using the macro for iteration over a container.
-    printf ("Using macro EACH :\n");
-    for M_EACH (item, grow, list_string_t) {
+    printf ("Using macro EACH:\n");
+    for M_EACH (item, list, list_string_t) {
        printf ("Item = ");
        string_fputs (stdout, *item);
        printf ("\n");
@@ -52,30 +59,38 @@ int main(void)

    // You can also use classic iterator:
    list_string_it_t it;
-    printf ("Using iterators :\n");
-    for(list_string_it(it, grow) ; !list_string_end_p(it) ; list_string_next(it)) {
+    printf ("Using iterators:\n");
+    for(list_string_it(it, list) ; !list_string_end_p(it) ; list_string_next(it)) {
      const string_t *item = list_string_cref (it);
      printf ("Item = ");
      string_fputs (stdout, *item);
      printf ("\n");
    }

+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L)
+    // Another way: we map each element to the M_PRINT function.
+    printf ("Using macro ALGO_FOR_EACH:");
+    ALGO_FOR_EACH(list, list_string_t, M_PRINT, "\nItem = ");
+    printf ("\n");
+#endif
+
    // Get the min and the max of the list
-    string_t *p = astring_min(grow);
+    string_t *p = list_string_min(list);
    printf ("Min string is %s\n", string_get_cstr(*p));
-    p = astring_max(grow);
+    p = list_string_max(list);
    printf ("Max string is %s\n", string_get_cstr(*p));

    // We can even sort the list.
-    astring_sort(grow);
-    for M_EACH (item, grow, list_string_t) {
+    list_string_sort(list);
+    for M_EACH (item, list, list_string_t) {
        printf ("Sort Item = %s\n", string_get_cstr(*item) );
      }
    
    // Split a string into a list.
    string_set_str(tmpstr, "HELLO;JOHN;HOW;ARE;YOU");
-    astring_split(grow, tmpstr, ';');
-    for M_EACH (item, grow, list_string_t) {
+    list_string_split(list, tmpstr, ';');
+    // Iterate over the splitted list
+    for M_EACH (item, list, list_string_t) {
        printf ("Split Item = %s\n", string_get_cstr(*item) );
      }
    
@@ -25,8 +25,8 @@
 /* Define the needed data structure : */

 // Define a dictionnary of constant string --> integer and register it.
-DICT_DEF2(dict_mph, const char *, M_CSTR_OPLIST, uint32_t, M_DEFAULT_OPLIST)
-#define M_OPL_dict_mph_t() DICT_OPLIST(dict_mph, M_CSTR_OPLIST, M_DEFAULT_OPLIST)
+DICT_DEF2(dict_mph, const char *, M_CSTR_OPLIST, uint32_t, M_BASIC_OPLIST)
+#define M_OPL_dict_mph_t() DICT_OPLIST(dict_mph, M_CSTR_OPLIST, M_BASIC_OPLIST)

 // Define an array of integer to store the value and register it.
 ARRAY_DEF(array_value, uint32_t) // Start from 1. 0 is 'None'
@@ -124,7 +124,7 @@ CreateMinimalPerfectHash2(array_seed_t seed, array_value_t value,
           enought. */
        for(bool cont = true; cont ; ) {
          cont = false;
-          array_seed_clean(slots);
+          array_seed_reset(slots);
          for M_EACH(it, *b, array_cstr_t) {
              size_t s = hash(d, *it) % size;
              if (*array_value_get(value, s) != 0 || array_seed_contain_p(slots, s)){
@@ -48,8 +48,8 @@ static void program_init(program_t p, string_t text) {
        int left;
        array_int_pop_back(&left, leftstack);
        int right = pc;
-        *array_int_get_at (p->bracket_map, left) = right;
-        *array_int_get_at (p->bracket_map, right) = left;
+        *array_int_safe_get (p->bracket_map, left) = right;
+        *array_int_safe_get (p->bracket_map, right) = left;
      }

    pc++;
@@ -1,70 +0,0 @@
-#if HAVE_GMP
-
-#include <stdio.h>
-#include <gmp.h>
-
-#include "m-variant.h"
-#include "m-string.h"
-#include "m-dict.h"
-#include "m-array.h"
-
-/* Define a variant over two integers named integer_t
-   Notice than mpz_t has special init & clear functions
-   mpz_init & mpz_clear.
-   This is handle by the library.
-*/
-VARIANT_DEF2(my_integer,
-             (n, long long, M_DEFAULT_OPLIST),
-             (z, mpz_t, M_CLASSIC_OPLIST(mpz)))
-/* Define the oplist associated to this variant */
-#define MY_INTEGER_OPLIST VARIANT_OPLIST(my_integer, M_DEFAULT_OPLIST, M_CLASSIC_OPLIST(mpz))
-
-/* Define a dictionary of string --> integer named dict_my_t */
-DICT_DEF2(my_dict,
-          string_t, STRING_OPLIST,
-          my_integer_t, MY_INTEGER_OPLIST)
-/* Define the oplist associated to this dictionary */
-#define MY_DICT_OPLIST DICT_OPLIST(my_dict, STRING_OPLIST, MY_INTEGER_OPLIST)
-
-/* Define an array of such dictionary named array_my_t */
-ARRAY_DEF(my_array, my_dict_t, MY_DICT_OPLIST)
-/* Define the oplist associated to this array of dictionary of variant */
-#define MY_ARRAY_OPLIST ARRAY_OPLIST(my_array, MY_DICT_OPLIST)
-
-int main(void)
-{
-  M_LET(z, MY_INTEGER_OPLIST)         /* Define & init & clear an instance of a variant of integer */
-    M_LET(dict, MY_DICT_OPLIST)       /* Define & init & clear an instance of a dictionary of variant */
-    M_LET(array, MY_ARRAY_OPLIST)     /* Define & init & clear an intance of an array of dictionary of variant */
-    M_LET(gmp, M_CLASSIC_OPLIST(mpz)) /* M_LET allows even with non container type */
-    {
-      my_integer_set_n (z, 17LL);                // Set z as the long long 17
-      my_dict_set_at(dict, STRING_CTE("n1"), z); // Push it in the dictionary
-      mpz_set_str(gmp, "25446846874687468746874687468746874686874", 10); // Set gmp to a very long integer.
-      my_integer_set_z (z, gmp);                 // Set z as the mpz_t variable
-      my_dict_set_at(dict, STRING_CTE("n2"), z); // Push it in the dictionary
-      my_array_push_back (array, dict);          // Push the dictionary in the array
-
-      // Iterate over the array container
-      for M_EACH(item, array, MY_ARRAY_OPLIST) {
-          // Iterate over the dictionary container
-          for M_EACH(p, *item, MY_DICT_OPLIST) {
-              // Dictionary iterator are pair (key,value)
-              if (my_integer_n_p(p->value)) {
-                printf ("It is a long long, value = %lld\n",
-                        *my_integer_cget_n(p->value));
-              }
-              if (my_integer_z_p(p->value)) {
-                printf ("It is a mpz_t, value =");
-                mpz_out_str(stdout, 10, *my_integer_cget_z(p->value));
-                printf("\n");
-              }
-            }
-        }
-    } /* All variables are automatically cleared beyond this point */
-}
-
-#else
-// Nothing to do
-int main(void) { return 0; }
-#endif
@@ -4,7 +4,7 @@
 /* Register a dynamic seed to M*LIB hash function. 
   This shall be done before any M*LIB header inclusion. */
 unsigned long long rand_seed;
-#define M_HASH_SEED rand_seed
+#define M_USE_HASH_SEED rand_seed

 #include "m-array.h"
 #include "m-dict.h"
@@ -84,8 +84,8 @@ DICT_DEF2(dict_json, string_t, STRING_OPLIST, json_t, JSON_OPLIST)
 ARRAY_DEF(array_json, json_t, JSON_OPLIST)

 VARIANT_DEF2(variant_json,
-             (boolean, bool, M_OPEXTEND(M_DEFAULT_OPLIST, OUT_STR(boolean_out_str), IN_STR(boolean_in_str M_IPTR)) ),
-             (real, float, M_OPEXTEND (M_DEFAULT_OPLIST, OUT_STR(real_out_str), IN_STR(real_in_str M_IPTR))),
+             (boolean, bool, M_OPEXTEND(M_BASIC_OPLIST, OUT_STR(boolean_out_str), IN_STR(boolean_in_str M_IPTR)) ),
+             (real, float, M_OPEXTEND (M_BASIC_OPLIST, OUT_STR(real_out_str), IN_STR(real_in_str M_IPTR))),
             (array, array_json_t, ARRAY_OPLIST(array_json, JSON_OPLIST)), 
             (dict, dict_json_t, DICT_OPLIST(dict_json, STRING_OPLIST, JSON_OPLIST)))

@@ -10,7 +10,7 @@
   order to show/test the good chaining of the structures */

 TUPLE_DEF2(symbol, (type, int), (name, string_t))
-#define M_OPL_symbol_t() TUPLE_OPLIST(symbol, M_DEFAULT_OPLIST, STRING_OPLIST)
+#define M_OPL_symbol_t() TUPLE_OPLIST(symbol, M_BASIC_OPLIST, STRING_OPLIST)

 ARRAY_DEF(symbol_list, symbol_t)
 #define M_OPL_symbol_list_t() ARRAY_OPLIST(symbol_list, M_OPL_symbol_t())
@@ -19,13 +19,13 @@ TUPLE_DEF2(record, (fields, symbol_list_t))
 #define M_OPL_record_t() TUPLE_OPLIST(record, M_OPL_symbol_list_t())

 TUPLE_DEF2(my_tuple, (name, string_t), (value, int))
-#define M_OPL_my_tuple_t() TUPLE_OPLIST(my_tuple)
+#define M_OPL_my_tuple_t() TUPLE_OPLIST(my_tuple, STRING_OPLIST, M_BASIC_OPLIST)

 ARRAY_DEF(my_list_of_tuple, my_tuple_t)
 #define M_OPL_my_list_of_tuple_t() ARRAY_OPLIST(my_list_of_tuple)

 TUPLE_DEF2(my_tuple_of_tuple, (name, string_t), (inner_tuple, my_tuple_t))
-#define M_OPL_my_tuple_of_tuple_t() TUPLE_OPLIST(my_tuple_of_tuple)
+#define M_OPL_my_tuple_of_tuple_t() TUPLE_OPLIST(my_tuple_of_tuple, STRING_OPLIST, M_OPL_my_tuple_t() )

 LIST_DEF(list_of_tuple_of_tuple, my_tuple_of_tuple_t)
 #define M_OPL_list_of_tuple_of_tuple_t() LIST_OPLIST(list_of_tuple_of_tuple, M_OPL_my_tuple_of_tuple_t() )
@@ -37,11 +37,11 @@ BUFFER_DEF(trbuff, my_triple_tuple_t, 100, BUFFER_QUEUE)
 #define M_OPL_trbuff_t() BUFFER_OPLIST(trbuff, M_OPL_my_triple_tuple_t())

 TUPLE_DEF2(my_junction, (active, bool), (buffer, trbuff_t))
-#define M_OPL_my_junction_t() TUPLE_OPLIST(my_junction, M_DEFAULT_OPLIST, M_OPL_trbuff_t())
+#define M_OPL_my_junction_t() TUPLE_OPLIST(my_junction, M_BASIC_OPLIST, M_OPL_trbuff_t())
           
 TUPLE_DEF2(mlib_point, (x, int), (y, int))
 #define M_OPL_mlib_point_t()                                            \
-  TUPLE_OPLIST(mlib_point, M_DEFAULT_OPLIST, M_DEFAULT_OPLIST)
+  TUPLE_OPLIST(mlib_point, M_BASIC_OPLIST, M_BASIC_OPLIST)

 TUPLE_DEF2(mlib_points, (first_ref, mlib_point_ptr, M_PTR_OPLIST),
           (second_ref, mlib_point_ptr, M_PTR_OPLIST),
@@ -3,7 +3,14 @@
 #include "m-array.h"
 #include "m-string.h"

-// Let's create an array of string_t and register it globaly
+/* This example show ARRAY_DEF usage with string,
+   M_LET macro usage with complex initialization condition:
+   how to initialize a dynamic array and initialize it with the given arguments.
+   It show also the M_EACH keywork
+*/
+
+// Let's create a dynamic array of string_t and register it globaly
+// a so called std::vector<std::string> in C++
 ARRAY_DEF(vector_string, string_t)
 #define M_OPL_vector_string_t() ARRAY_OPLIST(vector_string, STRING_OPLIST)

@@ -0,0 +1,16 @@
+/*
+ * Micro example to test if M*LIB supports not using stdio.h
+ */
+#define M_USE_STDIO 0
+#define M_RAISE_FATAL(...) abort()
+#include "m-array.h"
+
+ARRAY_DEF(arr, int)
+
+int main(void) {
+    arr_t a;
+    arr_init(a);
+    arr_push_back(a, 4);
+    arr_clear(a);
+    return 0;
+}
@@ -5,8 +5,7 @@
 #include "m-rbtree.h"

 // Let's define one utility function.
-void *xmalloc(size_t n);
-void *xmalloc(size_t n)
+static void *xmalloc(size_t n)
 {
  void *p = malloc (n);
  if (!p) abort();
@@ -20,6 +20,9 @@ static void main_macrofree(void)
    // Overwrite element 1 of the array.
    str_array_set_at(tab_name, 1, STRING_CTE("DVD"));

+    // Finaly rewrite 1 element of the array
+    string_set_str(*str_array_get(tab_name, 1), "BLU-RAY");
+    
    // Format some strings and push them back in the array
    string_t format;
    string_init_printf(format, "There are %d elements", str_array_size(tab_name));
@@ -54,6 +57,9 @@ static void main_macro(void)
        // Overwrite element 1 of the array.
        str_array_set_at(tab_name, 1, STRING_CTE("DVD"));

+        // Finaly rewrite 1 element of the array
+        string_set_str(*str_array_get(tab_name, 1), "BLU-RAY");
+    
        // Format some strings and push them back in the array
        M_LET(format, string_t) {
            string_printf(format, "There are %d elements", str_array_size(tab_name));
@@ -67,7 +73,7 @@ static void main_macro(void)
            // Set format to a formated string
            // In C11, we can mix string_t and char *.
            // We can also use M_CSTR to create a printf formated string.
-            string_sets(format, "FILE=", getenv("PWD"), "/", *str_array_get(tab_name, 2), M_CSTR("-%d.txt", str_array_size(tab_name) ));
+            string_sets(format, "FILE=", getenv("PWD"), "/", *str_array_get(tab_name, 2), M_CSTR("-%zu.txt", str_array_size(tab_name) ));
            str_array_push_back(tab_name, format);
 #endif
        } // beyond this point format is cleared
@@ -0,0 +1,45 @@
+#include <stdio.h>
+#include "m-string.h"
+#include "m-dict.h"
+#include "m-array.h"
+
+/* Definition of an associative map string_t --> size_t */
+DICT_DEF2(dict_str, string_t, size_t)
+#define M_OPL_dict_str_t() DICT_OPLIST(dict_str, STRING_OPLIST, M_BASIC_OPLIST)
+
+/* Definition of an array of string_t */
+ARRAY_DEF(vector_str, string_t)
+#define M_OPL_vector_str_t() ARRAY_OPLIST(vector_str, STRING_OPLIST)
+
+int main(void)
+{
+    // Construct an array of string, performing a convertion of the C const char *
+    // into a proper string_t at real time and push then into a dynamic array
+    // that is declared, initialized and cleared.
+    M_LET( (words, ("This"), ("is"), ("a"), ("useless"), ("sentence"), ("."),
+                    ("It"), ("is"), ("used"), ("a"), ("bit"), ("to"), ("count"), ("words"), (".") ),
+                    vector_str_t) {
+        // Print the arrays.
+        printf("The words are: ");
+        vector_str_out_str(stdout, words);
+        printf("\n");
+
+        // Count the words.
+        M_LET(map, dict_str_t) {
+            // Count the words into the dictionnary 'map'
+            for M_EACH(w, words, vector_str_t) {
+                (*dict_str_safe_get(map, *w)) ++;
+            }
+
+            // Print the count:
+            for M_EACH(p, map, dict_str_t) {
+                // In C11 version we can use the M_PRINT macro that simplifies formatting.
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L)            
+                M_PRINT(p->value, " occurences of ", p->key, "\n");
+#else
+                printf ("%zu occurences of %s\n", p->value, string_get_cstr(p->key));
+#endif
+            }
+        }
+    }
+}
@@ -5,20 +5,21 @@
 #include "m-serial-json.h"
 #include "m-string.h"

-/* Define the employee */
+/* Define the employee class */
 TUPLE_DEF2(employee,
           (name, string_t),
           (age, int),
           (idnum, int))
-#define M_OPL_employee_t() TUPLE_OPLIST(employee, STRING_OPLIST, M_DEFAULT_OPLIST, M_DEFAULT_OPLIST)
+/* Register globaly the employee_t oplist */
+#define M_OPL_employee_t() TUPLE_OPLIST(employee, STRING_OPLIST, M_BASIC_OPLIST, M_BASIC_OPLIST)

-/* Define an array of employee and some algorithms on it */
+/* Define an array of employee, register the oplist and define further algorithms on it */
 ARRAY_DEF(vector_employee, employee_t)
 #define M_OPL_vector_employee_t() ARRAY_OPLIST(vector_employee, M_OPL_employee_t())
 ALGO_DEF(vector_employee, vector_employee_t)

-/* Define the function object to select the sort order
- * named 'compare_by' which is an instance of the interface
+/* Define the function object to select the sort order.
+ * It is named 'compare_by' and is an instance of the interface
 * 'vector_employee_cmp_obj' created by ALGO_DEF.
 */
 FUNC_OBJ_INS_DEF(compare_by /* name of the instance */,
@@ -75,15 +76,12 @@ int main(void)
    // Sort the database by employee ID number
    M_LET( (cmp, STRING_CTE("idnum")), compare_by_t )
      vector_employee_sort_fo(emps, compare_by_as_interface(cmp));
-    printf("Employees sorted by idnum are: ");
-    vector_employee_out_str(stdout, emps);
+    M_PRINT("Employees sorted by idnum are: ", (emps, vector_employee_t), "\n" );

    // Sort the database by employee name
    M_LET( (cmp, STRING_CTE("name")), compare_by_t )
      vector_employee_sort_fo(emps, compare_by_as_interface(cmp));
-    printf("\nEmployees sorted by name are: ");
-    vector_employee_out_str(stdout, emps);
-    printf("\n");
+    M_PRINT("Employees sorted by name are: ", (emps, vector_employee_t), "\n" );

    // End
  }
@@ -0,0 +1,232 @@
+#include <stdio.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include "m-tuple.h"
+#include "m-tree.h"
+#include "m-worker.h"
+#include "m-string.h"
+#include "m-atomic.h"
+
+
+/* Define the comparison function for atomic_uint type
+   to sort the atomic unsigned int with the biggest value first. */
+static inline int atomic_uint_cmp(const atomic_uint *a, const atomic_uint *b)
+{
+  unsigned ai = atomic_load(a), bi = atomic_load(b);
+  return ai > bi ? -1 : ai < bi;
+}
+
+/* Define the oplist for atomic_uint and register it globally.
+   This oplist extends the basic oplist by:
+   * disabling HASH for atomic as the default hash method won't work.
+   * providing the methods for CMP, INIT_SET and SET operators (with their API adaptator) */
+#define M_OPL_atomic_uint() M_OPEXTEND(M_BASIC_OPLIST, HASH(0), CMP(API_6(atomic_uint_cmp)), INIT_SET(API_2(atomic_store)), SET(API_2(atomic_store)))
+
+
+/* Define a directory as a tree where each node contains:
+   * the number of lines of the files in this directory,
+   * and the name of the directory/
+   Since we want to sort with the number of lines only, we extend the oplist of a string by disabling the compare method.
+   So first, let's define the node as a tuple of such elements:
+*/
+M_TUPLE_DEF2( dir, (nlines, atomic_uint), (name, m_string_t, M_OPEXTEND(M_STRING_OPLIST, CMP(0))))
+/* Register globally the oplist of this tuple */
+#define M_OPL_dir_t() M_TUPLE_OPLIST(dir, M_OPL_atomic_uint(), M_STRING_OPLIST)
+
+/* Define a hierarchical tree of directory.
+   Note that it will use the globally registered oplist associated to dir_t to use it */
+M_TREE_DEF(tree, dir_t)
+
+
+/* Maximum number of characters read by file */
+#define MAX_READ_BUFFER 8192
+
+/* Maximum number of directory to scan */
+#define MAX_DIRECTORY 100000
+
+
+/* Define the pool of worker threads */
+m_worker_t workers;
+
+/* Global synchronous block for all threads */
+m_worker_sync_t workers_block;
+
+/* Add a specialization of the spawn function for the scan_file function.
+   This functions takes as input an iterator of a tree (treated as a POD data),
+   and a file name */
+M_WORKER_SPAWN_DEF2(scan_file, (parent, tree_it_t, M_POD_OPLIST), (filename, m_string_t) )
+
+
+/* Add either the root node or a child to parent in function of the existence of parent */
+static tree_it_t
+add_directory(tree_it_t parent, const m_string_t dirname)
+{
+  if (tree_end_p(parent)) {
+    return tree_emplace_root( tree_tree(parent), 0, dirname);
+  } else {
+    return tree_emplace_child(parent, 0, dirname);
+  }
+}
+
+/* count the number of end of line character in the buffer */
+static unsigned
+count_eol(size_t num, const char buffer[num])
+{
+  unsigned count = 0;
+  for(size_t i = 0; i < num; i++) {
+    count += buffer[i] == '\n';
+  }
+  return count;
+}
+
+/* Test if a filename suffix ends with a C++ or C suffix */
+static bool
+is_a_c_file(const m_string_t filename)
+{
+  return (m_string_end_with_str_p(filename, ".c")
+    || m_string_end_with_str_p(filename, ".h")
+    || m_string_end_with_str_p(filename, ".cpp")
+    || m_string_end_with_str_p(filename, ".hpp"));
+}
+
+/* Scan the file and count its number of lines */
+static void
+scan_file(tree_it_t parent, m_string_t filename)
+{
+  FILE *f = fopen(m_string_get_cstr(filename), "rt");
+  if (f == NULL) {
+    fprintf(stderr, "ERROR: Cannot open %s as a text file.\n", m_string_get_cstr(filename) );
+    exit(1);
+  }
+
+  /* Read the FILE per bulk of MAX_READ_BUFFER */
+  char buffer[MAX_READ_BUFFER];
+  unsigned count = 0;
+  size_t num;
+  do {
+    num = fread (buffer, 1, MAX_READ_BUFFER, f);
+    count += count_eol(num, buffer);
+  } while (num == MAX_READ_BUFFER);
+  fclose(f);
+
+  /* Adding the number of lines to the parent directory */
+  dir_t *d = tree_ref(parent);
+  /* atomic add because the scan of files is done in parallel */
+  atomic_fetch_add( &(*d)->nlines, count );
+}
+
+/* Scan the directories recursively for all files */
+static void
+scan_directories(tree_it_t parent, const m_string_t dirname)
+{
+  tree_it_t it = add_directory(parent, dirname);
+
+  m_string_t filename;
+  m_string_init(filename);
+  DIR *dir = opendir(m_string_get_cstr(dirname));
+  if (dir == NULL) {
+    fprintf(stderr, "ERROR: Cannot open %s as a directory.\n", m_string_get_cstr(dirname) );
+    exit(1);
+  }
+
+  // Scan all entries in the directory
+  struct dirent *entry = readdir(dir);
+  while (entry) {
+    // Ignore hidden entries (including '.' and '..')
+    if (entry->d_name[0] != '.') {
+      // Construct the path to the filename by concatenating dirname, "/" and d_name
+      m_string_sets(filename, dirname, "/", entry->d_name);
+      // Get the property of this filename
+      struct stat buf;
+      int err = stat(m_string_get_cstr(filename), &buf);
+      if (err != 0) {
+        fprintf(stderr, "ERROR: Cannot stat %s\n", m_string_get_cstr(filename));
+        exit(2);
+      }
+      // Further scanning in function of the kind of entry
+      if (S_ISDIR(buf.st_mode)) {
+        scan_directories(it, filename);
+      } else if (is_a_c_file(filename)) {
+        // Spawn a scan of file to available workers or run it ourselves
+        m_worker_spawn_scan_file(workers_block, scan_file, it, filename);
+      }
+    }
+    // Next entry in the directory
+    entry = readdir(dir);
+  }
+  
+  closedir(dir);
+  m_string_clear(filename);
+}
+
+/* Consolidate all lines number to the parent directory */
+static void
+consolidate_directories(tree_t directories)
+{
+  // Scan all entries, first the children, then the parent
+  for(tree_it_t it = tree_it_post(directories) ; !tree_end_p(it) ; tree_next_post(&it) ) {
+    dir_t *parent = tree_up_ref(it);
+    dir_t *myself = tree_ref(it);
+    if (parent != NULL) {
+      // Add the child number of lines to the parent
+      atomic_fetch_add_explicit(&(*parent)->nlines, (*myself)->nlines, memory_order_relaxed);
+    }
+    // Sort the data of the children by the number of lines
+    tree_sort_child(it);
+  }
+}
+
+/* Print the consolidated results on stdout */
+static void
+print_result(tree_t directories)
+{
+  // Scan all entries, first the parent, then the children
+  for(tree_it_t it = tree_it(directories) ; !tree_end_p(it) ; tree_next(&it) ) {
+    int i, depth = tree_depth(it);
+    for(i = 0; i < depth; i++) printf("+");
+    for(     ; i < 8; i++) printf(" ");
+    const dir_t *d = tree_cref(it);
+    printf("%6u %s\n", (unsigned) (*d)->nlines, m_string_get_cstr( (*d)->name ) );
+  }
+}
+
+int main(int argc, const char *argv[])
+{
+  tree_t directories;
+  m_string_t str;
+
+  printf("Count the number of C/C++ lines of code\n");
+  if (argc < 2) {
+    fprintf(stderr, "ERROR. Usage is '%s <directory>'.\n", argv[0]);
+    exit(1);
+  }
+
+  /* Initialize the worker threads */
+  m_worker_init(workers);
+  
+  /* Init the tree, reserve for at least the number of max directory
+    and prevent any further increase of allocation:
+    this is to ensure that other threads can deref a dir safely */
+  tree_init(directories);
+  tree_reserve(directories, MAX_DIRECTORY);
+  tree_lock(directories, true);
+  m_string_init_set_cstr(str, argv[1]);
+  tree_it_t it = tree_it_end(directories);
+
+  /* Main processing */
+  m_worker_start(workers_block, workers);
+  scan_directories(it, str);
+  worker_sync(workers_block);
+  consolidate_directories(directories);
+  print_result(directories);
+
+  /* Clear everything & quit */
+  m_string_clear(str);
+  tree_clear(directories);
+  m_worker_clear(workers);
+
+  exit(0);
+}
@@ -0,0 +1,82 @@
+// Based on https://github.com/nanopb/nanopb/blob/master/examples/simple/simple.c
+#include <stdio.h>
+
+#include "m-serial-json.h"
+#include "m-tuple.h"
+#include "m-string.h"
+
+// Define a structure with one field
+TUPLE_DEF2(SimpleMessage,
+           (lucky_number, int))
+
+int main(void)
+{
+  string_t buffer;
+  m_serial_return_code_t status;
+
+  /* Let's define a string 'buffer' that will receive the JSON representation of our message*/
+  string_init(buffer);
+
+  /* Encode our message */
+  {
+    SimpleMessage_t message;
+    SimpleMessage_init(message);
+    
+    /* Create a stream that will write to our string buffer. */
+    m_serial_str_json_write_t stream;
+    m_serial_str_json_write_init(stream, buffer);
+        
+    /* Fill in the lucky number */
+    message->lucky_number = 13;
+        
+    /* Now we are ready to encode the message! */
+    status = SimpleMessage_out_serial(stream, message);
+    
+    /* Then just check for any errors.. */
+    if (status != M_SERIAL_OK_DONE)
+      {
+        printf("Encoding failed: %d\n", status);
+        return 1;
+      }
+
+    /* Clear the objets */
+    m_serial_str_json_write_clear(stream);
+    SimpleMessage_clear(message);
+  }
+  
+  /* Now we could transmit the message over network, store it in a file
+   * It is represented in a string 'buffer'
+   * but we are doing it right now.
+   */
+  
+  {
+    /* Allocate another space for the decoded message. */
+    SimpleMessage_t message;
+    SimpleMessage_init(message);
+    
+    /* Create a stream that reads from the buffer. */
+    m_serial_str_json_read_t stream;
+    m_serial_str_json_read_init(stream, string_get_cstr(buffer));
+    
+    /* Now we are ready to decode the message. */
+    status = SimpleMessage_in_serial(message, stream);
+    
+    /* Check for errors... */
+    if (status != M_SERIAL_OK_DONE)
+      {
+        printf("Decoding failed: %d\n", status);
+        return 1;
+      }
+    
+    /* Print the data contained in the message. */
+    printf("Your lucky number was %d!\n", message->lucky_number);
+
+    /* Clear the objets */
+    m_serial_str_json_read_clear(stream);
+    SimpleMessage_clear(message);
+  }
+
+  string_clear(buffer);
+  
+  return 0;
+}
@@ -2,6 +2,8 @@
 #include "m-tuple.h"
 #include "m-array.h"

+/* Basic example to show JSON serialization */
+
 // Let's define a 'person' composed of several fields.
 TUPLE_DEF2(person,
           (surname, string_t),
@@ -9,7 +11,7 @@ TUPLE_DEF2(person,
           (present, bool)
           )
 // Register the oplist of this tuple globaly
-#define M_OPL_person_t() TUPLE_OPLIST(person, M_DEFAULT_OPLIST, STRING_OPLIST, M_DEFAULT_OPLIST )
+#define M_OPL_person_t() TUPLE_OPLIST(person, STRING_OPLIST, M_BASIC_OPLIST, M_BOOL_OPLIST )

 // Let's define an array of person
 ARRAY_DEF(base, person_t)
@@ -48,6 +50,7 @@ int main(void)
  M_LET(base, base_t) {
    // Read the JSON file and fill-in base
    read(base, "ex11-json01.json");
+    base_emplace_back(base, STRING_CTE("John"), 40, false);
    // Print the contents of base:
    printf ("List of presents:\n");
    for M_EACH(el, base, base_t) {
@@ -0,0 +1,243 @@
+#if HAVE_GMP && HAVE_MPFR
+
+#include <stdio.h>
+#include <gmp.h>
+#include <mpfr.h>
+
+#include "m-variant.h"
+#include "m-string.h"
+#include "m-dict.h"
+#include "m-array.h"
+#include "m-algo.h"
+
+// GMP doesn't provide a fast hash function (It is needed for being able to use mpz_t as key in a hashmap)
+static inline size_t
+mpz_fast_hash(const mpz_t z)
+{
+  mp_size_t  n = z->_mp_size;
+  mp_limb_t *p = z->_mp_d;
+  M_HASH_DECL(hash);
+
+  if (n <= 0) {
+    M_HASH_UP (hash, 0x7F5C1458);
+    if (n == 0) {
+      return M_HASH_FINAL (hash);
+    }
+    n = -n;
+  }
+  while (n-- > 0) {
+    M_HASH_UP (hash, *p++);
+  }
+  return M_HASH_FINAL (hash);
+}
+
+/* Define the OPLIST of a mpz_t and register it globally */
+#define M_OPL_mpz_t()                                                   \
+  (INIT(mpz_init), INIT_SET(mpz_init_set), SET(mpz_set), CLEAR(mpz_clear), \
+   INIT_WITH(API_1(M_INIT_WITH_THROUGH_EMPLACE_TYPE)),                  \
+   EQUAL( API( mpz_cmp, EQ(0), ARG1, ARG2)),                            \
+   CMP(mpz_cmp),                                                        \
+   HASH(mpz_fast_hash),                                                 \
+   OUT_STR( API( mpz_out_str, VOID, ARG1, 10, ARG2)),                   \
+   IN_STR( API( mpz_inp_str, GT(0), ARG1, ARG2, 10)),                   \
+   ADD(mpz_add), SUB(mpz_sub), MUL(mpz_mul), DIV(mpz_div),              \
+   EMPLACE_TYPE( LIST( (_si, mpz_init_set_si, int),                     \
+                       (_ui, mpz_init_set_ui, unsigned),                \
+                       (_d,  mpz_init_set_d,  double),                  \
+                       (_cstr, API(mpz_init_set_str, VOID, ARG1, ARG2, 10), const char *), \
+                       (_str, API(mpz_init_set_str, VOID, ARG1, ARG2, 10), char *) )), \
+   TYPE(mpz_t) )
+
+
+
+// MPFR doesn't provide a fast hash function (It is needed for being able to use mpz_t as key in a hashmap)
+static size_t
+mpfr_fast_hash (const mpfr_t f)
+{
+  mp_limb_t *p = f->_mpfr_d;
+  mp_size_t  n = (f->_mpfr_prec-1)/(sizeof(mp_limb_t)*CHAR_BIT)+1;
+  M_HASH_DECL (h);
+
+  M_HASH_UP (h, f->_mpfr_exp);
+
+  if (MPFR_SIGN (f) < 0)
+    M_HASH_UP (h, 1);
+
+  /* Special value: NAN, INF and ZERO */
+  if (mpfr_nan_p (f) || mpfr_inf_p (f) || mpfr_zero_p (f))
+    return M_HASH_FINAL (h);
+
+  /* Mantissa */
+  do {
+    M_HASH_UP (h, *p++);
+  } while (--n > 0);
+  return M_HASH_FINAL (h);
+}
+
+/* Define the OPLIST of a mpfr_t and register it globally */
+#define M_OPL_mpfr_t()                                                   \
+  (INIT(mpfr_init), INIT_SET(API(mpfr_init_set, VOID, ARG1, ARG2, MPFR_RNDN)), SET(API(mpfr_set, VOID, ARG1, ARG2, MPFR_RNDN)), CLEAR(mpfr_clear), \
+   INIT_WITH(API_1(M_INIT_WITH_THROUGH_EMPLACE_TYPE)),                  \
+   EQUAL( API( mpfr_cmp, EQ(0), ARG1, ARG2)),                            \
+   CMP(mpfr_cmp),                                                        \
+   HASH(mpfr_fast_hash),                                                 \
+   OUT_STR( API( mpfr_out_str, VOID, ARG1, 10, 0, ARG2, MPFR_RNDN)),     \
+   IN_STR( API( mpfr_inp_str, GT(0), ARG1, ARG2, 10, MPFR_RNDN)),        \
+   ADD( API(mpfr_add, VOID, ARG1, ARG2, ARG3, MPFR_RNDN)),               \
+   SUB( API(mpfr_sub, VOID, ARG1, ARG2, ARG3, MPFR_RNDN)),               \
+   MUL( API(mpfr_mul, VOID, ARG1, ARG2, ARG3, MPFR_RNDN)),               \
+   DIV( API(mpfr_div, VOID, ARG1, ARG2, ARG3, MPFR_RNDN)),               \
+   EMPLACE_TYPE( LIST( (_si, API(mpfr_init_set_si, VOID, ARG1, ARG2, MPFR_RNDN), int), \
+                       (_ui, API(mpfr_init_set_ui, VOID, ARG1, ARG2, MPFR_RNDN), unsigned), \
+                       (_d,  API(mpfr_init_set_d,  VOID, ARG1, ARG2, MPFR_RNDN), double), \
+                       (_ld, API(mpfr_init_set_ld, VOID, ARG1, ARG2, MPFR_RNDN), long double), \
+                       (_z,  API(mpfr_init_set_z,  VOID, ARG1, ARG2, MPFR_RNDN), mpz_t), \
+                       (_zptr,  API(mpfr_init_set_z,  VOID, ARG1, ARG2, MPFR_RNDN), mpz_ptr), \
+                       (_cstr, API(mpfr_init_set_str, VOID, ARG1, ARG2, 10, MPFR_RNDN), const char *), \
+                       (_str, API(mpfr_init_set_str, VOID, ARG1, ARG2, 10, MPFR_RNDN), char *) )), \
+   TYPE(mpfr_t) )
+
+
+/* Define a variant (aka a typed union) over three kind of numbers named my_number_t
+   Notice than mpz_t/mpfr_t has special init & clear functions.
+   This is handled by the library.
+*/
+VARIANT_DEF2(my_number,
+             (n, long long),
+             (z, mpz_t),
+             (fr, mpfr_t) )
+/* Register the oplist associated to this variant named my_number_t */
+#define M_OPL_my_number_t() VARIANT_OPLIST(my_number, M_BASIC_OPLIST, M_OPL_mpz_t(), M_OPL_mpfr_t() )
+
+
+/* Define a dictionary of string_t --> my_number_t named my_dict_t */
+DICT_DEF2(my_dict, string_t, my_number_t)
+/* Register the oplist associated to this dictionary named my_dict_t */
+#define M_OPL_my_dict_t() DICT_OPLIST(my_dict, STRING_OPLIST, M_OPL_my_number_t() )
+
+
+/* Define an array of such dictionary named my_array_t */
+ARRAY_DEF(my_array, my_dict_t)
+/* Register the oplist associated to this array (of dictionary of variant) named my_array_t*/
+#define M_OPL_my_array_t() ARRAY_OPLIST(my_array, M_OPL_my_dict_t())
+
+
+// Show how to define an array of mpz_t and some algorithms on it
+ARRAY_DEF(array_mpz, mpz_t)
+#define M_OPL_array_mpz_t() ARRAY_OPLIST(array_mpz, M_OPL_mpz_t())
+ALGO_DEF(array_mpz, array_mpz_t)
+
+// Show how to define an array of mpfr_t and some algorithms on it
+ARRAY_DEF(array_mpfr, mpfr_t)
+#define M_OPL_array_mpfr_t() ARRAY_OPLIST(array_mpfr, M_OPL_mpfr_t())
+ALGO_DEF(array_mpfr, array_mpfr_t)
+
+static void
+compute_roots(array_mpfr_t roots, const array_mpz_t pol)
+{
+  assert( array_mpz_size(pol) == 3);
+  // Initialize mpfr_t variables from the mpz_t values in the array 'pol'
+  M_LET( (a, (*array_mpz_get(pol, 0))),
+         (b, (*array_mpz_get(pol, 1))),
+         (c, (*array_mpz_get(pol, 2))),
+         delta, tmp, mpfr_t) {
+      // Reset the output array
+      array_mpfr_reset(roots);
+      // Compute the first root
+      mpfr_mul(delta, b, b, MPFR_RNDN);
+      mpfr_mul_ui(tmp, a, 4, MPFR_RNDN);
+      mpfr_mul(tmp, tmp, c, MPFR_RNDN);
+      mpfr_sub(delta, delta, tmp, MPFR_RNDN);
+      mpfr_sqrt(delta, delta, MPFR_RNDN);
+      mpfr_neg(tmp, b, MPFR_RNDN);
+      mpfr_add(tmp, tmp, delta, MPFR_RNDN);
+      mpfr_div(tmp, tmp, a, MPFR_RNDN);
+      mpfr_div_2ui(tmp, tmp, 1, MPFR_RNDN);
+      // Push first root
+      array_mpfr_push_back(roots, tmp);
+      // Compute second root
+      mpfr_neg(tmp, b, MPFR_RNDN);
+      mpfr_sub(tmp, tmp, delta, MPFR_RNDN);
+      mpfr_div(tmp, tmp, a, MPFR_RNDN);
+      mpfr_div_2ui(tmp, tmp, 1, MPFR_RNDN);
+      // Push second root
+      array_mpfr_push_back(roots, tmp);
+  } // Clear the mpfr_t variables after this point.
+}
+
+int main(void)
+{
+  M_LET(z, my_number_t)               /* Define & init & clear an instance of a variant of my_number_t */
+    M_LET(dict, my_dict_t)            /* Define & init & clear an instance of a dictionary of variant */
+    M_LET(array, my_array_t)          /* Define & init & clear an intance of an array of dictionary of variant */
+    M_LET(gmp, mpz_t)                 /* M_LET allows even with non container type */
+    {
+      my_number_set_n (z, 17LL);                 // Set z as the long long 17
+      my_dict_set_at(dict, STRING_CTE("n1"), z); // Push it in the dictionary
+
+      mpz_set_str(gmp, "25446846874687468746874687468746874686874", 10); // Set gmp to a very long integer.
+      my_number_set_z (z, gmp);                  // Set z as the mpz_t variable
+      my_dict_set_at(dict, STRING_CTE("n2"), z); // Push it in the dictionary
+
+      my_array_push_back (array, dict);          // Push the dictionary in the array
+
+      // Let's add a new element in the array through a mpfr_t set to 42.17
+      M_LET( (fr, ("42.17")), mpfr_t) {
+        my_number_set_fr(z, fr);                // Set z as this variable.
+      }
+      my_dict_set_at(dict, STRING_CTE("n3"), z); // Push it in the dictionary
+
+      my_number_emplace_fr_si(z, 42);            // Directly emplace the variant as a mpfr_t with a signed integer for init
+      my_dict_set_at(dict, STRING_CTE("n4"), z); // Push it in the dictionary
+
+      my_number_emplace_z_ui(z, 189);            // Directly emplace the variant as a mpz_t with an unsigned integer for init
+      my_dict_set_at(dict, STRING_CTE("n5"), z); // Push it in the dictionary
+      
+      my_array_push_back (array, dict);          // Push the dictionary in the array
+        
+      // Iterate over the array container
+      for M_EACH(item, array, my_array_t) {
+          // Iterate over the dictionary '*item' container which is of type my_dict_t
+          for M_EACH(p, *item, my_dict_t) {
+              // Dictionary iterator are pair (key,value)
+              printf("Key is '%s'. ", string_get_cstr(p->key));
+              // In function of the type of value
+              if (my_number_n_p(p->value)) {
+                // Print it. 
+                M_PRINT("It is a long long, value = ", *my_number_cget_n(p->value), "\n");
+              }
+              if (my_number_z_p(p->value)) {
+                // Print it. Since mpz_t isn't a native type, M_PRINT macro doesn't know it by default
+                // So we need to add the type to the value.
+                // M_PRINT will then look at its globally registered oplist
+                // and known how to print it.
+                M_PRINT("It is a mpz_t, value = ", (*my_number_cget_z(p->value), mpz_t), "\n");
+              }
+              if (my_number_fr_p(p->value)) {
+                // Same but with a MPFR number.
+                M_PRINT("It is a mpfr_t, value = ", (*my_number_cget_fr(p->value), mpfr_t), "\n");
+              }
+            }
+          printf("Next element of array\n");
+        }
+      
+      // Print all the array in one step. Need to be done in C11 only
+      M_PRINT("\nThe array is equal to ", (array, my_array_t), "\n");
+    } /* All variables are automatically cleared beyond this point */
+
+    // Define an array of mpz_t as { 1, 2, 1 } (with auto promotion from integer / string / double)
+    // The auto-promotion uses _Generic feature and is available only in C11.
+    M_LET ( (az, (1), ("2"), (1.0)), array_mpz_t)
+    M_LET ( roots, array_mpfr_t) {
+      // Compute roots
+      compute_roots(roots, az);
+      // Display of roots:
+      M_PRINT("Roots of ", (az, array_mpz_t), " are ", (roots, array_mpfr_t), "\n");
+    }
+
+}
+
+#else
+// Nothing to do
+int main(void) { return 0; }
+#endif
@@ -0,0 +1,106 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+#include "m-rbtree.h"
+#include "m-string.h"
+
+// Let's define a Red Black Tree over the constant C strings
+// Notice that we need to specify the oplist for this case
+// so that M*LIB handle the pointers to const char correctly. 
+RBTREE_DEF(tree_cstr, const char *, M_CSTR_OPLIST)
+
+// The classic C way
+// It is probably the best for beginner in M*LIB to start like this.
+static void classic1(void)
+{
+  tree_cstr_t tree;
+
+  tree_cstr_init(tree);
+
+  tree_cstr_push (tree, "Hello");
+  tree_cstr_push (tree, "World");
+  tree_cstr_push (tree, "How");
+  tree_cstr_push (tree, "Are");
+  tree_cstr_push (tree, "You");
+
+  printf("\nUsing C string, the generated (sorted) tree is ");
+  tree_cstr_out_str(stdout, tree);
+  printf ("\n");
+
+  const char *present = tree_cstr_get(tree, "How") == NULL ? "not " : "";
+  printf("The word 'How' is %spresent\n", present);
+
+  present = tree_cstr_get(tree, "Not") == NULL ? "not " : "";
+  printf("The word 'Not' is %spresent\n", present);
+
+  tree_cstr_clear(tree);
+}
+
+
+// Let's define another Red Black Tree over the M*LIB strings
+// Notice that we don't need to specify the oplist for this case.
+RBTREE_DEF(tree_str, string_t)
+
+// The classic C way
+// It is probably the best for beginner in M*LIB to start like this.
+static void classic2(void)
+{
+  tree_str_t tree;
+
+  tree_str_init(tree);
+
+  // STRING_CTE enables to construct a temporary const string_t from a const char *
+  // usable for function call.
+  tree_str_push (tree, STRING_CTE("Hello"));
+  tree_str_push (tree, STRING_CTE("World"));
+  tree_str_push (tree, STRING_CTE("How"));
+  tree_str_push (tree, STRING_CTE("Are"));
+  tree_str_push (tree, STRING_CTE("You"));
+
+  printf("\nUsing M*LIB string_t, the generated (sorted) tree is ");
+  tree_str_out_str(stdout, tree);
+  printf ("\n");
+
+  const char *present = tree_str_get(tree, STRING_CTE("How")) == NULL ? "not " : "";
+  printf("The word 'How' is %spresent\n", present);
+
+  present = tree_str_get(tree, STRING_CTE("Not")) == NULL ? "not " : "";
+  printf("The word 'Not' is %spresent\n", present);
+
+  tree_str_clear(tree);
+}
+
+
+// Registering the oplist helps writting the macro
+// as we can only refer to the type in the macro.
+#define M_OPL_tree_str_t() RBTREE_OPLIST(tree_str, STRING_OPLIST)
+
+static void macro(void)
+{
+  // Using macro (shorter but may be unfamiliar syntax for novive with M*LIB)
+  // This will declare the variable 'tree' as a 'tree_str_t' and initialize with
+  // the given initialization list '("Hello"), ("World"), ("How"), ("Are"), ("You")'
+  // The strings are given within '()' so that the constructor performs an emplace
+  // of the value to push in the tree (to initialize a string_t with a const char * type)
+  // instead of a push (which takes a compliant string_t as argument).
+  // An alternative is to use STRING_CTE for the arguments.
+  M_LET( (tree, ("Hello"), ("World"), ("How"), ("Are"), ("You")), tree_str_t) {
+    // In C11, the M_PRINT macro allows the use of a simplified syntax for printing.
+    M_PRINT("\nUsing M*LIB string_t + macro, the generated (sorted) tree is ", (tree, tree_str_t), "\n");
+    
+    const char *present = tree_str_get(tree, STRING_CTE("How")) == NULL ? "not " : "";
+    printf("The word 'How' is %spresent\n", present);
+    
+    present = tree_str_get(tree, STRING_CTE("Not")) == NULL ? "not " : "";
+    printf("The word 'Not' is %spresent\n", present);
+  }
+}
+  
+int main(void)
+{
+  classic1();
+  classic2();
+  macro();
+  return 0;
+}
@@ -7,7 +7,7 @@

 // Let's define a tuple composed of (offset, value) and register it
 TUPLE_DEF2(symbol, (offset, long), (value, long))
-#define M_OPL_symbol_t() TUPLE_OPLIST(symbol, M_DEFAULT_OPLIST, M_DEFAULT_OPLIST)
+#define M_OPL_symbol_t() TUPLE_OPLIST(symbol, M_BASIC_OPLIST, M_BASIC_OPLIST)

 // Let's define an array of such tuple and register it
 ARRAY_DEF(array_symbol, symbol_t)
@@ -0,0 +1,88 @@
+/* Based on the example of STC https://github.com/tylov/STC */
+#include "m-dict.h"
+#include "m-array.h"
+#include "m-deque.h"
+#include "m-list.h"
+#include "m-rbtree.h"
+#include "m-algo.h"
+#include "m-tuple.h"
+
+// NOTE: After each definition of a container, we register its oplist
+// It is not mandatory, but it makes the code easier to write and read.
+
+// Define a basic structure (POD structure) using a tuple to get the default functions
+TUPLE_DEF2(Point, (x, float), (y, float))
+#define M_OPL_Point_t() TUPLE_OPLIST(Point, M_BASIC_OPLIST, M_BASIC_OPLIST)
+
+// NOTE: array, list, deque don't have a native find function.
+// We'll use the algorithm header to create a find function for such containers.
+
+// Define a set of int & register its oplist
+DICT_SET_DEF(cset_i, int)
+#define M_OPL_cset_i_t() DICT_SET_OPLIST(cset_i, M_BASIC_OPLIST)
+
+// Define an array of Point, register its oplist & include some basic algorithms
+ARRAY_DEF(cvec_p, Point_t)
+#define M_OPL_cvec_p_t() ARRAY_OPLIST(cvec_p, M_OPL_Point_t())
+ALGO_DEF(cvec_p, cvec_p_t)
+
+// Define a deque of int, including some basic algorithms
+DEQUE_DEF(cdeq_i, int)
+#define M_OPL_cdeq_i_t() DEQUE_OPLIST(cdeq_i, M_BASIC_OPLIST)
+ALGO_DEF(cdeq_i, cdeq_i_t)
+
+// Define a backward list, including some basic algorithms
+LIST_DEF(clist_i, int)
+#define M_OPL_clist_i_t() LIST_OPLIST(clist_i, M_BASIC_OPLIST)
+ALGO_DEF(clist_i, clist_i_t)
+
+// Define an unordered map of int to int
+DICT_DEF2(csmap_i, int, int)
+#define M_OPL_csmap_i_t() DICT_OPLIST(csmap_i, M_BASIC_OPLIST, M_BASIC_OPLIST)
+
+int main(void)
+{
+  // Define, init & set the different containers.
+  M_LET( (set, 10, 20, 30), cset_i_t)
+    M_LET( (vec, (10, 1), (20, 2), (30, 3) ), cvec_p_t)
+    M_LET( (deq, 10, 20, 30), cdeq_i_t)
+    M_LET( (lst, 10, 20, 30), clist_i_t)
+    M_LET( (map, (20, 2), (10, 1), (30,3) ), csmap_i_t) {
+    
+    // add one more element to each container
+    cset_i_push(set, 40);
+    cvec_p_push_back(vec, (Point_t) {{40, 4}} );
+    cdeq_i_push_front(deq, 5);
+    clist_i_push_back(lst, 5);
+    csmap_i_set_at(map, 40, 4);
+
+    M_PRINT("vec= ", (vec, cvec_p_t));
+    
+    // Find an element (either native or through the algo header)
+    int *i1 = cset_i_get(set, 20);
+    cvec_p_it_t i2; cvec_p_find(i2, vec, (Point_t) {{20, 2}});
+    cdeq_i_it_t i3; cdeq_i_find(i3, deq, 20);
+    clist_i_it_t i4; clist_i_find(i4, lst, 20);
+    int *i5 = csmap_i_get(map, 20);
+    printf("\nFound: %d, (%g, %g), %d, %d, [%d: %d]\n",
+           *i1,
+           (*cvec_p_ref(i2))->x, (*cvec_p_ref(i2))->y,
+           *cdeq_i_ref(i3),
+           *clist_i_ref(i4),
+           20, *i5);
+
+    // Erase the elements found (through key or through iterators)
+    cset_i_erase(set, *i1);
+    cvec_p_remove(vec, i2);
+    cdeq_i_remove(deq, i3);
+    clist_i_remove(lst, i4);
+    csmap_i_erase(map, *i5);
+
+    // Display everything in one call by using the registered print functions of the different types.
+    M_PRINT("After erasing elements found:\n",
+            "set: ", (set, cset_i_t), "\n",
+            "vec: ", (vec, cvec_p_t), "\n",
+            "deq: ", (deq, cdeq_i_t), "\n",
+            "map: ", (map, csmap_i_t), "\n");
+  }
+}
@@ -1,7 +1,7 @@
 /*
 * M*LIB - Thin stdatomic wrapper for C++ compatibility
 *
- * Copyright (c) 2017-2021, Patrick Pelissier
+ * Copyright (c) 2017-2023, Patrick Pelissier
 * All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
@@ -154,7 +154,7 @@ using std::memory_order_seq_cst;
 */
 #else

-#include "m-mutex.h"
+#include "m-thread.h"
 #include "m-core.h"

 M_BEGIN_PROTECTED_CODE
@@ -1,7 +1,7 @@
 /*
 * M*LIB - Concurrent memory pool allocator
 *
- * Copyright (c) 2017-2021, Patrick Pelissier
+ * Copyright (c) 2017-2023, Patrick Pelissier
 * All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
@@ -32,69 +32,69 @@
 M_BEGIN_PROTECTED_CODE

 /* Minimum number of nodes per group of nodes */
-#define C_MEMPOOL_MIN_NODE_PER_GROUP 16
+#define M_CMEMP00L_MIN_NODE_PER_GROUP 16

-#define C_MEMPOOL_DEF(name, type_t)                                           \
+#define M_C_MEMPOOL_DEF(name, type_t)                                         \
  M_BEGIN_PROTECTED_CODE                                                      \
-  C_MEMPOOL_DEF_SINGLY_LIST(name, type_t)                                     \
-  C_MEMPOOL_DEF_LF_QUEUE(name, type_t)                                        \
-  C_MEMPOOL_DEF_LFMP_THREAD_MEMPOOL(name, type_t)                             \
-  C_MEMPOOL_DEF_SYSTEM_ALLOC(name, type_t)                                    \
-  C_MEMPOOL_DEF_LF_MEMPOOL(name, type_t)                                      \
+  M_CMEMP00L_DEF_SINGLY_LIST(name, type_t)                                    \
+  M_CMEMP00L_DEF_LF_QUEUE(name, type_t)                                       \
+  M_CMEMP00L_DEF_LFMP_THREAD_MEMPOOL(name, type_t)                            \
+  M_CMEMP00L_DEF_SYSTEM_ALLOC(name, type_t)                                   \
+  M_CMEMP00L_DEF_LF_MEMPOOL(name, type_t)                                     \
  M_END_PROTECTED_CODE

 /* Classic internal Singly List without allocation */
-#define C_MEMPOOL_DEF_SINGLY_LIST(name, type_t)                               \
+#define M_CMEMP00L_DEF_SINGLY_LIST(name, type_t)                              \
                                                                              \
-  typedef struct M_C(name, _slist_node_s) {                                   \
-    struct M_C(name, _slist_node_s) *next;                                    \
+  typedef struct M_F(name, _slist_node_s) {                                   \
+    struct M_F(name, _slist_node_s) *next;                                    \
    type_t               data;                                                \
-  } M_C(name, _slist_node_ct);                                                \
+  } M_F(name, _slist_node_ct);                                                \
                                                                              \
-  typedef struct M_C(name, _slist_node_s) *M_C(name, _slist_ct)[1];           \
+  typedef struct M_F(name, _slist_node_s) *M_F(name, _slist_ct)[1];           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _slist_init)(M_C(name, _slist_ct) list)                           \
+  M_F(name, _slist_init)(M_F(name, _slist_ct) list)                           \
  {                                                                           \
    *list = NULL;                                                             \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _slist_push)(M_C(name, _slist_ct) list,                           \
-                        M_C(name, _slist_node_ct) *node)                      \
+  M_F(name, _slist_push)(M_F(name, _slist_ct) list,                           \
+                        M_F(name, _slist_node_ct) *node)                      \
  {                                                                           \
    node->next = *list;                                                       \
    *list = node;                                                             \
  }                                                                           \
                                                                              \
-  static inline M_C(name, _slist_node_ct) *                                   \
-  M_C(name, _slist_pop)(M_C(name, _slist_ct) list)                            \
+  static inline M_F(name, _slist_node_ct) *                                   \
+  M_F(name, _slist_pop)(M_F(name, _slist_ct) list)                            \
  {                                                                           \
    M_ASSERT (*list != NULL);                                                 \
-    M_C(name, _slist_node_ct) *node = *list;                                  \
+    M_F(name, _slist_node_ct) *node = *list;                                  \
    *list = node->next;                                                       \
    M_IF_DEBUG(node->next = NULL;)                                            \
    return node;                                                              \
  }                                                                           \
                                                                              \
  static inline bool                                                          \
-  M_C(name, _slist_empty_p)(M_C(name, _slist_ct) list)                        \
+  M_F(name, _slist_empty_p)(M_F(name, _slist_ct) list)                        \
  {                                                                           \
    return *list == NULL;                                                     \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _slist_move)(M_C(name, _slist_ct) list,                           \
-                         M_C(name, _slist_ct) src)                            \
+  M_F(name, _slist_move)(M_F(name, _slist_ct) list,                           \
+                         M_F(name, _slist_ct) src)                            \
  {                                                                           \
    *list = *src;                                                             \
    *src  = NULL;                                                             \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _slist_clear)(M_C(name, _slist_ct) list)                          \
+  M_F(name, _slist_clear)(M_F(name, _slist_ct) list)                          \
  {                                                                           \
-    M_C(name, _slist_node_ct) *it = *list, *next;                             \
+    M_F(name, _slist_node_ct) *it = *list, *next;                             \
    while (it) {                                                              \
      next = it->next;                                                        \
      M_MEMORY_DEL(it);                                                       \
@@ -123,25 +123,25 @@ M_BEGIN_PROTECTED_CODE
 */
 /* TODO: Optimize alignement to reduce memory consumption. NIL object can use [] 
   to reduce memory consumption too (non compatible with C++ ...) */
-#define C_MEMPOOL_DEF_LF_QUEUE(name, type_t)                                  \
+#define M_CMEMP00L_DEF_LF_QUEUE(name, type_t)                                 \
                                                                              \
-  typedef struct M_C(name, _lf_node_s) {                                      \
-    M_ATTR_EXTENSION _Atomic(struct M_C(name, _lf_node_s) *) next;            \
+  typedef struct M_F(name, _lf_node_s) {                                      \
+    M_ATTR_EXTENSION _Atomic(struct M_F(name, _lf_node_s) *) next;            \
    m_gc_atomic_ticket_ct                    cpt;                             \
-    M_C(name, _slist_ct)                     list;                            \
-  } M_C(name, _lf_node_t);                                                    \
+    M_F(name, _slist_ct)                     list;                            \
+  } M_F(name, _lf_node_t);                                                    \
                                                                              \
-  typedef struct M_C(name, _lflist_s) {                                       \
-    M_ATTR_EXTENSION _Atomic(M_C(name, _lf_node_t) *) head;                   \
+  typedef struct M_F(name, _lflist_s) {                                       \
+    M_ATTR_EXTENSION _Atomic(M_F(name, _lf_node_t) *) head;                   \
    char                       align1[M_ALIGN_FOR_CACHELINE_EXCLUSION];       \
-    M_ATTR_EXTENSION _Atomic(M_C(name, _lf_node_t) *) tail;                   \
+    M_ATTR_EXTENSION _Atomic(M_F(name, _lf_node_t) *) tail;                   \
    char                       align2[M_ALIGN_FOR_CACHELINE_EXCLUSION];       \
-    M_C(name, _lf_node_t)            nil;                                     \
-  } M_C(name, _lflist_ct)[1];                                                 \
+    M_F(name, _lf_node_t)            nil;                                     \
+  } M_F(name, _lflist_ct)[1];                                                 \
                                                                              \
  static inline void                                                          \
-  M_C(name, _lflist_init)(M_C(name, _lflist_ct) list,                         \
-                          M_C(name, _lf_node_t) *node)                        \
+  M_F(name, _lflist_init)(M_F(name, _lflist_ct) list,                         \
+                          M_F(name, _lf_node_t) *node)                        \
  {                                                                           \
    atomic_init(&list->head, node);                                           \
    atomic_init(&list->tail, node);                                           \
@@ -149,17 +149,17 @@ M_BEGIN_PROTECTED_CODE
  }                                                                           \
                                                                              \
  static inline bool                                                          \
-  M_C(name, _lflist_empty_p)(M_C(name, _lflist_ct) list)                      \
+  M_F(name, _lflist_empty_p)(M_F(name, _lflist_ct) list)                      \
  {                                                                           \
    return atomic_load(&list->tail) == atomic_load(&list->head);              \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _lflist_push)(M_C(name, _lflist_ct) list,                         \
-                          M_C(name, _lf_node_t) *node, m_core_backoff_ct bkoff) \
+  M_F(name, _lflist_push)(M_F(name, _lflist_ct) list,                         \
+                          M_F(name, _lf_node_t) *node, m_core_backoff_ct bkoff) \
  {                                                                           \
-    M_C(name, _lf_node_t) *tail;                                              \
-    M_C(name, _lf_node_t) *next;                                              \
+    M_F(name, _lf_node_t) *tail;                                              \
+    M_F(name, _lf_node_t) *next;                                              \
                                                                              \
    atomic_store_explicit(&node->next, &list->nil, memory_order_relaxed);     \
    m_core_backoff_reset(bkoff);                                              \
@@ -190,12 +190,12 @@ M_BEGIN_PROTECTED_CODE
                                            memory_order_relaxed);            \
  }                                                                           \
                                                                              \
-  static inline M_C(name, _lf_node_t) *                                       \
-  M_C(name, _lflist_pop)(M_C(name, _lflist_ct) list, m_core_backoff_ct bkoff) \
+  static inline M_F(name, _lf_node_t) *                                       \
+  M_F(name, _lflist_pop)(M_F(name, _lflist_ct) list, m_core_backoff_ct bkoff) \
  {                                                                           \
-    M_C(name, _lf_node_t) *head;                                              \
-    M_C(name, _lf_node_t) *tail;                                              \
-    M_C(name, _lf_node_t) *next;                                              \
+    M_F(name, _lf_node_t) *head;                                              \
+    M_F(name, _lf_node_t) *tail;                                              \
+    M_F(name, _lf_node_t) *next;                                              \
                                                                              \
    /* Reinitialize backoff */                                                \
    m_core_backoff_reset(bkoff);                                              \
@@ -236,18 +236,18 @@ M_BEGIN_PROTECTED_CODE
       provided that the node we return is older than the one we should return, \
       Therefore, we return the previous dummy head.                          \
       As such, it is not the original MSqueue algorithm. */                  \
-    M_IF_DEBUG(atomic_store(&head->next, (M_C(name, _lf_node_t) *) 0);)       \
+    M_IF_DEBUG(atomic_store(&head->next, (M_F(name, _lf_node_t) *) 0);)       \
   return head;                                                               \
  }                                                                           \
                                                                              \
  /* Dequeue a node if the node is old enough */                              \
-  static inline M_C(name, _lf_node_t) *                                       \
-  M_C(name, _lflist_pop_if)(M_C(name, _lflist_ct) list,                       \
+  static inline M_F(name, _lf_node_t) *                                       \
+  M_F(name, _lflist_pop_if)(M_F(name, _lflist_ct) list,                       \
                            m_gc_ticket_ct age, m_core_backoff_ct bkoff)      \
  {                                                                           \
-    M_C(name, _lf_node_t) *head;                                              \
-    M_C(name, _lf_node_t) *tail;                                              \
-    M_C(name, _lf_node_t) *next;                                              \
+    M_F(name, _lf_node_t) *head;                                              \
+    M_F(name, _lf_node_t) *tail;                                              \
+    M_F(name, _lf_node_t) *next;                                              \
                                                                              \
    m_core_backoff_reset(bkoff);                                              \
    while (true) {                                                            \
@@ -277,55 +277,55 @@ M_BEGIN_PROTECTED_CODE
          }                                                                   \
        }                                                                     \
    }                                                                         \
-    M_IF_DEBUG(atomic_store(&head->next, (M_C(name, _lf_node_t) *) 0);)       \
+    M_IF_DEBUG(atomic_store(&head->next, (M_F(name, _lf_node_t) *) 0);)       \
   return head;                                                               \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _lflist_clear)(M_C(name, _lflist_ct) list)                        \
+  M_F(name, _lflist_clear)(M_F(name, _lflist_ct) list)                        \
  {                                                                           \
    m_core_backoff_ct bkoff;                                                  \
    m_core_backoff_init(bkoff);                                               \
    while (true) {                                                            \
-      M_C(name, _lf_node_t) *node = M_C(name, _lflist_pop)(list, bkoff);      \
+      M_F(name, _lf_node_t) *node = M_F(name, _lflist_pop)(list, bkoff);      \
      if (node == NULL) break;                                                \
-      M_C(name, _lf_node_t) *next = atomic_load_explicit(&node->next,         \
+      M_F(name, _lf_node_t) *next = atomic_load_explicit(&node->next,         \
                                                         memory_order_relaxed); \
-      M_C(name, _slist_clear)(node->list);                                    \
+      M_F(name, _slist_clear)(node->list);                                    \
      M_MEMORY_DEL(node);                                                     \
      node = next;                                                            \
    }                                                                         \
    /* Dummy node to free too */                                              \
-    M_C(name, _lf_node_t) *dummy;                                             \
+    M_F(name, _lf_node_t) *dummy;                                             \
    dummy = atomic_load_explicit(&list->head, memory_order_relaxed);          \
-    M_C(name, _slist_clear)(dummy->list);                                     \
+    M_F(name, _slist_clear)(dummy->list);                                     \
    M_MEMORY_DEL(dummy);                                                      \
  }                                                                           \

 /* System node allocator: request memory to the system.
   As such it is a non Lock-Free path. */
-#define C_MEMPOOL_DEF_SYSTEM_ALLOC(name, type_t)                              \
+#define M_CMEMP00L_DEF_SYSTEM_ALLOC(name, type_t)                             \
                                                                              \
-  static inline M_C(name, _lf_node_t) *                                       \
-       M_C(name, _alloc_node)(unsigned int initial)                           \
+  static inline M_F(name, _lf_node_t) *                                       \
+       M_F(name, _alloc_node)(unsigned int initial)                           \
  {                                                                           \
-    M_C(name, _lf_node_t) * node;                                             \
-    node = M_MEMORY_ALLOC(M_C(name, _lf_node_t));                             \
-    if (M_UNLIKELY(node == NULL)) {                                           \
-      M_MEMORY_FULL(sizeof(M_C(name, _lf_node_t)));                           \
+    M_F(name, _lf_node_t) * node;                                             \
+    node = M_MEMORY_ALLOC(M_F(name, _lf_node_t));                             \
+    if (M_UNLIKELY_NOMEM (node == NULL)) {                                    \
+      M_MEMORY_FULL(sizeof(M_F(name, _lf_node_t)));                           \
      return NULL;                                                            \
    }                                                                         \
-    atomic_init(&node->next, (M_C(name, _lf_node_t) *) 0);                    \
+    atomic_init(&node->next, (M_F(name, _lf_node_t) *) 0);                    \
    atomic_init(&node->cpt, 0UL);                                             \
-    M_C(name, _slist_init)(node->list);                                       \
+    M_F(name, _slist_init)(node->list);                                       \
    for(unsigned i = 0; i < initial; i++) {                                   \
-      M_C(name, _slist_node_ct) *n;                                           \
-      n = M_MEMORY_ALLOC(M_C(name, _slist_node_ct));                          \
-      if (M_UNLIKELY(n == NULL)) {                                            \
-        M_MEMORY_FULL(sizeof(M_C(name, _lf_node_t)));                         \
+      M_F(name, _slist_node_ct) *n;                                           \
+      n = M_MEMORY_ALLOC(M_F(name, _slist_node_ct));                          \
+      if (M_UNLIKELY_NOMEM (n == NULL)) {                                     \
+        M_MEMORY_FULL(sizeof(M_F(name, _lf_node_t)));                         \
        return NULL;                                                          \
      }                                                                       \
-      M_C(name, _slist_push)(node->list, n);                                  \
+      M_F(name, _slist_push)(node->list, n);                                  \
    }                                                                         \
    return node;                                                              \
  }                                                                           \
@@ -386,160 +386,160 @@ M_BEGIN_PROTECTED_CODE

   As such it won't support more than ULONG_MAX sleep for all threads.
 */
-#define C_MEMPOOL_DEF_LFMP_THREAD_MEMPOOL(name, type_t)                       \
+#define M_CMEMP00L_DEF_LFMP_THREAD_MEMPOOL(name, type_t)                      \
                                                                              \
-  typedef struct M_C(name, _lfmp_thread_s) {                                  \
-    M_C(name, _slist_ct)  free;                                               \
-    M_C(name, _slist_ct)  to_be_reclaimed;                                    \
-    M_CACHELINE_ALIGN(align1, M_C(name, _slist_ct), M_C(name, _slist_ct));    \
-  } M_C(name, _lfmp_thread_ct);                                               \
+  typedef struct M_F(name, _lfmp_thread_s) {                                  \
+    M_F(name, _slist_ct)  free;                                               \
+    M_F(name, _slist_ct)  to_be_reclaimed;                                    \
+    M_CACHELINE_ALIGN(align1, M_F(name, _slist_ct), M_F(name, _slist_ct));    \
+  } M_F(name, _lfmp_thread_ct);                                               \
                                                                              \
  static inline void                                                          \
-  M_C(name, _lfmp_thread_init)(M_C(name, _lfmp_thread_ct) *t)                 \
+  M_F(name, _lfmp_thread_init)(M_F(name, _lfmp_thread_ct) *t)                 \
  {                                                                           \
-    M_C(name, _slist_init)(t->free);                                          \
-    M_C(name, _slist_init)(t->to_be_reclaimed);                               \
+    M_F(name, _slist_init)(t->free);                                          \
+    M_F(name, _slist_init)(t->to_be_reclaimed);                               \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _lfmp_thread_clear)(M_C(name, _lfmp_thread_ct) *t)                \
+  M_F(name, _lfmp_thread_clear)(M_F(name, _lfmp_thread_ct) *t)                \
  {                                                                           \
-    M_ASSERT(M_C(name, _slist_empty_p)(t->to_be_reclaimed));                  \
-    M_C(name, _slist_clear)(t->free);                                         \
-    M_C(name, _slist_clear)(t->to_be_reclaimed);                              \
+    M_ASSERT(M_F(name, _slist_empty_p)(t->to_be_reclaimed));                  \
+    M_F(name, _slist_clear)(t->free);                                         \
+    M_F(name, _slist_clear)(t->to_be_reclaimed);                              \
  }                                                                           \

 /* NOTE: once a node is deleted, its data are kept readable until the future GC */
-#define C_MEMPOOL_DEF_LF_MEMPOOL(name, type_t)                                \
+#define M_CMEMP00L_DEF_LF_MEMPOOL(name, type_t)                               \
                                                                              \
-  typedef struct M_C(name, _s) {                                              \
+  typedef struct M_F(name, _s) {                                              \
    unsigned                  initial;                                        \
-    M_C(name, _lfmp_thread_ct) *thread_data;                                  \
-    M_C(name, _lflist_ct)      free;                                          \
-    M_C(name, _lflist_ct)      to_be_reclaimed;                               \
-    M_C(name, _lflist_ct)      empty;                                         \
-    m_gc_mempool_list_ct       mempool_node;                                  \
+    M_F(name, _lfmp_thread_ct) *thread_data;                                  \
+    M_F(name, _lflist_ct)      free;                                          \
+    M_F(name, _lflist_ct)      to_be_reclaimed;                               \
+    M_F(name, _lflist_ct)      empty;                                         \
+    m_cmemp00l_list_ct       mempool_node;                                    \
    struct m_gc_s            *gc_mem;                                         \
-  } M_C(name, _t)[1];                                                         \
+  } M_F(name, _t)[1];                                                         \
                                                                              \
  /* Garbage collect of the nodes of the mempool on sleep */                  \
  static inline void                                                          \
-  M_C(name, _int_gc_on_sleep)(m_gc_t gc_mem, m_gc_mempool_list_ct *data,      \
+  M_C3(m_cmemp00l_,name,_gc_on_sleep)(m_gc_t gc_mem, m_cmemp00l_list_ct *data, \
         m_gc_tid_t id, m_gc_ticket_ct ticket, m_gc_ticket_ct min_ticket)     \
  {                                                                           \
    /* Get back the mempool from the node */                                  \
-    struct M_C(name, _s) *mempool =                                           \
-      M_TYPE_FROM_FIELD(struct M_C(name, _s), data, m_gc_mempool_list_ct, mempool_node); \
+    struct M_F(name, _s) *mempool =                                           \
+      M_TYPE_FROM_FIELD(struct M_F(name, _s), data, m_cmemp00l_list_ct, mempool_node); \
                                                                              \
    /* Move the local nodes of the mempool to be reclaimed to the thread into the global pool */ \
-    if (!M_C(name, _slist_empty_p)(mempool->thread_data[id].to_be_reclaimed)) { \
-      M_C(name, _lf_node_t) *node;                                            \
+    if (!M_F(name, _slist_empty_p)(mempool->thread_data[id].to_be_reclaimed)) { \
+      M_F(name, _lf_node_t) *node;                                            \
      /* Get a new empty group of nodes */                                    \
-      node = M_C(name, _lflist_pop)(mempool->empty, gc_mem->thread_data[id].bkoff); \
+      node = M_F(name, _lflist_pop)(mempool->empty, gc_mem->thread_data[id].bkoff); \
      if (M_UNLIKELY (node == NULL)) {                                        \
        /* Fail to get an empty group of node.                                \
           Alloc a new one from the system */                                 \
-        node = M_C(name, _alloc_node)(0);                                     \
+        node = M_F(name, _alloc_node)(0);                                     \
        M_ASSERT(node != NULL);                                               \
      }                                                                       \
-      M_ASSERT(M_C(name, _slist_empty_p)(node->list));                        \
-      M_C(name, _slist_move)(node->list, mempool->thread_data[id].to_be_reclaimed); \
+      M_ASSERT(M_F(name, _slist_empty_p)(node->list));                        \
+      M_F(name, _slist_move)(node->list, mempool->thread_data[id].to_be_reclaimed); \
      atomic_store_explicit(&node->cpt, ticket, memory_order_relaxed);        \
-      M_C(name, _lflist_push)(mempool->to_be_reclaimed, node, gc_mem->thread_data[id].bkoff); \
+      M_F(name, _lflist_push)(mempool->to_be_reclaimed, node, gc_mem->thread_data[id].bkoff); \
    }                                                                         \
                                                                              \
    /* Perform a GC of the freelist of nodes */                               \
    while (true) {                                                            \
-      M_C(name, _lf_node_t) *node;                                            \
-      node = M_C(name, _lflist_pop_if)(mempool->to_be_reclaimed,              \
+      M_F(name, _lf_node_t) *node;                                            \
+      node = M_F(name, _lflist_pop_if)(mempool->to_be_reclaimed,              \
                                       min_ticket, gc_mem->thread_data[id].bkoff); \
      if (node == NULL) break;                                                \
-      M_C(name, _lflist_push)(mempool->free, node, gc_mem->thread_data[id].bkoff); \
+      M_F(name, _lflist_push)(mempool->free, node, gc_mem->thread_data[id].bkoff); \
    }                                                                         \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _init)(M_C(name, _t) mem, m_gc_t gc_mem,                          \
+  M_F(name, _init)(M_F(name, _t) mem, m_gc_t gc_mem,                          \
                   unsigned init_node_count, unsigned init_group_count)       \
  {                                                                           \
    const size_t max_thread =  gc_mem->max_thread;                            \
    /* Initialize the thread data of the mempool */                           \
-    mem->thread_data = M_MEMORY_REALLOC(M_C(name, _lfmp_thread_ct), NULL, max_thread); \
-    if (mem->thread_data == NULL) {                                           \
-      M_MEMORY_FULL(max_thread * sizeof(M_C(name, _lfmp_thread_ct)));         \
+    mem->thread_data = M_MEMORY_REALLOC(M_F(name, _lfmp_thread_ct), NULL, max_thread); \
+    if (M_UNLIKELY_NOMEM (mem->thread_data == NULL)) {                        \
+      M_MEMORY_FULL(max_thread * sizeof(M_F(name, _lfmp_thread_ct)));         \
      return;                                                                 \
    }                                                                         \
    for(unsigned i = 0; i < max_thread;i++) {                                 \
-      M_C(name, _lfmp_thread_init)(&mem->thread_data[i]);                     \
+      M_F(name, _lfmp_thread_init)(&mem->thread_data[i]);                     \
    }                                                                         \
    /* Preallocate some group of nodes for the mempool */                     \
-    mem->initial = M_MAX(C_MEMPOOL_MIN_NODE_PER_GROUP, init_node_count);      \
-    M_C(name, _lflist_init)(mem->free, M_C(name, _alloc_node)(init_node_count)); \
-    M_C(name, _lflist_init)(mem->to_be_reclaimed, M_C(name, _alloc_node)(init_node_count)); \
-    M_C(name, _lflist_init)(mem->empty, M_C(name, _alloc_node)(0));           \
+    mem->initial = M_MAX(M_CMEMP00L_MIN_NODE_PER_GROUP, init_node_count);     \
+    M_F(name, _lflist_init)(mem->free, M_F(name, _alloc_node)(init_node_count)); \
+    M_F(name, _lflist_init)(mem->to_be_reclaimed, M_F(name, _alloc_node)(init_node_count)); \
+    M_F(name, _lflist_init)(mem->empty, M_F(name, _alloc_node)(0));           \
    for(unsigned i = 1; i < init_group_count; i++) {                          \
-      M_C(name, _lflist_push)(mem->free, M_C(name, _alloc_node)(init_node_count), \
+      M_F(name, _lflist_push)(mem->free, M_F(name, _alloc_node)(init_node_count), \
                              gc_mem->thread_data[0].bkoff);                  \
-      M_C(name, _lflist_push)(mem->empty, M_C(name, _alloc_node)(0),          \
+      M_F(name, _lflist_push)(mem->empty, M_F(name, _alloc_node)(0),          \
                              gc_mem->thread_data[0].bkoff);                  \
    }                                                                         \
    /* Register the mempool in the GC */                                      \
-    mem->mempool_node.gc_on_sleep = M_C(name, _int_gc_on_sleep);              \
+    mem->mempool_node.gc_on_sleep = M_C3(m_cmemp00l_,name,_gc_on_sleep);      \
    mem->mempool_node.next = gc_mem->mempool_list;                            \
    gc_mem->mempool_list = &mem->mempool_node;                                \
    mem->gc_mem = gc_mem;                                                     \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _clear)(M_C(name, _t) mem)                                        \
+  M_F(name, _clear)(M_F(name, _t) mem)                                        \
  {                                                                           \
    const unsigned max_thread = mem->gc_mem->max_thread;                      \
    for(unsigned i = 0; i < max_thread;i++) {                                 \
-      M_C(name, _lfmp_thread_clear)(&mem->thread_data[i]);                    \
+      M_F(name, _lfmp_thread_clear)(&mem->thread_data[i]);                    \
    }                                                                         \
    M_MEMORY_FREE(mem->thread_data);                                          \
    mem->thread_data = NULL;                                                  \
-    M_C(name, _lflist_clear)(mem->empty);                                     \
-    M_C(name, _lflist_clear)(mem->free);                                      \
-    M_ASSERT(M_C(name, _lflist_empty_p)(mem->to_be_reclaimed));               \
-    M_C(name, _lflist_clear)(mem->to_be_reclaimed);                           \
+    M_F(name, _lflist_clear)(mem->empty);                                     \
+    M_F(name, _lflist_clear)(mem->free);                                      \
+    M_ASSERT(M_F(name, _lflist_empty_p)(mem->to_be_reclaimed));               \
+    M_F(name, _lflist_clear)(mem->to_be_reclaimed);                           \
    /* TODO: Unregister from the GC? */                                       \
  }                                                                           \
                                                                              \
  static inline type_t *                                                      \
-  M_C(name, _new)(M_C(name, _t) mem, m_gc_tid_t id)                           \
+  M_F(name, _new)(M_F(name, _t) mem, m_gc_tid_t id)                           \
  {                                                                           \
-    M_C(name, _slist_node_ct) *snode;                                         \
-    M_C(name, _lf_node_t) *node;                                              \
+    M_F(name, _slist_node_ct) *snode;                                         \
+    M_F(name, _lf_node_t) *node;                                              \
    while (true) {                                                            \
      /* Fast & likely path where we access the thread pool of nodes */       \
-      if (M_LIKELY(!M_C(name, _slist_empty_p)(mem->thread_data[id].free))) {  \
-        snode = M_C(name, _slist_pop)(mem->thread_data[id].free);             \
+      if (M_LIKELY(!M_F(name, _slist_empty_p)(mem->thread_data[id].free))) {  \
+        snode = M_F(name, _slist_pop)(mem->thread_data[id].free);             \
        return &snode->data;                                                  \
      }                                                                       \
      /* Request a group node to the freelist of groups */                    \
-      node = M_C(name, _lflist_pop)(mem->free, mem->gc_mem->thread_data[id].bkoff); \
+      node = M_F(name, _lflist_pop)(mem->free, mem->gc_mem->thread_data[id].bkoff); \
      if (M_UNLIKELY (node == NULL)) {                                        \
        /* Request a new group to the system. Non Lock Free path */           \
        M_ASSERT(mem->initial > 0);                                           \
-        node = M_C(name, _alloc_node)(mem->initial);                          \
+        node = M_F(name, _alloc_node)(mem->initial);                          \
        M_ASSERT(node != NULL);                                               \
-        M_ASSERT(!M_C(name, _slist_empty_p)(node->list));                     \
+        M_ASSERT(!M_F(name, _slist_empty_p)(node->list));                     \
      }                                                                       \
-      M_C(name, _slist_move)(mem->thread_data[id].free, node->list);          \
+      M_F(name, _slist_move)(mem->thread_data[id].free, node->list);          \
      /* Push back the empty group */                                         \
-      M_ASSERT (M_C(name, _slist_empty_p)(node->list));                       \
-      M_C(name, _lflist_push)(mem->empty, node, mem->gc_mem->thread_data[id].bkoff); \
+      M_ASSERT (M_F(name, _slist_empty_p)(node->list));                       \
+      M_F(name, _lflist_push)(mem->empty, node, mem->gc_mem->thread_data[id].bkoff); \
    }                                                                         \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _del)(M_C(name, _t) mem, type_t *d, m_gc_tid_t id)                \
+  M_F(name, _del)(M_F(name, _t) mem, type_t *d, m_gc_tid_t id)                \
  {                                                                           \
-    M_C(name, _slist_node_ct) *snode;                                         \
+    M_F(name, _slist_node_ct) *snode;                                         \
    M_ASSERT( d != NULL);                                                     \
-    snode = M_TYPE_FROM_FIELD(M_C(name, _slist_node_ct), d, type_t, data);    \
-    M_C(name, _slist_push)(mem->thread_data[id].to_be_reclaimed, snode);      \
+    snode = M_TYPE_FROM_FIELD(M_F(name, _slist_node_ct), d, type_t, data);    \
+    M_F(name, _slist_push)(mem->thread_data[id].to_be_reclaimed, snode);      \
  }                                                                           \


@@ -555,13 +555,13 @@ typedef atomic_ulong  m_gc_atomic_ticket_ct;

 /* Define the Linked List of mempools that are registered in the GC */
 struct m_gc_s;
-typedef struct m_gc_mempool_list_s {
-  struct m_gc_mempool_list_s *next;
+typedef struct m_cmemp00l_list_s {
+  struct m_cmemp00l_list_s *next;
  void (*gc_on_sleep)(struct m_gc_s *gc_mem,
-                      struct m_gc_mempool_list_s *data, m_gc_tid_t id,
+                      struct m_cmemp00l_list_s *data, m_gc_tid_t id,
                      m_gc_ticket_ct ticket, m_gc_ticket_ct min_ticket);
  void *data;
-} m_gc_mempool_list_ct;
+} m_cmemp00l_list_ct;

 /* Define the Garbage collector thread data */
 typedef struct m_gc_lfmp_thread_s {
@@ -574,9 +574,9 @@ typedef struct m_gc_lfmp_thread_s {
 typedef struct m_gc_s {
  m_gc_atomic_ticket_ct      ticket;
  m_gc_tid_t                 max_thread;
-  genint_t                   thread_alloc;
+  m_genint_t                 thread_alloc;
  m_gc_lfmp_thread_ct       *thread_data;
-  m_gc_mempool_list_ct      *mempool_list;
+  m_cmemp00l_list_ct     *mempool_list;
 } m_gc_t[1];

 static inline void
@@ -586,9 +586,9 @@ m_gc_init(m_gc_t gc_mem, size_t max_thread)
  M_ASSERT(max_thread > 0 && max_thread < INT_MAX);

  atomic_init(&gc_mem->ticket, 0UL);
-  genint_init(gc_mem->thread_alloc, (unsigned int) max_thread);
+  m_genint_init(gc_mem->thread_alloc, (unsigned int) max_thread);
  gc_mem->thread_data = M_MEMORY_REALLOC(m_gc_lfmp_thread_ct, NULL, max_thread);
-  if (gc_mem->thread_data == NULL) {
+  if (M_UNLIKELY_NOMEM (gc_mem->thread_data == NULL)) {
    M_MEMORY_FULL(max_thread * sizeof(m_gc_lfmp_thread_ct));
    return;
  }
@@ -610,7 +610,7 @@ m_gc_clear(m_gc_t gc_mem)
  }
  M_MEMORY_FREE(gc_mem->thread_data);
  gc_mem->thread_data = NULL;
-  genint_clear(gc_mem->thread_alloc);
+  m_genint_clear(gc_mem->thread_alloc);
 }

 static inline m_gc_tid_t
@@ -618,7 +618,7 @@ m_gc_attach_thread(m_gc_t gc_mem)
 {
  M_ASSERT(gc_mem != NULL && gc_mem->max_thread > 0);
  
-  unsigned id = genint_pop(gc_mem->thread_alloc);
+  unsigned id = m_genint_pop(gc_mem->thread_alloc);
  return M_ASSIGN_CAST(m_gc_tid_t, id);
 }
  
@@ -629,7 +629,7 @@ m_gc_detach_thread(m_gc_t gc_mem, m_gc_tid_t id)
  M_ASSERT(id < gc_mem->max_thread);
  M_ASSERT(atomic_load(&gc_mem->thread_data[id].ticket) == ULONG_MAX);

-  genint_push(gc_mem->thread_alloc, id);
+  m_genint_push(gc_mem->thread_alloc, id);
 }
  
 static inline void
@@ -644,7 +644,7 @@ m_gc_awake(m_gc_t gc_mem, m_gc_tid_t id)
 }
  
 static inline m_gc_ticket_ct
-m_gc_int_min_ticket(m_gc_t gc_mem)
+m_cmemp00l_gc_min_ticket(m_gc_t gc_mem)
 {
  m_gc_ticket_ct min = atomic_load(&gc_mem->thread_data[0].ticket);
  for(m_gc_tid_t i = 1; i < gc_mem->max_thread; i++) {
@@ -660,9 +660,9 @@ m_gc_sleep(m_gc_t gc_mem, m_gc_tid_t id)
  /* Increase life time of the thread */
  m_gc_ticket_ct t = atomic_fetch_add(&gc_mem->ticket, 1UL);
  atomic_store(&gc_mem->thread_data[id].ticket, t+1);
-  const m_gc_ticket_ct min_ticket = m_gc_int_min_ticket(gc_mem);
+  const m_gc_ticket_ct min_ticket = m_cmemp00l_gc_min_ticket(gc_mem);
  /* Iterate over all registered mempools */
-  m_gc_mempool_list_ct *it = gc_mem->mempool_list;
+  m_cmemp00l_list_ct *it = gc_mem->mempool_list;

  while (it) {
    /* Perform a garbage collect of the mempool */
@@ -681,9 +681,9 @@ m_gc_sleep(m_gc_t gc_mem, m_gc_tid_t id)
 /*                                                                     */
 /***********************************************************************/

-C_MEMPOOL_DEF_SINGLY_LIST(m_vlapool, char)
-C_MEMPOOL_DEF_LF_QUEUE(m_vlapool, char)
-C_MEMPOOL_DEF_SYSTEM_ALLOC(m_vlapool, char)
+M_CMEMP00L_DEF_SINGLY_LIST(m_vlapool, char)
+M_CMEMP00L_DEF_LF_QUEUE(m_vlapool, char)
+M_CMEMP00L_DEF_SYSTEM_ALLOC(m_vlapool, char)

 typedef struct m_vlapool_lfmp_thread_s {
  m_vlapool_slist_ct  to_be_reclaimed;
@@ -707,18 +707,18 @@ typedef struct m_vlapool_s {
  m_vlapool_lflist_ct        to_be_reclaimed;
  m_vlapool_lflist_ct        empty;
  m_vlapool_lfmp_thread_ct  *thread_data;
-  m_gc_mempool_list_ct      mvla_node;
+  m_cmemp00l_list_ct      mvla_node;
  struct m_gc_s             *gc_mem;
 } m_vlapool_t[1];

 /* Garbage collect of the nodes of the vla mempool on sleep */
 static inline void
-m_vlapool_int_gc_on_sleep(m_gc_t gc_mem, m_gc_mempool_list_ct *data,
+m_cmemp00l_vlapool_on_sleep(m_gc_t gc_mem, m_cmemp00l_list_ct *data,
                          m_gc_tid_t id, m_gc_ticket_ct ticket, m_gc_ticket_ct min_ticket)
 {
  /* Get back the mempool from the node */
  struct m_vlapool_s *vlapool =
-    M_TYPE_FROM_FIELD(struct m_vlapool_s, data, m_gc_mempool_list_ct, mvla_node);
+    M_TYPE_FROM_FIELD(struct m_vlapool_s, data, m_cmemp00l_list_ct, mvla_node);

  /* Move the local nodes of the vlapool to be reclaimed to the thread into the global pool */
  if (!m_vlapool_slist_empty_p(vlapool->thread_data[id].to_be_reclaimed)) {
@@ -758,7 +758,7 @@ m_vlapool_init(m_vlapool_t mem, m_gc_t gc_mem)

  /* Initialize the thread data of the vlapool */
  mem->thread_data = M_MEMORY_REALLOC(m_vlapool_lfmp_thread_ct, NULL, max_thread);
-  if (mem->thread_data == NULL) {
+  if (M_UNLIKELY_NOMEM (mem->thread_data == NULL)) {
    M_MEMORY_FULL(max_thread * sizeof(m_vlapool_lfmp_thread_ct));
    return;
  }
@@ -771,7 +771,7 @@ m_vlapool_init(m_vlapool_t mem, m_gc_t gc_mem)
  m_vlapool_lflist_init(mem->empty, m_vlapool_alloc_node(0));

  /* Register the mempool in the GC */
-  mem->mvla_node.gc_on_sleep = m_vlapool_int_gc_on_sleep;
+  mem->mvla_node.gc_on_sleep = m_cmemp00l_vlapool_on_sleep;
  mem->mvla_node.next = gc_mem->mempool_list;
  gc_mem->mempool_list = &mem->mvla_node;
  mem->gc_mem = gc_mem;
@@ -828,4 +828,8 @@ m_vlapool_del(m_vlapool_t mem, void *d, m_gc_tid_t id)

 M_END_PROTECTED_CODE

+#if M_USE_SMALL_NAME
+#define C_MEMPOOL_DEF M_C_MEMPOOL_DEF
+#endif
+
 #endif
@@ -1,7 +1,7 @@
 /*
 * M*LIB - Function Object module
 *
- * Copyright (c) 2017-2021, Patrick Pelissier
+ * Copyright (c) 2017-2023, Patrick Pelissier
 * All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
@@ -32,10 +32,8 @@
 * USAGE:
 *    FUNC_OBJ_ITF_DEF(name, retcode type, type of param1, type of param 2, ...)
 */
-#define FUNC_OBJ_ITF_DEF(name, ...)                                           \
-  M_BEGIN_PROTECTED_CODE                                                      \
-  M_IF_NARGS_EQ1(__VA_ARGS__)(FUNCOBJI_ITF_NO_PARAM_DEF, FUNCOBJI_ITF_PARAM_DEF)(name, M_C(name, _t), __VA_ARGS__) \
-  M_END_PROTECTED_CODE
+#define M_FUNC_OBJ_ITF_DEF(name, ...)                                         \
+  M_FUNC_OBJ_ITF_DEF_AS(name, M_F(name,_t), __VA_ARGS__)


 /* Define a function object interface of name 'name'
@@ -43,9 +41,9 @@
 * USAGE:
 *    FUNC_OBJ_ITF_DEF_AS(name, name_t, retcode type, type of param1, type of param 2, ...)
 */
-#define FUNC_OBJ_ITF_DEF_AS(name, name_t, ...)                                \
+#define M_FUNC_OBJ_ITF_DEF_AS(name, name_t, ...)                              \
  M_BEGIN_PROTECTED_CODE                                                      \
-  M_IF_NARGS_EQ1(__VA_ARGS__)(FUNCOBJI_ITF_NO_PARAM_DEF, FUNCOBJI_ITF_PARAM_DEF)(name, name_t, __VA_ARGS__) \
+  M_IF_NARGS_EQ1(__VA_ARGS__)(M_FUNC0BJ_ITF_NO_PARAM_DEF, M_FUNC0BJ_ITF_PARAM_DEF)(name, name_t, __VA_ARGS__) \
  M_END_PROTECTED_CODE


@@ -67,10 +65,8 @@
 * USAGE/EXAMPLE:
 *   FUNC_OBJ_INS_DEF(name, base_name, (param1, ...), { return param1 * self->member1 }, (member1, int), ...)
 */
-#define FUNC_OBJ_INS_DEF(name, base_name, param_list, ...)                    \
-  M_BEGIN_PROTECTED_CODE                                                      \
-  M_IF_NARGS_EQ1(__VA_ARGS__)(FUNCOBJI_INS_NO_ATTR_DEF, FUNCOBJI_INS_ATTR_DEF)(name, M_C(name, _t), base_name, param_list, __VA_ARGS__) \
-  M_END_PROTECTED_CODE
+#define M_FUNC_OBJ_INS_DEF(name, base_name, param_list, ...)                  \
+  M_FUNC_OBJ_INS_DEF_AS(name, M_F(name,_t), base_name, param_list, __VA_ARGS__)


 /* Define a function object instance of name 'name' based on the interface 'base_name'
@@ -80,9 +76,9 @@
 * USAGE/EXAMPLE:
 *   FUNC_OBJ_INS_DEF_AS(name, name_t, base_name, (param1, ...), { return param1 * self->member1 }, (member1, int), ...)
 */
-#define FUNC_OBJ_INS_DEF_AS(name, name_t, base_name, param_list, ...)         \
+#define M_FUNC_OBJ_INS_DEF_AS(name, name_t, base_name, param_list, ...)       \
  M_BEGIN_PROTECTED_CODE                                                      \
-  M_IF_NARGS_EQ1(__VA_ARGS__)(FUNCOBJI_INS_NO_ATTR_DEF, FUNCOBJI_INS_ATTR_DEF)(name, name_t, base_name, param_list, __VA_ARGS__) \
+  M_IF_NARGS_EQ1(__VA_ARGS__)(M_FUNC0BJ_INS_NO_ATTR_DEF, M_FUNC0BJ_INS_ATTR_DEF)(name, name_t, base_name, param_list, __VA_ARGS__) \
  M_END_PROTECTED_CODE


@@ -90,19 +86,19 @@
 * USAGE:
 *  FUNC_OBJ_INS_OPLIST(name, oplist of the attr1, ...)
 */
-#define FUNC_OBJ_INS_OPLIST(...)                                              \
-  M_IF_NARGS_EQ1(__VA_ARGS__)(FUNCOBJI_INS_NO_ATTR_OPLIST, FUNCOBJI_INS_ATTR_OPLIST_P1)( __VA_ARGS__)
+#define M_FUNC_OBJ_INS_OPLIST(...)                                            \
+  M_IF_NARGS_EQ1(__VA_ARGS__)(M_FUNC0BJ_INS_NO_ATTR_OPLIST, M_FUNC0BJ_INS_ATTR_OPLIST_P1)( __VA_ARGS__)



-/********************************************************************************/
-/********************************** INTERNAL ************************************/
-/********************************************************************************/
+/*****************************************************************************/
+/******************************** INTERNAL ***********************************/
+/*****************************************************************************/

 /* To be used by M_IF_FUNCOBJ macro defined in m-core.
   NOTE: It is reversed (0 instead of 1) so that it can be used in M_IF reliabely.
 */
-#define M_FUNCOBJ_IS_NOT_DEFINED 0
+#define M_FUNC0BJ_IS_NOT_DEFINED 0

 /* Design Constraints:
 *  callback SHALL be the first member of the structures in all the definitions.
@@ -113,57 +109,60 @@
 */

 /* Specialization of the OPLIST in function if there is at least one member or not */
-#define FUNCOBJI_INS_NO_ATTR_OPLIST(name) (                                   \
+#define M_FUNC0BJ_INS_NO_ATTR_OPLIST(name) (                                  \
  NAME(name),                                                                 \
-  TYPE(M_C(name, _ct)),                                                       \
-  CLEAR(M_C(name, _clear)),                                                   \
-  INIT(M_C(name,_init))                                                       \
+  TYPE(M_F(name, _ct)),                                                       \
+  CLEAR(M_F(name, _clear)),                                                   \
+  INIT(M_F(name,_init))                                                       \
  )

 /* Validate the oplist before going further */
-#define FUNCOBJI_INS_ATTR_OPLIST_P1(name, ...)                                \
-  M_IF(M_REDUCE(M_OPLIST_P, M_AND, __VA_ARGS__))(FUNCOBJI_INS_ATTR_OPLIST_P3, FUNCOBJI_INS_ATTR_OPLIST_FAILURE)(name, __VA_ARGS__)
+#define M_FUNC0BJ_INS_ATTR_OPLIST_P1(name, ...)                               \
+  M_IF(M_REDUCE(M_OPLIST_P, M_AND, __VA_ARGS__))(M_FUNC0BJ_INS_ATTR_OPLIST_P3, M_FUNC0BJ_INS_ATTR_OPLIST_FAILURE)(name, __VA_ARGS__)

 /* Prepare a clean compilation failure */
-#define FUNCOBJI_INS_ATTR_OPLIST_FAILURE(name, ...)                           \
+#define M_FUNC0BJ_INS_ATTR_OPLIST_FAILURE(name, ...)                          \
  ((M_LIB_ERROR(ONE_ARGUMENT_OF_FUNC_OBJ_INS_OPLIST_IS_NOT_AN_OPLIST, name, __VA_ARGS__)))

 /* Define the oplist of the instance */
-#define FUNCOBJI_INS_ATTR_OPLIST_P3(name, ...) (                              \
+#define M_FUNC0BJ_INS_ATTR_OPLIST_P3(name, ...) (                             \
  NAME(name),                                                                 \
-  TYPE(M_C(name, _ct)),                                                       \
-  INIT_WITH(M_C(name, _init_with)),                                           \
-  CLEAR(M_C(name, _clear)),                                                   \
-  M_IF_METHOD_ALL(INIT, __VA_ARGS__)(INIT(M_C(name,_init)),),                 \
+  TYPE(M_F(name, _ct)),                                                       \
+  INIT_WITH(M_F(name, _init_with)),                                           \
+  CLEAR(M_F(name, _clear)),                                                   \
+  M_IF_METHOD_ALL(INIT, __VA_ARGS__)(INIT(M_F(name,_init)),),                 \
+  PROPERTIES(( LET_AS_INIT_WITH(1) ))                                         \
  )


+/******************************** INTERNAL ***********************************/
+
 /* Specialization of the definition a function object interface of name 'name'
 * with a function like "retcode (void)" that doesn't have any input parameters.
 * Define the following types to be used by instance:
- * - M_C(name, _retcode_ct): internal type of the return code
- * - M_C(name, _callback_ct): internal type of the callback.
- * - M_C(name, _ct): synonym of main type used by oplist.
+ * - M_F(name, _retcode_ct): internal type of the return code
+ * - M_F(name, _callback_ct): internal type of the callback.
+ * - M_F(name, _ct): synonym of main type used by oplist.
 */
-#define FUNCOBJI_ITF_NO_PARAM_DEF(name, interface_t, retcode)                 \
+#define M_FUNC0BJ_ITF_NO_PARAM_DEF(name, interface_t, retcode)                \
                                                                              \
  /* Forward declaration */                                                   \
-  struct M_C(name, _s);                                                       \
+  struct M_F(name, _s);                                                       \
                                                                              \
  /* Internal type for instance */                                            \
-  typedef retcode M_C(name, _retcode_ct);                                     \
+  typedef retcode M_F(name, _retcode_ct);                                     \
  /* No parameters to the callback */                                         \
-  typedef retcode(*M_C(name, _callback_ct))(struct M_C(name, _s) *);          \
+  typedef retcode(*M_F(name, _callback_ct))(struct M_F(name, _s) *);          \
                                                                              \
-  typedef struct M_C(name, _s) {                                              \
-     M_C(name, _callback_ct) callback;                                        \
+  typedef struct M_F(name, _s) {                                              \
+     M_F(name, _callback_ct) callback;                                        \
  } interface_t[1];                                                           \
                                                                              \
  /* Internal type for oplist & instance */                                   \
-  typedef interface_t M_C(name, _ct);                                         \
+  typedef interface_t M_F(name, _ct);                                         \
                                                                              \
  static inline retcode                                                       \
-  M_C(name, _call)(interface_t funcobj)                                       \
+  M_F(name, _call)(interface_t funcobj)                                       \
  {                                                                           \
    M_IF(M_KEYWORD_P(void, retcode)) ( /* nothing */,return)                  \
      funcobj->callback(funcobj);                                             \
@@ -174,86 +173,88 @@
 * with a function like retcode, type of param1, type of param 2, ...
 * with mandatory input parameters.
 * Define the following types to be used by instance:
- * - M_C(name, _retcode_ct): internal type of the return code
- * - M_C(name, _callback_ct): internal type of the callback.
+ * - M_F(name, _retcode_ct): internal type of the return code
+ * - M_F(name, _callback_ct): internal type of the callback.
 * - M_C4(name, _param_, num, _ct) for each parameter defined
- * - M_C(name, _ct): synonym of main type used by oplist.
+ * - M_F(name, _ct): synonym of main type used by oplist.
 */
-#define FUNCOBJI_ITF_PARAM_DEF(name, interface_t, retcode, ...)               \
+#define M_FUNC0BJ_ITF_PARAM_DEF(name, interface_t, retcode, ...)              \
                                                                              \
  /* Forward declaration */                                                   \
-  struct M_C(name, _s);                                                       \
+  struct M_F(name, _s);                                                       \
                                                                              \
  /* Internal types for instance */                                           \
-  typedef retcode M_C(name, _retcode_ct);                                     \
+  typedef retcode M_F(name, _retcode_ct);                                     \
  /* Define types for all parameters */                                       \
-  M_MAP3(FUNCOBJI_BASE_TYPE, name, __VA_ARGS__)                               \
+  M_MAP3(M_FUNC0BJ_BASE_TYPE, name, __VA_ARGS__)                              \
  /* Define callback type with all parameters */                              \
-  typedef retcode(*M_C(name, _callback_ct))(struct M_C(name, _s) *, __VA_ARGS__); \
+  typedef retcode(*M_F(name, _callback_ct))(struct M_F(name, _s) *, __VA_ARGS__); \
                                                                              \
-  typedef struct M_C(name, _s) {                                              \
-     M_C(name, _callback_ct) callback;                                        \
+  typedef struct M_F(name, _s) {                                              \
+     M_F(name, _callback_ct) callback;                                        \
  } interface_t[1];                                                           \
                                                                              \
  /* Internal type for oplist & instance */                                   \
-  typedef interface_t M_C(name, _ct);                                         \
+  typedef interface_t M_F(name, _ct);                                         \
                                                                              \
  static inline retcode                                                       \
-  M_C(name, _call)(interface_t funcobj                                        \
-                   M_MAP3(FUNCOBJI_BASE_ARGLIST, name, __VA_ARGS__) )         \
+  M_F(name, _call)(interface_t funcobj                                        \
+                   M_MAP3(M_FUNC0BJ_BASE_ARGLIST, name, __VA_ARGS__) )        \
  {                                                                           \
    /* If the retcode is 'void', don't return the value of the callback */    \
    M_IF(M_KEYWORD_P(void, retcode)) ( /* nothing */,return)                  \
-      funcobj->callback(funcobj M_MAP3(FUNCOBJI_BASE_ARGCALL, name, __VA_ARGS__) ); \
+      funcobj->callback(funcobj M_MAP3(M_FUNC0BJ_BASE_ARGCALL, name, __VA_ARGS__) ); \
  }


+/******************************** INTERNAL ***********************************/
+
 /* Specialization of the definition a function object instance of name 'name'
 * with no member attribute.
 */
-#define FUNCOBJI_INS_NO_ATTR_DEF(name, instance_t, base_name, param_list, callback_core) \
-  typedef struct M_C(name, _s) {                                              \
+#define M_FUNC0BJ_INS_NO_ATTR_DEF(name, instance_t, base_name, param_list, callback_core) \
+  typedef struct M_F(name, _s) {                                              \
    M_C(base_name, _callback_ct) callback;                                    \
  } instance_t[1];                                                            \
                                                                              \
  /* Internal type for oplist */                                              \
-  typedef instance_t M_C(name, _ct);                                          \
+  typedef instance_t M_F(name, _ct);                                          \
                                                                              \
  static inline M_C(base_name, _retcode_ct)                                   \
-  M_C(name, _callback)(M_C(base_name, _ct) _self                              \
+  M_F(name, _callback)(M_C(base_name, _ct) _self                              \
                      M_IF_EMPTY(M_OPFLAT param_list)(                        \
                          /* No param */,                                     \
-                          M_MAP3(FUNCOBJI_INS_ARGLIST, base_name, M_OPFLAT param_list) \
+                          M_MAP3(M_FUNC0BJ_INS_ARGLIST, base_name, M_OPFLAT param_list) \
                                                                    )         \
                      )                                                       \
  {                                                                           \
-    struct M_C(name, _s) *self = (struct M_C(name, _s) *)_self;               \
+    struct M_F(name, _s) *self = (struct M_F(name, _s) *)_self;               \
    (void) self; /* maybe unused */                                           \
    callback_core;                                                            \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _init_with)(instance_t obj)                                       \
+  M_F(name, _init_with)(instance_t obj)                                       \
  {                                                                           \
-    obj->callback = M_C(name, _callback);                                     \
+    obj->callback = M_F(name, _callback);                                     \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _clear)(instance_t obj)                                           \
+  M_F(name, _clear)(instance_t obj)                                           \
  {                                                                           \
    (void) obj; /* nothing to do */                                           \
  }                                                                           \
                                                                              \
  static inline struct M_C(base_name, _s) *                                   \
-  M_C(name, _as_interface)(instance_t obj)                                    \
+  M_F(name, _as_interface)(instance_t obj)                                    \
  {                                                                           \
    return (struct M_C(base_name, _s) *) obj;                                 \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _init)(instance_t obj)                                            \
+  M_F(name, _init)(instance_t obj)                                            \
  {                                                                           \
-    obj->callback = M_C(name, _callback);                                     \
+    obj->callback = M_F(name, _callback);                                     \
  }                                                                           \
   

@@ -261,142 +262,154 @@
 * with mandatory member attribute.
 * First inject oplist in member attributes.
 */
-#define FUNCOBJI_INS_ATTR_DEF(name, instance_t, base_name, param_list, callback_core, ...) \
-  FUNCOBJI_INS_ATTR_DEF_P2(name, instance_t, base_name, param_list, callback_core, FUNCOBJI_INJECT_GLOBAL(__VA_ARGS__) )
+#define M_FUNC0BJ_INS_ATTR_DEF(name, instance_t, base_name, param_list, callback_core, ...) \
+  M_FUNC0BJ_INS_ATTR_DEF_P2(name, instance_t, base_name, param_list, callback_core, M_FUNC0BJ_INJECT_GLOBAL(__VA_ARGS__) )

 /* Inject the oplist within the list of arguments */
-#define FUNCOBJI_INJECT_GLOBAL(...)                                           \
-  M_MAP_C(FUNCOBJI_INJECT_OPLIST_A, __VA_ARGS__)
+#define M_FUNC0BJ_INJECT_GLOBAL(...)                                          \
+  M_MAP_C(M_FUNC0BJ_INJECT_OPLIST_A, __VA_ARGS__)

 /* Transform (x, type) into (x, type, oplist) if there is global registered oplist 
-   or (x, type, M_DEFAULT_OPLIST) if there is no global one,
+   or (x, type, M_BASIC_OPLIST) if there is no global one,
   or keep (x, type, oplist) if oplist was already present */
-#define FUNCOBJI_INJECT_OPLIST_A( duo_or_trio )                               \
-  FUNCOBJI_INJECT_OPLIST_B duo_or_trio
-#define FUNCOBJI_INJECT_OPLIST_B( f, ... )                                    \
+#define M_FUNC0BJ_INJECT_OPLIST_A( duo_or_trio )                              \
+  M_FUNC0BJ_INJECT_OPLIST_B duo_or_trio
+#define M_FUNC0BJ_INJECT_OPLIST_B( f, ... )                                   \
  M_IF_NARGS_EQ1(__VA_ARGS__)( (f, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)()), (f, __VA_ARGS__) )

 // Test if all third argument of all arguments is an oplist
-#define FUNCOBJI_IF_ALL_OPLIST(...)                                           \
-  M_IF(M_REDUCE(FUNCOBJI_IS_OPLIST_P, M_AND, __VA_ARGS__))
+#define M_FUNC0BJ_IF_ALL_OPLIST(...)                                          \
+  M_IF(M_REDUCE(M_FUNC0BJ_IS_OPLIST_P, M_AND, __VA_ARGS__))
 // Test if the third argument is an oplist. a is a trio (name, type, oplist)
-#define FUNCOBJI_IS_OPLIST_P(a)                                               \
+#define M_FUNC0BJ_IS_OPLIST_P(a)                                              \
  M_OPLIST_P(M_RET_ARG3 a)

 /* Validate the oplist before going further */
-#define FUNCOBJI_INS_ATTR_DEF_P2(name, instance_t, base_name, param_list, callback_core, ...) \
-  FUNCOBJI_IF_ALL_OPLIST(__VA_ARGS__)(FUNCOBJI_INS_ATTR_DEF_P3, FUNCOBJI_INS_ATTR_DEF_FAILURE)(name, instance_t, base_name, param_list, callback_core, __VA_ARGS__)
+#define M_FUNC0BJ_INS_ATTR_DEF_P2(name, instance_t, base_name, param_list, callback_core, ...) \
+  M_FUNC0BJ_IF_ALL_OPLIST(__VA_ARGS__)(M_FUNC0BJ_INS_ATTR_DEF_P3, M_FUNC0BJ_INS_ATTR_DEF_FAILURE)(name, instance_t, base_name, param_list, callback_core, __VA_ARGS__)

 /* Stop processing with a compilation failure */
-#define FUNCOBJI_INS_ATTR_DEF_FAILURE(name, instance_t, base_name, param_list, callback_core, ...) \
+#define M_FUNC0BJ_INS_ATTR_DEF_FAILURE(name, instance_t, base_name, param_list, callback_core, ...) \
  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(FUNC_OBJ_INS_DEF): at least one of the given argument is not a valid oplist: " #__VA_ARGS__)

 /* Expand the Function Object with members */
-#define FUNCOBJI_INS_ATTR_DEF_P3(name, instance_t, base_name, param_list, callback_core, ...) \
-  typedef struct M_C(name, _s) {                                              \
+#define M_FUNC0BJ_INS_ATTR_DEF_P3(name, instance_t, base_name, param_list, callback_core, ...) \
+  typedef struct M_F(name, _s) {                                              \
    /* Callback is the mandatory first argument */                            \
    M_C(base_name, _callback_ct) callback;                                    \
    /* All the member attribute of the Function Object */                     \
-    M_MAP(FUNCOBJI_INS_ATTR_STRUCT, __VA_ARGS__)                              \
+    M_MAP(M_FUNC0BJ_INS_ATTR_STRUCT, __VA_ARGS__)                             \
   } instance_t[1];                                                           \
                                                                              \
  /* Internal type for oplist */                                              \
-  typedef instance_t M_C(name, _ct);                                          \
+  typedef instance_t M_F(name, _ct);                                          \
                                                                              \
-  FUNCOBJI_CONTROL_ALL_OPLIST(name, __VA_ARGS__)                              \
+  M_FUNC0BJ_CONTROL_ALL_OPLIST(name, __VA_ARGS__)                             \
                                                                              \
  static inline M_C(base_name, _retcode_ct)                                   \
-  M_C(name, _callback)(M_C(base_name, _ct) _self                              \
+  M_F(name, _callback)(M_C(base_name, _ct) _self                              \
                      M_IF_EMPTY(M_OPFLAT param_list)(                        \
                        /* No param */,                                       \
-                        M_MAP3(FUNCOBJI_INS_ARGLIST, base_name, M_OPFLAT param_list) \
+                        M_MAP3(M_FUNC0BJ_INS_ARGLIST, base_name, M_OPFLAT param_list) \
                                                                    )         \
                      )                                                       \
  {                                                                           \
-    struct M_C(name, _s) *self = (struct M_C(name, _s) *)(void*)_self;	       \
+    /* Let's go through an uintptr_t to avoid [broken] aliasing detection by compiler */ \
+    uintptr_t __self = (uintptr_t) _self;                                     \
+    struct M_F(name, _s) *self = (struct M_F(name, _s) *)(void*)__self;       \
    (void) self; /* maybe unused */                                           \
    callback_core;                                                            \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _init_with)(instance_t obj M_MAP(FUNCOBJI_INS_ATTR_LIST, __VA_ARGS__)) \
+  M_F(name, _init_with)(instance_t obj M_MAP(M_FUNC0BJ_INS_ATTR_LIST, __VA_ARGS__)) \
  {                                                                           \
-    obj->callback = M_C(name, _callback);                                     \
-    M_MAP(FUNCOBJI_INS_ATTR_INIT_SET, __VA_ARGS__);                           \
+    obj->callback = M_F(name, _callback);                                     \
+    M_MAP(M_FUNC0BJ_INS_ATTR_INIT_SET, __VA_ARGS__);                          \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _clear)(instance_t obj)                                           \
+  M_F(name, _clear)(instance_t obj)                                           \
  {                                                                           \
-    M_MAP(FUNCOBJI_INS_ATTR_CLEAR, __VA_ARGS__);                              \
+    M_MAP(M_FUNC0BJ_INS_ATTR_CLEAR, __VA_ARGS__);                             \
  }                                                                           \
                                                                              \
  static inline struct M_C(base_name, _s) *                                   \
-  M_C(name, _as_interface)(instance_t obj)                                    \
+  M_F(name, _as_interface)(instance_t obj)                                    \
  {                                                                           \
    return (struct M_C(base_name, _s) *) obj;                                 \
  }                                                                           \
                                                                              \
-  M_IF(FUNCOBJI_TEST_METHOD_P(INIT, __VA_ARGS))                               \
+  M_IF(M_FUNC0BJ_TEST_METHOD_P(INIT, __VA_ARGS))                              \
  (                                                                           \
  static inline void                                                          \
-  M_C(name, _init)(instance_t obj)                                            \
+  M_F(name, _init)(instance_t obj)                                            \
  {                                                                           \
-    obj->callback = M_C(name, _callback);                                     \
-    M_MAP(FUNCOBJI_INS_ATTR_INIT, __VA_ARGS__);                               \
+    obj->callback = M_F(name, _callback);                                     \
+    M_MAP(M_FUNC0BJ_INS_ATTR_INIT, __VA_ARGS__);                              \
  }                                                                           \
  , /* END OF INIT METHOD */ )                                                \



 /* Define a numbered type of a parameter of the callback*/
-#define FUNCOBJI_BASE_TYPE(name, num, type)                                   \
+#define M_FUNC0BJ_BASE_TYPE(name, num, type)                                  \
  typedef type M_C4(name, _param_, num, _ct);

 /* Define a list of the type of arguments for a function definition */
-#define FUNCOBJI_BASE_ARGLIST(name, num, type)                                \
+#define M_FUNC0BJ_BASE_ARGLIST(name, num, type)                               \
  M_DEFERRED_COMMA type M_C(param_, num)

 /* Define a list of arguments for a function call */
-#define FUNCOBJI_BASE_ARGCALL(name, num, type)                                \
+#define M_FUNC0BJ_BASE_ARGCALL(name, num, type)                               \
  M_DEFERRED_COMMA M_C(param_, num)


 /* Helper macros */
 /* arg = (name, type [, oplist]) */
-#define FUNCOBJI_INS_ATTR_STRUCT(arg)                                         \
+#define M_FUNC0BJ_INS_ATTR_STRUCT(arg)                                        \
  M_RET_ARG2 arg M_RET_ARG1 arg;

-#define FUNCOBJI_INS_ATTR_LIST(arg)                                           \
+#define M_FUNC0BJ_INS_ATTR_LIST(arg)                                          \
  M_DEFERRED_COMMA M_RET_ARG2 arg const M_RET_ARG1 arg

-#define FUNCOBJI_INS_ATTR_INIT(arg)                                           \
+#define M_FUNC0BJ_INS_ATTR_INIT(arg)                                          \
  M_CALL_INIT(M_RET_ARG3 arg, obj -> M_RET_ARG1 arg);

-#define FUNCOBJI_INS_ATTR_INIT_SET(arg)                                       \
+#define M_FUNC0BJ_INS_ATTR_INIT_SET(arg)                                      \
  M_CALL_INIT_SET(M_RET_ARG3 arg, obj -> M_RET_ARG1 arg, M_RET_ARG1 arg);

-#define FUNCOBJI_INS_ATTR_CLEAR(arg)                                          \
+#define M_FUNC0BJ_INS_ATTR_CLEAR(arg)                                         \
  M_CALL_CLEAR(M_RET_ARG3 arg, obj -> M_RET_ARG1 arg);

 /* Define the list of arguments of the instance of the callback */
-#define FUNCOBJI_INS_ARGLIST(name, num, param)                                \
+#define M_FUNC0BJ_INS_ARGLIST(name, num, param)                               \
  M_DEFERRED_COMMA M_C4(name, _param_, num, _ct) param


 /* Macros for testing for a method presence in all the attributes */
-#define FUNCOBJI_TEST_METHOD2_P(method, op)                                   \
+#define M_FUNC0BJ_TEST_METHOD2_P(method, op)                                  \
  M_TEST_METHOD_P(method, op)
-#define FUNCOBJI_TEST_METHOD1_P(method, arg)                                  \
-  M_APPLY(FUNCOBJI_TEST_METHOD2_P, method, M_RET_ARG3 arg)
-#define FUNCOBJI_TEST_METHOD_P(method, ...)                                   \
-  M_IF(M_REDUCE2(FUNCOBJI_TEST_METHOD1_P, M_AND, method, __VA_ARGS__))
+#define M_FUNC0BJ_TEST_METHOD1_P(method, arg)                                 \
+  M_APPLY(M_FUNC0BJ_TEST_METHOD2_P, method, M_RET_ARG3 arg)
+#define M_FUNC0BJ_TEST_METHOD_P(method, ...)                                  \
+  M_IF(M_REDUCE2(M_FUNC0BJ_TEST_METHOD1_P, M_AND, method, __VA_ARGS__))

 /* Macro for checking compatible type and oplist for all the attributes */
-#define FUNCOBJI_CONTROL_ALL_OPLIST(name, ...)                                \
-  M_MAP2(FUNCOBJI_CONTROL_OPLIST, name, __VA_ARGS__)
-#define FUNCOBJI_CONTROL_OPLIST(name, a)                                      \
+#define M_FUNC0BJ_CONTROL_ALL_OPLIST(name, ...)                               \
+  M_MAP2(M_FUNC0BJ_CONTROL_OPLIST, name, __VA_ARGS__)
+#define M_FUNC0BJ_CONTROL_OPLIST(name, a)                                     \
  M_CHECK_COMPATIBLE_OPLIST(name, M_RET_ARG1 a, M_RET_ARG2 a, M_RET_ARG3 a)


+/******************************** INTERNAL ***********************************/
+
+#if M_USE_SMALL_NAME
+#define FUNC_OBJ_ITF_DEF M_FUNC_OBJ_ITF_DEF
+#define FUNC_OBJ_ITF_DEF_AS M_FUNC_OBJ_ITF_DEF_AS
+#define FUNC_OBJ_INS_DEF M_FUNC_OBJ_INS_DEF
+#define FUNC_OBJ_INS_DEF_AS M_FUNC_OBJ_INS_DEF_AS
+#define FUNC_OBJ_INS_OPLIST M_FUNC_OBJ_INS_OPLIST
+#endif
+
 #endif
@@ -1,7 +1,7 @@
 /*
 * M*LIB - Integer Generator (GENINT) module
 *
- * Copyright (c) 2017-2021, Patrick Pelissier
+ * Copyright (c) 2017-2023, Patrick Pelissier
 * All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
@@ -30,7 +30,7 @@

 M_BEGIN_PROTECTED_CODE

-/* GENINT is a container providing unique integers.
+/* GENINT is an internal container providing unique integers.
  It has the following properties:
   - it stores integer from [0..N) (N is fixed).
   - an integer can have only one occurrence in the container.
@@ -39,64 +39,62 @@ M_BEGIN_PROTECTED_CODE
   - there are no order (like FIFO or stack)

   This can be used to map integers to index of resources in a table.
-   At most we can support N = 2048 with the master limb usage.
+   At most we can support N = 32*64 = 2048 with the master limb usage.
   For the typical usage of this container
   (mapping hardware or software limited resources), this should be
   enough.
 */

-// TO DO: We may want a specialization with constant N value.
-
 // Define the limb size used by genint
-typedef unsigned long long genint_limb_ct;
+typedef unsigned long long m_genint_limb_ct;

 /* Define a generator of unique integer (Lock Free) */
-typedef struct genint_s {
-  unsigned int n;            // size of the container
-  unsigned int max;          // number of allocated limb - 1
-  genint_limb_ct mask0;       // mask of the last limb (constant)
-  genint_limb_ct mask_master; // mask of the master limb that controls others (constant)
-  atomic_ullong master;      // master bitfield (which informs if a limb is full or not)
-  atomic_ullong *data;       // the bitfield which informs if an integer is used or not
-} genint_t[1];
+typedef struct m_genint_s {
+  unsigned int n;               // size of the container
+  unsigned int max;             // number of allocated limb - 1
+  m_genint_limb_ct mask0;       // mask of the last limb (constant)
+  m_genint_limb_ct mask_master; // mask of the master limb that controls others (constant)
+  atomic_ullong master;         // master bitfield (which informs if a limb is full or not)
+  atomic_ullong *data;          // the bitfield which informs if an integer is used or not
+} m_genint_t[1];

-// Define the max absolute supported value
-#define GENINT_MAX_ALLOC (GENINT_LIMBSIZE * (GENINT_LIMBSIZE - GENINT_ABA_CPT))
+// Define the max absolute supported value. It should be 2048 on most implementations.
+#define M_GENINT_MAX_ALLOC (M_GEN1NT_LIMBSIZE * (M_GEN1NT_LIMBSIZE - M_GEN1NT_ABA_CPT))

 // Define the size of a limb in bits.
-#define GENINT_LIMBSIZE ((unsigned)(sizeof(genint_limb_ct) * CHAR_BIT))
+#define M_GEN1NT_LIMBSIZE ((unsigned)(sizeof(m_genint_limb_ct) * CHAR_BIT))

 // Define the contract of a genint
-#define GENINT_CONTRACT(s)                              do {                  \
+#define M_GEN1NT_CONTRACT(s)                              do {                \
    M_ASSERT (s != NULL);                                                     \
-    M_ASSERT (s->n > 0 && s->n <= GENINT_MAX_ALLOC);                          \
-    M_ASSERT ((s->max+1) * GENINT_LIMBSIZE >= s->n);                          \
+    M_ASSERT (s->n > 0 && s->n <= M_GENINT_MAX_ALLOC);                        \
+    M_ASSERT ((s->max+1) * M_GEN1NT_LIMBSIZE >= s->n);                        \
    M_ASSERT (s->data != NULL);                                               \
  } while (0)

 // Define the limb one
-#define GENINT_ONE  ((genint_limb_ct)1)
+#define M_GEN1NT_ONE  ((m_genint_limb_ct)1)

-#define GENINT_FULL_MASK ULLONG_MAX
+#define M_GEN1NT_FULL_MASK ULLONG_MAX

 // Value returned in case of error (not integer available).
-#define GENINT_ERROR (UINT_MAX)
+#define M_GENINT_ERROR (UINT_MAX)

 /* 32 bits of the master mask are kept for handling the ABA problem.
 * NOTE: May be too much. 16 bits should be more than enough. TBC
 */
-#define GENINT_ABA_CPT 32
-#define GENINT_ABA_CPT_T uint32_t
+#define M_GEN1NT_ABA_CPT 32
+#define M_GEN1NT_ABA_CPT_T uint32_t

 // Set the bit 'i' of the master limb, and increase ABA counter.
-#define GENINT_MASTER_SET(master, i)                                          \
-  ((((master)& (~((GENINT_ONE<< GENINT_ABA_CPT)-1))) | (GENINT_ONE << (GENINT_LIMBSIZE - 1 - i))) \
-   |((GENINT_ABA_CPT_T)((master) + 1)))
+#define M_GEN1NT_MASTER_SET(master, i)                                        \
+  ((((master)& (~((M_GEN1NT_ONE<< M_GEN1NT_ABA_CPT)-1))) | (M_GEN1NT_ONE << (M_GEN1NT_LIMBSIZE - 1 - i))) \
+   |((M_GEN1NT_ABA_CPT_T)((master) + 1)))

 // Reset the bit i of the master limb, and increase ABA counter.
-#define GENINT_MASTER_RESET(master, i)                                        \
-  (((master) & (~((GENINT_ONE<< GENINT_ABA_CPT)-1)) & ~(GENINT_ONE << (GENINT_LIMBSIZE - 1 - i))) \
-   |((GENINT_ABA_CPT_T)((master) + 1)))
+#define M_GEN1NT_MASTER_RESET(master, i)                                      \
+  (((master) & (~((M_GEN1NT_ONE<< M_GEN1NT_ABA_CPT)-1)) & ~(M_GEN1NT_ONE << (M_GEN1NT_LIMBSIZE - 1 - i))) \
+   |((M_GEN1NT_ABA_CPT_T)((master) + 1)))

 /* Initialize an integer generator (CONSTRUCTOR).
 * Initialy, the container is full of all the integers up to 'n-1'
@@ -106,86 +104,86 @@ typedef struct genint_s {
 * for all threads.
 */
 static inline void
-genint_init(genint_t s, unsigned int n)
+m_genint_init(m_genint_t s, unsigned int n)
 {
-  M_ASSERT (s != NULL && n > 0 && n <= GENINT_MAX_ALLOC);
-  const size_t alloc = (n + GENINT_LIMBSIZE - 1) / GENINT_LIMBSIZE;
-  const unsigned int index  = n % GENINT_LIMBSIZE;
+  M_ASSERT (s != NULL && n > 0 && n <= M_GENINT_MAX_ALLOC);
+  const size_t alloc = (n + M_GEN1NT_LIMBSIZE - 1) / M_GEN1NT_LIMBSIZE;
+  const unsigned int index  = n % M_GEN1NT_LIMBSIZE;
  atomic_ullong *ptr = M_MEMORY_REALLOC (atomic_ullong, NULL, alloc);
-  if (M_UNLIKELY (ptr == NULL)) {
+  if (M_UNLIKELY_NOMEM (ptr == NULL)) {
    M_MEMORY_FULL(alloc);
    return;
  }
  s->n = n;
  s->data = ptr;
  s->max = (unsigned int) (alloc-1);
-  s->mask0 = (index == 0) ? GENINT_FULL_MASK : ~((GENINT_ONE<<(GENINT_LIMBSIZE-index))-1);
-  s->mask_master = (((GENINT_ONE << alloc) - 1) << (GENINT_LIMBSIZE-alloc)) >> GENINT_ABA_CPT;
-  atomic_init (&s->master, (genint_limb_ct)0);
+  s->mask0 = (index == 0) ? M_GEN1NT_FULL_MASK : ~((M_GEN1NT_ONE<<(M_GEN1NT_LIMBSIZE-index))-1);
+  s->mask_master = (((M_GEN1NT_ONE << alloc) - 1) << (M_GEN1NT_LIMBSIZE-alloc)) >> M_GEN1NT_ABA_CPT;
+  atomic_init (&s->master, (m_genint_limb_ct)0);
  for(unsigned int i = 0; i < alloc; i++)
-    atomic_init(&s->data[i], (genint_limb_ct)0);
-  GENINT_CONTRACT(s);
+    atomic_init(&s->data[i], (m_genint_limb_ct)0);
+  M_GEN1NT_CONTRACT(s);
 }

 /* Clear an integer generator (Destructor) */
 static inline void
-genint_clear(genint_t s)
+m_genint_clear(m_genint_t s)
 {
-  GENINT_CONTRACT(s);
+  M_GEN1NT_CONTRACT(s);
  M_MEMORY_FREE(s->data);
  s->data = NULL;
 }

 /* Return the maximum integer that the generator will provide */
 static inline size_t
-genint_size(genint_t s)
+m_genint_size(m_genint_t s)
 {
-  GENINT_CONTRACT(s);
+  M_GEN1NT_CONTRACT(s);
  return s->n;
 }

 /* Get an unique integer from the integer generator.
 * NOTE: For a typical case, the amortized cost is one CAS per pop. */
 static inline unsigned int
-genint_pop(genint_t s)
+m_genint_pop(m_genint_t s)
 {
-  GENINT_CONTRACT(s);
+  M_GEN1NT_CONTRACT(s);
  // First read master to see which limb is not full.
-  genint_limb_ct master = atomic_load(&s->master);
+  m_genint_limb_ct master = atomic_load(&s->master);
  // While master is not full
-  while ((master >> GENINT_ABA_CPT) != s->mask_master) {
+  while ((master >> M_GEN1NT_ABA_CPT) != s->mask_master) {
    // Let's get the index i of the first not full limb according to master.
    unsigned int i = m_core_clz64(~master);
-    M_ASSERT (i < GENINT_LIMBSIZE);
+    M_ASSERT (i < M_GEN1NT_LIMBSIZE);
    // Let's compute the mask of this limb representing the limb as being full
-    genint_limb_ct mask = s->mask0;
-    mask = (i == s->max) ? mask : GENINT_FULL_MASK;
+    m_genint_limb_ct mask = s->mask0;
+    mask = (i == s->max) ? mask : M_GEN1NT_FULL_MASK;
    unsigned int bit;
    // Let's load this limb,
-    genint_limb_ct next, org = atomic_load(&s->data[i]);
+    m_genint_limb_ct next, org = atomic_load(&s->data[i]);
    do {
      // If it is now full, we have been preempted by another.
      if (M_UNLIKELY (org == mask))
        goto next_element;
-      M_ASSERT (org != GENINT_FULL_MASK);
+      M_ASSERT (org != M_GEN1NT_FULL_MASK);
      // At least one bit is free in the limb. Find one.
-      bit = GENINT_LIMBSIZE - 1 - m_core_clz64(~org);
-      M_ASSERT (bit < GENINT_LIMBSIZE);
-      M_ASSERT ((org & (GENINT_ONE<<bit)) == 0);
-      M_ASSERT (i * GENINT_LIMBSIZE + GENINT_LIMBSIZE - 1 - bit < s->n);
+      bit = M_GEN1NT_LIMBSIZE - 1 - m_core_clz64(~org);
+      M_ASSERT (bit < M_GEN1NT_LIMBSIZE);
+      M_ASSERT ((org & (M_GEN1NT_ONE<<bit)) == 0);
+      M_ASSERT (i * M_GEN1NT_LIMBSIZE + M_GEN1NT_LIMBSIZE - 1 - bit < s->n);
      // Set the integer as being used.
-      next = org | (GENINT_ONE << bit);
+      next = org | (M_GEN1NT_ONE << bit);
      // Try to reserve the integer 
    } while (!atomic_compare_exchange_weak (&s->data[i], &org, next));
    // We have reserved the integer.
    // If the limb is now full, try to update master
    if (M_UNLIKELY(next == mask)) {
      while (true) {
-        genint_limb_ct newMaster;
+        m_genint_limb_ct newMaster;
        if (next == mask) {
-          newMaster = GENINT_MASTER_SET(master, i);
+          newMaster = M_GEN1NT_MASTER_SET(master, i);
        } else {
-          newMaster = GENINT_MASTER_RESET(master, i);
+          newMaster = M_GEN1NT_MASTER_RESET(master, i);
        }
        if (atomic_compare_exchange_weak (&s->master, &master, newMaster))
          break;
@@ -194,46 +192,46 @@ genint_pop(genint_t s)
      }
    }
    // Return the new number
-    GENINT_CONTRACT(s);
-    return i * GENINT_LIMBSIZE + GENINT_LIMBSIZE - 1 - bit;
+    M_GEN1NT_CONTRACT(s);
+    return i * M_GEN1NT_LIMBSIZE + M_GEN1NT_LIMBSIZE - 1 - bit;
  next_element:
    // Reload master
    master = atomic_load(&s->master);
  }
-  GENINT_CONTRACT(s);
-  return GENINT_ERROR; // No more resource available
+  M_GEN1NT_CONTRACT(s);
+  return M_GENINT_ERROR; // No more resource available
 }

 /* Restore a used integer in the integer generator.
 * NOTE: For a typical case, the amortized cost is one CAS per pop */
 static inline void
-genint_push(genint_t s, unsigned int n)
+m_genint_push(m_genint_t s, unsigned int n)
 {
-  GENINT_CONTRACT(s);
+  M_GEN1NT_CONTRACT(s);
  M_ASSERT (n < s->n);
-  const unsigned int i    = n / GENINT_LIMBSIZE;
-  const unsigned int bit  = GENINT_LIMBSIZE - 1 - (n % GENINT_LIMBSIZE);
-  genint_limb_ct master = atomic_load(&s->master);
+  const unsigned int i    = n / M_GEN1NT_LIMBSIZE;
+  const unsigned int bit  = M_GEN1NT_LIMBSIZE - 1 - (n % M_GEN1NT_LIMBSIZE);
+  m_genint_limb_ct master = atomic_load(&s->master);
  // Load the limb
-  genint_limb_ct next, org = atomic_load(&s->data[i]);
+  m_genint_limb_ct next, org = atomic_load(&s->data[i]);
  do {
-    M_ASSERT ((org & (GENINT_ONE << bit)) != 0);
+    M_ASSERT ((org & (M_GEN1NT_ONE << bit)) != 0);
    // Reset it
-    next = org & (~(GENINT_ONE << bit));
+    next = org & (~(M_GEN1NT_ONE << bit));
    //  Try to unreserve it.
  } while (!atomic_compare_exchange_weak (&s->data[i], &org, next));
  // if the limb  was marked as full by master
-  genint_limb_ct mask = s->mask0;
-  mask = (i == s->max) ? mask : GENINT_FULL_MASK;
+  m_genint_limb_ct mask = s->mask0;
+  mask = (i == s->max) ? mask : M_GEN1NT_FULL_MASK;
  if (M_UNLIKELY (next != mask)) {
    // Let's compute the mask of this limb representing the limb as being full
    // Let's try to update master to say that this limb is not full
    while (true) {
-      genint_limb_ct newMaster;
+      m_genint_limb_ct newMaster;
      if (next == mask) {
-        newMaster = GENINT_MASTER_SET(master, i);
+        newMaster = M_GEN1NT_MASTER_SET(master, i);
      } else {
-        newMaster = GENINT_MASTER_RESET(master, i);
+        newMaster = M_GEN1NT_MASTER_RESET(master, i);
      }
      if (atomic_compare_exchange_weak (&s->master, &master, newMaster))
        break;
@@ -241,7 +239,7 @@ genint_push(genint_t s, unsigned int n)
      next = atomic_load(&s->data[i]);
    }
  }
-  GENINT_CONTRACT(s);
+  M_GEN1NT_CONTRACT(s);
 }

 M_END_PROTECTED_CODE
@@ -1,7 +1,7 @@
 /*
 * M*LIB - Intrusive List module
 *
- * Copyright (c) 2017-2021, Patrick Pelissier
+ * Copyright (c) 2017-2023, Patrick Pelissier
 * All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
@@ -26,7 +26,7 @@
 #define MSTARLIB_I_LIST_H

 #include "m-core.h"
-#include "m-list.h" // For LISTI_ITBASE_DEF
+#include "m-list.h" // For M_L1ST_DEF_ITBASE

 /* Interface to add to a structure to enable intrusive doubly-linked support.
   name: name of the intrusive list.
@@ -38,20 +38,16 @@
      ...
     } tmp_str_t;
 */
-#define ILIST_INTERFACE(name, type)                                           \
-  struct ilist_head_s name
+#define M_ILIST_INTERFACE(name, type)                                         \
+  struct m_il1st_head_s name


 /* Define a doubly-linked intrusive list of a given type.
   The type needs to have ILIST_INTERFACE().
   USAGE:
     ILIST_DEF(name, type [, oplist_of_the_type]) */
-#define ILIST_DEF(name, ...)                                                  \
-  M_BEGIN_PROTECTED_CODE                                                      \
-  ILISTI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                   \
-                ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_C(name, _t), M_C(name, _it_t) ), \
-                 (name, __VA_ARGS__,                                      M_C(name, _t), M_C(name, _it_t) ))) \
-  M_END_PROTECTED_CODE
+#define M_ILIST_DEF(name, ...)                                                \
+  M_ILIST_DEF_AS(name, M_F(name,_t), M_F(name,_it_t), __VA_ARGS__)


 /* Define a doubly-linked intrusive list of a given type
@@ -59,9 +55,9 @@
   The type needs to have ILIST_INTERFACE().
   USAGE:
     ILIST_DEF_AS(name, name_t, it_t, type [, oplist_of_the_type]) */
-#define ILIST_DEF_AS(name, name_t, it_t, ...)                                 \
+#define M_ILIST_DEF_AS(name, name_t, it_t, ...)                               \
  M_BEGIN_PROTECTED_CODE                                                      \
-  ILISTI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                   \
+  M_IL1ST_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                  \
                ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t, it_t ), \
                 (name, __VA_ARGS__,                                        name_t, it_t ))) \
  M_END_PROTECTED_CODE
@@ -70,63 +66,69 @@
 /* Define the oplist of a doubly-linked instrusive list of type.
   USAGE:
     ILIST_OPLIST(name [, oplist_of_the_type]) */
-#define ILIST_OPLIST(...)                                                     \
-  ILISTI_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                \
-                ((__VA_ARGS__, M_DEFAULT_OPLIST),                             \
+#define M_ILIST_OPLIST(...)                                                   \
+  M_IL1ST_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                               \
+                ((__VA_ARGS__, M_BASIC_OPLIST),                               \
                 (__VA_ARGS__ )))


-/********************************** INTERNAL ************************************/
+/*****************************************************************************/
+/******************************** INTERNAL ***********************************/
+/*****************************************************************************/

 /* Define the basic structure to be added in all objects. */
-typedef struct ilist_head_s {
-  struct ilist_head_s *next;
-  struct ilist_head_s *prev;
-} ilist_head_ct;
+typedef struct m_il1st_head_s {
+  struct m_il1st_head_s *next;
+  struct m_il1st_head_s *prev;
+} m_il1st_head_ct;

 /* Indirection call to allow expanding all arguments */
-#define ILISTI_OPLIST_P1(arg) ILISTI_OPLIST_P2 arg
+#define M_IL1ST_OPLIST_P1(arg) M_IL1ST_OPLIST_P2 arg

 /* Validation of the given oplist */
-#define ILISTI_OPLIST_P2(name, oplist)                                        \
-  M_IF_OPLIST(oplist)(ILISTI_OPLIST_P3, ILISTI_OPLIST_FAILURE)(name, oplist)
+#define M_IL1ST_OPLIST_P2(name, oplist)                                       \
+  M_IF_OPLIST(oplist)(M_IL1ST_OPLIST_P3, M_IL1ST_OPLIST_FAILURE)(name, oplist)

 /* Prepare a clean compilation failure */
-#define ILISTI_OPLIST_FAILURE(name, oplist)                                   \
+#define M_IL1ST_OPLIST_FAILURE(name, oplist)                                  \
  ((M_LIB_ERROR(ARGUMENT_OF_ILIST_OPLIST_IS_NOT_AN_OPLIST, name, oplist)))

 /* Define the oplist of an ilist of type */
-#define ILISTI_OPLIST_P3(name, oplist)                                        \
-  (INIT(M_C(name, _init)),                                                    \
-   CLEAR(M_C(name, _clear)),                                                  \
-   INIT_MOVE(M_C(name, _init_move)),                                          \
-   MOVE(M_C(name, _move)),                                                    \
-   TYPE(M_C(name,_ct)),                                                       \
-   CLEAN(M_C(name,_clean)),                                                   \
-   SUBTYPE(M_C(name,_subtype_ct)),                                            \
-   EMPTY_P(M_C(name,_empty_p)),                                               \
-   IT_TYPE(M_C(name,_it_ct)),                                                 \
-   IT_FIRST(M_C(name,_it)),                                                   \
-   IT_SET(M_C(name,_it_set)),                                                 \
-   IT_LAST(M_C(name,_it_last)),                                               \
-   IT_END(M_C(name,_it_end)),                                                 \
-   IT_END_P(M_C(name,_end_p)),                                                \
-   IT_LAST_P(M_C(name,_last_p)),                                              \
-   IT_EQUAL_P(M_C(name,_it_equal_p)),                                         \
-   IT_NEXT(M_C(name,_next)),                                                  \
-   IT_PREVIOUS(M_C(name,_previous)),                                          \
-   IT_REF(M_C(name,_ref)),                                                    \
-   IT_CREF(M_C(name,_cref)),                                                  \
-   IT_REMOVE(M_C(name,_remove)),                                              \
-   M_IF_METHOD(NEW, oplist)(IT_INSERT(M_C(name,_insert)),),                   \
+#define M_IL1ST_OPLIST_P3(name, oplist)                                       \
+  (INIT(M_F(name, _init)),                                                    \
+   CLEAR(M_F(name, _clear)),                                                  \
+   INIT_MOVE(M_F(name, _init_move)),                                          \
+   MOVE(M_F(name, _move)),                                                    \
+   NAME(name),                                                                \
+   TYPE(M_F(name,_ct)),                                                       \
+   RESET(M_F(name,_reset)),                                                   \
+   SUBTYPE(M_F(name,_subtype_ct)),                                            \
+   EMPTY_P(M_F(name,_empty_p)),                                               \
+   IT_TYPE(M_F(name,_it_ct)),                                                 \
+   IT_FIRST(M_F(name,_it)),                                                   \
+   IT_SET(M_F(name,_it_set)),                                                 \
+   IT_LAST(M_F(name,_it_last)),                                               \
+   IT_END(M_F(name,_it_end)),                                                 \
+   IT_END_P(M_F(name,_end_p)),                                                \
+   IT_LAST_P(M_F(name,_last_p)),                                              \
+   IT_EQUAL_P(M_F(name,_it_equal_p)),                                         \
+   IT_NEXT(M_F(name,_next)),                                                  \
+   IT_PREVIOUS(M_F(name,_previous)),                                          \
+   IT_REF(M_F(name,_ref)),                                                    \
+   IT_CREF(M_F(name,_cref)),                                                  \
+   IT_REMOVE(M_F(name,_remove)),                                              \
+   M_IF_METHOD(NEW, oplist)(IT_INSERT(M_F(name,_insert)),),                   \
   OPLIST(oplist),                                                            \
-   SPLICE_BACK(M_C(name,_splice_back))                                        \
+   SPLICE_BACK(M_F(name,_splice_back))                                        \
   ,M_IF_METHOD(NEW, oplist)(NEW(M_GET_NEW oplist),)                          \
   ,M_IF_METHOD(DEL, oplist)(DEL(M_GET_DEL oplist),)                          \
   )

+
+/******************************** INTERNAL ***********************************/
+
 /* Contract respected by all intrusive lists */
-#define ILISTI_CONTRACT(name, list) do {                                      \
+#define M_IL1ST_CONTRACT(name, list) do {                                     \
    M_ASSERT(list != NULL);                                                   \
    M_ASSERT(list->name.prev != NULL);                                        \
    M_ASSERT(list->name.next != NULL);                                        \
@@ -135,7 +137,7 @@ typedef struct ilist_head_s {
    M_ASSERT(!(list->name.prev == &list->name) || list->name.prev == list->name.next); \
  } while (0)

-#define ILISTI_NODE_CONTRACT(node) do {                                       \
+#define M_IL1ST_NODE_CONTRACT(node) do {                                      \
    M_ASSERT((node) != NULL);                                                 \
    M_ASSERT((node)->prev != NULL);                                           \
    M_ASSERT((node)->next != NULL);                                           \
@@ -143,15 +145,15 @@ typedef struct ilist_head_s {
    M_ASSERT((node)->prev->next == node);                                     \
  } while (0)

-/* Indirection call to allow expanding all arguments (TBC) */
-#define ILISTI_DEF_P1(arg) ILISTI_DEF_P2 arg
+/* Indirection call to allow expanding all arguments */
+#define M_IL1ST_DEF_P1(arg) M_ID( M_IL1ST_DEF_P2 arg )

 /* Validate the oplist before going further */
-#define ILISTI_DEF_P2(name, type, oplist, list_t, it_t)                       \
-  M_IF_OPLIST(oplist)(ILISTI_DEF_P3, ILISTI_DEF_FAILURE)(name, type, oplist, list_t, it_t)
+#define M_IL1ST_DEF_P2(name, type, oplist, list_t, it_t)                      \
+  M_IF_OPLIST(oplist)(M_IL1ST_DEF_P3, M_IL1ST_DEF_FAILURE)(name, type, oplist, list_t, it_t)

 /* Stop processing with a compilation failure */
-#define ILISTI_DEF_FAILURE(name, type, oplist, list_t, it_t)                  \
+#define M_IL1ST_DEF_FAILURE(name, type, oplist, list_t, it_t)                 \
  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(ILIST_DEF): the given argument is not a valid oplist: " #oplist)

 /* Definition of the type and function for an intrusive doubly-linked list.
@@ -162,51 +164,60 @@ typedef struct ilist_head_s {
    list_t: type of the intrusive list (name##_t)
    it_t: iterator of the intrusive list (name##_it_t)
 */
-#define ILISTI_DEF_P3(name, type, oplist, list_t, it_t)                       \
+#define M_IL1ST_DEF_P3(name, type, oplist, list_t, it_t)                      \
+  M_IL1ST_DEF_TYPE(name, type, oplist, list_t, it_t)                          \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_IL1ST_DEF_CORE(name, type, oplist, list_t, it_t)                          \
+  /* Used of internal macro from m-list */                                    \
+  M_L1ST_DEF_ITBASE(M_EXPAND_FUNC_INLINE, name, type, oplist, list_t, it_t)
+
+/* Define the type of an intrusive list */
+#define M_IL1ST_DEF_TYPE(name, type, oplist, list_t, it_t)                    \
                                                                              \
  /* Define the list as a structure containing pointers                       \
   * to the front & back nodes */                                             \
-  typedef struct M_C(name, _s) {                                              \
-    struct ilist_head_s name;                                                 \
+  typedef struct M_F(name, _s) {                                              \
+    struct m_il1st_head_s name;                                               \
  } list_t[1];                                                                \
                                                                              \
  /* Define internal types pointers to such a list */                         \
-  typedef struct M_C(name, _s) *M_C(name, _ptr);                              \
-  typedef const struct M_C(name, _s) *M_C(name, _srcptr);                     \
+  typedef struct M_F(name, _s) *M_F(name, _ptr);                              \
+  typedef const struct M_F(name, _s) *M_F(name, _srcptr);                     \
                                                                              \
  /* Define iterator of such a list */                                        \
-  typedef struct M_C(name, _it_s) {                                           \
-    struct ilist_head_s *head;                                                \
-    struct ilist_head_s *previous;                                            \
-    struct ilist_head_s *current;                                             \
-    struct ilist_head_s *next;                                                \
+  typedef struct M_F(name, _it_s) {                                           \
+    struct m_il1st_head_s *head;                                              \
+    struct m_il1st_head_s *previous;                                          \
+    struct m_il1st_head_s *current;                                           \
+    struct m_il1st_head_s *next;                                              \
  } it_t[1];                                                                  \
                                                                              \
  /* Define types used by oplist */                                           \
-  typedef type   M_C(name, _subtype_ct);                                      \
-  typedef list_t M_C(name, _ct);                                              \
-  typedef it_t   M_C(name, _it_ct);                                           \
-                                                                              \
-  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  typedef type   M_F(name, _subtype_ct);                                      \
+  typedef list_t M_F(name, _ct);                                              \
+  typedef it_t   M_F(name, _it_ct);                                           \
+
+/* Define core functions for intrusive lists */
+#define M_IL1ST_DEF_CORE(name, type, oplist, list_t, it_t)                    \
                                                                              \
  static inline void                                                          \
-  M_C(name, _init)(list_t list)                                               \
+  M_F(name, _init)(list_t list)                                               \
  {                                                                           \
    M_ASSERT (list != NULL);                                                  \
    list->name.next = &list->name;                                            \
    list->name.prev = &list->name;                                            \
-    ILISTI_CONTRACT(name, list);                                              \
+    M_IL1ST_CONTRACT(name, list);                                             \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _clean)(list_t list)                                              \
+  M_F(name, _reset)(list_t list)                                              \
  {                                                                           \
-    ILISTI_CONTRACT(name, list);                                              \
-    for(struct ilist_head_s *it = list->name.next, *next ;                    \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    for(struct m_il1st_head_s *it = list->name.next, *next ;                  \
        it != &list->name; it = next) {                                       \
      /* Cannot check node contract as previous node may be deleted */        \
      type *obj = M_TYPE_FROM_FIELD(type, it,                                 \
-                                    struct ilist_head_s, name);               \
+                                    struct m_il1st_head_s, name);             \
      /* Read next now before the object is destroyed */                      \
      next = it->next;                                                        \
      M_ASSERT (next != NULL);                                                \
@@ -217,34 +228,34 @@ typedef struct ilist_head_s {
    /* Nothing remains in the list anymore */                                 \
    list->name.next = &list->name;                                            \
    list->name.prev = &list->name;                                            \
-    ILISTI_CONTRACT(name, list);                                              \
+    M_IL1ST_CONTRACT(name, list);                                             \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _clear)(list_t list)                                              \
+  M_F(name, _clear)(list_t list)                                              \
  {                                                                           \
    /* Nothing to do more than clean the list itself */                       \
-    M_C(name, _clean)(list);                                                  \
+    M_F(name, _reset)(list);                                                  \
    /* For safety purpose (create invalid represenation of object) */         \
    list->name.next = NULL;                                                   \
    list->name.prev = NULL;                                                   \
  }                                                                           \
                                                                              \
  static inline bool                                                          \
-  M_C(name, _empty_p)(const list_t list)                                      \
+  M_F(name, _empty_p)(const list_t list)                                      \
  {                                                                           \
-    ILISTI_CONTRACT(name, list);                                              \
+    M_IL1ST_CONTRACT(name, list);                                             \
    return list->name.next == &list->name;                                    \
  }                                                                           \
                                                                              \
                                                                              \
  static inline void                                                          \
-  M_C(name, _init_move)(list_t list, list_t ref)                              \
+  M_F(name, _init_move)(list_t list, list_t ref)                              \
  {                                                                           \
-    ILISTI_CONTRACT(name, ref);                                               \
+    M_IL1ST_CONTRACT(name, ref);                                              \
    M_ASSERT (list != ref);                                                   \
-    M_C(name,_init)(list);                                                    \
-    if (!M_C(name,_empty_p)(ref)) {                                           \
+    M_F(name,_init)(list);                                                    \
+    if (!M_F(name,_empty_p)(ref)) {                                           \
      list->name.next = ref->name.next;                                       \
      list->name.prev = ref->name.prev;                                       \
      list->name.next->prev = &list->name;                                    \
@@ -252,63 +263,63 @@ typedef struct ilist_head_s {
    }                                                                         \
    ref->name.next = NULL;                                                    \
    ref->name.prev = NULL;                                                    \
-    ILISTI_CONTRACT(name, list);                                              \
+    M_IL1ST_CONTRACT(name, list);                                             \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _move)(list_t list, list_t ref)                                   \
+  M_F(name, _move)(list_t list, list_t ref)                                   \
  {                                                                           \
-    M_C(name, _clear)(list);                                                  \
-    M_C(name, _init_move)(list, ref);                                         \
+    M_F(name, _clear)(list);                                                  \
+    M_F(name, _init_move)(list, ref);                                         \
  }                                                                           \
                                                                              \
  static inline size_t                                                        \
-  M_C(name, _size)(const list_t list)                                         \
+  M_F(name, _size)(const list_t list)                                         \
  {                                                                           \
-    ILISTI_CONTRACT(name, list);                                              \
+    M_IL1ST_CONTRACT(name, list);                                             \
    size_t s = 0;                                                             \
    /* Scan the full list to count the number of elements */                  \
-    for(const struct ilist_head_s *it = list->name.next ;                     \
+    for(const struct m_il1st_head_s *it = list->name.next ;                   \
        it != &list->name; it = it->next) {                                   \
-      ILISTI_NODE_CONTRACT(it);                                               \
+      M_IL1ST_NODE_CONTRACT(it);                                              \
      s++;                                                                    \
    }                                                                         \
    return s;                                                                 \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _push_back)(list_t list, type *obj)                               \
+  M_F(name, _push_back)(list_t list, type *obj)                               \
  {                                                                           \
-    ILISTI_CONTRACT(name, list);                                              \
+    M_IL1ST_CONTRACT(name, list);                                             \
    M_ASSERT (obj != NULL);                                                   \
-    struct ilist_head_s *prev = list->name.prev;                              \
+    struct m_il1st_head_s *prev = list->name.prev;                            \
    list->name.prev = &obj->name;                                             \
    obj->name.prev = prev;                                                    \
    obj->name.next = &list->name;                                             \
    prev->next = &obj->name;                                                  \
-    ILISTI_CONTRACT(name, list);                                              \
+    M_IL1ST_CONTRACT(name, list);                                             \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _push_front)(list_t list, type *obj)                              \
+  M_F(name, _push_front)(list_t list, type *obj)                              \
  {                                                                           \
-    ILISTI_CONTRACT(name, list);                                              \
+    M_IL1ST_CONTRACT(name, list);                                             \
    M_ASSERT (obj != NULL);                                                   \
-    struct ilist_head_s *next = list->name.next;                              \
+    struct m_il1st_head_s *next = list->name.next;                            \
    list->name.next = &obj->name;                                             \
    obj->name.next = next;                                                    \
    obj->name.prev = &list->name;                                             \
    next->prev = &obj->name;                                                  \
-    ILISTI_CONTRACT(name, list);                                              \
+    M_IL1ST_CONTRACT(name, list);                                             \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _push_after)(type *obj_pos, type *obj)                            \
+  M_F(name, _push_after)(type *obj_pos, type *obj)                            \
  {                                                                           \
    M_ASSERT (obj_pos != NULL && obj != NULL);                                \
    /* We don't have the list, so we have no contract at list level */        \
-    ILISTI_NODE_CONTRACT(&obj_pos->name);                                     \
-    struct ilist_head_s *next = obj_pos->name.next;                           \
+    M_IL1ST_NODE_CONTRACT(&obj_pos->name);                                    \
+    struct m_il1st_head_s *next = obj_pos->name.next;                         \
    obj_pos->name.next = &obj->name;                                          \
    obj->name.next = next;                                                    \
    obj->name.prev = &obj_pos->name;                                          \
@@ -316,7 +327,7 @@ typedef struct ilist_head_s {
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _init_field)(type *obj)                                           \
+  M_F(name, _init_field)(type *obj)                                           \
  {                                                                           \
    M_ASSERT (obj != NULL);                                                   \
    /* Init the fields of the node. To be used in object constructor */       \
@@ -325,13 +336,13 @@ typedef struct ilist_head_s {
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _unlink)(type *obj)                                               \
+  M_F(name, _unlink)(type *obj)                                               \
  {                                                                           \
    M_ASSERT (obj != NULL);                                                   \
    /* We don't have the list, so we have no contract at list level */        \
-    ILISTI_NODE_CONTRACT(&obj->name);                                         \
-    struct ilist_head_s *next = obj->name.next;                               \
-    struct ilist_head_s *prev = obj->name.prev;                               \
+    M_IL1ST_NODE_CONTRACT(&obj->name);                                        \
+    struct m_il1st_head_s *next = obj->name.next;                             \
+    struct m_il1st_head_s *prev = obj->name.prev;                             \
    next->prev = prev;                                                        \
    prev->next = next;                                                        \
    /* Note: not really needed, but safer */                                  \
@@ -340,109 +351,109 @@ typedef struct ilist_head_s {
  }                                                                           \
                                                                              \
  static inline type *                                                        \
-  M_C(name, _back)(const list_t list)                                         \
+  M_F(name, _back)(const list_t list)                                         \
  {                                                                           \
-    ILISTI_CONTRACT(name, list);                                              \
-    M_ASSERT(!M_C(name, _empty_p)(list));                                     \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    M_ASSERT(!M_F(name, _empty_p)(list));                                     \
    return M_TYPE_FROM_FIELD(type, list->name.prev,                           \
-                             struct ilist_head_s, name);                      \
+                             struct m_il1st_head_s, name);                    \
  }                                                                           \
                                                                              \
  static inline type *                                                        \
-  M_C(name, _front)(const list_t list)                                        \
+  M_F(name, _front)(const list_t list)                                        \
  {                                                                           \
-    ILISTI_CONTRACT(name, list);                                              \
-    M_ASSERT(!M_C(name, _empty_p)(list));                                     \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    M_ASSERT(!M_F(name, _empty_p)(list));                                     \
    return M_TYPE_FROM_FIELD(type, list->name.next,                           \
-                             struct ilist_head_s, name);                      \
+                             struct m_il1st_head_s, name);                    \
  }                                                                           \
                                                                              \
  static inline type *                                                        \
-  M_C(name, _next_obj)(const list_t list, type const *obj)                    \
+  M_F(name, _next_obj)(const list_t list, type const *obj)                    \
  {                                                                           \
-    ILISTI_CONTRACT(name, list);                                              \
+    M_IL1ST_CONTRACT(name, list);                                             \
    M_ASSERT (obj != NULL);                                                   \
-    ILISTI_NODE_CONTRACT(&obj->name);                                         \
+    M_IL1ST_NODE_CONTRACT(&obj->name);                                        \
    return obj->name.next == &list->name ? NULL :                             \
      M_TYPE_FROM_FIELD(type, obj->name.next,                                 \
-                        struct ilist_head_s, name);                           \
+                        struct m_il1st_head_s, name);                         \
  }                                                                           \
                                                                              \
  static inline type *                                                        \
-  M_C(name, _previous_obj)(const list_t list, type const *obj)                \
+  M_F(name, _previous_obj)(const list_t list, type const *obj)                \
  {                                                                           \
-    ILISTI_CONTRACT(name, list);                                              \
+    M_IL1ST_CONTRACT(name, list);                                             \
    M_ASSERT (obj != NULL);                                                   \
-    ILISTI_NODE_CONTRACT(&obj->name);                                         \
+    M_IL1ST_NODE_CONTRACT(&obj->name);                                        \
    return obj->name.prev == &list->name ? NULL :                             \
      M_TYPE_FROM_FIELD(type, obj->name.prev,                                 \
-                        struct ilist_head_s, name);                           \
+                        struct m_il1st_head_s, name);                         \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _it)(it_t it, const list_t list)                                  \
+  M_F(name, _it)(it_t it, const list_t list)                                  \
  {                                                                           \
-    ILISTI_CONTRACT(name, list);                                              \
+    M_IL1ST_CONTRACT(name, list);                                             \
    M_ASSERT (it != NULL);                                                    \
    it->head = list->name.next->prev;                                         \
    it->current = list->name.next;                                            \
    it->next = list->name.next->next;                                         \
    it->previous = it->head;                                                  \
-    ILISTI_NODE_CONTRACT(it->current);                                        \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _it_set)(it_t it, const it_t cit)                                 \
+  M_F(name, _it_set)(it_t it, const it_t cit)                                 \
  {                                                                           \
    M_ASSERT (it != NULL && cit != NULL);                                     \
    it->head = cit->head;                                                     \
    it->current = cit->current;                                               \
    it->next = cit->next;                                                     \
    it->previous = cit->previous;                                             \
-    ILISTI_NODE_CONTRACT(it->current);                                        \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _it_last)(it_t it, list_t const list)                             \
+  M_F(name, _it_last)(it_t it, list_t const list)                             \
  {                                                                           \
-    ILISTI_CONTRACT(name, list);                                              \
+    M_IL1ST_CONTRACT(name, list);                                             \
    M_ASSERT (it != NULL);                                                    \
    it->head = list->name.next->prev;                                         \
    it->current = list->name.prev;                                            \
    it->next = it->head;                                                      \
    it->previous = list->name.prev->prev;                                     \
-    ILISTI_NODE_CONTRACT(it->current);                                        \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _it_end)(it_t it, list_t const list)                              \
+  M_F(name, _it_end)(it_t it, list_t const list)                              \
  {                                                                           \
    M_ASSERT (it != NULL && list != NULL);                                    \
    it->head = list->name.next->prev;                                         \
    it->current = it->head;                                                   \
    it->next = list->name.next;                                               \
    it->previous = list->name.prev;                                           \
-    ILISTI_NODE_CONTRACT(it->current);                                        \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
  }                                                                           \
                                                                              \
  static inline bool                                                          \
-  M_C(name, _end_p)(const it_t it)                                            \
+  M_F(name, _end_p)(const it_t it)                                            \
  {                                                                           \
    M_ASSERT (it != NULL);                                                    \
-    ILISTI_NODE_CONTRACT(it->current);                                        \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
    return it->current == it->head;                                           \
  }                                                                           \
                                                                              \
  static inline bool                                                          \
-  M_C(name, _last_p)(const it_t it)                                           \
+  M_F(name, _last_p)(const it_t it)                                           \
  {                                                                           \
    M_ASSERT (it != NULL);                                                    \
-    ILISTI_NODE_CONTRACT(it->current);                                        \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
    return it->next == it->head || it->current == it->head;                   \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _next)(it_t it)                                                   \
+  M_F(name, _next)(it_t it)                                                   \
  {                                                                           \
    M_ASSERT (it != NULL);                                                    \
    /* Cannot check node for it->current: it may have been deleted! */        \
@@ -453,11 +464,11 @@ typedef struct ilist_head_s {
    it->next     = it->current->next;                                         \
    it->previous = it->current->prev;                                         \
    M_ASSERT (it->next != NULL && it->previous != NULL);                      \
-    ILISTI_NODE_CONTRACT(it->current);                                        \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _previous)(it_t it)                                               \
+  M_F(name, _previous)(it_t it)                                               \
  {                                                                           \
    M_ASSERT (it != NULL);                                                    \
    /* Cannot check node for it->current: it may have been deleted! */        \
@@ -468,11 +479,11 @@ typedef struct ilist_head_s {
    it->next     = it->current->next;                                         \
    it->previous = it->current->prev;                                         \
    M_ASSERT (it->next != NULL && it->previous != NULL);                      \
-    ILISTI_NODE_CONTRACT(it->current);                                        \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
  }                                                                           \
                                                                              \
  static inline bool                                                          \
-  M_C(name, _it_equal_p)(const it_t it1, const it_t it2 )                     \
+  M_F(name, _it_equal_p)(const it_t it1, const it_t it2 )                     \
  {                                                                           \
    M_ASSERT (it1 != NULL && it2 != NULL);                                    \
    /* No need to check for next & previous */                                \
@@ -480,151 +491,153 @@ typedef struct ilist_head_s {
  }                                                                           \
                                                                              \
  static inline type *                                                        \
-  M_C(name, _ref)(const it_t it)                                              \
+  M_F(name, _ref)(const it_t it)                                              \
  {                                                                           \
    M_ASSERT (it != NULL && it->current != NULL);                             \
-    ILISTI_NODE_CONTRACT(it->current);                                        \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
    /* check if 'it' was not deleted */                                       \
    M_ASSERT (it->current->next == it->next);                                 \
    M_ASSERT (it->current->prev == it->previous);                             \
-    M_ASSERT (!M_C(name, _end_p)(it));                                        \
+    M_ASSERT (!M_F(name, _end_p)(it));                                        \
    return M_TYPE_FROM_FIELD(type, it->current,                               \
-                             struct ilist_head_s, name);                      \
+                             struct m_il1st_head_s, name);                    \
  }                                                                           \
                                                                              \
  static inline type const *                                                  \
-  M_C(name, _cref)(const it_t it)                                             \
+  M_F(name, _cref)(const it_t it)                                             \
  {                                                                           \
-    type *ptr = M_C(name, _ref)(it);                                          \
+    type *ptr = M_F(name, _ref)(it);                                          \
    return M_CONST_CAST(type, ptr);                                           \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _remove)(list_t list, it_t it)                                    \
+  M_F(name, _remove)(list_t list, it_t it)                                    \
  {                                                                           \
-    ILISTI_CONTRACT(name, list);                                              \
-    ILISTI_NODE_CONTRACT(it->current);                                        \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
    (void)list;        /* list param is not used */                           \
    type *obj = M_TYPE_FROM_FIELD(type, it->current,                          \
-                                  struct ilist_head_s, name);                 \
-    M_C(name, _unlink)(obj);                                                  \
+                                  struct m_il1st_head_s, name);               \
+    M_F(name, _unlink)(obj);                                                  \
    M_CALL_CLEAR(oplist, obj);                                                \
    M_IF_METHOD(DEL, oplist)(M_CALL_DEL(oplist, obj), (void) 0);              \
-    M_C(name, _next)(it);                                                     \
+    M_F(name, _next)(it);                                                     \
  }                                                                           \
                                                                              \
-  M_IF_METHOD(NEW, oplist)(                                                   \
+  M_IF_METHOD2(NEW, INIT_SET, oplist)(                                        \
  static inline void                                                          \
-  M_C(name, _insert)(list_t list, it_t it, type x)                            \
+  M_F(name, _insert)(list_t list, it_t it, type x)                            \
  {                                                                           \
-    ILISTI_CONTRACT(name, list);                                              \
-    ILISTI_NODE_CONTRACT(it->current);                                        \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
    type *p = M_CALL_NEW(oplist, type);                                       \
-    if (M_UNLIKELY (p == NULL)) {                                             \
+    if (M_UNLIKELY_NOMEM (p == NULL)) {                                       \
      M_MEMORY_FULL (sizeof (type));                                          \
      return ;                                                                \
    }                                                                         \
    M_CALL_INIT_SET(oplist, *p, x);                                           \
-    type *obj = M_C(name, _ref)(it);                                          \
-    M_C(name, _push_after)(obj, p);                                           \
+    type *obj = M_F(name, _ref)(it);                                          \
+    M_F(name, _push_after)(obj, p);                                           \
    it->current = p;                                                          \
    (void) list;                                                              \
-    ILISTI_CONTRACT(name, list);                                              \
+    M_IL1ST_CONTRACT(name, list);                                             \
  }                                                                           \
-  , /* NEW not defined */)                                                    \
+  , /* NEW & INIT_SET not defined */)                                         \
                                                                              \
  static inline type *                                                        \
-  M_C(name, _pop_back)(list_t list)                                           \
+  M_F(name, _pop_back)(list_t list)                                           \
  {                                                                           \
-    ILISTI_CONTRACT(name, list);                                              \
-    M_ASSERT (!M_C(name, _empty_p)(list));                                    \
-    type *obj = M_C(name, _back)(list);                                       \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    M_ASSERT (!M_F(name, _empty_p)(list));                                    \
+    type *obj = M_F(name, _back)(list);                                       \
    list->name.prev = list->name.prev->prev;                                  \
    list->name.prev->next = &list->name;                                      \
    return obj;                                                               \
  }                                                                           \
                                                                              \
  static inline type *                                                        \
-  M_C(name, _pop_front)(list_t list)                                          \
+  M_F(name, _pop_front)(list_t list)                                          \
  {                                                                           \
-    ILISTI_CONTRACT(name, list);                                              \
-    M_ASSERT (!M_C(name, _empty_p)(list));                                    \
-    type *obj = M_C(name, _front)(list);                                      \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    M_ASSERT (!M_F(name, _empty_p)(list));                                    \
+    type *obj = M_F(name, _front)(list);                                      \
    list->name.next = list->name.next->next;                                  \
    list->name.next->prev = &list->name;                                      \
    return obj;                                                               \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _splice)(list_t list1, list_t list2)                              \
+  M_F(name, _splice)(list_t list1, list_t list2)                              \
  {                                                                           \
-    ILISTI_CONTRACT(name, list1);                                             \
-    ILISTI_CONTRACT(name, list2);                                             \
-    struct ilist_head_s *midle1 = list1->name.prev;                           \
-    struct ilist_head_s *midle2 = list2->name.next;                           \
+    M_IL1ST_CONTRACT(name, list1);                                            \
+    M_IL1ST_CONTRACT(name, list2);                                            \
+    struct m_il1st_head_s *midle1 = list1->name.prev;                         \
+    struct m_il1st_head_s *midle2 = list2->name.next;                         \
    midle1->next = midle2;                                                    \
    midle2->prev = midle1;                                                    \
    list1->name.prev = list2->name.prev;                                      \
    list2->name.prev->next = &list1->name;                                    \
    list2->name.next = &list2->name;                                          \
    list2->name.prev = &list2->name;                                          \
-    ILISTI_CONTRACT(name, list1);                                             \
-    ILISTI_CONTRACT(name, list2);                                             \
+    M_IL1ST_CONTRACT(name, list1);                                            \
+    M_IL1ST_CONTRACT(name, list2);                                            \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _splice_back)(list_t nv, list_t ov, it_t it)                      \
+  M_F(name, _splice_back)(list_t nv, list_t ov, it_t it)                      \
  {                                                                           \
-    ILISTI_CONTRACT(name, nv);                                                \
-    ILISTI_CONTRACT(name, ov);                                                \
-    ILISTI_NODE_CONTRACT(it->current);                                        \
+    M_IL1ST_CONTRACT(name, nv);                                               \
+    M_IL1ST_CONTRACT(name, ov);                                               \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
    M_ASSERT (it != NULL);                                                    \
    (void) ov;                                                                \
-    type *obj = M_C(name, _ref)(it);                                          \
-    M_C(name, _unlink)(obj);                                                  \
-    M_C(name, _push_back)(nv, obj);                                           \
-    M_C(name, _next)(it);                                                     \
-    ILISTI_CONTRACT(name, nv);                                                \
-    ILISTI_CONTRACT(name, ov);                                                \
+    type *obj = M_F(name, _ref)(it);                                          \
+    M_F(name, _unlink)(obj);                                                  \
+    M_F(name, _push_back)(nv, obj);                                           \
+    M_F(name, _next)(it);                                                     \
+    M_IL1ST_CONTRACT(name, nv);                                               \
+    M_IL1ST_CONTRACT(name, ov);                                               \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _splice_at)(list_t nlist, it_t npos,                              \
+  M_F(name, _splice_at)(list_t nlist, it_t npos,                              \
                        list_t olist, it_t opos)                              \
  {                                                                           \
-    ILISTI_CONTRACT(name, nlist);                                             \
-    ILISTI_CONTRACT(name, olist);                                             \
+    M_IL1ST_CONTRACT(name, nlist);                                            \
+    M_IL1ST_CONTRACT(name, olist);                                            \
    M_ASSERT (npos != NULL && opos != NULL);                                  \
-    M_ASSERT (!M_C(name, _end_p)(opos));                                      \
+    M_ASSERT (!M_F(name, _end_p)(opos));                                      \
    /* npos may be end */                                                     \
    (void) olist, (void) nlist;                                               \
-    type *obj = M_C(name, _ref)(opos);                                        \
-    struct ilist_head_s *ref = npos->current;                                 \
+    type *obj = M_F(name, _ref)(opos);                                        \
+    struct m_il1st_head_s *ref = npos->current;                               \
    /* Remove object */                                                       \
-    M_C(name, _unlink)(obj);                                                  \
+    M_F(name, _unlink)(obj);                                                  \
    /* Push 'obj' after 'ref' */                                              \
-    struct ilist_head_s *next = ref->next;                                    \
+    struct m_il1st_head_s *next = ref->next;                                  \
    ref->next = &obj->name;                                                   \
    obj->name.next = next;                                                    \
    obj->name.prev = ref;                                                     \
    next->prev = &obj->name;                                                  \
    /* Move iterator in old list */                                           \
-    M_C(name, _next)(opos);                                                   \
+    M_F(name, _next)(opos);                                                   \
    /* Set npos iterator to new position of object */                         \
    npos->previous = ref;                                                     \
    npos->current = &obj->name;                                               \
    npos->next = next;                                                        \
-    ILISTI_CONTRACT(name, nlist);                                             \
-    ILISTI_CONTRACT(name, olist);                                             \
+    M_IL1ST_CONTRACT(name, nlist);                                            \
+    M_IL1ST_CONTRACT(name, olist);                                            \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _swap)(list_t d, list_t e)                                        \
+  M_F(name, _swap)(list_t d, list_t e)                                        \
  {                                                                           \
-    ILISTI_CONTRACT(name, d);                                                 \
-    ILISTI_CONTRACT(name, e);                                                 \
-    struct ilist_head_s *d_item = d->name.next;                               \
-    struct ilist_head_s *e_item = e->name.next;                               \
+    M_IL1ST_CONTRACT(name, d);                                                \
+    M_IL1ST_CONTRACT(name, e);                                                \
+    struct m_il1st_head_s *d_item = d->name.next;                             \
+    struct m_il1st_head_s *e_item = e->name.next;                             \
+    /* it is more complicated than other swap functions since                 \
+       we need to detect "cyclic" loop */                                     \
    d->name.next = e_item == &e->name ? &d->name : e_item;                    \
    e->name.next = d_item == &d->name ? &e->name : d_item;                    \
    d_item = d->name.prev;                                                    \
@@ -635,15 +648,15 @@ typedef struct ilist_head_s {
    d->name.prev->next = &d->name;                                            \
    e->name.next->prev = &e->name;                                            \
    e->name.prev->next = &e->name;                                            \
-    ILISTI_CONTRACT(name, d);                                                 \
-    ILISTI_CONTRACT(name, e);                                                 \
+    M_IL1ST_CONTRACT(name, d);                                                \
+    M_IL1ST_CONTRACT(name, e);                                                \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _reverse)(list_t list)                                            \
+  M_F(name, _reverse)(list_t list)                                            \
  {                                                                           \
-    ILISTI_CONTRACT(name, list);                                              \
-    struct ilist_head_s *next, *it;                                           \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    struct m_il1st_head_s *next, *it;                                         \
    for(it = list->name.next ; it != &list->name; it = next) {                \
      next = it->next;                                                        \
      it->next = it->prev;                                                    \
@@ -652,11 +665,17 @@ typedef struct ilist_head_s {
    next = it->next;                                                          \
    it->next = it->prev;                                                      \
    it->prev = next;                                                          \
-    ILISTI_CONTRACT(name, list);                                              \
+    M_IL1ST_CONTRACT(name, list);                                             \
  }                                                                           \
-                                                                              \
-  /* Used of macro from m-list */                                             \
-  LISTI_ITBASE_DEF(name, type, oplist, list_t, it_t)


+/******************************** INTERNAL ***********************************/
+
+#if M_USE_SMALL_NAME
+#define ILIST_INTERFACE M_ILIST_INTERFACE
+#define ILIST_DEF M_ILIST_DEF
+#define ILIST_DEF_AS M_ILIST_DEF_AS
+#define ILIST_OPLIST M_ILIST_OPLIST
+#endif
+
 #endif
@@ -1,7 +1,7 @@
 /*
 * M*LIB - INTRUSIVE SHARED PTR Module
 *
- * Copyright (c) 2017-2021, Patrick Pelissier
+ * Copyright (c) 2017-2023, Patrick Pelissier
 * All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
@@ -32,9 +32,9 @@ M_BEGIN_PROTECTED_CODE

 /* Define the oplist of a intrusive shared pointer.
   USAGE: ISHARED_OPLIST(name [, oplist_of_the_type]) */
-#define ISHARED_PTR_OPLIST(...)                                               \
-  ISHAREDI_PTR_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                          \
-                         ((__VA_ARGS__, M_DEFAULT_OPLIST),                    \
+#define M_ISHARED_PTR_OPLIST(...)                                             \
+  M_ISHAR3D_PTR_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                         \
+                         ((__VA_ARGS__, M_BASIC_OPLIST),                      \
                          (__VA_ARGS__ )))


@@ -42,105 +42,114 @@ M_BEGIN_PROTECTED_CODE
   name: name of the intrusive shared pointer.
   type: name of the type of the structure (aka. struct test_s) - not used currently.
   NOTE: There can be only one interface of this kind in a type! */
-#define ISHARED_PTR_INTERFACE(name, type)                                     \
-  atomic_int M_C(name, _cpt)
+#define M_ISHARED_PTR_INTERFACE(name, type)                                   \
+  atomic_int M_F(name, _cpt)


 /* Value of the interface field for static intialization (Uses C99 designated element). */
-#define ISHARED_PTR_STATIC_DESIGNATED_INIT(name, type)                        \
-  .M_C(name, _cpt) = ATOMIC_VAR_INIT(0)
+#define M_ISHARED_PTR_STATIC_DESIGNATED_INIT(name, type)                      \
+  .M_F(name, _cpt) = ATOMIC_VAR_INIT(0)

 /* Value of the interface field for static intialization (Uses C89 designated element). */
-#define ISHARED_PTR_STATIC_INIT(name, type)                                   \
+#define M_ISHARED_PTR_STATIC_INIT(name, type)                                 \
  ATOMIC_VAR_INIT(0)


 /* Define the intrusive shared pointer type and its static inline functions.
   USAGE: ISHARED_PTR_DEF(name, type, [, oplist]) */
-#define ISHARED_PTR_DEF(name, ...)                                            \
-  M_BEGIN_PROTECTED_CODE                                                      \
-  ISHAREDI_PTR_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                             \
-                      ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_C(name, _t)  ), \
-                       (name, __VA_ARGS__                                       , M_C(name, _t) ))) \
-  M_END_PROTECTED_CODE
+#define M_ISHARED_PTR_DEF(name, ...)                                          \
+  M_ISHARED_PTR_DEF_AS(name, M_F(name,_t), __VA_ARGS__)


 /* Define the intrusive shared pointer type and its static inline functions
  as the name name_t
   USAGE: ISHARED_PTR_DEF_AS(name, name_t, type, [, oplist]) */
-#define ISHARED_PTR_DEF_AS(name, name_t, ...)                                 \
+#define M_ISHARED_PTR_DEF_AS(name, name_t, ...)                               \
  M_BEGIN_PROTECTED_CODE                                                      \
-  ISHAREDI_PTR_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                             \
+  M_ISHAR3D_PTR_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                            \
                      ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t ), \
                       (name, __VA_ARGS__                                       , name_t ))) \
  M_END_PROTECTED_CODE


-/********************************** INTERNAL ************************************/
+/*****************************************************************************/
+/******************************** INTERNAL ***********************************/
+/*****************************************************************************/

 // Deferred evaluation
-#define ISHAREDI_PTR_OPLIST_P1(arg) ISHAREDI_PTR_OPLIST_P2 arg
+#define M_ISHAR3D_PTR_OPLIST_P1(arg) M_ISHAR3D_PTR_OPLIST_P2 arg

 /* Validation of the given oplist */
-#define ISHAREDI_PTR_OPLIST_P2(name, oplist)                                  \
-  M_IF_OPLIST(oplist)(ISHAREDI_PTR_OPLIST_P3, ISHAREDI_PTR_OPLIST_FAILURE)(name, oplist)
+#define M_ISHAR3D_PTR_OPLIST_P2(name, oplist)                                 \
+  M_IF_OPLIST(oplist)(M_ISHAR3D_PTR_OPLIST_P3, M_ISHAR3D_PTR_OPLIST_FAILURE)(name, oplist)

 /* Prepare a clean compilation failure */
-#define ISHAREDI_PTR_OPLIST_FAILURE(name, oplist)                             \
+#define M_ISHAR3D_PTR_OPLIST_FAILURE(name, oplist)                            \
  ((M_LIB_ERROR(ARGUMENT_OF_ISHARED_PTR_OPLIST_IS_NOT_AN_OPLIST, name, oplist)))

 // Define the oplist
-#define ISHAREDI_PTR_OPLIST_P3(name, oplist) (                                \
+#define M_ISHAR3D_PTR_OPLIST_P3(name, oplist) (                               \
  INIT(M_INIT_DEFAULT),                                                       \
-  INIT_SET(API_4(M_C(name, _init_set))),                                      \
-  SET(M_C(name, _set) M_IPTR),                                                \
-  CLEAR(M_C(name, _clear)),                                                   \
-  CLEAN(M_C(name, _clean) M_IPTR),                                            \
-  TYPE(M_C(name, _ct)),                                                       \
+  INIT_SET(API_4(M_F(name, _init_set))),                                      \
+  SET(M_F(name, _set) M_IPTR),                                                \
+  CLEAR(M_F(name, _clear)),                                                   \
+  RESET(M_F(name, _reset) M_IPTR),                                            \
+  NAME(name),                                                                 \
+  TYPE(M_F(name, _ct)),                                                       \
  OPLIST(oplist),                                                             \
-  SUBTYPE(M_C(name, _subtype_ct))                                             \
+  SUBTYPE(M_F(name, _subtype_ct))                                             \
  ,M_IF_METHOD(NEW, oplist)(NEW(M_GET_NEW oplist),)                           \
  ,M_IF_METHOD(REALLOC, oplist)(REALLOC(M_GET_REALLOC oplist),)               \
  ,M_IF_METHOD(DEL, oplist)(DEL(M_GET_DEL oplist),)                           \
  )

+
+/******************************** INTERNAL ***********************************/
+
 // Deferred evaluatioin
-#define ISHAREDI_PTR_DEF_P1(arg) ISHAREDI_PTR_DEF_P2 arg
+#define M_ISHAR3D_PTR_DEF_P1(arg) M_ID( M_ISHAR3D_PTR_DEF_P2 arg )

 /* Validate the oplist before going further */
-#define ISHAREDI_PTR_DEF_P2(name, type, oplist, shared_t)                     \
-  M_IF_OPLIST(oplist)(ISHAREDI_PTR_DEF_P3, ISHAREDI_PTR_DEF_FAILURE)(name, type, oplist, shared_t)
+#define M_ISHAR3D_PTR_DEF_P2(name, type, oplist, shared_t)                    \
+  M_IF_OPLIST(oplist)(M_ISHAR3D_PTR_DEF_P3, M_ISHAR3D_PTR_DEF_FAILURE)(name, type, oplist, shared_t)

 /* Stop processing with a compilation failure */
-#define ISHAREDI_PTR_DEF_FAILURE(name, type, oplist, shared_t)                \
+#define M_ISHAR3D_PTR_DEF_FAILURE(name, type, oplist, shared_t)               \
  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(ISHARED_PTR_DEF): the given argument is not a valid oplist: " #oplist)

-#define ISHAREDI_PTR_DEF_P3(name, type, oplist, shared_t)                     \
+#define M_ISHAR3D_PTR_DEF_P3(name, type, oplist, shared_t)                    \
+  M_ISHAR3D_PTR_DEF_TYPE(name, type, oplist, shared_t)                        \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_ISHAR3D_PTR_DEF_CORE(name, type, oplist, shared_t)                        \
+ 
+/* Define the types */
+#define M_ISHAR3D_PTR_DEF_TYPE(name, type, oplist, shared_t)                  \
                                                                              \
  /* The shared pointer is only a pointer to the type */                      \
  typedef type *shared_t;                                                     \
                                                                              \
  /* Define internal types for oplist */                                      \
-  typedef shared_t M_C(name, _ct);                                            \
-  typedef type     M_C(name, _subtype_ct);                                    \
-                                                                              \
-  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  typedef shared_t M_F(name, _ct);                                            \
+  typedef type     M_F(name, _subtype_ct);                                    \
+
+/* Define the core functions */
+#define M_ISHAR3D_PTR_DEF_CORE(name, type, oplist, shared_t)                  \
                                                                              \
  static inline shared_t                                                      \
-  M_C(name, _init)(type *ptr)                                                 \
+  M_F(name, _init)(type *ptr)                                                 \
  {                                                                           \
    /* Initialize the type referenced by the pointer */                       \
    if (M_LIKELY (ptr != NULL)) {                                             \
-      atomic_init(&ptr->M_C(name, _cpt), 2);                                  \
+      atomic_init(&ptr->M_F(name, _cpt), 2);                                  \
    }                                                                         \
    return ptr;                                                               \
  }                                                                           \
                                                                              \
  static inline shared_t                                                      \
-  M_C(name, _init_set)(shared_t shared)                                       \
+  M_F(name, _init_set)(shared_t shared)                                       \
  {                                                                           \
    if (M_LIKELY (shared != NULL)) {                                          \
-      int n = atomic_fetch_add(&(shared->M_C(name, _cpt)), 2);                \
+      int n = atomic_fetch_add(&(shared->M_F(name, _cpt)), 2);                \
      (void) n;                                                               \
    }                                                                         \
    return shared;                                                            \
@@ -151,56 +160,56 @@ M_BEGIN_PROTECTED_CODE
  (                                                                           \
  /* This function is only for static object */                               \
  static inline shared_t                                                      \
-  M_C(name, _init_once)(type *shared)                                         \
+  M_F(name, _init_once)(type *shared)                                         \
  {                                                                           \
    if (M_LIKELY (shared != NULL)) {                                          \
      /* Pretty much like atomic_add, except the first one increment by 1, others by 2 */ \
-      int o = atomic_load(&(shared->M_C(name, _cpt)));                        \
+      int o = atomic_load(&(shared->M_F(name, _cpt)));                        \
      int n;                                                                  \
      do {                                                                    \
        n = o + 1 + (o != 0);                                                 \
-      } while (!atomic_compare_exchange_strong(&(shared->M_C(name, _cpt)), &o, n)); \
+      } while (!atomic_compare_exchange_strong(&(shared->M_F(name, _cpt)), &o, n)); \
      if (o == 0) {                                                           \
      /* Partial initialization: _cpt is odd */                               \
        /* Call the INIT function once */                                     \
        M_CALL_INIT(oplist, *shared);                                         \
        /* Finish initialization: _cpt is even */                             \
-        atomic_fetch_add(&(shared->M_C(name, _cpt)), 1);                      \
+        atomic_fetch_add(&(shared->M_F(name, _cpt)), 1);                      \
      } else if ( (o&1) != 0) {                                               \
        /* Not fully initialized yet: wait for initialization */              \
        m_core_backoff_ct bkoff;                                              \
        m_core_backoff_init(bkoff);                                           \
        /* Wait for _cpt to be _even */                                       \
-        while ((atomic_load(&(shared->M_C(name, _cpt)))&1) != 0 ) {           \
+        while ((atomic_load(&(shared->M_F(name, _cpt)))&1) != 0 ) {           \
            m_core_backoff_wait(bkoff);                                       \
        }                                                                     \
      }                                                                       \
-      M_ASSERT( (atomic_load(&(shared->M_C(name, _cpt)))&1) == 0);            \
+      M_ASSERT( (atomic_load(&(shared->M_F(name, _cpt)))&1) == 0);            \
    }                                                                         \
    return shared;                                                            \
  }                                                                           \
  ,                                                                           \
  /* This function is only for dynamic object */                              \
  static inline shared_t                                                      \
-  M_C(name, _init_new)(void)                                                  \
+  M_F(name, _init_new)(void)                                                  \
  {                                                                           \
    type *ptr = M_CALL_NEW(oplist, type);                                     \
-    if (ptr == NULL) {                                                        \
+    if (M_UNLIKELY_NOMEM (ptr == NULL)) {                                     \
      M_MEMORY_FULL(sizeof(type));                                            \
      return NULL;                                                            \
    }                                                                         \
    M_CALL_INIT(oplist, *ptr);                                                \
-    atomic_init (&ptr->M_C(name, _cpt), 2);                                   \
+    atomic_init (&ptr->M_F(name, _cpt), 2);                                   \
    return ptr;                                                               \
  }                                                                           \
    /* End of NEW */)                                                         \
  , /* End of INIT */)                                                        \
                                                                              \
  static inline void                                                          \
-  M_C(name, _clear)(shared_t shared)                                          \
+  M_F(name, _clear)(shared_t shared)                                          \
  {                                                                           \
    if (shared != NULL) {                                                     \
-      if (atomic_fetch_sub(&(shared->M_C(name, _cpt)), 2) == 2) {             \
+      if (atomic_fetch_sub(&(shared->M_F(name, _cpt)), 2) == 2) {             \
        M_CALL_CLEAR(oplist, *shared);                                        \
        M_IF_DISABLED_METHOD(DEL, oplist)(, M_CALL_DEL(oplist, shared);)      \
      }                                                                       \
@@ -208,31 +217,42 @@ M_BEGIN_PROTECTED_CODE
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _clear_ptr)(shared_t *shared)                                     \
+  M_F(name, _clear_ptr)(shared_t *shared)                                     \
  {                                                                           \
    M_ASSERT(shared != NULL);                                                 \
-    M_C(name, _clear)(*shared);                                               \
+    M_F(name, _clear)(*shared);                                               \
    *shared = NULL;                                                           \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _clean)(shared_t *shared)                                         \
+  M_F(name, _reset)(shared_t *shared)                                         \
  {                                                                           \
-    M_C(name, _clear)(*shared);                                               \
+    M_F(name, _clear)(*shared);                                               \
    *shared = NULL;                                                           \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _set)(shared_t *ptr, shared_t shared)                             \
+  M_F(name, _set)(shared_t *ptr, shared_t shared)                             \
  {                                                                           \
    M_ASSERT (ptr != NULL);                                                   \
    if (M_LIKELY (*ptr != shared)) {                                          \
-      M_C(name, _clear)(*ptr);                                                \
-      *ptr = M_C(name, _init_set)(shared);                                    \
+      M_F(name, _clear)(*ptr);                                                \
+      *ptr = M_F(name, _init_set)(shared);                                    \
    }                                                                         \
  }                                                                           \
                                                                              \

 M_END_PROTECTED_CODE

+/******************************** INTERNAL ***********************************/
+
+#if M_USE_SMALL_NAME
+#define ISHARED_PTR_OPLIST M_ISHARED_PTR_OPLIST
+#define ISHARED_PTR_INTERFACE M_ISHARED_PTR_INTERFACE
+#define ISHARED_PTR_STATIC_DESIGNATED_INIT M_ISHARED_PTR_STATIC_DESIGNATED_INIT
+#define ISHARED_PTR_STATIC_INIT M_ISHARED_PTR_STATIC_INIT
+#define ISHARED_PTR_DEF M_ISHARED_PTR_DEF
+#define ISHARED_PTR_DEF_AS M_ISHARED_PTR_DEF_AS
+#endif
+
 #endif
@@ -1,7 +1,7 @@
 /*
 * M*LIB - MEMPOOL module
 *
- * Copyright (c) 2017-2021, Patrick Pelissier
+ * Copyright (c) 2017-2023, Patrick Pelissier
 * All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
@@ -27,92 +27,109 @@

 #include "m-core.h"

-/* Fast Fixed Size thread unsafe allocator based on memory region.
+/* Fast, fixed size, thread unsafe allocator based on memory regions.
+   No oplist is needed.
   USAGE:
-     MEMPOOL_DEF(memppol_uint, unsigned int)
+     MEMPOOL_DEF(name, type)
+   Example:
+     MEMPOOL_DEF(mempool_uint, unsigned int)
     ...
-     memppol_uint_t m;
+     mempool_uint_t m;
     mempool_uint_init(m);
     unsigned int *ptr = mempool_uint_alloc(m);
     *ptr = 17;
     mempool_uint_free(m, ptr);
     mempool_uint_clear(m); // Give back memory to system
-   NOTE: Can not use m-list since it may be expanded from LIST_DEF
 */
-#define MEMPOOL_DEF(name, type)                                               \
-  M_BEGIN_PROTECTED_CODE                                                      \
-  MEMPOOL_DEF_P2(name, type, M_C(name, _t) )                                  \
-  M_END_PROTECTED_CODE
+#define M_MEMPOOL_DEF(name, type)                                             \
+  M_MEMPOOL_DEF_AS(name, M_F(name,_t), type)


-/* Fast Fixed Size thread unsafe allocator based on memory region.
+/* Fast, fixed Size, thread unsafe allocator based on memory region.
   USAGE:
-     MEMPOOL_DEF_AS(memppol_uint, name_t, unsigned int)
+     MEMPOOL_DEF_AS(name, name_t, type)
 */
-#define MEMPOOL_DEF_AS(name, name_t, type)                                    \
+#define M_MEMPOOL_DEF_AS(name, name_t, type)                                  \
  M_BEGIN_PROTECTED_CODE                                                      \
-  MEMPOOL_DEF_P2(name, type, name_t )                                         \
+  M_M3MPOOL_DEF_P2(name, type, name_t )                                       \
  M_END_PROTECTED_CODE


-/* User shall be able to cutomize the size of the segment and/or
+/* User shall be able to cutomize the size of the region segment and/or
   the minimun number of elements.
-   The default is the number of elements that fits in 16KB.
+   The default is the number of elements that fits in 16KB, or 256
+   is the size of the type is too big.
 */
-#ifndef MEMPOOL_MAX_PER_SEGMENT
-#define MEMPOOL_MAX_PER_SEGMENT(type)                                         \
+#ifndef M_USE_MEMPOOL_MAX_PER_SEGMENT
+#define M_USE_MEMPOOL_MAX_PER_SEGMENT(type)                                   \
  M_MAX((16*1024-sizeof(unsigned int) - 2*sizeof(void*)) / sizeof (type), 256U)
 #endif


-/********************************** INTERNAL ************************************/
+/*****************************************************************************/
+/********************************** INTERNAL *********************************/
+/*****************************************************************************/

-#define MEMPOOL_DEF_P2(name, type, name_t)                                    \
+/*
+  Technically, it uses a list of memory regions, where multiple
+  allocations are performed in each region. However, it
+  can not use m-list since it may be expanded from LIST_DEF
+  (recursive dependency problem). */
+#define M_M3MPOOL_DEF_P2(name, type, name_t)                                  \
+  M_M3MPOOL_DEF_TYPE(name, type, name_t)                                      \
+  M_M3MPOOL_DEF_CORE(name, type, name_t)
+
+/* Define the types of the mempool */
+#define M_M3MPOOL_DEF_TYPE(name, type, name_t)                                \
                                                                              \
  /* Define the type of element in a segment of the mempool.                  \
    Either it is the basic type or a pointer to another one.  */              \
-  typedef union M_C(name,_union_s) {                                          \
+  typedef union M_F(name,_union_s) {                                          \
    type t;                                                                   \
-    union M_C(name,_union_s) *next;                                           \
-  } M_C(name,_union_ct);                                                      \
+    union M_F(name,_union_s) *next;                                           \
+  } M_F(name,_union_ct);                                                      \
                                                                              \
  /* Define a segment of a mempool.                                           \
    It is an array of basic type, each segment is in a linked list */         \
-  typedef struct M_C(name,_segment_s) {                                       \
+  typedef struct M_F(name,_segment_s) {                                       \
    unsigned int count;                                                       \
-    struct M_C(name,_segment_s) *next;                                        \
-    M_C(name,_union_ct)        tab[MEMPOOL_MAX_PER_SEGMENT(type)];            \
-  } M_C(name,_segment_ct);                                                    \
+    struct M_F(name,_segment_s) *next;                                        \
+    M_F(name,_union_ct)        tab[M_USE_MEMPOOL_MAX_PER_SEGMENT(type)];      \
+  } M_F(name,_segment_ct);                                                    \
                                                                              \
  /* Define a mempool.                                                        \
    It is a pointer to the first free object within the segments              \
    and the segments themselves           */                                  \
-  typedef struct M_C(name, _s) {                                              \
-    M_C(name,_union_ct)   *free_list;                                         \
-    M_C(name,_segment_ct) *current_segment;                                   \
+  typedef struct M_F(name, _s) {                                              \
+    M_F(name,_union_ct)   *free_list;                                         \
+    M_F(name,_segment_ct) *current_segment;                                   \
  } name_t[1];                                                                \
+
+
+/* Define the core functions of the mempool */
+#define M_M3MPOOL_DEF_CORE(name, type, name_t)                                \
                                                                              \
  static inline void                                                          \
-  M_C(name,_init)(name_t mem)                                                 \
+  M_F(name,_init)(name_t mem)                                                 \
  {                                                                           \
    mem->free_list = NULL;                                                    \
-    mem->current_segment = M_MEMORY_ALLOC(M_C(name,_segment_ct));             \
-    if (mem->current_segment == NULL) {                                       \
-      M_MEMORY_FULL(sizeof (M_C(name,_segment_ct)));                          \
+    mem->current_segment = M_MEMORY_ALLOC(M_F(name,_segment_ct));             \
+    if (M_UNLIKELY_NOMEM(mem->current_segment == NULL)) {                     \
+      M_MEMORY_FULL(sizeof (M_F(name,_segment_ct)));                          \
      return;                                                                 \
    }                                                                         \
    mem->current_segment->next = NULL;                                        \
    mem->current_segment->count = 0;                                          \
-    MEMPOOLI_CONTRACT(mem, type);                                             \
+    M_M3MPOOL_CONTRACT(mem, type);                                            \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name,_clear)(name_t mem)                                                \
+  M_F(name,_clear)(name_t mem)                                                \
  {                                                                           \
-    MEMPOOLI_CONTRACT(mem, type);                                             \
-    M_C(name,_segment_ct) *segment = mem->current_segment;                    \
+    M_M3MPOOL_CONTRACT(mem, type);                                            \
+    M_F(name,_segment_ct) *segment = mem->current_segment;                    \
    while (segment != NULL) {                                                 \
-      M_C(name,_segment_ct) *next = segment->next;                            \
+      M_F(name,_segment_ct) *next = segment->next;                            \
      M_MEMORY_DEL (segment);                                                 \
      segment = next;                                                         \
    }                                                                         \
@@ -122,25 +139,25 @@
  }                                                                           \
                                                                              \
  static inline type *                                                        \
-  M_C(name,_alloc)(name_t mem)                                                \
+  M_F(name,_alloc)(name_t mem)                                                \
  {                                                                           \
-    MEMPOOLI_CONTRACT(mem, type);                                             \
+    M_M3MPOOL_CONTRACT(mem, type);                                            \
    /* Test if one object is in the free list */                              \
-    M_C(name,_union_ct) *ret = mem->free_list;                                \
+    M_F(name,_union_ct) *ret = mem->free_list;                                \
    if (ret != NULL) {                                                        \
      /* Yes, so return it, and pop it from the free list */                  \
      mem->free_list = ret->next;                                             \
      return &ret->t;                                                         \
    }                                                                         \
    /* No cheap free object exist. Test within a segment */                   \
-    M_C(name,_segment_ct) *segment = mem->current_segment;                    \
+    M_F(name,_segment_ct) *segment = mem->current_segment;                    \
    M_ASSERT(segment != NULL);                                                \
    unsigned int count = segment->count;                                      \
    /* If segment is full, allocate a new one from the system */              \
-    if (M_UNLIKELY (count >= MEMPOOL_MAX_PER_SEGMENT(type))) {                \
-      M_C(name,_segment_ct) *new_segment = M_MEMORY_ALLOC (M_C(name,_segment_ct)); \
-      if (M_UNLIKELY (new_segment == NULL)) {                                 \
-        M_MEMORY_FULL(sizeof (M_C(name,_segment_ct)));                        \
+    if (M_UNLIKELY (count >= M_USE_MEMPOOL_MAX_PER_SEGMENT(type))) {          \
+      M_F(name,_segment_ct) *new_segment = M_MEMORY_ALLOC (M_F(name,_segment_ct)); \
+      if (M_UNLIKELY_NOMEM (new_segment == NULL)) {                           \
+        M_MEMORY_FULL(sizeof (M_F(name,_segment_ct)));                        \
        return NULL;                                                          \
      }                                                                       \
      new_segment->next = segment;                                            \
@@ -152,30 +169,38 @@
    /* Return the object as the last element of the current segment */        \
    ret = &segment->tab[count];                                               \
    segment->count = count + 1;                                               \
-    MEMPOOLI_CONTRACT(mem, type);                                             \
+    M_M3MPOOL_CONTRACT(mem, type);                                            \
    return &ret->t;                                                           \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name,_free)(name_t mem, type *ptr)                                      \
+  M_F(name,_free)(name_t mem, type *ptr)                                      \
  {                                                                           \
-    MEMPOOLI_CONTRACT(mem, type);                                             \
+    M_M3MPOOL_CONTRACT(mem, type);                                            \
    /* NOTE: Unsafe cast: suppose that the given pointer                      \
       was allocated by the previous alloc function. */                       \
-    M_C(name,_union_ct) *ret = (M_C(name,_union_ct) *)(uintptr_t)ptr;         \
+    M_F(name,_union_ct) *ret = (M_F(name,_union_ct) *)(uintptr_t)ptr;         \
    /* Add the object back in the free list */                                \
    ret->next = mem->free_list;                                               \
    mem->free_list = ret;                                                     \
    /* NOTE: the objects are NOT given back to the system until the mempool   \
    is fully cleared */                                                       \
-    MEMPOOLI_CONTRACT(mem, type);                                             \
+    M_M3MPOOL_CONTRACT(mem, type);                                            \
  }                                                                           \

-/* MEMPOOL contract */
-#define MEMPOOLI_CONTRACT(mempool, type) do {                                 \
+/* MEMPOOL contract. We only control the current segment. */
+#define M_M3MPOOL_CONTRACT(mempool, type) do {                                \
    M_ASSERT((mempool) != NULL);                                              \
    M_ASSERT((mempool)->current_segment != NULL);                             \
-    M_ASSERT((mempool)->current_segment->count <= MEMPOOL_MAX_PER_SEGMENT(type)); \
+    M_ASSERT((mempool)->current_segment->count <= M_USE_MEMPOOL_MAX_PER_SEGMENT(type)); \
  } while (0)

+
+/********************************** INTERNAL *********************************/
+
+#if M_USE_SMALL_NAME
+#define MEMPOOL_DEF M_MEMPOOL_DEF
+#define MEMPOOL_DEF_AS M_MEMPOOL_DEF_AS
+#endif
+
 #endif
@@ -1,7 +1,7 @@
 /*
- * M*LIB - Thin Mutex & Thread wrapper
+ * M*LIB - Thin Mutex & Thread wrapper (compatibility layer)
 *
- * Copyright (c) 2017-2021, Patrick Pelissier
+ * Copyright (c) 2017-2023, Patrick Pelissier
 * All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
@@ -22,506 +22,7 @@
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-#ifndef MSTARLIB_MUTEX_H
-#define MSTARLIB_MUTEX_H
-
-/* Auto-detect the thread backend to use if the user has not override it */
-#ifndef M_USE_THREAD_BACKEND
-# if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L                 \
-  && !defined(__STDC_NO_THREADS__)
-#  define M_USE_THREAD_BACKEND 1
-# elif defined(WIN32) || defined(_WIN32) || defined(__CYGWIN__)
-#  define M_USE_THREAD_BACKEND 2
-# else
-#  define M_USE_THREAD_BACKEND 3
-# endif
-#endif
-
-
-/****************************** C11 version ********************************/
-#if M_USE_THREAD_BACKEND == 1
-
-#include <threads.h>
-#include <assert.h>
-#include <stdbool.h>
-#include "m-core.h"
-
-M_BEGIN_PROTECTED_CODE
-
-/* Define a mutex type based on C11 definition */
-typedef mtx_t                  m_mutex_t[1];
-
-/* Define a condition variable type based on C11 definition */
-typedef cnd_t                  m_cond_t[1];
-
-/* Define a thread type based on C11 definition */
-typedef thrd_t                 m_thread_t[1];
-
-/* Initialize the mutex (constructor) */
-static inline void m_mutex_init(m_mutex_t m)
-{
-  int rc = mtx_init(m, mtx_plain);
-  // Abort program in case of initialization failure
-  // There is really nothing else to do if a mutex cannot be constructed
-  M_ASSERT_INIT (rc == 0, "mutex");
-}
-
-/* Clear the mutex (destructor) */
-static inline void m_mutex_clear(m_mutex_t m)
-{
-  mtx_destroy(m);
-}
-
-/* Lock the mutex */
-static inline void m_mutex_lock(m_mutex_t m)
-{
-  mtx_lock(m);
-}
-
-/* Unlock the mutex */
-static inline void m_mutex_unlock(m_mutex_t m)
-{
-  mtx_unlock(m);
-}
-
-/* Initialize the condition variable (constructor) */
-static inline void m_cond_init(m_cond_t c)
-{
-  int rc = cnd_init(c);
-  // Abort program in case of initialization failure
-  // There is really nothing else to do if the object cannot be constructed
-  M_ASSERT_INIT (rc == 0, "conditional variable");
-}
-
-/* Clear the condition variable (destructor) */
-static inline void m_cond_clear(m_cond_t c)
-{
-  cnd_destroy(c);
-}
-
-/* Signal the condition variable to at least one waiting thread */
-static inline void m_cond_signal(m_cond_t c)
-{
-  cnd_signal(c);
-}
-
-/* Signal the condition variable to all waiting threads */
-static inline void m_cond_broadcast(m_cond_t c)
-{
-  cnd_broadcast(c);
-}
-
-/* Wait for signaling the condition variable by another thread */
-static inline void m_cond_wait(m_cond_t c, m_mutex_t m)
-{
-  cnd_wait(c, m);
-}
-
-/* Create the thread (constructor) and start it */
-static inline void m_thread_create(m_thread_t t, void (*func)(void*), void* arg)
-{
-  int rc = thrd_create(t, (int(*)(void*))(void(*)(void))func, arg);
-  // Abort program in case of initialization failure
-  M_ASSERT_INIT (rc == thrd_success, "thread");
-}
-
-/* Wait for the thread to terminate and destroy it (destructor) */
-static inline void m_thread_join(m_thread_t t)
-{
-  int rc = thrd_join(*t, NULL);
-  M_ASSERT (rc == thrd_success);
-  // Avoid warning about variable unused.
-  (void) rc;
-}
-
-/* The thread has nothing meaningfull to do.
-   Inform the OS to let other threads be scheduled */
-static inline void m_thread_yield(void)
-{
-  thrd_yield();
-}
-
-/* Sleep the thread for at least usec microseconds.
-   Return true if the sleep was successful */
-static inline bool m_thread_sleep(unsigned long long usec)
-{
-  struct timespec tv;
-  tv.tv_sec = (long) (usec / 1000000ULL);
-  tv.tv_nsec = (long) ((usec % 1000000ULL) * 1000UL);
-  int retval = thrd_sleep(&tv, NULL);
-  return retval == 0;
-}
-
-// Internal type, not exported.
-typedef once_flag                     m_once_ct[1];
-
-// Initial value for m_once_ct
-#define M_ONCEI_INIT_VALUE            { ONCE_FLAG_INIT }
-
-// Call the function exactly once
-static inline void m_oncei_call(m_once_ct o, void (*func)(void))
-{
-  call_once(o,func);
-}
-
-// Attribute to use to allocate a global variable to a thread.
-#define M_THREAD_ATTR _Thread_local
-
-M_END_PROTECTED_CODE
-
-
-/****************************** WIN32 version ******************************/
-#elif M_USE_THREAD_BACKEND == 2
-
-/* CLANG provides some useless and wrong warnings:
- * - _WIN32_WINNT starts with '_' which is reserved by the standard
- * as per the MSVC compiler, it is needed to be defined by the user
- * to define which version of windows it want to be compatible with.
- * - windows.h may be different than the case used by the file sytem
- * there is however no normalized case.
- *
- * So, theses warnings have to be ignored and are disabled.
- *
- * We cannot add theses warnings in M_BEGIN_PROTECTED_CODE
- * as they need to be disabled **BEFORE** including any system header
- * and m-core includes some system headers.
- * So we need to disable them explictly here.
- */
-#if defined(__clang__) && __clang_major__ >= 4
-  _Pragma("clang diagnostic push")
-  _Pragma("clang diagnostic ignored \"-Wreserved-id-macro\"")
-  _Pragma("clang diagnostic ignored \"-Wnonportable-system-include-path\"")
-#endif
-
-/* CriticalSection & ConditionVariable are available from Windows Vista */
-#ifndef WINVER
-#define WINVER        _WIN32_WINNT_VISTA
-#endif
-#ifndef _WIN32_WINNT
-#define _WIN32_WINNT  _WIN32_WINNT_VISTA
-#endif
-
-/* Include system headers */
-#include <windows.h>
-#include <assert.h>
-#include <stdbool.h>
-#include "m-core.h"
-
-#if defined(__clang__) && __clang_major__ >= 4
-  _Pragma("clang diagnostic pop")
-#endif
-
-M_BEGIN_PROTECTED_CODE
-
-/* Define a thread type based on WINDOWS definition */
-typedef HANDLE                 m_thread_t[1];
-
-/* Define a mutex type based on WINDOWS definition */
-typedef CRITICAL_SECTION       m_mutex_t[1];
-
-/* Define a condition variable type based on WINDOWS definition */
-typedef CONDITION_VARIABLE     m_cond_t[1];
-
-/* Initialize a mutex (Constructor)*/
-static inline void m_mutex_init(m_mutex_t m)
-{
-  InitializeCriticalSection(m);
-}
-
-/* Clear a mutex (destructor) */
-static inline void m_mutex_clear(m_mutex_t m)
-{
-  DeleteCriticalSection(m);
-}
-
-/* Lock a mutex */
-static inline void m_mutex_lock(m_mutex_t m)
-{
-  EnterCriticalSection(m);
-}
-
-/* Unlock a mutex */
-static inline void m_mutex_unlock(m_mutex_t m)
-{
-  LeaveCriticalSection(m);
-}
-
-/* Initialize a condition variable (constructor) */
-static inline void m_cond_init(m_cond_t c)
-{
-  InitializeConditionVariable(c);
-}
-
-/* Clear a condition variable (destructor) */
-static inline void m_cond_clear(m_cond_t c)
-{
-  (void) c; // There is no destructor for this object.
-}
-
-/* Signal a condition variable to at least one waiting thread */
-static inline void m_cond_signal(m_cond_t c)
-{
-  WakeConditionVariable(c);
-}
-
-/* Signal a condition variable to all waiting threads */
-static inline void m_cond_broadcast(m_cond_t c)
-{
-  WakeAllConditionVariable(c);
-}
-
-/* Wait for a condition variable */
-static inline void m_cond_wait(m_cond_t c, m_mutex_t m)
-{
-  SleepConditionVariableCS(c, m, INFINITE);
-}
-
-/* Create a thread (constructor) and start it */
-static inline void m_thread_create(m_thread_t t, void (*func)(void*), void *arg)
-{
-  *t = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) (uintptr_t) func, arg, 0, NULL);
-  M_ASSERT_INIT (*t != NULL, "thread");
-}
-
-/* Wait for the thread to terminate and destroy it (destructor) */
-static inline void m_thread_join(m_thread_t t)
-{
-  DWORD dwWaitResult = WaitForSingleObject(*t, INFINITE);
-  (void) dwWaitResult;
-  M_ASSERT (dwWaitResult == WAIT_OBJECT_0);
-  CloseHandle(*t);
-}
-
-/* The thread has nothing meaningfull to do.
-   Inform the OS to let other threads be scheduled */
-static inline void m_thread_yield(void)
-{
-  Sleep(0);
-}
-
-/* Sleep the thread for at least usec microseconds
-   Return true if the sleep was successful */
-static inline bool m_thread_sleep(unsigned long long usec)
-{
-  LARGE_INTEGER ft;
-  M_ASSERT (usec <= LLONG_MAX);
-  ft.QuadPart = -(10LL*(long long) usec);
-  HANDLE hd = CreateWaitableTimer(NULL, TRUE, NULL);
-  M_ASSERT_INIT (hd != NULL, "timer");
-  SetWaitableTimer(hd, &ft, 0, NULL, NULL, 0);
-  DWORD dwWaitResult = WaitForSingleObject(hd, INFINITE);
-  CloseHandle(hd);
-  return dwWaitResult == WAIT_OBJECT_0;
-}
-
-
-// Internal type, not exported.
-typedef INIT_ONCE                     m_once_ct[1];
-#define M_ONCEI_INIT_VALUE            { INIT_ONCE_STATIC_INIT }
-static inline BOOL CALLBACK m_oncei_callback( PINIT_ONCE InitOnce, PVOID Parameter, PVOID *lpContext)
-{
-    void (*func)(void);
-    (void) InitOnce;
-    (void) lpContext;
-    func = (void (*)(void))(uintptr_t) Parameter;
-    (*func)();
-    return TRUE;
-}
-static inline void m_oncei_call(m_once_ct o, void (*func)(void))
-{
-  InitOnceExecuteOnce(o, m_oncei_callback, (void*)(intptr_t)func, NULL);
-}
-
-#if defined(_MSC_VER)
-// Attribute to use to allocate a global variable to a thread (MSVC def).
-# define M_THREAD_ATTR __declspec( thread )
-#else
-// Attribute to use to allocate a global variable to a thread (GCC def).
-# define M_THREAD_ATTR __thread
-#endif
-
-M_END_PROTECTED_CODE
-
-
-/**************************** PTHREAD version ******************************/
-#else
-
-#include <pthread.h>
-#ifdef _POSIX_PRIORITY_SCHEDULING
-#include <sched.h>
-#endif
-#include <sys/time.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <assert.h>
-#include <stdbool.h>
-#include "m-core.h"
-
-M_BEGIN_PROTECTED_CODE
-
-/* Define a mutex type based on PTHREAD definition */
-typedef pthread_mutex_t        m_mutex_t[1];
-
-/* Define a condition variable type based on PTHREAD definition */
-typedef pthread_cond_t         m_cond_t[1];
-
-/* Define a thread type based on PTHREAD definition */
-typedef pthread_t              m_thread_t[1];
-
-/* Initialize the mutex (constructor) */
-static inline void m_mutex_init(m_mutex_t m)
-{
-  int _rc = pthread_mutex_init(m, NULL);
-  // Abort program in case of initialization failure
-  // There is really nothing else to do if a mutex cannot be constructed
-  M_ASSERT_INIT (_rc == 0, "mutex");
-}
-
-/* Clear the mutex (destructor) */
-static inline void m_mutex_clear(m_mutex_t m)
-{
-  pthread_mutex_destroy(m);
-}
-
-/* Lock the mutex */
-static inline void m_mutex_lock(m_mutex_t m)
-{
-  pthread_mutex_lock(m);
-}
-
-/* Unlock the mutex */
-static inline void m_mutex_unlock(m_mutex_t m)
-{
-  pthread_mutex_unlock(m);
-}
-
-/* Lazy lock initialization */
-#define M_MUTEXI_INIT_VALUE    { PTHREAD_MUTEX_INITIALIZER }
-
-/* Internal function compatible with lazy lock */
-static inline void m_mutexi_lazy_lock(m_mutex_t m)
-{
-  pthread_mutex_lock(m);
-}
-
-/* Initialize the condition variable (constructor) */
-static inline void m_cond_init(m_cond_t c)
-{
-  int _rc = pthread_cond_init(c, NULL);
-  // Abort program in case of initialization failure
-  // There is really nothing else to do if a mutex cannot be constructed
-  M_ASSERT_INIT (_rc == 0, "conditional variable");
-}
-
-/* Clear the condition variable (destructor) */
-static inline void m_cond_clear(m_cond_t c)
-{
-  pthread_cond_destroy(c);
-}
-
-/* Signal a condition variable to at least a waiting thread */
-static inline void m_cond_signal(m_cond_t c)
-{
-  pthread_cond_signal(c);
-}
-
-/* Signal a condition variable to all waiting threads */
-static inline void m_cond_broadcast(m_cond_t c)
-{
-  pthread_cond_broadcast(c);
-}
-
-/* Waiting for a condition variable */
-static inline void m_cond_wait(m_cond_t c, m_mutex_t m)
-{
-  pthread_cond_wait(c, m);
-}
-
-/* Create a thread (constructor) and start it */
-static inline void m_thread_create(m_thread_t t, void (*func)(void*), void *arg)
-{
-  int _rc = pthread_create(t, NULL, (void*(*)(void*))(void(*)(void))func, arg);
-  M_ASSERT_INIT (_rc == 0, "thread");
-}
-
-/* Wait for the thread to terminate and destroy it (destructor) */
-static inline void m_thread_join(m_thread_t t)
-{
-  int _rc = pthread_join(*t, NULL);
-  (void)_rc; // Avoid warning about variable unused.
-  M_ASSERT (_rc == 0);
-}
-
-/* The thread has nothing meaningfull to do.
-   Inform the OS to let other threads be scheduled */
-static inline void m_thread_yield(void)
-{
-#ifdef _POSIX_PRIORITY_SCHEDULING
-  sched_yield();
-#endif
-}
-
-/* Sleep for at least usec microseconds
-   Return true if the sleep was successful */
-static inline bool m_thread_sleep(unsigned long long usec)
-{
-  struct timeval tv;
-  /* We don't want to use usleep or nanosleep so that
-     we remain compatible with strict C99 build */
-  tv.tv_sec = (time_t) (usec / 1000000ULL);
-  tv.tv_usec = (suseconds_t) (usec % 1000000ULL);
-  int retval = select(1, NULL, NULL, NULL, &tv);
-  return retval == 0;
-}
-
-// Internal type, not exported.
-typedef pthread_once_t                m_once_ct[1];
-#define M_ONCEI_INIT_VALUE            { PTHREAD_ONCE_INIT }
-static inline void m_oncei_call(m_once_ct o, void (*func)(void))
-{
-  pthread_once(o,func);
-}
-
-#define M_THREAD_ATTR __thread
-
-M_END_PROTECTED_CODE
-
-#endif
-
-// TODO: Obsolete M_LOCK macro.
-
-/* M_LOCK macro. Allow simple locking encapsulation.
-   USAGE:
-    static M_LOCK_DECL(name);
-    int f(int n) {
-      M_LOCK(name) {
-        // Exclusive access
-      }
-    }
-*/
-/* NOTE: Either using direct support by the OS (WIN32/PTHREAD)
-   or using C11's ONCE mechanism */
-#ifdef M_MUTEXI_INIT_VALUE
-# define M_LOCK_DECL(name) m_mutex_t name = M_MUTEXI_INIT_VALUE
-# define M_LOCK(name)                                                         \
-  M_LOCKI_DO(name, M_C(local_cont_, __LINE__), m_mutexi_lazy_lock, m_mutex_unlock)
-#else
-# define M_LOCK_DECL(name)                                                    \
-  m_mutex_t name;                                                             \
-  static void M_C(m_mutex_init_, name)(void) {                                \
-    m_mutex_init(name);                                                       \
-  }                                                                           \
-  m_once_ct M_C(m_once_, name) = M_ONCEI_INIT_VALUE
-# define M_LOCKI_BY_ONCE(name)                                                \
-  (m_oncei_call(M_C(m_once_, name), M_C(m_mutex_init_, name)),                \
-   m_mutex_lock(name), (void) 0 )
-# define M_LOCK(name)                                                         \
-  M_LOCKI_DO(name, M_C(local_cont_, __LINE__), M_LOCKI_BY_ONCE, m_mutex_unlock)
-#endif
-
-#define M_LOCKI_DO(name, cont, lock_func, unlock_func)                        \
-  for(bool cont = true                                                        \
-        ; cont && (lock_func (name), true);                                   \
-      (unlock_func (name), cont = false))
-
+#if defined(__GNUC__) && __GNUC__ >= 4
+#warning "m-mutex.h is an obsolete header. Use m-thread.h instead."
 #endif
+#include "m-thread.h"
@@ -1,7 +1,7 @@
 /*
 * M*LIB - dynamic priority queue module
 *
- * Copyright (c) 2017-2021, Patrick Pelissier
+ * Copyright (c) 2017-2023, Patrick Pelissier
 * All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
@@ -32,20 +32,16 @@

 /* Define a prioqueue of a given type and its associated functions.
   USAGE: PRIOQUEUE_DEF(name, type [, oplist_of_the_type]) */
-#define PRIOQUEUE_DEF(name, ...)                                              \
-  M_BEGIN_PROTECTED_CODE                                                      \
-  PRIOQUEUEI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                               \
-                    ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_C(name,_t), M_C(name,_it_t) ), \
-                     (name, __VA_ARGS__,                                        M_C(name,_t), M_C(name,_it_t)))) \
-  M_END_PROTECTED_CODE
+#define M_PRIOQUEUE_DEF(name, ...)                                            \
+  M_PRIOQUEUE_DEF_AS(name, M_F(name,_t), M_F(name,_it_t), __VA_ARGS__)


 /* Define a prioqueue of a given type and its associated functions.
  as the name name_t with an iterator named it_t
   USAGE: PRIOQUEUE_DEF_AS(name, name_t, it_t, type [, oplist_of_the_type]) */
-#define PRIOQUEUE_DEF_AS(name, name_t, it_t, ...)                             \
+#define M_PRIOQUEUE_DEF_AS(name, name_t, it_t, ...)                           \
  M_BEGIN_PROTECTED_CODE                                                      \
-  PRIOQUEUEI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                               \
+  M_PR1OQUEUE_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                              \
                    ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t, it_t ), \
                     (name, __VA_ARGS__,                                        name_t, it_t ))) \
  M_END_PROTECTED_CODE
@@ -53,67 +49,77 @@

 /* Define the oplist of a prioqueue of type.
   USAGE: PRIOQUEUE_OPLIST(name[, oplist of the type]) */
-#define PRIOQUEUE_OPLIST(...)                                                 \
-  PRIOQUEUEI_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                            \
-                       ((__VA_ARGS__, M_DEFAULT_OPLIST),                      \
+#define M_PRIOQUEUE_OPLIST(...)                                               \
+  M_PR1OQUEUE_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                           \
+                       ((__VA_ARGS__, M_BASIC_OPLIST),                        \
                        (__VA_ARGS__ )))


-
-/********************************** INTERNAL ************************************/
+/*****************************************************************************/
+/********************************** INTERNAL *********************************/
+/*****************************************************************************/

 /* Deferred evaluation for the definition,
   so that all arguments are evaluated before further expansion */
-#define PRIOQUEUEI_OPLIST_P1(arg) PRIOQUEUEI_OPLIST_P2 arg
+#define M_PR1OQUEUE_OPLIST_P1(arg) M_PR1OQUEUE_OPLIST_P2 arg

 /* Validation of the given oplist */
-#define PRIOQUEUEI_OPLIST_P2(name, oplist)                                    \
-  M_IF_OPLIST(oplist)(PRIOQUEUEI_OPLIST_P3, PRIOQUEUEI_OPLIST_FAILURE)(name, oplist)
+#define M_PR1OQUEUE_OPLIST_P2(name, oplist)                                   \
+  M_IF_OPLIST(oplist)(M_PR1OQUEUE_OPLIST_P3, M_PR1OQUEUE_OPLIST_FAILURE)(name, oplist)

 /* Prepare a clean compilation failure */
-#define PRIOQUEUEI_OPLIST_FAILURE(name, oplist)                               \
+#define M_PR1OQUEUE_OPLIST_FAILURE(name, oplist)                              \
  ((M_LIB_ERROR(ARGUMENT_OF_PRIOQUEUE_OPLIST_IS_NOT_AN_OPLIST, name, oplist)))

 /* Define oplist of a priority queue */
-#define PRIOQUEUEI_OPLIST_P3(name, oplist)                                    \
-  (INIT(M_C(name, _init))                                                     \
-   ,INIT_SET(M_C(name, _init_set))                                            \
+#define M_PR1OQUEUE_OPLIST_P3(name, oplist)                                   \
+  (INIT(M_F(name, _init))                                                     \
+   ,INIT_SET(M_F(name, _init_set))                                            \
   ,INIT_WITH(API_1(M_INIT_VAI))                                              \
-   ,SET(M_C(name, _set))                                                      \
-   ,CLEAR(M_C(name, _clear))                                                  \
-   ,INIT_MOVE(M_C(name, _init_move))                                          \
-   ,MOVE(M_C(name, _move))                                                    \
-   ,SWAP(M_C(name, _swap))                                                    \
-   ,TYPE(M_C(name,_ct))                                                       \
-   ,SUBTYPE(M_C(name, _subtype_ct))                                           \
-   ,CLEAN(M_C(name,_clean))                                                   \
-   ,PUSH(M_C(name,_push))                                                     \
-   ,POP(M_C(name,_pop))                                                       \
+   ,SET(M_F(name, _set))                                                      \
+   ,CLEAR(M_F(name, _clear))                                                  \
+   ,INIT_MOVE(M_F(name, _init_move))                                          \
+   ,MOVE(M_F(name, _move))                                                    \
+   ,SWAP(M_F(name, _swap))                                                    \
+   ,NAME(name)                                                                \
+   ,TYPE(M_F(name,_ct))                                                       \
+   ,SUBTYPE(M_F(name, _subtype_ct))                                           \
+   ,RESET(M_F(name,_reset))                                                   \
+   ,PUSH(M_F(name,_push))                                                     \
+   ,POP(M_F(name,_pop))                                                       \
   ,OPLIST(oplist)                                                            \
-   ,EMPTY_P(M_C(name, _empty_p)),                                             \
-   ,GET_SIZE(M_C(name, _size))                                                \
-   ,IT_TYPE(M_C(name, _it_ct)),                                               \
-   IT_FIRST(M_C(name,_it)),                                                   \
-   IT_END(M_C(name,_it_end)),                                                 \
-   IT_SET(M_C(name,_it_set)),                                                 \
-   IT_END_P(M_C(name,_end_p)),                                                \
-   IT_EQUAL_P(M_C(name,_it_equal_p)),                                         \
-   IT_LAST_P(M_C(name,_last_p)),                                              \
-   IT_NEXT(M_C(name,_next)),                                                  \
-   IT_CREF(M_C(name,_cref)),                                                  \
+   ,EMPTY_P(M_F(name, _empty_p))                                              \
+   ,GET_SIZE(M_F(name, _size))                                                \
+   ,IT_TYPE(M_F(name, _it_ct))                                                \
+   ,IT_FIRST(M_F(name,_it))                                                   \
+   ,IT_END(M_F(name,_it_end))                                                 \
+   ,IT_SET(M_F(name,_it_set))                                                 \
+   ,IT_END_P(M_F(name,_end_p))                                                \
+   ,IT_EQUAL_P(M_F(name,_it_equal_p))                                         \
+   ,IT_LAST_P(M_F(name,_last_p))                                              \
+   ,IT_NEXT(M_F(name,_next))                                                  \
+   ,IT_CREF(M_F(name,_cref))                                                  \
+   ,M_IF_METHOD(GET_STR, oplist)(GET_STR(M_F(name, _get_str)),)               \
+   ,M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(M_F(name, _parse_str)),)         \
+   ,M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_F(name, _out_str)),)               \
+   ,M_IF_METHOD(IN_STR, oplist)(IN_STR(M_F(name, _in_str)),)                  \
+   ,M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(M_F(name, _out_serial)),)      \
+   ,M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(M_F(name, _in_serial)),)         \
   )


+/********************************** INTERNAL *********************************/
+
 /* Deferred evaluation for the definition,
   so that all arguments are evaluated before further expansion */
-#define PRIOQUEUEI_DEF_P1(arg)    PRIOQUEUEI_DEF_P2 arg
+#define M_PR1OQUEUE_DEF_P1(arg)    M_ID( M_PR1OQUEUE_DEF_P2 arg )

 /* Validate the oplist before going further */
-#define PRIOQUEUEI_DEF_P2(name, type, oplist, prioqueue_t, it_t)              \
-  M_IF_OPLIST(oplist)(PRIOQUEUEI_DEF_P3, PRIOQUEUEI_DEF_FAILURE)(name, type, oplist, prioqueue_t, it_t)
+#define M_PR1OQUEUE_DEF_P2(name, type, oplist, prioqueue_t, it_t)             \
+  M_IF_OPLIST(oplist)(M_PR1OQUEUE_DEF_P3, M_PR1OQUEUE_DEF_FAILURE)(name, type, oplist, prioqueue_t, it_t)

 /* Stop processing with a compilation failure */
-#define PRIOQUEUEI_DEF_FAILURE(name, type, oplist, prioqueue_t, it_t)         \
+#define M_PR1OQUEUE_DEF_FAILURE(name, type, oplist, prioqueue_t, it_t)        \
  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(PRIOQUEUE_DEF): the given argument is not a valid oplist: " #oplist)

 /* Define the priority queue:
@@ -123,317 +129,391 @@
   - prioqueue_t: type of the container,
   - it_t: iterator of the container
 */
-#define PRIOQUEUEI_DEF_P3(name, type, oplist, prioqueue_t, it_t)              \
-                                                                              \
+#define M_PR1OQUEUE_DEF_P3(name, type, oplist, prioqueue_t, it_t)             \
  /* Definition of the internal array used to construct the priority queue */ \
-  ARRAY_DEF(M_C(name, _array), type, oplist)                                  \
+  ARRAY_DEF(M_F(name, _array), type, oplist)                                  \
+  M_PR1OQUEUE_DEF_TYPE(name, type, oplist, prioqueue_t, it_t)                 \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_PR1OQUEUE_DEF_CORE(name, type, oplist, prioqueue_t, it_t)                 \
+  M_PR1OQUEUE_DEF_IT(name, type, oplist, prioqueue_t, it_t)                   \
+  M_PR1OQUEUE_DEF_IO(name, type, oplist, prioqueue_t, it_t)                   \
+  M_EMPLACE_QUEUE_DEF(name, prioqueue_t, M_F(name, _emplace), oplist, M_EMPLACE_QUEUE_GENE)
+
+/* Define the types */
+#define M_PR1OQUEUE_DEF_TYPE(name, type, oplist, prioqueue_t, it_t)           \
                                                                              \
  /* Define the priority queue over the defined array */                      \
-  typedef struct M_C(name, _s) {                                              \
-    M_C(name, _array_t) array;                                                \
+  typedef struct M_F(name, _s) {                                              \
+    M_F(name, _array_t) array;                                                \
  } prioqueue_t[1];                                                           \
  /* Define the pointer references to the priority queue */                   \
-  typedef struct M_C(name, _s) *M_C(name, _ptr);                              \
-  typedef const struct M_C(name, _s) *M_C(name, _srcptr);                     \
+  typedef struct M_F(name, _s) *M_F(name, _ptr);                              \
+  typedef const struct M_F(name, _s) *M_F(name, _srcptr);                     \
                                                                              \
  /* The iterator is the same one as the one of the internal array */         \
-  typedef M_C(name, _array_it_t) it_t;                                        \
+  typedef M_F(name, _array_it_t) it_t;                                        \
                                                                              \
  /* Definition of the internal types used by the oplist */                   \
-  typedef prioqueue_t M_C(name, _ct);                                         \
-  typedef type        M_C(name, _subtype_ct);                                 \
-  typedef it_t        M_C(name, _it_ct);                                      \
-                                                                              \
-  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  typedef prioqueue_t M_F(name, _ct);                                         \
+  typedef type        M_F(name, _subtype_ct);                                 \
+  typedef it_t        M_F(name, _it_ct);                                      \
+
+/* Define the core functions */
+#define M_PR1OQUEUE_DEF_CORE(name, type, oplist, prioqueue_t, it_t)           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _init)(prioqueue_t p)                                             \
+  M_F(name, _init)(prioqueue_t p)                                             \
  {                                                                           \
-    M_C(name, _array_init)(p->array);                                         \
+    M_F(name, _array_init)(p->array);                                         \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _init_set)(prioqueue_t p, prioqueue_t const o)                    \
+  M_F(name, _init_set)(prioqueue_t p, prioqueue_t const o)                    \
  {                                                                           \
-    M_C(name, _array_init_set)(p->array, o->array);                           \
+    M_F(name, _array_init_set)(p->array, o->array);                           \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _set)(prioqueue_t p, prioqueue_t const o)                         \
+  M_F(name, _set)(prioqueue_t p, prioqueue_t const o)                         \
  {                                                                           \
-    M_C(name, _array_set)(p->array, o->array);                                \
+    M_F(name, _array_set)(p->array, o->array);                                \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _clear)(prioqueue_t p)                                            \
+  M_F(name, _clear)(prioqueue_t p)                                            \
  {                                                                           \
-    M_C(name, _array_clear)(p->array);                                        \
+    M_F(name, _array_clear)(p->array);                                        \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _init_move)(prioqueue_t p, prioqueue_t o)                         \
+  M_F(name, _init_move)(prioqueue_t p, prioqueue_t o)                         \
  {                                                                           \
-    M_C(name, _array_init_move)(p->array, o->array);                          \
+    M_F(name, _array_init_move)(p->array, o->array);                          \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _move)(prioqueue_t p, prioqueue_t o)                              \
+  M_F(name, _move)(prioqueue_t p, prioqueue_t o)                              \
  {                                                                           \
-    M_C(name, _array_move)(p->array, o->array);                               \
+    M_F(name, _array_move)(p->array, o->array);                               \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _swap)(prioqueue_t p, prioqueue_t o)                              \
+  M_F(name, _swap)(prioqueue_t p, prioqueue_t o)                              \
  {                                                                           \
-    M_C(name, _array_swap)(p->array, o->array);                               \
+    M_F(name, _array_swap)(p->array, o->array);                               \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _clean)(prioqueue_t p)                                            \
+  M_F(name, _reset)(prioqueue_t p)                                            \
  {                                                                           \
-    M_C(name, _array_clean)(p->array);                                        \
+    M_F(name, _array_reset)(p->array);                                        \
  }                                                                           \
                                                                              \
  static inline size_t                                                        \
-  M_C(name, _i_parent)(size_t i)                                              \
+  M_F(name, _i_parent)(size_t i)                                              \
  {                                                                           \
    M_ASSERT (i > 0);                                                         \
    return (i - 1) / 2;                                                       \
  }                                                                           \
                                                                              \
  static inline size_t                                                        \
-  M_C(name, _i_lchild)(size_t i)                                              \
+  M_F(name, _i_lchild)(size_t i)                                              \
  {                                                                           \
    M_ASSERT(i <= ((SIZE_MAX)-2)/2);                                          \
    return 2*i + 1;                                                           \
  }                                                                           \
                                                                              \
  static inline size_t                                                        \
-  M_C(name, _i_rchild)(size_t i)                                              \
+  M_F(name, _i_rchild)(size_t i)                                              \
  {                                                                           \
    M_ASSERT(i <= ((SIZE_MAX)-2)/2);                                          \
    return 2*i + 2;                                                           \
  }                                                                           \
                                                                              \
  static inline int                                                           \
-  M_C(name, _i_cmp)(const prioqueue_t p, size_t i, size_t j)                  \
+  M_F(name, _i_cmp)(const prioqueue_t p, size_t i, size_t j)                  \
  {                                                                           \
-    return M_CALL_CMP(oplist, *M_C(name, _array_cget)(p->array, i),           \
-                      *M_C(name, _array_cget)(p->array, j));                  \
+    return M_CALL_CMP(oplist, *M_F(name, _array_cget)(p->array, i),           \
+                      *M_F(name, _array_cget)(p->array, j));                  \
  }                                                                           \
                                                                              \
  static inline bool                                                          \
-  M_C(name, _empty_p)(prioqueue_t const p)                                    \
+  M_F(name, _empty_p)(prioqueue_t const p)                                    \
  {                                                                           \
-    return M_C(name, _array_empty_p)(p->array);                               \
+    return M_F(name, _array_empty_p)(p->array);                               \
  }                                                                           \
                                                                              \
  static inline size_t                                                        \
-  M_C(name, _size)(prioqueue_t const p)                                       \
+  M_F(name, _size)(prioqueue_t const p)                                       \
  {                                                                           \
-    return M_C(name, _array_size)(p->array);                                  \
+    return M_F(name, _array_size)(p->array);                                  \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _push)(prioqueue_t p, type const x)                               \
+  M_F(name, _push)(prioqueue_t p, type const x)                               \
  {                                                                           \
    /* Push back the new element at the end of the array */                   \
-    M_C(name, _array_push_back)(p->array, x);                                 \
+    M_F(name, _array_push_back)(p->array, x);                                 \
                                                                              \
    /* Reorder the array by swapping with its parent                          \
     * until it reaches the right position */                                 \
-    size_t i = M_C(name, _array_size)(p->array)-1;                            \
+    size_t i = M_F(name, _array_size)(p->array)-1;                            \
    while (i > 0) {                                                           \
-      size_t j = M_C(name, _i_parent)(i);                                     \
-      if (M_C(name, _i_cmp)(p, j, i) <= 0)                                    \
+      size_t j = M_F(name, _i_parent)(i);                                     \
+      if (M_F(name, _i_cmp)(p, j, i) <= 0)                                    \
        break;                                                                \
-      M_C(name, _array_swap_at) (p->array, i, j);                             \
+      M_F(name, _array_swap_at) (p->array, i, j);                             \
      i = j;                                                                  \
    }                                                                         \
  }                                                                           \
                                                                              \
  static inline type const *                                                  \
-  M_C(name, _front)(prioqueue_t const p)                                      \
+  M_F(name, _front)(prioqueue_t const p)                                      \
  {                                                                           \
-    return M_C(name, _array_cget)(p->array, 0);                               \
+    return M_F(name, _array_cget)(p->array, 0);                               \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _pop)(type *x, prioqueue_t p)                                     \
+  M_F(name, _pop)(type *x, prioqueue_t p)                                     \
  {                                                                           \
    /* Swap the front element with the last element */                        \
-    size_t size = M_C(name, _array_size)(p->array)-1;                         \
-    M_C(name, _array_swap_at) (p->array, 0, size);                            \
+    size_t size = M_F(name, _array_size)(p->array)-1;                         \
+    M_F(name, _array_swap_at) (p->array, 0, size);                            \
    /* Swap the new last element  */                                          \
-    M_C(name, _array_pop_back)(x, p->array);                                  \
+    M_F(name, _array_pop_back)(x, p->array);                                  \
                                                                              \
    /* Reorder the heap */                                                    \
    size_t i = 0;                                                             \
    while (true) {                                                            \
-      size_t child = M_C(name, _i_lchild)(i);                                 \
+      size_t child = M_F(name, _i_lchild)(i);                                 \
      if (child >= size)                                                      \
        break;                                                                \
-      size_t otherChild = M_C(name, _i_rchild)(i);                            \
+      size_t otherChild = M_F(name, _i_rchild)(i);                            \
      if (otherChild < size                                                   \
-          && M_C(name, _i_cmp)(p, otherChild, child) < 0 ) {                  \
+          && M_F(name, _i_cmp)(p, otherChild, child) < 0 ) {                  \
        child = otherChild;                                                   \
      }                                                                       \
-      if (M_C(name, _i_cmp)(p, i, child) <= 0)                                \
+      if (M_F(name, _i_cmp)(p, i, child) <= 0)                                \
        break;                                                                \
-      M_C(name, _array_swap_at) (p->array, i, child);                         \
+      M_F(name, _array_swap_at) (p->array, i, child);                         \
      i = child;                                                              \
    }                                                                         \
  }                                                                           \
                                                                              \
-  /* Define iterators over the array iterator */                              \
-  static inline void                                                          \
-  M_C(name, _it)(it_t it, prioqueue_t const v)                                \
-  {                                                                           \
-    M_C(name, _array_it)(it, v->array);                                       \
-  }                                                                           \
-                                                                              \
-  static inline void                                                          \
-  M_C(name, _it_last)(it_t it, prioqueue_t const v)                           \
-  {                                                                           \
-    M_C(name, _array_it_last)(it, v->array);                                  \
-  }                                                                           \
-                                                                              \
-  static inline void                                                          \
-  M_C(name, _it_end)(it_t it, prioqueue_t const v)                            \
-  {                                                                           \
-    M_C(name, _array_it_end)(it, v->array);                                   \
-  }                                                                           \
-                                                                              \
-  static inline void                                                          \
-  M_C(name, _it_set)(it_t it, const it_t org)                                 \
-  {                                                                           \
-    M_C(name, _array_it_set)(it, org);                                        \
-  }                                                                           \
-                                                                              \
-  static inline bool                                                          \
-  M_C(name, _end_p)(const it_t it)                                            \
-  {                                                                           \
-    return M_C(name, _array_end_p)(it);                                       \
-  }                                                                           \
-                                                                              \
-  static inline bool                                                          \
-  M_C(name, _last_p)(const it_t it)                                           \
-  {                                                                           \
-    return M_C(name, _array_last_p)(it);                                      \
-  }                                                                           \
-                                                                              \
-  static inline bool                                                          \
-  M_C(name, _it_equal_p)(const it_t it1,                                      \
-                         const it_t it2)                                      \
-  {                                                                           \
-    return M_C(name, _array_it_equal_p)(it1, it2);                            \
-  }                                                                           \
-                                                                              \
-  static inline void                                                          \
-  M_C(name, _next)(it_t it)                                                   \
-  {                                                                           \
-    M_C(name, _array_next)(it);                                               \
-  }                                                                           \
-                                                                              \
-  static inline void                                                          \
-  M_C(name, _previous)(it_t it)                                               \
-  {                                                                           \
-    M_C(name, _array_previous)(it);                                           \
-  }                                                                           \
-                                                                              \
-  static inline type const *                                                  \
-  M_C(name, _cref)(const it_t it)                                             \
-  {                                                                           \
-    return M_C(name, _array_cref)(it);                                        \
-  }                                                                           \
-                                                                              \
  M_IF_METHOD(EQUAL, oplist)                                                  \
  (                                                                           \
    /* EQUAL & CMP may be uncorrelated */                                     \
    static inline bool                                                        \
-    M_C(name, _equal_p)(prioqueue_t const p, prioqueue_t const q)             \
+    M_F(name, _equal_p)(prioqueue_t const p, prioqueue_t const q)             \
    {                                                                         \
-      return M_C(name, _array_equal_p)(p->array, q->array);                   \
+      return M_F(name, _array_equal_p)(p->array, q->array);                   \
    }                                                                         \
                                                                              \
-   static inline bool                                                         \
-   M_C(name, _erase)(prioqueue_t p, type x)                                   \
+   static inline size_t                                                       \
+   M_F(name, _i_find)(prioqueue_t p, type const x)                            \
   {                                                                          \
-     /* First pass: search for an item EQUAL to x */                          \
-     /* NOTE: An HASHMAP may be a good idea to optimize this pass. */         \
-     size_t size = M_C(name, _array_size)(p->array);                          \
+     size_t size = M_F(name, _array_size)(p->array);                          \
     size_t i = 0;                                                            \
     for(i = 0; i < size; i++) {                                              \
-       if (M_CALL_EQUAL(oplist, *M_C(name, _array_cget)(p->array, i), x))     \
+       /* FIXME: Can we use CMP and the partial order to go faster? */        \
+       if (M_CALL_EQUAL(oplist, *M_F(name, _array_cget)(p->array, i), x))     \
         break;                                                               \
     }                                                                        \
+     return i;                                                                \
+   }                                                                          \
+                                                                              \
+   static inline bool                                                         \
+   M_F(name, _erase)(prioqueue_t p, type const x)                             \
+   {                                                                          \
+     /* First pass: search for an item EQUAL to x */                          \
+     size_t size = M_F(name, _array_size)(p->array);                          \
+     size_t i = M_F(name, _i_find)(p, x);                                     \
     /* If x is not found, then stop */                                       \
     if (i >= size)                                                           \
       return false;                                                          \
     /* Swap the found item and the last element */                           \
     size--;                                                                  \
-     M_C(name, _array_swap_at) (p->array, i, size);                           \
-     M_C(name, _array_pop_back)(NULL, p->array);                              \
+     M_F(name, _array_swap_at) (p->array, i, size);                           \
+     M_F(name, _array_pop_back)(NULL, p->array);                              \
     /* Move back the last swapped element to its right position in the heap */ \
     while (true) {                                                           \
-       size_t child = M_C(name, _i_lchild)(i);                                \
+       size_t child = M_F(name, _i_lchild)(i);                                \
       if (child >= size) break;                                              \
-       size_t otherChild = M_C(name, _i_rchild)(i);                           \
+       size_t otherChild = M_F(name, _i_rchild)(i);                           \
       if (otherChild < size                                                  \
-           && M_C(name, _i_cmp)(p, otherChild, child) < 0 ) {                 \
+           && M_F(name, _i_cmp)(p, otherChild, child) < 0 ) {                 \
         child = otherChild;                                                  \
       }                                                                      \
-       if (M_C(name, _i_cmp)(p, i, child) <= 0) break;                        \
-       M_C(name, _array_swap_at) (p->array, i, child);                        \
+       if (M_F(name, _i_cmp)(p, i, child) <= 0) break;                        \
+       M_F(name, _array_swap_at) (p->array, i, child);                        \
       i = child;                                                             \
     }                                                                        \
     return true;                                                             \
   }                                                                          \
                                                                              \
   static inline void                                                         \
-   M_C(name, _update)(prioqueue_t p, type const xold, type const xnew)        \
+   M_F(name, _update)(prioqueue_t p, type const xold, type const xnew)        \
   {                                                                          \
     /* NOTE: xold can be the same pointer than xnew */                       \
     /* First pass: search for an item EQUAL to x */                          \
-     size_t size = M_C(name, _array_size)(p->array);                          \
-     size_t i = 0;                                                            \
-     for(i = 0; i < size; i++) {                                              \
-       if (M_CALL_EQUAL(oplist, *M_C(name, _array_cget)(p->array, i), xold))  \
-         break;                                                               \
-     }                                                                        \
+     size_t size = M_F(name, _array_size)(p->array);                          \
+     size_t i = M_F(name, _i_find)(p, xold);                                  \
     /* We shall have found the item */                                       \
     M_ASSERT (i < size);                                                     \
     /* Test if the position of the old data is further or nearer than the new */ \
-     int cmp = M_CALL_CMP(oplist, *M_C(name, _array_cget)(p->array, i), xnew); \
+     int cmp = M_CALL_CMP(oplist, *M_F(name, _array_cget)(p->array, i), xnew); \
     /* Set the found item to the new element */                              \
-     M_C(name, _array_set_at) (p->array, i, xnew);                            \
+     M_F(name, _array_set_at) (p->array, i, xnew);                            \
     if (cmp < 0) {                                                           \
      /* Move back the updated element to its new position, further in the heap */ \
      while (true) {                                                          \
-        size_t child = M_C(name, _i_lchild)(i);                               \
+        size_t child = M_F(name, _i_lchild)(i);                               \
        if (child >= size) break;                                             \
-        size_t otherChild = M_C(name, _i_rchild)(i);                          \
+        size_t otherChild = M_F(name, _i_rchild)(i);                          \
        if (otherChild < size                                                 \
-            && M_C(name, _i_cmp)(p, otherChild, child) < 0 ) {                \
+            && M_F(name, _i_cmp)(p, otherChild, child) < 0 ) {                \
          child = otherChild;                                                 \
        }                                                                     \
-        if (M_C(name, _i_cmp)(p, i, child) <= 0) break;                       \
-        M_C(name, _array_swap_at) (p->array, i, child);                       \
+        if (M_F(name, _i_cmp)(p, i, child) <= 0) break;                       \
+        M_F(name, _array_swap_at) (p->array, i, child);                       \
        i = child;                                                            \
      }                                                                       \
     } else {                                                                 \
      /* Move back the updated element to its new position, nearest in the heap */ \
      while (i > 0) {                                                         \
-        size_t parent = M_C(name, _i_parent)(i);                              \
-        if (M_C(name, _i_cmp)(p, parent, i) <= 0) break;                      \
-        M_C(name, _array_swap_at) (p->array, i, parent);                      \
+        size_t parent = M_F(name, _i_parent)(i);                              \
+        if (M_F(name, _i_cmp)(p, parent, i) <= 0) break;                      \
+        M_F(name, _array_swap_at) (p->array, i, parent);                      \
        i = parent;                                                           \
      }                                                                       \
     }                                                                        \
   }                                                                          \
   , /* No EQUAL */ )                                                         \

+/* Define the IT based functions */
+#define M_PR1OQUEUE_DEF_IT(name, type, oplist, prioqueue_t, it_t)             \
+                                                                              \
+  /* Define iterators over the array iterator */                              \
+  static inline void                                                          \
+  M_F(name, _it)(it_t it, prioqueue_t const v)                                \
+  {                                                                           \
+    M_F(name, _array_it)(it, v->array);                                       \
+  }                                                                           \
+                                                                              \
+  static inline void                                                          \
+  M_F(name, _it_last)(it_t it, prioqueue_t const v)                           \
+  {                                                                           \
+    M_F(name, _array_it_last)(it, v->array);                                  \
+  }                                                                           \
+                                                                              \
+  static inline void                                                          \
+  M_F(name, _it_end)(it_t it, prioqueue_t const v)                            \
+  {                                                                           \
+    M_F(name, _array_it_end)(it, v->array);                                   \
+  }                                                                           \
+                                                                              \
+  static inline void                                                          \
+  M_F(name, _it_set)(it_t it, const it_t org)                                 \
+  {                                                                           \
+    M_F(name, _array_it_set)(it, org);                                        \
+  }                                                                           \
+                                                                              \
+  static inline bool                                                          \
+  M_F(name, _end_p)(const it_t it)                                            \
+  {                                                                           \
+    return M_F(name, _array_end_p)(it);                                       \
+  }                                                                           \
+                                                                              \
+  static inline bool                                                          \
+  M_F(name, _last_p)(const it_t it)                                           \
+  {                                                                           \
+    return M_F(name, _array_last_p)(it);                                      \
+  }                                                                           \
+                                                                              \
+  static inline bool                                                          \
+  M_F(name, _it_equal_p)(const it_t it1,                                      \
+                         const it_t it2)                                      \
+  {                                                                           \
+    return M_F(name, _array_it_equal_p)(it1, it2);                            \
+  }                                                                           \
+                                                                              \
+  static inline void                                                          \
+  M_F(name, _next)(it_t it)                                                   \
+  {                                                                           \
+    M_F(name, _array_next)(it);                                               \
+  }                                                                           \
+                                                                              \
+  static inline void                                                          \
+  M_F(name, _previous)(it_t it)                                               \
+  {                                                                           \
+    M_F(name, _array_previous)(it);                                           \
+  }                                                                           \
+                                                                              \
+  static inline type const *                                                  \
+  M_F(name, _cref)(const it_t it)                                             \
+  {                                                                           \
+    return M_F(name, _array_cref)(it);                                        \
+  }                                                                           \
+
+/* Define the IO functions */
+#define M_PR1OQUEUE_DEF_IO(name, type, oplist, prioqueue_t, it_t)             \
+  M_IF_METHOD(OUT_STR, oplist)(                                               \
+  static inline void                                                          \
+  M_F(name, _out_str)(FILE *file, const prioqueue_t p)                        \
+  {                                                                           \
+    M_F(name, _array_out_str)(file, p->array);                                \
+  }                                                                           \
+  ,/* No OUT_STR */)                                                          \
+                                                                              \
+  M_IF_METHOD(IN_STR, oplist)(                                                \
+  static inline bool                                                          \
+  M_F(name, _in_str)(prioqueue_t p, FILE *file)                               \
+  {                                                                           \
+    return M_F(name, _array_in_str)(p->array, file);                          \
+  }                                                                           \
+  ,/* No IN_STR */)                                                           \
+                                                                              \
+  M_IF_METHOD(GET_STR, oplist)(                                               \
+  static inline void                                                          \
+  M_F(name, _get_str)(string_t str, const prioqueue_t p, bool append)         \
+  {                                                                           \
+    M_F(name, _array_get_str)(str, p->array, append);                         \
+  }                                                                           \
+  ,/* No GET_STR */)                                                          \
+                                                                              \
+  M_IF_METHOD(PARSE_STR, oplist)(                                             \
+  static inline bool                                                          \
+  M_F(name, _parse_str)(prioqueue_t p, const char str[], const char **endp)   \
+  {                                                                           \
+    return M_F(name, _array_parse_str)(p->array, str, endp);                  \
+  }                                                                           \
+  ,/* No PARSE_STR */)                                                        \
+                                                                              \
+  M_IF_METHOD(OUT_SERIAL, oplist)(                                            \
+  static inline m_serial_return_code_t                                        \
+  M_F(name, _out_serial)(m_serial_write_t f, const prioqueue_t p)             \
+  {                                                                           \
+    return M_F(name, _array_out_serial)(f, p->array);                         \
+  }                                                                           \
+  ,/* No OUT_SERIAL */)                                                       \
+                                                                              \
+  M_IF_METHOD2(IN_SERIAL, INIT, oplist)(                                      \
+  static inline m_serial_return_code_t                                        \
+  M_F(name, _in_serial)(prioqueue_t p, m_serial_read_t f)                     \
+  {                                                                           \
+    return M_F(name, _array_in_serial)(p->array, f);                          \
+  }                                                                           \
+  ,/* No in_SERIAL */)                                                        \
+

 // TODO: set all & remove all function

+/********************************** INTERNAL *********************************/
+
+#if M_USE_SMALL_NAME
+#define PRIOQUEUE_DEF M_PRIOQUEUE_DEF
+#define PRIOQUEUE_DEF_AS M_PRIOQUEUE_DEF_AS
+#define PRIOQUEUE_OPLIST M_PRIOQUEUE_OPLIST
+#endif
+
 #endif
@@ -1,7 +1,7 @@
 /*
 * M*LIB - Serial BIN
 *
- * Copyright (c) 2017-2021, Patrick Pelissier
+ * Copyright (c) 2017-2023, Patrick Pelissier
 * All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
@@ -32,12 +32,17 @@

 M_BEGIN_PROTECTED_CODE

+
+/********************************************************************************/
+/************************** FILE / WRITE / BIN    *******************************/
+/********************************************************************************/
+
 /* Internal service:
 * Write size_t in the stream in a compact form to reduce consumption
 * (and I/O bandwidth)
 */
 static inline bool
-m_serial_bin_write_size(FILE *f, const size_t size)
+m_ser1al_bin_write_size(FILE *f, const size_t size)
 {
  bool b;
  if (M_LIKELY(size < 253))
@@ -84,7 +89,7 @@ m_serial_bin_write_size(FILE *f, const size_t size)
 * (and I/O bandwidth)
 */
 static inline bool
-m_serial_bin_read_size(FILE *f, size_t *size)
+m_ser1al_bin_read_size(FILE *f, size_t *size)
 {
  int c;
  c = fgetc(f);
@@ -94,7 +99,7 @@ m_serial_bin_read_size(FILE *f, size_t *size)
    return true;
  }
  size_t s = 0;
-  int l = (c = 255) ? 8 : (c == 254) ? 4 : 2;
+  int l = (c == 255) ? 8 : (c == 254) ? 4 : 2;
  for(int i = 0; i < l; i++) {
      c = fgetc(f);
      if (M_UNLIKELY(c == EOF)) return false;
@@ -107,7 +112,7 @@ m_serial_bin_read_size(FILE *f, size_t *size)
 /* Write the boolean 'data' into the serial stream 'serial'.
   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
 static inline m_serial_return_code_t
-m_serial_bin_write_boolean(m_serial_write_t serial, const bool data)
+m_ser1al_bin_write_boolean(m_serial_write_t serial, const bool data)
 {
  FILE *f = (FILE *)serial->data[0].p;
  size_t n = fwrite (M_ASSIGN_CAST(const void*, &data), sizeof (bool), 1, f);
@@ -117,7 +122,7 @@ m_serial_bin_write_boolean(m_serial_write_t serial, const bool data)
 /* Write the integer 'data' of 'size_of_type' bytes into the serial stream 'serial'.
   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
 static inline m_serial_return_code_t
-m_serial_bin_write_integer(m_serial_write_t serial,const long long data, const size_t size_of_type)
+m_ser1al_bin_write_integer(m_serial_write_t serial,const long long data, const size_t size_of_type)
 {
  int8_t   i8;
  int16_t i16;
@@ -153,7 +158,7 @@ m_serial_bin_write_integer(m_serial_write_t serial,const long long data, const s
 /* Write the float 'data' of 'size_of_type' bytes into the serial stream 'serial'.
   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
 static inline m_serial_return_code_t
-m_serial_bin_write_float(m_serial_write_t serial, const long double data, const size_t size_of_type)
+m_ser1al_bin_write_float(m_serial_write_t serial, const long double data, const size_t size_of_type)
 {
  float   f1;
  double  f2;
@@ -179,13 +184,13 @@ m_serial_bin_write_float(m_serial_write_t serial, const long double data, const
 /* Write the null-terminated string 'data'into the serial stream 'serial'.
   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
 static inline m_serial_return_code_t
-m_serial_bin_write_string(m_serial_write_t serial, const char data[], size_t length)
+m_ser1al_bin_write_string(m_serial_write_t serial, const char data[], size_t length)
 {
  M_ASSERT_SLOW(length == strlen(data) );
  FILE *f = (FILE *)serial->data[0].p;
  M_ASSERT(f != NULL && data != NULL);
  // Write first the number of (non null) characters
-  if (m_serial_bin_write_size(f, length) != true) return m_core_serial_fail();
+  if (m_ser1al_bin_write_size(f, length) != true) return m_core_serial_fail();
  // Write the characters (excluding the final null char)
  // NOTE: fwrite supports length == 0.
  size_t n = fwrite (M_ASSIGN_CAST(const void*, data), 1, length, f);
@@ -199,7 +204,7 @@ m_serial_bin_write_string(m_serial_write_t serial, const char data[], size_t len
   (local is an unique serialization object of the array).
   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
 static inline m_serial_return_code_t
-m_serial_bin_write_array_start(m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements)
+m_ser1al_bin_write_array_start(m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements)
 {
  FILE *f = (FILE *)serial->data[0].p;
  size_t n = fwrite (M_ASSIGN_CAST(const void*, &number_of_elements), sizeof number_of_elements, 1, f);
@@ -210,7 +215,7 @@ m_serial_bin_write_array_start(m_serial_local_t local, m_serial_write_t serial,
 /* Write an array separator between elements of an array into the serial stream 'serial' if needed.
   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
 static inline  m_serial_return_code_t
-m_serial_bin_write_array_next(m_serial_local_t local, m_serial_write_t serial)
+m_ser1al_bin_write_array_next(m_serial_local_t local, m_serial_write_t serial)
 {
  FILE *f = (FILE *)serial->data[0].p;
  // Need separator if we don't know the real size 
@@ -226,7 +231,7 @@ m_serial_bin_write_array_next(m_serial_local_t local, m_serial_write_t serial)
 /* End the writing of an array into the serial stream 'serial'.
   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
 static inline   m_serial_return_code_t
-m_serial_bin_write_array_end(m_serial_local_t local, m_serial_write_t serial)
+m_ser1al_bin_write_array_end(m_serial_local_t local, m_serial_write_t serial)
 {
  FILE *f = (FILE *)serial->data[0].p;
  // Need mark if we don't know the real size 
@@ -242,7 +247,7 @@ m_serial_bin_write_array_end(m_serial_local_t local, m_serial_write_t serial)
 /* Write a value separator between element of the same pair of a map into the serial stream 'serial' if needed.
   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
 static inline   m_serial_return_code_t
-m_serial_bin_write_map_value(m_serial_local_t local, m_serial_write_t serial)
+m_ser1al_bin_write_map_value(m_serial_local_t local, m_serial_write_t serial)
 {
  (void) local; // argument not used
  (void) serial;
@@ -254,7 +259,7 @@ m_serial_bin_write_map_value(m_serial_local_t local, m_serial_write_t serial)
   (local is an unique serialization object of the tuple).
   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
 static inline   m_serial_return_code_t
-m_serial_bin_write_tuple_start(m_serial_local_t local, m_serial_write_t serial)
+m_ser1al_bin_write_tuple_start(m_serial_local_t local, m_serial_write_t serial)
 {
  (void) local; // argument not used
  (void) serial;
@@ -264,7 +269,7 @@ m_serial_bin_write_tuple_start(m_serial_local_t local, m_serial_write_t serial)
 /* Start writing the field named field_name[index] of a tuple into the serial stream 'serial'.
   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
 static inline   m_serial_return_code_t
-m_serial_bin_write_tuple_id(m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
+m_ser1al_bin_write_tuple_id(m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
 {
  (void) local; // argument not used
  (void) serial;
@@ -277,7 +282,7 @@ m_serial_bin_write_tuple_id(m_serial_local_t local, m_serial_write_t serial, con
 /* End the write of a tuple into the serial stream 'serial'.
   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
 static inline   m_serial_return_code_t
-m_serial_bin_write_tuple_end(m_serial_local_t local, m_serial_write_t serial)
+m_ser1al_bin_write_tuple_end(m_serial_local_t local, m_serial_write_t serial)
 {
  (void) local; // argument not used
  (void) serial;
@@ -290,7 +295,7 @@ m_serial_bin_write_tuple_end(m_serial_local_t local, m_serial_write_t serial)
   Otherwise, the field 'field_name[index]' will be filled.
     Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
 static inline   m_serial_return_code_t
-m_serial_bin_write_variant_start(m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
+m_ser1al_bin_write_variant_start(m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
 {
  (void) field_name;
  (void) max;
@@ -303,7 +308,7 @@ m_serial_bin_write_variant_start(m_serial_local_t local, m_serial_write_t serial
 /* End Writing a variant into the serial stream 'serial'. 
   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
 static inline   m_serial_return_code_t
-m_serial_bin_write_variant_end(m_serial_local_t local, m_serial_write_t serial)
+m_ser1al_bin_write_variant_end(m_serial_local_t local, m_serial_write_t serial)
 {
  (void) local; // argument not used
  (void) serial;
@@ -311,28 +316,28 @@ m_serial_bin_write_variant_end(m_serial_local_t local, m_serial_write_t serial)
 }

 /* The exported interface. */
-static const m_serial_write_interface_t m_serial_write_bin_interface = {
-  m_serial_bin_write_boolean,
-  m_serial_bin_write_integer,
-  m_serial_bin_write_float,
-  m_serial_bin_write_string, 
-  m_serial_bin_write_array_start,
-  m_serial_bin_write_array_next,
-  m_serial_bin_write_array_end,
-  m_serial_bin_write_array_start,
-  m_serial_bin_write_map_value,
-  m_serial_bin_write_array_next,
-  m_serial_bin_write_array_end,
-  m_serial_bin_write_tuple_start,
-  m_serial_bin_write_tuple_id,
-  m_serial_bin_write_tuple_end,
-  m_serial_bin_write_variant_start,
-  m_serial_bin_write_variant_end
+static const m_serial_write_interface_t m_ser1al_bin_write_interface = {
+  m_ser1al_bin_write_boolean,
+  m_ser1al_bin_write_integer,
+  m_ser1al_bin_write_float,
+  m_ser1al_bin_write_string,
+  m_ser1al_bin_write_array_start,
+  m_ser1al_bin_write_array_next,
+  m_ser1al_bin_write_array_end,
+  m_ser1al_bin_write_array_start,
+  m_ser1al_bin_write_map_value,
+  m_ser1al_bin_write_array_next,
+  m_ser1al_bin_write_array_end,
+  m_ser1al_bin_write_tuple_start,
+  m_ser1al_bin_write_tuple_id,
+  m_ser1al_bin_write_tuple_end,
+  m_ser1al_bin_write_variant_start,
+  m_ser1al_bin_write_variant_end
 };

 static inline void m_serial_bin_write_init(m_serial_write_t serial, FILE *f)
 {
-  serial->m_interface = &m_serial_write_bin_interface;
+  serial->m_interface = &m_ser1al_bin_write_interface;
  serial->data[0].p = M_ASSIGN_CAST(void*, f);
 }

@@ -344,15 +349,22 @@ static inline void m_serial_bin_write_clear(m_serial_write_t serial)

 /* Define a synonym of m_serial_read_t to the BIN serializer with its proper OPLIST */
 typedef m_serial_write_t m_serial_bin_write_t;
-#define M_OPL_m_serial_bin_write_t()                                          \
-  (INIT_WITH(m_serial_bin_write_init), CLEAR(m_serial_bin_write_clear), TYPE(m_serial_bin_write_t) )

+#define M_OPL_m_serial_bin_write_t()                                          \
+  (INIT_WITH(m_serial_bin_write_init), CLEAR(m_serial_bin_write_clear),       \
+  TYPE(m_serial_bin_write_t), PROPERTIES(( LET_AS_INIT_WITH(1) )) )
+
+
+
+/********************************************************************************/
+/************************** FILE / READ  / BIN    *******************************/
+/********************************************************************************/

 /* Read from the stream 'serial' a boolean.
   Set '*b' with the boolean value if succeeds 
   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
 static inline  m_serial_return_code_t
-m_serial_bin_read_boolean(m_serial_read_t serial, bool *b){
+m_ser1al_bin_read_boolean(m_serial_read_t serial, bool *b){
  FILE *f = (FILE*) serial->data[0].p;
  size_t n = fread (M_ASSIGN_CAST(void*, b), sizeof (bool), 1, f);
  return n == 1 ? M_SERIAL_OK_DONE : m_core_serial_fail();
@@ -362,7 +374,7 @@ m_serial_bin_read_boolean(m_serial_read_t serial, bool *b){
   Set '*i' with the integer value if succeeds 
   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
 static inline  m_serial_return_code_t
-m_serial_bin_read_integer(m_serial_read_t serial, long long *i, const size_t size_of_type){
+m_ser1al_bin_read_integer(m_serial_read_t serial, long long *i, const size_t size_of_type){
  int8_t   i8;
  int16_t i16;
  int32_t i32;
@@ -397,7 +409,7 @@ m_serial_bin_read_integer(m_serial_read_t serial, long long *i, const size_t siz
   Set '*r' with the boolean value if succeeds 
   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
 static inline  m_serial_return_code_t
-m_serial_bin_read_float(m_serial_read_t serial, long double *r, const size_t size_of_type){
+m_ser1al_bin_read_float(m_serial_read_t serial, long double *r, const size_t size_of_type){
  float   f1;
  double  f2;
  long double f3;
@@ -422,15 +434,15 @@ m_serial_bin_read_float(m_serial_read_t serial, long double *r, const size_t siz
   Set 's' with the string if succeeds 
   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
 static inline  m_serial_return_code_t
-m_serial_bin_read_string(m_serial_read_t serial, struct string_s *s){
+m_ser1al_bin_read_string(m_serial_read_t serial, struct string_s *s){
  FILE *f = (FILE*) serial->data[0].p;
  M_ASSERT(f != NULL && s != NULL);
  // First read the number of non null characters
  size_t length;
-  if (m_serial_bin_read_size(f, &length) != true) return m_core_serial_fail();
+  if (m_ser1al_bin_read_size(f, &length) != true) return m_core_serial_fail();
  // Use of internal string interface to dimension the string
-  char *p = stringi_fit2size(s, length + 1);
-  stringi_set_size(s, length);
+  char *p = m_str1ng_fit2size(s, length + 1);
+  m_str1ng_set_size(s, length);
  // Read the characters excluding the final null one.
  // NOTE: fread supports length == 0.
  size_t n = fread(M_ASSIGN_CAST(void*, p), 1, length, f);
@@ -447,7 +459,7 @@ m_serial_bin_read_string(m_serial_read_t serial, struct string_s *s){
   M_SERIAL_OK_DONE if it succeeds and the array ends (the array is empty),
   M_SERIAL_FAIL otherwise */
 static inline  m_serial_return_code_t
-m_serial_bin_read_array_start(m_serial_local_t local, m_serial_read_t serial, size_t *num)
+m_ser1al_bin_read_array_start(m_serial_local_t local, m_serial_read_t serial, size_t *num)
 {
  FILE *f = (FILE*) serial->data[0].p;
  size_t n = fread (M_ASSIGN_CAST(void*, num), sizeof *num, 1, f);
@@ -471,7 +483,7 @@ m_serial_bin_read_array_start(m_serial_local_t local, m_serial_read_t serial, si
   M_SERIAL_OK_DONE if it succeeds and the array ends,
   M_SERIAL_FAIL otherwise */
 static inline  m_serial_return_code_t
-m_serial_bin_read_array_next(m_serial_local_t local, m_serial_read_t serial)
+m_ser1al_bin_read_array_next(m_serial_local_t local, m_serial_read_t serial)
 {
  FILE *f = (FILE*) serial->data[0].p;
  if (local->data[0].b) {
@@ -493,7 +505,7 @@ m_serial_bin_read_array_next(m_serial_local_t local, m_serial_read_t serial)
   Return M_SERIAL_OK_CONTINUE if it succeeds and the map continue,
   M_SERIAL_FAIL otherwise */
 static inline  m_serial_return_code_t
-m_serial_bin_read_map_value(m_serial_local_t local, m_serial_read_t serial)
+m_ser1al_bin_read_map_value(m_serial_local_t local, m_serial_read_t serial)
 {
  (void) local; // argument not used
  (void) serial;
@@ -504,7 +516,7 @@ m_serial_bin_read_map_value(m_serial_local_t local, m_serial_read_t serial)
   Return M_SERIAL_OK_CONTINUE if it succeeds and the tuple continues,
   M_SERIAL_FAIL otherwise */
 static inline  m_serial_return_code_t
-m_serial_bin_read_tuple_start(m_serial_local_t local, m_serial_read_t serial)
+m_ser1al_bin_read_tuple_start(m_serial_local_t local, m_serial_read_t serial)
 {
  (void) serial;
  local->data[1].i = 0;
@@ -518,7 +530,7 @@ m_serial_bin_read_tuple_start(m_serial_local_t local, m_serial_read_t serial)
   Return M_SERIAL_OK_DONE if it succeeds and the tuple ends,
   M_SERIAL_FAIL otherwise */
 static inline  m_serial_return_code_t
-m_serial_bin_read_tuple_id(m_serial_local_t local, m_serial_read_t serial, const char *const field_name [], const int max, int *id)
+m_ser1al_bin_read_tuple_id(m_serial_local_t local, m_serial_read_t serial, const char *const field_name [], const int max, int *id)
 {
  (void) serial;
  (void) field_name;
@@ -535,7 +547,7 @@ m_serial_bin_read_tuple_id(m_serial_local_t local, m_serial_read_t serial, const
   Return M_SERIAL_OK_DONE if it succeeds and the variant ends(variant is empty),
   M_SERIAL_FAIL otherwise */
 static inline  m_serial_return_code_t
-m_serial_bin_read_variant_start(m_serial_local_t local, m_serial_read_t serial, const char *const field_name[], const int max, int*id)
+m_ser1al_bin_read_variant_start(m_serial_local_t local, m_serial_read_t serial, const char *const field_name[], const int max, int*id)
 {
  (void) field_name;
  (void) max;
@@ -549,32 +561,32 @@ m_serial_bin_read_variant_start(m_serial_local_t local, m_serial_read_t serial,
   Return M_SERIAL_OK_DONE if it succeeds and the variant ends,
   M_SERIAL_FAIL otherwise */
 static inline  m_serial_return_code_t
-m_serial_bin_read_variant_end(m_serial_local_t local, m_serial_read_t serial)
+m_ser1al_bin_read_variant_end(m_serial_local_t local, m_serial_read_t serial)
 {
  (void) local; // argument not used
  (void) serial;
  return M_SERIAL_OK_DONE;
 }

-static const m_serial_read_interface_t m_serial_bin_read_interface = {
-  m_serial_bin_read_boolean,
-  m_serial_bin_read_integer,
-  m_serial_bin_read_float,
-  m_serial_bin_read_string,
-  m_serial_bin_read_array_start,
-  m_serial_bin_read_array_next,
-  m_serial_bin_read_array_start,
-  m_serial_bin_read_map_value,
-  m_serial_bin_read_array_next,
-  m_serial_bin_read_tuple_start,
-  m_serial_bin_read_tuple_id,
-  m_serial_bin_read_variant_start,
-  m_serial_bin_read_variant_end
+static const m_serial_read_interface_t m_ser1al_bin_read_interface = {
+  m_ser1al_bin_read_boolean,
+  m_ser1al_bin_read_integer,
+  m_ser1al_bin_read_float,
+  m_ser1al_bin_read_string,
+  m_ser1al_bin_read_array_start,
+  m_ser1al_bin_read_array_next,
+  m_ser1al_bin_read_array_start,
+  m_ser1al_bin_read_map_value,
+  m_ser1al_bin_read_array_next,
+  m_ser1al_bin_read_tuple_start,
+  m_ser1al_bin_read_tuple_id,
+  m_ser1al_bin_read_variant_start,
+  m_ser1al_bin_read_variant_end
 };

 static inline void m_serial_bin_read_init(m_serial_read_t serial, FILE *f)
 {
-  serial->m_interface = &m_serial_bin_read_interface;
+  serial->m_interface = &m_ser1al_bin_read_interface;
  serial->data[0].p = M_ASSIGN_CAST(void*, f);
 }

@@ -586,7 +598,8 @@ static inline void m_serial_bin_read_clear(m_serial_read_t serial)
 /* Define a synonym of m_serial_read_t to the BIN serializer with its proper OPLIST */
 typedef m_serial_read_t m_serial_bin_read_t;
 #define M_OPL_m_serial_bin_read_t()                                           \
-  (INIT_WITH(m_serial_bin_read_init), CLEAR(m_serial_bin_read_clear), TYPE(m_serial_bin_read_t) )
+  (INIT_WITH(m_serial_bin_read_init), CLEAR(m_serial_bin_read_clear),         \
+   TYPE(m_serial_bin_read_t), PROPERTIES(( LET_AS_INIT_WITH(1) )) )

 M_END_PROTECTED_CODE

@@ -1,7 +1,7 @@
 /*
 * M*LIB - SHARED Module
 *
- * Copyright (c) 2017-2021, Patrick Pelissier
+ * Copyright (c) 2017-2023, Patrick Pelissier
 * All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
@@ -31,239 +31,242 @@

 M_BEGIN_PROTECTED_CODE

-/* Define the oplist of a shared pointer.
-   USAGE: SHARED_OPLIST(name [, oplist_of_the_type]) */
-#define SHARED_PTR_OPLIST(...)                                                \
-  SHAREDI_PTR_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                           \
-                        ((__VA_ARGS__, M_DEFAULT_OPLIST ),                    \
-                         (__VA_ARGS__ )))
-
-
 /* Define shared pointer and its function.
   USAGE: SHARED_PTR_DEF(name, type, [, oplist]) */
-#define SHARED_PTR_DEF(name, ...)                                             \
-  M_BEGIN_PROTECTED_CODE                                                      \
-  SHAREDI_PTR_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                              \
-                     ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), SHAREDI_ATOMIC_OPLIST, M_C(name, _t) ), \
-                      (name, __VA_ARGS__ ,                                       SHAREDI_ATOMIC_OPLIST, M_C(name, _t) ))) \
-  M_END_PROTECTED_CODE
+#define M_SHARED_PTR_DEF(name, ...)                                           \
+  M_SHARED_PTR_DEF_AS(name, M_F(name,_t), __VA_ARGS__)


 /* Define shared pointer and its function
   as the given name name_t
   USAGE: SHARED_PTR_DEF_AS(name, name_t, type, [, oplist]) */
-#define SHARED_PTR_DEF_AS(name, name_t, ...)                                  \
+#define M_SHARED_PTR_DEF_AS(name, name_t, ...)                                \
  M_BEGIN_PROTECTED_CODE                                                      \
-  SHAREDI_PTR_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                              \
-                     ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), SHAREDI_ATOMIC_OPLIST, name_t ), \
-                      (name, __VA_ARGS__ ,                                       SHAREDI_ATOMIC_OPLIST, name_t ))) \
+  M_SHAR3D_PTR_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                             \
+                     ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_SHAR3D_ATOMIC_OPLIST, name_t ), \
+                      (name, __VA_ARGS__ ,                                       M_SHAR3D_ATOMIC_OPLIST, name_t ))) \
  M_END_PROTECTED_CODE


+/* Define the oplist of a shared pointer.
+   USAGE: SHARED_OPLIST(name [, oplist_of_the_type]) */
+#define M_SHARED_PTR_OPLIST(...)                                              \
+  M_SHAR3D_PTR_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                          \
+                        ((__VA_ARGS__, M_BASIC_OPLIST ),                      \
+                         (__VA_ARGS__ )))
+
+
 /* Define relaxed shared pointer and its function (thread unsafe).
   USAGE: SHARED_PTR_RELAXED_DEF(name, type, [, oplist]) */
-#define SHARED_PTR_RELAXED_DEF(name, ...)                                     \
-  M_BEGIN_PROTECTED_CODE                                                      \
-  SHAREDI_PTR_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                              \
-                     ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), SHAREDI_INTEGER_OPLIST, M_C(name, _t) ), \
-                      (name, __VA_ARGS__,                                        SHAREDI_INTEGER_OPLIST, M_C(name, _t) ))) \
-  M_END_PROTECTED_CODE
+#define M_SHARED_PTR_RELAXED_DEF(name, ...)                                   \
+  M_SHARED_PTR_RELAXED_DEF_AS(name, M_F(name,_t), __VA_ARGS__)


 /* Define relaxed shared pointer and its function (thread unsafe)
   as the given name name_t
   USAGE: SHARED_PTR_RELAXED_DEF(name, type, [, oplist]) */
-#define SHARED_PTR_RELAXED_DEF_AS(name, name_t, ...)                          \
+#define M_SHARED_PTR_RELAXED_DEF_AS(name, name_t, ...)                        \
  M_BEGIN_PROTECTED_CODE                                                      \
-  SHAREDI_PTR_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                              \
-                     ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), SHAREDI_INTEGER_OPLIST, name_t ), \
-                      (name, __VA_ARGS__,                                        SHAREDI_INTEGER_OPLIST, name_t ))) \
+  M_SHAR3D_PTR_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                             \
+                     ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_SHAR3D_INTEGER_OPLIST, name_t ), \
+                      (name, __VA_ARGS__,                                        M_SHAR3D_INTEGER_OPLIST, name_t ))) \
  M_END_PROTECTED_CODE


 /* Define shared resource and its function.
   This is a bounded pool of resource shared by multiple owners.
   USAGE: SHARED_RESOURCE_DEF(name, type, [, oplist]) */
-#define SHARED_RESOURCE_DEF(name, ...)                                        \
-  M_BEGIN_PROTECTED_CODE                                                      \
-  SHAREDI_RESOURCE_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                         \
-                          ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_C(name, _t), M_C(name, _it_t)  ), \
-                           (name, __VA_ARGS__,                                        M_C(name, _t), M_C(name, _it_t)  ))) \
-  M_END_PROTECTED_CODE
+#define M_SHARED_RESOURCE_DEF(name, ...)                                      \
+  M_SHARED_RESOURCE_DEF_AS(name, M_F(name,_t), M_F(name,_it_t), __VA_ARGS__)


 /* Define shared resource and its function
   as the given name named_t and the iterator it_t
   This is a bounded pool of resource shared by multiple owners.
   USAGE: SHARED_RESOURCE_DEF_AS(name, name_t, it_t, type, [, oplist]) */
-#define SHARED_RESOURCE_DEF_AS(name, name_t, it_t, ...)                       \
+#define M_SHARED_RESOURCE_DEF_AS(name, name_t, it_t, ...)                     \
  M_BEGIN_PROTECTED_CODE                                                      \
-  SHAREDI_RESOURCE_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                         \
+  M_SHAR3D_RESOURCE_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                        \
                          ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t, it_t ), \
                           (name, __VA_ARGS__,                                        name_t, it_t ))) \
  M_END_PROTECTED_CODE



-/********************************** INTERNAL ************************************/
+/*****************************************************************************/
+/********************************** INTERNAL *********************************/
+/*****************************************************************************/

 // deferred evaluation
-#define SHAREDI_PTR_OPLIST_P1(arg) SHAREDI_PTR_OPLIST_P2 arg
+#define M_SHAR3D_PTR_OPLIST_P1(arg) M_SHAR3D_PTR_OPLIST_P2 arg

 /* Validation of the given, shared_t oplist */
-#define SHAREDI_PTR_OPLIST_P2(name, oplist)                                   \
-  M_IF_OPLIST(oplist)(SHAREDI_PTR_OPLIST_P3, SHAREDI_PTR_OPLIST_FAILURE)(name, oplist)
+#define M_SHAR3D_PTR_OPLIST_P2(name, oplist)                                  \
+  M_IF_OPLIST(oplist)(M_SHAR3D_PTR_OPLIST_P3, M_SHAR3D_PTR_OPLIST_FAILURE)(name, oplist)

 /* Prepare a clean compilation failure */
-#define SHAREDI_PTR_OPLIST_FAILURE(name, oplist)                              \
+#define M_SHAR3D_PTR_OPLIST_FAILURE(name, oplist)                             \
  ((M_LIB_ERROR(ARGUMENT_OF_SHARED_PTR_OPLIST_IS_NOT_AN_OPLIST, name, oplist)))

-#define SHAREDI_PTR_OPLIST_P3(name, oplist) (                                 \
-  INIT(M_C(name, _init)),                                                     \
-  CLEAR(M_C(name, _clear)),                                                   \
-  INIT_SET(M_C(name, _init_set)),                                             \
-  SET(M_C(name, _set))                                                        \
-  INIT_MOVE(M_C(name, _init_move)),                                           \
-  CLEAN(M_C(name, _clean)),                                                   \
-  MOVE(M_C(name, _move)),                                                     \
-  SWAP(M_C(name, _swap))                                                      \
-  ,TYPE(M_C(name, _ct))                                                       \
+#define M_SHAR3D_PTR_OPLIST_P3(name, oplist) (                                \
+  INIT(M_F(name, _init)),                                                     \
+  CLEAR(M_F(name, _clear)),                                                   \
+  INIT_SET(M_F(name, _init_set)),                                             \
+  SET(M_F(name, _set))                                                        \
+  INIT_MOVE(M_F(name, _init_move)),                                           \
+  RESET(M_F(name, _reset)),                                                   \
+  MOVE(M_F(name, _move)),                                                     \
+  SWAP(M_F(name, _swap))                                                      \
+  ,NAME(name)                                                                 \
+  ,TYPE(M_F(name, _ct))                                                       \
  ,M_IF_METHOD(NEW, oplist)(NEW(M_GET_NEW oplist),)                           \
  ,M_IF_METHOD(REALLOC, oplist)(REALLOC(M_GET_REALLOC oplist),)               \
  ,M_IF_METHOD(DEL, oplist)(DEL(M_GET_DEL oplist),)                           \
  )

 // OPLIST to handle a counter of atomic type
-#define SHAREDI_ATOMIC_OPLIST (TYPE(atomic_int),                              \
+#define M_SHAR3D_ATOMIC_OPLIST (TYPE(atomic_int),                             \
                               INIT_SET(atomic_init),                         \
                               ADD(atomic_fetch_add),                         \
                               SUB(atomic_fetch_sub),                         \
                               IT_CREF(atomic_load))

 // OPLIST to handle a counter of non-atomic type
-#define SHAREDI_INTEGER_OPLIST (TYPE(int),                                    \
-                                INIT_SET(sharedi_integer_init_set),           \
-                                ADD(sharedi_integer_add),                     \
-                                SUB(sharedi_integer_sub),                     \
-                                IT_CREF(sharedi_integer_cref))
+#define M_SHAR3D_INTEGER_OPLIST (TYPE(int),                                   \
+                                INIT_SET(m_shar3d_integer_init_set),          \
+                                ADD(m_shar3d_integer_add),                    \
+                                SUB(m_shar3d_integer_sub),                    \
+                                IT_CREF(m_shar3d_integer_cref))

 /* Atomic like interface for basic integers */
-static inline void sharedi_integer_init_set(int *p, int val) { *p = val; }
-static inline int sharedi_integer_add(int *p, int val) { int r = *p;  *p += val; return r; }
-static inline int sharedi_integer_sub(int *p, int val) { int r = *p;  *p -= val; return r; }
-static inline int sharedi_integer_cref(int *p) { return *p; }
+static inline void m_shar3d_integer_init_set(int *p, int val) { *p = val; }
+static inline int m_shar3d_integer_add(int *p, int val) { int r = *p;  *p += val; return r; }
+static inline int m_shar3d_integer_sub(int *p, int val) { int r = *p;  *p -= val; return r; }
+static inline int m_shar3d_integer_cref(int *p) { return *p; }
+
+
+/********************************** INTERNAL *********************************/

 /* Contract of a shared pointer */
-#define SHAREDI_CONTRACT(shared, cpt_oplist) do {                             \
+#define M_SHAR3D_CONTRACT(shared, cpt_oplist) do {                            \
    M_ASSERT(shared != NULL);                                                 \
    M_ASSERT(*shared == NULL || M_CALL_IT_CREF(cpt_oplist, &(*shared)->cpt) >= 1); \
  } while (0)

 // deferred evaluation
-#define SHAREDI_PTR_DEF_P1(arg) SHAREDI_PTR_DEF_P2 arg
+#define M_SHAR3D_PTR_DEF_P1(arg) M_ID( M_SHAR3D_PTR_DEF_P2 arg )

 /* Validate the oplist before going further */
-#define SHAREDI_PTR_DEF_P2(name, type, oplist, cpt_oplist, shared_t)          \
-  M_IF_OPLIST(oplist)(SHAREDI_PTR_DEF_P3, SHAREDI_PTR_DEF_FAILURE)(name, type, oplist, cpt_oplist, shared_t)
+#define M_SHAR3D_PTR_DEF_P2(name, type, oplist, cpt_oplist, shared_t)         \
+  M_IF_OPLIST(oplist)(M_SHAR3D_PTR_DEF_P3, M_SHAR3D_PTR_DEF_FAILURE)(name, type, oplist, cpt_oplist, shared_t)

 /* Stop processing with a compilation failure */
-#define SHAREDI_PTR_DEF_FAILURE(name, type, oplist, cpt_oplist, shared_t)     \
+#define M_SHAR3D_PTR_DEF_FAILURE(name, type, oplist, cpt_oplist, shared_t)    \
  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(SHARED_PTR_DEF): the given argument is not a valid oplist: " #oplist)

 /* Code generation */
-#define SHAREDI_PTR_DEF_P3(name, type, oplist, cpt_oplist, shared_t)          \
+#define M_SHAR3D_PTR_DEF_P3(name, type, oplist, cpt_oplist, shared_t)         \
+  M_SHAR3D_PTR_DEF_TYPE(name, type, oplist, cpt_oplist, shared_t)             \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_SHAR3D_PTR_DEF_CORE(name, type, oplist, cpt_oplist, shared_t)             \
+
+/* Define the types */
+#define M_SHAR3D_PTR_DEF_TYPE(name, type, oplist, cpt_oplist, shared_t)       \
                                                                              \
-  typedef struct M_C(name, _s){                                               \
+  typedef struct M_F(name, _s){                                               \
    type *data;                        /* Pointer to the data */              \
    M_GET_TYPE cpt_oplist  cpt; /* Counter of how many refs the data */       \
    bool  combineAlloc; /* Does the data and the ptr share the slot? */       \
  } *shared_t[1];                                                             \
-  typedef struct M_C(name, _s) *M_C(name, _ptr);                              \
-  typedef const struct M_C(name, _s) *M_C(name, _srcptr);                     \
+  typedef struct M_F(name, _s) *M_F(name, _ptr);                              \
+  typedef const struct M_F(name, _s) *M_F(name, _srcptr);                     \
                                                                              \
  /* Internal type for oplist */                                              \
-  typedef shared_t M_C(name, _ct);                                            \
+  typedef shared_t M_F(name, _ct);                                            \
                                                                              \
-  typedef struct M_C(name, combine_s) {                                       \
+  typedef struct M_F(name, combine_s) {                                       \
    type data;                                                                \
-    struct M_C(name, _s) ptr;                                                 \
-  } M_C(name, combine_ct)[1];                                                 \
-                                                                              \
-  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+    struct M_F(name, _s) ptr;                                                 \
+  } M_F(name, combine_ct)[1];                                                 \
+
+/* Define the core functions */
+#define M_SHAR3D_PTR_DEF_CORE(name, type, oplist, cpt_oplist, shared_t)       \
                                                                              \
  static inline void                                                          \
-  M_C(name, _init)(shared_t shared)                                           \
+  M_F(name, _init)(shared_t shared)                                           \
  {                                                                           \
    *shared = NULL;                                                           \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _init2)(shared_t shared, type *data)                              \
+  M_F(name, _init2)(shared_t shared, type *data)                              \
  {                                                                           \
    M_ASSERT (shared != NULL);                                                \
    /* The shared ptr get exclusive access to data */                         \
-    struct M_C(name, _s) *ptr;                                                \
+    struct M_F(name, _s) *ptr;                                                \
    if (M_UNLIKELY (data == NULL)) {                                          \
      *shared = NULL;                                                         \
      return;                                                                 \
    }                                                                         \
-    ptr = M_CALL_NEW(oplist, struct M_C(name, _s));                           \
-    if (M_UNLIKELY (ptr == NULL)) {                                           \
-      M_MEMORY_FULL(sizeof(struct M_C(name, _s)));                            \
+    ptr = M_CALL_NEW(oplist, struct M_F(name, _s));                           \
+    if (M_UNLIKELY_NOMEM (ptr == NULL)) {                                     \
+      M_MEMORY_FULL(sizeof(struct M_F(name, _s)));                            \
      return;                                                                 \
    }                                                                         \
    ptr->data = data;                                                         \
    M_CALL_INIT_SET(cpt_oplist, &ptr->cpt, 1);                                \
    ptr->combineAlloc = false;                                                \
    *shared = ptr;                                                            \
-    SHAREDI_CONTRACT(shared, cpt_oplist);                                     \
+    M_SHAR3D_CONTRACT(shared, cpt_oplist);                                    \
  }                                                                           \
                                                                              \
+  M_IF_METHOD(INIT, oplist)(                                                  \
  static inline void                                                          \
-  M_C(name, _init_new)(shared_t shared)                                       \
+  M_F(name, _init_new)(shared_t shared)                                       \
  {                                                                           \
    /* NOTE: Alloc 1 struct with both structures. */                          \
-    struct M_C(name, combine_s) *p =                                          \
-      M_CALL_NEW(oplist, struct M_C(name, combine_s));                        \
-    if (M_UNLIKELY (p == NULL)) {                                             \
-      M_MEMORY_FULL(sizeof(struct M_C(name, combine_s)));                     \
+    struct M_F(name, combine_s) *p =                                          \
+      M_CALL_NEW(oplist, struct M_F(name, combine_s));                        \
+    if (M_UNLIKELY_NOMEM (p == NULL)) {                                       \
+      M_MEMORY_FULL(sizeof(struct M_F(name, combine_s)));                     \
      return;                                                                 \
    }                                                                         \
-    struct M_C(name, _s) *ptr = &p->ptr;                                      \
+    struct M_F(name, _s) *ptr = &p->ptr;                                      \
    type *data = &p->data;                                                    \
    M_CALL_INIT( oplist, *data);                                              \
    ptr->data = data;                                                         \
    M_CALL_INIT_SET(cpt_oplist, &ptr->cpt, 1);                                \
    ptr->combineAlloc = true;                                                 \
    *shared = ptr;                                                            \
-    SHAREDI_CONTRACT(shared, cpt_oplist);                                     \
+    M_SHAR3D_CONTRACT(shared, cpt_oplist);                                    \
  }                                                                           \
+  , /* No INIT */ )                                                           \
                                                                              \
  static inline bool                                                          \
-  M_C(name, _NULL_p)(const shared_t shared)                                   \
+  M_F(name, _NULL_p)(const shared_t shared)                                   \
  {                                                                           \
-    SHAREDI_CONTRACT(shared, cpt_oplist);                                     \
+    M_SHAR3D_CONTRACT(shared, cpt_oplist);                                    \
    return *shared == NULL;                                                   \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _init_set)(shared_t dest,                                         \
+  M_F(name, _init_set)(shared_t dest,                                         \
                       const shared_t shared)                                 \
  {                                                                           \
-    SHAREDI_CONTRACT(shared, cpt_oplist);                                     \
+    M_SHAR3D_CONTRACT(shared, cpt_oplist);                                    \
    M_ASSERT (dest != shared);                                                \
    *dest = *shared;                                                          \
    if (*dest != NULL) {                                                      \
      int n = M_CALL_ADD(cpt_oplist, &((*dest)->cpt), 1);                     \
      (void) n;        /* unused return value */                              \
    }                                                                         \
-    SHAREDI_CONTRACT(dest, cpt_oplist);                                       \
+    M_SHAR3D_CONTRACT(dest, cpt_oplist);                                      \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _clear)(shared_t dest)                                            \
+  M_F(name, _clear)(shared_t dest)                                            \
  {                                                                           \
-    SHAREDI_CONTRACT(dest, cpt_oplist);                                       \
+    M_SHAR3D_CONTRACT(dest, cpt_oplist);                                      \
    if (*dest != NULL)        {                                               \
      if (M_CALL_SUB(cpt_oplist, &((*dest)->cpt), 1) == 1)        {           \
        bool combineAlloc = (*dest)->combineAlloc;                            \
@@ -278,73 +281,73 @@ static inline int sharedi_integer_cref(int *p) { return *p; }
      }                                                                       \
      *dest = NULL;                                                           \
    }                                                                         \
-    SHAREDI_CONTRACT(dest, cpt_oplist);                                       \
+    M_SHAR3D_CONTRACT(dest, cpt_oplist);                                      \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _clean)(shared_t dest)                                            \
+  M_F(name, _reset)(shared_t dest)                                            \
  {                                                                           \
    /* NOTE: Clear will also set dest to NULL */                              \
-    M_C(name, _clear)(dest);                                                  \
+    M_F(name, _clear)(dest);                                                  \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _set)(shared_t dest,                                              \
+  M_F(name, _set)(shared_t dest,                                              \
                  const shared_t shared)                                      \
  {                                                                           \
-    SHAREDI_CONTRACT(dest, cpt_oplist);                                       \
-    SHAREDI_CONTRACT(shared, cpt_oplist);                                     \
-    M_C(name, _clear)(dest);                                                  \
-    M_C(name, _init_set)(dest, shared);                                       \
+    M_SHAR3D_CONTRACT(dest, cpt_oplist);                                      \
+    M_SHAR3D_CONTRACT(shared, cpt_oplist);                                    \
+    M_F(name, _clear)(dest);                                                  \
+    M_F(name, _init_set)(dest, shared);                                       \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _init_move)(shared_t dest,                                        \
+  M_F(name, _init_move)(shared_t dest,                                        \
                        shared_t shared)                                      \
  {                                                                           \
-    SHAREDI_CONTRACT(shared, cpt_oplist);                                     \
+    M_SHAR3D_CONTRACT(shared, cpt_oplist);                                    \
    M_ASSERT (dest != NULL && dest != shared);                                \
    *dest = *shared;                                                          \
    *shared = NULL;                                                           \
-    SHAREDI_CONTRACT(dest, cpt_oplist);                                       \
+    M_SHAR3D_CONTRACT(dest, cpt_oplist);                                      \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _move)(shared_t dest,                                             \
+  M_F(name, _move)(shared_t dest,                                             \
                   shared_t shared)                                           \
  {                                                                           \
-    SHAREDI_CONTRACT(dest, cpt_oplist);                                       \
-    SHAREDI_CONTRACT(shared, cpt_oplist);                                     \
+    M_SHAR3D_CONTRACT(dest, cpt_oplist);                                      \
+    M_SHAR3D_CONTRACT(shared, cpt_oplist);                                    \
    M_ASSERT (dest != shared);                                                \
-    M_C(name, _clear)(dest);                                                  \
-    M_C(name, _init_move)(dest, shared);                                      \
+    M_F(name, _clear)(dest);                                                  \
+    M_F(name, _init_move)(dest, shared);                                      \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _swap)(shared_t p1,                                               \
+  M_F(name, _swap)(shared_t p1,                                               \
                   shared_t p2)                                               \
  {                                                                           \
-    SHAREDI_CONTRACT(p1, cpt_oplist);                                         \
-    SHAREDI_CONTRACT(p2, cpt_oplist);                                         \
+    M_SHAR3D_CONTRACT(p1, cpt_oplist);                                        \
+    M_SHAR3D_CONTRACT(p2, cpt_oplist);                                        \
    /* NOTE: SWAP is not atomic */                                            \
-    M_SWAP (struct M_C(name, _s)*, *p1, *p2);                                 \
-    SHAREDI_CONTRACT(p1, cpt_oplist);                                         \
-    SHAREDI_CONTRACT(p2, cpt_oplist);                                         \
+    M_SWAP (struct M_F(name, _s)*, *p1, *p2);                                 \
+    M_SHAR3D_CONTRACT(p1, cpt_oplist);                                        \
+    M_SHAR3D_CONTRACT(p2, cpt_oplist);                                        \
  }                                                                           \
                                                                              \
  static inline bool                                                          \
-  M_C(name, _equal_p)(const shared_t p1,                                      \
+  M_F(name, _equal_p)(const shared_t p1,                                      \
                      const shared_t p2)                                      \
  {                                                                           \
-    SHAREDI_CONTRACT(p1, cpt_oplist);                                         \
-    SHAREDI_CONTRACT(p2, cpt_oplist);                                         \
+    M_SHAR3D_CONTRACT(p1, cpt_oplist);                                        \
+    M_SHAR3D_CONTRACT(p2, cpt_oplist);                                        \
    return *p1 == *p2;                                                        \
  }                                                                           \
                                                                              \
  static inline type const *                                                  \
-  M_C(name, _cref)(const shared_t shared)                                     \
+  M_F(name, _cref)(const shared_t shared)                                     \
  {                                                                           \
-    SHAREDI_CONTRACT(shared, cpt_oplist);                                     \
+    M_SHAR3D_CONTRACT(shared, cpt_oplist);                                    \
    M_ASSERT(*shared != NULL);                                                \
    type *data = (*shared)->data;                                             \
    M_ASSERT (data != NULL);                                                  \
@@ -352,150 +355,157 @@ static inline int sharedi_integer_cref(int *p) { return *p; }
  }                                                                           \
                                                                              \
  static inline type *                                                        \
-  M_C(name, _ref)(shared_t shared)                                            \
+  M_F(name, _ref)(shared_t shared)                                            \
  {                                                                           \
-    SHAREDI_CONTRACT(shared, cpt_oplist);                                     \
+    M_SHAR3D_CONTRACT(shared, cpt_oplist);                                    \
    M_ASSERT(*shared != NULL);                                                \
    type *data = (*shared)->data;                                             \
    M_ASSERT (data != NULL);                                                  \
    return data;                                                              \
  }                                                                           \
-  


-/********************************** SHARED RESOURCE ************************************/
+/********************************** INTERNAL *********************************/

-#define SHAREDI_RESOURCE_CONTRACT(s) do {                                     \
+#define M_SHAR3D_RESOURCE_CONTRACT(s) do {                                    \
    M_ASSERT (s != NULL);                                                     \
    M_ASSERT (s->buffer != NULL);                                             \
  } while (0)

 // deferred
-#define SHAREDI_RESOURCE_DEF_P1(arg) SHAREDI_RESOURCE_DEF_P2 arg
+#define M_SHAR3D_RESOURCE_DEF_P1(arg) M_ID( M_SHAR3D_RESOURCE_DEF_P2 arg )

 /* Validate the oplist before going further */
-#define SHAREDI_RESOURCE_DEF_P2(name, type, oplist, shared_t, it_t)           \
-  M_IF_OPLIST(oplist)(SHAREDI_RESOURCE_DEF_P3, SHAREDI_RESOURCE_DEF_FAILURE)(name, type, oplist, shared_t, it_t)
+#define M_SHAR3D_RESOURCE_DEF_P2(name, type, oplist, shared_t, it_t)          \
+  M_IF_OPLIST(oplist)(M_SHAR3D_RESOURCE_DEF_P3, M_SHAR3D_RESOURCE_DEF_FAILURE)(name, type, oplist, shared_t, it_t)

 /* Stop processing with a compilation failure */
-#define SHAREDI_RESOURCE_DEF_FAILURE(name, type, oplist, shared_t, it_t)      \
+#define M_SHAR3D_RESOURCE_DEF_FAILURE(name, type, oplist, shared_t, it_t)     \
  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(SHARED_RESOURCE_DEF): the given argument is not a valid oplist: " #oplist)

-#define SHAREDI_RESOURCE_DEF_P3(name, type, oplist, shared_t, it_t)           \
+#define M_SHAR3D_RESOURCE_DEF_P3(name, type, oplist, shared_t, it_t)          \
+  M_SHAR3D_RESOURCE_DEF_TYPE(name, type, oplist, shared_t, it_t)              \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_SHAR3D_RESOURCE_DEF_CORE(name, type, oplist, shared_t, it_t)              \
+
+/* Define the types */
+#define M_SHAR3D_RESOURCE_DEF_TYPE(name, type, oplist, shared_t, it_t)        \
                                                                              \
  /* Create an aligned type to avoid false sharing between threads */         \
-  typedef struct M_C(name, _atype_s) {                                        \
+  typedef struct M_F(name, _atype_s) {                                        \
    atomic_uint  cpt;                                                         \
    type         x;                                                           \
    M_CACHELINE_ALIGN(align, type, atomic_uint);                              \
-  } M_C(name, _atype_ct);                                                     \
+  } M_F(name, _atype_ct);                                                     \
                                                                              \
-  typedef struct M_C(name, _s) {                                              \
-    genint_t             core;                                                \
-    M_C(name, _atype_ct) *buffer;                                             \
+  typedef struct M_F(name, _s) {                                              \
+    m_genint_t             core;                                              \
+    M_F(name, _atype_ct) *buffer;                                             \
  } shared_t[1];                                                              \
                                                                              \
-  typedef struct M_C(name, _it_s) {                                           \
+  typedef struct M_F(name, _it_s) {                                           \
    unsigned int idx;                                                         \
-    struct M_C(name, _s) *ref;                                                \
+    struct M_F(name, _s) *ref;                                                \
  } it_t[1];                                                                  \
                                                                              \
  /* Internal Types for oplist */                                             \
-  typedef shared_t M_C(name, _ct);                                            \
-                                                                              \
+  typedef shared_t M_F(name, _ct);                                            \
+
+/* Define the core functions */
+#define M_SHAR3D_RESOURCE_DEF_CORE(name, type, oplist, shared_t, it_t)        \
  static inline void                                                          \
-  M_C(name, _init)(shared_t s, size_t n)                                      \
+  M_F(name, _init)(shared_t s, size_t n)                                      \
  {                                                                           \
    M_ASSERT(s != NULL);                                                      \
    M_ASSERT (n > 0 && n < UINT_MAX);                                         \
-    s->buffer = M_CALL_REALLOC(oplist, M_C(name, _atype_ct), NULL, n);        \
-    if (M_UNLIKELY (s->buffer == NULL)) {                                     \
-      M_MEMORY_FULL(sizeof(M_C(name, _atype_ct)) * n);                        \
+    s->buffer = M_CALL_REALLOC(oplist, M_F(name, _atype_ct), NULL, n);        \
+    if (M_UNLIKELY_NOMEM (s->buffer == NULL)) {                               \
+      M_MEMORY_FULL(sizeof(M_F(name, _atype_ct)) * n);                        \
      return;                                                                 \
    }                                                                         \
    for(size_t i = 0; i < n; i++) {                                           \
      M_CALL_INIT(oplist, s->buffer[i].x);                                    \
      atomic_init (&s->buffer[i].cpt, 0U);                                    \
    }                                                                         \
-    genint_init(s->core, (unsigned int) n);                                   \
-    SHAREDI_RESOURCE_CONTRACT(s);                                             \
+    m_genint_init(s->core, (unsigned int) n);                                 \
+    M_SHAR3D_RESOURCE_CONTRACT(s);                                            \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _clear)(shared_t s)                                               \
+  M_F(name, _clear)(shared_t s)                                               \
  {                                                                           \
-    SHAREDI_RESOURCE_CONTRACT(s);                                             \
-    size_t n = genint_size(s->core);                                          \
+    M_SHAR3D_RESOURCE_CONTRACT(s);                                            \
+    size_t n = m_genint_size(s->core);                                        \
    for(size_t i = 0; i < n; i++) {                                           \
      M_CALL_CLEAR(oplist, s->buffer[i].x);                                   \
    }                                                                         \
    M_CALL_FREE(oplist, s->buffer);                                           \
    s->buffer = NULL;                                                         \
-    genint_clear(s->core);                                                    \
+    m_genint_clear(s->core);                                                  \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _it)(it_t it, shared_t s)                                         \
+  M_F(name, _it)(it_t it, shared_t s)                                         \
  {                                                                           \
-    SHAREDI_RESOURCE_CONTRACT(s);                                             \
+    M_SHAR3D_RESOURCE_CONTRACT(s);                                            \
    M_ASSERT (it != NULL);                                                    \
-    unsigned int idx = genint_pop(s->core);                                   \
+    unsigned int idx = m_genint_pop(s->core);                                 \
    it->idx = idx;                                                            \
    it->ref = s;                                                              \
-    if (M_LIKELY (idx != GENINT_ERROR)) {                                     \
+    if (M_LIKELY (idx != M_GENINT_ERROR)) {                                   \
      M_ASSERT(atomic_load(&s->buffer[idx].cpt) == 0);                        \
      atomic_store(&s->buffer[idx].cpt, 1U);                                  \
    }                                                                         \
  }                                                                           \
                                                                              \
  static inline bool                                                          \
-  M_C(name, _end_p)(it_t it)                                                  \
+  M_F(name, _end_p)(it_t it)                                                  \
  {                                                                           \
    M_ASSERT (it != NULL);                                                    \
-    return it->idx == GENINT_ERROR;                                           \
+    return it->idx == M_GENINT_ERROR;                                         \
  }                                                                           \
                                                                              \
  static inline type *                                                        \
-  M_C(name, _ref)(it_t it)                                                    \
+  M_F(name, _ref)(it_t it)                                                    \
  {                                                                           \
-    M_ASSERT (it != NULL && it->ref != NULL && it->idx != GENINT_ERROR);      \
-    SHAREDI_RESOURCE_CONTRACT(it->ref);                                       \
+    M_ASSERT (it != NULL && it->ref != NULL && it->idx != M_GENINT_ERROR);    \
+    M_SHAR3D_RESOURCE_CONTRACT(it->ref);                                      \
    return &it->ref->buffer[it->idx].x;                                       \
  }                                                                           \
                                                                              \
  static inline type const *                                                  \
-  M_C(name, _cref)(it_t it)                                                   \
+  M_F(name, _cref)(it_t it)                                                   \
  {                                                                           \
-    M_ASSERT (it != NULL && it->ref != NULL && it->idx != GENINT_ERROR);      \
-    SHAREDI_RESOURCE_CONTRACT(it->ref);                                       \
+    M_ASSERT (it != NULL && it->ref != NULL && it->idx != M_GENINT_ERROR);    \
+    M_SHAR3D_RESOURCE_CONTRACT(it->ref);                                      \
    return M_CONST_CAST (type, &it->ref->buffer[it->idx].x);                  \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _end)(it_t it, shared_t s)                                        \
+  M_F(name, _end)(it_t it, shared_t s)                                        \
  {                                                                           \
-    SHAREDI_RESOURCE_CONTRACT(s);                                             \
+    M_SHAR3D_RESOURCE_CONTRACT(s);                                            \
    M_ASSERT (it != NULL);                                                    \
    M_ASSERT (it->ref == s);                                                  \
    unsigned int idx = it->idx;                                               \
-    if (M_LIKELY (idx != GENINT_ERROR)) {                                     \
+    if (M_LIKELY (idx != M_GENINT_ERROR)) {                                   \
      unsigned int c = atomic_fetch_sub (&it->ref->buffer[idx].cpt, 1U);      \
      if (c == 1) {                                                           \
-        genint_push(it->ref->core, idx);                                      \
+        m_genint_push(it->ref->core, idx);                                    \
      }                                                                       \
-      it->idx = GENINT_ERROR;                                                 \
+      it->idx = M_GENINT_ERROR;                                               \
    }                                                                         \
  }                                                                           \
                                                                              \
  static inline void                                                          \
-  M_C(name, _it_set)(it_t itd, it_t its)                                      \
+  M_F(name, _it_set)(it_t itd, it_t its)                                      \
  {                                                                           \
    M_ASSERT (itd != NULL && its != NULL);                                    \
-    SHAREDI_RESOURCE_CONTRACT(its->ref);                                      \
+    M_SHAR3D_RESOURCE_CONTRACT(its->ref);                                     \
    itd->ref = its->ref;                                                      \
    unsigned int idx = its->idx;                                              \
    itd->idx = idx;                                                           \
-    if (M_LIKELY (idx != GENINT_ERROR)) {                                     \
+    if (M_LIKELY (idx != M_GENINT_ERROR)) {                                   \
      unsigned int c = atomic_fetch_add(&itd->ref->buffer[idx].cpt, 1U);      \
      M_ASSERT (c >= 1);                                                      \
    }                                                                         \
@@ -503,4 +513,16 @@ static inline int sharedi_integer_cref(int *p) { return *p; }

 M_END_PROTECTED_CODE

+/********************************** INTERNAL *********************************/
+
+#if M_USE_SMALL_NAME
+#define SHARED_PTR_OPLIST M_SHARED_PTR_OPLIST
+#define SHARED_PTR_DEF M_SHARED_PTR_DEF
+#define SHARED_PTR_DEF_AS M_SHARED_PTR_DEF_AS
+#define SHARED_PTR_RELAXED_DEF M_SHARED_PTR_RELAXED_DEF
+#define SHARED_PTR_RELAXED_DEF_AS M_SHARED_PTR_RELAXED_DEF_AS
+#define SHARED_RESOURCE_DEF M_SHARED_RESOURCE_DEF
+#define SHARED_RESOURCE_DEF_AS M_SHARED_RESOURCE_DEF_AS
+#endif
+
 #endif
@@ -0,0 +1,529 @@
+/*
+ * M*LIB - Thin Mutex & Thread wrapper
+ *
+ * Copyright (c) 2017-2023, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_MUTEX_H
+#define MSTARLIB_MUTEX_H
+
+/* Auto-detect the thread backend to use if the user has not override it */
+#ifndef M_USE_THREAD_BACKEND
+# if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L                 \
+  && !defined(__STDC_NO_THREADS__)
+#  define M_USE_THREAD_BACKEND 1
+# elif defined(WIN32) || defined(_WIN32) || defined(__CYGWIN__)
+#  define M_USE_THREAD_BACKEND 2
+# else
+#  define M_USE_THREAD_BACKEND 3
+# endif
+#endif
+
+
+/****************************** C11 version ********************************/
+#if M_USE_THREAD_BACKEND == 1
+
+#include <threads.h>
+#include <assert.h>
+#include <stdbool.h>
+#include "m-core.h"
+
+M_BEGIN_PROTECTED_CODE
+
+/* Define a mutex type based on C11 definition */
+typedef mtx_t                  m_mutex_t[1];
+
+/* Define a condition variable type based on C11 definition */
+typedef cnd_t                  m_cond_t[1];
+
+/* Define a thread type based on C11 definition */
+typedef thrd_t                 m_thread_t[1];
+
+/* Initialize the mutex (constructor) */
+static inline void m_mutex_init(m_mutex_t m)
+{
+  int rc = mtx_init(m, mtx_plain);
+  // Abort program in case of initialization failure
+  // There is really nothing else to do if a mutex cannot be constructed
+  M_ASSERT_INIT (rc == thrd_success, "mutex");
+}
+
+/* Clear the mutex (destructor) */
+static inline void m_mutex_clear(m_mutex_t m)
+{
+  mtx_destroy(m);
+}
+
+/* Lock the mutex */
+static inline void m_mutex_lock(m_mutex_t m)
+{
+  mtx_lock(m);
+}
+
+/* Unlock the mutex */
+static inline void m_mutex_unlock(m_mutex_t m)
+{
+  mtx_unlock(m);
+}
+
+/* Initialize the condition variable (constructor) */
+static inline void m_cond_init(m_cond_t c)
+{
+  int rc = cnd_init(c);
+  // Abort program in case of initialization failure
+  // There is really nothing else to do if the object cannot be constructed
+  M_ASSERT_INIT (rc == thrd_success, "conditional variable");
+}
+
+/* Clear the condition variable (destructor) */
+static inline void m_cond_clear(m_cond_t c)
+{
+  cnd_destroy(c);
+}
+
+/* Signal the condition variable to at least one waiting thread */
+static inline void m_cond_signal(m_cond_t c)
+{
+  cnd_signal(c);
+}
+
+/* Signal the condition variable to all waiting threads */
+static inline void m_cond_broadcast(m_cond_t c)
+{
+  cnd_broadcast(c);
+}
+
+/* Wait for signaling the condition variable by another thread */
+static inline void m_cond_wait(m_cond_t c, m_mutex_t m)
+{
+  cnd_wait(c, m);
+}
+
+/* Create the thread (constructor) and start it */
+static inline void m_thread_create(m_thread_t t, void (*func)(void*), void* arg)
+{
+  int rc = thrd_create(t, (int(*)(void*))(void(*)(void))func, arg);
+  // Abort program in case of initialization failure
+  M_ASSERT_INIT (rc == thrd_success, "thread");
+}
+
+/* Wait for the thread to terminate and destroy it (destructor) */
+static inline void m_thread_join(m_thread_t t)
+{
+  int rc = thrd_join(*t, NULL);
+  M_ASSERT (rc == thrd_success);
+  // Avoid warning about variable unused.
+  (void) rc;
+}
+
+/* The thread has nothing meaningfull to do.
+   Inform the OS to let other threads be scheduled */
+static inline void m_thread_yield(void)
+{
+  thrd_yield();
+}
+
+/* Sleep the thread for at least usec microseconds.
+   Return true if the sleep was successful */
+static inline bool m_thread_sleep(unsigned long long usec)
+{
+  struct timespec tv;
+  tv.tv_sec = (long) (usec / 1000000ULL);
+  tv.tv_nsec = (long) ((usec % 1000000ULL) * 1000UL);
+  int retval = thrd_sleep(&tv, NULL);
+  return retval == 0;
+}
+
+// a helper structure for m_once_call
+typedef once_flag                     m_once_t[1];
+
+// Initial value for m_once_t
+#define M_ONCE_INIT_VALUE            { ONCE_FLAG_INIT }
+
+// Call the function exactly once
+static inline void m_once_call(m_once_t o, void (*func)(void))
+{
+  call_once(o,func);
+}
+
+// Attribute to use to allocate a global variable to a thread.
+#define M_THREAD_ATTR _Thread_local
+
+M_END_PROTECTED_CODE
+
+
+/****************************** WIN32 version ******************************/
+#elif M_USE_THREAD_BACKEND == 2
+
+/* CLANG provides some useless and wrong warnings:
+ * - _WIN32_WINNT starts with '_' which is reserved by the standard
+ * as per the MSVC compiler, it is needed to be defined by the user
+ * to define which version of windows it want to be compatible with.
+ * - windows.h may be different than the case used by the file sytem
+ * there is however no normalized case.
+ *
+ * So, theses warnings have to be ignored and are disabled.
+ *
+ * We cannot add theses warnings in M_BEGIN_PROTECTED_CODE
+ * as they need to be disabled **BEFORE** including any system header
+ * and m-core includes some system headers.
+ * So we need to disable them explictly here.
+ */
+#if defined(__clang__) && __clang_major__ >= 4
+  _Pragma("clang diagnostic push")
+  _Pragma("clang diagnostic ignored \"-Wreserved-id-macro\"")
+  _Pragma("clang diagnostic ignored \"-Wnonportable-system-include-path\"")
+#endif
+
+/* CriticalSection & ConditionVariable are available from Windows Vista */
+#ifndef WINVER
+#define WINVER        _WIN32_WINNT_VISTA
+#endif
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT  _WIN32_WINNT_VISTA
+#endif
+
+/* Include system headers */
+#include <windows.h>
+#include <assert.h>
+#include <stdbool.h>
+#include "m-core.h"
+
+#if defined(__clang__) && __clang_major__ >= 4
+  _Pragma("clang diagnostic pop")
+#endif
+
+M_BEGIN_PROTECTED_CODE
+
+/* Define a thread type based on WINDOWS definition */
+typedef HANDLE                 m_thread_t[1];
+
+/* Define a mutex type based on WINDOWS definition */
+typedef CRITICAL_SECTION       m_mutex_t[1];
+
+/* Define a condition variable type based on WINDOWS definition */
+typedef CONDITION_VARIABLE     m_cond_t[1];
+
+/* Initialize a mutex (Constructor)*/
+static inline void m_mutex_init(m_mutex_t m)
+{
+  InitializeCriticalSection(m);
+}
+
+/* Clear a mutex (destructor) */
+static inline void m_mutex_clear(m_mutex_t m)
+{
+  DeleteCriticalSection(m);
+}
+
+/* Lock a mutex */
+static inline void m_mutex_lock(m_mutex_t m)
+{
+  EnterCriticalSection(m);
+}
+
+/* Unlock a mutex */
+static inline void m_mutex_unlock(m_mutex_t m)
+{
+  LeaveCriticalSection(m);
+}
+
+/* Initialize a condition variable (constructor) */
+static inline void m_cond_init(m_cond_t c)
+{
+  InitializeConditionVariable(c);
+}
+
+/* Clear a condition variable (destructor) */
+static inline void m_cond_clear(m_cond_t c)
+{
+  (void) c; // There is no destructor for this object.
+}
+
+/* Signal a condition variable to at least one waiting thread */
+static inline void m_cond_signal(m_cond_t c)
+{
+  WakeConditionVariable(c);
+}
+
+/* Signal a condition variable to all waiting threads */
+static inline void m_cond_broadcast(m_cond_t c)
+{
+  WakeAllConditionVariable(c);
+}
+
+/* Wait for a condition variable */
+static inline void m_cond_wait(m_cond_t c, m_mutex_t m)
+{
+  SleepConditionVariableCS(c, m, INFINITE);
+}
+
+/* Create a thread (constructor) and start it */
+static inline void m_thread_create(m_thread_t t, void (*func)(void*), void *arg)
+{
+  *t = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) (uintptr_t) func, arg, 0, NULL);
+  M_ASSERT_INIT (*t != NULL, "thread");
+}
+
+/* Wait for the thread to terminate and destroy it (destructor) */
+static inline void m_thread_join(m_thread_t t)
+{
+  DWORD dwWaitResult = WaitForSingleObject(*t, INFINITE);
+  (void) dwWaitResult;
+  M_ASSERT (dwWaitResult == WAIT_OBJECT_0);
+  CloseHandle(*t);
+}
+
+/* The thread has nothing meaningfull to do.
+   Inform the OS to let other threads be scheduled */
+static inline void m_thread_yield(void)
+{
+  Sleep(0);
+}
+
+/* Sleep the thread for at least usec microseconds
+   Return true if the sleep was successful */
+static inline bool m_thread_sleep(unsigned long long usec)
+{
+  LARGE_INTEGER ft;
+  M_ASSERT (usec <= LLONG_MAX);
+  ft.QuadPart = -(10LL*(long long) usec);
+  HANDLE hd = CreateWaitableTimer(NULL, TRUE, NULL);
+  M_ASSERT_INIT (hd != NULL, "timer");
+  SetWaitableTimer(hd, &ft, 0, NULL, NULL, 0);
+  DWORD dwWaitResult = WaitForSingleObject(hd, INFINITE);
+  CloseHandle(hd);
+  return dwWaitResult == WAIT_OBJECT_0;
+}
+
+
+typedef INIT_ONCE                     m_once_t[1];
+#define M_ONCE_INIT_VALUE            { INIT_ONCE_STATIC_INIT }
+static inline BOOL CALLBACK m_once_callback( PINIT_ONCE InitOnce, PVOID Parameter, PVOID *lpContext)
+{
+    void (*func)(void);
+    (void) InitOnce;
+    (void) lpContext;
+    func = (void (*)(void))(uintptr_t) Parameter;
+    (*func)();
+    return TRUE;
+}
+static inline void m_once_call(m_once_t o, void (*func)(void))
+{
+  InitOnceExecuteOnce(o, m_once_callback, (void*)(intptr_t)func, NULL);
+}
+
+#if defined(_MSC_VER)
+// Attribute to use to allocate a global variable to a thread (MSVC def).
+# define M_THREAD_ATTR __declspec( thread )
+#else
+// Attribute to use to allocate a global variable to a thread (GCC def).
+# define M_THREAD_ATTR __thread
+#endif
+
+M_END_PROTECTED_CODE
+
+
+/**************************** PTHREAD version ******************************/
+#else
+
+#include <pthread.h>
+#ifdef _POSIX_PRIORITY_SCHEDULING
+#include <sched.h>
+#endif
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <assert.h>
+#include <stdbool.h>
+#include "m-core.h"
+
+M_BEGIN_PROTECTED_CODE
+
+/* Define a mutex type based on PTHREAD definition */
+typedef pthread_mutex_t        m_mutex_t[1];
+
+/* Define a condition variable type based on PTHREAD definition */
+typedef pthread_cond_t         m_cond_t[1];
+
+/* Define a thread type based on PTHREAD definition */
+typedef pthread_t              m_thread_t[1];
+
+/* Initialize the mutex (constructor) */
+static inline void m_mutex_init(m_mutex_t m)
+{
+  int _rc = pthread_mutex_init(m, NULL);
+  // Abort program in case of initialization failure
+  // There is really nothing else to do if a mutex cannot be constructed
+  M_ASSERT_INIT (_rc == 0, "mutex");
+}
+
+/* Clear the mutex (destructor) */
+static inline void m_mutex_clear(m_mutex_t m)
+{
+  pthread_mutex_destroy(m);
+}
+
+/* Lock the mutex */
+static inline void m_mutex_lock(m_mutex_t m)
+{
+  pthread_mutex_lock(m);
+}
+
+/* Unlock the mutex */
+static inline void m_mutex_unlock(m_mutex_t m)
+{
+  pthread_mutex_unlock(m);
+}
+
+/* Lazy lock initialization */
+#define M_MUTEXI_INIT_VALUE    { PTHREAD_MUTEX_INITIALIZER }
+
+/* Internal function compatible with lazy lock */
+static inline void m_mutexi_lazy_lock(m_mutex_t m)
+{
+  pthread_mutex_lock(m);
+}
+
+/* Initialize the condition variable (constructor) */
+static inline void m_cond_init(m_cond_t c)
+{
+  int _rc = pthread_cond_init(c, NULL);
+  // Abort program in case of initialization failure
+  // There is really nothing else to do if a mutex cannot be constructed
+  M_ASSERT_INIT (_rc == 0, "conditional variable");
+}
+
+/* Clear the condition variable (destructor) */
+static inline void m_cond_clear(m_cond_t c)
+{
+  pthread_cond_destroy(c);
+}
+
+/* Signal a condition variable to at least a waiting thread */
+static inline void m_cond_signal(m_cond_t c)
+{
+  pthread_cond_signal(c);
+}
+
+/* Signal a condition variable to all waiting threads */
+static inline void m_cond_broadcast(m_cond_t c)
+{
+  pthread_cond_broadcast(c);
+}
+
+/* Waiting for a condition variable */
+static inline void m_cond_wait(m_cond_t c, m_mutex_t m)
+{
+  pthread_cond_wait(c, m);
+}
+
+/* Create a thread (constructor) and start it */
+static inline void m_thread_create(m_thread_t t, void (*func)(void*), void *arg)
+{
+  int _rc = pthread_create(t, NULL, (void*(*)(void*))(void(*)(void))func, arg);
+  M_ASSERT_INIT (_rc == 0, "thread");
+}
+
+/* Wait for the thread to terminate and destroy it (destructor) */
+static inline void m_thread_join(m_thread_t t)
+{
+  int _rc = pthread_join(*t, NULL);
+  (void)_rc; // Avoid warning about variable unused.
+  M_ASSERT (_rc == 0);
+}
+
+/* The thread has nothing meaningfull to do.
+   Inform the OS to let other threads be scheduled */
+static inline void m_thread_yield(void)
+{
+#ifdef _POSIX_PRIORITY_SCHEDULING
+  sched_yield();
+#endif
+}
+
+/* Sleep for at least usec microseconds
+   Return true if the sleep was successful */
+static inline bool m_thread_sleep(unsigned long long usec)
+{
+  struct timeval tv;
+  /* We don't want to use usleep or nanosleep so that
+     we remain compatible with strict C99 build */
+  tv.tv_sec = (time_t) (usec / 1000000ULL);
+  tv.tv_usec = (suseconds_t) (usec % 1000000ULL);
+  int retval = select(1, NULL, NULL, NULL, &tv);
+  return retval == 0;
+}
+
+typedef pthread_once_t                m_once_t[1];
+#define M_ONCE_INIT_VALUE            { PTHREAD_ONCE_INIT }
+static inline void m_once_call(m_once_t o, void (*func)(void))
+{
+  pthread_once(o,func);
+}
+
+#if defined(__GNUC__)
+# define M_THREAD_ATTR __thread
+#else
+# define M_THREAD_ATTR  /* Not supported */
+#endif
+
+M_END_PROTECTED_CODE
+
+#endif
+
+// TODO: Obsolete M_LOCK macro.
+
+/* M_LOCK macro. Allow simple locking encapsulation.
+   USAGE:
+    static M_LOCK_DECL(name);
+    int f(int n) {
+      M_LOCK(name) {
+        // Exclusive access
+      }
+    }
+*/
+/* NOTE: Either using direct support by the OS (WIN32/PTHREAD)
+   or using C11's ONCE mechanism */
+#ifdef M_MUTEXI_INIT_VALUE
+# define M_LOCK_DECL(name) m_mutex_t name = M_MUTEXI_INIT_VALUE
+# define M_LOCK(name)                                                         \
+  M_LOCKI_DO(name, M_C(local_cont_, __LINE__), m_mutexi_lazy_lock, m_mutex_unlock)
+#else
+# define M_LOCK_DECL(name)                                                    \
+  m_mutex_t name;                                                             \
+  static void M_C(m_mutex_init_, name)(void) {                                \
+    m_mutex_init(name);                                                       \
+  }                                                                           \
+  m_once_t M_C(m_once_, name) = M_ONCE_INIT_VALUE
+# define M_LOCKI_BY_ONCE(name)                                                \
+  (m_once_call(M_C(m_once_, name), M_C(m_mutex_init_, name)),                 \
+   m_mutex_lock(name), (void) 0 )
+# define M_LOCK(name)                                                         \
+  M_LOCKI_DO(name, M_C(local_cont_, __LINE__), M_LOCKI_BY_ONCE, m_mutex_unlock)
+#endif
+
+#define M_LOCKI_DO(name, cont, lock_func, unlock_func)                        \
+  for(bool cont = true                                                        \
+        ; cont && (lock_func (name), true);                                   \
+      (unlock_func (name), cont = false))
+
+#endif
@@ -0,0 +1,576 @@
+/*
+ * M*LIB - try / catch mechanism for M*LIB
+ *
+ * Copyright (c) 2017-2023, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_TRY_H
+#define MSTARLIB_TRY_H
+
+#include "m-core.h"
+#include "m-thread.h"
+
+/*
+ * Select mechanism to use for support of RAII and exception,
+ * so that for each variables defined in M_LET,
+ * their destructor is still called on throwing exceptions.
+ * It is either the C++ try,
+ * it uses a GCC or CLANG extension,
+ * or the standard c compliant way (much slower).
+ */
+#ifndef M_USE_TRY_MECHANISM
+# if defined(__has_extension)
+#  if __has_extension(blocks)
+#   define M_TRY_CLANG_BLOCKS
+#  endif
+# endif
+# if defined(__cplusplus)
+#  define M_USE_TRY_MECHANISM 1
+# elif defined(M_TRY_CLANG_BLOCKS)
+#  define M_USE_TRY_MECHANISM 2
+# elif defined(__GNUC__) && !defined(__clang__)
+#  define M_USE_TRY_MECHANISM 3
+# else
+#  define M_USE_TRY_MECHANISM 4
+# endif
+#endif
+
+
+/*
+ * Start a protected section of code 'name' where all exceptions are catched
+ * by the associated CATCH section.
+ */
+#define M_TRY(name)                                                           \
+  M_TRY_B( M_C(m_try_bool_, name), M_C(m_try_buf_, name), name)
+
+
+/*
+ * Catch an exception associated to the TRY block 'name' that matches the given error_code
+ * If error_code is 0, it catches all error codes.
+ * error code shall be a constant positive integer.
+ */
+#define M_CATCH(name, error_code) M_CATCH_B(name, error_code)
+
+
+/*
+ * Throw an exception to the upper try block
+ * error_code shall be the first argument. 
+ * Other arguments are integers or pointers stored in the exception.
+ * error code shall be a constant positive integer.
+ */
+#define M_THROW(...) do {                                                     \
+    M_STATIC_ASSERT(M_RET_ARG1 (__VA_ARGS__) != 0,                            \
+                    M_LIB_NOT_A_CONSTANT_NON_NULL_INTEGER,                    \
+                    "The error code shall be a non null constant");           \
+    M_STATIC_ASSERT(M_NARGS (__VA_ARGS__) <= 1+M_USE_MAX_CONTEXT,             \
+                    M_LIB_TOO_MANY_ARGUMENTS,                                 \
+                    "There are too many arguments for an exception.");        \
+    M_IF_NARGS_EQ1(__VA_ARGS__)(M_THROW_1, M_THROW_N)(__VA_ARGS__);           \
+  } while (0)
+
+
+/*
+ * Size of the context data that are stored in an exception.
+ */
+#ifndef M_USE_MAX_CONTEXT
+#define M_USE_MAX_CONTEXT 10
+#endif
+
+/*
+ * The exception itself.
+ *
+ * It is POD data where every fields can be used by the user.
+ * It has been decided to have only one exception to simplify error
+ * code, and because :
+ * - using generic types is much hard in C to do (still possible)
+ * - it will make exceptions more usable for errors which should not 
+ * be handled by exceptions.
+ *
+ * For C++, we need to encapsulate it in a template,
+ * so that it can be a unique type for each error code,
+ * which is needed for the catch mechanism.
+ * We all need to override the operator -> since the C++
+ * throw the type and catch the type, whereas the C back-end
+ * throw the type and catch a pointer to the type:
+ * within the catch block you are supposed to use the arrow
+ * operator to test the content of the exception.
+ */
+#if M_USE_TRY_MECHANISM == 1
+namespace m_lib {
+template <unsigned int N>
+#endif
+struct m_exception_s {
+  unsigned   error_code;                   // Error code
+  unsigned short line;                     // Line number where the error was detected
+  unsigned short num;                      // Number of entries in 'context' table
+  const char *filename;                    // filename  where the error was detected
+  intptr_t    context[M_USE_MAX_CONTEXT];  // Specific context of the exception
+#ifdef __cplusplus
+  m_exception_s<N> *operator->() { return this; }
+#endif
+};
+#if M_USE_TRY_MECHANISM == 1
+}
+#endif
+
+// Typical Error codes (TODO: add more classic?)
+#define M_ERROR_MEMORY  1
+#define M_ERROR_ACCESS  2
+#define M_ERROR_BUSY    3
+
+/*
+ * Define all global needed by the try mechanism with a
+ * thread attribute. It needs to be defined once in all the program
+ */
+#define M_TRY_DEF_ONCE() M_TRY_DEF_ONCE_B()
+
+
+/*
+ * Re-throw the last exception
+ * It shall be done in a CATCH block.
+ */
+#define M_RETHROW() m_rethrow()
+
+
+/*****************************************************************************/
+/********************************** INTERNAL *********************************/
+/*****************************************************************************/
+
+/*
+ * Define the C++ back-end.
+ * It is fully different from C back-end as it reuses the classic try of the C++.
+ * Surprisingly it has more constraints than the C one.
+ * error_code shall be a positive, constant integer.
+ * the catch all block shall always be the last block.
+ * at least catch block is mandatory for each try block.
+ * Note that theses constraints are meaningless in real code,
+ * and simply good behavior.
+ * Notice also that you won't have any access to the exception for a catch all error.
+ */
+#if M_USE_TRY_MECHANISM == 1
+
+// Define the CATCH block. If error_code is 0, it shall catch all errors.
+// NOTE: It will even catch non M*LIB errors.
+#define M_CATCH_B(name, error_code)                                           \
+  M_IF(M_BOOL(error_code))                                                    \
+  (catch (m_lib::m_exception_s<error_code> &name), catch (...))
+
+// No global to define in C++
+#define M_TRY_DEF_ONCE_B()   /* Nothing to do */
+
+// Reuse the try keyword of the C++
+#define M_TRY_B(cont, buf, exception)                                         \
+  try
+
+// Reuse the throw keyword of the C++
+// by throwing the type m_lib::m_exception_s<error_code>
+#define M_THROW_1(error_code)                                                 \
+  throw m_lib::m_exception_s<error_code>{ error_code, __LINE__, 0, __FILE__, { 0 } }
+
+// Reuse the throw keyword of the C++
+// by throwing the type m_lib::m_exception_s<error_code>
+#define M_THROW_N(error_code, ...)                                            \
+  throw m_lib::m_exception_s<error_code>{ error_code, __LINE__,               \
+      M_NARGS(__VA_ARGS__), __FILE__, { __VA_ARGS__ } }
+
+// Nothing to inject for a pre initialization of a M*LIB object
+#define M_LET_TRY_INJECT_PRE_B(cont, oplist, name) /* Nothing to do */
+
+// Code to inject for a post initialization of a M*LIB object
+// We create a C++ object with a destructor that will call the CLEAR operator of the M*LIB object
+// by using a lambda function.
+// If the CLEAR operator is called naturally, we disable the destructor of the C++ object.
+#define M_LET_TRY_INJECT_POST_B(cont, oplist, name)                           \
+  for(m_lib::m_regclear M_C(m_try_regclear_, name){[&](void) { M_CALL_CLEAR(oplist, name); } } \
+        ; cont ; M_C(m_try_regclear_, name).disable() )
+
+// M_DEFER Injection / pre initialization
+#define M_DEFER_TRY_INJECT_PRE_B(cont, ...) /* Nothing to do */
+
+// M_DEFER Injection / post initialization
+// Register the stack frame and tests for the longjmp.
+// In which case call the 'clear' operations (...), unstack the error list and rethrow the error.
+#define M_DEFER_TRY_INJECT_POST_B(cont, ...)                                  \
+  for(m_lib::m_regclear M_C(m_try_regclear_, cont){[&](void) { __VA_ARGS__; } } \
+        ; cont ; M_C(m_try_regclear_, cont).disable() )
+
+// Definition of the C++ object wrapper
+// The registered function is called by the destructor,
+// except if the disable function has been called.
+#include <functional>
+namespace m_lib {
+  class m_regclear {
+    std::function<void(void)> function;
+    bool done;
+  public:
+    inline m_regclear(const std::function<void(void)> &f) : function{f}, done{false} { }
+    inline void disable(void) { done = true; }
+    inline ~m_regclear() { if (done == false) { function(); done = true; } }
+  };
+}
+
+// Rethrow is simply throw without any argument 
+#define m_rethrow() throw
+
+
+/*****************************************************************************/
+
+/* The C back-end. 
+ * It is fully different from the C++ back-end and is based on setjmp/lonjmp
+ * (classic implementation).
+ * The main difficulty is the mechanism to register the CLEAR operators
+ * to call when throwing an exception.
+ * Contrary to the C++ back-end, it is not cost-free as it adds some 
+ * instructions to the normal behavior of the program.
+ */
+#else
+
+#if (M_USE_TRY_MECHANISM == 3)
+// Use of builtin setjmp / longjmp for GCC
+// There are at least twice faster at worst, and reduce stack consumption
+// See https://gcc.gnu.org/onlinedocs/gcc/Nonlocal-Gotos.html
+// CLANG doesn't support these builtins officialy (https://groups.google.com/g/llvm-dev/c/9QgfdW23K8M)
+#define m_try_setjmp(x)     __builtin_setjmp(x)
+#define m_try_longjmp(x,v)  __builtin_longjmp(x, v)
+typedef intptr_t           m_try_jmp_buf[5];
+#define m_try_jmp_buf      m_try_jmp_buf
+#else
+// C compliant setjmp
+#include <setjmp.h>
+#define m_try_setjmp(x)     setjmp(x)
+#define m_try_longjmp(x,v)  longjmp(x, v)
+#define m_try_jmp_buf       jmp_buf
+#endif
+
+// Define the CATCH block associated to the 'name' TRY to catch the exception
+// associated to 'error_code' and provide 'name' as a pointer to the exception
+// if the exception matches the error code.
+// If error code is 0, it matches all errors.
+#define M_CATCH_B(name, error_code)                                           \
+  else if (m_catch( M_C(m_try_buf_, name), (error_code), &name))
+
+// Define the operator to define nested functions (GCC) or blocks (CLANG)
+#if M_USE_TRY_MECHANISM == 2
+# define M_TRY_FUNC_OPERATOR ^
+#else
+# define M_TRY_FUNC_OPERATOR *
+#endif
+
+// Define the linked structure used to identify what is present in the C stack.
+// We create for each M_TRY and each M_LET a new node in the stack that represents
+// this point in the stack frame. Each nodes are linked together, so that we can
+// analyze the stack frame on exception.
+typedef struct m_try_s {
+  enum { M_STATE_TRY, M_STATE_EXCEPTION_IN_PROGRESS, M_STATE_EXCEPTION_CATCHED,
+         M_STATE_CLEAR_JMPBUF, M_STATE_CLEAR_CB } kind;
+  struct m_try_s *next;
+  union {
+    m_try_jmp_buf buf;
+    struct { void (M_TRY_FUNC_OPERATOR func)(void*); void *data; } clear;
+  } data;
+} m_try_t[1];
+
+// Define the TRY block.
+// Classic usage of the for trick to push destructor on the exit path.
+#define M_TRY_B(cont, buf, exception)                                         \
+ for(bool cont = true ; cont ; cont = false)                                  \
+   for(m_try_t buf ; cont ; m_try_clear(buf), cont = false )                  \
+     for(const struct m_exception_s *exception = NULL; cont; cont = false, exception = exception) \
+       if (m_try_init(buf))
+
+// Throw the error code
+#define M_THROW_1(error_code)                                                 \
+  m_throw( &(const struct m_exception_s) { error_code, __LINE__, 0, __FILE__, { 0 } } )
+
+// Throw the error code
+#define M_THROW_N(error_code, ...)                                            \
+  m_throw( &(const struct m_exception_s) { error_code, __LINE__, M_NARGS(__VA_ARGS__), __FILE__, \
+        { __VA_ARGS__ } } )
+
+// Copy an exception to another.
+static inline void
+m_exception_set(struct m_exception_s *out, const struct m_exception_s *in)
+{
+  if (in != out) {
+    memcpy(out, in, sizeof *out);
+  }
+}
+
+// The global thread attribute variables and functions.
+extern M_THREAD_ATTR struct m_try_s *m_global_error_list;
+extern M_THREAD_ATTR struct m_exception_s m_global_exception;
+extern M_ATTR_NO_RETURN M_ATTR_COLD_FUNCTION void m_throw(const struct m_exception_s *exception);
+
+// Macro to add once in one source file to define theses global:
+#define M_TRY_DEF_ONCE_B()                                                    \
+  M_THREAD_ATTR struct m_try_s *m_global_error_list;                          \
+  M_THREAD_ATTR struct m_exception_s m_global_exception;                      \
+                                                                              \
+  /* Throw the given exception                                                \
+     This function should be rarely called. */                                \
+  M_ATTR_NO_RETURN M_ATTR_COLD_FUNCTION void                                  \
+  m_throw(const struct m_exception_s *exception)                              \
+  {                                                                           \
+    /* Analyze the error list to see what has been registered */              \
+    struct m_try_s *e = m_global_error_list;                                  \
+    while (e != NULL) {                                                       \
+      /* A CLEAR operator has been registered: call it */                     \
+      if (e->kind == M_STATE_CLEAR_CB) {                                      \
+        e->data.clear.func(e->data.clear.data);                               \
+      }                                                                       \
+      else {                                                                  \
+        /* A JUMP command has been registered.                                \
+         * Either due to the M_TRY block or                                   \
+         * because of the jump to the CLEAR operator of the object to clear. */ \
+        M_ASSERT(e->kind == M_STATE_TRY || e->kind == M_STATE_CLEAR_JMPBUF);  \
+        /* If the exception is already m_global_exception, it won't be copied */ \
+        m_exception_set(&m_global_exception, exception);                      \
+        e->kind = M_STATE_EXCEPTION_IN_PROGRESS;                              \
+        m_global_error_list = e;                                              \
+        m_try_longjmp(e->data.buf, 1);                                        \
+      }                                                                       \
+      /* Next stack frame */                                                  \
+      e = e->next;                                                            \
+    }                                                                         \
+    /* No exception found.                                                    \
+       Display the information and halt program . */                          \
+    M_RAISE_FATAL("Exception '%u' raised by (%s:%d) is not catched. Program aborted.\n", \
+                  exception->error_code, exception->filename, exception->line); \
+  }
+
+// Rethrow the error
+static inline void
+m_rethrow(void)
+{
+  M_ASSERT(m_global_error_list != NULL);
+  m_throw(&m_global_exception);
+}
+
+// Catch the error code associated to the TRY block state
+// and provide a pointer to the exception (which is a global).
+static inline bool
+m_catch(m_try_t state, unsigned error_code, const struct m_exception_s **exception)
+{
+  M_ASSERT(m_global_error_list == state);
+  M_ASSERT(state->kind == M_STATE_EXCEPTION_IN_PROGRESS);
+  *exception = &m_global_exception;
+  if (error_code != 0 && m_global_exception.error_code != error_code)
+    return false;
+  // The exception has been catched.
+  state->kind = M_STATE_EXCEPTION_CATCHED;
+  // Unstack the try block, so that next throw command in the CATCH block
+  // will reach the upper TRY block.
+  m_global_error_list = state->next;
+  return true;
+}
+
+// Initialize the state to a TRY state.
+static inline void
+m_try_init(m_try_t state)
+{
+  state->kind = M_STATE_TRY;
+  state->next = m_global_error_list;
+  m_global_error_list = state;
+  // setjmp needs to be done in the MACRO.
+}
+#define m_try_init(s)                                                         \
+  M_LIKELY ((m_try_init(s), m_try_setjmp(((s)->data.buf)) != 1))
+
+// Disable the current TRY block.
+static inline void
+m_try_clear(m_try_t state)
+{
+  // Even if there is a CATCH block and an unstack of the exception
+  // m_global_error_list won't be changed.
+  m_global_error_list = state->next;
+  if (M_UNLIKELY (state->kind == M_STATE_EXCEPTION_IN_PROGRESS)) {
+    // There was no catch for this error.
+    // Forward it to the upper level.
+     m_rethrow();
+  }
+}
+
+
+// Implement the M_LET injection macros, so that the CLEAR operator is called on exception
+// Helper functions
+// Each mechanisme provide 3 helper functions:
+// * pre: which is called before the constructor
+// * post: which is called after the constructor
+// * final: which is called before the destructor.
+
+// We register a call to the CLEAR callback.
+// We don't modify m_global_error_list until we have successfully called the INIT operator
+// to avoid registering the CLEAR operator on exception whereas the object is not initialized yet.
+// However we register the position in the stack frame now so that in case of partial initialization
+// of the object (if the INIT operator of the object calls other INIT operators of composed fields),
+// since partial initialization will be unstacked naturally by the composing object.
+static inline bool
+m_try_cb_pre(m_try_t state)
+{
+  state->kind = M_STATE_CLEAR_CB;
+  state->next = m_global_error_list;
+  return true;
+}
+
+// We register the function to call of the initialized object.
+static inline bool
+m_try_cb_post(m_try_t state, void (M_TRY_FUNC_OPERATOR func)(void*), void *data)
+{
+  state->data.clear.func = func;
+  state->data.clear.data = data;
+  m_global_error_list = state;
+  return true;
+}
+
+// The object will be cleared.
+// We can pop the stack frame of the errors.
+static inline void
+m_try_cb_final(m_try_t state)
+{
+  m_global_error_list = state->next;
+}
+
+// Pre initialization function. Save the stack frame for a longjmp
+static inline bool
+m_try_jump_pre(m_try_t state)
+{
+  state->kind = M_STATE_CLEAR_JMPBUF;
+  state->next = m_global_error_list;
+  return true;
+}
+
+// Post initialization function. Register the stack frame for a longjmp
+static inline void
+m_try_jump_post(m_try_t state)
+{
+  m_global_error_list = state;
+}
+// And call setjmp to register the position in the code.
+#define m_try_jump_post(s)                                                    \
+  M_LIKELY ((m_try_jump_post(s), m_try_setjmp(((s)->data.buf)) != 1))
+
+// The object will be cleared.
+// We can pop the stack frame of the errors.
+static inline void
+m_try_jump_final(m_try_t state)
+{
+  m_global_error_list = state->next;
+}
+
+
+// Implement the M_LET injection macros, so that the CLEAR operator is called on exception
+//
+#if M_USE_TRY_MECHANISM == 1
+# error M*LIB: Internal error. C++ back-end requested within C implementation.
+
+#elif M_USE_TRY_MECHANISM == 2
+// Use of CLANG blocks
+
+#define M_LET_TRY_INJECT_PRE_B(cont, oplist, name)                            \
+  for(m_try_t M_C(m_try_state_, name); cont &&                                \
+        m_try_cb_pre(M_C(m_try_state_, name) ); )
+
+#define M_LET_TRY_INJECT_POST_B(cont, oplist, name)                           \
+  for(m_try_cb_post(M_C(m_try_state_, name),                                  \
+                      ^ void (void *_data) { M_GET_TYPE oplist *_t = _data; M_CALL_CLEAR(oplist, *_t); }, \
+                      (void*) &name); cont; m_try_cb_final(M_C(m_try_state_, name)) )
+
+#elif M_USE_TRY_MECHANISM == 3
+// Use of GCC nested functions.
+
+#define M_LET_TRY_INJECT_PRE_B(cont, oplist, name)                            \
+  for(m_try_t M_C(m_try_state_, name); cont &&                                \
+        m_try_cb_pre(M_C(m_try_state_, name) ); )
+
+#define M_LET_TRY_INJECT_POST_B(cont, oplist, name)                           \
+  for(m_try_cb_post(M_C(m_try_state_, name),                                  \
+                      __extension__ ({ __extension__ void _callback (void *_data) { M_GET_TYPE oplist *_t = _data; M_CALL_CLEAR(oplist, *_t); } _callback; }), \
+                      (void*) &name); cont; m_try_cb_final(M_C(m_try_state_, name)) )
+
+#elif M_USE_TRY_MECHANISM == 4
+// STD C compliant (without compiler extension): use of setjmp
+// This is the basic implementation in case of compiler unknown.
+// It uses setjmp/longjmp, and as such, is much slower than
+// other implementations.
+
+// M_LET Injection / pre initialization
+// Initialize the stack frame.
+#define M_LET_TRY_INJECT_PRE_B(cont, oplist, name)                            \
+  for(m_try_t M_C(m_try_state_, name); cont &&                                \
+        m_try_jump_pre(M_C(m_try_state_, name)); )
+
+// M_LET Injection / post initialization
+// Register the stack frame and tests for the longjmp.
+// In which case call the CLEAR operator, unstack the error list and rethrow the error.
+#define M_LET_TRY_INJECT_POST_B(cont, oplist, name)                           \
+  for( ; cont ; m_try_jump_final(M_C(m_try_state_, name)))                    \
+    if (m_try_jump_post(M_C(m_try_state_, name))                              \
+        || (M_CALL_CLEAR(oplist, name), m_try_jump_final(M_C(m_try_state_, name)), m_rethrow(), false))
+
+#else
+# error M*LIB: Invalid value for M_USE_TRY_MECHANISM [1..4]
+#endif
+
+
+// M_DEFER Injection / pre initialization
+// Initialize the stack frame.
+#define M_DEFER_TRY_INJECT_PRE_B(cont, ...)                                   \
+  for(m_try_t M_C(m_try_state_, cont); cont &&                                \
+        m_try_jump_pre(M_C(m_try_state_, cont)); )
+
+// M_DEFER Injection / post initialization
+// Register the stack frame and tests for the longjmp.
+// In which case call the CLEAR operator, unstack the error list and rethrow the error.
+#define M_DEFER_TRY_INJECT_POST_B(cont, ...)                                  \
+  for( ; cont ; m_try_jump_final(M_C(m_try_state_, cont)))                    \
+    if (m_try_jump_post(M_C(m_try_state_, cont))                              \
+        || (__VA_ARGS__ , m_try_jump_final(M_C(m_try_state_, cont)), m_rethrow(), false))
+
+#endif /* cplusplus */
+
+/*****************************************************************************/
+
+// Macro injection for M_LET.
+// If the oplist defined NOCLEAR property, we won't register this variable for clear on exception
+#undef  M_LET_TRY_INJECT_PRE
+#define M_LET_TRY_INJECT_PRE(cont, oplist, name)                              \
+  M_IF(M_GET_PROPERTY(oplist, NOCLEAR))(M_EAT, M_LET_TRY_INJECT_PRE_B)        \
+  (cont, oplist, name)
+
+#undef  M_LET_TRY_INJECT_POST
+#define M_LET_TRY_INJECT_POST(cont, oplist, name)                             \
+  M_IF(M_GET_PROPERTY(oplist, NOCLEAR))(M_EAT, M_LET_TRY_INJECT_POST_B)       \
+  (cont, oplist, name)
+
+
+// Macro injection for M_DEFER.
+#undef  M_DEFER_TRY_INJECT_PRE
+#define M_DEFER_TRY_INJECT_PRE(cont, ...)  M_DEFER_TRY_INJECT_PRE_B(cont, __VA_ARGS__)
+#undef  M_DEFER_TRY_INJECT_POST
+#define M_DEFER_TRY_INJECT_POST(cont, ...) M_DEFER_TRY_INJECT_POST_B(cont, __VA_ARGS__)
+
+
+// In case of MEMORY FULL errors, throw an error instead of aborting.
+#undef  M_MEMORY_FULL
+#define M_MEMORY_FULL(size)    M_THROW(M_ERROR_MEMORY, (intptr_t)(size))
+
+#endif
+
@@ -1,7 +1,7 @@
 /*
 * M*LIB / WORKER - Extra worker interface
 *
- * Copyright (c) 2017-2021, Patrick Pelissier
+ * Copyright (c) 2017-2023, Patrick Pelissier
 * All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
@@ -38,11 +38,11 @@

 #include "m-atomic.h"
 #include "m-buffer.h"
-#include "m-mutex.h"
+#include "m-thread.h"

-/* Include needed system header for detection of how many core on the system */
+/* Include needed system header for detection of how many cores are available in the system */
 #if defined(_WIN32)
-# include <windows.h>
+# include <sysinfoapi.h>
 #elif (defined(__APPLE__) && defined(__MACH__))                               \
  || defined(__DragonFly__) || defined(__FreeBSD__)                           \
  || defined(__NetBSD__) || defined(__OpenBSD__)
@@ -96,8 +96,8 @@
 M_BEGIN_PROTECTED_CODE

 /* Definition of a work order */
-typedef struct work_order_s {
-  struct worker_sync_s *block;    // Reference to the shared Synchronization block
+typedef struct m_work3r_order_s {
+  struct m_worker_sync_s *block;  // Reference to the shared Synchronization block
  void * data;                    // The work order data
  void (*func) (void *data);      // The work order function (for GCC)
 #if M_USE_WORKER_CLANG_BLOCK
@@ -106,52 +106,52 @@ typedef struct work_order_s {
 #if M_USE_WORKER_CPP_FUNCTION
  std::function<void(void*)> function; // The work order function (for C++)
 #endif
-} worker_order_ct;
+} m_work3r_order_ct;

 /* Define the macros needed to initialize an order.
 * * MACRO to be used to send an empty order to stop the thread
 * * MACRO to complete the not-used fields
 */
 #if M_USE_WORKER_CLANG_BLOCK || M_USE_WORKER_CPP_FUNCTION
-# define WORKERI_EMPTY_ORDER { NULL, NULL, NULL, NULL }
-# define WORKERI_EXTRA_ORDER , NULL
+# define M_WORK3R_EMPTY_ORDER { NULL, NULL, NULL, NULL }
+# define M_WORK3R_EXTRA_ORDER , NULL
 #else
-# define WORKERI_EMPTY_ORDER { NULL, NULL, NULL }
-# define WORKERI_EXTRA_ORDER
+# define M_WORK3R_EMPTY_ORDER { NULL, NULL, NULL }
+# define M_WORK3R_EXTRA_ORDER
 #endif

-/* As in C++, it uses std::function, M_POD_OPLIST
+/* As it is C++, it uses std::function, M_POD_OPLIST
   is not sufficient for initialization of the structure.
   So let's use C++ constructor, destructor and copy constructor */
 #if M_USE_WORKER_CPP_FUNCTION
-# define WORKERI_CPP_INIT(x) (new (&(x)) worker_order_ct())
-# define WORKERI_CPP_INIT_SET(x, y) (new (&(x)) worker_order_ct(y))
-# define WORKERI_CPP_SET(x, y) ((x) = (y))
-# define WORKERI_CPP_CLEAR(x) ((&(x))->~worker_order_ct())
-# define WORKERI_CPP_INIT_MOVE(x,y) (new (&(x)) worker_order_ct(y), ((&(y))->~worker_order_ct()))
-# define WORKER_OPLIST                                                        \
-      (INIT(WORKERI_CPP_INIT), INIT_SET(WORKERI_CPP_INIT_SET),                \
-      SET(WORKERI_CPP_SET), CLEAR(WORKERI_CPP_CLEAR), INIT_MOVE(WORKERI_CPP_INIT_MOVE) )
+# define M_WORK3R_CPP_INIT(x)        (new (&(x)) m_work3r_order_ct())
+# define M_WORK3R_CPP_INIT_SET(x, y) (new (&(x)) m_work3r_order_ct(y))
+# define M_WORK3R_CPP_SET(x, y)      ((x) = (y))
+# define M_WORK3R_CPP_CLEAR(x)       ((&(x))->~m_work3r_order_ct())
+# define M_WORK3R_CPP_INIT_MOVE(x,y) (new (&(x)) m_work3r_order_ct(y), ((&(y))->~m_work3r_order_ct()))
+# define M_WORK3R_OPLIST                                                      \
+      (INIT(M_WORK3R_CPP_INIT), INIT_SET(M_WORK3R_CPP_INIT_SET),              \
+      SET(M_WORK3R_CPP_SET), CLEAR(M_WORK3R_CPP_CLEAR), INIT_MOVE(M_WORK3R_CPP_INIT_MOVE) )
 #else
-# define WORKER_OPLIST M_POD_OPLIST
+# define M_WORK3R_OPLIST M_POD_OPLIST
 #endif

-/* Definition of a worker (implemented by a thread) */
-typedef struct worker_thread_s {
+/* Definition of the identity of a worker thread */
+typedef struct m_work3r_thread_s {
  m_thread_t id;
-} worker_thread_ct;
+} m_work3r_thread_ct;

 /* Definition of the queue that will record the work orders */
-BUFFER_DEF_AS(worker_queue, m_worker_queue_ct, worker_order_ct, 0, 
-           BUFFER_QUEUE|BUFFER_UNBLOCKING_PUSH|BUFFER_BLOCKING_POP|BUFFER_THREAD_SAFE|BUFFER_DEFERRED_POP, WORKER_OPLIST)
+BUFFER_DEF(m_work3r_queue, m_work3r_order_ct, 0,
+           BUFFER_QUEUE|BUFFER_UNBLOCKING_PUSH|BUFFER_BLOCKING_POP|BUFFER_THREAD_SAFE|BUFFER_DEFERRED_POP, M_WORK3R_OPLIST)

 /* Definition the global pool of workers */
-typedef struct worker_s {
+typedef struct m_worker_s {
  /* The work order queue */
-  m_worker_queue_ct queue_g;
+  m_work3r_queue_t queue_g;

  /* The table of available workers */
-  worker_thread_ct *worker;
+  m_work3r_thread_ct *worker;

  /* Number of workers in the table */
  unsigned int numWorker_g;
@@ -165,18 +165,142 @@ typedef struct worker_s {
  m_mutex_t lock;
  m_cond_t  a_thread_ends;        // EVENT: A worker has ended

-} worker_t[1];
+} m_worker_t[1];

 /* Definition of the synchronization point for workers */
-typedef struct worker_sync_s {
+typedef struct m_worker_sync_s {
  atomic_int num_spawn;                 // Number of spawned workers accord this synchronization point
  atomic_int num_terminated_spawn;      // Number of terminated spawned workers
-  struct worker_s *worker;              // Reference to the pool of workers
-} worker_sync_t[1];
+  struct m_worker_s *worker;            // Reference to the pool of workers
+} m_worker_sync_t[1];

-/* Return the number of CPU of the system */
+
+/* Extend m_worker_spawn by defining a specialization function
+   with the given arguments.
+   Generate the needed encapsulation for the user.
+   USAGE: name, oplists of arguments */
+#define M_WORKER_SPAWN_DEF2(name, ...)                                        \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_WORK3R_SPAWN_EXTEND_P1( (name, M_MAP_C(M_WORK3R_SPAWN_EXTEND_P0, __VA_ARGS__) ) ) \
+  M_END_PROTECTED_CODE
+
+/* Output a valid oplist with the given type.
+   input is (fieldname, type) or (fieldname, type, oplist)
+   Output shall be : M_OPEXTEND(M_GLOBAL_OPLIST_OR_DEF(type_or_oplist)(), TYPE(type)) / M_OPEXTEND(oplist, TYPE(type))
+ */
+#define M_WORK3R_SPAWN_EXTEND_P0(...)                   M_SUFFIX_FUNCTION_BY_NARGS(M_WORK3R_SPAWN_EXTEND_P0, M_ID __VA_ARGS__) __VA_ARGS__
+#define M_WORK3R_SPAWN_EXTEND_P0_2(field, type)         M_OPEXTEND(M_GLOBAL_OPLIST_OR_DEF(type)(), TYPE(type))
+#define M_WORK3R_SPAWN_EXTEND_P0_3(field, type, oplist) M_IF_OPLIST(oplist)(M_WORK3R_SPAWN_EXTEND_P0_3_OK, M_WORK3R_SPAWN_EXTEND_P0_3_KO)(field, type, oplist)
+#define M_WORK3R_SPAWN_EXTEND_P0_3_OK(field, type, oplist) M_OPEXTEND(oplist, TYPE(type))
+#define M_WORK3R_SPAWN_EXTEND_P0_3_KO(field, type, oplist)                    \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(M_WORKER_SPAWN_EXTEND): the argument is not a valid oplist: " M_MAP(M_AS_STR, oplist))
+
+/* Deferred evaluation for the definition,
+   so that all arguments are evaluated before further expansion */
+#define M_WORK3R_SPAWN_EXTEND_P1(arg) M_ID( M_WORK3R_SPAWN_EXTEND_P2 arg )
+
+/* Validate the oplist before going further */
+#define M_WORK3R_SPAWN_EXTEND_P2(name, ...)                                   \
+  M_IF(M_REDUCE(M_OPLIST_P, M_AND, __VA_ARGS__))                              \
+  (M_WORK3R_SPAWN_EXTEND_P3, M_WORK3R_SPAWN_EXTEND_FAILURE)(name, __VA_ARGS__)
+
+/* Stop processing with a compilation failure */
+#define M_WORK3R_SPAWN_EXTEND_FAILURE(name, ...)                              \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST,                                       \
+                   "(M_WORKER_SPAWN_EXTEND): at least one of the given argument is not a valid oplist: " \
+                   M_MAP(M_AS_STR, __VA_ARGS__))
+
+/* Define the extension of spawn */
+#define M_WORK3R_SPAWN_EXTEND_P3(name, ...)                                   \
+  M_WORK3R_SPAWN_EXTEND_DEF_TYPE(name, __VA_ARGS__)                           \
+  M_WORK3R_SPAWN_EXTEND_DEF_CALLBACK(name, __VA_ARGS__)                       \
+  M_WORK3R_SPAWN_EXTEND_DEF_EMPLACE(name, __VA_ARGS__)                        \
+
+/* Define the type */
+#define M_WORK3R_SPAWN_EXTEND_DEF_TYPE(name, ...)                             \
+  typedef void (*M_C3(m_worker_,name, _callback_ct))(M_MAP_C(M_WORK3R_SPAWN_EXTEND_DEF_TYPE_TYPE, __VA_ARGS__)); \
+  struct M_C3(m_worker_, name, _s){                                           \
+    M_C3(m_worker_, name, _callback_ct) callback;                             \
+    M_MAP3(M_WORK3R_SPAWN_EXTEND_DEF_TYPE_FIELD, data, __VA_ARGS__)           \
+      };
+
+#define M_WORK3R_SPAWN_EXTEND_DEF_TYPE_FIELD(data, num, oplist)               \
+  M_GET_TYPE oplist M_C(field, num);
+
+#define M_WORK3R_SPAWN_EXTEND_DEF_TYPE_TYPE(oplist)                           \
+  M_GET_TYPE oplist
+
+/* Define the callback */
+#define M_WORK3R_SPAWN_EXTEND_DEF_CALLBACK(name, ...)                         \
+  static inline void                                                          \
+  M_C3(m_work3r_, name, _clear)(struct M_C3(m_worker_, name, _s) *p)          \
+  {                                                                           \
+    M_MAP3(M_WORK3R_SPAWN_EXTEND_DEF_CALLBACK_CLEAR, data, __VA_ARGS__)       \
+    /* TODO: Overload */                                                      \
+    M_MEMORY_DEL(p);                                                          \
+  }                                                                           \
+                                                                              \
+  static inline void                                                          \
+  M_C3(m_work3r_, name, _callback)(void *data)                                \
+  {                                                                           \
+    struct M_C3(m_worker_, name, _s) *p = (struct M_C3(m_worker_, name, _s) *) data; \
+    (*p->callback)(                                                           \
+    M_MAP3_C(M_WORK3R_SPAWN_EXTEND_DEF_CALLBACK_FIELD, data, __VA_ARGS__)     \
+                                                                        );    \
+    M_C3(m_work3r_, name, _clear)(p);                                         \
+  }
+
+#define M_WORK3R_SPAWN_EXTEND_DEF_CALLBACK_FIELD(data, num, oplist)           \
+  p->M_C(field, num)
+
+#define M_WORK3R_SPAWN_EXTEND_DEF_CALLBACK_CLEAR(data, num, oplist)           \
+  M_CALL_CLEAR(oplist, p->M_C(field, num)) ;
+
+/* Define the emplace like spawn method */
+#define M_WORK3R_SPAWN_EXTEND_DEF_EMPLACE(name, ...)                          \
+  static inline void                                                          \
+  M_C(m_worker_spawn_, name)(m_worker_sync_t block, M_C3(m_worker_, name, _callback_ct) callback, \
+                             M_MAP3_C(M_WORK3R_SPAWN_EXTEND_DEF_EMPLACE_FIELD, data, __VA_ARGS__) \
+                             )                                                \
+  {                                                                           \
+    if (!m_work3r_queue_full_p(block->worker->queue_g)) {                     \
+      struct M_C3(m_worker_, name, _s) *p = M_MEMORY_ALLOC ( struct M_C3(m_worker_, name, _s)); \
+      if (M_UNLIKELY_NOMEM(p == NULL)) {                                      \
+        M_MEMORY_FULL(sizeof (struct M_C3(m_worker_, name, _s)));             \
+      }                                                                       \
+      p->callback = callback;                                                 \
+      M_MAP3(M_WORK3R_SPAWN_EXTEND_DEF_EMPLACE_FIELD_COPY, data, __VA_ARGS__) \
+      const m_work3r_order_ct w = { block, p, M_C3(m_work3r_, name, _callback) M_WORK3R_EXTRA_ORDER }; \
+      if (m_work3r_queue_push (block->worker->queue_g, w) == true) {          \
+        atomic_fetch_add (&block->num_spawn, 1);                              \
+        return;                                                               \
+      }                                                                       \
+      /* No worker available now. Call the function ourself */                \
+      /* But before clear the allocated data */                               \
+      M_C3(m_work3r_, name, _clear)(p);                                       \
+    }                                                                         \
+    /* No worker available. Call the function ourself */                      \
+    (*callback) (                                                             \
+                 M_MAP3_C(M_WORK3R_SPAWN_EXTEND_DEF_EMPLACE_FIELD_ALONE, data, __VA_ARGS__) \
+                                                                        );    \
+  }
+
+#define M_WORK3R_SPAWN_EXTEND_DEF_EMPLACE_FIELD(data, num, oplist)            \
+  M_GET_TYPE oplist M_C(param, num)
+
+#define M_WORK3R_SPAWN_EXTEND_DEF_EMPLACE_FIELD_COPY(data, num, oplist)       \
+  M_CALL_INIT_SET(oplist, p-> M_C(field, num), M_C(param, num) );
+
+#define M_WORK3R_SPAWN_EXTEND_DEF_EMPLACE_FIELD_ALONE(data, num, oplist)      \
+  M_C(param, num)
+
+
+
+/* Return the number of CPU cores available in the system.
+   Works for WINDOWS, MACOS, *BSD, LINUX.
+ */
 static inline int
-workeri_get_cpu_count(void)
+m_work3r_get_cpu_count(void)
 {
 #if defined(_WIN32)
  SYSTEM_INFO sysinfo;
@@ -193,6 +317,8 @@ workeri_get_cpu_count(void)
  return M_MAX(1, count);
 #elif defined (_SC_NPROCESSORS_ONLN)
  return (int) sysconf(_SC_NPROCESSORS_ONLN);
+#elif defined (_SC_NPROCESSORS_CONF)
+  return (int) sysconf(_SC_NPROCESSORS_CONF);
 #else
  return 1;
 #endif
@@ -200,25 +326,25 @@ workeri_get_cpu_count(void)

 // (INTERNAL) Debug support for workers
 #if 1
-#define WORKERI_DEBUG(...) (void) 0
+#define M_WORK3R_DEBUG(...) (void) 0
 #else
-#define WORKERI_DEBUG(...) printf(__VA_ARGS__)
+#define M_WORK3R_DEBUG(...) printf(__VA_ARGS__)
 #endif

 /* Execute the registered work order **synchronously** */
 static inline void
-workeri_exec(worker_order_ct *w)
+m_work3r_exec(m_work3r_order_ct *w)
 {
  M_ASSERT (w!= NULL && w->block != NULL);
-  WORKERI_DEBUG ("Starting thread with data %p\n", w->data);
+  M_WORK3R_DEBUG ("Starting thread with data %p\n", w->data);
 #if M_USE_WORKER_CLANG_BLOCK
-  WORKERI_DEBUG ("Running %s f=%p b=%p\n", (w->func == NULL) ? "Blocks" : "Function", w->func, w->blockFunc);
+  M_WORK3R_DEBUG ("Running %s f=%p b=%p\n", (w->func == NULL) ? "Blocks" : "Function", w->func, w->blockFunc);
  if (w->func == NULL)
    w->blockFunc(w->data);
  else
 #endif
 #if M_USE_WORKER_CPP_FUNCTION
-    WORKERI_DEBUG ("Running %s f=%p b=%p\n", (w->function == NULL) ? "Lambda" : "Function", w->func, w->blockFunc);
+    M_WORK3R_DEBUG ("Running %s f=%p b=%p\n", (w->function == NULL) ? "Lambda" : "Function", w->func, w->blockFunc);
    if (w->function)
      w->function(w->data);
    else
@@ -231,28 +357,28 @@ workeri_exec(worker_order_ct *w)

 /* The worker thread main loop*/
 static inline void
-workeri_thread(void *arg)
+m_work3r_thread(void *arg)
 {
  // Get back the given argument
-  struct worker_s *g = M_ASSIGN_CAST(struct worker_s *, arg);
+  struct m_worker_s *g = M_ASSIGN_CAST(struct m_worker_s *, arg);
  while (true) {
-    worker_order_ct w;
+    m_work3r_order_ct w;
    // If needed, reset the global state of the worker
    if (g->resetFunc_g != NULL) {
      g->resetFunc_g();
    }
    // Waiting for data
-    WORKERI_DEBUG ("Waiting for data (queue: %lu / %lu)\n", worker_queue_size(g->queue_g), worker_queue_capacity(g->queue_g));
-    worker_queue_pop(&w, g->queue_g);
+    M_WORK3R_DEBUG ("Waiting for data (queue: %lu / %lu)\n", m_work3r_queue_size(g->queue_g), m_work3r_queue_capacity(g->queue_g));
+    m_work3r_queue_pop(&w, g->queue_g);
    // We received a work order 
    // Note: that the work order is still present in the queue
    // preventing further work order to be pushed in the queue until it finishes doing the work
    // If a stop request is received, terminate the thread 
    if (w.block == NULL) break;
    // Execute the work order
-    workeri_exec(&w);
+    m_work3r_exec(&w);
    // Consumme fully the work order in the queue
-    worker_queue_pop_release(g->queue_g);
+    m_work3r_queue_pop_release(g->queue_g);
    // Signal that a worker has finished.
    m_mutex_lock(g->lock);
    m_cond_broadcast(g->a_thread_ends);
@@ -272,23 +398,23 @@ workeri_thread(void *arg)
   @clearFunc: function to clear the state of a worker before terminaning (or NULL if none)
 */
 static inline void
-worker_init(worker_t g, int numWorker, unsigned int extraQueue, void (*resetFunc)(void), void (*clearFunc)(void))
+m_worker_init(m_worker_t g, int numWorker, unsigned int extraQueue, void (*resetFunc)(void), void (*clearFunc)(void))
 {
  M_ASSERT (numWorker >= -1);
  // Auto compute number of workers if the argument is 0
  if (numWorker <= 0)
-    numWorker = (1 + (numWorker == -1))*workeri_get_cpu_count()-1;
-  WORKERI_DEBUG ("Starting queue with: %d\n", numWorker + extraQueue);
+    numWorker = (1 + (numWorker == -1))*m_work3r_get_cpu_count()-1;
+  M_WORK3R_DEBUG ("Starting queue with: %d\n", numWorker + extraQueue);
  // Initialization
  // numWorker can still be 0 if it is a single core cpu (no worker available)
  M_ASSERT(numWorker >= 0);
  size_t numWorker_st = (size_t) numWorker;
-  g->worker = M_MEMORY_REALLOC(worker_thread_ct, NULL, numWorker_st);
-  if (g->worker == NULL) {
-    M_MEMORY_FULL(sizeof (worker_thread_ct) * numWorker_st);
+  g->worker = M_MEMORY_REALLOC(m_work3r_thread_ct, NULL, numWorker_st);
+  if (M_UNLIKELY_NOMEM (g->worker == NULL)) {
+    M_MEMORY_FULL(sizeof (m_work3r_thread_ct) * numWorker_st);
    return;
  }
-  worker_queue_init(g->queue_g, numWorker_st + extraQueue);
+  m_work3r_queue_init(g->queue_g, numWorker_st + extraQueue);
  g->numWorker_g = (unsigned int) numWorker_st;
  g->resetFunc_g = resetFunc;
  g->clearFunc_g = clearFunc;
@@ -297,30 +423,31 @@ worker_init(worker_t g, int numWorker, unsigned int extraQueue, void (*resetFunc
  
  // Create & start the workers
  for(size_t i = 0; i < numWorker_st; i++) {
-    m_thread_create(g->worker[i].id, workeri_thread, M_ASSIGN_CAST(void*, g));
+    m_thread_create(g->worker[i].id, m_work3r_thread, M_ASSIGN_CAST(void*, g));
  }
 }
 /* Initialization of the worker module (constructor)
+   Provide default values for the arguments.
   Input:
   @numWorker: number of worker to create (0=autodetect, -1=2*autodetect)
   @extraQueue: number of extra work order we can get if all workers are full
   @resetFunc: function to reset the state of a worker between work orders (optional)
   @clearFunc: function to clear the state of a worker before terminaning (optional)
 */
-#define worker_init(...) worker_init(M_DEFAULT_ARGS(5, (0, 0, NULL, NULL), __VA_ARGS__))
+#define m_worker_init(...) m_worker_init(M_DEFAULT_ARGS(5, (0, 0, NULL, NULL), __VA_ARGS__))

 /* Clear of the worker module (destructor) */
 static inline void
-worker_clear(worker_t g)
+m_worker_clear(m_worker_t g)
 {
-  M_ASSERT (worker_queue_empty_p (g->queue_g));
+  M_ASSERT (m_work3r_queue_empty_p (g->queue_g));
  // Push the terminate order on the queue
  for(unsigned int i = 0; i < g->numWorker_g; i++) {
-    worker_order_ct w = WORKERI_EMPTY_ORDER;
+    m_work3r_order_ct w = M_WORK3R_EMPTY_ORDER;
    // Normaly all worker threads shall be waiting at this
    // stage, so all push won't block as the queue is empty.
    // But for robustness, let's wait.
-    worker_queue_push_blocking (g->queue_g, w, true);
+    m_work3r_queue_push_blocking (g->queue_g, w, true);
  }
  // Wait for thread terminanison
  for(unsigned int i = 0; i < g->numWorker_g; i++) {
@@ -330,13 +457,13 @@ worker_clear(worker_t g)
  M_MEMORY_FREE(g->worker);
  m_mutex_clear(g->lock);
  m_cond_clear(g->a_thread_ends);
-  worker_queue_clear(g->queue_g);
+  m_work3r_queue_clear(g->queue_g);
 }

 /* Start a new collaboration between workers of pool 'g'
   by defining the synchronization point 'block' */
 static inline void
-worker_start(worker_sync_t block, worker_t g)
+m_worker_start(m_worker_sync_t block, m_worker_t g)
 {
  atomic_init (&block->num_spawn, 0);
  atomic_init (&block->num_terminated_spawn, 0);
@@ -349,16 +476,16 @@ worker_start(worker_sync_t block, worker_t g)
   The work order if composed of the function 'func' and its 'data'
 */
 static inline void
-worker_spawn(worker_sync_t block, void (*func)(void *data), void *data)
+m_worker_spawn(m_worker_sync_t block, void (*func)(void *data), void *data)
 {
-  const worker_order_ct w = {  block, data, func WORKERI_EXTRA_ORDER };
-  if (M_UNLIKELY (!worker_queue_full_p(block->worker->queue_g))
-      && worker_queue_push (block->worker->queue_g, w) == true) {
-    WORKERI_DEBUG ("Sending data to thread: %p (block: %d / %d)\n", data, block->num_spawn, block->num_terminated_spawn);
+  const m_work3r_order_ct w = {  block, data, func M_WORK3R_EXTRA_ORDER };
+  if (M_UNLIKELY (!m_work3r_queue_full_p(block->worker->queue_g))
+      && m_work3r_queue_push (block->worker->queue_g, w) == true) {
+    M_WORK3R_DEBUG ("Sending data to thread: %p (block: %d / %d)\n", data, block->num_spawn, block->num_terminated_spawn);
    atomic_fetch_add (&block->num_spawn, 1);
    return;
  }
-  WORKERI_DEBUG ("Running data ourself: %p\n", data);
+  M_WORK3R_DEBUG ("Running data ourself: %p\n", data);
  /* No worker available. Call the function ourself */
  (*func) (data);
 }
@@ -367,16 +494,16 @@ worker_spawn(worker_sync_t block, void (*func)(void *data), void *data)
 /* Spawn or not the given work order to workers,
   or do it ourself if no worker is available */
 static inline void
-worker_spawn_block(worker_sync_t block, void (^func)(void *data), void *data)
+m_work3r_spawn_block(m_worker_sync_t block, void (^func)(void *data), void *data)
 {
-  const worker_order_ct w = {  block, data, NULL, func };
-  if (M_UNLIKELY (!worker_queue_full_p(block->worker->queue_g))
-      && worker_queue_push (block->worker->queue_g, w) == true) {
-    WORKERI_DEBUG ("Sending data to thread as block: %p (block: %d / %d)\n", data, block->num_spawn, block->num_terminated_spawn);
+  const m_work3r_order_ct w = {  block, data, NULL, func };
+  if (M_UNLIKELY (!m_work3r_queue_full_p(block->worker->queue_g))
+      && m_work3r_queue_push (block->worker->queue_g, w) == true) {
+    M_WORK3R_DEBUG ("Sending data to thread as block: %p (block: %d / %d)\n", data, block->num_spawn, block->num_terminated_spawn);
    atomic_fetch_add (&block->num_spawn, 1);
    return;
  }
-  WORKERI_DEBUG ("Running data ourself as block: %p\n", data);
+  M_WORK3R_DEBUG ("Running data ourself as block: %p\n", data);
  /* No worker available. Call the function ourself */
  func (data);
 }
@@ -386,16 +513,16 @@ worker_spawn_block(worker_sync_t block, void (^func)(void *data), void *data)
 /* Spawn or not the given work order to workers,
   or do it ourself if no worker is available */
 static inline void
-worker_spawn_function(worker_sync_t block, std::function<void(void *data)> func, void *data)
+m_work3r_spawn_function(m_worker_sync_t block, std::function<void(void *data)> func, void *data)
 {
-  const worker_order_ct w = {  block, data, NULL, func };
-  if (M_UNLIKELY (!worker_queue_full_p(block->worker->queue_g))
-      && worker_queue_push (block->worker->queue_g, w) == true) {
-    WORKERI_DEBUG ("Sending data to thread as block: %p (block: %d / %d)\n", data, block->num_spawn, block->num_terminated_spawn);
+  const m_work3r_order_ct w = {  block, data, NULL, func };
+  if (M_UNLIKELY (!m_work3r_queue_full_p(block->worker->queue_g))
+      && m_work3r_queue_push (block->worker->queue_g, w) == true) {
+    M_WORK3R_DEBUG ("Sending data to thread as block: %p (block: %d / %d)\n", data, block->num_spawn, block->num_terminated_spawn);
    atomic_fetch_add (&block->num_spawn, 1);
    return;
  }
-  WORKERI_DEBUG ("Running data ourself as block: %p\n", data);
+  M_WORK3R_DEBUG ("Running data ourself as block: %p\n", data);
  /* No worker available. Call the function ourself */
  func (data);
 }
@@ -403,7 +530,7 @@ worker_spawn_function(worker_sync_t block, std::function<void(void *data)> func,

 /* Test if all work orders of the given synchronization point are finished */
 static inline bool
-worker_sync_p(worker_sync_t block)
+m_worker_sync_p(m_worker_sync_t block)
 {
  /* If the number of spawns is greated than the number
     of terminated spawns, some spawns are still working.
@@ -413,14 +540,14 @@ worker_sync_p(worker_sync_t block)

 /* Wait for all work orders of the given synchronization point to be finished */
 static inline void
-worker_sync(worker_sync_t block)
+m_worker_sync(m_worker_sync_t block)
 {
-  WORKERI_DEBUG ("Waiting for thread terminasion.\n");
+  M_WORK3R_DEBUG ("Waiting for thread terminasion.\n");
  // Fast case: all workers have finished
-  if (worker_sync_p(block)) return;
+  if (m_worker_sync_p(block)) return;
  // Slow case: perform a locked wait to put this thread to waiting state
  m_mutex_lock(block->worker->lock);
-  while (!worker_sync_p(block)) {
+  while (!m_worker_sync_p(block)) {
    m_cond_wait(block->worker->a_thread_ends, block->worker->lock);
  }
  m_mutex_unlock(block->worker->lock);
@@ -428,19 +555,19 @@ worker_sync(worker_sync_t block)

 /* Flush any work order in the queue ourself if some remains.*/
 static inline void
-worker_flush(worker_t g)
+m_worker_flush(m_worker_t g)
 {
-  worker_order_ct w;
-  while (worker_queue_pop_blocking (&w, g->queue_g, false) == true) {
-    workeri_exec(&w);
-    worker_queue_pop_release(g->queue_g);
+  m_work3r_order_ct w;
+  while (m_work3r_queue_pop_blocking (&w, g->queue_g, false) == true) {
+    m_work3r_exec(&w);
+    m_work3r_queue_pop_release(g->queue_g);
  }
 }


 /* Return the number of workers */
 static inline size_t
-worker_count(worker_t g)
+m_worker_count(m_worker_t g)
 {
  return g->numWorker_g + 1;
 }
@@ -454,78 +581,78 @@ worker_count(worker_t g)
  TODO: Support oplist for input & outputs parameters 
 */
 #if M_USE_WORKER_CLANG_BLOCK
-#define WORKER_SPAWN(_block, _input, _core, _output)                          \
-  WORKER_DEF_DATA(_input, _output)                                            \
-  WORKER_DEF_SUBBLOCK(_input, _output, _core)                                 \
-  worker_spawn_block ((_block), WORKER_SPAWN_SUBFUNC_NAME,  &WORKER_SPAWN_DATA_NAME)
+#define M_WORKER_SPAWN(_block, _input, _core, _output)                        \
+  M_WORK3R_DEF_DATA(_input, _output)                                          \
+  M_WORK3R_DEF_SUBBLOCK(_input, _output, _core)                               \
+  m_work3r_spawn_block ((_block), M_WORK3R_SPAWN_SUBFUNC_NAME,  &M_WORK3R_SPAWN_DATA_NAME)
 #elif M_USE_WORKER_CPP_FUNCTION
 // TODO: Explicit pass all arguments by reference.
-#define WORKER_SPAWN(_block, _input, _core, _output)                          \
-  worker_spawn_function ((_block), [&](void *param) {(void)param ; _core } ,  NULL)
+#define M_WORKER_SPAWN(_block, _input, _core, _output)                        \
+  m_work3r_spawn_function ((_block), [&](void *param) {(void)param ; _core } ,  NULL)
 #else
-#define WORKER_SPAWN(_block, _input, _core, _output)                          \
-  WORKER_DEF_DATA(_input, _output)                                            \
-  WORKER_DEF_SUBFUNC(_input, _output, _core)                                  \
-  worker_spawn ((_block), WORKER_SPAWN_SUBFUNC_NAME,  &WORKER_SPAWN_DATA_NAME)
+#define M_WORKER_SPAWN(_block, _input, _core, _output)                        \
+  M_WORK3R_DEF_DATA(_input, _output)                                          \
+  M_WORK3R_DEF_SUBFUNC(_input, _output, _core)                                \
+  m_worker_spawn ((_block), M_WORK3R_SPAWN_SUBFUNC_NAME,  &M_WORK3R_SPAWN_DATA_NAME)
 #endif

-#define WORKER_SPAWN_STRUCT_NAME   M_C(worker_data_s_, __LINE__)
-#define WORKER_SPAWN_DATA_NAME     M_C(worker_data_, __LINE__)
-#define WORKER_SPAWN_SUBFUNC_NAME  M_C(worker_subfunc_, __LINE__)
-#define WORKER_DEF_DATA(_input, _output)                                      \
-  struct WORKER_SPAWN_STRUCT_NAME {                                           \
-    WORKER_DEF_DATA_INPUT _input                                              \
-    M_IF_EMPTY _output ( , WORKER_DEF_DATA_OUTPUT _output)                    \
-      } WORKER_SPAWN_DATA_NAME = {                                            \
-    WORKER_INIT_DATA_INPUT _input                                             \
-    M_IF_EMPTY _output (, WORKER_INIT_DATA_OUTPUT _output)                    \
+#define M_WORK3R_SPAWN_STRUCT_NAME   M_C(m_work3r_data_s_, __LINE__)
+#define M_WORK3R_SPAWN_DATA_NAME     M_C(m_work3r_data_, __LINE__)
+#define M_WORK3R_SPAWN_SUBFUNC_NAME  M_C(m_work3r_subfunc_, __LINE__)
+#define M_WORK3R_DEF_DATA(_input, _output)                                    \
+  struct M_WORK3R_SPAWN_STRUCT_NAME {                                         \
+    M_WORK3R_DEF_DATA_INPUT _input                                            \
+    M_IF_EMPTY _output ( , M_WORK3R_DEF_DATA_OUTPUT _output)                  \
+      } M_WORK3R_SPAWN_DATA_NAME = {                                          \
+    M_WORK3R_INIT_DATA_INPUT _input                                           \
+    M_IF_EMPTY _output (, M_WORK3R_INIT_DATA_OUTPUT _output)                  \
  };
-#define WORKER_DEF_SINGLE_INPUT(var) __typeof__(var) var;
-#define WORKER_DEF_DATA_INPUT(...)                                            \
-  M_MAP(WORKER_DEF_SINGLE_INPUT, __VA_ARGS__)
-#define WORKER_DEF_SINGLE_OUTPUT(var)                                         \
+#define M_WORK3R_DEF_SINGLE_INPUT(var) __typeof__(var) var;
+#define M_WORK3R_DEF_DATA_INPUT(...)                                          \
+  M_MAP(M_WORK3R_DEF_SINGLE_INPUT, __VA_ARGS__)
+#define M_WORK3R_DEF_SINGLE_OUTPUT(var)                                       \
  __typeof__(var) *M_C(var, _ptr);
-#define WORKER_DEF_DATA_OUTPUT(...)                                           \
-  M_MAP(WORKER_DEF_SINGLE_OUTPUT, __VA_ARGS__)
-#define WORKER_INIT_SINGLE_INPUT(var)                                         \
+#define M_WORK3R_DEF_DATA_OUTPUT(...)                                         \
+  M_MAP(M_WORK3R_DEF_SINGLE_OUTPUT, __VA_ARGS__)
+#define M_WORK3R_INIT_SINGLE_INPUT(var)                                       \
  .var = var,
-#define WORKER_INIT_DATA_INPUT(...)                                           \
-  M_MAP(WORKER_INIT_SINGLE_INPUT, __VA_ARGS__)
-#define WORKER_INIT_SINGLE_OUTPUT(var)                                        \
+#define M_WORK3R_INIT_DATA_INPUT(...)                                         \
+  M_MAP(M_WORK3R_INIT_SINGLE_INPUT, __VA_ARGS__)
+#define M_WORK3R_INIT_SINGLE_OUTPUT(var)                                      \
  .M_C(var, _ptr) = &var,
-#define WORKER_INIT_DATA_OUTPUT(...)                                          \
-  M_MAP(WORKER_INIT_SINGLE_OUTPUT, __VA_ARGS__)
-#define WORKER_DEF_SUBFUNC(_input, _output, _core)                            \
-  __extension__ auto void WORKER_SPAWN_SUBFUNC_NAME(void *) ;                 \
-  __extension__ void WORKER_SPAWN_SUBFUNC_NAME(void *_data)                   \
+#define M_WORK3R_INIT_DATA_OUTPUT(...)                                        \
+  M_MAP(M_WORK3R_INIT_SINGLE_OUTPUT, __VA_ARGS__)
+#define M_WORK3R_DEF_SUBFUNC(_input, _output, _core)                          \
+  __extension__ auto void M_WORK3R_SPAWN_SUBFUNC_NAME(void *) ;               \
+  __extension__ void M_WORK3R_SPAWN_SUBFUNC_NAME(void *_data)                 \
  {                                                                           \
-    struct WORKER_SPAWN_STRUCT_NAME *_s_data = _data ;                        \
-    WORKER_INIT_LOCAL_INPUT _input                                            \
-      M_IF_EMPTY _output ( , WORKER_INIT_LOCAL_OUTPUT _output)                \
+    struct M_WORK3R_SPAWN_STRUCT_NAME *_s_data = _data ;                      \
+    M_WORK3R_INIT_LOCAL_INPUT _input                                          \
+      M_IF_EMPTY _output ( , M_WORK3R_INIT_LOCAL_OUTPUT _output)              \
      do { _core } while (0);                                                 \
-    M_IF_EMPTY _output ( , WORKER_PROPAGATE_LOCAL_OUTPUT _output)             \
+    M_IF_EMPTY _output ( , M_WORK3R_PROPAGATE_LOCAL_OUTPUT _output)           \
  };
-#define WORKER_DEF_SUBBLOCK(_input, _output, _core)                           \
-  void (^WORKER_SPAWN_SUBFUNC_NAME) (void *) = ^ void (void * _data)          \
+#define M_WORK3R_DEF_SUBBLOCK(_input, _output, _core)                         \
+  void (^M_WORK3R_SPAWN_SUBFUNC_NAME) (void *) = ^ void (void * _data)        \
  {                                                                           \
-    struct WORKER_SPAWN_STRUCT_NAME *_s_data = _data ;                        \
-    WORKER_INIT_LOCAL_INPUT _input                                            \
-      M_IF_EMPTY _output ( , WORKER_INIT_LOCAL_OUTPUT _output)                \
+    struct M_WORK3R_SPAWN_STRUCT_NAME *_s_data = _data ;                      \
+    M_WORK3R_INIT_LOCAL_INPUT _input                                          \
+      M_IF_EMPTY _output ( , M_WORK3R_INIT_LOCAL_OUTPUT _output)              \
      do { _core } while (0);                                                 \
-    M_IF_EMPTY _output ( , WORKER_PROPAGATE_LOCAL_OUTPUT _output)             \
+    M_IF_EMPTY _output ( , M_WORK3R_PROPAGATE_LOCAL_OUTPUT _output)           \
  };
-#define WORKER_INIT_SINGLE_LOCAL_INPUT(var)                                   \
+#define M_WORK3R_INIT_SINGLE_LOCAL_INPUT(var)                                 \
  __typeof__(var) var = _s_data->var;
-#define WORKER_INIT_LOCAL_INPUT(...)                                          \
-  M_MAP(WORKER_INIT_SINGLE_LOCAL_INPUT, __VA_ARGS__)
-#define WORKER_INIT_SINGLE_LOCAL_OUTPUT(var)                                  \
+#define M_WORK3R_INIT_LOCAL_INPUT(...)                                        \
+  M_MAP(M_WORK3R_INIT_SINGLE_LOCAL_INPUT, __VA_ARGS__)
+#define M_WORK3R_INIT_SINGLE_LOCAL_OUTPUT(var)                                \
  __typeof__(var) var;
-#define WORKER_INIT_LOCAL_OUTPUT(...)                                         \
-  M_MAP(WORKER_INIT_SINGLE_LOCAL_OUTPUT, __VA_ARGS__)
-#define WORKER_PROPAGATE_SINGLE_OUTPUT(var)                                   \
+#define M_WORK3R_INIT_LOCAL_OUTPUT(...)                                       \
+  M_MAP(M_WORK3R_INIT_SINGLE_LOCAL_OUTPUT, __VA_ARGS__)
+#define M_WORK3R_PROPAGATE_SINGLE_OUTPUT(var)                                 \
  *(_s_data->M_C(var, _ptr)) = var;
-#define WORKER_PROPAGATE_LOCAL_OUTPUT(...)                                    \
-  M_MAP(WORKER_PROPAGATE_SINGLE_OUTPUT, __VA_ARGS__)
+#define M_WORK3R_PROPAGATE_LOCAL_OUTPUT(...)                                  \
+  M_MAP(M_WORK3R_PROPAGATE_SINGLE_OUTPUT, __VA_ARGS__)

 M_END_PROTECTED_CODE

@@ -533,22 +660,39 @@ M_END_PROTECTED_CODE

 /*   Define empty types and empty functions to not use any worker */

-typedef struct worker_block_s {
+typedef struct m_worker_block_s {
  int x;
-} worker_sync_t[1];
+} m_worker_sync_t[1];

-typedef struct worker_s {
+typedef struct m_worker_s {
  int x;
-} worker_t[1];
+} m_worker_t[1];

-#define worker_init(g, numWorker, extraQueue, resetFunc) do { (void) g; } while (0)
-#define worker_clear(g) do { (void) g; } while (0)
-#define worker_start(b, w) do { (void) b; } while (0)
-#define worker_spawn(b, f, d) do { f(d); } while (0)
-#define worker_sync(b) do { (void) b; } while (0)
-#define worker_count(w) 1
-#define WORKER_SPAWN(b, i, c, o) do { c } while (0)
+#define m_worker_init(g, numWorker, extraQueue, resetFunc) do { (void) g; } while (0)
+#define m_worker_clear(g) do { (void) g; } while (0)
+#define m_worker_start(b, w) do { (void) b; } while (0)
+#define m_worker_spawn(b, f, d) do { f(d); } while (0)
+#define m_worker_sync_p(b) true
+#define m_worker_sync(b) do { (void) b; } while (0)
+#define m_worker_count(w) 1
+#define m_worker_flush(w) do { (void) w; } while (0)
+#define M_WORKER_SPAWN(b, i, c, o) do { c } while (0)

 #endif /* M_USE_WORKER */

+
+#if M_USE_SMALL_NAME
+#define worker_t      m_worker_t
+#define worker_sync_t m_worker_sync_t
+#define worker_init   m_worker_init
+#define worker_clear  m_worker_clear
+#define worker_start  m_worker_start
+#define worker_spawn  m_worker_spawn
+#define worker_sync_p m_worker_sync_p
+#define worker_sync   m_worker_sync
+#define worker_count  m_worker_count
+#define worker_flush  m_worker_flush
+#define WORKER_SPAWN  M_WORKER_SPAWN
+#endif
+
 #endif