libfoundation: Add type checks to exported MCSet functions.

peter-b · peter-b · commit e096b9b5b898 · 2015-10-07T21:28:41.000+01:00
diff --git a/libfoundation/src/foundation-set.cpp b/libfoundation/src/foundation-set.cpp
@@ -31,6 +31,19 @@ bool MCSetCreateSingleton(uindex_t p_element, MCSetRef& r_set)
 
 bool MCSetCreateWithIndices(uindex_t *p_elements, uindex_t p_element_count, MCSetRef& r_set)
 {
+	if (p_element_count == 0)
+	{
+		if (nil != kMCEmptySet)
+		{
+			r_set = MCValueRetain(kMCEmptySet);
+			return true;
+		}
+	}
+	else
+	{
+		MCAssert(nil != p_elements);
+	}
+
 	MCSetRef t_set;
 	if (!MCSetCreateMutable(t_set))
 		return false;
@@ -43,6 +56,8 @@ bool MCSetCreateWithIndices(uindex_t *p_elements, uindex_t p_element_count, MCSe
 
 bool MCSetCreateWithLimbsAndRelease(uindex_t *p_limbs, uindex_t p_limb_count, MCSetRef& r_set)
 {
+	MCAssert(nil != p_limbs);
+
 	__MCSet *self;
 	if (!__MCValueCreate(kMCValueTypeCodeSet, self))
 		return false;
@@ -72,6 +87,8 @@ bool MCSetCreateMutable(MCSetRef& r_set)
 
 bool MCSetCopy(MCSetRef self, MCSetRef& r_new_set)
 {
+	__MCAssertIsSet(self);
+
 	if (!MCSetIsMutable(self))
 	{
 		r_new_set = MCValueRetain(self);
@@ -82,6 +99,8 @@ bool MCSetCopy(MCSetRef self, MCSetRef& r_new_set)
 
 bool MCSetCopyAndRelease(MCSetRef self, MCSetRef& r_new_set)
 {
+	__MCAssertIsSet(self);
+
 	if (!MCSetIsMutable(self))
 	{
 		r_new_set = self;
@@ -100,11 +119,14 @@ bool MCSetCopyAndRelease(MCSetRef self, MCSetRef& r_new_set)
 
 bool MCSetMutableCopy(MCSetRef self, MCSetRef& r_new_set)
 {
+	__MCAssertIsSet(self);
 	return __MCSetClone(self, true, r_new_set);
 }
 
 bool MCSetMutableCopyAndRelease(MCSetRef self, MCSetRef& r_new_set)
 {
+	__MCAssertIsSet(self);
+
 	if (self -> references == 1)
 	{
 		self -> flags |= kMCSetFlagIsMutable;
@@ -119,13 +141,17 @@ bool MCSetMutableCopyAndRelease(MCSetRef self, MCSetRef& r_new_set)
 
 bool MCSetIsMutable(MCSetRef self)
 {
+	__MCAssertIsSet(self);
+
 	return (self -> flags & kMCSetFlagIsMutable) != 0;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool MCSetIsEmpty(MCSetRef self)
 {
+	__MCAssertIsSet(self);
+
 	for(uindex_t i = 0; i < self -> limb_count; i++)
 		if (self -> limbs[i] != 0)
 			return false;
@@ -134,6 +160,9 @@ bool MCSetIsEmpty(MCSetRef self)
 
 bool MCSetIsEqualTo(MCSetRef self, MCSetRef other_self)
 {
+	__MCAssertIsSet(self);
+	__MCAssertIsSet(other_self);
+
 	for(uindex_t i = 0; i < MCMax(self -> limb_count, other_self -> limb_count); i++)
 	{
 		uindex_t t_left_limb, t_right_limb;
@@ -148,6 +177,9 @@ bool MCSetIsEqualTo(MCSetRef self, MCSetRef other_self)
 
 bool MCSetContains(MCSetRef self, MCSetRef other_self)
 {
+	__MCAssertIsSet(self);
+	__MCAssertIsSet(other_self);
+
 	for(uindex_t i = 0; i < MCMax(self -> limb_count, other_self -> limb_count); i++)
 	{
 		uindex_t t_left_limb, t_right_limb;
@@ -161,6 +193,9 @@ bool MCSetContains(MCSetRef self, MCSetRef other_self)
 
 bool MCSetIntersects(MCSetRef self, MCSetRef other_self)
 {
+	__MCAssertIsSet(self);
+	__MCAssertIsSet(other_self);
+
 	for(uindex_t i = 0; i < MCMax(self -> limb_count, other_self -> limb_count); i++)
 	{
 		uindex_t t_left_limb, t_right_limb;
@@ -174,6 +209,8 @@ bool MCSetIntersects(MCSetRef self, MCSetRef other_self)
 
 bool MCSetContainsIndex(MCSetRef self, uindex_t p_element)
 {
+	__MCAssertIsSet(self);
+
 	if (p_element >= self -> limb_count * 32)
 		return false;
 	return (self -> limbs[p_element / 32] & (1 << (p_element % 32))) != 0;
@@ -253,6 +290,8 @@ bool MCSetIntersect(MCSetRef self, MCSetRef p_other_set)
 
 bool MCSetIterate(MCSetRef self, uindex_t& x_iterator, uindex_t& r_element)
 {
+	__MCAssertIsSet(self);
+
 	while(x_iterator < self -> limb_count * 32)
 	{
 		x_iterator++;

Original file line number	Diff line number	Diff line change
`@@ -31,6 +31,19 @@ bool MCSetCreateSingleton(uindex_t p_element, MCSetRef& r_set)`
`31`	`31`
`32`	`32`	`bool MCSetCreateWithIndices(uindex_t *p_elements, uindex_t p_element_count, MCSetRef& r_set)`
`33`	`33`	`{`
	`34`	`+ if (p_element_count == 0)`
	`35`	`+ {`
	`36`	`+ if (nil != kMCEmptySet)`
	`37`	`+ {`
	`38`	`+ r_set = MCValueRetain(kMCEmptySet);`
	`39`	`+ return true;`
	`40`	`+ }`
	`41`	`+ }`
	`42`	`+ else`
	`43`	`+ {`
	`44`	`+ MCAssert(nil != p_elements);`
	`45`	`+ }`
	`46`	`+`
`34`	`47`	`MCSetRef t_set;`
`35`	`48`	`if (!MCSetCreateMutable(t_set))`
`36`	`49`	`return false;`
`@@ -43,6 +56,8 @@ bool MCSetCreateWithIndices(uindex_t *p_elements, uindex_t p_element_count, MCSe`
`43`	`56`
`44`	`57`	`bool MCSetCreateWithLimbsAndRelease(uindex_t *p_limbs, uindex_t p_limb_count, MCSetRef& r_set)`
`45`	`58`	`{`
	`59`	`+ MCAssert(nil != p_limbs);`
	`60`	`+`
`46`	`61`	`__MCSet *self;`
`47`	`62`	`if (!__MCValueCreate(kMCValueTypeCodeSet, self))`
`48`	`63`	`return false;`
`@@ -72,6 +87,8 @@ bool MCSetCreateMutable(MCSetRef& r_set)`
`72`	`87`
`73`	`88`	`bool MCSetCopy(MCSetRef self, MCSetRef& r_new_set)`
`74`	`89`	`{`
	`90`	`+ __MCAssertIsSet(self);`
	`91`	`+`
`75`	`92`	`if (!MCSetIsMutable(self))`
`76`	`93`	`{`
`77`	`94`	`r_new_set = MCValueRetain(self);`
`@@ -82,6 +99,8 @@ bool MCSetCopy(MCSetRef self, MCSetRef& r_new_set)`
`82`	`99`
`83`	`100`	`bool MCSetCopyAndRelease(MCSetRef self, MCSetRef& r_new_set)`
`84`	`101`	`{`
	`102`	`+ __MCAssertIsSet(self);`
	`103`	`+`
`85`	`104`	`if (!MCSetIsMutable(self))`
`86`	`105`	`{`
`87`	`106`	`r_new_set = self;`
`@@ -100,11 +119,14 @@ bool MCSetCopyAndRelease(MCSetRef self, MCSetRef& r_new_set)`
`100`	`119`
`101`	`120`	`bool MCSetMutableCopy(MCSetRef self, MCSetRef& r_new_set)`
`102`	`121`	`{`
	`122`	`+ __MCAssertIsSet(self);`
`103`	`123`	`return __MCSetClone(self, true, r_new_set);`
`104`	`124`	`}`
`105`	`125`
`106`	`126`	`bool MCSetMutableCopyAndRelease(MCSetRef self, MCSetRef& r_new_set)`
`107`	`127`	`{`
	`128`	`+ __MCAssertIsSet(self);`
	`129`	`+`
`108`	`130`	`if (self -> references == 1)`
`109`	`131`	`{`
`110`	`132`	`self -> flags \|= kMCSetFlagIsMutable;`
`@@ -119,13 +141,17 @@ bool MCSetMutableCopyAndRelease(MCSetRef self, MCSetRef& r_new_set)`
`119`	`141`
`120`	`142`	`bool MCSetIsMutable(MCSetRef self)`
`121`	`143`	`{`
	`144`	`+ __MCAssertIsSet(self);`
	`145`	`+`
`122`	`146`	`return (self -> flags & kMCSetFlagIsMutable) != 0;`
`123`	`147`	`}`
`124`	`148`
`125`	`149`	`////////////////////////////////////////////////////////////////////////////////`
`126`	`150`
`127`	`151`	`bool MCSetIsEmpty(MCSetRef self)`
`128`	`152`	`{`
	`153`	`+ __MCAssertIsSet(self);`
	`154`	`+`
`129`	`155`	`for(uindex_t i = 0; i < self -> limb_count; i++)`
`130`	`156`	`if (self -> limbs[i] != 0)`
`131`	`157`	`return false;`
`@@ -134,6 +160,9 @@ bool MCSetIsEmpty(MCSetRef self)`
`134`	`160`
`135`	`161`	`bool MCSetIsEqualTo(MCSetRef self, MCSetRef other_self)`
`136`	`162`	`{`
	`163`	`+ __MCAssertIsSet(self);`
	`164`	`+ __MCAssertIsSet(other_self);`
	`165`	`+`
`137`	`166`	`for(uindex_t i = 0; i < MCMax(self -> limb_count, other_self -> limb_count); i++)`
`138`	`167`	`{`
`139`	`168`	`uindex_t t_left_limb, t_right_limb;`
`@@ -148,6 +177,9 @@ bool MCSetIsEqualTo(MCSetRef self, MCSetRef other_self)`
`148`	`177`
`149`	`178`	`bool MCSetContains(MCSetRef self, MCSetRef other_self)`
`150`	`179`	`{`
	`180`	`+ __MCAssertIsSet(self);`
	`181`	`+ __MCAssertIsSet(other_self);`
	`182`	`+`
`151`	`183`	`for(uindex_t i = 0; i < MCMax(self -> limb_count, other_self -> limb_count); i++)`
`152`	`184`	`{`
`153`	`185`	`uindex_t t_left_limb, t_right_limb;`
`@@ -161,6 +193,9 @@ bool MCSetContains(MCSetRef self, MCSetRef other_self)`
`161`	`193`
`162`	`194`	`bool MCSetIntersects(MCSetRef self, MCSetRef other_self)`
`163`	`195`	`{`
	`196`	`+ __MCAssertIsSet(self);`
	`197`	`+ __MCAssertIsSet(other_self);`
	`198`	`+`
`164`	`199`	`for(uindex_t i = 0; i < MCMax(self -> limb_count, other_self -> limb_count); i++)`
`165`	`200`	`{`
`166`	`201`	`uindex_t t_left_limb, t_right_limb;`
`@@ -174,6 +209,8 @@ bool MCSetIntersects(MCSetRef self, MCSetRef other_self)`
`174`	`209`
`175`	`210`	`bool MCSetContainsIndex(MCSetRef self, uindex_t p_element)`
`176`	`211`	`{`
	`212`	`+ __MCAssertIsSet(self);`
	`213`	`+`
`177`	`214`	`if (p_element >= self -> limb_count * 32)`
`178`	`215`	`return false;`
`179`	`216`	`return (self -> limbs[p_element / 32] & (1 << (p_element % 32))) != 0;`
`@@ -253,6 +290,8 @@ bool MCSetIntersect(MCSetRef self, MCSetRef p_other_set)`
`253`	`290`
`254`	`291`	`bool MCSetIterate(MCSetRef self, uindex_t& x_iterator, uindex_t& r_element)`
`255`	`292`	`{`
	`293`	`+ __MCAssertIsSet(self);`
	`294`	`+`
`256`	`295`	`while(x_iterator < self -> limb_count * 32)`
`257`	`296`	`{`
`258`	`297`	`x_iterator++;`