libsheepy

libsheepySmall.c (53276B)

---

 // MIT License
 //
 // Copyright (c) 2026 Remy Noulin
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 #include "libsheepySmall.h"
 #include <inttypes.h>
 
 #define internal static
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <stdbool.h>
 #include <string.h>
 #include <stdio.h>
 
 bool isSTypeF(smallt *obj, char sType);
 size_t sSizeTiny(smallt *obj);
 sBoolt* allocSBool(bool value);
 sContainert* allocSContainer(void *data);
 sDictt* allocSDict(void);
 sDoublet* allocSDouble(double value);
 sIntt* allocSInt(int64_t value);
 sStringt* allocSStringTiny(const char* data);
 sArrayt* allocSArray(void);
 sUndefinedt* allocSUndefined(void);
 sBytest* allocSBytes(void);
 void sFree(smallt *obj);
 void sFreeTiny(smallt *obj);
 void sDictFreeElement(sDictElemt *e);
 void sDictFreeElements(sDictt *dict);
 void sDictFreeTiny(sDictt *dict);
 void sArrayFreeElements(sArrayt *array);
 void sArrayFreeTiny(sArrayt *array);
 smallt* sDuplicate(smallt *o);
 smallt* sDuplicateTiny(smallt *obj);
 sDictt* sDictDuplicateTiny(sDictt *dict);
 sArrayt* sArrayDuplicateTiny(sArrayt *array);
 char* sToStringTiny(smallt *obj);
 char* sToString(smallt *obj);
 char* sBoolToStringTiny(sBoolt* obj);
 char* sContainerToStringTiny(sContainert* obj UNUSED);
 char* sDictToStringTiny(sDictt* obj);
 char* sDoubleToStringTiny(sDoublet* obj);
 char* sIntToStringTiny(sIntt* obj);
 char* sStringToStringTiny(sStringt* obj);
 char* sArrayToStringTiny(sArrayt* obj);
 char* sUndefinedToStringTiny(sUndefinedt* obj UNUSED);
 char* sBytesToStringTiny(sBytest* obj);
 char* sEscapeTiny(smallt *obj);
 char* sEscape(smallt *obj);
 char* sDictEscapeTiny(sDictt* obj);
 char* sStringEscapeTiny(sStringt* obj);
 char* sArrayEscapeTiny(sArrayt* obj);
 char* sTypesTiny(smallt* obj);
 sBytest* sTypesToBytesTiny(smallt *obj);
 const char** sDictTypeStrings(sDictt* obj);
 const char ** sTypesToStrings(sBytest *types);
 sBytest* sDictTypes(sDictt* obj);
 sBytest* sDictTypesTiny(sDictt* obj);
 const char** sArrayTypeStrings(sArrayt* obj);
 sBytest* sArrayTypes(sArrayt* obj);
 sBytest* sArrayTypesTiny(sArrayt* obj);
 smallt* sDictGet(sDictt *dict, const char *key);
 smallt** sDictGetP(sDictt *dict, const char *key);
 smallt* sDictGetTiny(sDictt *dict, const char *key);
 void sDictSetP(sDictt **dict, const char *key, smallt *data);
 void sDictSetTiny(sDictt **dict, const char *key, smallt *data);
 void sDictPushTiny(sDictt **dict, const char *key, smallt *data);
 void sDictDelTiny(sDictt *dict, const char *key);
 char* sStringGetTiny(sStringt *string);
 void sStringSetTiny(sStringt **string, const char *news);
 void sArrayPushTiny(sArrayt **array, smallt* data);
 void sArrayPrependTiny(sArrayt **array, smallt* data);
 smallt* sArrayPopTiny(sArrayt *array);
 smallt* sArrayDequeueTiny(sArrayt *array);
 smallt** sArrayGetP(sArrayt *array, uint32_t index);
 smallt* sArrayGetTiny(sArrayt *array, uint32_t index);
 void sArraySetShortTiny(sArrayt *array, uint32_t index, smallt *value);
 void sArraySetP(sArrayt *array, uint32_t index, smallt *value);
 void sArraySetTiny(sArrayt *array, uint32_t index, smallt *value);
 int sArrayReverseTiny(sArrayt *array);
 void sArrayDelTiny(sArrayt *array, uint32_t index);
 void sArrayDelRangeTiny(sArrayt *array, uint32_t start, uint32_t end);
 void* sBytesGet(sBytest *bytes);
 void* sBytesGetTiny(sBytest *bytes);
 void sBytesPush(sBytest **bytes, char data);
 void sBytesPushBuffer(sBytest **bytes, void* data, uint32_t size);
 void sBytesPushBufferTiny(sBytest **bytes, void* data, uint32_t size);
 sBytest *sSerial(smallt *obj);
 sBytest *sSerialTiny(smallt *obj);
 void sDictSerialElementsTiny(sBytest **r, sDictt *dict);
 void sArraySerialElementsTiny(sBytest **r, sArrayt *array);
 smallt* sDeserial(sBytest *obj);
 smallt* sDeserialTiny(sBytest *obj);
 void sDictDeserialElementsTiny(sDictt **dict, char **data);
 void sArrayDeserialElementsTiny(sArrayt **array, char **data);
 
 /** \file
  * Functions for the small objects smallt
  *
  * The small objects are used internally in the small baset objects: smallBoolt, smallContainert...
  *
  * The functions here implement basic functionnality.
  *
  * The *Tiny functions dont sanitize the parameters.
  * The *Short functions dont create objects and do the minimum possible and have no checks.
  *
  * Adjust SDICT_MIN_ELEMENTS, SDICT_REALLOC_STEPS, SARRAY_MIN_ELEMENTS and SARRAY_REALLOC_STEPS to balance speed
  * and memory usage.
  */
 
 // min MIN_ELEMENTS is 1
 #define SDICT_MIN_ELEMENTS     12
 #define SDICT_REALLOC_STEPS    4
 // min MIN_ELEMENTS is 1
 #define SARRAY_MIN_ELEMENTS    4
 #define SARRAY_REALLOC_STEPS   4
 
 /**
  * is Small Type
  * true if obj has type sType
  *
  * \param
  *    obj small object to check
  * \return
  *    true if object has type sType
  */
 bool isSTypeF(smallt *obj, char sType) {
 
   if (!obj) {
     return(false);
   }
   return(isSType(obj, sType));
 }
 
 /**
  * unused function and wrong result
  * TODO update or remove
  */
 size_t sSizeTiny(smallt *obj) {
   size_t r = 0;;
 
   /* if !obj */
   /*   return 0 */
 
   switch(obj->type) {
     case UNDEFINED:
       r = sizeof(sUndefinedt);
       break;
     case BOOL:
       r = sizeof(sBoolt);
       break;
     case CONTAINER:
       r = sizeof(sContainert);
       break;
     case DICT:
       if (!((sDictt *)obj)->count) {
         r = sizeof(sDictt);
       }
       else {
         r = sizeof(sDictt) + sizeof(sDictElemt) * (((sDictt *)obj)->count - 1);
       }
       break;
     case DOUBLE:
       r = sizeof(sDoublet);
       break;
     case INT:
       r = sizeof(sIntt);
       break;
     case STRING:
       r = sizeof(sStringt) + strlen(&(((sStringt *)obj)->data));
       break;
     case ARRAY:
       if (!((sArrayt* )obj)->count) {
         r = sizeof(sArrayt);
       }
       else {
         r = sizeof(sArrayt) + sizeof(smallt *) * (((sArrayt* )obj)->count - 1);
       }
       break;
     case BYTES:
       if (!((sBytest* )obj)->count) {
         r = sizeof(sBytest);
       }
       else {
         r = sizeof(sBytest) + sizeof(char) * (((sBytest* )obj)->count - 1);
       }
       break;
     default:;
       // return 0
   }
   return(r);
 }
 
 /**
  * allocate a small bool
  *
  * \param
  *    value initialize object with value
  * \return
  *    new object initialized with value
  */
 sBoolt* allocSBool(bool value) {
   sBoolt *r = NULL;
 
   isError(r, malloc(sizeof(sBoolt))) return(NULL);
   r->type  = BOOL;
   r->value = value;
   return(r);
 }
 
 /**
  * allocate a small container
  * The container holds a pointer to a user buffer
  *
  * \param
  *    data initialize object with data pointer
  * \return
  *    new object initialized with data pointer
  */
 sContainert* allocSContainer(void *data) {
   sContainert *r = NULL;
 
   isError(r, malloc(sizeof(sContainert))) return(NULL);
   r->type     = CONTAINER;
   r->dataType = SH_DT_UNKNOWN;
   r->data     = data;
   r->free     = NULL;
   return(r);
 }
 
 /**
  * allocate a small dict
  *
  * \return
  *    new empty dict
  */
 sDictt* allocSDict(void) {
   sDictt *r = NULL;
 
   isError(r, malloc(sizeof(sDictt) + sizeof(sDictElemt) * (SDICT_MIN_ELEMENTS-1))) return(NULL);
   r->type     = DICT;
   r->count    = 0;
   r->maxCount = SDICT_MIN_ELEMENTS;
   return(r);
 }
 
 /**
  * allocate a small double
  *
  * \param
  *    value initialize object with value
  * \return
  *    new object initialized with value
  */
 sDoublet* allocSDouble(double value) {
   sDoublet *r = NULL;
 
   isError(r, malloc(sizeof(sDoublet))) return(NULL);
   r->type  = DOUBLE;
   r->value = value;
   return(r);
 }
 
 /**
  * allocate a small int
  *
  * \param
  *    value initialize object with value
  * \return
  *    new object initialized with value
  */
 sIntt* allocSInt(int64_t value) {
   sIntt *r = NULL;
 
   isError(r, malloc(sizeof(sIntt))) return(NULL);
   r->type  = INT;
   r->value = value;
   return(r);
 }
 
 /**
  * allocate a small string
  *
  * \param
  *    value initialize object with value
  * \return
  *    new object initialized with value
  */
 sStringt* allocSStringTiny(const char* data) {
   sStringt *r = NULL;
   size_t len;
   char *T = NULL;
 
   len      = strlen(data);
   isError(r, malloc(sizeof(sStringt) + len)) return(NULL);
   r->type  = STRING;
   // should be: strcpy(&(r->data), data); but it fails (Abort trap 6) with clang / macOS
   T = &(r->data);;
   strcpy(T, data);
   return(r);
 }
 
 /**
  * allocate a small array
  *
  * \return
  *    new empty array
  */
 // keep data uninitialized (count)
 sArrayt* allocSArray(void) {
   sArrayt *r = NULL;
 
   isError(r, malloc(sizeof(sArrayt) + sizeof(smallt *) * SARRAY_MIN_ELEMENTS)) return(NULL);
   r->type     = ARRAY;
   r->count    = 0;
   r->maxCount = SARRAY_MIN_ELEMENTS;
   return(r);
 }
 
 /**
  * allocate a small undefined object
  *
  * \return
  *    new undefined object
  */
 sUndefinedt* allocSUndefined(void) {
   sUndefinedt *r = NULL;
 
   isError(r, malloc(sizeof(sUndefinedt))) return(NULL);
   r->type = UNDEFINED;
   return(r);
 }
 
 /**
  * allocate a small bytes object
  *
  * \return
  *    new small bytes object
  */
 sBytest* allocSBytes(void) {
   sBytest *r = NULL;
 
   isError(r, malloc(sizeof(sBytest))) return(NULL);
   r->type     = BYTES;
   r->count    = 0;
   return(r);
 }
 
 /**
  * free non null objects
  */
 void sFree(smallt *obj) {
 
   if (obj) {
     sFreeTiny(obj);
 }
   }
 
 /**
  * free any type of small object
  *
  * objects that are not of type sDict or sArray are freed with the standard free
  *
  * \param
  *    obj object to free
  */
 void sFreeTiny(smallt *obj) {
   sContainert *c = NULL;
 
   switch(obj->type) {
     case DICT:
       sDictFreeTiny((sDictt *) obj);
       break;
     case ARRAY:
       sArrayFreeTiny((sArrayt *) obj);
       break;
     case CONTAINER:
       c = (sContainert*)obj;
       if (c->free) {
         c->free(c->data);
         c->data = NULL;
       }
       free(obj);
       break;
     default:
       free(obj);
   }
 }
 
 /**
  * free a dictionary element
  *
  * the key and the object are freed
  *
  * \param
  *    e element to free
  */
 void sDictFreeElement(sDictElemt *e) {
 
   if (e->key) {
     free(e->key);
     sFreeTiny(e->data);
     e->key = NULL;
 }
   }
 
 /**
  * free dictionary elements
  *
  * \param
  *    dict dictionary to free
  */
 void sDictFreeElements(sDictt *dict) {
 
   forEachSDict(dict, e) {
       sDictFreeElement(e);
 }
   }
 
 /**
  * free dictionary elements and dictionary object
  *
  * \param
  *    dict dictionary to free
  */
 void sDictFreeTiny(sDictt *dict) {
 
   sDictFreeElements(dict);
   free(dict);
 }
 
 /**
  * free array elements
  *
  * \param
  *    array array to free
  */
 void sArrayFreeElements(sArrayt *array) {
 
   forEachSArray(array, e) {
     sFree(e);
 }
   }
 
 /**
  * free array elements and array object
  *
  * \param
  *    array array to free
  */
 void sArrayFreeTiny(sArrayt *array) {
 
   sArrayFreeElements(array);
   free(array);
 }
 
 /**
  * duplicate small object
  *
  * \param
  *    o small object
  * \return
  *    duplicated object
  *    NULL when o is NULL
  */
 smallt* sDuplicate(smallt *o) {
 
   if (!o) {
     return(NULL);
   }
 
   return(sDuplicateTiny(o));
 }
 
 /**
  * duplicate small object
  *
  * for containers, the pointer is copied to new object
  *
  * \param
  *    obj small object
  * \return
  *    duplicated object
  */
 smallt* sDuplicateTiny(smallt *obj) {
   smallt *r = NULL;
   sBytest *B = NULL;
   sContainert *c = NULL;
 
   switch(obj->type) {
     case UNDEFINED:
       r = (smallt *)allocSUndefined();
       break;
     case BOOL:
       r = (smallt *)allocSBool(((sBoolt *)obj)->value);
       break;
     case CONTAINER:
       // data is not copied, same data pointer is used
       isError(c, allocSContainer(((sContainert *)obj)->data)) return(NULL);
       c->dataType = ((sContainert *)obj)->dataType;
       c->free     = ((sContainert *)obj)->free;
       r           = (smallt *)c;
       break;
     case DICT:
       r = (smallt *)sDictDuplicateTiny((sDictt *)obj);
       break;
     case DOUBLE:
       r = (smallt *)allocSDouble(((sDoublet *)obj)->value);
       break;
     case INT:
       r = (smallt *)allocSInt(((sIntt *)obj)->value);
       break;
     case STRING:
       r = (smallt *) strdup((char *) obj);;
       break;
     case ARRAY:
       r = (smallt *)sArrayDuplicateTiny((sArrayt *)obj);
       break;
     case BYTES:
       isError(B, allocSBytes()) return(NULL);
       if (((sBytest *)obj)->count) {
         sBytesPushBuffer(&B, sBytesGetTiny((sBytest *)obj), ((sBytest *)obj)->count);
       }
       r = (smallt *) B;
       break;
     default:
       logME(libsheepyErrorMask, "Unsupported object type.");
   }
   return(r);
 }
 
 /**
  * duplicate dictionary
  *
  * \param
  *    dict dictionary to duplicate
  * \return
  *    duplicated dictionary
  */
 sDictt* sDictDuplicateTiny(sDictt *dict) {
 
   sDictt *d = allocSDict();
   if (!d) {
     return(NULL);
   }
 
   forEachSDict(dict, e) {
     if (e->key) {
       smallt *eDup = sDuplicateTiny(e->data);
       sDictPushTiny(&d, e->key, eDup);
   }
     }
   return(d);
 }
 
 /**
  * duplicate array
  *
  * \param
  *    array array to duplicate
  * \return
  *    duplicated array
  */
 sArrayt* sArrayDuplicateTiny(sArrayt *array) {
 
   sArrayt *a = allocSArray();
   if (!a) {
     return(NULL);
   }
 
   forEachSArray(array, e) {
     sArrayPushTiny(&a, sDuplicate(e));
   }
   return(a);
 }
 
 /**
  * stringify a small object
  *
  * the returned string has to be freed
  *
  * \param
  *    obj object
  * \return
  *    string representing the object
  */
 char* sToStringTiny(smallt *obj) {
   char *r = NULL;
 
   switch(obj->type) {
     case UNDEFINED:
       r = sUndefinedToStringTiny((sUndefinedt *)obj);
       break;
     case BOOL:
       r = sBoolToStringTiny((sBoolt *)obj);
       break;
     case CONTAINER:
       r = sContainerToStringTiny((sContainert *)obj);
       break;
     case DICT:
       r = sDictToStringTiny((sDictt *)obj);
       break;
     case DOUBLE:
       r = sDoubleToStringTiny((sDoublet *)obj);
       break;
     case INT:
       r = sIntToStringTiny((sIntt *)obj);
       break;
     case STRING:
       r = sStringToStringTiny((sStringt *)obj);
       break;
     case ARRAY:
       r = sArrayToStringTiny((sArrayt* )obj);
       break;
     case BYTES:
       r = sBytesToStringTiny((sBytest* )obj);
       break;
     default:
       logME(libsheepyErrorMask, "Unsupported object type.");
   }
   return(r);
 }
 
 /**
  * stringify object
  *
  * the returned string has to be freed
  *
  * \param
  *    obj object
  * \return
  *    string representing the object
  *    NULL when obj is NULL
  */
 char* sToString(smallt *obj) {
 
   if (obj) {
     return(sToStringTiny(obj));
   }
   return(NULL);
 }
 
 /**
  * stringify bool
  *
  * the returned string has to be freed
  *
  * \param
  *    obj object
  * \return
  *    string representing the object
  */
 char* sBoolToStringTiny(sBoolt* obj) {
 
   if (obj->value) {
     return(strdup("true"));
   }
   else {
     return(strdup("false"));
 }
   }
 
 /**
  * stringify container
  *
  * \return
  *    <data container> string
  */
 char* sContainerToStringTiny(sContainert* obj UNUSED) {
 
   return(strdup("<data container>"));
 }
 
 /**
  * stringify dictionary
  *
  * the returned string has to be freed
  *
  * \param
  *    obj object
  * \return
  *    string representing the object
  */
 char* sDictToStringTiny(sDictt* obj) {
   char *s = NULL;
 
   if (!obj->count) {
     return(strdup("{}"));
   }
 
   char *r = strdup("{");
 
   bool hasAtLeastOneElement = no;
 
   forEachSDict(obj, e) {
     if (e->key) {
       hasAtLeastOneElement = yes;
       pErrorNULL(iAppendS(&r, "\""));
       pErrorNULL(iAppendS(&r, e->key));
       pErrorNULL(iAppendS(&r, "\""));
       if (isSType(e->data, STRING) || isSType(e->data, CONTAINER)) {
         // add quotes for strings
         pErrorNULL(iAppendS(&r, ":\""));
         s = sToStringTiny(e->data);
         pErrorNULL(iAppendS(&r, s));
         free(s);
         pErrorNULL(iAppendS(&r, "\","));
       }
       else {
         pErrorNULL(iAppendS(&r, ":"));
         s = sToStringTiny(e->data);
         pErrorNULL(iAppendS(&r, s));
         free(s);
         pErrorNULL(iAppendS(&r, ","));
   }
     }
       }
 
   if (hasAtLeastOneElement) {
     pErrorNULL(setS(r, -1, '}'));
   }
   else {
     pErrorNULL(iAppendS(&r, "}"));
   }
   return(r);
 }
 
 /**
  * stringify double
  *
  * the returned string has to be freed
  *
  * \param
  *    obj object
  * \return
  *    string representing the object
  */
 char* sDoubleToStringTiny(sDoublet* obj) {
   char *s = NULL;
 
   isError(s, malloc(256*sizeof(char))) return(NULL);
   snprintf(s,256, "%e", obj->value);
 
   return(s);
 }
 
 /**
  * stringify int
  *
  * the returned string has to be freed
  *
  * \param
  *    obj object
  * \return
  *    string representing the object
  */
 char* sIntToStringTiny(sIntt* obj) {
   char *s = NULL;
 
   isError(s, malloc(256*sizeof(char))) return(NULL);
   snprintf(s,256, "%" PRIi64, obj->value);
 
   return(s);
 }
 
 /**
  * stringify string
  *
  * the returned string has to be freed
  *
  * \param
  *    obj object
  * \return
  *    string representing the object
  */
 char* sStringToStringTiny(sStringt* obj) {
 
   return(strdup(sStringGetTiny(obj)));
 }
 
 /**
  * stringify array
  *
  * the returned string has to be freed
  *
  * \param
  *    obj object
  * \return
  *    string representing the object
  */
 char* sArrayToStringTiny(sArrayt* obj) {
   char *s = NULL;
 
   if (!obj->count) {
     return(strdup("[]"));
   }
 
   char *r      = strdup("[");
   uint32_t cnt   = 0;;
   bool emptySlot = false;;
   forEachSArray(obj, o) {
     if (!o) {
       // empty slot
       emptySlot = true;;
       continue;
     }
     emptySlot = false;;
     cnt++;
     if (isSType(o, STRING) || isSType(o, CONTAINER)) {
       // add quotes for strings
       pErrorNULL(iAppendS(&r, "\""));
       s = sToStringTiny(o);
       pErrorNULL(iAppendS(&r, s));
       free(s);
       pErrorNULL(iAppendS(&r, "\""));
     }
     else {
       s = sToStringTiny(o);
       pErrorNULL(iAppendS(&r, s));
       free(s);
     }
     pErrorNULL(iAppendS(&r, ","));
   }
   if (!cnt && emptySlot) {
     pErrorNULL(iAppendS(&r, "]"));
   }
   else {
     pErrorNULL(setS(r, -1, ']'));
   }
   return(r);
 }
 
 /**
  * stringify undefined
  *
  * the returned string has to be freed
  *
  * \param
  *    obj object
  * \return
  *    "null" string
  */
 char* sUndefinedToStringTiny(sUndefinedt* obj UNUSED) {
 
   return(strdup("null"));
 }
 
 /**
  * stringify small bytes
  *
  * the returned string has to be freed
  *
  * \param
  *    obj object
  * \return
  *    bytes converted to decimal string representing the object
  */
 char* sBytesToStringTiny(sBytest* obj) {
 
   if (!obj->count) {
     return(strdup("[]"));
   }
 
   char *r = toHexSepS(&(obj->data), obj->count, ",");
   pErrorNULL(iPrependS(&r, "["));
   pErrorNULL(iAppendS(&r, "]"));
   return(r);
 }
 
 /**
  * stringify a small object
  *
  * Escape characters to produce a parsable json
  *
  * the returned string has to be freed
  *
  * \param
  *    obj object
  * \return
  *    string representing the object
  */
 char* sEscapeTiny(smallt *obj) {
   char *r = NULL;
 
   switch(obj->type) {
     case UNDEFINED:
       r = sUndefinedToStringTiny((sUndefinedt *)obj);
       break;
     case BOOL:
       r = sBoolToStringTiny((sBoolt *)obj);
       break;
     case CONTAINER:
       r = sContainerToStringTiny((sContainert *)obj);
       break;
     case DICT:
       r = sDictEscapeTiny((sDictt *)obj);
       break;
     case DOUBLE:
       r = sDoubleToStringTiny((sDoublet *)obj);
       break;
     case INT:
       r = sIntToStringTiny((sIntt *)obj);
       break;
     case STRING:
       r = sStringEscapeTiny((sStringt *)obj);
       break;
     case ARRAY:
       r = sArrayEscapeTiny((sArrayt* )obj);
       break;
     case BYTES:
       r = sBytesToStringTiny((sBytest* )obj);
       break;
     default:
       logME(libsheepyErrorMask, "Unsupported object type.");
   }
   return(r);
 }
 
 /**
  * stringify object
  *
  * the returned string has to be freed
  *
  * \param
  *    obj object
  * \return
  *    string representing the object
  *    NULL when obj is NULL
  */
 char* sEscape(smallt *obj) {
 
   if (obj) {
     return(sEscapeTiny(obj));
   }
   return(NULL);
 }
 
 /**
  * stringify dictionary
  *
  * the returned string has to be freed
  *
  * \param
  *    obj object
  * \return
  *    string representing the object
  */
 char* sDictEscapeTiny(sDictt* obj) {
   char *s = NULL;
 
   if (!obj->count) {
     return(strdup("{}"));
   }
 
   char *r = strdup("{");
 
   bool hasAtLeastOneElement = no;
 
   forEachSDict(obj, e) {
     if (e->key) {
       hasAtLeastOneElement = yes;
       pErrorNULL(iAppendS(&r, "\""));
       pErrorNULL(iAppendNFreeS(&r, escapeS(e->key, '\"')));
       pErrorNULL(iAppendS(&r, "\""));
       if (isSType(e->data, STRING)) {
         // add quotes for strings
         pErrorNULL(iAppendS(&r, ":\""));
         s = sEscapeTiny(e->data);
         pErrorNULL(iAppendS(&r, s));
         free(s);
         pErrorNULL(iAppendS(&r, "\","));
       }
       else if (isSType(e->data, CONTAINER)) {
         // add quotes for strings
         pErrorNULL(iAppendS(&r, ":\""));
         s = sToStringTiny(e->data);
         pErrorNULL(iAppendS(&r, s));
         free(s);
         pErrorNULL(iAppendS(&r, "\","));
       }
       else {
         pErrorNULL(iAppendS(&r, ":"));
         s = sEscapeTiny(e->data);
         pErrorNULL(iAppendS(&r, s));
         free(s);
         pErrorNULL(iAppendS(&r, ","));
   }
     }
       }
 
   if (hasAtLeastOneElement) {
     pErrorNULL(setS(r, -1, '}'));
   }
   else {
     pErrorNULL(iAppendS(&r, "}"));
   }
   return(r);
 }
 
 /**
  * stringify string
  *
  * the returned string has to be freed
  *
  * \param
  *    obj object
  * \return
  *    string representing the object
  */
 char* sStringEscapeTiny(sStringt* obj) {
 
   return(escapeS(sStringGetTiny(obj), '\"'));
 }
 
 /**
  * stringify array
  *
  * the returned string has to be freed
  *
  * \param
  *    obj object
  * \return
  *    string representing the object
  */
 char* sArrayEscapeTiny(sArrayt* obj) {
   char *s = NULL;
 
   if (!obj->count) {
     return(strdup("[]"));
   }
 
   char *r      = strdup("[");
   uint32_t cnt   = 0;;
   bool emptySlot = false;;
   forEachSArray(obj, o) {
     if (!o) {
       // empty slot
       emptySlot = true;;
       continue;
     }
     emptySlot = false;;
     cnt++;
     if (isSType(o, STRING)) {
       // add quotes for strings
       pErrorNULL(iAppendS(&r, "\""));
       s = sEscapeTiny(o);
       pErrorNULL(iAppendS(&r, s));
       free(s);
       pErrorNULL(iAppendS(&r, "\""));
     }
     else if (isSType(o, CONTAINER)) {
       // add quotes for strings
       pErrorNULL(iAppendS(&r, "\""));
       s = sToStringTiny(o);
       pErrorNULL(iAppendS(&r, s));
       free(s);
       pErrorNULL(iAppendS(&r, "\""));
     }
     else {
       s = sEscapeTiny(o);
       pErrorNULL(iAppendS(&r, s));
       free(s);
     }
     pErrorNULL(iAppendS(&r, ","));
   }
   if (!cnt && emptySlot) {
     pErrorNULL(iAppendS(&r, "]"));
   }
   else {
     pErrorNULL(setS(r, -1, ']'));
   }
   return(r);
 }
 
 /**
  * get list of object types string
  *
  * only the types in the first level are listed
  *
  * \param
  *    obj small array or dictionary
  * \return
  *    string listing types in array or dictionary
  */
 char* sTypesTiny(smallt* obj) {
   char *r = NULL;
   sArrayt *a = NULL;
   sBytest *types = NULL;
 
   isError(types, sTypesToBytesTiny(obj)) return(NULL);
 
   for (uint32_t i = 0; i < types->count;i++) {
     char b = (&(types->data))[i];
     if ((size_t)b >= ARRAY_SIZE(SMALL_TYPE_NAMES)) {
       free(types);
       if (a) {
         sArrayFreeTiny(a);
       }
       return(NULL);
     }
     sStringt *s = allocSStringTiny(SMALL_TYPE_NAMES[(size_t) b]);
     if (!s) {
       free(types);
       if (a) {
         sArrayFreeTiny(a);
       }
       return(NULL);
     }
     sArrayPushTiny(&a, (smallt *) s);
   }
 
   r = sArrayToStringTiny(a);
   free(types);
   sArrayFreeTiny(a);
   return(r);
 }
 
 /**
  * collect the types in an array or dictionary
  *
  * \param
  *    obj array or dictionary
  * \return
  *    sBytes list of types in array or dictionary
  */
 sBytest* sTypesToBytesTiny(smallt *obj) {
   sBytest *r = NULL;
 
   switch(obj->type) {
     case DICT:
       r = sDictTypesTiny((sDictt *) obj);;
       break;
     case ARRAY:
       r = sArrayTypesTiny((sArrayt *) obj);;
       break;
     default:;
   }
   return(r);
 }
 
 /**
  * list first level of dictionary types in a list of strings
  *
  * free the return value because the strings are const - dont use listFreeS
  *
  * \param
  *    obj dictionary
  * \return
  *    list of strings representing the types
  */
 const char** sDictTypeStrings(sDictt* obj) {
 
   sBytest *types  = sDictTypes(obj);
 
   return(sTypesToStrings(types));
 }
 
 /**
  * convert a list of object types to a list of strings
  *
  * \param
  *    types object types in a sBytes object, this parameter is freed at the end of the function, except when there is an error
  * \return
  *    list of strings representing the object types, use free to free the list (not listFreeS)
  *    NULL error, types is not freed
  */
 const char ** sTypesToStrings(sBytest *types) {
   const char **r = NULL;
 
   if (!types) {
     return(NULL);
   }
 
   isError(r, malloc((types->count+1) * sizeof(char *))) return(NULL);
   r[types->count] = NULL;
 
   for (uint32_t i = 0 ; i < types->count ; i++) {
     char b = (&(types->data))[i];
     if ((size_t)b >= ARRAY_SIZE(SMALL_TYPE_NAMES)) {
       free(r);
       return(NULL);
     }
     r[i]   = SMALL_TYPE_NAMES[(size_t) b];
   }
 
   free(types);
   return(r);
 }
 
 /**
  * list first level of object types in dictionary
  *
  * \param
  *    obj dictionary
  * \return
  *    list of object types in a sBytes object
  *    NULL when obj is NULL or not a dictionary
  */
 sBytest* sDictTypes(sDictt* obj) {
 
   if (!obj || !isSType(obj, DICT)) {
     return(NULL);
   }
 
   return(sDictTypesTiny(obj));
 }
 
 /**
  * list first level of object types in dictionary
  *
  * \param
  *    obj dictionary
  * \return
  *    list of object types in a sBytes object
  */
 sBytest* sDictTypesTiny(sDictt* obj) {
   sBytest *r = NULL;
 
   forEachSDict(obj, e) {
     if (e->key) {
       sBytesPush(&r, e->data->type);
   }
     }
 
   return(r);
 }
 
 /**
  * list first level of array types in a list of strings
  *
  * free the return because the strings are const - dont use listFreeS
  *
  * \param
  *    obj array
  * \return
  *    list of strings representing the types
  */
 const char** sArrayTypeStrings(sArrayt* obj) {
 
   sBytest *types  = sArrayTypes(obj);
 
   return(sTypesToStrings(types));
 }
 
 /**
  * list first level of object types in array
  *
  * \param
  *    obj array
  * \return
  *    list of object types in a sBytes object
  *    NULL when obj is NULL or not an array
  */
 sBytest* sArrayTypes(sArrayt* obj) {
 
   if (!obj || !isSType(obj, ARRAY)) {
     return(NULL);
   }
 
   return(sArrayTypesTiny(obj));
 }
 
 /**
  * list first level of object types in array
  *
  * \param
  *    obj array
  * \return
  *    list of object types in a sBytes object
  */
 sBytest* sArrayTypesTiny(sArrayt* obj) {
   sBytest *r = NULL;
 
   forEachSArray(obj, e) {
     if (e) {
       sBytesPush(&r, e->type);
   }
     }
 
   return(r);
 }
 
 /**
  * get object stored at key
  *
  * \param
  *    dict dictionary
  *    key key to search in dictionary
  * \return
  *    object stored at key
  *    NULL when dict is NULL or when key is NULL
  */
 smallt* sDictGet(sDictt *dict, const char *key) {
 
   if (!dict || !key) {
     return(NULL);
   }
 
   return(sDictGetTiny(dict, key));
 }
 
 /**
  * get pointer to object at key
  *
  * \param
  *   dict dictionary
  * \param
  *   key key to search in dictionary
  * \return
  *   pointer to object stored at key
  *   NULL when the key is not found
  */
 smallt** sDictGetP(sDictt *dict, const char *key) {
 
   if (!dict || !key) {
     return(NULL);
   }
 
   forEachSDict(dict, e) {
     if (e->key && eqS(key, e->key)) {
         return(&(e->data));
   }
     }
 
   return(NULL);
 }
 
 /**
  * get object stored at key
  *
  * \param
  *    dict dictionary
  *    key key to search in dictionary
  * \return
  *    object stored at key
  *    NULL when the key is not found
  */
 smallt* sDictGetTiny(sDictt *dict, const char *key) {
 
   forEachSDict(dict, e) {
     if (e->key && strEq(key, e->key)) {
         return(e->data);
   }
     }
 
   return(NULL);
 }
 
 /**
  * dictionary set pointer
  *
  * when the key already exists, the associated object is not freed.
  * This is useful for updating arrays, dictionaries and strings in the dictionary
  *
  * when dict is NULL, a new dictionary is allocated
  *
  * when the key doesn't exist, a new element is created
  *
  * when data is NULL, the element is not set
  *
  * \param
  *    dict dictionary
  *    key key associated with data
  *    data object to store
  */
 // TODO create SetShort - create element and add - no alloc
 void sDictSetP(sDictt **dict, const char *key, smallt *data) {
 
   if (!(*dict)) {
     sDictPushTiny(dict, key, data);
     return;
   }
 
   if (!data) {
     // NULL not inserted in dictionary
     return;
   }
 
   forEachSDict(*dict, e) {
     if (e->key && strEq(key, e->key)) {
       e->data = data;
       return;
   }
     }
 
   // create new element
   sDictPushTiny(dict, key, data);
 }
 
 /**
  * dictionary set key, value
  *
  * when the key already exists, the associated object is freed.
  * The new data replaces the previous data
  *
  * when dict is NULL, a new dictionary is allocated
  *
  * when the key doesn't exist, a new element is created
  *
  * when data is NULL, the element is not set
  *
  * \param
  *    dict dictionary
  *    key key associated with data
  *    data object to store
  */
 void sDictSetTiny(sDictt **dict, const char *key, smallt *data) {
 
   if (!(*dict)) {
     sDictPushTiny(dict, key, data);
     return;
   }
 
   if (!data) {
     // NULL not inserted in dictionary
     return;
   }
 
   forEachSDict(*dict, e) {
     if (e->key && strEq(key, e->key)) {
       sFree(e->data);
       e->data = data;
       return;
   }
     }
 
   // create new element
   sDictPushTiny(dict, key, data);
 }
 
 /**
  * push new key-value
  *
  * when data is NULL, the element is not created
  *
  * this function doesnt check if key already exists
  *
  * when dict is NULL, a new dictionary is allocated
  *
  * the dictionary is reallocated when count is greater than
  * maxCount
  *
  * \param
  *    dict dictionary
  *    key key associated with data
  *    data object to store
  */
 // TODO create PushShort - create element and add - no alloc
 void sDictPushTiny(sDictt **dict, const char *key, smallt *data) {
 
   /* // sanity checks */
   /* if !dict */
   /*   return */
 
   if (!(*dict)) {
     // create dict
     isError(*dict, allocSDict()) {
       return;
     }
   }
 
   if (!data) {
     // NULL not inserted in dictionary
     return;
   }
 
   if ((*dict)->count == 0) {
     (*dict)->elements.key  = strdup(key);
     (*dict)->elements.data = data;
   }
   else {
     if ((*dict)->count >= (*dict)->maxCount) {
       // realloc
       sDictt *tmp = realloc(*dict, sizeof(sDictt) + sizeof(sDictElemt) * ((*dict)->count + SDICT_REALLOC_STEPS-1));
       if (!tmp) {
         return;
       }
       else {
         *dict = tmp;
         (*dict)->maxCount = 1 + (*dict)->count + SDICT_REALLOC_STEPS-1;
     }
       }
     sDictElemt *di = &((*dict)->elements);
     di[(*dict)->count].key  = strdup(key);
     di[(*dict)->count].data = data;
   }
 
   (*dict)->count++;
   return;
 }
 
 /**
  * delete dictionary element
  *
  * \param
  *    dict dictionary
  *    key key to search
  */
 void sDictDelTiny(sDictt *dict, const char *key) {
 
   forEachSDict(dict, e) {
     if (e->key && strEq(key, e->key)) {
       sDictFreeElement(e);
       return;
 }
   }
     }
 
 /**
  * get string in a small string object
  *
  * \param
  *    string small string object
  * \return
  *    string in small string
  *    the returned value can't be reallocated since
  *    it is not a pointer to a mallocated buffer
  */
 char* sStringGetTiny(sStringt *string) {
 
   return(&(string->data));
 }
 
 /**
  * set string in small string
  *
  * \param
  *    string small string
  *    news new string
  */
 void sStringSetTiny(sStringt **string, const char *news) {
 
   free(*string);
   *string = allocSStringTiny(news);
 }
 
 /**
  * push data to array
  *
  * when array is NULL, a new array is allocated
  *
  * the array is reallocated when count is greater than
  * maxCount
  *
  * \param
  *    array
  *    data data to store
  */
 // TODO create PushShort - create element and add - no alloc
 void sArrayPushTiny(sArrayt **array, smallt* data) {
 
   /* // sanity checks */
   /* if !array */
   /*   return */
 
   if (!(*array)) {
     // create array
     isError(*array, allocSArray())
       return;
   }
 
   if ((*array)->count == 0) {
     (*array)->data = data;;
   }
   else {
     if ((*array)->count >= (*array)->maxCount) {
       // realloc
       //print 'ARRAY REALLOC'
       sArrayt *tmp = realloc(*array, sizeof(sArrayt) + sizeof(smallt *) * ((*array)->count + SARRAY_REALLOC_STEPS));
       if (!tmp) {
         return;
       }
       else {
         *array = tmp;
         (*array)->maxCount = 1 + (*array)->count + SARRAY_REALLOC_STEPS-1;
     }
       }
     smallt **arr = &((*array)->data);
     arr[(*array)->count] = data;
   }
 
   (*array)->count++;
   return;
 }
 
 /**
  * prepend data in array
  *
  * when array is NULL, a new array is allocated
  *
  * the array is reallocated when count is greater than
  * maxCount
  *
  * \param
  *    array
  *    data data to store
  */
 void sArrayPrependTiny(sArrayt **array, smallt* data) {
 
   /* // sanity checks */
   /* if !array */
   /*   return */
 
   if (!(*array)) {
     // create array
     isError(*array, allocSArray())
       return;
   }
 
   if ((*array)->count == 0) {
     (*array)->data = data;;
   }
   else {
     if ((*array)->count >= (*array)->maxCount) {
       // realloc
       //print 'ARRAY REALLOC'
       sArrayt *tmp = realloc(*array, sizeof(sArrayt) + sizeof(smallt *) * ((*array)->count + SARRAY_REALLOC_STEPS));
       if (!tmp) {
         return;
       }
       else {
         *array = tmp;
         (*array)->maxCount = 1 + (*array)->count + SARRAY_REALLOC_STEPS-1;
     }
       }
     smallt **arr = &((*array)->data);
     // shift list
     for (uint32_t i = (*array)->count; i > 0; i--) {
       arr[i] = arr[i-1];
     }
     arr[0] = data;
   }
 
   (*array)->count++;
   return;
 }
 
 /**
  * pop object from array
  */
 smallt* sArrayPopTiny(sArrayt *array) {
   smallt *r = NULL;
 
   /* if !array->count */
   /*   return NULL */
 
   r = sArrayGetTiny(array, array->count -1);
   array->count--;
   return(r);
 }
 
 /**
  * dequeue object from array
  */
 smallt* sArrayDequeueTiny(sArrayt *array) {
   smallt *r = NULL;
 
   /* if !array->count */
   /*   return NULL */
 
   smallt **arr = &(array->data);
   r            = arr[0];
   // shift list
   for (uint32_t i = 1 ; i < array->count ; i++) {
     arr[i-1] = arr[i];
   }
   array->count--;
   return(r);
 }
 
 /**
  * get pointer to object at index
  *
  * \param
  *    array
  *    index in array
  * \return
  *    pointer to object at index
  */
 smallt** sArrayGetP(sArrayt *array, uint32_t index) {
 
   return(&(((smallt **) &(array->data))[index]));
 }
 
 /**
  * get object at index
  *
  * \param
  *    array
  *    index in array
  * \return
  *    object at index
  */
 smallt* sArrayGetTiny(sArrayt *array, uint32_t index) {
 
   return(((smallt **) &(array->data))[index]);
 }
 
 /**
  * set value at index
  *
  * the previous element is not freed.
  * This is useful for updating arrays, dictionaries and strings in the array
  *
  * \param
  *    array
  *    index where the value is set
  *    value to store
  */
 void sArraySetShortTiny(sArrayt *array, uint32_t index, smallt *value) {
 
   ((smallt **) &(array->data))[index] = value;
 }
 
 /**
  * set value at index
  *
  * the previous element is not freed.
  * This is useful for updating arrays, dictionaries and strings in the array
  *
  * \param
  *    array
  *    index where the value is set
  *    value to store
  */
 void sArraySetP(sArrayt *array, uint32_t index, smallt *value) {
 
   sArraySetShortTiny(array, index, value);
 }
 
 /**
  * set value at index
  *
  * the previous element is freed.
  * The new data replaces the previous data
  *
  * \param
  *    array
  *    index where the value is set
  *    value to store
  */
 void sArraySetTiny(sArrayt *array, uint32_t index, smallt *value) {
 
   if (value == (((smallt **) &(array->data))[index])) {
     // value is same element as the element already in the array
     return;
   }
   sFree(((smallt **) &(array->data))[index]);
   sArraySetShortTiny(array, index, value);
 }
 
 /**
  * reverse element order
  *
  * the last element becomes the first one
  *
  * \param
  *    array to reverse
  * \return
  *    1 success
  *    0 error
  */
 int sArrayReverseTiny(sArrayt *array) {
 
   /* if !array->count */
   /*   return -1 */
 
   smallt **arr = &(array->data);
   for (uint32_t i = 0 ; i < array->count/2 ; i++) {
     smallt *a              = arr[i];
     arr[i]                 = arr[array->count-1 -i];
     arr[array->count-1 -i] = a;
   }
   return(1);
 }
 
 /**
  * delete element at index
  *
  * the element is freed and NULL is set at index
  * count is unchanged
  *
  * \param
  *    array
  *    index
  */
 void sArrayDelTiny(sArrayt *array, uint32_t index) {
 
   sArraySetTiny(array, index, NULL);
 }
 
 /**
  * delete range and shift elements
  *
  * the elements are freed
  * and count is reduced
  *
  * the range [start, end] is not checked for validity
  *
  * \param
  *    array
  * \param
  *    start
  * \param
  *    end
  */
 void sArrayDelRangeTiny(sArrayt *array, uint32_t start, uint32_t end) {
 
   smallt **arr = &(array->data);
 
   // free elements in range start, end
   for (uint32_t i = start ; i < end ; i++) {
     sFree(arr[i]);
   }
 
   // copy pointers from range end, array->count to start
   for (uint32_t i = 0 ; i < (array->count - end) ; i ++) {
     arr[start+i] = arr[end + i];;
   }
 
   array->count -= end - start;
 }
 
 /**
  * get buffer in small bytes
  *
  * \param
  *    bytes small bytes
  * \return
  *    pointer to data in small bytes
  *    NULL when bytes is NULL or bytes is not of type sBytes
  */
 void* sBytesGet(sBytest *bytes) {
 
   if (!bytes || !isSType(bytes, BYTES)) {
     return(NULL);
   }
 
   return(sBytesGetTiny(bytes));
 }
 
 /**
  * get buffer in small bytes
  *
  * \param
  *    bytes small bytes
  * \return
  *    pointer to data in small bytes
  */
 void* sBytesGetTiny(sBytest *bytes) {
 
   return(&(bytes->data));
 }
 
 /**
  * push char to bytes
  *
  * when bytes is NULL, a new small bytes object is allocated
  *
  * the small bytes object is reallocated
  *
  * \param
  *    bytes small bytes
  *    data char to push
  */
 void sBytesPush(sBytest **bytes, char data) {
 
   if (!(*bytes)) {
     // create bytes
     isError(*bytes, allocSBytes())
       return;
   }
 
   if ((*bytes)->count == 0) {
     (*bytes)->data = data;;
   }
   else {
     sBytest *tmp = realloc(*bytes, sizeof(sBytest) + sizeof(char) * ((*bytes)->count));
     if (!tmp) {
       return;
     }
     else {
       *bytes = tmp;
       (&((*bytes)->data))[(*bytes)->count] = data;
   }
     }
 
   (*bytes)->count++;
   return;
 }
 
 /**
  * push data buffer to bytes
  *
  * when bytes is NULL, a new small bytes object is allocated
  *
  * the small bytes object is reallocated
  *
  * when data is NULL, the function does nothing
  *
  * \param
  *    bytes small bytes
  *    data buffer to push
  *    size size of buffer
  */
 void sBytesPushBuffer(sBytest **bytes, void* data, uint32_t size) {
 
   if (!(*bytes)) {
     // create bytes
     *bytes          = allocSBytes();
   }
 
   if (!data || !size) {
     return;
   }
 
   sBytesPushBufferTiny(bytes, data, size);
 }
 
 
 /**
  * push data buffer to bytes
  *
  * the small bytes object is reallocated
  *
  * \param
  *    bytes small bytes
  *    data buffer to push
  *    size size of buffer
  */
 void sBytesPushBufferTiny(sBytest **bytes, void* data, uint32_t size) {
 
   if ((*bytes)->count == 0) {
     sBytest *tmp = realloc(*bytes, sizeof(sBytest) + sizeof(char) * (size-1));
     if (!tmp) {
       return;
     }
     else {
       *bytes = tmp;
       memcpy(&((*bytes)->data), data, size);
       (*bytes)->count = size;;
   }
     }
   else {
     sBytest *tmp = realloc(*bytes, sizeof(sBytest) + sizeof(char) * ((*bytes)->count + size-1));
     if (!tmp) {
       return;
     }
     else {
       *bytes = tmp;
       memcpy((&((*bytes)->data))+(*bytes)->count, data, size);
       (*bytes)->count += size;;
   }
     }
   return;
 }
 
 /**
  * serialize object to small bytes
  *
  * \param
  *    obj object
  * \return
  *    small bytes object representing obj
  *    NULL when obj is NULL
  */
 sBytest *sSerial(smallt *obj) {
 
   if (!obj) {
     return(NULL);
   }
 
   return(sSerialTiny(obj));
 }
 
 /**
  * serialize object to small bytes
  *
  * All elements are serialized recursively
  *
  * the data in containers is not serialized
  *
  * \param
  *    obj object
  * \return
  *    small bytes object representing obj
  */
 // TODO reimplement using loops
 // TODO serialize simple types
 sBytest *sSerialTiny(smallt *obj) {
   sBytest *r = NULL;
   sBytest *B = NULL;
 
   switch(obj->type) {
     case UNDEFINED:
       sBytesPush(&r, obj->type);
       break;
     case BOOL:
       sBytesPush(&r, obj->type);
       sBytesPushBuffer(&r, &((sBoolt *)&(obj->type))->value, sizeof(bool));
       break;
     case CONTAINER:
       sBytesPush(&r, obj->type);
       break;
     case DICT:
       sDictSerialElementsTiny(&r, (sDictt *)&(obj->type));
       break;
     case DOUBLE:
       sBytesPush(&r, obj->type);
       sBytesPushBuffer(&r, &((sDoublet *)&(obj->type))->value, sizeof(double));
       break;
     case INT:
       sBytesPush(&r, obj->type);
       sBytesPushBuffer(&r, &((sIntt *)&(obj->type))->value, sizeof(int64_t));
       break;
     case STRING:
       sBytesPush(&r, obj->type);
       sBytesPushBuffer(&r, &((sStringt *)&(obj->type))->data, (uint32_t)sizeof(sStringt) + (uint32_t)strlen(&(((sStringt *)&(obj->type))->data)) -1);
       break;
     case ARRAY:
       sArraySerialElementsTiny(&r, (sArrayt *)&(obj->type));
       break;
     case BYTES:
       sBytesPush(&r, obj->type);
       B = (sBytest *)&(obj->type);
       sBytesPushBuffer(&r, &(B->count), sizeof(uint32_t));
       sBytesPushBuffer(&r, &(B->data), B->count);
       break;
     default:
       logME(libsheepyErrorMask, "Unsupported object type.");
   }
   return(r);
 }
 
 /**
  * serialize dictionary
  *
  * the serialized dict is pushed to r.
  * All elements are serialized recursively
  *
  * the data in containers is not serialized
  *
  * \param
  *   r small bytes object
  *   dict dictionary to serialize
  */
 void sDictSerialElementsTiny(sBytest **r, sDictt *dict) {
   sBytest *B = NULL;
 
   sBytesPush(r, dict->type);
   sBytesPushBuffer(r, &(dict->count), sizeof(uint32_t));
 
   forEachSDict(dict, e) {
     if (e->key) {
       sBytesPushBuffer(r, e->key, (uint32_t)strlen(e->key) + 1);
       sBytesPush(r, e->data->type);
 
       switch(e->data->type) {
         case UNDEFINED:
           break;
         case BOOL:
           sBytesPushBuffer(r, &((sBoolt *)(e->data))->value, sizeof(bool));
           break;
         case CONTAINER:
           break;
         case DICT:
           // decrease to overwrite the e->type since sDictSerialElementsTiny stores the type
           // again
           (*r)->count--;
           sDictSerialElementsTiny(r, (sDictt *)(e->data));
           break;
         case DOUBLE:
           sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
           break;
         case INT:
           sBytesPushBuffer(r, &((sIntt *)(e->data))->value, sizeof(int64_t));
           break;
         case STRING:
           sBytesPushBuffer(r, &((sStringt *)(e->data))->data, (uint32_t)sizeof(sStringt) + (uint32_t)strlen(&(((sStringt *)(e->data))->data)) -1);
           break;
         case ARRAY:
           // decrease to overwrite the e->type since sDictSerialElementsTiny stores the type
           // again
           (*r)->count--;
           sArraySerialElementsTiny(r, (sArrayt *)(e->data));
           break;
         case BYTES:
           B = (sBytest *)(e->data);
           sBytesPushBuffer(r, &(B->count), sizeof(uint32_t));
           sBytesPushBuffer(r, &(B->data), B->count);
           break;
         default:
           logME(libsheepyErrorMask, "Unsupported object type.");
       }
   }
     }
   return;
 }
 
 /**
  * serialize array
  *
  * the serialized array is pushed to r.
  * All elements are serialized recursively
  *
  * the data in containers is not serialized
  *
  * \param
  *   r small bytes object
  *   array to serialize
  */
 void sArraySerialElementsTiny(sBytest **r, sArrayt *array) {
   sBytest *B = NULL;
 
   sBytesPush(r, array->type);
   sBytesPushBuffer(r, &(array->count), sizeof(uint32_t));
 
   forEachSArray(array, e) {
     if (!e) {
       // empty slots are represented as undefined elements
       sBytesPush(r, UNDEFINED);
     }
     else {
       sBytesPush(r, e->type);
 
       switch(e->type) {
         case UNDEFINED:
           break;
         case BOOL:
           sBytesPushBuffer(r, &((sBoolt *)e)->value, sizeof(bool));
           break;
         case CONTAINER:
           break;
         case DICT:
           // decrease to overwrite the e->type since sDictSerialElementsTiny stores the type
           // again
           (*r)->count--;
           sDictSerialElementsTiny(r, (sDictt *)e);
           break;
         case DOUBLE:
           sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
           break;
         case INT:
           sBytesPushBuffer(r, &((sIntt *)e)->value, sizeof(int64_t));
           break;
         case STRING:
           sBytesPushBuffer(r, &((sStringt *)e)->data, (uint32_t)sizeof(sStringt) + (uint32_t)strlen(&(((sStringt *)e)->data)) -1);
           break;
         case ARRAY:
           // decrease to overwrite the e->type since sDictSerialElementsTiny stores the type
           // again
           (*r)->count--;
           sArraySerialElementsTiny(r, (sArrayt *)e);
           break;
         case BYTES:
           B = (sBytest *)e;
           sBytesPushBuffer(r, &(B->count), sizeof(uint32_t));
           sBytesPushBuffer(r, &(B->data), B->count);
           break;
         default:
           logME(libsheepyErrorMask, "Unsupported object type.");
       }
   }
     }
   return;
 }
 
 /**
  * deserialize small bytes object
  *
  * \param
  *    obj small bytes
  * \return
  *    new deserialized object
  *    NULL when obj is NULL or obj is empty
  */
 smallt* sDeserial(sBytest *obj) {
 
   if (!obj || !obj->count) {
     return(NULL);
   }
 
   return(sDeserialTiny(obj));
 }
 
 /**
  * deserialize small bytes object
  *
  * \param
  *    obj small bytes
  * \return
  *    new deserialized object
  *    NULL when there is a malloc error
  */
 // TODO reimplement using loops
 smallt* sDeserialTiny(sBytest *obj) {
   smallt   *r = NULL;
   bool *b = NULL;
   double *D = NULL;
   int64_t *i = NULL;
   char *s = NULL;
   sBytest *B = NULL;
   uint32_t *count = NULL;
   char *data = NULL;
 
   switch(obj->data) {
     case UNDEFINED:
       r = (smallt *) allocSUndefined();
       break;
     case BOOL:
       data = &(obj->data)+1;
       b = (bool *)data;
       r = (smallt *) allocSBool(*b);
       break;
     case CONTAINER:
       r = (smallt *) allocSContainer(NULL);
       break;
     case DICT:
       data = (char *)&(obj->data)+1;
       sDictDeserialElementsTiny((sDictt **)&r, &data);
       break;
     case DOUBLE:
       data = &(obj->data)+1;
       D = (double *)data;
       r = (smallt *) allocSDouble(*D);
       break;
     case INT:
       data = &(obj->data)+1;
       i = (int64_t *)data;
       r = (smallt *) allocSInt(*i);
       break;
     case STRING:
       s = (char *)&(obj->data)+1;
       r = (smallt *) allocSStringTiny(s);
       break;
     case ARRAY:
       data = (char *)&(obj->data)+1;
       sArrayDeserialElementsTiny((sArrayt **)&r, &data);
       break;
     case BYTES:
       isError(B, allocSBytes()) return(NULL);
       data  = &(obj->data)+1;
       count = (uint32_t *)data;
       s     = (char *)data + sizeof(uint32_t);
       sBytesPushBuffer(&B, s, *count);
       r = (smallt *)B;
       break;
     default:
       logME(libsheepyErrorMask, "Unsupported object type.");
   }
 
   return(r);
 }
 
 /**
  * deserialize dictionary from data
  *
  * a new dictionary is allocated
  *
  * \param
  *    dict dictionary holding the elements
  *    data serialized dictionary
  */
 void sDictDeserialElementsTiny(sDictt **dict, char **data) {
   sUndefinedt *u = NULL;
   bool *b = NULL;
   sBoolt *bo = NULL;
   sContainert *c = NULL;
   double *D = NULL;
   sDoublet *Do = NULL;
   sDictt *d = NULL;
   int64_t *i = NULL;
   sIntt *io = NULL;
   char *s = NULL;
   sStringt *so = NULL;
   sArrayt *a = NULL;
   sBytest *B = NULL;
   uint32_t *count = NULL;
   uint32_t dictCount;
 
   dictCount  = *((uint32_t *)(*data));
   *data     += sizeof(uint32_t);
 
   if (!dictCount) {
     *dict = allocSDict();
     return;
   }
 
   for (uint32_t counter = 0 ; counter < dictCount ; counter++) {
     char type;
     char *key;
     key    = *data;
     *data += strlen(key)+1;
     type   = *((*data)++);
 
     switch(type) {
       case UNDEFINED:
         u = allocSUndefined();
         sDictPushTiny(dict, key, (smallt *) u);
         break;
       case BOOL:
         b      = (bool *)(*data);
         *data += sizeof(bool);
         bo     = allocSBool(*b);
         sDictPushTiny(dict, key, (smallt *) bo);
         break;
       case CONTAINER:
         c = allocSContainer(NULL);
         sDictPushTiny(dict, key, (smallt *) c);
         break;
       case DICT:
         d = NULL;
         sDictDeserialElementsTiny(&d, data);
         sDictPushTiny(dict, key, (smallt *) d);
         break;
       case DOUBLE:
         D      = (double *)(*data);
         *data += sizeof(double);
         Do     = allocSDouble(*D);
         sDictPushTiny(dict, key, (smallt *) Do);
         break;
       case INT:
         i      = (int64_t *)(*data);
         *data += sizeof(int64_t);
         io     = allocSInt(*i);
         sDictPushTiny(dict, key, (smallt *) io);
         break;
       case STRING:
         s      = (char *)(*data);
         *data += strlen(s)+1;
         so     = allocSStringTiny(s);
         sDictPushTiny(dict, key, (smallt *) so);
         break;
       case ARRAY:
         a = NULL;
         sArrayDeserialElementsTiny(&a, data);
         sDictPushTiny(dict, key, (smallt *) a);
         break;
       case BYTES:
         isError(B, allocSBytes()) {
           return;
         }
         count  = (uint32_t *)(*data);
         *data += sizeof(uint32_t);
         s      = *data;
         *data += *count;
         sBytesPushBuffer(&B, s, *count);
         sDictPushTiny(dict, key, (smallt *) B);
         break;
       default:
         logME(libsheepyErrorMask, "Unsupported object type.");
     }
 }
   }
 
 /**
  * deserialize array from data
  *
  * a new array is allocated
  *
  * \param
  *    array holding the elements
  *    data serialized dictionary
  */
 void sArrayDeserialElementsTiny(sArrayt **array, char **data) {
   sUndefinedt *u = NULL;
   bool *b = NULL;
   sBoolt *bo = NULL;
   sContainert *c = NULL;
   double *D = NULL;
   sDoublet *Do = NULL;
   sDictt *d = NULL;
   int64_t *i = NULL;
   sIntt *io = NULL;
   char *s = NULL;
   sStringt *so = NULL;
   sArrayt *a = NULL;
   sBytest *B = NULL;
   uint32_t *count = NULL;
   uint32_t arrayCount;
 
   arrayCount  = *((uint32_t *)(*data));
   *data     += sizeof(uint32_t);
 
   if (!arrayCount) {
     *array = allocSArray();
     return;
   }
 
   for (uint32_t counter = 0 ; counter < arrayCount ; counter++) {
     char type;
     type  = *((*data)++);
 
     switch(type) {
       case UNDEFINED:
         u = allocSUndefined();
         sArrayPushTiny(array, (smallt *) u);
         break;
       case BOOL:
         b      = (bool *)(*data);
         *data += sizeof(bool);
         bo     = allocSBool(*b);
         sArrayPushTiny(array, (smallt *) bo);
         break;
       case CONTAINER:
         c = allocSContainer(NULL);
         sArrayPushTiny(array, (smallt *) c);
         break;
       case DICT:
         d = NULL;
         sDictDeserialElementsTiny(&d, data);
         sArrayPushTiny(array, (smallt *) d);
         break;
       case DOUBLE:
         D      = (double *)(*data);
         *data += sizeof(double);
         Do     = allocSDouble(*D);
         sArrayPushTiny(array, (smallt *) Do);
         break;
       case INT:
         i      = (int64_t *)(*data);
         *data += sizeof(int64_t);
         io     = allocSInt(*i);
         sArrayPushTiny(array, (smallt *) io);
         break;
       case STRING:
         s      = (char *)(*data);
         *data += strlen(s)+1;
         so     = allocSStringTiny(s);
         sArrayPushTiny(array, (smallt *) so);
         break;
       case ARRAY:
         a = NULL;
         sArrayDeserialElementsTiny(&a, data);
         sArrayPushTiny(array, (smallt *) a);
         break;
       case BYTES:
         isError(B, allocSBytes()) {
           return;
         }
         count  = (uint32_t *)(*data);
         *data += sizeof(uint32_t);
         s      = *data;
         *data += *count;
         sBytesPushBuffer(&B, s, *count);
         sArrayPushTiny(array, (smallt *) B);
         break;
       default:
         logME(libsheepyErrorMask, "Unsupported object type.");
     }
 }
   }