online_distribution/eventlibraries/Cframe.C

0001 /*
0002 ** Cframe.C
0003 **
0004 ** Author: $Author: purschke $
0005 **   Date: $Date: 2000/07/21 01:51:10 $
0006 **
0007 ** $Log: Cframe.C,v $
0008 ** Revision 1.1.1.1  2000/07/21 01:51:10  purschke
0009 ** mlp -- adding the new automakified "basic" module to CVS.
0010 **
0011 **
0012 ** Revision 1.10  1999/05/17 19:47:16  markacs
0013 ** (stephen) added findNextError and whole indirection chain
0014 **
0015 ** Revision 1.9  1999/04/16 20:12:11  markacs
0016 ** (stephen) fixing findFrameErrorStart, findFrameHistoryStart, adjustFrameLength to deal correctly with padding
0017 **
0018 ** Revision 1.8  1999/04/13 18:27:38  markacs
0019 ** (stephen) put history block access in
0020 **
0021 ** Revision 1.7  1998/12/16 15:40:52  markacs
0022 ** (stephen markacs) changes to rawFormat code to stop using bool,true,false
0023 **
0024 ** Revision 1.6  1998/12/11 22:01:54  markacs
0025 ** (stephen markacs) adding log into cvs tags
0026 **
0027 */
0028 #include "phenixOnline.h"
0029 #include "frameHdr.h"
0030
0031 #include "Cframe.h"
0032 #include "CframeV1.h"
0033 #include <stdlib.h>
0034
0035 /* Returns a pointer to the start of the frame data block.
0036 **
0037 ** This function does not depend on the version of the frame header since header
0038 ** length is in the same location for all versions.
0039 */
0040 PTR_ret findFrameDataStart ( FRAME_ptr frame_ptr) {
0041 #ifdef STRONG_CHECK
0042   if (!validFrameHdr(frame_ptr)) return ptrFailure;
0043 #endif
0044   return (PHDWORD*)frame_ptr + getFrameHdrLength(frame_ptr);
0045 }
0046
0047 /*  Return a pointer to the end of the frame data block/
0048  */
0049 PTR_ret findFrameDataEnd ( FRAME_ptr frame_ptr) {
0050   PHDWORD* start_ptr = findFrameDataStart(frame_ptr);
0051   PHDWORD length = getFrameDataLength(frame_ptr);
0052   if ((start_ptr == ptrFailure)||(length==valueFailure))
0053     return ptrFailure;
0054   else
0055     return start_ptr + length - 1;
0056 }
0057
0058
0059 /*
0060 ** checkFrameHdrVersion checks that FrameMark and FrameHdrLength
0061 **  are correct for a frame of the given version and, if so,
0062 **  returns FrameHdrVersion.  Elsewise it returns valueFailure.
0063 */
0064 VALUE_ret checkFrameHdrVersion ( FRAME_ptr frame_ptr)
0065 {
0066   PHDWORD frameMark;
0067   PHDWORD frameHdrLength;
0068   UINT version = getFrameHdrVersion(frame_ptr);
0069   if (version != valueFailure) {
0070     frameMark = getFrameMark(frame_ptr);
0071     frameHdrLength = getFrameHdrLength(frame_ptr);
0072     if ( (frameMark == frameMarkV[version]) &&
0073          (frameHdrLength == frameHdrLengthV[version])) {
0074       setFrameSuccess();
0075       return version;
0076     }
0077     else {
0078       setFrameError(FORMAT_ERR_INVALID_FRAMEMARK, frame_ptr, frameMark);
0079       return valueFailure;
0080     }
0081   }
0082   else return valueFailure;
0083 }
0084
0085 /*  Return a pointer to the last word in the frame.
0086  */
0087 PTR_ret findFrameEnd ( FRAME_ptr frame_ptr)
0088 {
0089   if (validFrameHdr(frame_ptr))
0090   {
0091     PHDWORD frameLength = getFrameLength(frame_ptr);
0092     if (frameLength != valueFailure)
0093     {
0094       setFrameSuccess();
0095       return ( (PHDWORD*)frame_ptr + frameLength - 1);
0096     }
0097     else return ptrFailure;
0098   }
0099   else return ptrFailure;
0100 }
0101
0102 /*
0103 ** checkFrameEndianism returns 1 if the frame header is valid
0104 **  as it is, returns 0 if the frame header would be valid if swapped,
0105 **  and returns valueFailure otherwise.
0106 */
0107 VALUE_ret checkFrameEndianism(FRAME_ptr frame_ptr)
0108 {
0109   if (validFrameHdr(frame_ptr)) return 1;
0110   else
0111     { PHDWORD * buffer = (PHDWORD*)malloc(4*maxFrameHdrLength);
0112       dwordByteSwap(buffer, frame_ptr, maxFrameHdrLength);
0113       if (validFrameHdr(buffer)) return 0;
0114       else return valueFailure;
0115     }
0116 }
0117
0118
0119
0120 /* adjustFrameLength adds addDwords to the frame, with padding
0121    if pad is TRUE, and returns the new frame length */
0122 VALUE_ret adjustFrameLength (FRAME_ptr frame_ptr, UINT maxFrameLength,
0123                              UINT addDwords     , LOGIC_ret pad)
0124 {
0125   UINT padDwords;
0126   UINT currentLength;
0127   UINT newDwords;
0128   UINT newLength;
0129
0130 #ifdef STRONGCHECK
0131   if (!validFrameHdr(frame_ptr)) return valueFailure;
0132 #endif
0133
0134   if (pad) removeFramePadding(frame_ptr);
0135   currentLength = getFrameLength(frame_ptr);
0136
0137   newDwords = addDwords;
0138   newLength = currentLength + newDwords;
0139
0140   /*  Perform the padding calculation if requested
0141    */
0142   if (pad) {
0143     UINT modulo = newLength % currentFrameQuantum;
0144     if (modulo > 0) padDwords = currentFrameQuantum - modulo;
0145     else padDwords = 0;
0146
0147     newLength += padDwords;
0148     newDwords += padDwords;
0149   }
0150   else padDwords = 0;
0151
0152   /*  Check for buffer overflow
0153    */
0154   if (newLength > maxFrameLength) {
0155     setFrameError(FORMAT_ERR_BUFFER_OVERFLOW, frame_ptr, newLength);
0156     return valueFailure;
0157   }
0158
0159   /*
0160   ** below:Check to make sure we don't overflow the 32 bit length field.
0161   ** Note that this calculation may look "funny", but it is necessary
0162   ** to evaluate it like this to prevent the calculation from
0163   ** suffering a 32-bit overflow itself.  Also note that
0164   ** a length that fills the 32-bit length field corresponds
0165   ** to a frame taking up over 16 gigabytes of memory.
0166   */
0167   if (maxDwordValue - currentLength < newDwords) {
0168     setFrameError(FORMAT_ERR_LENGTH_OVERFLOW, frame_ptr, newLength);
0169     return valueFailure;
0170   }
0171
0172   setFrameLength(frame_ptr, newLength);
0173   if (padDwords != 0)
0174   {
0175     PHDWORD* pad_ptr = frame_ptr + newLength - padDwords;
0176     dwordClear (pad_ptr, padDwords);  /* clear padding words */
0177     setFramePadding(frame_ptr, padDwords);
0178   }
0179   return newLength;
0180 }
0181
0182
0183 /* removeFramePadding strips padding off a frame and
0184    returns the length of the frame                      */
0185
0186 VALUE_ret removeFramePadding (FRAME_ptr frame_ptr)
0187 {
0188   UINT length;
0189   UINT padDwords = getFramePadding(frame_ptr);
0190   length = getFrameLength(frame_ptr);
0191   length-=padDwords;
0192   setFrameLength(frame_ptr, length);
0193   setFramePadding(frame_ptr, 0);
0194   return length;
0195 }
0196
0197
0198 /* Here begins the code for the version-DEPENDENT functions */
0199 /* (only if not in DCM mode)                                */
0200 /* ======================================================== */
0201
0202 #ifndef DCM
0203
0204 typedef LOGIC_ret CHECKFUNCTION ( FRAME_ptr);
0205 typedef VALUE_ret ACCESSFUNCTION ( FRAME_ptr);
0206 typedef PTR_ret   PTRACCESSFUNCTION ( FRAME_ptr);
0207 typedef VALUE_ret MODIFYFUNCTION (FRAME_ptr, UINT);
0208 typedef LOGIC_ret LOGICALMODIFYFUNCTION (FRAME_ptr, UINT);
0209 typedef VALUE_ret VARRAYCOPYFUNCTION(FRAME_ptr, PHDWORD*, UINT);
0210 typedef LOGIC_ret LARRAYCOPYFUNCTION(FRAME_ptr, PHDWORD*, UINT);
0211 typedef VALUE_ret MAKEHDRFUNCTION(FRAME_ptr, UINT, UINT, UINT, UINT);
0212 typedef VALUE_ret PARAMACCESSFUNCTION (FRAME_ptr, UINT);
0213 typedef PTR_ret   FINDNEXTFUNCTION (FRAME_ptr, FRAME_ptr);
0214
0215 typedef ACCESSFUNCTION* ACCESSFUNCTIONPTR_arr[NUM_FRAME_VERSIONS];
0216 typedef PTRACCESSFUNCTION* PTRACCESSFUNCTIONPTR_arr[NUM_FRAME_VERSIONS];
0217 typedef CHECKFUNCTION*  CHECKFUNCTIONPTR_arr[NUM_FRAME_VERSIONS];
0218 typedef MODIFYFUNCTION* MODIFYFUNCTIONPTR_arr[NUM_FRAME_VERSIONS];
0219 typedef LOGICALMODIFYFUNCTION* LOGICALMODIFYFUNCTIONPTR_arr[NUM_FRAME_VERSIONS];
0220 typedef VARRAYCOPYFUNCTION* VARRAYCOPYFUNCTIONPTR_arr[NUM_FRAME_VERSIONS];
0221 typedef LARRAYCOPYFUNCTION* LARRAYCOPYFUNCTIONPTR_arr[NUM_FRAME_VERSIONS];
0222 typedef MAKEHDRFUNCTION* MAKEHDRFUNCTIONPTR_arr[NUM_FRAME_VERSIONS];
0223 typedef PARAMACCESSFUNCTION* PARAMACCESSFUNCTIONPTR_arr[NUM_FRAME_VERSIONS];
0224 typedef FINDNEXTFUNCTION* FINDNEXTFUNCTIONPTR_arr[NUM_FRAME_VERSIONS];
0225
0226 /*
0227 ** IMPORTANT: The zeroth element in the indirection arrays is defined in the
0228 **            lines below to be a null pointer.  It is thus very important
0229 **            that anywhere the array is deferenced, it is checked that
0230 **            it is not the zeroth element that is dereferenced.  If it
0231 **            is, a null pointer will be dereferenced and s segmentation
0232 **            fault or some other ugliness will occur.
0233 */
0234 ACCESSFUNCTIONPTR_arr CONSTANT getFrameSourceIdV = {0, &getFrameSourceIdV1};
0235 ACCESSFUNCTIONPTR_arr CONSTANT getFrameTypeV = {0, &getFrameTypeV1};
0236 ACCESSFUNCTIONPTR_arr CONSTANT getFrameStatusV = {0, &getFrameStatusV1};
0237 ACCESSFUNCTIONPTR_arr CONSTANT getFrameDataTypeV = {0, &getFrameDataTypeV1};
0238 ACCESSFUNCTIONPTR_arr CONSTANT getFramePaddingV = {0, &getFramePaddingV1};
0239 ACCESSFUNCTIONPTR_arr CONSTANT getFrameHistoryLengthV = {0, &getFrameHistoryLengthV1};
0240 ACCESSFUNCTIONPTR_arr CONSTANT getFrameErrorLengthV = {0, &getFrameErrorLengthV1};
0241 ACCESSFUNCTIONPTR_arr CONSTANT getFrameDataLengthV = {0, &getFrameDataLengthV1};
0242 ACCESSFUNCTIONPTR_arr CONSTANT getFrameAlignLengthV = {0, &getFrameAlignLengthV1};
0243
0244 PTRACCESSFUNCTIONPTR_arr CONSTANT findFrameErrorStartV = {0, &findFrameErrorStartV1};
0245 PTRACCESSFUNCTIONPTR_arr CONSTANT findFrameAlignBlockV = {0, &findFrameAlignBlockV1};
0246 PTRACCESSFUNCTIONPTR_arr CONSTANT findFrameHistoryStartV = {0, &findFrameHistoryStartV1};
0247
0248 MODIFYFUNCTIONPTR_arr CONSTANT orFrameStatusV = {0, &orFrameStatusV1};
0249 MODIFYFUNCTIONPTR_arr CONSTANT setFramePaddingV = {0, &setFramePaddingV1};
0250 MODIFYFUNCTIONPTR_arr CONSTANT adjustFrameDataLengthV = {0, &adjustFrameDataLengthV1};
0251 MODIFYFUNCTIONPTR_arr CONSTANT adjustFrameHistoryLengthV = {0, &adjustFrameHistoryLengthV1};
0252 MODIFYFUNCTIONPTR_arr CONSTANT adjustFrameErrorLengthV = {0, &adjustFrameErrorLengthV1};
0253
0254 LOGICALMODIFYFUNCTIONPTR_arr CONSTANT setDataTypeV = {0, &setDataTypeV1};
0255 LOGICALMODIFYFUNCTIONPTR_arr CONSTANT setFrameTypeV = {0, &setFrameTypeV1};
0256 LOGICALMODIFYFUNCTIONPTR_arr CONSTANT setSourceIdV = {0, &setSourceIdV1};
0257 LOGICALMODIFYFUNCTIONPTR_arr CONSTANT setFrameHistoryLengthV = {0, &setFrameHistoryLengthV1};
0258 LOGICALMODIFYFUNCTIONPTR_arr CONSTANT setFrameErrorLengthV = {0, &setFrameErrorLengthV1};
0259 LOGICALMODIFYFUNCTIONPTR_arr CONSTANT setFrameAlignLengthV = {0, &setFrameAlignLengthV1};
0260 LOGICALMODIFYFUNCTIONPTR_arr CONSTANT setFrameStatusV = {0, &setFrameStatusV1};
0261
0262 VARRAYCOPYFUNCTIONPTR_arr CONSTANT getAlignBlockV = {0, &getAlignBlockV1};
0263 LARRAYCOPYFUNCTIONPTR_arr CONSTANT setAlignBlockV = {0, &setAlignBlockV1};
0264
0265 MAKEHDRFUNCTIONPTR_arr CONSTANT makeFrameHdrV = {0, &makeFrameHdrV1};
0266
0267 PARAMACCESSFUNCTIONPTR_arr CONSTANT getHistoryEntryV = {0, &getHistoryEntryV1};
0268 PARAMACCESSFUNCTIONPTR_arr CONSTANT getHistoryStageV = {0, &getHistoryStageV1};
0269 PARAMACCESSFUNCTIONPTR_arr CONSTANT getHistorySourceIndexV = {0, &getHistorySourceIndexV1};
0270 PARAMACCESSFUNCTIONPTR_arr CONSTANT getHistoryStatusV = {0, &getHistoryStatusV1};
0271 FINDNEXTFUNCTIONPTR_arr CONSTANT findNextErrorV = {0, &findNextErrorV1};
0272
0273 VALUE_ret getFrameStatus ( FRAME_ptr frame_ptr)
0274 {
0275   UINT version = getFrameHdrVersion(frame_ptr);
0276   if (version != valueFailure)
0277     return (*getFrameStatusV[version])(frame_ptr);
0278   else
0279     return valueFailure;
0280 }
0281
0282 VALUE_ret getFrameType ( FRAME_ptr frame_ptr)
0283 {
0284   UINT version = getFrameHdrVersion(frame_ptr);
0285   if (version != valueFailure)
0286     return (*getFrameTypeV[version])(frame_ptr);
0287   else
0288     return valueFailure;
0289 }
0290
0291
0292 VALUE_ret getFrameSourceId ( FRAME_ptr frame_ptr)
0293 {
0294   UINT version = getFrameHdrVersion(frame_ptr);
0295   if (version != valueFailure)
0296     return (*getFrameSourceIdV[version])(frame_ptr);
0297   else
0298     return valueFailure;
0299 }
0300
0301
0302 VALUE_ret getFrameDataType ( FRAME_ptr frame_ptr)
0303 {
0304   UINT version = getFrameHdrVersion(frame_ptr);
0305   if (version != valueFailure)
0306     return (*getFrameDataTypeV[version])(frame_ptr);
0307   else
0308     return valueFailure;
0309 }
0310
0311
0312 VALUE_ret getFrameDataLength ( FRAME_ptr frame_ptr)
0313 {
0314   UINT version = getFrameHdrVersion(frame_ptr);
0315   if (version != valueFailure)
0316     return (*getFrameDataLengthV[version])(frame_ptr);
0317   else
0318     return valueFailure;
0319 }
0320
0321
0322 VALUE_ret getFrameHistoryLength ( FRAME_ptr frame_ptr)
0323 {
0324   UINT version = getFrameHdrVersion(frame_ptr);
0325   if (version != valueFailure)
0326     return (*getFrameHistoryLengthV[version])(frame_ptr);
0327   else
0328     return valueFailure;
0329 }
0330
0331
0332 VALUE_ret getFrameErrorLength ( FRAME_ptr frame_ptr)
0333 {
0334   UINT version = getFrameHdrVersion(frame_ptr);
0335   if (version != valueFailure)
0336     return (*getFrameErrorLengthV[version])(frame_ptr);
0337   else
0338     return valueFailure;
0339 }
0340
0341
0342 VALUE_ret getFrameAlignLength ( FRAME_ptr frame_ptr)
0343 {
0344   UINT version = getFrameHdrVersion(frame_ptr);
0345   if (version != valueFailure)
0346     return (*getFrameAlignLengthV[version])(frame_ptr);
0347   else
0348     return valueFailure;
0349 }
0350
0351
0352 PTR_ret findFrameAlignBlock ( FRAME_ptr frame_ptr)
0353 {
0354   UINT version = getFrameHdrVersion(frame_ptr);
0355   if (version != valueFailure)
0356     return (*findFrameAlignBlockV[version])(frame_ptr);
0357   else
0358     return ptrFailure;
0359 }
0360
0361
0362 PTR_ret findFrameHistoryStart ( FRAME_ptr frame_ptr)
0363 {
0364   UINT version = getFrameHdrVersion(frame_ptr);
0365   if (version != valueFailure)
0366     return (*findFrameHistoryStartV[version])(frame_ptr);
0367   else
0368     return ptrFailure;
0369 }
0370
0371
0372 PTR_ret findFrameErrorStart ( FRAME_ptr frame_ptr)
0373 {
0374   UINT version = getFrameHdrVersion(frame_ptr);
0375   if (version != valueFailure)
0376     return (*findFrameErrorStartV[version])(frame_ptr);
0377   else
0378     return ptrFailure;
0379 }
0380
0381
0382 VALUE_ret orFrameStatus (FRAME_ptr frame_ptr, UINT statusBits)
0383 {
0384   UINT version = getFrameHdrVersion(frame_ptr);
0385   if (version != valueFailure)
0386     return (*orFrameStatusV[version])(frame_ptr, statusBits);
0387   else
0388     return valueFailure;
0389 }
0390
0391
0392 VALUE_ret getFramePadding ( FRAME_ptr frame_ptr)
0393 {
0394   UINT version = getFrameHdrVersion(frame_ptr);
0395   if (version != valueFailure)
0396     return (*getFramePaddingV[version])(frame_ptr);
0397   else
0398     return valueFailure;
0399 }
0400
0401
0402 /*  Construct a header for a frame using the "current" header version
0403  */
0404 VALUE_ret makeFrameHdr (FRAME_ptr frame_ptr,  UINT maxFrameLen,  UINT dataType,
0405             UINT frameType,  UINT sourceId)
0406 {
0407   return (*makeFrameHdrV[currentFrameHdrVersion])(frame_ptr, maxFrameLen, dataType,
0408                           frameType, sourceId);
0409 }
0410
0411 VALUE_ret adjustFrameDataLength (FRAME_ptr frame_ptr, UINT newDwords)
0412 {
0413   UINT version = getFrameHdrVersion(frame_ptr);
0414   if (version != valueFailure)
0415     return (*adjustFrameDataLengthV[version])(frame_ptr, newDwords);
0416   else
0417     return valueFailure;
0418 }
0419
0420
0421 VALUE_ret adjustFrameHistoryLength (FRAME_ptr frame_ptr, UINT newDwords)
0422 {
0423   UINT version = getFrameHdrVersion(frame_ptr);
0424   if (version != valueFailure)
0425     return (*adjustFrameHistoryLengthV[version])(frame_ptr, newDwords);
0426   else
0427     return valueFailure;
0428 }
0429
0430 VALUE_ret adjustFrameErrorLength (FRAME_ptr frame_ptr, UINT newDwords)
0431 {
0432   UINT version = getFrameHdrVersion(frame_ptr);
0433   if (version != valueFailure)
0434     return (*adjustFrameErrorLengthV[version])(frame_ptr, newDwords);
0435   else
0436     return valueFailure;
0437 }
0438
0439 VALUE_ret setFramePadding (FRAME_ptr frame_ptr, UINT padDwords)
0440 {
0441   UINT version = getFrameHdrVersion(frame_ptr);
0442   if (version != valueFailure)
0443     return (*setFramePaddingV[version])(frame_ptr, padDwords);
0444   else
0445     return valueFailure;
0446 }
0447
0448 LOGIC_ret setDataType (FRAME_ptr frame_ptr, UINT dataType)
0449 {
0450   UINT version = getFrameHdrVersion(frame_ptr);
0451   if (version != valueFailure)
0452     return (*setDataTypeV[version])(frame_ptr, dataType);
0453   else
0454     return FALSE;
0455 }
0456
0457 LOGIC_ret setFrameType (FRAME_ptr frame_ptr, UINT frameType)
0458 {
0459   UINT version = getFrameHdrVersion(frame_ptr);
0460   if (version != valueFailure)
0461     return (*setFrameTypeV[version])(frame_ptr, frameType);
0462   else
0463     return FALSE;
0464 }
0465
0466 LOGIC_ret setSourceId (FRAME_ptr frame_ptr, UINT sourceId)
0467 {
0468   UINT version = getFrameHdrVersion(frame_ptr);
0469   if (version != valueFailure)
0470     return (*setSourceIdV[version])(frame_ptr, sourceId);
0471   else
0472     return FALSE;
0473 }
0474
0475 LOGIC_ret setFrameHistoryLength (FRAME_ptr frame_ptr, UINT historyLength)
0476 {
0477   UINT version = getFrameHdrVersion(frame_ptr);
0478   if (version != valueFailure)
0479     return (*setFrameHistoryLengthV[version])(frame_ptr, historyLength);
0480   else
0481     return FALSE;
0482 }
0483
0484 LOGIC_ret setFrameErrorLength (FRAME_ptr frame_ptr, UINT errorLength)
0485 {
0486   UINT version = getFrameHdrVersion(frame_ptr);
0487   if (version != valueFailure)
0488     return (*setFrameErrorLengthV[version])(frame_ptr, errorLength);
0489   else
0490     return FALSE;
0491 }
0492
0493 LOGIC_ret setFrameAlignLength (FRAME_ptr frame_ptr, UINT alignLength)
0494 {
0495   UINT version = getFrameHdrVersion(frame_ptr);
0496   if (version != valueFailure)
0497     return (*setFrameAlignLengthV[version])(frame_ptr, alignLength);
0498   else
0499     return FALSE;
0500 }
0501
0502 LOGIC_ret setFrameStatus (FRAME_ptr frame_ptr, UINT status)
0503 {
0504   UINT version = getFrameHdrVersion(frame_ptr);
0505   if (version != valueFailure)
0506     return (*setFrameStatusV[version])(frame_ptr, status);
0507   else
0508     return FALSE;
0509 }
0510
0511 VALUE_ret getAlignBlock (FRAME_ptr frame_ptr, PHDWORD* alignDestination, UINT maxNumDwords)
0512 {
0513   UINT version = getFrameHdrVersion(frame_ptr);
0514   if (version != valueFailure)
0515     return (*getAlignBlockV[version])(frame_ptr, alignDestination, maxNumDwords);
0516   else
0517     return valueFailure;
0518 }
0519
0520 LOGIC_ret setAlignBlock (FRAME_ptr frame_ptr,PHDWORD* alignSource, UINT numDwords)
0521 {
0522   UINT version = getFrameHdrVersion(frame_ptr);
0523   if (version != valueFailure)
0524     return (*setAlignBlockV[version])(frame_ptr, alignSource, numDwords);
0525   else
0526     return FALSE;
0527 }
0528
0529 VALUE_ret getHistoryEntry (FRAME_ptr frame_ptr, UINT index)
0530 {
0531   UINT version = getFrameHdrVersion(frame_ptr);
0532   if (version != valueFailure)
0533     return (*getHistoryEntryV[version])(frame_ptr, index);
0534   else
0535     return valueFailure;
0536 }
0537
0538 VALUE_ret getHistoryStage (FRAME_ptr frame_ptr, UINT index)
0539 {
0540   UINT version = getFrameHdrVersion(frame_ptr);
0541   if (version != valueFailure)
0542     return (*getHistoryStageV[version])(frame_ptr, index);
0543   else
0544     return valueFailure;
0545 }
0546
0547 VALUE_ret getHistorySourceIndex (FRAME_ptr frame_ptr, UINT index)
0548 {
0549   UINT version = getFrameHdrVersion(frame_ptr);
0550   if (version != valueFailure)
0551     return (*getHistorySourceIndexV[version])(frame_ptr, index);
0552   else
0553     return valueFailure;
0554 }
0555
0556 VALUE_ret getHistoryStatus (FRAME_ptr frame_ptr, UINT index)
0557 {
0558   UINT version = getFrameHdrVersion(frame_ptr);
0559   if (version != valueFailure)
0560     return (*getHistoryStatusV[version])(frame_ptr, index);
0561   else
0562     return valueFailure;
0563 }
0564
0565 PTR_ret findNextError (FRAME_ptr frame_ptr, FRAME_ptr thisError)
0566 {
0567   UINT version = getFrameHdrVersion(frame_ptr);
0568   if (version != valueFailure)
0569     return (*findNextErrorV[version])(frame_ptr, thisError);
0570   else
0571     return ptrFailure;
0572 }
0573
0574 #endif /* end of ifndef DCM */
0575
0576 /* ====================================================== */
0577 /* Here ends the code for the version-DEPENDENT functions */
0578
0579
0580
0581
0582
0583
0584
0585
0586
0587
0588
0589