libsheepyCSmallArray.c (385763B)
1 // MIT License 2 // 3 // Copyright (c) 2026 Remy Noulin 4 // 5 // Permission is hereby granted, free of charge, to any person obtaining a copy 6 // of this software and associated documentation files (the "Software"), to deal 7 // in the Software without restriction, including without limitation the rights 8 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 // copies of the Software, and to permit persons to whom the Software is 10 // furnished to do so, subject to the following conditions: 11 // 12 // The above copyright notice and this permission notice shall be included in all 13 // copies or substantial portions of the Software. 14 // 15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 // SOFTWARE. 22 23 #include "../libsheepyObject.h" 24 #include "libsheepyCSmallArray.h" 25 #include "libsheepyCSmallArrayInternal.h" 26 #include "../../release/libsheepy.h" 27 28 #define internal static 29 30 #include <stdio.h> 31 #include <stdarg.h> 32 #include <stdbool.h> 33 #include <string.h> 34 #include <stdlib.h> 35 #include <stdint.h> 36 37 void initiateSmallArray(smallArrayt *self); 38 void registerMethodsSmallArray(smallArrayFunctionst *f); 39 void initiateAllocateSmallArray(smallArrayt **self); 40 smallArrayt* allocSmallArray(void); 41 smallArrayt* allocArraySmallArray(char **array); 42 smallArrayt* allocCArraySmallArray(const char **array); 43 void cleanUpSmallArrayTerminateG(smallArrayt **val); 44 void cleanUpSmallArrayFreeLocalG(smallArrayt *val); 45 void cleanUpSmallArrayFreeG(smallArrayt **val); 46 void cleanUpSmallArrayFinishG(smallArrayt **val); 47 void cleanUpSmallArrayDisposeG(smallArrayt *val); 48 void cleanUpSmallArraySmashG(smallArrayt **val); 49 smallArrayt* createSAF(const char *paramType, ...); 50 void finalizeRecycleSmallArray(void *arg UNUSED); 51 void finalizeSmallArray(void); 52 internal void freeSmallArray(smallArrayt *self); 53 internal void terminateSmallArray(smallArrayt **self); 54 internal char* toStringSmallArray(smallArrayt *self); 55 internal smallArrayt* duplicateSmallArray(smallArrayt *self); 56 internal char* escapeSmallArray(smallArrayt *self); 57 internal void disposeSmallArray(smallArrayt *self); 58 internal void smashSmallArray(smallArrayt **self); 59 #if (NFreeStackCheck) 60 internal void finishSmallArray(smallArrayt **self); 61 #else 62 internal void finishSmallArray(smallArrayt **self); 63 #endif 64 internal const char* helpSmallArray(smallArrayt UNUSED *self); 65 internal void resetSmallArray(smallArrayt *self); 66 internal sArrayt* getsoSmallArray(smallArrayt *self); 67 internal void setsoSmallArray(smallArrayt *self, sArrayt *so); 68 internal smallArrayt* mirrorSmallArray(smallArrayt *self); 69 internal smallArrayt* fromArraySmallArray(smallArrayt *self, char **array, size_t size); 70 internal smallArrayt* fromCArraySmallArray(smallArrayt *self, const char **array, size_t size); 71 internal smallArrayt* fromArrayNFreeSmallArray(smallArrayt *self, char **array, size_t size); 72 internal smallArrayt* pushSmallArray(smallArrayt *self, baset *value); 73 internal smallArrayt* pushUndefinedSmallArray(smallArrayt *self); 74 internal smallArrayt* pushBoolSmallArray(smallArrayt *self, bool value); 75 internal smallArrayt* pushDoubleSmallArray(smallArrayt *self, double value); 76 internal smallArrayt* pushIntSmallArray(smallArrayt *self, int64_t value); 77 internal smallArrayt* pushSSmallArray(smallArrayt *self, const char *string); 78 internal smallArrayt* pushCharSmallArray(smallArrayt *self, char c); 79 internal smallArrayt* pushDictSmallArray(smallArrayt *self, smallDictt *dict); 80 internal smallArrayt* pushArraySmallArray(smallArrayt *self, smallArrayt *array); 81 internal smallArrayt* pushArraycSmallArray(smallArrayt *self, char **array); 82 internal smallArrayt* pushCArraycSmallArray(smallArrayt *self, const char **array); 83 internal smallArrayt* pushSmallBoolSmallArray(smallArrayt *self, smallBoolt *value); 84 internal smallArrayt* pushSmallBytesSmallArray(smallArrayt *self, smallBytest *value); 85 internal smallArrayt* pushSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value); 86 internal smallArrayt* pushSmallIntSmallArray(smallArrayt *self, smallIntt *value); 87 internal smallArrayt* pushSmallJsonSmallArray(smallArrayt *self, smallJsont *value); 88 internal smallArrayt* pushSmallStringSmallArray(smallArrayt *self, smallStringt *string); 89 internal smallArrayt* pushSmallContainerSmallArray(smallArrayt *self, smallContainert *container); 90 internal smallArrayt* pushNFreeSmallArray(smallArrayt *self, baset *value); 91 internal smallArrayt* pushNFreeUndefinedSmallArray(smallArrayt *self, undefinedt *u); 92 internal smallArrayt* pushNFreeSSmallArray(smallArrayt *self, char *string); 93 internal smallArrayt* pushNFreeDictSmallArray(smallArrayt *self, smallDictt *dict); 94 internal smallArrayt* pushNFreeArraySmallArray(smallArrayt *self, smallArrayt *array); 95 internal smallArrayt* pushNFreeArraycSmallArray(smallArrayt *self, char **array); 96 internal smallArrayt* pushNFreeSmallBoolSmallArray(smallArrayt *self, smallBoolt *value); 97 internal smallArrayt* pushNFreeSmallBytesSmallArray(smallArrayt *self, smallBytest *value); 98 internal smallArrayt* pushNFreeSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value); 99 internal smallArrayt* pushNFreeSmallIntSmallArray(smallArrayt *self, smallIntt *value); 100 internal smallArrayt* pushNFreeSmallJsonSmallArray(smallArrayt *self, smallJsont *value); 101 internal smallArrayt* pushNFreeSmallStringSmallArray(smallArrayt *self, smallStringt *string); 102 internal smallArrayt* pushNFreeSmallContainerSmallArray(smallArrayt *self, smallContainert *container); 103 internal smallArrayt* pushManySmallArray(smallArrayt *self, ...); 104 internal smallArrayt* pushManySSmallArray(smallArrayt *self, ...); 105 internal smallArrayt* pushNFreeManySmallArray(smallArrayt *self, ...); 106 internal smallArrayt* pushNFreeManySSmallArray(smallArrayt *self, ...); 107 internal baset* popSmallArray(smallArrayt *self); 108 internal undefinedt* popUndefinedSmallArray(smallArrayt *self); 109 internal bool popBoolSmallArray(smallArrayt *self); 110 internal double popDoubleSmallArray(smallArrayt *self); 111 internal int64_t popIntSmallArray(smallArrayt *self); 112 internal int32_t popInt32SmallArray(smallArrayt *self); 113 internal uint64_t popUintSmallArray(smallArrayt *self); 114 internal uint32_t popUint32SmallArray(smallArrayt *self); 115 internal char* popSSmallArray(smallArrayt *self); 116 internal smallDictt* popDictSmallArray(smallArrayt *self); 117 internal smallArrayt* popArraySmallArray(smallArrayt *self); 118 internal smallBoolt* popSmallBoolSmallArray(smallArrayt *self); 119 internal smallBytest* popSmallBytesSmallArray(smallArrayt *self); 120 internal smallDoublet* popSmallDoubleSmallArray(smallArrayt *self); 121 internal smallIntt* popSmallIntSmallArray(smallArrayt *self); 122 internal smallJsont* popSmallJsonSmallArray(smallArrayt *self); 123 internal smallStringt* popSmallStringSmallArray(smallArrayt *self); 124 internal void* popVoidSmallArray(smallArrayt *self); 125 internal smallContainert* popSmallContainerSmallArray(smallArrayt *self); 126 internal double popNumSmallArray(smallArrayt *self); 127 internal smallArrayt* prependSmallArray(smallArrayt *self, baset *value); 128 internal smallArrayt* prependUndefinedSmallArray(smallArrayt *self); 129 internal smallArrayt* prependBoolSmallArray(smallArrayt *self, bool value); 130 internal smallArrayt* prependDoubleSmallArray(smallArrayt *self, double value); 131 internal smallArrayt* prependIntSmallArray(smallArrayt *self, int64_t value); 132 internal smallArrayt* prependSSmallArray(smallArrayt *self, const char *string); 133 internal smallArrayt* prependCharSmallArray(smallArrayt *self, char c); 134 internal smallArrayt* prependDictSmallArray(smallArrayt *self, smallDictt *dict); 135 internal smallArrayt* prependArraySmallArray(smallArrayt *self, smallArrayt *array); 136 internal smallArrayt* prependArraycSmallArray(smallArrayt *self, char **array); 137 internal smallArrayt* prependCArraycSmallArray(smallArrayt *self, const char **array); 138 internal smallArrayt* prependSmallBoolSmallArray(smallArrayt *self, smallBoolt *value); 139 internal smallArrayt* prependSmallBytesSmallArray(smallArrayt *self, smallBytest *value); 140 internal smallArrayt* prependSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value); 141 internal smallArrayt* prependSmallIntSmallArray(smallArrayt *self, smallIntt *value); 142 internal smallArrayt* prependSmallJsonSmallArray(smallArrayt *self, smallJsont *json); 143 internal smallArrayt* prependSmallStringSmallArray(smallArrayt *self, smallStringt *string); 144 internal smallArrayt* prependSmallContainerSmallArray(smallArrayt *self, smallContainert *container); 145 internal smallArrayt* prependNFreeSmallArray(smallArrayt *self, baset *value); 146 internal smallArrayt* prependNFreeUndefinedSmallArray(smallArrayt *self, undefinedt *u); 147 internal smallArrayt* prependNFreeSSmallArray(smallArrayt *self, char *string); 148 internal smallArrayt* prependNFreeDictSmallArray(smallArrayt *self, smallDictt *dict); 149 internal smallArrayt* prependNFreeArraySmallArray(smallArrayt *self, smallArrayt *array); 150 internal smallArrayt* prependNFreeArraycSmallArray(smallArrayt *self, char **array); 151 internal smallArrayt* prependNFreeSmallBoolSmallArray(smallArrayt *self, smallBoolt *value); 152 internal smallArrayt* prependNFreeSmallBytesSmallArray(smallArrayt *self, smallBytest *value); 153 internal smallArrayt* prependNFreeSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value); 154 internal smallArrayt* prependNFreeSmallIntSmallArray(smallArrayt *self, smallIntt *value); 155 internal smallArrayt* prependNFreeSmallJsonSmallArray(smallArrayt *self, smallJsont *json); 156 internal smallArrayt* prependNFreeSmallStringSmallArray(smallArrayt *self, smallStringt *string); 157 internal smallArrayt* prependNFreeSmallContainerSmallArray(smallArrayt *self, smallContainert *container); 158 internal baset* dequeueSmallArray(smallArrayt *self); 159 internal undefinedt* dequeueUndefinedSmallArray(smallArrayt *self); 160 internal bool dequeueBoolSmallArray(smallArrayt *self); 161 internal double dequeueDoubleSmallArray(smallArrayt *self); 162 internal int64_t dequeueIntSmallArray(smallArrayt *self); 163 internal int32_t dequeueInt32SmallArray(smallArrayt *self); 164 internal uint64_t dequeueUintSmallArray(smallArrayt *self); 165 internal uint32_t dequeueUint32SmallArray(smallArrayt *self); 166 internal char* dequeueSSmallArray(smallArrayt *self); 167 internal smallDictt* dequeueDictSmallArray(smallArrayt *self); 168 internal smallArrayt* dequeueArraySmallArray(smallArrayt *self); 169 internal smallBoolt* dequeueSmallBoolSmallArray(smallArrayt *self); 170 internal smallBytest* dequeueSmallBytesSmallArray(smallArrayt *self); 171 internal smallDoublet* dequeueSmallDoubleSmallArray(smallArrayt *self); 172 internal smallIntt* dequeueSmallIntSmallArray(smallArrayt *self); 173 internal smallJsont* dequeueSmallJsonSmallArray(smallArrayt *self); 174 internal smallStringt* dequeueSmallStringSmallArray(smallArrayt *self); 175 internal void* dequeueVoidSmallArray(smallArrayt *self); 176 internal smallContainert* dequeueSmallContainerSmallArray(smallArrayt *self); 177 internal double dequeueNumSmallArray(smallArrayt *self); 178 internal smallArrayt* reverseSmallArray(smallArrayt *self); 179 internal smallArrayt* catSmallArray(smallArrayt *self, ...); 180 internal smallArrayt* appendSmallArray(smallArrayt *self, smallArrayt *array); 181 internal smallArrayt* appendSmallJsonSmallArray(smallArrayt *self, smallJsont *json); 182 internal smallArrayt* appendNSmashSmallArray(smallArrayt *self, smallArrayt *array); 183 internal smallArrayt* appendNSmashSmallJsonSmallArray(smallArrayt *self, smallJsont *json); 184 internal smallArrayt* appendArraySmallArray(smallArrayt *self, char **array); 185 internal smallArrayt* appendCArraySmallArray(smallArrayt *self, const char **array); 186 internal smallArrayt* appendNSmashArraySmallArray(smallArrayt *self, char **array); 187 internal smallArrayt* shiftSmallArray(smallArrayt *self, smallArrayt *array); 188 internal smallArrayt* shiftSmallJsonSmallArray(smallArrayt *self, smallJsont *json); 189 internal smallArrayt* shiftNSmashSmallArray(smallArrayt *self, smallArrayt *array); 190 internal smallArrayt* shiftNSmashSmallJsonSmallArray(smallArrayt *self, smallJsont *json); 191 internal smallArrayt* addSmallArray(smallArrayt *self, smallArrayt *array); 192 internal smallArrayt* sliceSmallArray(smallArrayt *self, int64_t start, int64_t end); 193 internal smallArrayt* cropSmallArray(smallArrayt *self, int64_t start, int64_t end); 194 internal baset* cropElemSmallArray(smallArrayt *self, int64_t index); 195 internal undefinedt* cropElemUndefinedSmallArray(smallArrayt *self, int64_t index); 196 internal bool cropElemBoolSmallArray(smallArrayt *self, int64_t index); 197 internal double cropElemDoubleSmallArray(smallArrayt *self, int64_t index); 198 internal int64_t cropElemIntSmallArray(smallArrayt *self, int64_t index); 199 internal int32_t cropElemInt32SmallArray(smallArrayt *self, int64_t index); 200 internal uint64_t cropElemUintSmallArray(smallArrayt *self, int64_t index); 201 internal uint32_t cropElemUint32SmallArray(smallArrayt *self, int64_t index); 202 internal char* cropElemSSmallArray(smallArrayt *self, int64_t index); 203 internal smallDictt* cropElemDictSmallArray(smallArrayt *self, int64_t index); 204 internal smallArrayt* cropElemArraySmallArray(smallArrayt *self, int64_t index); 205 internal smallBoolt* cropElemSmallBoolSmallArray(smallArrayt *self, int64_t index); 206 internal smallBytest* cropElemSmallBytesSmallArray(smallArrayt *self, int64_t index); 207 internal smallDoublet* cropElemSmallDoubleSmallArray(smallArrayt *self, int64_t index); 208 internal smallIntt* cropElemSmallIntSmallArray(smallArrayt *self, int64_t index); 209 internal smallJsont* cropElemSmallJsonSmallArray(smallArrayt *self, int64_t index); 210 internal smallStringt* cropElemSmallStringSmallArray(smallArrayt *self, int64_t index); 211 internal void* cropElemVoidSmallArray(smallArrayt *self, int64_t index); 212 internal smallContainert* cropElemSmallContainerSmallArray(smallArrayt *self, int64_t index); 213 internal smallArrayt* copySmallArray(smallArrayt *self, int64_t start, int64_t end); 214 internal smallArrayt* insertSmallArray(smallArrayt *self, int64_t index, smallArrayt *toInsert); 215 internal smallArrayt* insertSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInsert); 216 internal smallArrayt* insertNSmashSmallArray(smallArrayt *self, int64_t index, smallArrayt *toInsert); 217 internal smallArrayt* insertNSmashSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInsert); 218 internal smallArrayt* injectSmallArray(smallArrayt *self, int64_t index, baset *toInject); 219 internal smallArrayt* injectUndefinedSmallArray(smallArrayt *self, int64_t index); 220 internal smallArrayt* injectBoolSmallArray(smallArrayt *self, int64_t index, bool toInject); 221 internal smallArrayt* injectDoubleSmallArray(smallArrayt *self, int64_t index, double toInject); 222 internal smallArrayt* injectIntSmallArray(smallArrayt *self, int64_t index, int64_t toInject); 223 internal smallArrayt* injectSSmallArray(smallArrayt *self, int64_t index, const char *toInject); 224 internal smallArrayt* injectCharSmallArray(smallArrayt *self, int64_t index, char c); 225 internal smallArrayt* injectDictSmallArray(smallArrayt *self, int64_t index, smallDictt *toInject); 226 internal smallArrayt* injectArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *toInject); 227 internal smallArrayt* injectArraycSmallArray(smallArrayt *self, int64_t index, char **toInject); 228 internal smallArrayt* injectCArraycSmallArray(smallArrayt *self, int64_t index, const char **toInject); 229 internal smallArrayt* injectSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *toInject); 230 internal smallArrayt* injectSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *toInject); 231 internal smallArrayt* injectSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *toInject); 232 internal smallArrayt* injectSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *toInject); 233 internal smallArrayt* injectSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInject); 234 internal smallArrayt* injectSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *toInject); 235 internal smallArrayt* injectSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *toInject); 236 internal smallArrayt* injectNFreeSmallArray(smallArrayt *self, int64_t index, baset *toInject); 237 internal smallArrayt* injectNFreeUndefinedSmallArray(smallArrayt *self, int64_t index, undefinedt *u); 238 internal smallArrayt* injectNFreeSSmallArray(smallArrayt *self, int64_t index, char *toInject); 239 internal smallArrayt* injectNFreeDictSmallArray(smallArrayt *self, int64_t index, smallDictt *toInject); 240 internal smallArrayt* injectNFreeArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *toInject); 241 internal smallArrayt* injectNFreeArraycSmallArray(smallArrayt *self, int64_t index, char **toInject); 242 internal smallArrayt* injectNFreeSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *toInject); 243 internal smallArrayt* injectNFreeSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *toInject); 244 internal smallArrayt* injectNFreeSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *toInject); 245 internal smallArrayt* injectNFreeSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *toInject); 246 internal smallArrayt* injectNFreeSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInject); 247 internal smallArrayt* injectNFreeSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *toInject); 248 internal smallArrayt* injectNFreeSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *toInject); 249 internal smallArrayt* delSmallArray(smallArrayt *self, int64_t start, int64_t end); 250 internal smallArrayt* delElemSmallArray(smallArrayt *self, int64_t index); 251 internal smallArrayt* removeSmallArray(smallArrayt *self, int64_t start, int64_t end); 252 internal smallArrayt* removeElemSmallArray(smallArrayt *self, int64_t index); 253 internal int sortSCmp(const void * a, const void * b); 254 internal smallArrayt* sortSmallArray(smallArrayt *self); 255 #if (__APPLE__ || __FreeBSD__ || __DragonFly__) 256 internal int sortFCmp(void *func, const void *a, const void *b); 257 #else 258 internal int sortFCmp(const void *a, const void *b, void *func); 259 #endif 260 internal int icSortSCmp(const void * a, const void * b); 261 internal smallArrayt* icSortSmallArray(smallArrayt *self); 262 #if (__APPLE__ || __FreeBSD__ || __DragonFly__) 263 internal smallArrayt* sortFSmallArray(smallArrayt *self, shCmpt compareFunction); 264 #else 265 internal smallArrayt* sortFSmallArray(smallArrayt *self, shCmpt compareFunction); 266 #endif 267 internal bool equalSmallArray(smallArrayt *self, smallArrayt *array); 268 internal bool equalSmallArraySmallJson(smallArrayt *self, smallJsont *array); 269 internal bool equalSmallArrayArray(smallArrayt* self, char ** p2); 270 internal bool equalSmallArrayCArray(smallArrayt* self, const char ** p2); 271 internal bool equalSmallArrayBase(smallArrayt* self, baset* p2); 272 internal bool icEqualSmallArray(smallArrayt *self, smallArrayt *array); 273 internal bool icEqualSmallArraySmallJson(smallArrayt *self, smallJsont *array); 274 bool icEqualSmallArrayArray(smallArrayt* self, char ** p2); 275 bool icEqualSmallArrayCArray(smallArrayt* self, const char ** p2); 276 bool icEqualSmallArrayBase(smallArrayt* self, baset* p2); 277 internal size_t lenSmallArray(smallArrayt *self); 278 internal smallArrayt* trimSmallArray(smallArrayt *self); 279 baset* getAtSmallArray(smallArrayt *self, int64_t index); 280 internal undefinedt* getAtUndefinedSmallArray(smallArrayt *self, int64_t index); 281 internal bool getAtBoolSmallArray(smallArrayt *self, int64_t index); 282 internal bool* getAtBoolPSmallArray(smallArrayt *self, int64_t index); 283 internal double getAtDoubleSmallArray(smallArrayt *self, int64_t index); 284 internal double* getAtDoublePSmallArray(smallArrayt *self, int64_t index); 285 internal int64_t getAtIntSmallArray(smallArrayt *self, int64_t index); 286 internal int64_t* getAtIntPSmallArray(smallArrayt *self, int64_t index); 287 internal int32_t getAtInt32SmallArray(smallArrayt *self, int64_t index); 288 internal int32_t* getAtInt32PSmallArray(smallArrayt *self, int64_t index); 289 internal uint64_t getAtUintSmallArray(smallArrayt *self, int64_t index); 290 internal uint64_t* getAtUintPSmallArray(smallArrayt *self, int64_t index); 291 internal uint32_t getAtUint32SmallArray(smallArrayt *self, int64_t index); 292 internal uint32_t* getAtUint32PSmallArray(smallArrayt *self, int64_t index); 293 internal char* getAtSSmallArray(smallArrayt *self, int64_t index); 294 internal smallDictt* getAtDictSmallArray(smallArrayt *self, int64_t index); 295 internal smallArrayt* getAtArraySmallArray(smallArrayt *self, int64_t index); 296 internal smallBoolt* getAtSmallBoolSmallArray(smallArrayt *self, int64_t index); 297 internal smallBytest* getAtSmallBytesSmallArray(smallArrayt *self, int64_t index); 298 internal smallDoublet* getAtSmallDoubleSmallArray(smallArrayt *self, int64_t index); 299 internal smallIntt* getAtSmallIntSmallArray(smallArrayt *self, int64_t index); 300 internal smallJsont* getAtSmallJsonSmallArray(smallArrayt *self, int64_t index); 301 internal smallStringt* getAtSmallStringSmallArray(smallArrayt *self, int64_t index); 302 internal void* getAtVoidSmallArray(smallArrayt *self, int64_t index); 303 internal smallContainert* getAtSmallContainerSmallArray(smallArrayt *self, int64_t index); 304 baset* getAtNDupSmallArray(smallArrayt *self, int64_t index); 305 internal undefinedt* getAtNDupUndefinedSmallArray(smallArrayt *self, int64_t index); 306 internal bool getAtNDupBoolSmallArray(smallArrayt *self, int64_t index); 307 internal double getAtNDupDoubleSmallArray(smallArrayt *self, int64_t index); 308 internal int64_t getAtNDupIntSmallArray(smallArrayt *self, int64_t index); 309 internal int32_t getAtNDupInt32SmallArray(smallArrayt *self, int64_t index); 310 internal uint64_t getAtNDupUintSmallArray(smallArrayt *self, int64_t index); 311 internal uint32_t getAtNDupUint32SmallArray(smallArrayt *self, int64_t index); 312 internal char* getAtNDupSSmallArray(smallArrayt *self, int64_t index); 313 internal smallDictt* getAtNDupDictSmallArray(smallArrayt *self, int64_t index); 314 internal smallArrayt* getAtNDupArraySmallArray(smallArrayt *self, int64_t index); 315 internal smallBoolt* getAtNDupSmallBoolSmallArray(smallArrayt *self, int64_t index); 316 internal smallBytest* getAtNDupSmallBytesSmallArray(smallArrayt *self, int64_t index); 317 internal smallDoublet* getAtNDupSmallDoubleSmallArray(smallArrayt *self, int64_t index); 318 internal smallIntt* getAtNDupSmallIntSmallArray(smallArrayt *self, int64_t index); 319 internal smallJsont* getAtNDupSmallJsonSmallArray(smallArrayt *self, int64_t index); 320 internal smallStringt* getAtNDupSmallStringSmallArray(smallArrayt *self, int64_t index); 321 internal void* getAtNDupVoidSmallArray(smallArrayt *self, int64_t index); 322 internal smallContainert* getAtNDupSmallContainerSmallArray(smallArrayt *self, int64_t index); 323 internal smallArrayt* setAtSmallArray(smallArrayt *self, int64_t index, baset *value); 324 internal smallArrayt* setAtUndefinedSmallArray(smallArrayt *self, int64_t index); 325 internal smallArrayt* setAtBoolSmallArray(smallArrayt *self, int64_t index, bool value); 326 internal smallArrayt* setAtDoubleSmallArray(smallArrayt *self, int64_t index, double value); 327 internal smallArrayt* setAtIntSmallArray(smallArrayt *self, int64_t index, int64_t value); 328 internal smallArrayt* setAtSSmallArray(smallArrayt *self, int64_t index, const char *string); 329 internal smallArrayt* setAtCharSmallArray(smallArrayt *self, int64_t index, char c); 330 internal smallArrayt* setAtDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict); 331 internal smallArrayt* setAtArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array); 332 internal smallArrayt* setAtArraycSmallArray(smallArrayt *self, int64_t index, char **array); 333 internal smallArrayt* setAtCArraycSmallArray(smallArrayt *self, int64_t index, const char **array); 334 internal smallArrayt* setAtSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *value); 335 internal smallArrayt* setAtSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *value); 336 internal smallArrayt* setAtSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *value); 337 internal smallArrayt* setAtSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *value); 338 internal smallArrayt* setAtSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *value); 339 internal smallArrayt* setAtSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string); 340 internal smallArrayt* setAtSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *container); 341 internal smallArrayt* setAtNFreeSmallArray(smallArrayt *self, int64_t index, baset *value); 342 internal smallArrayt* setAtNFreeUndefinedSmallArray(smallArrayt *self, int64_t index, undefinedt *u); 343 internal smallArrayt* setAtNFreeSSmallArray(smallArrayt *self, int64_t index, char *string); 344 internal smallArrayt* setAtNFreeDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict); 345 internal smallArrayt* setAtNFreeArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array); 346 internal smallArrayt* setAtNFreeArraycSmallArray(smallArrayt *self, int64_t index, char **array); 347 internal smallArrayt* setAtNFreeSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *value); 348 internal smallArrayt* setAtNFreeSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *value); 349 internal smallArrayt* setAtNFreeSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *value); 350 internal smallArrayt* setAtNFreeSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *value); 351 internal smallArrayt* setAtNFreeSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *value); 352 internal smallArrayt* setAtNFreeSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string); 353 internal smallArrayt* setAtNFreeSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *container); 354 internal smallArrayt* setPAtDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict); 355 internal smallArrayt* setPAtArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array); 356 internal smallArrayt* setPAtSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *json); 357 internal smallArrayt* setPAtSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string); 358 internal smallArrayt* setPAtNFreeDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict); 359 internal smallArrayt* setPAtNFreeArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array); 360 internal smallArrayt* setPAtNFreeSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *json); 361 internal smallArrayt* setPAtNFreeSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string); 362 internal double getNumSmallArray(smallArrayt *self, int64_t index); 363 internal bool hasSmallArray(smallArrayt *self, baset *value); 364 internal bool hasUndefinedSmallArray(smallArrayt *self, undefinedt *u); 365 internal bool hasBoolSmallArray(smallArrayt *self, bool value); 366 internal bool hasDoubleSmallArray(smallArrayt *self, double value); 367 internal bool hasIntSmallArray(smallArrayt *self, int64_t value); 368 internal bool hasSSmallArray(smallArrayt *self, const char *string); 369 internal bool hasCharSmallArray(smallArrayt *self, char c); 370 internal bool hasDictSmallArray(smallArrayt *self, smallDictt *dict); 371 internal bool hasArraySmallArray(smallArrayt *self, smallArrayt *array); 372 internal bool hasArraycSmallArray(smallArrayt *self, char **array); 373 internal bool hasCArraycSmallArray(smallArrayt *self, const char **array); 374 internal bool hasSmallBoolSmallArray(smallArrayt *self, smallBoolt *value); 375 internal bool hasSmallBytesSmallArray(smallArrayt *self, smallBytest *value); 376 internal bool hasSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value); 377 internal bool hasSmallIntSmallArray(smallArrayt *self, smallIntt *value); 378 internal bool hasSmallJsonSmallArray(smallArrayt *self, smallJsont *string); 379 internal bool hasSmallStringSmallArray(smallArrayt *self, smallStringt *string); 380 internal bool hasSmallContainerSmallArray(smallArrayt *self, smallContainert *container); 381 internal ssize_t indexOfSmallArray(smallArrayt *self, baset *value); 382 internal ssize_t indexOfUndefinedSmallArray(smallArrayt *self, undefinedt *u); 383 internal ssize_t indexOfBoolSmallArray(smallArrayt *self, bool value); 384 internal ssize_t indexOfDoubleSmallArray(smallArrayt *self, double value); 385 internal ssize_t indexOfIntSmallArray(smallArrayt *self, int64_t value); 386 internal ssize_t indexOfSSmallArray(smallArrayt *self, const char *string); 387 internal ssize_t indexOfCharSmallArray(smallArrayt *self, char c); 388 internal ssize_t indexOfDictSmallArray(smallArrayt *self, smallDictt *dict); 389 internal ssize_t indexOfArraySmallArray(smallArrayt *self, smallArrayt *array); 390 internal ssize_t indexOfArraycSmallArray(smallArrayt *self, char **array); 391 internal ssize_t indexOfCArraycSmallArray(smallArrayt *self, const char **array); 392 internal ssize_t indexOfSmallBoolSmallArray(smallArrayt *self, smallBoolt *value); 393 internal ssize_t indexOfSmallBytesSmallArray(smallArrayt *self, smallBytest *value); 394 internal ssize_t indexOfSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value); 395 internal ssize_t indexOfSmallIntSmallArray(smallArrayt *self, smallIntt *value); 396 internal ssize_t indexOfSmallJsonSmallArray(smallArrayt *self, smallJsont *string); 397 internal ssize_t indexOfSmallStringSmallArray(smallArrayt *self, smallStringt *string); 398 internal ssize_t indexOfSmallContainerSmallArray(smallArrayt *self UNUSED, smallContainert *container UNUSED); 399 internal ssize_t binarySearchSmallArray(smallArrayt *self, baset *value); 400 internal ssize_t binarySearchUndefinedSmallArray(smallArrayt *self UNUSED, undefinedt *u UNUSED); 401 internal ssize_t binarySearchBoolSmallArray(smallArrayt *self, bool value); 402 internal ssize_t binarySearchDoubleSmallArray(smallArrayt *self, double value); 403 internal ssize_t binarySearchIntSmallArray(smallArrayt *self, int64_t value); 404 internal ssize_t binarySearchSSmallArray(smallArrayt *self, const char *string); 405 internal ssize_t binarySearchCharSmallArray(smallArrayt *self, char c); 406 internal ssize_t binarySearchDictSmallArray(smallArrayt *self, smallDictt *dict); 407 internal ssize_t binarySearchArraySmallArray(smallArrayt *self, smallArrayt *array); 408 internal ssize_t binarySearchArraycSmallArray(smallArrayt *self, char **array); 409 internal ssize_t binarySearchCArraycSmallArray(smallArrayt *self, const char **array); 410 internal ssize_t binarySearchSmallBoolSmallArray(smallArrayt *self, smallBoolt *value); 411 internal ssize_t binarySearchSmallBytesSmallArray(smallArrayt *self, smallBytest *value); 412 internal ssize_t binarySearchSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value); 413 internal ssize_t binarySearchSmallIntSmallArray(smallArrayt *self, smallIntt *value); 414 internal ssize_t binarySearchSmallJsonSmallArray(smallArrayt *self, smallJsont *string); 415 internal ssize_t binarySearchSmallStringSmallArray(smallArrayt *self, smallStringt *string); 416 internal ssize_t binarySearchSmallContainerSmallArray(smallArrayt *self UNUSED, smallContainert *container UNUSED); 417 internal smallArrayt* uniqSmallArray(smallArrayt *self); 418 internal bool icHasSmallArray(smallArrayt *self, baset *value); 419 internal bool icHasSSmallArray(smallArrayt *self, const char *string); 420 internal bool icHasCharSmallArray(smallArrayt *self, char c); 421 internal bool icHasDictSmallArray(smallArrayt *self, smallDictt *dict); 422 internal bool icHasArraySmallArray(smallArrayt *self, smallArrayt *array); 423 internal bool icHasArraycSmallArray(smallArrayt *self, char **array); 424 internal bool icHasCArraycSmallArray(smallArrayt *self, const char **array); 425 internal bool icHasSmallJsonSmallArray(smallArrayt *self, smallJsont *string); 426 internal bool icHasSmallStringSmallArray(smallArrayt *self, smallStringt *string); 427 internal ssize_t icIndexOfSmallArray(smallArrayt *self, baset *value); 428 internal ssize_t icIndexOfSSmallArray(smallArrayt *self, const char *string); 429 internal ssize_t icIndexOfCharSmallArray(smallArrayt *self, char c); 430 internal ssize_t icIndexOfDictSmallArray(smallArrayt *self, smallDictt *dict); 431 internal ssize_t icIndexOfArraySmallArray(smallArrayt *self, smallArrayt *array); 432 internal ssize_t icIndexOfArraycSmallArray(smallArrayt *self, char **array); 433 internal ssize_t icIndexOfCArraycSmallArray(smallArrayt *self, const char **array); 434 internal ssize_t icIndexOfSmallJsonSmallArray(smallArrayt *self, smallJsont *string); 435 internal ssize_t icIndexOfSmallStringSmallArray(smallArrayt *self, smallStringt *string); 436 internal ssize_t icBinarySearchSmallArray(smallArrayt *self, baset *value); 437 internal ssize_t icBinarySearchSSmallArray(smallArrayt *self, const char *string); 438 internal ssize_t icBinarySearchCharSmallArray(smallArrayt *self, char c); 439 internal ssize_t icBinarySearchDictSmallArray(smallArrayt *self, smallDictt *dict); 440 internal ssize_t icBinarySearchArraySmallArray(smallArrayt *self, smallArrayt *array); 441 internal ssize_t icBinarySearchArraycSmallArray(smallArrayt *self, char **array); 442 internal ssize_t icBinarySearchCArraycSmallArray(smallArrayt *self, const char **array); 443 internal ssize_t icBinarySearchSmallJsonSmallArray(smallArrayt *self, smallJsont *string); 444 internal ssize_t icBinarySearchSmallStringSmallArray(smallArrayt *self, smallStringt *string); 445 internal smallArrayt* icUniqSmallArray(smallArrayt *self); 446 internal smallArrayt* compactSmallArray(smallArrayt *self); 447 internal smallArrayt* emptySmallArray(smallArrayt *self); 448 internal bool isEmptySmallArray(smallArrayt *self); 449 internal bool isBlankSmallArray(smallArrayt *self); 450 internal void forEachSmallArrayF(smallArrayt *self, void *closure, forEachElementSmallArrayFt funcElem); 451 internal void enumerateSmallArrayF(smallArrayt *self, void *closure, enumerateElementSmallArrayFt funcElem); 452 internal baset* iterStartSmallArray(smallArrayt *self); 453 internal baset* iterStartLastSmallArray(smallArrayt *self); 454 internal baset* iterStartFromSmallArray(smallArrayt *self, int64_t index); 455 internal baset* iterStartFromStepSmallArray(smallArrayt *self, int64_t index, int64_t step); 456 internal baset* iterNextSmallArray(smallArrayt *self); 457 internal baset* iterElementSmallArray(smallArrayt *self); 458 internal ssize_t iterIndexSmallArray(smallArrayt *self); 459 internal int64_t iterStepSmallArray(smallArrayt *self); 460 internal smallStringt* joinSmallArray(smallArrayt *self, const char* delim); 461 internal smallStringt* joinCharSmallArray(smallArrayt *self, char c); 462 internal smallStringt* joinSmallJsonSmallArray(smallArrayt *self, smallJsont* delim); 463 internal smallStringt* joinSmallStringSmallArray(smallArrayt *self, smallStringt* delim); 464 internal char* joinSSmallArray(smallArrayt *self, const char* delim); 465 internal char* joinCharSSmallArray(smallArrayt *self, char c); 466 internal char* joinSmallJsonSSmallArray(smallArrayt *self, smallJsont* delim); 467 internal char* joinSmallStringSSmallArray(smallArrayt *self, smallStringt* delim); 468 internal smallArrayt* zipSmallArray(smallArrayt *self, smallArrayt *array1, smallArrayt *array2); 469 internal smallArrayt* zipSmallJsonSmallArray(smallArrayt *self, smallArrayt *array1, smallJsont *array2); 470 internal smallArrayt* zipSmallJsonSmallArraySmallArray(smallArrayt *self, smallJsont *array1, smallArrayt *array2); 471 internal smallArrayt* zipSmallJsonSmallJsonSmallArray(smallArrayt *self, smallJsont *array1, smallJsont *array2); 472 internal smallArrayt* zipSmallJsonCharSmallArray(smallArrayt *self, smallJsont *array1, char **array2); 473 internal smallArrayt* zipSmallJsonCCharSmallArray(smallArrayt *self, smallJsont *array1, const char **array2); 474 internal smallArrayt* zipArraySmallArray(smallArrayt *self, char** array1, smallArrayt *array2); 475 internal smallArrayt* zipCArraySmallArray(smallArrayt *self, const char** array1, smallArrayt *array2); 476 internal smallArrayt* zipArraySmallJsonSmallArray(smallArrayt *self, char** array1, smallJsont *array2); 477 internal smallArrayt* zipCArraySmallJsonSmallArray(smallArrayt *self, const char** array1, smallJsont *array2); 478 internal smallArrayt* zipCharSmallArray(smallArrayt *self, smallArrayt *array1, char** array2); 479 internal smallArrayt* zipCCharSmallArray(smallArrayt *self, smallArrayt *array1, const char** array2); 480 internal smallArrayt* zipArrayCharSmallArray(smallArrayt *self, char** array1, char** array2); 481 internal smallArrayt* zipCArrayCharSmallArray(smallArrayt *self, const char** array1, char** array2); 482 internal smallArrayt* zipArrayCCharSmallArray(smallArrayt *self, char** array1, const char** array2); 483 internal smallArrayt* zipCArrayCCharSmallArray(smallArrayt *self, const char** array1, const char** array2); 484 internal void logSmallArray(smallArrayt *self); 485 internal smallArrayt* readTextSmallArray(smallArrayt *self, const char *filePath); 486 internal smallArrayt* readTextSmallJsonSmallArray(smallArrayt *self, smallJsont *filePath); 487 internal smallArrayt* readTextSmallStringSmallArray(smallArrayt *self, smallStringt *filePath); 488 internal smallArrayt* readStreamSmallArray(smallArrayt *self, FILE *fp); 489 internal bool writeTextSmallArray(smallArrayt *self, const char *filePath); 490 internal bool writeTextSmallJsonSmallArray(smallArrayt *self, smallJsont *filePath); 491 internal bool writeTextSmallStringSmallArray(smallArrayt *self, smallStringt *filePath); 492 internal bool writeStreamSmallArray(smallArrayt *self, FILE *fp); 493 internal bool appendTextSmallArray(smallArrayt *self, const char *filePath); 494 internal bool appendTextSmallStringSmallArray(smallArrayt *self, smallStringt *filePath); 495 internal const char* typeStringSmallArray(smallArrayt *self, int64_t index); 496 internal smallStringt* typeSmallStringSmallArray(smallArrayt *self, int64_t index); 497 internal char typeSmallArray(smallArrayt *self, int64_t index); 498 internal const char** typeStringsSmallArray(smallArrayt *self); 499 internal smallArrayt* typeSmallStringsSmallArray(smallArrayt *self); 500 internal smallBytest* typesSmallArray(smallArrayt *self); 501 internal bool isETypeSmallArray(smallArrayt *self, int64_t index, const char *type); 502 internal bool isEUndefinedSmallArray(smallArrayt *self, int64_t index); 503 internal bool isEBoolSmallArray(smallArrayt *self, int64_t index); 504 internal bool isEContainerSmallArray(smallArrayt *self, int64_t index); 505 internal bool isEDictSmallArray(smallArrayt *self, int64_t index); 506 internal bool isEDoubleSmallArray(smallArrayt *self, int64_t index); 507 internal bool isEIntSmallArray(smallArrayt *self, int64_t index); 508 internal bool isEStringSmallArray(smallArrayt *self, int64_t index); 509 internal bool isEFaststringSmallArray(smallArrayt *self, int64_t index); 510 internal bool isEArraySmallArray(smallArrayt *self, int64_t index); 511 internal bool isEBytesSmallArray(smallArrayt *self, int64_t index); 512 internal bool areAllETypeSmallArray(smallArrayt *self, const char *type); 513 internal bool areAllEUndefinedSmallArray(smallArrayt *self); 514 internal bool areAllEBoolSmallArray(smallArrayt *self); 515 internal bool areAllEContainerSmallArray(smallArrayt *self); 516 internal bool areAllEDictSmallArray(smallArrayt *self); 517 internal bool areAllEDoubleSmallArray(smallArrayt *self); 518 internal bool areAllEIntSmallArray(smallArrayt *self); 519 internal bool areAllEStringSmallArray(smallArrayt *self); 520 internal bool areAllEFaststringSmallArray(smallArrayt *self); 521 internal bool areAllEArraySmallArray(smallArrayt *self); 522 internal bool areAllEBytesSmallArray(smallArrayt *self); 523 smallArrayt* allocSmallArrayG(smallArrayt *self UNUSED); 524 smallArrayt* duplicateSmallArrayG (smallArrayt *self); 525 smallArrayt* fromArraySmallArrayG (smallArrayt *self, char **array, size_t size); 526 smallArrayt* fromCArraySmallArrayG (smallArrayt *self, const char **array, size_t size); 527 smallArrayt* setFromSmallArrayG(smallArrayt *self, char **array); 528 smallArrayt* setFromCSmallArrayG(smallArrayt *self, const char **array); 529 smallArrayt* pushSmallArrayG (smallArrayt *self, baset *value); 530 smallArrayt* pushUndefinedSmallArrayG(smallArrayt *self, void *value UNUSED); 531 smallArrayt* pushBoolSmallArrayG (smallArrayt *self, bool value); 532 smallArrayt* pushDoubleSmallArrayG (smallArrayt *self, double value); 533 smallArrayt* pushIntSmallArrayG (smallArrayt *self, int64_t value); 534 smallArrayt* pushSSmallArrayG (smallArrayt *self, const char *string); 535 smallArrayt* pushCharSmallArrayG(smallArrayt *self, char c); 536 smallArrayt* pushDictSmallArrayG (smallArrayt *self, smallDictt *dict); 537 smallArrayt* pushArraySmallArrayG (smallArrayt *self, smallArrayt *array); 538 smallArrayt* pushArraycSmallArrayG (smallArrayt *self, char **array); 539 smallArrayt* pushCArraycSmallArrayG (smallArrayt *self, const char **array); 540 smallArrayt* pushVoidSmallArrayG (smallArrayt *self, void *value); 541 smallArrayt* pushSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value); 542 smallArrayt* pushSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value); 543 smallArrayt* pushSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value); 544 smallArrayt* pushSmallIntSmallArrayG (smallArrayt *self, smallIntt *value); 545 smallArrayt* pushSmallJsonSmallArrayG(smallArrayt *self, smallJsont *value); 546 smallArrayt* pushSmallStringSmallArrayG (smallArrayt *self, smallStringt *string); 547 smallArrayt* pushSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container); 548 smallArrayt* pushNFreeSmallArrayG (smallArrayt *self, baset *value); 549 smallArrayt* pushNFreeUndefinedSmallArrayG(smallArrayt *self, undefinedt *value); 550 smallArrayt* pushNFreeSSmallArrayG (smallArrayt *self, char *string); 551 smallArrayt* pushNFreeDictSmallArrayG (smallArrayt *self, smallDictt *dict); 552 smallArrayt* pushNFreeArraySmallArrayG (smallArrayt *self, smallArrayt *array); 553 smallArrayt* pushNFreeArraycSmallArrayG (smallArrayt *self, char **array); 554 smallArrayt* pushNFreeSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value); 555 smallArrayt* pushNFreeSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value); 556 smallArrayt* pushNFreeSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value); 557 smallArrayt* pushNFreeSmallIntSmallArrayG (smallArrayt *self, smallIntt *value); 558 smallArrayt* pushNFreeSmallJsonSmallArrayG(smallArrayt *self, smallJsont *value); 559 smallArrayt* pushNFreeSmallStringSmallArrayG (smallArrayt *self, smallStringt *string); 560 smallArrayt* pushNFreeSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container); 561 baset* popSmallArrayG (smallArrayt *self, baset* retType UNUSED); 562 undefinedt* popUndefinedSmallArrayG (smallArrayt *self, undefinedt* retType UNUSED); 563 bool popBoolSmallArrayG (smallArrayt *self, bool retType UNUSED); 564 double popDoubleSmallArrayG (smallArrayt *self, double retType UNUSED); 565 int64_t popIntSmallArrayG (smallArrayt *self, int64_t retType UNUSED); 566 int32_t popInt32SmallArrayG (smallArrayt *self, int32_t retType UNUSED); 567 uint64_t popUintSmallArrayG (smallArrayt *self, uint64_t retType UNUSED); 568 uint32_t popUint32SmallArrayG (smallArrayt *self, uint32_t retType UNUSED); 569 char* popSSmallArrayG (smallArrayt *self, char* retType UNUSED); 570 smallDictt* popDictSmallArrayG (smallArrayt *self, smallDictt* retType UNUSED); 571 smallArrayt* popArraySmallArrayG (smallArrayt *self, smallArrayt* retType UNUSED); 572 smallBoolt* popSmallBoolSmallArrayG (smallArrayt *self, smallBoolt* retType UNUSED); 573 smallBytest* popSmallBytesSmallArrayG (smallArrayt *self, smallBytest* retType UNUSED); 574 smallDoublet* popSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet* retType UNUSED); 575 smallIntt* popSmallIntSmallArrayG (smallArrayt *self, smallIntt* retType UNUSED); 576 smallJsont* popSmallJsonSmallArrayG (smallArrayt *self, smallJsont* retType UNUSED); 577 smallStringt* popSmallStringSmallArrayG (smallArrayt *self, smallStringt* retType UNUSED); 578 void* popVoidSmallArrayG (smallArrayt *self, void* retType UNUSED); 579 smallContainert* popSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED); 580 smallArrayt* prependSmallArrayG (smallArrayt *self, baset *value); 581 smallArrayt* prependUndefinedSmallArrayG(smallArrayt *self, void *value UNUSED); 582 smallArrayt* prependBoolSmallArrayG (smallArrayt *self, bool value); 583 smallArrayt* prependDoubleSmallArrayG (smallArrayt *self, double value); 584 smallArrayt* prependIntSmallArrayG (smallArrayt *self, int64_t value); 585 smallArrayt* prependSSmallArrayG (smallArrayt *self, const char *string); 586 smallArrayt* prependCharSmallArrayG(smallArrayt *self, char c); 587 smallArrayt* prependDictSmallArrayG (smallArrayt *self, smallDictt *dict); 588 smallArrayt* prependArraySmallArrayG (smallArrayt *self, smallArrayt *array); 589 smallArrayt* prependArraycSmallArrayG (smallArrayt *self, char **array); 590 smallArrayt* prependCArraycSmallArrayG (smallArrayt *self, const char **array); 591 smallArrayt* prependVoidSmallArrayG (smallArrayt *self, void *value); 592 smallArrayt* prependSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value); 593 smallArrayt* prependSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value); 594 smallArrayt* prependSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value); 595 smallArrayt* prependSmallIntSmallArrayG (smallArrayt *self, smallIntt *value); 596 smallArrayt* prependSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json); 597 smallArrayt* prependSmallStringSmallArrayG (smallArrayt *self, smallStringt *string); 598 smallArrayt* prependSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container); 599 smallArrayt* prependNFreeSmallArrayG (smallArrayt *self, baset *value); 600 smallArrayt* prependNFreeUndefinedSmallArrayG(smallArrayt *self, undefinedt *value); 601 smallArrayt* prependNFreeSSmallArrayG (smallArrayt *self, char *string); 602 smallArrayt* prependNFreeDictSmallArrayG (smallArrayt *self, smallDictt *dict); 603 smallArrayt* prependNFreeArraySmallArrayG (smallArrayt *self, smallArrayt *array); 604 smallArrayt* prependNFreeArraycSmallArrayG (smallArrayt *self, char **array); 605 smallArrayt* prependNFreeSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value); 606 smallArrayt* prependNFreeSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value); 607 smallArrayt* prependNFreeSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value); 608 smallArrayt* prependNFreeSmallIntSmallArrayG (smallArrayt *self, smallIntt *value); 609 smallArrayt* prependNFreeSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json); 610 smallArrayt* prependNFreeSmallStringSmallArrayG (smallArrayt *self, smallStringt *string); 611 smallArrayt* prependNFreeSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container); 612 baset* dequeueSmallArrayG (smallArrayt *self, baset* retType UNUSED); 613 undefinedt* dequeueUndefinedSmallArrayG (smallArrayt *self, undefinedt* retType UNUSED); 614 bool dequeueBoolSmallArrayG (smallArrayt *self, bool retType UNUSED); 615 double dequeueDoubleSmallArrayG (smallArrayt *self, double retType UNUSED); 616 int64_t dequeueIntSmallArrayG (smallArrayt *self, int64_t retType UNUSED); 617 int32_t dequeueInt32SmallArrayG (smallArrayt *self, int32_t retType UNUSED); 618 uint64_t dequeueUintSmallArrayG (smallArrayt *self, uint64_t retType UNUSED); 619 uint32_t dequeueUint32SmallArrayG (smallArrayt *self, uint32_t retType UNUSED); 620 char* dequeueSSmallArrayG (smallArrayt *self, char* retType UNUSED); 621 smallDictt* dequeueDictSmallArrayG (smallArrayt *self, smallDictt* retType UNUSED); 622 smallArrayt* dequeueArraySmallArrayG (smallArrayt *self, smallArrayt* retType UNUSED); 623 smallBoolt* dequeueSmallBoolSmallArrayG (smallArrayt *self, smallBoolt* retType UNUSED); 624 smallBytest* dequeueSmallBytesSmallArrayG (smallArrayt *self, smallBytest* retType UNUSED); 625 smallDoublet* dequeueSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet* retType UNUSED); 626 smallIntt* dequeueSmallIntSmallArrayG (smallArrayt *self, smallIntt* retType UNUSED); 627 smallJsont* dequeueSmallJsonSmallArrayG (smallArrayt *self, smallJsont* retType UNUSED); 628 smallStringt* dequeueSmallStringSmallArrayG (smallArrayt *self, smallStringt* retType UNUSED); 629 void* dequeueVoidSmallArrayG (smallArrayt *self, void* retType UNUSED); 630 smallContainert* dequeueSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED); 631 baset* getAtSmallArrayG (smallArrayt *self, baset* retType UNUSED, int64_t index); 632 undefinedt* getAtUndefinedSmallArrayG (smallArrayt *self, undefinedt* retType UNUSED, int64_t index); 633 bool getAtBoolSmallArrayG (smallArrayt *self, bool retType UNUSED, int64_t index); 634 bool* getAtBoolPSmallArrayG (smallArrayt *self, bool* retType UNUSED, int64_t index); 635 double getAtDoubleSmallArrayG (smallArrayt *self, double retType UNUSED, int64_t index); 636 double* getAtDoublePSmallArrayG (smallArrayt *self, double* retType UNUSED, int64_t index); 637 int64_t getAtIntSmallArrayG (smallArrayt *self, int64_t retType UNUSED, int64_t index); 638 int64_t* getAtIntPSmallArrayG (smallArrayt *self, int64_t* retType UNUSED, int64_t index); 639 int32_t getAtInt32SmallArrayG (smallArrayt *self, int32_t retType UNUSED, int64_t index); 640 int32_t* getAtInt32PSmallArrayG (smallArrayt *self, int32_t* retType UNUSED, int64_t index); 641 uint64_t getAtUintSmallArrayG (smallArrayt *self, uint64_t retType UNUSED, int64_t index); 642 uint64_t* getAtUintPSmallArrayG (smallArrayt *self, uint64_t* retType UNUSED, int64_t index); 643 uint32_t getAtUint32SmallArrayG (smallArrayt *self, uint32_t retType UNUSED, int64_t index); 644 uint32_t* getAtUint32PSmallArrayG (smallArrayt *self, uint32_t* retType UNUSED, int64_t index); 645 char* getAtSSmallArrayG (smallArrayt *self, char* retType UNUSED, int64_t index); 646 smallDictt* getAtDictSmallArrayG (smallArrayt *self, smallDictt* retType UNUSED, int64_t index); 647 smallArrayt* getAtArraySmallArrayG (smallArrayt *self, smallArrayt* retType UNUSED, int64_t index); 648 smallBoolt* getAtSmallBoolSmallArrayG (smallArrayt *self, smallBoolt* retType UNUSED, int64_t index); 649 smallBytest* getAtSmallBytesSmallArrayG (smallArrayt *self, smallBytest* retType UNUSED, int64_t index); 650 smallDoublet* getAtSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet* retType UNUSED, int64_t index); 651 smallIntt* getAtSmallIntSmallArrayG (smallArrayt *self, smallIntt* retType UNUSED, int64_t index); 652 smallJsont* getAtSmallJsonSmallArrayG(smallArrayt *self, smallJsont* retType UNUSED, int64_t index); 653 smallStringt* getAtSmallStringSmallArrayG (smallArrayt *self, smallStringt* retType UNUSED, int64_t index); 654 void* getAtVoidSmallArrayG (smallArrayt *self, void* retType UNUSED, int64_t index); 655 smallContainert* getAtSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, int64_t index); 656 baset* getAtNDupSmallArrayG (smallArrayt *self, baset* retType UNUSED, int64_t index); 657 undefinedt* getAtNDupUndefinedSmallArrayG (smallArrayt *self, undefinedt* retType UNUSED, int64_t index); 658 bool getAtNDupBoolSmallArrayG (smallArrayt *self, bool retType UNUSED, int64_t index); 659 double getAtNDupDoubleSmallArrayG (smallArrayt *self, double retType UNUSED, int64_t index); 660 int64_t getAtNDupIntSmallArrayG (smallArrayt *self, int64_t retType UNUSED, int64_t index); 661 int32_t getAtNDupInt32SmallArrayG (smallArrayt *self, int32_t retType UNUSED, int64_t index); 662 uint64_t getAtNDupUintSmallArrayG (smallArrayt *self, uint64_t retType UNUSED, int64_t index); 663 uint32_t getAtNDupUint32SmallArrayG (smallArrayt *self, uint32_t retType UNUSED, int64_t index); 664 char* getAtNDupSSmallArrayG (smallArrayt *self, char* retType UNUSED, int64_t index); 665 smallDictt* getAtNDupDictSmallArrayG (smallArrayt *self, smallDictt* retType UNUSED, int64_t index); 666 smallArrayt* getAtNDupArraySmallArrayG (smallArrayt *self, smallArrayt* retType UNUSED, int64_t index); 667 smallBoolt* getAtNDupSmallBoolSmallArrayG (smallArrayt *self, smallBoolt* retType UNUSED, int64_t index); 668 smallBytest* getAtNDupSmallBytesSmallArrayG (smallArrayt *self, smallBytest* retType UNUSED, int64_t index); 669 smallDoublet* getAtNDupSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet* retType UNUSED, int64_t index); 670 smallIntt* getAtNDupSmallIntSmallArrayG (smallArrayt *self, smallIntt* retType UNUSED, int64_t index); 671 smallJsont* getAtNDupSmallJsonSmallArrayG (smallArrayt *self, smallJsont* retType UNUSED, int64_t index); 672 smallStringt* getAtNDupSmallStringSmallArrayG (smallArrayt *self, smallStringt* retType UNUSED, int64_t index); 673 void* getAtNDupVoidSmallArrayG (smallArrayt *self, void* retType UNUSED, int64_t index); 674 smallContainert* getAtNDupSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, int64_t index); 675 smallArrayt* setAtSmallArrayG (smallArrayt *self, int64_t index, baset *value); 676 smallArrayt* setAtUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value UNUSED); 677 smallArrayt* setAtBoolSmallArrayG (smallArrayt *self, int64_t index, bool value); 678 smallArrayt* setAtDoubleSmallArrayG (smallArrayt *self, int64_t index, double value); 679 smallArrayt* setAtIntSmallArrayG (smallArrayt *self, int64_t index, int64_t value); 680 smallArrayt* setAtSSmallArrayG (smallArrayt *self, int64_t index, const char *string); 681 smallArrayt* setAtCharSmallArrayG(smallArrayt *self, int64_t index, char c); 682 smallArrayt* setAtDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict); 683 smallArrayt* setAtArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array); 684 smallArrayt* setAtArraycSmallArrayG (smallArrayt *self, int64_t index, char **array); 685 smallArrayt* setAtCArraycSmallArrayG (smallArrayt *self, int64_t index, const char **array); 686 smallArrayt* setAtVoidSmallArrayG (smallArrayt *self, int64_t index, void *value); 687 smallArrayt* setAtSmallBoolSmallArrayG (smallArrayt *self, int64_t index, smallBoolt *value); 688 smallArrayt* setAtSmallBytesSmallArrayG (smallArrayt *self, int64_t index, smallBytest *value); 689 smallArrayt* setAtSmallDoubleSmallArrayG (smallArrayt *self, int64_t index, smallDoublet *value); 690 smallArrayt* setAtSmallIntSmallArrayG (smallArrayt *self, int64_t index, smallIntt *value); 691 smallArrayt* setAtSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *value); 692 smallArrayt* setAtSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string); 693 smallArrayt* setAtSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container); 694 smallArrayt* setAtNFreeSmallArrayG (smallArrayt *self, int64_t index, baset *value); 695 smallArrayt* setAtNFreeUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value); 696 smallArrayt* setAtNFreeSSmallArrayG (smallArrayt *self, int64_t index, char *string); 697 smallArrayt* setAtNFreeDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict); 698 smallArrayt* setAtNFreeArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array); 699 smallArrayt* setAtNFreeArraycSmallArrayG (smallArrayt *self, int64_t index, char **array); 700 smallArrayt* setAtNFreeSmallBoolSmallArrayG (smallArrayt *self, int64_t index, smallBoolt *value); 701 smallArrayt* setAtNFreeSmallBytesSmallArrayG (smallArrayt *self, int64_t index, smallBytest *value); 702 smallArrayt* setAtNFreeSmallDoubleSmallArrayG (smallArrayt *self, int64_t index, smallDoublet *value); 703 smallArrayt* setAtNFreeSmallIntSmallArrayG (smallArrayt *self, int64_t index, smallIntt *value); 704 smallArrayt* setAtNFreeSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *value); 705 smallArrayt* setAtNFreeSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string); 706 smallArrayt* setAtNFreeSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container); 707 smallArrayt* setPAtDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict); 708 smallArrayt* setPAtArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array); 709 smallArrayt* setPAtSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *json); 710 smallArrayt* setPAtSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string); 711 smallArrayt* setPAtNFreeDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict); 712 smallArrayt* setPAtNFreeArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array); 713 smallArrayt* setPAtNFreeSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *json); 714 smallArrayt* setPAtNFreeSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string); 715 double getNumSmallArrayG(smallArrayt *self, int64_t index); 716 smallArrayt* reverseSmallArrayG (smallArrayt *self); 717 smallArrayt* appendSmallArrayG (smallArrayt *self, smallArrayt *array); 718 smallArrayt* appendSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json); 719 smallArrayt* appendNSmashSmallArrayG (smallArrayt *self, smallArrayt *array); 720 smallArrayt* appendNSmashSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json); 721 smallArrayt* appendArraySmallArrayG (smallArrayt *self, char **array); 722 smallArrayt* appendNSmashArraySmallArrayG (smallArrayt *self, char **array); 723 smallArrayt* appendCArraySmallArrayG (smallArrayt *self, const char **array); 724 smallArrayt* shiftSmallArrayG (smallArrayt *self, smallArrayt *array); 725 smallArrayt* shiftSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json); 726 smallArrayt* shiftNSmashSmallArrayG (smallArrayt *self, smallArrayt *array); 727 smallArrayt* shiftNSmashSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json); 728 smallArrayt* addSmallArrayG (smallArrayt *self, smallArrayt *array); 729 smallArrayt* sliceSmallArrayG(smallArrayt *self, int64_t start, int64_t end); 730 smallArrayt* cropSmallArrayG (smallArrayt *self, int64_t start, int64_t end); 731 baset* cropElemSmallArrayG (smallArrayt *self, int64_t index); 732 undefinedt* cropElemUndefinedSmallArrayG (smallArrayt *self, int64_t index); 733 bool cropElemBoolSmallArrayG (smallArrayt *self, int64_t index); 734 double cropElemDoubleSmallArrayG (smallArrayt *self, int64_t index); 735 int64_t cropElemIntSmallArrayG (smallArrayt *self, int64_t index); 736 int32_t cropElemInt32SmallArrayG (smallArrayt *self, int64_t index); 737 uint64_t cropElemUintSmallArrayG (smallArrayt *self, int64_t index); 738 uint32_t cropElemUint32SmallArrayG (smallArrayt *self, int64_t index); 739 char* cropElemSSmallArrayG (smallArrayt *self, int64_t index); 740 smallDictt* cropElemDictSmallArrayG (smallArrayt *self, int64_t index); 741 smallArrayt* cropElemArraySmallArrayG (smallArrayt *self, int64_t index); 742 smallBoolt* cropElemSmallBoolSmallArrayG (smallArrayt *self, int64_t index); 743 smallBytest* cropElemSmallBytesSmallArrayG (smallArrayt *self, int64_t index); 744 smallDoublet* cropElemSmallDoubleSmallArrayG (smallArrayt *self, int64_t index); 745 smallIntt* cropElemSmallIntSmallArrayG (smallArrayt *self, int64_t index); 746 smallJsont* cropElemSmallJsonSmallArrayG (smallArrayt *self, int64_t index); 747 smallStringt* cropElemSmallStringSmallArrayG (smallArrayt *self, int64_t index); 748 void* cropElemVoidSmallArrayG (smallArrayt *self, int64_t index); 749 smallContainert* cropElemSmallContainerSmallArrayG(smallArrayt *self, int64_t index); 750 smallArrayt* copySmallArrayG (smallArrayt *self, int64_t start, int64_t end); 751 smallArrayt* insertSmallArrayG(smallArrayt *self, int64_t index, smallArrayt *toInsert); 752 smallArrayt* insertSmallJsonSmallArrayG (smallArrayt *self, int64_t index, smallJsont *toInsert); 753 smallArrayt* insertNSmashSmallArrayG(smallArrayt *self, int64_t index, smallArrayt *toInsert); 754 smallArrayt* insertNSmashSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *toInsert); 755 smallArrayt* injectSmallArrayG (smallArrayt *self, int64_t index, baset *value); 756 smallArrayt* injectUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value UNUSED); 757 smallArrayt* injectBoolSmallArrayG (smallArrayt *self, int64_t index, bool value); 758 smallArrayt* injectDoubleSmallArrayG (smallArrayt *self, int64_t index, double value); 759 smallArrayt* injectIntSmallArrayG (smallArrayt *self, int64_t index, int64_t value); 760 smallArrayt* injectSSmallArrayG (smallArrayt *self, int64_t index, const char *string); 761 smallArrayt* injectCharSmallArrayG(smallArrayt *self, int64_t index, char c); 762 smallArrayt* injectDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict); 763 smallArrayt* injectArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array); 764 smallArrayt* injectArraycSmallArrayG (smallArrayt *self, int64_t index, char **array); 765 smallArrayt* injectCArraycSmallArrayG (smallArrayt *self, int64_t index, const char **array); 766 smallArrayt* injectVoidSmallArrayG (smallArrayt *self, int64_t index, void *value); 767 smallArrayt* injectSmallBoolSmallArrayG (smallArrayt *self, int64_t index, smallBoolt *value); 768 smallArrayt* injectSmallBytesSmallArrayG (smallArrayt *self, int64_t index, smallBytest *value); 769 smallArrayt* injectSmallDoubleSmallArrayG (smallArrayt *self, int64_t index, smallDoublet *value); 770 smallArrayt* injectSmallIntSmallArrayG (smallArrayt *self, int64_t index, smallIntt *value); 771 smallArrayt* injectSmallJsonSmallArrayG (smallArrayt *self, int64_t index, smallJsont *string); 772 smallArrayt* injectSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string); 773 smallArrayt* injectSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container); 774 smallArrayt* injectNFreeSmallArrayG (smallArrayt *self, int64_t index, baset *value); 775 smallArrayt* injectNFreeUndefinedSmallArrayG(smallArrayt *self, int64_t index, undefinedt *value); 776 smallArrayt* injectNFreeSSmallArrayG (smallArrayt *self, int64_t index, char *string); 777 smallArrayt* injectNFreeDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict); 778 smallArrayt* injectNFreeArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array); 779 smallArrayt* injectNFreeArraycSmallArrayG (smallArrayt *self, int64_t index, char **array); 780 smallArrayt* injectNFreeSmallBoolSmallArrayG (smallArrayt *self, int64_t index, smallBoolt *value); 781 smallArrayt* injectNFreeSmallBytesSmallArrayG (smallArrayt *self, int64_t index, smallBytest *value); 782 smallArrayt* injectNFreeSmallDoubleSmallArrayG (smallArrayt *self, int64_t index, smallDoublet *value); 783 smallArrayt* injectNFreeSmallIntSmallArrayG (smallArrayt *self, int64_t index, smallIntt *value); 784 smallArrayt* injectNFreeSmallJsonSmallArrayG (smallArrayt *self, int64_t index, smallJsont *string); 785 smallArrayt* injectNFreeSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string); 786 smallArrayt* injectNFreeSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container); 787 smallArrayt* delSmallArrayG (smallArrayt *self, int64_t start, int64_t end); 788 smallArrayt* delElemSmallArrayG (smallArrayt *self, int64_t index); 789 smallArrayt* removeSmallArrayG (smallArrayt *self, int64_t start, int64_t end); 790 smallArrayt* removeElemSmallArrayG (smallArrayt *self, int64_t index); 791 smallArrayt* sortSmallArrayG (smallArrayt *self); 792 smallArrayt* sortFSmallArrayG(smallArrayt *self, shCmpt compareFunction); 793 smallArrayt* icSortSmallArrayG (smallArrayt *self); 794 bool equalSmallArrayG (smallArrayt *self, smallArrayt *array); 795 bool equalSmallArraySmallJsonG(smallArrayt *self, smallJsont *array); 796 bool equalSmallArrayArrayG(smallArrayt* self, char ** p2); 797 bool equalSmallArrayCArrayG(smallArrayt* self, const char ** p2); 798 bool equalSmallArrayBaseG(smallArrayt* self, baset* p2); 799 bool icEqualSmallArrayG (smallArrayt *self, smallArrayt *array); 800 bool icEqualSmallArraySmallJsonG(smallArrayt *self, smallJsont *array); 801 bool icEqualSmallArrayArrayG(smallArrayt* self, char ** p2); 802 bool icEqualSmallArrayCArrayG(smallArrayt* self, const char ** p2); 803 bool icEqualSmallArrayBaseG(smallArrayt* self, baset* p2); 804 size_t lenSmallArrayG (smallArrayt *self); 805 smallArrayt* trimSmallArrayG (smallArrayt *self); 806 bool hasSmallArrayG (smallArrayt *self, baset *value); 807 bool hasUndefinedSmallArrayG(smallArrayt *self, undefinedt *value); 808 bool hasBoolSmallArrayG (smallArrayt *self, bool value); 809 bool hasDoubleSmallArrayG (smallArrayt *self, double value); 810 bool hasIntSmallArrayG (smallArrayt *self, int64_t value); 811 bool hasSSmallArrayG (smallArrayt *self, const char *string); 812 bool hasCharSmallArrayG(smallArrayt *self, char c); 813 bool hasDictSmallArrayG (smallArrayt *self, smallDictt *dict); 814 bool hasArraySmallArrayG (smallArrayt *self, smallArrayt *array); 815 bool hasArraycSmallArrayG (smallArrayt *self, char **array); 816 bool hasCArraycSmallArrayG (smallArrayt *self, const char **array); 817 bool hasSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value); 818 bool hasSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value); 819 bool hasSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value); 820 bool hasSmallIntSmallArrayG (smallArrayt *self, smallIntt *value); 821 bool hasSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string); 822 bool hasSmallStringSmallArrayG (smallArrayt *self, smallStringt *string); 823 bool hasSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container); 824 ssize_t indexOfSmallArrayG (smallArrayt *self, baset *value); 825 ssize_t indexOfUndefinedSmallArrayG(smallArrayt *self, undefinedt *value); 826 ssize_t indexOfBoolSmallArrayG (smallArrayt *self, bool value); 827 ssize_t indexOfDoubleSmallArrayG (smallArrayt *self, double value); 828 ssize_t indexOfIntSmallArrayG (smallArrayt *self, int64_t value); 829 ssize_t indexOfSSmallArrayG (smallArrayt *self, const char *string); 830 ssize_t indexOfCharSmallArrayG(smallArrayt *self, char c); 831 ssize_t indexOfDictSmallArrayG (smallArrayt *self, smallDictt *dict); 832 ssize_t indexOfArraySmallArrayG (smallArrayt *self, smallArrayt *array); 833 ssize_t indexOfArraycSmallArrayG (smallArrayt *self, char **array); 834 ssize_t indexOfCArraycSmallArrayG (smallArrayt *self, const char **array); 835 ssize_t indexOfSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value); 836 ssize_t indexOfSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value); 837 ssize_t indexOfSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value); 838 ssize_t indexOfSmallIntSmallArrayG (smallArrayt *self, smallIntt *value); 839 ssize_t indexOfSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string); 840 ssize_t indexOfSmallStringSmallArrayG (smallArrayt *self, smallStringt *string); 841 ssize_t indexOfSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container); 842 ssize_t binarySearchSmallArrayG (smallArrayt *self, baset *value); 843 ssize_t binarySearchUndefinedSmallArrayG(smallArrayt *self, undefinedt *value); 844 ssize_t binarySearchBoolSmallArrayG (smallArrayt *self, bool value); 845 ssize_t binarySearchDoubleSmallArrayG (smallArrayt *self, double value); 846 ssize_t binarySearchIntSmallArrayG (smallArrayt *self, int64_t value); 847 ssize_t binarySearchSSmallArrayG (smallArrayt *self, const char *string); 848 ssize_t binarySearchCharSmallArrayG(smallArrayt *self, char c); 849 ssize_t binarySearchDictSmallArrayG (smallArrayt *self, smallDictt *dict); 850 ssize_t binarySearchArraySmallArrayG (smallArrayt *self, smallArrayt *array); 851 ssize_t binarySearchArraycSmallArrayG (smallArrayt *self, char **array); 852 ssize_t binarySearchCArraycSmallArrayG (smallArrayt *self, const char **array); 853 ssize_t binarySearchSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value); 854 ssize_t binarySearchSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value); 855 ssize_t binarySearchSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value); 856 ssize_t binarySearchSmallIntSmallArrayG (smallArrayt *self, smallIntt *value); 857 ssize_t binarySearchSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string); 858 ssize_t binarySearchSmallStringSmallArrayG (smallArrayt *self, smallStringt *string); 859 ssize_t binarySearchSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container); 860 smallArrayt* uniqSmallArrayG(smallArrayt *self, int dum UNUSED); 861 bool icHasSmallArrayG (smallArrayt *self, baset *value); 862 bool icHasSSmallArrayG (smallArrayt *self, const char *string); 863 bool icHasCharSmallArrayG(smallArrayt *self, char c); 864 bool icHasDictSmallArrayG (smallArrayt *self, smallDictt *dict); 865 bool icHasArraySmallArrayG (smallArrayt *self, smallArrayt *array); 866 bool icHasArraycSmallArrayG (smallArrayt *self, char **array); 867 bool icHasCArraycSmallArrayG (smallArrayt *self, const char **array); 868 bool icHasSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string); 869 bool icHasSmallStringSmallArrayG (smallArrayt *self, smallStringt *string); 870 ssize_t icIndexOfSmallArrayG (smallArrayt *self, baset *value); 871 ssize_t icIndexOfSSmallArrayG (smallArrayt *self, const char *string); 872 ssize_t icIndexOfCharSmallArrayG(smallArrayt *self, char c); 873 ssize_t icIndexOfDictSmallArrayG (smallArrayt *self, smallDictt *dict); 874 ssize_t icIndexOfArraySmallArrayG (smallArrayt *self, smallArrayt *array); 875 ssize_t icIndexOfArraycSmallArrayG (smallArrayt *self, char **array); 876 ssize_t icIndexOfCArraycSmallArrayG (smallArrayt *self, const char **array); 877 ssize_t icIndexOfSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string); 878 ssize_t icIndexOfSmallStringSmallArrayG (smallArrayt *self, smallStringt *string); 879 ssize_t icBinarySearchSmallArrayG (smallArrayt *self, baset *value); 880 ssize_t icBinarySearchSSmallArrayG (smallArrayt *self, const char *string); 881 ssize_t icBinarySearchCharSmallArrayG(smallArrayt *self, char c); 882 ssize_t icBinarySearchDictSmallArrayG (smallArrayt *self, smallDictt *dict); 883 ssize_t icBinarySearchArraySmallArrayG (smallArrayt *self, smallArrayt *array); 884 ssize_t icBinarySearchArraycSmallArrayG (smallArrayt *self, char **array); 885 ssize_t icBinarySearchCArraycSmallArrayG (smallArrayt *self, const char **array); 886 ssize_t icBinarySearchSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string); 887 ssize_t icBinarySearchSmallStringSmallArrayG (smallArrayt *self, smallStringt *string); 888 smallArrayt* icUniqSmallArrayG(smallArrayt *self, int dum UNUSED); 889 smallArrayt* compactSmallArrayG (smallArrayt *self); 890 smallArrayt* emptySmallArrayG (smallArrayt *self); 891 bool isEmptySmallArrayG (smallArrayt *self); 892 bool isBlankSmallArrayG (smallArrayt *self); 893 smallStringt* joinSmallArrayG(smallArrayt *self, const char* delim); 894 smallStringt* joinCharSmallArrayG(smallArrayt *self, char c); 895 smallStringt* joinSmallJsonSmallArrayG (smallArrayt *self, smallJsont* delim); 896 smallStringt* joinSmallStringSmallArrayG(smallArrayt *self, smallStringt* delim); 897 char* joinSSmallArrayG(smallArrayt *self, const char* delim); 898 char* joinCharSSmallArrayG(smallArrayt *self, char c); 899 char* joinSmallJsonSSmallArrayG (smallArrayt *self, smallJsont* delim); 900 char* joinSmallStringSSmallArrayG(smallArrayt *self, smallStringt* delim); 901 smallArrayt* zipSmallArrayG(smallArrayt *self, smallArrayt *array1, smallArrayt *array2); 902 smallArrayt* zipSmallJsonSmallArrayG(smallArrayt *self, smallArrayt *array1, smallJsont *array2); 903 smallArrayt* zipSmallJsonSmallArraySmallArrayG(smallArrayt *self, smallJsont *array1, smallArrayt *array2); 904 smallArrayt* zipSmallJsonSmallJsonSmallArrayG(smallArrayt *self, smallJsont *array1, smallJsont *array2); 905 smallArrayt* zipSmallJsonCharSmallArrayG(smallArrayt *self, smallJsont *array1, char **array2); 906 smallArrayt* zipSmallJsonCCharSmallArrayG(smallArrayt *self, smallJsont *array1, const char **array2); 907 smallArrayt* zipArraySmallArrayG(smallArrayt *self, char** array1, smallArrayt *array2); 908 smallArrayt* zipCArraySmallArrayG(smallArrayt *self, const char** array1, smallArrayt *array2); 909 smallArrayt* zipArraySmallJsonSmallArrayG(smallArrayt *self, char** array1, smallJsont *array2); 910 smallArrayt* zipCArraySmallJsonSmallArrayG(smallArrayt *self, const char** array1, smallJsont *array2); 911 smallArrayt* zipCharSmallArrayG(smallArrayt *self, smallArrayt *array1, char** array2); 912 smallArrayt* zipCCharSmallArrayG(smallArrayt *self, smallArrayt *array1, const char** array2); 913 smallArrayt* zipArrayCharSmallArrayG(smallArrayt *self, char** array1, char** array2); 914 smallArrayt* zipArrayCCharSmallArrayG(smallArrayt *self, char** array1, const char** array2); 915 smallArrayt* zipCArrayCharSmallArrayG(smallArrayt *self, const char** array1, char** array2); 916 smallArrayt* zipCArrayCCharSmallArrayG(smallArrayt *self, const char** array1, const char** array2); 917 void logSmallArrayG(smallArrayt *self); 918 smallArrayt* readTextSmallArrayG (smallArrayt *self, const char *filePath); 919 smallArrayt* readTextSmallJsonSmallArrayG (smallArrayt *self, smallJsont *filePath); 920 smallArrayt* readTextSmallStringSmallArrayG(smallArrayt *self, smallStringt *filePath); 921 smallArrayt* readStreamSmallArrayG (smallArrayt *self, FILE *fp); 922 bool writeTextSmallArrayG (smallArrayt *self, const char *filePath); 923 bool writeTextSmallJsonSmallArrayG (smallArrayt *self, smallJsont *filePath); 924 bool writeTextSmallStringSmallArrayG(smallArrayt *self, smallStringt *filePath); 925 bool writeStreamSmallArrayG (smallArrayt *self, FILE *fp); 926 bool appendTextSmallArrayG(smallArrayt *self, const char *filePath); 927 bool appendTextSmallStringSmallArrayG(smallArrayt *self, smallStringt *filePath); 928 smallStringt* typeSmallStringSmallArrayG(smallArrayt *self, int64_t index); 929 smallArrayt* typeSmallStringsSmallArrayG(smallArrayt *self); 930 931 void initiateSmallArray(smallArrayt *self) { 932 933 self->type = "smallArray"; 934 if (!smallArrayF) { 935 isError(smallArrayF, malloc(sizeof(smallArrayFunctionst))) { 936 self->f = NULL; 937 return; 938 } 939 registerMethodsSmallArray(smallArrayF); 940 } 941 self->f = smallArrayF; 942 943 self->a = NULL; 944 self->iterIndex = -1; 945 self->iterStep = 0; 946 self->iterElement = NULL; 947 self->iterElementDataType = 0; 948 } 949 950 void registerMethodsSmallArray(smallArrayFunctionst *f) { 951 952 f->free = freeSmallArray; 953 f->terminate = terminateSmallArray; 954 f->toString = toStringSmallArray; 955 f->duplicate = duplicateSmallArray; 956 957 f->escape = escapeSmallArray; 958 f->dispose = disposeSmallArray; 959 f->reset = resetSmallArray; 960 f->smash = smashSmallArray; 961 f->finish = finishSmallArray; 962 f->help = helpSmallArray; 963 f->getso = getsoSmallArray; 964 f->setso = setsoSmallArray; 965 f->mirror = mirrorSmallArray; 966 f->get = getAtSmallArray; 967 f->getAtUndefined = getAtUndefinedSmallArray; 968 f->getAtBool = getAtBoolSmallArray; 969 f->getAtBoolP = getAtBoolPSmallArray; 970 f->getAtDouble = getAtDoubleSmallArray; 971 f->getAtDoubleP = getAtDoublePSmallArray; 972 f->getAtInt = getAtIntSmallArray; 973 f->getAtIntP = getAtIntPSmallArray; 974 f->getAtInt32 = getAtInt32SmallArray; 975 f->getAtInt32P = getAtInt32PSmallArray; 976 f->getAtUint = getAtUintSmallArray; 977 f->getAtUintP = getAtUintPSmallArray; 978 f->getAtUint32 = getAtUint32SmallArray; 979 f->getAtUint32P = getAtUint32PSmallArray; 980 f->getAtS = getAtSSmallArray; 981 f->getAtDict = getAtDictSmallArray; 982 f->getAtArray = getAtArraySmallArray; 983 f->getAtSmallBool = getAtSmallBoolSmallArray; 984 f->getAtSmallBytes = getAtSmallBytesSmallArray; 985 f->getAtSmallDouble = getAtSmallDoubleSmallArray; 986 f->getAtSmallInt = getAtSmallIntSmallArray; 987 f->getAtSmallJson = getAtSmallJsonSmallArray; 988 f->getAtSmallString = getAtSmallStringSmallArray; 989 f->getAtVoid = getAtVoidSmallArray; 990 f->getAtSmallContainer = getAtSmallContainerSmallArray; 991 f->getNDup = getAtNDupSmallArray; 992 f->getAtNDupUndefined = getAtNDupUndefinedSmallArray; 993 f->getAtNDupBool = getAtNDupBoolSmallArray; 994 f->getAtNDupDouble = getAtNDupDoubleSmallArray; 995 f->getAtNDupInt = getAtNDupIntSmallArray; 996 f->getAtNDupInt32 = getAtNDupInt32SmallArray; 997 f->getAtNDupUint = getAtNDupUintSmallArray; 998 f->getAtNDupUint32 = getAtNDupUint32SmallArray; 999 f->getAtNDupS = getAtNDupSSmallArray; 1000 f->getAtNDupDict = getAtNDupDictSmallArray; 1001 f->getAtNDupArray = getAtNDupArraySmallArray; 1002 f->getAtNDupSmallBool = getAtNDupSmallBoolSmallArray; 1003 f->getAtNDupSmallBytes = getAtNDupSmallBytesSmallArray; 1004 f->getAtNDupSmallDouble = getAtNDupSmallDoubleSmallArray; 1005 f->getAtNDupSmallInt = getAtNDupSmallIntSmallArray; 1006 f->getAtNDupSmallJson = getAtNDupSmallJsonSmallArray; 1007 f->getAtNDupSmallString = getAtNDupSmallStringSmallArray; 1008 f->getAtNDupVoid = getAtNDupVoidSmallArray; 1009 f->getAtNDupSmallContainer = getAtNDupSmallContainerSmallArray; 1010 f->set = setAtSmallArray; 1011 f->fromArray = fromArraySmallArray; 1012 f->fromCArray = fromCArraySmallArray; 1013 f->fromArrayNFree = fromArrayNFreeSmallArray; 1014 f->push = pushSmallArray; 1015 f->pushUndefined = pushUndefinedSmallArray; 1016 f->pushBool = pushBoolSmallArray; 1017 f->pushDouble = pushDoubleSmallArray; 1018 f->pushInt = pushIntSmallArray; 1019 f->pushS = pushSSmallArray; 1020 f->pushChar = pushCharSmallArray; 1021 f->pushDict = pushDictSmallArray; 1022 f->pushArray = pushArraySmallArray; 1023 f->pushArrayc = pushArraycSmallArray; 1024 f->pushCArrayc = pushCArraycSmallArray; 1025 f->pushSmallBool = pushSmallBoolSmallArray; 1026 f->pushSmallBytes = pushSmallBytesSmallArray; 1027 f->pushSmallDouble = pushSmallDoubleSmallArray; 1028 f->pushSmallInt = pushSmallIntSmallArray; 1029 f->pushSmallJson = pushSmallJsonSmallArray; 1030 f->pushSmallString = pushSmallStringSmallArray; 1031 f->pushSmallContainer = pushSmallContainerSmallArray; 1032 f->pushNFree = pushNFreeSmallArray; 1033 f->pushNFreeUndefined = pushNFreeUndefinedSmallArray; 1034 f->pushNFreeS = pushNFreeSSmallArray; 1035 f->pushNFreeDict = pushNFreeDictSmallArray; 1036 f->pushNFreeArray = pushNFreeArraySmallArray; 1037 f->pushNFreeArrayc = pushNFreeArraycSmallArray; 1038 f->pushNFreeSmallBool = pushNFreeSmallBoolSmallArray; 1039 f->pushNFreeSmallBytes = pushNFreeSmallBytesSmallArray; 1040 f->pushNFreeSmallDouble = pushNFreeSmallDoubleSmallArray; 1041 f->pushNFreeSmallInt = pushNFreeSmallIntSmallArray; 1042 f->pushNFreeSmallJson = pushNFreeSmallJsonSmallArray; 1043 f->pushNFreeSmallString = pushNFreeSmallStringSmallArray; 1044 f->pushNFreeSmallContainer = pushNFreeSmallContainerSmallArray; 1045 f->pushMany = pushManySmallArray; 1046 f->pushManyS = pushManySSmallArray; 1047 f->pushNFreeMany = pushNFreeManySmallArray; 1048 f->pushNFreeManyS = pushNFreeManySSmallArray; 1049 f->pop = popSmallArray; 1050 f->popUndefined = popUndefinedSmallArray; 1051 f->popBool = popBoolSmallArray; 1052 f->popDouble = popDoubleSmallArray; 1053 f->popInt = popIntSmallArray; 1054 f->popInt32 = popInt32SmallArray; 1055 f->popUint = popUintSmallArray; 1056 f->popUint32 = popUint32SmallArray; 1057 f->popS = popSSmallArray; 1058 f->popDict = popDictSmallArray; 1059 f->popArray = popArraySmallArray; 1060 f->popSmallBool = popSmallBoolSmallArray; 1061 f->popSmallBytes = popSmallBytesSmallArray; 1062 f->popSmallDouble = popSmallDoubleSmallArray; 1063 f->popSmallInt = popSmallIntSmallArray; 1064 f->popSmallJson = popSmallJsonSmallArray; 1065 f->popSmallString = popSmallStringSmallArray; 1066 f->popVoid = popVoidSmallArray; 1067 f->popSmallContainer = popSmallContainerSmallArray; 1068 f->popNum = popNumSmallArray; 1069 f->prepend = prependSmallArray; 1070 f->prependUndefined = prependUndefinedSmallArray; 1071 f->prependBool = prependBoolSmallArray; 1072 f->prependDouble = prependDoubleSmallArray; 1073 f->prependInt = prependIntSmallArray; 1074 f->prependS = prependSSmallArray; 1075 f->prependChar = prependCharSmallArray; 1076 f->prependDict = prependDictSmallArray; 1077 f->prependArray = prependArraySmallArray; 1078 f->prependArrayc = prependArraycSmallArray; 1079 f->prependCArrayc = prependCArraycSmallArray; 1080 f->prependSmallBool = prependSmallBoolSmallArray; 1081 f->prependSmallBytes = prependSmallBytesSmallArray; 1082 f->prependSmallDouble = prependSmallDoubleSmallArray; 1083 f->prependSmallInt = prependSmallIntSmallArray; 1084 f->prependSmallJson = prependSmallJsonSmallArray; 1085 f->prependSmallString = prependSmallStringSmallArray; 1086 f->prependSmallContainer = prependSmallContainerSmallArray; 1087 f->prependNFree = prependNFreeSmallArray; 1088 f->prependNFreeUndefined = prependNFreeUndefinedSmallArray; 1089 f->prependNFreeS = prependNFreeSSmallArray; 1090 f->prependNFreeDict = prependNFreeDictSmallArray; 1091 f->prependNFreeArray = prependNFreeArraySmallArray; 1092 f->prependNFreeArrayc = prependNFreeArraycSmallArray; 1093 f->prependNFreeSmallBool = prependNFreeSmallBoolSmallArray; 1094 f->prependNFreeSmallBytes = prependNFreeSmallBytesSmallArray; 1095 f->prependNFreeSmallDouble = prependNFreeSmallDoubleSmallArray; 1096 f->prependNFreeSmallInt = prependNFreeSmallIntSmallArray; 1097 f->prependNFreeSmallJson = prependNFreeSmallJsonSmallArray; 1098 f->prependNFreeSmallString = prependNFreeSmallStringSmallArray; 1099 f->prependNFreeSmallContainer = prependNFreeSmallContainerSmallArray; 1100 f->dequeue = dequeueSmallArray; 1101 f->dequeueUndefined = dequeueUndefinedSmallArray; 1102 f->dequeueBool = dequeueBoolSmallArray; 1103 f->dequeueDouble = dequeueDoubleSmallArray; 1104 f->dequeueInt = dequeueIntSmallArray; 1105 f->dequeueInt32 = dequeueInt32SmallArray; 1106 f->dequeueUint = dequeueUintSmallArray; 1107 f->dequeueUint32 = dequeueUint32SmallArray; 1108 f->dequeueS = dequeueSSmallArray; 1109 f->dequeueDict = dequeueDictSmallArray; 1110 f->dequeueArray = dequeueArraySmallArray; 1111 f->dequeueSmallBool = dequeueSmallBoolSmallArray; 1112 f->dequeueSmallBytes = dequeueSmallBytesSmallArray; 1113 f->dequeueSmallDouble = dequeueSmallDoubleSmallArray; 1114 f->dequeueSmallInt = dequeueSmallIntSmallArray; 1115 f->dequeueSmallJson = dequeueSmallJsonSmallArray; 1116 f->dequeueSmallString = dequeueSmallStringSmallArray; 1117 f->dequeueVoid = dequeueVoidSmallArray; 1118 f->dequeueSmallContainer = dequeueSmallContainerSmallArray; 1119 f->dequeueNum = dequeueNumSmallArray; 1120 f->reverse = reverseSmallArray; 1121 f->cat = catSmallArray; 1122 f->append = appendSmallArray; 1123 f->appendSmallJson = appendSmallJsonSmallArray; 1124 f->appendNSmash = appendNSmashSmallArray; 1125 f->appendNSmashSmallJson = appendNSmashSmallJsonSmallArray; 1126 f->appendArray = appendArraySmallArray; 1127 f->appendCArray = appendCArraySmallArray; 1128 f->appendNSmashArray = appendNSmashArraySmallArray; 1129 f->shift = shiftSmallArray; { 1130 f->shiftSmallJson = shiftSmallJsonSmallArray; { 1131 f->shiftNSmash = shiftNSmashSmallArray; { 1132 f->shiftNSmashSmallJson = shiftNSmashSmallJsonSmallArray; { 1133 f->add = addSmallArray; 1134 f->slice = sliceSmallArray; 1135 f->crop = cropSmallArray; 1136 f->cropElem = cropElemSmallArray; 1137 f->cropElemUndefined = cropElemUndefinedSmallArray; 1138 f->cropElemBool = cropElemBoolSmallArray; 1139 f->cropElemDouble = cropElemDoubleSmallArray; 1140 f->cropElemInt = cropElemIntSmallArray; 1141 f->cropElemInt32 = cropElemInt32SmallArray; 1142 f->cropElemUint = cropElemUintSmallArray; 1143 f->cropElemUint32 = cropElemUint32SmallArray; 1144 f->cropElemS = cropElemSSmallArray; 1145 f->cropElemDict = cropElemDictSmallArray; 1146 f->cropElemArray = cropElemArraySmallArray; 1147 f->cropElemSmallBool = cropElemSmallBoolSmallArray; 1148 f->cropElemSmallBytes = cropElemSmallBytesSmallArray; 1149 f->cropElemSmallDouble = cropElemSmallDoubleSmallArray; 1150 f->cropElemSmallInt = cropElemSmallIntSmallArray; 1151 f->cropElemSmallJson = cropElemSmallJsonSmallArray; 1152 f->cropElemSmallString = cropElemSmallStringSmallArray; 1153 f->cropElemVoid = cropElemVoidSmallArray; 1154 f->cropElemSmallContainer = cropElemSmallContainerSmallArray; 1155 f->copy = copySmallArray; 1156 f->insert = insertSmallArray; 1157 f->insertSmallJson = insertSmallJsonSmallArray; 1158 f->insertNSmash = insertNSmashSmallArray; 1159 f->insertNSmashSmallJson = insertNSmashSmallJsonSmallArray; 1160 f->inject = injectSmallArray; 1161 f->injectUndefined = injectUndefinedSmallArray; 1162 f->injectBool = injectBoolSmallArray; 1163 f->injectDouble = injectDoubleSmallArray; 1164 f->injectInt = injectIntSmallArray; 1165 f->injectS = injectSSmallArray; 1166 f->injectChar = injectCharSmallArray; 1167 f->injectDict = injectDictSmallArray; 1168 f->injectArray = injectArraySmallArray; 1169 f->injectArrayc = injectArraycSmallArray; 1170 f->injectCArrayc = injectCArraycSmallArray; 1171 f->injectSmallBool = injectSmallBoolSmallArray; 1172 f->injectSmallBytes = injectSmallBytesSmallArray; 1173 f->injectSmallDouble = injectSmallDoubleSmallArray; 1174 f->injectSmallInt = injectSmallIntSmallArray; 1175 f->injectSmallJson = injectSmallJsonSmallArray; 1176 f->injectSmallString = injectSmallStringSmallArray; 1177 f->injectSmallContainer = injectSmallContainerSmallArray; 1178 f->injectNFree = injectNFreeSmallArray; 1179 f->injectNFreeUndefined = injectNFreeUndefinedSmallArray; 1180 f->injectNFreeS = injectNFreeSSmallArray; 1181 f->injectNFreeDict = injectNFreeDictSmallArray; 1182 f->injectNFreeArray = injectNFreeArraySmallArray; 1183 f->injectNFreeArrayc = injectNFreeArraycSmallArray; 1184 f->injectNFreeSmallBool = injectNFreeSmallBoolSmallArray; 1185 f->injectNFreeSmallBytes = injectNFreeSmallBytesSmallArray; 1186 f->injectNFreeSmallDouble = injectNFreeSmallDoubleSmallArray; 1187 f->injectNFreeSmallInt = injectNFreeSmallIntSmallArray; 1188 f->injectNFreeSmallJson = injectNFreeSmallJsonSmallArray; 1189 f->injectNFreeSmallString = injectNFreeSmallStringSmallArray; 1190 f->injectNFreeSmallContainer = injectNFreeSmallContainerSmallArray; 1191 f->del = delSmallArray; 1192 f->delElem = delElemSmallArray; 1193 f->remove = removeSmallArray; 1194 f->removeElem = removeElemSmallArray; 1195 f->sort = sortSmallArray; 1196 f->sortF = sortFSmallArray; 1197 f->icSort = icSortSmallArray; 1198 f->equal = equalSmallArray; 1199 f->equalSmallJson = equalSmallArraySmallJson; 1200 f->equalArray = equalSmallArrayArray; 1201 f->equalCArray = equalSmallArrayCArray; 1202 f->equalBase = equalSmallArrayBase; 1203 f->icEqual = icEqualSmallArray; 1204 f->icEqualSmallJson = icEqualSmallArraySmallJson; 1205 f->icEqualArray = icEqualSmallArrayArray; 1206 f->icEqualCArray = icEqualSmallArrayCArray; 1207 f->icEqualBase = icEqualSmallArrayBase; 1208 f->len = lenSmallArray; 1209 f->trim = trimSmallArray; 1210 f->getAt = getAtSmallArray; 1211 f->getAtNDup = getAtNDupSmallArray; 1212 f->setAt = setAtSmallArray; 1213 f->setAtUndefined = setAtUndefinedSmallArray; 1214 f->setAtBool = setAtBoolSmallArray; 1215 f->setAtDouble = setAtDoubleSmallArray; 1216 f->setAtInt = setAtIntSmallArray; 1217 f->setAtS = setAtSSmallArray; 1218 f->setAtChar = setAtCharSmallArray; 1219 f->setAtDict = setAtDictSmallArray; 1220 f->setAtArray = setAtArraySmallArray; 1221 f->setAtArrayc = setAtArraycSmallArray; 1222 f->setAtCArrayc = setAtCArraycSmallArray; 1223 f->setAtSmallBool = setAtSmallBoolSmallArray; 1224 f->setAtSmallBytes = setAtSmallBytesSmallArray; 1225 f->setAtSmallDouble = setAtSmallDoubleSmallArray; 1226 f->setAtSmallInt = setAtSmallIntSmallArray; 1227 f->setAtSmallJson = setAtSmallJsonSmallArray; 1228 f->setAtSmallString = setAtSmallStringSmallArray; 1229 f->setAtSmallContainer = setAtSmallContainerSmallArray; 1230 f->setAtNFree = setAtNFreeSmallArray; 1231 f->setAtNFreeUndefined = setAtNFreeUndefinedSmallArray; 1232 f->setAtNFreeS = setAtNFreeSSmallArray; 1233 f->setAtNFreeDict = setAtNFreeDictSmallArray; 1234 f->setAtNFreeArray = setAtNFreeArraySmallArray; 1235 f->setAtNFreeArrayc = setAtNFreeArraycSmallArray; 1236 f->setAtNFreeSmallBool = setAtNFreeSmallBoolSmallArray; 1237 f->setAtNFreeSmallBytes = setAtNFreeSmallBytesSmallArray; 1238 f->setAtNFreeSmallDouble = setAtNFreeSmallDoubleSmallArray; 1239 f->setAtNFreeSmallInt = setAtNFreeSmallIntSmallArray; 1240 f->setAtNFreeSmallJson = setAtNFreeSmallJsonSmallArray; 1241 f->setAtNFreeSmallString = setAtNFreeSmallStringSmallArray; 1242 f->setAtNFreeSmallContainer = setAtNFreeSmallContainerSmallArray; 1243 f->setPAtDict = setPAtDictSmallArray; 1244 f->setPAtArray = setPAtArraySmallArray; 1245 f->setPAtSmallJson = setPAtSmallJsonSmallArray; 1246 f->setPAtSmallString = setPAtSmallStringSmallArray; 1247 f->setPAtNFreeDict = setPAtNFreeDictSmallArray; 1248 f->setPAtNFreeArray = setPAtNFreeArraySmallArray; 1249 f->setPAtNFreeSmallJson = setPAtNFreeSmallJsonSmallArray; 1250 f->setPAtNFreeSmallString = setPAtNFreeSmallStringSmallArray; 1251 f->getNum = getNumSmallArray; 1252 f->has = hasSmallArray; 1253 f->hasUndefined = hasUndefinedSmallArray; 1254 f->hasBool = hasBoolSmallArray; 1255 f->hasDouble = hasDoubleSmallArray; 1256 f->hasInt = hasIntSmallArray; 1257 f->hasS = hasSSmallArray; 1258 f->hasChar = hasCharSmallArray; 1259 f->hasDict = hasDictSmallArray; 1260 f->hasArray = hasArraySmallArray; 1261 f->hasArrayc = hasArraycSmallArray; 1262 f->hasCArrayc = hasCArraycSmallArray; 1263 f->hasSmallBool = hasSmallBoolSmallArray; 1264 f->hasSmallBytes = hasSmallBytesSmallArray; 1265 f->hasSmallDouble = hasSmallDoubleSmallArray; 1266 f->hasSmallInt = hasSmallIntSmallArray; 1267 f->hasSmallJson = hasSmallJsonSmallArray; 1268 f->hasSmallString = hasSmallStringSmallArray; 1269 f->hasSmallContainer = hasSmallContainerSmallArray; 1270 f->indexOf = indexOfSmallArray; 1271 f->indexOfUndefined = indexOfUndefinedSmallArray; 1272 f->indexOfBool = indexOfBoolSmallArray; 1273 f->indexOfDouble = indexOfDoubleSmallArray; 1274 f->indexOfInt = indexOfIntSmallArray; 1275 f->indexOfS = indexOfSSmallArray; 1276 f->indexOfChar = indexOfCharSmallArray; 1277 f->indexOfDict = indexOfDictSmallArray; 1278 f->indexOfArray = indexOfArraySmallArray; 1279 f->indexOfArrayc = indexOfArraycSmallArray; 1280 f->indexOfCArrayc = indexOfCArraycSmallArray; 1281 f->indexOfSmallBool = indexOfSmallBoolSmallArray; 1282 f->indexOfSmallBytes = indexOfSmallBytesSmallArray; 1283 f->indexOfSmallDouble = indexOfSmallDoubleSmallArray; 1284 f->indexOfSmallInt = indexOfSmallIntSmallArray; 1285 f->indexOfSmallJson = indexOfSmallJsonSmallArray; 1286 f->indexOfSmallString = indexOfSmallStringSmallArray; 1287 f->indexOfSmallContainer = indexOfSmallContainerSmallArray; 1288 f->binarySearch = binarySearchSmallArray; 1289 f->binarySearchUndefined = binarySearchUndefinedSmallArray; 1290 f->binarySearchBool = binarySearchBoolSmallArray; 1291 f->binarySearchDouble = binarySearchDoubleSmallArray; 1292 f->binarySearchInt = binarySearchIntSmallArray; 1293 f->binarySearchS = binarySearchSSmallArray; 1294 f->binarySearchChar = binarySearchCharSmallArray; 1295 f->binarySearchDict = binarySearchDictSmallArray; 1296 f->binarySearchArray = binarySearchArraySmallArray; 1297 f->binarySearchArrayc = binarySearchArraycSmallArray; 1298 f->binarySearchCArrayc = binarySearchCArraycSmallArray; 1299 f->binarySearchSmallBool = binarySearchSmallBoolSmallArray; 1300 f->binarySearchSmallBytes = binarySearchSmallBytesSmallArray; 1301 f->binarySearchSmallDouble = binarySearchSmallDoubleSmallArray; 1302 f->binarySearchSmallInt = binarySearchSmallIntSmallArray; 1303 f->binarySearchSmallJson = binarySearchSmallJsonSmallArray; 1304 f->binarySearchSmallString = binarySearchSmallStringSmallArray; 1305 f->binarySearchSmallContainer = binarySearchSmallContainerSmallArray; 1306 f->uniq = uniqSmallArray; 1307 f->icHas = icHasSmallArray; 1308 f->icHasS = icHasSSmallArray; 1309 f->icHasChar = icHasCharSmallArray; 1310 f->icHasDict = icHasDictSmallArray; 1311 f->icHasArray = icHasArraySmallArray; 1312 f->icHasArrayc = icHasArraycSmallArray; 1313 f->icHasCArrayc = icHasCArraycSmallArray; 1314 f->icHasSmallJson = icHasSmallJsonSmallArray; 1315 f->icHasSmallString = icHasSmallStringSmallArray; 1316 f->icIndexOf = icIndexOfSmallArray; 1317 f->icIndexOfS = icIndexOfSSmallArray; 1318 f->icIndexOfChar = icIndexOfCharSmallArray; 1319 f->icIndexOfDict = icIndexOfDictSmallArray; 1320 f->icIndexOfArray = icIndexOfArraySmallArray; 1321 f->icIndexOfArrayc = icIndexOfArraycSmallArray; 1322 f->icIndexOfCArrayc = icIndexOfCArraycSmallArray; 1323 f->icIndexOfSmallJson = icIndexOfSmallJsonSmallArray; 1324 f->icIndexOfSmallString = icIndexOfSmallStringSmallArray; 1325 f->icBinarySearch = icBinarySearchSmallArray; 1326 f->icBinarySearchS = icBinarySearchSSmallArray; 1327 f->icBinarySearchChar = icBinarySearchCharSmallArray; 1328 f->icBinarySearchDict = icBinarySearchDictSmallArray; 1329 f->icBinarySearchArray = icBinarySearchArraySmallArray; 1330 f->icBinarySearchArrayc = icBinarySearchArraycSmallArray; 1331 f->icBinarySearchCArrayc = icBinarySearchCArraycSmallArray; 1332 f->icBinarySearchSmallJson = icBinarySearchSmallJsonSmallArray; 1333 f->icBinarySearchSmallString = icBinarySearchSmallStringSmallArray; 1334 f->icUniq = icUniqSmallArray; 1335 f->compact = compactSmallArray; 1336 f->empty = emptySmallArray; 1337 f->isEmpty = isEmptySmallArray; 1338 f->isBlank = isBlankSmallArray; 1339 f->forEach = forEachSmallArrayF; { 1340 // cg_c bug 1341 f->enumerate = enumerateSmallArrayF; { 1342 f->iterStart = iterStartSmallArray; 1343 f->iterStartLast = iterStartLastSmallArray; 1344 f->iterStartFrom = iterStartFromSmallArray; 1345 f->iterStartFromStep = iterStartFromStepSmallArray; 1346 f->iterNext = iterNextSmallArray; 1347 f->iterElement = iterElementSmallArray; 1348 f->iterIndex = iterIndexSmallArray; 1349 f->iterStep = iterStepSmallArray; 1350 f->join = joinSmallArray; 1351 f->joinChar = joinCharSmallArray; 1352 f->joinSmallJson = joinSmallJsonSmallArray; 1353 f->joinSmallString = joinSmallStringSmallArray; 1354 f->joinS = joinSSmallArray; 1355 f->joinCharS = joinCharSSmallArray; 1356 f->joinSmallJsonS = joinSmallJsonSSmallArray; 1357 f->joinSmallStringS = joinSmallStringSSmallArray; 1358 f->zip = zipSmallArray; 1359 f->zipSmallJson = zipSmallJsonSmallArray; 1360 f->zipSmallJsonSmallArray = zipSmallJsonSmallArraySmallArray; 1361 f->zipSmallJsonSmallJson = zipSmallJsonSmallJsonSmallArray; 1362 f->zipSmallJsonChar = zipSmallJsonCharSmallArray; 1363 f->zipSmallJsonCChar = zipSmallJsonCCharSmallArray; 1364 f->zipArray = zipArraySmallArray; 1365 f->zipCArray = zipCArraySmallArray; 1366 f->zipArraySmallJson = zipArraySmallJsonSmallArray; 1367 f->zipCArraySmallJson = zipCArraySmallJsonSmallArray; 1368 f->zipChar = zipCharSmallArray; 1369 f->zipCChar = zipCCharSmallArray; 1370 f->zipArrayChar = zipArrayCharSmallArray; 1371 f->zipCArrayChar = zipCArrayCharSmallArray; 1372 f->zipArrayCChar = zipArrayCCharSmallArray; 1373 f->zipCArrayCChar = zipCArrayCCharSmallArray; 1374 f->log = logSmallArray; 1375 f->readText = readTextSmallArray; 1376 f->readTextSmallJson = readTextSmallJsonSmallArray; 1377 f->readTextSmallString = readTextSmallStringSmallArray; 1378 f->readStream = readStreamSmallArray; 1379 f->writeText = writeTextSmallArray; 1380 f->writeTextSmallJson = writeTextSmallJsonSmallArray; 1381 f->writeTextSmallString = writeTextSmallStringSmallArray; 1382 f->writeStream = writeStreamSmallArray; 1383 f->appendText = appendTextSmallArray; 1384 f->appendTextSmallString = appendTextSmallStringSmallArray; 1385 f->typeString = typeStringSmallArray; 1386 f->typeSmallString = typeSmallStringSmallArray; 1387 f->type = typeSmallArray; 1388 f->typeStrings = typeStringsSmallArray; 1389 f->typeSmallStrings = typeSmallStringsSmallArray; 1390 f->types = typesSmallArray; 1391 f->isEType = isETypeSmallArray; 1392 f->isEUndefined = isEUndefinedSmallArray; 1393 f->isEBool = isEBoolSmallArray; 1394 f->isEContainer = isEContainerSmallArray; 1395 f->isEDict = isEDictSmallArray; 1396 f->isEDouble = isEDoubleSmallArray; 1397 f->isEInt = isEIntSmallArray; 1398 f->isEString = isEStringSmallArray; 1399 f->isEFaststring = isEFaststringSmallArray; 1400 f->isEArray = isEArraySmallArray; 1401 f->isEBytes = isEBytesSmallArray; 1402 f->areAllEType = areAllETypeSmallArray; 1403 f->areAllEUndefined = areAllEUndefinedSmallArray; 1404 f->areAllEBool = areAllEBoolSmallArray; 1405 f->areAllEContainer = areAllEContainerSmallArray; 1406 f->areAllEDict = areAllEDictSmallArray; 1407 f->areAllEDouble = areAllEDoubleSmallArray; 1408 f->areAllEInt = areAllEIntSmallArray; 1409 f->areAllEString = areAllEStringSmallArray; 1410 f->areAllEFaststring = areAllEFaststringSmallArray; 1411 f->areAllEArray = areAllEArraySmallArray; 1412 f->areAllEBytes = areAllEBytesSmallArray; 1413 } 1414 } 1415 } 1416 } 1417 } 1418 } 1419 } 1420 1421 void initiateAllocateSmallArray(smallArrayt **self) { 1422 1423 if (self) { 1424 #if (recycleContainers) 1425 initAllocateRecycle(smallArrayt); 1426 #else 1427 isError(*self, malloc(sizeof(smallArrayt))) 1428 return; 1429 #endif 1430 // recycleContainers 1431 if (*self) { 1432 initiateSmallArray(*self); 1433 if (!(*self)->f) { 1434 finishSmallArray(self); 1435 } 1436 } 1437 } 1438 } 1439 1440 smallArrayt* allocSmallArray(void) { 1441 smallArrayt *r = NULL; 1442 1443 initiateAllocateSmallArray(&r); 1444 return(r); 1445 } 1446 1447 smallArrayt* allocArraySmallArray(char **array) { 1448 smallArrayt *r = NULL; 1449 1450 isError(r, allocSmallArray()) return(NULL); 1451 fromArraySmallArray(r, array, 0); 1452 return(r); 1453 } 1454 1455 smallArrayt* allocCArraySmallArray(const char **array) { 1456 smallArrayt *r = NULL; 1457 1458 isError(r, allocSmallArray()) return(NULL); 1459 fromCArraySmallArray(r, array, 0); 1460 return(r); 1461 } 1462 1463 void cleanUpSmallArrayTerminateG(smallArrayt **val) { 1464 1465 terminateO(*val); 1466 } 1467 1468 void cleanUpSmallArrayFreeLocalG(smallArrayt *val) { 1469 1470 freeO(val); 1471 } 1472 1473 void cleanUpSmallArrayFreeG(smallArrayt **val) { 1474 1475 freeO(*val); 1476 } 1477 1478 void cleanUpSmallArrayFinishG(smallArrayt **val) { 1479 1480 finishO(*val); 1481 } 1482 1483 void cleanUpSmallArrayDisposeG(smallArrayt *val) { 1484 1485 disposeO(val); 1486 } 1487 1488 void cleanUpSmallArraySmashG(smallArrayt **val) { 1489 1490 smashO(*val); 1491 } 1492 1493 smallArrayt* createSAF(const char *paramType, ...) { 1494 va_list pl; 1495 smallArrayt *r = NULL; 1496 1497 isError(r, allocSmallArray()) return(NULL); 1498 1499 // push arguments to a list 1500 va_start(pl, paramType); 1501 paramType = va_arg(pl, const char *); 1502 while (paramType) { 1503 pushSSmallArray(r, paramType); 1504 paramType = va_arg(pl, const char *); 1505 } 1506 va_end(pl); 1507 return(r); 1508 } 1509 1510 void finalizeRecycleSmallArray(void *arg UNUSED) { 1511 1512 #if (recycleContainers) 1513 finalizeRecycle 1514 #endif 1515 // recycleContainers 1516 } 1517 1518 void finalizeSmallArray(void) { 1519 1520 if (smallArrayF) { 1521 free(smallArrayF); 1522 smallArrayF = NULL; 1523 } 1524 finalizeRecycleSmallArray(NULL); 1525 } 1526 1527 internal void freeSmallArray(smallArrayt *self) { 1528 1529 sFree((smallt *)self->a); 1530 resetSmallArray(self); 1531 } 1532 1533 internal void terminateSmallArray(smallArrayt **self) { 1534 1535 freeSmallArray(*self); 1536 finishSmallArray(self); 1537 } 1538 1539 1540 internal char* toStringSmallArray(smallArrayt *self) { 1541 1542 if (!self->a) { 1543 return(strdup("[]")); 1544 } 1545 return(sToString((smallt *)self->a)); 1546 } 1547 1548 internal smallArrayt* duplicateSmallArray(smallArrayt *self) { 1549 1550 createAllocateSmallArray(dup); 1551 if (!dup) { 1552 return(NULL); 1553 } 1554 dup->iterElementDataType = self->iterElementDataType; 1555 if (self->a) { 1556 forEachSArray(self->a, o) { 1557 if (o) { 1558 sArrayPushTiny(&(dup->a), sDuplicateTiny(o)); 1559 } 1560 } 1561 1562 dup->iterIndex = self->iterIndex; 1563 dup->iterStep = self->iterStep; 1564 if (dup->iterIndex != -1) { 1565 dup->iterElement = toBaset(sArrayGetTiny(dup->a, (uint32_t)dup->iterIndex)); 1566 } 1567 } 1568 return(dup); 1569 } 1570 1571 internal char* escapeSmallArray(smallArrayt *self) { 1572 1573 if (!self->a) { 1574 return(strdup("[]")); 1575 } 1576 return(sEscape((smallt *)self->a)); 1577 } 1578 1579 internal void disposeSmallArray(smallArrayt *self) { 1580 1581 if (self->a) { 1582 // free containers of baset object to avoid leaks 1583 forEachSArray(self->a, o) { 1584 if (o && o->type == CONTAINER && (((sContainert*)o)->dataType == SH_DT_BASET)) { 1585 free(o); 1586 } 1587 } 1588 free(self->a); 1589 resetSmallArray(self); 1590 } 1591 } 1592 1593 internal void smashSmallArray(smallArrayt **self) { 1594 1595 disposeSmallArray(*self); 1596 finishSmallArray(self); 1597 } 1598 1599 #if (NFreeStackCheck) 1600 internal void finishSmallArray(smallArrayt **self) { 1601 1602 resetSmallArray(*self); 1603 1604 register u64 rsp asm("rsp"); 1605 if ((u64)*self > rsp) { 1606 logW("Probably trying to free a smallArray on stack: "BLD PRIx64 RST" sp: "BLD PRIx64 RST, *self, rsp); 1607 logBtrace; 1608 } 1609 else { 1610 #if (recycleContainers) 1611 finishRecycle 1612 #else 1613 free(*self); 1614 #endif 1615 // recycleContainers 1616 *self = NULL; 1617 } 1618 } 1619 1620 #else 1621 // #if NFreeStackCheck 1622 internal void finishSmallArray(smallArrayt **self) { 1623 1624 resetSmallArray(*self); 1625 1626 #if (recycleContainers) 1627 finishRecycle 1628 #else 1629 free(*self); 1630 #endif 1631 // recycleContainers 1632 *self = NULL; 1633 } 1634 1635 #endif 1636 // #if NFreeStackCheck 1637 1638 internal const char* helpSmallArray(smallArrayt UNUSED *self) { 1639 1640 return(helpTextSmallArray); 1641 } 1642 1643 internal void resetSmallArray(smallArrayt *self) { 1644 1645 if (self->iterIndex != -1) { 1646 if (self->iterElementDataType != SH_DT_BASET) { 1647 finishO(self->iterElement); 1648 } 1649 self->iterElement = NULL; 1650 self->iterIndex = -1; 1651 } 1652 self->a = NULL; 1653 } 1654 1655 internal sArrayt* getsoSmallArray(smallArrayt *self) { 1656 1657 return(self->a); 1658 } 1659 1660 internal void setsoSmallArray(smallArrayt *self, sArrayt *so) { 1661 1662 resetSmallArray(self); 1663 self->a = so; 1664 } 1665 1666 internal smallArrayt* mirrorSmallArray(smallArrayt *self) { 1667 1668 createAllocateSmallArray(mirror); 1669 if (!mirror) { 1670 return(NULL); 1671 } 1672 1673 if (!self->a) { 1674 // empty Array 1675 return(mirror); 1676 } 1677 1678 mirror->a = self->a; 1679 1680 mirror->iterElementDataType = self->iterElementDataType; 1681 mirror->iterIndex = self->iterIndex; 1682 mirror->iterStep = self->iterStep; 1683 if (mirror->iterIndex != -1) { 1684 mirror->iterElement = toBaset(sArrayGetTiny(mirror->a, (uint32_t)mirror->iterIndex)); 1685 } 1686 return(mirror); 1687 } 1688 1689 1690 // size 0 means NULL terminated array 1691 internal smallArrayt* fromArraySmallArray(smallArrayt *self, char **array, size_t size) { 1692 1693 // sanity checks 1694 if (!array) { 1695 return(NULL); 1696 } 1697 1698 freeSmallArray(self); 1699 1700 if (!size) { 1701 forEachCharP(array, e) { 1702 sStringt *s = allocSStringTiny(*e); 1703 if (!s) { 1704 return(NULL); 1705 } 1706 sArrayPushTiny(&(self->a), (smallt *) s); 1707 } 1708 return(self); 1709 } 1710 1711 // copy array content 1712 for (size_t i = 0 ; i < size ; i++) { 1713 if (array[i]) { 1714 // remove NULL strings 1715 sStringt *s = allocSStringTiny(array[i]); 1716 if (!s) { 1717 return(NULL); 1718 } 1719 sArrayPushTiny(&(self->a), (smallt *) s); 1720 } 1721 else { 1722 sArrayPushTiny(&(self->a), NULL); 1723 } 1724 } 1725 1726 return(self); 1727 } 1728 1729 internal smallArrayt* fromCArraySmallArray(smallArrayt *self, const char **array, size_t size) { 1730 1731 // sanity checks 1732 if (!array) { 1733 return(NULL); 1734 } 1735 1736 freeSmallArray(self); 1737 1738 if (!size) { 1739 forEachCCharP(array, e) { 1740 sStringt *s = allocSStringTiny(*e); 1741 if (!s) { 1742 return(NULL); 1743 } 1744 sArrayPushTiny(&(self->a), (smallt *) s); 1745 } 1746 return(self); 1747 } 1748 1749 // copy array content 1750 for (size_t i = 0 ; i < size ; i++) { 1751 if (array[i]) { 1752 // remove NULL strings 1753 sStringt *s = allocSStringTiny(array[i]); 1754 if (!s) { 1755 return(NULL); 1756 } 1757 sArrayPushTiny(&(self->a), (smallt *) s); 1758 } 1759 else { 1760 sArrayPushTiny(&(self->a), NULL); 1761 } 1762 } 1763 1764 return(self); 1765 } 1766 1767 internal smallArrayt* fromArrayNFreeSmallArray(smallArrayt *self, char **array, size_t size) { 1768 1769 smallArrayt *r = fromArraySmallArray(self, array, size); 1770 1771 if (r) { 1772 if (!size) { 1773 listFreeS(array); 1774 } 1775 else { 1776 for (size_t i = 0 ; i < size ; i++) { 1777 free(array[i]); 1778 } 1779 free(array); 1780 } 1781 } 1782 return(r); 1783 } 1784 1785 internal smallArrayt* pushSmallArray(smallArrayt *self, baset *value) { 1786 smallt *o = NULL; 1787 1788 if (!value) { 1789 return(NULL); 1790 } 1791 o = toSmallt(value);; 1792 if (!o) { 1793 return(NULL); 1794 } 1795 sArrayPushTiny(&(self->a), o); 1796 return(self); 1797 } 1798 1799 internal smallArrayt* pushUndefinedSmallArray(smallArrayt *self) { 1800 1801 smallt *o = (smallt *) allocSUndefined(); 1802 if (!o) { 1803 return(NULL); 1804 } 1805 sArrayPushTiny(&(self->a), o); 1806 return(self); 1807 } 1808 1809 internal smallArrayt* pushBoolSmallArray(smallArrayt *self, bool value) { 1810 1811 smallt *o = (smallt *) allocSBool(value); 1812 if (!o) { 1813 return(NULL); 1814 } 1815 sArrayPushTiny(&(self->a), o); 1816 return(self); 1817 } 1818 1819 internal smallArrayt* pushDoubleSmallArray(smallArrayt *self, double value) { 1820 1821 smallt *o = (smallt *) allocSDouble(value); 1822 if (!o) { 1823 return(NULL); 1824 } 1825 sArrayPushTiny(&(self->a), o); 1826 return(self); 1827 } 1828 1829 internal smallArrayt* pushIntSmallArray(smallArrayt *self, int64_t value) { 1830 1831 smallt *o = (smallt *) allocSInt(value); 1832 if (!o) { 1833 return(NULL); 1834 } 1835 sArrayPushTiny(&(self->a), o); 1836 return(self); 1837 } 1838 1839 internal smallArrayt* pushSSmallArray(smallArrayt *self, const char *string) { 1840 1841 smallt *o; 1842 if (!string) { 1843 return(NULL); 1844 } 1845 else { 1846 isError(o, (smallt *) allocSStringTiny(string)) return(NULL); 1847 } 1848 sArrayPushTiny(&(self->a), o); 1849 return(self); 1850 } 1851 1852 internal smallArrayt* pushCharSmallArray(smallArrayt *self, char c) { 1853 1854 charToS(s, c); 1855 return(pushSSmallArray(self, s)); 1856 } 1857 1858 internal smallArrayt* pushDictSmallArray(smallArrayt *self, smallDictt *dict) { 1859 1860 if (checkObjectTypes && dict && !isOSmallDict(dict)) { 1861 return(NULL); 1862 } 1863 1864 if (!dict) { 1865 return(NULL); 1866 } 1867 1868 if (!dict->d) { 1869 isError(dict->d, allocSDict()) return(NULL); 1870 } 1871 1872 sArrayPushTiny(&(self->a), (smallt *)dict->d); 1873 return(self); 1874 } 1875 1876 1877 internal smallArrayt* pushArraySmallArray(smallArrayt *self, smallArrayt *array) { 1878 1879 if (checkObjectTypes && array && !isOSmallArray(array)) { 1880 return(NULL); 1881 } 1882 1883 if (!array) { 1884 return(NULL); 1885 } 1886 1887 if (!array->a) { 1888 // allocate empty array 1889 isError(array->a, allocSArray()) return(NULL); 1890 } 1891 1892 sArrayPushTiny(&(self->a), (smallt *)array->a); 1893 return(self); 1894 } 1895 1896 internal smallArrayt* pushArraycSmallArray(smallArrayt *self, char **array) { 1897 1898 // sanity checks 1899 if (!array) { 1900 return(NULL); 1901 } 1902 1903 sArrayt *a = allocSArray(); 1904 if (!a) { 1905 return(NULL); 1906 } 1907 1908 forEachCharP(array, e) { 1909 sStringt *s = allocSStringTiny(*e); 1910 if (!s) { 1911 return(NULL); 1912 } 1913 sArrayPushTiny(&a, (smallt *) s); 1914 } 1915 sArrayPushTiny(&(self->a), (smallt *) a); 1916 return(self); 1917 } 1918 1919 internal smallArrayt* pushCArraycSmallArray(smallArrayt *self, const char **array) { 1920 1921 // sanity checks 1922 if (!array) { 1923 return(NULL); 1924 } 1925 1926 sArrayt *a = allocSArray(); 1927 if (!a) { 1928 return(NULL); 1929 } 1930 1931 forEachCCharP(array, e) { 1932 sStringt *s = allocSStringTiny(*e); 1933 if (!s) { 1934 return(NULL); 1935 } 1936 sArrayPushTiny(&a, (smallt *) s); 1937 } 1938 sArrayPushTiny(&(self->a), (smallt *) a); 1939 return(self); 1940 } 1941 1942 internal smallArrayt* pushSmallBoolSmallArray(smallArrayt *self, smallBoolt *value) { 1943 1944 if (checkObjectTypes && value && !isOSmallBool(value)) { 1945 return(NULL); 1946 } 1947 1948 if (!value) { 1949 return(NULL); 1950 } 1951 1952 if (!value->value) { 1953 isError(value->value, allocSBool(false)) return(NULL); 1954 } 1955 sArrayPushTiny(&(self->a), (smallt *) value->value); 1956 return(self); 1957 } 1958 1959 internal smallArrayt* pushSmallBytesSmallArray(smallArrayt *self, smallBytest *value) { 1960 1961 if (checkObjectTypes && value && !isOSmallBytes(value)) { 1962 return(NULL); 1963 } 1964 1965 if (!value) { 1966 return(NULL); 1967 } 1968 1969 if (!value->B) { 1970 isError(value->B, allocSBytes()) return(NULL); 1971 } 1972 sArrayPushTiny(&(self->a), (smallt*) value->B); 1973 return(self); 1974 } 1975 1976 internal smallArrayt* pushSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value) { 1977 1978 if (checkObjectTypes && value && !isOSmallDouble(value)) { 1979 return(NULL); 1980 } 1981 1982 if (!value) { 1983 return(NULL); 1984 } 1985 1986 if (!value->value) { 1987 isError(value->value, allocSDouble(0)) return(NULL); 1988 } 1989 sArrayPushTiny(&(self->a), (smallt *) value->value); 1990 return(self); 1991 } 1992 1993 internal smallArrayt* pushSmallIntSmallArray(smallArrayt *self, smallIntt *value) { 1994 1995 if (checkObjectTypes && value && !isOSmallInt(value)) { 1996 return(NULL); 1997 } 1998 1999 if (!value) { 2000 return(NULL); 2001 } 2002 2003 if (!value->value) { 2004 isError(value->value, allocSInt(0)) return(NULL); 2005 } 2006 sArrayPushTiny(&(self->a), (smallt *) value->value); 2007 return(self); 2008 } 2009 2010 internal smallArrayt* pushSmallJsonSmallArray(smallArrayt *self, smallJsont *value) { 2011 2012 if (checkObjectTypes && value && !isOSmallJson(value)) { 2013 return(NULL); 2014 } 2015 2016 if (!value) { 2017 return(NULL); 2018 } 2019 2020 smallt *o = getsoO(value); 2021 if (!o) { 2022 // smallJson is empty, create an empty dict 2023 isError(o, (smallt*)allocSDict()) return(NULL); 2024 setsoO(value, o); 2025 } 2026 2027 sArrayPushTiny(&(self->a), o); 2028 return(self); 2029 } 2030 2031 internal smallArrayt* pushSmallStringSmallArray(smallArrayt *self, smallStringt *string) { 2032 2033 if (checkObjectTypes && string && !isOSmallString(string)) { 2034 return(NULL); 2035 } 2036 2037 if (!string) { 2038 return(NULL); 2039 } 2040 2041 if (!string->data) { 2042 isError(string->data, allocSStringTiny("")) return(NULL); 2043 } 2044 sArrayPushTiny(&(self->a), (smallt*) string->data); 2045 return(self); 2046 } 2047 2048 internal smallArrayt* pushSmallContainerSmallArray(smallArrayt *self, smallContainert *container) { 2049 2050 if (checkObjectTypes && container && !isOSmallContainer(container)) { 2051 return(NULL); 2052 } 2053 2054 if (!container) { 2055 return(NULL); 2056 } 2057 2058 if (!container->data) { 2059 isError(container->data, allocSContainer(NULL)) return(NULL); 2060 } 2061 sArrayPushTiny(&(self->a), (smallt *) container->data); 2062 return(self); 2063 } 2064 2065 2066 internal smallArrayt* pushNFreeSmallArray(smallArrayt *self, baset *value) { 2067 smallt *o = NULL; 2068 2069 if (!value) { 2070 return(NULL); 2071 } 2072 o = toSmallt(value);; 2073 if (!o) { 2074 return(NULL); 2075 } 2076 sArrayPushTiny(&(self->a), o); 2077 2078 if (!(o->type == CONTAINER && (((sContainert*)o)->dataType == SH_DT_BASET))) { 2079 finishO(value); 2080 } 2081 return(self); 2082 } 2083 2084 internal smallArrayt* pushNFreeUndefinedSmallArray(smallArrayt *self, undefinedt *u) { 2085 2086 smallArrayt *r = pushUndefinedSmallArray(self);; 2087 if (r) { 2088 terminateO(u); 2089 } 2090 return(r); 2091 } 2092 2093 internal smallArrayt* pushNFreeSSmallArray(smallArrayt *self, char *string) { 2094 2095 smallArrayt *r = pushSSmallArray(self, string); 2096 if (r) { 2097 free(string); 2098 } 2099 return(r); 2100 } 2101 2102 internal smallArrayt* pushNFreeDictSmallArray(smallArrayt *self, smallDictt *dict) { 2103 2104 smallArrayt *r = pushDictSmallArray(self, dict); 2105 if (r) { 2106 finishO(dict); 2107 } 2108 return(r); 2109 } 2110 2111 internal smallArrayt* pushNFreeArraySmallArray(smallArrayt *self, smallArrayt *array) { 2112 2113 smallArrayt *r = pushArraySmallArray(self, array); 2114 if (r) { 2115 finishO(array); 2116 } 2117 return(r); 2118 } 2119 2120 internal smallArrayt* pushNFreeArraycSmallArray(smallArrayt *self, char **array) { 2121 2122 smallArrayt *r = pushArraycSmallArray(self, array); 2123 if (r) { 2124 listFreeS(array); 2125 } 2126 return(r); 2127 } 2128 2129 internal smallArrayt* pushNFreeSmallBoolSmallArray(smallArrayt *self, smallBoolt *value) { 2130 2131 smallArrayt *r = pushSmallBoolSmallArray(self, value); 2132 if (r) { 2133 finishO(value); 2134 } 2135 return(r); 2136 } 2137 2138 internal smallArrayt* pushNFreeSmallBytesSmallArray(smallArrayt *self, smallBytest *value) { 2139 2140 smallArrayt *r = pushSmallBytesSmallArray(self, value); 2141 if (r) { 2142 finishO(value); 2143 } 2144 return(r); 2145 } 2146 2147 internal smallArrayt* pushNFreeSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value) { 2148 2149 smallArrayt *r = pushSmallDoubleSmallArray(self, value); 2150 if (r) { 2151 finishO(value); 2152 } 2153 return(r); 2154 } 2155 2156 internal smallArrayt* pushNFreeSmallIntSmallArray(smallArrayt *self, smallIntt *value) { 2157 2158 smallArrayt *r = pushSmallIntSmallArray(self, value); 2159 if (r) { 2160 finishO(value); 2161 } 2162 return(r); 2163 } 2164 2165 internal smallArrayt* pushNFreeSmallJsonSmallArray(smallArrayt *self, smallJsont *value) { 2166 2167 smallArrayt *r = pushSmallJsonSmallArray(self, value); 2168 if (r) { 2169 finishO(value); 2170 } 2171 return(r); 2172 } 2173 2174 internal smallArrayt* pushNFreeSmallStringSmallArray(smallArrayt *self, smallStringt *string) { 2175 2176 smallArrayt *r = pushSmallStringSmallArray(self, string); 2177 if (r) { 2178 finishO(string); 2179 } 2180 return(r); 2181 } 2182 2183 internal smallArrayt* pushNFreeSmallContainerSmallArray(smallArrayt *self, smallContainert *container) { 2184 2185 smallArrayt *r = pushSmallContainerSmallArray(self, container); 2186 if (r) { 2187 finishO(container); 2188 } 2189 return(r); 2190 } 2191 2192 internal smallArrayt* pushManySmallArray(smallArrayt *self, ...) { 2193 va_list pl; 2194 baset *paramType = NULL; 2195 2196 // add arguments to a list 2197 va_start(pl, self); 2198 paramType = va_arg(pl, baset*); 2199 while (paramType) { 2200 smallArrayt *r = pushSmallArray(self, paramType);; 2201 if (!r) { 2202 va_end(pl); 2203 return(NULL); 2204 } 2205 paramType = va_arg(pl, baset*); 2206 } 2207 va_end(pl); 2208 return(self); 2209 } 2210 2211 internal smallArrayt* pushManySSmallArray(smallArrayt *self, ...) { 2212 va_list pl; 2213 char *paramType = NULL; 2214 2215 // add arguments to a list 2216 va_start(pl, self); 2217 paramType = va_arg(pl, char*); 2218 while (paramType) { 2219 smallArrayt *r = pushSSmallArray(self, paramType);; 2220 if (!r) { 2221 va_end(pl); 2222 return(NULL); 2223 } 2224 paramType = va_arg(pl, char*); 2225 } 2226 va_end(pl); 2227 return(self); 2228 } 2229 2230 internal smallArrayt* pushNFreeManySmallArray(smallArrayt *self, ...) { 2231 va_list pl; 2232 baset *paramType = NULL; 2233 2234 // add arguments to a list 2235 va_start(pl, self); 2236 paramType = va_arg(pl, baset*); 2237 while (paramType) { 2238 smallArrayt *r = pushNFreeSmallArray(self, paramType);; 2239 if (!r) { 2240 va_end(pl); 2241 return(NULL); 2242 } 2243 paramType = va_arg(pl, baset*); 2244 } 2245 va_end(pl); 2246 return(self); 2247 } 2248 2249 internal smallArrayt* pushNFreeManySSmallArray(smallArrayt *self, ...) { 2250 va_list pl; 2251 char *paramType = NULL; 2252 2253 // add arguments to a list 2254 va_start(pl, self); 2255 paramType = va_arg(pl, char*); 2256 while (paramType) { 2257 smallArrayt *r = pushNFreeSSmallArray(self, paramType);; 2258 if (!r) { 2259 va_end(pl); 2260 return(NULL); 2261 } 2262 paramType = va_arg(pl, char*); 2263 } 2264 va_end(pl); 2265 return(self); 2266 } 2267 2268 2269 internal baset* popSmallArray(smallArrayt *self) { 2270 size_t len; 2271 smallt *o = NULL; 2272 2273 len = lenSmallArray(self); 2274 if (!len) { 2275 return(NULL); 2276 } 2277 2278 for (size_t i = len ; i != 0 ; i--) { 2279 o = sArrayPopTiny(self->a); 2280 if (o) { 2281 break; 2282 } 2283 } 2284 2285 if (!o) { 2286 return(NULL); 2287 } 2288 2289 if (o->type == UNDEFINED) { 2290 free(o); 2291 return((baset*) allocUndefined()); 2292 } 2293 else if (o->type == CONTAINER) { 2294 cast(sContainert*, sc, o); 2295 if (sc->dataType == SH_DT_BASET) { 2296 // baset object in stored in the container, free the container since 2297 // it was allocated automatically in the toSmallt function in libsheepyObject.c 2298 baset *r = toBaset(o); 2299 free(o); 2300 return(r); 2301 } 2302 } 2303 return(toBaset(o)); 2304 } 2305 2306 internal undefinedt* popUndefinedSmallArray(smallArrayt *self) { 2307 size_t len; 2308 smallt *o = NULL; 2309 2310 len = lenSmallArray(self); 2311 if (!len) { 2312 return(NULL); 2313 } 2314 2315 for (size_t i = len ; i != 0 ; i--) { 2316 o = sArrayGetTiny(self->a, self->a->count -1); 2317 if (o) { 2318 break; 2319 } 2320 self->a->count--; 2321 } 2322 2323 if (!o) { 2324 return(NULL); 2325 } 2326 2327 if (o->type != UNDEFINED) { 2328 return(NULL); 2329 } 2330 2331 // finish poping 2332 free(o); 2333 self->a->count--; 2334 return(allocUndefined()); 2335 } 2336 2337 internal bool popBoolSmallArray(smallArrayt *self) { 2338 smallBoolt *e = NULL; 2339 bool r = false;; 2340 2341 e = popSmallBoolSmallArray(self); 2342 if (e) { 2343 r = e->f->get(e); 2344 terminateO(e); 2345 } 2346 return(r); 2347 } 2348 2349 internal double popDoubleSmallArray(smallArrayt *self) { 2350 smallDoublet *e = NULL; 2351 double r = 0;; 2352 2353 e = popSmallDoubleSmallArray(self); 2354 if (e) { 2355 r = e->f->get(e); 2356 terminateO(e); 2357 } 2358 return(r); 2359 } 2360 2361 internal int64_t popIntSmallArray(smallArrayt *self) { 2362 smallIntt *e = NULL; 2363 int64_t r = 0;; 2364 2365 e = popSmallIntSmallArray(self); 2366 if (e) { 2367 r = e->f->get(e); 2368 terminateO(e); 2369 } 2370 return(r); 2371 } 2372 2373 internal int32_t popInt32SmallArray(smallArrayt *self) { 2374 smallIntt *e = NULL; 2375 int32_t r = 0;; 2376 2377 e = popSmallIntSmallArray(self); 2378 if (e) { 2379 r = (int32_t)e->f->get(e); 2380 terminateO(e); 2381 } 2382 return(r); 2383 } 2384 2385 internal uint64_t popUintSmallArray(smallArrayt *self) { 2386 smallIntt *e = NULL; 2387 uint64_t r = 0;; 2388 2389 e = popSmallIntSmallArray(self); 2390 if (e) { 2391 r = (uint64_t)e->f->get(e); 2392 terminateO(e); 2393 } 2394 return(r); 2395 } 2396 2397 internal uint32_t popUint32SmallArray(smallArrayt *self) { 2398 smallIntt *e = NULL; 2399 uint32_t r = 0;; 2400 2401 e = popSmallIntSmallArray(self); 2402 if (e) { 2403 r = (uint32_t)e->f->get(e); 2404 terminateO(e); 2405 } 2406 return(r); 2407 } 2408 2409 internal char* popSSmallArray(smallArrayt *self) { 2410 smallStringt *e = NULL; 2411 char* r = NULL; 2412 2413 e = popSmallStringSmallArray(self); 2414 if (e) { 2415 r = e->f->toString(e); 2416 terminateO(e); 2417 } 2418 return(r); 2419 } 2420 2421 internal smallDictt* popDictSmallArray(smallArrayt *self) { 2422 size_t len; 2423 smallt *o = NULL; 2424 2425 len = lenSmallArray(self); 2426 if (!len) { 2427 return(NULL); 2428 } 2429 2430 for (size_t i = len ; i != 0 ; i--) { 2431 o = sArrayGetTiny(self->a, self->a->count -1); 2432 if (o) { 2433 break; 2434 } 2435 self->a->count--; 2436 } 2437 2438 if (!o) { 2439 return(NULL); 2440 } 2441 2442 if (o->type != DICT) { 2443 return(NULL); 2444 } 2445 2446 // finish poping 2447 self->a->count--; 2448 return((smallDictt*)toBaset(o)); 2449 } 2450 2451 internal smallArrayt* popArraySmallArray(smallArrayt *self) { 2452 size_t len; 2453 smallt *o = NULL; 2454 2455 len = lenSmallArray(self); 2456 if (!len) { 2457 return(NULL); 2458 } 2459 2460 for (size_t i = len ; i != 0 ; i--) { 2461 o = sArrayGetTiny(self->a, self->a->count -1); 2462 if (o) { 2463 break; 2464 } 2465 self->a->count--; 2466 } 2467 2468 if (!o) { 2469 return(NULL); 2470 } 2471 2472 if (o->type != ARRAY) { 2473 return(NULL); 2474 } 2475 2476 // finish poping 2477 self->a->count--; 2478 return((smallArrayt*)toBaset(o)); 2479 } 2480 2481 internal smallBoolt* popSmallBoolSmallArray(smallArrayt *self) { 2482 size_t len; 2483 smallt *o = NULL; 2484 2485 len = lenSmallArray(self); 2486 if (!len) { 2487 return(NULL); 2488 } 2489 2490 for (size_t i = len ; i != 0 ; i--) { 2491 o = sArrayGetTiny(self->a, self->a->count -1); 2492 if (o) { 2493 break; 2494 } 2495 self->a->count--; 2496 } 2497 2498 if (!o) { 2499 return(NULL); 2500 } 2501 2502 if (o->type != BOOL) { 2503 return(NULL); 2504 } 2505 2506 // finish poping 2507 self->a->count--; 2508 return((smallBoolt*)toBaset(o)); 2509 } 2510 2511 internal smallBytest* popSmallBytesSmallArray(smallArrayt *self) { 2512 size_t len; 2513 smallt *o = NULL; 2514 2515 len = lenSmallArray(self); 2516 if (!len) { 2517 return(NULL); 2518 } 2519 2520 for (size_t i = len ; i != 0 ; i--) { 2521 o = sArrayGetTiny(self->a, self->a->count -1); 2522 if (o) { 2523 break; 2524 } 2525 self->a->count--; 2526 } 2527 2528 if (!o) { 2529 return(NULL); 2530 } 2531 2532 if (o->type != BYTES) { 2533 return(NULL); 2534 } 2535 2536 // finish poping 2537 self->a->count--; 2538 return((smallBytest*)toBaset(o)); 2539 } 2540 2541 internal smallDoublet* popSmallDoubleSmallArray(smallArrayt *self) { 2542 size_t len; 2543 smallt *o = NULL; 2544 2545 len = lenSmallArray(self); 2546 if (!len) { 2547 return(NULL); 2548 } 2549 2550 for (size_t i = len ; i != 0 ; i--) { 2551 o = sArrayGetTiny(self->a, self->a->count -1); 2552 if (o) { 2553 break; 2554 } 2555 self->a->count--; 2556 } 2557 2558 if (!o) { 2559 return(NULL); 2560 } 2561 2562 if (o->type != DOUBLE) { 2563 return(NULL); 2564 } 2565 2566 // finish poping 2567 self->a->count--; 2568 return((smallDoublet*)toBaset(o)); 2569 } 2570 2571 internal smallIntt* popSmallIntSmallArray(smallArrayt *self) { 2572 size_t len; 2573 smallt *o = NULL; 2574 2575 len = lenSmallArray(self); 2576 if (!len) { 2577 return(NULL); 2578 } 2579 2580 for (size_t i = len ; i != 0 ; i--) { 2581 o = sArrayGetTiny(self->a, self->a->count -1); 2582 if (o) { 2583 break; 2584 } 2585 self->a->count--; 2586 } 2587 2588 if (!o) { 2589 return(NULL); 2590 } 2591 2592 if (o->type != INT) { 2593 return(NULL); 2594 } 2595 2596 // finish poping 2597 self->a->count--; 2598 return((smallIntt*)toBaset(o)); 2599 } 2600 2601 internal smallJsont* popSmallJsonSmallArray(smallArrayt *self) { 2602 size_t len; 2603 smallt *o = NULL; 2604 2605 len = lenSmallArray(self); 2606 if (!len) { 2607 return(NULL); 2608 } 2609 2610 for (size_t i = len ; i != 0 ; i--) { 2611 o = sArrayGetTiny(self->a, self->a->count -1); 2612 if (o) { 2613 break; 2614 } 2615 self->a->count--; 2616 } 2617 2618 if (!o) { 2619 return(NULL); 2620 } 2621 2622 if ((o->type == BYTES) || (o->type == CONTAINER)) { 2623 return(NULL); 2624 } 2625 2626 // finish poping 2627 self->a->count--; 2628 2629 baset *e = toBaset(o); 2630 2631 createAllocateSmallJson(r); 2632 if (!r) { 2633 return(NULL); 2634 } 2635 setTopNFreeO(r, e); 2636 return(r); 2637 } 2638 2639 internal smallStringt* popSmallStringSmallArray(smallArrayt *self) { 2640 size_t len; 2641 smallt *o = NULL; 2642 2643 len = lenSmallArray(self); 2644 if (!len) { 2645 return(NULL); 2646 } 2647 2648 for (size_t i = len ; i != 0 ; i--) { 2649 o = sArrayGetTiny(self->a, self->a->count -1); 2650 if (o) { 2651 break; 2652 } 2653 self->a->count--; 2654 } 2655 2656 if (!o) { 2657 return(NULL); 2658 } 2659 2660 if (o->type != STRING) { 2661 return(NULL); 2662 } 2663 2664 // finish poping 2665 self->a->count--; 2666 return((smallStringt*)toBaset(o)); 2667 } 2668 2669 internal void* popVoidSmallArray(smallArrayt *self) { 2670 smallContainert *e = NULL; 2671 void* r = NULL; 2672 2673 e = popSmallContainerSmallArray(self); 2674 if (e) { 2675 r = e->f->get(e); 2676 smashO(e); 2677 } 2678 return(r); 2679 } 2680 2681 internal smallContainert* popSmallContainerSmallArray(smallArrayt *self) { 2682 size_t len; 2683 smallt *o = NULL; 2684 2685 len = lenSmallArray(self); 2686 if (!len) { 2687 return(NULL); 2688 } 2689 2690 for (size_t i = len ; i != 0 ; i--) { 2691 o = sArrayGetTiny(self->a, self->a->count -1); 2692 if (o) { 2693 break; 2694 } 2695 self->a->count--; 2696 } 2697 2698 if (!o) { 2699 return(NULL); 2700 } 2701 2702 if (o->type != CONTAINER) { 2703 return(NULL); 2704 } 2705 2706 if (((sContainert*)o)->dataType == SH_DT_BASET) { 2707 return(NULL); 2708 } 2709 2710 // finish poping 2711 self->a->count--; 2712 return((smallContainert*)toBaset(o)); 2713 } 2714 2715 internal double popNumSmallArray(smallArrayt *self) { 2716 size_t len; 2717 smallt *o = NULL; 2718 2719 len = lenSmallArray(self); 2720 if (!len) { 2721 return(0); 2722 } 2723 2724 for (size_t i = len ; i != 0 ; i--) { 2725 o = sArrayGetTiny(self->a, self->a->count -1); 2726 if (o) { 2727 break; 2728 } 2729 self->a->count--; 2730 } 2731 2732 if (!o) { 2733 return(0); 2734 } 2735 2736 if (o->type != INT && o->type != DOUBLE) { 2737 return(0); 2738 } 2739 2740 baset *e = toBaset(o); 2741 2742 // finish poping 2743 self->a->count--; 2744 2745 double r = 0; 2746 if (isOSmallDouble(e)) { 2747 r = getValO((smallDoublet*)e); 2748 } 2749 elif (isOSmallInt(e)) { 2750 r = (double)getValO((smallIntt*)e); 2751 } 2752 terminateO(e); 2753 return(r); 2754 } 2755 2756 internal smallArrayt* prependSmallArray(smallArrayt *self, baset *value) { 2757 smallt *o = NULL; 2758 2759 if (!value) { 2760 return(NULL); 2761 } 2762 2763 o = toSmallt(value);; 2764 if (!o) { 2765 return(NULL); 2766 } 2767 sArrayPrependTiny(&(self->a), o); 2768 return(self); 2769 } 2770 2771 internal smallArrayt* prependUndefinedSmallArray(smallArrayt *self) { 2772 2773 smallt *o = (smallt *) allocSUndefined(); 2774 if (!o) { 2775 return(NULL); 2776 } 2777 sArrayPrependTiny(&(self->a), o); 2778 return(self); 2779 } 2780 2781 internal smallArrayt* prependBoolSmallArray(smallArrayt *self, bool value) { 2782 2783 smallt *o = (smallt *) allocSBool(value); 2784 if (!o) { 2785 return(NULL); 2786 } 2787 sArrayPrependTiny(&(self->a), o); 2788 return(self); 2789 } 2790 2791 internal smallArrayt* prependDoubleSmallArray(smallArrayt *self, double value) { 2792 2793 smallt *o = (smallt *) allocSDouble(value); 2794 if (!o) { 2795 return(NULL); 2796 } 2797 sArrayPrependTiny(&(self->a), o); 2798 return(self); 2799 } 2800 2801 internal smallArrayt* prependIntSmallArray(smallArrayt *self, int64_t value) { 2802 2803 smallt *o = (smallt *) allocSInt(value); 2804 if (!o) { 2805 return(NULL); 2806 } 2807 sArrayPrependTiny(&(self->a), o); 2808 return(self); 2809 } 2810 2811 internal smallArrayt* prependSSmallArray(smallArrayt *self, const char *string) { 2812 2813 smallt *o; 2814 if (!string) { 2815 return(NULL); 2816 } 2817 else { 2818 isError(o, (smallt *) allocSStringTiny(string)) return(NULL); 2819 } 2820 sArrayPrependTiny(&(self->a), o); 2821 return(self); 2822 } 2823 2824 internal smallArrayt* prependCharSmallArray(smallArrayt *self, char c) { 2825 2826 charToS(s, c); 2827 return(prependSSmallArray(self, s)); 2828 } 2829 2830 internal smallArrayt* prependDictSmallArray(smallArrayt *self, smallDictt *dict) { 2831 2832 if (checkObjectTypes && dict && !isOSmallDict(dict)) { 2833 return(NULL); 2834 } 2835 2836 if (!dict) { 2837 return(NULL); 2838 } 2839 2840 if (!dict->d) { 2841 isError(dict->d, allocSDict()) return(NULL); 2842 } 2843 2844 sArrayPrependTiny(&(self->a), (smallt *)dict->d); 2845 return(self); 2846 } 2847 2848 2849 internal smallArrayt* prependArraySmallArray(smallArrayt *self, smallArrayt *array) { 2850 2851 if (checkObjectTypes && array && !isOSmallArray(array)) { 2852 return(NULL); 2853 } 2854 2855 if (!array) { 2856 return(NULL); 2857 } 2858 2859 if (!array->a) { 2860 // allocate empty array 2861 isError(array->a, allocSArray()) return(NULL); 2862 } 2863 2864 sArrayPrependTiny(&(self->a), (smallt *)array->a); 2865 return(self); 2866 } 2867 2868 internal smallArrayt* prependArraycSmallArray(smallArrayt *self, char **array) { 2869 2870 if (!array) { 2871 return(NULL); 2872 } 2873 2874 sArrayt *a = allocSArray(); 2875 if (!a) { 2876 return(NULL); 2877 } 2878 2879 forEachCharP(array, e) { 2880 sStringt *s = allocSStringTiny(*e); 2881 if (!s) { 2882 return(NULL); 2883 } 2884 sArrayPushTiny(&a, (smallt *) s); 2885 } 2886 sArrayPrependTiny(&(self->a), (smallt *) a); 2887 return(self); 2888 } 2889 2890 internal smallArrayt* prependCArraycSmallArray(smallArrayt *self, const char **array) { 2891 2892 if (!array) { 2893 return(NULL); 2894 } 2895 2896 sArrayt *a = allocSArray(); 2897 if (!a) { 2898 return(NULL); 2899 } 2900 2901 forEachCCharP(array, e) { 2902 sStringt *s = allocSStringTiny(*e); 2903 if (!s) { 2904 return(NULL); 2905 } 2906 sArrayPushTiny(&a, (smallt *) s); 2907 } 2908 sArrayPrependTiny(&(self->a), (smallt *) a); 2909 return(self); 2910 } 2911 2912 internal smallArrayt* prependSmallBoolSmallArray(smallArrayt *self, smallBoolt *value) { 2913 2914 if (checkObjectTypes && value && !isOSmallBool(value)) { 2915 return(NULL); 2916 } 2917 2918 if (!value) { 2919 return(NULL); 2920 } 2921 2922 if (!value->value) { 2923 isError(value->value, allocSBool(false)) return(NULL); 2924 } 2925 sArrayPrependTiny(&(self->a), (smallt *) value->value); 2926 return(self); 2927 } 2928 2929 internal smallArrayt* prependSmallBytesSmallArray(smallArrayt *self, smallBytest *value) { 2930 2931 if (checkObjectTypes && value && !isOSmallBytes(value)) { 2932 return(NULL); 2933 } 2934 2935 if (!value) { 2936 return(NULL); 2937 } 2938 2939 if (!value->B) { 2940 isError(value->B, allocSBytes()) return(NULL); 2941 } 2942 sArrayPrependTiny(&(self->a), (smallt *) value->B); 2943 return(self); 2944 } 2945 2946 internal smallArrayt* prependSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value) { 2947 2948 if (checkObjectTypes && value && !isOSmallDouble(value)) { 2949 return(NULL); 2950 } 2951 2952 if (!value) { 2953 return(NULL); 2954 } 2955 2956 if (!value->value) { 2957 isError(value->value, allocSDouble(0)) return(NULL); 2958 } 2959 sArrayPrependTiny(&(self->a), (smallt *) value->value); 2960 return(self); 2961 } 2962 2963 internal smallArrayt* prependSmallIntSmallArray(smallArrayt *self, smallIntt *value) { 2964 2965 if (checkObjectTypes && value && !isOSmallInt(value)) { 2966 return(NULL); 2967 } 2968 2969 if (!value) { 2970 return(NULL); 2971 } 2972 2973 if (!value->value) { 2974 isError(value->value, allocSInt(0)) return(NULL); 2975 } 2976 sArrayPrependTiny(&(self->a), (smallt *) value->value); 2977 return(self); 2978 } 2979 2980 internal smallArrayt* prependSmallJsonSmallArray(smallArrayt *self, smallJsont *json) { 2981 2982 if (checkObjectTypes && json && !isOSmallJson(json)) { 2983 return(NULL); 2984 } 2985 2986 if (!json) { 2987 return(NULL); 2988 } 2989 2990 smallt *o = getsoO(json); 2991 if (!o) { 2992 // smallJson is empty, create an empty dict 2993 isError(o, (smallt*)allocSDict()) return(NULL); 2994 setsoO(json, o); 2995 } 2996 2997 sArrayPrependTiny(&(self->a), o); 2998 return(self); 2999 } 3000 3001 internal smallArrayt* prependSmallStringSmallArray(smallArrayt *self, smallStringt *string) { 3002 3003 if (checkObjectTypes && string && !isOSmallString(string)) { 3004 return(NULL); 3005 } 3006 3007 if (!string) { 3008 return(NULL); 3009 } 3010 3011 if (!string->data) { 3012 isError(string->data, allocSStringTiny("")) return(NULL); 3013 } 3014 sArrayPrependTiny(&(self->a), (smallt *) string->data); 3015 return(self); 3016 } 3017 3018 internal smallArrayt* prependSmallContainerSmallArray(smallArrayt *self, smallContainert *container) { 3019 3020 if (checkObjectTypes && container && !isOSmallContainer(container)) { 3021 return(NULL); 3022 } 3023 3024 if (!container) { 3025 return(NULL); 3026 } 3027 3028 if (!container->data) { 3029 isError(container->data, allocSContainer(NULL)) return(NULL); 3030 } 3031 sArrayPrependTiny(&(self->a), (smallt *) container->data); 3032 return(self); 3033 } 3034 3035 3036 internal smallArrayt* prependNFreeSmallArray(smallArrayt *self, baset *value) { 3037 smallt *o = NULL; 3038 3039 if (!value) { 3040 return(NULL); 3041 } 3042 3043 o = toSmallt(value);; 3044 if (!o) { 3045 return(NULL); 3046 } 3047 sArrayPrependTiny(&(self->a), o); 3048 3049 if (!(o->type == CONTAINER && (((sContainert*)o)->dataType == SH_DT_BASET))) { 3050 finishO(value); 3051 } 3052 return(self); 3053 } 3054 3055 internal smallArrayt* prependNFreeUndefinedSmallArray(smallArrayt *self, undefinedt *u) { 3056 3057 smallArrayt *r = prependUndefinedSmallArray(self);; 3058 if (r) { 3059 terminateO(u); 3060 } 3061 return(self); 3062 } 3063 3064 internal smallArrayt* prependNFreeSSmallArray(smallArrayt *self, char *string) { 3065 3066 smallArrayt *r = prependSSmallArray(self, string); 3067 if (r) { 3068 free(string); 3069 } 3070 return(r); 3071 } 3072 3073 internal smallArrayt* prependNFreeDictSmallArray(smallArrayt *self, smallDictt *dict) { 3074 3075 smallArrayt *r = prependDictSmallArray(self, dict); 3076 if (r) { 3077 finishO(dict); 3078 } 3079 return(r); 3080 } 3081 3082 internal smallArrayt* prependNFreeArraySmallArray(smallArrayt *self, smallArrayt *array) { 3083 3084 smallArrayt *r = prependArraySmallArray(self, array); 3085 if (r) { 3086 finishO(array); 3087 } 3088 return(r); 3089 } 3090 3091 internal smallArrayt* prependNFreeArraycSmallArray(smallArrayt *self, char **array) { 3092 3093 smallArrayt *r = prependArraycSmallArray(self, array); 3094 if (r) { 3095 listFreeS(array); 3096 } 3097 return(r); 3098 } 3099 3100 internal smallArrayt* prependNFreeSmallBoolSmallArray(smallArrayt *self, smallBoolt *value) { 3101 3102 smallArrayt *r = prependSmallBoolSmallArray(self, value); 3103 if (r) { 3104 finishO(value); 3105 } 3106 return(r); 3107 } 3108 3109 internal smallArrayt* prependNFreeSmallBytesSmallArray(smallArrayt *self, smallBytest *value) { 3110 3111 smallArrayt *r = prependSmallBytesSmallArray(self, value); 3112 if (r) { 3113 finishO(value); 3114 } 3115 return(r); 3116 } 3117 3118 internal smallArrayt* prependNFreeSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value) { 3119 3120 smallArrayt *r = prependSmallDoubleSmallArray(self, value); 3121 if (r) { 3122 finishO(value); 3123 } 3124 return(r); 3125 } 3126 3127 internal smallArrayt* prependNFreeSmallIntSmallArray(smallArrayt *self, smallIntt *value) { 3128 3129 smallArrayt *r = prependSmallIntSmallArray(self, value); 3130 if (r) { 3131 finishO(value); 3132 } 3133 return(r); 3134 } 3135 3136 internal smallArrayt* prependNFreeSmallJsonSmallArray(smallArrayt *self, smallJsont *json) { 3137 3138 smallArrayt *r = prependSmallJsonSmallArray(self, json); 3139 if (r) { 3140 finishO(json); 3141 } 3142 return(r); 3143 } 3144 3145 internal smallArrayt* prependNFreeSmallStringSmallArray(smallArrayt *self, smallStringt *string) { 3146 3147 smallArrayt *r = prependSmallStringSmallArray(self, string); 3148 if (r) { 3149 finishO(string); 3150 } 3151 return(r); 3152 } 3153 3154 internal smallArrayt* prependNFreeSmallContainerSmallArray(smallArrayt *self, smallContainert *container) { 3155 3156 smallArrayt *r = prependSmallContainerSmallArray(self, container); 3157 if (r) { 3158 finishO(container); 3159 } 3160 return(r); 3161 } 3162 3163 internal baset* dequeueSmallArray(smallArrayt *self) { 3164 size_t len; 3165 smallt *o = NULL; 3166 3167 len = lenSmallArray(self); 3168 if (!len) { 3169 return(NULL); 3170 } 3171 3172 for (size_t i = len ; i != 0 ; i--) { 3173 o = sArrayDequeueTiny(self->a); 3174 if (o) { 3175 break; 3176 } 3177 } 3178 3179 if (!o) { 3180 return(NULL); 3181 } 3182 3183 if (o->type == UNDEFINED) { 3184 free(o); 3185 return((baset*) allocUndefined()); 3186 } 3187 else if (o->type == CONTAINER) { 3188 cast(sContainert*, sc, o); 3189 if (sc->dataType == SH_DT_BASET) { 3190 // baset object in stored in the container, free the container since 3191 // it was allocated automatically in the toSmallt function in libsheepyObject.c 3192 baset *r = toBaset(o); 3193 free(o); 3194 return(r); 3195 } 3196 } 3197 return(toBaset(o)); 3198 } 3199 3200 internal undefinedt* dequeueUndefinedSmallArray(smallArrayt *self) { 3201 size_t len; 3202 smallt *o = NULL; 3203 3204 len = lenSmallArray(self); 3205 if (!len) { 3206 return(NULL); 3207 } 3208 3209 size_t i; 3210 for (i = 0 ; i < len ; i++) { 3211 o = sArrayGetTiny(self->a, (uint32_t)i); 3212 if (o) { 3213 break; 3214 } 3215 } 3216 3217 if (!o) { 3218 return(NULL); 3219 } 3220 3221 if (o->type != UNDEFINED) { 3222 return(NULL); 3223 } 3224 3225 // finish dequeuing 3226 smallt **arr = &(self->a->data); 3227 // shift list 3228 for (uint32_t j = (uint32_t)i+1 ; j < self->a->count ; j++) { 3229 arr[j-i-1] = arr[j]; 3230 } 3231 self->a->count -= (uint32_t)i+1; 3232 3233 free(o); 3234 return(allocUndefined()); 3235 } 3236 3237 internal bool dequeueBoolSmallArray(smallArrayt *self) { 3238 smallBoolt *e = NULL; 3239 bool r = false;; 3240 3241 e = dequeueSmallBoolSmallArray(self); 3242 if (e) { 3243 r = e->f->get(e); 3244 terminateO(e); 3245 } 3246 return(r); 3247 } 3248 3249 internal double dequeueDoubleSmallArray(smallArrayt *self) { 3250 smallDoublet *e = NULL; 3251 double r = 0;; 3252 3253 e = dequeueSmallDoubleSmallArray(self); 3254 if (e) { 3255 r = e->f->get(e); 3256 terminateO(e); 3257 } 3258 return(r); 3259 } 3260 3261 internal int64_t dequeueIntSmallArray(smallArrayt *self) { 3262 smallIntt *e = NULL; 3263 int64_t r = 0;; 3264 3265 e = dequeueSmallIntSmallArray(self); 3266 if (e) { 3267 r = e->f->get(e); 3268 terminateO(e); 3269 } 3270 return(r); 3271 } 3272 3273 internal int32_t dequeueInt32SmallArray(smallArrayt *self) { 3274 smallIntt *e = NULL; 3275 int32_t r = 0;; 3276 3277 e = dequeueSmallIntSmallArray(self); 3278 if (e) { 3279 r = (int32_t)e->f->get(e); 3280 terminateO(e); 3281 } 3282 return(r); 3283 } 3284 3285 internal uint64_t dequeueUintSmallArray(smallArrayt *self) { 3286 smallIntt *e = NULL; 3287 uint64_t r = 0;; 3288 3289 e = dequeueSmallIntSmallArray(self); 3290 if (e) { 3291 r = (uint64_t)e->f->get(e); 3292 terminateO(e); 3293 } 3294 return(r); 3295 } 3296 3297 internal uint32_t dequeueUint32SmallArray(smallArrayt *self) { 3298 smallIntt *e = NULL; 3299 uint32_t r = 0;; 3300 3301 e = dequeueSmallIntSmallArray(self); 3302 if (e) { 3303 r = (uint32_t)e->f->get(e); 3304 terminateO(e); 3305 } 3306 return(r); 3307 } 3308 3309 internal char* dequeueSSmallArray(smallArrayt *self) { 3310 smallStringt *e = NULL; 3311 char* r = NULL; 3312 3313 e = dequeueSmallStringSmallArray(self); 3314 if (e) { 3315 r = e->f->toString(e); 3316 terminateO(e); 3317 } 3318 return(r); 3319 } 3320 3321 internal smallDictt* dequeueDictSmallArray(smallArrayt *self) { 3322 size_t len; 3323 smallt *o = NULL; 3324 3325 len = lenSmallArray(self); 3326 if (!len) { 3327 return(NULL); 3328 } 3329 3330 size_t i; 3331 for (i = 0 ; i < len ; i++) { 3332 o = sArrayGetTiny(self->a, (uint32_t)i); 3333 if (o) { 3334 break; 3335 } 3336 } 3337 3338 if (!o) { 3339 return(NULL); 3340 } 3341 3342 if (o->type != DICT) { 3343 return(NULL); 3344 } 3345 3346 // finish dequeuing 3347 smallt **arr = &(self->a->data); 3348 // shift list 3349 for (uint32_t j = (uint32_t)i+1 ; j < self->a->count ; j++) { 3350 arr[j-i-1] = arr[j]; 3351 } 3352 self->a->count -= (uint32_t)i+1; 3353 3354 return((smallDictt*) toBaset(o)); 3355 } 3356 3357 internal smallArrayt* dequeueArraySmallArray(smallArrayt *self) { 3358 size_t len; 3359 smallt *o = NULL; 3360 3361 len = lenSmallArray(self); 3362 if (!len) { 3363 return(NULL); 3364 } 3365 3366 size_t i; 3367 for (i = 0 ; i < len ; i++) { 3368 o = sArrayGetTiny(self->a, (uint32_t)i); 3369 if (o) { 3370 break; 3371 } 3372 } 3373 3374 if (!o) { 3375 return(NULL); 3376 } 3377 3378 if (o->type != ARRAY) { 3379 return(NULL); 3380 } 3381 3382 // finish dequeuing 3383 smallt **arr = &(self->a->data); 3384 // shift list 3385 for (uint32_t j = (uint32_t)i+1 ; j < self->a->count ; j++) { 3386 arr[j-i-1] = arr[j]; 3387 } 3388 self->a->count -= (uint32_t)i+1; 3389 3390 return((smallArrayt*) toBaset(o)); 3391 } 3392 3393 internal smallBoolt* dequeueSmallBoolSmallArray(smallArrayt *self) { 3394 size_t len; 3395 smallt *o = NULL; 3396 3397 len = lenSmallArray(self); 3398 if (!len) { 3399 return(NULL); 3400 } 3401 3402 size_t i; 3403 for (i = 0 ; i < len ; i++) { 3404 o = sArrayGetTiny(self->a, (uint32_t)i); 3405 if (o) { 3406 break; 3407 } 3408 } 3409 3410 if (!o) { 3411 return(NULL); 3412 } 3413 3414 if (o->type != BOOL) { 3415 return(NULL); 3416 } 3417 3418 // finish dequeuing 3419 smallt **arr = &(self->a->data); 3420 // shift list 3421 for (uint32_t j = (uint32_t)i+1 ; j < self->a->count ; j++) { 3422 arr[j-i-1] = arr[j]; 3423 } 3424 self->a->count -= (uint32_t)i+1; 3425 3426 return((smallBoolt*) toBaset(o)); 3427 } 3428 3429 internal smallBytest* dequeueSmallBytesSmallArray(smallArrayt *self) { 3430 size_t len; 3431 smallt *o = NULL; 3432 3433 len = lenSmallArray(self); 3434 if (!len) { 3435 return(NULL); 3436 } 3437 3438 size_t i; 3439 for (i = 0 ; i < len ; i++) { 3440 o = sArrayGetTiny(self->a, (uint32_t)i); 3441 if (o) { 3442 break; 3443 } 3444 } 3445 3446 if (!o) { 3447 return(NULL); 3448 } 3449 3450 if (o->type != BYTES) { 3451 return(NULL); 3452 } 3453 3454 // finish dequeuing 3455 smallt **arr = &(self->a->data); 3456 // shift list 3457 for (uint32_t j = (uint32_t)i+1 ; j < self->a->count ; j++) { 3458 arr[j-i-1] = arr[j]; 3459 } 3460 self->a->count -= (uint32_t)i+1; 3461 3462 return((smallBytest*) toBaset(o)); 3463 } 3464 3465 internal smallDoublet* dequeueSmallDoubleSmallArray(smallArrayt *self) { 3466 size_t len; 3467 smallt *o = NULL; 3468 3469 len = lenSmallArray(self); 3470 if (!len) { 3471 return(NULL); 3472 } 3473 3474 size_t i; 3475 for (i = 0 ; i < len ; i++) { 3476 o = sArrayGetTiny(self->a, (uint32_t)i); 3477 if (o) { 3478 break; 3479 } 3480 } 3481 3482 if (!o) { 3483 return(NULL); 3484 } 3485 3486 if (o->type != DOUBLE) { 3487 return(NULL); 3488 } 3489 3490 // finish dequeuing 3491 smallt **arr = &(self->a->data); 3492 // shift list 3493 for (uint32_t j = (uint32_t)i+1 ; j < self->a->count ; j++) { 3494 arr[j-i-1] = arr[j]; 3495 } 3496 self->a->count -= (uint32_t)i+1; 3497 3498 return((smallDoublet*) toBaset(o)); 3499 } 3500 3501 internal smallIntt* dequeueSmallIntSmallArray(smallArrayt *self) { 3502 size_t len; 3503 smallt *o = NULL; 3504 3505 len = lenSmallArray(self); 3506 if (!len) { 3507 return(NULL); 3508 } 3509 3510 size_t i; 3511 for (i = 0 ; i < len ; i++) { 3512 o = sArrayGetTiny(self->a, (uint32_t)i); 3513 if (o) { 3514 break; 3515 } 3516 } 3517 3518 if (!o) { 3519 return(NULL); 3520 } 3521 3522 if (o->type != INT) { 3523 return(NULL); 3524 } 3525 3526 // finish dequeuing 3527 smallt **arr = &(self->a->data); 3528 // shift list 3529 for (uint32_t j = (uint32_t)i+1 ; j < self->a->count ; j++) { 3530 arr[j-i-1] = arr[j]; 3531 } 3532 self->a->count -= (uint32_t)i+1; 3533 3534 return((smallIntt*) toBaset(o)); 3535 } 3536 3537 internal smallJsont* dequeueSmallJsonSmallArray(smallArrayt *self) { 3538 size_t len; 3539 smallt *o = NULL; 3540 3541 len = lenSmallArray(self); 3542 if (!len) { 3543 return(NULL); 3544 } 3545 3546 size_t i; 3547 for (i = 0 ; i < len ; i++) { 3548 o = sArrayGetTiny(self->a, (uint32_t)i); 3549 if (o) { 3550 break; 3551 } 3552 } 3553 3554 if (!o) { 3555 return(NULL); 3556 } 3557 3558 if ((o->type == BYTES) || (o->type == CONTAINER)) { 3559 return(NULL); 3560 } 3561 3562 // finish dequeuing 3563 smallt **arr = &(self->a->data); 3564 // shift list 3565 for (uint32_t j = (uint32_t)i+1 ; j < self->a->count ; j++) { 3566 arr[j-i-1] = arr[j]; 3567 } 3568 self->a->count -= (uint32_t)i+1; 3569 3570 baset *e = toBaset(o); 3571 3572 createAllocateSmallJson(r); 3573 if (!r) { 3574 return(NULL); 3575 } 3576 setTopNFreeO(r, e); 3577 return(r); 3578 } 3579 3580 internal smallStringt* dequeueSmallStringSmallArray(smallArrayt *self) { 3581 size_t len; 3582 smallt *o = NULL; 3583 3584 len = lenSmallArray(self); 3585 if (!len) { 3586 return(NULL); 3587 } 3588 3589 size_t i; 3590 for (i = 0 ; i < len ; i++) { 3591 o = sArrayGetTiny(self->a, (uint32_t)i); 3592 if (o) { 3593 break; 3594 } 3595 } 3596 3597 if (!o) { 3598 return(NULL); 3599 } 3600 3601 if (o->type != STRING) { 3602 return(NULL); 3603 } 3604 3605 // finish dequeuing 3606 smallt **arr = &(self->a->data); 3607 // shift list 3608 for (uint32_t j = (uint32_t)i+1 ; j < self->a->count ; j++) { 3609 arr[j-i-1] = arr[j]; 3610 } 3611 self->a->count -= (uint32_t)i+1; 3612 3613 return((smallStringt*) toBaset(o)); 3614 } 3615 3616 internal void* dequeueVoidSmallArray(smallArrayt *self) { 3617 smallContainert *e = NULL; 3618 void* r = NULL; 3619 3620 e = dequeueSmallContainerSmallArray(self); 3621 if (e) { 3622 r = e->f->get(e); 3623 smashO(e); 3624 } 3625 return(r); 3626 } 3627 3628 internal smallContainert* dequeueSmallContainerSmallArray(smallArrayt *self) { 3629 size_t len; 3630 smallt *o = NULL; 3631 3632 len = lenSmallArray(self); 3633 if (!len) { 3634 return(NULL); 3635 } 3636 3637 size_t i; 3638 for (i = 0 ; i < len ; i++) { 3639 o = sArrayGetTiny(self->a, (uint32_t)i); 3640 if (o) { 3641 break; 3642 } 3643 } 3644 3645 if (!o) { 3646 return(NULL); 3647 } 3648 3649 if (o->type != CONTAINER) { 3650 return(NULL); 3651 } 3652 3653 if (((sContainert*)o)->dataType == SH_DT_BASET) { 3654 return(NULL); 3655 } 3656 3657 // finish dequeuing 3658 smallt **arr = &(self->a->data); 3659 // shift list 3660 for (uint32_t j = (uint32_t)i+1 ; j < self->a->count ; j++) { 3661 arr[j-i-1] = arr[j]; 3662 } 3663 self->a->count -= (uint32_t)i+1; 3664 3665 return((smallContainert*) toBaset(o)); 3666 } 3667 3668 internal double dequeueNumSmallArray(smallArrayt *self) { 3669 size_t len; 3670 smallt *o = NULL; 3671 3672 len = lenSmallArray(self); 3673 if (!len) { 3674 return(0); 3675 } 3676 3677 size_t i; 3678 for (i = 0 ; i < len ; i++) { 3679 o = sArrayGetTiny(self->a, (uint32_t)i); 3680 if (o) { 3681 break; 3682 } 3683 } 3684 3685 if (!o) { 3686 return(0); 3687 } 3688 3689 if (o->type != INT && o->type != DOUBLE) { 3690 return(0); 3691 } 3692 3693 // finish dequeuing 3694 smallt **arr = &(self->a->data); 3695 // shift list 3696 for (uint32_t j = (uint32_t)i+1 ; j < self->a->count ; j++) { 3697 arr[j-i-1] = arr[j]; 3698 } 3699 self->a->count -= (uint32_t)i+1; 3700 3701 baset *e = toBaset(o); 3702 3703 double r = 0; 3704 if (isOSmallDouble(e)) { 3705 r = getValO((smallDoublet*)e); 3706 } 3707 elif (isOSmallInt(e)) { 3708 r = (double)getValO((smallIntt*)e); 3709 } 3710 terminateO(e); 3711 return(r); 3712 } 3713 3714 internal smallArrayt* reverseSmallArray(smallArrayt *self) { 3715 size_t len; 3716 3717 len = lenSmallArray(self); 3718 3719 if (len < 2) { 3720 // empty or 1 element list 3721 return(self); 3722 } 3723 3724 if (!sArrayReverseTiny(self->a)) { 3725 return(NULL); 3726 } 3727 return(self); 3728 } 3729 3730 internal smallArrayt* catSmallArray(smallArrayt *self, ...) { 3731 va_list pl; 3732 smallArrayt *paramType = NULL; 3733 3734 // add arguments to a list 3735 va_start(pl, self); 3736 paramType = va_arg(pl, smallArrayt*); 3737 while (paramType) { 3738 smallArrayt *r = appendSmallArray(self, paramType);; 3739 if (!r) { 3740 va_end(pl); 3741 return(NULL); 3742 } 3743 paramType = va_arg(pl, smallArrayt*); 3744 } 3745 va_end(pl); 3746 return(self); 3747 } 3748 3749 internal smallArrayt* appendSmallArray(smallArrayt *self, smallArrayt *array) { 3750 3751 // sanity checks 3752 if (!array) { 3753 return(NULL); 3754 } 3755 3756 if (checkObjectTypes && !isOSmallArray(array)) { 3757 return(NULL); 3758 } 3759 3760 if (!array->f->len(array)) { 3761 // self not modified 3762 return(self); 3763 } 3764 3765 if (self->a == array->a) { 3766 // self and array identical, cancel this operations 3767 // to avoid double free undefined behavior in free 3768 return(NULL); 3769 } 3770 3771 // copy array 3772 forEachSArray(array->a, o) { 3773 sArrayPushTiny(&(self->a), o); 3774 } 3775 3776 return(self); 3777 } 3778 3779 internal smallArrayt* appendSmallJsonSmallArray(smallArrayt *self, smallJsont *json) { 3780 3781 // sanity checks 3782 if (!json) { 3783 return(NULL); 3784 } 3785 3786 if (checkObjectTypes && !isOSmallJson(json)) { 3787 return(NULL); 3788 } 3789 3790 const char *type = getTopTypeO(json); 3791 3792 if (!eqS(type,"array")) { 3793 return(NULL); 3794 } 3795 3796 if (!json->f->len(json)) { 3797 // self not modified 3798 return(self); 3799 } 3800 3801 if (self->a == json->topA) { 3802 // self and array identical, cancel this operations 3803 // to avoid double free undefined behavior in free 3804 return(NULL); 3805 } 3806 3807 // copy array 3808 forEachSArray(json->topA, o) { 3809 sArrayPushTiny(&(self->a), o); 3810 } 3811 3812 return(self); 3813 } 3814 3815 internal smallArrayt* appendNSmashSmallArray(smallArrayt *self, smallArrayt *array) { 3816 smallArrayt *r = NULL; 3817 3818 r = appendSmallArray(self, array); 3819 if (r) { 3820 smashO(array); 3821 } 3822 return(r); 3823 } 3824 3825 internal smallArrayt* appendNSmashSmallJsonSmallArray(smallArrayt *self, smallJsont *json) { 3826 smallArrayt *r = NULL; 3827 3828 r = appendSmallJsonSmallArray(self, json); 3829 if (r) { 3830 smashO(json); 3831 } 3832 return(r); 3833 } 3834 3835 internal smallArrayt* appendArraySmallArray(smallArrayt *self, char **array) { 3836 3837 if (!array) { 3838 return(NULL); 3839 } 3840 3841 if (!*array) { 3842 return(self); 3843 } 3844 3845 forEachCharP(array, e) { 3846 sStringt *s = allocSStringTiny(*e); 3847 if (!s) { 3848 return(NULL); 3849 } 3850 sArrayPushTiny(&(self->a), (smallt *) s); 3851 } 3852 return(self); 3853 } 3854 3855 internal smallArrayt* appendCArraySmallArray(smallArrayt *self, const char **array) { 3856 3857 if (!array) { 3858 return(NULL); 3859 } 3860 3861 if (!*array) { 3862 return(self); 3863 } 3864 3865 forEachCCharP(array, e) { 3866 sStringt *s = allocSStringTiny(*e); 3867 if (!s) { 3868 return(NULL); 3869 } 3870 sArrayPushTiny(&(self->a), (smallt *) s); 3871 } 3872 return(self); 3873 } 3874 3875 internal smallArrayt* appendNSmashArraySmallArray(smallArrayt *self, char **array) { 3876 3877 if (!array) { 3878 return(NULL); 3879 } 3880 3881 if (!*array) { 3882 free(array); 3883 return(self); 3884 } 3885 3886 forEachCharP(array, e) { 3887 sStringt *s = allocSStringTiny(*e); 3888 if (!s) { 3889 // keep array when there is an error 3890 return(NULL); 3891 } 3892 sArrayPushTiny(&(self->a), (smallt *) s); 3893 } 3894 3895 listFreeS(array); 3896 return(self); 3897 } 3898 3899 internal smallArrayt* shiftSmallArray(smallArrayt *self, smallArrayt *array) { 3900 3901 return(insertSmallArray(self, 0, array)); 3902 } 3903 3904 internal smallArrayt* shiftSmallJsonSmallArray(smallArrayt *self, smallJsont *json) { 3905 3906 return(insertSmallJsonSmallArray(self, 0, json)); 3907 } 3908 3909 internal smallArrayt* shiftNSmashSmallArray(smallArrayt *self, smallArrayt *array) { 3910 3911 return(insertNSmashSmallArray(self, 0, array)); 3912 } 3913 3914 internal smallArrayt* shiftNSmashSmallJsonSmallArray(smallArrayt *self, smallJsont *json) { 3915 3916 return(insertNSmashSmallJsonSmallArray(self, 0, json)); 3917 } 3918 3919 3920 internal smallArrayt* addSmallArray(smallArrayt *self, smallArrayt *array) { 3921 smallArrayt *r = NULL; 3922 3923 // sanity checks 3924 if (!array) { 3925 return(NULL); 3926 } 3927 3928 if (checkObjectTypes && !isOSmallArray(array)) { 3929 return(NULL); 3930 } 3931 3932 if (!array->f->len(array)) { 3933 return(duplicateSmallArray(self)); 3934 } 3935 3936 if (self->a == array->a) { 3937 // self and array identical, cancel this operations 3938 // to avoid double free undefined behavior in free 3939 return(NULL); 3940 } 3941 3942 r = duplicateSmallArray(self); 3943 3944 // copy array 3945 forEachSArray(array->a, o) { 3946 sArrayPushTiny(&(r->a), o); 3947 } 3948 3949 return(r); 3950 } 3951 3952 internal smallArrayt* sliceSmallArray(smallArrayt *self, int64_t start, int64_t end) { 3953 size_t len; 3954 3955 len = lenSmallArray(self); 3956 // sanity checks 3957 if (!len) { 3958 return(NULL); 3959 } 3960 3961 if (start > (int64_t)len) { 3962 emptySmallArray(self); 3963 return(NULL); 3964 } 3965 if (end > (int64_t)len) { 3966 end = (int64_t)len; 3967 } 3968 if (start <= -(int64_t)len) { 3969 start = -(int64_t)len; 3970 } 3971 if (end <= -(int64_t)len) { 3972 emptySmallArray(self); 3973 return(NULL); 3974 } 3975 if (start < 0) { 3976 start = (int64_t)len + start; 3977 } 3978 if (end <= 0) { 3979 end = (int64_t)len + end; 3980 } 3981 if (end < start) { 3982 emptySmallArray(self); 3983 return(NULL); 3984 } 3985 3986 if (start == end) { 3987 // empty list 3988 freeSmallArray(self); 3989 return(self); 3990 } 3991 else { 3992 // start < end < len 3993 3994 sArrayDelRangeTiny(self->a, (uint32_t)end, (uint32_t)len); 3995 sArrayDelRangeTiny(self->a, 0, (uint32_t)start); 3996 } 3997 3998 return(self); 3999 } 4000 4001 internal smallArrayt* cropSmallArray(smallArrayt *self, int64_t start, int64_t end) { 4002 size_t len; 4003 smallt *o = NULL; 4004 4005 len = lenSmallArray(self); 4006 // sanity checks 4007 if (!len) { 4008 return(NULL); 4009 } 4010 4011 if (start > (int64_t)len) { 4012 return(NULL); 4013 } 4014 if (end > (int64_t)len) { 4015 end = (int64_t)len; 4016 } 4017 if (start <= -(int64_t)len) { 4018 start = -(int64_t)len; 4019 } 4020 if (end <= -(int64_t)len) { 4021 return(NULL); 4022 } 4023 if (start < 0) { 4024 start = (int64_t)len + start; 4025 } 4026 if (end <= 0) { 4027 end = (int64_t)len + end; 4028 } 4029 if (end < start) { 4030 return(NULL); 4031 } 4032 4033 createAllocateSmallArray(r); 4034 if (!r) { 4035 return(NULL); 4036 } 4037 4038 if (start < end) { 4039 // start < end < len 4040 int64_t n; 4041 n = end - start; 4042 4043 for (int64_t i=0;i < n;i++) { 4044 o = sArrayGetTiny(self->a, (uint32_t)(start+i)); 4045 sArrayPushTiny(&(r->a), o); 4046 } 4047 4048 // copy pointers from range end, array->count to start 4049 smallt **arr = &(self->a->data); 4050 4051 for (uint32_t i = 0 ; i < (self->a->count - end) ; i ++) { 4052 arr[start+i] = arr[end + i]; 4053 } 4054 4055 self->a->count -= (uint32_t)(end - start); 4056 } 4057 4058 return(r); 4059 } 4060 4061 internal baset* cropElemSmallArray(smallArrayt *self, int64_t index) { 4062 baset *r = NULL; 4063 4064 if (index >= (int64_t)lenSmallArray(self)) { 4065 return(NULL); 4066 } 4067 if (index < -(int64_t)lenSmallArray(self)) { 4068 return(NULL); 4069 } 4070 if (index < 0) { 4071 index = (int64_t)lenSmallArray(self) + index; 4072 } 4073 4074 smallt *o = sArrayGetTiny(self->a, (uint32_t)index);; 4075 if (!o) { 4076 return(NULL); 4077 } 4078 4079 if (o->type == UNDEFINED) { 4080 free(o); 4081 r = (baset*) allocUndefined(); 4082 goto removeElem; 4083 } 4084 else if (o->type == CONTAINER) { 4085 cast(sContainert*, sc, o); 4086 if (sc->dataType == SH_DT_BASET) { 4087 // baset object in stored in the container, free the container since 4088 // it was allocated automatically in the toSmallt function in libsheepyObject.c 4089 r = toBaset(o); 4090 free(o); 4091 goto removeElem; 4092 } 4093 } 4094 r = toBaset(o);; 4095 4096 removeElem:; 4097 4098 // copy pointers from range index+1, array->count to index 4099 smallt **arr = &(self->a->data); 4100 4101 for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) { 4102 arr[index+i] = arr[index+1 + i]; 4103 } 4104 4105 self->a->count--; 4106 4107 return(r); 4108 } 4109 4110 4111 internal undefinedt* cropElemUndefinedSmallArray(smallArrayt *self, int64_t index) { 4112 4113 if (index >= (int64_t)lenSmallArray(self)) { 4114 return(NULL); 4115 } 4116 if (index < -(int64_t)lenSmallArray(self)) { 4117 return(NULL); 4118 } 4119 if (index < 0) { 4120 index = (int64_t)lenSmallArray(self) + index; 4121 } 4122 4123 smallt *o = sArrayGetTiny(self->a, (uint32_t)index);; 4124 if (!o) { 4125 return(NULL); 4126 } 4127 if (o->type != UNDEFINED) { 4128 return(NULL); 4129 } 4130 4131 free(o); 4132 undefinedt *r = allocUndefined(); 4133 4134 // copy pointers from range index+1, array->count to index 4135 smallt **arr = &(self->a->data); 4136 4137 for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) { 4138 arr[index+i] = arr[index+1 + i]; 4139 } 4140 4141 self->a->count--; 4142 4143 return(r); 4144 } 4145 4146 4147 internal bool cropElemBoolSmallArray(smallArrayt *self, int64_t index) { 4148 4149 if (index >= (int64_t)lenSmallArray(self)) { 4150 return(false); 4151 } 4152 if (index < -(int64_t)lenSmallArray(self)) { 4153 return(false); 4154 } 4155 if (index < 0) { 4156 index = (int64_t)lenSmallArray(self) + index; 4157 } 4158 4159 bool r = false; 4160 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 4161 if (!o) { 4162 return(false); 4163 } 4164 smallBoolt *e = (smallBoolt*)toBaset(o); 4165 if (e) { 4166 if (checkObjectTypes && !isOSmallBool(e)) { 4167 if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) { 4168 return(false); 4169 } 4170 finishO(e); 4171 return(false); 4172 } 4173 r = e->f->get(e); 4174 terminateO(e); 4175 4176 // copy pointers from range index+1, array->count to index 4177 smallt **arr = &(self->a->data); 4178 4179 for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) { 4180 arr[index+i] = arr[index+1 + i]; 4181 } 4182 4183 self->a->count--; 4184 } 4185 4186 return(r); 4187 } 4188 4189 internal double cropElemDoubleSmallArray(smallArrayt *self, int64_t index) { 4190 4191 if (index >= (int64_t)lenSmallArray(self)) { 4192 return(0); 4193 } 4194 if (index < -(int64_t)lenSmallArray(self)) { 4195 return(0); 4196 } 4197 if (index < 0) { 4198 index = (int64_t)lenSmallArray(self) + index; 4199 } 4200 4201 double r = 0; 4202 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 4203 if (!o) { 4204 return(0); 4205 } 4206 smallDoublet *e = (smallDoublet*)toBaset(o); 4207 if (e) { 4208 if (checkObjectTypes && !isOSmallDouble(e)) { 4209 if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) { 4210 return(0); 4211 } 4212 finishO(e); 4213 return(0); 4214 } 4215 r = e->f->get(e); 4216 terminateO(e); 4217 4218 // copy pointers from range index+1, array->count to index 4219 smallt **arr = &(self->a->data); 4220 4221 for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) { 4222 arr[index+i] = arr[index+1 + i]; 4223 } 4224 4225 self->a->count--; 4226 } 4227 4228 return(r); 4229 } 4230 4231 internal int64_t cropElemIntSmallArray(smallArrayt *self, int64_t index) { 4232 4233 if (index >= (int64_t)lenSmallArray(self)) { 4234 return(0); 4235 } 4236 if (index < -(int64_t)lenSmallArray(self)) { 4237 return(0); 4238 } 4239 if (index < 0) { 4240 index = (int64_t)lenSmallArray(self) + index; 4241 } 4242 4243 int64_t r = 0; 4244 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 4245 if (!o) { 4246 return(0); 4247 } 4248 smallIntt *e = (smallIntt*)toBaset(o); 4249 if (e) { 4250 if (checkObjectTypes && !isOSmallInt(e)) { 4251 if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) { 4252 return(0); 4253 } 4254 finishO(e); 4255 return(0); 4256 } 4257 r = e->f->get(e); 4258 terminateO(e); 4259 4260 // copy pointers from range index+1, array->count to index 4261 smallt **arr = &(self->a->data); 4262 4263 for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) { 4264 arr[index+i] = arr[index+1 + i]; 4265 } 4266 4267 self->a->count--; 4268 } 4269 4270 return(r); 4271 } 4272 4273 4274 internal int32_t cropElemInt32SmallArray(smallArrayt *self, int64_t index) { 4275 4276 if (index >= (int64_t)lenSmallArray(self)) { 4277 return(0); 4278 } 4279 if (index < -(int64_t)lenSmallArray(self)) { 4280 return(0); 4281 } 4282 if (index < 0) { 4283 index = (int64_t)lenSmallArray(self) + index; 4284 } 4285 4286 int32_t r = 0; 4287 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 4288 if (!o) { 4289 return(0); 4290 } 4291 smallIntt *e = (smallIntt*)toBaset(o); 4292 if (e) { 4293 if (checkObjectTypes && !isOSmallInt(e)) { 4294 if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) { 4295 return(0); 4296 } 4297 finishO(e); 4298 return(0); 4299 } 4300 r = (int32_t)e->f->get(e); 4301 terminateO(e); 4302 4303 // copy pointers from range index+1, array->count to index 4304 smallt **arr = &(self->a->data); 4305 4306 for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) { 4307 arr[index+i] = arr[index+1 + i]; 4308 } 4309 4310 self->a->count--; 4311 } 4312 4313 return(r); 4314 } 4315 4316 internal uint64_t cropElemUintSmallArray(smallArrayt *self, int64_t index) { 4317 4318 if (index >= (int64_t)lenSmallArray(self)) { 4319 return(0); 4320 } 4321 if (index < -(int64_t)lenSmallArray(self)) { 4322 return(0); 4323 } 4324 if (index < 0) { 4325 index = (int64_t)lenSmallArray(self) + index; 4326 } 4327 4328 uint64_t r = 0; 4329 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 4330 if (!o) { 4331 return(0); 4332 } 4333 smallIntt *e = (smallIntt*)toBaset(o); 4334 if (e) { 4335 if (checkObjectTypes && !isOSmallInt(e)) { 4336 if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) { 4337 return(0); 4338 } 4339 finishO(e); 4340 return(0); 4341 } 4342 r = (uint64_t)e->f->get(e); 4343 terminateO(e); 4344 4345 // copy pointers from range index+1, array->count to index 4346 smallt **arr = &(self->a->data); 4347 4348 for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) { 4349 arr[index+i] = arr[index+1 + i]; 4350 } 4351 4352 self->a->count--; 4353 } 4354 4355 return(r); 4356 } 4357 4358 internal uint32_t cropElemUint32SmallArray(smallArrayt *self, int64_t index) { 4359 4360 if (index >= (int64_t)lenSmallArray(self)) { 4361 return(0); 4362 } 4363 if (index < -(int64_t)lenSmallArray(self)) { 4364 return(0); 4365 } 4366 if (index < 0) { 4367 index = (int64_t)lenSmallArray(self) + index; 4368 } 4369 4370 uint32_t r = 0; 4371 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 4372 if (!o) { 4373 return(0); 4374 } 4375 smallIntt *e = (smallIntt*)toBaset(o); 4376 if (e) { 4377 if (checkObjectTypes && !isOSmallInt(e)) { 4378 if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) { 4379 return(0); 4380 } 4381 finishO(e); 4382 return(0); 4383 } 4384 r = (uint32_t)e->f->get(e); 4385 terminateO(e); 4386 4387 // copy pointers from range index+1, array->count to index 4388 smallt **arr = &(self->a->data); 4389 4390 for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) { 4391 arr[index+i] = arr[index+1 + i]; 4392 } 4393 4394 self->a->count--; 4395 } 4396 4397 return(r); 4398 } 4399 4400 internal char* cropElemSSmallArray(smallArrayt *self, int64_t index) { 4401 4402 if (index >= (int64_t)lenSmallArray(self)) { 4403 return(NULL); 4404 } 4405 if (index < -(int64_t)lenSmallArray(self)) { 4406 return(NULL); 4407 } 4408 if (index < 0) { 4409 index = (int64_t)lenSmallArray(self) + index; 4410 } 4411 4412 char *r = NULL; 4413 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 4414 if (!o) { 4415 return(NULL); 4416 } 4417 smallStringt *e = (smallStringt*)toBaset(o); 4418 if (e) { 4419 if (checkObjectTypes && !isOSmallString(e)) { 4420 if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) { 4421 return(NULL); 4422 } 4423 finishO(e); 4424 return(NULL); 4425 } 4426 r = dupS(e->f->get(e)); 4427 terminateO(e); 4428 4429 // copy pointers from range index+1, array->count to index 4430 smallt **arr = &(self->a->data); 4431 4432 for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) { 4433 arr[index+i] = arr[index+1 + i]; 4434 } 4435 4436 self->a->count--; 4437 } 4438 4439 return(r); 4440 } 4441 4442 internal smallDictt* cropElemDictSmallArray(smallArrayt *self, int64_t index) { 4443 4444 if (index >= (int64_t)lenSmallArray(self)) { 4445 return(NULL); 4446 } 4447 if (index < -(int64_t)lenSmallArray(self)) { 4448 return(NULL); 4449 } 4450 if (index < 0) { 4451 index = (int64_t)lenSmallArray(self) + index; 4452 } 4453 4454 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 4455 if (!o) { 4456 return(NULL); 4457 } 4458 smallDictt *r = (smallDictt*)toBaset(o); 4459 if (checkObjectTypes && r && !isOSmallDict(r)) { 4460 if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) { 4461 return(NULL); 4462 } 4463 finishO(r); 4464 return(NULL); 4465 } 4466 4467 // copy pointers from range index+1, array->count to index 4468 smallt **arr = &(self->a->data); 4469 4470 for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) { 4471 arr[index+i] = arr[index+1 + i]; 4472 } 4473 4474 self->a->count--; 4475 4476 return(r); 4477 } 4478 4479 internal smallArrayt* cropElemArraySmallArray(smallArrayt *self, int64_t index) { 4480 4481 if (index >= (int64_t)lenSmallArray(self)) { 4482 return(NULL); 4483 } 4484 if (index < -(int64_t)lenSmallArray(self)) { 4485 return(NULL); 4486 } 4487 if (index < 0) { 4488 index = (int64_t)lenSmallArray(self) + index; 4489 } 4490 4491 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 4492 if (!o) { 4493 return(NULL); 4494 } 4495 smallArrayt *r = (smallArrayt*)toBaset(o); 4496 if (checkObjectTypes && r && !isOSmallArray(r)) { 4497 if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) { 4498 return(NULL); 4499 } 4500 finishO(r); 4501 return(NULL); 4502 } 4503 4504 // copy pointers from range index+1, array->count to index 4505 smallt **arr = &(self->a->data); 4506 4507 for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) { 4508 arr[index+i] = arr[index+1 + i]; 4509 } 4510 4511 self->a->count--; 4512 4513 return(r); 4514 } 4515 4516 internal smallBoolt* cropElemSmallBoolSmallArray(smallArrayt *self, int64_t index) { 4517 4518 if (index >= (int64_t)lenSmallArray(self)) { 4519 return(NULL); 4520 } 4521 if (index < -(int64_t)lenSmallArray(self)) { 4522 return(NULL); 4523 } 4524 if (index < 0) { 4525 index = (int64_t)lenSmallArray(self) + index; 4526 } 4527 4528 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 4529 if (!o) { 4530 return(NULL); 4531 } 4532 smallBoolt *r = (smallBoolt*)toBaset(o); 4533 if (checkObjectTypes && r && !isOSmallBool(r)) { 4534 if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) { 4535 return(NULL); 4536 } 4537 finishO(r); 4538 return(NULL); 4539 } 4540 4541 // copy pointers from range index+1, array->count to index 4542 smallt **arr = &(self->a->data); 4543 4544 for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) { 4545 arr[index+i] = arr[index+1 + i]; 4546 } 4547 4548 self->a->count--; 4549 4550 return(r); 4551 } 4552 4553 internal smallBytest* cropElemSmallBytesSmallArray(smallArrayt *self, int64_t index) { 4554 4555 if (index >= (int64_t)lenSmallArray(self)) { 4556 return(NULL); 4557 } 4558 if (index < -(int64_t)lenSmallArray(self)) { 4559 return(NULL); 4560 } 4561 if (index < 0) { 4562 index = (int64_t)lenSmallArray(self) + index; 4563 } 4564 4565 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 4566 if (!o) { 4567 return(NULL); 4568 } 4569 smallBytest *r = (smallBytest*)toBaset(o); 4570 if (checkObjectTypes && r && !isOSmallBytes(r)) { 4571 if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) { 4572 return(NULL); 4573 } 4574 finishO(r); 4575 return(NULL); 4576 } 4577 4578 // copy pointers from range index+1, array->count to index 4579 smallt **arr = &(self->a->data); 4580 4581 for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) { 4582 arr[index+i] = arr[index+1 + i]; 4583 } 4584 4585 self->a->count--; 4586 4587 return(r); 4588 } 4589 4590 internal smallDoublet* cropElemSmallDoubleSmallArray(smallArrayt *self, int64_t index) { 4591 4592 if (index >= (int64_t)lenSmallArray(self)) { 4593 return(NULL); 4594 } 4595 if (index < -(int64_t)lenSmallArray(self)) { 4596 return(NULL); 4597 } 4598 if (index < 0) { 4599 index = (int64_t)lenSmallArray(self) + index; 4600 } 4601 4602 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 4603 if (!o) { 4604 return(NULL); 4605 } 4606 smallDoublet *r = (smallDoublet*)toBaset(o); 4607 if (checkObjectTypes && r && !isOSmallDouble(r)) { 4608 if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) { 4609 return(NULL); 4610 } 4611 finishO(r); 4612 return(NULL); 4613 } 4614 4615 // copy pointers from range index+1, array->count to index 4616 smallt **arr = &(self->a->data); 4617 4618 for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) { 4619 arr[index+i] = arr[index+1 + i]; 4620 } 4621 4622 self->a->count--; 4623 4624 return(r); 4625 } 4626 4627 internal smallIntt* cropElemSmallIntSmallArray(smallArrayt *self, int64_t index) { 4628 4629 if (index >= (int64_t)lenSmallArray(self)) { 4630 return(NULL); 4631 } 4632 if (index < -(int64_t)lenSmallArray(self)) { 4633 return(NULL); 4634 } 4635 if (index < 0) { 4636 index = (int64_t)lenSmallArray(self) + index; 4637 } 4638 4639 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 4640 if (!o) { 4641 return(NULL); 4642 } 4643 smallIntt *r = (smallIntt*)toBaset(o); 4644 if (checkObjectTypes && r && !isOSmallInt(r)) { 4645 if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) { 4646 return(NULL); 4647 } 4648 finishO(r); 4649 return(NULL); 4650 } 4651 4652 // copy pointers from range index+1, array->count to index 4653 smallt **arr = &(self->a->data); 4654 4655 for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) { 4656 arr[index+i] = arr[index+1 + i]; 4657 } 4658 4659 self->a->count--; 4660 4661 return(r); 4662 } 4663 4664 internal smallJsont* cropElemSmallJsonSmallArray(smallArrayt *self, int64_t index) { 4665 4666 if (index >= (int64_t)lenSmallArray(self)) { 4667 return(NULL); 4668 } 4669 if (index < -(int64_t)lenSmallArray(self)) { 4670 return(NULL); 4671 } 4672 if (index < 0) { 4673 index = (int64_t)lenSmallArray(self) + index; 4674 } 4675 4676 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 4677 if (!o) { 4678 return(NULL); 4679 } 4680 if ((o->type == BYTES) || (o->type == CONTAINER)) { 4681 return(NULL); 4682 } 4683 baset *e = toBaset(o); 4684 if (!e) { 4685 finishO(e); 4686 return(NULL); 4687 } 4688 createAllocateSmallJson(r); 4689 if (!r) { 4690 finishO(e); 4691 return(NULL); 4692 } 4693 setTopNFreeO(r, e); 4694 4695 // copy pointers from range index+1, array->count to index 4696 smallt **arr = &(self->a->data); 4697 4698 for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) { 4699 arr[index+i] = arr[index+1 + i]; 4700 } 4701 4702 self->a->count--; 4703 4704 return(r); 4705 } 4706 4707 internal smallStringt* cropElemSmallStringSmallArray(smallArrayt *self, int64_t index) { 4708 4709 if (index >= (int64_t)lenSmallArray(self)) { 4710 return(NULL); 4711 } 4712 if (index < -(int64_t)lenSmallArray(self)) { 4713 return(NULL); 4714 } 4715 if (index < 0) { 4716 index = (int64_t)lenSmallArray(self) + index; 4717 } 4718 4719 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 4720 if (!o) { 4721 return(NULL); 4722 } 4723 smallStringt *r = (smallStringt*)toBaset(o); 4724 if (checkObjectTypes && r && !isOSmallString(r)) { 4725 if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) { 4726 return(NULL); 4727 } 4728 finishO(r); 4729 return(NULL); 4730 } 4731 4732 // copy pointers from range index+1, array->count to index 4733 smallt **arr = &(self->a->data); 4734 4735 for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) { 4736 arr[index+i] = arr[index+1 + i]; 4737 } 4738 4739 self->a->count--; 4740 4741 return(r); 4742 } 4743 4744 internal void* cropElemVoidSmallArray(smallArrayt *self, int64_t index) { 4745 4746 if (index >= (int64_t)lenSmallArray(self)) { 4747 return(NULL); 4748 } 4749 if (index < -(int64_t)lenSmallArray(self)) { 4750 return(NULL); 4751 } 4752 if (index < 0) { 4753 index = (int64_t)lenSmallArray(self) + index; 4754 } 4755 4756 void *r = NULL; 4757 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 4758 if (!o) { 4759 return(NULL); 4760 } 4761 smallContainert *e = (smallContainert*)toBaset(o); 4762 if (e) { 4763 if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) { 4764 return(NULL); 4765 } 4766 if (checkObjectTypes && !isOSmallContainer(e)) { 4767 finishO(e); 4768 return(NULL); 4769 } 4770 r = e->f->get(e); 4771 smashO(e); 4772 4773 // copy pointers from range index+1, array->count to index 4774 smallt **arr = &(self->a->data); 4775 4776 for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) { 4777 arr[index+i] = arr[index+1 + i]; 4778 } 4779 4780 self->a->count--; 4781 } 4782 4783 return(r); 4784 } 4785 4786 internal smallContainert* cropElemSmallContainerSmallArray(smallArrayt *self, int64_t index) { 4787 4788 if (index >= (int64_t)lenSmallArray(self)) { 4789 return(NULL); 4790 } 4791 if (index < -(int64_t)lenSmallArray(self)) { 4792 return(NULL); 4793 } 4794 if (index < 0) { 4795 index = (int64_t)lenSmallArray(self) + index; 4796 } 4797 4798 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 4799 if (!o) { 4800 return(NULL); 4801 } 4802 smallContainert *r = (smallContainert*)toBaset(o); 4803 if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) { 4804 return(NULL); 4805 } 4806 if (checkObjectTypes && r && !isOSmallContainer(r)) { 4807 finishO(r); 4808 return(NULL); 4809 } 4810 4811 // copy pointers from range index+1, array->count to index 4812 smallt **arr = &(self->a->data); 4813 4814 for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) { 4815 arr[index+i] = arr[index+1 + i]; 4816 } 4817 4818 self->a->count--; 4819 4820 return(r); 4821 } 4822 4823 internal smallArrayt* copySmallArray(smallArrayt *self, int64_t start, int64_t end) { 4824 size_t len; 4825 smallt *o = NULL; 4826 4827 len = lenSmallArray(self); 4828 // sanity checks 4829 if (!len) { 4830 return(NULL); 4831 } 4832 4833 if (start >= (int64_t)len) { 4834 return(NULL); 4835 } 4836 if (end > (int64_t)len) { 4837 end = (int64_t)len; 4838 } 4839 if (start <= -(int64_t)len) { 4840 start = -(int64_t)len; 4841 } 4842 if (end <= -(int64_t)len) { 4843 return(NULL); 4844 } 4845 if (start < 0) { 4846 start = (int64_t)len + start; 4847 } 4848 if (end <= 0) { 4849 end = (int64_t)len + end; 4850 } 4851 if (end < start) { 4852 return(NULL); 4853 } 4854 4855 createAllocateSmallArray(r); 4856 if (!r) { 4857 return(NULL); 4858 } 4859 4860 if (start == end) { 4861 // empty list 4862 return(r); 4863 } 4864 else { 4865 // start < end < len 4866 int64_t n; 4867 n = end - start; 4868 4869 for (int64_t i=0;i < n;i++) { 4870 o = sArrayGetTiny(self->a, (uint32_t)(start+i)); 4871 sArrayPushTiny(&(r->a), sDuplicate(o)); 4872 } 4873 } 4874 4875 return(r); 4876 } 4877 4878 internal smallArrayt* insertSmallArray(smallArrayt *self, int64_t index, smallArrayt *toInsert) { 4879 size_t len;; 4880 4881 //sanity checks 4882 if (checkObjectTypes && toInsert && !isOSmallArray(toInsert)) { 4883 return(NULL); 4884 } 4885 4886 if (!toInsert) { 4887 return(NULL); 4888 } 4889 4890 if (self->a == toInsert->a) { 4891 return(NULL); 4892 } 4893 4894 len = lenSmallArray(self); 4895 4896 if (!len && index == -1) { 4897 // empty array, index -1 is equal to 0 4898 index = 0; 4899 } 4900 bool neg = false; 4901 if (index < 0) { 4902 neg = true; 4903 } 4904 4905 if (index > (int64_t)len) { 4906 return(NULL); 4907 } 4908 if (neg) { 4909 index++; 4910 } 4911 if (index < -(int64_t)len) { 4912 return(NULL); 4913 } 4914 if (neg) { 4915 index = (int64_t)len + index; 4916 } 4917 4918 4919 if (!toInsert->f->len(toInsert)) { 4920 return(self); 4921 } 4922 4923 sArrayt *a = allocSArray(); 4924 if (!a) { 4925 return(NULL); 4926 } 4927 4928 smallt *o; 4929 if (index == 0) { 4930 // insert at beginning 4931 for (int64_t i=0;i < (int64_t)toInsert->f->len(toInsert);i++) { 4932 o = sArrayGetTiny(toInsert->a, (uint32_t)i); 4933 sArrayPushTiny(&a, o); 4934 } 4935 for (int64_t i=0;i < (int64_t)len;i++) { 4936 o = sArrayGetTiny(self->a, (uint32_t)i); 4937 sArrayPushTiny(&a, o); 4938 } 4939 } 4940 else { 4941 4942 for (int64_t i=0;i < index;i++) { 4943 o = sArrayGetTiny(self->a, (uint32_t)i); 4944 sArrayPushTiny(&a, o); 4945 } 4946 for (int64_t i=0;i < (int64_t)toInsert->f->len(toInsert);i++) { 4947 o = sArrayGetTiny(toInsert->a, (uint32_t)i); 4948 sArrayPushTiny(&a, o); 4949 } 4950 for (int64_t i=index;i < (int64_t)len;i++) { 4951 o = sArrayGetTiny(self->a, (uint32_t)i); 4952 sArrayPushTiny(&a, o); 4953 } 4954 } 4955 4956 free(self->a); 4957 self->a = a; 4958 return(self); 4959 } 4960 4961 internal smallArrayt* insertSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInsert) { 4962 4963 if (!toInsert) { 4964 return(NULL); 4965 } 4966 4967 if (checkObjectTypes && !isOSmallJson(toInsert)) { 4968 return(NULL); 4969 } 4970 4971 const char *type = getTopTypeO(toInsert); 4972 4973 if (!eqS(type,"array")) { 4974 return(NULL); 4975 } 4976 4977 if (!lenO(toInsert)) { 4978 return(self); 4979 } 4980 4981 createSmallArray(a); 4982 if (!a.f) { 4983 return(NULL); 4984 } 4985 setsoO(&a, (sArrayt*)getsoO(toInsert)); 4986 return(insertSmallArray(self, index, &a)); 4987 } 4988 4989 internal smallArrayt* insertNSmashSmallArray(smallArrayt *self, int64_t index, smallArrayt *toInsert) { 4990 smallArrayt *r = NULL; 4991 4992 r = insertSmallArray(self, index, toInsert); 4993 if (r) { 4994 smashO(toInsert); 4995 } 4996 return(r); 4997 } 4998 4999 internal smallArrayt* insertNSmashSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInsert) { 5000 smallArrayt *r = NULL; 5001 5002 r = insertSmallJsonSmallArray(self, index, toInsert); 5003 if (r) { 5004 smashO(toInsert); 5005 } 5006 return(r); 5007 } 5008 5009 5010 internal smallArrayt* injectSmallArray(smallArrayt *self, int64_t index, baset *toInject) { 5011 size_t len; 5012 5013 if (!toInject) { 5014 return(NULL); 5015 } 5016 5017 len = lenSmallArray(self); 5018 5019 if (!len && index == -1) { 5020 // empty string, index -1 is equal to 0 5021 index = 0; 5022 } 5023 bool neg = false; 5024 if (index < 0) { 5025 neg = true; 5026 } 5027 5028 if (index > (int64_t)len) { 5029 return(NULL); 5030 } 5031 if (neg) { 5032 index++; 5033 } 5034 if (index < -(int64_t)len) { 5035 return(NULL); 5036 } 5037 if (neg) { 5038 index = (int64_t)len + index; 5039 } 5040 5041 5042 sArrayt *a = allocSArray(); 5043 if (!a) { 5044 return(NULL); 5045 } 5046 5047 smallt *o = toSmallt(toInject); 5048 if (!o) { 5049 sFree((smallt*)a); 5050 return(NULL); 5051 } 5052 5053 if (index == 0) { 5054 // inject at beginning 5055 sArrayPushTiny(&a, o); 5056 for (int64_t i=0;i < (int64_t)len;i++) { 5057 o = sArrayGetTiny(self->a, (uint32_t)i); 5058 sArrayPushTiny(&a, o); 5059 } 5060 } 5061 else { 5062 5063 smallt *o2; 5064 for (int64_t i=0;i < index;i++) { 5065 o2 = sArrayGetTiny(self->a, (uint32_t)i); 5066 sArrayPushTiny(&a, o2); 5067 } 5068 sArrayPushTiny(&a, o); 5069 for (int64_t i=index;i < (int64_t)len;i++) { 5070 o = sArrayGetTiny(self->a, (uint32_t)i); 5071 sArrayPushTiny(&a, o); 5072 } 5073 } 5074 5075 free(self->a); 5076 self->a = a; 5077 return(self); 5078 } 5079 5080 internal smallArrayt* injectUndefinedSmallArray(smallArrayt *self, int64_t index) { 5081 size_t len; 5082 5083 len = lenSmallArray(self); 5084 5085 if (!len && index == -1) { 5086 // empty string, index -1 is equal to 0 5087 index = 0; 5088 } 5089 bool neg = false; 5090 if (index < 0) { 5091 neg = true; 5092 } 5093 5094 if (index > (int64_t)len) { 5095 return(NULL); 5096 } 5097 if (neg) { 5098 index++; 5099 } 5100 if (index < -(int64_t)len) { 5101 return(NULL); 5102 } 5103 if (neg) { 5104 index = (int64_t)len + index; 5105 } 5106 5107 5108 sArrayt *a = allocSArray(); 5109 if (!a) { 5110 return(NULL); 5111 } 5112 5113 smallt *o = (smallt *) allocSUndefined(); 5114 5115 if (index == 0) { 5116 // inject at beginning 5117 sArrayPushTiny(&a, o); 5118 for (int64_t i=0;i < (int64_t)len;i++) { 5119 o = sArrayGetTiny(self->a, (uint32_t)i); 5120 sArrayPushTiny(&a, o); 5121 } 5122 } 5123 else { 5124 5125 smallt *o2; 5126 for (int64_t i=0;i < index;i++) { 5127 o2 = sArrayGetTiny(self->a, (uint32_t)i); 5128 sArrayPushTiny(&a, o2); 5129 } 5130 sArrayPushTiny(&a, o); 5131 for (int64_t i=index;i < (int64_t)len;i++) { 5132 o = sArrayGetTiny(self->a, (uint32_t)i); 5133 sArrayPushTiny(&a, o); 5134 } 5135 } 5136 5137 free(self->a); 5138 self->a = a; 5139 return(self); 5140 } 5141 5142 internal smallArrayt* injectBoolSmallArray(smallArrayt *self, int64_t index, bool toInject) { 5143 size_t len; 5144 5145 len = lenSmallArray(self); 5146 5147 if (!len && index == -1) { 5148 // empty string, index -1 is equal to 0 5149 index = 0; 5150 } 5151 bool neg = false; 5152 if (index < 0) { 5153 neg = true; 5154 } 5155 5156 if (index > (int64_t)len) { 5157 return(NULL); 5158 } 5159 if (neg) { 5160 index++; 5161 } 5162 if (index < -(int64_t)len) { 5163 return(NULL); 5164 } 5165 if (neg) { 5166 index = (int64_t)len + index; 5167 } 5168 5169 5170 sArrayt *a = allocSArray(); 5171 if (!a) { 5172 return(NULL); 5173 } 5174 5175 smallt *o = NULL; 5176 o = (smallt *) allocSBool(toInject); 5177 5178 if (index == 0) { 5179 // inject at beginning 5180 sArrayPushTiny(&a, o); 5181 for (int64_t i=0;i < (int64_t)len;i++) { 5182 o = sArrayGetTiny(self->a, (uint32_t)i); 5183 sArrayPushTiny(&a, o); 5184 } 5185 } 5186 else { 5187 5188 smallt *o2; 5189 for (int64_t i=0;i < index;i++) { 5190 o2 = sArrayGetTiny(self->a, (uint32_t)i); 5191 sArrayPushTiny(&a, o2); 5192 } 5193 sArrayPushTiny(&a, o); 5194 for (int64_t i=index;i < (int64_t)len;i++) { 5195 o = sArrayGetTiny(self->a, (uint32_t)i); 5196 sArrayPushTiny(&a, o); 5197 } 5198 } 5199 5200 free(self->a); 5201 self->a = a; 5202 return(self); 5203 } 5204 5205 internal smallArrayt* injectDoubleSmallArray(smallArrayt *self, int64_t index, double toInject) { 5206 size_t len; 5207 5208 len = lenSmallArray(self); 5209 5210 if (!len && index == -1) { 5211 // empty string, index -1 is equal to 0 5212 index = 0; 5213 } 5214 bool neg = false; 5215 if (index < 0) { 5216 neg = true; 5217 } 5218 5219 if (index > (int64_t)len) { 5220 return(NULL); 5221 } 5222 if (neg) { 5223 index++; 5224 } 5225 if (index < -(int64_t)len) { 5226 return(NULL); 5227 } 5228 if (neg) { 5229 index = (int64_t)len + index; 5230 } 5231 5232 5233 sArrayt *a = allocSArray(); 5234 if (!a) { 5235 return(NULL); 5236 } 5237 5238 smallt *o = NULL; 5239 o = (smallt *) allocSDouble(toInject); 5240 5241 if (index == 0) { 5242 // inject at beginning 5243 sArrayPushTiny(&a, o); 5244 for (int64_t i=0;i < (int64_t)len;i++) { 5245 o = sArrayGetTiny(self->a, (uint32_t)i); 5246 sArrayPushTiny(&a, o); 5247 } 5248 } 5249 else { 5250 5251 smallt *o2; 5252 for (int64_t i=0;i < index;i++) { 5253 o2 = sArrayGetTiny(self->a, (uint32_t)i); 5254 sArrayPushTiny(&a, o2); 5255 } 5256 sArrayPushTiny(&a, o); 5257 for (int64_t i=index;i < (int64_t)len;i++) { 5258 o = sArrayGetTiny(self->a, (uint32_t)i); 5259 sArrayPushTiny(&a, o); 5260 } 5261 } 5262 5263 free(self->a); 5264 self->a = a; 5265 return(self); 5266 } 5267 5268 internal smallArrayt* injectIntSmallArray(smallArrayt *self, int64_t index, int64_t toInject) { 5269 size_t len; 5270 5271 len = lenSmallArray(self); 5272 5273 if (!len && index == -1) { 5274 // empty string, index -1 is equal to 0 5275 index = 0; 5276 } 5277 bool neg = false; 5278 if (index < 0) { 5279 neg = true; 5280 } 5281 5282 if (index > (int64_t)len) { 5283 return(NULL); 5284 } 5285 if (neg) { 5286 index++; 5287 } 5288 if (index < -(int64_t)len) { 5289 return(NULL); 5290 } 5291 if (neg) { 5292 index = (int64_t)len + index; 5293 } 5294 5295 5296 sArrayt *a = allocSArray(); 5297 if (!a) { 5298 return(NULL); 5299 } 5300 5301 smallt *o = NULL; 5302 o = (smallt *) allocSInt(toInject); 5303 5304 if (index == 0) { 5305 // inject at beginning 5306 sArrayPushTiny(&a, o); 5307 for (int64_t i=0;i < (int64_t)len;i++) { 5308 o = sArrayGetTiny(self->a, (uint32_t)i); 5309 sArrayPushTiny(&a, o); 5310 } 5311 } 5312 else { 5313 5314 smallt *o2; 5315 for (int64_t i=0;i < index;i++) { 5316 o2 = sArrayGetTiny(self->a, (uint32_t)i); 5317 sArrayPushTiny(&a, o2); 5318 } 5319 sArrayPushTiny(&a, o); 5320 for (int64_t i=index;i < (int64_t)len;i++) { 5321 o = sArrayGetTiny(self->a, (uint32_t)i); 5322 sArrayPushTiny(&a, o); 5323 } 5324 } 5325 5326 free(self->a); 5327 self->a = a; 5328 return(self); 5329 } 5330 5331 internal smallArrayt* injectSSmallArray(smallArrayt *self, int64_t index, const char *toInject) { 5332 size_t len; 5333 5334 if (!toInject) { 5335 return(NULL); 5336 } 5337 5338 len = lenSmallArray(self); 5339 5340 if (!len && index == -1) { 5341 // empty string, index -1 is equal to 0 5342 index = 0; 5343 } 5344 bool neg = false; 5345 if (index < 0) { 5346 neg = true; 5347 } 5348 5349 if (index > (int64_t)len) { 5350 return(NULL); 5351 } 5352 if (neg) { 5353 index++; 5354 } 5355 if (index < -(int64_t)len) { 5356 return(NULL); 5357 } 5358 if (neg) { 5359 index = (int64_t)len + index; 5360 } 5361 5362 5363 sArrayt *a = allocSArray(); 5364 if (!a) { 5365 return(NULL); 5366 } 5367 5368 smallt *o = (smallt *) allocSStringTiny(toInject); 5369 5370 if (index == 0) { 5371 // inject at beginning 5372 sArrayPushTiny(&a, o); 5373 for (int64_t i=0;i < (int64_t)len;i++) { 5374 o = sArrayGetTiny(self->a, (uint32_t)i); 5375 sArrayPushTiny(&a, o); 5376 } 5377 } 5378 else { 5379 5380 smallt *o2; 5381 for (int64_t i=0;i < index;i++) { 5382 o2 = sArrayGetTiny(self->a, (uint32_t)i); 5383 sArrayPushTiny(&a, o2); 5384 } 5385 sArrayPushTiny(&a, o); 5386 for (int64_t i=index;i < (int64_t)len;i++) { 5387 o = sArrayGetTiny(self->a, (uint32_t)i); 5388 sArrayPushTiny(&a, o); 5389 } 5390 } 5391 5392 free(self->a); 5393 self->a = a; 5394 return(self); 5395 } 5396 5397 internal smallArrayt* injectCharSmallArray(smallArrayt *self, int64_t index, char c) { 5398 5399 charToS(s, c); 5400 return(injectSSmallArray(self, index, s)); 5401 } 5402 5403 internal smallArrayt* injectDictSmallArray(smallArrayt *self, int64_t index, smallDictt *toInject) { 5404 size_t len; 5405 5406 if (!toInject) { 5407 return(NULL); 5408 } 5409 5410 if (checkObjectTypes && toInject && !isOSmallDict(toInject)) { 5411 return(NULL); 5412 } 5413 5414 len = lenSmallArray(self); 5415 5416 if (!len && index == -1) { 5417 // empty string, index -1 is equal to 0 5418 index = 0; 5419 } 5420 bool neg = false; 5421 if (index < 0) { 5422 neg = true; 5423 } 5424 5425 if (index > (int64_t)len) { 5426 return(NULL); 5427 } 5428 if (neg) { 5429 index++; 5430 } 5431 if (index < -(int64_t)len) { 5432 return(NULL); 5433 } 5434 if (neg) { 5435 index = (int64_t)len + index; 5436 } 5437 5438 5439 sArrayt *a = allocSArray(); 5440 if (!a) { 5441 return(NULL); 5442 } 5443 5444 if (!toInject->d) { 5445 isError(toInject->d, allocSDict()) return(NULL); 5446 } 5447 5448 smallt *o = (smallt *) toInject->d; 5449 5450 if (index == 0) { 5451 // inject at beginning 5452 sArrayPushTiny(&a, o); 5453 for (int64_t i=0;i < (int64_t)len;i++) { 5454 o = sArrayGetTiny(self->a, (uint32_t)i); 5455 sArrayPushTiny(&a, o); 5456 } 5457 } 5458 else { 5459 5460 smallt *o2; 5461 for (int64_t i=0;i < index;i++) { 5462 o2 = sArrayGetTiny(self->a, (uint32_t)i); 5463 sArrayPushTiny(&a, o2); 5464 } 5465 sArrayPushTiny(&a, o); 5466 for (int64_t i=index;i < (int64_t)len;i++) { 5467 o = sArrayGetTiny(self->a, (uint32_t)i); 5468 sArrayPushTiny(&a, o); 5469 } 5470 } 5471 5472 free(self->a); 5473 self->a = a; 5474 return(self); 5475 } 5476 5477 internal smallArrayt* injectArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *toInject) { 5478 size_t len; 5479 5480 if (!toInject) { 5481 return(NULL); 5482 } 5483 5484 if (checkObjectTypes && toInject && !isOSmallArray(toInject)) { 5485 return(NULL); 5486 } 5487 5488 len = lenSmallArray(self); 5489 5490 if (!len && index == -1) { 5491 // empty string, index -1 is equal to 0 5492 index = 0; 5493 } 5494 bool neg = false; 5495 if (index < 0) { 5496 neg = true; 5497 } 5498 5499 if (index > (int64_t)len) { 5500 return(NULL); 5501 } 5502 if (neg) { 5503 index++; 5504 } 5505 if (index < -(int64_t)len) { 5506 return(NULL); 5507 } 5508 if (neg) { 5509 index = (int64_t)len + index; 5510 } 5511 5512 5513 sArrayt *a = allocSArray(); 5514 if (!a) { 5515 return(NULL); 5516 } 5517 5518 if (!toInject->a) { 5519 isError(toInject->a, allocSArray()) return(NULL); 5520 } 5521 5522 smallt *o = (smallt *) toInject->a; 5523 5524 if (index == 0) { 5525 // inject at beginning 5526 sArrayPushTiny(&a, o); 5527 for (int64_t i=0;i < (int64_t)len;i++) { 5528 o = sArrayGetTiny(self->a, (uint32_t)i); 5529 sArrayPushTiny(&a, o); 5530 } 5531 } 5532 else { 5533 5534 smallt *o2; 5535 for (int64_t i=0;i < index;i++) { 5536 o2 = sArrayGetTiny(self->a, (uint32_t)i); 5537 sArrayPushTiny(&a, o2); 5538 } 5539 sArrayPushTiny(&a, o); 5540 for (int64_t i=index;i < (int64_t)len;i++) { 5541 o = sArrayGetTiny(self->a, (uint32_t)i); 5542 sArrayPushTiny(&a, o); 5543 } 5544 } 5545 5546 free(self->a); 5547 self->a = a; 5548 return(self); 5549 } 5550 5551 internal smallArrayt* injectArraycSmallArray(smallArrayt *self, int64_t index, char **toInject) { 5552 size_t len; 5553 5554 if (!toInject) { 5555 return(NULL); 5556 } 5557 5558 len = lenSmallArray(self); 5559 5560 if (!len && index == -1) { 5561 // empty string, index -1 is equal to 0 5562 index = 0; 5563 } 5564 bool neg = false; 5565 if (index < 0) { 5566 neg = true; 5567 } 5568 5569 if (index > (int64_t)len) { 5570 return(NULL); 5571 } 5572 if (neg) { 5573 index++; 5574 } 5575 if (index < -(int64_t)len) { 5576 return(NULL); 5577 } 5578 if (neg) { 5579 index = (int64_t)len + index; 5580 } 5581 5582 5583 sArrayt *a = allocSArray(); 5584 if (!a) { 5585 return(NULL); 5586 } 5587 5588 smallt *o = NULL; 5589 sArrayt *aa = allocSArray(); 5590 5591 forEachCharP(toInject, e) { 5592 sStringt *s = allocSStringTiny(*e); 5593 if (!s) { 5594 if (a) { 5595 sArrayFreeTiny(a); 5596 } 5597 if (aa) { 5598 sArrayFreeTiny(aa); 5599 } 5600 return(NULL); 5601 } 5602 sArrayPushTiny(&aa, (smallt *) s); 5603 } 5604 o = (smallt *) aa; 5605 5606 if (index == 0) { 5607 // inject at beginning 5608 sArrayPushTiny(&a, o); 5609 for (int64_t i=0;i < (int64_t)len;i++) { 5610 o = sArrayGetTiny(self->a, (uint32_t)i); 5611 sArrayPushTiny(&a, o); 5612 } 5613 } 5614 else { 5615 5616 smallt *o2; 5617 for (int64_t i=0;i < index;i++) { 5618 o2 = sArrayGetTiny(self->a, (uint32_t)i); 5619 sArrayPushTiny(&a, o2); 5620 } 5621 sArrayPushTiny(&a, o); 5622 for (int64_t i=index;i < (int64_t)len;i++) { 5623 o = sArrayGetTiny(self->a, (uint32_t)i); 5624 sArrayPushTiny(&a, o); 5625 } 5626 } 5627 5628 free(self->a); 5629 self->a = a; 5630 return(self); 5631 } 5632 5633 internal smallArrayt* injectCArraycSmallArray(smallArrayt *self, int64_t index, const char **toInject) { 5634 size_t len; 5635 5636 if (!toInject) { 5637 return(NULL); 5638 } 5639 5640 len = lenSmallArray(self); 5641 5642 if (!len && index == -1) { 5643 // empty string, index -1 is equal to 0 5644 index = 0; 5645 } 5646 bool neg = false; 5647 if (index < 0) { 5648 neg = true; 5649 } 5650 5651 if (index > (int64_t)len) { 5652 return(NULL); 5653 } 5654 if (neg) { 5655 index++; 5656 } 5657 if (index < -(int64_t)len) { 5658 return(NULL); 5659 } 5660 if (neg) { 5661 index = (int64_t)len + index; 5662 } 5663 5664 5665 sArrayt *a = allocSArray(); 5666 if (!a) { 5667 return(NULL); 5668 } 5669 5670 smallt *o = NULL; 5671 sArrayt *aa = allocSArray(); 5672 5673 forEachCCharP(toInject, e) { 5674 sStringt *s = allocSStringTiny(*e); 5675 if (!s) { 5676 if (a) { 5677 sArrayFreeTiny(a); 5678 } 5679 if (aa) { 5680 sArrayFreeTiny(aa); 5681 } 5682 return(NULL); 5683 } 5684 sArrayPushTiny(&aa, (smallt *) s); 5685 } 5686 o = (smallt *) aa; 5687 5688 if (index == 0) { 5689 // inject at beginning 5690 sArrayPushTiny(&a, o); 5691 for (int64_t i=0;i < (int64_t)len;i++) { 5692 o = sArrayGetTiny(self->a, (uint32_t)i); 5693 sArrayPushTiny(&a, o); 5694 } 5695 } 5696 else { 5697 5698 smallt *o2; 5699 for (int64_t i=0;i < index;i++) { 5700 o2 = sArrayGetTiny(self->a, (uint32_t)i); 5701 sArrayPushTiny(&a, o2); 5702 } 5703 sArrayPushTiny(&a, o); 5704 for (int64_t i=index;i < (int64_t)len;i++) { 5705 o = sArrayGetTiny(self->a, (uint32_t)i); 5706 sArrayPushTiny(&a, o); 5707 } 5708 } 5709 5710 free(self->a); 5711 self->a = a; 5712 return(self); 5713 } 5714 5715 internal smallArrayt* injectSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *toInject) { 5716 5717 if (!toInject) { 5718 return(NULL); 5719 } 5720 5721 if (checkObjectTypes && toInject && !isOSmallBool(toInject)) { 5722 return(NULL); 5723 } 5724 5725 if (!toInject->value) { 5726 isError(toInject->value, allocSBool(false)) return(NULL); 5727 } 5728 5729 return(injectSmallArray(self, index, (baset*)toInject)); 5730 } 5731 5732 internal smallArrayt* injectSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *toInject) { 5733 5734 if (!toInject) { 5735 return(NULL); 5736 } 5737 5738 if (checkObjectTypes && toInject && !isOSmallBytes(toInject)) { 5739 return(NULL); 5740 } 5741 5742 if (!toInject->B) { 5743 isError(toInject->B, allocSBytes()) return(NULL); 5744 } 5745 5746 return(injectSmallArray(self, index, (baset*)toInject)); 5747 } 5748 5749 internal smallArrayt* injectSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *toInject) { 5750 5751 if (!toInject) { 5752 return(NULL); 5753 } 5754 5755 if (checkObjectTypes && toInject && !isOSmallDouble(toInject)) { 5756 return(NULL); 5757 } 5758 5759 if (!toInject->value) { 5760 isError(toInject->value, allocSDouble(0)) return(NULL); 5761 } 5762 5763 return(injectSmallArray(self, index, (baset*)toInject)); 5764 } 5765 5766 internal smallArrayt* injectSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *toInject) { 5767 5768 if (!toInject) { 5769 return(NULL); 5770 } 5771 5772 if (checkObjectTypes && toInject && !isOSmallInt(toInject)) { 5773 return(NULL); 5774 } 5775 5776 if (!toInject->value) { 5777 isError(toInject->value, allocSInt(0)) return(NULL); 5778 } 5779 5780 return(injectSmallArray(self, index, (baset*)toInject)); 5781 } 5782 5783 internal smallArrayt* injectSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInject) { 5784 5785 if (!toInject) { 5786 return(NULL); 5787 } 5788 5789 if (checkObjectTypes && toInject && !isOSmallJson(toInject)) { 5790 return(NULL); 5791 } 5792 5793 smallt *o = getsoO(toInject); 5794 if (!o) { 5795 // smallJson is empty, create an empty dict 5796 isError(o, (smallt*)allocSDict()) return(NULL); 5797 setsoO(toInject, o); 5798 } 5799 5800 baset *O = getTopO(toInject); 5801 5802 smallArrayt *r = injectSmallArray(self, index, O); 5803 finishO(O); 5804 return(r); 5805 } 5806 5807 internal smallArrayt* injectSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *toInject) { 5808 5809 if (!toInject) { 5810 return(NULL); 5811 } 5812 5813 if (checkObjectTypes && toInject && !isOSmallString(toInject)) { 5814 return(NULL); 5815 } 5816 5817 if (!toInject->data) { 5818 isError(toInject->data, allocSStringTiny("")) return(NULL); 5819 } 5820 5821 return(injectSmallArray(self, index, (baset*)toInject)); 5822 } 5823 5824 internal smallArrayt* injectSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *toInject) { 5825 5826 if (!toInject) { 5827 return(NULL); 5828 } 5829 5830 if (checkObjectTypes && toInject && !isOSmallContainer(toInject)) { 5831 return(NULL); 5832 } 5833 5834 if (!toInject->data) { 5835 isError(toInject->data, allocSContainer(NULL)) return(NULL); 5836 } 5837 5838 return(injectSmallArray(self, index, (baset*)toInject)); 5839 } 5840 5841 internal smallArrayt* injectNFreeSmallArray(smallArrayt *self, int64_t index, baset *toInject) { 5842 size_t len; 5843 5844 if (!toInject) { 5845 return(NULL); 5846 } 5847 5848 len = lenSmallArray(self); 5849 5850 if (!len && index == -1) { 5851 // empty string, index -1 is equal to 0 5852 index = 0; 5853 } 5854 bool neg = false; 5855 if (index < 0) { 5856 neg = true; 5857 } 5858 5859 if (index > (int64_t)len) { 5860 return(NULL); 5861 } 5862 if (neg) { 5863 index++; 5864 } 5865 if (index < -(int64_t)len) { 5866 return(NULL); 5867 } 5868 if (neg) { 5869 index = (int64_t)len + index; 5870 } 5871 5872 5873 sArrayt *a = allocSArray(); 5874 if (!a) { 5875 return(NULL); 5876 } 5877 5878 smallt *o = toSmallt(toInject); 5879 if (!o) { 5880 sFree((smallt*)a); 5881 return(NULL); 5882 } 5883 5884 if (!(o->type == CONTAINER && (((sContainert*)o)->dataType == SH_DT_BASET))) { 5885 finishO(toInject); 5886 } 5887 5888 if (index == 0) { 5889 // inject at beginning 5890 sArrayPushTiny(&a, o); 5891 for (int64_t i=0;i < (int64_t)len;i++) { 5892 o = sArrayGetTiny(self->a, (uint32_t)i); 5893 sArrayPushTiny(&a, o); 5894 } 5895 } 5896 else { 5897 5898 smallt *o2; 5899 for (int64_t i=0;i < index;i++) { 5900 o2 = sArrayGetTiny(self->a, (uint32_t)i); 5901 sArrayPushTiny(&a, o2); 5902 } 5903 sArrayPushTiny(&a, o); 5904 for (int64_t i=index;i < (int64_t)len;i++) { 5905 o = sArrayGetTiny(self->a, (uint32_t)i); 5906 sArrayPushTiny(&a, o); 5907 } 5908 } 5909 5910 free(self->a); 5911 self->a = a; 5912 5913 return(self); 5914 } 5915 5916 internal smallArrayt* injectNFreeUndefinedSmallArray(smallArrayt *self, int64_t index, undefinedt *u) { 5917 5918 smallArrayt *r = injectUndefinedSmallArray(self, index); 5919 if (r) { 5920 terminateO(u); 5921 } 5922 return(r); 5923 } 5924 5925 internal smallArrayt* injectNFreeSSmallArray(smallArrayt *self, int64_t index, char *toInject) { 5926 5927 smallArrayt *r = injectSSmallArray(self, index, toInject); 5928 if (r) { 5929 free(toInject); 5930 } 5931 return(r); 5932 } 5933 5934 internal smallArrayt* injectNFreeDictSmallArray(smallArrayt *self, int64_t index, smallDictt *toInject) { 5935 5936 smallArrayt *r = injectDictSmallArray(self, index, toInject); 5937 if (r) { 5938 finishO(toInject); 5939 } 5940 return(r); 5941 } 5942 5943 internal smallArrayt* injectNFreeArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *toInject) { 5944 5945 smallArrayt *r = injectArraySmallArray(self, index, toInject); 5946 if (r) { 5947 finishO(toInject); 5948 } 5949 return(r); 5950 } 5951 5952 internal smallArrayt* injectNFreeArraycSmallArray(smallArrayt *self, int64_t index, char **toInject) { 5953 5954 smallArrayt *r = injectArraycSmallArray(self, index, toInject); 5955 if (r) { 5956 listFreeS(toInject); 5957 } 5958 return(r); 5959 } 5960 5961 internal smallArrayt* injectNFreeSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *toInject) { 5962 5963 smallArrayt *r = injectSmallBoolSmallArray(self, index, toInject); 5964 if (r) { 5965 finishO(toInject); 5966 } 5967 return(r); 5968 } 5969 5970 internal smallArrayt* injectNFreeSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *toInject) { 5971 5972 smallArrayt *r = injectSmallBytesSmallArray(self, index, toInject); 5973 if (r) { 5974 finishO(toInject); 5975 } 5976 return(r); 5977 } 5978 5979 internal smallArrayt* injectNFreeSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *toInject) { 5980 5981 smallArrayt *r = injectSmallDoubleSmallArray(self, index, toInject); 5982 if (r) { 5983 finishO(toInject); 5984 } 5985 return(r); 5986 } 5987 5988 internal smallArrayt* injectNFreeSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *toInject) { 5989 5990 smallArrayt *r = injectSmallIntSmallArray(self, index, toInject); 5991 if (r) { 5992 finishO(toInject); 5993 } 5994 return(r); 5995 } 5996 5997 internal smallArrayt* injectNFreeSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInject) { 5998 5999 smallArrayt *r = injectSmallJsonSmallArray(self, index, toInject); 6000 if (r) { 6001 finishO(toInject); 6002 } 6003 return(r); 6004 } 6005 6006 internal smallArrayt* injectNFreeSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *toInject) { 6007 6008 smallArrayt *r = injectSmallStringSmallArray(self, index, toInject); 6009 if (r) { 6010 finishO(toInject); 6011 } 6012 return(r); 6013 } 6014 6015 internal smallArrayt* injectNFreeSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *toInject) { 6016 6017 smallArrayt *r = injectSmallContainerSmallArray(self, index, toInject); 6018 if (r) { 6019 finishO(toInject); 6020 } 6021 return(r); 6022 } 6023 6024 internal smallArrayt* delSmallArray(smallArrayt *self, int64_t start, int64_t end) { 6025 size_t len;; 6026 6027 len = lenSmallArray(self); 6028 6029 // sanity checks 6030 if (len == 0) { 6031 return(NULL); 6032 } 6033 6034 if (start >= (int64_t)len) { 6035 start = (int64_t)len; 6036 } 6037 if (end > (int64_t)len) { 6038 end = (int64_t)len; 6039 } 6040 if (start <= -(int64_t)len) { 6041 start = -(int64_t)len; 6042 } 6043 if (end <= -(int64_t)len) { 6044 end = -(int64_t)len; 6045 } 6046 if (start < 0) { 6047 start = (int64_t)len + start; 6048 } 6049 if (end <= 0) { 6050 end = (int64_t)len + end; 6051 } 6052 if (end < start) { 6053 return(NULL); 6054 } 6055 6056 if (start == end) { 6057 return(self); 6058 } 6059 6060 // start < end < len 6061 sArrayDelRangeTiny(self->a, (uint32_t)start, (uint32_t)end); 6062 6063 return(self); 6064 } 6065 6066 internal smallArrayt* delElemSmallArray(smallArrayt *self, int64_t index) { 6067 size_t len;; 6068 6069 len = lenSmallArray(self); 6070 6071 if (index >= (int64_t)len) { 6072 return(NULL); 6073 } 6074 if (index < -(int64_t)len) { 6075 return(NULL); 6076 } 6077 if (index < 0) { 6078 index = (int64_t)len + index; 6079 } 6080 6081 sArrayDelTiny(self->a, (uint32_t)index); 6082 return(self); 6083 } 6084 6085 internal smallArrayt* removeSmallArray(smallArrayt *self, int64_t start, int64_t end) { 6086 size_t len;; 6087 6088 len = lenSmallArray(self); 6089 6090 // sanity checks 6091 if (len == 0) { 6092 return(NULL); 6093 } 6094 6095 if (start >= (int64_t)len) { 6096 start = (int64_t)len; 6097 } 6098 if (end > (int64_t)len) { 6099 end = (int64_t)len; 6100 } 6101 if (start <= -(int64_t)len) { 6102 start = -(int64_t)len; 6103 } 6104 if (end <= -(int64_t)len) { 6105 end = -(int64_t)len; 6106 } 6107 if (start < 0) { 6108 start = (int64_t)len + start; 6109 } 6110 if (end <= 0) { 6111 end = (int64_t)len + end; 6112 } 6113 if (end < start) { 6114 return(NULL); 6115 } 6116 6117 if (start == end) { 6118 return(self); 6119 } 6120 6121 // start < end < len 6122 for (uint32_t i = (uint32_t)start ; i < end ; i++) { 6123 sArraySetShortTiny(self->a, i, NULL); 6124 } 6125 6126 return(self); 6127 } 6128 6129 internal smallArrayt* removeElemSmallArray(smallArrayt *self, int64_t index) { 6130 size_t len;; 6131 6132 len = lenSmallArray(self); 6133 6134 if (index >= (int64_t)len) { 6135 return(NULL); 6136 } 6137 if (index < -(int64_t)len) { 6138 return(NULL); 6139 } 6140 if (index < 0) { 6141 index = (int64_t)len + index; 6142 } 6143 6144 sArraySetShortTiny(self->a, (uint32_t)index, NULL); 6145 return(self); 6146 } 6147 6148 internal int sortSCmp(const void * a, const void * b) { 6149 6150 // sanity checks 6151 smallt *A = (*((smallt *const*)a)); 6152 smallt *B = (*((smallt *const*)b)); 6153 if (!A && !B) { 6154 return(0); 6155 } 6156 if (!A && B) { 6157 return(-1); 6158 } 6159 if (A && !B) { 6160 return(1); 6161 } 6162 char *As, *Bs; 6163 int r; 6164 if (A->type != B->type) { 6165 return(A->type - B->type); 6166 } 6167 else { 6168 switch (A->type){ 6169 case UNDEFINED: 6170 return(0); 6171 case BOOL: 6172 return((((sBoolt*)A)->value < ((sBoolt*)B)->value) * -1); 6173 case CONTAINER: 6174 return(0); 6175 case DICT: 6176 if (((sDictt*)A)->count < ((sDictt*)B)->count) { 6177 return(-1); 6178 } 6179 else if (((sDictt*)A)->count == ((sDictt*)B)->count) { 6180 As = sToString(A); 6181 Bs = sToString(B); 6182 // TODO compare recursively 6183 r = strcmp(As,Bs);; 6184 freeManyS(As,Bs); 6185 return(r); 6186 } 6187 else { 6188 return(1); 6189 } 6190 case DOUBLE: 6191 if (((sDoublet*)A)->value < ((sDoublet*)B)->value) { 6192 return(-1); 6193 } 6194 else if (((sDoublet*)A)->value == ((sDoublet*)B)->value) { 6195 return(0); 6196 } 6197 else { 6198 return(1); 6199 } 6200 case INT: 6201 if (((sIntt*)A)->value < ((sIntt*)B)->value) { 6202 return(-1); 6203 } 6204 else if (((sIntt*)A)->value == ((sIntt*)B)->value) { 6205 return(0); 6206 } 6207 else { 6208 return(1); 6209 } 6210 case STRING: 6211 return(strcmp(sStringGetTiny((sStringt*)A), sStringGetTiny((sStringt*)B))); 6212 case ARRAY: 6213 if (((sArrayt*)A)->count < ((sArrayt*)B)->count) { 6214 return(-1); 6215 } 6216 else if (((sArrayt*)A)->count == ((sArrayt*)B)->count) { 6217 As = sToString(A); 6218 Bs = sToString(B); 6219 // TODO compare recursively 6220 r = strcmp(As,Bs);; 6221 freeManyS(As,Bs); 6222 return(r); 6223 } 6224 else { 6225 return(1); 6226 } 6227 case BYTES: 6228 if (((sBytest*)A)->count < ((sBytest*)B)->count) { 6229 return(-1); 6230 } 6231 else if (((sBytest*)A)->count == ((sBytest*)B)->count) { 6232 return(memcmp(&((sBytest*)A)->data, &((sBytest*)B)->data, ((sBytest*)A)->count)); 6233 } 6234 else { 6235 return(1); 6236 } 6237 default: 6238 return(0); 6239 } 6240 } 6241 } 6242 6243 internal smallArrayt* sortSmallArray(smallArrayt *self) { 6244 size_t len; 6245 6246 len = lenSmallArray(self); 6247 // sanity checks 6248 if (!len) { 6249 return(NULL); 6250 } 6251 // sort 6252 smallt **arr = &(self->a->data); 6253 qsort(arr, lenSmallArray(self), sizeof(smallt *), sortSCmp); 6254 return(self); 6255 } 6256 6257 #if (__APPLE__ || __FreeBSD__ || __DragonFly__) 6258 internal int sortFCmp(void *func, const void *a, const void *b) { 6259 shCmpt cmp; 6260 6261 smallt *A = (*((smallt *const*)a)); 6262 smallt *B = (*((smallt *const*)b)); 6263 6264 baset *aO = toBaset(A);; 6265 baset *bO = toBaset(B);; 6266 6267 cmp = (shCmpt) func; 6268 int r = cmp(aO, bO); 6269 6270 if ((A->type != CONTAINER) || (A->type == CONTAINER && ((sContainert*)A)->dataType != SH_DT_BASET)) { 6271 finishO(aO); 6272 } 6273 if ((A->type != CONTAINER) || (A->type == CONTAINER && ((sContainert*)A)->dataType != SH_DT_BASET)) { 6274 finishO(bO); 6275 } 6276 return(r); 6277 } 6278 #else 6279 internal int sortFCmp(const void *a, const void *b, void *func) { 6280 shCmpt cmp; 6281 6282 smallt *A = (*((smallt *const*)a)); 6283 smallt *B = (*((smallt *const*)b)); 6284 6285 baset *aO = toBaset(A);; 6286 baset *bO = toBaset(B);; 6287 6288 cmp = (shCmpt) func; 6289 int r = cmp(aO, bO); 6290 6291 if ((A->type != CONTAINER) || (A->type == CONTAINER && ((sContainert*)A)->dataType != SH_DT_BASET)) { 6292 finishO(aO); 6293 } 6294 if ((A->type != CONTAINER) || (A->type == CONTAINER && ((sContainert*)A)->dataType != SH_DT_BASET)) { 6295 finishO(bO); 6296 } 6297 return(r); 6298 } 6299 #endif 6300 6301 internal int icSortSCmp(const void * a, const void * b) { 6302 6303 // sanity checks 6304 smallt *A = (*((smallt *const*)a)); 6305 smallt *B = (*((smallt *const*)b)); 6306 if (!A && !B) { 6307 return(0); 6308 } 6309 if (!A && B) { 6310 return(-1); 6311 } 6312 if (A && !B) { 6313 return(1); 6314 } 6315 char *As, *Bs; 6316 int r; 6317 if (A->type != B->type) { 6318 return(A->type - B->type); 6319 } 6320 else { 6321 switch (A->type){ 6322 case UNDEFINED: 6323 return(0); 6324 case BOOL: 6325 return((((sBoolt*)A)->value < ((sBoolt*)B)->value) * -1); 6326 case CONTAINER: 6327 return(0); 6328 case DICT: 6329 if (((sDictt*)A)->count < ((sDictt*)B)->count) { 6330 return(-1); 6331 } 6332 else if (((sDictt*)A)->count == ((sDictt*)B)->count) { 6333 As = sToString(A); 6334 Bs = sToString(B); 6335 // TODO compare recursively 6336 r = strcasecmp(As,Bs);; 6337 freeManyS(As,Bs); 6338 return(r); 6339 } 6340 else { 6341 return(1); 6342 } 6343 case DOUBLE: 6344 if (((sDoublet*)A)->value < ((sDoublet*)B)->value) { 6345 return(-1); 6346 } 6347 else if (((sDoublet*)A)->value == ((sDoublet*)B)->value) { 6348 return(0); 6349 } 6350 else { 6351 return(1); 6352 } 6353 case INT: 6354 if (((sIntt*)A)->value < ((sIntt*)B)->value) { 6355 return(-1); 6356 } 6357 else if (((sIntt*)A)->value == ((sIntt*)B)->value) { 6358 return(0); 6359 } 6360 else { 6361 return(1); 6362 } 6363 case STRING: 6364 return(strcasecmp(sStringGetTiny((sStringt*)A), sStringGetTiny((sStringt*)B))); 6365 case ARRAY: 6366 if (((sArrayt*)A)->count < ((sArrayt*)B)->count) { 6367 return(-1); 6368 } 6369 else if (((sArrayt*)A)->count == ((sArrayt*)B)->count) { 6370 As = sToString(A); 6371 Bs = sToString(B); 6372 // TODO compare recursively 6373 r = strcasecmp(As,Bs);; 6374 freeManyS(As,Bs); 6375 return(r); 6376 } 6377 else { 6378 return(1); 6379 } 6380 case BYTES: 6381 if (((sBytest*)A)->count < ((sBytest*)B)->count) { 6382 return(-1); 6383 } 6384 else if (((sBytest*)A)->count == ((sBytest*)B)->count) { 6385 return(memcmp(&((sBytest*)A)->data, &((sBytest*)B)->data, ((sBytest*)A)->count)); 6386 } 6387 else { 6388 return(1); 6389 } 6390 default: 6391 return(0); 6392 } 6393 } 6394 } 6395 6396 internal smallArrayt* icSortSmallArray(smallArrayt *self) { 6397 size_t len; 6398 6399 len = lenSmallArray(self); 6400 // sanity checks 6401 if (!len) { 6402 return(NULL); 6403 } 6404 // sort 6405 smallt **arr = &(self->a->data); 6406 qsort(arr, lenSmallArray(self), sizeof(smallt *), icSortSCmp); 6407 return(self); 6408 } 6409 6410 #if (__APPLE__ || __FreeBSD__ || __DragonFly__) 6411 // qsort_r has the parameters in a different order 6412 internal smallArrayt* sortFSmallArray(smallArrayt *self, shCmpt compareFunction) { 6413 size_t len; 6414 6415 len = lenSmallArray(self); 6416 // sanity checks 6417 if (!len || !compareFunction) { 6418 return(NULL); 6419 } 6420 // sort 6421 smallt **arr = &(self->a->data); 6422 qsort_r(arr, lenSmallArray(self), sizeof(smallt *), compareFunction, sortFCmp); 6423 return(self); 6424 } 6425 #else 6426 internal smallArrayt* sortFSmallArray(smallArrayt *self, shCmpt compareFunction) { 6427 size_t len; 6428 6429 len = lenSmallArray(self); 6430 // sanity checks 6431 if (!len || !compareFunction) { 6432 return(NULL); 6433 } 6434 // sort 6435 smallt **arr = &(self->a->data); 6436 #if (__TERMUX__ || __OpenBSD__ || MUSL_LIBC || __sun__ || __HAIKU__) 6437 // qsort_r is missing in Termux 6438 smallt *tmp; 6439 QSORT(lenSmallArray(self), LESSsa, SWAPsa); 6440 #else 6441 qsort_r(arr, lenSmallArray(self), sizeof(smallt *), sortFCmp, compareFunction); 6442 #endif 6443 return(self); 6444 } 6445 #endif 6446 6447 internal bool equalSmallArray(smallArrayt *self, smallArrayt *array) { 6448 6449 // sanity checks 6450 if (!array) { 6451 return(false); 6452 } 6453 6454 if (checkObjectTypes && array && !isOSmallArray(array)) { 6455 return(false); 6456 } 6457 6458 if (!lenSmallArray(self) && !lenO(array)) { 6459 // both arrays are empty 6460 return(true); 6461 } 6462 if (!lenSmallArray(self) || !lenO(array)) { 6463 return(false); 6464 } 6465 if (lenSmallArray(self) != lenO(array)) { 6466 return(false); 6467 } 6468 6469 // compare elements 6470 char *es = NULL; 6471 char *as = NULL; 6472 enumerateSArray(self->a, e, i) { 6473 if (not e) { 6474 if (not sArrayGetTiny(array->a, (uint32_t)i)) { 6475 continue; 6476 } 6477 else { 6478 return(false); 6479 } 6480 } 6481 if ((e->type != sArrayGetTiny(array->a, (uint32_t)i)->type)) { 6482 return(false); 6483 } 6484 else { 6485 switch (e->type) { 6486 // not needed always equal - case UNDEFINED: 6487 case BOOL: 6488 if (((sBoolt*)e)->value != ((sBoolt*)sArrayGetTiny(array->a, (uint32_t)i))->value) { 6489 return(false); 6490 } 6491 break; 6492 // TODO case CONTAINER: 6493 case DICT: 6494 es = sToString(e); 6495 as = sToString(sArrayGetTiny(array->a, (uint32_t)i)); 6496 if (!strEq(es, as)) { 6497 free(es); 6498 free(as); 6499 return(false); 6500 } 6501 free(es); 6502 free(as); 6503 break; 6504 case DOUBLE: 6505 if (((sDoublet*)e)->value != ((sDoublet*)sArrayGetTiny(array->a, (uint32_t)i))->value) { 6506 return(false); 6507 } 6508 break; 6509 case INT: 6510 if (((sIntt*)e)->value != ((sIntt*)sArrayGetTiny(array->a, (uint32_t)i))->value) { 6511 return(false); 6512 } 6513 break; 6514 case STRING: 6515 if (!strEq(sStringGetTiny((sStringt*)e), sStringGetTiny((sStringt*)sArrayGetTiny(array->a, (uint32_t)i)))) { 6516 return(false); 6517 } 6518 break; 6519 case ARRAY: 6520 es = sToString(e); 6521 as = sToString(sArrayGetTiny(array->a, (uint32_t)i)); 6522 if (!strEq(es, as)) { 6523 free(es); 6524 free(as); 6525 return(false); 6526 } 6527 free(es); 6528 free(as); 6529 break; 6530 case BYTES: 6531 if (((sBytest*)e)->count != ((sBytest*)sArrayGetTiny(array->a, (uint32_t)i))->count) { 6532 return(false); 6533 } 6534 if (memcmp(&((sBytest*)e)->data, &((sBytest*)sArrayGetTiny(array->a, (uint32_t)i))->data, ((sBytest*)e)->count)) { 6535 return(false); 6536 } 6537 break; 6538 default: 6539 // unsupported type 6540 return(false); 6541 break; 6542 } 6543 } 6544 } 6545 6546 return(true); 6547 } 6548 6549 internal bool equalSmallArraySmallJson(smallArrayt *self, smallJsont *array) { 6550 6551 if (!array) { 6552 return(false); 6553 } 6554 6555 // sanity checks 6556 if (checkObjectTypes && array && !isOSmallJson(array)) { 6557 return(false); 6558 } 6559 6560 return(array->f->equalSmallArray(array, self)); 6561 } 6562 6563 internal bool equalSmallArrayArray(smallArrayt* self, char ** p2) { 6564 6565 // sanity checks 6566 if (!lenSmallArray(self) && !listLengthS(p2)) { 6567 // both arrays are empty 6568 return(true); 6569 } 6570 if (!lenSmallArray(self) || !listLengthS(p2)) { 6571 return(false); 6572 } 6573 if (lenSmallArray(self) != listLengthS(p2)) { 6574 return(false); 6575 } 6576 6577 // compare elements 6578 enumerateSArray(self->a, e, i) { 6579 if (not e) { 6580 return(false); 6581 } 6582 if (e->type != STRING) { 6583 return(false); 6584 } 6585 if (!strEq(sStringGetTiny((sStringt*)e), p2[i])) { 6586 return(false); 6587 } 6588 } 6589 6590 return(true); 6591 } 6592 6593 internal bool equalSmallArrayCArray(smallArrayt* self, const char ** p2) { 6594 6595 // sanity checks 6596 if (!lenSmallArray(self) && !listLengthCS(p2)) { 6597 // both arrays are empty 6598 return(true); 6599 } 6600 if (!lenSmallArray(self) || !listLengthCS(p2)) { 6601 return(false); 6602 } 6603 if (lenSmallArray(self) != listLengthCS(p2)) { 6604 return(false); 6605 } 6606 6607 // compare elements 6608 enumerateSArray(self->a, e, i) { 6609 if (not e) { 6610 return(false); 6611 } 6612 if (e->type != STRING) { 6613 return(false); 6614 } 6615 if (!strEq(sStringGetTiny((sStringt*)e), p2[i])) { 6616 return(false); 6617 } 6618 } 6619 6620 return(true); 6621 } 6622 6623 internal bool equalSmallArrayBase(smallArrayt* self, baset* p2) { 6624 6625 if (!lenSmallArray(self) || !p2) { 6626 return(false); 6627 } 6628 6629 if (!isOType(p2, "smallArray")) { 6630 return(false); 6631 } 6632 6633 cast(smallArrayt *, arr, p2); 6634 6635 return(equalSmallArray(self, arr)); 6636 } 6637 6638 6639 internal bool icEqualSmallArray(smallArrayt *self, smallArrayt *array) { 6640 6641 // sanity checks 6642 if (!array) { 6643 return(false); 6644 } 6645 6646 if (checkObjectTypes && array && !isOSmallArray(array)) { 6647 return(false); 6648 } 6649 6650 if (!lenSmallArray(self) && !lenO(array)) { 6651 // both arrays are empty 6652 return(true); 6653 } 6654 if (!lenSmallArray(self) || !lenO(array)) { 6655 return(false); 6656 } 6657 if (lenSmallArray(self) != lenO(array)) { 6658 return(false); 6659 } 6660 6661 // compare elements 6662 char *es = NULL; 6663 char *as = NULL; 6664 enumerateSArray(self->a, e, i) { 6665 if (not e) { 6666 if (not sArrayGetTiny(array->a, (uint32_t)i)) { 6667 continue; 6668 } 6669 else { 6670 return(false); 6671 } 6672 } 6673 if ((e->type != sArrayGetTiny(array->a, (uint32_t)i)->type)) { 6674 return(false); 6675 } 6676 else { 6677 switch (e->type) { 6678 // not needed always equal - case UNDEFINED: 6679 case BOOL: 6680 if (((sBoolt*)e)->value != ((sBoolt*)sArrayGetTiny(array->a, (uint32_t)i))->value) { 6681 return(false); 6682 } 6683 break; 6684 // TODO case CONTAINER: 6685 case DICT: 6686 es = sToString(e); 6687 as = sToString(sArrayGetTiny(array->a, (uint32_t)i)); 6688 if (!icEqS(es, as)) { 6689 free(es); 6690 free(as); 6691 return(false); 6692 } 6693 free(es); 6694 free(as); 6695 break; 6696 case DOUBLE: 6697 if (((sDoublet*)e)->value != ((sDoublet*)sArrayGetTiny(array->a, (uint32_t)i))->value) { 6698 return(false); 6699 } 6700 break; 6701 case INT: 6702 if (((sIntt*)e)->value != ((sIntt*)sArrayGetTiny(array->a, (uint32_t)i))->value) { 6703 return(false); 6704 } 6705 break; 6706 case STRING: 6707 if (!icEqS(sStringGetTiny((sStringt*)e), sStringGetTiny((sStringt*)sArrayGetTiny(array->a, (uint32_t)i)))) { 6708 return(false); 6709 } 6710 break; 6711 case ARRAY: 6712 es = sToString(e); 6713 as = sToString(sArrayGetTiny(array->a, (uint32_t)i)); 6714 if (!icEqS(es, as)) { 6715 free(es); 6716 free(as); 6717 return(false); 6718 } 6719 free(es); 6720 free(as); 6721 break; 6722 case BYTES: 6723 if (((sBytest*)e)->count != ((sBytest*)sArrayGetTiny(array->a, (uint32_t)i))->count) { 6724 return(false); 6725 } 6726 if (memcmp(&((sBytest*)e)->data, &((sBytest*)sArrayGetTiny(array->a, (uint32_t)i))->data, ((sBytest*)e)->count)) { 6727 return(false); 6728 } 6729 break; 6730 default: 6731 // unsupported type 6732 return(false); 6733 break; 6734 } 6735 } 6736 } 6737 6738 return(true); 6739 } 6740 6741 internal bool icEqualSmallArraySmallJson(smallArrayt *self, smallJsont *array) { 6742 6743 // sanity checks 6744 if (!array) { 6745 return(false); 6746 } 6747 6748 if (checkObjectTypes && !isOSmallJson(array)) { 6749 return(false); 6750 } 6751 6752 const char *type = getTopTypeO(array); 6753 6754 if (!eqS(type,"array")) { 6755 return(false); 6756 } 6757 6758 return(array->f->icEqualSmallArray(array, self)); 6759 } 6760 6761 bool icEqualSmallArrayArray(smallArrayt* self, char ** p2) { 6762 6763 // sanity checks 6764 if (!lenSmallArray(self) && !listLengthS(p2)) { 6765 // both arrays are empty 6766 return(true); 6767 } 6768 if (!lenSmallArray(self) || !listLengthS(p2)) { 6769 return(false); 6770 } 6771 if (lenSmallArray(self) != listLengthS(p2)) { 6772 return(false); 6773 } 6774 6775 // compare elements 6776 enumerateSArray(self->a, e, i) { 6777 if (not e) { 6778 return(false); 6779 } 6780 if (e->type != STRING) { 6781 return(false); 6782 } 6783 if (!icEqS(sStringGetTiny((sStringt*)e), p2[i])) { 6784 return(false); 6785 } 6786 } 6787 6788 return(true); 6789 } 6790 6791 bool icEqualSmallArrayCArray(smallArrayt* self, const char ** p2) { 6792 6793 // sanity checks 6794 if (!lenSmallArray(self) && !listLengthCS(p2)) { 6795 // both arrays are empty 6796 return(true); 6797 } 6798 if (!lenSmallArray(self) || !listLengthCS(p2)) { 6799 return(false); 6800 } 6801 if (lenSmallArray(self) != listLengthCS(p2)) { 6802 return(false); 6803 } 6804 6805 // compare elements 6806 enumerateSArray(self->a, e, i) { 6807 if (not e) { 6808 return(false); 6809 } 6810 if (e->type != STRING) { 6811 return(false); 6812 } 6813 if (!icEqS(sStringGetTiny((sStringt*)e), p2[i])) { 6814 return(false); 6815 } 6816 } 6817 6818 return(true); 6819 } 6820 6821 bool icEqualSmallArrayBase(smallArrayt* self, baset* p2) { 6822 6823 if (!lenSmallArray(self) || !p2) { 6824 return(false); 6825 } 6826 6827 if (!isOType(p2, "smallArray")) { 6828 return(false); 6829 } 6830 6831 cast(smallArrayt *, arr, p2); 6832 6833 return(icEqualSmallArray(self, arr)); 6834 } 6835 6836 6837 internal size_t lenSmallArray(smallArrayt *self) { 6838 6839 if (!self->a) { 6840 return(0); 6841 } 6842 6843 return(self->a->count); 6844 } 6845 6846 internal smallArrayt* trimSmallArray(smallArrayt *self) { 6847 smallt *o = NULL; 6848 sArrayt *a = NULL; 6849 6850 a = allocSArray(); 6851 if (!a) { 6852 return(NULL); 6853 } 6854 6855 for (size_t i = 0 ; i < lenSmallArray(self); i++) { 6856 o = sArrayGetTiny(self->a, (uint32_t)i); 6857 if (o) { 6858 sArrayPushTiny(&a, o); 6859 } 6860 } 6861 6862 free(self->a); 6863 self->a = a; 6864 return(self); 6865 } 6866 6867 baset* getAtSmallArray(smallArrayt *self, int64_t index) { 6868 6869 if (index >= (int64_t)lenSmallArray(self)) { 6870 return(NULL); 6871 } 6872 if (index < -(int64_t)lenSmallArray(self)) { 6873 return(NULL); 6874 } 6875 if (index < 0) { 6876 index = (int64_t)lenSmallArray(self) + index; 6877 } 6878 6879 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 6880 if (!o) { 6881 return(NULL); 6882 } 6883 6884 baset *r = toBaset(o); 6885 return(r); 6886 } 6887 6888 internal undefinedt* getAtUndefinedSmallArray(smallArrayt *self, int64_t index) { 6889 6890 if (index >= (int64_t)lenSmallArray(self)) { 6891 return(NULL); 6892 } 6893 if (index < -(int64_t)lenSmallArray(self)) { 6894 return(NULL); 6895 } 6896 if (index < 0) { 6897 index = (int64_t)lenSmallArray(self) + index; 6898 } 6899 6900 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 6901 if (!o) { 6902 return(NULL); 6903 } 6904 if (o->type != UNDEFINED) { 6905 return(NULL); 6906 } 6907 return(allocUndefined()); 6908 } 6909 6910 internal bool getAtBoolSmallArray(smallArrayt *self, int64_t index) { 6911 smallBoolt *e = NULL; 6912 bool r = false;; 6913 6914 e = getAtSmallBoolSmallArray(self, index); 6915 if (e) { 6916 r = e->f->get(e); 6917 finishO(e); 6918 } 6919 return(r); 6920 } 6921 6922 internal bool* getAtBoolPSmallArray(smallArrayt *self, int64_t index) { 6923 smallBoolt *e = NULL; 6924 bool* r = NULL; 6925 6926 e = getAtSmallBoolSmallArray(self, index); 6927 if (e) { 6928 r = e->f->getP(e); 6929 finishO(e); 6930 } 6931 return(r); 6932 } 6933 6934 internal double getAtDoubleSmallArray(smallArrayt *self, int64_t index) { 6935 smallDoublet *e = NULL; 6936 double r = 0;; 6937 6938 e = getAtSmallDoubleSmallArray(self, index); 6939 if (e) { 6940 r = e->f->get(e); 6941 finishO(e); 6942 } 6943 return(r); 6944 } 6945 6946 internal double* getAtDoublePSmallArray(smallArrayt *self, int64_t index) { 6947 smallDoublet *e = NULL; 6948 double* r = NULL; 6949 6950 e = getAtSmallDoubleSmallArray(self, index); 6951 if (e) { 6952 r = e->f->getP(e); 6953 finishO(e); 6954 } 6955 return(r); 6956 } 6957 6958 internal int64_t getAtIntSmallArray(smallArrayt *self, int64_t index) { 6959 smallIntt *e = NULL; 6960 int64_t r = 0;; 6961 6962 e = getAtSmallIntSmallArray(self, index); 6963 if (e) { 6964 r = e->f->get(e); 6965 finishO(e); 6966 } 6967 return(r); 6968 } 6969 6970 internal int64_t* getAtIntPSmallArray(smallArrayt *self, int64_t index) { 6971 smallIntt *e = NULL; 6972 int64_t* r = NULL; 6973 6974 e = getAtSmallIntSmallArray(self, index); 6975 if (e) { 6976 r = e->f->getP(e); 6977 finishO(e); 6978 } 6979 return(r); 6980 } 6981 6982 internal int32_t getAtInt32SmallArray(smallArrayt *self, int64_t index) { 6983 smallIntt *e = NULL; 6984 int32_t r = 0;; 6985 6986 e = getAtSmallIntSmallArray(self, index); 6987 if (e) { 6988 r = (int32_t)e->f->get(e); 6989 finishO(e); 6990 } 6991 return(r); 6992 } 6993 6994 internal int32_t* getAtInt32PSmallArray(smallArrayt *self, int64_t index) { 6995 smallIntt *e = NULL; 6996 int32_t* r = NULL; 6997 6998 e = getAtSmallIntSmallArray(self, index); 6999 if (e) { 7000 r = (int32_t *)e->f->getP(e); 7001 finishO(e); 7002 } 7003 return(r); 7004 } 7005 7006 internal uint64_t getAtUintSmallArray(smallArrayt *self, int64_t index) { 7007 smallIntt *e = NULL; 7008 uint64_t r = 0;; 7009 7010 e = getAtSmallIntSmallArray(self, index); 7011 if (e) { 7012 r = (uint64_t)e->f->get(e); 7013 finishO(e); 7014 } 7015 return(r); 7016 } 7017 7018 internal uint64_t* getAtUintPSmallArray(smallArrayt *self, int64_t index) { 7019 smallIntt *e = NULL; 7020 uint64_t* r = NULL; 7021 7022 e = getAtSmallIntSmallArray(self, index); 7023 if (e) { 7024 r = (uint64_t *)e->f->getP(e); 7025 finishO(e); 7026 } 7027 return(r); 7028 } 7029 7030 internal uint32_t getAtUint32SmallArray(smallArrayt *self, int64_t index) { 7031 smallIntt *e = NULL; 7032 uint32_t r = 0;; 7033 7034 e = getAtSmallIntSmallArray(self, index); 7035 if (e) { 7036 r = (uint32_t)e->f->get(e); 7037 finishO(e); 7038 } 7039 return(r); 7040 } 7041 7042 internal uint32_t* getAtUint32PSmallArray(smallArrayt *self, int64_t index) { 7043 smallIntt *e = NULL; 7044 uint32_t* r = NULL; 7045 7046 e = getAtSmallIntSmallArray(self, index); 7047 if (e) { 7048 r = (uint32_t *)e->f->getP(e); 7049 finishO(e); 7050 } 7051 return(r); 7052 } 7053 7054 internal char* getAtSSmallArray(smallArrayt *self, int64_t index) { 7055 smallStringt *e = NULL; 7056 char* r = NULL; 7057 7058 e = getAtSmallStringSmallArray(self, index); 7059 if (e) { 7060 r = e->f->get(e); 7061 finishO(e); 7062 } 7063 return(r); 7064 } 7065 7066 internal smallDictt* getAtDictSmallArray(smallArrayt *self, int64_t index) { 7067 7068 if (index >= (int64_t)lenSmallArray(self)) { 7069 return(NULL); 7070 } 7071 if (index < -(int64_t)lenSmallArray(self)) { 7072 return(NULL); 7073 } 7074 if (index < 0) { 7075 index = (int64_t)lenSmallArray(self) + index; 7076 } 7077 7078 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 7079 if (!o) { 7080 return(NULL); 7081 } 7082 if (o->type != DICT) { 7083 return(NULL); 7084 } 7085 return((smallDictt*) toBaset(o)); 7086 } 7087 7088 internal smallArrayt* getAtArraySmallArray(smallArrayt *self, int64_t index) { 7089 7090 if (index >= (int64_t)lenSmallArray(self)) { 7091 return(NULL); 7092 } 7093 if (index < -(int64_t)lenSmallArray(self)) { 7094 return(NULL); 7095 } 7096 if (index < 0) { 7097 index = (int64_t)lenSmallArray(self) + index; 7098 } 7099 7100 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 7101 if (!o) { 7102 return(NULL); 7103 } 7104 if (o->type != ARRAY) { 7105 return(NULL); 7106 } 7107 return((smallArrayt*) toBaset(o)); 7108 } 7109 7110 internal smallBoolt* getAtSmallBoolSmallArray(smallArrayt *self, int64_t index) { 7111 7112 if (index >= (int64_t)lenSmallArray(self)) { 7113 return(NULL); 7114 } 7115 if (index < -(int64_t)lenSmallArray(self)) { 7116 return(NULL); 7117 } 7118 if (index < 0) { 7119 index = (int64_t)lenSmallArray(self) + index; 7120 } 7121 7122 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 7123 if (!o) { 7124 return(NULL); 7125 } 7126 if (o->type != BOOL) { 7127 return(NULL); 7128 } 7129 return((smallBoolt*) toBaset(o)); 7130 } 7131 7132 internal smallBytest* getAtSmallBytesSmallArray(smallArrayt *self, int64_t index) { 7133 7134 if (index >= (int64_t)lenSmallArray(self)) { 7135 return(NULL); 7136 } 7137 if (index < -(int64_t)lenSmallArray(self)) { 7138 return(NULL); 7139 } 7140 if (index < 0) { 7141 index = (int64_t)lenSmallArray(self) + index; 7142 } 7143 7144 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 7145 if (!o) { 7146 return(NULL); 7147 } 7148 if (o->type != BYTES) { 7149 return(NULL); 7150 } 7151 return((smallBytest*) toBaset(o)); 7152 } 7153 7154 internal smallDoublet* getAtSmallDoubleSmallArray(smallArrayt *self, int64_t index) { 7155 7156 if (index >= (int64_t)lenSmallArray(self)) { 7157 return(NULL); 7158 } 7159 if (index < -(int64_t)lenSmallArray(self)) { 7160 return(NULL); 7161 } 7162 if (index < 0) { 7163 index = (int64_t)lenSmallArray(self) + index; 7164 } 7165 7166 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 7167 if (!o) { 7168 return(NULL); 7169 } 7170 if (o->type != DOUBLE) { 7171 return(NULL); 7172 } 7173 return((smallDoublet*) toBaset(o)); 7174 } 7175 7176 internal smallIntt* getAtSmallIntSmallArray(smallArrayt *self, int64_t index) { 7177 7178 if (index >= (int64_t)lenSmallArray(self)) { 7179 return(NULL); 7180 } 7181 if (index < -(int64_t)lenSmallArray(self)) { 7182 return(NULL); 7183 } 7184 if (index < 0) { 7185 index = (int64_t)lenSmallArray(self) + index; 7186 } 7187 7188 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 7189 if (!o) { 7190 return(NULL); 7191 } 7192 if (o->type != INT) { 7193 return(NULL); 7194 } 7195 return((smallIntt*) toBaset(o)); 7196 } 7197 7198 internal smallJsont* getAtSmallJsonSmallArray(smallArrayt *self, int64_t index) { 7199 7200 if (index >= (int64_t)lenSmallArray(self)) { 7201 return(NULL); 7202 } 7203 if (index < -(int64_t)lenSmallArray(self)) { 7204 return(NULL); 7205 } 7206 if (index < 0) { 7207 index = (int64_t)lenSmallArray(self) + index; 7208 } 7209 7210 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 7211 if (!o) { 7212 return(NULL); 7213 } 7214 if ((o->type == BYTES) || (o->type == CONTAINER)) { 7215 return(NULL); 7216 } 7217 baset *e = toBaset(o); 7218 7219 createAllocateSmallJson(r); 7220 if (!r) { 7221 finishO(e); 7222 return(NULL); 7223 } 7224 setTopNFreeO(r, e); 7225 return(r); 7226 } 7227 7228 internal smallStringt* getAtSmallStringSmallArray(smallArrayt *self, int64_t index) { 7229 7230 if (index >= (int64_t)lenSmallArray(self)) { 7231 return(NULL); 7232 } 7233 if (index < -(int64_t)lenSmallArray(self)) { 7234 return(NULL); 7235 } 7236 if (index < 0) { 7237 index = (int64_t)lenSmallArray(self) + index; 7238 } 7239 7240 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 7241 if (!o) { 7242 return(NULL); 7243 } 7244 if (o->type != STRING) { 7245 return(NULL); 7246 } 7247 return((smallStringt*) toBaset(o)); 7248 } 7249 7250 internal void* getAtVoidSmallArray(smallArrayt *self, int64_t index) { 7251 smallContainert *e = NULL; 7252 void* r = NULL; 7253 7254 e = getAtSmallContainerSmallArray(self, index); 7255 if (e) { 7256 r = e->f->get(e); 7257 finishO(e); 7258 } 7259 return(r); 7260 } 7261 7262 internal smallContainert* getAtSmallContainerSmallArray(smallArrayt *self, int64_t index) { 7263 7264 if (index >= (int64_t)lenSmallArray(self)) { 7265 return(NULL); 7266 } 7267 if (index < -(int64_t)lenSmallArray(self)) { 7268 return(NULL); 7269 } 7270 if (index < 0) { 7271 index = (int64_t)lenSmallArray(self) + index; 7272 } 7273 7274 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 7275 if (!o) { 7276 return(NULL); 7277 } 7278 if (o->type != CONTAINER) { 7279 return(NULL); 7280 } 7281 if (((sContainert*)o)->dataType == SH_DT_BASET) { 7282 return(NULL); 7283 } 7284 return((smallContainert*) toBaset(o)); 7285 } 7286 7287 baset* getAtNDupSmallArray(smallArrayt *self, int64_t index) { 7288 7289 if (index >= (int64_t)lenSmallArray(self)) { 7290 return(NULL); 7291 } 7292 if (index < -(int64_t)lenSmallArray(self)) { 7293 return(NULL); 7294 } 7295 if (index < 0) { 7296 index = (int64_t)lenSmallArray(self) + index; 7297 } 7298 7299 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 7300 if (!o) { 7301 return(NULL); 7302 } 7303 7304 if (o->type == UNDEFINED) { 7305 return((baset*) allocUndefined()); 7306 } 7307 7308 if (o->type == CONTAINER && (((sContainert*)o)->dataType == SH_DT_BASET)) { 7309 baset *b = ((sContainert*)o)->data; 7310 return(duplicateO(b)); 7311 } 7312 return(toBaset(sDuplicate(o))); 7313 } 7314 7315 internal undefinedt* getAtNDupUndefinedSmallArray(smallArrayt *self, int64_t index) { 7316 7317 if (index >= (int64_t)lenSmallArray(self)) { 7318 return(NULL); 7319 } 7320 if (index < -(int64_t)lenSmallArray(self)) { 7321 return(NULL); 7322 } 7323 if (index < 0) { 7324 index = (int64_t)lenSmallArray(self) + index; 7325 } 7326 7327 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 7328 if (!o) { 7329 return(NULL); 7330 } 7331 if (o->type != UNDEFINED) { 7332 return(NULL); 7333 } 7334 return(allocUndefined()); 7335 } 7336 7337 internal bool getAtNDupBoolSmallArray(smallArrayt *self, int64_t index) { 7338 smallBoolt *e = NULL; 7339 bool r = false;; 7340 7341 e = getAtNDupSmallBoolSmallArray(self, index); 7342 if (e) { 7343 r = e->f->get(e); 7344 terminateO(e); 7345 } 7346 return(r); 7347 } 7348 7349 internal double getAtNDupDoubleSmallArray(smallArrayt *self, int64_t index) { 7350 smallDoublet *e = NULL; 7351 double r = 0;; 7352 7353 e = getAtNDupSmallDoubleSmallArray(self, index); 7354 if (e) { 7355 r = e->f->get(e); 7356 terminateO(e); 7357 } 7358 return(r); 7359 } 7360 7361 internal int64_t getAtNDupIntSmallArray(smallArrayt *self, int64_t index) { 7362 smallIntt *e = NULL; 7363 int64_t r = 0;; 7364 7365 e = getAtNDupSmallIntSmallArray(self, index); 7366 if (e) { 7367 r = e->f->get(e); 7368 terminateO(e); 7369 } 7370 return(r); 7371 } 7372 7373 internal int32_t getAtNDupInt32SmallArray(smallArrayt *self, int64_t index) { 7374 smallIntt *e = NULL; 7375 int32_t r = 0;; 7376 7377 e = getAtNDupSmallIntSmallArray(self, index); 7378 if (e) { 7379 r = (int32_t)e->f->get(e); 7380 terminateO(e); 7381 } 7382 return(r); 7383 } 7384 7385 internal uint64_t getAtNDupUintSmallArray(smallArrayt *self, int64_t index) { 7386 smallIntt *e = NULL; 7387 uint64_t r = 0;; 7388 7389 e = getAtNDupSmallIntSmallArray(self, index); 7390 if (e) { 7391 r = (uint64_t)e->f->get(e); 7392 terminateO(e); 7393 } 7394 return(r); 7395 } 7396 7397 internal uint32_t getAtNDupUint32SmallArray(smallArrayt *self, int64_t index) { 7398 smallIntt *e = NULL; 7399 uint32_t r = 0;; 7400 7401 e = getAtNDupSmallIntSmallArray(self, index); 7402 if (e) { 7403 r = (uint32_t)e->f->get(e); 7404 terminateO(e); 7405 } 7406 return(r); 7407 } 7408 7409 internal char* getAtNDupSSmallArray(smallArrayt *self, int64_t index) { 7410 smallStringt *e = NULL; 7411 char* r = NULL; 7412 7413 e = getAtNDupSmallStringSmallArray(self, index); 7414 if (e) { 7415 r = e->f->toString(e); 7416 terminateO(e); 7417 } 7418 return(r); 7419 } 7420 7421 internal smallDictt* getAtNDupDictSmallArray(smallArrayt *self, int64_t index) { 7422 7423 if (index >= (int64_t)lenSmallArray(self)) { 7424 return(NULL); 7425 } 7426 if (index < -(int64_t)lenSmallArray(self)) { 7427 return(NULL); 7428 } 7429 if (index < 0) { 7430 index = (int64_t)lenSmallArray(self) + index; 7431 } 7432 7433 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 7434 if (!o) { 7435 return(NULL); 7436 } 7437 if (o->type != DICT) { 7438 return(NULL); 7439 } 7440 return((smallDictt*)toBaset(sDuplicate(o))); 7441 } 7442 7443 internal smallArrayt* getAtNDupArraySmallArray(smallArrayt *self, int64_t index) { 7444 7445 if (index >= (int64_t)lenSmallArray(self)) { 7446 return(NULL); 7447 } 7448 if (index < -(int64_t)lenSmallArray(self)) { 7449 return(NULL); 7450 } 7451 if (index < 0) { 7452 index = (int64_t)lenSmallArray(self) + index; 7453 } 7454 7455 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 7456 if (!o) { 7457 return(NULL); 7458 } 7459 if (o->type != ARRAY) { 7460 return(NULL); 7461 } 7462 return((smallArrayt*)toBaset(sDuplicate(o))); 7463 } 7464 7465 internal smallBoolt* getAtNDupSmallBoolSmallArray(smallArrayt *self, int64_t index) { 7466 7467 if (index >= (int64_t)lenSmallArray(self)) { 7468 return(NULL); 7469 } 7470 if (index < -(int64_t)lenSmallArray(self)) { 7471 return(NULL); 7472 } 7473 if (index < 0) { 7474 index = (int64_t)lenSmallArray(self) + index; 7475 } 7476 7477 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 7478 if (!o) { 7479 return(NULL); 7480 } 7481 if (o->type != BOOL) { 7482 return(NULL); 7483 } 7484 return((smallBoolt*)toBaset(sDuplicate(o))); 7485 } 7486 7487 internal smallBytest* getAtNDupSmallBytesSmallArray(smallArrayt *self, int64_t index) { 7488 7489 if (index >= (int64_t)lenSmallArray(self)) { 7490 return(NULL); 7491 } 7492 if (index < -(int64_t)lenSmallArray(self)) { 7493 return(NULL); 7494 } 7495 if (index < 0) { 7496 index = (int64_t)lenSmallArray(self) + index; 7497 } 7498 7499 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 7500 if (!o) { 7501 return(NULL); 7502 } 7503 if (o->type != BYTES) { 7504 return(NULL); 7505 } 7506 return((smallBytest*)toBaset(sDuplicate(o))); 7507 } 7508 7509 internal smallDoublet* getAtNDupSmallDoubleSmallArray(smallArrayt *self, int64_t index) { 7510 7511 if (index >= (int64_t)lenSmallArray(self)) { 7512 return(NULL); 7513 } 7514 if (index < -(int64_t)lenSmallArray(self)) { 7515 return(NULL); 7516 } 7517 if (index < 0) { 7518 index = (int64_t)lenSmallArray(self) + index; 7519 } 7520 7521 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 7522 if (!o) { 7523 return(NULL); 7524 } 7525 if (o->type != DOUBLE) { 7526 return(NULL); 7527 } 7528 return((smallDoublet*)toBaset(sDuplicate(o))); 7529 } 7530 7531 internal smallIntt* getAtNDupSmallIntSmallArray(smallArrayt *self, int64_t index) { 7532 7533 if (index >= (int64_t)lenSmallArray(self)) { 7534 return(NULL); 7535 } 7536 if (index < -(int64_t)lenSmallArray(self)) { 7537 return(NULL); 7538 } 7539 if (index < 0) { 7540 index = (int64_t)lenSmallArray(self) + index; 7541 } 7542 7543 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 7544 if (!o) { 7545 return(NULL); 7546 } 7547 if (o->type != INT) { 7548 return(NULL); 7549 } 7550 return((smallIntt*)toBaset(sDuplicate(o))); 7551 } 7552 7553 internal smallJsont* getAtNDupSmallJsonSmallArray(smallArrayt *self, int64_t index) { 7554 7555 if (index >= (int64_t)lenSmallArray(self)) { 7556 return(NULL); 7557 } 7558 if (index < -(int64_t)lenSmallArray(self)) { 7559 return(NULL); 7560 } 7561 if (index < 0) { 7562 index = (int64_t)lenSmallArray(self) + index; 7563 } 7564 7565 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 7566 if (!o) { 7567 return(NULL); 7568 } 7569 if ((o->type == BYTES) || (o->type == CONTAINER)) { 7570 return(NULL); 7571 } 7572 7573 baset *e = toBaset(sDuplicate(o)); 7574 7575 createAllocateSmallJson(r); 7576 if (!r) { 7577 finishO(e); 7578 return(NULL); 7579 } 7580 setTopNFreeO(r, e); 7581 return(r); 7582 } 7583 7584 internal smallStringt* getAtNDupSmallStringSmallArray(smallArrayt *self, int64_t index) { 7585 7586 if (index >= (int64_t)lenSmallArray(self)) { 7587 return(NULL); 7588 } 7589 if (index < -(int64_t)lenSmallArray(self)) { 7590 return(NULL); 7591 } 7592 if (index < 0) { 7593 index = (int64_t)lenSmallArray(self) + index; 7594 } 7595 7596 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 7597 if (!o) { 7598 return(NULL); 7599 } 7600 if (o->type != STRING) { 7601 return(NULL); 7602 } 7603 return((smallStringt*)toBaset(sDuplicate(o))); 7604 } 7605 7606 internal void* getAtNDupVoidSmallArray(smallArrayt *self, int64_t index) { 7607 smallContainert *e = NULL; 7608 void* r = NULL; 7609 7610 e = getAtNDupSmallContainerSmallArray(self, index); 7611 if (e) { 7612 r = e->f->get(e); 7613 smashO(e); 7614 } 7615 return(r); 7616 } 7617 7618 internal smallContainert* getAtNDupSmallContainerSmallArray(smallArrayt *self, int64_t index) { 7619 7620 if (index >= (int64_t)lenSmallArray(self)) { 7621 return(NULL); 7622 } 7623 if (index < -(int64_t)lenSmallArray(self)) { 7624 return(NULL); 7625 } 7626 if (index < 0) { 7627 index = (int64_t)lenSmallArray(self) + index; 7628 } 7629 7630 smallt *o = sArrayGetTiny(self->a, (uint32_t)index); 7631 if (!o) { 7632 return(NULL); 7633 } 7634 if (o->type != CONTAINER) { 7635 return(NULL); 7636 } 7637 if (((sContainert*)o)->dataType == SH_DT_BASET) { 7638 return(NULL); 7639 } 7640 smallContainert *e = (smallContainert*)toBaset(o); 7641 smallContainert *r = duplicateO(e); 7642 finishO(e); 7643 return(r); 7644 } 7645 7646 internal smallArrayt* setAtSmallArray(smallArrayt *self, int64_t index, baset *value) { 7647 7648 if (!value) { 7649 return(NULL); 7650 } 7651 7652 if (index >= (int64_t)lenSmallArray(self)) { 7653 return(NULL); 7654 } 7655 if (index < -(int64_t)lenSmallArray(self)) { 7656 return(NULL); 7657 } 7658 if (index < 0) { 7659 index = (int64_t)lenSmallArray(self) + index; 7660 } 7661 7662 sArraySetTiny(self->a, (uint32_t)index, toSmallt(value)); 7663 return(self); 7664 } 7665 7666 internal smallArrayt* setAtUndefinedSmallArray(smallArrayt *self, int64_t index) { 7667 7668 if (index >= (int64_t)lenSmallArray(self)) { 7669 return(NULL); 7670 } 7671 if (index < -(int64_t)lenSmallArray(self)) { 7672 return(NULL); 7673 } 7674 if (index < 0) { 7675 index = (int64_t)lenSmallArray(self) + index; 7676 } 7677 7678 smallt *o = (smallt *) allocSUndefined(); 7679 if (!o) { 7680 return(NULL); 7681 } 7682 sArraySetTiny(self->a, (uint32_t)index, o); 7683 return(self); 7684 } 7685 7686 internal smallArrayt* setAtBoolSmallArray(smallArrayt *self, int64_t index, bool value) { 7687 7688 if (index >= (int64_t)lenSmallArray(self)) { 7689 return(NULL); 7690 } 7691 if (index < -(int64_t)lenSmallArray(self)) { 7692 return(NULL); 7693 } 7694 if (index < 0) { 7695 index = (int64_t)lenSmallArray(self) + index; 7696 } 7697 7698 smallt *o = (smallt *) allocSBool(value); 7699 if (!o) { 7700 return(NULL); 7701 } 7702 sArraySetTiny(self->a, (uint32_t)index, o); 7703 return(self); 7704 } 7705 7706 internal smallArrayt* setAtDoubleSmallArray(smallArrayt *self, int64_t index, double value) { 7707 7708 if (index >= (int64_t)lenSmallArray(self)) { 7709 return(NULL); 7710 } 7711 if (index < -(int64_t)lenSmallArray(self)) { 7712 return(NULL); 7713 } 7714 if (index < 0) { 7715 index = (int64_t)lenSmallArray(self) + index; 7716 } 7717 7718 smallt *o = (smallt *) allocSDouble(value); 7719 if (!o) { 7720 return(NULL); 7721 } 7722 sArraySetTiny(self->a, (uint32_t)index, o); 7723 return(self); 7724 } 7725 7726 internal smallArrayt* setAtIntSmallArray(smallArrayt *self, int64_t index, int64_t value) { 7727 7728 if (index >= (int64_t)lenSmallArray(self)) { 7729 return(NULL); 7730 } 7731 if (index < -(int64_t)lenSmallArray(self)) { 7732 return(NULL); 7733 } 7734 if (index < 0) { 7735 index = (int64_t)lenSmallArray(self) + index; 7736 } 7737 7738 smallt *o = (smallt *) allocSInt(value); 7739 if (!o) { 7740 return(NULL); 7741 } 7742 sArraySetTiny(self->a, (uint32_t)index, o); 7743 return(self); 7744 } 7745 7746 internal smallArrayt* setAtSSmallArray(smallArrayt *self, int64_t index, const char *string) { 7747 7748 if (!string) { 7749 return(NULL); 7750 } 7751 7752 if (index >= (int64_t)lenSmallArray(self)) { 7753 return(NULL); 7754 } 7755 if (index < -(int64_t)lenSmallArray(self)) { 7756 return(NULL); 7757 } 7758 if (index < 0) { 7759 index = (int64_t)lenSmallArray(self) + index; 7760 } 7761 7762 smallt *o; 7763 isError(o, (smallt *) allocSStringTiny(string)) return(NULL); 7764 sArraySetTiny(self->a, (uint32_t)index, o); 7765 return(self); 7766 } 7767 7768 internal smallArrayt* setAtCharSmallArray(smallArrayt *self, int64_t index, char c) { 7769 7770 charToS(s, c); 7771 return(setAtSSmallArray(self, index, s)); 7772 } 7773 7774 internal smallArrayt* setAtDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict) { 7775 7776 if (!dict) { 7777 return(NULL); 7778 } 7779 7780 if (checkObjectTypes && dict && !isOSmallDict(dict)) { 7781 return(NULL); 7782 } 7783 7784 if (index >= (int64_t)lenSmallArray(self)) { 7785 return(NULL); 7786 } 7787 if (index < -(int64_t)lenSmallArray(self)) { 7788 return(NULL); 7789 } 7790 if (index < 0) { 7791 index = (int64_t)lenSmallArray(self) + index; 7792 } 7793 7794 if (!dict->d) { 7795 isError(dict->d, allocSDict()) return(NULL); 7796 } 7797 7798 sArraySetTiny(self->a, (uint32_t)index, (smallt *)dict->d); 7799 return(self); 7800 } 7801 7802 7803 internal smallArrayt* setAtArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array) { 7804 7805 if (!array) { 7806 return(NULL); 7807 } 7808 7809 if (checkObjectTypes && array && !isOSmallArray(array)) { 7810 return(NULL); 7811 } 7812 7813 if (index >= (int64_t)lenSmallArray(self)) { 7814 return(NULL); 7815 } 7816 if (index < -(int64_t)lenSmallArray(self)) { 7817 return(NULL); 7818 } 7819 if (index < 0) { 7820 index = (int64_t)lenSmallArray(self) + index; 7821 } 7822 7823 if (!array->a) { 7824 // allocate empty array 7825 isError(array->a, allocSArray()) return(NULL); 7826 } 7827 7828 sArraySetTiny(self->a, (uint32_t)index, (smallt *)array->a); 7829 return(self); 7830 } 7831 7832 internal smallArrayt* setAtArraycSmallArray(smallArrayt *self, int64_t index, char **array) { 7833 7834 if (!array) { 7835 return(NULL); 7836 } 7837 7838 if (index >= (int64_t)lenSmallArray(self)) { 7839 return(NULL); 7840 } 7841 if (index < -(int64_t)lenSmallArray(self)) { 7842 return(NULL); 7843 } 7844 if (index < 0) { 7845 index = (int64_t)lenSmallArray(self) + index; 7846 } 7847 7848 sArrayt *a = allocSArray(); 7849 if (!a) { 7850 return(NULL); 7851 } 7852 7853 forEachCharP(array, e) { 7854 sStringt *s = allocSStringTiny(*e); 7855 if (!s) { 7856 if (a) { 7857 sArrayFreeTiny(a); 7858 } 7859 return(NULL); 7860 } 7861 sArrayPushTiny(&a, (smallt *) s); 7862 } 7863 7864 sArraySetTiny(self->a, (uint32_t)index, (smallt *)a); 7865 return(self); 7866 } 7867 7868 internal smallArrayt* setAtCArraycSmallArray(smallArrayt *self, int64_t index, const char **array) { 7869 7870 if (!array) { 7871 return(NULL); 7872 } 7873 7874 if (index >= (int64_t)lenSmallArray(self)) { 7875 return(NULL); 7876 } 7877 if (index < -(int64_t)lenSmallArray(self)) { 7878 return(NULL); 7879 } 7880 if (index < 0) { 7881 index = (int64_t)lenSmallArray(self) + index; 7882 } 7883 7884 sArrayt *a = allocSArray(); 7885 if (!a) { 7886 return(NULL); 7887 } 7888 7889 forEachCCharP(array, e) { 7890 sStringt *s = allocSStringTiny(*e); 7891 if (!s) { 7892 if (a) { 7893 sArrayFreeTiny(a); 7894 } 7895 return(NULL); 7896 } 7897 sArrayPushTiny(&a, (smallt *) s); 7898 } 7899 7900 sArraySetTiny(self->a, (uint32_t)index, (smallt *)a); 7901 return(self); 7902 } 7903 7904 internal smallArrayt* setAtSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *value) { 7905 7906 if (!value) { 7907 return(NULL); 7908 } 7909 7910 if (checkObjectTypes && value && !isOSmallBool(value)) { 7911 return(NULL); 7912 } 7913 7914 if (index >= (int64_t)lenSmallArray(self)) { 7915 return(NULL); 7916 } 7917 if (index < -(int64_t)lenSmallArray(self)) { 7918 return(NULL); 7919 } 7920 if (index < 0) { 7921 index = (int64_t)lenSmallArray(self) + index; 7922 } 7923 7924 if (!value->value) { 7925 isError(value->value, allocSBool(false)) return(NULL); 7926 } 7927 sArraySetTiny(self->a, (uint32_t)index, (smallt *) value->value); 7928 return(self); 7929 } 7930 7931 internal smallArrayt* setAtSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *value) { 7932 7933 if (!value) { 7934 return(NULL); 7935 } 7936 7937 if (checkObjectTypes && value && !isOSmallBytes(value)) { 7938 return(NULL); 7939 } 7940 7941 if (index >= (int64_t)lenSmallArray(self)) { 7942 return(NULL); 7943 } 7944 if (index < -(int64_t)lenSmallArray(self)) { 7945 return(NULL); 7946 } 7947 if (index < 0) { 7948 index = (int64_t)lenSmallArray(self) + index; 7949 } 7950 7951 if (!value->B) { 7952 isError(value->B, allocSBytes()) return(NULL); 7953 } 7954 sArraySetTiny(self->a, (uint32_t)index, (smallt*) value->B); 7955 return(self); 7956 } 7957 7958 internal smallArrayt* setAtSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *value) { 7959 7960 if (!value) { 7961 return(NULL); 7962 } 7963 7964 if (checkObjectTypes && value && !isOSmallDouble(value)) { 7965 return(NULL); 7966 } 7967 7968 if (index >= (int64_t)lenSmallArray(self)) { 7969 return(NULL); 7970 } 7971 if (index < -(int64_t)lenSmallArray(self)) { 7972 return(NULL); 7973 } 7974 if (index < 0) { 7975 index = (int64_t)lenSmallArray(self) + index; 7976 } 7977 7978 if (!value->value) { 7979 isError(value->value, allocSDouble(0)) return(NULL); 7980 } 7981 sArraySetTiny(self->a, (uint32_t)index, (smallt*) value->value); 7982 return(self); 7983 } 7984 7985 internal smallArrayt* setAtSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *value) { 7986 7987 if (!value) { 7988 return(NULL); 7989 } 7990 7991 if (checkObjectTypes && value && !isOSmallInt(value)) { 7992 return(NULL); 7993 } 7994 7995 if (index >= (int64_t)lenSmallArray(self)) { 7996 return(NULL); 7997 } 7998 if (index < -(int64_t)lenSmallArray(self)) { 7999 return(NULL); 8000 } 8001 if (index < 0) { 8002 index = (int64_t)lenSmallArray(self) + index; 8003 } 8004 8005 if (!value->value) { 8006 isError(value->value, allocSInt(0)) return(NULL); 8007 } 8008 sArraySetTiny(self->a, (uint32_t)index, (smallt*) value->value); 8009 return(self); 8010 } 8011 8012 internal smallArrayt* setAtSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *value) { 8013 8014 if (!value) { 8015 return(NULL); 8016 } 8017 8018 if (checkObjectTypes && value && !isOSmallJson(value)) { 8019 return(NULL); 8020 } 8021 8022 if (index >= (int64_t)lenSmallArray(self)) { 8023 return(NULL); 8024 } 8025 if (index < -(int64_t)lenSmallArray(self)) { 8026 return(NULL); 8027 } 8028 if (index < 0) { 8029 index = (int64_t)lenSmallArray(self) + index; 8030 } 8031 8032 smallt *o = getsoO(value); 8033 if (!o) { 8034 // smallJson is empty, create an empty dict 8035 isError(o, (smallt*) allocSDict()) return(NULL); 8036 setsoO(value, o); 8037 } 8038 8039 sArraySetTiny(self->a, (uint32_t)index, o); 8040 return(self); 8041 } 8042 8043 internal smallArrayt* setAtSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string) { 8044 8045 if (!string) { 8046 return(NULL); 8047 } 8048 8049 if (checkObjectTypes && string && !isOSmallString(string)) { 8050 return(NULL); 8051 } 8052 8053 if (index >= (int64_t)lenSmallArray(self)) { 8054 return(NULL); 8055 } 8056 if (index < -(int64_t)lenSmallArray(self)) { 8057 return(NULL); 8058 } 8059 if (index < 0) { 8060 index = (int64_t)lenSmallArray(self) + index; 8061 } 8062 8063 if (!string->data) { 8064 isError(string->data, allocSStringTiny("")) return(NULL); 8065 } 8066 sArraySetTiny(self->a, (uint32_t)index, (smallt *)string->data); 8067 return(self); 8068 } 8069 8070 internal smallArrayt* setAtSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *container) { 8071 8072 if (!container) { 8073 return(NULL); 8074 } 8075 8076 if (checkObjectTypes && container && !isOSmallContainer(container)) { 8077 return(NULL); 8078 } 8079 8080 if (index >= (int64_t)lenSmallArray(self)) { 8081 return(NULL); 8082 } 8083 if (index < -(int64_t)lenSmallArray(self)) { 8084 return(NULL); 8085 } 8086 if (index < 0) { 8087 index = (int64_t)lenSmallArray(self) + index; 8088 } 8089 8090 if (!container->data) { 8091 isError(container->data, allocSContainer(NULL)) return(NULL); 8092 } 8093 sArraySetTiny(self->a, (uint32_t)index, (smallt *) container->data); 8094 return(self); 8095 } 8096 8097 internal smallArrayt* setAtNFreeSmallArray(smallArrayt *self, int64_t index, baset *value) { 8098 8099 if (!value) { 8100 return(NULL); 8101 } 8102 8103 if (index >= (int64_t)lenSmallArray(self)) { 8104 return(NULL); 8105 } 8106 if (index < -(int64_t)lenSmallArray(self)) { 8107 return(NULL); 8108 } 8109 if (index < 0) { 8110 index = (int64_t)lenSmallArray(self) + index; 8111 } 8112 8113 smallt *o = toSmallt(value); 8114 if (!o) { 8115 return(NULL); 8116 } 8117 sArraySetTiny(self->a, (uint32_t)index, o); 8118 8119 if (!(o->type == CONTAINER && (((sContainert*)o)->dataType == SH_DT_BASET))) { 8120 finishO(value); 8121 } 8122 return(self); 8123 } 8124 8125 internal smallArrayt* setAtNFreeUndefinedSmallArray(smallArrayt *self, int64_t index, undefinedt *u) { 8126 8127 smallArrayt *r = setAtUndefinedSmallArray(self, index); 8128 if (r) { 8129 terminateO(u); 8130 } 8131 return(r); 8132 } 8133 8134 internal smallArrayt* setAtNFreeSSmallArray(smallArrayt *self, int64_t index, char *string) { 8135 8136 smallArrayt *r = setAtSSmallArray(self, index, string); 8137 if (r) { 8138 free(string); 8139 } 8140 return(r); 8141 } 8142 8143 internal smallArrayt* setAtNFreeDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict) { 8144 8145 smallArrayt *r = setAtDictSmallArray(self, index, dict); 8146 if (r) { 8147 finishO(dict); 8148 } 8149 return(r); 8150 } 8151 8152 internal smallArrayt* setAtNFreeArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array) { 8153 8154 smallArrayt *r = setAtArraySmallArray(self, index, array); 8155 if (r) { 8156 finishO(array); 8157 } 8158 return(r); 8159 } 8160 8161 internal smallArrayt* setAtNFreeArraycSmallArray(smallArrayt *self, int64_t index, char **array) { 8162 8163 smallArrayt *r = setAtArraycSmallArray(self, index, array); 8164 if (r) { 8165 listFreeS(array); 8166 } 8167 return(r); 8168 } 8169 8170 internal smallArrayt* setAtNFreeSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *value) { 8171 8172 smallArrayt *r = setAtSmallBoolSmallArray(self, index, value); 8173 if (r) { 8174 finishO(value); 8175 } 8176 return(r); 8177 } 8178 8179 internal smallArrayt* setAtNFreeSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *value) { 8180 8181 smallArrayt *r = setAtSmallBytesSmallArray(self, index, value); 8182 if (r) { 8183 finishO(value); 8184 } 8185 return(r); 8186 } 8187 8188 internal smallArrayt* setAtNFreeSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *value) { 8189 8190 smallArrayt *r = setAtSmallDoubleSmallArray(self, index, value); 8191 if (r) { 8192 finishO(value); 8193 } 8194 return(r); 8195 } 8196 8197 internal smallArrayt* setAtNFreeSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *value) { 8198 8199 smallArrayt *r = setAtSmallIntSmallArray(self, index, value); 8200 if (r) { 8201 finishO(value); 8202 } 8203 return(r); 8204 } 8205 8206 internal smallArrayt* setAtNFreeSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *value) { 8207 8208 smallArrayt *r = setAtSmallJsonSmallArray(self, index, value); 8209 if (r) { 8210 finishO(value); 8211 } 8212 return(r); 8213 } 8214 8215 internal smallArrayt* setAtNFreeSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string) { 8216 8217 smallArrayt *r = setAtSmallStringSmallArray(self, index, string); 8218 if (r) { 8219 finishO(string); 8220 } 8221 return(r); 8222 } 8223 8224 internal smallArrayt* setAtNFreeSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *container) { 8225 8226 smallArrayt *r = setAtSmallContainerSmallArray(self, index, container); 8227 if (r) { 8228 finishO(container); 8229 } 8230 return(r); 8231 } 8232 8233 8234 internal smallArrayt* setPAtDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict) { 8235 8236 if (!dict) { 8237 return(NULL); 8238 } 8239 8240 if (checkObjectTypes && dict && !isOSmallDict(dict)) { 8241 return(NULL); 8242 } 8243 8244 if (index >= (int64_t)lenSmallArray(self)) { 8245 return(NULL); 8246 } 8247 if (index < -(int64_t)lenSmallArray(self)) { 8248 return(NULL); 8249 } 8250 if (index < 0) { 8251 index = (int64_t)lenSmallArray(self) + index; 8252 } 8253 8254 if (!dict->d) { 8255 // realloc error 8256 return(NULL); 8257 } 8258 8259 sArraySetP(self->a, (uint32_t)index, (smallt *)dict->d); 8260 return(self); 8261 } 8262 8263 internal smallArrayt* setPAtArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array) { 8264 8265 if (!array) { 8266 return(NULL); 8267 } 8268 8269 if (checkObjectTypes && array && !isOSmallArray(array)) { 8270 return(NULL); 8271 } 8272 8273 if (index >= (int64_t)lenSmallArray(self)) { 8274 return(NULL); 8275 } 8276 if (index < -(int64_t)lenSmallArray(self)) { 8277 return(NULL); 8278 } 8279 if (index < 0) { 8280 index = (int64_t)lenSmallArray(self) + index; 8281 } 8282 8283 if (!array->a) { 8284 // realloc error 8285 return(NULL); 8286 } 8287 8288 sArraySetP(self->a, (uint32_t)index, (smallt *)array->a); 8289 return(self); 8290 } 8291 8292 internal smallArrayt* setPAtSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *json) { 8293 8294 if (!json) { 8295 return(NULL); 8296 } 8297 8298 if (checkObjectTypes && json && !isOSmallJson(json)) { 8299 return(NULL); 8300 } 8301 8302 if (index >= (int64_t)lenSmallArray(self)) { 8303 return(NULL); 8304 } 8305 if (index < -(int64_t)lenSmallArray(self)) { 8306 return(NULL); 8307 } 8308 if (index < 0) { 8309 index = (int64_t)lenSmallArray(self) + index; 8310 } 8311 8312 smallt *o; 8313 o = getsoO(json); 8314 if (!o) { 8315 // realloc error 8316 return(NULL); 8317 } 8318 sArraySetP(self->a, (uint32_t)index, o); 8319 return(self); 8320 } 8321 8322 internal smallArrayt* setPAtSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string) { 8323 8324 if (!string) { 8325 return(NULL); 8326 } 8327 8328 if (checkObjectTypes && string && !isOSmallString(string)) { 8329 return(NULL); 8330 } 8331 8332 if (index >= (int64_t)lenSmallArray(self)) { 8333 return(NULL); 8334 } 8335 if (index < -(int64_t)lenSmallArray(self)) { 8336 return(NULL); 8337 } 8338 if (index < 0) { 8339 index = (int64_t)lenSmallArray(self) + index; 8340 } 8341 8342 if (!string->data) { 8343 // realloc error 8344 return(NULL); 8345 } 8346 8347 smallt *o = (smallt *) string->data; 8348 sArraySetP(self->a, (uint32_t)index, o); 8349 return(self); 8350 } 8351 8352 internal smallArrayt* setPAtNFreeDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict) { 8353 8354 if (!dict) { 8355 return(NULL); 8356 } 8357 8358 if (checkObjectTypes && dict && !isOSmallDict(dict)) { 8359 return(NULL); 8360 } 8361 8362 if (index >= (int64_t)lenSmallArray(self)) { 8363 return(NULL); 8364 } 8365 if (index < -(int64_t)lenSmallArray(self)) { 8366 return(NULL); 8367 } 8368 if (index < 0) { 8369 index = (int64_t)lenSmallArray(self) + index; 8370 } 8371 8372 if (!dict->d) { 8373 // realloc error 8374 return(NULL); 8375 } 8376 8377 sArraySetP(self->a, (uint32_t)index, (smallt *)dict->d); 8378 finishO(dict); 8379 return(self); 8380 } 8381 8382 8383 internal smallArrayt* setPAtNFreeArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array) { 8384 8385 if (!array) { 8386 return(NULL); 8387 } 8388 8389 if (checkObjectTypes && array && !isOSmallArray(array)) { 8390 return(NULL); 8391 } 8392 8393 if (index >= (int64_t)lenSmallArray(self)) { 8394 return(NULL); 8395 } 8396 if (index < -(int64_t)lenSmallArray(self)) { 8397 return(NULL); 8398 } 8399 if (index < 0) { 8400 index = (int64_t)lenSmallArray(self) + index; 8401 } 8402 8403 if (!array->a) { 8404 // realloc error 8405 return(NULL); 8406 } 8407 8408 sArraySetP(self->a, (uint32_t)index, (smallt *)array->a); 8409 finishO(array); 8410 return(self); 8411 } 8412 8413 internal smallArrayt* setPAtNFreeSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *json) { 8414 8415 if (!json) { 8416 return(NULL); 8417 } 8418 8419 if (checkObjectTypes && json && !isOSmallJson(json)) { 8420 return(NULL); 8421 } 8422 8423 if (index >= (int64_t)lenSmallArray(self)) { 8424 return(NULL); 8425 } 8426 if (index < -(int64_t)lenSmallArray(self)) { 8427 return(NULL); 8428 } 8429 if (index < 0) { 8430 index = (int64_t)lenSmallArray(self) + index; 8431 } 8432 8433 smallt *o; 8434 o = getsoO(json);; 8435 if (!o) { 8436 // realloc error 8437 return(NULL); 8438 } 8439 finishO(json); 8440 sArraySetP(self->a, (uint32_t)index, o); 8441 return(self); 8442 } 8443 8444 internal smallArrayt* setPAtNFreeSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string) { 8445 8446 if (!string) { 8447 return(NULL); 8448 } 8449 8450 if (checkObjectTypes && string && !isOSmallString(string)) { 8451 return(NULL); 8452 } 8453 8454 if (index >= (int64_t)lenSmallArray(self)) { 8455 return(NULL); 8456 } 8457 if (index < -(int64_t)lenSmallArray(self)) { 8458 return(NULL); 8459 } 8460 if (index < 0) { 8461 index = (int64_t)lenSmallArray(self) + index; 8462 } 8463 8464 if (!string->data) { 8465 // realloc error 8466 return(NULL); 8467 } 8468 8469 smallt *o = (smallt *) string->data; 8470 finishO(string); 8471 sArraySetP(self->a, (uint32_t)index, o); 8472 return(self); 8473 } 8474 8475 internal double getNumSmallArray(smallArrayt *self, int64_t index) { 8476 8477 if (index >= (int64_t)lenSmallArray(self)) { 8478 return(0); 8479 } 8480 if (index < -(int64_t)lenSmallArray(self)) { 8481 return(0); 8482 } 8483 if (index < 0) { 8484 index = (int64_t)lenSmallArray(self) + index; 8485 } 8486 8487 smallt *e = sArrayGetTiny(self->a, (uint32_t)index); 8488 if (!e) { 8489 return(0); 8490 } 8491 if (e->type != INT && e->type != DOUBLE) { 8492 return(0); 8493 } 8494 8495 baset *o = toBaset(e); 8496 8497 double r = 0; 8498 if (isOSmallDouble(o)) { 8499 r = getValO((smallDoublet*)o); 8500 } 8501 elif (isOSmallInt(o)) { 8502 r = (double)getValO((smallIntt*)o); 8503 } 8504 finishO(o); 8505 return(r); 8506 } 8507 8508 internal bool hasSmallArray(smallArrayt *self, baset *value) { 8509 8510 if (!value) { 8511 return(false); 8512 } 8513 8514 if (indexOfSmallArray(self, value) == -1) { 8515 return(false); 8516 } 8517 8518 return(true); 8519 } 8520 8521 internal bool hasUndefinedSmallArray(smallArrayt *self, undefinedt *u) { 8522 8523 if (!u) { 8524 return(false); 8525 } 8526 8527 if (checkObjectTypes && !isOUndefined(u)) { 8528 return(false); 8529 } 8530 8531 if (indexOfUndefinedSmallArray(self, u) == -1) { 8532 return(false); 8533 } 8534 8535 return(true); 8536 } 8537 8538 internal bool hasBoolSmallArray(smallArrayt *self, bool value) { 8539 8540 if (indexOfBoolSmallArray(self, value) == -1) { 8541 return(false); 8542 } 8543 8544 return(true); 8545 } 8546 8547 internal bool hasDoubleSmallArray(smallArrayt *self, double value) { 8548 8549 if (indexOfDoubleSmallArray(self, value) == -1) { 8550 return(false); 8551 } 8552 8553 return(true); 8554 } 8555 8556 internal bool hasIntSmallArray(smallArrayt *self, int64_t value) { 8557 8558 if (indexOfIntSmallArray(self, value) == -1) { 8559 return(false); 8560 } 8561 8562 return(true); 8563 } 8564 8565 internal bool hasSSmallArray(smallArrayt *self, const char *string) { 8566 8567 if (!string) { 8568 return(false); 8569 } 8570 8571 if (indexOfSSmallArray(self, string) == -1) { 8572 return(false); 8573 } 8574 8575 return(true); 8576 } 8577 8578 internal bool hasCharSmallArray(smallArrayt *self, char c) { 8579 8580 charToS(s, c); 8581 return(hasSSmallArray(self, s)); 8582 } 8583 8584 internal bool hasDictSmallArray(smallArrayt *self, smallDictt *dict) { 8585 8586 if (!dict) { 8587 return(false); 8588 } 8589 8590 if (checkObjectTypes && !isOSmallDict(dict)) { 8591 return(false); 8592 } 8593 8594 if (indexOfDictSmallArray(self, dict) == -1) { 8595 return(false); 8596 } 8597 8598 return(true); 8599 } 8600 8601 internal bool hasArraySmallArray(smallArrayt *self, smallArrayt *array) { 8602 8603 if (!array) { 8604 return(false); 8605 } 8606 8607 if (checkObjectTypes && !isOSmallArray(array)) { 8608 return(false); 8609 } 8610 8611 if (indexOfArraySmallArray(self, array) == -1) { 8612 return(false); 8613 } 8614 8615 return(true); 8616 } 8617 8618 internal bool hasArraycSmallArray(smallArrayt *self, char **array) { 8619 8620 if (!array) { 8621 return(false); 8622 } 8623 8624 if (indexOfArraycSmallArray(self, array) == -1) { 8625 return(false); 8626 } 8627 8628 return(true); 8629 } 8630 8631 internal bool hasCArraycSmallArray(smallArrayt *self, const char **array) { 8632 8633 if (!array) { 8634 return(false); 8635 } 8636 8637 if (indexOfCArraycSmallArray(self, array) == -1) { 8638 return(false); 8639 } 8640 8641 return(true); 8642 } 8643 8644 internal bool hasSmallBoolSmallArray(smallArrayt *self, smallBoolt *value) { 8645 8646 if (!value) { 8647 return(false); 8648 } 8649 8650 if (checkObjectTypes && !isOSmallBool(value)) { 8651 return(false); 8652 } 8653 8654 if (indexOfSmallBoolSmallArray(self, value) == -1) { 8655 return(false); 8656 } 8657 8658 return(true); 8659 } 8660 8661 internal bool hasSmallBytesSmallArray(smallArrayt *self, smallBytest *value) { 8662 8663 if (!value) { 8664 return(false); 8665 } 8666 8667 if (checkObjectTypes && !isOSmallBytes(value)) { 8668 return(false); 8669 } 8670 8671 if (indexOfSmallBytesSmallArray(self, value) == -1) { 8672 return(false); 8673 } 8674 8675 return(true); 8676 } 8677 8678 internal bool hasSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value) { 8679 8680 if (!value) { 8681 return(false); 8682 } 8683 8684 if (checkObjectTypes && !isOSmallDouble(value)) { 8685 return(false); 8686 } 8687 8688 if (indexOfSmallDoubleSmallArray(self, value) == -1) { 8689 return(false); 8690 } 8691 8692 return(true); 8693 } 8694 8695 internal bool hasSmallIntSmallArray(smallArrayt *self, smallIntt *value) { 8696 8697 if (!value) { 8698 return(false); 8699 } 8700 8701 if (checkObjectTypes && !isOSmallInt(value)) { 8702 return(false); 8703 } 8704 8705 if (indexOfSmallIntSmallArray(self, value) == -1) { 8706 return(false); 8707 } 8708 8709 return(true); 8710 } 8711 8712 internal bool hasSmallJsonSmallArray(smallArrayt *self, smallJsont *string) { 8713 8714 if (!string) { 8715 return(false); 8716 } 8717 8718 if (checkObjectTypes && !isOSmallJson(string)) { 8719 return(false); 8720 } 8721 8722 if (indexOfSmallJsonSmallArray(self, string) == -1) { 8723 return(false); 8724 } 8725 8726 return(true); 8727 } 8728 8729 internal bool hasSmallStringSmallArray(smallArrayt *self, smallStringt *string) { 8730 8731 if (!string) { 8732 return(false); 8733 } 8734 8735 if (checkObjectTypes && !isOSmallString(string)) { 8736 return(false); 8737 } 8738 8739 if (indexOfSmallStringSmallArray(self, string) == -1) { 8740 return(false); 8741 } 8742 8743 return(true); 8744 } 8745 8746 internal bool hasSmallContainerSmallArray(smallArrayt *self, smallContainert *container) { 8747 8748 if (!container) { 8749 return(false); 8750 } 8751 8752 if (checkObjectTypes && !isOSmallContainer(container)) { 8753 return(NULL); 8754 } 8755 8756 if (indexOfSmallContainerSmallArray(self, container) == -1) { 8757 return(false); 8758 } 8759 8760 return(true); 8761 } 8762 8763 internal ssize_t indexOfSmallArray(smallArrayt *self, baset *value) { 8764 8765 // sanity checks 8766 if (!lenSmallArray(self) || !value) { 8767 return(-1); 8768 } 8769 8770 // search string in elements 8771 char *s = toStringO(value); 8772 char *es = NULL; 8773 8774 enumerateSArray(self->a, e, i) { 8775 if (not e) { 8776 continue; 8777 } 8778 es = sToString(e); 8779 if (strEq(es, s)) { 8780 free(es); 8781 free(s); 8782 return((ssize_t)i); 8783 } 8784 free(es); 8785 } 8786 free(s); 8787 return(-1); 8788 } 8789 8790 internal ssize_t indexOfUndefinedSmallArray(smallArrayt *self, undefinedt *u) { 8791 8792 // sanity checks 8793 if (!lenSmallArray(self) || !u) { 8794 return(-1); 8795 } 8796 8797 if (checkObjectTypes && !isOUndefined(u)) { 8798 return(-1); 8799 } 8800 8801 // search string in elements 8802 enumerateSArray(self->a, e, i) { 8803 if (not e) { 8804 continue; 8805 } 8806 if (e->type == UNDEFINED) { 8807 return((ssize_t)i); 8808 } 8809 } 8810 return(-1); 8811 } 8812 8813 internal ssize_t indexOfBoolSmallArray(smallArrayt *self, bool value) { 8814 8815 // sanity checks 8816 if (!lenSmallArray(self)) { 8817 return(-1); 8818 } 8819 8820 // search value in elements 8821 enumerateSArray(self->a, e, i) { 8822 if (not e) { 8823 continue; 8824 } 8825 if (e->type == BOOL && ((sBoolt*)e)->value == value) { 8826 return((ssize_t)i); 8827 } 8828 } 8829 return(-1); 8830 } 8831 8832 internal ssize_t indexOfDoubleSmallArray(smallArrayt *self, double value) { 8833 8834 // sanity checks 8835 if (!lenSmallArray(self)) { 8836 return(-1); 8837 } 8838 8839 // search value in elements 8840 enumerateSArray(self->a, e, i) { 8841 if (not e) { 8842 continue; 8843 } 8844 if (e->type == DOUBLE && ((sDoublet*)e)->value == value) { 8845 return((ssize_t)i); 8846 } 8847 } 8848 return(-1); 8849 } 8850 8851 internal ssize_t indexOfIntSmallArray(smallArrayt *self, int64_t value) { 8852 8853 // sanity checks 8854 if (!lenSmallArray(self)) { 8855 return(-1); 8856 } 8857 8858 // search value in elements 8859 enumerateSArray(self->a, e, i) { 8860 if (not e) { 8861 continue; 8862 } 8863 if (e->type == INT && ((sIntt*)e)->value == value) { 8864 return((ssize_t)i); 8865 } 8866 } 8867 return(-1); 8868 } 8869 8870 internal ssize_t indexOfSSmallArray(smallArrayt *self, const char *string) { 8871 8872 // sanity checks 8873 if (!lenSmallArray(self)) { 8874 return(-1); 8875 } 8876 if (!string) { 8877 return(-1); 8878 } 8879 // search string in elements 8880 enumerateSArray(self->a, e, i) { 8881 if (not e) { 8882 continue; 8883 } 8884 if (e->type == STRING && strEq(sStringGetTiny((sStringt*)e), string)) { 8885 return((ssize_t)i); 8886 } 8887 } 8888 return(-1); 8889 } 8890 8891 internal ssize_t indexOfCharSmallArray(smallArrayt *self, char c) { 8892 8893 charToS(s, c); 8894 return(indexOfSSmallArray(self, s)); 8895 } 8896 8897 internal ssize_t indexOfDictSmallArray(smallArrayt *self, smallDictt *dict) { 8898 8899 // sanity checks 8900 if (!lenSmallArray(self) || !dict) { 8901 return(-1); 8902 } 8903 8904 if (checkObjectTypes && !isOSmallDict(dict)) { 8905 return(-1); 8906 } 8907 8908 // search object in elements 8909 char *s = toStringO(dict); 8910 char *es = NULL;; 8911 8912 enumerateSArray(self->a, e, i) { 8913 if (not e) { 8914 continue; 8915 } 8916 if (e->type == DICT) { 8917 es = sToString(e); 8918 if (strEq(es, s)) { 8919 free(es); 8920 free(s); 8921 return((ssize_t)i); 8922 } 8923 free(es); 8924 } 8925 } 8926 free(s); 8927 return(-1); 8928 } 8929 8930 internal ssize_t indexOfArraySmallArray(smallArrayt *self, smallArrayt *array) { 8931 8932 // sanity checks 8933 if (!lenSmallArray(self) || !array) { 8934 return(-1); 8935 } 8936 8937 if (checkObjectTypes && !isOSmallArray(array)) { 8938 return(-1); 8939 } 8940 8941 // search object in elements 8942 char *s = toStringO(array); 8943 char *es = NULL;; 8944 8945 enumerateSArray(self->a, e, i) { 8946 if (not e) { 8947 continue; 8948 } 8949 if (e->type == ARRAY) { 8950 es = sToString(e); 8951 if (strEq(es, s)) { 8952 free(es); 8953 free(s); 8954 return((ssize_t)i); 8955 } 8956 free(es); 8957 } 8958 } 8959 free(s); 8960 return(-1); 8961 } 8962 8963 internal ssize_t indexOfArraycSmallArray(smallArrayt *self, char **array) { 8964 8965 // sanity checks 8966 if (!lenSmallArray(self) || !array) { 8967 return(-1); 8968 } 8969 8970 // search object in elements 8971 char *s = toStringListSGF(array); 8972 char *es = NULL;; 8973 8974 enumerateSArray(self->a, e, i) { 8975 if (not e) { 8976 continue; 8977 } 8978 if (e->type == ARRAY) { 8979 es = sToString(e); 8980 if (strEq(es, s)) { 8981 free(es); 8982 free(s); 8983 return((ssize_t)i); 8984 } 8985 free(es); 8986 } 8987 } 8988 free(s); 8989 return(-1); 8990 } 8991 8992 internal ssize_t indexOfCArraycSmallArray(smallArrayt *self, const char **array) { 8993 8994 // sanity checks 8995 if (!lenSmallArray(self) || !array) { 8996 return(-1); 8997 } 8998 8999 // search object in elements 9000 char *s = toStringListCSGF(array); 9001 char *es = NULL;; 9002 9003 enumerateSArray(self->a, e, i) { 9004 if (not e) { 9005 continue; 9006 } 9007 if (e->type == ARRAY) { 9008 es = sToString(e); 9009 if (strEq(es, s)) { 9010 free(es); 9011 free(s); 9012 return((ssize_t)i); 9013 } 9014 free(es); 9015 } 9016 } 9017 free(s); 9018 return(-1); 9019 } 9020 9021 internal ssize_t indexOfSmallBoolSmallArray(smallArrayt *self, smallBoolt *value) { 9022 9023 // sanity checks 9024 if (!lenSmallArray(self) || !value) { 9025 return(-1); 9026 } 9027 9028 if (checkObjectTypes && !isOSmallBool(value)) { 9029 return(-1); 9030 } 9031 9032 // search object in elements 9033 bool b = value->f->get(value); 9034 9035 enumerateSArray(self->a, e, i) { 9036 if (not e) { 9037 continue; 9038 } 9039 if (e->type == BOOL && ((sBoolt*)e)->value == b) { 9040 return((ssize_t)i); 9041 } 9042 } 9043 return(-1); 9044 } 9045 9046 internal ssize_t indexOfSmallBytesSmallArray(smallArrayt *self, smallBytest *value) { 9047 9048 // sanity checks 9049 if (!lenSmallArray(self) || !value || !value->B) { 9050 return(-1); 9051 } 9052 9053 if (checkObjectTypes && !isOSmallBytes(value)) { 9054 return(-1); 9055 } 9056 9057 // search object in elements 9058 void *b = sBytesGet(value->B); 9059 uint32_t count = value->B->count; 9060 9061 enumerateSArray(self->a, e, i) { 9062 if (not e) { 9063 continue; 9064 } 9065 if (e->type == BYTES && ((sBytest*)e)->count == count && !memcmp(&(((sBytest*)e)->data), b, count)) { 9066 return((ssize_t)i); 9067 } 9068 } 9069 return(-1); 9070 } 9071 9072 internal ssize_t indexOfSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value) { 9073 9074 // sanity checks 9075 if (!lenSmallArray(self) || !value) { 9076 return(-1); 9077 } 9078 9079 if (checkObjectTypes && !isOSmallDouble(value)) { 9080 return(-1); 9081 } 9082 9083 // search object in elements 9084 double v = value->f->get(value); 9085 9086 enumerateSArray(self->a, e, i) { 9087 if (not e) { 9088 continue; 9089 } 9090 if (e->type == DOUBLE && ((sDoublet*)e)->value == v) { 9091 return((ssize_t)i); 9092 } 9093 } 9094 return(-1); 9095 } 9096 9097 internal ssize_t indexOfSmallIntSmallArray(smallArrayt *self, smallIntt *value) { 9098 9099 // sanity checks 9100 if (!lenSmallArray(self) || !value) { 9101 return(-1); 9102 } 9103 9104 if (checkObjectTypes && !isOSmallInt(value)) { 9105 return(-1); 9106 } 9107 9108 // search object in elements 9109 int64_t v = value->f->get(value); 9110 9111 enumerateSArray(self->a, e, i) { 9112 if (not e) { 9113 continue; 9114 } 9115 if (e->type == INT && ((sIntt*)e)->value == v) { 9116 return((ssize_t)i); 9117 } 9118 } 9119 return(-1); 9120 } 9121 9122 internal ssize_t indexOfSmallJsonSmallArray(smallArrayt *self, smallJsont *string) { 9123 9124 if (!lenSmallArray(self) || !string) { 9125 return(-1); 9126 } 9127 9128 if (checkObjectTypes && !isOSmallJson(string)) { 9129 return(-1); 9130 } 9131 9132 const char *type = getTopTypeO(string); 9133 9134 if (!type) { 9135 // smallJson is empty 9136 return(-1); 9137 } 9138 9139 baset *O = NULL; 9140 ssize_t r = -1; 9141 if (eqS(type, "undefined")) { 9142 O = getTopO(string); 9143 r = indexOfSmallArray(self, O); 9144 finishO(O); 9145 } 9146 else if (eqS(type, "bool")) { 9147 O = getTopO(string); 9148 r = indexOfSmallBoolSmallArray(self, (smallBoolt*)O); 9149 finishO(O); 9150 } 9151 else if (eqS(type, "double")) { 9152 O = getTopO(string); 9153 r = indexOfSmallDoubleSmallArray(self, (smallDoublet*)O); 9154 finishO(O); 9155 } 9156 else if (eqS(type, "int")) { 9157 O = getTopO(string); 9158 r = indexOfSmallIntSmallArray(self, (smallIntt*)O); 9159 finishO(O); 9160 } 9161 else if (eqS(type, "string")) { 9162 O = getTopO(string); 9163 r = indexOfSmallStringSmallArray(self, (smallStringt*)O); 9164 finishO(O); 9165 } 9166 else if (eqS(type, "dict")) { 9167 O = getTopO(string); 9168 r = indexOfDictSmallArray(self, (smallDictt*)O); 9169 finishO(O); 9170 } 9171 else if (eqS(type, "array")) { 9172 O = getTopO(string); 9173 r = indexOfArraySmallArray(self, (smallArrayt*)O); 9174 finishO(O); 9175 } 9176 return(r); 9177 } 9178 9179 9180 internal ssize_t indexOfSmallStringSmallArray(smallArrayt *self, smallStringt *string) { 9181 9182 // sanity checks 9183 if (!lenSmallArray(self)) { 9184 return(-1); 9185 } 9186 9187 if (!string || !string->data) { 9188 return(-1); 9189 } 9190 9191 if (checkObjectTypes && !isOSmallString(string)) { 9192 return(-1); 9193 } 9194 9195 // search string in elements 9196 char *s = sStringGetTiny(string->data); 9197 9198 enumerateSArray(self->a, e, i) { 9199 if (not e) { 9200 continue; 9201 } 9202 if (e->type == STRING && strEq(sStringGetTiny((sStringt*)e), s)) { 9203 return((ssize_t)i); 9204 } 9205 } 9206 return(-1); 9207 } 9208 9209 internal ssize_t indexOfSmallContainerSmallArray(smallArrayt *self UNUSED, smallContainert *container UNUSED) { 9210 9211 // TODO 9212 return(-1); 9213 } 9214 9215 internal ssize_t binarySearchSmallArray(smallArrayt *self, baset *value) { 9216 ssize_t first = 0, middle, last;; 9217 9218 if (!lenSmallArray(self) || !value) { 9219 return(-1); 9220 } 9221 9222 char *s = toStringO(value); 9223 char *m = NULL; 9224 9225 ssize_t r = -1; 9226 last = (ssize_t)lenSmallArray(self) - 1; 9227 while (first <= last) { 9228 middle = (first+last)/2; 9229 m = sToString(sArrayGetTiny(self->a, (uint32_t)middle)); 9230 if (!m) { 9231 // there are null element in the array 9232 // the array needs to be trimmed or compacted 9233 goto finish; 9234 } 9235 if (strcmp(m, s) < 0) { 9236 first = middle + 1; 9237 } 9238 else if (strcmp(m, s) == 0) { 9239 r = middle; 9240 free(m); 9241 goto finish; 9242 } 9243 else { 9244 last = middle -1; 9245 } 9246 free(m); 9247 } 9248 finish: 9249 free(s); 9250 return(r); 9251 } 9252 9253 internal ssize_t binarySearchUndefinedSmallArray(smallArrayt *self UNUSED, undefinedt *u UNUSED) { 9254 // ssize_t first = 0, middle, last 9255 9256 // it doesn't make sense to search for undefined 9257 // the array has to be sorted 9258 // so undefined is always at postion 0 9259 return(-1); 9260 9261 // if !lenSmallArray(self) || !undefined 9262 // return -1 9263 9264 // if checkObjectTypes && !isOUndefined(undefined) 9265 // return -1 9266 9267 // smallt *m = NULL 9268 9269 // ssize_t r = -1 9270 // last = lenSmallArray(self) - 1 9271 // while first <= last 9272 // middle = (first+last)/2 9273 // m = sArrayGetTiny(self->a, middle) 9274 // if !m 9275 // // there are null element in the array 9276 // // the array needs to be trimmed or compacted 9277 // return -1 9278 // if m->type < UNDEFINED 9279 // first = middle + 1 9280 // else if m->type = UNDEFINED 9281 // r = middle 9282 // goto finish; 9283 // else 9284 // last = middle -1 9285 // finish: 9286 // return r 9287 } 9288 9289 internal ssize_t binarySearchBoolSmallArray(smallArrayt *self, bool value) { 9290 ssize_t first = 0, middle, last;; 9291 9292 if (!lenSmallArray(self)) { 9293 return(-1); 9294 } 9295 9296 sBoolt *m = NULL; 9297 9298 ssize_t r = -1; 9299 last = (ssize_t)lenSmallArray(self) - 1; 9300 while (first <= last) { 9301 middle = (first+last)/2; 9302 m = (sBoolt*)(sArrayGetTiny(self->a, (uint32_t)middle)); 9303 if (!m) { 9304 // there are null element in the array 9305 // the array needs to be trimmed or compacted 9306 return(-1); 9307 } 9308 if (m->type < BOOL || ((m->type == BOOL) && (m->value < value))) { 9309 first = middle + 1; 9310 } 9311 else if ((m->type == BOOL) && (m->value == value)) { 9312 r = middle; 9313 goto finish; 9314 } 9315 else { 9316 last = middle -1; 9317 } 9318 } 9319 finish: 9320 return(r); 9321 } 9322 9323 9324 internal ssize_t binarySearchDoubleSmallArray(smallArrayt *self, double value) { 9325 ssize_t first = 0, middle, last;; 9326 9327 if (!lenSmallArray(self)) { 9328 return(-1); 9329 } 9330 9331 sDoublet *m = NULL; 9332 9333 ssize_t r = -1; 9334 last = (ssize_t)lenSmallArray(self) - 1; 9335 while (first <= last) { 9336 middle = (first+last)/2; 9337 m = (sDoublet*)(sArrayGetTiny(self->a, (uint32_t)middle)); 9338 if (!m) { 9339 // there are null element in the array 9340 // the array needs to be trimmed or compacted 9341 return(-1); 9342 } 9343 if (m->type < DOUBLE || ((m->type == DOUBLE) && (m->value < value))) { 9344 first = middle + 1; 9345 } 9346 else if ((m->type == DOUBLE) && (m->value == value)) { 9347 r = middle; 9348 goto finish; 9349 } 9350 else { 9351 last = middle -1; 9352 } 9353 } 9354 finish: 9355 return(r); 9356 } 9357 9358 internal ssize_t binarySearchIntSmallArray(smallArrayt *self, int64_t value) { 9359 ssize_t first = 0, middle, last;; 9360 9361 if (!lenSmallArray(self)) { 9362 return(-1); 9363 } 9364 9365 sIntt *m = NULL; 9366 9367 ssize_t r = -1; 9368 last = (ssize_t)lenSmallArray(self) - 1; 9369 while (first <= last) { 9370 middle = (first+last)/2; 9371 m = (sIntt*)(sArrayGetTiny(self->a, (uint32_t)middle)); 9372 if (!m) { 9373 // there are null element in the array 9374 // the array needs to be trimmed or compacted 9375 return(-1); 9376 } 9377 if (m->type < INT || ((m->type == INT) && (m->value < value))) { 9378 first = middle + 1; 9379 } 9380 else if ((m->type == INT) && (m->value == value)) { 9381 r = middle; 9382 goto finish; 9383 } 9384 else { 9385 last = middle -1; 9386 } 9387 } 9388 finish: 9389 return(r); 9390 } 9391 9392 internal ssize_t binarySearchSSmallArray(smallArrayt *self, const char *string) { 9393 ssize_t first = 0, middle, last;; 9394 9395 if (!lenSmallArray(self) || !string) { 9396 return(-1); 9397 } 9398 9399 smallt *e = NULL; 9400 9401 last = (ssize_t)lenSmallArray(self) - 1; 9402 while (first <= last) { 9403 middle = (first+last)/2; 9404 e = sArrayGetTiny(self->a, (uint32_t)middle); 9405 if (!e) { 9406 // there are null element in the array 9407 // the array needs to be trimmed or compacted 9408 return(-1); 9409 } 9410 char *m = sStringGetTiny((sStringt*)(e)); 9411 if (e->type < STRING || ((e->type == STRING) && (strcmp(m, string) < 0))) { 9412 first = middle + 1; 9413 } 9414 else if ((e->type == STRING) && (strcmp(m, string) == 0)) { 9415 return(middle); 9416 } 9417 else { 9418 last = middle -1; 9419 } 9420 } 9421 return(-1); 9422 } 9423 9424 internal ssize_t binarySearchCharSmallArray(smallArrayt *self, char c) { 9425 9426 charToS(s, c); 9427 return(binarySearchSSmallArray(self, s)); 9428 } 9429 9430 internal ssize_t binarySearchDictSmallArray(smallArrayt *self, smallDictt *dict) { 9431 ssize_t first = 0, middle, last;; 9432 9433 if (!lenSmallArray(self) || !dict) { 9434 return(-1); 9435 } 9436 9437 if (checkObjectTypes && !isOSmallDict(dict)) { 9438 return(-1); 9439 } 9440 9441 char *s = toStringO(dict); 9442 smallt *e = NULL; 9443 char *m = NULL; 9444 9445 ssize_t r = -1; 9446 last = (ssize_t)lenSmallArray(self) - 1; 9447 while (first <= last) { 9448 middle = (first+last)/2; 9449 e = sArrayGetTiny(self->a, (uint32_t)middle); 9450 if (!e) { 9451 // there are null element in the array 9452 // the array needs to be trimmed or compacted 9453 goto finish; 9454 } 9455 // cg_c bug, can't use comma operator, extra code 9456 if (e->type == DICT) { 9457 m = sToString(e); 9458 } 9459 // cg_c bug, can't use comma operator 9460 /* if e->type < DICT || ((e->type = DICT) && strcmp((m=sToString(e),m), s) < 0) */ 9461 if (e->type < DICT || ((e->type == DICT) && strcmp(m, s) < 0)) { 9462 first = middle + 1; 9463 } 9464 else if ((e->type == DICT) && strcmp(m, s) == 0) { 9465 r = middle; 9466 free(m); 9467 goto finish; 9468 } 9469 else { 9470 last = middle -1; 9471 } 9472 if (e->type == DICT) { 9473 free(m); 9474 } 9475 } 9476 finish: 9477 free(s); 9478 return(r); 9479 } 9480 9481 internal ssize_t binarySearchArraySmallArray(smallArrayt *self, smallArrayt *array) { 9482 ssize_t first = 0, middle, last;; 9483 9484 if (!lenSmallArray(self) || !array) { 9485 return(-1); 9486 } 9487 9488 if (checkObjectTypes && !isOSmallArray(array)) { 9489 return(-1); 9490 } 9491 9492 char *s = toStringO(array); 9493 smallt *e = NULL; 9494 char *m = NULL; 9495 9496 ssize_t r = -1; 9497 last = (ssize_t)lenSmallArray(self) - 1; 9498 while (first <= last) { 9499 middle = (first+last)/2; 9500 e = sArrayGetTiny(self->a, (uint32_t)middle); 9501 if (!e) { 9502 // there are null element in the array 9503 // the array needs to be trimmed or compacted 9504 goto finish; 9505 } 9506 // cg_c bug, can't use comma operator, extra code 9507 if (e->type == ARRAY) { 9508 m = sToString(e); 9509 } 9510 // cg_c bug, can't use comma operator 9511 /* if e->type < ARRAY || ((e->type = ARRAY) && strcmp((m=sToString(e),m), s) < 0) */ 9512 if (e->type < ARRAY || ((e->type == ARRAY) && strcmp(m, s) < 0)) { 9513 first = middle + 1; 9514 } 9515 else if ((e->type == ARRAY) && strcmp(m, s) == 0) { 9516 r = middle; 9517 free(m); 9518 goto finish; 9519 } 9520 else { 9521 last = middle -1; 9522 } 9523 if (e->type == ARRAY) { 9524 free(m); 9525 } 9526 } 9527 finish: 9528 free(s); 9529 return(r); 9530 } 9531 9532 internal ssize_t binarySearchArraycSmallArray(smallArrayt *self, char **array) { 9533 ssize_t first = 0, middle, last;; 9534 9535 if (!lenSmallArray(self) || !array) { 9536 return(-1); 9537 } 9538 9539 char *s = toStringListSGF(array); 9540 smallt *e = NULL; 9541 char *m = NULL; 9542 9543 ssize_t r = -1; 9544 last = (ssize_t)lenSmallArray(self) - 1; 9545 while (first <= last) { 9546 middle = (first+last)/2; 9547 e = sArrayGetTiny(self->a, (uint32_t)middle); 9548 if (!e) { 9549 // there are null element in the array 9550 // the array needs to be trimmed or compacted 9551 goto finish; 9552 } 9553 // cg_c bug, can't use comma operator, extra code 9554 if (e->type == ARRAY) { 9555 m = sToString(e); 9556 } 9557 // cg_c bug, can't use comma operator 9558 /* if e->type < ARRAY || ((e->type = ARRAY) && strcmp((m=sToString(e),m), s) < 0) */ 9559 if (e->type < ARRAY || ((e->type == ARRAY) && strcmp(m, s) < 0)) { 9560 first = middle + 1; 9561 } 9562 else if ((e->type == ARRAY) && strcmp(m, s) == 0) { 9563 r = middle; 9564 free(m); 9565 goto finish; 9566 } 9567 else { 9568 last = middle -1; 9569 } 9570 if (e->type == ARRAY) { 9571 free(m); 9572 } 9573 } 9574 finish: 9575 free(s); 9576 return(r); 9577 } 9578 9579 internal ssize_t binarySearchCArraycSmallArray(smallArrayt *self, const char **array) { 9580 ssize_t first = 0, middle, last;; 9581 9582 if (!lenSmallArray(self) || !array) { 9583 return(-1); 9584 } 9585 9586 char *s = toStringListCSGF(array); 9587 smallt *e = NULL; 9588 char *m = NULL; 9589 9590 ssize_t r = -1; 9591 last = (ssize_t)lenSmallArray(self) - 1; 9592 while (first <= last) { 9593 middle = (first+last)/2; 9594 e = sArrayGetTiny(self->a, (uint32_t)middle); 9595 if (!e) { 9596 // there are null element in the array 9597 // the array needs to be trimmed or compacted 9598 goto finish; 9599 } 9600 // cg_c bug, can't use comma operator, extra code 9601 if (e->type == ARRAY) { 9602 m = sToString(e); 9603 } 9604 // cg_c bug, can't use comma operator 9605 /* if e->type < ARRAY || ((e->type = ARRAY) && strcmp((m=sToString(e),m), s) < 0) */ 9606 if (e->type < ARRAY || ((e->type == ARRAY) && strcmp(m, s) < 0)) { 9607 first = middle + 1; 9608 } 9609 else if ((e->type == ARRAY) && strcmp(m, s) == 0) { 9610 r = middle; 9611 free(m); 9612 goto finish; 9613 } 9614 else { 9615 last = middle -1; 9616 } 9617 if (e->type == ARRAY) { 9618 free(m); 9619 } 9620 } 9621 finish: 9622 free(s); 9623 return(r); 9624 } 9625 9626 internal ssize_t binarySearchSmallBoolSmallArray(smallArrayt *self, smallBoolt *value) { 9627 ssize_t first = 0, middle, last;; 9628 9629 if (!lenSmallArray(self) || !value) { 9630 return(-1); 9631 } 9632 9633 if (checkObjectTypes && !isOSmallBool(value)) { 9634 return(-1); 9635 } 9636 9637 bool b = value->f->get(value); 9638 sBoolt *m = NULL; 9639 9640 ssize_t r = -1; 9641 last = (ssize_t)lenSmallArray(self) - 1; 9642 while (first <= last) { 9643 middle = (first+last)/2; 9644 m = (sBoolt*)(sArrayGetTiny(self->a, (uint32_t)middle)); 9645 if (!m) { 9646 // there are null element in the array 9647 // the array needs to be trimmed or compacted 9648 goto finish; 9649 } 9650 if (m->type < BOOL || ((m->type == BOOL) && (m->value < b))) { 9651 first = middle + 1; 9652 } 9653 else if ((m->type == BOOL) && (m->value == b)) { 9654 r = middle; 9655 goto finish; 9656 } 9657 else { 9658 last = middle -1; 9659 } 9660 } 9661 finish: 9662 return(r); 9663 } 9664 9665 internal ssize_t binarySearchSmallBytesSmallArray(smallArrayt *self, smallBytest *value) { 9666 ssize_t first = 0, middle, last;; 9667 9668 if (!lenSmallArray(self) || !value || !value->B) { 9669 return(-1); 9670 } 9671 9672 if (checkObjectTypes && !isOSmallBytes(value)) { 9673 return(-1); 9674 } 9675 9676 void *b = sBytesGet(value->B); 9677 uint32_t count = value->B->count; 9678 sBytest *m = NULL; 9679 9680 ssize_t r = -1; 9681 last = (ssize_t)lenSmallArray(self) - 1; 9682 while (first <= last) { 9683 middle = (first+last)/2; 9684 m = (sBytest*)(sArrayGetTiny(self->a, (uint32_t)middle)); 9685 if (!m) { 9686 // there are null element in the array 9687 // the array needs to be trimmed or compacted 9688 goto finish; 9689 } 9690 if (m->type < BYTES || ((m->type == BYTES) && ((m->count < count) || (memcmp(&m->data, b, count) < 0)))) { 9691 first = middle + 1; 9692 } 9693 else if ((m->type == BYTES) && (m->count == count) && !memcmp(&m->data, b, count)) { 9694 r = middle; 9695 goto finish; 9696 } 9697 else { 9698 last = middle -1; 9699 } 9700 } 9701 finish: 9702 return(r); 9703 } 9704 9705 internal ssize_t binarySearchSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value) { 9706 ssize_t first = 0, middle, last;; 9707 9708 if (!lenSmallArray(self) || !value) { 9709 return(-1); 9710 } 9711 9712 if (checkObjectTypes && !isOSmallDouble(value)) { 9713 return(-1); 9714 } 9715 9716 double v = value->f->get(value); 9717 sDoublet *m = NULL; 9718 9719 ssize_t r = -1; 9720 last = (ssize_t)lenSmallArray(self) - 1; 9721 while (first <= last) { 9722 middle = (first+last)/2; 9723 m = (sDoublet*)(sArrayGetTiny(self->a, (uint32_t)middle)); 9724 if (!m) { 9725 // there are null element in the array 9726 // the array needs to be trimmed or compacted 9727 goto finish; 9728 } 9729 if (m->type < DOUBLE || ((m->type == DOUBLE) && (m->value < v))) { 9730 first = middle + 1; 9731 } 9732 else if ((m->type == DOUBLE) && (m->value == v)) { 9733 r = middle; 9734 goto finish; 9735 } 9736 else { 9737 last = middle -1; 9738 } 9739 } 9740 finish: 9741 return(r); 9742 } 9743 9744 internal ssize_t binarySearchSmallIntSmallArray(smallArrayt *self, smallIntt *value) { 9745 ssize_t first = 0, middle, last;; 9746 9747 if (!lenSmallArray(self) || !value) { 9748 return(-1); 9749 } 9750 9751 if (checkObjectTypes && !isOSmallInt(value)) { 9752 return(-1); 9753 } 9754 9755 int64_t v = value->f->get(value); 9756 sIntt *m = NULL; 9757 9758 ssize_t r = -1; 9759 last = (ssize_t)lenSmallArray(self) - 1; 9760 while (first <= last) { 9761 middle = (first+last)/2; 9762 m = (sIntt*)(sArrayGetTiny(self->a, (uint32_t)middle)); 9763 if (!m) { 9764 // there are null element in the array 9765 // the array needs to be trimmed or compacted 9766 goto finish; 9767 } 9768 if (m->type < INT || ((m->type == INT) && (m->value < v))) { 9769 first = middle + 1; 9770 } 9771 else if ((m->type == INT) && (m->value == v)) { 9772 r = middle; 9773 goto finish; 9774 } 9775 else { 9776 last = middle -1; 9777 } 9778 } 9779 finish: 9780 return(r); 9781 } 9782 9783 internal ssize_t binarySearchSmallJsonSmallArray(smallArrayt *self, smallJsont *string) { 9784 9785 if (!lenSmallArray(self) || !string) { 9786 return(-1); 9787 } 9788 9789 if (checkObjectTypes && !isOSmallJson(string)) { 9790 return(-1); 9791 } 9792 9793 const char *type = getTopTypeO(string); 9794 9795 if (!type) { 9796 // smallJson is empty 9797 return(-1); 9798 } 9799 9800 baset *O = NULL; 9801 ssize_t r = -1; 9802 if (eqS(type, "undefined")) { 9803 // it doesn't make sense to search for undefined 9804 // the array has to be sorted 9805 // so undefined is always at postion 0 9806 return(-1); 9807 } 9808 else if (eqS(type, "bool")) { 9809 O = getTopO(string); 9810 r = binarySearchSmallBoolSmallArray(self, (smallBoolt*)O); 9811 finishO(O); 9812 } 9813 else if (eqS(type, "double")) { 9814 O = getTopO(string); 9815 r = binarySearchSmallDoubleSmallArray(self, (smallDoublet*)O); 9816 finishO(O); 9817 } 9818 else if (eqS(type, "int")) { 9819 O = getTopO(string); 9820 r = binarySearchSmallIntSmallArray(self, (smallIntt*)O); 9821 finishO(O); 9822 } 9823 else if (eqS(type, "string")) { 9824 O = getTopO(string); 9825 r = binarySearchSmallStringSmallArray(self, (smallStringt*)O); 9826 finishO(O); 9827 } 9828 else if (eqS(type, "dict")) { 9829 O = getTopO(string); 9830 r = binarySearchDictSmallArray(self, (smallDictt*)O); 9831 finishO(O); 9832 } 9833 else if (eqS(type, "array")) { 9834 O = getTopO(string); 9835 r = binarySearchArraySmallArray(self, (smallArrayt*)O); 9836 finishO(O); 9837 } 9838 return(r); 9839 } 9840 9841 internal ssize_t binarySearchSmallStringSmallArray(smallArrayt *self, smallStringt *string) { 9842 ssize_t first = 0, middle, last;; 9843 9844 if (!lenSmallArray(self) || !string || !string->data) { 9845 return(-1); 9846 } 9847 9848 char *s = sStringGetTiny(string->data); 9849 smallt *e = NULL; 9850 9851 if (checkObjectTypes && !isOSmallString(string)) { 9852 return(-1); 9853 } 9854 9855 last = (ssize_t)lenSmallArray(self) - 1; 9856 while (first <= last) { 9857 middle = (first+last)/2; 9858 e = sArrayGetTiny(self->a, (uint32_t)middle); 9859 if (!e) { 9860 // there are null element in the array 9861 // the array needs to be trimmed or compacted 9862 return(-1); 9863 } 9864 char *m = sStringGetTiny((sStringt*)(e)); 9865 if (e->type < STRING || ((e->type == STRING) && (strcmp(m, s) < 0))) { 9866 first = middle + 1; 9867 } 9868 else if ((e->type == STRING) && (strcmp(m, s) == 0)) { 9869 return(middle); 9870 } 9871 else { 9872 last = middle -1; 9873 } 9874 } 9875 return(-1); 9876 } 9877 9878 internal ssize_t binarySearchSmallContainerSmallArray(smallArrayt *self UNUSED, smallContainert *container UNUSED) { 9879 9880 // TODO 9881 return(-1); 9882 } 9883 9884 9885 9886 9887 9888 internal smallArrayt* uniqSmallArray(smallArrayt *self) { 9889 9890 // sanity checks 9891 if (!lenSmallArray(self)) { 9892 return(NULL); 9893 } 9894 9895 if (lenSmallArray(self) == 1) { 9896 return(self); 9897 } 9898 9899 createAllocateSmallArray(r); 9900 if (!r) { 9901 return(NULL); 9902 } 9903 createAllocateSmallArray(a); 9904 if (!a) { 9905 terminateO(r); 9906 return(NULL); 9907 } 9908 createAllocateSmallDict(d); 9909 if (!d) { 9910 terminateO(r); 9911 terminateO(a); 9912 return(NULL); 9913 } 9914 createAllocateSmallBytes(B); 9915 if (!B) { 9916 terminateO(r); 9917 terminateO(a); 9918 terminateO(B); 9919 return(NULL); 9920 } 9921 9922 // push element to new list if it is not already in new list 9923 bool pushE = false; 9924 bool foundUndefined = false; 9925 forEachSArray(self->a, e) { 9926 if (e) { 9927 switch (e->type) { 9928 case UNDEFINED: 9929 if (!foundUndefined) { 9930 pushE = true; 9931 foundUndefined = true; 9932 } 9933 else { 9934 free(e); 9935 } 9936 break; 9937 case BOOL: 9938 if (r->f->indexOfBool(r, ((sBoolt*)e)->value) == -1) { 9939 pushE = true; 9940 } 9941 else { 9942 free(e); 9943 } 9944 break; 9945 // TODO case CONTAINER: 9946 case DICT: 9947 d->d = (sDictt*)e; 9948 if (r->f->indexOfDict(r, d) == -1) { 9949 pushE = true; 9950 } 9951 else { 9952 freeO(d); 9953 } 9954 break; 9955 case DOUBLE: 9956 if (r->f->indexOfDouble(r, ((sDoublet*)e)->value) == -1) { 9957 pushE = true; 9958 } 9959 else { 9960 free(e); 9961 } 9962 break; 9963 case INT: 9964 if (r->f->indexOfInt(r, ((sIntt*)e)->value) == -1) { 9965 pushE = true; 9966 } 9967 else { 9968 free(e); 9969 } 9970 break; 9971 case STRING: 9972 if (r->f->indexOfS(r, sStringGetTiny((sStringt*)e)) == -1) { 9973 pushE = true; 9974 } 9975 else { 9976 free(e); 9977 } 9978 break; 9979 case ARRAY: 9980 a->a = (sArrayt*)e; 9981 if (r->f->indexOfArray(r, a) == -1) { 9982 pushE = true; 9983 } 9984 else { 9985 freeO(a); 9986 } 9987 break; 9988 case BYTES: 9989 B->B = (sBytest*)e; 9990 if (r->f->indexOfSmallBytes(r, B) == -1) { 9991 pushE = true; 9992 } 9993 else { 9994 freeO(B); 9995 } 9996 break; 9997 default: 9998 logC("Unsupported object type!"); 9999 } 10000 } 10001 if (pushE) { 10002 sArrayPushTiny(&(r->a), e); 10003 pushE = false; 10004 } 10005 } 10006 10007 finishManyG(a, d, B); 10008 10009 free(self->a); 10010 self->a = r->a; 10011 finishO(r); 10012 return(self); 10013 } 10014 10015 10016 internal bool icHasSmallArray(smallArrayt *self, baset *value) { 10017 10018 if (!value) { 10019 return(false); 10020 } 10021 10022 if (icIndexOfSmallArray(self, value) == -1) { 10023 return(false); 10024 } 10025 10026 return(true); 10027 } 10028 10029 internal bool icHasSSmallArray(smallArrayt *self, const char *string) { 10030 10031 if (!string) { 10032 return(false); 10033 } 10034 10035 if (icIndexOfSSmallArray(self, string) == -1) { 10036 return(false); 10037 } 10038 10039 return(true); 10040 } 10041 10042 internal bool icHasCharSmallArray(smallArrayt *self, char c) { 10043 10044 charToS(s, c); 10045 return(icHasSSmallArray(self, s)); 10046 } 10047 10048 internal bool icHasDictSmallArray(smallArrayt *self, smallDictt *dict) { 10049 10050 if (!dict) { 10051 return(false); 10052 } 10053 10054 if (icIndexOfDictSmallArray(self, dict) == -1) { 10055 return(false); 10056 } 10057 10058 return(true); 10059 } 10060 10061 internal bool icHasArraySmallArray(smallArrayt *self, smallArrayt *array) { 10062 10063 if (!array) { 10064 return(false); 10065 } 10066 10067 if (icIndexOfArraySmallArray(self, array) == -1) { 10068 return(false); 10069 } 10070 10071 return(true); 10072 } 10073 10074 internal bool icHasArraycSmallArray(smallArrayt *self, char **array) { 10075 10076 if (!array) { 10077 return(false); 10078 } 10079 10080 if (icIndexOfArraycSmallArray(self, array) == -1) { 10081 return(false); 10082 } 10083 10084 return(true); 10085 } 10086 10087 internal bool icHasCArraycSmallArray(smallArrayt *self, const char **array) { 10088 10089 if (!array) { 10090 return(false); 10091 } 10092 10093 if (icIndexOfCArraycSmallArray(self, array) == -1) { 10094 return(false); 10095 } 10096 10097 return(true); 10098 } 10099 10100 internal bool icHasSmallJsonSmallArray(smallArrayt *self, smallJsont *string) { 10101 10102 if (!string) { 10103 return(false); 10104 } 10105 10106 if (icIndexOfSmallJsonSmallArray(self, string) == -1) { 10107 return(false); 10108 } 10109 10110 return(true); 10111 } 10112 10113 internal bool icHasSmallStringSmallArray(smallArrayt *self, smallStringt *string) { 10114 10115 if (!string) { 10116 return(false); 10117 } 10118 10119 if (icIndexOfSmallStringSmallArray(self, string) == -1) { 10120 return(false); 10121 } 10122 10123 return(true); 10124 } 10125 10126 internal ssize_t icIndexOfSmallArray(smallArrayt *self, baset *value) { 10127 10128 // sanity checks 10129 if (!lenSmallArray(self) || !value) { 10130 return(-1); 10131 } 10132 10133 // search string in elements 10134 char *s = toStringO(value); 10135 char *es = NULL; 10136 10137 enumerateSArray(self->a, e, i) { 10138 if (not e) { 10139 continue; 10140 } 10141 es = sToString(e); 10142 if (icEqS(es, s)) { 10143 free(es); 10144 free(s); 10145 return((ssize_t)i); 10146 } 10147 free(es); 10148 } 10149 free(s); 10150 return(-1); 10151 } 10152 10153 internal ssize_t icIndexOfSSmallArray(smallArrayt *self, const char *string) { 10154 10155 // sanity checks 10156 if (!lenSmallArray(self)) { 10157 return(-1); 10158 } 10159 if (!string) { 10160 return(-1); 10161 } 10162 // search string in elements 10163 enumerateSArray(self->a, e, i) { 10164 if (not e) { 10165 continue; 10166 } 10167 if (e->type == STRING && icEqS(sStringGetTiny((sStringt*)e), string)) { 10168 return((ssize_t)i); 10169 } 10170 } 10171 return(-1); 10172 } 10173 10174 internal ssize_t icIndexOfCharSmallArray(smallArrayt *self, char c) { 10175 10176 charToS(s, c); 10177 return(icIndexOfSSmallArray(self, s)); 10178 } 10179 10180 internal ssize_t icIndexOfDictSmallArray(smallArrayt *self, smallDictt *dict) { 10181 10182 // sanity checks 10183 if (!lenSmallArray(self) || !dict) { 10184 return(-1); 10185 } 10186 10187 if (checkObjectTypes && !isOSmallDict(dict)) { 10188 return(-1); 10189 } 10190 10191 // search object in elements 10192 char *s = toStringO(dict); 10193 char *es = NULL;; 10194 10195 enumerateSArray(self->a, e, i) { 10196 if (not e) { 10197 continue; 10198 } 10199 if (e->type == DICT) { 10200 es = sToString(e); 10201 if (icEqS(es, s)) { 10202 free(es); 10203 free(s); 10204 return((ssize_t)i); 10205 } 10206 free(es); 10207 } 10208 } 10209 free(s); 10210 return(-1); 10211 } 10212 10213 internal ssize_t icIndexOfArraySmallArray(smallArrayt *self, smallArrayt *array) { 10214 10215 // sanity checks 10216 if (!lenSmallArray(self) || !array) { 10217 return(-1); 10218 } 10219 10220 if (checkObjectTypes && !isOSmallArray(array)) { 10221 return(-1); 10222 } 10223 10224 // search object in elements 10225 char *s = toStringO(array); 10226 char *es = NULL;; 10227 10228 enumerateSArray(self->a, e, i) { 10229 if (not e) { 10230 continue; 10231 } 10232 if (e->type == ARRAY) { 10233 es = sToString(e); 10234 if (icEqS(es, s)) { 10235 free(es); 10236 free(s); 10237 return((ssize_t)i); 10238 } 10239 free(es); 10240 } 10241 } 10242 free(s); 10243 return(-1); 10244 } 10245 10246 internal ssize_t icIndexOfArraycSmallArray(smallArrayt *self, char **array) { 10247 10248 // sanity checks 10249 if (!lenSmallArray(self) || !array) { 10250 return(-1); 10251 } 10252 10253 // search object in elements 10254 char *s = toStringListSGF(array); 10255 char *es = NULL;; 10256 10257 enumerateSArray(self->a, e, i) { 10258 if (not e) { 10259 continue; 10260 } 10261 if (e->type == ARRAY) { 10262 es = sToString(e); 10263 if (icEqS(es, s)) { 10264 free(es); 10265 free(s); 10266 return((ssize_t)i); 10267 } 10268 free(es); 10269 } 10270 } 10271 free(s); 10272 return(-1); 10273 } 10274 10275 internal ssize_t icIndexOfCArraycSmallArray(smallArrayt *self, const char **array) { 10276 10277 // sanity checks 10278 if (!lenSmallArray(self) || !array) { 10279 return(-1); 10280 } 10281 10282 // search object in elements 10283 char *s = toStringListCSGF(array); 10284 char *es = NULL;; 10285 10286 enumerateSArray(self->a, e, i) { 10287 if (not e) { 10288 continue; 10289 } 10290 if (e->type == ARRAY) { 10291 es = sToString(e); 10292 if (icEqS(es, s)) { 10293 free(es); 10294 free(s); 10295 return((ssize_t)i); 10296 } 10297 free(es); 10298 } 10299 } 10300 free(s); 10301 return(-1); 10302 } 10303 10304 internal ssize_t icIndexOfSmallJsonSmallArray(smallArrayt *self, smallJsont *string) { 10305 10306 if (!lenSmallArray(self) || !string) { 10307 return(-1); 10308 } 10309 10310 if (checkObjectTypes && !isOSmallJson(string)) { 10311 return(-1); 10312 } 10313 10314 const char *type = getTopTypeO(string); 10315 10316 if (!type) { 10317 // smallJson is empty 10318 return(-1); 10319 } 10320 10321 baset *O = NULL; 10322 ssize_t r = -1; 10323 if (eqS(type, "undefined")) { 10324 O = getTopO(string); 10325 r = indexOfSmallArray(self, O); 10326 finishO(O); 10327 } 10328 else if (eqS(type, "bool")) { 10329 O = getTopO(string); 10330 r = indexOfSmallBoolSmallArray(self, (smallBoolt*)O); 10331 finishO(O); 10332 } 10333 else if (eqS(type, "double")) { 10334 O = getTopO(string); 10335 r = indexOfSmallDoubleSmallArray(self, (smallDoublet*)O); 10336 finishO(O); 10337 } 10338 else if (eqS(type, "int")) { 10339 O = getTopO(string); 10340 r = indexOfSmallIntSmallArray(self, (smallIntt*)O); 10341 finishO(O); 10342 } 10343 else if (eqS(type, "string")) { 10344 O = getTopO(string); 10345 r = icIndexOfSmallStringSmallArray(self, (smallStringt*)O); 10346 finishO(O); 10347 } 10348 else if (eqS(type, "dict")) { 10349 O = getTopO(string); 10350 r = icIndexOfDictSmallArray(self, (smallDictt*)O); 10351 finishO(O); 10352 } 10353 else if (eqS(type, "array")) { 10354 O = getTopO(string); 10355 r = icIndexOfArraySmallArray(self, (smallArrayt*)O); 10356 finishO(O); 10357 } 10358 return(r); 10359 } 10360 10361 internal ssize_t icIndexOfSmallStringSmallArray(smallArrayt *self, smallStringt *string) { 10362 10363 // sanity checks 10364 if (!lenSmallArray(self)) { 10365 return(-1); 10366 } 10367 10368 if (!string || !string->data) { 10369 return(-1); 10370 } 10371 10372 if (checkObjectTypes && !isOSmallString(string)) { 10373 return(-1); 10374 } 10375 10376 // search string in elements 10377 char *s = sStringGetTiny(string->data); 10378 10379 enumerateSArray(self->a, e, i) { 10380 if (not e) { 10381 continue; 10382 } 10383 if (e->type == STRING && icEqS(sStringGetTiny((sStringt*)e), s)) { 10384 return((ssize_t)i); 10385 } 10386 } 10387 return(-1); 10388 } 10389 10390 internal ssize_t icBinarySearchSmallArray(smallArrayt *self, baset *value) { 10391 ssize_t first = 0, middle, last;; 10392 10393 if (!lenSmallArray(self) || !value) { 10394 return(-1); 10395 } 10396 10397 char *s = toStringO(value); 10398 char *m = NULL; 10399 10400 ssize_t r = -1; 10401 last = (ssize_t)lenSmallArray(self) - 1; 10402 while (first <= last) { 10403 middle = (first+last)/2; 10404 m = sToString(sArrayGetTiny(self->a, (uint32_t)middle)); 10405 if (!m) { 10406 // there are null element in the array 10407 // the array needs to be trimmed or compacted 10408 goto finish; 10409 } 10410 if (strcasecmp(m, s) < 0) { 10411 first = middle + 1; 10412 } 10413 else if (strcasecmp(m, s) == 0) { 10414 r = middle; 10415 free(m); 10416 goto finish; 10417 } 10418 else { 10419 last = middle -1; 10420 } 10421 free(m); 10422 } 10423 finish: 10424 free(s); 10425 return(r); 10426 } 10427 10428 internal ssize_t icBinarySearchSSmallArray(smallArrayt *self, const char *string) { 10429 ssize_t first = 0, middle, last;; 10430 10431 if (!lenSmallArray(self) || !string) { 10432 return(-1); 10433 } 10434 10435 smallt *e = NULL; 10436 10437 last = (ssize_t)lenSmallArray(self) - 1; 10438 while (first <= last) { 10439 middle = (first+last)/2; 10440 e = sArrayGetTiny(self->a, (uint32_t)middle); 10441 if (!e) { 10442 // there are null element in the array 10443 // the array needs to be trimmed or compacted 10444 return(-1); 10445 } 10446 char *m = sStringGetTiny((sStringt*)(e)); 10447 if (e->type < STRING || ((e->type == STRING) && (strcasecmp(m, string) < 0))) { 10448 first = middle + 1; 10449 } 10450 else if ((e->type == STRING) && (strcasecmp(m, string) == 0)) { 10451 return(middle); 10452 } 10453 else { 10454 last = middle -1; 10455 } 10456 } 10457 return(-1); 10458 } 10459 10460 internal ssize_t icBinarySearchCharSmallArray(smallArrayt *self, char c) { 10461 10462 charToS(s, c); 10463 return(icBinarySearchSSmallArray(self, s)); 10464 } 10465 10466 internal ssize_t icBinarySearchDictSmallArray(smallArrayt *self, smallDictt *dict) { 10467 ssize_t first = 0, middle, last;; 10468 10469 if (!lenSmallArray(self) || !dict) { 10470 return(-1); 10471 } 10472 10473 if (checkObjectTypes && !isOSmallDict(dict)) { 10474 return(-1); 10475 } 10476 10477 char *s = toStringO(dict); 10478 smallt *e = NULL; 10479 char *m = NULL; 10480 10481 ssize_t r = -1; 10482 last = (ssize_t)lenSmallArray(self) - 1; 10483 while (first <= last) { 10484 middle = (first+last)/2; 10485 e = sArrayGetTiny(self->a, (uint32_t)middle); 10486 if (!e) { 10487 // there are null element in the array 10488 // the array needs to be trimmed or compacted 10489 goto finish; 10490 } 10491 // cg_c bug, can't use comma operator, extra code 10492 if (e->type == DICT) { 10493 m = sToString(e); 10494 } 10495 // cg_c bug, can't use comma operator 10496 /* if e->type < DICT || ((e->type = DICT) && strcmp((m=sToString(e),m), s) < 0) */ 10497 if (e->type < DICT || ((e->type == DICT) && strcasecmp(m, s) < 0)) { 10498 first = middle + 1; 10499 } 10500 else if ((e->type == DICT) && strcasecmp(m, s) == 0) { 10501 r = middle; 10502 free(m); 10503 goto finish; 10504 } 10505 else { 10506 last = middle -1; 10507 } 10508 if (e->type == DICT) { 10509 free(m); 10510 } 10511 } 10512 finish: 10513 free(s); 10514 return(r); 10515 } 10516 10517 internal ssize_t icBinarySearchArraySmallArray(smallArrayt *self, smallArrayt *array) { 10518 ssize_t first = 0, middle, last;; 10519 10520 if (!lenSmallArray(self) || !array) { 10521 return(-1); 10522 } 10523 10524 if (checkObjectTypes && !isOSmallArray(array)) { 10525 return(-1); 10526 } 10527 10528 char *s = toStringO(array); 10529 smallt *e = NULL; 10530 char *m = NULL; 10531 10532 ssize_t r = -1; 10533 last = (ssize_t)lenSmallArray(self) - 1; 10534 while (first <= last) { 10535 middle = (first+last)/2; 10536 e = sArrayGetTiny(self->a, (uint32_t)middle); 10537 if (!e) { 10538 // there are null element in the array 10539 // the array needs to be trimmed or compacted 10540 goto finish; 10541 } 10542 // cg_c bug, can't use comma operator, extra code 10543 if (e->type == ARRAY) { 10544 m = sToString(e); 10545 } 10546 // cg_c bug, can't use comma operator 10547 /* if e->type < ARRAY || ((e->type = ARRAY) && strcmp((m=sToString(e),m), s) < 0) */ 10548 if (e->type < ARRAY || ((e->type == ARRAY) && strcasecmp(m, s) < 0)) { 10549 first = middle + 1; 10550 } 10551 else if ((e->type == ARRAY) && strcasecmp(m, s) == 0) { 10552 r = middle; 10553 free(m); 10554 goto finish; 10555 } 10556 else { 10557 last = middle -1; 10558 } 10559 if (e->type == ARRAY) { 10560 free(m); 10561 } 10562 } 10563 finish: 10564 free(s); 10565 return(r); 10566 } 10567 10568 internal ssize_t icBinarySearchArraycSmallArray(smallArrayt *self, char **array) { 10569 ssize_t first = 0, middle, last;; 10570 10571 if (!lenSmallArray(self) || !array) { 10572 return(-1); 10573 } 10574 10575 char *s = toStringListSGF(array); 10576 smallt *e = NULL; 10577 char *m = NULL; 10578 10579 ssize_t r = -1; 10580 last = (ssize_t)lenSmallArray(self) - 1; 10581 while (first <= last) { 10582 middle = (first+last)/2; 10583 e = sArrayGetTiny(self->a, (uint32_t)middle); 10584 if (!e) { 10585 // there are null element in the array 10586 // the array needs to be trimmed or compacted 10587 goto finish; 10588 } 10589 // cg_c bug, can't use comma operator, extra code 10590 if (e->type == ARRAY) { 10591 m = sToString(e); 10592 } 10593 // cg_c bug, can't use comma operator 10594 /* if e->type < ARRAY || ((e->type = ARRAY) && strcmp((m=sToString(e),m), s) < 0) */ 10595 if (e->type < ARRAY || ((e->type == ARRAY) && strcasecmp(m, s) < 0)) { 10596 first = middle + 1; 10597 } 10598 else if ((e->type == ARRAY) && strcasecmp(m, s) == 0) { 10599 r = middle; 10600 free(m); 10601 goto finish; 10602 } 10603 else { 10604 last = middle -1; 10605 } 10606 if (e->type == ARRAY) { 10607 free(m); 10608 } 10609 } 10610 finish: 10611 free(s); 10612 return(r); 10613 } 10614 10615 internal ssize_t icBinarySearchCArraycSmallArray(smallArrayt *self, const char **array) { 10616 ssize_t first = 0, middle, last;; 10617 10618 if (!lenSmallArray(self) || !array) { 10619 return(-1); 10620 } 10621 10622 char *s = toStringListCSGF(array); 10623 smallt *e = NULL; 10624 char *m = NULL; 10625 10626 ssize_t r = -1; 10627 last = (ssize_t)lenSmallArray(self) - 1; 10628 while (first <= last) { 10629 middle = (first+last)/2; 10630 e = sArrayGetTiny(self->a, (uint32_t)middle); 10631 if (!e) { 10632 // there are null element in the array 10633 // the array needs to be trimmed or compacted 10634 goto finish; 10635 } 10636 // cg_c bug, can't use comma operator, extra code 10637 if (e->type == ARRAY) { 10638 m = sToString(e); 10639 } 10640 // cg_c bug, can't use comma operator 10641 /* if e->type < ARRAY || ((e->type = ARRAY) && strcmp((m=sToString(e),m), s) < 0) */ 10642 if (e->type < ARRAY || ((e->type == ARRAY) && strcasecmp(m, s) < 0)) { 10643 first = middle + 1; 10644 } 10645 else if ((e->type == ARRAY) && strcasecmp(m, s) == 0) { 10646 r = middle; 10647 free(m); 10648 goto finish; 10649 } 10650 else { 10651 last = middle -1; 10652 } 10653 if (e->type == ARRAY) { 10654 free(m); 10655 } 10656 } 10657 finish: 10658 free(s); 10659 return(r); 10660 } 10661 10662 internal ssize_t icBinarySearchSmallJsonSmallArray(smallArrayt *self, smallJsont *string) { 10663 10664 if (!lenSmallArray(self) || !string) { 10665 return(-1); 10666 } 10667 10668 if (checkObjectTypes && !isOSmallJson(string)) { 10669 return(-1); 10670 } 10671 10672 const char *type = getTopTypeO(string); 10673 10674 if (!type) { 10675 // smallJson is empty 10676 return(-1); 10677 } 10678 10679 baset *O = NULL; 10680 ssize_t r = -1; 10681 if (eqS(type, "undefined")) { 10682 // it doesn't make sense to search for undefined 10683 // the array has to be sorted 10684 // so undefined is always at postion 0 10685 return(-1); 10686 } 10687 else if (eqS(type, "bool")) { 10688 O = getTopO(string); 10689 r = binarySearchSmallBoolSmallArray(self, (smallBoolt*)O); 10690 finishO(O); 10691 } 10692 else if (eqS(type, "double")) { 10693 O = getTopO(string); 10694 r = binarySearchSmallDoubleSmallArray(self, (smallDoublet*)O); 10695 finishO(O); 10696 } 10697 else if (eqS(type, "int")) { 10698 O = getTopO(string); 10699 r = binarySearchSmallIntSmallArray(self, (smallIntt*)O); 10700 finishO(O); 10701 } 10702 else if (eqS(type, "string")) { 10703 O = getTopO(string); 10704 r = icBinarySearchSmallStringSmallArray(self, (smallStringt*)O); 10705 finishO(O); 10706 } 10707 else if (eqS(type, "dict")) { 10708 O = getTopO(string); 10709 r = icBinarySearchDictSmallArray(self, (smallDictt*)O); 10710 finishO(O); 10711 } 10712 else if (eqS(type, "array")) { 10713 O = getTopO(string); 10714 r = icBinarySearchArraySmallArray(self, (smallArrayt*)O); 10715 finishO(O); 10716 } 10717 return(r); 10718 } 10719 10720 internal ssize_t icBinarySearchSmallStringSmallArray(smallArrayt *self, smallStringt *string) { 10721 ssize_t first = 0, middle, last;; 10722 10723 if (!lenSmallArray(self) || !string || !string->data) { 10724 return(-1); 10725 } 10726 10727 if (checkObjectTypes && !isOSmallString(string)) { 10728 return(-1); 10729 } 10730 10731 char *s = sStringGetTiny(string->data); 10732 smallt *e = NULL; 10733 10734 last = (ssize_t)lenSmallArray(self) - 1; 10735 while (first <= last) { 10736 middle = (first+last)/2; 10737 e = sArrayGetTiny(self->a, (uint32_t)middle); 10738 if (!e) { 10739 // there are null element in the array 10740 // the array needs to be trimmed or compacted 10741 return(-1); 10742 } 10743 char *m = sStringGetTiny((sStringt*)(e)); 10744 if (e->type < STRING || ((e->type == STRING) && (strcasecmp(m, s) < 0))) { 10745 first = middle + 1; 10746 } 10747 else if ((e->type == STRING) && (strcasecmp(m, s) == 0)) { 10748 return(middle); 10749 } 10750 else { 10751 last = middle -1; 10752 } 10753 } 10754 return(-1); 10755 } 10756 10757 10758 10759 10760 10761 internal smallArrayt* icUniqSmallArray(smallArrayt *self) { 10762 10763 // sanity checks 10764 if (!lenSmallArray(self)) { 10765 return(NULL); 10766 } 10767 10768 if (lenSmallArray(self) == 1) { 10769 return(self); 10770 } 10771 10772 createAllocateSmallArray(r); 10773 if (!r) { 10774 return(NULL); 10775 } 10776 createAllocateSmallArray(a); 10777 if (!a) { 10778 terminateO(r); 10779 return(NULL); 10780 } 10781 createAllocateSmallDict(d); 10782 if (!d) { 10783 terminateO(r); 10784 terminateO(a); 10785 return(NULL); 10786 } 10787 createAllocateSmallBytes(B); 10788 if (!B) { 10789 terminateO(r); 10790 terminateO(a); 10791 terminateO(B); 10792 return(NULL); 10793 } 10794 10795 // push element to new list if it is not already in new list 10796 bool pushE = false; 10797 bool foundUndefined = false; 10798 forEachSArray(self->a, e) { 10799 if (e) { 10800 switch (e->type) { 10801 case UNDEFINED: 10802 if (!foundUndefined) { 10803 pushE = true; 10804 foundUndefined = true; 10805 } 10806 else { 10807 free(e); 10808 } 10809 break; 10810 case BOOL: 10811 if (r->f->indexOfBool(r, ((sBoolt*)e)->value) == -1) { 10812 pushE = true; 10813 } 10814 else { 10815 free(e); 10816 } 10817 break; 10818 // TODO case CONTAINER: 10819 case DICT: 10820 d->d = (sDictt*)e; 10821 if (r->f->icIndexOfDict(r, d) == -1) { 10822 pushE = true; 10823 } 10824 else { 10825 freeO(d); 10826 } 10827 break; 10828 case DOUBLE: 10829 if (r->f->indexOfDouble(r, ((sDoublet*)e)->value) == -1) { 10830 pushE = true; 10831 } 10832 else { 10833 free(e); 10834 } 10835 break; 10836 case INT: 10837 if (r->f->indexOfInt(r, ((sIntt*)e)->value) == -1) { 10838 pushE = true; 10839 } 10840 else { 10841 free(e); 10842 } 10843 break; 10844 case STRING: 10845 if (r->f->icIndexOfS(r, sStringGetTiny((sStringt*)e)) == -1) { 10846 pushE = true; 10847 } 10848 else { 10849 free(e); 10850 } 10851 break; 10852 case ARRAY: 10853 a->a = (sArrayt*)e; 10854 if (r->f->icIndexOfArray(r, a) == -1) { 10855 pushE = true; 10856 } 10857 else { 10858 freeO(a); 10859 } 10860 break; 10861 case BYTES: 10862 B->B = (sBytest*)e; 10863 if (r->f->indexOfSmallBytes(r, B) == -1) { 10864 pushE = true; 10865 } 10866 else { 10867 freeO(B); 10868 } 10869 break; 10870 default: 10871 logC("Unsupported object type!"); 10872 } 10873 } 10874 if (pushE) { 10875 sArrayPushTiny(&(r->a), e); 10876 pushE = false; 10877 } 10878 } 10879 10880 finishManyG(a, d, B); 10881 10882 free(self->a); 10883 self->a = r->a; 10884 finishO(r); 10885 return(self); 10886 } 10887 10888 10889 internal smallArrayt* compactSmallArray(smallArrayt *self) { 10890 10891 // sanity checks 10892 if (!lenSmallArray(self)) { 10893 return(NULL); 10894 } 10895 10896 createAllocateSmallArray(r); 10897 if (!r) { 10898 return(NULL); 10899 } 10900 10901 char *trim = NULL; 10902 10903 // keep non empty elements 10904 forEachSArray(self->a, e) { 10905 if (e) { 10906 switch (e->type) { 10907 case UNDEFINED: 10908 free(e); 10909 break; 10910 case BOOL: 10911 sArrayPushTiny(&(r->a), e); 10912 break; 10913 case CONTAINER: 10914 sArrayPushTiny(&(r->a), e); 10915 break; 10916 case DICT: 10917 if (((sDictt*)e)->count > 0) { 10918 sArrayPushTiny(&(r->a), e); 10919 } 10920 else { 10921 sFree(e); 10922 } 10923 break; 10924 case DOUBLE: 10925 sArrayPushTiny(&(r->a), e); 10926 break; 10927 case INT: 10928 sArrayPushTiny(&(r->a), e); 10929 break; 10930 case STRING: 10931 trim = trimS(sStringGetTiny((sStringt*)e)); 10932 if (*trim != 0) { 10933 sArrayPushTiny(&(r->a), e); 10934 } 10935 else { 10936 free(e); 10937 } 10938 free(trim); 10939 break; 10940 case ARRAY: 10941 if (((sArrayt*)e)->count > 0) { 10942 sArrayPushTiny(&(r->a), e); 10943 } 10944 else { 10945 sFree(e); 10946 } 10947 break; 10948 case BYTES: 10949 if (((sBytest*)e)->count > 0) { 10950 sArrayPushTiny(&(r->a), e); 10951 } 10952 else { 10953 sFree(e); 10954 } 10955 break; 10956 default: 10957 logC("Unsupported object type!"); 10958 } 10959 } 10960 } 10961 10962 free(self->a); 10963 if ((r->a)) { 10964 self->a = r->a; 10965 } 10966 else { 10967 // r->a is null and has no elements, allocate an empty sArray 10968 // to make setP work correctly after a call to compact. 10969 // For example: 10970 // smallArrayt *a = getG(dict, rtSmallArrayt, "key"); 10971 // compactG(a); 10972 // setNFreePG(dict, "key", a); 10973 // if self->a is null then setNFreePG returns an error and the "key" array pointer 10974 // is not updated causing memory errors 10975 self->a = allocSArray();; 10976 } 10977 finishO(r); 10978 return(self); 10979 } 10980 10981 10982 internal smallArrayt* emptySmallArray(smallArrayt *self) { 10983 10984 freeSmallArray(self); 10985 return(self); 10986 } 10987 10988 internal bool isEmptySmallArray(smallArrayt *self) { 10989 size_t len; 10990 10991 len = lenSmallArray(self); 10992 10993 if (!len) { 10994 return(true); 10995 } 10996 10997 for (size_t i=0; i < len; i++) { 10998 smallt *o = sArrayGetTiny(self->a, (uint32_t)i); 10999 if (o) { 11000 return(false); 11001 } 11002 } 11003 11004 return(true); 11005 } 11006 11007 internal bool isBlankSmallArray(smallArrayt *self) { 11008 11009 if (!lenSmallArray(self)) { 11010 return(true); 11011 } 11012 11013 forEachSArray(self->a, e) { 11014 if (e) { 11015 switch (e->type) { 11016 // skip undefined - case UNDEFINED: 11017 case BOOL: 11018 return(false); 11019 case CONTAINER: 11020 return(false); 11021 case DICT: 11022 if (((sDictt*)e)->count > 0) { 11023 return(false); 11024 } 11025 break; 11026 case DOUBLE: 11027 return(false); 11028 case INT: 11029 return(false); 11030 case STRING: 11031 if (!isBlankS(sStringGetTiny((sStringt*)e))) { 11032 return(false); 11033 } 11034 break; 11035 case ARRAY: 11036 if (((sArrayt*)e)->count > 0) { 11037 return(false); 11038 } 11039 break; 11040 case BYTES: 11041 if (((sBytest*)e)->count > 0) { 11042 return(false); 11043 } 11044 break; 11045 default: 11046 logC("Unsupported object type!"); 11047 } 11048 } 11049 } 11050 return(true); 11051 } 11052 11053 internal void forEachSmallArrayF(smallArrayt *self, void *closure, forEachElementSmallArrayFt funcElem) { 11054 11055 // sanity checks 11056 if (!lenSmallArray(self)) { 11057 return; 11058 } 11059 11060 forEachSArray(self->a, e) { 11061 if (not e) { 11062 continue; 11063 } 11064 baset *E = toBaset(e); 11065 if (!funcElem(closure, E)) { 11066 if (e->type == CONTAINER && ((sContainert*)e)->dataType == SH_DT_BASET) { 11067 break; 11068 } 11069 finishO(E); 11070 break; 11071 } 11072 if (e->type == CONTAINER && ((sContainert*)e)->dataType == SH_DT_BASET) { 11073 continue; 11074 } 11075 finishO(E); 11076 } 11077 return; 11078 } 11079 11080 internal void enumerateSmallArrayF(smallArrayt *self, void *closure, enumerateElementSmallArrayFt funcElem) { 11081 11082 // sanity checks 11083 if (!lenSmallArray(self)) { 11084 return; 11085 } 11086 11087 enumerateSArray(self->a, e, i) { 11088 if (not e) { 11089 continue; 11090 } 11091 baset *E = toBaset(e); 11092 if (!funcElem(closure, i, E)) { 11093 if (e->type == CONTAINER && ((sContainert*)e)->dataType == SH_DT_BASET) { 11094 break; 11095 } 11096 finishO(E); 11097 break; 11098 } 11099 if (e->type == CONTAINER && ((sContainert*)e)->dataType == SH_DT_BASET) { 11100 continue; 11101 } 11102 finishO(E); 11103 } 11104 return; 11105 } 11106 11107 internal baset* iterStartSmallArray(smallArrayt *self) { 11108 11109 // reset iterIndex to a known value 11110 self->iterIndex = -1; 11111 if (isEmptySmallArray(self)) { 11112 // no iteration on empty arrays 11113 return(NULL); 11114 } 11115 11116 // get first element 11117 // find first non NULL element, deleted element can be at index 0 11118 range(i, self->a->count) 11119 if (sArrayGetTiny(self->a, (uint32_t)i)) { 11120 self->iterIndex = (ssize_t)i; 11121 break; 11122 } 11123 self->iterStep = 1; 11124 if (self->iterElementDataType != SH_DT_BASET) { 11125 // free already created base object 11126 finishO(self->iterElement); 11127 } 11128 smallt *o = sArrayGetTiny(self->a, (uint32_t)self->iterIndex); 11129 if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) { 11130 self->iterElementDataType = SH_DT_BASET; 11131 } 11132 else { 11133 self->iterElementDataType = SH_DT_UNKNOWN; 11134 } 11135 self->iterElement = toBaset(o); 11136 return(self->iterElement); 11137 } 11138 11139 internal baset* iterStartLastSmallArray(smallArrayt *self) { 11140 11141 // reset iterIndex to a known value 11142 self->iterIndex = -1; 11143 if (isEmptySmallArray(self)) { 11144 // no iteration on empty arrays 11145 return(NULL); 11146 } 11147 11148 // get first element 11149 // find first non NULL element, deleted element can be at index 0 11150 rangeDown(i, self->a->count) 11151 if (sArrayGetTiny(self->a, (uint32_t)i)) { 11152 self->iterIndex = i; 11153 break; 11154 } 11155 self->iterStep = -1; 11156 if (self->iterElementDataType != SH_DT_BASET) { 11157 // free already created base object 11158 finishO(self->iterElement); 11159 } 11160 smallt *o = sArrayGetTiny(self->a, (uint32_t)self->iterIndex); 11161 if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) { 11162 self->iterElementDataType = SH_DT_BASET; 11163 } 11164 else { 11165 self->iterElementDataType = SH_DT_UNKNOWN; 11166 } 11167 self->iterElement = toBaset(o); 11168 return(self->iterElement); 11169 } 11170 11171 internal baset* iterStartFromSmallArray(smallArrayt *self, int64_t index) { 11172 11173 // reset iterIndex to a known value 11174 self->iterIndex = -1; 11175 if (isEmptySmallArray(self)) { 11176 // no iteration on empty arrays 11177 return(NULL); 11178 } 11179 11180 if (index >= (int64_t)lenSmallArray(self)) { 11181 return(NULL); 11182 } 11183 if (index < -(int64_t)lenSmallArray(self)) { 11184 return(NULL); 11185 } 11186 if (index < 0) { 11187 index = (int64_t)lenSmallArray(self) + index; 11188 } 11189 11190 // get first element 11191 // find first non NULL element, deleted element can be at index 0 11192 rangeFrom(i, (size_t)index, self->a->count) 11193 if (sArrayGetTiny(self->a, (uint32_t)i)) { 11194 self->iterIndex = (ssize_t)i; 11195 break; 11196 } 11197 if (self->iterIndex == -1) { 11198 // no element was found in the dictionary 11199 return(NULL); 11200 } 11201 self->iterStep = 1; 11202 if (self->iterElementDataType != SH_DT_BASET) { 11203 // free already created base object 11204 finishO(self->iterElement); 11205 } 11206 smallt *o = sArrayGetTiny(self->a, (uint32_t)self->iterIndex); 11207 if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) { 11208 self->iterElementDataType = SH_DT_BASET; 11209 } 11210 else { 11211 self->iterElementDataType = SH_DT_UNKNOWN; 11212 } 11213 self->iterElement = toBaset(o); 11214 return(self->iterElement); 11215 } 11216 11217 internal baset* iterStartFromStepSmallArray(smallArrayt *self, int64_t index, int64_t step) { 11218 11219 // reset iterIndex to a known value 11220 self->iterIndex = -1; 11221 if (isEmptySmallArray(self)) { 11222 // no iteration on empty arrays 11223 return(NULL); 11224 } 11225 11226 if (!step) { 11227 // step 0 is invalid because it causes an infinite loop 11228 return(NULL); 11229 } 11230 11231 if (index >= (int64_t)lenSmallArray(self)) { 11232 return(NULL); 11233 } 11234 if (index < -(int64_t)lenSmallArray(self)) { 11235 return(NULL); 11236 } 11237 if (index < 0) { 11238 index = (int64_t)lenSmallArray(self) + index; 11239 } 11240 11241 // get first element 11242 // find first non NULL element, deleted element can be at index 0 11243 rangeFromStep(i, (size_t)index, self->a->count, step) 11244 if (sArrayGetTiny(self->a, (uint32_t)i)) { 11245 self->iterIndex = (ssize_t)i; 11246 break; 11247 } 11248 if (self->iterIndex == -1) { 11249 // no element was found in the dictionary 11250 return(NULL); 11251 } 11252 self->iterStep = step; 11253 if (self->iterElementDataType != SH_DT_BASET) { 11254 // free already created base object 11255 finishO(self->iterElement); 11256 } 11257 smallt *o = sArrayGetTiny(self->a, (uint32_t)self->iterIndex); 11258 if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) { 11259 self->iterElementDataType = SH_DT_BASET; 11260 } 11261 else { 11262 self->iterElementDataType = SH_DT_UNKNOWN; 11263 } 11264 self->iterElement = toBaset(o); 11265 return(self->iterElement); 11266 } 11267 11268 internal baset* iterNextSmallArray(smallArrayt *self) { 11269 11270 if (self->iterIndex == -1) { 11271 // the iteration hasn't started 11272 return(NULL); 11273 } 11274 // free already created base object 11275 if (self->iterElementDataType != SH_DT_BASET) { 11276 finishO(self->iterElement); 11277 } 11278 else { 11279 self->iterElement = NULL; 11280 } 11281 // get next element until we get a valid item or the end is reached 11282 while (!self->iterElement) { 11283 // get next element 11284 self->iterIndex += self->iterStep; 11285 if ((self->iterIndex >= (ssize_t)lenSmallArray(self) || self->iterIndex < 0)) { 11286 // the index is outside the array, the iteration is finished 11287 self->iterIndex = -1; 11288 return(NULL); 11289 } 11290 smallt *o = sArrayGetTiny(self->a, (uint32_t)self->iterIndex); 11291 if (!o) { 11292 continue; 11293 } 11294 if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) { 11295 self->iterElementDataType = SH_DT_BASET; 11296 } 11297 else { 11298 self->iterElementDataType = SH_DT_UNKNOWN; 11299 } 11300 self->iterElement = toBaset(o); 11301 } 11302 return(self->iterElement); 11303 } 11304 11305 internal baset* iterElementSmallArray(smallArrayt *self) { 11306 11307 return(self->iterElement); 11308 } 11309 11310 internal ssize_t iterIndexSmallArray(smallArrayt *self) { 11311 11312 return(self->iterIndex); 11313 } 11314 11315 internal int64_t iterStepSmallArray(smallArrayt *self) { 11316 11317 return(self->iterStep); 11318 } 11319 11320 internal smallStringt* joinSmallArray(smallArrayt *self, const char* delim) { 11321 smallStringt *r = NULL; 11322 11323 // sanity checks 11324 if (!lenSmallArray(self) || !delim) { 11325 return(NULL); 11326 } 11327 11328 char *s; 11329 11330 forEachSArray(self->a, e) { 11331 if (e) { 11332 switch (e->type) { 11333 case STRING: 11334 if (!r) { 11335 r = allocSmallString(sStringGetTiny((sStringt*)e)); 11336 } 11337 else { 11338 r->f->appendS(r, delim); 11339 r->f->appendS(r, sStringGetTiny((sStringt*)e)); 11340 } 11341 break; 11342 default: 11343 s = sToString(e); 11344 if (!r) { 11345 r = allocSmallString(s); 11346 } 11347 else { 11348 r->f->appendS(r, delim); 11349 r->f->appendS(r, s); 11350 } 11351 free(s); 11352 } 11353 } 11354 } 11355 return(r); 11356 } 11357 11358 internal smallStringt* joinCharSmallArray(smallArrayt *self, char c) { 11359 11360 charToS(s, c); 11361 return(joinSmallArray(self, s)); 11362 } 11363 11364 internal smallStringt* joinSmallJsonSmallArray(smallArrayt *self, smallJsont* delim) { 11365 11366 if (!delim) { 11367 return(NULL); 11368 } 11369 11370 if (checkObjectTypes && !isOSmallJson(delim)) { 11371 return(NULL); 11372 } 11373 11374 const char *type = getTopTypeO(delim); 11375 11376 if (!eqS(type,"string")) { 11377 return(NULL); 11378 } 11379 11380 return(joinSmallArray(self, sjGet(delim))); 11381 } 11382 11383 internal smallStringt* joinSmallStringSmallArray(smallArrayt *self, smallStringt* delim) { 11384 11385 if (!delim) { 11386 return(NULL); 11387 } 11388 return(joinSmallArray(self, ssGet(delim))); 11389 } 11390 11391 internal char* joinSSmallArray(smallArrayt *self, const char* delim) { 11392 char *r = NULL; 11393 11394 // sanity checks 11395 if (!lenSmallArray(self) || !delim) { 11396 return(NULL); 11397 } 11398 11399 char *s; 11400 11401 forEachSArray(self->a, e) { 11402 if (e) { 11403 switch (e->type) { 11404 case STRING: 11405 if (!r) { 11406 r = strdup(sStringGetTiny((sStringt*)e)); 11407 } 11408 else { 11409 pErrorNULL(iAppendS(&r, delim)); 11410 pErrorNULL(iAppendS(&r, sStringGetTiny((sStringt*)e))); 11411 } 11412 break; 11413 default: 11414 s = sToString(e); 11415 if (!s) { 11416 free(r); 11417 return(NULL); 11418 } 11419 if (!r) { 11420 r = strdup(s); 11421 } 11422 else { 11423 pErrorNULL(iAppendS(&r, delim)); 11424 pErrorNULL(iAppendS(&r, s)); 11425 } 11426 free(s); 11427 } 11428 } 11429 } 11430 11431 return(r); 11432 } 11433 11434 internal char* joinCharSSmallArray(smallArrayt *self, char c) { 11435 11436 charToS(s, c); 11437 return(joinSSmallArray(self, s)); 11438 } 11439 11440 internal char* joinSmallJsonSSmallArray(smallArrayt *self, smallJsont* delim) { 11441 11442 if (!delim) { 11443 return(NULL); 11444 } 11445 11446 if (checkObjectTypes && !isOSmallJson(delim)) { 11447 return(NULL); 11448 } 11449 11450 const char *type = getTopTypeO(delim); 11451 11452 if (!eqS(type,"string")) { 11453 return(NULL); 11454 } 11455 11456 return(joinSSmallArray(self, sjGet(delim))); 11457 } 11458 11459 internal char* joinSmallStringSSmallArray(smallArrayt *self, smallStringt* delim) { 11460 11461 if (!delim) { 11462 return(NULL); 11463 } 11464 return(joinSSmallArray(self, ssGet(delim))); 11465 } 11466 11467 internal smallArrayt* zipSmallArray(smallArrayt *self, smallArrayt *array1, smallArrayt *array2) { 11468 size_t len; 11469 size_t count; 11470 11471 if (!array1 || !array2) { 11472 return(NULL); 11473 } 11474 11475 if (checkObjectTypes && (!isOSmallArray(array1) || !isOSmallArray(array2))) { 11476 return(NULL); 11477 } 11478 11479 if (!array1->f->len(array1) || !array2->f->len(array2)) { 11480 return(self); 11481 } 11482 11483 len = MIN(array1->f->len(array1), array2->f->len(array2)); 11484 11485 count = 0; 11486 11487 enumerateSmallArray(array1, E1, i) { 11488 createAllocateSmallArray(a); 11489 if (!a) { 11490 finishO(E1); 11491 return(NULL); 11492 } 11493 pushNFreeO(a, E1); 11494 pushNFreeO(a, getO(array2, (int64_t)i)); 11495 pushNFreeArraySmallArray(self, a); 11496 count++; 11497 if (count == len) { 11498 break; 11499 } 11500 } 11501 11502 return(self); 11503 } 11504 11505 internal smallArrayt* zipSmallJsonSmallArray(smallArrayt *self, smallArrayt *array1, smallJsont *array2) { 11506 11507 if (!array1 || !array2) { 11508 return(NULL); 11509 } 11510 11511 if (checkObjectTypes && !isOSmallArray(array1)) { 11512 return(NULL); 11513 } 11514 11515 if (checkObjectTypes && !isOSmallJson(array2)) { 11516 return(NULL); 11517 } 11518 11519 const char *type = getTopTypeO(array2); 11520 11521 if (!eqS(type,"array")) { 11522 return(NULL); 11523 } 11524 11525 createSmallArray(a); 11526 if (!a.f) { 11527 return(NULL); 11528 } 11529 setsoO(&a, (sArrayt*)getsoO(array2)); 11530 return(zipSmallArray(self, array1, &a)); 11531 } 11532 11533 internal smallArrayt* zipSmallJsonSmallArraySmallArray(smallArrayt *self, smallJsont *array1, smallArrayt *array2) { 11534 11535 if (!array1 || !array2) { 11536 return(NULL); 11537 } 11538 11539 if (checkObjectTypes && !isOSmallJson(array1)) { 11540 return(NULL); 11541 } 11542 11543 if (checkObjectTypes && !isOSmallArray(array2)) { 11544 return(NULL); 11545 } 11546 11547 const char *type = getTopTypeO(array1); 11548 11549 if (!eqS(type,"array")) { 11550 return(NULL); 11551 } 11552 11553 createSmallArray(a); 11554 if (!a.f) { 11555 return(NULL); 11556 } 11557 setsoO(&a, (sArrayt*)getsoO(array1)); 11558 return(zipSmallArray(self, &a, array2)); 11559 } 11560 11561 internal smallArrayt* zipSmallJsonSmallJsonSmallArray(smallArrayt *self, smallJsont *array1, smallJsont *array2) { 11562 11563 if (!array1 || !array2) { 11564 return(NULL); 11565 } 11566 11567 if (checkObjectTypes && !isOSmallJson(array1)) { 11568 return(NULL); 11569 } 11570 11571 if (checkObjectTypes && !isOSmallJson(array2)) { 11572 return(NULL); 11573 } 11574 11575 const char *type = getTopTypeO(array1); 11576 11577 if (!eqS(type,"array")) { 11578 return(NULL); 11579 } 11580 11581 type = getTopTypeO(array2); 11582 11583 if (!eqS(type,"array")) { 11584 return(NULL); 11585 } 11586 11587 createSmallArray(a); 11588 if (!a.f) { 11589 return(NULL); 11590 } 11591 createSmallArray(b); 11592 if (!b.f) { 11593 return(NULL); 11594 } 11595 setsoO(&a, (sArrayt*)getsoO(array1)); 11596 setsoO(&b, (sArrayt*)getsoO(array2)); 11597 return(zipSmallArray(self, &a, &b)); 11598 } 11599 11600 internal smallArrayt* zipSmallJsonCharSmallArray(smallArrayt *self, smallJsont *array1, char **array2) { 11601 11602 if (!array1 || !array2) { 11603 return(NULL); 11604 } 11605 11606 if (checkObjectTypes && !isOSmallJson(array1)) { 11607 return(NULL); 11608 } 11609 11610 const char *type = getTopTypeO(array1); 11611 11612 if (!eqS(type,"array")) { 11613 return(NULL); 11614 } 11615 11616 createSmallArray(a); 11617 if (!a.f) { 11618 return(NULL); 11619 } 11620 setsoO(&a, (sArrayt*)getsoO(array1)); 11621 return(zipCharSmallArray(self, &a, array2)); 11622 } 11623 11624 internal smallArrayt* zipSmallJsonCCharSmallArray(smallArrayt *self, smallJsont *array1, const char **array2) { 11625 11626 if (!array1 || !array2) { 11627 return(NULL); 11628 } 11629 11630 if (checkObjectTypes && !isOSmallJson(array1)) { 11631 return(NULL); 11632 } 11633 11634 const char *type = getTopTypeO(array1); 11635 11636 if (!eqS(type,"array")) { 11637 return(NULL); 11638 } 11639 11640 createSmallArray(a); 11641 if (!a.f) { 11642 return(NULL); 11643 } 11644 setsoO(&a, (sArrayt*)getsoO(array1)); 11645 return(zipCCharSmallArray(self, &a, array2)); 11646 } 11647 11648 internal smallArrayt* zipArraySmallArray(smallArrayt *self, char** array1, smallArrayt *array2) { 11649 size_t len; 11650 size_t count; 11651 11652 if (!array1 || !array2) { 11653 return(NULL); 11654 } 11655 11656 if (checkObjectTypes && !isOSmallArray(array2)) { 11657 return(NULL); 11658 } 11659 11660 if (!listLengthS(array1) || !array2->f->len(array2)) { 11661 return(self); 11662 } 11663 11664 len = MIN(listLengthS(array1), array2->f->len(array2));; 11665 11666 count = 0; 11667 11668 enumerateS(array1, E1, i) { 11669 createAllocateSmallArray(a); 11670 if (!a) { 11671 return(NULL); 11672 } 11673 a->f->pushNFreeS(a, E1); 11674 pushNFreeO(a, getO(array2, (int64_t)i)); 11675 pushNFreeArraySmallArray(self, a); 11676 count++; 11677 if (count == len) { 11678 break; 11679 } 11680 } 11681 11682 return(self); 11683 } 11684 11685 internal smallArrayt* zipCArraySmallArray(smallArrayt *self, const char** array1, smallArrayt *array2) { 11686 size_t len; 11687 size_t count; 11688 11689 if (!array1 || !array2) { 11690 return(NULL); 11691 } 11692 11693 if (checkObjectTypes && !isOSmallArray(array2)) { 11694 return(NULL); 11695 } 11696 11697 if (!listLengthCS(array1) || !array2->f->len(array2)) { 11698 return(self); 11699 } 11700 11701 len = MIN(listLengthCS(array1), array2->f->len(array2));; 11702 11703 count = 0; 11704 11705 enumerateCS(array1, E1, i) { 11706 createAllocateSmallArray(a); 11707 if (!a) { 11708 return(NULL); 11709 } 11710 a->f->pushS(a, E1); 11711 pushNFreeO(a, getO(array2, (int64_t)i)); 11712 pushNFreeArraySmallArray(self, a); 11713 count++; 11714 if (count == len) { 11715 break; 11716 } 11717 } 11718 11719 return(self); 11720 } 11721 11722 internal smallArrayt* zipArraySmallJsonSmallArray(smallArrayt *self, char** array1, smallJsont *array2) { 11723 11724 if (!array1 || !array2) { 11725 return(NULL); 11726 } 11727 11728 if (checkObjectTypes && !isOSmallJson(array2)) { 11729 return(NULL); 11730 } 11731 11732 const char *type = getTopTypeO(array2); 11733 11734 if (!eqS(type,"array")) { 11735 return(NULL); 11736 } 11737 11738 createSmallArray(a); 11739 if (!a.f) { 11740 return(NULL); 11741 } 11742 setsoO(&a, (sArrayt*)getsoO(array2)); 11743 return(zipArraySmallArray(self, array1, &a)); 11744 } 11745 11746 internal smallArrayt* zipCArraySmallJsonSmallArray(smallArrayt *self, const char** array1, smallJsont *array2) { 11747 11748 if (!array1 || !array2) { 11749 return(NULL); 11750 } 11751 11752 if (checkObjectTypes && !isOSmallJson(array2)) { 11753 return(NULL); 11754 } 11755 11756 const char *type = getTopTypeO(array2); 11757 11758 if (!eqS(type,"array")) { 11759 return(NULL); 11760 } 11761 11762 createSmallArray(a); 11763 if (!a.f) { 11764 return(NULL); 11765 } 11766 setsoO(&a, (sArrayt*)getsoO(array2)); 11767 return(zipCArraySmallArray(self, array1, &a)); 11768 } 11769 11770 internal smallArrayt* zipCharSmallArray(smallArrayt *self, smallArrayt *array1, char** array2) { 11771 size_t len; 11772 size_t count; 11773 11774 if (!array1 || !array2) { 11775 return(NULL); 11776 } 11777 11778 if (checkObjectTypes && !isOSmallArray(array1)) { 11779 return(NULL); 11780 } 11781 11782 if (!array1->f->len(array1) || !listLengthS(array2)) { 11783 return(self); 11784 } 11785 11786 len = MIN(array1->f->len(array1), listLengthS(array2));; 11787 11788 count = 0; 11789 11790 enumerateSmallArray(array1, E1, i) { 11791 createAllocateSmallArray(a); 11792 if (!a) { 11793 finishO(E1); 11794 return(NULL); 11795 } 11796 pushNFreeO(a, E1); 11797 a->f->pushNFreeS(a, array2[i]); 11798 pushNFreeArraySmallArray(self, a); 11799 count++; 11800 if (count == len) { 11801 break; 11802 } 11803 } 11804 11805 return(self); 11806 } 11807 11808 internal smallArrayt* zipCCharSmallArray(smallArrayt *self, smallArrayt *array1, const char** array2) { 11809 size_t len; 11810 size_t count; 11811 11812 if (!array1 || !array2) { 11813 return(NULL); 11814 } 11815 11816 if (checkObjectTypes && !isOSmallArray(array1)) { 11817 return(NULL); 11818 } 11819 11820 if (!array1->f->len(array1) || !listLengthCS(array2)) { 11821 return(self); 11822 } 11823 11824 len = MIN(array1->f->len(array1), listLengthCS(array2));; 11825 11826 count = 0; 11827 11828 enumerateSmallArray(array1, E1, i) { 11829 createAllocateSmallArray(a); 11830 if (!a) { 11831 finishO(E1); 11832 return(NULL); 11833 } 11834 pushNFreeO(a, E1); 11835 a->f->pushS(a, array2[i]); 11836 pushNFreeArraySmallArray(self, a); 11837 count++; 11838 if (count == len) { 11839 break; 11840 } 11841 } 11842 11843 return(self); 11844 } 11845 11846 internal smallArrayt* zipArrayCharSmallArray(smallArrayt *self, char** array1, char** array2) { 11847 size_t len; 11848 size_t count; 11849 11850 if (!array1 || !array2) { 11851 return(NULL); 11852 } 11853 11854 if (!listLengthS(array1) || !listLengthS(array2)) { 11855 return(self); 11856 } 11857 11858 len = MIN(listLengthS(array1), listLengthS(array2));; 11859 11860 count = 0; 11861 11862 enumerateS(array1, E1, i) { 11863 createAllocateSmallArray(a); 11864 if (!a) { 11865 return(NULL); 11866 } 11867 a->f->pushNFreeS(a, E1); 11868 a->f->pushNFreeS(a, array2[i]); 11869 pushNFreeArraySmallArray(self, a); 11870 count++; 11871 if (count == len) { 11872 break; 11873 } 11874 } 11875 11876 return(self); 11877 } 11878 11879 internal smallArrayt* zipCArrayCharSmallArray(smallArrayt *self, const char** array1, char** array2) { 11880 size_t len; 11881 size_t count; 11882 11883 if (!array1 || !array2) { 11884 return(NULL); 11885 } 11886 11887 if (!listLengthCS(array1) || !listLengthS(array2)) { 11888 return(self); 11889 } 11890 11891 len = MIN(listLengthCS(array1), listLengthS(array2));; 11892 11893 count = 0; 11894 11895 enumerateCS(array1, E1, i) { 11896 createAllocateSmallArray(a); 11897 if (!a) { 11898 return(NULL); 11899 } 11900 a->f->pushS(a, E1); 11901 a->f->pushNFreeS(a, array2[i]); 11902 pushNFreeArraySmallArray(self, a); 11903 count++; 11904 if (count == len) { 11905 break; 11906 } 11907 } 11908 11909 return(self); 11910 } 11911 11912 internal smallArrayt* zipArrayCCharSmallArray(smallArrayt *self, char** array1, const char** array2) { 11913 size_t len; 11914 size_t count; 11915 11916 if (!array1 || !array2) { 11917 return(NULL); 11918 } 11919 11920 if (!listLengthS(array1) || !listLengthCS(array2)) { 11921 return(self); 11922 } 11923 11924 len = MIN(listLengthS(array1), listLengthCS(array2));; 11925 11926 count = 0; 11927 11928 enumerateS(array1, E1, i) { 11929 createAllocateSmallArray(a); 11930 if (!a) { 11931 return(NULL); 11932 } 11933 a->f->pushNFreeS(a, E1); 11934 a->f->pushS(a, array2[i]); 11935 pushNFreeArraySmallArray(self, a); 11936 count++; 11937 if (count == len) { 11938 break; 11939 } 11940 } 11941 11942 return(self); 11943 } 11944 11945 internal smallArrayt* zipCArrayCCharSmallArray(smallArrayt *self, const char** array1, const char** array2) { 11946 size_t len; 11947 size_t count; 11948 11949 if (!array1 || !array2) { 11950 return(NULL); 11951 } 11952 11953 if (!listLengthCS(array1) || !listLengthCS(array2)) { 11954 return(self); 11955 } 11956 11957 len = MIN(listLengthCS(array1), listLengthCS(array2));; 11958 11959 count = 0; 11960 11961 enumerateCS(array1, E1, i) { 11962 createAllocateSmallArray(a); 11963 if (!a) { 11964 return(NULL); 11965 } 11966 a->f->pushS(a, E1); 11967 a->f->pushS(a, array2[i]); 11968 pushNFreeArraySmallArray(self, a); 11969 count++; 11970 if (count == len) { 11971 break; 11972 } 11973 } 11974 11975 return(self); 11976 } 11977 11978 internal void logSmallArray(smallArrayt *self) { 11979 11980 if (!lenSmallArray(self)) { 11981 return; 11982 } 11983 11984 forEachSArray(self->a, e) { 11985 if (e) { 11986 char *s = sToString(e); 11987 if (s) { 11988 puts(s); 11989 } 11990 else { 11991 puts("(null)"); 11992 } 11993 free(s); 11994 } 11995 } 11996 return; 11997 } 11998 11999 internal smallArrayt* readTextSmallArray(smallArrayt *self, const char *filePath) { 12000 FILE *fp = NULL; 12001 size_t len; 12002 char* line = NULL; 12003 ssize_t read; 12004 12005 // sanity checks 12006 if (!filePath || isBlankS(filePath)) { 12007 return(NULL); 12008 } 12009 fp = fopen(filePath, "r"); 12010 if (!fp) { 12011 pFuncError 12012 shEPrintfS("The path was: \"%s\"\n", filePath); 12013 return(NULL); 12014 } 12015 12016 // read all lines 12017 read = getline(&line, &len, fp); 12018 while (read != -1) { 12019 { 12020 char* pos = NULL; 12021 pos = strchr(line, '\n'); 12022 if (pos != NULL) 12023 *pos = '\0'; 12024 } 12025 pushSSmallArray(self, line); 12026 read = getline(&line, &len, fp); 12027 } 12028 fclose(fp); 12029 free(line); 12030 return(self); 12031 } 12032 12033 internal smallArrayt* readTextSmallJsonSmallArray(smallArrayt *self, smallJsont *filePath) { 12034 12035 if (!filePath) { 12036 return(NULL); 12037 } 12038 12039 if (checkObjectTypes && !isOSmallJson(filePath)) { 12040 return(NULL); 12041 } 12042 12043 const char *type = getTopTypeO(filePath); 12044 12045 if (!eqS(type,"string")) { 12046 return(NULL); 12047 } 12048 12049 return(readTextSmallArray(self, getTopSO(filePath))); 12050 } 12051 12052 internal smallArrayt* readTextSmallStringSmallArray(smallArrayt *self, smallStringt *filePath) { 12053 12054 if (!filePath) { 12055 return(NULL); 12056 } 12057 12058 if (checkObjectTypes && !isOSmallString(filePath)) { 12059 return(NULL); 12060 } 12061 12062 return(readTextSmallArray(self, ssGet(filePath))); 12063 } 12064 12065 internal smallArrayt* readStreamSmallArray(smallArrayt *self, FILE *fp) { 12066 size_t len; 12067 char* line = NULL; 12068 ssize_t read; 12069 12070 if (!fp) { 12071 return(NULL); 12072 } 12073 12074 // read all lines 12075 read = getline(&line, &len, (FILE*)fp); 12076 while (read != -1) { 12077 { 12078 char* pos = NULL; 12079 pos = strchr(line, '\n'); 12080 if (pos != NULL) 12081 *pos = '\0'; 12082 } 12083 pushSSmallArray(self, line); 12084 read = getline(&line, &len, (FILE*)fp); 12085 } 12086 free(line); 12087 return(self); 12088 } 12089 12090 internal bool writeTextSmallArray(smallArrayt *self, const char *filePath) { 12091 FILE *fp = NULL; 12092 12093 // sanity checks 12094 if (!filePath || isBlankS(filePath)) { 12095 return(false); 12096 } 12097 12098 fp = fopen(filePath, "w"); 12099 if (!fp) { 12100 pFuncError 12101 shEPrintfS("The path was: \"%s\"\n", filePath); 12102 return(false); 12103 } 12104 if (!lenSmallArray(self)) { 12105 fclose(fp); 12106 return(false); 12107 } 12108 forEachSArray(self->a, e) { 12109 if (e) { 12110 // add new line 12111 fprintf(fp, "%s\n", sStringGetTiny((sStringt*)e)); 12112 } 12113 } 12114 fclose(fp); 12115 return(true); 12116 } 12117 12118 internal bool writeTextSmallJsonSmallArray(smallArrayt *self, smallJsont *filePath) { 12119 12120 if (!filePath) { 12121 return(false); 12122 } 12123 12124 if (checkObjectTypes && !isOSmallJson(filePath)) { 12125 return(false); 12126 } 12127 12128 const char *type = getTopTypeO(filePath); 12129 12130 if (!eqS(type,"string")) { 12131 return(false); 12132 } 12133 12134 return(writeTextSmallArray(self, getTopSO(filePath))); 12135 } 12136 12137 internal bool writeTextSmallStringSmallArray(smallArrayt *self, smallStringt *filePath) { 12138 12139 if (!filePath) { 12140 return(false); 12141 } 12142 12143 if (checkObjectTypes && !isOSmallString(filePath)) { 12144 return(false); 12145 } 12146 12147 return(writeTextSmallArray(self, ssGet(filePath))); 12148 } 12149 12150 internal bool writeStreamSmallArray(smallArrayt *self, FILE *fp) { 12151 12152 // sanity checks 12153 if (!fp || !lenSmallArray(self)) { 12154 return(false); 12155 } 12156 forEachSArray(self->a, e) { 12157 if (e) { 12158 // add new line 12159 fprintf((FILE*)fp, "%s\n", sStringGetTiny((sStringt*)e)); 12160 } 12161 } 12162 return(true); 12163 } 12164 12165 internal bool appendTextSmallArray(smallArrayt *self, const char *filePath) { 12166 FILE *fp = NULL; 12167 12168 // sanity checks 12169 if (!filePath || isBlankS(filePath)) { 12170 return(false); 12171 } 12172 12173 fp = fopen(filePath, "a"); 12174 if (!fp) { 12175 pStrError("writeText error"); 12176 return(false); 12177 } 12178 if (!lenSmallArray(self)) { 12179 fclose(fp); 12180 return(false); 12181 } 12182 forEachSArray(self->a, e) { 12183 if (e) { 12184 // add new line 12185 fprintf(fp, "%s\n", sStringGetTiny((sStringt*)e)); 12186 } 12187 } 12188 fclose(fp); 12189 return(true); 12190 } 12191 12192 internal bool appendTextSmallStringSmallArray(smallArrayt *self, smallStringt *filePath) { 12193 12194 if (!filePath) { 12195 return(false); 12196 } 12197 12198 if (checkObjectTypes && !isOSmallString(filePath)) { 12199 return(false); 12200 } 12201 12202 return(appendTextSmallArray(self, ssGet(filePath))); 12203 } 12204 12205 12206 internal const char* typeStringSmallArray(smallArrayt *self, int64_t index) { 12207 12208 return(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)]); 12209 } 12210 12211 internal smallStringt* typeSmallStringSmallArray(smallArrayt *self, int64_t index) { 12212 12213 return(allocSmallString(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)])); 12214 } 12215 12216 internal char typeSmallArray(smallArrayt *self, int64_t index) { 12217 size_t len; 12218 12219 len = lenSmallArray(self); 12220 12221 if (!len) { 12222 return(0); 12223 } 12224 12225 if (index >= (int64_t)len) { 12226 return(0); 12227 } 12228 if (index < -(int64_t)len) { 12229 return(0); 12230 } 12231 if (index < 0) { 12232 index = (int64_t)len + index; 12233 } 12234 12235 smallt *r = sArrayGetTiny(self->a, (uint32_t)index); 12236 if (!r) { 12237 return(0); 12238 } 12239 12240 return(r->type); 12241 } 12242 12243 internal const char** typeStringsSmallArray(smallArrayt *self) { 12244 12245 return(sArrayTypeStrings(self->a)); 12246 } 12247 12248 internal smallArrayt* typeSmallStringsSmallArray(smallArrayt *self) { 12249 12250 const char** r = sArrayTypeStrings(self->a); 12251 if (!r) { 12252 return(NULL); 12253 } 12254 createAllocateSmallArray(a); 12255 if (!a) { 12256 return(NULL); 12257 } 12258 fromCArraySmallArray(a, r, 0); 12259 free(r); 12260 return(a); 12261 } 12262 12263 internal smallBytest* typesSmallArray(smallArrayt *self) { 12264 sBytest *types = NULL; 12265 12266 types = sArrayTypes(self->a); 12267 12268 if (!types) { 12269 return(NULL); 12270 } 12271 12272 createAllocateSmallBytes(r); 12273 if (!r) { 12274 return(NULL); 12275 } 12276 r->B = types; 12277 return(r); 12278 } 12279 12280 internal bool isETypeSmallArray(smallArrayt *self, int64_t index, const char *type) { 12281 12282 if (!type) { 12283 return(false); 12284 } 12285 12286 return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], type)); 12287 } 12288 12289 internal bool isEUndefinedSmallArray(smallArrayt *self, int64_t index) { 12290 12291 return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "undefined")); 12292 } 12293 12294 internal bool isEBoolSmallArray(smallArrayt *self, int64_t index) { 12295 12296 return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "bool")); 12297 } 12298 12299 internal bool isEContainerSmallArray(smallArrayt *self, int64_t index) { 12300 12301 return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "container")); 12302 } 12303 12304 internal bool isEDictSmallArray(smallArrayt *self, int64_t index) { 12305 12306 return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "dict")); 12307 } 12308 12309 internal bool isEDoubleSmallArray(smallArrayt *self, int64_t index) { 12310 12311 return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "double")); 12312 } 12313 12314 internal bool isEIntSmallArray(smallArrayt *self, int64_t index) { 12315 12316 return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "int")); 12317 } 12318 12319 internal bool isEStringSmallArray(smallArrayt *self, int64_t index) { 12320 12321 return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "string")); 12322 } 12323 12324 internal bool isEFaststringSmallArray(smallArrayt *self, int64_t index) { 12325 12326 return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "faststring")); 12327 } 12328 12329 internal bool isEArraySmallArray(smallArrayt *self, int64_t index) { 12330 12331 return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "array")); 12332 } 12333 12334 internal bool isEBytesSmallArray(smallArrayt *self, int64_t index) { 12335 12336 return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "bytes")); 12337 } 12338 12339 internal bool areAllETypeSmallArray(smallArrayt *self, const char *type) { 12340 12341 if (!type) { 12342 return(false); 12343 } 12344 12345 size_t len = lenSmallArray(self); 12346 12347 if (!len) { 12348 return(false); 12349 } 12350 12351 bool r = true; 12352 range(i, len) { 12353 if (!eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, (int64_t)i)], type)) { 12354 r = false; 12355 break; 12356 } 12357 } 12358 return(r); 12359 } 12360 12361 internal bool areAllEUndefinedSmallArray(smallArrayt *self) { 12362 12363 return(areAllETypeSmallArray(self, "undefined")); 12364 } 12365 12366 internal bool areAllEBoolSmallArray(smallArrayt *self) { 12367 12368 return(areAllETypeSmallArray(self, "bool")); 12369 } 12370 12371 internal bool areAllEContainerSmallArray(smallArrayt *self) { 12372 12373 return(areAllETypeSmallArray(self, "container")); 12374 } 12375 12376 internal bool areAllEDictSmallArray(smallArrayt *self) { 12377 12378 return(areAllETypeSmallArray(self, "dict")); 12379 } 12380 12381 internal bool areAllEDoubleSmallArray(smallArrayt *self) { 12382 12383 return(areAllETypeSmallArray(self, "double")); 12384 } 12385 12386 internal bool areAllEIntSmallArray(smallArrayt *self) { 12387 12388 return(areAllETypeSmallArray(self, "int")); 12389 } 12390 12391 internal bool areAllEStringSmallArray(smallArrayt *self) { 12392 12393 return(areAllETypeSmallArray(self, "string")); 12394 } 12395 12396 internal bool areAllEFaststringSmallArray(smallArrayt *self) { 12397 12398 return(areAllETypeSmallArray(self, "faststring")); 12399 } 12400 12401 internal bool areAllEArraySmallArray(smallArrayt *self) { 12402 12403 return(areAllETypeSmallArray(self, "array")); 12404 } 12405 12406 internal bool areAllEBytesSmallArray(smallArrayt *self) { 12407 12408 return(areAllETypeSmallArray(self, "bytes")); 12409 } 12410 12411 12412 12413 smallArrayt* allocSmallArrayG(smallArrayt *self UNUSED) { 12414 12415 return(allocSmallArray()); 12416 } 12417 12418 smallArrayt* duplicateSmallArrayG (smallArrayt *self) { 12419 12420 return(self->f->duplicate(self)); 12421 } 12422 12423 void freeSmallArrayG (smallArrayt *self) {self->f->free(self);} 12424 12425 smallArrayt* fromArraySmallArrayG (smallArrayt *self, char **array, size_t size) { 12426 12427 return(self->f->fromArray(self, array, size)); 12428 } 12429 12430 smallArrayt* fromCArraySmallArrayG (smallArrayt *self, const char **array, size_t size) { 12431 12432 return(self->f->fromCArray(self, array, size)); 12433 } 12434 12435 smallArrayt* setFromSmallArrayG(smallArrayt *self, char **array) { 12436 12437 return(self->f->fromArray(self, array, 0)); 12438 } 12439 12440 smallArrayt* setFromCSmallArrayG(smallArrayt *self, const char **array) { 12441 12442 return(self->f->fromCArray(self, array, 0)); 12443 } 12444 12445 smallArrayt* pushSmallArrayG (smallArrayt *self, baset *value) { 12446 12447 return(self->f->push(self, value)); 12448 } 12449 12450 smallArrayt* pushUndefinedSmallArrayG(smallArrayt *self, void *value UNUSED) { 12451 12452 return(self->f->pushUndefined(self)); 12453 } 12454 12455 smallArrayt* pushBoolSmallArrayG (smallArrayt *self, bool value) { 12456 12457 return(self->f->pushBool(self,value)); 12458 } 12459 12460 smallArrayt* pushDoubleSmallArrayG (smallArrayt *self, double value) { 12461 12462 return(self->f->pushDouble(self,value)); 12463 } 12464 12465 smallArrayt* pushIntSmallArrayG (smallArrayt *self, int64_t value) { 12466 12467 return(self->f->pushInt(self,value)); 12468 } 12469 12470 smallArrayt* pushSSmallArrayG (smallArrayt *self, const char *string) { 12471 12472 return(self->f->pushS(self,string)); 12473 } 12474 12475 smallArrayt* pushCharSmallArrayG(smallArrayt *self, char c) { 12476 12477 return(self->f->pushChar(self,c)); 12478 } 12479 12480 smallArrayt* pushDictSmallArrayG (smallArrayt *self, smallDictt *dict) { 12481 12482 return(self->f->pushDict(self,dict)); 12483 } 12484 12485 smallArrayt* pushArraySmallArrayG (smallArrayt *self, smallArrayt *array) { 12486 12487 return(self->f->pushArray(self,array)); 12488 } 12489 12490 smallArrayt* pushArraycSmallArrayG (smallArrayt *self, char **array) { 12491 12492 return(self->f->pushArrayc(self,array)); 12493 } 12494 12495 smallArrayt* pushCArraycSmallArrayG (smallArrayt *self, const char **array) { 12496 12497 return(self->f->pushCArrayc(self,array)); 12498 } 12499 12500 smallArrayt* pushVoidSmallArrayG (smallArrayt *self, void *value) { 12501 12502 if (value) { 12503 smallContainert *c = allocSmallContainer(value); 12504 if (!c) { 12505 return(NULL); 12506 } 12507 return(self->f->pushNFreeSmallContainer(self, c)); 12508 } 12509 return(self->f->pushUndefined(self)); 12510 } 12511 12512 smallArrayt* pushSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value) { 12513 12514 return(self->f->pushSmallBool(self,value)); 12515 } 12516 12517 smallArrayt* pushSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value) { 12518 12519 return(self->f->pushSmallBytes(self,value)); 12520 } 12521 12522 smallArrayt* pushSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value) { 12523 12524 return(self->f->pushSmallDouble(self,value)); 12525 } 12526 12527 smallArrayt* pushSmallIntSmallArrayG (smallArrayt *self, smallIntt *value) { 12528 12529 return(self->f->pushSmallInt(self,value)); 12530 } 12531 12532 smallArrayt* pushSmallJsonSmallArrayG(smallArrayt *self, smallJsont *value) { 12533 12534 return(self->f->pushSmallJson(self,value)); 12535 } 12536 12537 smallArrayt* pushSmallStringSmallArrayG (smallArrayt *self, smallStringt *string) { 12538 12539 return(self->f->pushSmallString(self,string)); 12540 } 12541 12542 smallArrayt* pushSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container) { 12543 12544 return(self->f->pushSmallContainer(self,container)); 12545 } 12546 12547 12548 smallArrayt* pushNFreeSmallArrayG (smallArrayt *self, baset *value) { 12549 12550 return(self->f->pushNFree(self,value)); 12551 } 12552 12553 smallArrayt* pushNFreeUndefinedSmallArrayG(smallArrayt *self, undefinedt *value) { 12554 12555 return(self->f->pushNFreeUndefined(self,value)); 12556 } 12557 12558 smallArrayt* pushNFreeSSmallArrayG (smallArrayt *self, char *string) { 12559 12560 return(self->f->pushNFreeS(self,string)); 12561 } 12562 12563 smallArrayt* pushNFreeDictSmallArrayG (smallArrayt *self, smallDictt *dict) { 12564 12565 return(self->f->pushNFreeDict(self,dict)); 12566 } 12567 12568 smallArrayt* pushNFreeArraySmallArrayG (smallArrayt *self, smallArrayt *array) { 12569 12570 return(self->f->pushNFreeArray(self,array)); 12571 } 12572 12573 smallArrayt* pushNFreeArraycSmallArrayG (smallArrayt *self, char **array) { 12574 12575 return(self->f->pushNFreeArrayc(self,array)); 12576 } 12577 12578 smallArrayt* pushNFreeSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value) { 12579 12580 return(self->f->pushNFreeSmallBool(self,value)); 12581 } 12582 12583 smallArrayt* pushNFreeSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value) { 12584 12585 return(self->f->pushNFreeSmallBytes(self,value)); 12586 } 12587 12588 smallArrayt* pushNFreeSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value) { 12589 12590 return(self->f->pushNFreeSmallDouble(self,value)); 12591 } 12592 12593 smallArrayt* pushNFreeSmallIntSmallArrayG (smallArrayt *self, smallIntt *value) { 12594 12595 return(self->f->pushNFreeSmallInt(self,value)); 12596 } 12597 12598 smallArrayt* pushNFreeSmallJsonSmallArrayG(smallArrayt *self, smallJsont *value) { 12599 12600 return(self->f->pushNFreeSmallJson(self,value)); 12601 } 12602 12603 smallArrayt* pushNFreeSmallStringSmallArrayG (smallArrayt *self, smallStringt *string) { 12604 12605 return(self->f->pushNFreeSmallString(self,string)); 12606 } 12607 12608 smallArrayt* pushNFreeSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container) { 12609 12610 return(self->f->pushNFreeSmallContainer(self,container)); 12611 } 12612 12613 12614 12615 baset* popSmallArrayG (smallArrayt *self, baset* retType UNUSED) { 12616 12617 return(self->f->pop(self)); 12618 } 12619 12620 undefinedt* popUndefinedSmallArrayG (smallArrayt *self, undefinedt* retType UNUSED) { 12621 12622 return(self->f->popUndefined(self)); 12623 } 12624 12625 bool popBoolSmallArrayG (smallArrayt *self, bool retType UNUSED) { 12626 12627 return(self->f->popBool(self)); 12628 } 12629 12630 double popDoubleSmallArrayG (smallArrayt *self, double retType UNUSED) { 12631 12632 return(self->f->popDouble(self)); 12633 } 12634 12635 int64_t popIntSmallArrayG (smallArrayt *self, int64_t retType UNUSED) { 12636 12637 return(self->f->popInt(self)); 12638 } 12639 12640 int32_t popInt32SmallArrayG (smallArrayt *self, int32_t retType UNUSED) { 12641 12642 return(self->f->popInt32(self)); 12643 } 12644 12645 uint64_t popUintSmallArrayG (smallArrayt *self, uint64_t retType UNUSED) { 12646 12647 return(self->f->popUint(self)); 12648 } 12649 12650 uint32_t popUint32SmallArrayG (smallArrayt *self, uint32_t retType UNUSED) { 12651 12652 return(self->f->popUint32(self)); 12653 } 12654 12655 char* popSSmallArrayG (smallArrayt *self, char* retType UNUSED) { 12656 12657 return(self->f->popS(self)); 12658 } 12659 12660 smallDictt* popDictSmallArrayG (smallArrayt *self, smallDictt* retType UNUSED) { 12661 12662 return(self->f->popDict(self)); 12663 } 12664 12665 smallArrayt* popArraySmallArrayG (smallArrayt *self, smallArrayt* retType UNUSED) { 12666 12667 return(self->f->popArray(self)); 12668 } 12669 12670 smallBoolt* popSmallBoolSmallArrayG (smallArrayt *self, smallBoolt* retType UNUSED) { 12671 12672 return(self->f->popSmallBool(self)); 12673 } 12674 12675 smallBytest* popSmallBytesSmallArrayG (smallArrayt *self, smallBytest* retType UNUSED) { 12676 12677 return(self->f->popSmallBytes(self)); 12678 } 12679 12680 smallDoublet* popSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet* retType UNUSED) { 12681 12682 return(self->f->popSmallDouble(self)); 12683 } 12684 12685 smallIntt* popSmallIntSmallArrayG (smallArrayt *self, smallIntt* retType UNUSED) { 12686 12687 return(self->f->popSmallInt(self)); 12688 } 12689 12690 smallJsont* popSmallJsonSmallArrayG (smallArrayt *self, smallJsont* retType UNUSED) { 12691 12692 return(self->f->popSmallJson(self)); 12693 } 12694 12695 smallStringt* popSmallStringSmallArrayG (smallArrayt *self, smallStringt* retType UNUSED) { 12696 12697 return(self->f->popSmallString(self)); 12698 } 12699 12700 void* popVoidSmallArrayG (smallArrayt *self, void* retType UNUSED) { 12701 12702 return(self->f->popVoid(self)); 12703 } 12704 12705 smallContainert* popSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED) { 12706 12707 return(self->f->popSmallContainer(self)); 12708 } 12709 12710 12711 smallArrayt* prependSmallArrayG (smallArrayt *self, baset *value) { 12712 12713 return(self->f->prepend(self, value)); 12714 } 12715 12716 smallArrayt* prependUndefinedSmallArrayG(smallArrayt *self, void *value UNUSED) { 12717 12718 return(self->f->prependUndefined(self)); 12719 } 12720 12721 smallArrayt* prependBoolSmallArrayG (smallArrayt *self, bool value) { 12722 12723 return(self->f->prependBool(self,value)); 12724 } 12725 12726 smallArrayt* prependDoubleSmallArrayG (smallArrayt *self, double value) { 12727 12728 return(self->f->prependDouble(self,value)); 12729 } 12730 12731 smallArrayt* prependIntSmallArrayG (smallArrayt *self, int64_t value) { 12732 12733 return(self->f->prependInt(self,value)); 12734 } 12735 12736 smallArrayt* prependSSmallArrayG (smallArrayt *self, const char *string) { 12737 12738 return(self->f->prependS(self,string)); 12739 } 12740 12741 smallArrayt* prependCharSmallArrayG(smallArrayt *self, char c) { 12742 12743 return(self->f->prependChar(self,c)); 12744 } 12745 12746 smallArrayt* prependDictSmallArrayG (smallArrayt *self, smallDictt *dict) { 12747 12748 return(self->f->prependDict(self,dict)); 12749 } 12750 12751 smallArrayt* prependArraySmallArrayG (smallArrayt *self, smallArrayt *array) { 12752 12753 return(self->f->prependArray(self,array)); 12754 } 12755 12756 smallArrayt* prependArraycSmallArrayG (smallArrayt *self, char **array) { 12757 12758 return(self->f->prependArrayc(self,array)); 12759 } 12760 12761 smallArrayt* prependCArraycSmallArrayG (smallArrayt *self, const char **array) { 12762 12763 return(self->f->prependCArrayc(self,array)); 12764 } 12765 12766 smallArrayt* prependVoidSmallArrayG (smallArrayt *self, void *value) { 12767 12768 if (value) { 12769 smallContainert *c = allocSmallContainer(value); 12770 if (!c) { 12771 return(NULL); 12772 } 12773 return(self->f->prependNFreeSmallContainer(self, c)); 12774 } 12775 return(self->f->prependUndefined(self)); 12776 } 12777 12778 smallArrayt* prependSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value) { 12779 12780 return(self->f->prependSmallBool(self,value)); 12781 } 12782 12783 smallArrayt* prependSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value) { 12784 12785 return(self->f->prependSmallBytes(self,value)); 12786 } 12787 12788 smallArrayt* prependSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value) { 12789 12790 return(self->f->prependSmallDouble(self,value)); 12791 } 12792 12793 smallArrayt* prependSmallIntSmallArrayG (smallArrayt *self, smallIntt *value) { 12794 12795 return(self->f->prependSmallInt(self,value)); 12796 } 12797 12798 smallArrayt* prependSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json) { 12799 12800 return(self->f->prependSmallJson(self,json)); 12801 } 12802 12803 smallArrayt* prependSmallStringSmallArrayG (smallArrayt *self, smallStringt *string) { 12804 12805 return(self->f->prependSmallString(self,string)); 12806 } 12807 12808 smallArrayt* prependSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container) { 12809 12810 return(self->f->prependSmallContainer(self,container)); 12811 } 12812 12813 12814 smallArrayt* prependNFreeSmallArrayG (smallArrayt *self, baset *value) { 12815 12816 return(self->f->prependNFree(self,value)); 12817 } 12818 12819 smallArrayt* prependNFreeUndefinedSmallArrayG(smallArrayt *self, undefinedt *value) { 12820 12821 return(self->f->prependNFreeUndefined(self,value)); 12822 } 12823 12824 smallArrayt* prependNFreeSSmallArrayG (smallArrayt *self, char *string) { 12825 12826 return(self->f->prependNFreeS(self,string)); 12827 } 12828 12829 smallArrayt* prependNFreeDictSmallArrayG (smallArrayt *self, smallDictt *dict) { 12830 12831 return(self->f->prependNFreeDict(self,dict)); 12832 } 12833 12834 smallArrayt* prependNFreeArraySmallArrayG (smallArrayt *self, smallArrayt *array) { 12835 12836 return(self->f->prependNFreeArray(self,array)); 12837 } 12838 12839 smallArrayt* prependNFreeArraycSmallArrayG (smallArrayt *self, char **array) { 12840 12841 return(self->f->prependNFreeArrayc(self,array)); 12842 } 12843 12844 smallArrayt* prependNFreeSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value) { 12845 12846 return(self->f->prependNFreeSmallBool(self,value)); 12847 } 12848 12849 smallArrayt* prependNFreeSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value) { 12850 12851 return(self->f->prependNFreeSmallBytes(self,value)); 12852 } 12853 12854 smallArrayt* prependNFreeSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value) { 12855 12856 return(self->f->prependNFreeSmallDouble(self,value)); 12857 } 12858 12859 smallArrayt* prependNFreeSmallIntSmallArrayG (smallArrayt *self, smallIntt *value) { 12860 12861 return(self->f->prependNFreeSmallInt(self,value)); 12862 } 12863 12864 smallArrayt* prependNFreeSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json) { 12865 12866 return(self->f->prependNFreeSmallJson(self,json)); 12867 } 12868 12869 smallArrayt* prependNFreeSmallStringSmallArrayG (smallArrayt *self, smallStringt *string) { 12870 12871 return(self->f->prependNFreeSmallString(self,string)); 12872 } 12873 12874 smallArrayt* prependNFreeSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container) { 12875 12876 return(self->f->prependNFreeSmallContainer(self,container)); 12877 } 12878 12879 12880 12881 baset* dequeueSmallArrayG (smallArrayt *self, baset* retType UNUSED) { 12882 12883 return(self->f->dequeue(self)); 12884 } 12885 12886 undefinedt* dequeueUndefinedSmallArrayG (smallArrayt *self, undefinedt* retType UNUSED) { 12887 12888 return(self->f->dequeueUndefined(self)); 12889 } 12890 12891 bool dequeueBoolSmallArrayG (smallArrayt *self, bool retType UNUSED) { 12892 12893 return(self->f->dequeueBool(self)); 12894 } 12895 12896 double dequeueDoubleSmallArrayG (smallArrayt *self, double retType UNUSED) { 12897 12898 return(self->f->dequeueDouble(self)); 12899 } 12900 12901 int64_t dequeueIntSmallArrayG (smallArrayt *self, int64_t retType UNUSED) { 12902 12903 return(self->f->dequeueInt(self)); 12904 } 12905 12906 int32_t dequeueInt32SmallArrayG (smallArrayt *self, int32_t retType UNUSED) { 12907 12908 return(self->f->dequeueInt32(self)); 12909 } 12910 12911 uint64_t dequeueUintSmallArrayG (smallArrayt *self, uint64_t retType UNUSED) { 12912 12913 return(self->f->dequeueUint(self)); 12914 } 12915 12916 uint32_t dequeueUint32SmallArrayG (smallArrayt *self, uint32_t retType UNUSED) { 12917 12918 return(self->f->dequeueUint32(self)); 12919 } 12920 12921 char* dequeueSSmallArrayG (smallArrayt *self, char* retType UNUSED) { 12922 12923 return(self->f->dequeueS(self)); 12924 } 12925 12926 smallDictt* dequeueDictSmallArrayG (smallArrayt *self, smallDictt* retType UNUSED) { 12927 12928 return(self->f->dequeueDict(self)); 12929 } 12930 12931 smallArrayt* dequeueArraySmallArrayG (smallArrayt *self, smallArrayt* retType UNUSED) { 12932 12933 return(self->f->dequeueArray(self)); 12934 } 12935 12936 smallBoolt* dequeueSmallBoolSmallArrayG (smallArrayt *self, smallBoolt* retType UNUSED) { 12937 12938 return(self->f->dequeueSmallBool(self)); 12939 } 12940 12941 smallBytest* dequeueSmallBytesSmallArrayG (smallArrayt *self, smallBytest* retType UNUSED) { 12942 12943 return(self->f->dequeueSmallBytes(self)); 12944 } 12945 12946 smallDoublet* dequeueSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet* retType UNUSED) { 12947 12948 return(self->f->dequeueSmallDouble(self)); 12949 } 12950 12951 smallIntt* dequeueSmallIntSmallArrayG (smallArrayt *self, smallIntt* retType UNUSED) { 12952 12953 return(self->f->dequeueSmallInt(self)); 12954 } 12955 12956 smallJsont* dequeueSmallJsonSmallArrayG (smallArrayt *self, smallJsont* retType UNUSED) { 12957 12958 return(self->f->dequeueSmallJson(self)); 12959 } 12960 12961 smallStringt* dequeueSmallStringSmallArrayG (smallArrayt *self, smallStringt* retType UNUSED) { 12962 12963 return(self->f->dequeueSmallString(self)); 12964 } 12965 12966 void* dequeueVoidSmallArrayG (smallArrayt *self, void* retType UNUSED) { 12967 12968 return(self->f->dequeueVoid(self)); 12969 } 12970 12971 smallContainert* dequeueSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED) { 12972 12973 return(self->f->dequeueSmallContainer(self)); 12974 } 12975 12976 12977 12978 12979 baset* getAtSmallArrayG (smallArrayt *self, baset* retType UNUSED, int64_t index) { 12980 12981 return(self->f->getAt(self,index)); 12982 } 12983 12984 undefinedt* getAtUndefinedSmallArrayG (smallArrayt *self, undefinedt* retType UNUSED, int64_t index) { 12985 12986 return(self->f->getAtUndefined(self,index)); 12987 } 12988 12989 bool getAtBoolSmallArrayG (smallArrayt *self, bool retType UNUSED, int64_t index) { 12990 12991 return(self->f->getAtBool(self,index)); 12992 } 12993 12994 bool* getAtBoolPSmallArrayG (smallArrayt *self, bool* retType UNUSED, int64_t index) { 12995 12996 return(self->f->getAtBoolP(self,index)); 12997 } 12998 12999 double getAtDoubleSmallArrayG (smallArrayt *self, double retType UNUSED, int64_t index) { 13000 13001 return(self->f->getAtDouble(self,index)); 13002 } 13003 13004 double* getAtDoublePSmallArrayG (smallArrayt *self, double* retType UNUSED, int64_t index) { 13005 13006 return(self->f->getAtDoubleP(self,index)); 13007 } 13008 13009 int64_t getAtIntSmallArrayG (smallArrayt *self, int64_t retType UNUSED, int64_t index) { 13010 13011 return(self->f->getAtInt(self,index)); 13012 } 13013 13014 int64_t* getAtIntPSmallArrayG (smallArrayt *self, int64_t* retType UNUSED, int64_t index) { 13015 13016 return(self->f->getAtIntP(self,index)); 13017 } 13018 13019 int32_t getAtInt32SmallArrayG (smallArrayt *self, int32_t retType UNUSED, int64_t index) { 13020 13021 return(self->f->getAtInt32(self,index)); 13022 } 13023 13024 int32_t* getAtInt32PSmallArrayG (smallArrayt *self, int32_t* retType UNUSED, int64_t index) { 13025 13026 return(self->f->getAtInt32P(self,index)); 13027 } 13028 13029 uint64_t getAtUintSmallArrayG (smallArrayt *self, uint64_t retType UNUSED, int64_t index) { 13030 13031 return(self->f->getAtUint(self,index)); 13032 } 13033 13034 uint64_t* getAtUintPSmallArrayG (smallArrayt *self, uint64_t* retType UNUSED, int64_t index) { 13035 13036 return(self->f->getAtUintP(self,index)); 13037 } 13038 13039 uint32_t getAtUint32SmallArrayG (smallArrayt *self, uint32_t retType UNUSED, int64_t index) { 13040 13041 return(self->f->getAtUint32(self,index)); 13042 } 13043 13044 uint32_t* getAtUint32PSmallArrayG (smallArrayt *self, uint32_t* retType UNUSED, int64_t index) { 13045 13046 return(self->f->getAtUint32P(self,index)); 13047 } 13048 13049 char* getAtSSmallArrayG (smallArrayt *self, char* retType UNUSED, int64_t index) { 13050 13051 return(self->f->getAtS(self,index)); 13052 } 13053 13054 smallDictt* getAtDictSmallArrayG (smallArrayt *self, smallDictt* retType UNUSED, int64_t index) { 13055 13056 return(self->f->getAtDict(self,index)); 13057 } 13058 13059 smallArrayt* getAtArraySmallArrayG (smallArrayt *self, smallArrayt* retType UNUSED, int64_t index) { 13060 13061 return(self->f->getAtArray(self,index)); 13062 } 13063 13064 smallBoolt* getAtSmallBoolSmallArrayG (smallArrayt *self, smallBoolt* retType UNUSED, int64_t index) { 13065 13066 return(self->f->getAtSmallBool(self,index)); 13067 } 13068 13069 smallBytest* getAtSmallBytesSmallArrayG (smallArrayt *self, smallBytest* retType UNUSED, int64_t index) { 13070 13071 return(self->f->getAtSmallBytes(self,index)); 13072 } 13073 13074 smallDoublet* getAtSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet* retType UNUSED, int64_t index) { 13075 13076 return(self->f->getAtSmallDouble(self,index)); 13077 } 13078 13079 smallIntt* getAtSmallIntSmallArrayG (smallArrayt *self, smallIntt* retType UNUSED, int64_t index) { 13080 13081 return(self->f->getAtSmallInt(self,index)); 13082 } 13083 13084 smallJsont* getAtSmallJsonSmallArrayG(smallArrayt *self, smallJsont* retType UNUSED, int64_t index) { 13085 13086 return(self->f->getAtSmallJson(self,index)); 13087 } 13088 13089 smallStringt* getAtSmallStringSmallArrayG (smallArrayt *self, smallStringt* retType UNUSED, int64_t index) { 13090 13091 return(self->f->getAtSmallString(self,index)); 13092 } 13093 13094 void* getAtVoidSmallArrayG (smallArrayt *self, void* retType UNUSED, int64_t index) { 13095 13096 return(self->f->getAtVoid(self,index)); 13097 } 13098 13099 smallContainert* getAtSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, int64_t index) { 13100 13101 return(self->f->getAtSmallContainer(self,index)); 13102 } 13103 13104 13105 baset* getAtNDupSmallArrayG (smallArrayt *self, baset* retType UNUSED, int64_t index) { 13106 13107 return(self->f->getAtNDup(self,index)); 13108 } 13109 13110 undefinedt* getAtNDupUndefinedSmallArrayG (smallArrayt *self, undefinedt* retType UNUSED, int64_t index) { 13111 13112 return(self->f->getAtNDupUndefined(self,index)); 13113 } 13114 13115 bool getAtNDupBoolSmallArrayG (smallArrayt *self, bool retType UNUSED, int64_t index) { 13116 13117 return(self->f->getAtNDupBool(self,index)); 13118 } 13119 13120 double getAtNDupDoubleSmallArrayG (smallArrayt *self, double retType UNUSED, int64_t index) { 13121 13122 return(self->f->getAtNDupDouble(self,index)); 13123 } 13124 13125 int64_t getAtNDupIntSmallArrayG (smallArrayt *self, int64_t retType UNUSED, int64_t index) { 13126 13127 return(self->f->getAtNDupInt(self,index)); 13128 } 13129 13130 int32_t getAtNDupInt32SmallArrayG (smallArrayt *self, int32_t retType UNUSED, int64_t index) { 13131 13132 return(self->f->getAtNDupInt32(self,index)); 13133 } 13134 13135 uint64_t getAtNDupUintSmallArrayG (smallArrayt *self, uint64_t retType UNUSED, int64_t index) { 13136 13137 return(self->f->getAtNDupUint(self,index)); 13138 } 13139 13140 uint32_t getAtNDupUint32SmallArrayG (smallArrayt *self, uint32_t retType UNUSED, int64_t index) { 13141 13142 return(self->f->getAtNDupUint32(self,index)); 13143 } 13144 13145 char* getAtNDupSSmallArrayG (smallArrayt *self, char* retType UNUSED, int64_t index) { 13146 13147 return(self->f->getAtNDupS(self,index)); 13148 } 13149 13150 smallDictt* getAtNDupDictSmallArrayG (smallArrayt *self, smallDictt* retType UNUSED, int64_t index) { 13151 13152 return(self->f->getAtNDupDict(self,index)); 13153 } 13154 13155 smallArrayt* getAtNDupArraySmallArrayG (smallArrayt *self, smallArrayt* retType UNUSED, int64_t index) { 13156 13157 return(self->f->getAtNDupArray(self,index)); 13158 } 13159 13160 smallBoolt* getAtNDupSmallBoolSmallArrayG (smallArrayt *self, smallBoolt* retType UNUSED, int64_t index) { 13161 13162 return(self->f->getAtNDupSmallBool(self,index)); 13163 } 13164 13165 smallBytest* getAtNDupSmallBytesSmallArrayG (smallArrayt *self, smallBytest* retType UNUSED, int64_t index) { 13166 13167 return(self->f->getAtNDupSmallBytes(self,index)); 13168 } 13169 13170 smallDoublet* getAtNDupSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet* retType UNUSED, int64_t index) { 13171 13172 return(self->f->getAtNDupSmallDouble(self,index)); 13173 } 13174 13175 smallIntt* getAtNDupSmallIntSmallArrayG (smallArrayt *self, smallIntt* retType UNUSED, int64_t index) { 13176 13177 return(self->f->getAtNDupSmallInt(self,index)); 13178 } 13179 13180 smallJsont* getAtNDupSmallJsonSmallArrayG (smallArrayt *self, smallJsont* retType UNUSED, int64_t index) { 13181 13182 return(self->f->getAtNDupSmallJson(self,index)); 13183 } 13184 13185 smallStringt* getAtNDupSmallStringSmallArrayG (smallArrayt *self, smallStringt* retType UNUSED, int64_t index) { 13186 13187 return(self->f->getAtNDupSmallString(self,index)); 13188 } 13189 13190 void* getAtNDupVoidSmallArrayG (smallArrayt *self, void* retType UNUSED, int64_t index) { 13191 13192 return(self->f->getAtNDupVoid(self,index)); 13193 } 13194 13195 smallContainert* getAtNDupSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, int64_t index) { 13196 13197 return(self->f->getAtNDupSmallContainer(self,index)); 13198 } 13199 13200 smallArrayt* setAtSmallArrayG (smallArrayt *self, int64_t index, baset *value) { 13201 13202 return(self->f->setAt(self, index, value)); 13203 } 13204 13205 smallArrayt* setAtUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value UNUSED) { 13206 13207 return(self->f->setAtUndefined(self,index)); 13208 } 13209 13210 smallArrayt* setAtBoolSmallArrayG (smallArrayt *self, int64_t index, bool value) { 13211 13212 return(self->f->setAtBool(self,index,value)); 13213 } 13214 13215 smallArrayt* setAtDoubleSmallArrayG (smallArrayt *self, int64_t index, double value) { 13216 13217 return(self->f->setAtDouble(self,index,value)); 13218 } 13219 13220 smallArrayt* setAtIntSmallArrayG (smallArrayt *self, int64_t index, int64_t value) { 13221 13222 return(self->f->setAtInt(self,index,value)); 13223 } 13224 13225 smallArrayt* setAtSSmallArrayG (smallArrayt *self, int64_t index, const char *string) { 13226 13227 return(self->f->setAtS(self,index,string)); 13228 } 13229 13230 smallArrayt* setAtCharSmallArrayG(smallArrayt *self, int64_t index, char c) { 13231 13232 return(self->f->setAtChar(self,index,c)); 13233 } 13234 13235 smallArrayt* setAtDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict) { 13236 13237 return(self->f->setAtDict(self,index,dict)); 13238 } 13239 13240 smallArrayt* setAtArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array) { 13241 13242 return(self->f->setAtArray(self,index,array)); 13243 } 13244 13245 smallArrayt* setAtArraycSmallArrayG (smallArrayt *self, int64_t index, char **array) { 13246 13247 return(self->f->setAtArrayc(self,index,array)); 13248 } 13249 13250 smallArrayt* setAtCArraycSmallArrayG (smallArrayt *self, int64_t index, const char **array) { 13251 13252 return(self->f->setAtCArrayc(self,index,array)); 13253 } 13254 13255 smallArrayt* setAtVoidSmallArrayG (smallArrayt *self, int64_t index, void *value) { 13256 13257 if (value) { 13258 smallContainert *c = allocSmallContainer(value); 13259 if (!c) { 13260 return(NULL); 13261 } 13262 return(self->f->setAtNFreeSmallContainer(self, index, c)); 13263 } 13264 return(self->f->setAtUndefined(self,index)); 13265 } 13266 13267 smallArrayt* setAtSmallBoolSmallArrayG (smallArrayt *self, int64_t index, smallBoolt *value) { 13268 13269 return(self->f->setAtSmallBool(self,index,value)); 13270 } 13271 13272 smallArrayt* setAtSmallBytesSmallArrayG (smallArrayt *self, int64_t index, smallBytest *value) { 13273 13274 return(self->f->setAtSmallBytes(self,index,value)); 13275 } 13276 13277 smallArrayt* setAtSmallDoubleSmallArrayG (smallArrayt *self, int64_t index, smallDoublet *value) { 13278 13279 return(self->f->setAtSmallDouble(self,index,value)); 13280 } 13281 13282 smallArrayt* setAtSmallIntSmallArrayG (smallArrayt *self, int64_t index, smallIntt *value) { 13283 13284 return(self->f->setAtSmallInt(self,index,value)); 13285 } 13286 13287 smallArrayt* setAtSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *value) { 13288 13289 return(self->f->setAtSmallJson(self,index,value)); 13290 } 13291 13292 smallArrayt* setAtSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string) { 13293 13294 return(self->f->setAtSmallString(self,index,string)); 13295 } 13296 13297 smallArrayt* setAtSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container) { 13298 13299 return(self->f->setAtSmallContainer(self,index,container)); 13300 } 13301 13302 13303 smallArrayt* setAtNFreeSmallArrayG (smallArrayt *self, int64_t index, baset *value) { 13304 13305 return(self->f->setAtNFree(self,index,value)); 13306 } 13307 13308 smallArrayt* setAtNFreeUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value) { 13309 13310 return(self->f->setAtNFreeUndefined(self,index,value)); 13311 } 13312 13313 smallArrayt* setAtNFreeSSmallArrayG (smallArrayt *self, int64_t index, char *string) { 13314 13315 return(self->f->setAtNFreeS(self,index,string)); 13316 } 13317 13318 smallArrayt* setAtNFreeDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict) { 13319 13320 return(self->f->setAtNFreeDict(self,index,dict)); 13321 } 13322 13323 smallArrayt* setAtNFreeArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array) { 13324 13325 return(self->f->setAtNFreeArray(self,index,array)); 13326 } 13327 13328 smallArrayt* setAtNFreeArraycSmallArrayG (smallArrayt *self, int64_t index, char **array) { 13329 13330 return(self->f->setAtNFreeArrayc(self,index,array)); 13331 } 13332 13333 smallArrayt* setAtNFreeSmallBoolSmallArrayG (smallArrayt *self, int64_t index, smallBoolt *value) { 13334 13335 return(self->f->setAtNFreeSmallBool(self,index,value)); 13336 } 13337 13338 smallArrayt* setAtNFreeSmallBytesSmallArrayG (smallArrayt *self, int64_t index, smallBytest *value) { 13339 13340 return(self->f->setAtNFreeSmallBytes(self,index,value)); 13341 } 13342 13343 smallArrayt* setAtNFreeSmallDoubleSmallArrayG (smallArrayt *self, int64_t index, smallDoublet *value) { 13344 13345 return(self->f->setAtNFreeSmallDouble(self,index,value)); 13346 } 13347 13348 smallArrayt* setAtNFreeSmallIntSmallArrayG (smallArrayt *self, int64_t index, smallIntt *value) { 13349 13350 return(self->f->setAtNFreeSmallInt(self,index,value)); 13351 } 13352 13353 smallArrayt* setAtNFreeSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *value) { 13354 13355 return(self->f->setAtNFreeSmallJson(self,index,value)); 13356 } 13357 13358 smallArrayt* setAtNFreeSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string) { 13359 13360 return(self->f->setAtNFreeSmallString(self,index,string)); 13361 } 13362 13363 smallArrayt* setAtNFreeSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container) { 13364 13365 return(self->f->setAtNFreeSmallContainer(self,index,container)); 13366 } 13367 13368 13369 smallArrayt* setPAtDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict) { 13370 13371 return(self->f->setPAtDict(self,index,dict)); 13372 } 13373 13374 smallArrayt* setPAtArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array) { 13375 13376 return(self->f->setPAtArray(self,index,array)); 13377 } 13378 13379 smallArrayt* setPAtSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *json) { 13380 13381 return(self->f->setPAtSmallJson(self,index,json)); 13382 } 13383 13384 smallArrayt* setPAtSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string) { 13385 13386 return(self->f->setPAtSmallString(self,index,string)); 13387 } 13388 13389 smallArrayt* setPAtNFreeDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict) { 13390 13391 return(self->f->setPAtNFreeDict(self,index,dict)); 13392 } 13393 13394 smallArrayt* setPAtNFreeArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array) { 13395 13396 return(self->f->setPAtNFreeArray(self,index,array)); 13397 } 13398 13399 smallArrayt* setPAtNFreeSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *json) { 13400 13401 return(self->f->setPAtNFreeSmallJson(self,index,json)); 13402 } 13403 13404 smallArrayt* setPAtNFreeSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string) { 13405 13406 return(self->f->setPAtNFreeSmallString(self,index,string)); 13407 } 13408 13409 double getNumSmallArrayG(smallArrayt *self, int64_t index) { 13410 13411 return(self->f->getNum(self, index)); 13412 } 13413 13414 smallArrayt* reverseSmallArrayG (smallArrayt *self) { 13415 13416 return(self->f->reverse(self)); 13417 } 13418 13419 smallArrayt* appendSmallArrayG (smallArrayt *self, smallArrayt *array) { 13420 13421 return(self->f->append(self, array)); 13422 } 13423 13424 smallArrayt* appendSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json) { 13425 13426 return(self->f->appendSmallJson(self, json)); 13427 } 13428 13429 smallArrayt* appendNSmashSmallArrayG (smallArrayt *self, smallArrayt *array) { 13430 13431 return(self->f->appendNSmash(self,array)); 13432 } 13433 13434 smallArrayt* appendNSmashSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json) { 13435 13436 return(self->f->appendNSmashSmallJson(self,json)); 13437 } 13438 13439 smallArrayt* appendArraySmallArrayG (smallArrayt *self, char **array) { 13440 13441 return(self->f->appendArray(self, array)); 13442 } 13443 13444 smallArrayt* appendNSmashArraySmallArrayG (smallArrayt *self, char **array) { 13445 13446 return(self->f->appendNSmashArray(self,array)); 13447 } 13448 13449 smallArrayt* appendCArraySmallArrayG (smallArrayt *self, const char **array) { 13450 13451 return(self->f->appendCArray(self, array)); 13452 } 13453 13454 smallArrayt* shiftSmallArrayG (smallArrayt *self, smallArrayt *array) { 13455 13456 return(self->f->shift(self, array)); { 13457 // cg c bug if 13458 } 13459 } 13460 13461 smallArrayt* shiftSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json) { 13462 13463 return(self->f->shiftSmallJson(self, json)); { 13464 // cg c bug if 13465 } 13466 } 13467 13468 smallArrayt* shiftNSmashSmallArrayG (smallArrayt *self, smallArrayt *array) { 13469 13470 return(self->f->shiftNSmash(self,array)); { 13471 // cg c bug if 13472 } 13473 } 13474 13475 smallArrayt* shiftNSmashSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json) { 13476 13477 return(self->f->shiftNSmashSmallJson(self,json)); { 13478 // cg c bug if 13479 } 13480 } 13481 13482 smallArrayt* addSmallArrayG (smallArrayt *self, smallArrayt *array) { 13483 13484 return(self->f->add(self, array)); 13485 } 13486 13487 smallArrayt* sliceSmallArrayG(smallArrayt *self, int64_t start, int64_t end) { 13488 13489 return(self->f->slice(self, start, end)); 13490 } 13491 13492 smallArrayt* cropSmallArrayG (smallArrayt *self, int64_t start, int64_t end) { 13493 13494 return(self->f->crop(self, start, end)); 13495 } 13496 13497 baset* cropElemSmallArrayG (smallArrayt *self, int64_t index) { 13498 13499 return(self->f->cropElem(self, index)); 13500 } 13501 13502 undefinedt* cropElemUndefinedSmallArrayG (smallArrayt *self, int64_t index) { 13503 13504 return(self->f->cropElemUndefined(self, index)); 13505 } 13506 13507 bool cropElemBoolSmallArrayG (smallArrayt *self, int64_t index) { 13508 13509 return(self->f->cropElemBool(self, index)); 13510 } 13511 13512 double cropElemDoubleSmallArrayG (smallArrayt *self, int64_t index) { 13513 13514 return(self->f->cropElemDouble(self, index)); 13515 } 13516 13517 int64_t cropElemIntSmallArrayG (smallArrayt *self, int64_t index) { 13518 13519 return(self->f->cropElemInt(self, index)); 13520 } 13521 13522 int32_t cropElemInt32SmallArrayG (smallArrayt *self, int64_t index) { 13523 13524 return(self->f->cropElemInt32(self, index)); 13525 } 13526 13527 uint64_t cropElemUintSmallArrayG (smallArrayt *self, int64_t index) { 13528 13529 return(self->f->cropElemUint(self, index)); 13530 } 13531 13532 uint32_t cropElemUint32SmallArrayG (smallArrayt *self, int64_t index) { 13533 13534 return(self->f->cropElemUint32(self, index)); 13535 } 13536 13537 char* cropElemSSmallArrayG (smallArrayt *self, int64_t index) { 13538 13539 return(self->f->cropElemS(self, index)); 13540 } 13541 13542 smallDictt* cropElemDictSmallArrayG (smallArrayt *self, int64_t index) { 13543 13544 return(self->f->cropElemDict(self, index)); 13545 } 13546 13547 smallArrayt* cropElemArraySmallArrayG (smallArrayt *self, int64_t index) { 13548 13549 return(self->f->cropElemArray(self, index)); 13550 } 13551 13552 smallBoolt* cropElemSmallBoolSmallArrayG (smallArrayt *self, int64_t index) { 13553 13554 return(self->f->cropElemSmallBool(self, index)); 13555 } 13556 13557 smallBytest* cropElemSmallBytesSmallArrayG (smallArrayt *self, int64_t index) { 13558 13559 return(self->f->cropElemSmallBytes(self, index)); 13560 } 13561 13562 smallDoublet* cropElemSmallDoubleSmallArrayG (smallArrayt *self, int64_t index) { 13563 13564 return(self->f->cropElemSmallDouble(self, index)); 13565 } 13566 13567 smallIntt* cropElemSmallIntSmallArrayG (smallArrayt *self, int64_t index) { 13568 13569 return(self->f->cropElemSmallInt(self, index)); 13570 } 13571 13572 smallJsont* cropElemSmallJsonSmallArrayG (smallArrayt *self, int64_t index) { 13573 13574 return(self->f->cropElemSmallJson(self, index)); 13575 } 13576 13577 smallStringt* cropElemSmallStringSmallArrayG (smallArrayt *self, int64_t index) { 13578 13579 return(self->f->cropElemSmallString(self, index)); 13580 } 13581 13582 void* cropElemVoidSmallArrayG (smallArrayt *self, int64_t index) { 13583 13584 return(self->f->cropElemVoid(self, index)); 13585 } 13586 13587 smallContainert* cropElemSmallContainerSmallArrayG(smallArrayt *self, int64_t index) { 13588 13589 return(self->f->cropElemSmallContainer(self, index)); 13590 } 13591 13592 smallArrayt* copySmallArrayG (smallArrayt *self, int64_t start, int64_t end) { 13593 13594 return(self->f->copy(self, start, end)); 13595 } 13596 13597 smallArrayt* insertSmallArrayG(smallArrayt *self, int64_t index, smallArrayt *toInsert) { 13598 13599 return(self->f->insert(self, index, toInsert)); 13600 } 13601 13602 smallArrayt* insertSmallJsonSmallArrayG (smallArrayt *self, int64_t index, smallJsont *toInsert) { 13603 13604 return(self->f->insertSmallJson(self, index, toInsert)); 13605 } 13606 13607 smallArrayt* insertNSmashSmallArrayG(smallArrayt *self, int64_t index, smallArrayt *toInsert) { 13608 13609 return(self->f->insertNSmash(self, index, toInsert)); 13610 } 13611 13612 smallArrayt* insertNSmashSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *toInsert) { 13613 13614 return(self->f->insertNSmashSmallJson(self, index, toInsert)); 13615 } 13616 13617 smallArrayt* injectSmallArrayG (smallArrayt *self, int64_t index, baset *value) { 13618 13619 return(self->f->inject(self, index, value)); 13620 } 13621 13622 smallArrayt* injectUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value UNUSED) { 13623 13624 return(self->f->injectUndefined(self,index)); 13625 } 13626 13627 smallArrayt* injectBoolSmallArrayG (smallArrayt *self, int64_t index, bool value) { 13628 13629 return(self->f->injectBool(self,index,value)); 13630 } 13631 13632 smallArrayt* injectDoubleSmallArrayG (smallArrayt *self, int64_t index, double value) { 13633 13634 return(self->f->injectDouble(self,index,value)); 13635 } 13636 13637 smallArrayt* injectIntSmallArrayG (smallArrayt *self, int64_t index, int64_t value) { 13638 13639 return(self->f->injectInt(self,index,value)); 13640 } 13641 13642 smallArrayt* injectSSmallArrayG (smallArrayt *self, int64_t index, const char *string) { 13643 13644 return(self->f->injectS(self,index,string)); 13645 } 13646 13647 smallArrayt* injectCharSmallArrayG(smallArrayt *self, int64_t index, char c) { 13648 13649 return(self->f->injectChar(self,index,c)); 13650 } 13651 13652 smallArrayt* injectDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict) { 13653 13654 return(self->f->injectDict(self,index,dict)); 13655 } 13656 13657 smallArrayt* injectArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array) { 13658 13659 return(self->f->injectArray(self,index,array)); 13660 } 13661 13662 smallArrayt* injectArraycSmallArrayG (smallArrayt *self, int64_t index, char **array) { 13663 13664 return(self->f->injectArrayc(self,index,array)); 13665 } 13666 13667 smallArrayt* injectCArraycSmallArrayG (smallArrayt *self, int64_t index, const char **array) { 13668 13669 return(self->f->injectCArrayc(self,index,array)); 13670 } 13671 13672 smallArrayt* injectVoidSmallArrayG (smallArrayt *self, int64_t index, void *value) { 13673 13674 if (value) { 13675 smallContainert *c = allocSmallContainer(value); 13676 if (!c) { 13677 return(NULL); 13678 } 13679 return(self->f->injectNFreeSmallContainer(self, index, c)); 13680 } 13681 return(self->f->injectUndefined(self,index)); 13682 } 13683 13684 smallArrayt* injectSmallBoolSmallArrayG (smallArrayt *self, int64_t index, smallBoolt *value) { 13685 13686 return(self->f->injectSmallBool(self,index,value)); 13687 } 13688 13689 smallArrayt* injectSmallBytesSmallArrayG (smallArrayt *self, int64_t index, smallBytest *value) { 13690 13691 return(self->f->injectSmallBytes(self,index,value)); 13692 } 13693 13694 smallArrayt* injectSmallDoubleSmallArrayG (smallArrayt *self, int64_t index, smallDoublet *value) { 13695 13696 return(self->f->injectSmallDouble(self,index,value)); 13697 } 13698 13699 smallArrayt* injectSmallIntSmallArrayG (smallArrayt *self, int64_t index, smallIntt *value) { 13700 13701 return(self->f->injectSmallInt(self,index,value)); 13702 } 13703 13704 smallArrayt* injectSmallJsonSmallArrayG (smallArrayt *self, int64_t index, smallJsont *string) { 13705 13706 return(self->f->injectSmallJson(self,index,string)); 13707 } 13708 13709 smallArrayt* injectSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string) { 13710 13711 return(self->f->injectSmallString(self,index,string)); 13712 } 13713 13714 smallArrayt* injectSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container) { 13715 13716 return(self->f->injectSmallContainer(self,index,container)); 13717 } 13718 13719 13720 smallArrayt* injectNFreeSmallArrayG (smallArrayt *self, int64_t index, baset *value) { 13721 13722 return(self->f->injectNFree(self,index,value)); 13723 } 13724 13725 smallArrayt* injectNFreeUndefinedSmallArrayG(smallArrayt *self, int64_t index, undefinedt *value) { 13726 13727 return(self->f->injectNFreeUndefined(self,index,value)); 13728 } 13729 13730 smallArrayt* injectNFreeSSmallArrayG (smallArrayt *self, int64_t index, char *string) { 13731 13732 return(self->f->injectNFreeS(self,index,string)); 13733 } 13734 13735 smallArrayt* injectNFreeDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict) { 13736 13737 return(self->f->injectNFreeDict(self,index,dict)); 13738 } 13739 13740 smallArrayt* injectNFreeArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array) { 13741 13742 return(self->f->injectNFreeArray(self,index,array)); 13743 } 13744 13745 smallArrayt* injectNFreeArraycSmallArrayG (smallArrayt *self, int64_t index, char **array) { 13746 13747 return(self->f->injectNFreeArrayc(self,index,array)); 13748 } 13749 13750 smallArrayt* injectNFreeSmallBoolSmallArrayG (smallArrayt *self, int64_t index, smallBoolt *value) { 13751 13752 return(self->f->injectNFreeSmallBool(self,index,value)); 13753 } 13754 13755 smallArrayt* injectNFreeSmallBytesSmallArrayG (smallArrayt *self, int64_t index, smallBytest *value) { 13756 13757 return(self->f->injectNFreeSmallBytes(self,index,value)); 13758 } 13759 13760 smallArrayt* injectNFreeSmallDoubleSmallArrayG (smallArrayt *self, int64_t index, smallDoublet *value) { 13761 13762 return(self->f->injectNFreeSmallDouble(self,index,value)); 13763 } 13764 13765 smallArrayt* injectNFreeSmallIntSmallArrayG (smallArrayt *self, int64_t index, smallIntt *value) { 13766 13767 return(self->f->injectNFreeSmallInt(self,index,value)); 13768 } 13769 13770 smallArrayt* injectNFreeSmallJsonSmallArrayG (smallArrayt *self, int64_t index, smallJsont *string) { 13771 13772 return(self->f->injectNFreeSmallJson(self,index,string)); 13773 } 13774 13775 smallArrayt* injectNFreeSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string) { 13776 13777 return(self->f->injectNFreeSmallString(self,index,string)); 13778 } 13779 13780 smallArrayt* injectNFreeSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container) { 13781 13782 return(self->f->injectNFreeSmallContainer(self,index,container)); 13783 } 13784 13785 smallArrayt* delSmallArrayG (smallArrayt *self, int64_t start, int64_t end) { 13786 13787 return(self->f->del(self, start, end)); 13788 } 13789 13790 smallArrayt* delElemSmallArrayG (smallArrayt *self, int64_t index) { 13791 13792 return(self->f->delElem(self, index)); 13793 } 13794 13795 smallArrayt* removeSmallArrayG (smallArrayt *self, int64_t start, int64_t end) { 13796 13797 return(self->f->remove(self, start, end)); 13798 } 13799 13800 smallArrayt* removeElemSmallArrayG (smallArrayt *self, int64_t index) { 13801 13802 return(self->f->removeElem(self, index)); 13803 } 13804 13805 smallArrayt* sortSmallArrayG (smallArrayt *self) { 13806 13807 return(self->f->sort(self)); 13808 } 13809 13810 smallArrayt* sortFSmallArrayG(smallArrayt *self, shCmpt compareFunction) { 13811 13812 return(self->f->sortF(self,compareFunction)); 13813 } 13814 13815 smallArrayt* icSortSmallArrayG (smallArrayt *self) { 13816 13817 return(self->f->icSort(self)); 13818 } 13819 13820 bool equalSmallArrayG (smallArrayt *self, smallArrayt *array) { 13821 13822 return(self->f->equal(self, array)); 13823 } 13824 13825 bool equalSmallArraySmallJsonG(smallArrayt *self, smallJsont *array) { 13826 13827 return(self->f->equalSmallJson(self, array)); 13828 } 13829 13830 bool equalSmallArrayArrayG(smallArrayt* self, char ** p2) { 13831 13832 return(self->f->equalArray(self, p2)); 13833 } 13834 13835 bool equalSmallArrayCArrayG(smallArrayt* self, const char ** p2) { 13836 13837 return(self->f->equalCArray(self, p2)); 13838 } 13839 13840 bool equalSmallArrayBaseG(smallArrayt* self, baset* p2) { 13841 13842 return(self->f->equalBase(self, p2)); 13843 } 13844 13845 bool icEqualSmallArrayG (smallArrayt *self, smallArrayt *array) { 13846 13847 return(self->f->icEqual(self, array)); 13848 } 13849 13850 bool icEqualSmallArraySmallJsonG(smallArrayt *self, smallJsont *array) { 13851 13852 return(self->f->icEqualSmallJson(self, array)); 13853 } 13854 13855 bool icEqualSmallArrayArrayG(smallArrayt* self, char ** p2) { 13856 13857 return(self->f->icEqualArray(self, p2)); 13858 } 13859 13860 bool icEqualSmallArrayCArrayG(smallArrayt* self, const char ** p2) { 13861 13862 return(self->f->icEqualCArray(self, p2)); 13863 } 13864 13865 bool icEqualSmallArrayBaseG(smallArrayt* self, baset* p2) { 13866 13867 return(self->f->icEqualBase(self, p2)); 13868 } 13869 13870 size_t lenSmallArrayG (smallArrayt *self) { 13871 13872 return(self->f->len(self)); 13873 } 13874 13875 smallArrayt* trimSmallArrayG (smallArrayt *self) { 13876 13877 return(self->f->trim(self)); 13878 } 13879 13880 bool hasSmallArrayG (smallArrayt *self, baset *value) { 13881 13882 return(self->f->has(self, value)); 13883 } 13884 13885 bool hasUndefinedSmallArrayG(smallArrayt *self, undefinedt *value) { 13886 13887 return(self->f->hasUndefined(self, value)); 13888 } 13889 13890 bool hasBoolSmallArrayG (smallArrayt *self, bool value) { 13891 13892 return(self->f->hasBool(self,value)); 13893 } 13894 13895 bool hasDoubleSmallArrayG (smallArrayt *self, double value) { 13896 13897 return(self->f->hasDouble(self,value)); 13898 } 13899 13900 bool hasIntSmallArrayG (smallArrayt *self, int64_t value) { 13901 13902 return(self->f->hasInt(self,value)); 13903 } 13904 13905 bool hasSSmallArrayG (smallArrayt *self, const char *string) { 13906 13907 return(self->f->hasS(self,string)); 13908 } 13909 13910 bool hasCharSmallArrayG(smallArrayt *self, char c) { 13911 13912 return(self->f->hasChar(self,c)); 13913 } 13914 13915 bool hasDictSmallArrayG (smallArrayt *self, smallDictt *dict) { 13916 13917 return(self->f->hasDict(self,dict)); 13918 } 13919 13920 bool hasArraySmallArrayG (smallArrayt *self, smallArrayt *array) { 13921 13922 return(self->f->hasArray(self,array)); 13923 } 13924 13925 bool hasArraycSmallArrayG (smallArrayt *self, char **array) { 13926 13927 return(self->f->hasArrayc(self,array)); 13928 } 13929 13930 bool hasCArraycSmallArrayG (smallArrayt *self, const char **array) { 13931 13932 return(self->f->hasCArrayc(self,array)); 13933 } 13934 13935 bool hasSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value) { 13936 13937 return(self->f->hasSmallBool(self,value)); 13938 } 13939 13940 bool hasSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value) { 13941 13942 return(self->f->hasSmallBytes(self,value)); 13943 } 13944 13945 bool hasSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value) { 13946 13947 return(self->f->hasSmallDouble(self,value)); 13948 } 13949 13950 bool hasSmallIntSmallArrayG (smallArrayt *self, smallIntt *value) { 13951 13952 return(self->f->hasSmallInt(self,value)); 13953 } 13954 13955 bool hasSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string) { 13956 13957 return(self->f->hasSmallJson(self,string)); 13958 } 13959 13960 bool hasSmallStringSmallArrayG (smallArrayt *self, smallStringt *string) { 13961 13962 return(self->f->hasSmallString(self,string)); 13963 } 13964 13965 bool hasSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container) { 13966 13967 return(self->f->hasSmallContainer(self,container)); 13968 } 13969 13970 ssize_t indexOfSmallArrayG (smallArrayt *self, baset *value) { 13971 13972 return(self->f->indexOf(self, value)); 13973 } 13974 13975 ssize_t indexOfUndefinedSmallArrayG(smallArrayt *self, undefinedt *value) { 13976 13977 return(self->f->indexOfUndefined(self, value)); 13978 } 13979 13980 ssize_t indexOfBoolSmallArrayG (smallArrayt *self, bool value) { 13981 13982 return(self->f->indexOfBool(self,value)); 13983 } 13984 13985 ssize_t indexOfDoubleSmallArrayG (smallArrayt *self, double value) { 13986 13987 return(self->f->indexOfDouble(self,value)); 13988 } 13989 13990 ssize_t indexOfIntSmallArrayG (smallArrayt *self, int64_t value) { 13991 13992 return(self->f->indexOfInt(self,value)); 13993 } 13994 13995 ssize_t indexOfSSmallArrayG (smallArrayt *self, const char *string) { 13996 13997 return(self->f->indexOfS(self,string)); 13998 } 13999 14000 ssize_t indexOfCharSmallArrayG(smallArrayt *self, char c) { 14001 14002 return(self->f->indexOfChar(self,c)); 14003 } 14004 14005 ssize_t indexOfDictSmallArrayG (smallArrayt *self, smallDictt *dict) { 14006 14007 return(self->f->indexOfDict(self,dict)); 14008 } 14009 14010 ssize_t indexOfArraySmallArrayG (smallArrayt *self, smallArrayt *array) { 14011 14012 return(self->f->indexOfArray(self,array)); 14013 } 14014 14015 ssize_t indexOfArraycSmallArrayG (smallArrayt *self, char **array) { 14016 14017 return(self->f->indexOfArrayc(self,array)); 14018 } 14019 14020 ssize_t indexOfCArraycSmallArrayG (smallArrayt *self, const char **array) { 14021 14022 return(self->f->indexOfCArrayc(self,array)); 14023 } 14024 14025 ssize_t indexOfSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value) { 14026 14027 return(self->f->indexOfSmallBool(self,value)); 14028 } 14029 14030 ssize_t indexOfSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value) { 14031 14032 return(self->f->indexOfSmallBytes(self,value)); 14033 } 14034 14035 ssize_t indexOfSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value) { 14036 14037 return(self->f->indexOfSmallDouble(self,value)); 14038 } 14039 14040 ssize_t indexOfSmallIntSmallArrayG (smallArrayt *self, smallIntt *value) { 14041 14042 return(self->f->indexOfSmallInt(self,value)); 14043 } 14044 14045 ssize_t indexOfSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string) { 14046 14047 return(self->f->indexOfSmallJson(self,string)); 14048 } 14049 14050 ssize_t indexOfSmallStringSmallArrayG (smallArrayt *self, smallStringt *string) { 14051 14052 return(self->f->indexOfSmallString(self,string)); 14053 } 14054 14055 ssize_t indexOfSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container) { 14056 14057 return(self->f->indexOfSmallContainer(self,container)); 14058 } 14059 14060 ssize_t binarySearchSmallArrayG (smallArrayt *self, baset *value) { 14061 14062 return(self->f->binarySearch(self, value)); 14063 } 14064 14065 ssize_t binarySearchUndefinedSmallArrayG(smallArrayt *self, undefinedt *value) { 14066 14067 return(self->f->binarySearchUndefined(self, value)); 14068 } 14069 14070 ssize_t binarySearchBoolSmallArrayG (smallArrayt *self, bool value) { 14071 14072 return(self->f->binarySearchBool(self,value)); 14073 } 14074 14075 ssize_t binarySearchDoubleSmallArrayG (smallArrayt *self, double value) { 14076 14077 return(self->f->binarySearchDouble(self,value)); 14078 } 14079 14080 ssize_t binarySearchIntSmallArrayG (smallArrayt *self, int64_t value) { 14081 14082 return(self->f->binarySearchInt(self,value)); 14083 } 14084 14085 ssize_t binarySearchSSmallArrayG (smallArrayt *self, const char *string) { 14086 14087 return(self->f->binarySearchS(self,string)); 14088 } 14089 14090 ssize_t binarySearchCharSmallArrayG(smallArrayt *self, char c) { 14091 14092 return(self->f->binarySearchChar(self,c)); 14093 } 14094 14095 ssize_t binarySearchDictSmallArrayG (smallArrayt *self, smallDictt *dict) { 14096 14097 return(self->f->binarySearchDict(self,dict)); 14098 } 14099 14100 ssize_t binarySearchArraySmallArrayG (smallArrayt *self, smallArrayt *array) { 14101 14102 return(self->f->binarySearchArray(self,array)); 14103 } 14104 14105 ssize_t binarySearchArraycSmallArrayG (smallArrayt *self, char **array) { 14106 14107 return(self->f->binarySearchArrayc(self,array)); 14108 } 14109 14110 ssize_t binarySearchCArraycSmallArrayG (smallArrayt *self, const char **array) { 14111 14112 return(self->f->binarySearchCArrayc(self,array)); 14113 } 14114 14115 ssize_t binarySearchSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value) { 14116 14117 return(self->f->binarySearchSmallBool(self,value)); 14118 } 14119 14120 ssize_t binarySearchSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value) { 14121 14122 return(self->f->binarySearchSmallBytes(self,value)); 14123 } 14124 14125 ssize_t binarySearchSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value) { 14126 14127 return(self->f->binarySearchSmallDouble(self,value)); 14128 } 14129 14130 ssize_t binarySearchSmallIntSmallArrayG (smallArrayt *self, smallIntt *value) { 14131 14132 return(self->f->binarySearchSmallInt(self,value)); 14133 } 14134 14135 ssize_t binarySearchSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string) { 14136 14137 return(self->f->binarySearchSmallJson(self,string)); 14138 } 14139 14140 ssize_t binarySearchSmallStringSmallArrayG (smallArrayt *self, smallStringt *string) { 14141 14142 return(self->f->binarySearchSmallString(self,string)); 14143 } 14144 14145 ssize_t binarySearchSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container) { 14146 14147 return(self->f->binarySearchSmallContainer(self,container)); 14148 } 14149 14150 smallArrayt* uniqSmallArrayG(smallArrayt *self, int dum UNUSED) { 14151 14152 return(self->f->uniq(self)); 14153 } 14154 14155 bool icHasSmallArrayG (smallArrayt *self, baset *value) { 14156 14157 return(self->f->icHas(self, value)); 14158 } 14159 14160 bool icHasSSmallArrayG (smallArrayt *self, const char *string) { 14161 14162 return(self->f->icHasS(self,string)); 14163 } 14164 14165 bool icHasCharSmallArrayG(smallArrayt *self, char c) { 14166 14167 return(self->f->icHasChar(self,c)); 14168 } 14169 14170 bool icHasDictSmallArrayG (smallArrayt *self, smallDictt *dict) { 14171 14172 return(self->f->icHasDict(self,dict)); 14173 } 14174 14175 bool icHasArraySmallArrayG (smallArrayt *self, smallArrayt *array) { 14176 14177 return(self->f->icHasArray(self,array)); 14178 } 14179 14180 bool icHasArraycSmallArrayG (smallArrayt *self, char **array) { 14181 14182 return(self->f->icHasArrayc(self,array)); 14183 } 14184 14185 bool icHasCArraycSmallArrayG (smallArrayt *self, const char **array) { 14186 14187 return(self->f->icHasCArrayc(self,array)); 14188 } 14189 14190 bool icHasSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string) { 14191 14192 return(self->f->icHasSmallJson(self,string)); 14193 } 14194 14195 bool icHasSmallStringSmallArrayG (smallArrayt *self, smallStringt *string) { 14196 14197 return(self->f->icHasSmallString(self,string)); 14198 } 14199 14200 ssize_t icIndexOfSmallArrayG (smallArrayt *self, baset *value) { 14201 14202 return(self->f->icIndexOf(self, value)); 14203 } 14204 14205 ssize_t icIndexOfSSmallArrayG (smallArrayt *self, const char *string) { 14206 14207 return(self->f->icIndexOfS(self,string)); 14208 } 14209 14210 ssize_t icIndexOfCharSmallArrayG(smallArrayt *self, char c) { 14211 14212 return(self->f->icIndexOfChar(self,c)); 14213 } 14214 14215 ssize_t icIndexOfDictSmallArrayG (smallArrayt *self, smallDictt *dict) { 14216 14217 return(self->f->icIndexOfDict(self,dict)); 14218 } 14219 14220 ssize_t icIndexOfArraySmallArrayG (smallArrayt *self, smallArrayt *array) { 14221 14222 return(self->f->icIndexOfArray(self,array)); 14223 } 14224 14225 ssize_t icIndexOfArraycSmallArrayG (smallArrayt *self, char **array) { 14226 14227 return(self->f->icIndexOfArrayc(self,array)); 14228 } 14229 14230 ssize_t icIndexOfCArraycSmallArrayG (smallArrayt *self, const char **array) { 14231 14232 return(self->f->icIndexOfCArrayc(self,array)); 14233 } 14234 14235 ssize_t icIndexOfSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string) { 14236 14237 return(self->f->icIndexOfSmallJson(self,string)); 14238 } 14239 14240 ssize_t icIndexOfSmallStringSmallArrayG (smallArrayt *self, smallStringt *string) { 14241 14242 return(self->f->icIndexOfSmallString(self,string)); 14243 } 14244 14245 ssize_t icBinarySearchSmallArrayG (smallArrayt *self, baset *value) { 14246 14247 return(self->f->icBinarySearch(self, value)); 14248 } 14249 14250 ssize_t icBinarySearchSSmallArrayG (smallArrayt *self, const char *string) { 14251 14252 return(self->f->icBinarySearchS(self,string)); 14253 } 14254 14255 ssize_t icBinarySearchCharSmallArrayG(smallArrayt *self, char c) { 14256 14257 return(self->f->icBinarySearchChar(self,c)); 14258 } 14259 14260 ssize_t icBinarySearchDictSmallArrayG (smallArrayt *self, smallDictt *dict) { 14261 14262 return(self->f->icBinarySearchDict(self,dict)); 14263 } 14264 14265 ssize_t icBinarySearchArraySmallArrayG (smallArrayt *self, smallArrayt *array) { 14266 14267 return(self->f->icBinarySearchArray(self,array)); 14268 } 14269 14270 ssize_t icBinarySearchArraycSmallArrayG (smallArrayt *self, char **array) { 14271 14272 return(self->f->icBinarySearchArrayc(self,array)); 14273 } 14274 14275 ssize_t icBinarySearchCArraycSmallArrayG (smallArrayt *self, const char **array) { 14276 14277 return(self->f->icBinarySearchCArrayc(self,array)); 14278 } 14279 14280 ssize_t icBinarySearchSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string) { 14281 14282 return(self->f->icBinarySearchSmallJson(self,string)); 14283 } 14284 14285 ssize_t icBinarySearchSmallStringSmallArrayG (smallArrayt *self, smallStringt *string) { 14286 14287 return(self->f->icBinarySearchSmallString(self,string)); 14288 } 14289 14290 smallArrayt* icUniqSmallArrayG(smallArrayt *self, int dum UNUSED) { 14291 14292 return(self->f->icUniq(self)); 14293 } 14294 14295 smallArrayt* compactSmallArrayG (smallArrayt *self) { 14296 14297 return(self->f->compact(self)); 14298 } 14299 14300 smallArrayt* emptySmallArrayG (smallArrayt *self) { 14301 14302 return(self->f->empty(self)); 14303 } 14304 14305 bool isEmptySmallArrayG (smallArrayt *self) { 14306 14307 return(self->f->isEmpty(self)); 14308 } 14309 14310 bool isBlankSmallArrayG (smallArrayt *self) { 14311 14312 return(self->f->isBlank(self)); 14313 } 14314 14315 smallStringt* joinSmallArrayG(smallArrayt *self, const char* delim) { 14316 14317 return(self->f->join(self, delim)); 14318 } 14319 14320 smallStringt* joinCharSmallArrayG(smallArrayt *self, char c) { 14321 14322 return(self->f->joinChar(self,c)); 14323 } 14324 14325 smallStringt* joinSmallJsonSmallArrayG (smallArrayt *self, smallJsont* delim) { 14326 14327 return(self->f->joinSmallJson(self,delim)); 14328 } 14329 14330 smallStringt* joinSmallStringSmallArrayG(smallArrayt *self, smallStringt* delim) { 14331 14332 return(self->f->joinSmallString(self,delim)); 14333 } 14334 14335 char* joinSSmallArrayG(smallArrayt *self, const char* delim) { 14336 14337 return(self->f->joinS(self,delim)); 14338 } 14339 14340 char* joinCharSSmallArrayG(smallArrayt *self, char c) { 14341 14342 return(self->f->joinCharS(self,c)); 14343 } 14344 14345 char* joinSmallJsonSSmallArrayG (smallArrayt *self, smallJsont* delim) { 14346 14347 return(self->f->joinSmallJsonS(self,delim)); 14348 } 14349 14350 char* joinSmallStringSSmallArrayG(smallArrayt *self, smallStringt* delim) { 14351 14352 return(self->f->joinSmallStringS(self,delim)); 14353 } 14354 14355 smallArrayt* zipSmallArrayG(smallArrayt *self, smallArrayt *array1, smallArrayt *array2) { 14356 14357 return(self->f->zip(self,array1,array2)); 14358 } 14359 14360 smallArrayt* zipSmallJsonSmallArrayG(smallArrayt *self, smallArrayt *array1, smallJsont *array2) { 14361 14362 return(self->f->zipSmallJson(self,array1,array2)); 14363 } 14364 14365 smallArrayt* zipSmallJsonSmallArraySmallArrayG(smallArrayt *self, smallJsont *array1, smallArrayt *array2) { 14366 14367 return(self->f->zipSmallJsonSmallArray(self,array1,array2)); 14368 } 14369 14370 smallArrayt* zipSmallJsonSmallJsonSmallArrayG(smallArrayt *self, smallJsont *array1, smallJsont *array2) { 14371 14372 return(self->f->zipSmallJsonSmallJson(self,array1,array2)); 14373 } 14374 14375 smallArrayt* zipSmallJsonCharSmallArrayG(smallArrayt *self, smallJsont *array1, char **array2) { 14376 14377 return(self->f->zipSmallJsonChar(self,array1,array2)); 14378 } 14379 14380 smallArrayt* zipSmallJsonCCharSmallArrayG(smallArrayt *self, smallJsont *array1, const char **array2) { 14381 14382 return(self->f->zipSmallJsonCChar(self,array1,array2)); 14383 } 14384 14385 smallArrayt* zipArraySmallArrayG(smallArrayt *self, char** array1, smallArrayt *array2) { 14386 14387 return(self->f->zipArray(self,array1,array2)); 14388 } 14389 14390 smallArrayt* zipCArraySmallArrayG(smallArrayt *self, const char** array1, smallArrayt *array2) { 14391 14392 return(self->f->zipCArray(self,array1,array2)); 14393 } 14394 14395 smallArrayt* zipArraySmallJsonSmallArrayG(smallArrayt *self, char** array1, smallJsont *array2) { 14396 14397 return(self->f->zipArraySmallJson(self,array1,array2)); 14398 } 14399 14400 smallArrayt* zipCArraySmallJsonSmallArrayG(smallArrayt *self, const char** array1, smallJsont *array2) { 14401 14402 return(self->f->zipCArraySmallJson(self,array1,array2)); 14403 } 14404 14405 smallArrayt* zipCharSmallArrayG(smallArrayt *self, smallArrayt *array1, char** array2) { 14406 14407 return(self->f->zipChar(self,array1,array2)); 14408 } 14409 14410 smallArrayt* zipCCharSmallArrayG(smallArrayt *self, smallArrayt *array1, const char** array2) { 14411 14412 return(self->f->zipCChar(self,array1,array2)); 14413 } 14414 14415 smallArrayt* zipArrayCharSmallArrayG(smallArrayt *self, char** array1, char** array2) { 14416 14417 return(self->f->zipArrayChar(self,array1,array2)); 14418 } 14419 14420 smallArrayt* zipArrayCCharSmallArrayG(smallArrayt *self, char** array1, const char** array2) { 14421 14422 return(self->f->zipArrayCChar(self,array1,array2)); 14423 } 14424 14425 smallArrayt* zipCArrayCharSmallArrayG(smallArrayt *self, const char** array1, char** array2) { 14426 14427 return(self->f->zipCArrayChar(self,array1,array2)); 14428 } 14429 14430 smallArrayt* zipCArrayCCharSmallArrayG(smallArrayt *self, const char** array1, const char** array2) { 14431 14432 return(self->f->zipCArrayCChar(self,array1,array2)); 14433 } 14434 14435 void logSmallArrayG(smallArrayt *self) { 14436 14437 self->f->log(self); 14438 } 14439 14440 smallArrayt* readTextSmallArrayG (smallArrayt *self, const char *filePath) { 14441 14442 return(self->f->readText(self, filePath)); 14443 } 14444 14445 smallArrayt* readTextSmallJsonSmallArrayG (smallArrayt *self, smallJsont *filePath) { 14446 14447 return(self->f->readTextSmallJson(self,filePath)); 14448 } 14449 14450 smallArrayt* readTextSmallStringSmallArrayG(smallArrayt *self, smallStringt *filePath) { 14451 14452 return(self->f->readTextSmallString(self,filePath)); 14453 } 14454 14455 smallArrayt* readStreamSmallArrayG (smallArrayt *self, FILE *fp) { 14456 14457 return(self->f->readStream(self, fp)); 14458 } 14459 14460 bool writeTextSmallArrayG (smallArrayt *self, const char *filePath) { 14461 14462 return(self->f->writeText(self, filePath)); 14463 } 14464 14465 bool writeTextSmallJsonSmallArrayG (smallArrayt *self, smallJsont *filePath) { 14466 14467 return(self->f->writeTextSmallJson(self,filePath)); 14468 } 14469 14470 bool writeTextSmallStringSmallArrayG(smallArrayt *self, smallStringt *filePath) { 14471 14472 return(self->f->writeTextSmallString(self,filePath)); 14473 } 14474 14475 bool writeStreamSmallArrayG (smallArrayt *self, FILE *fp) { 14476 14477 return(self->f->writeStream(self, fp)); 14478 } 14479 14480 bool appendTextSmallArrayG(smallArrayt *self, const char *filePath) { 14481 14482 return(self->f->appendText(self,filePath)); 14483 } 14484 14485 bool appendTextSmallStringSmallArrayG(smallArrayt *self, smallStringt *filePath) { 14486 14487 return(self->f->appendTextSmallString(self,filePath)); 14488 } 14489 14490 smallStringt* typeSmallStringSmallArrayG(smallArrayt *self, int64_t index) { 14491 14492 return(self->f->typeSmallString(self,index)); 14493 } 14494 14495 smallArrayt* typeSmallStringsSmallArrayG(smallArrayt *self) { 14496 14497 return(self->f->typeSmallStrings(self)); 14498 } 14499