Data Bank Functions (bk_xxx)

Functions
void	bk_init (void *event)
BOOL	bk_is32 (const void *event)
BOOL	bk_is32a (const void *event)
void	bk_init32 (void *event)
void	bk_init32a (void *event)
INT	bk_size (const void *event)
static void	copy_bk_name (char *dst, const char *src)
void	bk_create (void *event, const char *name, WORD type, void **pdata)
INT	bk_copy (char *pevent, char *psrce, const char *bkname)
int	bk_delete (void *event, const char *name)
INT	bk_close (void *event, void *pdata)
INT	bk_list (const void *event, char *bklist)
INT	bk_locate (const void *event, const char *name, void *pdata)
INT	bk_find (const BANK_HEADER *pbkh, const char *name, DWORD *bklen, DWORD *bktype, void **pdata)
INT	bk_iterate (const void *event, BANK **pbk, void *pdata)
INT	bk_iterate32 (const void *event, BANK32 **pbk, void *pdata)
INT	bk_iterate32a (const void *event, BANK32A **pbk32a, void *pdata)
INT	bk_swap (void *event, BOOL force)

Detailed Description

dox

Function Documentation

bk_close()

INT bk_close	(	void *	event,
		void *	pdata
	)

dox Close the Midas bank priviously created by bk_create(). The data pointer pdata must be obtained by bk_create() and used as an address to fill a bank. It is incremented with every value written to the bank and finally points to a location just after the last byte of the bank. It is then passed to bk_close() to finish the bank creation

Parameters

event	pointer to current composed event
pdata	pointer to the data

Returns

number of bytes contained in bank

Definition at line 18297 of file midas.cxx.

                                       {
   if (bk_is32a((BANK_HEADER *) event)) {
      BANK32A *pbk32a = (BANK32A *) ((char *) (((BANK_HEADER *) event) + 1) + ((BANK_HEADER *) event)->data_size);
      pbk32a->data_size = (DWORD) ((char *) pdata - (char *) (pbk32a + 1));
      if (pbk32a->type == TID_STRUCT && pbk32a->data_size == 0)
         printf("Warning: TID_STRUCT bank %c%c%c%c has zero size\n", pbk32a->name[0], pbk32a->name[1], pbk32a->name[2], pbk32a->name[3]);
      ((BANK_HEADER *) event)->data_size += sizeof(BANK32A) + ALIGN8(pbk32a->data_size);
      return pbk32a->data_size;
   } else if (bk_is32((BANK_HEADER *) event)) {
      BANK32 *pbk32 = (BANK32 *) ((char *) (((BANK_HEADER *) event) + 1) + ((BANK_HEADER *) event)->data_size);
      pbk32->data_size = (DWORD) ((char *) pdata - (char *) (pbk32 + 1));
      if (pbk32->type == TID_STRUCT && pbk32->data_size == 0)
         printf("Warning: TID_STRUCT bank %c%c%c%c has zero size\n", pbk32->name[0], pbk32->name[1], pbk32->name[2], pbk32->name[3]);
      ((BANK_HEADER *) event)->data_size += sizeof(BANK32) + ALIGN8(pbk32->data_size);
      return pbk32->data_size;
   } else {
      BANK *pbk = (BANK *) ((char *) (((BANK_HEADER *) event) + 1) + ((BANK_HEADER *) event)->data_size);
      uint32_t size = (uint32_t) ((char *) pdata - (char *) (pbk + 1));
      if (size > 0xFFFF) {
         printf("Error: Bank size %d exceeds 16-bit limit of 65526, please use bk_init32() to create a 32-bit bank\n", size);
         size = 0;
      }
      pbk->data_size = (WORD) (size);
      if (pbk->type == TID_STRUCT && pbk->data_size == 0)
         printf("Warning: TID_STRUCT bank %c%c%c%c has zero size\n", pbk->name[0], pbk->name[1], pbk->name[2], pbk->name[3]);
      size = ((BANK_HEADER *) event)->data_size + sizeof(BANK) + ALIGN8(pbk->data_size);
      if (size > 0xFFFF) {
         printf("Error: Bank size %d exceeds 16-bit limit of 65526, please use bk_init32() to create a 32-bit bank\n", size);
         size = 0;
      }
      ((BANK_HEADER *) event)->data_size = size;
      return pbk->data_size;
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bk_copy()

INT bk_copy	(	char *	pevent,
		char *	psrce,
		const char *	bkname
	)

dox Copy a bank given by name if found from a buffer source to a destination buffer.

Parameters

*	pevent pointing after the EVENT_HEADER (as in FE)
*	psrce pointing to EVENT_HEADER in this case (for ebch[i].pfragment)
bkname	Bank to be found and copied from psrce to pevent

Returns

EB_SUCCESS if bank found, 0 if not found (pdest untouched)

Definition at line 18121 of file midas.cxx.

                                                           {
 
   INT status;
   DWORD bklen, bktype, bksze;
   BANK_HEADER *psBkh;
   BANK *psbkh;
   char *pdest;
   void *psdata;
 
   // source pointing on the BANKxx
   psBkh = (BANK_HEADER *) ((EVENT_HEADER *) psrce + 1);
   // Find requested bank
   status = bk_find(psBkh, bkname, &bklen, &bktype, &psdata);
   // Return 0 if not found
   if (status != SUCCESS) return 0;
 
   // Check bank type...
   // You cannot mix BANK and BANK32 so make sure all the FE use either
   // bk_init(pevent) or bk_init32(pevent).
   if (bk_is32a(psBkh)) {
 
      // pointer to the source bank header
      BANK32A *psbkh32a = ((BANK32A *) psdata - 1);
      // Data size in the bank
      bksze = psbkh32a->data_size;
 
      // Get to the end of the event
      pdest = (char *) (((BANK_HEADER *) pevent) + 1) + ((BANK_HEADER *) pevent)->data_size;
      // Copy from BANK32 to end of Data
      memmove(pdest, (char *) psbkh32a, ALIGN8(bksze) + sizeof(BANK32A));
      // Bring pointer to the next free location
      pdest += ALIGN8(bksze) + sizeof(BANK32A);
 
   } else if (bk_is32(psBkh)) {
 
      // pointer to the source bank header
      BANK32 *psbkh32 = ((BANK32 *) psdata - 1);
      // Data size in the bank
      bksze = psbkh32->data_size;
 
      // Get to the end of the event
      pdest = (char *) (((BANK_HEADER *) pevent) + 1) + ((BANK_HEADER *) pevent)->data_size;
      // Copy from BANK32 to end of Data
      memmove(pdest, (char *) psbkh32, ALIGN8(bksze) + sizeof(BANK32));
      // Bring pointer to the next free location
      pdest += ALIGN8(bksze) + sizeof(BANK32);
 
   } else {
 
      // pointer to the source bank header
      psbkh = ((BANK *) psdata - 1);
      // Data size in the bank
      bksze = psbkh->data_size;
 
      // Get to the end of the event
      pdest = (char *) (((BANK_HEADER *) pevent) + 1) + ((BANK_HEADER *) pevent)->data_size;
      // Copy from BANK to end of Data
      memmove(pdest, (char *) psbkh, ALIGN8(bksze) + sizeof(BANK));
      // Bring pointer to the next free location
      pdest += ALIGN8(bksze) + sizeof(BANK);
   }
 
   // Close bank (adjust BANK_HEADER size)
   bk_close(pevent, pdest);
   // Adjust EVENT_HEADER size
   ((EVENT_HEADER *) pevent - 1)->data_size = ((BANK_HEADER *) pevent)->data_size + sizeof(BANK_HEADER);
   return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bk_create()

void bk_create	(	void *	event,
		const char *	name,
		WORD	type,
		void **	pdata
	)

Create a Midas bank. The data pointer pdata must be used as an address to fill a bank. It is incremented with every value written to the bank and finally points to a location just after the last byte of the bank. It is then passed to the function bk_close() to finish the bank creation.

INT *pdata;
bk_init(pevent);
bk_create(pevent, "ADC0", TID_INT32, &pdata);
*pdata++ = 123
*pdata++ = 456
bk_close(pevent, pdata);

Parameters

event	pointer to the data area
name	of the bank, must be exactly 4 charaters
type	type of bank, one of the Midas_Data_Types values defined in midas.h
pdata	pointer to the data area of the newly created bank

Returns

void

Definition at line 18078 of file midas.cxx.

                                                                       {
   if (bk_is32a((BANK_HEADER *) event)) {
      if (((PTYPE) event & 0x07) != 0) {
         cm_msg(MERROR, "bk_create", "Bank %s created with unaligned event pointer", name);
         return;
      }
      BANK32A *pbk32a;
 
      pbk32a = (BANK32A *) ((char *) (((BANK_HEADER *) event) + 1) + ((BANK_HEADER *) event)->data_size);
      copy_bk_name(pbk32a->name, name);
      pbk32a->type = type;
      pbk32a->data_size = 0;
      *pdata = pbk32a + 1;
   } else if (bk_is32((BANK_HEADER *) event)) {
      BANK32 *pbk32;
 
      pbk32 = (BANK32 *) ((char *) (((BANK_HEADER *) event) + 1) + ((BANK_HEADER *) event)->data_size);
      copy_bk_name(pbk32->name, name);
      pbk32->type = type;
      pbk32->data_size = 0;
      *pdata = pbk32 + 1;
   } else {
      BANK *pbk;
 
      pbk = (BANK *) ((char *) (((BANK_HEADER *) event) + 1) + ((BANK_HEADER *) event)->data_size);
      copy_bk_name(pbk->name, name);
      pbk->type = type;
      pbk->data_size = 0;
      *pdata = pbk + 1;
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bk_delete()

int bk_delete	(	void *	event,
		const char *	name
	)

Definition at line 18191 of file midas.cxx.

{
   BANK *pbk;
   DWORD dname;
   int remaining;
 
   if (bk_is32a((BANK_HEADER *) event)) {
      /* locate bank */
      BANK32A *pbk32a = (BANK32A *) (((BANK_HEADER *) event) + 1);
      copy_bk_name((char *) &dname, name);
      do {
         if (*((DWORD *) pbk32a->name) == dname) {
            /* bank found, delete it */
            remaining = ((char *) event + ((BANK_HEADER *) event)->data_size +
                         sizeof(BANK_HEADER)) - ((char *) (pbk32a + 1) + ALIGN8(pbk32a->data_size));
 
            /* reduce total event size */
            ((BANK_HEADER *) event)->data_size -= sizeof(BANK32) + ALIGN8(pbk32a->data_size);
 
            /* copy remaining bytes */
            if (remaining > 0)
               memmove(pbk32a, (char *) (pbk32a + 1) + ALIGN8(pbk32a->data_size), remaining);
            return CM_SUCCESS;
         }
 
         pbk32a = (BANK32A *) ((char *) (pbk32a + 1) + ALIGN8(pbk32a->data_size));
      } while ((DWORD) ((char *) pbk32a - (char *) event) <
               ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER));
   } else if (bk_is32((BANK_HEADER *) event)) {
      /* locate bank */
      BANK32 *pbk32 = (BANK32 *) (((BANK_HEADER *) event) + 1);
      copy_bk_name((char *) &dname, name);
      do {
         if (*((DWORD *) pbk32->name) == dname) {
            /* bank found, delete it */
            remaining = ((char *) event + ((BANK_HEADER *) event)->data_size +
                         sizeof(BANK_HEADER)) - ((char *) (pbk32 + 1) + ALIGN8(pbk32->data_size));
 
            /* reduce total event size */
            ((BANK_HEADER *) event)->data_size -= sizeof(BANK32) + ALIGN8(pbk32->data_size);
 
            /* copy remaining bytes */
            if (remaining > 0)
               memmove(pbk32, (char *) (pbk32 + 1) + ALIGN8(pbk32->data_size), remaining);
            return CM_SUCCESS;
         }
 
         pbk32 = (BANK32 *) ((char *) (pbk32 + 1) + ALIGN8(pbk32->data_size));
      } while ((DWORD) ((char *) pbk32 - (char *) event) <
               ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER));
   } else {
      /* locate bank */
      pbk = (BANK *) (((BANK_HEADER *) event) + 1);
      copy_bk_name((char *) &dname, name);
      do {
         if (*((DWORD *) pbk->name) == dname) {
            /* bank found, delete it */
            remaining = ((char *) event + ((BANK_HEADER *) event)->data_size +
                         sizeof(BANK_HEADER)) - ((char *) (pbk + 1) + ALIGN8(pbk->data_size));
 
            /* reduce total event size */
            ((BANK_HEADER *) event)->data_size -= sizeof(BANK) + ALIGN8(pbk->data_size);
 
            /* copy remaining bytes */
            if (remaining > 0)
               memmove(pbk, (char *) (pbk + 1) + ALIGN8(pbk->data_size), remaining);
            return CM_SUCCESS;
         }
 
         pbk = (BANK *) ((char *) (pbk + 1) + ALIGN8(pbk->data_size));
      } while ((DWORD) ((char *) pbk - (char *) event) <
               ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER));
   }
 
   return 0;
}

Here is the call graph for this function:

bk_find()

INT bk_find	(	const BANK_HEADER *	pbkh,
		const char *	name,
		DWORD *	bklen,
		DWORD *	bktype,
		void **	pdata
	)

Finds a MIDAS bank of given name inside an event.

Parameters

pbkh	pointer to current composed event
name	bank name to look for
bklen	number of elemtents in bank
bktype	bank type, one of TID_xxx
pdata	pointer to data area of bank, NULL if bank not found

Returns

1 if bank found, 0 otherwise

Definition at line 18509 of file midas.cxx.

                                                                                                  {
   DWORD dname;
 
   if (bk_is32a(pbkh)) {
      BANK32A *pbk32a = (BANK32A *) (pbkh + 1);
      copy_bk_name((char *) &dname, name);
      do {
         if (*((DWORD *) pbk32a->name) == dname) {
            int tid = pbk32a->type & 0xFF;
            if (tid >= TID_LAST) {
               *((void **) pdata) = NULL;
               return 0;
            }
            *((void **) pdata) = pbk32a + 1;
            if (tid_size[tid] == 0)
               *bklen = pbk32a->data_size;
            else
               *bklen = pbk32a->data_size / tid_size[tid];
 
            *bktype = pbk32a->type;
            return 1;
         }
         pbk32a = (BANK32A *) ((char *) (pbk32a + 1) + ALIGN8(pbk32a->data_size));
      } while ((DWORD) ((char *) pbk32a - (char *) pbkh) < pbkh->data_size + sizeof(BANK_HEADER));
   } else if (bk_is32(pbkh)) {
         BANK32 *pbk32 = (BANK32 *) (pbkh + 1);
      copy_bk_name((char *) &dname, name);
      do {
         if (*((DWORD *) pbk32->name) == dname) {
            int tid = pbk32->type & 0xFF;
            if (tid >= TID_LAST) {
               *((void **) pdata) = NULL;
               return 0;
            }
            *((void **) pdata) = pbk32 + 1;
            if (tid_size[tid] == 0)
               *bklen = pbk32->data_size;
            else
               *bklen = pbk32->data_size / tid_size[tid];
 
            *bktype = pbk32->type;
            return 1;
         }
         pbk32 = (BANK32 *) ((char *) (pbk32 + 1) + ALIGN8(pbk32->data_size));
      } while ((DWORD) ((char *) pbk32 - (char *) pbkh) < pbkh->data_size + sizeof(BANK_HEADER));
   } else {
      BANK *pbk = (BANK *) (pbkh + 1);
      copy_bk_name((char *) &dname, name);
      do {
         if (*((DWORD *) pbk->name) == dname) {
            int tid = pbk->type & 0xFF;
            if (tid >= TID_LAST) {
               *((void **) pdata) = NULL;
               return 0;
            }
            *((void **) pdata) = pbk + 1;
            if (tid_size[tid] == 0)
               *bklen = pbk->data_size;
            else
               *bklen = pbk->data_size / tid_size[tid];
 
            *bktype = pbk->type;
            return 1;
         }
         pbk = (BANK *) ((char *) (pbk + 1) + ALIGN8(pbk->data_size));
      } while ((DWORD) ((char *) pbk - (char *) pbkh) < pbkh->data_size + sizeof(BANK_HEADER));
   }
 
   /* bank not found */
   *((void **) pdata) = NULL;
   return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bk_init()

void bk_init

(

void *

event

)

Initializes an event for Midas banks structure. Before banks can be created in an event, bk_init() has to be called first.

Parameters

event

pointer to the area of event

Definition at line 17923 of file midas.cxx.

                          {
   ((BANK_HEADER *) event)->data_size = 0;
   ((BANK_HEADER *) event)->flags = BANK_FORMAT_VERSION;
}

Here is the caller graph for this function:

bk_init32()

void bk_init32

(

void *

event

)

dox Initializes an event for Midas banks structure for large bank size (> 32KBytes) Before banks can be created in an event, bk_init32() has to be called first.

Parameters

event

pointer to the area of event

Returns

void

Definition at line 17986 of file midas.cxx.

                            {
   ((BANK_HEADER *) event)->data_size = 0;
   ((BANK_HEADER *) event)->flags = BANK_FORMAT_VERSION | BANK_FORMAT_32BIT;
}

Here is the caller graph for this function:

bk_init32a()

void bk_init32a

(

void *

event

)

Initializes an event for Midas banks structure for large bank size (> 32KBytes) which are aligned on 64-bit boundaries. Before banks can be created in an event, bk_init32a() has to be called first.

Parameters

event

pointer to the area of event

Returns

void

Definition at line 17999 of file midas.cxx.

                             {
   ((BANK_HEADER *) event)->data_size = 0;
   ((BANK_HEADER *) event)->flags = BANK_FORMAT_VERSION | BANK_FORMAT_32BIT | BANK_FORMAT_64BIT_ALIGNED;
}

Here is the caller graph for this function:

bk_is32()

BOOL bk_is32

(

const void *

event

)

dox

Definition at line 17932 of file midas.cxx.

{
   return ((((BANK_HEADER *) event)->flags & BANK_FORMAT_32BIT) > 0);
}

Here is the caller graph for this function:

bk_is32a()

BOOL bk_is32a

(

const void *

event

)

Definition at line 17954 of file midas.cxx.

{
   return ((((BANK_HEADER *) event)->flags & BANK_FORMAT_64BIT_ALIGNED) > 0);
}

Here is the caller graph for this function:

bk_iterate()

INT bk_iterate	(	const void *	event,
		BANK **	pbk,
		void *	pdata
	)

Iterates through banks inside an event. The function can be used to enumerate all banks of an event. The returned pointer to the bank header has following structure:

typedef struct {
char   name[4];
WORD   type;
WORD   data_size;
} BANK;

where type is a TID_xxx value and data_size the size of the bank in bytes.

BANK *pbk;
INT  size;
void *pdata;
char name[5];
pbk = NULL;
do
{
 size = bk_iterate(event, &pbk, &pdata);
 if (pbk == NULL)
  break;
 *((DWORD *)name) = *((DWORD *)(pbk)->name);
 name[4] = 0;
 printf("bank %s found\n", name);
} while(TRUE);

Parameters

event	Pointer to data area of event.
pbk	pointer to the bank header, must be NULL for the first call to this function.
pdata	Pointer to the bank header, must be NULL for the first call to this function

Returns

Size of bank in bytes

Definition at line 18618 of file midas.cxx.

                                                           {
   if (*pbk == NULL)
      *pbk = (BANK *) (((BANK_HEADER *) event) + 1);
   else
      *pbk = (BANK *) ((char *) (*pbk + 1) + ALIGN8((*pbk)->data_size));
 
   *((void **) pdata) = (*pbk) + 1;
 
   if ((DWORD) ((char *) *pbk - (char *) event) >= ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER)) {
      *pbk = *((BANK **) pdata) = NULL;
      return 0;
   }
 
   return (*pbk)->data_size;
}

Here is the caller graph for this function:

bk_iterate32()

INT bk_iterate32	(	const void *	event,
		BANK32 **	pbk,
		void *	pdata
	)

dox

Definition at line 18639 of file midas.cxx.

{
   if (*pbk == NULL)
      *pbk = (BANK32 *) (((BANK_HEADER *) event) + 1);
   else
      *pbk = (BANK32 *) ((char *) (*pbk + 1) + ALIGN8((*pbk)->data_size));
 
   *((void **) pdata) = (*pbk) + 1;
 
   if ((DWORD) ((char *) *pbk - (char *) event) >= ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER)) {
      *pbk = NULL;
      pdata = NULL;
      return 0;
   }
 
   return (*pbk)->data_size;
}

Here is the caller graph for this function:

bk_iterate32a()

INT bk_iterate32a	(	const void *	event,
		BANK32A **	pbk32a,
		void *	pdata
	)

Definition at line 18675 of file midas.cxx.

{
   if (*pbk32a == NULL)
      *pbk32a = (BANK32A *) (((BANK_HEADER *) event) + 1);
   else
      *pbk32a = (BANK32A *) ((char *) (*pbk32a + 1) + ALIGN8((*pbk32a)->data_size));
 
   *((void **) pdata) = (*pbk32a) + 1;
 
   if ((DWORD) ((char *) *pbk32a - (char *) event) >= ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER)) {
      *pbk32a = NULL;
      pdata = NULL;
      return 0;
   }
 
   return (*pbk32a)->data_size;
}

Here is the caller graph for this function:

bk_list()

INT bk_list	(	const void *	event,
		char *	bklist
	)

Extract the MIDAS bank name listing of an event. The bklist should be dimensioned with STRING_BANKLIST_MAX which corresponds to a max of BANKLIST_MAX banks (midas.h: 32 banks max).

INT adc_calib(EVENT_HEADER *pheader, void *pevent)
{
  INT    n_adc, nbanks;
  WORD   *pdata;
  char   banklist[STRING_BANKLIST_MAX];
 
  // Display # of banks and list of banks in the event
  nbanks = bk_list(pevent, banklist);
  printf("#banks:%d List:%s\n", nbanks, banklist);
 
  // look for ADC0 bank, return if not present
  n_adc = bk_locate(pevent, "ADC0", &pdata);
  ...
}

Parameters

event	pointer to current composed event
bklist	returned ASCII string, has to be booked with STRING_BANKLIST_MAX.

Returns

number of bank found in this event.

Definition at line 18357 of file midas.cxx.

                                             {                               /* Full event */
   INT nbk;
   BANK *pmbk = NULL;
   BANK32 *pmbk32 = NULL;
   BANK32A *pmbk32a = NULL;
   char *pdata;
 
   /* compose bank list */
   bklist[0] = 0;
   nbk = 0;
   do {
      /* scan all banks for bank name only */
      if (bk_is32a(event)) {
         bk_iterate32a(event, &pmbk32a, &pdata);
         if (pmbk32a == NULL)
            break;
      } else if (bk_is32(event)) {
         bk_iterate32(event, &pmbk32, &pdata);
         if (pmbk32 == NULL)
            break;
      } else {
         bk_iterate(event, &pmbk, &pdata);
         if (pmbk == NULL)
            break;
      }
      nbk++;
 
      if (nbk > BANKLIST_MAX) {
         cm_msg(MINFO, "bk_list", "over %i banks -> truncated", BANKLIST_MAX);
         return (nbk - 1);
      }
      if (bk_is32a(event))
         strncat(bklist, (char *) pmbk32a->name, 4);
      else if (bk_is32(event))
         strncat(bklist, (char *) pmbk32->name, 4);
      else
         strncat(bklist, (char *) pmbk->name, 4);
   } while (1);
   return (nbk);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bk_locate()

INT bk_locate	(	const void *	event,
		const char *	name,
		void *	pdata
	)

Locates a MIDAS bank of given name inside an event.

Parameters

event	pointer to current composed event
name	bank name to look for
pdata	pointer to data area of bank, NULL if bank not found

Returns

number of values inside the bank

Definition at line 18406 of file midas.cxx.

                                                                {
   BANK *pbk;
   BANK32 *pbk32;
   BANK32A *pbk32a;
   DWORD dname;
   const BANK_HEADER *pbh = (const BANK_HEADER *) event;
   const size_t event_size = (size_t) pbh->data_size + sizeof(BANK_HEADER);
 
   auto range_fits = [event, event_size](const void *ptr, size_t size) {
      ptrdiff_t offset = (const char *) ptr - (const char *) event;
      return offset >= 0 && (size_t) offset <= event_size && size <= event_size - (size_t) offset;
   };
 
   auto report_corrupt_bank = [pdata]() {
      cm_msg(MERROR, "bk_locate", "corrupted bank in event");
      *((void **) pdata) = NULL;
      return 0;
   };
 
   if (bk_is32a(event)) {
      pbk32a = (BANK32A *) (((BANK_HEADER *) event) + 1);
      copy_bk_name((char *) &dname, name);
      while (range_fits(pbk32a, 1)) {
         if (!range_fits(pbk32a, sizeof(BANK32A)))
            return report_corrupt_bank();
         size_t remaining = event_size - ((char *) pbk32a - (char *) event) - sizeof(BANK32A);
         size_t bank_size = pbk32a->data_size;
         size_t padding = (8 - bank_size % 8) % 8;
         if (bank_size > remaining || padding > remaining - bank_size)
            return report_corrupt_bank();
         if (*((DWORD *) pbk32a->name) == dname) {
            int tid = pbk32a->type & 0xFF;
            if (tid >= TID_LAST)
               return report_corrupt_bank();
            *((void **) pdata) = pbk32a + 1;
            if (tid_size[tid] == 0)
               return pbk32a->data_size;
            return pbk32a->data_size / tid_size[tid];
         }
         pbk32a = (BANK32A *) ((char *) (pbk32a + 1) + bank_size + padding);
      }
   } else if (bk_is32(event)) {
      pbk32 = (BANK32 *) (((BANK_HEADER *) event) + 1);
      copy_bk_name((char *) &dname, name);
      while (range_fits(pbk32, 1)) {
         if (!range_fits(pbk32, sizeof(BANK32)))
            return report_corrupt_bank();
         size_t remaining = event_size - ((char *) pbk32 - (char *) event) - sizeof(BANK32);
         size_t bank_size = pbk32->data_size;
         size_t padding = (8 - bank_size % 8) % 8;
         if (bank_size > remaining || padding > remaining - bank_size)
            return report_corrupt_bank();
         if (*((DWORD *) pbk32->name) == dname) {
            int tid = pbk32->type & 0xFF;
            if (tid >= TID_LAST)
               return report_corrupt_bank();
            *((void **) pdata) = pbk32 + 1;
            if (tid_size[tid] == 0)
               return pbk32->data_size;
            return pbk32->data_size / tid_size[tid];
         }
         pbk32 = (BANK32 *) ((char *) (pbk32 + 1) + bank_size + padding);
      }
   } else {
      pbk = (BANK *) (((BANK_HEADER *) event) + 1);
      copy_bk_name((char *) &dname, name);
      while (range_fits(pbk, 1)) {
         if (!range_fits(pbk, sizeof(BANK)))
            return report_corrupt_bank();
         size_t remaining = event_size - ((char *) pbk - (char *) event) - sizeof(BANK);
         size_t bank_size = pbk->data_size;
         size_t padding = (8 - bank_size % 8) % 8;
         if (bank_size > remaining || padding > remaining - bank_size)
            return report_corrupt_bank();
         if (*((DWORD *) pbk->name) == dname) {
            int tid = pbk->type & 0xFF;
            if (tid >= TID_LAST)
               return report_corrupt_bank();
            *((void **) pdata) = pbk + 1;
            if (tid_size[tid] == 0)
               return pbk->data_size;
            return pbk->data_size / tid_size[tid];
         }
         pbk = (BANK *) ((char *) (pbk + 1) + bank_size + padding);
      }
 
   }
 
   /* bank not found */
   *((void **) pdata) = NULL;
   return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bk_size()

INT bk_size

(

const void *

event

)

Returns the size of an event containing banks. The total size of an event is the value returned by bk_size() plus the size of the event header (sizeof(EVENT_HEADER)).

Parameters

event

pointer to the area of event

Returns

number of bytes contained in data area of event

Definition at line 18012 of file midas.cxx.

                               {
   return ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER);
}

Here is the caller graph for this function:

bk_swap()

INT bk_swap	(	void *	event,
		BOOL	force
	)

dox Swaps bytes from little endian to big endian or vice versa for a whole event.

An event contains a flag which is set by bk_init() to identify the endian format of an event. If force is FALSE, this flag is evaluated and the event is only swapped if it is in the "wrong" format for this system. An event can be swapped to the "wrong" format on purpose for example by a front-end which wants to produce events in a "right" format for a back-end analyzer which has different byte ordering.

Parameters

event	pointer to data area of event
force	If TRUE, the event is always swapped, if FALSE, the event is only swapped if it is in the wrong format.

Returns

1==event has been swap, 0==event has not been swapped.

Definition at line 18729 of file midas.cxx.

                                     {
   BANK_HEADER *pbh;
   BANK *pbk;
   BANK32 *pbk32;
   BANK32A *pbk32a;
   void *pdata;
   WORD type;
 
   pbh = (BANK_HEADER *) event;
 
   /* only swap if flags in high 16-bit */
   if (pbh->flags < 0x10000 && !force)
      return 0;
 
   /* swap bank header */
   DWORD_SWAP(&pbh->data_size);
   DWORD_SWAP(&pbh->flags);
 
   pbk = (BANK *) (pbh + 1);
   pbk32 = (BANK32 *) pbk;
   pbk32a = (BANK32A *) pbk;
 
   /* scan event */
   while ((char *) pbk - (char *) pbh < (INT) pbh->data_size + (INT) sizeof(BANK_HEADER)) {
      /* swap bank header */
      if (bk_is32a(event)) {
         DWORD_SWAP(&pbk32a->type);
         DWORD_SWAP(&pbk32a->data_size);
         pdata = pbk32a + 1;
         type = (WORD) pbk32a->type;
      } else if (bk_is32(event)) {
         DWORD_SWAP(&pbk32->type);
         DWORD_SWAP(&pbk32->data_size);
         pdata = pbk32 + 1;
         type = (WORD) pbk32->type;
      } else {
         WORD_SWAP(&pbk->type);
         WORD_SWAP(&pbk->data_size);
         pdata = pbk + 1;
         type = pbk->type;
      }
 
      /* pbk points to next bank */
      if (bk_is32a(event)) {
         pbk32a = (BANK32A *) ((char *) (pbk32a + 1) + ALIGN8(pbk32a->data_size));
         pbk = (BANK *) pbk32a;
      } else if (bk_is32(event)) {
         pbk32 = (BANK32 *) ((char *) (pbk32 + 1) + ALIGN8(pbk32->data_size));
         pbk = (BANK *) pbk32;
      } else {
         pbk = (BANK *) ((char *) (pbk + 1) + ALIGN8(pbk->data_size));
         pbk32 = (BANK32 *) pbk;
      }
 
      switch (type) {
         case TID_UINT16:
         case TID_INT16:
            while ((char *) pdata < (char *) pbk) {
               WORD_SWAP(pdata);
               pdata = (void *) (((WORD *) pdata) + 1);
            }
            break;
 
         case TID_UINT32:
         case TID_INT32:
         case TID_BOOL:
         case TID_FLOAT:
            while ((char *) pdata < (char *) pbk) {
               DWORD_SWAP(pdata);
               pdata = (void *) (((DWORD *) pdata) + 1);
            }
            break;
 
         case TID_DOUBLE:
         case TID_INT64:
         case TID_UINT64:
            while ((char *) pdata < (char *) pbk) {
               QWORD_SWAP(pdata);
               pdata = (void *) (((double *) pdata) + 1);
            }
            break;
      }
   }
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

copy_bk_name()

static void copy_bk_name ( char *  dst, const char *  src  )

static

Definition at line 18016 of file midas.cxx.

{
   // copy 4 byte bank name from "src" to "dst", set unused bytes of "dst" to NUL.
 
   if (src[0] == 0) {
      // invalid empty name
      dst[0] = 0;
      dst[1] = 0;
      dst[2] = 0;
      dst[3] = 0;
      return;
   }
 
   dst[0] = src[0];
 
   if (src[1] == 0) {
      dst[1] = 0;
      dst[2] = 0;
      dst[3] = 0;
      return;
   }
 
   dst[1] = src[1];
 
   if (src[2] == 0) {
      dst[2] = 0;
      dst[3] = 0;
      return;
   }
 
   dst[2] = src[2];
 
   if (src[3] == 0) {
      dst[3] = 0;
      return;
   }
 
   dst[3] = src[3];
}

Here is the caller graph for this function: