From 3455d6f2e5083a3a8a163d8a7ed385e46d5db91d Mon Sep 17 00:00:00 2001 From: goodale Date: Tue, 21 Nov 2000 23:41:53 +0000 Subject: Making the overload macros more generic. Can now do #define OVERLOADABLE_CALL MyThorn #define OVERLOADABLE_PREFIX MyThornFunc #define OVERLOADABLE_DUMMY_PREFIX MyThornDummyFunc to get it to generate functions/function pointers of the form MyThornOverloadFoo MyThornFuncFoo and MyThornDummyFuncFoo In the flesh these are CCTK_, CCTK_, and CCTKi_Dummy respectively. Tom git-svn-id: http://svn.cactuscode.org/flesh/trunk@1898 17b73243-c579-4c4c-a9d2-2d5706c11dac --- src/include/CommOverloadables.h | 19 +++++++ src/include/IOOverloadables.h | 20 ++++++++ src/include/MainOverloadables.h | 21 ++++++++ src/include/OverloadMacros.h | 111 ++++++++++++++++++++++++++-------------- 4 files changed, 132 insertions(+), 39 deletions(-) (limited to 'src/include') diff --git a/src/include/CommOverloadables.h b/src/include/CommOverloadables.h index d44728e9..b8758410 100644 --- a/src/include/CommOverloadables.h +++ b/src/include/CommOverloadables.h @@ -12,6 +12,22 @@ #include "cctk_Flesh.h" #include "cctk_GroupsOnGH.h" +#ifdef OVERLOADABLE_CALL +#undef OVERLOADABLE_CALL +#endif + +#ifdef OVERLOABLE_PREFIX +#undef OVERLOADABLE_PREFIX +#endif + +#ifdef OVERLOABLE_DUMMY_PREFIX +#undef OVERLOADABLE_DUMMY_PREFIX +#endif + +#define OVERLOADABLE_CALL CCTK_ +#define OVERLOADABLE_PREFIX CCTK_ +#define OVERLOADABLE_DUMMY_PREFIX CCTKi_Dummy + #ifdef ARGUMENTS #undef ARGUMENTS #endif @@ -74,6 +90,9 @@ OVERLOADABLE(GroupDynamicData) #undef ARGUMENTS #undef RETURN_TYPE +#undef OVERLOADABLE_CALL +#undef OVERLOADABLE_PREFIX +#undef OVERLOADABLE_DUMMY_PREFIX diff --git a/src/include/IOOverloadables.h b/src/include/IOOverloadables.h index f2f7ea15..ee838f07 100644 --- a/src/include/IOOverloadables.h +++ b/src/include/IOOverloadables.h @@ -9,6 +9,22 @@ @version $Header$ @@*/ +#ifdef OVERLOADABLE_CALL +#undef OVERLOADABLE_CALL +#endif + +#ifdef OVERLOABLE_PREFIX +#undef OVERLOADABLE_PREFIX +#endif + +#ifdef OVERLOABLE_DUMMY_PREFIX +#undef OVERLOADABLE_DUMMY_PREFIX +#endif + +#define OVERLOADABLE_CALL CCTK_ +#define OVERLOADABLE_PREFIX CCTK_ +#define OVERLOADABLE_DUMMY_PREFIX CCTKi_Dummy + #ifdef ARGUMENTS #undef ARGUMENTS #endif @@ -30,3 +46,7 @@ OVERLOADABLE(OutputVarAsByMethod) #undef ARGUMENTS #undef RETURN_TYPE + +#undef OVERLOADABLE_CALL +#undef OVERLOADABLE_PREFIX +#undef OVERLOADABLE_DUMMY_PREFIX diff --git a/src/include/MainOverloadables.h b/src/include/MainOverloadables.h index f658ab49..34ae5023 100644 --- a/src/include/MainOverloadables.h +++ b/src/include/MainOverloadables.h @@ -9,6 +9,23 @@ @version $Header$ @@*/ + +#ifdef OVERLOADABLE_CALL +#undef OVERLOADABLE_CALL +#endif + +#ifdef OVERLOABLE_PREFIX +#undef OVERLOADABLE_PREFIX +#endif + +#ifdef OVERLOABLE_DUMMY_PREFIX +#undef OVERLOADABLE_DUMMY_PREFIX +#endif + +#define OVERLOADABLE_CALL CCTK_ +#define OVERLOADABLE_PREFIX CCTK_ +#define OVERLOADABLE_DUMMY_PREFIX CCTKi_Dummy + #ifdef ARGUMENTS #undef ARGUMENTS #endif @@ -40,3 +57,7 @@ OVERLOADABLE(SetMainLoopIndex) #undef ARGUMENTS #undef RETURN_TYPE + +#undef OVERLOADABLE_CALL +#undef OVERLOADABLE_PREFIX +#undef OVERLOADABLE_DUMMY_PREFIX diff --git a/src/include/OverloadMacros.h b/src/include/OverloadMacros.h index eb2ba190..8f8b959c 100644 --- a/src/include/OverloadMacros.h +++ b/src/include/OverloadMacros.h @@ -9,7 +9,7 @@ @@*/ #ifndef _OVERLOADMACROS_H_ -#define _OVERLOADMACROS_H_ +#define _OVERLOADMACROS_H_ 1 /* These are a load of macros used to make overloadable functions. * @@ -20,6 +20,14 @@ * Defining OVERLOADABLE(name) as OVERLOADABLE_(name) * and then including the header will create functions, prototypes * dummy functions or some checking code as required. + * + * One must also define + * + * #define OVERLOADABLE_CALL prefix for calling overload functions + * #define OVERLOADABLE_PREFIX prefix for real functions + * #define OVERLOADABLE_DUMMY_PREFIX prefix for dummy functions + * + * to apply prefices to the functions. */ /* This macro defines a global variable with the name of the function @@ -27,58 +35,83 @@ * * The function can only be called twice - to set the default, and to overload it. */ -#define OVERLOADABLE_FUNCTION(name) \ -RETURN_TYPE (*CCTK_##name)(ARGUMENTS) = NULL; \ -int CCTK_Overload##name(RETURN_TYPE (*func)(ARGUMENTS)) \ -{ \ - int return_code; \ - static int overloaded = 0; \ - if(overloaded < 2) \ - { \ - CCTK_##name = func; \ - overloaded++; \ - return_code = overloaded; \ - } \ - else \ - { \ - char *message = malloc( (200+strlen(#name))*sizeof(char) ); \ - sprintf(message, \ - "Warning: Attempted to overload function %s twice\n",\ - #name); \ - CCTK_Warn(1,__LINE__,__FILE__,"Cactus",message); \ - free(message); \ - return_code = 0; \ - } \ - \ - return return_code; \ +#define OVERLOADABLE_FUNCTION(name) \ + _OVERLOADABLE_FUNCTION(OVERLOADABLE_CALL,OVERLOADABLE_PREFIX, OVERLOADABLE_DUMMY_PREFIX, name) +#define _OVERLOADABLE_FUNCTION(call, prefix, dummy_prefix, name) \ + __OVERLOADABLE_FUNCTION(call, prefix, dummy_prefix, name) + +#define __OVERLOADABLE_FUNCTION(call, prefix, dummy_prefix, name) \ +RETURN_TYPE (*prefix##name)(ARGUMENTS) = NULL; \ +int call##Overload##name(RETURN_TYPE (*func)(ARGUMENTS)) \ +{ \ + int return_code; \ + static int overloaded = 0; \ + if(overloaded < 2) \ + { \ + prefix##name = func; \ + overloaded++; \ + return_code = overloaded; \ + } \ + else \ + { \ + char *message = malloc( (200+strlen(#name))*sizeof(char) ); \ + sprintf(message, \ + "Warning: Attempted to overload function %s%s twice\n",\ + #prefix, #name); \ + CCTK_Warn(1,__LINE__,__FILE__,"Cactus",message); \ + free(message); \ + return_code = 0; \ + } \ + \ + return return_code; \ } /* This macro creates an extern declaration for an overloadable function */ -#define OVERLOADABLE_PROTOTYPE(name) \ -extern RETURN_TYPE (*CCTK_##name)(ARGUMENTS); + +#define OVERLOADABLE_PROTOTYPE(name) _OVERLOADABLE_PROTOTYPE(OVERLOADABLE_PREFIX, OVERLOADABLE_DUMMY_PREFIX, name) +#define _OVERLOADABLE_PROTOTYPE(prefix, dummy_prefix, name) __OVERLOADABLE_PROTOTYPE(prefix, dummy_prefix, name) + +#define __OVERLOADABLE_PROTOTYPE(prefix, dummy_prefix, name) \ +extern RETURN_TYPE (*prefix##name)(ARGUMENTS); /* This macro defines a dummy function */ -#define OVERLOADABLE_DUMMY(name) \ -RETURN_TYPE CCTKi_Dummy##name(ARGUMENTS) \ -{ \ - fprintf(stderr, "Dummy %s called.\n", #name); \ - return 0; \ +#define OVERLOADABLE_DUMMY(name) _OVERLOADABLE_DUMMY(OVERLOADABLE_PREFIX, OVERLOADABLE_DUMMY_PREFIX, name) +#define _OVERLOADABLE_DUMMY(prefix, dummy_prefix, name) __OVERLOADABLE_DUMMY(prefix, dummy_prefix, name) + +#define __OVERLOADABLE_DUMMY(prefix, dummy_prefix, name) \ +RETURN_TYPE dummy_prefix##name(ARGUMENTS) \ +{ \ + fprintf(stderr, "Dummy %s%s called.\n", #dummy_prefix,#name); \ + return 0; \ } /* This macro defines the prototype for a dummy function. */ -#define OVERLOADABLE_DUMMYPROTOTYPE(name) \ -RETURN_TYPE CCTKi_Dummy##name(ARGUMENTS); +#define OVERLOADABLE_DUMMYPROTOTYPE(name) _OVERLOADABLE_DUMMYPROTOTYPE(OVERLOADABLE_PREFIX, OVERLOADABLE_DUMMY_PREFIX, name) +#define _OVERLOADABLE_DUMMYPROTOTYPE(prefix, dummy_prefix, name) __OVERLOADABLE_DUMMYPROTOTYPE(prefix, dummy_prefix, name) + +#define __OVERLOADABLE_DUMMYPROTOTYPE(prefix, dummy_prefix, name) \ +RETURN_TYPE dummy_prefix##name(ARGUMENTS); /* This macro defines a check line which will set the overloadable * function to be the dummy if it hasn't been set. */ -#define OVERLOADABLE_CHECK(name) \ - if(!CCTK_##name) CCTK_##name = CCTKi_Dummy##name; + +#define OVERLOADABLE_CHECK(name) _OVERLOADABLE_CHECK(OVERLOADABLE_PREFIX, OVERLOADABLE_DUMMY_PREFIX, name) +#define _OVERLOADABLE_CHECK(prefix, dummy_prefix, name) __OVERLOADABLE_CHECK(prefix, dummy_prefix, name) + +#define __OVERLOADABLE_CHECK(prefix, dummy_prefix, name) \ + if(!prefix##name) prefix##name = dummy_prefix##name; /* This macro defines the prototype for the overloading function itself */ -#define OVERLOADABLE_OVERLOADPROTO(name) \ -int CCTK_Overload##name(RETURN_TYPE (*func)(ARGUMENTS)); + +#define OVERLOADABLE_OVERLOADPROTO(name) \ + _OVERLOADABLE_OVERLOADPROTO(OVERLOADABLE_CALL,OVERLOADABLE_PREFIX, OVERLOADABLE_DUMMY_PREFIX, name) +#define _OVERLOADABLE_OVERLOADPROTO(call,prefix, dummy_prefix, name) \ + __OVERLOADABLE_OVERLOADPROTO(call,prefix, dummy_prefix, name) + +#define __OVERLOADABLE_OVERLOADPROTO(call,prefix, dummy_prefix, name) \ +int call##Overload##name(RETURN_TYPE (*func)(ARGUMENTS)); -#endif +#endif /* _OVERLOADMACROS_H_ */ -- cgit v1.2.3