Functions | |
void | bk_init (void *event) |
void | bk_init32 (void *event) |
INT | bk_size (void *event) |
void | bk_create (void *event, const char *name, WORD type, void *pdata) |
INT | bk_close (void *event, void *pdata) |
INT | bk_list (void *event, char *bklist) |
INT | bk_locate (void *event, const char *name, void *pdata) |
INT | bk_find (BANK_HEADER *pbkh, const char *name, DWORD *bklen, DWORD *bktype, void **pdata) |
INT | bk_iterate (void *event, BANK **pbk, void *pdata) |
INT | bk_swap (void *event, BOOL force) |
INT bk_close | ( | void * | event, | |
void * | pdata | |||
) |
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
event | pointer to current composed event | |
pdata | pointer to the data |
Definition at line 13042 of file midas.c.
Referenced by adc_calib(), read_scaler_event(), read_trigger_event(), scaler_accum(), and write_event_midas().
13043 { 13044 if (((BANK_HEADER *) event)->flags & BANK_FORMAT_32BIT) { 13045 BANK32 *pbk32; 13046 13047 pbk32 = (BANK32 *) ((char *) (((BANK_HEADER *) event) + 1) + ((BANK_HEADER *) event)->data_size); 13048 pbk32->data_size = (DWORD) ((char *) pdata - (char *) (pbk32 + 1)); 13049 if (pbk32->type == TID_STRUCT && pbk32->data_size == 0) 13050 printf("Warning: bank %c%c%c%c has zero size\n", 13051 pbk32->name[0], pbk32->name[1], pbk32->name[2], pbk32->name[3]); 13052 ((BANK_HEADER *) event)->data_size += sizeof(BANK32) + ALIGN8(pbk32->data_size); 13053 return pbk32->data_size; 13054 } else { 13055 BANK *pbk; 13056 13057 pbk = (BANK *) ((char *) (((BANK_HEADER *) event) + 1) + ((BANK_HEADER *) event)->data_size); 13058 pbk->data_size = (WORD) ((char *) pdata - (char *) (pbk + 1)); 13059 if (pbk->type == TID_STRUCT && pbk->data_size == 0) 13060 printf("Warning: bank %c%c%c%c has zero size\n", pbk->name[0], pbk->name[1], pbk->name[2], 13061 pbk->name[3]); 13062 ((BANK_HEADER *) event)->data_size += sizeof(BANK) + ALIGN8(pbk->data_size); 13063 return pbk->data_size; 13064 } 13065 }
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_INT, &pdata); *pdata++ = 123 *pdata++ = 456 bk_close(pevent, pdata);
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 |
Definition at line 12930 of file midas.c.
Referenced by adc_calib(), adc_summing(), eb_user(), read_scaler_event(), read_trigger_event(), scaler_accum(), and write_event_midas().
12931 { 12932 if (((BANK_HEADER *) event)->flags & BANK_FORMAT_32BIT) { 12933 BANK32 *pbk32; 12934 12935 pbk32 = (BANK32 *) ((char *) (((BANK_HEADER *) event) + 1) + ((BANK_HEADER *) event)->data_size); 12936 strncpy(pbk32->name, name, 4); 12937 pbk32->type = type; 12938 pbk32->data_size = 0; 12939 *((void **) pdata) = pbk32 + 1; 12940 } else { 12941 BANK *pbk; 12942 12943 pbk = (BANK *) ((char *) (((BANK_HEADER *) event) + 1) + ((BANK_HEADER *) event)->data_size); 12944 strncpy(pbk->name, name, 4); 12945 pbk->type = type; 12946 pbk->data_size = 0; 12947 *((void **) pdata) = pbk + 1; 12948 } 12949 }
INT bk_find | ( | BANK_HEADER * | pbkh, | |
const char * | name, | |||
DWORD * | bklen, | |||
DWORD * | bktype, | |||
void ** | pdata | |||
) |
Finds a MIDAS bank of given name inside an event.
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 |
Definition at line 13186 of file midas.c.
13187 { 13188 BANK *pbk; 13189 BANK32 *pbk32; 13190 DWORD dname; 13191 13192 if (bk_is32(pbkh)) { 13193 pbk32 = (BANK32 *) (pbkh + 1); 13194 strncpy((char *) &dname, name, 4); 13195 do { 13196 if (*((DWORD *) pbk32->name) == dname) { 13197 *((void **) pdata) = pbk32 + 1; 13198 if (tid_size[pbk32->type & 0xFF] == 0) 13199 *bklen = pbk32->data_size; 13200 else 13201 *bklen = pbk32->data_size / tid_size[pbk32->type & 0xFF]; 13202 13203 *bktype = pbk32->type; 13204 return 1; 13205 } 13206 pbk32 = (BANK32 *) ((char *) (pbk32 + 1) + ALIGN8(pbk32->data_size)); 13207 } while ((DWORD) ((char *) pbk32 - (char *) pbkh) < pbkh->data_size + sizeof(BANK_HEADER)); 13208 } else { 13209 pbk = (BANK *) (pbkh + 1); 13210 strncpy((char *) &dname, name, 4); 13211 do { 13212 if (*((DWORD *) pbk->name) == dname) { 13213 *((void **) pdata) = pbk + 1; 13214 if (tid_size[pbk->type & 0xFF] == 0) 13215 *bklen = pbk->data_size; 13216 else 13217 *bklen = pbk->data_size / tid_size[pbk->type & 0xFF]; 13218 13219 *bktype = pbk->type; 13220 return 1; 13221 } 13222 pbk = (BANK *) ((char *) (pbk + 1) + ALIGN8(pbk->data_size)); 13223 } while ((DWORD) ((char *) pbk - (char *) pbkh) < pbkh->data_size + sizeof(BANK_HEADER)); 13224 } 13225 13226 /* bank not found */ 13227 *((void **) pdata) = NULL; 13228 return 0; 13229 }
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.
event | pointer to the area of event |
Definition at line 12848 of file midas.c.
Referenced by eb_user(), read_scaler_event(), read_trigger_event(), and write_event_midas().
12849 { 12850 ((BANK_HEADER *) event)->data_size = 0; 12851 ((BANK_HEADER *) event)->flags = BANK_FORMAT_VERSION; 12852 }
void bk_init32 | ( | void * | event | ) |
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.
event | pointer to the area of event |
Definition at line 12889 of file midas.c.
Referenced by write_event_midas().
12890 { 12891 ((BANK_HEADER *) event)->data_size = 0; 12892 ((BANK_HEADER *) event)->flags = BANK_FORMAT_VERSION | BANK_FORMAT_32BIT; 12893 }
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:
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);
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 |
Definition at line 13267 of file midas.c.
Referenced by ascii_write(), bk_list(), dump_write(), md_bank_event_display(), update_odb(), write_event_ascii(), write_event_hbook(), write_event_midas(), and write_event_odb().
13268 { 13269 if (*pbk == NULL) 13270 *pbk = (BANK *) (((BANK_HEADER *) event) + 1); 13271 else 13272 *pbk = (BANK *) ((char *) (*pbk + 1) + ALIGN8((*pbk)->data_size)); 13273 13274 *((void **) pdata) = (*pbk) + 1; 13275 13276 if ((DWORD) ((char *) *pbk - (char *) event) >= ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER)) { 13277 *pbk = *((BANK **) pdata) = NULL; 13278 return 0; 13279 } 13280 13281 return (*pbk)->data_size; 13282 }
INT bk_list | ( | 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); ... }
event | pointer to current composed event | |
bklist | returned ASCII string, has to be booked with STRING_BANKLIST_MAX. |
Definition at line 13092 of file midas.c.
Referenced by md_bank_event_display().
13093 { /* Full event */ 13094 INT nbk, size; 13095 BANK *pmbk = NULL; 13096 BANK32 *pmbk32 = NULL; 13097 char *pdata; 13098 13099 /* compose bank list */ 13100 bklist[0] = 0; 13101 nbk = 0; 13102 do { 13103 /* scan all banks for bank name only */ 13104 if (bk_is32(event)) { 13105 size = bk_iterate32(event, &pmbk32, &pdata); 13106 if (pmbk32 == NULL) 13107 break; 13108 } else { 13109 size = bk_iterate(event, &pmbk, &pdata); 13110 if (pmbk == NULL) 13111 break; 13112 } 13113 nbk++; 13114 13115 if (nbk > BANKLIST_MAX) { 13116 cm_msg(MINFO, "bk_list", "over %i banks -> truncated", BANKLIST_MAX); 13117 return (nbk - 1); 13118 } 13119 if (bk_is32(event)) 13120 strncat(bklist, (char *) pmbk32->name, 4); 13121 else 13122 strncat(bklist, (char *) pmbk->name, 4); 13123 } 13124 while (1); 13125 return (nbk); 13126 }
INT bk_locate | ( | void * | event, | |
const char * | name, | |||
void * | pdata | |||
) |
Locates a MIDAS bank of given name inside an event.
event | pointer to current composed event | |
name | bank name to look for | |
pdata | pointer to data area of bank, NULL if bank not found |
Definition at line 13136 of file midas.c.
Referenced by adc_calib(), adc_summing(), md_bank_event_display(), and scaler_accum().
13137 { 13138 BANK *pbk; 13139 BANK32 *pbk32; 13140 DWORD dname; 13141 13142 if (bk_is32(event)) { 13143 pbk32 = (BANK32 *) (((BANK_HEADER *) event) + 1); 13144 strncpy((char *) &dname, name, 4); 13145 while ((DWORD) ((char *) pbk32 - (char *) event) < 13146 ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER)) { 13147 if (*((DWORD *) pbk32->name) == dname) { 13148 *((void **) pdata) = pbk32 + 1; 13149 if (tid_size[pbk32->type & 0xFF] == 0) 13150 return pbk32->data_size; 13151 return pbk32->data_size / tid_size[pbk32->type & 0xFF]; 13152 } 13153 pbk32 = (BANK32 *) ((char *) (pbk32 + 1) + ALIGN8(pbk32->data_size)); 13154 } 13155 } else { 13156 pbk = (BANK *) (((BANK_HEADER *) event) + 1); 13157 strncpy((char *) &dname, name, 4); 13158 while ((DWORD) ((char *) pbk - (char *) event) < 13159 ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER)) { 13160 if (*((DWORD *) pbk->name) == dname) { 13161 *((void **) pdata) = pbk + 1; 13162 if (tid_size[pbk->type & 0xFF] == 0) 13163 return pbk->data_size; 13164 return pbk->data_size / tid_size[pbk->type & 0xFF]; 13165 } 13166 pbk = (BANK *) ((char *) (pbk + 1) + ALIGN8(pbk->data_size)); 13167 } 13168 13169 } 13170 13171 /* bank not found */ 13172 *((void **) pdata) = NULL; 13173 return 0; 13174 }
INT bk_size | ( | 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)).
event | pointer to the area of event |
Definition at line 12903 of file midas.c.
Referenced by eb_user(), process_event(), read_scaler_event(), and read_trigger_event().
12904 { 12905 return ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER); 12906 }
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.
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. |
Definition at line 13342 of file midas.c.
Referenced by ascii_write(), dump_write(), eb_mfragment_add(), md_event_swap(), process_event(), and source_scan().
13343 { 13344 BANK_HEADER *pbh; 13345 BANK *pbk; 13346 BANK32 *pbk32; 13347 void *pdata; 13348 WORD type; 13349 BOOL b32; 13350 13351 pbh = (BANK_HEADER *) event; 13352 13353 /* only swap if flags in high 16-bit */ 13354 if (pbh->flags < 0x10000 && !force) 13355 return 0; 13356 13357 /* swap bank header */ 13358 DWORD_SWAP(&pbh->data_size); 13359 DWORD_SWAP(&pbh->flags); 13360 13361 /* check for 32bit banks */ 13362 b32 = ((pbh->flags & BANK_FORMAT_32BIT) > 0); 13363 13364 pbk = (BANK *) (pbh + 1); 13365 pbk32 = (BANK32 *) pbk; 13366 13367 /* scan event */ 13368 while ((char *) pbk - (char *) pbh < (INT) pbh->data_size + (INT) sizeof(BANK_HEADER)) { 13369 /* swap bank header */ 13370 if (b32) { 13371 DWORD_SWAP(&pbk32->type); 13372 DWORD_SWAP(&pbk32->data_size); 13373 pdata = pbk32 + 1; 13374 type = (WORD) pbk32->type; 13375 } else { 13376 WORD_SWAP(&pbk->type); 13377 WORD_SWAP(&pbk->data_size); 13378 pdata = pbk + 1; 13379 type = pbk->type; 13380 } 13381 13382 /* pbk points to next bank */ 13383 if (b32) { 13384 pbk32 = (BANK32 *) ((char *) (pbk32 + 1) + ALIGN8(pbk32->data_size)); 13385 pbk = (BANK *) pbk32; 13386 } else { 13387 pbk = (BANK *) ((char *) (pbk + 1) + ALIGN8(pbk->data_size)); 13388 pbk32 = (BANK32 *) pbk; 13389 } 13390 13391 switch (type) { 13392 case TID_WORD: 13393 case TID_SHORT: 13394 while ((char *) pdata < (char *) pbk) { 13395 WORD_SWAP(pdata); 13396 pdata = (void *) (((WORD *) pdata) + 1); 13397 } 13398 break; 13399 13400 case TID_DWORD: 13401 case TID_INT: 13402 case TID_BOOL: 13403 case TID_FLOAT: 13404 while ((char *) pdata < (char *) pbk) { 13405 DWORD_SWAP(pdata); 13406 pdata = (void *) (((DWORD *) pdata) + 1); 13407 } 13408 break; 13409 13410 case TID_DOUBLE: 13411 while ((char *) pdata < (char *) pbk) { 13412 QWORD_SWAP(pdata); 13413 pdata = (void *) (((double *) pdata) + 1); 13414 } 13415 break; 13416 } 13417 } 13418 13419 return CM_SUCCESS; 13420 }