EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
CframeV1.h
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file CframeV1.h
1 /*
2 ** CframeV1.h
3 **
4 ** Author: $Author: purschke $
5 ** Date: $Date: 2000/07/21 01:51:10 $
6 **
7 ** $Log: CframeV1.h,v $
8 ** Revision 1.1.1.1 2000/07/21 01:51:10 purschke
9 ** mlp -- adding the new automakified "basic" module to CVS.
10 **
11 **
12 ** Revision 1.9 1999/05/17 19:47:06 markacs
13 ** (stephen) added findNextError and whole indirection chain
14 **
15 ** Revision 1.8 1999/04/16 20:12:10 markacs
16 ** (stephen) fixing findFrameErrorStart, findFrameHistoryStart, adjustFrameLength to deal correctly with padding
17 **
18 ** Revision 1.7 1999/04/13 18:27:37 markacs
19 ** (stephen) put history block access in
20 **
21 ** Revision 1.6 1998/12/16 15:40:51 markacs
22 ** (stephen markacs) changes to rawFormat code to stop using bool,true,false
23 **
24 ** Revision 1.5 1998/12/11 22:01:12 markacs
25 ** (stephen markacs) adding log into cvs tags
26 **
27 */
28 /*
29 ** CframeV1.h
30 **
31 ** Now contains combination of old CframeV1.h and CframeV1.C.
32 ** This change was made to allow inlining
33 **
34 ** The layout of the file is as follows:
35 **
36 ** (1) definition of version-dependent field parameters
37 ** (2) includes of phenixOnline.h, etc.
38 ** (3) prototypes of functions defined later in this file
39 ** (4) include of Cframe.h
40 ** (5) defintion of V1 functions
41 **
42 **
43 ** For additional comments, see Cframe.h
44 **
45 */
46 
47 #ifndef _CFRAMEV1_
48 #define _CFRAMEV1_
49 
50 #ifdef __cplusplus
51 extern "C" {
52 #endif
53 
54 #include "phenixOnline.h"
55 #include "formatError.h"
56 #include "framePublic.h"
57 #include "frameV1Public.h"
58 #include "frameHdrV1.h"
59 #include "Cframe.h"
60 
61 /*
62 ** Function prototype definitions
63 ** ============================================================
64 */
65 
66 VALUE_ret makeFrameHdrV1 (PHDWORD*, UINT, UINT, UINT, UINT);
67 VALUE_ret getFrameDataLengthV1 (FRAME_ptr);
68 VALUE_ret adjustFrameHistoryLengthV1 (FRAME_ptr, UINT);
69 VALUE_ret adjustFrameErrorLengthV1 (FRAME_ptr, UINT);
70 VALUE_ret orFrameStatusV1 (FRAME_ptr, UINT);
71 
72 INLINE_P LOGIC_ret validFrameHdrV1 (FRAME_ptr);
73 INLINE_P LOGIC_ret emptyFrameV1 (FRAME_ptr);
74 
75 INLINE_P VALUE_ret getFrameErrorLengthV1 (FRAME_ptr);
76 INLINE_P VALUE_ret getFrameHistoryLengthV1 (FRAME_ptr);
77 INLINE_P VALUE_ret getFrameAlignLengthV1 (FRAME_ptr);
78 INLINE_P VALUE_ret getFramePaddingV1 (FRAME_ptr);
79 
80 INLINE_P VALUE_ret getFrameSourceIdV1 (FRAME_ptr);
81 INLINE_P VALUE_ret getFrameTypeV1 (FRAME_ptr);
82 INLINE_P VALUE_ret getFrameDataTypeV1 (FRAME_ptr);
83 INLINE_P VALUE_ret getFrameStatusV1 (FRAME_ptr);
84 
85 INLINE_P VALUE_ret adjustFrameDataLengthV1 (FRAME_ptr, UINT);
86 INLINE_P VALUE_ret setFramePaddingV1 (FRAME_ptr, UINT);
87 
88 INLINE_P LOGIC_ret setDataTypeV1(FRAME_ptr, UINT);
89 INLINE_P LOGIC_ret setFrameTypeV1(FRAME_ptr, UINT);
90 INLINE_P LOGIC_ret setSourceIdV1(FRAME_ptr, UINT);
91 INLINE_P LOGIC_ret setFrameHistoryLengthV1(FRAME_ptr, UINT);
92 INLINE_P LOGIC_ret setFrameErrorLengthV1(FRAME_ptr, UINT);
93 INLINE_P LOGIC_ret setFrameAlignLengthV1(FRAME_ptr, UINT);
94 INLINE_P LOGIC_ret setFrameStatusV1(FRAME_ptr, UINT);
95 
96 INLINE_P PTR_ret findFrameAlignBlockV1 (FRAME_ptr);
97 INLINE_P PTR_ret findFrameErrorStartV1 (FRAME_ptr);
98 INLINE_P PTR_ret findFrameHistoryStartV1 (FRAME_ptr);
99 
100 INLINE_P VALUE_ret getAlignBlockV1 (FRAME_ptr, PHDWORD*, UINT);
101 INLINE_P LOGIC_ret setAlignBlockV1 (FRAME_ptr, PHDWORD*, UINT);
102 
103 INLINE_P VALUE_ret getHistoryEntryV1 (FRAME_ptr, UINT);
104 INLINE_P VALUE_ret getHistoryStageV1 (FRAME_ptr, UINT);
105 INLINE_P VALUE_ret getHistorySourceIndexV1 (FRAME_ptr, UINT);
106 INLINE_P VALUE_ret getHistoryStatusV1 (FRAME_ptr, UINT);
107 
108 /* note: the following three are not referenced by indirection
109  from outside */
110 INLINE_P VALUE_ret getStageFromHistoryEntryV1 (PHDWORD);
111 INLINE_P VALUE_ret getSourceIndexFromHistoryEntryV1 (PHDWORD);
112 INLINE_P VALUE_ret getStatusFromHistoryEntryV1 (PHDWORD);
113 
114 INLINE_P PTR_ret findNextErrorV1 (FRAME_ptr, FRAME_ptr);
115 
116 /*
117 ** Inlined routines
118 ** ============================================================
119 */
120 
121 /* Check to see if this can really be a valid V1 header
122 */
123 INLINE_D LOGIC_ret validFrameHdrV1 (FRAME_ptr frame_ptr)
124 {
125  if (getFrameHdrLength(frame_ptr) == V1_FRAMEHDR_LENGTH) {
126  setFrameSuccess();
127  return TRUE;
128  }
129  else {
130  setFrameError (FORMAT_ERR_INVALID_HEADER, frame_ptr, 0);
131  return FALSE;
132  }
133 }
134 
135 
136 /* Check to see if this is an empty frame.
137 */
138 INLINE_D LOGIC_ret emptyFrameV1 (FRAME_ptr frame_ptr)
139 {
140  return getFrameHdrLength(frame_ptr) == getFrameLength(frame_ptr);
141 }
142 
143 
144 INLINE_D VALUE_ret getFramePaddingV1 (FRAME_ptr frame_ptr)
145 {
146  return getBitsMACRO(frame_ptr,
147  PADDING_OFFSET_OF_DWORD,
148  PADDING_OFFSET_IN_DWORD,
149  PADDING_MASK );
150 }
151 
152 
153 INLINE_D VALUE_ret getFrameSourceIdV1 (FRAME_ptr frame_ptr)
154 {
155  return getBitsMACRO(frame_ptr,
156  SOURCE_ID_OFFSET_OF_DWORD,
157  SOURCE_ID_OFFSET_IN_DWORD,
158  SOURCE_ID_MASK );
159 }
160 
161 
162 INLINE_D VALUE_ret getFrameDataTypeV1 (FRAME_ptr frame_ptr)
163 {
164  return getBitsMACRO(frame_ptr,
165  DATA_TYPE_OFFSET_OF_DWORD,
166  DATA_TYPE_OFFSET_IN_DWORD,
167  DATA_TYPE_MASK );
168 }
169 
170 
171 INLINE_D VALUE_ret getFrameTypeV1 (FRAME_ptr frame_ptr)
172 {
173  return getBitsMACRO(frame_ptr,
174  FRAME_TYPE_OFFSET_OF_DWORD,
175  FRAME_TYPE_OFFSET_IN_DWORD,
176  FRAME_TYPE_MASK );
177 }
178 
179 
180 INLINE_D VALUE_ret getFrameStatusV1 (FRAME_ptr frame_ptr)
181 {
182  return getBitsMACRO(frame_ptr,
183  STATUS_OFFSET_OF_DWORD,
184  STATUS_OFFSET_IN_DWORD,
185  STATUS_MASK );
186 }
187 
188 
189 INLINE_D VALUE_ret getFrameErrorLengthV1 (FRAME_ptr frame_ptr)
190 {
191  return getBitsMACRO(frame_ptr,
192  ERROR_LENGTH_OFFSET_OF_DWORD,
193  ERROR_LENGTH_OFFSET_IN_DWORD,
194  ERROR_LENGTH_MASK );
195 }
196 
197 
198 INLINE_D VALUE_ret getFrameHistoryLengthV1 (FRAME_ptr frame_ptr)
199 {
200  return getBitsMACRO(frame_ptr,
201  HISTORY_LENGTH_OFFSET_OF_DWORD,
202  HISTORY_LENGTH_OFFSET_IN_DWORD,
203  HISTORY_LENGTH_MASK );
204 }
205 
206 
207 INLINE_D VALUE_ret getFrameAlignLengthV1 (FRAME_ptr frame_ptr)
208 {
209  return getBitsMACRO(frame_ptr,
210  ALIGN_LENGTH_OFFSET_OF_DWORD,
211  ALIGN_LENGTH_OFFSET_IN_DWORD,
212  ALIGN_LENGTH_MASK );
213 }
214 
215 
216 /* Return pointer to start of error block in frame
217 */
218 INLINE_D PTR_ret findFrameErrorStartV1 (FRAME_ptr frame_ptr)
219 {
220  return frame_ptr + getFrameLength(frame_ptr)
221  - getFrameErrorLengthV1(frame_ptr)
222  - getFramePadding(frame_ptr);
223 }
224 
225 
226 /* Return pointer to start of history block in frame
227 */
228 INLINE_D PTR_ret findFrameHistoryStartV1 (FRAME_ptr frame_ptr)
229 {
230  return frame_ptr + getFrameLength(frame_ptr)
231  - getFrameErrorLengthV1(frame_ptr)
232  - getFrameHistoryLengthV1(frame_ptr)
233  - getFramePadding(frame_ptr);
234 }
235 
236 
237 /* Return pointer to start of alignment block */
238 INLINE_D PTR_ret findFrameAlignBlockV1 (FRAME_ptr frame_ptr)
239 {
240  return frame_ptr + ALIGN_OFFSET_OF_DWORD;
241 }
242 
243 INLINE_D VALUE_ret setFramePaddingV1 (FRAME_ptr frame_ptr, UINT numPadDwords)
244 {
245  setBitsMACRO(frame_ptr,
246  PADDING_OFFSET_OF_DWORD,
247  PADDING_OFFSET_IN_DWORD,
248  PADDING_MASK,
249  numPadDwords );
250  return TRUE;
251 }
252 
253 
254 /*
255 ** Adjust the size of the data block in the frame header.
256 **
257 ** Note: this routine is only intended to change an explicit
258 ** size that appears in a header. For V1 frames no such
259 ** field is present so we simply return the current data
260 ** block size.
261 */
262 
263 INLINE_D UINT adjustFrameDataLengthV1 (FRAME_ptr frame_ptr, UINT newDwords)
264 {
265  UINT currentDataLength = getFrameDataLengthV1 (frame_ptr);
266 
267  if (currentDataLength == valueFailure)
268  return valueFailure;
269  else
270  return currentDataLength + newDwords;
271 }
272 
273 INLINE_D LOGIC_ret setDataTypeV1(FRAME_ptr frame_ptr, UINT dataType)
274 {
275 #ifndef DCM_CHECK
276  if (dataType > maxByteValue) return FALSE;
277 #endif
278  setBitsMACRO(frame_ptr,
279  DATA_TYPE_OFFSET_OF_DWORD,
280  DATA_TYPE_OFFSET_IN_DWORD,
281  DATA_TYPE_MASK,
282  dataType );
283  return TRUE;
284 }
285 
286 
287 INLINE_D LOGIC_ret setFrameTypeV1(FRAME_ptr frame_ptr, UINT frameType)
288 {
289 #ifndef DCM_CHECK
290  if (frameType > maxByteValue) return FALSE;
291 #endif
292  setBitsMACRO(frame_ptr,
293  FRAME_TYPE_OFFSET_OF_DWORD,
294  FRAME_TYPE_OFFSET_IN_DWORD,
295  FRAME_TYPE_MASK,
296  frameType );
297  return TRUE;
298 }
299 
300 
301 INLINE_D LOGIC_ret setSourceIdV1(FRAME_ptr frame_ptr, UINT sourceId)
302 {
303 #ifndef DCM_CHECK
304  if (sourceId > maxSwordValue) return FALSE;
305 #endif
306  setBitsMACRO(frame_ptr,
307  SOURCE_ID_OFFSET_OF_DWORD,
308  SOURCE_ID_OFFSET_IN_DWORD,
309  SOURCE_ID_MASK,
310  sourceId );
311  return TRUE;
312 }
313 
314 
315 INLINE_D LOGIC_ret setFrameHistoryLengthV1(FRAME_ptr frame_ptr, UINT historyLength)
316 {
317 #ifndef DCM_CHECK
318  if (historyLength > maxSwordValue) return FALSE;
319 #endif
320  setBitsMACRO(frame_ptr,
321  HISTORY_LENGTH_OFFSET_OF_DWORD,
322  HISTORY_LENGTH_OFFSET_IN_DWORD,
323  HISTORY_LENGTH_MASK,
324  historyLength );
325  return TRUE;
326 }
327 
328 
329 INLINE_D LOGIC_ret setFrameErrorLengthV1(FRAME_ptr frame_ptr, UINT errorLength)
330 {
331 #ifndef DCM_CHECK
332  if (errorLength > maxSwordValue) return FALSE;
333 #endif
334  setBitsMACRO(frame_ptr,
335  ERROR_LENGTH_OFFSET_OF_DWORD,
336  ERROR_LENGTH_OFFSET_IN_DWORD,
337  ERROR_LENGTH_MASK,
338  errorLength );
339  return TRUE;
340 }
341 
342 
343 INLINE_D LOGIC_ret setFrameAlignLengthV1(FRAME_ptr frame_ptr, UINT alignLength)
344 {
345 #ifndef DCM_CHECK
346  if (alignLength > maxByteValue) return FALSE;
347 #endif
348  setBitsMACRO(frame_ptr,
349  ALIGN_LENGTH_OFFSET_OF_DWORD,
350  ALIGN_LENGTH_OFFSET_IN_DWORD,
351  ALIGN_LENGTH_MASK,
352  alignLength );
353  return TRUE;
354 }
355 
356 INLINE_D LOGIC_ret setFrameStatusV1(FRAME_ptr frame_ptr, UINT status)
357 {
358 #ifndef DCM_CHECK
359  if (status > maxSwordValue) return FALSE;
360 #endif
361  setBitsMACRO(frame_ptr,
362  STATUS_OFFSET_OF_DWORD,
363  STATUS_OFFSET_IN_DWORD,
364  STATUS_MASK,
365  status );
366  return TRUE;
367 }
368 
369 
370 INLINE_D VALUE_ret getAlignBlockV1 (FRAME_ptr frame_ptr, PHDWORD* alignDestination,
371  UINT maxNumDwords)
372 {
373  UINT alignLength = getFrameAlignLength(frame_ptr);
374  if (maxNumDwords < alignLength) return valueFailure;
375  dwordCopy(alignDestination, (frame_ptr+ALIGN_OFFSET_OF_DWORD), alignLength);
376  return alignLength;
377 }
378 
379 
380 INLINE_D LOGIC_ret setAlignBlockV1 (FRAME_ptr frame_ptr, PHDWORD* alignSource,
381  UINT numDwords)
382 {
383  UINT alignLength = getFrameAlignLength(frame_ptr);
384  if (numDwords != alignLength) return FALSE;
385  dwordCopy((frame_ptr+ALIGN_OFFSET_OF_DWORD), alignSource, alignLength);
386  return TRUE;
387 }
388 
389 /* get entry in history block by entry index, where indices count
390  from THE BOTTOM */
391 
392 INLINE_D VALUE_ret getHistoryEntryV1 (FRAME_ptr frame_ptr, UINT index)
393 {
394  UINT historyLength = getFrameHistoryLength(frame_ptr);
395  if (index>=historyLength) return valueFailure;
396  return *(findFrameHistoryStart(frame_ptr)+(historyLength-index-1));
397 }
398 
399 INLINE_D VALUE_ret getStageFromHistoryEntryV1(PHDWORD historyEntry)
400 {
401  return (historyEntry&0xf0000000)>>28;
402 }
403 
404 INLINE_D VALUE_ret getSourceIndexFromHistoryEntryV1(PHDWORD historyEntry)
405 {
406  return (historyEntry&0x0fff0000)>>16;
407 }
408 
409 INLINE_D VALUE_ret getStatusFromHistoryEntryV1(PHDWORD historyEntry)
410 {
411  return historyEntry&0x0000ffff;
412 }
413 
414 INLINE_D VALUE_ret getHistoryStageV1(FRAME_ptr frame_ptr, UINT index)
415 {
416  return getStageFromHistoryEntryV1(getHistoryEntryV1(frame_ptr,index));
417 }
418 
419 INLINE_D VALUE_ret getHistorySourceIndexV1(FRAME_ptr frame_ptr, UINT index)
420 {
421  return getSourceIndexFromHistoryEntryV1(getHistoryEntryV1(frame_ptr,index));
422 }
423 
424 INLINE_D VALUE_ret getHistoryStatusV1(FRAME_ptr frame_ptr, UINT index)
425 {
426  return getStatusFromHistoryEntryV1(getHistoryEntryV1(frame_ptr,index));
427 }
428 
429 INLINE_D PTR_ret findNextErrorV1(FRAME_ptr frame_ptr, FRAME_ptr thisError)
430 {
431  if (thisError < findFrameErrorStart(frame_ptr) ||
432  thisError > findFrameEnd(frame_ptr) ) return ptrFailure;
433  PHDWORD errorType = *thisError;
434  FRAME_ptr temp_ptr;
435  switch (errorType)
436  {
437  case 1111573574: temp_ptr = thisError+3; break; // "BADF" : bad frame
438  case 1296651078: temp_ptr = thisError+2; break; // "MISF" : missing frame
439  case 1111573584: temp_ptr = thisError+4; break; // "BADP" : bad packet
440  case 1296651088: temp_ptr = thisError+3; break; // "MISP" : missing packet
441  case 1430537542: temp_ptr = thisError+(*(thisError+1)); break; // "UDEF" : undefined error
442  default: return ptrFailure;
443  }
444  if (temp_ptr > findFrameEnd(frame_ptr)) return ptrFailure;
445  return temp_ptr;
446 }
447 
448 #ifdef __cplusplus
449 }
450 #endif
451 
452 #endif /* end of ifndef _CFRAMEV1_ */
453 
454 
455 
456 
457 
458 
459 
460 
461 
462 
463 
464