libsheepyObject.c

Go to the documentation of this file.

// MIT License
//
// Copyright (c) 2023 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 "../libsheepyObject.h"
#if (!defined(__OpenBSD__))
// pthread.h is already included in tpool.h for pthread_mutex_t in OpenBSD with GCC 4.9.4
#include "pthread.h"
#endif
#if (!(__APPLE__ || __FreeBSD__ || __TERMUX__ || __OpenBSD__ || __DragonFly__ || MUSL_LIBC || __sun__))
//register_printf_specifier
#include "printf.h"
#endif
#if (!(__APPLE__ || __FreeBSD__ || __OpenBSD__ || __DragonFly__ || __HAIKU__))
// sysinfo
#include "sys/sysinfo.h"
#endif

#define internal static

#include <sys/stat.h>
#include <ctype.h>
#include <unistd.h>
#include <stdio.h>
#include <dirent.h>
#include <stdarg.h>
#if (!(__OpenBSD__ || __HAIKU__))
#include <wordexp.h>
#endif
#include <stdbool.h>
#include <string.h>
#include <stdlib.h>
#include <libgen.h>
#include <stdint.h>

#if (!defined(__OpenBSD__))
#endif
#if (!(__APPLE__ || __FreeBSD__ || __TERMUX__ || __OpenBSD__ || __DragonFly__ || MUSL_LIBC || __sun__))
#endif
#if (!(__APPLE__ || __FreeBSD__ || __OpenBSD__ || __DragonFly__ || __HAIKU__))
#endif
#if (__APPLE__ || __FreeBSD__ || __OpenBSD__ || __DragonFly__ || __sun__ || __HAIKU__)
smallDictt *shSysinfo(void);
smallDictt *shSysinfo(void);
#endif
void cleanUpBaseTerminateG(baset **val);
void cleanUpBaseFreeG(baset **val);
void cleanUpBaseFinishG(baset **val);
void cleanUpBaseSmashG(baset **val);
baset *duplicateBaseG(baset *self);
void freeManyOF(void *paramType, ...);
void terminateManyOF(void *paramType, ...);
void smashManyOF(void *paramType, ...);
void finishManyOF(void *paramType, ...);
smallJsont *getProgPathJO(void);
smallStringt *getProgPathO(void);
smallJsont *getRealProgPathJO(void);
smallStringt *getRealProgPathO(void);
int systemJO(smallJsont *command);
int systemO(smallStringt *command);
int systemNFreeJOF(smallJsont *command, int line, const char *thisFunc, const char *thisFileName);
int systemNFreeOF(smallStringt *command, int line, const char *thisFunc, const char *thisFileName);
#if (!(__APPLE__ || __FreeBSD__ || __TERMUX__ || __OpenBSD__ || __DragonFly__ || MUSL_LIBC || __sun__ || __HAIKU__))
int print_m(FILE *stream, const struct printf_info *info, const void *const *args);
int print_m_arginfo(const struct printf_info *info UNUSED, size_t n, int *argtypes, int* size);
#endif
void putsOF(baset* object);
void putsUndefinedGF(undefinedt* object);
void putsBoolGF(bool object);
void putsBoolPGF(bool* object);
void putsDoubleGF(double object);
void putsDoublePGF(double* object);
void putsIntGF(int64_t object);
void putsIntPGF(int64_t* object);
void putsInt32GF(int32_t object);
void putsInt32PGF(int32_t* object);
void putsUintGF(uint64_t object);
void putsUintPGF(uint64_t* object);
void putsUint32GF(uint32_t object);
void putsUint32PGF(uint32_t* object);
void putsSGF(const char* object);
void putsListSGF(char** object);
void putsListCSGF(const char** object);
void putsDictGF(smallDictt* object);
void putsJsonGF(smallJsont* object);
void putsArrayGF(smallArrayt* object);
void putsSmallBoolGF(smallBoolt* object);
void putsSmallBytesGF(smallBytest* object);
void putsSmallDoubleGF(smallDoublet* object);
void putsSmallIntGF(smallIntt* object);
void putsSmallStringGF(smallStringt* object);
void putsVoidGF(void* object);
void putsSmallContainerGF(smallContainert* object);
char *toStringOF(baset* object);
char *toStringUndefinedGF(undefinedt* object);
char *toStringBoolGF(bool object);
char *toStringBoolPGF(bool* object);
char *toStringFloatGF(float object);
char *toStringFloatPGF(float* object);
char *toStringDoubleGF(double object);
char *toStringDoublePGF(double* object);
char *toStringIntGF(int64_t object);
char *toStringIntPGF(int64_t* object);
char *toStringInt32GF(int32_t object);
char *toStringInt32PGF(int32_t* object);
char *toStringInt16GF(int16_t object);
char *toStringInt16PGF(int16_t* object);
char *toStringUintGF(uint64_t object);
char *toStringUintPGF(uint64_t* object);
char *toStringUint32GF(uint32_t object);
char *toStringUint32PGF(uint32_t* object);
char *toStringUint16GF(uint16_t object);
char *toStringUint16PGF(uint16_t* object);
char *toStringUint8GF(uint8_t object);
char *toStringUint8PGF(uint8_t* object);
char *toStringCharGF(char object);
char *toStringSGF(const char* object);
char *toStringListSGF(char** object);
char *toStringListCSGF(const char** object);
char *toStringDictGF(smallDictt* object);
char *toStringArrayGF(smallArrayt* object);
char *toStringSmallBoolGF(smallBoolt* object);
char *toStringSmallBytesGF(smallBytest* object);
char *toStringSmallDoubleGF(smallDoublet* object);
char *toStringSmallIntGF(smallIntt* object);
char *toStringSmallStringGF(smallStringt* object);
char *toStringVoidGF(void* object);
char *toStringSmallContainerGF(smallContainert* object);
char *toStringSmallJsonGF(smallJsont* object);
char *otos(void *basetObj);
smallStringt *formatO(const char *fmt, ...);
int execO(const char *cmd, smallArrayt *out, smallArrayt *err UNUSED);
int execSmallJsonO(smallJsont *cmd, smallArrayt *out, smallArrayt *err);
int execSmallStringO(smallStringt *cmd, smallArrayt *out, smallArrayt *err);
smallArrayt* walkDirO(const char* dirPath);
smallArrayt *walkDirSmallJsonO(smallJsont* dirPath);
smallArrayt *walkDirSmallStringO(smallStringt* dirPath);
internal void walkADir(const char *dirPath, smallArrayt *list);
smallArrayt* walkDirDirO(const char* dirPath);
smallArrayt *walkDirDirSmallJsonO(smallJsont* dirPath);
smallArrayt *walkDirDirSmallStringO(smallStringt* dirPath);
internal void walkADirDir(const char *dirPath, smallArrayt *list);
smallArrayt *readDirO(const char *dirPath);
smallArrayt *readDirSmallJsonO(smallJsont *dirPath);
smallArrayt *readDirSmallStringO(smallStringt *dirPath);
smallArrayt *readDirDirO(const char *dirPath);
smallArrayt *readDirDirSmallJsonO(smallJsont *dirPath);
smallArrayt *readDirDirSmallStringO(smallStringt *dirPath);
smallArrayt *walkDirAllO(const char* dirPath);
smallArrayt *walkDirAllSmallJsonO(smallJsont* dirPath);
smallArrayt *walkDirAllSmallStringO(smallStringt* dirPath);
internal void walkADirAll(const char *dirPath, smallArrayt *list);
smallArrayt *readDirAllO(const char *dirPath);
smallArrayt *readDirAllSmallJsonO(smallJsont *dirPath);
smallArrayt *readDirAllSmallStringO(smallStringt *dirPath);
time_t getModificationTimeJO(smallJsont *path);
time_t getModificationTimeO(smallStringt *path);
int setModificationTimeJO(smallJsont *path, time_t mtime);
int setModificationTimeO(smallStringt *path, time_t mtime);
bool equalModificationTimesJO(smallJsont *path1, smallJsont *path2);
bool equalModificationTimesSJO(const char *path1, smallJsont *path2);
bool equalModificationTimesJOS(smallJsont *path1, const char *path2);
bool equalModificationTimesJOO(smallJsont *path1, smallStringt *path2);
bool equalModificationTimesOJO(smallStringt *path1, smallJsont *path2);
bool equalModificationTimesO(smallStringt *path1, smallStringt *path2);
bool equalModificationTimesSO(const char *path1, smallStringt *path2);
bool equalModificationTimesOS(smallStringt *path1, const char *path2);
smallJsont *timeToJO(const time_t t);
smallStringt *timeToSO(const time_t t);
smallJsont *shDirnameJO(smallJsont *path);
smallStringt *shDirnameO(smallStringt *path);
smallJsont *expandHomeJO(smallJsont *path);
#if (__OpenBSD__ || __HAIKU__)
smallStringt *expandHomeO(smallStringt *path);
#else
smallStringt *expandHomeO(smallStringt *path);
#endif
smallJsont *normalizePathJO(smallJsont *path);
smallStringt *normalizePathO(smallStringt *path);
smallJsont *getCwdJO(void);
smallStringt *getCwdO(void);
int chDirJO(smallJsont *path);
int chDirO(smallStringt *path);
bool isDirJO(smallJsont *path);
bool isDirO(smallStringt *path);
bool isLinkJO(smallJsont *path);
bool isLinkO(smallStringt *path);
bool fileExistsJO(smallJsont *filePath);
bool fileExistsO(smallStringt *filePath);
bool fileChmodJO(smallJsont *filePath, mode_t mode);
bool fileChmodO(smallStringt *filePath, mode_t mode);
ssize_t fileSizeJO(smallJsont *filePath);
ssize_t fileSizeO(smallStringt *filePath);
void *readFileToNewG(void *none UNUSED, const char *filePath);
void *readStreamToNewG(void *none UNUSED, FILE *fp);
char *readFileToG(char **string, const char *filePath);
char *readStreamToG(char **string, FILE *fp);
void readTextSmallJsonNotSupported(char ***self UNUSED, smallJsont *path UNUSED);
void readTextSmallStringNotSupported(char ***self UNUSED, smallStringt *path UNUSED);
void readToFileSmallJsonNotSupported(void *self UNUSED, smallJsont *path UNUSED);
void readToFileSmallStringNotSupported(void *self UNUSED, smallStringt *path UNUSED);
int writeFileFromG(const char *string, const char *filePath);
int writeStreamFromG(const char *string, FILE *fp);
int writeTextSmallJsonNotSupported(char **self UNUSED, smallJsont *path UNUSED);
int writeTextSmallStringNotSupported(char **self UNUSED, smallStringt *path UNUSED);
int writeTextCCSmallJsonNotSupported(const char **self UNUSED, smallJsont *path UNUSED);
int writeTextCCSmallStringNotSupported(const char **self UNUSED, smallStringt *path UNUSED);
char **readTextSG(char ***list, const char *filePath);
char **readTextStreamG(char ***list, FILE *fp);
bool writeTextSG(char **list, const char *filePath);
bool writeTextStreamG(char **list, FILE *fp);
bool writeTextCG(const char **list, const char *filePath);
bool writeTextStreamCG(const char **list, FILE *fp);
bool appendFileSG(const char *string, const char *filePath);
bool appendTextSG(char **list, const char *filePath);
bool appendTextCG(const char **list, const char *filePath);
int mkdirParentsSmallJsonO(smallJsont* path);
int mkdirParentsO(smallStringt* path);
int rmAllSmallJsonO(smallJsont* path);
int rmAllO(smallStringt* path);
int copyO(smallStringt* src, smallStringt* dst);
int copySSmallJsonO(const char* src, smallJsont* dst);
int copySO(const char* src, smallStringt* dst);
int copySmallJsonOS(smallJsont* src, const char* dst);
int copySmallJsonSmallJson(smallJsont* src, smallJsont* dst);
int copySmallJsonO(smallJsont* src, smallStringt* dst);
int copyOS(smallStringt* src, const char* dst);
int copyOSmallJson(smallStringt* src, smallJsont* dst);
int renameSmallJsonO(smallJsont* src, smallStringt* dst);
int renameSmallJsonSmallJson(smallJsont* src, smallJsont* dst);
int renameSmallJsonOS(smallJsont* src, const char* dst);
int renameO(smallStringt* src, smallStringt* dst);
int renameOSmallJson(smallStringt* src, smallJsont* dst);
int renameSSmallJsonO(const char* src, smallJsont* dst);
int renameSO(const char* src, smallStringt* dst);
int renameOS(smallStringt* src, const char* dst);
int moveSmallJsonO(smallJsont* src, smallStringt* dst);
int moveSmallJsonSmallJson(smallJsont* src, smallJsont* dst);
int moveSmallJsonOS(smallJsont* src, const char* dst);
int moveO(smallStringt* src, smallStringt* dst);
int moveOSmallJson(smallStringt* src, smallJsont* dst);
int moveSSmallJsonO(const char* src, smallJsont* dst);
int moveSO(const char* src, smallStringt* dst);
int moveOS(smallStringt* src, const char* dst);
smallJsont *randomSmallJsonO(uint64_t length);
smallStringt *randomSO(uint64_t length);
smallJsont *randomAlphaNumSmallJsonO(uint64_t length);
smallStringt *randomAlphaNumSO(uint64_t length);
smallJsont *readSmallJsonO(void);
smallStringt *readO(void);
smallJsont *readLineSmallJsonO(FILE *fp);
smallStringt *readLineO(FILE *fp);
char *intToSG(char *retType UNUSED, int64_t n);
char *doubleToSG(char *retType UNUSED, double n);
char **iListUniqG(char ***list, int dum UNUSED);
char **iicListUniqG(char ***list, int dum UNUSED);
char **listFromArrayG(char **retType UNUSED, char **array, size_t size);
char **listFromCArrayG(char **retType UNUSED, const char **array, size_t size);
char getSG(const char *string, int retType UNUSED, int64_t index);
char *listGetG(char **list, int retType UNUSED, int64_t index);
char *listGetCG(const char **list, int retType UNUSED, int64_t index);
char *iListGetG(char **list, int retType UNUSED, int64_t index);
const char *iListGetCG(const char **list, int retType UNUSED, int64_t index);
char *listPopG(char ***list, int retType UNUSED);
char *listDequeueG(char ***list, int retType UNUSED);
char **listDupCG(const char **list);
bool listEqCG(char **list1, const char **list2);
bool listEqC1G(const char **list1, char **list2);
bool listEqCCG(const char **list1, const char **list2);
bool icListEqCG(char **list1, const char **list2);
bool icListEqC1G(const char **list1, char **list2);
bool icListEqCCG(const char **list1, const char **list2);
size_t listLengthCG(const char **list);
ssize_t listIndexOfCG(const char **list, const char *string);
ssize_t listIndexOfCharCG(const char **list, char c);
ssize_t icListIndexOfCG(const char **list, const char *string);
ssize_t icListIndexOfCharCG(const char **list, char c);
bool listHasCharCG(const char **list, char c);
bool listHasCG(const char **list, const char *string);
bool icListHasCG(const char **list, const char *string);
bool icListHasCharCG(const char **list, char c);
char *joinCG(const char **list, const char* delim);
char *joinCharCG(const char **list, char delim);
char **listAddCG(char **list1, const char **list2);
int listPrintCG(const char **list);
bool eqCharChar(char c, char value);
bool equalChaOG(char c, baset* value);
bool equalChaBoolG(char c UNUSED, bool value UNUSED);
bool equalChaDoubleG(char c, double value);
bool equalChaInt64G(char c, int64_t value);
bool equalChaInt32G(char c, int32_t value);
bool equalChaUint32G(char c, uint32_t value);
bool equalChaUint64G(char c, uint64_t value);
bool equalChaSmallBytesG(char c, smallBytest* value);
bool equalChaSmallDoubleG(char c, smallDoublet* value);
bool equalChaSmallIntG(char c, smallIntt* value);
bool equalChaSmallJsonG(char c, smallJsont* value);
bool equalChaSmallStringG(char c, smallStringt* value);
bool equalCharOG(const char *s, baset* value);
bool equalCharBoolG(const char *s, bool value);
bool equalCharDoubleG(const char *s, double value);
bool equalCharInt64G(const char *s, int64_t value);
bool equalCharInt32G(const char *s, int32_t value);
bool equalCharUint32G(const char *s, uint32_t value);
bool equalCharUint64G(const char *s, uint64_t value);
bool equalCharSmallBoolG(const char *s, smallBoolt* value);
bool equalCharSmallBytesG(const char *s, smallBytest* value);
bool equalCharSmallDoubleG(const char *s, smallDoublet* value);
bool equalCharSmallIntG(const char *s, smallIntt* value);
bool equalCharPSmallJsonG(const char *s, smallJsont* value);
bool equalCharPSmallStringG(const char *s, smallStringt* value);
bool equalArrayOG(char ** p1, baset* p2);
bool equalCArrayOG(const char ** p1, baset* p2);
bool equalArraySmallJsonG(char ** p1, smallJsont* p2);
bool equalArraySmallArrayG(char ** p1, smallArrayt* p2);
bool equalCArraySmallJsonG(const char ** p1, smallJsont* p2);
bool equalCArraySmallArrayG(const char ** p1, smallArrayt* p2);
bool equalOCharG(baset* p1, const char * p2);
bool equalOChaG(baset* p1, char p2);
bool equalOArrayG(baset* p1, char ** p2);
bool equalOCArrayG(baset* p1, const char ** p2);
bool equalOOG(baset* p1, baset* p2);
bool equalOBoolG(baset* p1, bool p2);
bool equalODoubleG(baset* p1, double p2);
bool equalOInt64G(baset* p1, int64_t p2);
bool equalOInt32G(baset* p1, int32_t p2);
bool equalOUint32G(baset* p1, uint32_t p2);
bool equalOUint64G(baset* p1, uint64_t p2);
bool equalOSmallArrayG(baset* p1, smallArrayt* p2);
bool equalOSmallBoolG(baset* p1, smallBoolt* p2);
bool equalOSmallBytesG(baset* p1, smallBytest* p2);
bool equalOSmallDoubleG(baset* p1, smallDoublet* p2);
bool equalOSmallDictG(baset* p1, smallDictt* p2);
bool equalOSmallIntG(baset* p1, smallIntt* p2);
bool equalOSmallJsonG(baset* p1, smallJsont* p2);
bool equalOSmallStringG(baset* p1, smallStringt* p2);
bool equalBoolChaG(bool p1 UNUSED, char p2 UNUSED);
bool equalBoolCharG(bool p1, const char * p2);
bool equalBoolOG(bool p1, baset* p2);
bool equalBoolFG(bool p1, bool p2);
bool equalBoolDoubleG(bool p1, double p2);
bool equalBoolInt64G(bool p1, int64_t p2);
bool equalBoolInt32G(bool p1, int32_t p2);
bool equalBoolUint32G(bool p1, uint32_t p2);
bool equalBoolUint64G(bool p1, uint64_t p2);
bool equalBoolSmallBoolG(bool p1, smallBoolt* p2);
bool equalBoolSmallBytesG(bool p1, smallBytest* p2);
bool equalBoolSmallDoubleG(bool p1, smallDoublet* p2);
bool equalBoolSmallIntG(bool p1, smallIntt* p2);
bool equalBoolSmallJsonG(bool p1, smallJsont* p2);
bool equalBoolSmallStringG(bool p1, smallStringt* p2);
bool equalDoubleChaG(double p1, char p2);
bool equalDoubleCharG(double p1, const char * p2);
bool equalDoubleBaseG(double p1, baset* p2);
bool equalDoubleBoolG(double p1, bool p2);
bool equalDoubleFG(double p1, double p2);
bool equalDoubleInt64G(double p1, int64_t p2);
bool equalDoubleInt32G(double p1, int32_t p2);
bool equalDoubleUint32G(double p1, uint32_t p2);
bool equalDoubleUint64G(double p1, uint64_t p2);
bool equalDoubleSmallBoolG(double p1, smallBoolt* p2);
bool equalDoubleSmallBytesG(double p1, smallBytest* p2);
bool equalDoubleSmallDoubleG(double p1, smallDoublet* p2);
bool equalDoubleSmallIntG(double p1, smallIntt* p2);
bool equalDoubleSmallJsonG(double p1, smallJsont* p2);
bool equalDoubleSmallStringG(double p1, smallStringt* p2);
bool equalInt64ChaG(int64_t p1, char p2);
bool equalInt64CharG(int64_t p1, const char * p2);
bool equalInt64BaseG(int64_t p1, baset* p2);
bool equalInt64BoolG(int64_t p1, bool p2);
bool equalInt64DoubleG(int64_t p1, double p2);
bool equalInt64FG(int64_t p1, int64_t p2);
bool equalInt64Int32G(int64_t p1, int32_t p2);
bool equalInt64Uint32G(int64_t p1, uint32_t p2);
bool equalInt64Uint64G(int64_t p1, uint64_t p2);
bool equalInt64SmallBoolG(int64_t p1, smallBoolt* p2);
bool equalInt64SmallBytesG(int64_t p1, smallBytest* p2);
bool equalInt64SmallDoubleG(int64_t p1, smallDoublet* p2);
bool equalInt64SmallIntG(int64_t p1, smallIntt* p2);
bool equalInt64SmallJsonG(int64_t p1, smallJsont* p2);
bool equalInt64SmallStringG(int64_t p1, smallStringt* p2);
bool equalInt32ChaG(int32_t p1, char p2);
bool equalInt32CharG(int32_t p1, const char * p2);
bool equalInt32BaseG(int32_t p1, baset* p2);
bool equalInt32BoolG(int32_t p1, bool p2);
bool equalInt32DoubleG(int32_t p1, double p2);
bool equalInt32Int64G(int32_t p1, int64_t p2);
bool equalInt32FG(int32_t p1, int32_t p2);
bool equalInt32Uint32G(int32_t p1, uint32_t p2);
bool equalInt32Uint64G(int32_t p1, uint64_t p2);
bool equalInt32SmallBoolG(int32_t p1, smallBoolt* p2);
bool equalInt32SmallBytesG(int32_t p1, smallBytest* p2);
bool equalInt32SmallDoubleG(int32_t p1, smallDoublet* p2);
bool equalInt32SmallIntG(int32_t p1, smallIntt* p2);
bool equalInt32SmallJsonG(int32_t p1, smallJsont* p2);
bool equalInt32SmallStringG(int32_t p1, smallStringt* p2);
bool equalUint32ChaG(uint32_t p1, char p2);
bool equalUint32CharG(uint32_t p1, const char * p2);
bool equalUint32BaseG(uint32_t p1, baset* p2);
bool equalUint32BoolG(uint32_t p1, bool p2);
bool equalUint32DoubleG(uint32_t p1, double p2);
bool equalUint32Int64G(uint32_t p1, int64_t p2);
bool equalUint32Int32G(uint32_t p1, int32_t p2);
bool equalUint32FG(uint32_t p1, uint32_t p2);
bool equalUint32Uint64G(uint32_t p1, uint64_t p2);
bool equalUint32SmallBoolG(uint32_t p1, smallBoolt* p2);
bool equalUint32SmallBytesG(uint32_t p1, smallBytest* p2);
bool equalUint32SmallDoubleG(uint32_t p1, smallDoublet* p2);
bool equalUint32SmallIntG(uint32_t p1, smallIntt* p2);
bool equalUint32SmallJsonG(uint32_t p1, smallJsont* p2);
bool equalUint32SmallStringG(uint32_t p1, smallStringt* p2);
bool equalUint64ChaG(uint64_t p1, char p2);
bool equalUint64CharG(uint64_t p1, const char * p2);
bool equalUint64BaseG(uint64_t p1, baset* p2);
bool equalUint64BoolG(uint64_t p1, bool p2);
bool equalUint64DoubleG(uint64_t p1, double p2);
bool equalUint64Int64G(uint64_t p1, int64_t p2);
bool equalUint64Int32G(uint64_t p1, int32_t p2);
bool equalUint64Uint32G(uint64_t p1, uint32_t p2);
bool equalUint64FG(uint64_t p1, uint64_t p2);
bool equalUint64SmallBoolG(uint64_t p1, smallBoolt* p2);
bool equalUint64SmallBytesG(uint64_t p1, smallBytest* p2);
bool equalUint64SmallDoubleG(uint64_t p1, smallDoublet* p2);
bool equalUint64SmallIntG(uint64_t p1, smallIntt* p2);
bool equalUint64SmallJsonG(uint64_t p1, smallJsont* p2);
bool equalUint64SmallStringG(uint64_t p1, smallStringt* p2);
bool notEqualCharG(char c UNUSED, void *value UNUSED);
bool notEqualOCharG(void *a UNUSED, char c UNUSED);
bool notEqualOG(void *a UNUSED, void *b UNUSED);
bool notEqualCCOG(const char *a UNUSED, void *b UNUSED);
bool notEqualBoolOG(bool p1 UNUSED, void *p2 UNUSED);
bool notEqualDoubleOG(double p1 UNUSED, void *p2 UNUSED);
bool notEqualInt64OG(int64_t p1 UNUSED, void *p2 UNUSED);
bool notEqualInt32OG(int32_t p1 UNUSED, void *p2 UNUSED);
bool notEqualUint32OG(uint32_t p1 UNUSED, void *p2 UNUSED);
bool notEqualUint64OG(uint64_t p1 UNUSED, void *p2 UNUSED);
bool notEqualOBoolG(void *p1 UNUSED, bool p2 UNUSED);
bool notEqualDoubleG(void *p1 UNUSED, double p2 UNUSED);
bool notEqualOInt64G(void *p1 UNUSED, int64_t p2 UNUSED);
bool notEqualOInt32G(void *p1 UNUSED, int32_t p2 UNUSED);
bool notEqualOUint32G(void *p1 UNUSED, uint32_t p2 UNUSED);
bool notEqualOUint64G(void *p1 UNUSED, uint64_t p2 UNUSED);
bool icEqCharChar(char c, char value);
bool icEqualChaOG(char c, baset* value);
bool icEqualChaSmallJsonG(char c, smallJsont* value);
bool icEqualChaSmallStringG(char c, smallStringt* value);
bool icEqualCharOG(const char *s, baset* value);
bool icEqualCharPSmallJsonG(const char *s, smallJsont* value);
bool icEqualCharPSmallStringG(const char *s, smallStringt* value);
bool icEqualArrayOG(char ** p1, baset* p2);
bool icEqualCArrayOG(const char ** p1, baset* p2);
bool icEqualArraySmallJsonG(char ** p1, smallJsont* p2);
bool icEqualCArraySmallJsonG(const char ** p1, smallJsont* p2);
bool icEqualArraySmallArrayG(char ** p1, smallArrayt* p2);
bool icEqualCArraySmallArrayG(const char ** p1, smallArrayt* p2);
bool icEqualOCharG(baset* p1, const char * p2);
bool icEqualOChaG(baset* p1, char p2);
bool icEqualOArrayG(baset* p1, char ** p2);
bool icEqualOCArrayG(baset* p1, const char ** p2);
bool icEqualOOG(baset* p1, baset* p2);
bool icEqualOSmallArrayG(baset* p1, smallArrayt* p2);
bool icEqualOSmallDictG(baset* p1, smallDictt* p2);
bool icEqualOSmallJsonG(baset* p1, smallJsont* p2);
bool icEqualOSmallStringG(baset* p1, smallStringt* p2);
void freeBasetInContainer(void *baseo);
smallt *toSmallt(baset *obj);
baset *toBaset(smallt *obj);
int cpuCount(void);
unsigned registerFinalizeRecycleContainersInThreadPool(recycleContainersFt f);
void finalizeLibsheepyRecycleContainers(void *arg UNUSED);
void finalizeLibsheepyAtExit(void);
#if (__APPLE__ || __FreeBSD__ || __TERMUX__ || __OpenBSD__ || __DragonFly__ || MUSL_LIBC || __sun__ || __HAIKU__)
void initLibsheepyObject(void);
void initLibsheepyObject(void);
#endif

#if (__APPLE__ || __FreeBSD__ || __OpenBSD__ || __DragonFly__ || __sun__ || __HAIKU__)
smallDictt *shSysinfo(void) {

  // TODO macos
  // https://stackoverflow.com/questions/12523704/mac-os-x-equivalent-header-file-for-sysinfo-h-in-linux
  //
  createAllocateSmallDict(r);
  if (!r) {
    return(NULL);
  }

  setIntO(r, "uptime", 0);
  setIntO(r, "loads", 0);
  setIntO(r, "totalram", 0);
  setIntO(r, "freeram", 0);
  setIntO(r, "sharedram", 0);
  setIntO(r, "bufferram", 0);
  setIntO(r, "totalswap", 0);
  setIntO(r, "freeswap", 0);
  setIntO(r, "procs", 0);
  return(r);
}
#else // #if (__APPLE__ || __FreeBSD__ || __OpenBSD__ || __DragonFly__ || __sun__ || __HAIKU__)
smallDictt *shSysinfo(void) {

  createAllocateSmallDict(r);
  if (!r) {
    return(NULL);
  }

  struct sysinfo info;

  if (sysinfo(&info) == -1) {
    pFuncError
    terminateO(r);
    return(NULL);
  }

  setIntO(r, "uptime", info.uptime);
  setIntO(r, "loads", (int64_t)info.loads[0]);
  setIntO(r, "totalram", (int64_t)info.totalram);
  setIntO(r, "freeram", (int64_t)info.freeram);
  setIntO(r, "sharedram", (int64_t)info.sharedram);
  setIntO(r, "bufferram", (int64_t)info.bufferram);
  setIntO(r, "totalswap", (int64_t)info.totalswap);
  setIntO(r, "freeswap", (int64_t)info.freeswap);
  setIntO(r, "procs", info.procs);
  return(r);
}
#endif
// #if __APPLE__ || __FreeBSD__ || __OpenBSD__ || __DragonFly__ || __sun__ || __HAIKU__

void cleanUpBaseTerminateG(baset **val) {

  terminateO(*val);
}

void cleanUpBaseFreeG(baset **val) {

  freeO(*val);
}

void cleanUpBaseFinishG(baset **val) {

  finishO(*val);
}

void cleanUpBaseSmashG(baset **val) {

  smashO(*val);
}

baset *duplicateBaseG(baset *self) {

  return(self->f->duplicate(self));
}

void freeManyOF(void *paramType, ...) {
  va_list pl;

  freeO((baset*)paramType);

  // add arguments to a list
  va_start(pl, paramType);
  paramType = va_arg(pl, baset *);
  while (paramType) {
    freeO((baset*)paramType);
    paramType = va_arg(pl, baset *);
  }
  va_end(pl);
}

void terminateManyOF(void *paramType, ...) {
  va_list pl;
  baset *obj = NULL;

  obj = (baset*)paramType;
  terminateO(obj);

  // add arguments to a list
  va_start(pl, paramType);
  paramType = va_arg(pl, baset *);
  while (paramType) {
    obj = (baset*)paramType;
    terminateO(obj);
    paramType = va_arg(pl, baset *);
  }
  va_end(pl);
}

void smashManyOF(void *paramType, ...) {
  va_list pl;
  baset *obj = NULL;

  obj = (baset*)paramType;
  smashO(obj);

  // add arguments to a list
  va_start(pl, paramType);
  paramType = va_arg(pl, baset *);
  while (paramType) {
    obj = (baset*)paramType;
    smashO(obj);
    paramType = va_arg(pl, baset *);
  }
  va_end(pl);
}

void finishManyOF(void *paramType, ...) {
  va_list pl;
  baset *obj = NULL;

  obj = (baset*)paramType;
  finishO(obj);

  // add arguments to a list
  va_start(pl, paramType);
  paramType = va_arg(pl, baset *);
  while (paramType) {
    obj = (baset*)paramType;
    finishO(obj);
    paramType = va_arg(pl, baset *);
  }
  va_end(pl);
}

smallJsont *getProgPathJO(void) {

  createAllocateSmallJson(r);
  if (!r) {
    return(NULL);
  }
  setTopStringO(r, getProgPath());
  return(r);
}

smallStringt *getProgPathO(void) {

  return(allocSmallString(getProgPath()));
}

smallJsont *getRealProgPathJO(void) {

  createAllocateSmallJson(r);
  if (!r) {
    return(NULL);
  }
  setTopStringO(r, getRealProgPath());
  return(r);
}

smallStringt *getRealProgPathO(void) {

  return(allocSmallString(getRealProgPath()));
}

int systemJO(smallJsont *command) {

  if (!command) {
    return(-1);
  }

  const char *type = getTopTypeO(command);

  if (!eqS(type,"string")) {
    return(-1);
  }

  return(system(getTopSO(command)));
}

int systemO(smallStringt *command) {

  if (!command) {
    return(-1);
  }

  return(system(ssGet(command)));
}

int systemNFreeJOF(smallJsont *command, int line, const char *thisFunc, const char *thisFileName) {
  int r;

  if (!command) {
    return(-1);
  }

  const char *type = getTopTypeO(command);

  if (!eqS(type,"string")) {
    return(-1);
  }

  char *cmd = getTopSO(command);;

  r = system(cmd);
  if (r) {
    printf("\nSystem Error at %d, %s, %s. The command was: \"%s\"\n", line, thisFunc, thisFileName, cmd);
    printf("\n");
  }
  terminateO(command);
  return(r);
}

int systemNFreeOF(smallStringt *command, int line, const char *thisFunc, const char *thisFileName) {
  int r;

  if (!command) {
    return(-1);
  }

  char *cmd = ssGet(command);;

  r = system(cmd);
  if (r) {
    printf("\nSystem Error at %d, %s, %s. The command was: \"%s\"\n", line, thisFunc, thisFileName, cmd);
    printf("\n");
  }
  terminateO(command);
  return(r);
}

#if (!(__APPLE__ || __FreeBSD__ || __TERMUX__ || __OpenBSD__ || __DragonFly__ || MUSL_LIBC || __sun__ || __HAIKU__))

int print_m(FILE *stream, const struct printf_info *info, const void *const *args) {
  const baset *o = NULL;
  char *b = NULL;
  int len;

  o = *((baset*const*) args[0]);
  // warning OK: toString discards const qualifier -Wdiscarded-qualifiers
  _Pragma ("GCC diagnostic push")
  _Pragma ("GCC diagnostic ignored \"-Wdiscarded-qualifiers\"") {
  //#pragma GCC diagnostic push
  //bug in cg_c - #pragma GCC diagnostic ignored "-Wdiscarded-qualifiers"
  b = toStringO(o);
  _Pragma ("GCC diagnostic pop")
  //#pragma GCC diagnostic pop

  /* Pad to the minimum field width and print to the stream. */
  //len = fprintf(stream, "%*s", (info->left ? -info->width : info->width), b)
  sheepyRGBFP;
  free(b);
  return(len);
}
  }

int print_m_arginfo(const struct printf_info *info UNUSED, size_t n, int *argtypes, int* size) {

  if (n > 0) {
    argtypes[0] = PA_POINTER;
    size[0]     = sizeof(baset*);
  }
  return(1);
}

#endif
// #if __APPLE__ || __FreeBSD_ || __TERMUX__ || __OpenBSD__ || __DragonFly__ || MUSL_LIBC || __sun__ || __HAIKU__

void putsOF(baset* object) {
  char *s = NULL;

  if (!object) {
    return;
  }
  s = toStringO(object);
  puts(s);
  free(s);
}

void putsUndefinedGF(undefinedt* object) {
  char *s = NULL;

  if (!object) {
    return;
  }
  s = toStringO((baset *)object);
  puts(s);
  free(s);
}

void putsBoolGF(bool object) {

  if (object) {
    puts("true");
  }
  else {
    puts("false");
}
  }

void putsBoolPGF(bool* object) {

  if (!object) {
    return;
  }
  if (*object) {
    puts("true");
  }
  else {
    puts("false");
}
  }

void putsDoubleGF(double object) {
  char *s = NULL;

  isError(s, malloc(256*sizeof(char))) {
    return;
  }
  snprintf(s,256, "%e", object);
  puts(s);
  free(s);
}

void putsDoublePGF(double* object) {
  char *s = NULL;

  if (!object) {
    return;
  }
  isError(s, malloc(256*sizeof(char))) {
    return;
  }
  snprintf(s,256, "%e", *object);
  puts(s);
  free(s);
}

void putsIntGF(int64_t object) {
  char *s = NULL;

  s = intToS(object);
  if (s) {
    puts(s);
  }
  free(s);
}

void putsIntPGF(int64_t* object) {
  char *s = NULL;

  if (!object) {
    return;
  }
  s = intToS(*object);
  if (s) {
    puts(s);
  }
  free(s);
}

void putsInt32GF(int32_t object) {
  char *s = NULL;

  s = intToS(object);
  if (s) {
    puts(s);
  }
  free(s);
}

void putsInt32PGF(int32_t* object) {
  char *s = NULL;

  if (!object) {
    return;
  }
  s = intToS(*object);
  if (s) {
    puts(s);
  }
  free(s);
}

void putsUintGF(uint64_t object) {
  char *s = NULL;

  // TODO create uintToS
  s = intToS((int64_t)object);
  if (s) {
    puts(s);
  }
  free(s);
}

void putsUintPGF(uint64_t* object) {
  char *s = NULL;

  if (!object) {
    return;
  }
  // TODO create uintToS
  s = intToS((int64_t)*object);
  if (s) {
    puts(s);
  }
  free(s);
}

void putsUint32GF(uint32_t object) {
  char *s = NULL;

  s = intToS(object);
  if (s) {
    puts(s);
  }
  free(s);
}

void putsUint32PGF(uint32_t* object) {
  char *s = NULL;

  if (!object) {
    return;
  }
  s = intToS(*object);
  if (s) {
    puts(s);
  }
  free(s);
}

void putsSGF(const char* object) {

  if (!object) {
    return;
  }
  puts(object);
}

void putsListSGF(char** object) {

  pError0(listPrintS(object));
}

void putsListCSGF(const char** object) {

  pError0(listPrintCS(object));
}

void putsDictGF(smallDictt* object) {
  char *s = NULL;

  if (!object) {
    return;
  }
  s = toStringO((baset *)object);
  if (s) {
    puts(s);
  }
  free(s);
}

void putsJsonGF(smallJsont* object) {
  char *s = NULL;

  if (!object) {
    return;
  }
  s = toStringO((baset *)object);
  if (s) {
    puts(s);
  }
  free(s);
}

void putsArrayGF(smallArrayt* object) {
  char *s = NULL;

  if (!object) {
    return;
  }
  s = toStringO((baset *)object);
  if (s) {
    puts(s);
  }
  free(s);
}

void putsSmallBoolGF(smallBoolt* object) {
  char *s = NULL;

  if (!object) {
    return;
  }
  s = toStringO((baset *)object);
  if (s) {
    puts(s);
  }
  free(s);
}

void putsSmallBytesGF(smallBytest* object) {
  char *s = NULL;

  if (!object) {
    return;
  }
  s = toStringO((baset *)object);
  if (s) {
    puts(s);
  }
  free(s);
}

void putsSmallDoubleGF(smallDoublet* object) {
  char *s = NULL;

  if (!object) {
    return;
  }
  s = toStringO((baset *)object);
  if (s) {
    puts(s);
  }
  free(s);
}

void putsSmallIntGF(smallIntt* object) {
  char *s = NULL;

  if (!object) {
    return;
  }
  s = toStringO((baset *)object);
  if (s) {
    puts(s);
  }
  free(s);
}

void putsSmallStringGF(smallStringt* object) {
  char *s = NULL;

  if (!object) {
    return;
  }
  s = toStringO((baset *)object);
  if (s) {
    puts(s);
  }
  free(s);
}

void putsVoidGF(void* object) {

  if (!object) {
    return;
  }
  puts("Unsupported putsG type or void pointer");
}

void putsSmallContainerGF(smallContainert* object) {
  char *s = NULL;

  if (!object) {
    return;
  }
  s = toStringO((baset *)object);
  if (s) {
    puts(s);
  }
  free(s);
}


char *toStringOF(baset* object) {

  if (!object) {
    return(NULL);
  }
  return(toStringO(object));
}

char *toStringUndefinedGF(undefinedt* object) {

  if (!object) {
    return(NULL);
  }
  return(toStringO((baset *)object));
}

char *toStringBoolGF(bool object) {

  if (object) {
    return(strdup("true"));
  }
  else {
    return(strdup("false"));
}
  }

char *toStringBoolPGF(bool* object) {

  if (!object) {
    return(NULL);
  }
  if (*object) {
    return(strdup("true"));
  }
  else {
    return(strdup("false"));
}
  }

char *toStringFloatGF(float object) {
  char *s = NULL;

  isError(s, malloc(256*sizeof(char))) return(NULL);
  snprintf(s,256, "%f", (double)object);
  return(s);
}

char *toStringFloatPGF(float* object) {
  char *s = NULL;

  if (!object) {
    return(NULL);
  }
  isError(s, malloc(256*sizeof(char))) return(NULL);
  snprintf(s,256, "%f", (double)*object);
  return(s);
}

char *toStringDoubleGF(double object) {
  char *s = NULL;

  isError(s, malloc(256*sizeof(char))) return(NULL);
  snprintf(s,256, "%e", object);
  return(s);
}

char *toStringDoublePGF(double* object) {
  char *s = NULL;

  if (!object) {
    return(NULL);
  }
  isError(s, malloc(256*sizeof(char))) return(NULL);
  snprintf(s,256, "%e", *object);
  return(s);
}

char *toStringIntGF(int64_t object) {

  return(intToS(object));
}

char *toStringIntPGF(int64_t* object) {

  if (!object) {
    return(NULL);
  }
  return(intToS(*object));
}

char *toStringInt32GF(int32_t object) {

  return(intToS(object));
}

char *toStringInt32PGF(int32_t* object) {

  if (!object) {
    return(NULL);
  }
  return(intToS(*object));
}

char *toStringInt16GF(int16_t object) {

  return(intToS(object));
}

char *toStringInt16PGF(int16_t* object) {

  if (!object) {
    return(NULL);
  }
  return(intToS(*object));
}

char *toStringUintGF(uint64_t object) {

  // TODO create uintToS
  return(intToS((int64_t)object));
}

char *toStringUintPGF(uint64_t* object) {

  if (!object) {
    return(NULL);
  }
  // TODO create uintToS
  return(intToS((int64_t)*object));
}

char *toStringUint32GF(uint32_t object) {

  return(intToS(object));
}

char *toStringUint32PGF(uint32_t* object) {

  if (!object) {
    return(NULL);
  }
  return(intToS(*object));
}

char *toStringUint16GF(uint16_t object) {

  return(intToS(object));
}

char *toStringUint16PGF(uint16_t* object) {

  if (!object) {
    return(NULL);
  }
  return(intToS(*object));
}

char *toStringUint8GF(uint8_t object) {

  return(intToS(object));
}

char *toStringUint8PGF(uint8_t* object) {

  if (!object) {
    return(NULL);
  }
  return(intToS(*object));
}

char *toStringCharGF(char object) {
  char r[2];;

  r[0] = object;
  r[1] = 0;

  return(strdup(r));
}

char *toStringSGF(const char* object) {

  return(dupS(object));
}

char *toStringListSGF(char** object) {

  if (!object) {
    return(NULL);
  }
  char *s = join(object, "\",\"");
  if (!s) {
    // empty list
    return(strdup("[]"));
  }
  char *r = catS("[\"", s, "\"]");;
  free(s);
  return(r);
}

char *toStringListCSGF(const char** object) {

  if (!object) {
    return(NULL);
  }
  char *s = joinCS(object, "\",\"");
  if (!s) {
    // empty list
    return(strdup("[]"));
  }
  char *r = catS("[\"", s, "\"]");;
  free(s);
  return(r);
}

char *toStringDictGF(smallDictt* object) {

  if (!object) {
    return(NULL);
  }
  return(toStringO((baset *)object));
}

char *toStringArrayGF(smallArrayt* object) {

  if (!object) {
    return(NULL);
  }
  return(toStringO((baset *)object));
}

char *toStringSmallBoolGF(smallBoolt* object) {

  if (!object) {
    return(NULL);
  }
  return(toStringO((baset *)object));
}

char *toStringSmallBytesGF(smallBytest* object) {

  if (!object) {
    return(NULL);
  }
  return(toStringO((baset *)object));
}

char *toStringSmallDoubleGF(smallDoublet* object) {

  if (!object) {
    return(NULL);
  }
  return(toStringO((baset *)object));
}

char *toStringSmallIntGF(smallIntt* object) {

  if (!object) {
    return(NULL);
  }
  return(toStringO((baset *)object));
}

char *toStringSmallStringGF(smallStringt* object) {

  if (!object) {
    return(NULL);
  }
  return(toStringO((baset *)object));
}

char *toStringVoidGF(void* object) {

  if (!object) {
    return(NULL);
  }
  return(strdup("Unsupported toStringG type or void pointer"));
}

char *toStringSmallContainerGF(smallContainert* object) {

  if (!object) {
    return(NULL);
  }
  return(toStringO((baset *)object));
}

char *toStringSmallJsonGF(smallJsont* object) {

  if (!object) {
    return(NULL);
  }
  return(toStringO((baset *)object));
}

char *otos(void *basetObj) {

  cast(baset*, obj, basetObj);
  return(toStringO(obj));
}

smallStringt *formatO(const char *fmt, ...) {
  char *r = NULL;
  va_list pl;

  if (!fmt) {
    return(NULL);
  }
  va_start(pl, fmt);
  if (vasprintf(&r, fmt, pl) == -1) {
    va_end(pl);
    return(NULL);
  }
  va_end(pl);

  smallStringt *R = allocSmallString(r);
  free(r);
  if (!R) {
    return(NULL);
  }
  return(R);
}


int execO(const char *cmd, smallArrayt *out, smallArrayt *err UNUSED) {
  FILE* fp = NULL;
  char **list = NULL;

  // sanity checks
  if (!cmd) {
    return(0);
  }

  if (!out) {
    return(0);
  }

  fp = popen(cmd, "r");
  if (!fp) {
    pFuncError
    shEPrintfS("The command was: \"%s\"\n", cmd);
    return(0);//LCOV_EXCL_LINE
  }

  list = readStream(fp);

  pclose(fp);
  out->f->fromArrayNFree(out, list, 0);
  return(1);
}

int execSmallJsonO(smallJsont *cmd, smallArrayt *out, smallArrayt *err) {

  if (!cmd) {
    return(0);
  }

  const char *type = getTopTypeO(cmd);

  if (!eqS(type,"string")) {
    return(0);
  }

  return(execO(sjGet(cmd), out, err));
}

int execSmallStringO(smallStringt *cmd, smallArrayt *out, smallArrayt *err) {

  if (!cmd) {
    return(0);
  }
  return(execO(ssGet(cmd), out, err));
}

smallArrayt* walkDirO(const char* dirPath) {

  // sanity checks
  if (!dirPath || isBlankS(dirPath)) {
    return(NULL);
  }

  createAllocateSmallArray(list);
  if (!list) {
    return(NULL);
  }
  walkADir(dirPath, list);

  list->f->sort(list);

  return(list);
}

smallArrayt *walkDirSmallJsonO(smallJsont* dirPath) {

  if (!dirPath) {
    return(NULL);
  }

  const char *type = getTopTypeO(dirPath);

  if (!eqS(type,"string")) {
    return(NULL);
  }

  return(walkDirO(getTopSO(dirPath)));
}

smallArrayt *walkDirSmallStringO(smallStringt* dirPath) {

  if (!dirPath) {
    return(NULL);
  }
  return(walkDirO(ssGet(dirPath)));
}

internal void walkADir(const char *dirPath, smallArrayt *list) {
  DIR *d = NULL;
  struct dirent *dp = NULL;
  char *sPath = NULL;

  d = opendir(dirPath);
  if (!d) {
    pFuncError
    shEPrintfS("The path was: \"%s\"\n", dirPath);
    return;
  }

  dp = readdir(d);
  while (dp) {
    if (eqS(dp->d_name, ".") || eqS(dp->d_name, "..")) {
      dp = readdir(d);
      continue;
    }

    sPath = catS(dirPath, "/", dp->d_name);

    if (isDir(sPath)) {
      if (!isLink(sPath)) {
        walkADir(sPath, list);
    }
      }
    else {
      list->f->pushS(list, sPath);
    }
    free(sPath);
    dp = readdir(d);
  }

  closedir(d);
}

smallArrayt* walkDirDirO(const char* dirPath) {

  // sanity checks
  if (!dirPath || isBlankS(dirPath)) {
    return(NULL);
  }

  createAllocateSmallArray(list);
  if (!list) {
    return(NULL);
  }
  walkADirDir(dirPath, list);

  list->f->sort(list);

  return(list);
}

smallArrayt *walkDirDirSmallJsonO(smallJsont* dirPath) {

  if (!dirPath) {
    return(NULL);
  }

  const char *type = getTopTypeO(dirPath);

  if (!eqS(type,"string")) {
    return(NULL);
  }

  return(walkDirDirO(getTopSO(dirPath)));
}

smallArrayt *walkDirDirSmallStringO(smallStringt* dirPath) {

  if (!dirPath) {
    return(NULL);
  }
  return(walkDirDirO(ssGet(dirPath)));
}

internal void walkADirDir(const char *dirPath, smallArrayt *list) {
  DIR *d = NULL;
  struct dirent *dp = NULL;
  char *sPath = NULL;

  d = opendir(dirPath);
  if (!d) {
    pFuncError
    shEPrintfS("The path was: \"%s\"\n", dirPath);
    return;
  }

  dp = readdir(d);
  while (dp) {
    if (eqS(dp->d_name, ".") || eqS(dp->d_name, "..")) {
      dp = readdir(d);
      continue;
    }

    sPath = catS(dirPath, "/", dp->d_name);

    if (isDir(sPath)) {
      list->f->pushS(list, sPath);
      if (!isLink(sPath)) {
        walkADirDir(sPath, list);
    }
      }
    free(sPath);
    dp = readdir(d);
  }

  closedir(d);
}

smallArrayt *readDirO(const char *dirPath) {
  DIR *d = NULL;
  struct dirent *dp = NULL;

  // sanity checks
  if (!dirPath || isBlankS(dirPath)) {
    return(NULL);
  }

  createAllocateSmallArray(list);
  if (!list) {
    return(NULL);
  }

  d = opendir(dirPath);
  if (!d) {
    pFuncError
    shEPrintfS("The path was: \"%s\"\n", dirPath);
    return(list);
  }

  dp = readdir(d);
  while (dp) {
    if (eqS(dp->d_name, ".") || eqS(dp->d_name, "..")) {
      dp = readdir(d);
      continue;
    }

    char *sPath = catS(dirPath, "/", dp->d_name);

    if (!isDir(sPath)) {
      list->f->pushS(list, dp->d_name);
    }
    free(sPath);
    dp = readdir(d);
  }

  closedir(d);

  list->f->sort(list);

  return(list);
}

smallArrayt *readDirSmallJsonO(smallJsont *dirPath) {

  if (!dirPath) {
    return(NULL);
  }

  const char *type = getTopTypeO(dirPath);

  if (!eqS(type,"string")) {
    return(NULL);
  }

  return(readDirO(getTopSO(dirPath)));
}

smallArrayt *readDirSmallStringO(smallStringt *dirPath) {

  if (!dirPath) {
    return(NULL);
  }
  return(readDirO(ssGet(dirPath)));
}

smallArrayt *readDirDirO(const char *dirPath) {
  DIR *d = NULL;
  struct dirent *dp = NULL;

  // sanity checks
  if (!dirPath || isBlankS(dirPath)) {
    return(NULL);
  }

  createAllocateSmallArray(list);
  if (!list) {
    return(NULL);
  }

  d = opendir(dirPath);
  if (!d) {
    pFuncError
    shEPrintfS("The path was: \"%s\"\n", dirPath);
    return(list);
  }

  dp = readdir(d);
  while (dp) {
    if (eqS(dp->d_name, ".") || eqS(dp->d_name, "..")) {
      dp = readdir(d);
      continue;
    }

    char *sPath = catS(dirPath, "/", dp->d_name);

    if (isDir(sPath)) {
      list->f->pushS(list, dp->d_name);
    }
    free(sPath);
    dp = readdir(d);
  }

  closedir(d);

  list->f->sort(list);

  return(list);
}

smallArrayt *readDirDirSmallJsonO(smallJsont *dirPath) {

  if (!dirPath) {
    return(NULL);
  }

  const char *type = getTopTypeO(dirPath);

  if (!eqS(type,"string")) {
    return(NULL);
  }

  return(readDirDirO(getTopSO(dirPath)));
}

smallArrayt *readDirDirSmallStringO(smallStringt *dirPath) {

  if (!dirPath) {
    return(NULL);
  }
  return(readDirDirO(ssGet(dirPath)));
}

smallArrayt *walkDirAllO(const char* dirPath) {

  // sanity checks
  if (!dirPath || isBlankS(dirPath)) {
    return(NULL);
  }

  createAllocateSmallArray(list);
  if (!list) {
    return(NULL);
  }
  walkADirAll(dirPath, list);

  list->f->sort(list);

  return(list);
}

smallArrayt *walkDirAllSmallJsonO(smallJsont* dirPath) {

  if (!dirPath) {
    return(NULL);
  }

  const char *type = getTopTypeO(dirPath);

  if (!eqS(type,"string")) {
    return(NULL);
  }

  return(walkDirAllO(getTopSO(dirPath)));
}

smallArrayt *walkDirAllSmallStringO(smallStringt* dirPath) {

  if (!dirPath) {
    return(NULL);
  }
  return(walkDirAllO(ssGet(dirPath)));
}

internal void walkADirAll(const char *dirPath, smallArrayt *list) {
  DIR *d = NULL;
  struct dirent *dp = NULL;
  char *sPath = NULL;

  d = opendir(dirPath);
  if (!d) {
    pFuncError
    shEPrintfS("The path was: \"%s\"\n", dirPath);
    return;
  }

  dp = readdir(d);
  while (dp) {
    if (eqS(dp->d_name, ".") || eqS(dp->d_name, "..")) {
      dp = readdir(d);
      continue;
    }

    sPath = catS(dirPath, "/", dp->d_name);

    list->f->pushS(list, sPath);

    if (isDir(sPath)) {
      if (!isLink(sPath)) {
        walkADirAll(sPath, list);
    }
      }
    dp = readdir(d);
    free(sPath);
  }

  closedir(d);
}

smallArrayt *readDirAllO(const char *dirPath) {
  DIR *d = NULL;
  struct dirent *dp = NULL;

  // sanity checks
  if (!dirPath || isBlankS(dirPath)) {
    return(NULL);
  }

  createAllocateSmallArray(list);
  if (!list) {
    return(NULL);
  }

  d = opendir(dirPath);
  if (!d) {
    pFuncError
    shEPrintfS("The path was: \"%s\"\n", dirPath);
    return(list);
  }

  dp = readdir(d);
  while (dp) {
    if (eqS(dp->d_name, ".") || eqS(dp->d_name, "..")) {
      dp = readdir(d);
      continue;
    }

    char *sPath = catS(dirPath, "/", dp->d_name);

    list->f->pushS(list, dp->d_name);
    free(sPath);
    dp = readdir(d);
  }

  closedir(d);

  list->f->sort(list);

  return(list);
}

smallArrayt *readDirAllSmallJsonO(smallJsont *dirPath) {

  if (!dirPath) {
    return(NULL);
  }

  const char *type = getTopTypeO(dirPath);

  if (!eqS(type,"string")) {
    return(NULL);
  }

  return(readDirAllO(getTopSO(dirPath)));
}

smallArrayt *readDirAllSmallStringO(smallStringt *dirPath) {

  if (!dirPath) {
    return(NULL);
  }
  return(readDirAllO(ssGet(dirPath)));
}

time_t getModificationTimeJO(smallJsont *path) {

  if (!path) {
    return(0);
  }

  const char *type = getTopTypeO(path);

  if (!eqS(type,"string")) {
    return(0);
  }

  return(getModificationTime(getTopSO(path))); {
  // bug cg_c IF
}
  }

time_t getModificationTimeO(smallStringt *path) {

  if (!path || !path->data) {
    return(0);
  }

  return(getModificationTime(ssGet(path))); {
  // bug cg_c IF
}
  }


int setModificationTimeJO(smallJsont *path, time_t mtime) {

  if (!path) {
    return(0);
  }

  const char *type = getTopTypeO(path);

  if (!eqS(type,"string")) {
    return(0);
  }

  return(setModificationTime(getTopSO(path), mtime)); {
  // bug cg_c IF
}
  }

int setModificationTimeO(smallStringt *path, time_t mtime) {

  if (!path || !path->data) {
    return(0);
  }

  return(setModificationTime(ssGet(path), mtime)); {
  // bug cg_c IF
}
  }


bool equalModificationTimesJO(smallJsont *path1, smallJsont *path2) {

  if (!path1 || !path2) {
    return(false);
  }

  const char *type = getTopTypeO(path1);

  if (!eqS(type,"string")) {
    return(false);
  }

  type = getTopTypeO(path2);

  if (!eqS(type,"string")) {
    return(false);
  }

  return(equalModificationTimes(getTopSO(path1), getTopSO(path2))); {
  // bug cg_c IF
}
  }

bool equalModificationTimesSJO(const char *path1, smallJsont *path2) {

  if (!path1 || !path2) {
    return(false);
  }

  const char *type = getTopTypeO(path2);

  if (!eqS(type,"string")) {
    return(false);
  }

  return(equalModificationTimes(path1, getTopSO(path2))); {
  // bug cg_c IF
}
  }

bool equalModificationTimesJOS(smallJsont *path1, const char *path2) {

  if (!path1 || !path2) {
    return(false);
  }

  const char *type = getTopTypeO(path1);

  if (!eqS(type,"string")) {
    return(false);
  }

  return(equalModificationTimes(getTopSO(path1), path2)); {
  // bug cg_c IF
}
  }

bool equalModificationTimesJOO(smallJsont *path1, smallStringt *path2) {

  if (!path1 || !path2 || !path2->data) {
    return(false);
  }

  const char *type = getTopTypeO(path1);

  if (!eqS(type,"string")) {
    return(false);
  }

  return(equalModificationTimes(getTopSO(path1), ssGet(path2))); {
  // bug cg_c IF
}
  }

bool equalModificationTimesOJO(smallStringt *path1, smallJsont *path2) {

  if (!path1 || !path2 || !path1->data) {
    return(false);
  }

  const char *type = getTopTypeO(path2);

  if (!eqS(type,"string")) {
    return(false);
  }

  return(equalModificationTimes(ssGet(path1), getTopSO(path2))); {
  // bug cg_c IF
}
  }

bool equalModificationTimesO(smallStringt *path1, smallStringt *path2) {

  if (!path1 || !path2 || !path1->data || !path2->data) {
    return(false);
  }

  time_t t1 = getModificationTimeO(path1); {
  time_t t2 = getModificationTimeO(path2); {

  if (!t1 || !t2) {
    return(false);
  }
  return(t1 == t2);;
}
  }
  }

bool equalModificationTimesSO(const char *path1, smallStringt *path2) {

  if (!path2) {
    return(false);
  }
  return(equalModificationTimes(path1, ssGet(path2))); {
  // cg_c bug
}
  }

bool equalModificationTimesOS(smallStringt *path1, const char *path2) {

  if (!path1) {
    return(false);
  }
  return(equalModificationTimes(ssGet(path1), path2)); {
  // cg_c bug
}
  }

smallJsont *timeToJO(const time_t t) {

  char *s         = timeToS(t);
  createAllocateSmallJson(r);
  if (!r) {
    free(s);
    return(NULL);
  }
  setTopStringO(r, s);
  free(s);
  return(r);
}

smallStringt *timeToSO(const time_t t) {

  char *s         = timeToS(t);
  smallStringt *r = allocSmallString(s);
  free(s);
  if (!r) {
    return(NULL);
  }
  return(r);
}

smallJsont *shDirnameJO(smallJsont *path) {

  if (!path) {
    return(NULL);
  }

  const char *type = getTopTypeO(path);

  if (!eqS(type,"string")) {
    return(NULL);
  }

  createAllocateSmallJson(r);
  if (!r) {
    return(NULL);
  }
  setTopNFreeStringO(r, shDirname(getTopSO(path)));
  return(r);
}

smallStringt *shDirnameO(smallStringt *path) {
  char *dir = NULL;
  smallStringt *r = NULL;

  if (!path || !path->data) {
    return(NULL);
  }

  if (isBlankO(path)) {
    return(allocSmallString("./"));
  }

  dir = strdup(ssGet(path));
  dirname(dir);

  // is dirname empty?
  if (strEq(dir, ssGet(path))) {
    // set dir to pwd when dirname is empty
    free(dir);
    dir = strdup("./");
  }
  r = allocSmallString(dir);
  free(dir);
  if (!r) {
    return(NULL);
  }
  return(r);
}


smallJsont *expandHomeJO(smallJsont *path) {

  // sanity checks
  if (!path) {
    return(NULL);
  }

  const char *type = getTopTypeO(path);

  if (!eqS(type,"string")) {
    return(NULL);
  }

  char *r = expandHome(getTopSO(path));
  freeO(path);
  setTopNFreeStringO(path, r);
  return(path);
}

#if (__OpenBSD__ || __HAIKU__)
smallStringt *expandHomeO(smallStringt *path) {

  // sanity checks
  if (!path || !path->data) {
    return(NULL);
  }

  char *r = expandHome(ssGet(path));
  path->f->set(path, r);
  free(r);
  return(path);
}

#else
smallStringt *expandHomeO(smallStringt *path) {
  wordexp_t exp_result;

  // sanity checks
  // duplicate path to be able to realloc (impossible when path is static)
  // expand ~/ or ~USER

  // sanity checks
  if (!path || !path->data) {
    return(NULL);
  }

  #if (!__TERMUX__)
  // expand ~/
  int status = wordexp(path->f->get(path), &exp_result, 0);;
  switch (status) {
    case WRDE_BADCHAR:
      shEPrintfS("expandHomeO error: unquoted invalid character\n");
      shEPrintfS("The path was: \"%s\"\n", ssGet(path));
      return(NULL);
    case WRDE_BADVAL:
      shEPrintfS("expandHomeO error: undefined shell variable\n");
      shEPrintfS("The path was: \"%s\"\n", ssGet(path));
      return(NULL);
    case WRDE_NOSPACE:
      shEPrintfS("expandHomeO error: out of memory\n");
      shEPrintfS("The path was: \"%s\"\n", ssGet(path));
      return(NULL);
    case WRDE_SYNTAX:
      shEPrintfS("expandHomeO error: syntax error\n");
      shEPrintfS("The path was: \"%s\"\n", ssGet(path));
      return(NULL);
    default:
      break;
  }

  path->f->set(path, exp_result.we_wordv[0]);
  wordfree(&exp_result);
  #else
  path->f->replace(path, "~", "/data/data/com.termux/files/home", 1);
  #endif
  return(path);
}

#endif
// #if __OpenBSD__ || __HAIKU__

smallJsont *normalizePathJO(smallJsont *path) {

  if (!path) {
    return(NULL);
  }

  const char *type = getTopTypeO(path);

  if (!eqS(type,"string")) {
    return(NULL);
  }

  char *r = normalizePath(getTopSO(path));
  freeO(path);
  setTopNFreeStringO(path, r);
  return(path);
}

smallStringt *normalizePathO(smallStringt *path) {

  // sanity checks
  if (!path || !path->data) {
    return(NULL);
  }

  if (isEmptyO(path)) {
    return(path);
  }

  // list path elements
  char **pathL = splitSO(path, "/");

  // remove empty elements
  pErrorNULL(iListCompactS(&pathL));

  if (listIsEmptyS(pathL)) {
    listFreeS(pathL);
    // keep leading /
    path->f->set(path, "/");
    return(path);
  }

  // new path elements
  char **list = NULL;

  // detect leading double dots
  bool onlyLeadingDoubleDots = true;

  // add elements to list
  forEachCharP(pathL, level) {
    if (strEq(*level, "..")) {
      if (onlyLeadingDoubleDots) {
        // keep leading ..
        pErrorNULL(listPushS(&list, ".."));
      }
      else {
        // remove .. in path
        char *s = listPopS(&list);
        free(s);
    }
      }
    else if (!strEq(*level, ".")) {
      // remove . and add elements
      pErrorNULL(listPushS(&list, *level));
      // an element is pushed, so this is the end of leading double dots
      onlyLeadingDoubleDots = false;
  }
    }

  if (listLengthS(list) == 1 && strEq(list[0], "..") && path->f->getAt(path, 0) == '/') {
    // handle ../ .. /.. /../
    list[0][0] = 0;
  }

  // handle /.: add empty string
  if (path->f->equalS(path, "/.")) {
    pErrorNULL(listPushS(&list, ""));
  }

  // keep leading /
  if (path->f->getAt(path, 0) == '/') {
    if (listIsEmptyS(list)) {
      // .. cancelled path: /a/b/../..
      listFreeManyS(pathL, list);
      path->f->set(path, "/");
      return(path);
    }
    pErrorNULL(listPrependS(&list, ""));
  }

  // create new path
  char *r = join(list, "/");;
  // keep order pathL, list because list can be NULL
  // if it is first listFreeManyS stops early
  listFreeManyS(pathL, list);
  if (!r) {
    path->f->set(path, "");
    return(path);
  }
  path->f->setNFree(path, r);
  return(path);
}


smallJsont *getCwdJO(void) {

  char *s = getCwd();

  if (!s) {
    return(NULL);
  }

  createAllocateSmallJson(r);
  if (!r) {
    free(s);
    return(NULL);
  }
  setTopNFreeStringO(r, s);
  return(r);
}

smallStringt *getCwdO(void) {
  char *r = NULL;

  r = getcwd(NULL, 0);
  if (!r) {
    pFuncError
    return(NULL);
  }
  createAllocateSmallString(s);
  if (!s) {
    free(r);
    return(NULL);
  }
  s->f->setNFree(s, r);
  return(s);
}

int chDirJO(smallJsont *path) {

  if (!path) {
    return(0);
  }

  const char *type = getTopTypeO(path);

  if (!eqS(type,"string")) {
    return(0);
  }

  return(chDir(getTopSO(path)));
}

int chDirO(smallStringt *path) {

  if (!path) {
    return(0);
  }

  int r = chdir(ssGet(path));
  if (r) {
    pFuncError
    shEPrintfS("The path was: \"%s\"\n", ssGet(path));
    return(0);
  }
  return(1);
}

bool isDirJO(smallJsont *path) {

  if (!path) {
    return(false);
  }

  const char *type = getTopTypeO(path);

  if (!eqS(type,"string")) {
    return(false);
  }

  return(isDir(getTopSO(path)));
}

bool isDirO(smallStringt *path) {
  struct stat st;

  // sanity checks
  if (!path || isBlankO(path)) {
    return(false);
  }

  if (stat(ssGet(path), &st) == -1) {
    return(false);
  }

  if (!S_ISDIR(st.st_mode)) {
    return(false);
  }
  return(true);
}

bool isLinkJO(smallJsont *path) {

  if (!path) {
    return(false);
  }

  const char *type = getTopTypeO(path);

  if (!eqS(type,"string")) {
    return(false);
  }

  return(isLink(getTopSO(path)));
}

bool isLinkO(smallStringt *path) {
  struct stat st;

  // sanity checks
  if (!path || isBlankO(path)) {
    return(false);
  }

  if (lstat(ssGet(path), &st) == -1) {
    return(false);
  }

  if (!S_ISLNK(st.st_mode)) {
    return(false);
  }
  return(true);
}

bool fileExistsJO(smallJsont *filePath) {

  if (!filePath) {
    return(false);
  }

  const char *type = getTopTypeO(filePath);

  if (!eqS(type,"string")) {
    return(false);
  }

  return(fileExists(getTopSO(filePath)));
}

bool fileExistsO(smallStringt *filePath) {

  // sanity checks
  if (!filePath || filePath->f->isBlank(filePath)) {
    return(false);
  }

  int r = access(filePath->f->get(filePath), F_OK);
  //if r
  //  perror("fileExists error");
  // dont print error because this is a test
  return(r != -1);;
}

bool fileChmodJO(smallJsont *filePath, mode_t mode) {

  if (!filePath) {
    return(false);
  }

  const char *type = getTopTypeO(filePath);

  if (!eqS(type,"string")) {
    return(false);
  }

  return(fileChmod(getTopSO(filePath), mode));
}

bool fileChmodO(smallStringt *filePath, mode_t mode) {

  // sanity checks
  if (!filePath || isBlankO(filePath)) {
    return(false);
  }

  int r = chmod(ssGet(filePath), mode);
  if (r) {
    pFuncError
    shEPrintfS("The path was: \"%s\"\n", ssGet(filePath));
  }
  return(r == 0);;
}

ssize_t fileSizeJO(smallJsont *filePath) {

  if (!filePath) {
    return(-1);
  }

  const char *type = getTopTypeO(filePath);

  if (!eqS(type,"string")) {
    return(-1);
  }

  return(fileSize(getTopSO(filePath)));
}

ssize_t fileSizeO(smallStringt *filePath) {
  struct stat st;

  // sanity checks
  if (!filePath || isBlankO(filePath)) {
    return(-1);
  }

  int r = stat(ssGet(filePath), &st);;
  if (r) {
    pFuncError
    shEPrintfS("The path was: \"%s\"\n", ssGet(filePath));
    return(-1);
  }

  // macOS returns a varying number a number above the constant below
  // when the file doesnt exists
  if ((uint64_t)(st.st_size) > 140734000000000) {
    return(-1);//LCOV_EXCL_LINE
  }
  return(st.st_size);
}

void *readFileToNewG(void *none UNUSED, const char *filePath) {

  return(readFileToS(filePath));
}

void *readStreamToNewG(void *none UNUSED, FILE *fp) {

  return(readStreamToS(fp));
}

char *readFileToG(char **string, const char *filePath) {

  if (!string) {
    return(NULL);
  }
  *string = readFileToS(filePath);
  return(*string);
}

char *readStreamToG(char **string, FILE *fp) {

  if (!string) {
    return(NULL);
  }
  *string = readStreamToS(fp);
  return(*string);
}

void readTextSmallJsonNotSupported(char ***self UNUSED, smallJsont *path UNUSED) {

  // TODO
  shPrintError;
  logI("readFile smallJsont path not supported");
}

void readTextSmallStringNotSupported(char ***self UNUSED, smallStringt *path UNUSED) {

  // TODO
  shPrintError;
  logI("readFile smallStringt path not supported");
}

void readToFileSmallJsonNotSupported(void *self UNUSED, smallJsont *path UNUSED) {

  // TODO
  shPrintError;
  logI("readFile smallJsont path not supported");
}

void readToFileSmallStringNotSupported(void *self UNUSED, smallStringt *path UNUSED) {

  // TODO
  shPrintError;
  logI("readFile smallStringt path not supported");
}

int writeFileFromG(const char *string, const char *filePath) {

  return(writeFileS(filePath, string));
}

int writeStreamFromG(const char *string, FILE *fp) {

  return(writeStreamS(fp, string));
}

int writeTextSmallJsonNotSupported(char **self UNUSED, smallJsont *path UNUSED) {

  // TODO
  shPrintError;
  logI("writeFile smallJsont path not supported");
  return(0);
}

int writeTextSmallStringNotSupported(char **self UNUSED, smallStringt *path UNUSED) {

  // TODO
  shPrintError;
  logI("writeFile smallStringt path not supported");
  return(0);
}

int writeTextCCSmallJsonNotSupported(const char **self UNUSED, smallJsont *path UNUSED) {

  // TODO
  shPrintError;
  logI("writeFile smallJsont path not supported");
  return(0);
}

int writeTextCCSmallStringNotSupported(const char **self UNUSED, smallStringt *path UNUSED) {

  // TODO
  shPrintError;
  logI("writeFile smallStringt path not supported");
  return(0);
}

char **readTextSG(char ***list, const char *filePath) {

  if (!list) {
    return(NULL);
  }
  *list = readText(filePath);
  return(*list);
}

char **readTextStreamG(char ***list, FILE *fp) {

  if (!list) {
    return(NULL);
  }
  *list = readStream(fp);
  return(*list);
}

bool writeTextSG(char **list, const char *filePath) {

  return(writeText(filePath, list));
}

bool writeTextStreamG(char **list, FILE *fp) {

  return(writeStream(fp, list));
}

bool writeTextCG(const char **list, const char *filePath) {

  return(writeCText(filePath, list));
}

bool writeTextStreamCG(const char **list, FILE *fp) {

  return(writeCStream(fp, list));
}

bool appendFileSG(const char *string, const char *filePath) {

  return(appendFileS(filePath, string));
}

bool appendTextSG(char **list, const char *filePath) {

  return(appendText(filePath, list));
}

bool appendTextCG(const char **list, const char *filePath) {

  return(appendCText(filePath, list));
}

int mkdirParentsSmallJsonO(smallJsont* path) {

  if (!path) {
    return(0);
  }

  const char *type = getTopTypeO(path);

  if (!eqS(type,"string")) {
    return(0);
  }

  return(mkdirParents(getTopSO(path)));
}

int mkdirParentsO(smallStringt* path) {

  // sanity checks
  if (!path || path->f->isBlank(path)) {
    return(0);
  }

  return(mkdirParents(ssGet(path)));
}

int rmAllSmallJsonO(smallJsont* path) {

  if (!path) {
    return(0);
  }

  const char *type = getTopTypeO(path);

  if (!eqS(type,"string")) {
    return(0);
  }

  return(rmAll(getTopSO(path)));
}

int rmAllO(smallStringt* path) {

  // sanity checks
  if (!path || path->f->isBlank(path)) {
    return(0);
  }

  return(rmAll(ssGet(path)));
}

int copyO(smallStringt* src, smallStringt* dst) {

  // sanity checks
  if (!src || !dst || src->f->isBlank(src) || dst->f->isBlank(dst)) {
    return(0);
  }

  return(copy(ssGet(src), ssGet(dst)));
}

int copySSmallJsonO(const char* src, smallJsont* dst) {

  if (!src || !dst || isBlankS(src)) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallJson(dst)) {
    return(0);
  }

  const char *type = getTopTypeO(dst);

  if (!eqS(type,"string")) {
    return(0);
  }

  if (isBlankO(dst)) {
    return(0);
  }

  return(copy(src, getTopSO(dst)));
}

int copySO(const char* src, smallStringt* dst) {

  // sanity checks
  if (!src || !dst || isBlankS(src) || dst->f->isBlank(dst)) {
    return(0);
  }

  return(copy(src, ssGet(dst)));
}

int copySmallJsonOS(smallJsont* src, const char* dst) {

  if (!src || !dst || isBlankS(dst)) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallJson(src)) {
    return(0);
  }

  const char *type = getTopTypeO(src);

  if (!eqS(type,"string")) {
    return(0);
  }

  if (isBlankO(src)) {
    return(0);
  }

  return(copy(getTopSO(src), dst));
}

int copySmallJsonSmallJson(smallJsont* src, smallJsont* dst) {

  if (!src || !dst) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallJson(src)) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallJson(dst)) {
    return(0);
  }

  const char *type = getTopTypeO(src);

  if (!eqS(type,"string")) {
    return(0);
  }

  type = getTopTypeO(dst);

  if (!eqS(type,"string")) {
    return(0);
  }

  if (isBlankO(src) || isBlankO(dst)) {
    return(0);
  }

  return(copy(getTopSO(src), getTopSO(dst)));
}

int copySmallJsonO(smallJsont* src, smallStringt* dst) {

  if (!src || !dst) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallJson(src)) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallString(dst)) {
    return(0);
  }

  const char *type = getTopTypeO(src);

  if (!eqS(type,"string")) {
    return(0);
  }

  if (isBlankO(src) || isBlankO(dst)) {
    return(0);
  }

  return(copy(getTopSO(src), ssGet(dst)));
}

int copyOS(smallStringt* src, const char* dst) {

  // sanity checks
  if (!src || !dst || src->f->isBlank(src) || isBlankS(dst)) {
    return(0);
  }

  return(copy(ssGet(src), dst));
}

int copyOSmallJson(smallStringt* src, smallJsont* dst) {

  if (!src || !dst) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallString(src)) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallJson(dst)) {
    return(0);
  }

  const char *type = getTopTypeO(dst);

  if (!eqS(type,"string")) {
    return(0);
  }

  if (isBlankO(src) || isBlankO(dst)) {
    return(0);
  }

  return(copy(ssGet(src), getTopSO(dst)));
}

int renameSmallJsonO(smallJsont* src, smallStringt* dst) {

  if (!src || !dst) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallJson(src)) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallString(dst)) {
    return(0);
  }

  const char *type = getTopTypeO(src);

  if (!eqS(type,"string")) {
    return(0);
  }

  if (isBlankO(src) || isBlankO(dst)) {
    return(0);
  }

  return(shRename(getTopSO(src), ssGet(dst)));
}

int renameSmallJsonSmallJson(smallJsont* src, smallJsont* dst) {

  if (!src || !dst) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallJson(src)) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallJson(dst)) {
    return(0);
  }

  const char *type = getTopTypeO(src);

  if (!eqS(type,"string")) {
    return(0);
  }

  type = getTopTypeO(dst);

  if (!eqS(type,"string")) {
    return(0);
  }

  if (isBlankO(src) || isBlankO(dst)) {
    return(0);
  }

  return(shRename(getTopSO(src), getTopSO(dst)));
}

int renameSmallJsonOS(smallJsont* src, const char* dst) {

  if (!src || !dst || isBlankS(dst)) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallJson(src)) {
    return(0);
  }

  const char *type = getTopTypeO(src);

  if (!eqS(type,"string")) {
    return(0);
  }

  if (isBlankO(src)) {
    return(0);
  }

  return(shRename(getTopSO(src), dst));
}

int renameO(smallStringt* src, smallStringt* dst) {

  // sanity checks
  if (!src || !dst || src->f->isBlank(src) || dst->f->isBlank(dst)) {
    return(0);
  }

  return(shRename(ssGet(src), ssGet(dst)));
}

int renameOSmallJson(smallStringt* src, smallJsont* dst) {

  if (!src || !dst) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallString(src)) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallJson(dst)) {
    return(0);
  }

  const char *type = getTopTypeO(dst);

  if (!eqS(type,"string")) {
    return(0);
  }

  if (isBlankO(src) || isBlankO(dst)) {
    return(0);
  }

  return(shRename(ssGet(src), getTopSO(dst)));
}

int renameSSmallJsonO(const char* src, smallJsont* dst) {

  if (!dst) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallJson(dst)) {
    return(0);
  }

  const char *type = getTopTypeO(dst);

  if (!eqS(type,"string")) {
    return(0);
  }

  if (isBlankS(src) || isBlankO(dst)) {
    return(0);
  }

  return(shRename(src, sjGet(dst)));
}

int renameSO(const char* src, smallStringt* dst) {

  if (!dst) {
    return(0);
  }
  return(shRename(src, ssGet(dst)));
}

int renameOS(smallStringt* src, const char* dst) {

  if (!src) {
    return(0);
  }
  return(shRename(ssGet(src), dst));
}

int moveSmallJsonO(smallJsont* src, smallStringt* dst) {

  if (!src || !dst) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallJson(src)) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallString(dst)) {
    return(0);
  }

  const char *type = getTopTypeO(src);

  if (!eqS(type,"string")) {
    return(0);
  }

  if (isBlankO(src) || isBlankO(dst)) {
    return(0);
  }

  return(shMove(getTopSO(src), ssGet(dst)));
}

int moveSmallJsonSmallJson(smallJsont* src, smallJsont* dst) {

  if (!src || !dst) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallJson(src)) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallJson(dst)) {
    return(0);
  }

  const char *type = getTopTypeO(src);

  if (!eqS(type,"string")) {
    return(0);
  }

  type = getTopTypeO(dst);

  if (!eqS(type,"string")) {
    return(0);
  }

  if (isBlankO(src) || isBlankO(dst)) {
    return(0);
  }

  return(shMove(getTopSO(src), getTopSO(dst)));
}

int moveSmallJsonOS(smallJsont* src, const char* dst) {

  if (!src || !dst || isBlankS(dst)) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallJson(src)) {
    return(0);
  }

  const char *type = getTopTypeO(src);

  if (!eqS(type,"string")) {
    return(0);
  }

  if (isBlankO(src)) {
    return(0);
  }

  return(shMove(getTopSO(src), dst));
}

int moveO(smallStringt* src, smallStringt* dst) {

  // sanity checks
  if (!src || !dst || src->f->isBlank(src) || dst->f->isBlank(dst)) {
    return(0);
  }

  return(shMove(ssGet(src), ssGet(dst)));
}

int moveOSmallJson(smallStringt* src, smallJsont* dst) {

  if (!src || !dst) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallString(src)) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallJson(dst)) {
    return(0);
  }

  const char *type = getTopTypeO(dst);

  if (!eqS(type,"string")) {
    return(0);
  }

  if (isBlankO(src) || isBlankO(dst)) {
    return(0);
  }

  return(shMove(ssGet(src), getTopSO(dst)));
}

int moveSSmallJsonO(const char* src, smallJsont* dst) {

  if (!dst) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallJson(dst)) {
    return(0);
  }

  const char *type = getTopTypeO(dst);

  if (!eqS(type,"string")) {
    return(0);
  }

  if (isBlankS(src) || isBlankO(dst)) {
    return(0);
  }

  return(shMove(src, sjGet(dst)));
}

int moveSO(const char* src, smallStringt* dst) {

  if (!dst) {
    return(0);
  }
  return(shMove(src, ssGet(dst)));
}

int moveOS(smallStringt* src, const char* dst) {

  if (!src) {
    return(0);
  }
  return(shMove(ssGet(src), dst));
}

smallJsont *randomSmallJsonO(uint64_t length) {
  char *s = NULL;

  s = randomS(length);
  if (!s) {
    return(NULL);
  }
  createAllocateSmallJson(r);
  if (!r) {
    free(s);
    return(NULL);
  }
  setTopNFreeStringO(r, s);
  return(r);
}

smallStringt *randomSO(uint64_t length) {
  char *s = NULL;

  s = randomS(length);
  if (!s) {
    return(NULL);
  }
  createAllocateSmallString(r);
  if (!r) {
    free(s);
    return(NULL);
  }
  r->f->setNFree(r, s);
  return(r);
}

smallJsont *randomAlphaNumSmallJsonO(uint64_t length) {
  char *s = NULL;

  s = randomAlphaNumS(length);
  if (!s) {
    return(NULL);
  }
  createAllocateSmallJson(r);
  if (!r) {
    free(s);
    return(NULL);
  }
  setTopNFreeStringO(r, s);
  return(r);
}

smallStringt *randomAlphaNumSO(uint64_t length) {
  char *s = NULL;

  s = randomAlphaNumS(length);
  if (!s) {
    return(NULL);
  }
  createAllocateSmallString(r);
  if (!r) {
    free(s);
    return(NULL);
  }
  r->f->setNFree(r, s);
  return(r);
}

smallJsont *readSmallJsonO(void) {

  char *s = readS();
  if (!s) {
    return(NULL);
  }
  createAllocateSmallJson(r);
  if (!r) {
    free(s);
    return(NULL);
  }
  setTopNFreeStringO(r, s);
  return(r);
}

#define startMax   20

smallStringt *readO(void) {
  size_t max = startMax;;

  char *s = malloc(max);
  if (!s) {
    return(NULL);
  }

  size_t i = 0;
  while (1) {
    #ifndef unitTest
    int c = getchar();
    #else
    int c;
    if (i < startMax) {
      c = 'a';
    }
    else {
      c = '\n';
    }
    #endif
    if (c == '\n') {
      s[i] = 0;
      break;
    }
    s[i] = (char)c;
    if (i == max-1) {
      // buffer full
      max += max;
      char *tmp = realloc(s, max);
      if (!tmp) {
        free(s);
        return(NULL);
      }
      s = tmp;
    }
    i++;
  }
  createAllocateSmallString(r);
  if (!r) {
    free(s);
    return(NULL);
  }
  r->f->setNFree(r, s);
  return(r);
}

smallJsont *readLineSmallJsonO(FILE *fp) {

  char *s = readLine(fp);
  if (!s) {
    return(NULL);
  }
  createAllocateSmallJson(r);
  if (!r) {
    free(s);
    return(NULL);
  }
  setTopNFreeStringO(r, s);
  return(r);
}

smallStringt *readLineO(FILE *fp) {
  char *s = NULL;

  // sanity checks
  if (!fp) {
    return(NULL);
  }

  s = readLine(fp);
  if (!s) {
    return(NULL);
  }
  createAllocateSmallString(r);
  if (!r) {
    free(s);
    return(NULL);
  }
  r->f->setNFree(r, s);
  return(r);
}

char *intToSG(char *retType UNUSED, int64_t n) {

  return(intToS(n));
}

char *doubleToSG(char *retType UNUSED, double n) {

  return(doubleToS(n));
}

char **iListUniqG(char ***list, int dum UNUSED) {

  return(iListUniqS(list));
}

char **iicListUniqG(char ***list, int dum UNUSED) {

  return(iicListUniqS(list));
}

char **listFromArrayG(char **retType UNUSED, char **array, size_t size) {

  return(listFromArrayS(array, size));
}

char **listFromCArrayG(char **retType UNUSED, const char **array, size_t size) {

  return(listFromCArrayS(array, size));
}

char getSG(const char *string, int retType UNUSED, int64_t index) {

  return(getS(string, index));
}

char *listGetG(char **list, int retType UNUSED, int64_t index) {

  return(listGetS(list, index));
}

char *listGetCG(const char **list, int retType UNUSED, int64_t index) {

  return(listGetCS(list, index));
}

char *iListGetG(char **list, int retType UNUSED, int64_t index) {

  return(iListGetS(list, index));
}

const char *iListGetCG(const char **list, int retType UNUSED, int64_t index) {

  return(iListGetCS(list, index));
}

char *listPopG(char ***list, int retType UNUSED) {

  return(listPopS(list));
}

char *listDequeueG(char ***list, int retType UNUSED) {

  return(listDequeueS(list));
}

char **listDupCG(const char **list) {

  return(listDupCS(list));
}

bool listEqCG(char **list1, const char **list2) {

  return(listEqCS(list1, list2));
}

bool listEqC1G(const char **list1, char **list2) {

  return(listEqC1S(list1, list2));
}

bool listEqCCG(const char **list1, const char **list2) {

  return(listEqCCS(list1, list2));
}

bool icListEqCG(char **list1, const char **list2) {

  return(icListEqCS(list1, list2));
}

bool icListEqC1G(const char **list1, char **list2) {

  return(icListEqC1S(list1, list2));
}

bool icListEqCCG(const char **list1, const char **list2) {

  return(icListEqCCS(list1, list2));
}

size_t listLengthCG(const char **list) {

  return(listLengthCS(list));
}

ssize_t listIndexOfCG(const char **list, const char *string) {

  return(listIndexOfCS(list, string));
}

ssize_t listIndexOfCharCG(const char **list, char c) {

  return(listIndexOfCharCS(list, c));
}

ssize_t icListIndexOfCG(const char **list, const char *string) {

  return(icListIndexOfCS(list, string));
}

ssize_t icListIndexOfCharCG(const char **list, char c) {

  return(icListIndexOfCharCS(list, c));
}

bool listHasCharCG(const char **list, char c) {

  return(listHasCharCS(list, c));
}

bool listHasCG(const char **list, const char *string) {

  return(listHasCS(list, string));
}

bool icListHasCG(const char **list, const char *string) {

  return(icListHasCS(list, string));
}

bool icListHasCharCG(const char **list, char c) {

  return(icListHasCharCS(list, c));
}

char *joinCG(const char **list, const char* delim) {

  return(joinCS(list, delim));
}

char *joinCharCG(const char **list, char delim) {

  charToS(s, delim);
  return(joinCS(list, s));
}

char **listAddCG(char **list1, const char **list2) {

  return(listAddCS(list1, list2));
}

int listPrintCG(const char **list) {

  return(listPrintCS(list));
}

bool eqCharChar(char c, char value) {

  return(c == value);;
}

bool equalChaOG(char c, baset* value) {

  charToS(s, c);
  return(equalCharOG(s, value));
}

bool equalChaBoolG(char c UNUSED, bool value UNUSED) {

  return(false);
}

bool equalChaDoubleG(char c, double value) {

  charToS(s, c);
  return(equalDoubleCharG(value, s));
}

bool equalChaInt64G(char c, int64_t value) {

  charToS(s, c);
  return(equalInt64CharG(value, s));
}

bool equalChaInt32G(char c, int32_t value) {

  charToS(s, c);
  return(equalInt32CharG(value, s));
}

bool equalChaUint32G(char c, uint32_t value) {

  charToS(s, c);
  return(equalUint32CharG(value, s));
}

bool equalChaUint64G(char c, uint64_t value) {

  charToS(s, c);
  return(equalUint64CharG(value, s));
}

bool equalChaSmallBytesG(char c, smallBytest* value) {

  if (!value || !value->B) {
    return(false);
  }

  charToS(s, c);

  return(equalSO(value, s));
}

bool equalChaSmallDoubleG(char c, smallDoublet* value) {

  charToS(s, c);

  if (!value) {
    return(false);
  }
  return(value->f->equalChar(value, s));
}

bool equalChaSmallIntG(char c, smallIntt* value) {

  charToS(s, c);

  if (!value) {
    return(false);
  }
  return(value->f->equalChar(value, s));
}

bool equalChaSmallJsonG(char c, smallJsont* value) {

  if (!value) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallJson(value)) {
    return(0);
  }

  const char *type = getTopTypeO(value);

  if (!eqS(type,"string")) {
    return(0);
  }

  charToS(s, c);
  return(eqS(getTopSO(value), s));
}

bool equalChaSmallStringG(char c, smallStringt* value) {

  if (!value || !value->data) {
    return(false);
  }

  charToS(s, c);
  return(equalSO(value, s));
}


bool equalCharOG(const char *s, baset* value) {

  if (!s || !value) {
    return(false);
  }

  char *v = toStringO(value);
  bool r  = strEq(s, v);
  free(v);
  return(r);
}

bool equalCharBoolG(const char *s, bool value) {

  return(equalBoolCharG(value, s));
}

bool equalCharDoubleG(const char *s, double value) {

  return(equalDoubleCharG(value, s));
}

bool equalCharInt64G(const char *s, int64_t value) {

  return(equalInt64CharG(value, s));
}

bool equalCharInt32G(const char *s, int32_t value) {

  return(equalInt32CharG(value, s));
}

bool equalCharUint32G(const char *s, uint32_t value) {

  return(equalUint32CharG(value, s));
}

bool equalCharUint64G(const char *s, uint64_t value) {

  return(equalUint64CharG(value, s));
}

bool equalCharSmallBoolG(const char *s, smallBoolt* value) {

  if (!value) {
    return(false);
  }
  return(value->f->equalChar(value, s));
}

bool equalCharSmallBytesG(const char *s, smallBytest* value) {

  if (!value) {
    return(false);
  }
  return(value->f->equalS(value, s));
}

bool equalCharSmallDoubleG(const char *s, smallDoublet* value) {

  if (!value) {
    return(false);
  }
  return(value->f->equalChar(value, s));
}

bool equalCharSmallIntG(const char *s, smallIntt* value) {

  if (!value) {
    return(false);
  }
  return(value->f->equalChar(value, s));
}

bool equalCharPSmallJsonG(const char *s, smallJsont* value) {

  if (!value) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallJson(value)) {
    return(false);
  }

  const char *type = getTopTypeO(value);

  if (!eqS(type,"string")) {
    return(false);
  }

  return(eqS(getTopSO(value), s));
}

bool equalCharPSmallStringG(const char *s, smallStringt* value) {

  if (!value) {
    return(false);
  }
  return(equalSO(value, s));
}


bool equalArrayOG(char ** p1, baset* p2) {

  if (!p1 || !p2) {
    return(false);
  }

  if (!isOType(p2, "smallArray")) {
    return(false);
  }

  cast(smallArrayt *, arr, p2);

  if (!listLengthS(p1) || !lenO(arr)) {
    return(false);
  }

  // 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);
  }
    }

  return(true);
}

bool equalCArrayOG(const char ** p1, baset* p2) {

  if (!p1 || !p2) {
    return(false);
  }

  if (!isOType(p2, "smallArray")) {
    return(false);
  }

  cast(smallArrayt *, arr, p2);

  if (!listLengthCS(p1) || !lenO(arr)) {
    return(false);
  }

  // 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);
  }
    }

  return(true);
}

bool equalArraySmallJsonG(char ** p1, smallJsont* p2) {

  if (!p1 || !p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallJson(p2)) {
    return(false);
  }

  const char *type = getTopTypeO(p2);

  if (!eqS(type,"array")) {
    return(false);
  }

  return(p2->f->equalArray(p2, p1));
}

bool equalArraySmallArrayG(char ** p1, smallArrayt* p2) {

  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallArray(p2)) {
    return(false);
  }

  return(p2->f->equalArray(p2, p1));
}

bool equalCArraySmallJsonG(const char ** p1, smallJsont* p2) {

  if (!p1 || !p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallJson(p2)) {
    return(false);
  }

  const char *type = getTopTypeO(p2);

  if (!eqS(type,"array")) {
    return(false);
  }

  return(p2->f->equalCArray(p2, p1));
}

bool equalCArraySmallArrayG(const char ** p1, smallArrayt* p2) {

  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallArray(p2)) {
    return(false);
  }

  return(p2->f->equalCArray(p2, p1));
}

bool equalOCharG(baset* p1, const char * p2) {

  return(equalCharOG(p2, p1));
}

bool equalOChaG(baset* p1, char p2) {

  return(equalChaOG(p2, p1));
}

bool equalOArrayG(baset* p1, char ** p2) {

  return(equalArrayOG(p2, p1));
}

bool equalOCArrayG(baset* p1, const char ** p2) {

  return(equalCArrayOG(p2, p1));
}

bool equalOOG(baset* p1, baset* p2) {

  if (!p1 || !p2) {
    return(false);
  }

  char *s = toStringO(p1);
  char *S = toStringO(p2);
  bool r;
  if (strEq(s, S)) {
    r = true;
  }
  else {
    r = false;
  }
  freeManyS(s, S);
  return(r);
}

bool equalOBoolG(baset* p1, bool p2) {

  return(equalBoolOG(p2, p1));
}

bool equalODoubleG(baset* p1, double p2) {

  return(equalDoubleBaseG(p2, p1));
}

bool equalOInt64G(baset* p1, int64_t p2) {

  return(equalInt64BaseG(p2, p1));
}

bool equalOInt32G(baset* p1, int32_t p2) {

  return(equalInt32BaseG(p2, p1));
}

bool equalOUint32G(baset* p1, uint32_t p2) {

  return(equalUint32BaseG(p2, p1));
}

bool equalOUint64G(baset* p1, uint64_t p2) {

  return(equalUint64BaseG(p2, p1));
}

bool equalOSmallArrayG(baset* p1, smallArrayt* p2) {

  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallArray(p2)) {
    return(false);
  }

  return(p2->f->equalBase(p2, p1));
}

bool equalOSmallBoolG(baset* p1, smallBoolt* p2) {

  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallBool(p2)) {
    return(false);
  }

  return(p2->f->equalBase(p2, p1));
}

bool equalOSmallBytesG(baset* p1, smallBytest* p2) {

  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallBytes(p2)) {
    return(false);
  }

  return(p2->f->equalBase(p2, p1));
}

bool equalOSmallDoubleG(baset* p1, smallDoublet* p2) {

  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallDouble(p2)) {
    return(false);
  }

  return(p2->f->equalBase(p2, p1));
}

bool equalOSmallDictG(baset* p1, smallDictt* p2) {

  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallDict(p2)) {
    return(false);
  }

  return(p2->f->equalBase(p2, p1));
}

bool equalOSmallIntG(baset* p1, smallIntt* p2) {

  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallInt(p2)) {
    return(false);
  }

  return(p2->f->equalBase(p2, p1));
}

bool equalOSmallJsonG(baset* p1, smallJsont* p2) {

  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallJson(p2)) {
    return(false);
  }

  return(p2->f->equalBase(p2, p1));
}

bool equalOSmallStringG(baset* p1, smallStringt* p2) {

  if (!p1 || !p2 || !p2->data) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallString(p2)) {
    return(false);
  }

  char *s = toStringO(p1);

  bool r = equalSO(p2, s);
  free(s);
  return(r);
}

bool equalBoolChaG(bool p1 UNUSED, char p2 UNUSED) {

  return(false);
}

bool equalBoolCharG(bool p1, const char * p2) {

  if (!p2) {
    return(false);
  }

  if (strEq(p2, "true") || strEq(p2, "TRUE")) {
    return(p1);
  }
  else if (strEq(p2, "false") || strEq(p2, "FALSE")) {
    return(!p1);
  }
  return(false);
}

bool equalBoolOG(bool p1, baset* p2) {

  if (!p2) {
    return(false);
  }

  char *s = toStringO(p2);

  if (strEq(s, "true") || strEq(s, "TRUE")) {
    free(s);
    return(p1);
  }
  else if (strEq(s, "false") || strEq(s, "FALSE")) {
    free(s);
    return(!p1);
  }
  free(s);
  return(false);
}

bool equalBoolFG(bool p1, bool p2) {

  return(p1 == p2);;
}

bool equalBoolDoubleG(bool p1, double p2) {

  return(p1 == p2);;
}

bool equalBoolInt64G(bool p1, int64_t p2) {

  return(p1 == p2);;
}

bool equalBoolInt32G(bool p1, int32_t p2) {

  return(p1 == p2);;
}

bool equalBoolUint32G(bool p1, uint32_t p2) {

  return(p1 == p2);;
}

bool equalBoolUint64G(bool p1, uint64_t p2) {

  return(p1 == p2);;
}

bool equalBoolSmallBoolG(bool p1, smallBoolt* p2) {

  if (!p2 || !p2->value) {
    return(false);
  }

  return(p2->value->value == p1);;
}

bool equalBoolSmallBytesG(bool p1, smallBytest* p2) {

  if (!p2 || !p2->B) {
    return(false);
  }

  if (equalSO(p2, "true") || equalSO(p2, "TRUE")) {
    return(p1);
  }
  else if (equalSO(p2, "false") || equalSO(p2, "FALSE")) {
    return(!p1);
  }
  return(false);
}

bool equalBoolSmallDoubleG(bool p1, smallDoublet* p2) {

  if (!p2 || !p2->value) {
    return(false);
  }

  return(p2->value->value == p1);;
}

bool equalBoolSmallIntG(bool p1, smallIntt* p2) {

  if (!p2 || !p2->value) {
    return(false);
  }

  return(p2->value->value == p1);;
}

bool equalBoolSmallJsonG(bool p1, smallJsont* p2) {

  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallJson(p2)) {
    return(false);
  }

  return(equalBoolO(p2, p1));
}

bool equalBoolSmallStringG(bool p1, smallStringt* p2) {

  if (!p2 || !p2->data) {
    return(false);
  }

  char *s = sStringGetTiny(p2->data);
  if (strEq(s, "true") || strEq(s, "TRUE")) {
    return(p1);
  }
  else if (strEq(s, "false") || strEq(s, "FALSE")) {
    return(!p1);
  }
  return(false);
}

bool equalDoubleChaG(double p1, char p2) {

  return(equalChaDoubleG(p2, p1));
}

bool equalDoubleCharG(double p1, const char * p2) {

  if (!p2) {
    return(false);
  }

  if (isInt(p2) || !isNumber(p2)) {
    return(false);
  }

  double value = parseDouble(p2);

  return(p1 == value);;
}

bool equalDoubleBaseG(double p1, baset* p2) {

  if (!p2) {
    return(false);
  }

  char *s = toStringO(p2);

  if (isInt(s) || !isNumber(s)) {
    free(s);
    return(false);
  }

  double value = parseDouble(s);

  bool r;
  if (p1 == value) {
    r = true;
  }
  else {
    r = false;
  }
  free(s);
  return(r);
}

bool equalDoubleBoolG(double p1, bool p2) {

  return(p1 == p2);;
}

bool equalDoubleFG(double p1, double p2) {

  return(p1 == p2);;
}

bool equalDoubleInt64G(double p1, int64_t p2) {

  return(p1 == p2);;
}

bool equalDoubleInt32G(double p1, int32_t p2) {

  return(p1 == p2);;
}

bool equalDoubleUint32G(double p1, uint32_t p2) {

  return(p1 == p2);;
}

bool equalDoubleUint64G(double p1, uint64_t p2) {

  return(p1 == p2);;
}

bool equalDoubleSmallBoolG(double p1, smallBoolt* p2) {

  if (!p2 || !p2->value) {
    return(false);
  }

  return(p2->value->value == p1);;
}

bool equalDoubleSmallBytesG(double p1, smallBytest* p2) {

  if (!p2 || !p2->B) {
    return(false);
  }

  char *s = sBytesGet(p2->B);

  bool has0 = false;
  rangeDown(i, p2->B->count) {
    if (s[i] == 0) {
      has0 = true;
      break;
    }
  }

  if (!has0) {
    return(false);
  }

  if (isInt(s) || !isNumber(s)) {
    return(false);
  }

  double p2Value = parseDouble(s);

  return(p2Value == p1);;
}

bool equalDoubleSmallDoubleG(double p1, smallDoublet* p2) {

  if (!p2 || !p2->value) {
    return(false);
  }

  return(p2->value->value == p1);;
}

bool equalDoubleSmallIntG(double p1, smallIntt* p2) {

  if (!p2 || !p2->value) {
    return(false);
  }

  return(p2->value->value == p1);;
}

bool equalDoubleSmallJsonG(double p1, smallJsont* p2) {

  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallJson(p2)) {
    return(false);
  }

  return(equalDoubleO(p2, p1));
}

bool equalDoubleSmallStringG(double p1, smallStringt* p2) {

  if (!p2 || !p2->data) {
    return(false);
  }

  char *s = sStringGetTiny(p2->data);

  if (isInt(s) || !isNumber(s)) {
    return(false);
  }

  double p2Value = parseDoubleO(p2);

  return(p2Value == p1);;
}

bool equalInt64ChaG(int64_t p1, char p2) {

  return(equalChaInt64G(p2, p1));
}

bool equalInt64CharG(int64_t p1, const char * p2) {

  if (!p2) {
    return(false);
  }

  if (!isInt(p2)) {
    return(false);
  }

  int64_t value = parseInt(p2);

  return(p1 == value);;
}

bool equalInt64BaseG(int64_t p1, baset* p2) {

  if (!p2) {
    return(false);
  }

  char *s = toStringO(p2);

  if (!isInt(s)) {
    free(s);
    return(false);
  }

  int64_t value = parseInt(s);

  bool r;
  if (p1 == value) {
    r = true;
  }
  else {
    r = false;
  }
  free(s);
  return(r);
}

bool equalInt64BoolG(int64_t p1, bool p2) {

  return(p1 == p2);;
}

bool equalInt64DoubleG(int64_t p1, double p2) {

  return(p1 == p2);;
}

bool equalInt64FG(int64_t p1, int64_t p2) {

  return(p1 == p2);;
}

bool equalInt64Int32G(int64_t p1, int32_t p2) {

  return(p1 == p2);;
}

bool equalInt64Uint32G(int64_t p1, uint32_t p2) {

  return(p1 == p2);;
}

bool equalInt64Uint64G(int64_t p1, uint64_t p2) {

  return((uint64_t)p1 == p2);;
}

bool equalInt64SmallBoolG(int64_t p1, smallBoolt* p2) {

  if (!p2 || !p2->value) {
    return(false);
  }

  return(p2->value->value == p1);;
}

bool equalInt64SmallBytesG(int64_t p1, smallBytest* p2) {

  if (!p2 || !p2->B) {
    return(false);
  }

  char *s = sBytesGet(p2->B);

  bool has0 = false;
  rangeDown(i, p2->B->count) {
    if (s[i] == 0) {
      has0 = true;
      break;
    }
  }

  if (!has0) {
    return(false);
  }

  if (!isInt(s)) {
    return(false);
  }

  int64_t p2Value = parseInt(s);

  return(p2Value == p1);;
}

bool equalInt64SmallDoubleG(int64_t p1, smallDoublet* p2) {

  if (!p2 || !p2->value) {
    return(false);
  }

  return(p2->value->value == p1);;
}

bool equalInt64SmallIntG(int64_t p1, smallIntt* p2) {

  if (!p2 || !p2->value) {
    return(false);
  }

  return(p2->value->value == p1);;
}

bool equalInt64SmallJsonG(int64_t p1, smallJsont* p2) {

  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallJson(p2)) {
    return(false);
  }

  return(equalInt64O(p2, p1));
}

bool equalInt64SmallStringG(int64_t p1, smallStringt* p2) {

  if (!p2 || !p2->data) {
    return(false);
  }

  char *s = sStringGetTiny(p2->data);

  if (!isInt(s)) {
    return(false);
  }

  int64_t p2Value = parseIntO(p2);

  return(p2Value == p1);;
}

bool equalInt32ChaG(int32_t p1, char p2) {

  return(equalChaInt32G(p2, p1));
}

bool equalInt32CharG(int32_t p1, const char * p2) {

  if (!p2) {
    return(false);
  }

  if (!isInt(p2)) {
    return(false);
  }

  int32_t value = (int32_t)parseInt(p2);

  return(p1 == value);;
}

bool equalInt32BaseG(int32_t p1, baset* p2) {

  if (!p2) {
    return(false);
  }

  char *s = toStringO(p2);

  if (!isInt(s)) {
    free(s);
    return(false);
  }

  int32_t value = (int32_t)parseInt(s);

  bool r;
  if (p1 == value) {
    r = true;
  }
  else {
    r = false;
  }
  free(s);
  return(r);
}

bool equalInt32BoolG(int32_t p1, bool p2) {

  return(p1 == p2);;
}

bool equalInt32DoubleG(int32_t p1, double p2) {

  return(p1 == p2);;
}

bool equalInt32Int64G(int32_t p1, int64_t p2) {

  return(p1 == p2);;
}

bool equalInt32FG(int32_t p1, int32_t p2) {

  return(p1 == p2);;
}

bool equalInt32Uint32G(int32_t p1, uint32_t p2) {

  return((uint32_t)p1 == p2);;
}

bool equalInt32Uint64G(int32_t p1, uint64_t p2) {

  return((uint64_t)p1 == p2);;
}

bool equalInt32SmallBoolG(int32_t p1, smallBoolt* p2) {

  if (!p2 || !p2->value) {
    return(false);
  }

  return(p2->value->value == p1);;
}

bool equalInt32SmallBytesG(int32_t p1, smallBytest* p2) {

  if (!p2 || !p2->B) {
    return(false);
  }

  char *s = sBytesGet(p2->B);

  bool has0 = false;
  rangeDown(i, p2->B->count) {
    if (s[i] == 0) {
      has0 = true;
      break;
    }
  }

  if (!has0) {
    return(false);
  }

  if (!isInt(s)) {
    return(false);
  }

  int32_t p2Value = (int32_t)parseInt(s);

  return(p2Value == p1);;
}

bool equalInt32SmallDoubleG(int32_t p1, smallDoublet* p2) {

  if (!p2 || !p2->value) {
    return(false);
  }

  return(p2->value->value == p1);;
}

bool equalInt32SmallIntG(int32_t p1, smallIntt* p2) {

  if (!p2 || !p2->value) {
    return(false);
  }

  return(p2->value->value == p1);;
}

bool equalInt32SmallJsonG(int32_t p1, smallJsont* p2) {

  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallJson(p2)) {
    return(false);
  }

  return(equalInt32O(p2, p1));
}

bool equalInt32SmallStringG(int32_t p1, smallStringt* p2) {

  if (!p2 || !p2->data) {
    return(false);
  }

  char *s = sStringGetTiny(p2->data);

  if (!isInt(s)) {
    return(false);
  }

  int32_t p2Value = (int32_t)parseIntO(p2);

  return(p2Value == p1);;
}

bool equalUint32ChaG(uint32_t p1, char p2) {

  return(equalChaUint32G(p2, p1));
}

bool equalUint32CharG(uint32_t p1, const char * p2) {

  if (!p2) {
    return(false);
  }

  if (!isInt(p2)) {
    return(false);
  }

  uint32_t value = (uint32_t)parseInt(p2);

  return(p1 == value);;
}

bool equalUint32BaseG(uint32_t p1, baset* p2) {

  if (!p2) {
    return(false);
  }

  char *s = toStringO(p2);

  if (!isInt(s)) {
    free(s);
    return(false);
  }

  uint32_t value = (uint32_t)parseInt(s);

  bool r;
  if (p1 == value) {
    r = true;
  }
  else {
    r = false;
  }
  free(s);
  return(r);
}

bool equalUint32BoolG(uint32_t p1, bool p2) {

  return(p1 == p2);;
}

bool equalUint32DoubleG(uint32_t p1, double p2) {

  return(p1 == p2);;
}

bool equalUint32Int64G(uint32_t p1, int64_t p2) {

  return(p1 == p2);;
}

bool equalUint32Int32G(uint32_t p1, int32_t p2) {

  return(p1 == (uint32_t)p2);;
}

bool equalUint32FG(uint32_t p1, uint32_t p2) {

  return(p1 == p2);;
}

bool equalUint32Uint64G(uint32_t p1, uint64_t p2) {

  return(p1 == p2);;
}

bool equalUint32SmallBoolG(uint32_t p1, smallBoolt* p2) {

  if (!p2 || !p2->value) {
    return(false);
  }

  return(p2->value->value == p1);;
}

bool equalUint32SmallBytesG(uint32_t p1, smallBytest* p2) {

  if (!p2 || !p2->B) {
    return(false);
  }

  char *s = sBytesGet(p2->B);

  bool has0 = false;
  rangeDown(i, p2->B->count) {
    if (s[i] == 0) {
      has0 = true;
      break;
    }
  }

  if (!has0) {
    return(false);
  }

  if (!isInt(s)) {
    return(false);
  }

  uint32_t p2Value = (uint32_t)parseInt(s);

  return(p2Value == p1);;
}

bool equalUint32SmallDoubleG(uint32_t p1, smallDoublet* p2) {

  if (!p2 || !p2->value) {
    return(false);
  }

  return(p2->value->value == p1);;
}

bool equalUint32SmallIntG(uint32_t p1, smallIntt* p2) {

  if (!p2 || !p2->value) {
    return(false);
  }

  return(p2->value->value == p1);;
}

bool equalUint32SmallJsonG(uint32_t p1, smallJsont* p2) {

  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallJson(p2)) {
    return(false);
  }

  return(equalUint32O(p2, p1));
}

bool equalUint32SmallStringG(uint32_t p1, smallStringt* p2) {

  if (!p2 || !p2->data) {
    return(false);
  }

  char *s = sStringGetTiny(p2->data);

  if (!isInt(s)) {
    return(false);
  }

  uint32_t p2Value = (uint32_t)parseIntO(p2);

  return(p2Value == p1);;
}

bool equalUint64ChaG(uint64_t p1, char p2) {

  return(equalChaUint64G(p2, p1));
}

bool equalUint64CharG(uint64_t p1, const char * p2) {

  if (!p2) {
    return(false);
  }

  if (!isInt(p2)) {
    return(false);
  }

  uint64_t value = (uint64_t)parseInt(p2);

  return(p1 == value);;
}

bool equalUint64BaseG(uint64_t p1, baset* p2) {

  if (!p2) {
    return(false);
  }

  char *s = toStringO(p2);

  if (!isInt(s)) {
    free(s);
    return(false);
  }

  uint64_t value = (uint64_t)parseInt(s);

  bool r;
  if (p1 == value) {
    r = true;
  }
  else {
    r = false;
  }
  free(s);
  return(r);
}

bool equalUint64BoolG(uint64_t p1, bool p2) {

  return(p1 == p2);;
}

bool equalUint64DoubleG(uint64_t p1, double p2) {

  return(p1 == p2);;
}

bool equalUint64Int64G(uint64_t p1, int64_t p2) {

  return(p1 == (uint64_t)p2);;
}

bool equalUint64Int32G(uint64_t p1, int32_t p2) {

  return(p1 == (uint64_t)p2);;
}

bool equalUint64Uint32G(uint64_t p1, uint32_t p2) {

  return(p1 == p2);;
}

bool equalUint64FG(uint64_t p1, uint64_t p2) {

  return(p1 == p2);;
}

bool equalUint64SmallBoolG(uint64_t p1, smallBoolt* p2) {

  if (!p2 || !p2->value) {
    return(false);
  }

  return(p2->value->value == p1);;
}

bool equalUint64SmallBytesG(uint64_t p1, smallBytest* p2) {

  if (!p2 || !p2->B) {
    return(false);
  }

  char *s = sBytesGet(p2->B);

  bool has0 = false;
  rangeDown(i, p2->B->count) {
    if (s[i] == 0) {
      has0 = true;
      break;
    }
  }

  if (!has0) {
    return(false);
  }

  if (!isInt(s)) {
    return(false);
  }

  uint64_t p2Value = (uint64_t)parseInt(s);

  return(p2Value == p1);;
}

bool equalUint64SmallDoubleG(uint64_t p1, smallDoublet* p2) {

  if (!p2 || !p2->value) {
    return(false);
  }

  return(p2->value->value == p1);;
}

bool equalUint64SmallIntG(uint64_t p1, smallIntt* p2) {

  if (!p2 || !p2->value) {
    return(false);
  }

  return((uint64_t)p2->value->value == p1);;
}

bool equalUint64SmallJsonG(uint64_t p1, smallJsont* p2) {

  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallJson(p2)) {
    return(false);
  }

  return(equalUint64O(p2, p1));
}

bool equalUint64SmallStringG(uint64_t p1, smallStringt* p2) {

  if (!p2 || !p2->data) {
    return(false);
  }

  char *s = sStringGetTiny(p2->data);

  if (!isInt(s)) {
    return(false);
  }

  uint64_t p2Value = (uint64_t)parseIntO(p2);

  return(p2Value == p1);;
}

bool notEqualCharG(char c UNUSED, void *value UNUSED) {

  return(false);
}

bool notEqualOCharG(void *a UNUSED, char c UNUSED) {

  return(false);
}

bool notEqualOG(void *a UNUSED, void *b UNUSED) {

  return(false);
}

bool notEqualCCOG(const char *a UNUSED, void *b UNUSED) {

  return(false);
}

bool notEqualBoolOG(bool p1 UNUSED, void *p2 UNUSED) {

  return(false);
}

bool notEqualDoubleOG(double p1 UNUSED, void *p2 UNUSED) {

  return(false);
}

bool notEqualInt64OG(int64_t p1 UNUSED, void *p2 UNUSED) {

  return(false);
}

bool notEqualInt32OG(int32_t p1 UNUSED, void *p2 UNUSED) {

  return(false);
}

bool notEqualUint32OG(uint32_t p1 UNUSED, void *p2 UNUSED) {

  return(false);
}

bool notEqualUint64OG(uint64_t p1 UNUSED, void *p2 UNUSED) {

  return(false);
}

bool notEqualOBoolG(void *p1 UNUSED, bool p2 UNUSED) {

  return(false);
}

bool notEqualDoubleG(void *p1 UNUSED, double p2 UNUSED) {

  return(false);
}

bool notEqualOInt64G(void *p1 UNUSED, int64_t p2 UNUSED) {

  return(false);
}

bool notEqualOInt32G(void *p1 UNUSED, int32_t p2 UNUSED) {

  return(false);
}

bool notEqualOUint32G(void *p1 UNUSED, uint32_t p2 UNUSED) {

  return(false);
}

bool notEqualOUint64G(void *p1 UNUSED, uint64_t p2 UNUSED) {

  return(false);
}


bool icEqCharChar(char c, char value) {

  return(tolower(c) == tolower(value));;
}

bool icEqualChaOG(char c, baset* value) {

  charToS(s, c);
  return(icEqualCharOG(s, value));
}

bool icEqualChaSmallJsonG(char c, smallJsont* value) {

  // sanity checks
  if (!value) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallJson(value)) {
    return(false);
  }

  return(value->f->icEqualChar(value, c));
}

bool icEqualChaSmallStringG(char c, smallStringt* value) {

  if (!value) {
    return(false);
  }
  charToS(s, c);
  return(icEqualSO(value, s));
}


bool icEqualCharOG(const char *s, baset* value) {

  if (!s || !value) {
    return(false);
  }

  char *v = toStringO(value);
  bool r  = icEqS(s, v);
  free(v);
  return(r);
}

bool icEqualCharPSmallJsonG(const char *s, smallJsont* value) {

  // sanity checks
  if (!value) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallJson(value)) {
    return(false);
  }

  return(value->f->icEqualS(value, s));
}

bool icEqualCharPSmallStringG(const char *s, smallStringt* value) {

  if (!value) {
    return(false);
  }
  return(icEqualSO(value, s));
}


bool icEqualArrayOG(char ** p1, baset* p2) {

  if (!p1 || !p2) {
    return(false);
  }

  if (!isOType(p2, "smallArray")) {
    return(false);
  }

  cast(smallArrayt *, arr, p2);

  if (!listLengthS(p1) || !lenO(arr)) {
    return(false);
  }

  // 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);
  }
    }

  return(true);
}

bool icEqualCArrayOG(const char ** p1, baset* p2) {

  if (!p1 || !p2) {
    return(false);
  }

  if (!isOType(p2, "smallArray")) {
    return(false);
  }

  cast(smallArrayt *, arr, p2);

  if (!listLengthCS(p1) || !lenO(arr)) {
    return(false);
  }

  // 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);
  }
    }

  return(true);
}

bool icEqualArraySmallJsonG(char ** p1, smallJsont* p2) {

  // sanity checks
  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallJson(p2)) {
    return(false);
  }

  const char *type = getTopTypeO(p2);

  if (!eqS(type,"array")) {
    return(false);
  }

  return(p2->f->icEqualArray(p2, p1));
}

bool icEqualCArraySmallJsonG(const char ** p1, smallJsont* p2) {

  // sanity checks
  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallJson(p2)) {
    return(false);
  }

  const char *type = getTopTypeO(p2);

  if (!eqS(type,"array")) {
    return(false);
  }

  return(p2->f->icEqualCArray(p2, p1));
}

bool icEqualArraySmallArrayG(char ** p1, smallArrayt* p2) {

  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallArray(p2)) {
    return(false);
  }

  return(p2->f->icEqualArray(p2, p1));
}

bool icEqualCArraySmallArrayG(const char ** p1, smallArrayt* p2) {

  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallArray(p2)) {
    return(false);
  }

  return(p2->f->icEqualCArray(p2, p1));
}

bool icEqualOCharG(baset* p1, const char * p2) {

  return(icEqualCharOG(p2, p1));
}

bool icEqualOChaG(baset* p1, char p2) {

  return(icEqualChaOG(p2, p1));
}

bool icEqualOArrayG(baset* p1, char ** p2) {

  return(icEqualArrayOG(p2, p1));
}

bool icEqualOCArrayG(baset* p1, const char ** p2) {

  return(icEqualCArrayOG(p2, p1));
}

bool icEqualOOG(baset* p1, baset* p2) {

  if (!p1 || !p2) {
    return(false);
  }

  char *s = toStringO(p1);
  char *S = toStringO(p2);
  bool r;
  if (icEqS(s, S)) {
    r = true;
  }
  else {
    r = false;
  }
  freeManyS(s, S);
  return(r);
}

bool icEqualOSmallArrayG(baset* p1, smallArrayt* p2) {

  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallArray(p2)) {
    return(false);
  }

  return(p2->f->icEqualBase(p2, p1));
}

bool icEqualOSmallDictG(baset* p1, smallDictt* p2) {

  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallDict(p2)) {
    return(false);
  }

  return(p2->f->icEqualBase(p2, p1));
}

bool icEqualOSmallJsonG(baset* p1, smallJsont* p2) {

  // sanity checks
  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallJson(p2)) {
    return(false);
  }

  return(p2->f->icEqualBase(p2, p1));
}

bool icEqualOSmallStringG(baset* p1, smallStringt* p2) {

  if (!p1 || !p2 || !p2->data) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallString(p2)) {
    return(false);
  }

  char *s = toStringO(p1);

  bool r = icEqualSO(p2, s);
  free(s);
  return(r);
}



// TODO format function, print objects, stderr print

void freeBasetInContainer(void *baseo) {

  // Terminate baset object
  cast(baset*,o,baseo);
  terminateO(o);
}


smallt *toSmallt(baset *obj) {
  smallt *r = NULL;

  if (!obj) {
    return(NULL);
  }

  if (isOType(obj, "undefined")) {
    r      = (smallt *)allocSUndefined();
  }
  else if (isOType(obj, "smallArray")) {
    if (!((smallArrayt *)obj)->a) {
      ((smallArrayt *)obj)->a = allocSArray();
    }
    r = (smallt *)((smallArrayt *)obj)->a;
  }
  else if (isOType(obj, "smallDict")) {
    if (!((smallDictt *)obj)->d) {
      ((smallDictt *)obj)->d = allocSDict();
    }
    r = (smallt *)((smallDictt *)obj)->d;
  }
  else if (isOType(obj, "smallBool")) {
    if (!((smallBoolt *)obj)->value) {
      ((smallBoolt *)obj)->value = allocSBool(false);
    }
    r = (smallt *)((smallBoolt *)obj)->value;
  }
  else if (isOType(obj, "smallBytes")) {
    if (!((smallBytest *)obj)->B) {
      ((smallBytest *)obj)->B = allocSBytes();
    }
    r = (smallt *)((smallBytest *)obj)->B;
  }
  else if (isOType(obj, "smallContainer")) {
    if (!((smallContainert *)obj)->data) {
      ((smallContainert *)obj)->data = allocSContainer(NULL);
    }
    r = (smallt *)((smallContainert *)obj)->data;
  }
  else if (isOType(obj, "smallDouble")) {
    if (!((smallDoublet *)obj)->value) {
      ((smallDoublet *)obj)->value = allocSDouble(0);
    }
    r = (smallt *)((smallDoublet *)obj)->value;
  }
  else if (isOType(obj, "smallInt")) {
    if (!((smallIntt *)obj)->value) {
      ((smallIntt *)obj)->value = allocSInt(0);
    }
    r = (smallt *)((smallIntt *)obj)->value;
  }
  else if (isOType(obj, "smallString")) {
    if (!((smallStringt *)obj)->data) {
      ((smallStringt *)obj)->data = allocSStringTiny("");
    }
    r = (smallt *)((smallStringt *)obj)->data;
  }
  else {
    // store other baset object in sContainers
    sContainert *c = allocSContainer(obj);
    if (!c) {
      return(NULL);
    }
    c->dataType    = SH_DT_BASET;
    c->free        = freeBasetInContainer;
    r              = (smallt *) c;
  }

  return(r);
}


baset *toBaset(smallt *obj) {
  undefinedt *u = NULL;
  smallBoolt *b = NULL;
  smallBytest *B = NULL;
  smallContainert *c = NULL;
  smallDictt *d = NULL;
  smallDoublet *D = NULL;
  smallIntt *i = NULL;
  smallStringt *s = NULL;
  smallArrayt *a = NULL;
  baset *r = NULL;

  if (!obj) {
    return(NULL);
  }

  switch(obj->type) {
    case UNDEFINED:
      initiateAllocateUndefined(&u);
      r = (baset *)u;
      break;
    case BOOL:
      initiateAllocateSmallBool(&b);
      if (!b) {
        return(NULL);
      }
      b->value = (sBoolt *)obj;
      r = (baset *)b;
      break;
    case BYTES:
      initiateAllocateSmallBytes(&B);
      if (!B) {
        return(NULL);
      }
      B->B = (sBytest *)obj;
      r = (baset *)B;
      break;
    case CONTAINER:
      ;cast(sContainert*, sc, obj);
      if (sc->dataType == SH_DT_BASET) {
        r = (baset *)sc->data;
      }
      else {
        initiateAllocateSmallContainer(&c);
        if (!c) {
          return(NULL);
        }
        c->data = (sContainert *)obj;
        r = (baset *)c;
      }
      break;
    case DICT:
      initiateAllocateSmallDict(&d);
      if (!d) {
        return(NULL);
      }
      d->d = (sDictt *)obj;
      r = (baset *)d;
      break;
    case DOUBLE:
      initiateAllocateSmallDouble(&D);
      if (!D) {
        return(NULL);
      }
      D->value = (sDoublet *)obj;
      r = (baset *)D;
      break;
    case INT:
      initiateAllocateSmallInt(&i);
      if (!i) {
        return(NULL);
      }
      i->value = (sIntt *)obj;
      r = (baset *)i;
      break;
    case STRING:
      initiateAllocateSmallString(&s);
      if (!s) {
        return(NULL);
      }
      s->data = (sStringt *)obj;
      s->_len = strlen((char*)obj)-1;
      r = (baset *)s;
      break;
    case ARRAY:
      initiateAllocateSmallArray(&a);
      if (!a) {
        return(NULL);
      }
      a->a = (sArrayt *)obj;
      r = (baset *)a;
      break;
    default:;
      // return NULL
  }
  return(r);
}

int cpuCount(void) {

  return((int)sysconf(_SC_NPROCESSORS_ONLN));
}

dArrayT(finalizeRecycleContainersFuncst, recycleContainersFt);

internal finalizeRecycleContainersFuncst finalizeRecycleContainersFuncs;

unsigned registerFinalizeRecycleContainersInThreadPool(recycleContainersFt f) {

  dArrayAppend(&finalizeRecycleContainersFuncs, f);
  return(1);
}

void finalizeLibsheepyRecycleContainers(void *arg UNUSED) {

  // call finalizeRecycleSmall*
  range(i, dArrayCount(&finalizeRecycleContainersFuncs)) {
    dArrayAt(&finalizeRecycleContainersFuncs, i)(NULL);
  }
}

void finalizeLibsheepyAtExit(void) {

  tpoolKill;

  dArrayFree(&finalizeRecycleContainersFuncs);

  finalizeSmallDict();
  finalizeSmallArray();
  finalizeSmallJson();
  finalizeUndefined();
  finalizeSmallBytes();
  finalizeSmallBool();
  finalizeSmallContainer();
  finalizeSmallDouble();
  finalizeSmallInt();
  finalizeSmallString();
}

#if (__APPLE__ || __FreeBSD__ || __TERMUX__ || __OpenBSD__ || __DragonFly__ || MUSL_LIBC || __sun__ || __HAIKU__)
void initLibsheepyObject(void) {

  dArrayInit(&finalizeRecycleContainersFuncs);
  registerFinalizeRecycleContainersInThreadPool(finalizeRecycleSmallArray);
  registerFinalizeRecycleContainersInThreadPool(finalizeRecycleSmallBool);
  registerFinalizeRecycleContainersInThreadPool(finalizeRecycleSmallBytes);
  registerFinalizeRecycleContainersInThreadPool(finalizeRecycleSmallContainer);
  registerFinalizeRecycleContainersInThreadPool(finalizeRecycleSmallDict);
  registerFinalizeRecycleContainersInThreadPool(finalizeRecycleSmallDouble);
  registerFinalizeRecycleContainersInThreadPool(finalizeRecycleSmallInt);
  registerFinalizeRecycleContainersInThreadPool(finalizeRecycleSmallJson);
  registerFinalizeRecycleContainersInThreadPool(finalizeRecycleSmallString);
  registerFinalizeRecycleContainersInThreadPool(finalizeRecycleUndefined);

  int numberOfOnlineProcs = (int)sysconf(_SC_NPROCESSORS_ONLN);
  tpool = tpool_init(numberOfOnlineProcs);

  pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  range(i, tpoolLockCount) {
    tpoolLocks[i] = mutex;
  }

  // register %m type specifiers in printf for baset objects
  // not available in macos - register_printf_specifier('m', print_m, print_m_arginfo);

  // call finalizeLibsheepy when the program finishes
  pErrorNot0(atexit(finalizeLibsheepyAtExit));
}

#else // #if (__APPLE__ || __FreeBSD__ || __TERMUX__ || __OpenBSD__ || __DragonFly__ || MUSL_LIBC || __sun__ || __HAIKU__)
void initLibsheepyObject(void) {

  dArrayInit(&finalizeRecycleContainersFuncs);
  registerFinalizeRecycleContainersInThreadPool(finalizeRecycleSmallArray);
  registerFinalizeRecycleContainersInThreadPool(finalizeRecycleSmallBool);
  registerFinalizeRecycleContainersInThreadPool(finalizeRecycleSmallBytes);
  registerFinalizeRecycleContainersInThreadPool(finalizeRecycleSmallContainer);
  registerFinalizeRecycleContainersInThreadPool(finalizeRecycleSmallDict);
  registerFinalizeRecycleContainersInThreadPool(finalizeRecycleSmallDouble);
  registerFinalizeRecycleContainersInThreadPool(finalizeRecycleSmallInt);
  registerFinalizeRecycleContainersInThreadPool(finalizeRecycleSmallJson);
  registerFinalizeRecycleContainersInThreadPool(finalizeRecycleSmallString);
  registerFinalizeRecycleContainersInThreadPool(finalizeRecycleUndefined);

  int numberOfOnlineProcs = (int)sysconf(_SC_NPROCESSORS_ONLN);
  tpool = tpool_init(numberOfOnlineProcs);

  pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  range(i, tpoolLockCount) {
    tpoolLocks[i] = mutex;
  }

  // register %m type specifiers in printf for baset objects
  register_printf_specifier('m', print_m, print_m_arginfo); {

  // call finalizeLibsheepy when the program finishes
  pErrorNot0(atexit(finalizeLibsheepyAtExit));
}
  }

#endif
// #if __APPLE__ || __FreeBSD__ || __TERMUX__ || __OpenBSD__ || __DragonFly__ || MUSL_LIBC || __sun__ || __HAIKU__

undefinedt* undefined = NULL;

baset* rtBaset                     = NULL;
undefinedt* rtUndefinedt           = NULL;
bool rtBool                        = false;
bool* rtBoolP                      = NULL;
double rtDouble                    = 0;
double* rtDoubleP                  = NULL;
int64_t rtInt64_t                  = 0;
int64_t* rtInt64_tP                = NULL;
int32_t rtInt32_t                  = 0;
int32_t* rtInt32_tP                = NULL;
uint64_t rtUint64_t                = 0;
uint64_t* rtUint64_tP              = NULL;
uint32_t rtUint32_t                = 0;
uint32_t* rtUint32_tP              = NULL;
float rtF32                        = 0;
double rtF64                       = 0;
double* rtF64P                     = NULL;
int64_t rtI64                      = 0;
int64_t* rtI64P                    = NULL;
int32_t rtI32                      = 0;
int32_t* rtI32P                    = NULL;
uint64_t rtU64                     = 0;
uint64_t* rtU64P                   = NULL;
uint32_t rtU32                     = 0;
uint32_t* rtU32P                   = NULL;
uint16_t rtU16                     = 0;
uint8_t rtU8                       = 0;
char* rtChar                       = NULL;
smallArrayt* rtSmallArrayt         = NULL;
smallBoolt* rtSmallBoolt           = NULL;
smallBytest* rtSmallBytest         = NULL;
smallDictt* rtSmallDictt           = NULL;
smallDoublet* rtSmallDoublet       = NULL;
smallIntt* rtSmallIntt             = NULL;
smallJsont* rtSmallJsont           = NULL;
smallStringt* rtSmallStringt       = NULL;
void* rtVoid                       = NULL;
smallContainert* rtSmallContainert = NULL;