libsheepy

commit e72d85d9afaf2f22b4e9c52c87abacc87f176ff0
parent 82fdf683fbe46d8afa1da8d072152ddce069bb8c
Author: Remy Noulin <loader2x@gmail.com>
Date:   Mon, 31 Aug 2020 12:33:37 +0200

Ignore NULL elements in arrays (happens after elements are deleted from the array, positions of deleted elements are set to NULL) to avoid the need to compact arrays

src/json/libsheepyCSmallArray.c | 85 +++++++++++++++++++++++++++++++++++
src/json/libsheepyCSmallDict.c  |  8 +++-
src/json/libsheepyCSmallJson.c  | 98 ++++++++++++++++++++++++++++++++++++++++-
src/json/libsheepyObject.c      |  6 +++
src/libsheepy.h                 |  2 +-
5 files changed, 196 insertions(+), 3 deletions(-)

Diffstat:
M
src/json/libsheepyCSmallArray.c
 | 
85
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
M
src/json/libsheepyCSmallDict.c
 | 
8
+++++++-
M
src/json/libsheepyCSmallJson.c
 | 
98
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
M
src/json/libsheepyObject.c
 | 
6
++++++
M
src/libsheepy.h
 | 
2
+-

5 files changed, 196 insertions(+), 3 deletions(-)
diff --git a/src/json/libsheepyCSmallArray.c b/src/json/libsheepyCSmallArray.c
@@ -5928,6 +5928,14 @@ internal bool equalSmallArray(smallArrayt *self, smallArrayt *array) {
   char *es = NULL;
   char *as = NULL;
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      if (not sArrayGetTiny(array->a, i)) {
+        continue;
+      }
+      else {
+        return(false);
+    }
+      }
     if ((e->type != sArrayGetTiny(array->a, i)->type)) {
       return(false);
     }
@@ -6026,6 +6034,9 @@ internal bool equalSmallArrayArray(smallArrayt* self, char ** p2) {
 
   // compare elements
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      return(false);
+    }
     if (e->type != STRING) {
       return(false);
     }
@@ -6075,6 +6086,14 @@ internal bool icEqualSmallArray(smallArrayt *self, smallArrayt *array) {
   char *es = NULL;
   char *as = NULL;
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      if (not sArrayGetTiny(array->a, i)) {
+        continue;
+      }
+      else {
+        return(false);
+    }
+      }
     if ((e->type != sArrayGetTiny(array->a, i)->type)) {
       return(false);
     }
@@ -6179,6 +6198,9 @@ bool icEqualSmallArrayArray(smallArrayt* self, char ** p2) {
 
   // compare elements
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      return(false);
+    }
     if (e->type != STRING) {
       return(false);
     }
@@ -8055,6 +8077,9 @@ internal ssize_t indexOfSmallArray(smallArrayt *self, baset *value) {
   char *es = NULL;
 
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      continue;
+    }
     es = sToString(e);
     if (strEq(es, s)) {
       free(es);
@@ -8080,6 +8105,9 @@ internal ssize_t indexOfUndefinedSmallArray(smallArrayt *self, undefinedt *undef
 
   // search string in elements
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == UNDEFINED) {
       return(i);
   }
@@ -8096,6 +8124,9 @@ internal ssize_t indexOfBoolSmallArray(smallArrayt *self, bool value) {
 
   // search value in elements
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == BOOL && ((sBoolt*)e)->value == value) {
       return(i);
   }
@@ -8112,6 +8143,9 @@ internal ssize_t indexOfDoubleSmallArray(smallArrayt *self, double value) {
 
   // search value in elements
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == DOUBLE && ((sDoublet*)e)->value == value) {
       return(i);
   }
@@ -8128,6 +8162,9 @@ internal ssize_t indexOfIntSmallArray(smallArrayt *self, int64_t value) {
 
   // search value in elements
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == INT && ((sIntt*)e)->value == value) {
       return(i);
   }
@@ -8146,6 +8183,9 @@ internal ssize_t indexOfSSmallArray(smallArrayt *self, const char *string) {
   }
   // search string in elements
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == STRING && strEq(sStringGetTiny((sStringt*)e), string)) {
       return(i);
   }
@@ -8175,6 +8215,9 @@ internal ssize_t indexOfDictSmallArray(smallArrayt *self, smallDictt *dict) {
   char *es = NULL;;
 
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == DICT) {
       es = sToString(e);
       if (strEq(es, s)) {
@@ -8205,6 +8248,9 @@ internal ssize_t indexOfArraySmallArray(smallArrayt *self, smallArrayt *array) {
   char *es = NULL;;
 
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == ARRAY) {
       es = sToString(e);
       if (strEq(es, s)) {
@@ -8233,6 +8279,9 @@ internal ssize_t indexOfArraycSmallArray(smallArrayt *self, char **array) {
   char *es = NULL;;
 
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == ARRAY) {
       es = sToString(e);
       if (strEq(es, s)) {
@@ -8262,6 +8311,9 @@ internal ssize_t indexOfSmallBoolSmallArray(smallArrayt *self, smallBoolt *value
   bool b = value->f->get(value);
 
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == BOOL && ((sBoolt*)e)->value == b) {
       return(i);
   }
@@ -8285,6 +8337,9 @@ internal ssize_t indexOfSmallBytesSmallArray(smallArrayt *self, smallBytest *val
   uint32_t count = value->B->count;
 
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == BYTES && ((sBytest*)e)->count == count && !memcmp(&(((sBytest*)e)->data), b, count)) {
       return(i);
   }
@@ -8307,6 +8362,9 @@ internal ssize_t indexOfSmallDoubleSmallArray(smallArrayt *self, smallDoublet *v
   double v = value->f->get(value);
 
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == DOUBLE && ((sDoublet*)e)->value == v) {
       return(i);
   }
@@ -8329,6 +8387,9 @@ internal ssize_t indexOfSmallIntSmallArray(smallArrayt *self, smallIntt *value) 
   int64_t v = value->f->get(value);
 
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == INT && ((sIntt*)e)->value == v) {
       return(i);
   }
@@ -8413,6 +8474,9 @@ internal ssize_t indexOfSmallStringSmallArray(smallArrayt *self, smallStringt *s
   char *s = sStringGetTiny(string->data);
 
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == STRING && strEq(sStringGetTiny((sStringt*)e), s)) {
       return(i);
   }
@@ -9174,6 +9238,9 @@ internal ssize_t icIndexOfSmallArray(smallArrayt *self, baset *value) {
   char *es = NULL;
 
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      continue;
+    }
     es = sToString(e);
     if (icEqS(es, s)) {
       free(es);
@@ -9197,6 +9264,9 @@ internal ssize_t icIndexOfSSmallArray(smallArrayt *self, const char *string) {
   }
   // search string in elements
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == STRING && icEqS(sStringGetTiny((sStringt*)e), string)) {
       return(i);
   }
@@ -9226,6 +9296,9 @@ internal ssize_t icIndexOfDictSmallArray(smallArrayt *self, smallDictt *dict) {
   char *es = NULL;;
 
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == DICT) {
       es = sToString(e);
       if (icEqS(es, s)) {
@@ -9256,6 +9329,9 @@ internal ssize_t icIndexOfArraySmallArray(smallArrayt *self, smallArrayt *array)
   char *es = NULL;;
 
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == ARRAY) {
       es = sToString(e);
       if (icEqS(es, s)) {
@@ -9284,6 +9360,9 @@ internal ssize_t icIndexOfArraycSmallArray(smallArrayt *self, char **array) {
   char *es = NULL;;
 
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == ARRAY) {
       es = sToString(e);
       if (icEqS(es, s)) {
@@ -9374,6 +9453,9 @@ internal ssize_t icIndexOfSmallStringSmallArray(smallArrayt *self, smallStringt 
   char *s = sStringGetTiny(string->data);
 
   enumerateSArray(self->a, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == STRING && icEqS(sStringGetTiny((sStringt*)e), s)) {
       return(i);
   }
@@ -9891,6 +9973,9 @@ internal bool isBlankSmallArray(smallArrayt *self) {
 internal void forEachSmallArrayF(smallArrayt *self, void *closure, forEachElementSmallArrayFt funcElem) {
 
   forEachSmallArray(self, e) {
+    if (not e) {
+      continue;
+    }
     if (!funcElem(closure, e)) {
       finishO(e);
       break;
diff --git a/src/json/libsheepyCSmallDict.c b/src/json/libsheepyCSmallDict.c
@@ -4603,6 +4603,9 @@ internal smallDictt* zipSmallDict(smallDictt *self, smallArrayt *keys, smallArra
   count = 0;
 
   forEachSmallArray(keys, K) {
+    if (not K) {
+      return(NULL);
+    }
     castS(k, K);
     sDictSetTiny(&(self->d), ssGet(k), sArrayGetTiny(values->a, count));
     finishO(K);
@@ -4834,6 +4837,9 @@ internal smallDictt* zipVArraySmallDict(smallDictt *self, smallArrayt *keys, cha
 
   smallt *e;
   forEachSmallArray(keys, K) {
+    if (not K) {
+      return(NULL);
+    }
     castS(k, K);
     e = (smallt *) allocSStringTiny(values[count]);;
     sDictSetTiny(&(self->d), ssGet(k), e);
@@ -4862,7 +4868,7 @@ internal smallDictt* fromArraySmallDict(smallDictt *self, smallArrayt *items) {
   }
 
   forEachSmallArray(items, E) {
-    if (!isOType(E, "smallArray")) {
+    if (not E or !isOType(E, "smallArray")) {
       goto cont;
     }
     cast(smallArrayt*, a, E);
diff --git a/src/json/libsheepyCSmallJson.c b/src/json/libsheepyCSmallJson.c
@@ -3446,7 +3446,7 @@ internal smallJsont* fromArrayDictSmallJson(smallJsont *self, smallArrayt *items
   }
 
   forEachSmallArray(items, E) {
-    if (!isOType(E, "smallArray")) {
+    if (!E || !isOType(E, "smallArray")) {
       goto cont;
     }
     cast(smallArrayt*, a, E);
@@ -12092,6 +12092,9 @@ internal ssize_t indexOfSmallJson(smallJsont *self, baset *value) {
   char *es = NULL;
 
   enumerateSArray(self->topA, e, i) {
+    if (not e) {
+      continue;
+    }
     es = sToString(e);
     if (strEq(es, s)) {
       free(es);
@@ -12121,6 +12124,9 @@ internal ssize_t indexOfUndefinedSmallJson(smallJsont *self, undefinedt *undefin
 
   // search string in elements
   enumerateSArray(self->topA, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == UNDEFINED) {
       return(i);
   }
@@ -12141,6 +12147,9 @@ internal ssize_t indexOfBoolSmallJson(smallJsont *self, bool value) {
 
   // search value in elements
   enumerateSArray(self->topA, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == BOOL && ((sBoolt*)e)->value == value) {
       return(i);
   }
@@ -12161,6 +12170,9 @@ internal ssize_t indexOfDoubleSmallJson(smallJsont *self, double value) {
 
   // search value in elements
   enumerateSArray(self->topA, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == DOUBLE && ((sDoublet*)e)->value == value) {
       return(i);
   }
@@ -12181,6 +12193,9 @@ internal ssize_t indexOfIntSmallJson(smallJsont *self, int64_t value) {
 
   // search value in elements
   enumerateSArray(self->topA, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == INT && ((sIntt*)e)->value == value) {
       return(i);
   }
@@ -12206,6 +12221,9 @@ internal ssize_t indexOfSSmallJson(smallJsont *self, const char *string) {
       }
       // search string in elements
       enumerateSArray(self->topA, e, i) {
+        if (not e) {
+          continue;
+        }
         if (e->type == STRING && strEq(sStringGetTiny((sStringt*)e), string)) {
           return(i);
       }
@@ -12243,6 +12261,9 @@ internal ssize_t indexOfDictSmallJson(smallJsont *self, smallDictt *dict) {
   char *es = NULL;;
 
   enumerateSArray(self->topA, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == DICT) {
       es = sToString(e);
       if (strEq(es, s)) {
@@ -12277,6 +12298,9 @@ internal ssize_t indexOfArraySmallJson(smallJsont *self, smallArrayt *array) {
   char *es = NULL;;
 
   enumerateSArray(self->topA, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == ARRAY) {
       es = sToString(e);
       if (strEq(es, s)) {
@@ -12309,6 +12333,9 @@ internal ssize_t indexOfArraycSmallJson(smallJsont *self, char **array) {
   char *es = NULL;;
 
   enumerateSArray(self->topA, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == ARRAY) {
       es = sToString(e);
       if (strEq(es, s)) {
@@ -12342,6 +12369,9 @@ internal ssize_t indexOfSmallBoolSmallJson(smallJsont *self, smallBoolt *value) 
   bool b = value->f->get(value);
 
   enumerateSArray(self->topA, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == BOOL && ((sBoolt*)e)->value == b) {
       return(i);
   }
@@ -12369,6 +12399,9 @@ internal ssize_t indexOfSmallBytesSmallJson(smallJsont *self, smallBytest *value
   uint32_t count = value->B->count;
 
   enumerateSArray(self->topA, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == BYTES && ((sBytest*)e)->count == count && !memcmp(&(((sBytest*)e)->data), b, count)) {
       return(i);
   }
@@ -12395,6 +12428,9 @@ internal ssize_t indexOfSmallDoubleSmallJson(smallJsont *self, smallDoublet *val
   double v = value->f->get(value);
 
   enumerateSArray(self->topA, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == DOUBLE && ((sDoublet*)e)->value == v) {
       return(i);
   }
@@ -12421,6 +12457,9 @@ internal ssize_t indexOfSmallIntSmallJson(smallJsont *self, smallIntt *value) {
   int64_t v = value->f->get(value);
 
   enumerateSArray(self->topA, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == INT && ((sIntt*)e)->value == v) {
       return(i);
   }
@@ -12512,6 +12551,9 @@ internal ssize_t indexOfSmallStringSmallJson(smallJsont *self, smallStringt *str
       }
 
       enumerateSArray(self->topA, e, i) {
+        if (not e) {
+          continue;
+        }
         if (e->type == STRING && strEq(sStringGetTiny((sStringt*)e), s)) {
           return(i);
       }
@@ -13290,6 +13332,9 @@ internal ssize_t icIndexOfSmallJson(smallJsont *self, baset *value) {
   char *es = NULL;
 
   enumerateSArray(self->topA, e, i) {
+    if (not e) {
+      continue;
+    }
     es = sToString(e);
     if (icEqS(es, s)) {
       free(es);
@@ -13320,6 +13365,9 @@ internal ssize_t icIndexOfSSmallJson(smallJsont *self, const char *string) {
       }
       // search string in elements
       enumerateSArray(self->topA, e, i) {
+        if (not e) {
+          continue;
+        }
         if (e->type == STRING && icEqS(sStringGetTiny((sStringt*)e), string)) {
           return(i);
       }
@@ -13357,6 +13405,9 @@ internal ssize_t icIndexOfDictSmallJson(smallJsont *self, smallDictt *dict) {
   char *es = NULL;;
 
   enumerateSArray(self->topA, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == DICT) {
       es = sToString(e);
       if (icEqS(es, s)) {
@@ -13391,6 +13442,9 @@ internal ssize_t icIndexOfArraySmallJson(smallJsont *self, smallArrayt *array) {
   char *es = NULL;;
 
   enumerateSArray(self->topA, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == ARRAY) {
       es = sToString(e);
       if (icEqS(es, s)) {
@@ -13423,6 +13477,9 @@ internal ssize_t icIndexOfArraycSmallJson(smallJsont *self, char **array) {
   char *es = NULL;;
 
   enumerateSArray(self->topA, e, i) {
+    if (not e) {
+      continue;
+    }
     if (e->type == ARRAY) {
       es = sToString(e);
       if (icEqS(es, s)) {
@@ -13462,6 +13519,9 @@ internal ssize_t icIndexOfSmallStringSmallJson(smallJsont *self, smallStringt *s
       }
 
       enumerateSArray(self->topA, e, i) {
+        if (not e) {
+          continue;
+        }
         if (e->type == STRING && icEqS(sStringGetTiny((sStringt*)e), s)) {
           return(i);
       }
@@ -14895,6 +14955,9 @@ internal bool equalSmallJsonSmallArray(smallJsont *self, smallArrayt *array) {
   char *es = NULL;
   char *as = NULL;
   enumerateSArray(self->topA, e, i) {
+    if (not e) {
+      return(false);
+    }
     if ((e->type != sArrayGetTiny(array->a, i)->type)) {
       return(false);
     }
@@ -14975,6 +15038,9 @@ bool equalSmallJsonArray(smallJsont *self, char ** p2) {
 
   // compare elements
   enumerateSArray(self->topA, e, i) {
+    if (not e) {
+      return(false);
+    }
     if (e->type != STRING) {
       return(false);
     }
@@ -15539,6 +15605,9 @@ internal bool icEqualSmallJsonSmallArray(smallJsont *self, smallArrayt *array) {
   char *es = NULL;
   char *as = NULL;
   enumerateSArray(self->topA, e, i) {
+    if (not e) {
+      return(false);
+    }
     if ((e->type != sArrayGetTiny(array->a, i)->type)) {
       return(false);
     }
@@ -15615,6 +15684,9 @@ bool icEqualSmallJsonArray(smallJsont *self, char ** p2) {
 
   // compare elements
   enumerateSArray(self->topA, e, i) {
+    if (not e) {
+      return(false);
+    }
     if (e->type != STRING) {
       return(false);
     }
@@ -16641,6 +16713,9 @@ internal void forEachSmallJsonF(smallJsont *self, void *closure, forEachElementS
   }
 
   forEachSmallJson(self, e) {
+    if (!e) {
+      continue;
+    }
     if (!funcElem(closure, e)) {
       finishO(e);
       break;
@@ -16658,6 +16733,9 @@ internal void enumerateSmallJsonF(smallJsont *self, void *closure, enumerateElem
   }
 
   enumerateSArray(self->topA, e, i) {
+    if (not e) {
+      continue;
+    }
     baset *E = toBaset(e);
     if (!funcElem(closure, i, E)) {
       if (e->type == CONTAINER && ((sContainert*)e)->dataType == SH_DT_BASET) {
@@ -17614,6 +17692,9 @@ internal smallJsont* zipSmallJson(smallJsont *self, smallArrayt *array1, smallAr
     count = 0;
 
     forEachSmallArray(array1, K) {
+      if (!K) {
+        return(NULL);
+      }
       castS(k, K);
       sDictSetTiny(&(self->top), ssGet(k), sArrayGetTiny(array2->a, count));
       finishO(K);
@@ -17730,6 +17811,9 @@ internal smallJsont* zipCharSmallJson(smallJsont *self, smallArrayt *array1, cha
 
     smallt *e;
     forEachSmallArray(array1, K) {
+      if (!K) {
+        return(NULL);
+      }
       castS(k, K);
       e = (smallt *) allocSStringTiny(array2[count]);;
       sDictSetTiny(&(self->top), ssGet(k), e);
@@ -17847,6 +17931,9 @@ smallJsont* zipJsonSmallJson(smallJsont *self, smallJsont *array1, smallJsont *a
     count = 0;
 
     forEachSmallJson(array1, K) {
+      if (!K) {
+        return(NULL);
+      }
       castS(k, K);
       sDictSetTiny(&(self->top), ssGet(k), sArrayGetTiny(array2->topA, count));
       finishO(K);
@@ -17910,6 +17997,9 @@ smallJsont* zipJsonSmallArraySmallJson(smallJsont *self, smallJsont *array1, sma
     count = 0;
 
     forEachSmallJson(array1, K) {
+      if (!K) {
+        return(NULL);
+      }
       castS(k, K);
       sDictSetTiny(&(self->top), ssGet(k), sArrayGetTiny(array2->a, count));
       finishO(K);
@@ -17974,6 +18064,9 @@ smallJsont* zipJsonArraySmallJson(smallJsont *self, smallJsont *array1, char** a
 
     smallt *e;
     forEachSmallJson(array1, K) {
+      if (!K) {
+        return(NULL);
+      }
       castS(k, K);
       e = (smallt *) allocSStringTiny(array2[count]);;
       sDictSetTiny(&(self->top), ssGet(k), e);
@@ -18037,6 +18130,9 @@ smallJsont* zipSmallArrayJsonSmallJson(smallJsont *self, smallArrayt *array1, sm
     count = 0;
 
     forEachSmallArray(array1, K) {
+      if (!K) {
+        return(NULL);
+      }
       castS(k, K);
       sDictSetTiny(&(self->top), ssGet(k), sArrayGetTiny(array2->topA, count));
       finishO(K);
diff --git a/src/json/libsheepyObject.c b/src/json/libsheepyObject.c
@@ -3613,6 +3613,9 @@ bool equalArrayOG(char ** p1, baset* p2) {
   // compare elements
   // TODO compare any types of element, not only strings
   enumerateSArray(arr->a, e, i) {
+    if (not e) {
+      return(false);
+    }
     if (!strEq(sStringGetTiny((sStringt*)e), p1[i])) {
       return(false);
   }
@@ -4960,6 +4963,9 @@ bool icEqualArrayOG(char ** p1, baset* p2) {
   // compare elements
   // TODO compare any types of element, not only strings
   enumerateSArray(arr->a, e, i) {
+    if (not e) {
+      return(false);
+    }
     if (!icEqS(sStringGetTiny((sStringt*)e), p1[i])) {
       return(false);
   }
diff --git a/src/libsheepy.h b/src/libsheepy.h
@@ -98,7 +98,7 @@
 
 // version accoring to the version package: Release.Major.minor.patch
 // https://noulin.net/version/file/README.md.html
-#define LIBSHEEPY_VERSION "1.2.3.1"
+#define LIBSHEEPY_VERSION "1.2.3.2"
 
 #ifndef SH_PREFIX
 #define SH_PREFIX(NAME) NAME