libfoundation: Add type checks to MCError functions.

peter-b · peter-b · commit 8ae02d11b31e · 2015-10-08T02:19:17.000+01:00
diff --git a/libfoundation/src/foundation-error.cpp b/libfoundation/src/foundation-error.cpp
@@ -128,6 +128,11 @@ MCErrorCreateWithMessage (MCTypeInfoRef p_typeinfo,
                           MCArrayRef p_info,
                           MCErrorRef & r_error)
 {
+	__MCAssertIsErrorTypeInfo(p_typeinfo);
+	__MCAssertIsString(p_message);
+	if (nil != p_info)
+		__MCAssertIsArray(p_info);
+
     __MCError *self;
     if (!__MCValueCreate(kMCValueTypeCodeError, self))
         return false;
@@ -161,6 +166,7 @@ bool MCErrorCreate(MCTypeInfoRef p_typeinfo, MCArrayRef p_info, MCErrorRef& r_er
 MC_DLLEXPORT_DEF
 bool MCErrorUnwind(MCErrorRef p_error, MCValueRef p_target, uindex_t p_row, uindex_t p_column)
 {
+	__MCAssertIsError(p_error);
     MCErrorFrame *t_frame;
     if (!MCMemoryNew(t_frame))
         return false;
@@ -186,24 +192,29 @@ bool MCErrorUnwind(MCErrorRef p_error, MCValueRef p_target, uindex_t p_row, uind
 MC_DLLEXPORT_DEF
 MCNameRef MCErrorGetDomain(MCErrorRef self)
 {
+	__MCAssertIsError(self);
     return MCErrorTypeInfoGetDomain(self -> typeinfo);
 }
 
 MC_DLLEXPORT_DEF
 MCArrayRef MCErrorGetInfo(MCErrorRef self)
 {
+	__MCAssertIsError(self);
     return self -> info;
 }
 
 MC_DLLEXPORT_DEF
 MCStringRef MCErrorGetMessage(MCErrorRef self)
 {
+	__MCAssertIsError(self);
     return self -> message;
 }
 
 MC_DLLEXPORT_DEF
 uindex_t MCErrorGetDepth(MCErrorRef self)
 {
+	__MCAssertIsError(self);
+
     if (self -> backtrace == nil)
         return 0;
     
@@ -232,6 +243,8 @@ static MCErrorFrame *__MCErrorGetFrameAtLevel(MCErrorRef self, uindex_t p_level)
 MC_DLLEXPORT_DEF
 MCValueRef MCErrorGetTargetAtLevel(MCErrorRef self, uindex_t p_level)
 {
+	__MCAssertIsError(self);
+
     MCErrorFrame *t_frame;
     t_frame = __MCErrorGetFrameAtLevel(self, p_level);
     if (t_frame == nil)
@@ -243,6 +256,8 @@ MCValueRef MCErrorGetTargetAtLevel(MCErrorRef self, uindex_t p_level)
 MC_DLLEXPORT_DEF
 uindex_t MCErrorGetRowAtLevel(MCErrorRef self, uindex_t p_level)
 {
+	__MCAssertIsError(self);
+
     MCErrorFrame *t_frame;
     t_frame = __MCErrorGetFrameAtLevel(self, p_level);
     if (t_frame == nil)
@@ -254,6 +269,8 @@ uindex_t MCErrorGetRowAtLevel(MCErrorRef self, uindex_t p_level)
 MC_DLLEXPORT_DEF
 uindex_t MCErrorGetColumnAtLevel(MCErrorRef self, uindex_t p_level)
 {
+	__MCAssertIsError(self);
+
     MCErrorFrame *t_frame;
     t_frame = __MCErrorGetFrameAtLevel(self, p_level);
     if (t_frame == nil)
@@ -267,6 +284,8 @@ uindex_t MCErrorGetColumnAtLevel(MCErrorRef self, uindex_t p_level)
 MC_DLLEXPORT_DEF
 bool MCErrorThrow(MCErrorRef p_error)
 {
+	__MCAssertIsError(p_error);
+
     if (s_last_error != nil)
         MCValueRelease(s_last_error);
     
@@ -306,6 +325,8 @@ MCErrorCreateAndThrowWithMessageV (MCTypeInfoRef p_error_type,
                                    MCStringRef p_message,
                                    va_list p_args)
 {
+	__MCAssertIsErrorTypeInfo(p_error_type);
+	__MCAssertIsString(p_message);
     MCAutoArrayRef t_info;
     if (!MCArrayCreateMutable(&t_info))
         return false;
@@ -393,18 +414,21 @@ bool MCErrorThrowOutOfMemory(void)
 MC_DLLEXPORT_DEF
 bool MCErrorThrowUnboundType(MCTypeInfoRef p_type)
 {
+	__MCAssertIsTypeInfo(p_type);
     return MCErrorCreateAndThrow(kMCUnboundTypeErrorTypeInfo, "type", MCNamedTypeInfoGetName(p_type), nil);
 }
 
 MC_DLLEXPORT_DEF
 bool MCErrorThrowUnimplemented(MCStringRef p_reason)
 {
+	__MCAssertIsString(p_reason);
     return MCErrorCreateAndThrow(kMCUnimplementedErrorTypeInfo, "reason", p_reason, nil);
 }
 
 MC_DLLEXPORT_DEF
 bool MCErrorThrowGeneric(MCStringRef p_reason)
 {
+	__MCAssertIsString(p_reason);
     return MCErrorCreateAndThrow(kMCGenericErrorTypeInfo, "reason", p_reason, nil);
 }
 

Original file line number	Diff line number	Diff line change
`@@ -128,6 +128,11 @@ MCErrorCreateWithMessage (MCTypeInfoRef p_typeinfo,`
`128`	`128`	`MCArrayRef p_info,`
`129`	`129`	`MCErrorRef & r_error)`
`130`	`130`	`{`
	`131`	`+ __MCAssertIsErrorTypeInfo(p_typeinfo);`
	`132`	`+ __MCAssertIsString(p_message);`
	`133`	`+ if (nil != p_info)`
	`134`	`+ __MCAssertIsArray(p_info);`
	`135`	`+`
`131`	`136`	`__MCError *self;`
`132`	`137`	`if (!__MCValueCreate(kMCValueTypeCodeError, self))`
`133`	`138`	`return false;`
`@@ -161,6 +166,7 @@ bool MCErrorCreate(MCTypeInfoRef p_typeinfo, MCArrayRef p_info, MCErrorRef& r_er`
`161`	`166`	`MC_DLLEXPORT_DEF`
`162`	`167`	`bool MCErrorUnwind(MCErrorRef p_error, MCValueRef p_target, uindex_t p_row, uindex_t p_column)`
`163`	`168`	`{`
	`169`	`+ __MCAssertIsError(p_error);`
`164`	`170`	`MCErrorFrame *t_frame;`
`165`	`171`	`if (!MCMemoryNew(t_frame))`
`166`	`172`	`return false;`
`@@ -186,24 +192,29 @@ bool MCErrorUnwind(MCErrorRef p_error, MCValueRef p_target, uindex_t p_row, uind`
`186`	`192`	`MC_DLLEXPORT_DEF`
`187`	`193`	`MCNameRef MCErrorGetDomain(MCErrorRef self)`
`188`	`194`	`{`
	`195`	`+ __MCAssertIsError(self);`
`189`	`196`	`return MCErrorTypeInfoGetDomain(self -> typeinfo);`
`190`	`197`	`}`
`191`	`198`
`192`	`199`	`MC_DLLEXPORT_DEF`
`193`	`200`	`MCArrayRef MCErrorGetInfo(MCErrorRef self)`
`194`	`201`	`{`
	`202`	`+ __MCAssertIsError(self);`
`195`	`203`	`return self -> info;`
`196`	`204`	`}`
`197`	`205`
`198`	`206`	`MC_DLLEXPORT_DEF`
`199`	`207`	`MCStringRef MCErrorGetMessage(MCErrorRef self)`
`200`	`208`	`{`
	`209`	`+ __MCAssertIsError(self);`
`201`	`210`	`return self -> message;`
`202`	`211`	`}`
`203`	`212`
`204`	`213`	`MC_DLLEXPORT_DEF`
`205`	`214`	`uindex_t MCErrorGetDepth(MCErrorRef self)`
`206`	`215`	`{`
	`216`	`+ __MCAssertIsError(self);`
	`217`	`+`
`207`	`218`	`if (self -> backtrace == nil)`
`208`	`219`	`return 0;`
`209`	`220`
`@@ -232,6 +243,8 @@ static MCErrorFrame *__MCErrorGetFrameAtLevel(MCErrorRef self, uindex_t p_level)`
`232`	`243`	`MC_DLLEXPORT_DEF`
`233`	`244`	`MCValueRef MCErrorGetTargetAtLevel(MCErrorRef self, uindex_t p_level)`
`234`	`245`	`{`
	`246`	`+ __MCAssertIsError(self);`
	`247`	`+`
`235`	`248`	`MCErrorFrame *t_frame;`
`236`	`249`	`t_frame = __MCErrorGetFrameAtLevel(self, p_level);`
`237`	`250`	`if (t_frame == nil)`
`@@ -243,6 +256,8 @@ MCValueRef MCErrorGetTargetAtLevel(MCErrorRef self, uindex_t p_level)`
`243`	`256`	`MC_DLLEXPORT_DEF`
`244`	`257`	`uindex_t MCErrorGetRowAtLevel(MCErrorRef self, uindex_t p_level)`
`245`	`258`	`{`
	`259`	`+ __MCAssertIsError(self);`
	`260`	`+`
`246`	`261`	`MCErrorFrame *t_frame;`
`247`	`262`	`t_frame = __MCErrorGetFrameAtLevel(self, p_level);`
`248`	`263`	`if (t_frame == nil)`
`@@ -254,6 +269,8 @@ uindex_t MCErrorGetRowAtLevel(MCErrorRef self, uindex_t p_level)`
`254`	`269`	`MC_DLLEXPORT_DEF`
`255`	`270`	`uindex_t MCErrorGetColumnAtLevel(MCErrorRef self, uindex_t p_level)`
`256`	`271`	`{`
	`272`	`+ __MCAssertIsError(self);`
	`273`	`+`
`257`	`274`	`MCErrorFrame *t_frame;`
`258`	`275`	`t_frame = __MCErrorGetFrameAtLevel(self, p_level);`
`259`	`276`	`if (t_frame == nil)`
`@@ -267,6 +284,8 @@ uindex_t MCErrorGetColumnAtLevel(MCErrorRef self, uindex_t p_level)`
`267`	`284`	`MC_DLLEXPORT_DEF`
`268`	`285`	`bool MCErrorThrow(MCErrorRef p_error)`
`269`	`286`	`{`
	`287`	`+ __MCAssertIsError(p_error);`
	`288`	`+`
`270`	`289`	`if (s_last_error != nil)`
`271`	`290`	`MCValueRelease(s_last_error);`
`272`	`291`
`@@ -306,6 +325,8 @@ MCErrorCreateAndThrowWithMessageV (MCTypeInfoRef p_error_type,`
`306`	`325`	`MCStringRef p_message,`
`307`	`326`	`va_list p_args)`
`308`	`327`	`{`
	`328`	`+ __MCAssertIsErrorTypeInfo(p_error_type);`
	`329`	`+ __MCAssertIsString(p_message);`
`309`	`330`	`MCAutoArrayRef t_info;`
`310`	`331`	`if (!MCArrayCreateMutable(&t_info))`
`311`	`332`	`return false;`
`@@ -393,18 +414,21 @@ bool MCErrorThrowOutOfMemory(void)`
`393`	`414`	`MC_DLLEXPORT_DEF`
`394`	`415`	`bool MCErrorThrowUnboundType(MCTypeInfoRef p_type)`
`395`	`416`	`{`
	`417`	`+ __MCAssertIsTypeInfo(p_type);`
`396`	`418`	`return MCErrorCreateAndThrow(kMCUnboundTypeErrorTypeInfo, "type", MCNamedTypeInfoGetName(p_type), nil);`
`397`	`419`	`}`
`398`	`420`
`399`	`421`	`MC_DLLEXPORT_DEF`
`400`	`422`	`bool MCErrorThrowUnimplemented(MCStringRef p_reason)`
`401`	`423`	`{`
	`424`	`+ __MCAssertIsString(p_reason);`
`402`	`425`	`return MCErrorCreateAndThrow(kMCUnimplementedErrorTypeInfo, "reason", p_reason, nil);`
`403`	`426`	`}`
`404`	`427`
`405`	`428`	`MC_DLLEXPORT_DEF`
`406`	`429`	`bool MCErrorThrowGeneric(MCStringRef p_reason)`
`407`	`430`	`{`
	`431`	`+ __MCAssertIsString(p_reason);`
`408`	`432`	`return MCErrorCreateAndThrow(kMCGenericErrorTypeInfo, "reason", p_reason, nil);`
`409`	`433`	`}`
`410`	`434`