commit 03cc464cbbd9db5ff4c342f94b4d6483318f52a1 parent 4aab4275ccfef0fef0ca89fbf4ea5fddf85f7395 Author: Remy Noulin <loader2x@gmail.com> Date: Mon, 6 Jan 2020 16:34:47 +0100 add cleanFinish*, cleanDispose* and cleanSmash* and support NULL pointers in all cleanup functions completion.txt | 15 +++++++++++++++ documentation.md | 15 +++++++++++++++ release/json/libsheepyCSmallArray.h | 25 +++++++++++++++++++++++++ release/json/libsheepyCSmallBool.h | 8 ++++++++ release/json/libsheepyCSmallBytes.h | 8 ++++++++ release/json/libsheepyCSmallContainer.h | 8 ++++++++ release/json/libsheepyCSmallDict.h | 25 +++++++++++++++++++++++++ release/json/libsheepyCSmallDouble.h | 8 ++++++++ release/json/libsheepyCSmallInt.h | 8 ++++++++ release/json/libsheepyCSmallJson.h | 24 ++++++++++++++++++++++++ release/json/libsheepyCSmallString.h | 8 ++++++++ release/json/libsheepyCUndefined.h | 16 ++++++++++++++++ src/json/libsheepyCSmallArray.c | 22 ++++++++++++++++++++-- src/json/libsheepyCSmallArray.h | 25 +++++++++++++++++++++++++ src/json/libsheepyCSmallBool.c | 10 ++++++++-- src/json/libsheepyCSmallBool.h | 8 ++++++++ src/json/libsheepyCSmallBytes.c | 11 +++++++++-- src/json/libsheepyCSmallBytes.h | 8 ++++++++ src/json/libsheepyCSmallContainer.c | 10 ++++++++-- src/json/libsheepyCSmallContainer.h | 8 ++++++++ src/json/libsheepyCSmallDict.c | 22 ++++++++++++++++++++-- src/json/libsheepyCSmallDict.h | 25 +++++++++++++++++++++++++ src/json/libsheepyCSmallDouble.c | 10 ++++++++-- src/json/libsheepyCSmallDouble.h | 8 ++++++++ src/json/libsheepyCSmallInt.c | 10 ++++++++-- src/json/libsheepyCSmallInt.h | 8 ++++++++ src/json/libsheepyCSmallJson.c | 22 ++++++++++++++++++++-- src/json/libsheepyCSmallJson.h | 24 ++++++++++++++++++++++++ src/json/libsheepyCSmallString.c | 10 ++++++++-- src/json/libsheepyCSmallString.h | 8 ++++++++ src/json/libsheepyCUndefined.c | 16 ++++++++++++++-- src/json/libsheepyCUndefined.h | 16 ++++++++++++++++ 32 files changed, 429 insertions(+), 20 deletions(-) Diffstat:
32 files changed, 429 insertions(+), 20 deletions(-)
diff --git a/completion.txt b/completion.txt @@ -3359,6 +3359,9 @@ createSmallDict(obj) ;smallDictt obj; initiateSmallDict(&obj) createAllocateSmallDict(obj) ;smallDictt *obj; initiateAllocateSmallDict(&obj) cleanSmallDictP(name) smallDictt *name CLEANUP(cleanUpSmallDictTerminateG) cleanSmallDict(name) smallDictt name CLEANUP(cleanUpSmallDictFreeG); initiateSmallDict(&name) +cleanFinishSmallDictP(name) smallDictt *name CLEANUP(cleanUpSmallDictFinishG) +cleanDisposeSmallDict(name) smallDictt name CLEANUP(cleanUpSmallDictDisposeG); initiateSmallDict(&name) +cleanSmashSmallDictP(name) smallDictt *name CLEANUP(cleanUpSmallDictSmashG) forEachSmallDict(smallDict, key, value) forEachTypeSmallDict(type, smallDict, key, value) @@ -3372,6 +3375,9 @@ createSmallArray(obj) ;smallArrayt obj; initiateSmallArray(&obj) createAllocateSmallArray(obj) ;smallArrayt *obj; initiateAllocateSmallArray(&obj) cleanSmallArrayP(name) smallArrayt *name CLEANUP(cleanUpSmallArrayTerminateG) cleanSmallArray(name) smallArrayt name CLEANUP(cleanUpSmallArrayFreeG); initiateSmallArray(&name) +cleanFinishSmallArrayP(name) smallArrayt *name CLEANUP(cleanUpSmallArrayFinishG) +cleanDisposeSmallArray(name) smallArrayt name CLEANUP(cleanUpSmallArrayDisposeG); initiateSmallArray(&name) +cleanSmashSmallArrayP(name) smallArrayt *name CLEANUP(cleanUpSmallArraySmashG) createSA(...) createSAF("", __VA_ARGS__, NULL) forEachSmallArray(array, element) forEachTypeSmallArray(type, array, element) @@ -3395,6 +3401,9 @@ createAllocateSmallJson(obj) ;smallJsont *obj; initiateAllocateSmallJson(&obj) createSJ(...) createSJF("", __VA_ARGS__, NULL) cleanSmallJsonP(name) smallJsont *name CLEANUP(cleanUpSmallJsonTerminateG) cleanSmallJson(name) smallJsont name CLEANUP(cleanUpSmallJsonFreeG); initiateSmallJson(&name) +cleanFinishSmallJsonP(name) smallJsont *name CLEANUP(cleanUpSmallJsonFinishG) +cleanDisposeSmallJson(name) smallJsont name CLEANUP(cleanUpSmallJsonDisposeG); initiateSmallJson(&name) +cleanSmashSmallJsonP(name) smallJsont *name CLEANUP(cleanUpSmallJsonSmashG) forEachSmallJson(array, element) forEachDictSmallJson(smallJson, key, value) enumerateSmallJson(array, element, index) @@ -3409,6 +3418,7 @@ createSmallBytes(obj) ;smallBytest obj; initiateSmallBytes(&obj) createAllocateSmallBytes(obj) ;smallBytest *obj; initiateAllocateSmallBytes(&obj) cleanSmallBytesP(name) smallBytest *name CLEANUP(cleanUpSmallBytesTerminateG) cleanSmallBytes(name) smallBytest name CLEANUP(cleanUpSmallBytesFreeG); initiateSmallBytes(&name) +cleanFinishSmallBytesP(name) smallBytest *name CLEANUP(cleanUpSmallBytesFinishG) Class SmallBool @@ -3420,6 +3430,7 @@ createSmallBool(obj) ;smallBoolt obj; initiateSmallBool(&obj) createAllocateSmallBool(obj) ;smallBoolt *obj; initiateAllocateSmallBool(&obj) cleanSmallBoolP(name) smallBoolt *name CLEANUP(cleanUpSmallBoolTerminateG) cleanSmallBool(name) smallBoolt name CLEANUP(cleanUpSmallBoolFreeG); initiateSmallBool(&name) +cleanFinishSmallBoolP(name) smallBoolt *name CLEANUP(cleanUpSmallBoolFinishG) Class SmallContainer @@ -3431,6 +3442,7 @@ createSmallContainer(obj) ;smallContainert obj; initiateSmallContainer(&obj) createAllocateSmallContainer(obj) ;smallContainert *obj; initiateAllocateSmallContainer(&obj) cleanSmallContainerP(name) smallContainert *name CLEANUP(cleanUpSmallContainerTerminateG) cleanSmallContainer(name) smallContainert name CLEANUP(cleanUpSmallContainerFreeG); initiateSmallContainer(&name) +cleanFinishSmallContainerP(name) smallContainert *name CLEANUP(cleanUpSmallContainerFinishG) Class SmallDouble @@ -3442,6 +3454,7 @@ createSmallDouble(obj) ;smallDoublet obj; initiateSmallDouble(&obj) createAllocateSmallDouble(obj) ;smallDoublet *obj; initiateAllocateSmallDouble(&obj) cleanSmallDoubleP(name) smallDoublet *name CLEANUP(cleanUpSmallDoubleTerminateG) cleanSmallDouble(name) smallDoublet name CLEANUP(cleanUpSmallDoubleFreeG); initiateSmallDouble(&name) +cleanFinishSmallDoubleP(name) smallDoublet *name CLEANUP(cleanUpSmallDoubleFinishG) Class SmallInt @@ -3453,6 +3466,7 @@ createSmallInt(obj) ;smallIntt obj; initiateSmallInt(&obj) createAllocateSmallInt(obj) ;smallIntt *obj; initiateAllocateSmallInt(&obj) cleanSmallIntP(name) smallIntt *name CLEANUP(cleanUpSmallIntTerminateG) cleanSmallInt(name) smallIntt name CLEANUP(cleanUpSmallIntFreeG); initiateSmallInt(&name) +cleanFinishSmallIntP(name) smallIntt *name CLEANUP(cleanUpSmallIntFinishG) Class SmallString @@ -3464,6 +3478,7 @@ createSmallString(obj) ;smallStringt obj; initiateSmallString(&obj) createAllocateSmallString(obj) ;smallStringt *obj; initiateAllocateSmallString(&obj) cleanSmallStringP(name) smallStringt *name CLEANUP(cleanUpSmallStringTerminateG) cleanSmallString(name) smallStringt name CLEANUP(cleanUpSmallStringFreeG); initiateSmallString(&name) +cleanFinishSmallStringP(name) smallStringt *name CLEANUP(cleanUpSmallStringFinishG) createS(...) createSF("", __VA_ARGS__, NULL) extern undefinedt* undefined; diff --git a/documentation.md b/documentation.md @@ -17240,6 +17240,9 @@ createSmallDict(obj) ;smallDictt obj; initiateSmallDict(&obj) createAllocateSmallDict(obj) ;smallDictt *obj; initiateAllocateSmallDict(&obj) cleanSmallDictP(name) smallDictt *name CLEANUP(cleanUpSmallDictTerminateG) cleanSmallDict(name) smallDictt name CLEANUP(cleanUpSmallDictFreeG); initiateSmallDict(&name) +cleanFinishSmallDictP(name) smallDictt *name CLEANUP(cleanUpSmallDictFinishG) +cleanDisposeSmallDict(name) smallDictt name CLEANUP(cleanUpSmallDictDisposeG); initiateSmallDict(&name) +cleanSmashSmallDictP(name) smallDictt *name CLEANUP(cleanUpSmallDictSmashG) forEachSmallDict(smallDict, key, value) forEachTypeSmallDict(type, smallDict, key, value) @@ -17253,6 +17256,9 @@ createSmallArray(obj) ;smallArrayt obj; initiateSmallArray(&obj) createAllocateSmallArray(obj) ;smallArrayt *obj; initiateAllocateSmallArray(&obj) cleanSmallArrayP(name) smallArrayt *name CLEANUP(cleanUpSmallArrayTerminateG) cleanSmallArray(name) smallArrayt name CLEANUP(cleanUpSmallArrayFreeG); initiateSmallArray(&name) +cleanFinishSmallArrayP(name) smallArrayt *name CLEANUP(cleanUpSmallArrayFinishG) +cleanDisposeSmallArray(name) smallArrayt name CLEANUP(cleanUpSmallArrayDisposeG); initiateSmallArray(&name) +cleanSmashSmallArrayP(name) smallArrayt *name CLEANUP(cleanUpSmallArraySmashG) createSA(...) createSAF("", __VA_ARGS__, NULL) forEachSmallArray(array, element) forEachTypeSmallArray(type, array, element) @@ -17276,6 +17282,9 @@ createAllocateSmallJson(obj) ;smallJsont *obj; initiateAllocateSmallJson(&obj) createSJ(...) createSJF("", __VA_ARGS__, NULL) cleanSmallJsonP(name) smallJsont *name CLEANUP(cleanUpSmallJsonTerminateG) cleanSmallJson(name) smallJsont name CLEANUP(cleanUpSmallJsonFreeG); initiateSmallJson(&name) +cleanFinishSmallJsonP(name) smallJsont *name CLEANUP(cleanUpSmallJsonFinishG) +cleanDisposeSmallJson(name) smallJsont name CLEANUP(cleanUpSmallJsonDisposeG); initiateSmallJson(&name) +cleanSmashSmallJsonP(name) smallJsont *name CLEANUP(cleanUpSmallJsonSmashG) forEachSmallJson(array, element) forEachDictSmallJson(smallJson, key, value) enumerateSmallJson(array, element, index) @@ -17290,6 +17299,7 @@ createSmallBytes(obj) ;smallBytest obj; initiateSmallBytes(&obj) createAllocateSmallBytes(obj) ;smallBytest *obj; initiateAllocateSmallBytes(&obj) cleanSmallBytesP(name) smallBytest *name CLEANUP(cleanUpSmallBytesTerminateG) cleanSmallBytes(name) smallBytest name CLEANUP(cleanUpSmallBytesFreeG); initiateSmallBytes(&name) +cleanFinishSmallBytesP(name) smallBytest *name CLEANUP(cleanUpSmallBytesFinishG) Class SmallBool @@ -17301,6 +17311,7 @@ createSmallBool(obj) ;smallBoolt obj; initiateSmallBool(&obj) createAllocateSmallBool(obj) ;smallBoolt *obj; initiateAllocateSmallBool(&obj) cleanSmallBoolP(name) smallBoolt *name CLEANUP(cleanUpSmallBoolTerminateG) cleanSmallBool(name) smallBoolt name CLEANUP(cleanUpSmallBoolFreeG); initiateSmallBool(&name) +cleanFinishSmallBoolP(name) smallBoolt *name CLEANUP(cleanUpSmallBoolFinishG) Class SmallContainer @@ -17312,6 +17323,7 @@ createSmallContainer(obj) ;smallContainert obj; initiateSmallContainer(&obj) createAllocateSmallContainer(obj) ;smallContainert *obj; initiateAllocateSmallContainer(&obj) cleanSmallContainerP(name) smallContainert *name CLEANUP(cleanUpSmallContainerTerminateG) cleanSmallContainer(name) smallContainert name CLEANUP(cleanUpSmallContainerFreeG); initiateSmallContainer(&name) +cleanFinishSmallContainerP(name) smallContainert *name CLEANUP(cleanUpSmallContainerFinishG) Class SmallDouble @@ -17323,6 +17335,7 @@ createSmallDouble(obj) ;smallDoublet obj; initiateSmallDouble(&obj) createAllocateSmallDouble(obj) ;smallDoublet *obj; initiateAllocateSmallDouble(&obj) cleanSmallDoubleP(name) smallDoublet *name CLEANUP(cleanUpSmallDoubleTerminateG) cleanSmallDouble(name) smallDoublet name CLEANUP(cleanUpSmallDoubleFreeG); initiateSmallDouble(&name) +cleanFinishSmallDoubleP(name) smallDoublet *name CLEANUP(cleanUpSmallDoubleFinishG) Class SmallInt @@ -17334,6 +17347,7 @@ createSmallInt(obj) ;smallIntt obj; initiateSmallInt(&obj) createAllocateSmallInt(obj) ;smallIntt *obj; initiateAllocateSmallInt(&obj) cleanSmallIntP(name) smallIntt *name CLEANUP(cleanUpSmallIntTerminateG) cleanSmallInt(name) smallIntt name CLEANUP(cleanUpSmallIntFreeG); initiateSmallInt(&name) +cleanFinishSmallIntP(name) smallIntt *name CLEANUP(cleanUpSmallIntFinishG) Class SmallString @@ -17345,6 +17359,7 @@ createSmallString(obj) ;smallStringt obj; initiateSmallString(&obj) createAllocateSmallString(obj) ;smallStringt *obj; initiateAllocateSmallString(&obj) cleanSmallStringP(name) smallStringt *name CLEANUP(cleanUpSmallStringTerminateG) cleanSmallString(name) smallStringt name CLEANUP(cleanUpSmallStringFreeG); initiateSmallString(&name) +cleanFinishSmallStringP(name) smallStringt *name CLEANUP(cleanUpSmallStringFinishG) createS(...) createSF("", __VA_ARGS__, NULL) ``` diff --git a/release/json/libsheepyCSmallArray.h b/release/json/libsheepyCSmallArray.h @@ -1843,9 +1843,19 @@ smallArrayt* allocCArraySmallArray(const char **array); // terminate smallArrayt val when it is out of scope void cleanUpSmallArrayTerminateG(smallArrayt **val); + // free smallArrayt val when it is out of scope void cleanUpSmallArrayFreeG(smallArrayt *val); +// finish smallArrayt val when it is out of scope +void cleanUpSmallArrayFinishG(smallArrayt *val); + +// dispose smallArrayt val when it is out of scope +void cleanUpSmallArrayDisposeG(smallArrayt *val); + +// smash smallArrayt val when it is out of scope +void cleanUpSmallArraySmashG(smallArrayt *val); + /** * declare pointer name with type smallArrayt and terminate name when it is out of scope */ @@ -1857,6 +1867,21 @@ void cleanUpSmallArrayFreeG(smallArrayt *val); #define cleanSmallArray(name) smallArrayt name CLEANUP(cleanUpSmallArrayFreeG); initiateSmallArray(&name) /** + * declare pointer name with Type smallArrayt and finish name when it is out of scope + */ +#define cleanFinishSmallArrayP(name) smallArrayt *name CLEANUP(cleanUpSmallArrayFinishG) + +/** + * declare local object name with Type smallArrayt and dispose name when it is out of scope + */ +#define cleanDisposeSmallArray(name) smallArrayt name CLEANUP(cleanUpSmallArrayDisposeG); initiateSmallArray(&name) + +/** + * declare pointer name with Type smallArrayt and smash name when it is out of scope + */ +#define cleanSmashSmallArrayP(name) smallArrayt *name CLEANUP(cleanUpSmallArraySmashG) + +/** * create String Array Function * * create a smallArray for list of strings diff --git a/release/json/libsheepyCSmallBool.h b/release/json/libsheepyCSmallBool.h @@ -250,6 +250,9 @@ void cleanUpSmallBoolTerminateG(smallBoolt **val); // free smallBoolt val when it is out of scope void cleanUpSmallBoolFreeG(smallBoolt *val); +// finish smallBoolt val when it is out of scope +void cleanUpSmallBoolFinishG(smallBoolt *val); + /** * declare pointer name with type smallBoolt and terminate name when it is out of scope */ @@ -260,6 +263,11 @@ void cleanUpSmallBoolFreeG(smallBoolt *val); */ #define cleanSmallBool(name) smallBoolt name CLEANUP(cleanUpSmallBoolFreeG); initiateSmallBool(&name) +/** + * declare pointer name with Type smallBoolt and finish name when it is out of scope + */ +#define cleanFinishSmallBoolP(name) smallBoolt *name CLEANUP(cleanUpSmallBoolFinishG) + smallBoolt* duplicateSmallBoolG (smallBoolt *self); void freeSmallBoolG (smallBoolt *self); diff --git a/release/json/libsheepyCSmallBytes.h b/release/json/libsheepyCSmallBytes.h @@ -253,6 +253,9 @@ void cleanUpSmallBytesTerminateG(smallBytest **val); // free smallBytest val when it is out of scope void cleanUpSmallBytesFreeG(smallBytest *val); +// finish smallBytest val when it is out of scope +void cleanUpSmallBytesFinishG(smallBytest *val); + /** * declare pointer name with type smallBytest and terminate name when it is out of scope */ @@ -263,6 +266,11 @@ void cleanUpSmallBytesFreeG(smallBytest *val); */ #define cleanSmallBytes(name) smallBytest name CLEANUP(cleanUpSmallBytesFreeG); initiateSmallBytes(&name) +/** + * declare pointer name with Type smallBytest and finish name when it is out of scope + */ +#define cleanFinishSmallBytesP(name) smallBytest *name CLEANUP(cleanUpSmallBytesFinishG) + smallBytest* duplicateSmallBytesG (smallBytest *self); void freeSmallBytesG (smallBytest *self); diff --git a/release/json/libsheepyCSmallContainer.h b/release/json/libsheepyCSmallContainer.h @@ -220,6 +220,9 @@ void cleanUpSmallContainerTerminateG(smallContainert **val); // free smallContainert val when it is out of scope void cleanUpSmallContainerFreeG(smallContainert *val); +// finish smallContainert val when it is out of scope +void cleanUpSmallContainerFinishG(smallContainert *val); + /** * declare pointer name with type smallContainert and terminate name when it is out of scope */ @@ -230,6 +233,11 @@ void cleanUpSmallContainerFreeG(smallContainert *val); */ #define cleanSmallContainer(name) smallContainert name CLEANUP(cleanUpSmallContainerFreeG); initiateSmallContainer(&name) +/** + * declare pointer name with Type smallContainert and finish name when it is out of scope + */ +#define cleanFinishSmallContainerP(name) smallContainert *name CLEANUP(cleanUpSmallContainerFinishG) + smallContainert* duplicateSmallContainerG (smallContainert *self); void freeSmallContainerG(smallContainert *self); diff --git a/release/json/libsheepyCSmallDict.h b/release/json/libsheepyCSmallDict.h @@ -1048,9 +1048,19 @@ smallDictt* allocSmallDict(void); // terminate smallDictt val when it is out of scope void cleanUpSmallDictTerminateG(smallDictt **val); + // free smallDictt val when it is out of scope void cleanUpSmallDictFreeG(smallDictt *val); +// finish smallDictt val when it is out of scope +void cleanUpSmallDictFinishG(smallDictt *val); + +// dispose smallDictt val when it is out of scope +void cleanUpSmallDictDisposeG(smallDictt *val); + +// smash smallDictt val when it is out of scope +void cleanUpSmallDictSmashG(smallDictt *val); + /** * declare pointer name with type smallDictt and terminate name when it is out of scope */ @@ -1062,6 +1072,21 @@ void cleanUpSmallDictFreeG(smallDictt *val); #define cleanSmallDict(name) smallDictt name CLEANUP(cleanUpSmallDictFreeG); initiateSmallDict(&name) /** + * declare pointer name with Type smallDictt and finish name when it is out of scope + */ +#define cleanFinishSmallDictP(name) smallDictt *name CLEANUP(cleanUpSmallDictFinishG) + +/** + * declare local object name with Type smallDictt and dispose name when it is out of scope + */ +#define cleanDisposeSmallDict(name) smallDictt name CLEANUP(cleanUpSmallDictDisposeG); initiateSmallDict(&name) + +/** + * declare pointer name with Type smallDictt and smash name when it is out of scope + */ +#define cleanSmashSmallDictP(name) smallDictt *name CLEANUP(cleanUpSmallDictSmashG) + +/** * forEach - loop macro on smallDict keys */ #define forEachSmallDict(smallDict, key, value) \ diff --git a/release/json/libsheepyCSmallDouble.h b/release/json/libsheepyCSmallDouble.h @@ -248,6 +248,9 @@ void cleanUpSmallDoubleTerminateG(smallDoublet **val); // free smallDoublet val when it is out of scope void cleanUpSmallDoubleFreeG(smallDoublet *val); +// finish smallDoublet val when it is out of scope +void cleanUpSmallDoubleFinishG(smallDoublet *val); + /** * declare pointer name with type smallDoublet and terminate name when it is out of scope */ @@ -258,6 +261,11 @@ void cleanUpSmallDoubleFreeG(smallDoublet *val); */ #define cleanSmallDouble(name) smallDoublet name CLEANUP(cleanUpSmallDoubleFreeG); initiateSmallDouble(&name) +/** + * declare pointer name with Type smallDoublet and finish name when it is out of scope + */ +#define cleanFinishSmallDoubleP(name) smallDoublet *name CLEANUP(cleanUpSmallDoubleFinishG) + smallDoublet* duplicateSmallDoubleG (smallDoublet *self); void freeSmallDoubleG (smallDoublet *self); diff --git a/release/json/libsheepyCSmallInt.h b/release/json/libsheepyCSmallInt.h @@ -250,6 +250,9 @@ void cleanUpSmallIntTerminateG(smallIntt **val); // free smallIntt val when it is out of scope void cleanUpSmallIntFreeG(smallIntt *val); +// finish smallIntt val when it is out of scope +void cleanUpSmallIntFinishG(smallIntt *val); + /** * declare pointer name with type smallIntt and terminate name when it is out of scope */ @@ -260,6 +263,11 @@ void cleanUpSmallIntFreeG(smallIntt *val); */ #define cleanSmallInt(name) smallIntt name CLEANUP(cleanUpSmallIntFreeG); initiateSmallInt(&name) +/** + * declare pointer name with Type smallIntt and finish name when it is out of scope + */ +#define cleanFinishSmallIntP(name) smallIntt *name CLEANUP(cleanUpSmallIntFinishG) + smallIntt* duplicateSmallIntG (smallIntt *self); void freeSmallIntG (smallIntt *self); diff --git a/release/json/libsheepyCSmallJson.h b/release/json/libsheepyCSmallJson.h @@ -3432,6 +3432,15 @@ void cleanUpSmallJsonTerminateG(smallJsont **val); // free smallJsont val when it is out of scope void cleanUpSmallJsonFreeG(smallJsont *val); +// finish smallJsont val when it is out of scope +void cleanUpSmallJsonFinishG(smallJsont *val); + +// dispose smallJsont val when it is out of scope +void cleanUpSmallJsonDisposeG(smallJsont *val); + +// smash smallJsont val when it is out of scope +void cleanUpSmallJsonSmashG(smallJsont *val); + /** * declare pointer name with type smallJsont and terminate name when it is out of scope */ @@ -3442,6 +3451,21 @@ void cleanUpSmallJsonFreeG(smallJsont *val); */ #define cleanSmallJson(name) smallJsont name CLEANUP(cleanUpSmallJsonFreeG); initiateSmallJson(&name) +/** + * declare pointer name with Type smallJsont and finish name when it is out of scope + */ +#define cleanFinishSmallJsonP(name) smallJsont *name CLEANUP(cleanUpSmallJsonFinishG) + +/** + * declare local object name with Type smallJsont and dispose name when it is out of scope + */ +#define cleanDisposeSmallJson(name) smallJsont name CLEANUP(cleanUpSmallJsonDisposeG); initiateSmallJson(&name) + +/** + * declare pointer name with Type smallJsont and smash name when it is out of scope + */ +#define cleanSmashSmallJsonP(name) smallJsont *name CLEANUP(cleanUpSmallJsonSmashG) + smallJsont* duplicateSmallJsonG (smallJsont *self); void freeSmallJsonG (smallJsont *self); diff --git a/release/json/libsheepyCSmallString.h b/release/json/libsheepyCSmallString.h @@ -1288,6 +1288,9 @@ void cleanUpSmallStringTerminateG(smallStringt **val); // free smallStringt val when it is out of scope void cleanUpSmallStringFreeG(smallStringt *val); +// finish smallStringt val when it is out of scope +void cleanUpSmallStringFinishG(smallStringt *val); + /** * declare pointer name with type smallStringt and terminate name when it is out of scope */ @@ -1299,6 +1302,11 @@ void cleanUpSmallStringFreeG(smallStringt *val); #define cleanSmallString(name) smallStringt name CLEANUP(cleanUpSmallStringFreeG); initiateSmallString(&name) /** + * declare pointer name with Type smallStringt and finish name when it is out of scope + */ +#define cleanFinishSmallStringP(name) smallStringt *name CLEANUP(cleanUpSmallStringFinishG) + +/** * create String: f("qwd ", str," werr ", str2) * like catS, concatenate strings to a new smallString */ diff --git a/release/json/libsheepyCUndefined.h b/release/json/libsheepyCUndefined.h @@ -77,6 +77,12 @@ void cleanUpUndefinedTerminateG(undefinedt **val); // free undefinedt val when it is out of scope void cleanUpUndefinedFreeG(undefinedt *val); +// finish undefinedt val when it is out of scope +void cleanUpUndefinedFinishG(undefinedt *val); + +// smash undefinedt val when it is out of scope +void cleanUpUndefinedSmashG(undefinedt *val); + /** * declare pointer name with type undefinedt and terminate name when it is out of scope */ @@ -87,6 +93,16 @@ void cleanUpUndefinedFreeG(undefinedt *val); */ #define cleanUndefined(name) undefinedt name CLEANUP(cleanUpUndefinedFreeG); initiateUndefined(&name) +/** + * declare pointer name with Type undefinedt and finish name when it is out of scope + */ +#define cleanFinishUndefinedP(name) undefinedt *name CLEANUP(cleanUpUndefinedFinishG) + +/** + * declare pointer name with Type undefinedt and smash name when it is out of scope + */ +#define cleanSmashUndefinedP(name) undefinedt *name CLEANUP(cleanUpUndefinedSmashG) + undefinedt* duplicateUndefinedG (undefinedt *self); diff --git a/src/json/libsheepyCSmallArray.c b/src/json/libsheepyCSmallArray.c @@ -42,6 +42,9 @@ smallArrayt* allocArraySmallArray(char **array); smallArrayt* allocCArraySmallArray(const char **array); void cleanUpSmallArrayTerminateG(smallArrayt **val); void cleanUpSmallArrayFreeG(smallArrayt *val); +void cleanUpSmallArrayFinishG(smallArrayt *val); +void cleanUpSmallArrayDisposeG(smallArrayt *val); +void cleanUpSmallArraySmashG(smallArrayt *val); smallArrayt* createSAF(const char *paramType, ...); void finalizeRecycleSmallArray(void *arg UNUSED); void finalizeSmallArray(void); @@ -1397,12 +1400,27 @@ smallArrayt* allocCArraySmallArray(const char **array) { void cleanUpSmallArrayTerminateG(smallArrayt **val) { - terminateG(*val); + terminateO(*val); } void cleanUpSmallArrayFreeG(smallArrayt *val) { - freeG(val); + freeO(val); +} + +void cleanUpSmallArrayFinishG(smallArrayt *val) { + + finishO(val); +} + +void cleanUpSmallArrayDisposeG(smallArrayt *val) { + + disposeO(val); +} + +void cleanUpSmallArraySmashG(smallArrayt *val) { + + smashO(val); } smallArrayt* createSAF(const char *paramType, ...) { diff --git a/src/json/libsheepyCSmallArray.h b/src/json/libsheepyCSmallArray.h @@ -1843,9 +1843,19 @@ smallArrayt* allocCArraySmallArray(const char **array); // terminate smallArrayt val when it is out of scope void cleanUpSmallArrayTerminateG(smallArrayt **val); + // free smallArrayt val when it is out of scope void cleanUpSmallArrayFreeG(smallArrayt *val); +// finish smallArrayt val when it is out of scope +void cleanUpSmallArrayFinishG(smallArrayt *val); + +// dispose smallArrayt val when it is out of scope +void cleanUpSmallArrayDisposeG(smallArrayt *val); + +// smash smallArrayt val when it is out of scope +void cleanUpSmallArraySmashG(smallArrayt *val); + /** * declare pointer name with type smallArrayt and terminate name when it is out of scope */ @@ -1857,6 +1867,21 @@ void cleanUpSmallArrayFreeG(smallArrayt *val); #define cleanSmallArray(name) smallArrayt name CLEANUP(cleanUpSmallArrayFreeG); initiateSmallArray(&name) /** + * declare pointer name with Type smallArrayt and finish name when it is out of scope + */ +#define cleanFinishSmallArrayP(name) smallArrayt *name CLEANUP(cleanUpSmallArrayFinishG) + +/** + * declare local object name with Type smallArrayt and dispose name when it is out of scope + */ +#define cleanDisposeSmallArray(name) smallArrayt name CLEANUP(cleanUpSmallArrayDisposeG); initiateSmallArray(&name) + +/** + * declare pointer name with Type smallArrayt and smash name when it is out of scope + */ +#define cleanSmashSmallArrayP(name) smallArrayt *name CLEANUP(cleanUpSmallArraySmashG) + +/** * create String Array Function * * create a smallArray for list of strings diff --git a/src/json/libsheepyCSmallBool.c b/src/json/libsheepyCSmallBool.c @@ -40,6 +40,7 @@ void finalizeSmallBool(void); smallBoolt* allocSmallBool(bool value); void cleanUpSmallBoolTerminateG(smallBoolt **val); void cleanUpSmallBoolFreeG(smallBoolt *val); +void cleanUpSmallBoolFinishG(smallBoolt *val); internal void freeSmallBool(smallBoolt *self); internal void terminateSmallBool(smallBoolt **self); internal char* toStringSmallBool(smallBoolt *self); @@ -234,12 +235,17 @@ smallBoolt* allocSmallBool(bool value) { void cleanUpSmallBoolTerminateG(smallBoolt **val) { - terminateG(*val); + terminateO(*val); } void cleanUpSmallBoolFreeG(smallBoolt *val) { - freeG(val); + freeO(val); +} + +void cleanUpSmallBoolFinishG(smallBoolt *val) { + + finishO(val); } internal void freeSmallBool(smallBoolt *self) { diff --git a/src/json/libsheepyCSmallBool.h b/src/json/libsheepyCSmallBool.h @@ -250,6 +250,9 @@ void cleanUpSmallBoolTerminateG(smallBoolt **val); // free smallBoolt val when it is out of scope void cleanUpSmallBoolFreeG(smallBoolt *val); +// finish smallBoolt val when it is out of scope +void cleanUpSmallBoolFinishG(smallBoolt *val); + /** * declare pointer name with type smallBoolt and terminate name when it is out of scope */ @@ -260,6 +263,11 @@ void cleanUpSmallBoolFreeG(smallBoolt *val); */ #define cleanSmallBool(name) smallBoolt name CLEANUP(cleanUpSmallBoolFreeG); initiateSmallBool(&name) +/** + * declare pointer name with Type smallBoolt and finish name when it is out of scope + */ +#define cleanFinishSmallBoolP(name) smallBoolt *name CLEANUP(cleanUpSmallBoolFinishG) + smallBoolt* duplicateSmallBoolG (smallBoolt *self); void freeSmallBoolG (smallBoolt *self); diff --git a/src/json/libsheepyCSmallBytes.c b/src/json/libsheepyCSmallBytes.c @@ -40,6 +40,7 @@ void finalizeSmallBytes(void); smallBytest* allocSmallBytes(void *data, uint32_t size); void cleanUpSmallBytesTerminateG(smallBytest **val); void cleanUpSmallBytesFreeG(smallBytest *val); +void cleanUpSmallBytesFinishG(smallBytest *val); internal void freeSmallBytes(smallBytest *self); internal void terminateSmallBytes(smallBytest **self); #if (NFreeStackCheck) @@ -200,14 +201,20 @@ smallBytest* allocSmallBytes(void *data, uint32_t size) { void cleanUpSmallBytesTerminateG(smallBytest **val) { - terminateG(*val); + terminateO(*val); } void cleanUpSmallBytesFreeG(smallBytest *val) { - freeG(val); + freeO(val); } +void cleanUpSmallBytesFinishG(smallBytest *val) { + + finishO(val); +} + + internal void freeSmallBytes(smallBytest *self) { diff --git a/src/json/libsheepyCSmallBytes.h b/src/json/libsheepyCSmallBytes.h @@ -253,6 +253,9 @@ void cleanUpSmallBytesTerminateG(smallBytest **val); // free smallBytest val when it is out of scope void cleanUpSmallBytesFreeG(smallBytest *val); +// finish smallBytest val when it is out of scope +void cleanUpSmallBytesFinishG(smallBytest *val); + /** * declare pointer name with type smallBytest and terminate name when it is out of scope */ @@ -263,6 +266,11 @@ void cleanUpSmallBytesFreeG(smallBytest *val); */ #define cleanSmallBytes(name) smallBytest name CLEANUP(cleanUpSmallBytesFreeG); initiateSmallBytes(&name) +/** + * declare pointer name with Type smallBytest and finish name when it is out of scope + */ +#define cleanFinishSmallBytesP(name) smallBytest *name CLEANUP(cleanUpSmallBytesFinishG) + smallBytest* duplicateSmallBytesG (smallBytest *self); void freeSmallBytesG (smallBytest *self); diff --git a/src/json/libsheepyCSmallContainer.c b/src/json/libsheepyCSmallContainer.c @@ -38,6 +38,7 @@ void finalizeSmallContainer(void); smallContainert* allocSmallContainer(void *data); void cleanUpSmallContainerTerminateG(smallContainert **val); void cleanUpSmallContainerFreeG(smallContainert *val); +void cleanUpSmallContainerFinishG(smallContainert *val); internal void freeSmallContainer(smallContainert *self); internal void terminateSmallContainer(smallContainert **self); #if (NFreeStackCheck) @@ -139,12 +140,17 @@ smallContainert* allocSmallContainer(void *data) { void cleanUpSmallContainerTerminateG(smallContainert **val) { - terminateG(*val); + terminateO(*val); } void cleanUpSmallContainerFreeG(smallContainert *val) { - freeG(val); + freeO(val); +} + +void cleanUpSmallContainerFinishG(smallContainert *val) { + + finishO(val); } internal void freeSmallContainer(smallContainert *self) { diff --git a/src/json/libsheepyCSmallContainer.h b/src/json/libsheepyCSmallContainer.h @@ -220,6 +220,9 @@ void cleanUpSmallContainerTerminateG(smallContainert **val); // free smallContainert val when it is out of scope void cleanUpSmallContainerFreeG(smallContainert *val); +// finish smallContainert val when it is out of scope +void cleanUpSmallContainerFinishG(smallContainert *val); + /** * declare pointer name with type smallContainert and terminate name when it is out of scope */ @@ -230,6 +233,11 @@ void cleanUpSmallContainerFreeG(smallContainert *val); */ #define cleanSmallContainer(name) smallContainert name CLEANUP(cleanUpSmallContainerFreeG); initiateSmallContainer(&name) +/** + * declare pointer name with Type smallContainert and finish name when it is out of scope + */ +#define cleanFinishSmallContainerP(name) smallContainert *name CLEANUP(cleanUpSmallContainerFinishG) + smallContainert* duplicateSmallContainerG (smallContainert *self); void freeSmallContainerG(smallContainert *self); diff --git a/src/json/libsheepyCSmallDict.c b/src/json/libsheepyCSmallDict.c @@ -41,6 +41,9 @@ void finalizeSmallDict(void); smallDictt* allocSmallDict(void); void cleanUpSmallDictTerminateG(smallDictt **val); void cleanUpSmallDictFreeG(smallDictt *val); +void cleanUpSmallDictFinishG(smallDictt *val); +void cleanUpSmallDictDisposeG(smallDictt *val); +void cleanUpSmallDictSmashG(smallDictt *val); internal void freeSmallDict(smallDictt *self); internal void terminateSmallDict(smallDictt **self); internal char* toStringSmallDict(smallDictt *self); @@ -970,12 +973,27 @@ smallDictt* allocSmallDict(void) { void cleanUpSmallDictTerminateG(smallDictt **val) { - terminateG(*val); + terminateO(*val); } void cleanUpSmallDictFreeG(smallDictt *val) { - freeG(val); + freeO(val); +} + +void cleanUpSmallDictFinishG(smallDictt *val) { + + finishO(val); +} + +void cleanUpSmallDictDisposeG(smallDictt *val) { + + disposeO(val); +} + +void cleanUpSmallDictSmashG(smallDictt *val) { + + smashO(val); } internal void freeSmallDict(smallDictt *self) { diff --git a/src/json/libsheepyCSmallDict.h b/src/json/libsheepyCSmallDict.h @@ -1048,9 +1048,19 @@ smallDictt* allocSmallDict(void); // terminate smallDictt val when it is out of scope void cleanUpSmallDictTerminateG(smallDictt **val); + // free smallDictt val when it is out of scope void cleanUpSmallDictFreeG(smallDictt *val); +// finish smallDictt val when it is out of scope +void cleanUpSmallDictFinishG(smallDictt *val); + +// dispose smallDictt val when it is out of scope +void cleanUpSmallDictDisposeG(smallDictt *val); + +// smash smallDictt val when it is out of scope +void cleanUpSmallDictSmashG(smallDictt *val); + /** * declare pointer name with type smallDictt and terminate name when it is out of scope */ @@ -1062,6 +1072,21 @@ void cleanUpSmallDictFreeG(smallDictt *val); #define cleanSmallDict(name) smallDictt name CLEANUP(cleanUpSmallDictFreeG); initiateSmallDict(&name) /** + * declare pointer name with Type smallDictt and finish name when it is out of scope + */ +#define cleanFinishSmallDictP(name) smallDictt *name CLEANUP(cleanUpSmallDictFinishG) + +/** + * declare local object name with Type smallDictt and dispose name when it is out of scope + */ +#define cleanDisposeSmallDict(name) smallDictt name CLEANUP(cleanUpSmallDictDisposeG); initiateSmallDict(&name) + +/** + * declare pointer name with Type smallDictt and smash name when it is out of scope + */ +#define cleanSmashSmallDictP(name) smallDictt *name CLEANUP(cleanUpSmallDictSmashG) + +/** * forEach - loop macro on smallDict keys */ #define forEachSmallDict(smallDict, key, value) \ diff --git a/src/json/libsheepyCSmallDouble.c b/src/json/libsheepyCSmallDouble.c @@ -39,6 +39,7 @@ void finalizeSmallDouble(void); smallDoublet* allocSmallDouble(double value); void cleanUpSmallDoubleTerminateG(smallDoublet **val); void cleanUpSmallDoubleFreeG(smallDoublet *val); +void cleanUpSmallDoubleFinishG(smallDoublet *val); internal void freeSmallDouble(smallDoublet *self); internal void terminateSmallDouble(smallDoublet **self); internal char* toStringSmallDouble(smallDoublet *self); @@ -233,12 +234,17 @@ smallDoublet* allocSmallDouble(double value) { void cleanUpSmallDoubleTerminateG(smallDoublet **val) { - terminateG(*val); + terminateO(*val); } void cleanUpSmallDoubleFreeG(smallDoublet *val) { - freeG(val); + freeO(val); +} + +void cleanUpSmallDoubleFinishG(smallDoublet *val) { + + finishO(val); } internal void freeSmallDouble(smallDoublet *self) { diff --git a/src/json/libsheepyCSmallDouble.h b/src/json/libsheepyCSmallDouble.h @@ -248,6 +248,9 @@ void cleanUpSmallDoubleTerminateG(smallDoublet **val); // free smallDoublet val when it is out of scope void cleanUpSmallDoubleFreeG(smallDoublet *val); +// finish smallDoublet val when it is out of scope +void cleanUpSmallDoubleFinishG(smallDoublet *val); + /** * declare pointer name with type smallDoublet and terminate name when it is out of scope */ @@ -258,6 +261,11 @@ void cleanUpSmallDoubleFreeG(smallDoublet *val); */ #define cleanSmallDouble(name) smallDoublet name CLEANUP(cleanUpSmallDoubleFreeG); initiateSmallDouble(&name) +/** + * declare pointer name with Type smallDoublet and finish name when it is out of scope + */ +#define cleanFinishSmallDoubleP(name) smallDoublet *name CLEANUP(cleanUpSmallDoubleFinishG) + smallDoublet* duplicateSmallDoubleG (smallDoublet *self); void freeSmallDoubleG (smallDoublet *self); diff --git a/src/json/libsheepyCSmallInt.c b/src/json/libsheepyCSmallInt.c @@ -40,6 +40,7 @@ void finalizeSmallInt(void); smallIntt* allocSmallInt(int64_t value); void cleanUpSmallIntTerminateG(smallIntt **val); void cleanUpSmallIntFreeG(smallIntt *val); +void cleanUpSmallIntFinishG(smallIntt *val); internal void freeSmallInt(smallIntt *self); internal void terminateSmallInt(smallIntt **self); internal char* toStringSmallInt(smallIntt *self); @@ -239,12 +240,17 @@ smallIntt* allocSmallInt(int64_t value) { void cleanUpSmallIntTerminateG(smallIntt **val) { - terminateG(*val); + terminateO(*val); } void cleanUpSmallIntFreeG(smallIntt *val) { - freeG(val); + freeO(val); +} + +void cleanUpSmallIntFinishG(smallIntt *val) { + + finishO(val); } internal void freeSmallInt(smallIntt *self) { diff --git a/src/json/libsheepyCSmallInt.h b/src/json/libsheepyCSmallInt.h @@ -250,6 +250,9 @@ void cleanUpSmallIntTerminateG(smallIntt **val); // free smallIntt val when it is out of scope void cleanUpSmallIntFreeG(smallIntt *val); +// finish smallIntt val when it is out of scope +void cleanUpSmallIntFinishG(smallIntt *val); + /** * declare pointer name with type smallIntt and terminate name when it is out of scope */ @@ -260,6 +263,11 @@ void cleanUpSmallIntFreeG(smallIntt *val); */ #define cleanSmallInt(name) smallIntt name CLEANUP(cleanUpSmallIntFreeG); initiateSmallInt(&name) +/** + * declare pointer name with Type smallIntt and finish name when it is out of scope + */ +#define cleanFinishSmallIntP(name) smallIntt *name CLEANUP(cleanUpSmallIntFinishG) + smallIntt* duplicateSmallIntG (smallIntt *self); void freeSmallIntG (smallIntt *self); diff --git a/src/json/libsheepyCSmallJson.c b/src/json/libsheepyCSmallJson.c @@ -49,6 +49,9 @@ void finalizeSmallJson(void); smallJsont* allocSmallJson(void); void cleanUpSmallJsonTerminateG(smallJsont **val); void cleanUpSmallJsonFreeG(smallJsont *val); +void cleanUpSmallJsonFinishG(smallJsont *val); +void cleanUpSmallJsonDisposeG(smallJsont *val); +void cleanUpSmallJsonSmashG(smallJsont *val); internal void freeSmallJson(smallJsont *self); internal void terminateSmallJson(smallJsont **self); internal char* toStringSmallJson(smallJsont *self); @@ -2597,13 +2600,28 @@ smallJsont* allocSmallJson(void) { void cleanUpSmallJsonTerminateG(smallJsont **val) { - terminateG(*val); + terminateO(*val); } void cleanUpSmallJsonFreeG(smallJsont *val) { - freeG(val); + freeO(val); +} + +void cleanUpSmallJsonFinishG(smallJsont *val) { + + finishO(val); +} + +void cleanUpSmallJsonDisposeG(smallJsont *val) { + + disposeO(val); +} + +void cleanUpSmallJsonSmashG(smallJsont *val) { + + smashO(val); } diff --git a/src/json/libsheepyCSmallJson.h b/src/json/libsheepyCSmallJson.h @@ -3432,6 +3432,15 @@ void cleanUpSmallJsonTerminateG(smallJsont **val); // free smallJsont val when it is out of scope void cleanUpSmallJsonFreeG(smallJsont *val); +// finish smallJsont val when it is out of scope +void cleanUpSmallJsonFinishG(smallJsont *val); + +// dispose smallJsont val when it is out of scope +void cleanUpSmallJsonDisposeG(smallJsont *val); + +// smash smallJsont val when it is out of scope +void cleanUpSmallJsonSmashG(smallJsont *val); + /** * declare pointer name with type smallJsont and terminate name when it is out of scope */ @@ -3442,6 +3451,21 @@ void cleanUpSmallJsonFreeG(smallJsont *val); */ #define cleanSmallJson(name) smallJsont name CLEANUP(cleanUpSmallJsonFreeG); initiateSmallJson(&name) +/** + * declare pointer name with Type smallJsont and finish name when it is out of scope + */ +#define cleanFinishSmallJsonP(name) smallJsont *name CLEANUP(cleanUpSmallJsonFinishG) + +/** + * declare local object name with Type smallJsont and dispose name when it is out of scope + */ +#define cleanDisposeSmallJson(name) smallJsont name CLEANUP(cleanUpSmallJsonDisposeG); initiateSmallJson(&name) + +/** + * declare pointer name with Type smallJsont and smash name when it is out of scope + */ +#define cleanSmashSmallJsonP(name) smallJsont *name CLEANUP(cleanUpSmallJsonSmashG) + smallJsont* duplicateSmallJsonG (smallJsont *self); void freeSmallJsonG (smallJsont *self); diff --git a/src/json/libsheepyCSmallString.c b/src/json/libsheepyCSmallString.c @@ -43,6 +43,7 @@ void finalizeSmallString(void); smallStringt* allocSmallString(const char *string); void cleanUpSmallStringTerminateG(smallStringt **val); void cleanUpSmallStringFreeG(smallStringt *val); +void cleanUpSmallStringFinishG(smallStringt *val); smallStringt* createSF(const char *paramType, ...); internal void freeSmallString(smallStringt *self); internal void terminateSmallString(smallStringt **self); @@ -824,12 +825,17 @@ smallStringt* allocSmallString(const char *string) { void cleanUpSmallStringTerminateG(smallStringt **val) { - terminateG(*val); + terminateO(*val); } void cleanUpSmallStringFreeG(smallStringt *val) { - freeG(val); + freeO(val); +} + +void cleanUpSmallStringFinishG(smallStringt *val) { + + finishO(val); } smallStringt* createSF(const char *paramType, ...) { diff --git a/src/json/libsheepyCSmallString.h b/src/json/libsheepyCSmallString.h @@ -1288,6 +1288,9 @@ void cleanUpSmallStringTerminateG(smallStringt **val); // free smallStringt val when it is out of scope void cleanUpSmallStringFreeG(smallStringt *val); +// finish smallStringt val when it is out of scope +void cleanUpSmallStringFinishG(smallStringt *val); + /** * declare pointer name with type smallStringt and terminate name when it is out of scope */ @@ -1299,6 +1302,11 @@ void cleanUpSmallStringFreeG(smallStringt *val); #define cleanSmallString(name) smallStringt name CLEANUP(cleanUpSmallStringFreeG); initiateSmallString(&name) /** + * declare pointer name with Type smallStringt and finish name when it is out of scope + */ +#define cleanFinishSmallStringP(name) smallStringt *name CLEANUP(cleanUpSmallStringFinishG) + +/** * create String: f("qwd ", str," werr ", str2) * like catS, concatenate strings to a new smallString */ diff --git a/src/json/libsheepyCUndefined.c b/src/json/libsheepyCUndefined.c @@ -37,6 +37,8 @@ void finalizeUndefined(void); undefinedt* allocUndefined(void); void cleanUpUndefinedTerminateG(undefinedt **val); void cleanUpUndefinedFreeG(undefinedt *val); +void cleanUpUndefinedFinishG(undefinedt *val); +void cleanUpUndefinedSmashG(undefinedt *val); internal void freeUndefined(undefinedt *self UNUSED); internal void terminateUndefined(undefinedt **self); internal char* toStringUndefined(undefinedt *self UNUSED); @@ -103,12 +105,22 @@ undefinedt* allocUndefined(void) { void cleanUpUndefinedTerminateG(undefinedt **val) { - terminateG(*val); + terminateO(*val); } void cleanUpUndefinedFreeG(undefinedt *val) { - freeG(val); + freeO(val); +} + +void cleanUpUndefinedFinishG(undefinedt *val) { + + finishO(val); +} + +void cleanUpUndefinedSmashG(undefinedt *val) { + + smashO(val); } internal void freeUndefined(undefinedt *self UNUSED) { diff --git a/src/json/libsheepyCUndefined.h b/src/json/libsheepyCUndefined.h @@ -77,6 +77,12 @@ void cleanUpUndefinedTerminateG(undefinedt **val); // free undefinedt val when it is out of scope void cleanUpUndefinedFreeG(undefinedt *val); +// finish undefinedt val when it is out of scope +void cleanUpUndefinedFinishG(undefinedt *val); + +// smash undefinedt val when it is out of scope +void cleanUpUndefinedSmashG(undefinedt *val); + /** * declare pointer name with type undefinedt and terminate name when it is out of scope */ @@ -87,6 +93,16 @@ void cleanUpUndefinedFreeG(undefinedt *val); */ #define cleanUndefined(name) undefinedt name CLEANUP(cleanUpUndefinedFreeG); initiateUndefined(&name) +/** + * declare pointer name with Type undefinedt and finish name when it is out of scope + */ +#define cleanFinishUndefinedP(name) undefinedt *name CLEANUP(cleanUpUndefinedFinishG) + +/** + * declare pointer name with Type undefinedt and smash name when it is out of scope + */ +#define cleanSmashUndefinedP(name) undefinedt *name CLEANUP(cleanUpUndefinedSmashG) + undefinedt* duplicateUndefinedG (undefinedt *self);