online_distribution/eventlibraries/dataBlock.h

0001 /*
0002 ** dataBlock.h
0003 **
0004 ** Author: $Author: phoncs $
0005 **   Date: $Date: 2010/09/21 19:37:49 $
0006 **
0007 ** $Log: dataBlock.h,v $
0008 ** Revision 1.2  2010/09/21 19:37:49  phoncs
0009 ** DLW: change name of DWORD to PHDWORD
0010 **
0011 ** Revision 1.1.1.1  2000/07/21 01:51:11  purschke
0012 ** mlp -- adding the new automakified "basic" module to CVS.
0013 **
0014 **
0015 ** Revision 1.6  2000/03/22 22:58:37  phoncs
0016 ** mlp -- added DWORD
0017 **
0018 ** Revision 1.5  1998/12/11 22:01:15  markacs
0019 ** (stephen markacs) adding log into cvs tags
0020 **
0021 */
0022 /*
0023 **      dataBlock.h
0024 **
0025 **      This routine provides acces to information in the data descriptor.
0026 **      The data descriptor has a format which changes depending on the
0027 **      data structure employed.  So there are as many routines for
0028 **      creating data descriptors as there are data structures.
0029 **      Currently, the types of structures are:
0030 **
0031 **      - Unstructured: sets three fields, the hitFormat, dataPadding
0032 **        and wordSize, in a one dword descriptor.
0033 **
0034 */
0035
0036 #ifndef _DATABLOCK_
0037 #define _DATABLOCK_
0038
0039 #include "phenixOnline.h"
0040 #include "packetPublic.h"
0041 #include "Cpacket.h"
0042 #include "formatError.h"
0043
0044 /*
0045 **      Use C linkage.
0046 */
0047
0048 #ifdef __cplusplus
0049 extern "C" {
0050 #endif
0051
0052
0053   /*
0054   **  These are the offsets for unstructured data.
0055   **  For unstructured data the descriptor has a length
0056   **  of one dword.
0057   */
0058
0059 #define UNSTRUCT_DATA_PADDING_OFFSET_OF_DWORD 0
0060 #define UNSTRUCT_DATA_PADDING_OFFSET_IN_DWORD 24
0061 #define UNSTRUCT_DATA_PADDING_NUM_BITS 8
0062 #define UNSTRUCT_DATA_PADDING_MASK 0xff000000
0063
0064 #define UNSTRUCT_WORD_SIZE_OFFSET_OF_DWORD 0
0065 #define UNSTRUCT_WORD_SIZE_OFFSET_IN_DWORD 16
0066 #define UNSTRUCT_WORD_SIZE_NUM_BITS 8
0067 #define UNSTRUCT_WORD_SIZE_MASK 0x00ff0000
0068
0069 #define UNSTRUCT_HIT_FORMAT_OFFSET_OF_DWORD 0
0070 #define UNSTRUCT_HIT_FORMAT_OFFSET_IN_DWORD 0
0071 #define UNSTRUCT_HIT_FORMAT_NUM_BITS 16
0072 #define UNSTRUCT_HIT_FORMAT_MASK 0x0000ffff
0073
0074 CONSTANT PHDWORD UnstructDataDescrLength = 1;
0075
0076
0077
0078   /*
0079   ** These routines set/get unstructured descriptor fields given a pointer
0080   **  to a packet.
0081   */
0082
0083 INLINE_P LOGIC_ret makeUnstructPacketDataDescr (PACKET_ptr, UINT, UINT);
0084
0085 INLINE_P VALUE_ret getUnstructPacketWordSize (PACKET_ptr);
0086 INLINE_P VALUE_ret getUnstructPacketDataPadding (PACKET_ptr);
0087 INLINE_P VALUE_ret getUnstructPacketHitFormat (PACKET_ptr);
0088
0089 INLINE_P LOGIC_ret setUnstructPacketWordSize (PACKET_ptr, UINT);
0090 INLINE_P LOGIC_ret setUnstructPacketDataPadding (PACKET_ptr, UINT);
0091 INLINE_P LOGIC_ret setUnstructPacketHitFormat (PACKET_ptr, UINT);
0092
0093 VALUE_ret getUnstructPacketDataLengthBytes(PACKET_ptr);
0094 VALUE_ret getUnstructPacketDataLengthWords(PACKET_ptr);
0095 VALUE_ret extendUnstructPacketDataBlock(PACKET_ptr, UINT);
0096
0097
0098   /*
0099   **  These routines set/get fields from the descriptor given a pointer
0100   **    to the descriptor.
0101   */
0102
0103 INLINE_P LOGIC_ret makeUnstructDataDescr (PHDWORD*, UINT, UINT);
0104
0105 INLINE_P LOGIC_ret setUnstructDescrWordSize (PHDWORD*, UINT);
0106 INLINE_P LOGIC_ret setUnstructDescrDataPadding (PHDWORD*, UINT);
0107 INLINE_P LOGIC_ret setUnstructDescrHitFormat (PHDWORD*, UINT);
0108
0109 INLINE_P VALUE_ret getUnstructDescrWordSize (PHDWORD*);
0110 INLINE_P VALUE_ret getUnstructDescrDataPadding (PHDWORD*);
0111 INLINE_P VALUE_ret getUnstructDescrHitFormat (PHDWORD*);
0112
0113
0114 INLINE_D LOGIC_ret makeUnstructPacketDataDescr (PACKET_ptr packet_ptr,
0115                           UINT inWordSize,
0116                           UINT inHitFormat)
0117 {
0118   PHDWORD *descr_ptr;
0119
0120   /*
0121   **  Set the descriptor length in the packet header
0122   */
0123   setPacketDataDescrLength(packet_ptr, UnstructDataDescrLength);
0124
0125   descr_ptr = findPacketDataDescr(packet_ptr);
0126   if (descr_ptr == ptrFailure) return logicFailure;
0127   else return makeUnstructDataDescr(descr_ptr, inWordSize, inHitFormat);
0128 }
0129
0130 INLINE_D VALUE_ret getUnstructPacketWordSize (PACKET_ptr packet_ptr)
0131 {
0132   PHDWORD* descr_ptr = findPacketDataDescr(packet_ptr);
0133   if (descr_ptr == ptrFailure) return valueFailure;
0134   else return getUnstructDescrWordSize(descr_ptr);
0135 }
0136
0137 INLINE_D VALUE_ret getUnstructPacketHitFormat (PACKET_ptr packet_ptr)
0138 {
0139   PHDWORD* descr_ptr = findPacketDataDescr(packet_ptr);
0140   if (descr_ptr == ptrFailure) return valueFailure;
0141   else return getUnstructDescrHitFormat(descr_ptr);
0142 }
0143
0144 INLINE_D VALUE_ret getUnstructPacketDataPadding (PACKET_ptr packet_ptr)
0145 {
0146   PHDWORD* descr_ptr = findPacketDataDescr(packet_ptr);
0147   if (descr_ptr == ptrFailure) return valueFailure;
0148   else return getUnstructDescrDataPadding(descr_ptr);
0149 }
0150
0151 INLINE_D LOGIC_ret setUnstructPacketHitFormat (PACKET_ptr packet_ptr, UINT unHitFormat)
0152 {
0153   PHDWORD* descr_ptr = findPacketDataDescr(packet_ptr);
0154   if (descr_ptr == ptrFailure) return valueFailure;
0155   else {
0156     return setUnstructDescrHitFormat(descr_ptr, unHitFormat);
0157   }
0158 }
0159
0160 INLINE_D LOGIC_ret setUnstructPacketWordSize (PACKET_ptr packet_ptr, UINT unWordSize)
0161 {
0162   PHDWORD* descr_ptr = findPacketDataDescr(packet_ptr);
0163   if (descr_ptr == ptrFailure) return valueFailure;
0164   else {
0165     return setUnstructDescrWordSize(descr_ptr, unWordSize);
0166   }
0167 }
0168
0169 INLINE_D LOGIC_ret setUnstructPacketDataPadding (PACKET_ptr packet_ptr, UINT paddingBytes)
0170 {
0171   PHDWORD* descr_ptr = findPacketDataDescr(packet_ptr);
0172   if (descr_ptr == ptrFailure) return valueFailure;
0173   else {
0174     return setUnstructDescrDataPadding(descr_ptr, paddingBytes);
0175   }
0176 }
0177
0178   /*
0179   **  This routine creates a one dword data descriptor for unstructured data.  The
0180   **  wordSize and hitFormat are user specified values, the data padding entry is
0181   **  initialized to zero.
0182   */
0183
0184 INLINE_D LOGIC_ret makeUnstructDataDescr (PHDWORD* dataDescr_ptr, UINT inWordSize,
0185                     UINT inHitFormat)
0186 {
0187   *dataDescr_ptr = 0;
0188   setUnstructDescrWordSize (dataDescr_ptr, inWordSize);
0189   setUnstructDescrHitFormat (dataDescr_ptr, inHitFormat);
0190
0191   return logicSuccess;
0192 }
0193
0194 /*  Return the word size from the unstructured descriptor
0195  */
0196 INLINE_D VALUE_ret getUnstructDescrWordSize(PHDWORD* descr_ptr)
0197 {
0198   return getBitsMACRO(descr_ptr, UNSTRUCT_WORD_SIZE_OFFSET_OF_DWORD,
0199               UNSTRUCT_WORD_SIZE_OFFSET_IN_DWORD,
0200               UNSTRUCT_WORD_SIZE_MASK);
0201 }
0202
0203 /*  Return the hit format from the unstructured descriptor
0204  */
0205 INLINE_D VALUE_ret getUnstructDescrHitFormat(PHDWORD* descr_ptr)
0206 {
0207   return getBitsMACRO(descr_ptr, UNSTRUCT_HIT_FORMAT_OFFSET_OF_DWORD,
0208               UNSTRUCT_HIT_FORMAT_OFFSET_IN_DWORD,
0209               UNSTRUCT_HIT_FORMAT_MASK);
0210 }
0211
0212 /*  Return the data padding field from the unstructured descriptor
0213  */
0214 INLINE_D VALUE_ret getUnstructDescrDataPadding(PHDWORD* descr_ptr)
0215 {
0216   return getBitsMACRO(descr_ptr, UNSTRUCT_DATA_PADDING_OFFSET_OF_DWORD,
0217               UNSTRUCT_DATA_PADDING_OFFSET_IN_DWORD,
0218               UNSTRUCT_DATA_PADDING_MASK);
0219 }
0220
0221 /*  Set the word size in the unstructured descriptor
0222  */
0223 INLINE_D LOGIC_ret setUnstructDescrWordSize(PHDWORD* descr_ptr, UINT wordSize)
0224 {
0225   setBitsMACRO(descr_ptr, UNSTRUCT_WORD_SIZE_OFFSET_OF_DWORD,
0226            UNSTRUCT_WORD_SIZE_OFFSET_IN_DWORD,
0227            UNSTRUCT_WORD_SIZE_MASK, wordSize);
0228   return TRUE;
0229 }
0230
0231 /*  Set the hit format in the unstructured descriptor
0232  */
0233 INLINE_D LOGIC_ret setUnstructDescrHitFormat(PHDWORD* descr_ptr, UINT hitFormat)
0234 {
0235   setBitsMACRO(descr_ptr, UNSTRUCT_HIT_FORMAT_OFFSET_OF_DWORD,
0236            UNSTRUCT_HIT_FORMAT_OFFSET_IN_DWORD,
0237            UNSTRUCT_HIT_FORMAT_MASK, hitFormat);
0238   return TRUE;
0239 }
0240
0241 /*  Set the padding field in the unstructured descriptor
0242  */
0243 INLINE_D LOGIC_ret setUnstructDescrDataPadding(PHDWORD* descr_ptr,
0244                          UINT paddingBytes)
0245 {
0246   setBitsMACRO(descr_ptr, UNSTRUCT_DATA_PADDING_OFFSET_OF_DWORD,
0247               UNSTRUCT_DATA_PADDING_OFFSET_IN_DWORD,
0248               UNSTRUCT_DATA_PADDING_MASK, paddingBytes);
0249   return TRUE;
0250 }
0251
0252 #ifdef __cplusplus
0253 }
0254 /* end of external C */
0255 #endif
0256
0257 #endif
0258 /* end of indef _DATABLOCK_ */
0259
0260
0261
0262