Improve error messages by the compiler

if the number of arguments doesn't match what is expected.
WIP interface
2023-11-01 11:14:27 +01:00 · 2023-11-01 11:14:27 +01:00 · 2023-11-01 11:13:54 +01:00 · 2023-10-21 19:05:08 +02:00 · 2023-10-20 00:02:38 +02:00 · 2023-10-19 22:54:51 +02:00
165 changed files with 29048 additions and 12991 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
@@ -38,7 +38,13 @@ depend
 other/
 a*.dat
 config
+config.link
 *.log
 .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,28 +1,292 @@
 *Long term issues*
------------------
+==========================================================
+
+* TODO #33 : Handling of partially constructed object               :ANOMALY:
+
+** State
+
+Support of partially constructed object needs special code to handle it 
+correctly (register a correct cleanup function in case of exception).
+
+Current containers don't support such features.
+
+** Actions
+
+Add such support in M*LIB containers. 
+
+It can be difficult. For example, for array _init_set
+function due to the copy of the object one per one. Each copied sub object
+may throw an exception, so we always need to have the container in a correct
+state so that it can be cleanup.
+
+* TODO #32 : User specialization fields in the container        :ENHANCEMENT:
+
+** State
+
+Some methods of a contained object may need to have some options that 
+are neither constant nor global, but are specialized in function of the container.
+
+For example, a memory handler may need a parameter which is needed to identify
+which pool of memory has to be used.
+
+** Plan:
+
+Add a new operator "CONTEXT" which is a type to be added in the 
+defined container. Then it can be accessed by the operator through an extension
+of the GAIA by adding support for identification of specialization like this:
+
+     ( CONTEXT( memory_pool_ref ),
+       NEW( API(NONE, memory_pool_alloc, CONTEXT, ARG1)),
+       DEL( API(NONE, memory_pool_free, CONTEXT, ARG1)) )
+
+** Open points:
+
+- How to get access to the specialization field of the container? ==> Define the "self" name as the name of the container for all methods? What to do when there are several containers for a method?
+- How to initialize the specialization field of the container? provide custom initialization functions? It seems to be the hard point.
+
+* TODO #31 : Uniformize parametrisation options of containers   :ENHANCEMENT:
+
+** State 
+
+Currently in order to pass some parametrization of the containers,
+the parameters are passed to the generation macros through:
+
+- extra parameters of the macros,
+- special operators of the contained object oplist.
+
+The extra parameters of some generation macros break the uniformity
+of the interface.
+It is conceptually wrong to put some special operators of the contained object 
+that have only meanings for the container object.
+In case of adding new options, it break the existing interface or put another
+operator in the contained object oplist.
+
+
+The following parameters are used:
+
+- Fixed size of a queue (buffer / B+Tree),
+- Policy of a queue (buffer),
+- Type of the container, IT type of the container, Ref type of the iterator
+
+The following operators are used:
+
+- NEW / DEL / REALLOC / FREE
+- MEMPOOL / MEMPOOL_LINKAGE
+
+The following new options is planned:
+
+- Interface (See #28)
+- Extra parameter for memory allocation function 
+
+** Plan
+
+The M\_*\_DEF\_AS macros shall be changed like this:
+
+    M_*_DEF_AS(name, cont_oplist, type[, type_oplist])
+
+with cont\_oplist being the container oplist that gives parametrization to the container definition.
+The following operators are planned:
+
+- TYPE: to define the type of the container,
+- IT\_TYPE: to define the IT type of the container,
+- SUBTYPE: to define the type pointed by the iterator,
+- FIXED\_SIZE: to define the fixed size of a container,
+- POLICY: to define the policy of a container,
+- NEW / DEL / REALLOC / FREE: to define the memory interface,
+- MEMPOOL / MEMPOOL_LINKAGE: to request a definition of a specialized memory interface,
+- INTERFACE: to request a pure header definition, an implementation or both (see #28),
+- CONTEXT: to request an extra context parameter to add in the container.
+
+All operators should be optional.
+
+The NEW / DEL / REALLOC / FREE / MEMPOOL / MEMPOOL_LINKAGE won't have any effects anymore if defined in the contained object oplist.
+
+** Pro:
+
+- Uniformize interface
+
+** Con:
+
+- API breakage. It can be mitigated by providing an adaptating layer by prividing the new interface for M\_*\_DEF\_AS only
+and *\_DEF\_AS will provide a translation layer.
+
+* TODO #30 : Serialization rework                               :ENHANCEMENT:
+
+** State 
+Currently, each container supports 3 serialization methods:
+
+- old format to FILE 
+- old format to string
+- generic serialization 
+
+Generic serialiation connect the container format to the serialization object constraints.
+It is done through a vtable. As such there is a performance penality and it avoids proper inlining.
+
+** Evolution
+
+Old format should be deprecated and shall use the generic serialization interface.
+
+Serialization object shall provide an OPLIST of serialization.
+For example CORE will provide OLD Format oplist and serial-json will provide JSON format oplist.
+Each oplist will provide the suffix needed for the serialization, and the interface
+(see already existing interface).
+
+Then a container will generate specialized serialization methods for each provided oplist.
+
+Pros:
+
+- Faster
+- In the M*LIB philosphy: much like other oplist usage.
+
+Cons:
+
+- compatibility breakage.
+
+Open point:
+
+- how can a user add a new serialization object?
+- Can we make a generic serialization object to support migration path?
+
+** Example
+
+serial-json provides
+
+    #define M_SERIAL_1() (NAME(_json), READ_INT(...), WRITE_INT(...) )
+
+containers provides
+    
+    For i in 1 100 ; do 
+        if do exist M_SERIAL_ ## i () 
+             expand(SERIAL_METHOD with M_SERIAL_1())
+
+    SERIAL_METHOD(name, ....)
+      static inline m_serial_return_code_t                                        \
+      M_C(M_F(name, _out_serial),M_GET_NAME(serial_op) )(M_GET_TYPE(serial_op) f, const list_t list)               \
+
+* DONE #29 : Support of partial initialized object                  :ANOMALY:
+
+** State
+
+In case of exception during the construction of an object,
+if the object is partially constructed, there is no destructor to call.
+Therefore if there is some partially constructed object
+(with some fields already fully constructed), there will be some links.
+This is the same problem with C++
+
+** Proposition
+
+Provide new macros to perform the partial initialization before doing the remaining taf.
+Something like:
+
+    M_CHAIN_INIT( init_code, clear_code)
+
+or
+
+x is { string_t s; string_t d; int num; }
+
+void struct_init_set(struct_t x, const struct_t y)
+{
+    // First thing is Chained Initialization
+    M_CHAIN_INIT( string_init_set(x->s, y->s), string_clear(x->s) );
+    M_CHAIN_INIT( string_init_set(x->d, y->d), string_clear(x->d) );
+    // End of chain init
+    x->num = y->num;
+}
+
+M_CHAIN_INIT will push the clean code pretty much like M_LET.
+Everything else is done in M_LET: when the constructor fully returns,
+the index of the clean code to call is reset to its value before calling
+the constructor. It means that the partially initialized code will be removed
+from this stack before the clean method of the structure itself is pushed.
+
+If an exception is raised after a M_CHAIN_INIT, only the clean methods
+of the M_CHAIN_INIT are called.
+
+* 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.
+
+This argument is a generation parametric argument.
+oplist is a parameter that define the property of the contained type.
+It could be used to pass this information but it will be an abuse of interface.
+Another argument is needed.
+
+Used arguments to parameter generation not related to the contained type:
+
+- memory interface (NEW / DEL / ...)
+- queue policy
+- fixed size for queue
+- fixed node size for B+Tree
+- generate static inline, public (extern) or private (define) functions.
+- name of the type.
+- name of the iterator
+- name of the iterated element.
+- ...
+
+Use another oplist as argument for M_.._DEF_AS (See #31)
+
+ M_BUFFER_DEF_AS(name, (TYPE(toto), FIXED_SIZE(10), POLICY(STACK), INTERFACE(header)), int, M_BASIC_OPLIST)
+
+* TODO #27 : Uniformization of m-buffer interface               :ENHANCEMENT:
+
+** State
+
+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.
+
+** Plan
+
+- Uniformization of the interface (See #31)
+- 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.

-Any service that returns void shall return a "int".
+Any service that returns void shall return a "int" (or another type).
 In case of allocation failure, it shall return an error.
 M_CALL macro shall stop its execution if the service returns an error code
 and the error code represents an error (avoid rewritting everything)
@@ -81,19 +345,20 @@ RETCODE/RETCODE
 If really needed, the macro can be avoided and code can be hand written.

 Open points:
+
 - How to handle warnings on unused labels?
- What about M_LET/ M_EACH?
+- What about M_LET / M_EACH? Maybe only supports those.

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

 See https://en.wikipedia.org/wiki/Min-max_heap
 as DPRIORITY_QUEUE_DEF ?

 NOTE: Needs for such container?

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

-* TODO #23: Force MOVE semantic                                 :ENHANCEMENT:
+** State

 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
@@ -108,7 +373,7 @@ moving the data before they can be moved using MOVE. Two solutions:
 - New operator MOVE_SELF to fix a type after it has been moved.
 - If MOVE defined, force another table and then copy by hand the type. This will be slower and consumme more memory.

-** MOVE in OPLIST                                               :ENHANCEMENT:
+** MOVE in OPLIST

 Proposal: do not export INIT_MOVE / MOVE operator in OPLIST if the MOVE operator is 
 compatible with a pure COPY semantic. An exported MOVE operator will tell 
@@ -127,8 +392,22 @@ defined with [1] tricks but without an explicit INIT_MOVE / MOVE
 operators as it uses MOVE_DEFAULT which is not (fully compatible).
 ==> Analyse limitation and possible constraint usages.

+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.

-* TODO #20: Bucket priority queue                               :ENHANCEMENT:
+Defining this type seems possible with C11 _Generic and a TYPE in the oplist,
+but without C11 _Generic I don't see any way to define such macro.
+
+Without a way to write such a macro, the ticket seems pretty much a dead end.
+
+* TODO #20 : New: Bucket priority queue                         :ENHANCEMENT:

 Add a new kind of priority queue. 
 See https://en.wikipedia.org/wiki/Bucket_queue
@@ -144,23 +423,20 @@ except that we can scan 64 entries at a time).
 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?)

-
-* TODO #18: Missing methods                                     :ENHANCEMENT:
+* TODO #18 : Missing methods                                    :ENHANCEMENT:

 Some containers don't have all the methods they should.
 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 : New: Ressource handler                             :ENHANCEMENT:

-* TODO #17: 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
@@ -185,11 +461,10 @@ http://htmlpreview.github.io/?https://github.com/P-p-H-d/mlib/blob/master/doc/Co

 How to handle multiple resource ? 

- * variant: works fine. Memory usage can be (much) higher than needed if there is a lot of dissimilarity between the size of the objects.
- * embedded the type in the ressource handler: more work, API more complex. Memory usage seems better.
+ * variant: Pro : easy. Con: Memory usage can be (much) higher than needed if there is a lot of dissimilarity between the size of the objects.
+ * embedded the type in the ressource handler: Con: more work, API more complex. Pro: 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.
@@ -212,31 +487,7 @@ http://htmlpreview.github.io/?https://github.com/P-p-H-d/mlib/blob/master/doc/Co
 - needs to be logically deleted : needs a previous field
   (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:
+* DONE #14 : Memory allocation enhancement                      :ENHANCEMENT:

 Enhancement of the memory allocation scheme to find way to deal properly with advanced allocators:

@@ -270,8 +521,9 @@ 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.

+Duplicate with #32 which is more generic ==> Closed

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

 Add an extension to the SHARED_PTR API:

@@ -345,13 +597,14 @@ Other alternative solution is to use the bit 0 to mark the pointer as being upda

 Other implementation seems to have it hard to be lock-free: cf. https://github.com/llvm-mirror/libcxx/commit/5fec82dc0db3623546038e4a86baa44f749e554f

-
-
-* 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 +625,24 @@ 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 +680,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
@@ -21,8 +21,9 @@
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 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
+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 -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,18 +31,33 @@ RM=rm -f
 .SUFFIXES: .c .exe

 .c.exe:
-	$(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) `cat config` $< -o $@
+	$(CC) $(CFLAGS) $(CPPFLAGS) $< -o $@ `cat config` $(LDFLAGS)
+
+.c.o:
+	@$(MAKE) config
+	$(CC) $(CFLAGS) $(CPPFLAGS) -O2 `cat config.link` -DNDEBUG -g $< -c -o $@

 all: config
 	$(MAKE) `ls ex-*.c|sed -e 's/\.c/\.exe/g'`
 	if test "$(CC)" = "cc -std=c99" ; then $(MAKE) `ls ex11-*.c|sed -e 's/\.c/\.exe/g'` CC="cc -std=c11" ; fi
+	$(MAKE) exm.exe exn.exe
+
+exm.exe: exm-lib.o exm-main.o
+	$(CC) `cat config.link` -g $^ -o $@
+
+exn.exe: exn-lib.o exn-main.o
+	$(CC) `cat config.link` -g $^ -o $@

 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"
+	printf "#include <stdio.h>\nint main(void){printf(\"Ok\"); return 0;}\n" > config-test.c
+	$(CC) $(CFLAGS) $(CPPFLAGS) config-test.c -ffunction-sections -fdata-sections -Wl,--gc-sections 2> /dev/null && echo "-ffunction-sections -fdata-sections -Wl,--gc-sections" > config.link || echo "" > config.link
 	$(RM) config-test.c config-test.exe

 clean:
-	$(RM) *.exe *.s *~ *.o ./a.dat config
+	$(RM) *.exe *.s *~ *.o ./a.dat config config.link


@@ -4,16 +4,16 @@

 /* Define a dynamic array of int */ 
 ARRAY_DEF(vector_int, int)
-/* Register the oplist of this dynamic array globally */
+/* Register the oplist of this dynamic array globally (using implicitely M_BASIC_OPLIST) */
 #define M_OPL_vector_int_t() ARRAY_OPLIST(vector_int)
-/* Define some standards algorithms on this dynamic array */
+/* Define some standards algorithms on this dynamic array. We can reuse the prefix of the dynamic array */
 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 */
+/* Define some standards algorithms on this dynamic array. We can reuse the prefix of the dynamic array */
 ALGO_DEF(vector_bool, vector_bool_t)

 /* ID function */
@@ -41,10 +41,10 @@ int main(void)
 #else
    for M_EACH(it, myvector, vector_int_t) {
        printf(" %d", *it);
-      }
+    }
 #endif
    printf("\n");
-  }
+  } /* End of M_LET: myvector & tmp are automaticly cleared */
  
  // Same thing but with booleans
  M_LET(myvector, tmp, vector_bool_t) {
@@ -56,13 +56,13 @@ int main(void)
    printf("myvector contains:");
    for M_EACH(it, myvector, vector_bool_t) {
        printf(" %d", (int)*it);
-      }
+    }
    printf("\n");
    printf ("ALL: %d ANY: %d NONE: %d\n",
            vector_bool_all_of_p(myvector, id),
            vector_bool_any_of_p(myvector, id),
            vector_bool_none_of_p(myvector, id) );
-  }
+  } /* End of M_LET: myvector & tmp are automaticly cleared */

  return 0;
 }
@@ -3,18 +3,18 @@
 #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)
 /* Register the oplist of this array of integer globally */
 #define M_OPL_vector_int_t() ARRAY_OPLIST(vector_int)

-/* Micro macro to detect if a string starts with the given pattern */
+/* Micro macro to detect if the key string starts with the given pattern */
 #define start_with(pattern, item)                \
  string_start_with_str_p((item).key, (pattern))

@@ -23,14 +23,13 @@ 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
-    // Initialize tmp as a dictionanry
-    M_LET( (m, (STRING_CTE("foo"), 1), (STRING_CTE("bar"), 42), (STRING_CTE("bluez"), 7), (STRING_CTE("stop"), 789) ), tmp, dict_t) {
- 
-    /* Extract all elements of 'm' that starts with 'b' */
+  // Initialize m as a dictionnary and initialize it with the given database
+  // Initialize tmp as a dictionnary
+  M_LET( (m, (STRING_CTE("foo"), 1), (STRING_CTE("bar"), 42), (STRING_CTE("bluez"), 7), (STRING_CTE("stop"), 789) ), tmp, dict_t) {
+    /* Extract all elements of 'm' that starts with 'b' and fills tmp with it */
    ALGO_EXTRACT(tmp, dict_t, m, dict_t, start_with, "b");
    /* Extract the values of theses elements */
    ALGO_TRANSFORM(keys, vector_int_t, tmp, dict_t, get_value);
@@ -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.
-    M_LET( (v, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10), vector_int_t) {
-    int sum, product;
+  // 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 = 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,54 @@
 #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 'string_t'
+// The prefix used for generating functions will be 'list_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.
+// LIST_OPLIST is a macro used to generate the oplist associated to the
+// list itself. It needs the prefix used for generating the list (aka list_string here)
+// and the oplist of the item in the list (aka the string oplist)
 #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,34 +63,59 @@ 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) );
      }
    
  } // Everything is cleared after this point.
+
+  // Let's create another list of string and init it.
+  list_string_t list;
+  list_string_init(list);
+  // Let's put some elements in it:
+  list_string_emplace_back (list, "A");
+  list_string_emplace_back (list, "B");
+  list_string_emplace_back (list, "C");
+  list_string_emplace_back (list, "D");
+  // Reverse it
+  list_string_reverse(list);
+  // Let's display the string by serializing the elements of the list:
+  printf ("List of string = ");
+  list_string_out_str(stdout, list);
+  printf ("\n");
+  // Don't forget to clear the list before leaving
+  list_string_clear(list);
  
  return 0;
 }
@@ -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,132 @@
+#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)
+{
+  // Let's declare a tree on the stack.
+  // Even if the tree itself is allocated on the stack,
+  // the nodes will be allocated on the heap.
+  tree_cstr_t tree;
+  // Initialize the tree using the provided constructor
+  tree_cstr_init(tree);
+
+  // Let's fill in the tree
+  // Note that the object of the tree are pointer
+  // to array of char. Therefore the strings themselves
+  // are not stored in the tree but only a reference to then
+  // As such, the pointed objects shall not moved nor being
+  // destroyed, which is the case for const C string.
+  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");
+
+  // Let's print the tree.
+  // We'll use the OUT_STR method to display the tree
+  // without iterating ourself in the tree.
+  printf("\nUsing C string, the generated (sorted) tree is ");
+  tree_cstr_out_str(stdout, tree);
+  printf ("\n");
+
+  // Let's search for the key "How" in the tree.
+  // If it is not found a NULL pointer is returned.
+  // Otherwise a pointer to the key within the tree is returned.
+  // This pointer is valid until a modification operation on the tree is done.
+  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);
+
+  // Destroy the tree by calling the destructor.
+  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.
+// since the oplist of a string_t is registered globally.
+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.
+  // Note that this time the full string is stored within the tree,
+  // and not only a pointer to it.
+  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"));
+  // We may also push a const C string into a string_t by calling the emplace function
+  tree_str_emplace (tree, "You");
+
+  // Let's print the tree
+  printf("\nUsing M*LIB string_t, the generated (sorted) tree is ");
+  tree_str_out_str(stdout, tree);
+  printf ("\n");
+
+  // Let's search for the string "How"
+  // We convert it to a temporary string_t, and let's test
+  // if it is found or not by testing if the returned pointer to string_t
+  // is null or not.
+  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");
+  }
+}
@@ -0,0 +1,12 @@
+#ifndef MY_HEADER
+#define MY_HEADER
+
+// Request M*LIB to not inline functions if not the library source
+#define M_USE_DECL
+#include "m-string.h"
+#include "m-array.h"
+
+ARRAY_DEF(array_str, string_t)
+
+#endif
+
@@ -0,0 +1,5 @@
+// Request M*LIB to define functions
+// This include both m-string functions and array_str templated functions
+// Defining M_USE_EXTERN_DEF override M_USE_EXTERN_DECL definition
+#define M_USE_DEF
+#include "exm-header.h"
@@ -0,0 +1,14 @@
+#include "exm-header.h"
+
+int main(void)
+{
+  array_str_t a;
+  array_str_init(a);
+  array_str_emplace_back(a, "Hello");
+  array_str_emplace_back(a, "World");
+  printf("a=");
+  array_str_out_str(stdout, a);
+  printf("\n");
+  array_str_clear(a);
+  return 0;
+}
@@ -0,0 +1,14 @@
+#ifndef MY_HEADER
+#define MY_HEADER
+
+// Request M*LIB to not always inline functions
+#define M_USE_FINE_GRAINED_LINKAGE
+#include "m-string.h"
+#include "m-array.h"
+
+// The following functions will not be inlined:
+#define M_USE_DECL
+ARRAY_DEF(array_str, string_t)
+#undef M_USE_DECL
+
+#endif
@@ -0,0 +1,4 @@
+// Request M*LIB to define functions for functions defined within M_USE_DECL.
+#define M_USE_DEF
+#include "exn-header.h"
+
@@ -0,0 +1,19 @@
+#include "exn-header.h"
+
+int main(void)
+{
+  string_t s;
+  string_init_set_str(s, "a=");
+  string_fputs(stdout, s);
+  string_clear(s);
+  array_str_t a;
+  array_str_init(a);
+  array_str_emplace_back(a, "Hello");
+  array_str_emplace_back(a, "World");
+  //printf("a=");
+  array_str_out_str(stdout, a);
+  printf("\n");
+  array_str_clear(a);
+  //main2();
+  return 0;
+}
@@ -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
@@ -226,7 +226,7 @@ typedef _Atomic(uintmax_t)          atomic_uintmax_t;
 #endif

 /* (INTERNAL) Unlock the mutex and return the given value */
-static inline long long atomic_fetch_unlock (m_mutex_t *lock, long long val)
+M_INLINE long long atomic_fetch_unlock (m_mutex_t *lock, long long val)
 {
  m_mutex_unlock (*lock);
  return val;
@@ -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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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)                            \
+  M_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_INLINE bool                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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,43 +123,43 @@ 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_INLINE void                                                               \
+  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);                                           \
    atomic_store_explicit(&node->next, &list->nil, memory_order_relaxed);     \
  }                                                                           \
                                                                              \
-  static inline bool                                                          \
-  M_C(name, _lflist_empty_p)(M_C(name, _lflist_ct) list)                      \
+  M_INLINE bool                                                               \
+  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_INLINE void                                                               \
+  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) \
+  M_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,                       \
+  M_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_INLINE void                                                               \
+  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)                           \
+  M_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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE type_t *                                                           \
+  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_INLINE void                                                               \
+  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,21 +574,21 @@ 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
+M_INLINE void
 m_gc_init(m_gc_t gc_mem, size_t max_thread)
 {
  M_ASSERT(gc_mem != NULL);
  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;
  }
@@ -600,7 +600,7 @@ m_gc_init(m_gc_t gc_mem, size_t max_thread)
  gc_mem->mempool_list = NULL;
 }

-static inline void
+M_INLINE void
 m_gc_clear(m_gc_t gc_mem)
 {
  M_ASSERT(gc_mem != NULL && gc_mem->max_thread > 0);
@@ -610,29 +610,29 @@ 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
+M_INLINE m_gc_tid_t
 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);
 }
  
-static inline void
+M_INLINE void
 m_gc_detach_thread(m_gc_t gc_mem, m_gc_tid_t id)
 {
  M_ASSERT(gc_mem != NULL && gc_mem->max_thread > 0);
  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
+M_INLINE void
 m_gc_awake(m_gc_t gc_mem, m_gc_tid_t id)
 {
  M_ASSERT(gc_mem != NULL && gc_mem->max_thread > 0);
@@ -643,8 +643,8 @@ m_gc_awake(m_gc_t gc_mem, m_gc_tid_t id)
  atomic_store(&gc_mem->thread_data[id].ticket, t);
 }
  
-static inline m_gc_ticket_ct
-m_gc_int_min_ticket(m_gc_t gc_mem)
+M_INLINE m_gc_ticket_ct
+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++) {
@@ -654,15 +654,15 @@ m_gc_int_min_ticket(m_gc_t gc_mem)
  return min;
 }

-static inline void
+M_INLINE void
 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,22 +681,22 @@ 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;
  M_CACHELINE_ALIGN(align1, m_vlapool_slist_ct);
 } m_vlapool_lfmp_thread_ct;

-static inline void
+M_INLINE void
 m_vlapool_lfmp_thread_init(m_vlapool_lfmp_thread_ct *t)
 {
  m_vlapool_slist_init(t->to_be_reclaimed);
 }

-static inline void
+M_INLINE void
 m_vlapool_lfmp_thread_clear(m_vlapool_lfmp_thread_ct *t)
 {
  M_ASSERT(m_vlapool_slist_empty_p(t->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_INLINE void
+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)) {
@@ -751,14 +751,14 @@ m_vlapool_int_gc_on_sleep(m_gc_t gc_mem, m_gc_mempool_list_ct *data,
  }
 }

-static inline void
+M_INLINE void
 m_vlapool_init(m_vlapool_t mem, m_gc_t gc_mem)
 {
  const size_t max_thread =  gc_mem->max_thread;

  /* 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,13 +771,13 @@ 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;
 }

-static inline void
+M_INLINE void
 m_vlapool_clear(m_vlapool_t mem)
 {
  const unsigned max_thread = mem->gc_mem->max_thread;
@@ -792,7 +792,7 @@ m_vlapool_clear(m_vlapool_t mem)
  /* TODO: Unregister from the GC? */
 }

-static inline void *
+M_INLINE void *
 m_vlapool_new(m_vlapool_t mem, m_gc_tid_t id, size_t size)
 {
  M_ASSERT(mem != NULL && mem->gc_mem != NULL);
@@ -811,7 +811,7 @@ m_vlapool_new(m_vlapool_t mem, m_gc_tid_t id, size_t size)
  return (ptr == NULL) ? NULL : M_ASSIGN_CAST(void *, ptr + offsetof(struct m_vlapool_slist_node_s, data));
 }

-static inline void
+M_INLINE void
 m_vlapool_del(m_vlapool_t mem, void *d, m_gc_tid_t id)
 {
  M_ASSERT(mem != NULL && mem->gc_mem != NULL);
@@ -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_INLINE retcode                                                            \
+  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_INLINE retcode                                                            \
+  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_INLINE M_C(base_name, _retcode_ct)                                        \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE struct M_C(base_name, _s) *                                        \
+  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_INLINE void                                                               \
+  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_INLINE M_C(base_name, _retcode_ct)                                        \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE struct M_C(base_name, _s) *                                        \
+  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_INLINE void                                                               \
+  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'
@@ -105,87 +103,87 @@ typedef struct genint_s {
 * meaning it can be used to index global unique resources shared 
 * for all threads.
 */
-static inline void
-genint_init(genint_t s, unsigned int n)
+M_INLINE void
+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_INLINE void
+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_INLINE size_t
+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_INLINE unsigned int
+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_INLINE void
+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_ITBASE_DEF

 /* 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,67 @@
 /* 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))                                        \
-   ,M_IF_METHOD(NEW, oplist)(NEW(M_GET_NEW oplist),)                          \
-   ,M_IF_METHOD(DEL, oplist)(DEL(M_GET_DEL oplist),)                          \
+   SPLICE_BACK(M_F(name,_splice_back))                                        \
   )

+
+/******************************** 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 +135,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 +143,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 +162,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_ITBASE_DEF(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);                                           \
+  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)                    \
                                                                              \
-  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
-                                                                              \
-  static inline void                                                          \
-  M_C(name, _init)(list_t list)                                               \
+  M_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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 +226,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_INLINE void                                                               \
+  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_INLINE bool                                                               \
+  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_INLINE void                                                               \
+  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,71 +261,71 @@ 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_INLINE void                                                               \
+  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_INLINE size_t                                                             \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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;                                          \
    next->prev = &obj->name;                                                  \
  }                                                                           \
                                                                              \
-  static inline void                                                          \
-  M_C(name, _init_field)(type *obj)                                           \
+  M_INLINE void                                                               \
+  M_F(name, _init_field)(type *obj)                                           \
  {                                                                           \
    M_ASSERT (obj != NULL);                                                   \
    /* Init the fields of the node. To be used in object constructor */       \
@@ -324,14 +333,14 @@ typedef struct ilist_head_s {
    obj->name.prev = NULL;                                                    \
  }                                                                           \
                                                                              \
-  static inline void                                                          \
-  M_C(name, _unlink)(type *obj)                                               \
+  M_INLINE void                                                               \
+  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 */                                  \
@@ -339,110 +348,110 @@ typedef struct ilist_head_s {
    obj->name.prev = NULL;                                                    \
  }                                                                           \
                                                                              \
-  static inline type *                                                        \
-  M_C(name, _back)(const list_t list)                                         \
+  M_INLINE type *                                                             \
+  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_INLINE type *                                                             \
+  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_INLINE type *                                                             \
+  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_INLINE type *                                                             \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE bool                                                               \
+  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_INLINE bool                                                               \
+  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_INLINE void                                                               \
+  M_F(name, _next)(it_t it)                                                   \
  {                                                                           \
    M_ASSERT (it != NULL);                                                    \
    /* Cannot check node for it->current: it may have been deleted! */        \
@@ -453,11 +462,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_INLINE void                                                               \
+  M_F(name, _previous)(it_t it)                                               \
  {                                                                           \
    M_ASSERT (it != NULL);                                                    \
    /* Cannot check node for it->current: it may have been deleted! */        \
@@ -468,163 +477,165 @@ 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_INLINE bool                                                               \
+  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 */                                \
    return it1->head == it2->head && it1->current == it2->current;            \
  }                                                                           \
                                                                              \
-  static inline type *                                                        \
-  M_C(name, _ref)(const it_t it)                                              \
+  M_INLINE type *                                                             \
+  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_INLINE type const *                                                       \
+  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_INLINE void                                                               \
+  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)(                                                   \
-  static inline void                                                          \
-  M_C(name, _insert)(list_t list, it_t it, type x)                            \
+  M_IF_METHOD2(NEW, INIT_SET, oplist)(                                        \
+  M_INLINE void                                                               \
+  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_INLINE type *                                                             \
+  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_INLINE type *                                                             \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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 +646,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_INLINE void                                                               \
+  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 +663,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,111 @@ 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.
+/* Define the intrusive shared pointer type and its M_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
+/* Define the intrusive shared pointer type and its M_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))                                             \
-  ,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),)                           \
+  SUBTYPE(M_F(name, _subtype_ct))                                             \
  )

+
+/******************************** 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);                                    \
+  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)                  \
                                                                              \
-  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
-                                                                              \
-  static inline shared_t                                                      \
-  M_C(name, _init)(type *ptr)                                                 \
+  M_INLINE shared_t                                                           \
+  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_INLINE shared_t                                                           \
+  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;                                                            \
@@ -150,89 +156,100 @@ M_BEGIN_PROTECTED_CODE
  M_IF_DISABLED_METHOD(NEW, oplist)                                           \
  (                                                                           \
  /* This function is only for static object */                               \
-  static inline shared_t                                                      \
-  M_C(name, _init_once)(type *shared)                                         \
+  M_INLINE shared_t                                                           \
+  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_INLINE shared_t                                                           \
+  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_INLINE void                                                               \
+  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);)      \
      }                                                                       \
    }                                                                         \
  }                                                                           \
                                                                              \
-  static inline void                                                          \
-  M_C(name, _clear_ptr)(shared_t *shared)                                     \
+  M_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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;                                                         \
    }                                                                         \
@@ -121,26 +138,26 @@
    mem->current_segment = NULL;                                              \
  }                                                                           \
                                                                              \
-  static inline type *                                                        \
-  M_C(name,_alloc)(name_t mem)                                                \
+  M_INLINE type *                                                             \
+  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_INLINE void                                                               \
+  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,392 @@
   - 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);                                      \
+  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)           \
                                                                              \
-  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
-                                                                              \
-  static inline void                                                          \
-  M_C(name, _init)(prioqueue_t p)                                             \
+  M_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE size_t                                                             \
+  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_INLINE size_t                                                             \
+  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_INLINE size_t                                                             \
+  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_INLINE int                                                                \
+  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_INLINE bool                                                               \
+  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_INLINE size_t                                                             \
+  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_INLINE void                                                               \
+  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_INLINE type const *                                                       \
+  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_INLINE void                                                               \
+  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_INLINE bool                                                             \
+    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)                                   \
+   M_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))     \
+       /* We cannot use CMP and the partial order to go faster                \
+        EQUAL & CMP may be uncorrelated */                                    \
+       if (M_CALL_EQUAL(oplist, *M_F(name, _array_cget)(p->array, i), x))     \
         break;                                                               \
     }                                                                        \
+     return i;                                                                \
+   }                                                                          \
+                                                                              \
+   M_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_INLINE void                                                              \
+   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 */                              \
+  M_INLINE void                                                               \
+  M_F(name, _it)(it_t it, prioqueue_t const v)                                \
+  {                                                                           \
+    M_F(name, _array_it)(it, v->array);                                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_last)(it_t it, prioqueue_t const v)                           \
+  {                                                                           \
+    M_F(name, _array_it_last)(it, v->array);                                  \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_end)(it_t it, prioqueue_t const v)                            \
+  {                                                                           \
+    M_F(name, _array_it_end)(it, v->array);                                   \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_set)(it_t it, const it_t org)                                 \
+  {                                                                           \
+    M_F(name, _array_it_set)(it, org);                                        \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _end_p)(const it_t it)                                            \
+  {                                                                           \
+    return M_F(name, _array_end_p)(it);                                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _last_p)(const it_t it)                                           \
+  {                                                                           \
+    return M_F(name, _array_last_p)(it);                                      \
+  }                                                                           \
+                                                                              \
+  M_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);                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _next)(it_t it)                                                   \
+  {                                                                           \
+    M_F(name, _array_next)(it);                                               \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _previous)(it_t it)                                               \
+  {                                                                           \
+    M_F(name, _array_previous)(it);                                           \
+  }                                                                           \
+                                                                              \
+  M_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)(                                               \
+  M_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)(                                                \
+  M_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)(                                               \
+  M_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)(                                             \
+  M_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)(                                            \
+  M_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)(                                      \
+  M_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_INLINE bool
+m_ser1al_bin_write_size(FILE *f, const size_t size)
 {
  bool b;
  if (M_LIKELY(size < 253))
@@ -83,8 +88,8 @@ m_serial_bin_write_size(FILE *f, const size_t size)
 * Read size_t in the stream from a compact form to reduce consumption
 * (and I/O bandwidth)
 */
-static inline bool
-m_serial_bin_read_size(FILE *f, size_t *size)
+M_INLINE bool
+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;
@@ -106,8 +111,8 @@ 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_INLINE m_serial_return_code_t
+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);
@@ -116,76 +121,61 @@ 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_INLINE m_serial_return_code_t
+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;
-  int32_t i32;
-  int64_t i64;
  size_t n;
  
  FILE *f = (FILE *)serial->data[0].p;
-  switch (size_of_type) {
-  case 1:
-    i8 = (int8_t) data;
+  if (size_of_type == 1) {
+    int8_t i8 = (int8_t) data;
    n = fwrite (M_ASSIGN_CAST(const void*, &i8), sizeof i8, 1, f);
-    break;
-  case 2:
-    i16 = (int16_t) data;
+  } else if (size_of_type == 2) {
+    int16_t i16 = (int16_t) data;
    n = fwrite (M_ASSIGN_CAST(const void*, &i16), sizeof i16, 1, f);
-    break;
-  case 4:
-    i32 = (int32_t) data;
+  } else if (size_of_type == 4) {
+    int32_t i32 = (int32_t) data;
    n = fwrite (M_ASSIGN_CAST(const void*, &i32), sizeof i32, 1, f);
-    break;
-  case 8:
-    i64 = (int64_t) data;
+  } else {
+    M_ASSERT(size_of_type == 8);
+    int64_t i64 = (int64_t) data;
    n = fwrite (M_ASSIGN_CAST(const void*, &i64), sizeof i64, 1, f);
-    break;
-  default:
-    M_ASSERT_INIT(false, "an integer of suitable size (8/16/32/64)");
-    break;
  }
  return n == 1 ? M_SERIAL_OK_DONE : m_core_serial_fail();
 }

 /* 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_INLINE m_serial_return_code_t
+m_ser1al_bin_write_float(m_serial_write_t serial, const long double data, const size_t size_of_type)
 {
-  float   f1;
-  double  f2;
-  long double f3;
  size_t n;
  
  FILE *f = (FILE *)serial->data[0].p;
-  if (size_of_type == sizeof f1) {
-    f1 = (float) data;
+  if (size_of_type == sizeof (float) ) {
+    float f1 = (float) data;
    n = fwrite (M_ASSIGN_CAST(const void*, &f1), sizeof f1, 1, f);
-  } else if (size_of_type == sizeof f2) {
-    f2 = (double) data;
+  } else if (size_of_type == sizeof (double) ) {
+    double f2 = (double) data;
    n = fwrite (M_ASSIGN_CAST(const void*, &f2), sizeof f2, 1, f);
-  } else if (size_of_type == sizeof f3) {
-    f3 = (long double) data;
-    n = fwrite (M_ASSIGN_CAST(const void*, &f3), sizeof f3, 1, f);
  } else {
-    M_ASSERT_INIT(false, "a float of suitable size");
+    M_ASSERT(size_of_type == sizeof (long double) );
+    long double f3 = (long double) data;
+    n = fwrite (M_ASSIGN_CAST(const void*, &f3), sizeof f3, 1, f);
  }
  return n == 1 ? M_SERIAL_OK_DONE : m_core_serial_fail();
 }

 /* 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_INLINE m_serial_return_code_t
+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);
@@ -198,51 +188,40 @@ m_serial_bin_write_string(m_serial_write_t serial, const char data[], size_t len
   Initialize 'local' so that it can be used to serialize the array 
   (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_INLINE m_serial_return_code_t
+m_ser1al_bin_write_array_start(m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements)
 {
+  (void) local; //Unused
+  if (number_of_elements == (size_t)-1) return M_SERIAL_FAIL_RETRY;
  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);
-  local->data[0].b = (number_of_elements == 0);
  return n == 1 ? M_SERIAL_OK_CONTINUE : m_core_serial_fail();
 }

 /* 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_INLINE  m_serial_return_code_t
+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 
-  if (local->data[0].b) {
-    size_t n = 0xABCDEF;
-    n = fwrite (M_ASSIGN_CAST(const void*, &n), sizeof n, 1, f);
-    return n == 1 ? M_SERIAL_OK_CONTINUE : m_core_serial_fail();    
-  } else {
-    return M_SERIAL_OK_CONTINUE;
-  }
+  (void) local; // Unused
+  (void) serial; // Unused
+  return M_SERIAL_OK_CONTINUE;
 }

 /* 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_INLINE   m_serial_return_code_t
+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 
-  if (local->data[0].b) {
-    size_t n = 0x12345678;
-    n = fwrite (M_ASSIGN_CAST(const void*, &n), sizeof n, 1, f);
-    return n == 1 ? M_SERIAL_OK_CONTINUE : m_core_serial_fail();    
-  } else {
-    return M_SERIAL_OK_CONTINUE;
-  }
+  (void) local; // Unused
+  (void) serial; // Unused
+  return M_SERIAL_OK_CONTINUE;
 }

 /* 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_INLINE   m_serial_return_code_t
+m_ser1al_bin_write_map_value(m_serial_local_t local, m_serial_write_t serial)
 {
  (void) local; // argument not used
  (void) serial;
@@ -253,8 +232,8 @@ m_serial_bin_write_map_value(m_serial_local_t local, m_serial_write_t serial)
   Initialize 'local' so that it can serial the tuple 
   (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_INLINE   m_serial_return_code_t
+m_ser1al_bin_write_tuple_start(m_serial_local_t local, m_serial_write_t serial)
 {
  (void) local; // argument not used
  (void) serial;
@@ -263,8 +242,8 @@ 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_INLINE   m_serial_return_code_t
+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;
@@ -276,8 +255,8 @@ 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_INLINE   m_serial_return_code_t
+m_ser1al_bin_write_tuple_end(m_serial_local_t local, m_serial_write_t serial)
 {
  (void) local; // argument not used
  (void) serial;
@@ -289,8 +268,8 @@ m_serial_bin_write_tuple_end(m_serial_local_t local, m_serial_write_t serial)
     Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise 
   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_INLINE   m_serial_return_code_t
+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;
@@ -302,8 +281,8 @@ 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_INLINE   m_serial_return_code_t
+m_ser1al_bin_write_variant_end(m_serial_local_t local, m_serial_write_t serial)
 {
  (void) local; // argument not used
  (void) serial;
@@ -311,32 +290,32 @@ 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)
+M_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);
 }

-static inline void m_serial_bin_write_clear(m_serial_write_t serial)
+M_INLINE void m_serial_bin_write_clear(m_serial_write_t serial)
 {
  (void) serial; // Nothing to do
 }
@@ -344,15 +323,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_INLINE  m_serial_return_code_t
+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();
@@ -361,34 +347,27 @@ m_serial_bin_read_boolean(m_serial_read_t serial, bool *b){
 /* Read from the stream 'serial' an integer that can be represented with 'size_of_type' bytes.
   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_INLINE  m_serial_return_code_t
+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;
  int64_t i64;
  size_t n;
  FILE *f = (FILE *)serial->data[0].p;
-  switch (size_of_type) {
-  case 1:
+  if (size_of_type == 1) {
    n = fread (M_ASSIGN_CAST(void*, &i8), sizeof i8, 1, f);
    *i = i8;
-    break;
-  case 2:
+  } else if (size_of_type == 2) {
    n = fread (M_ASSIGN_CAST(void*, &i16), sizeof i16, 1, f);
    *i = i16;
-    break;
-  case 4:
+  } else if (size_of_type ==  4) {
    n = fread (M_ASSIGN_CAST(void*, &i32), sizeof i32, 1, f);
    *i = i32;
-    break;
-  case 8:
+  } else {
+    M_ASSERT(size_of_type == 8);
    n = fread (M_ASSIGN_CAST(void*, &i64), sizeof i64, 1, f);
    *i = i64;
-    break;
-  default:
-    M_ASSERT_INIT(false, "an integer of suitable size");
-    break;
  }
  return n == 1 ? M_SERIAL_OK_DONE : m_core_serial_fail();
 }
@@ -396,8 +375,8 @@ m_serial_bin_read_integer(m_serial_read_t serial, long long *i, const size_t siz
 /* Read from the stream 'serial' a float that can be represented with 'size_of_type' bytes.
   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_INLINE  m_serial_return_code_t
+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;
@@ -409,11 +388,10 @@ m_serial_bin_read_float(m_serial_read_t serial, long double *r, const size_t siz
  } else if (size_of_type == sizeof f2) {
    n = fread (M_ASSIGN_CAST(void*, &f2), sizeof f2, 1, f);
    *r = f2;
-  } else if (size_of_type == sizeof f3) {
+  } else {
+    M_ASSERT(size_of_type == sizeof f3);
    n = fread (M_ASSIGN_CAST(void*, &f3), sizeof f3, 1, f);
    *r = f3;
-  } else {
-    M_ASSERT_INIT(false, "a float of suitable size");
  }
  return n == 1 ? M_SERIAL_OK_DONE : m_core_serial_fail();
 }
@@ -421,16 +399,16 @@ m_serial_bin_read_float(m_serial_read_t serial, long double *r, const size_t siz
 /* Read from the stream 'serial' a string.
   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_INLINE  m_serial_return_code_t
+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);
@@ -446,54 +424,34 @@ m_serial_bin_read_string(m_serial_read_t serial, struct string_s *s){
   Return M_SERIAL_OK_CONTINUE if it succeeds and the array continue,
   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_INLINE  m_serial_return_code_t
+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);
-  if (n != 1)
-    return m_core_serial_fail();
-  local->data[0].b = (*num == 0);
  local->data[1].s = *num;
-  if (local->data[0].b) {
-    // Size not know ==> use of marker in the stream.
-    size_t p;
-    n = fread (M_ASSIGN_CAST(void*, &p), sizeof p, 1, f);
-    if (n != 1)
-      return m_core_serial_fail();
-    return p == 0xABCDEF ? M_SERIAL_OK_CONTINUE : p == 0x12345678 ? M_SERIAL_OK_DONE : m_core_serial_fail();
-  }
-  return M_SERIAL_OK_CONTINUE;
+  return (n != 1) ? m_core_serial_fail() : (local->data[1].s == 0) ? M_SERIAL_OK_DONE : M_SERIAL_OK_CONTINUE;
 }

 /* Continue reading from the stream 'serial' an array.
   Return M_SERIAL_OK_CONTINUE if it succeeds and the array continue,
   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_INLINE  m_serial_return_code_t
+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) {
-    // Size not know ==> use of marker in the stream.
-    size_t p, n;
-    n = fread (M_ASSIGN_CAST(void*, &p), sizeof p, 1, f);
-    if (n != 1)
-      return m_core_serial_fail();
-    return p == 0xABCDEF ? M_SERIAL_OK_CONTINUE : p == 0x12345678 ? M_SERIAL_OK_DONE : m_core_serial_fail();
-  } else {
-    M_ASSERT(local->data[1].s > 0);
-    local->data[1].s --;
-    return local->data[1].s == 0 ? M_SERIAL_OK_DONE : M_SERIAL_OK_CONTINUE;
-  }
+  (void) serial; // Unused
+  M_ASSERT(local->data[1].s > 0);
+  local->data[1].s --;
+  return local->data[1].s == 0 ? M_SERIAL_OK_DONE : M_SERIAL_OK_CONTINUE;
 }


 /* Continue reading from the stream 'serial' the value separator
   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_INLINE  m_serial_return_code_t
+m_ser1al_bin_read_map_value(m_serial_local_t local, m_serial_read_t serial)
 {
  (void) local; // argument not used
  (void) serial;
@@ -503,8 +461,8 @@ m_serial_bin_read_map_value(m_serial_local_t local, m_serial_read_t serial)
 /* Start reading a tuple from the stream '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_INLINE  m_serial_return_code_t
+m_ser1al_bin_read_tuple_start(m_serial_local_t local, m_serial_read_t serial)
 {
  (void) serial;
  local->data[1].i = 0;
@@ -517,8 +475,8 @@ m_serial_bin_read_tuple_start(m_serial_local_t local, m_serial_read_t serial)
   Return M_SERIAL_OK_CONTINUE if it succeeds and the tuple continues,
   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_INLINE  m_serial_return_code_t
+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;
@@ -534,8 +492,8 @@ m_serial_bin_read_tuple_id(m_serial_local_t local, m_serial_read_t serial, const
   Return M_SERIAL_OK_CONTINUE if it succeeds and the variant continues,
   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_INLINE  m_serial_return_code_t
+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;
@@ -548,37 +506,37 @@ m_serial_bin_read_variant_start(m_serial_local_t local, m_serial_read_t serial,
 /* End reading a variant from the stream '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_INLINE  m_serial_return_code_t
+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)
+M_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);
 }

-static inline void m_serial_bin_read_clear(m_serial_read_t serial)
+M_INLINE void m_serial_bin_read_clear(m_serial_read_t serial)
 {
  (void) serial; // Nothing to do
 }
@@ -586,7 +544,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,239 @@

 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))                                                       \
-  ,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),)                           \
+#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))                                                       \
  )

 // 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; }
+M_INLINE void m_shar3d_integer_init_set(int *p, int val) { *p = val; }
+M_INLINE int m_shar3d_integer_add(int *p, int val) { int r = *p;  *p += val; return r; }
+M_INLINE int m_shar3d_integer_sub(int *p, int val) { int r = *p;  *p -= val; return r; }
+M_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];                                                 \
+    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)       \
                                                                              \
-  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
-                                                                              \
-  static inline void                                                          \
-  M_C(name, _init)(shared_t shared)                                           \
+  M_INLINE void                                                               \
+  M_F(name, _init)(shared_t shared)                                           \
  {                                                                           \
    *shared = NULL;                                                           \
  }                                                                           \
                                                                              \
-  static inline void                                                          \
-  M_C(name, _init2)(shared_t shared, type *data)                              \
+  M_INLINE void                                                               \
+  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);                                    \
  }                                                                           \
                                                                              \
-  static inline void                                                          \
-  M_C(name, _init_new)(shared_t shared)                                       \
+  M_IF_METHOD(INIT, oplist)(                                                  \
+  M_INLINE void                                                               \
+  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_INLINE bool                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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,224 +278,231 @@ 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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE bool                                                               \
+  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_INLINE type const *                                                       \
+  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);                                                  \
    return M_CONST_CAST (type, data);                                         \
  }                                                                           \
                                                                              \
-  static inline type *                                                        \
-  M_C(name, _ref)(shared_t shared)                                            \
+  M_INLINE type *                                                             \
+  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);                                            \
-                                                                              \
-  static inline void                                                          \
-  M_C(name, _init)(shared_t s, size_t n)                                      \
+  typedef shared_t M_F(name, _ct);                                            \
+
+/* Define the core functions */
+#define M_SHAR3D_RESOURCE_DEF_CORE(name, type, oplist, shared_t, it_t)        \
+  M_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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_INLINE bool                                                               \
+  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_INLINE type *                                                             \
+  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_INLINE type const *                                                       \
+  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_INLINE void                                                               \
+  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_INLINE void                                                               \
+  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 +510,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