MIDAS
Loading...
Searching...
No Matches
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
eventpointer to current composed event
pdatapointer to the data
Returns
number of bytes contained in bank

Definition at line 16788 of file midas.cxx.

16788 {
16789 if (bk_is32a((BANK_HEADER *) event)) {
16790 BANK32A *pbk32a = (BANK32A *) ((char *) (((BANK_HEADER *) event) + 1) + ((BANK_HEADER *) event)->data_size);
16791 pbk32a->data_size = (DWORD) ((char *) pdata - (char *) (pbk32a + 1));
16792 if (pbk32a->type == TID_STRUCT && pbk32a->data_size == 0)
16793 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]);
16794 ((BANK_HEADER *) event)->data_size += sizeof(BANK32A) + ALIGN8(pbk32a->data_size);
16795 return pbk32a->data_size;
16796 } else if (bk_is32((BANK_HEADER *) event)) {
16797 BANK32 *pbk32 = (BANK32 *) ((char *) (((BANK_HEADER *) event) + 1) + ((BANK_HEADER *) event)->data_size);
16798 pbk32->data_size = (DWORD) ((char *) pdata - (char *) (pbk32 + 1));
16799 if (pbk32->type == TID_STRUCT && pbk32->data_size == 0)
16800 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]);
16801 ((BANK_HEADER *) event)->data_size += sizeof(BANK32) + ALIGN8(pbk32->data_size);
16802 return pbk32->data_size;
16803 } else {
16804 BANK *pbk = (BANK *) ((char *) (((BANK_HEADER *) event) + 1) + ((BANK_HEADER *) event)->data_size);
16805 uint32_t size = (uint32_t) ((char *) pdata - (char *) (pbk + 1));
16806 if (size > 0xFFFF) {
16807 printf("Error: Bank size %d exceeds 16-bit limit of 65526, please use bk_init32() to create a 32-bit bank\n", size);
16808 size = 0;
16809 }
16810 pbk->data_size = (WORD) (size);
16811 if (pbk->type == TID_STRUCT && pbk->data_size == 0)
16812 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]);
16813 size = ((BANK_HEADER *) event)->data_size + sizeof(BANK) + ALIGN8(pbk->data_size);
16814 if (size > 0xFFFF) {
16815 printf("Error: Bank size %d exceeds 16-bit limit of 65526, please use bk_init32() to create a 32-bit bank\n", size);
16816 size = 0;
16817 }
16818 ((BANK_HEADER *) event)->data_size = size;
16819 return pbk->data_size;
16820 }
16821}
BOOL bk_is32a(const void *event)
Definition midas.cxx:16445
BOOL bk_is32(const void *event)
Definition midas.cxx:16423
unsigned short int WORD
Definition mcstd.h:49
#define TID_STRUCT
Definition midas.h:348
#define ALIGN8(x)
Definition midas.h:522
#define DWORD
Definition mhdump.cxx:31
TH1X EXPRT * h1_book(const char *name, const char *title, int bins, double min, double max)
Definition rmidas.h:24
DWORD data_size
Definition midas.h:1228
DWORD data_size
Definition midas.h:1222
Definition midas.h:1213
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)
bknameBank to be found and copied from psrce to pevent
Returns
EB_SUCCESS if bank found, 0 if not found (pdest untouched)

Definition at line 16612 of file midas.cxx.

16612 {
16613
16614 INT status;
16617 BANK *psbkh;
16618 char *pdest;
16619 void *psdata;
16620
16621 // source pointing on the BANKxx
16622 psBkh = (BANK_HEADER *) ((EVENT_HEADER *) psrce + 1);
16623 // Find requested bank
16625 // Return 0 if not found
16626 if (status != SUCCESS) return 0;
16627
16628 // Check bank type...
16629 // You cannot mix BANK and BANK32 so make sure all the FE use either
16630 // bk_init(pevent) or bk_init32(pevent).
16631 if (bk_is32a(psBkh)) {
16632
16633 // pointer to the source bank header
16634 BANK32A *psbkh32a = ((BANK32A *) psdata - 1);
16635 // Data size in the bank
16637
16638 // Get to the end of the event
16639 pdest = (char *) (((BANK_HEADER *) pevent) + 1) + ((BANK_HEADER *) pevent)->data_size;
16640 // Copy from BANK32 to end of Data
16641 memmove(pdest, (char *) psbkh32a, ALIGN8(bksze) + sizeof(BANK32A));
16642 // Bring pointer to the next free location
16643 pdest += ALIGN8(bksze) + sizeof(BANK32A);
16644
16645 } else if (bk_is32(psBkh)) {
16646
16647 // pointer to the source bank header
16648 BANK32 *psbkh32 = ((BANK32 *) psdata - 1);
16649 // Data size in the bank
16651
16652 // Get to the end of the event
16653 pdest = (char *) (((BANK_HEADER *) pevent) + 1) + ((BANK_HEADER *) pevent)->data_size;
16654 // Copy from BANK32 to end of Data
16655 memmove(pdest, (char *) psbkh32, ALIGN8(bksze) + sizeof(BANK32));
16656 // Bring pointer to the next free location
16657 pdest += ALIGN8(bksze) + sizeof(BANK32);
16658
16659 } else {
16660
16661 // pointer to the source bank header
16662 psbkh = ((BANK *) psdata - 1);
16663 // Data size in the bank
16664 bksze = psbkh->data_size;
16665
16666 // Get to the end of the event
16667 pdest = (char *) (((BANK_HEADER *) pevent) + 1) + ((BANK_HEADER *) pevent)->data_size;
16668 // Copy from BANK to end of Data
16669 memmove(pdest, (char *) psbkh, ALIGN8(bksze) + sizeof(BANK));
16670 // Bring pointer to the next free location
16671 pdest += ALIGN8(bksze) + sizeof(BANK);
16672 }
16673
16674 // Close bank (adjust BANK_HEADER size)
16675 bk_close(pevent, pdest);
16676 // Adjust EVENT_HEADER size
16677 ((EVENT_HEADER *) pevent - 1)->data_size = ((BANK_HEADER *) pevent)->data_size + sizeof(BANK_HEADER);
16678 return SUCCESS;
16679}
INT bk_close(void *event, void *pdata)
Definition midas.cxx:16788
INT bk_find(const BANK_HEADER *pbkh, const char *name, DWORD *bklen, DWORD *bktype, void **pdata)
Definition midas.cxx:16960
unsigned int DWORD
Definition mcstd.h:51
#define SUCCESS
Definition mcstd.h:54
int INT
Definition midas.h:129
DWORD status
Definition odbhist.cxx:39
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.

bk_init(pevent);
bk_create(pevent, "ADC0", TID_INT32, &pdata);
*pdata++ = 123
*pdata++ = 456
bk_close(pevent, pdata);
void bk_init(void *event)
Definition midas.cxx:16414
void bk_create(void *event, const char *name, WORD type, void **pdata)
Definition midas.cxx:16569
#define TID_INT32
Definition midas.h:339
Parameters
eventpointer to the data area
nameof the bank, must be exactly 4 charaters
typetype of bank, one of the Midas_Data_Types values defined in midas.h
pdatapointer to the data area of the newly created bank
Returns
void

Definition at line 16569 of file midas.cxx.

16569 {
16570 if (bk_is32a((BANK_HEADER *) event)) {
16571 if (((PTYPE) event & 0x07) != 0) {
16572 cm_msg(MERROR, "bk_create", "Bank %s created with unaligned event pointer", name);
16573 return;
16574 }
16575 BANK32A *pbk32a;
16576
16577 pbk32a = (BANK32A *) ((char *) (((BANK_HEADER *) event) + 1) + ((BANK_HEADER *) event)->data_size);
16578 copy_bk_name(pbk32a->name, name);
16579 pbk32a->type = type;
16580 pbk32a->data_size = 0;
16581 *pdata = pbk32a + 1;
16582 } else if (bk_is32((BANK_HEADER *) event)) {
16583 BANK32 *pbk32;
16584
16585 pbk32 = (BANK32 *) ((char *) (((BANK_HEADER *) event) + 1) + ((BANK_HEADER *) event)->data_size);
16586 copy_bk_name(pbk32->name, name);
16587 pbk32->type = type;
16588 pbk32->data_size = 0;
16589 *pdata = pbk32 + 1;
16590 } else {
16591 BANK *pbk;
16592
16593 pbk = (BANK *) ((char *) (((BANK_HEADER *) event) + 1) + ((BANK_HEADER *) event)->data_size);
16594 copy_bk_name(pbk->name, name);
16595 pbk->type = type;
16596 pbk->data_size = 0;
16597 *pdata = pbk + 1;
16598 }
16599}
static void copy_bk_name(char *dst, const char *src)
Definition midas.cxx:16507
#define MERROR
Definition midas.h:559
INT cm_msg(INT message_type, const char *filename, INT line, const char *routine, const char *format,...)
Definition midas.cxx:915
INT type
Definition mana.cxx:269
#define PTYPE
Definition midas.h:170
#define name(x)
Definition midas_macro.h:24
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 16682 of file midas.cxx.

16698{
16699 BANK *pbk;
16700 DWORD dname;
16701 int remaining;
16702
16703 if (bk_is32a((BANK_HEADER *) event)) {
16704 /* locate bank */
16705 BANK32A *pbk32a = (BANK32A *) (((BANK_HEADER *) event) + 1);
16706 copy_bk_name((char *) &dname, name);
16707 do {
16708 if (*((DWORD *) pbk32a->name) == dname) {
16709 /* bank found, delete it */
16710 remaining = ((char *) event + ((BANK_HEADER *) event)->data_size +
16711 sizeof(BANK_HEADER)) - ((char *) (pbk32a + 1) + ALIGN8(pbk32a->data_size));
16712
16713 /* reduce total event size */
16714 ((BANK_HEADER *) event)->data_size -= sizeof(BANK32) + ALIGN8(pbk32a->data_size);
16715
16716 /* copy remaining bytes */
16717 if (remaining > 0)
16718 memmove(pbk32a, (char *) (pbk32a + 1) + ALIGN8(pbk32a->data_size), remaining);
16719 return CM_SUCCESS;
16720 }
16721
16722 pbk32a = (BANK32A *) ((char *) (pbk32a + 1) + ALIGN8(pbk32a->data_size));
16723 } while ((DWORD) ((char *) pbk32a - (char *) event) <
16724 ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER));
16725 } else if (bk_is32((BANK_HEADER *) event)) {
16726 /* locate bank */
16727 BANK32 *pbk32 = (BANK32 *) (((BANK_HEADER *) event) + 1);
16728 copy_bk_name((char *) &dname, name);
16729 do {
16730 if (*((DWORD *) pbk32->name) == dname) {
16731 /* bank found, delete it */
16732 remaining = ((char *) event + ((BANK_HEADER *) event)->data_size +
16733 sizeof(BANK_HEADER)) - ((char *) (pbk32 + 1) + ALIGN8(pbk32->data_size));
16734
16735 /* reduce total event size */
16736 ((BANK_HEADER *) event)->data_size -= sizeof(BANK32) + ALIGN8(pbk32->data_size);
16737
16738 /* copy remaining bytes */
16739 if (remaining > 0)
16740 memmove(pbk32, (char *) (pbk32 + 1) + ALIGN8(pbk32->data_size), remaining);
16741 return CM_SUCCESS;
16742 }
16743
16744 pbk32 = (BANK32 *) ((char *) (pbk32 + 1) + ALIGN8(pbk32->data_size));
16745 } while ((DWORD) ((char *) pbk32 - (char *) event) <
16746 ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER));
16747 } else {
16748 /* locate bank */
16749 pbk = (BANK *) (((BANK_HEADER *) event) + 1);
16750 copy_bk_name((char *) &dname, name);
16751 do {
16752 if (*((DWORD *) pbk->name) == dname) {
16753 /* bank found, delete it */
16754 remaining = ((char *) event + ((BANK_HEADER *) event)->data_size +
16755 sizeof(BANK_HEADER)) - ((char *) (pbk + 1) + ALIGN8(pbk->data_size));
16756
16757 /* reduce total event size */
16758 ((BANK_HEADER *) event)->data_size -= sizeof(BANK) + ALIGN8(pbk->data_size);
16759
16760 /* copy remaining bytes */
16761 if (remaining > 0)
16762 memmove(pbk, (char *) (pbk + 1) + ALIGN8(pbk->data_size), remaining);
16763 return CM_SUCCESS;
16764 }
16765
16766 pbk = (BANK *) ((char *) (pbk + 1) + ALIGN8(pbk->data_size));
16767 } while ((DWORD) ((char *) pbk - (char *) event) <
16768 ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER));
16769 }
16770
16771 return 0;
16772}
#define CM_SUCCESS
Definition midas.h:582
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
pbkhpointer to current composed event
namebank name to look for
bklennumber of elemtents in bank
bktypebank type, one of TID_xxx
pdatapointer to data area of bank, NULL if bank not found
Returns
1 if bank found, 0 otherwise

Definition at line 16960 of file midas.cxx.

16960 {
16961 DWORD dname;
16962
16963 if (bk_is32a(pbkh)) {
16964 BANK32A *pbk32a = (BANK32A *) (pbkh + 1);
16965 copy_bk_name((char *) &dname, name);
16966 do {
16967 if (*((DWORD *) pbk32a->name) == dname) {
16968 *((void **) pdata) = pbk32a + 1;
16969 if (tid_size[pbk32a->type & 0xFF] == 0)
16970 *bklen = pbk32a->data_size;
16971 else
16972 *bklen = pbk32a->data_size / tid_size[pbk32a->type & 0xFF];
16973
16974 *bktype = pbk32a->type;
16975 return 1;
16976 }
16977 pbk32a = (BANK32A *) ((char *) (pbk32a + 1) + ALIGN8(pbk32a->data_size));
16978 } while ((DWORD) ((char *) pbk32a - (char *) pbkh) < pbkh->data_size + sizeof(BANK_HEADER));
16979 } else if (bk_is32(pbkh)) {
16980 BANK32 *pbk32 = (BANK32 *) (pbkh + 1);
16981 copy_bk_name((char *) &dname, name);
16982 do {
16983 if (*((DWORD *) pbk32->name) == dname) {
16984 *((void **) pdata) = pbk32 + 1;
16985 if (tid_size[pbk32->type & 0xFF] == 0)
16986 *bklen = pbk32->data_size;
16987 else
16988 *bklen = pbk32->data_size / tid_size[pbk32->type & 0xFF];
16989
16990 *bktype = pbk32->type;
16991 return 1;
16992 }
16993 pbk32 = (BANK32 *) ((char *) (pbk32 + 1) + ALIGN8(pbk32->data_size));
16994 } while ((DWORD) ((char *) pbk32 - (char *) pbkh) < pbkh->data_size + sizeof(BANK_HEADER));
16995 } else {
16996 BANK *pbk = (BANK *) (pbkh + 1);
16997 copy_bk_name((char *) &dname, name);
16998 do {
16999 if (*((DWORD *) pbk->name) == dname) {
17000 *((void **) pdata) = pbk + 1;
17001 if (tid_size[pbk->type & 0xFF] == 0)
17002 *bklen = pbk->data_size;
17003 else
17004 *bklen = pbk->data_size / tid_size[pbk->type & 0xFF];
17005
17006 *bktype = pbk->type;
17007 return 1;
17008 }
17009 pbk = (BANK *) ((char *) (pbk + 1) + ALIGN8(pbk->data_size));
17010 } while ((DWORD) ((char *) pbk - (char *) pbkh) < pbkh->data_size + sizeof(BANK_HEADER));
17011 }
17012
17013 /* bank not found */
17014 *((void **) pdata) = NULL;
17015 return 0;
17016}
static const int tid_size[]
Definition midas.cxx:66
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
eventpointer to the area of event

Definition at line 16414 of file midas.cxx.

16414 {
16415 ((BANK_HEADER *) event)->data_size = 0;
16416 ((BANK_HEADER *) event)->flags = BANK_FORMAT_VERSION;
16417}
#define BANK_FORMAT_VERSION
Definition midas.h:1201
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
eventpointer to the area of event
Returns
void

Definition at line 16477 of file midas.cxx.

16477 {
16478 ((BANK_HEADER *) event)->data_size = 0;
16479 ((BANK_HEADER *) event)->flags = BANK_FORMAT_VERSION | BANK_FORMAT_32BIT;
16480}
#define BANK_FORMAT_32BIT
Definition midas.h:1202
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
eventpointer to the area of event
Returns
void

Definition at line 16490 of file midas.cxx.

16490 {
16491 ((BANK_HEADER *) event)->data_size = 0;
16493}
#define BANK_FORMAT_64BIT_ALIGNED
Definition midas.h:1203
Here is the caller graph for this function:

◆ bk_is32()

BOOL bk_is32 ( const void event)

dox

Definition at line 16423 of file midas.cxx.

16440{
16441 return ((((BANK_HEADER *) event)->flags & BANK_FORMAT_32BIT) > 0);
16442}
Here is the caller graph for this function:

◆ bk_is32a()

BOOL bk_is32a ( const void event)

Definition at line 16445 of file midas.cxx.

16463{
16464 return ((((BANK_HEADER *) event)->flags & BANK_FORMAT_64BIT_ALIGNED) > 0);
16465}
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 data_size;
} BANK;

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

INT size;
void *pdata;
char name[5];
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);
INT bk_iterate(const void *event, BANK **pbk, void *pdata)
Definition midas.cxx:17054
#define TRUE
Definition midas.h:182
Parameters
eventPointer to data area of event.
pbkpointer to the bank header, must be NULL for the first call to this function.
pdataPointer to the bank header, must be NULL for the first call to this function
Returns
Size of bank in bytes

Definition at line 17054 of file midas.cxx.

17054 {
17055 if (*pbk == NULL)
17056 *pbk = (BANK *) (((BANK_HEADER *) event) + 1);
17057 else
17058 *pbk = (BANK *) ((char *) (*pbk + 1) + ALIGN8((*pbk)->data_size));
17059
17060 *((void **) pdata) = (*pbk) + 1;
17061
17062 if ((DWORD) ((char *) *pbk - (char *) event) >= ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER)) {
17063 *pbk = *((BANK **) pdata) = NULL;
17064 return 0;
17065 }
17066
17067 return (*pbk)->data_size;
17068}
Here is the call graph for this function:
Here is the caller graph for this function:

◆ bk_iterate32()

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

dox

Definition at line 17075 of file midas.cxx.

17094{
17095 if (*pbk == NULL)
17096 *pbk = (BANK32 *) (((BANK_HEADER *) event) + 1);
17097 else
17098 *pbk = (BANK32 *) ((char *) (*pbk + 1) + ALIGN8((*pbk)->data_size));
17099
17100 *((void **) pdata) = (*pbk) + 1;
17101
17102 if ((DWORD) ((char *) *pbk - (char *) event) >= ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER)) {
17103 *pbk = NULL;
17104 pdata = NULL;
17105 return 0;
17106 }
17107
17108 return (*pbk)->data_size;
17109}
Here is the call graph for this function:
Here is the caller graph for this function:

◆ bk_iterate32a()

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

Definition at line 17111 of file midas.cxx.

17130{
17131 if (*pbk32a == NULL)
17132 *pbk32a = (BANK32A *) (((BANK_HEADER *) event) + 1);
17133 else
17134 *pbk32a = (BANK32A *) ((char *) (*pbk32a + 1) + ALIGN8((*pbk32a)->data_size));
17135
17136 *((void **) pdata) = (*pbk32a) + 1;
17137
17138 if ((DWORD) ((char *) *pbk32a - (char *) event) >= ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER)) {
17139 *pbk32a = NULL;
17140 pdata = NULL;
17141 return 0;
17142 }
17143
17144 return (*pbk32a)->data_size;
17145}
Here is the call graph for this function:
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)
{
// 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);
...
}
INT adc_calib(EVENT_HEADER *, void *)
Definition adccalib.cxx:107
INT bk_locate(const void *event, const char *name, void *pdata)
Definition midas.cxx:16897
INT bk_list(const void *event, char *bklist)
Definition midas.cxx:16848
#define STRING_BANKLIST_MAX
Definition midas.h:279
Parameters
eventpointer to current composed event
bklistreturned ASCII string, has to be booked with STRING_BANKLIST_MAX.
Returns
number of bank found in this event.

Definition at line 16848 of file midas.cxx.

16848 { /* Full event */
16849 INT nbk;
16850 BANK *pmbk = NULL;
16851 BANK32 *pmbk32 = NULL;
16852 BANK32A *pmbk32a = NULL;
16853 char *pdata;
16854
16855 /* compose bank list */
16856 bklist[0] = 0;
16857 nbk = 0;
16858 do {
16859 /* scan all banks for bank name only */
16860 if (bk_is32a(event)) {
16861 bk_iterate32a(event, &pmbk32a, &pdata);
16862 if (pmbk32a == NULL)
16863 break;
16864 } else if (bk_is32(event)) {
16865 bk_iterate32(event, &pmbk32, &pdata);
16866 if (pmbk32 == NULL)
16867 break;
16868 } else {
16869 bk_iterate(event, &pmbk, &pdata);
16870 if (pmbk == NULL)
16871 break;
16872 }
16873 nbk++;
16874
16875 if (nbk > BANKLIST_MAX) {
16876 cm_msg(MINFO, "bk_list", "over %i banks -> truncated", BANKLIST_MAX);
16877 return (nbk - 1);
16878 }
16879 if (bk_is32a(event))
16880 strncat(bklist, (char *) pmbk32a->name, 4);
16881 else if (bk_is32(event))
16882 strncat(bklist, (char *) pmbk32->name, 4);
16883 else
16884 strncat(bklist, (char *) pmbk->name, 4);
16885 } while (1);
16886 return (nbk);
16887}
INT bk_iterate32a(const void *event, BANK32A **pbk32a, void *pdata)
Definition midas.cxx:17111
INT bk_iterate32(const void *event, BANK32 **pbk, void *pdata)
Definition midas.cxx:17075
#define MINFO
Definition midas.h:560
#define BANKLIST_MAX
Definition midas.h:278
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
eventpointer to current composed event
namebank name to look for
pdatapointer to data area of bank, NULL if bank not found
Returns
number of values inside the bank

Definition at line 16897 of file midas.cxx.

16897 {
16898 BANK *pbk;
16899 BANK32 *pbk32;
16900 BANK32A *pbk32a;
16901 DWORD dname;
16902
16903 if (bk_is32a(event)) {
16904 pbk32a = (BANK32A *) (((BANK_HEADER *) event) + 1);
16905 copy_bk_name((char *) &dname, name);
16906 while ((DWORD) ((char *) pbk32a - (char *) event) <
16907 ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER)) {
16908 if (*((DWORD *) pbk32a->name) == dname) {
16909 *((void **) pdata) = pbk32a + 1;
16910 if (tid_size[pbk32a->type & 0xFF] == 0)
16911 return pbk32a->data_size;
16912 return pbk32a->data_size / tid_size[pbk32a->type & 0xFF];
16913 }
16914 pbk32a = (BANK32A *) ((char *) (pbk32a + 1) + ALIGN8(pbk32a->data_size));
16915 }
16916 } else if (bk_is32(event)) {
16917 pbk32 = (BANK32 *) (((BANK_HEADER *) event) + 1);
16918 copy_bk_name((char *) &dname, name);
16919 while ((DWORD) ((char *) pbk32 - (char *) event) <
16920 ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER)) {
16921 if (*((DWORD *) pbk32->name) == dname) {
16922 *((void **) pdata) = pbk32 + 1;
16923 if (tid_size[pbk32->type & 0xFF] == 0)
16924 return pbk32->data_size;
16925 return pbk32->data_size / tid_size[pbk32->type & 0xFF];
16926 }
16927 pbk32 = (BANK32 *) ((char *) (pbk32 + 1) + ALIGN8(pbk32->data_size));
16928 }
16929 } else {
16930 pbk = (BANK *) (((BANK_HEADER *) event) + 1);
16931 copy_bk_name((char *) &dname, name);
16932 while ((DWORD) ((char *) pbk - (char *) event) <
16933 ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER)) {
16934 if (*((DWORD *) pbk->name) == dname) {
16935 *((void **) pdata) = pbk + 1;
16936 if (tid_size[pbk->type & 0xFF] == 0)
16937 return pbk->data_size;
16938 return pbk->data_size / tid_size[pbk->type & 0xFF];
16939 }
16940 pbk = (BANK *) ((char *) (pbk + 1) + ALIGN8(pbk->data_size));
16941 }
16942
16943 }
16944
16945 /* bank not found */
16946 *((void **) pdata) = NULL;
16947 return 0;
16948}
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
eventpointer to the area of event
Returns
number of bytes contained in data area of event

Definition at line 16503 of file midas.cxx.

16503 {
16504 return ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER);
16505}
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
eventpointer to data area of event
forceIf 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 17165 of file midas.cxx.

17165 {
17167 BANK *pbk;
17168 BANK32 *pbk32;
17169 BANK32A *pbk32a;
17170 void *pdata;
17171 WORD type;
17172
17173 pbh = (BANK_HEADER *) event;
17174
17175 /* only swap if flags in high 16-bit */
17176 if (pbh->flags < 0x10000 && !force)
17177 return 0;
17178
17179 /* swap bank header */
17180 DWORD_SWAP(&pbh->data_size);
17181 DWORD_SWAP(&pbh->flags);
17182
17183 pbk = (BANK *) (pbh + 1);
17184 pbk32 = (BANK32 *) pbk;
17185 pbk32a = (BANK32A *) pbk;
17186
17187 /* scan event */
17188 while ((char *) pbk - (char *) pbh < (INT) pbh->data_size + (INT) sizeof(BANK_HEADER)) {
17189 /* swap bank header */
17190 if (bk_is32a(event)) {
17191 DWORD_SWAP(&pbk32a->type);
17192 DWORD_SWAP(&pbk32a->data_size);
17193 pdata = pbk32a + 1;
17194 type = (WORD) pbk32a->type;
17195 } else if (bk_is32(event)) {
17196 DWORD_SWAP(&pbk32->type);
17197 DWORD_SWAP(&pbk32->data_size);
17198 pdata = pbk32 + 1;
17199 type = (WORD) pbk32->type;
17200 } else {
17201 WORD_SWAP(&pbk->type);
17202 WORD_SWAP(&pbk->data_size);
17203 pdata = pbk + 1;
17204 type = pbk->type;
17205 }
17206
17207 /* pbk points to next bank */
17208 if (bk_is32a(event)) {
17209 pbk32a = (BANK32A *) ((char *) (pbk32a + 1) + ALIGN8(pbk32a->data_size));
17210 pbk = (BANK *) pbk32a;
17211 } else if (bk_is32(event)) {
17212 pbk32 = (BANK32 *) ((char *) (pbk32 + 1) + ALIGN8(pbk32->data_size));
17213 pbk = (BANK *) pbk32;
17214 } else {
17215 pbk = (BANK *) ((char *) (pbk + 1) + ALIGN8(pbk->data_size));
17216 pbk32 = (BANK32 *) pbk;
17217 }
17218
17219 switch (type) {
17220 case TID_UINT16:
17221 case TID_INT16:
17222 while ((char *) pdata < (char *) pbk) {
17224 pdata = (void *) (((WORD *) pdata) + 1);
17225 }
17226 break;
17227
17228 case TID_UINT32:
17229 case TID_INT32:
17230 case TID_BOOL:
17231 case TID_FLOAT:
17232 while ((char *) pdata < (char *) pbk) {
17234 pdata = (void *) (((DWORD *) pdata) + 1);
17235 }
17236 break;
17237
17238 case TID_DOUBLE:
17239 case TID_INT64:
17240 case TID_UINT64:
17241 while ((char *) pdata < (char *) pbk) {
17243 pdata = (void *) (((double *) pdata) + 1);
17244 }
17245 break;
17246 }
17247 }
17248
17249 return CM_SUCCESS;
17250}
#define TID_DOUBLE
Definition midas.h:343
#define TID_BOOL
Definition midas.h:340
#define TID_UINT64
Definition midas.h:352
#define TID_INT64
Definition midas.h:351
#define TID_UINT32
Definition midas.h:337
#define TID_UINT16
Definition midas.h:333
#define TID_INT16
Definition midas.h:335
#define TID_FLOAT
Definition midas.h:341
#define WORD_SWAP(x)
Definition msystem.h:65
#define QWORD_SWAP(x)
Definition msystem.h:86
#define DWORD_SWAP(x)
Definition msystem.h:74
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 16507 of file midas.cxx.

16508{
16509 // copy 4 byte bank name from "src" to "dst", set unused bytes of "dst" to NUL.
16510
16511 if (src[0] == 0) {
16512 // invalid empty name
16513 dst[0] = 0;
16514 dst[1] = 0;
16515 dst[2] = 0;
16516 dst[3] = 0;
16517 return;
16518 }
16519
16520 dst[0] = src[0];
16521
16522 if (src[1] == 0) {
16523 dst[1] = 0;
16524 dst[2] = 0;
16525 dst[3] = 0;
16526 return;
16527 }
16528
16529 dst[1] = src[1];
16530
16531 if (src[2] == 0) {
16532 dst[2] = 0;
16533 dst[3] = 0;
16534 return;
16535 }
16536
16537 dst[2] = src[2];
16538
16539 if (src[3] == 0) {
16540 dst[3] = 0;
16541 return;
16542 }
16543
16544 dst[3] = src[3];
16545}
Here is the caller graph for this function: