PTErr_t initAttrib (PTRefNum_t PTRefNum) { PTErr_t errnum = KCP_SUCCESS; KpInt32_t attrSize, year; KpChar_t attrBuf[KCM_MAX_ATTRIB_VALUE_LENGTH+1], yearStr[10]; kpTm_t currentTime; /* If the copyright string isn't there, then generate it */ attrSize = KCM_MAX_ATTRIB_VALUE_LENGTH; errnum = PTGetAttribute (PTRefNum, KCM_COPYRIGHT, &attrSize, attrBuf); if (errnum == KCP_INVAL_PTA_TAG) { KpGetLocalTime(¤tTime); /* get the current time, which has the current year */ year = currentTime.year + 1900; /* add 1900 to get the actual year */ KpItoa (year, yearStr); strcpy (attrBuf, FUT_COPYRIGHT_PREFIX); /* make the copyright string. */ strcat (attrBuf, yearStr); strcat (attrBuf, FUT_COPYRIGHT_SUFFIX); errnum = PTSetAttribute (PTRefNum, KCM_COPYRIGHT, attrBuf); } return errnum; }
/* insert delimiter ":", convert integer to ascii, * and append it to given string */ static void addIntStr (KpInt32_t integer, KpChar_p str) { KpChar_t intStr[20]; /* really large just in case */ strcat ( str, ":" ); /* insert delimiter */ KpItoa (integer, intStr); /* convert integer to ascii */ strcat ( str, intStr); /* append to input string */ }
/* if composition mode is input set input attribute to "is linearized" */ static PTErr_t setLinearized (PTRefNum_t PTRefNumR, KcmAttribute attrTag) { PTErr_t PTErr; KpChar_t attrStr[KCM_MAX_ATTRIB_VALUE_LENGTH+1]; KpItoa (KCM_IS_LINEARIZED, attrStr); PTErr = PTSetAttribute (PTRefNumR, attrTag, attrStr); return (PTErr); }
/* Generate attributes which must be in each PT */ static PTErr_t generateAttr (PTRefNum_t PTRefNumR) { PTErr_t PTErr; KpChar_t attrStr[KCM_MAX_ATTRIB_VALUE_LENGTH+1]; kpTm_t Date; KpGetLocalTime (&Date); /* get the current date and time */ KpItoa ((KpInt32_t) (1900 + Date.year), attrStr); /* start with year */ addIntStr ((KpInt32_t)Date.mon, attrStr); /* month */ addIntStr ((KpInt32_t)Date.mday, attrStr); /* day */ addIntStr ((KpInt32_t)Date.hour, attrStr); /* hour */ addIntStr ((KpInt32_t)Date.min, attrStr); /* minute */ addIntStr ((KpInt32_t)Date.sec, attrStr); /* second */ PTErr = PTSetAttribute (PTRefNumR, KCM_CREATE_TIME, attrStr); /* write time to destination PT */ if (PTErr == KCP_SUCCESS) { KpItoa (KCM_COMPOSED_CLASS, attrStr); PTErr = PTSetAttribute (PTRefNumR, KCM_CLASS, attrStr); /* set composition state to composed */ } return (PTErr); }
/* Set KCM_EFFECT_TYPE attribute, which use a default if the attribute is * present in both PTs but with different values */ static PTErr_t setEFFECTstate (PTRefNum_t PTRefNum1, PTRefNum_t PTRefNum2, PTRefNum_t PTRefNumR) { KpChar_t attrStr[KCM_MAX_ATTRIB_VALUE_LENGTH+1]; KpChar_t attrStr1[KCM_MAX_ATTRIB_VALUE_LENGTH+1], attrStr2[KCM_MAX_ATTRIB_VALUE_LENGTH+1]; PTErr_t PTErr, errnum1, errnum2; KpInt32_t attrSize; PTErr = KCP_FAILURE; /* attribute not yet written */ KpItoa (KCM_EFFECT_MULTIPLE, attrStr); /* initialize to default */ attrSize = KCM_MAX_ATTRIB_VALUE_LENGTH; /* get attribute from 1st PT */ errnum1 = PTGetAttribute (PTRefNum1, KCM_EFFECT_TYPE, &attrSize, attrStr1); attrSize = KCM_MAX_ATTRIB_VALUE_LENGTH; /* get attribute from 2nd PT */ errnum2 = PTGetAttribute (PTRefNum2, KCM_EFFECT_TYPE, &attrSize, attrStr2); if (errnum1 == KCP_SUCCESS) { if ((errnum2 != KCP_SUCCESS) || /* if attribute is not in 2nd */ (strcmp (attrStr1, attrStr2) == 0)) { /* or attribute values are the same */ strcpy (attrStr, attrStr1); /* use attribute in 1st PT */ } } else { if (errnum2 == KCP_SUCCESS) { /* if attribute is in 2nd */ strcpy (attrStr, attrStr2); /* use it */ } else { PTErr = KCP_SUCCESS; /* not in either PT, do not write attribute */ } } if (PTErr != KCP_SUCCESS) { /* write to destination PT */ PTErr = PTSetAttribute (PTRefNumR, KCM_EFFECT_TYPE, attrStr); } return (PTErr); }
static void MemLogFunc (void FAR *Ptr, long Size, MemLogType_t Type) { char MsgText [82]; static KpFileId fid; int32 MsgSize, i; char *sLogName; if (NULL == Ptr) return; /* check for first time */ if (lLogSeqNum == 0) { fLogFileError = KPFALSE; lLogUseCount = 0; sLogName = getenv("KPMEMTRACEFILE"); if (sLogName == NULL){ fLogFileError = KPTRUE; return; } /* create the log file */ if (KpFileOpen(sLogName, "w", &KCPDataDirProps, &fid) == 0) { fLogFileError = KPTRUE; return; } } if (fLogFileError == KPTRUE) return; ++lLogSeqNum; for (i = 0; i < 80; i++) { MsgText[i] = 32; /* SP */ } MsgText[i++] = '\n'; MsgText[i++] = 0; /* create proper log message */ switch (Type) { case MemLogAlloc: lLogUseCount++; KpLtos((int32)Ptr, MsgText); strcpy (&MsgText[10], "Allocate"); KpItoa(lLogSeqNum, &MsgText[20]); KpItoa(lLogUseCount, &MsgText[30]); KpItoa(Size, &MsgText[40]); break; case MemLogFree: lLogUseCount--; KpLtos((int32)Ptr, MsgText); strcpy (&MsgText[10], "Free"); KpItoa(lLogSeqNum, &MsgText[20]); KpItoa(lLogUseCount, &MsgText[30]); break; default: strcpy (MsgText, "Unknown memory log type\n"); break; } for (i = 0; i < 80; i++) { if (MsgText[i] == 0) { MsgText[i] = 32; /* SP */ } } /* write the message */ MsgSize = strlen (MsgText); if (KpFileWrite(fid, &MsgText, MsgSize) == 0){ fLogFileError = KPTRUE; return; } /* check for user requested break */ if (lLogSeqNum == KpSeqNumStopAt) { KpMemLogBreak (); } }
/* TpReadData reads a fut from a memory block and returns a handle to a newly allocated fut */ PTErr_t TpReadData( KpFd_p fd, PTType_t format, PTRefNum_t PTRefNum, KpHandle_t PTHdr, KpHandle_t FAR* PTData) { PTErr_t errnum; fut_p fut = NULL, theFutFromMatrix = NULL, newFut = NULL, lab2xyzFut = NULL, finalFut = NULL; fut_hdr_p futHdr; Fixed_t matrix[MF_MATRIX_DIM * MF_MATRIX_DIM + MF_MATRIX_DIM]; KpInt32_t ret, iomask; KpChar_t ENUM_String[20]; KpInt32_t inCS, i, i1; ResponseRecord_t inRedTRC, inGreenTRC, inBlueTRC; ResponseRecord_t outRedTRC, outGreenTRC, outBlueTRC; PTRefNum_t matrixPTRefNum; PTDataClass_t iClass, oClass; futHdr = (fut_hdr_p) lockBuffer (PTHdr); /* get buffer pointer */ if (futHdr == NULL) { errnum = KCP_MEM_LOCK_ERR; goto GetOut; } futHdr->profileType = getIntAttrDef (PTRefNum, KCM_ICC_PROFILE_TYPE); futHdr->spaceIn = getIntAttrDef (PTRefNum, KCM_SPACE_IN); futHdr->spaceOut = getIntAttrDef (PTRefNum, KCM_SPACE_OUT); futHdr->iDataClass = getDataClass (futHdr->spaceIn); futHdr->oDataClass = getDataClass (futHdr->spaceOut); switch (format) { case FUT_CIGAM: /* fut with bytes reversed */ case FUT_MAGIC: /* fut with bytes in correct order */ if ((fut = fut_alloc_fut ()) == NULL) { /* allocate a new fut structure */ errnum = KCP_NO_ACTIVATE_MEM; } else { if (fut_read_tbls (fd, fut, futHdr) != 1) { /* read fut tables */ errnum = KCP_PT_DATA_READ_ERR; } else { if (fut_io_decode (fut, futHdr) == 0) { errnum = KCP_PTERR_0; } else { errnum = KCP_SUCCESS; } } } break; case PTTYPE_MFT1: case PTTYPE_MFT2: fut = fut_readMFutTbls (fd, futHdr, matrix); /* read matrix fut tables */ if (fut == NULL) { errnum = KCP_NO_ACTIVATE_MEM; } else { inCS = getIntAttrDef (PTRefNum, KCM_SPACE_IN); if ((inCS == KCM_CIE_XYZ) && (isIdentityMatrix (matrix, MF_MATRIX_DIM) != 1)) { ret = makeOutputMatrixXform ((Fixed_p)&matrix, 8, &theFutFromMatrix); if (ret != 1) { errnum = KCP_INCON_PT; goto GetOut; } else { iomask = FUT_PASS(FUT_XYZ); /* get the Lab to XYZ fut */ lab2xyzFut = get_lab2xyz (KCP_GRID_DIM_SIXTEEN); newFut = fut_comp (theFutFromMatrix, lab2xyzFut, iomask); if (newFut != NULL) { finalFut = fut_comp (fut, newFut, iomask); } fut_free (theFutFromMatrix); /* free intermediate futs */ fut_free (lab2xyzFut); fut_free (fut); fut_free (newFut); fut = finalFut; /* set the input color space attribute to Lab */ KpItoa (KCM_CIE_LAB, ENUM_String); errnum = PTSetAttribute (PTRefNum, KCM_SPACE_IN, ENUM_String); if (errnum != KCP_SUCCESS) { goto GetOut; } /* set the input composition attribute to Lab */ errnum = PTSetAttribute (PTRefNum, KCM_IN_CHAIN_CLASS_2, "6"); if (errnum != KCP_SUCCESS) { goto GetOut; } } } if ((fut == NULL) || !fut_io_encode (fut, futHdr)) { /* make the info header */ errnum = KCP_INCON_PT; goto GetOut; } errnum = KCP_SUCCESS; } break; case PTTYPE_MA2B: case PTTYPE_MB2A: matrix[0] = matrix[4] = matrix[8] = KpF15d16FromDouble(1.0); matrix[1] = matrix[2] = matrix[3] = matrix[5] = matrix[6] = matrix[7] = matrix[9] = matrix[10] = matrix[11] = KpF15d16FromDouble(0.0); fut = fut_readMabFutTbls (fd, futHdr, matrix); /* read matrix fut tables */ if (fut == NULL) { errnum = KCP_NO_ACTIVATE_MEM; } else { if (fut->lutConfig & HAS_MATRIX_DATA) { i = MF_MATRIX_DIM * MF_MATRIX_DIM + MF_MATRIX_DIM; for (i1 = 0; i1 < i; i1++) { fut->matrix[i1] = matrix[i1]; } switch (fut->lutConfig) { case MAB_M_MATRIX_B_COMBO: case MBA_B_MATRIX_M_COMBO: inRedTRC.CurveCount = fut->mabInTblEntries[0]; inGreenTRC.CurveCount = fut->mabInTblEntries[1]; inBlueTRC.CurveCount = fut->mabInTblEntries[2]; inRedTRC.CurveData = fut->mabInRefTbl[0]; inGreenTRC.CurveData = fut->mabInRefTbl[1]; inBlueTRC.CurveData = fut->mabInRefTbl[2]; outRedTRC.CurveCount = fut->mabOutTblEntries[0]; outGreenTRC.CurveCount = fut->mabOutTblEntries[1]; outBlueTRC.CurveCount = fut->mabOutTblEntries[2]; outRedTRC.CurveData = fut->mabOutRefTbl[0]; outGreenTRC.CurveData = fut->mabOutRefTbl[1]; outBlueTRC.CurveData = fut->mabOutRefTbl[2]; iClass = getDataClass(futHdr->spaceIn); oClass = getDataClass(futHdr->spaceOut); ret = makeFutFromMatrix ((Fixed_p)&matrix, &inRedTRC, &inGreenTRC, &inBlueTRC, &outRedTRC, &outGreenTRC, &outBlueTRC, MATRIX_GRID_SIZE, iClass, oClass, (fut_p *)&theFutFromMatrix); break; case MBA_B_MATRIX_M_CLUT_A_COMBO: inRedTRC.CurveCount = fut->mabInTblEntries[0]; inGreenTRC.CurveCount = fut->mabInTblEntries[1]; inBlueTRC.CurveCount = fut->mabInTblEntries[2]; inRedTRC.CurveData = fut->mabInRefTbl[0]; inGreenTRC.CurveData = fut->mabInRefTbl[1]; inBlueTRC.CurveData = fut->mabInRefTbl[2]; iClass = getDataClass(futHdr->spaceIn); oClass = KCP_UNKNOWN; ret = makeFutFromMatrix ((Fixed_p)&matrix, &inRedTRC, &inGreenTRC, &inBlueTRC, NULL, NULL, NULL, MATRIX_GRID_SIZE, iClass, oClass, (fut_p *)&theFutFromMatrix); break; case MAB_A_CLUT_M_MATRIX_B_COMBO: outRedTRC.CurveCount = fut->mabOutTblEntries[0]; outGreenTRC.CurveCount = fut->mabOutTblEntries[1]; outBlueTRC.CurveCount = fut->mabOutTblEntries[2]; outRedTRC.CurveData = fut->mabOutRefTbl[0]; outGreenTRC.CurveData = fut->mabOutRefTbl[1]; outBlueTRC.CurveData = fut->mabOutRefTbl[2]; iClass = KCP_UNKNOWN; oClass = getDataClass(futHdr->spaceOut); ret = makeFutFromMatrix ((Fixed_p)&matrix, NULL, NULL, NULL, &outRedTRC, &outGreenTRC, &outBlueTRC, MATRIX_GRID_SIZE, iClass, oClass, (fut_p *)&theFutFromMatrix); break; default: break; } if (NULL != theFutFromMatrix) { /* Create a PT from the fut */ errnum = fut2PT (&theFutFromMatrix, KCM_UNKNOWN, KCM_UNKNOWN, PTTYPE_CALCULATED, &matrixPTRefNum); if (errnum != KCP_SUCCESS) { goto GetOut; } errnum = setMatrixPTRefNum (PTRefNum, matrixPTRefNum, fut->lutConfig); if (errnum != KCP_SUCCESS) { goto GetOut; } } if (ret != 1) { errnum = KCP_INCON_PT; goto GetOut; } } if ((fut == NULL) || !fut_io_encode (fut, futHdr)) { /* make the info header */ errnum = KCP_INCON_PT; goto GetOut; } errnum = KCP_SUCCESS; } break; default: break; } GetOut: if ((errnum != KCP_SUCCESS) || (fut == NULL)) { fut_free (fut); } else { /* return handle to fut to caller */ /* make sure the futs are in the reference state */ if (fut_to_mft (fut) == 1) { *PTData = (KpHandle_t)fut_unlock_fut (fut); } } if ( ! unlockBuffer (PTHdr)) { errnum = KCP_MEM_UNLOCK_ERR; } return errnum; }
PTErr_t TpSetImplicitAttr ( PTRefNum_t PTRefNum) { KpChar_t attribute[256]; PTErr_t errnum; fut_hdr_p futHdr; chan_hdr_p chan; KpInt32_t i1, i2, attributeTag, numOutVar, numInVar[FUT_NCHAN]; KpHandle_t PTHdr; errnum = PTSetAttribute (PTRefNum, KCM_TECH_TYPE, KCM_FUT_S); PTHdr = getPTHdr (PTRefNum); /* get the header info */ futHdr = (fut_hdr_p)lockBuffer (PTHdr); if (futHdr != NULL) { /* set the technology version attribute */ KpItoa (futHdr->version, attribute); errnum = PTSetAttribute (PTRefNum, KCM_TECH_VERSION, attribute); /* get the number of active output channels */ /* and the number of active inputs for each channel */ for (i1 = 0; i1 < FUT_NCHAN; i1++) { numInVar[i1] = 0; /* zero out the number of inputs array */ } numOutVar = 0; /* and # of outputs */ switch (futHdr->magic) { case PTTYPE_MFT1: case PTTYPE_MFT2: case PTTYPE_MB2A: case PTTYPE_MA2B: numOutVar = futHdr->icode[1]; /* copy from header */ for (i1 = 0; i1 < numOutVar; i1++) { numInVar[i1] = futHdr->icode[0]; } break; default: /* PTTYPE_FUTF */ for (i1 = 0, chan = futHdr->chan; i1 < FUT_NCHAN; i1++, chan++) { if ((chan->gcode & FUTIO_CODE) != FUTIO_NULL) { numOutVar++; for (i2 = 0; i2 < FUT_NCHAN; i2++) { if ((chan->icode[i2] & FUTIO_CODE) != FUTIO_NULL) { (numInVar[i1])++; } } } } break; } /* set the attribute for number of inputs for each channnel */ for (i1 = 0, attributeTag = KCM_NUM_IN_VAR_1; i1<FUT_NCHAN; i1++) { if (numInVar[i1] != 0) { KpItoa (numInVar[i1], attribute); PTSetAttribute (PTRefNum, attributeTag, attribute); attributeTag++; } } /* set the number of output channnels attribute */ KpItoa (numOutVar, attribute); errnum = PTSetAttribute (PTRefNum, KCM_NUM_OUT_VAR, attribute); if ( ! unlockBuffer (PTHdr)) { errnum = KCP_MEM_UNLOCK_ERR; } } return errnum; }
/* PTGetSizeF calculates the size of a PT in any format. */ PTErr_t PTGetSizeF (PTRefNum_t PTRefNum, PTType_t format, KpInt32_p mBlkSize) { PTErr_t errnum, errnum1; KpInt32_t extSize, intSize; KpHandle_t PTHdr, PTData; PTRefNum_t matrixPTRefNum; KpUInt32_t lutConfig; #if !defined KCP_ICC_ONLY KpHandle_t PTAttr; #endif #if !defined KCMS_NO_CRC KpChar_t strCRCmade[KCM_MAX_ATTRIB_VALUE_LENGTH+1]; KpInt32_t crc32; #endif errnum = getPTStatus (PTRefNum); if ((errnum == KCP_PT_ACTIVE) || (errnum == KCP_PT_INACTIVE) || (errnum == KCP_SERIAL_PT)) { if (mBlkSize == NULL) return (KCP_BAD_PTR); switch (format) { #if !defined KCP_ICC_ONLY case PTTYPE_FUTF: extSize = KCP_PT_HEADER_SIZE; /* size of external header */ break; #endif case PTTYPE_MFT1: case PTTYPE_MFT2: case PTTYPE_MFT2_VER_0: extSize = (2 * sizeof (KpInt32_t)) + (4 * sizeof (KpUInt8_t)) + (MF_MATRIX_DIM * MF_MATRIX_DIM * sizeof (KpInt32_t)); break; case PTTYPE_MAB1: case PTTYPE_MAB2: case PTTYPE_MBA1: case PTTYPE_MBA2: extSize = (7 * sizeof (KpInt32_t)) + (2 * sizeof (KpUInt8_t)) + sizeof (KpUInt16_t); errnum1 = getMatrixPTRefNum (PTRefNum, &matrixPTRefNum, &lutConfig); if (KCP_SUCCESS == errnum1) { extSize += ((MF_MATRIX_DIM * MF_MATRIX_DIM + MF_MATRIX_DIM) * sizeof (KpInt32_t)); } break; default: return (KCP_INVAL_PTTYPE); } if ((errnum == KCP_PT_ACTIVE) || (errnum == KCP_SERIAL_PT)) { /* when active, add size of external PT data block */ PTHdr = getPTHdr (PTRefNum); PTData = getPTData (PTRefNum); intSize = TpGetDataSize (PTHdr, PTData, format); if (intSize == 0) { PTRefNum_t resizePTRefNum; /* TpGetDataSize will return 0 if the grid table dimensions are not valid for the format specified. PTGetPTF will attempt to resize the grid table of the PT. Check if that resizing is possible */ errnum = gridDimValid (format, PTRefNum, &resizePTRefNum); if (errnum != KCP_SUCCESS) { return errnum; } /* Determine the size of the resized PT */ PTHdr = getPTHdr (resizePTRefNum); PTData = getPTData (resizePTRefNum); intSize = TpGetDataSize (PTHdr, PTData, format); PTCheckOut (resizePTRefNum); if (intSize == 0) { return KCP_INCON_PT; } } extSize += intSize; /* add size of data */ #if !defined KCMS_NO_CRC switch (format) { case PTTYPE_FUTF: errnum = TpCalCrc (PTHdr, PTData, &crc32); if (errnum == KCP_SUCCESS) { KpItoa(crc32, strCRCmade); PTSetAttribute(PTRefNum, KCM_CRC, strCRCmade); } break; default: break; } #endif } /* add size of attributes. Must be done after CRC calculation */ #if !defined KCP_ICC_ONLY switch (format) { case PTTYPE_FUTF: PTAttr = getPTAttr (PTRefNum); extSize += getAttrSize(PTAttr); /* plus size of attributes */ break; default: break; } #endif *mBlkSize = extSize; /* return external size of PT */ errnum = KCP_SUCCESS; } return (errnum); }
/* frees source fut on error */ PTErr_t fut2PT (fut_p *futSrc, KpInt32_t inSpace, KpInt32_t outSpace, KpInt32_t srcFormat, PTRefNum_p PTRefNumNew) { PTErr_t PTErr; fut_hdr_p PTHdr = NULL; KpHandle_t PTHdrH = NULL, PTDataH = NULL; KpChar_t colorSpaceAttr[20]; *PTRefNumNew = 0; if ( ! IS_FUT(*futSrc)) goto ErrOut1; PTHdr = allocBufferPtr (sizeof(fut_hdr_t)); /* get buffer for resultant info header */ if (PTHdr == NULL) { goto ErrOut4; } if (!fut_io_encode (*futSrc, PTHdr)) { /* make the info header */ goto ErrOut3; } PTHdr->srcFormat = srcFormat; PTDataH = fut_unlock_fut (*futSrc); if (PTDataH == NULL) { goto ErrOut2; } *futSrc = NULL; PTHdrH = unlockBufferPtr (PTHdr); /* unlock the header buffer */ if (PTHdrH == NULL) { goto ErrOut2; } PTHdr = NULL; PTErr = registerPT (PTHdrH, NULL, PTRefNumNew); /* enter PT into list */ if (PTErr != KCP_SUCCESS) { goto ErrOut0; } makeActive (*PTRefNumNew, PTDataH); /* activate the new PT */ if (inSpace != -1) { /* set the input color space attribute */ KpItoa (inSpace, colorSpaceAttr); PTErr = PTSetAttribute (*PTRefNumNew, KCM_IN_SPACE, colorSpaceAttr); } if (outSpace != -1) { /* set the output color space attribute */ KpItoa (outSpace, colorSpaceAttr); PTErr = PTSetAttribute (*PTRefNumNew, KCM_OUT_SPACE, colorSpaceAttr); } if (PTErr != KCP_SUCCESS) { goto ErrOut0; } getOut: return PTErr; ErrOut4: PTErr = KCP_NO_CHECKIN_MEM; goto ErrOut0; ErrOut3: PTErr = KCP_ENCODE_PTHDR_ERR; goto ErrOut0; ErrOut2: PTErr = KCP_MEM_UNLOCK_ERR; goto ErrOut0; ErrOut1: PTErr = KCP_BAD_ARG; ErrOut0: if (PTDataH != NULL) { *futSrc = fut_lock_fut (PTDataH); } if (*futSrc != FUT_NULL) fut_free (*futSrc); if (PTHdr != NULL) freeBufferPtr (PTHdr); if (PTHdrH != NULL) freeBuffer (PTHdrH); if (*PTRefNumNew != 0) PTCheckOut (*PTRefNumNew); goto getOut; }
/* PTActivate reads the PT data from an external memory block and * sets up the technology specific PT memory structures. Before loading * the PT, check to make sure that it matches the "checked in" info. */ PTErr_t PTActivate( PTRefNum_t PTRefNum, KpInt32_t mBlkSize, PTAddr_t PTAddr) { PTErr_t errnum; KpFd_t fd; KpHandle_t PTHdr, PTData, PTHdr2; fut_hdr_p futp; #if !defined KCMS_NO_CRC KpChar_t strCRCmade[KCM_MAX_ATTRIB_VALUE_LENGTH+1]; KpChar_t strCRCfound[KCM_MAX_ATTRIB_VALUE_LENGTH+1]; KpInt32_t crcAttrSize, crc32; #endif KpInt32_t attrSize; PTType_t format; errnum = getPTStatus (PTRefNum); if (errnum != KCP_PT_INACTIVE) { goto ErrOut1; } /* initialize memory file manager */ if (KpOpen (NULL, "m", &fd, NULL, (KpGenericPtr_t)PTAddr, mBlkSize) != KCMS_IO_SUCCESS) { errnum = KCP_SYSERR_1; goto ErrOut1; } /* read in the encoded header, verify that its the same as the original, then discard */ errnum = TpReadHdr (&fd, &PTHdr2, &format); if (errnum != KCP_SUCCESS ) { goto ErrOut2; } #if defined KCP_DIAG_LOG {KpChar_t string[256]; sprintf (string, "\nPTActivate\n PTRefNum %x, mBlkSize %d, PTAddr %x, format %x\n", PTRefNum, mBlkSize, PTAddr, format); kcpDiagLog (string);} #endif /* get and save size of attributes */ futp = lockBuffer (PTHdr2); attrSize = futp->idstr_len; unlockBuffer (PTHdr2); PTHdr = getPTHdr (PTRefNum); /* get the original PT header */ /* make sure the PT header and checkin info match */ errnum = TpCompareHdr (PTHdr, PTHdr2); (void) TpFreeHdr (PTHdr2); /* free the header */ if (errnum != KCP_SUCCESS) { /* then check for an error in hdrVerify */ goto ErrOut2; } #if !defined KCP_ICC_ONLY switch (format) { case PTTYPE_FUTF: /* discard the attribute info */ if (Kp_skip (&fd, attrSize) != KCMS_IO_SUCCESS){ /* may have been setAttribute after checkin */ errnum = KCP_PTERR_3; goto ErrOut2; } break; default: break; } #endif errnum = TpReadData (&fd, format, PTRefNum, PTHdr, &PTData); /* get the PT data */ if (errnum == KCP_SUCCESS) { if (PTMemTest () == 0) { /* enough memory to continue operations? */ errnum = KCP_NO_ACTIVATE_MEM; goto ErrOut3; } #if !defined KCMS_NO_CRC errnum = TpCalCrc (PTHdr, PTData, &crc32); /* calculate the CRC */ if (errnum == KCP_SUCCESS) { KpItoa(crc32, strCRCmade); crcAttrSize = KCM_MAX_ATTRIB_VALUE_LENGTH; errnum = PTGetAttribute(PTRefNum, KCM_CRC, &crcAttrSize, strCRCfound); if (errnum == KCP_INVAL_PTA_TAG) { /* if not present, just set it */ PTSetAttribute(PTRefNum, KCM_CRC, strCRCmade); errnum = KCP_SUCCESS; } else { /* if ((errnum == KCP_SUCCESS)*/ /* if present, must match */ /* && (strcmp (strCRCmade, strCRCfound) != 0)) { */ /* errnum = KCP_INCON_PT; */ /* goto ErrOut3; */ /* } */ } } #endif } if (errnum == KCP_SUCCESS) { /* Everything's OK, now activate */ makeActive (PTRefNum, PTData); } ErrOut2: (void) Kp_close (&fd); ErrOut1: return (errnum); ErrOut3: (void) TpFreeData (PTData); /* Release the PT memory */ goto ErrOut2; }