libfoundation: Add type checks to exported MCStream functions

peter-b · peter-b · commit a1eb9d3e815a · 2015-10-07T21:28:41.000+01:00
diff --git a/libfoundation/src/foundation-private.h b/libfoundation/src/foundation-private.h
@@ -301,6 +301,12 @@ inline MCValueTypeCode __MCValueGetTypeCode(__MCValue *self)
 	return (self -> flags >> 28);
 }
 
+inline const MCValueCustomCallbacks *
+__MCValueGetCustomCallbacks(__MCValue *self)
+{
+	return reinterpret_cast<__MCCustomValue *>(self)->callbacks;
+}
+
 template<class T> inline bool __MCValueCreate(MCValueTypeCode p_type_code, T*& r_value)
 {
 	__MCValue *t_value;
diff --git a/libfoundation/src/foundation-stream.cpp b/libfoundation/src/foundation-stream.cpp
@@ -130,6 +130,8 @@ static MCStreamCallbacks kMCMemoryInputStreamCallbacks =
 
 bool MCMemoryInputStreamCreate(const void *p_block, size_t p_size, MCStreamRef& r_stream)
 {
+	MCAssert(nil != p_block);
+
 	MCStreamRef t_stream;
 	if (!MCStreamCreate(&kMCMemoryInputStreamCallbacks, sizeof(__MCMemoryInputStream), t_stream))
 		return false;
@@ -200,6 +202,14 @@ static MCValueCustomCallbacks kMCStreamCustomValueCallbacks =
 	__MCStreamDescribe,
 };
 
+static inline void __MCAssertIsStream(MCStreamRef ref)
+{
+	__MCValue *val = reinterpret_cast<__MCValue *>(ref);
+	MCAssert(nil != val &&
+	         __MCValueGetTypeCode(val) == kMCValueTypeCodeCustom &&
+	         __MCValueGetCustomCallbacks(val) == &kMCStreamCustomValueCallbacks);
+}
+
 bool MCStreamCreate(const MCStreamCallbacks *p_callbacks, size_t p_extra_bytes, MCStreamRef& r_stream)
 {
 	__MCStream *self;
@@ -215,63 +225,85 @@ bool MCStreamCreate(const MCStreamCallbacks *p_callbacks, size_t p_extra_bytes,
 
 const MCStreamCallbacks *MCStreamGetCallbacks(MCStreamRef self)
 {
+	__MCAssertIsStream(self);
+
 	return self -> callbacks;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool MCStreamIsReadable(MCStreamRef self)
 {
+	__MCAssertIsStream(self);
+
 	return self -> callbacks -> read != nil;
 }
 
 bool MCStreamIsWritable(MCStreamRef self)
 {
+	__MCAssertIsStream(self);
+
 	return self -> callbacks -> write != nil;
 }
 
 bool MCStreamIsMarkable(MCStreamRef self)
 {
+	__MCAssertIsStream(self);
+
 	return self -> callbacks -> mark != nil;
 }
 
 bool MCStreamIsSeekable(MCStreamRef self)
 {
+	__MCAssertIsStream(self);
+
 	return self -> callbacks -> seek != nil;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool MCStreamGetAvailableForRead(MCStreamRef self, size_t& r_available)
 {
+	__MCAssertIsStream(self);
+
 	if (self -> callbacks -> get_available_for_read == nil)
 		return false;
 	return self -> callbacks -> get_available_for_read(self, r_available);
 }
 
 bool MCStreamRead(MCStreamRef self, void *p_buffer, size_t p_amount)
 {
+	__MCAssertIsStream(self);
+	MCAssert(nil != p_buffer);
+
 	if (self -> callbacks -> read == nil)
 		return false;
 	return self -> callbacks -> read(self, p_buffer, p_amount);
 }
 
 bool MCStreamGetAvailableForWrite(MCStreamRef self, size_t& r_available)
 {
+	__MCAssertIsStream(self);
+
 	if (self -> callbacks -> get_available_for_write == nil)
 		return false;
 	return self -> callbacks -> get_available_for_write(self, r_available);
 }
 
 bool MCStreamWrite(MCStreamRef self, const void *p_buffer, size_t p_amount)
 {
+	__MCAssertIsStream(self);
+	MCAssert(nil != p_buffer);
+
 	if (self -> callbacks -> write == nil)
 		return false;
 	return self -> callbacks -> write(self, p_buffer, p_amount);
 }
 
 bool MCStreamSkip(MCStreamRef self, size_t p_amount)
 {
+	__MCAssertIsStream(self);
+
 	if (self -> callbacks -> skip != nil)
 		return self -> callbacks -> skip(self, p_amount);
 	if (self -> callbacks -> seek != nil)
@@ -288,13 +320,17 @@ bool MCStreamSkip(MCStreamRef self, size_t p_amount)
 
 bool MCStreamMark(MCStreamRef self, size_t p_read_limit)
 {
+	__MCAssertIsStream(self);
+
 	if (self -> callbacks -> mark == nil)
 		return false;
 	return self -> callbacks -> mark(self, p_read_limit);
 }
 
 bool MCStreamReset(MCStreamRef self)
 {
+	__MCAssertIsStream(self);
+
 	if (self -> callbacks -> reset == nil)
 		return false;
 	return self -> callbacks -> reset(self);
@@ -304,13 +340,17 @@ bool MCStreamReset(MCStreamRef self)
 
 bool MCStreamTell(MCStreamRef self, filepos_t& r_position)
 {
+	__MCAssertIsStream(self);
+
 	if (self -> callbacks -> tell == nil)
 		return false;
 	return self -> callbacks -> tell(self, r_position);
 }
 
 bool MCStreamSeek(MCStreamRef self, filepos_t p_position)
 {
+	__MCAssertIsStream(self);
+
 	if (self -> callbacks -> seek == nil)
 		return false;
 	return self -> callbacks -> seek(self, p_position);

Original file line number	Diff line number	Diff line change
`@@ -301,6 +301,12 @@ inline MCValueTypeCode __MCValueGetTypeCode(__MCValue *self)`
`301`	`301`	`return (self -> flags >> 28);`
`302`	`302`	`}`
`303`	`303`
	`304`	`+inline const MCValueCustomCallbacks *`
	`305`	`+__MCValueGetCustomCallbacks(__MCValue *self)`
	`306`	`+{`
	`307`	`+ return reinterpret_cast<__MCCustomValue *>(self)->callbacks;`
	`308`	`+}`
	`309`	`+`
`304`	`310`	`template<class T> inline bool __MCValueCreate(MCValueTypeCode p_type_code, T*& r_value)`
`305`	`311`	`{`
`306`	`312`	`__MCValue *t_value;`
Original file line number	Diff line number	Diff line change
`@@ -130,6 +130,8 @@ static MCStreamCallbacks kMCMemoryInputStreamCallbacks =`
`130`	`130`
`131`	`131`	`bool MCMemoryInputStreamCreate(const void *p_block, size_t p_size, MCStreamRef& r_stream)`
`132`	`132`	`{`
	`133`	`+ MCAssert(nil != p_block);`
	`134`	`+`
`133`	`135`	`MCStreamRef t_stream;`
`134`	`136`	`if (!MCStreamCreate(&kMCMemoryInputStreamCallbacks, sizeof(__MCMemoryInputStream), t_stream))`
`135`	`137`	`return false;`
`@@ -200,6 +202,14 @@ static MCValueCustomCallbacks kMCStreamCustomValueCallbacks =`
`200`	`202`	`__MCStreamDescribe,`
`201`	`203`	`};`
`202`	`204`
	`205`	`+static inline void __MCAssertIsStream(MCStreamRef ref)`
	`206`	`+{`
	`207`	`+ __MCValue val = reinterpret_cast<__MCValue >(ref);`
	`208`	`+ MCAssert(nil != val &&`
	`209`	`+ __MCValueGetTypeCode(val) == kMCValueTypeCodeCustom &&`
	`210`	`+ __MCValueGetCustomCallbacks(val) == &kMCStreamCustomValueCallbacks);`
	`211`	`+}`
	`212`	`+`
`203`	`213`	`bool MCStreamCreate(const MCStreamCallbacks *p_callbacks, size_t p_extra_bytes, MCStreamRef& r_stream)`
`204`	`214`	`{`
`205`	`215`	`__MCStream *self;`
`@@ -215,63 +225,85 @@ bool MCStreamCreate(const MCStreamCallbacks *p_callbacks, size_t p_extra_bytes,`
`215`	`225`
`216`	`226`	`const MCStreamCallbacks *MCStreamGetCallbacks(MCStreamRef self)`
`217`	`227`	`{`
	`228`	`+ __MCAssertIsStream(self);`
	`229`	`+`
`218`	`230`	`return self -> callbacks;`
`219`	`231`	`}`
`220`	`232`
`221`	`233`	`////////////////////////////////////////////////////////////////////////////////`
`222`	`234`
`223`	`235`	`bool MCStreamIsReadable(MCStreamRef self)`
`224`	`236`	`{`
	`237`	`+ __MCAssertIsStream(self);`
	`238`	`+`
`225`	`239`	`return self -> callbacks -> read != nil;`
`226`	`240`	`}`
`227`	`241`
`228`	`242`	`bool MCStreamIsWritable(MCStreamRef self)`
`229`	`243`	`{`
	`244`	`+ __MCAssertIsStream(self);`
	`245`	`+`
`230`	`246`	`return self -> callbacks -> write != nil;`
`231`	`247`	`}`
`232`	`248`
`233`	`249`	`bool MCStreamIsMarkable(MCStreamRef self)`
`234`	`250`	`{`
	`251`	`+ __MCAssertIsStream(self);`
	`252`	`+`
`235`	`253`	`return self -> callbacks -> mark != nil;`
`236`	`254`	`}`
`237`	`255`
`238`	`256`	`bool MCStreamIsSeekable(MCStreamRef self)`
`239`	`257`	`{`
	`258`	`+ __MCAssertIsStream(self);`
	`259`	`+`
`240`	`260`	`return self -> callbacks -> seek != nil;`
`241`	`261`	`}`
`242`	`262`
`243`	`263`	`////////////////////////////////////////////////////////////////////////////////`
`244`	`264`
`245`	`265`	`bool MCStreamGetAvailableForRead(MCStreamRef self, size_t& r_available)`
`246`	`266`	`{`
	`267`	`+ __MCAssertIsStream(self);`
	`268`	`+`
`247`	`269`	`if (self -> callbacks -> get_available_for_read == nil)`
`248`	`270`	`return false;`
`249`	`271`	`return self -> callbacks -> get_available_for_read(self, r_available);`
`250`	`272`	`}`
`251`	`273`
`252`	`274`	`bool MCStreamRead(MCStreamRef self, void *p_buffer, size_t p_amount)`
`253`	`275`	`{`
	`276`	`+ __MCAssertIsStream(self);`
	`277`	`+ MCAssert(nil != p_buffer);`
	`278`	`+`
`254`	`279`	`if (self -> callbacks -> read == nil)`
`255`	`280`	`return false;`
`256`	`281`	`return self -> callbacks -> read(self, p_buffer, p_amount);`
`257`	`282`	`}`
`258`	`283`
`259`	`284`	`bool MCStreamGetAvailableForWrite(MCStreamRef self, size_t& r_available)`
`260`	`285`	`{`
	`286`	`+ __MCAssertIsStream(self);`
	`287`	`+`
`261`	`288`	`if (self -> callbacks -> get_available_for_write == nil)`
`262`	`289`	`return false;`
`263`	`290`	`return self -> callbacks -> get_available_for_write(self, r_available);`
`264`	`291`	`}`
`265`	`292`
`266`	`293`	`bool MCStreamWrite(MCStreamRef self, const void *p_buffer, size_t p_amount)`
`267`	`294`	`{`
	`295`	`+ __MCAssertIsStream(self);`
	`296`	`+ MCAssert(nil != p_buffer);`
	`297`	`+`
`268`	`298`	`if (self -> callbacks -> write == nil)`
`269`	`299`	`return false;`
`270`	`300`	`return self -> callbacks -> write(self, p_buffer, p_amount);`
`271`	`301`	`}`
`272`	`302`
`273`	`303`	`bool MCStreamSkip(MCStreamRef self, size_t p_amount)`
`274`	`304`	`{`
	`305`	`+ __MCAssertIsStream(self);`
	`306`	`+`
`275`	`307`	`if (self -> callbacks -> skip != nil)`
`276`	`308`	`return self -> callbacks -> skip(self, p_amount);`
`277`	`309`	`if (self -> callbacks -> seek != nil)`
`@@ -288,13 +320,17 @@ bool MCStreamSkip(MCStreamRef self, size_t p_amount)`
`288`	`320`
`289`	`321`	`bool MCStreamMark(MCStreamRef self, size_t p_read_limit)`
`290`	`322`	`{`
	`323`	`+ __MCAssertIsStream(self);`
	`324`	`+`
`291`	`325`	`if (self -> callbacks -> mark == nil)`
`292`	`326`	`return false;`
`293`	`327`	`return self -> callbacks -> mark(self, p_read_limit);`
`294`	`328`	`}`
`295`	`329`
`296`	`330`	`bool MCStreamReset(MCStreamRef self)`
`297`	`331`	`{`
	`332`	`+ __MCAssertIsStream(self);`
	`333`	`+`
`298`	`334`	`if (self -> callbacks -> reset == nil)`
`299`	`335`	`return false;`
`300`	`336`	`return self -> callbacks -> reset(self);`
`@@ -304,13 +340,17 @@ bool MCStreamReset(MCStreamRef self)`
`304`	`340`
`305`	`341`	`bool MCStreamTell(MCStreamRef self, filepos_t& r_position)`
`306`	`342`	`{`
	`343`	`+ __MCAssertIsStream(self);`
	`344`	`+`
`307`	`345`	`if (self -> callbacks -> tell == nil)`
`308`	`346`	`return false;`
`309`	`347`	`return self -> callbacks -> tell(self, r_position);`
`310`	`348`	`}`
`311`	`349`
`312`	`350`	`bool MCStreamSeek(MCStreamRef self, filepos_t p_position)`
`313`	`351`	`{`
	`352`	`+ __MCAssertIsStream(self);`
	`353`	`+`
`314`	`354`	`if (self -> callbacks -> seek == nil)`
`315`	`355`	`return false;`
`316`	`356`	`return self -> callbacks -> seek(self, p_position);`