instance.temp.h

#ifndef ctl_declarations
#error The 'ctl_declarations' template parameter was not defined.  It should be a string to pass to #include.
#endif

/*
 * Clean up the namespace from dg_patterns.h
 */
#define UNDEF_ALL
#include "ctl/dg/blank.h"


#define protocol_begin( label )                     const char* const ppConcat(szz,label)[1+ppConcat(label,_COUNT)] = \
                                                    {   /* The enumeration as strings */

/*
 * Make enumeration
 */
#define enum_begin( label )
#define enum_item( label )
#define enum_end( label )

/*
 * Make record
 *
 * Note the odd syntax for adding this up makes it clear to even the dumbest 
 * compilers that we're adding a bunch of constants, so simple records with 
 * all scalar contents will generally boil down to sticking a size_t on the
 * stack or in a register and returning.
 */
#define record_begin(label)                             #label,
#define record_var(label,type,val)
#define record_varok(label,type,val,min,max)
#define record_array(label,type,alen,val)
#define record_arrayok(label,type,alen,val,min,max)
#define record_objarray(label,type,alen)
#define record_achar(label,type,alen,val)
#define record_string(label,type)
#define record_obj(label,type)
#define record_ref(label,type)
#define record_preref(label,type)
#define record_enum(label,enum,val)
#define record_serial(label)
#define record_serialref(label)
#define record_member(stuff)
#define record_atinit(stuff)
#define record_atdestroy(stuff)
#define record_atcopy(stuff)
#define record_atmove(stuff)
#define record_atswap(stuff)
#define record_end(label)

#define record_alias(label,type)                        #label,

#define union_begin(label,etype)
#define union_alias(type,enum)
#define union_member(label,type,enum)
#define union_end(label,etype)

#define container_array(label,type,size)
#define container_vector(label,type)
#define container_list( label, type )
#define container_map( label, keytype, type )
#define container_multimap( label, keytype, type )
#define container_set( label, type )
#define container_multiset( label, type )

#define protocol_end( label )                           NULL\
                                                    };\
                                                    /* Establish the type_init pattern for enum, such as for union members. */\
                                                    void ppConcat(label,_init)( label* self ) \
                                                    { \
                                                        *self = (label)0; \
                                                    }\
                                                    const bool ppConcat(label,_isscalar) = true;


/****************************************************************************
 * \ingroup Patterns
 * 
 * Initialization
 *
 * Generate code to initialize a record to its default state.
 * 
 ****************************************************************************/

#define UNDEF_ALL
#include "ctl/dg/blank.h"

#define RECORD_INITS

/*
 * Make enum, enum string table for protocol, if defined
 */
#define protocol_begin( label )


/*
 * Make enum, enum string table
 */
#define enum_begin( label )                         /* The enumeration as strings */\
                                                    const char* const ppConcat(szz,label)[1+ppConcat(label,_COUNT)] = \
                                                    {
#define enum_item( label )                              #label,
#define enum_end( label )                               NULL\
                                                    };\
                                                    /* Establish the type_init pattern for enum, such as for union members. */\
                                                    void ppConcat(label,_init)( label* self ) \
                                                    { \
                                                        *self = (label)0; \
                                                    }\
                                                    const bool ppConcat(label,_isscalar) = true;


/*
 * Make record
 */
#define record_begin(label)                         void ppConcat(label,_init)( label* self ) \
                                                    {\
                                                        assertobjptr( self ); /* Assert: valid inputs */
#define record_var(label,type,val)                      self->label = (type)(val);
#define record_varok(label,type,val,min,max)            self->label = (type)(val);
#define record_array(label,type,alen,val)               array_fill( type, self->label, alen, val );
#define record_arrayok(label,type,alen,val,min,max)     array_fill( type, self->label, alen, val );
#define record_objarray(label,type,alen)                { array_foreach(type,self->label, curr ) ppConcat(type,_init)(curr); }
#define record_achar(label,type,alen,val)               cstrncpy(type)(self->label, (val), (alen) );
#define record_string(label,type)                       ctl_gstring_init(type, &self->label );
#define record_obj(label,type)                          ppC(ppConcat(type,_init)(&self->label);) /* C++ will invoke its default constructor */
#define record_ref(label,type)                          self->label = NULL;
#define record_preref(label,type)                       ctl_new(self->label,type); 
#define record_enum(label,type,val)                     self->label = (val);
#define record_serial(label)                            ctl_serial_init(&(self->label),NULL,NULL);
#define record_serialref(label)                         ctl_serial_init(&(self->label),NULL,NULL);
#define record_member(stuff)                            
#define record_atinit(stuff)                            { stuff }
#define record_atdestroy(stuff)
#define record_atcopy(stuff)
#define record_atmove(stuff)
#define record_atswap(stuff)
#define record_end(label)                           }\
                                                    const bool ppConcat(label,_isscalar) = false;
#define record_alias(label,type)


/*
 * Make union default initializer
 */
#define union_begin(label,etype)                    void ppConcat(label,_setup)( label* self, etype which ) \
                                                    {\
                                                        self->type = which;\
                                                        switch( self->type )\
                                                        {
#define union_alias(type,enum)                          case enum:
#define union_member(label,type,enum)                   case enum:\
                                                            ppConcat(type,_init)(&self->obj.label);\
                                                            break;
#define union_end(label,etype)                          default:\
                                                            throwassert(ppTokStr(ppConcat(label,_setup)) ":Unknown type");\
                                                            break;\
                                                        }\
                                                    }\
                                                    const bool ppConcat(label,_isscalar) = false;\
                                                    /* Default initializer, probably wrong */\
                                                    void ppConcat(label,_init)( label* self ) \
                                                    { \
                                                        ppConcat(label,_setup)( self, (etype)0 ); \
                                                    }\
                                                    /* Reset to different type */\
                                                    void ppConcat(label,_reset)( label* self, etype which )\
                                                    {\
                                                        ppConcat(label,_destroy)( self ); \
                                                        ppConcat(label,_setup)( self, which ); \
                                                    }

/*
 * Make containers
 */
#define container_array(label,type,size)            ctl_implement_array(label,type,ctl_cooked)
#define container_vector(label,type)                ctl_implement_vector(label,type,ctl_cooked)
#define container_list( label, type )               ctl_implement_list(label,type)
#define container_map( label, keytype, type )       ctl_implement_map(label,keytype,type)
#define container_multimap( label, keytype, type )  ctl_implement_multimap(label,keytype,type)
#define container_set( label, type )                ctl_implement_set(label,type)
#define container_multiset( label, type )           ctl_implement_multiset(label,type)

#define protocol_end( label )

/* Run definitions through translation */
#include ctl_declarations

/*
 * Clean up the namespace 
 */
#define UNDEF_ALL
#include "ctl/dg/blank.h"

/****************************************************************************
 * \ingroup Patterns
 * Destruction
 *
 * Generate code to destroy a record, freeing any resources it contains
 * 
 ****************************************************************************/

#define RECORD_DESTROY

#define protocol_begin( label )     enum_begin( label )

/*
 * Make enum
 */
#define enum_begin( label )                         void ppConcat(label,_destroy)( label* self ) {}
#define enum_item( label )
#define enum_end( label )

/*
 * Make record destroy
 */
#define record_begin(label)                         void ppConcat(label,_destroy)( label* self ) \
                                                    {\
                                                        assertobjptr( self ); /* Assert: valid inputs */
#define record_var(label,type,val)
#define record_varok(label,type,val,min,max)
#define record_array(label,type,alen,val)
#define record_arrayok(label,type,alen,val,min,max)
#define record_objarray(label,type,alen)                ppC({ array_foreach(type,self->label, curr ) ppConcat(type,_destroy)(curr); }) /* C++ will invoke its default constructors */
#define record_achar(label,type,alen,val)
#define record_string(label,type)                       ctl_gstring_destroy(type, &self->label );
#define record_obj(label,type)                          ppC(ppConcat(type,_destroy)(&self->label);) /* C++ will invoke its default constructor */
#define record_ref(label,type)                          ctl_delete(self->label);
#define record_preref(label,type)                       ctl_delete(self->label);
#define record_enum(label,type,val)
#define record_serial(label)                            ctl_serial_free( &self->label );
#define record_serialref(label)                         record_serial(label)
#define record_member(stuff)                            
#define record_atinit(stuff)
#define record_atdestroy(stuff)                         { stuff }
#define record_atcopy(stuff)
#define record_atmove(stuff)
#define record_atswap(stuff)
#define record_end(label)                           }

#define record_alias(label,type)

/*
 * Make union destroy
 */
#define union_begin(label,etype)                    void ppConcat(label,_destroy)( label* self ) \
                                                    {\
                                                        switch( self->type )\
                                                        {
#define union_alias(type,enum)                          case enum:
#define union_member(label,type,enum)                   case enum:\
                                                            ppConcat(type,_destroy)(&self->obj.label);\
                                                            break;
#define union_end(label,etype)                          default:\
                                                            throwassert(ppTokStr(ppConcat(label,_destroy)) ":Unknown type");\
                                                            break;\
                                                        }\
                                                    }

#define container_array(label,type,size)
#define container_vector(label,type)
#define container_list( label, type )
#define container_map( label, keytype, type )
#define container_multimap( label, keytype, type )
#define container_set( label, type )
#define container_multiset( label, type )

#define protocol_end( label )

/* Run definitions through translation */
#include ctl_declarations

/*
 * Clean up the namespace 
 */
#define UNDEF_ALL
#include "ctl/dg/blank.h"

#ifndef NO_RECORD_COPY

/****************************************************************************
 * \ingroup Patterns
 * Copy
 *
 * Generate code to copy one record to another
 * Destination of copy is assumed to be uninitialized.
 *
 ****************************************************************************/

#define RECORD_COPIES

#define protocol_begin( label )                     enum_begin( label )

/*
 * Make enum
 */
#define enum_begin( label )                         void ppConcat(label,_copy)( label* dst, const label* src ) { *dst = *src; }
#define enum_item( label )
#define enum_end( label )


/*
 * Make record
 */
#define record_begin(label)                         void ppConcat(label,_copy)( label* dst, const label* src ) \
                                                    {\
                                                        assertobjptr(dst);\
                                                        assertobjconst(src);
#define record_var(label,type,val)                      dst->label = src->label;
#define record_varok(label,type,val,min,max)            dst->label = src->label;
#define record_array(label,type,alen,val)               record_objarray(label,type,alen)
#define record_arrayok(label,type,alen,val,min,max)     record_objarray(label,type,alen)
#define record_objarray(label,type,alen)                {   type* dstcurr = dst->label; \
                                                            const type* srccurr = src->label; \
                                                            const type* pend = dstcurr + (alen); \
                                                            while( dstcurr < pend ) \
                                                                ppConcat(type,_copy)(dstcurr++,srccurr++);\
                                                        }
#define record_achar(label,type,alen,val)               cstrncpy(type)(dst->label,src->label,alen);
#define record_string(label,type)                       ctl_gstring_init_sz(type, &dst->label, src->label.begin );
#define record_obj(label,type)                          ppConcat(type,_copy)(&dst->label,&src->label);
#define record_ref(label,type)                          ctl_ref(dst->label,src->label);
#define record_preref(label,type)                       record_ref(label,type)
#define record_enum(label,enum,val)                     dst->label = src->label;
#define record_serial(label)                            ctl_serial_copy( &dst->label, &src->label ); ctl_serial_deref(&dst->label);
#define record_serialref(label)                         ctl_serial_copy( &dst->label, &src->label ); 
#define record_member(stuff)                            
#define record_atinit(stuff)
#define record_atdestroy(stuff)
#define record_atcopy(stuff)                            { stuff }
#define record_atmove(stuff)
#define record_atswap(stuff)
#define record_end(label)                           }

#define record_alias(label,type)

/*
 * Make union copy
 */
#define union_begin(label,etype)                    void ppConcat(label,_copy)( label* dst, const label* src ) \
                                                    {\
                                                        dst->type = src->type;\
                                                        switch( dst->type )\
                                                        {
#define union_alias(type,enum)                          case enum:
#define union_member(label,type,enum)                   case enum:\
                                                            ppConcat(type,_copy)(&dst->obj.label,&src->obj.label);\
                                                            break;
#define union_end(label,etype)                          default:\
                                                            throwassert(ppTokStr(ppConcat(label,_copy)) ":Unknown type");\
                                                            break;\
                                                        }\
                                                    }

#define container_array(label,type,size)
#define container_vector(label,type)
#define container_list( label, type )
#define container_map( label, keytype, type )
#define container_multimap( label, keytype, type )
#define container_set( label, type )
#define container_multiset( label, type )

#define protocol_end( label )       

/* Run definitions through translation */
#include ctl_declarations

/*
 * Clean up the namespace 
 */
#define UNDEF_ALL
#include "ctl/dg/blank.h"

#endif /* NO_RECORD_COPY */

#ifndef NO_RECORD_VALID

/****************************************************************************
 * \ingroup Patterns
 * Validity test
 *
 * Generate code to do bounds checks on a record for assertions, sanity tests
 * etc.
 *
 ****************************************************************************/

#define protocol_begin( label )                     enum_begin( label )

/*
 * Make enum
 */
#define enum_begin( label )                         bool ppConcat(label,_valid)( const label* self ) { return enum_isvalid(label,*self); }
#define enum_item( label )
#define enum_end( label )

/*
 * Make record
 */
#define record_begin(label)                         bool ppConcat(label,_valid)( const label* self ) \
                                                    {\
                                                        if( NULL == self ) return false; /* A bad pointer is definitely invalid */
#define record_var(label,type,val)                  
#define record_varok(label,type,val,min,max)            if( self->label < (min) || self->label > (max) ) return false;
#define record_array(label,type,alen,val)
#define record_arrayok(label,type,alen,val,min,max)     { array_foreach_const(type,self->label, curr ) if( *curr < (min) || (*curr > (max)) ) return false; }
#define record_objarray(label,type,alen)                { array_foreach_const(type,self->label, curr ) if( !ppConcat(type,_valid)(curr) ) return false; }
#define record_achar(label,type,alen,val)
#define record_string(label,type)                       
#define record_obj(label,type)                          if( !ppConcat(type,_valid)(&self->label) ) return false;
#define record_ref(label,type)                          if( self->label && !ppConcat(type,_valid)(self->label) ) return false;
#define record_preref(label,type)                       record_ref(label,type)
#define record_enum(label,enum,val)                     if( !enum_isvalid(enum,self->label) ) return false;
#define record_serial(label)                            if( self->label.curr < self->label.begin || self->label.curr > self->label.end ) return false;
#define record_serialref(label)                         record_serial(label)
#define record_member(stuff)
#define record_atinit(stuff)
#define record_atdestroy(stuff)
#define record_atcopy(stuff)
#define record_atmove(stuff)
#define record_atswap(stuff)
#define record_end(label)                               return true;\
                                                    }
/*
 * Make union validator
 */
#define union_begin(label,etype)                    bool ppConcat(label,_valid)( const label* self ) \
                                                    {\
                                                        switch( self->type )\
                                                        {
#define union_alias(type,enum)                          case enum:
#define union_member(label,type,enum)                   case enum:\
                                                            return ppConcat(type,_valid)(&self->obj.label);
#define union_end(label,etype)                          default:\
                                                            /* Unknown type */\
                                                            return false;\
                                                        }\
                                                    }

#define record_alias(label,type)

#define container_array(label,type,size)
#define container_vector(label,type)
#define container_list( label, type )
#define container_map( label, keytype, type )
#define container_multimap( label, keytype, type )
#define container_set( label, type )
#define container_multiset( label, type )

#define protocol_end( label )

/* Run definitions through translation */
#include ctl_declarations

/*
 * Clean up the namespace 
 */
#define UNDEF_ALL
#include "ctl/dg/blank.h"

#endif /* NO_RECORD_VALID */

#ifndef NO_RECORD_SIZE

/****************************************************************************
 * \ingroup Patterns
 * Memory Size
 *
 * Generate code to determine how much actual memory a record is consuming, 
 * including its allocations
 *
 ****************************************************************************/

#define protocol_begin( label )                     enum_begin( label )

/*
 * Make enumeration
 */
#define enum_begin( label )                         size_t ppConcat(label,_size)( const label* self ) { return sizeof(*self); }
#define enum_item( label )
#define enum_end( label )

/*
 * Make record
 *
 * Note the odd syntax for adding this up makes it clear to even the dumbest 
 * compilers that we're adding a bunch of constants, so simple records with 
 * all scalar contents will generally boil down to sticking a size_t on the
 * stack or in a register and returning.
 */
#define record_begin(label)                         size_t ppConcat(label,_size)( const label* self ) \
                                                    {\
                                                        size_t result;\
                                                        assertobjconst( self ); /* Assert: valid inputs */\
                                                        result = sizeof(*self)
#define record_var(label,type,val)
#define record_varok(label,type,val,min,max)
#define record_array(label,type,alen,val)
#define record_arrayok(label,type,alen,val,min,max)
#define record_objarray(label,type,alen)                ; { array_foreach_const(type,self->label, curr ) result += ppConcat(type,_size)( curr ); } result = (result - sizeof(self->label))
#define record_achar(label,type,alen,val)
#define record_string(label,type)                       + (self->label.endBuff - self->label.begin)
#define record_obj(label,type)                          + (ppConcat(type,_size)( &self->label ) - sizeof(self->label))
#define record_ref(label,type)                          + (NULL == self->label ? 0 : ppConcat(type,_size)( self->label ))
#define record_preref(label,type)                       record_ref(label,type)
#define record_enum(label,enum,val)
#define record_serial(label)                            + (NULL == self->label.buff ? 0 : ctl_serial_total( &self->label ) )
#define record_serialref(label)                         record_serial(label)
#define record_member(stuff)
#define record_atinit(stuff)
#define record_atdestroy(stuff)
#define record_atcopy(stuff)
#define record_atmove(stuff)
#define record_atswap(stuff)
#define record_end(label)                               ; return result;\
                                                    }

#define record_alias(label,type)

/*
 * Make union memory measurement
 */
#define union_begin(label,etype)                    size_t ppConcat(label,_size)( const label* self ) \
                                                    {\
                                                        switch( self->type )\
                                                        {
#define union_alias(type,enum)                          case enum:
#define union_member(label,type,enum)                   case enum:\
                                                            return sizeof(*self) + ppConcat(type,_size)(&self->obj.label) - sizeof(type);
#define union_end(label,etype)                          default:\
                                                            /* Unknown type */\
                                                            return sizeof(*self);\
                                                        }\
                                                    }

#define container_array(label,type,size)
#define container_vector(label,type)
#define container_list( label, type )
#define container_map( label, keytype, type )
#define container_multimap( label, keytype, type )
#define container_set( label, type )
#define container_multiset( label, type )

#define protocol_end( label )

/* Run definitions through translation */
#include ctl_declarations

/*
 * Clean up the namespace 
 */
#define UNDEF_ALL
#include "ctl/dg/blank.h"

#endif /* NO_RECORD_SIZE */