/* propagate a list of attributes */
PTErr_t moveAttrList ( PTRefNum_t PTRefNum1, PTRefNum_t PTRefNum2,
KpInt32_p attrList, KpInt32_t hasSimAttr, PTRefNum_t PTRefNumR)
{
PTErr_t errnum = KCP_SUCCESS;
KpHandle_t startR1AttrList = NULL, startR2AttrList = NULL;
KpInt32_t i1;
KpInt32_t attrSize;
KpChar_t attribute[KCM_MAX_ATTRIB_VALUE_LENGTH+1];
errnum = getPTStatus (PTRefNum1);
if ((errnum == KCP_PT_ACTIVE) || (errnum == KCP_PT_INACTIVE) || (errnum == KCP_SERIAL_PT)) {
startR1AttrList = getPTAttr (PTRefNum1);
}
errnum = getPTStatus (PTRefNum2);
if ((errnum == KCP_PT_ACTIVE) || (errnum == KCP_PT_INACTIVE) || (errnum == KCP_SERIAL_PT)) {
startR2AttrList = getPTAttr (PTRefNum2);
}
for (i1 = 0; attrList[i1] != ATTR_LIST_END; i1++) {
errnum = KCP_FAILURE;
if (startR1AttrList != NULL) {
attrSize = KCM_MAX_ATTRIB_VALUE_LENGTH;
errnum = GetAttribute (startR1AttrList, attrList[i1], &attrSize, attribute);
}
if ((errnum != KCP_SUCCESS) && (startR2AttrList != NULL)) { /* try for default attribute */
attrSize = KCM_MAX_ATTRIB_VALUE_LENGTH;
errnum = GetAttribute (startR2AttrList, attrList[i1], &attrSize, attribute);
}
if (errnum == KCP_SUCCESS) {
errnum = PTSetAttribute(PTRefNumR, attrList[i1], attribute); /* write to destination PT */
}
if (hasSimAttr == 1) {
if (errnum == KCP_INVAL_PTA_TAG) { /* try for backup attribute */
attrSize = KCM_MAX_ATTRIB_VALUE_LENGTH; /* read attribute */
errnum = GetAttribute (startR2AttrList, attrList[i1+1], &attrSize, attribute);
if (errnum == KCP_SUCCESS) { /* write to destination PT */
errnum = PTSetAttribute (PTRefNumR, attrList[i1], attribute);
}
}
i1++; /* skip past backup attribute */
}
if ((errnum != KCP_INVAL_PTA_TAG) && (errnum != KCP_SUCCESS)) {
return (errnum);
}
}
return KCP_SUCCESS;
}
/* PTGetPTF writes a PT to external memory in a variety of formats. */
PTErr_t
PTGetPTF ( PTRefNum_t PTRefNum,
PTType_t format,
KpInt32_t mBlkSize,
PTAddr_t PTAddr)
{
PTErr_t errnum, PTstatus;
KpHandle_t PTHdr, PTAttr, PTData;
KpFd_t fd;
KpInt32_t attrSize, resultSize, nBytes;
PTRefNum_t resizePTRefNum = 0, thePTRefNum;
KpChar_p memData;
errnum = getPTStatus (PTRefNum);
if ((errnum == KCP_PT_ACTIVE) || (errnum == KCP_PT_INACTIVE) || (errnum == KCP_SERIAL_PT)) {
#if defined KCP_DIAG_LOG
{KpChar_t string[256];
sprintf (string, "\nPTGetPTF\n PTRefNum %x, format %x, mBlkSize %d, PTAddr %x\n",
PTRefNum, format, mBlkSize, PTAddr);
kcpDiagLog (string);}
#endif
PTstatus = errnum;
/* verify the dimensions of the grid table are valid for the specified format. */
errnum = gridDimValid (format, PTRefNum, &resizePTRefNum);
if (errnum != KCP_SUCCESS) {
goto ErrOut1;
}
if (resizePTRefNum != 0) {
thePTRefNum = resizePTRefNum; /* resized PT made */
}
else {
thePTRefNum = PTRefNum; /* use original PT */
}
/* determine the size the resized PT */
errnum = PTGetSizeF (thePTRefNum, format, &resultSize);
if (errnum != KCP_SUCCESS) {
goto ErrOut1;
}
if (resultSize > mBlkSize) { /* PT may not be larger than the buffer size */
errnum = KCP_PT_BLOCK_TOO_SMALL;
goto ErrOut1;
}
PTAttr = getPTAttr (thePTRefNum);
PTHdr = getPTHdr (thePTRefNum);
PTData = getPTData (thePTRefNum);
/* initialize memory file manager to write the PT */
if (KpOpen (NULL, "m", &fd, NULL, (KpGenericPtr_t)PTAddr, mBlkSize) != KCMS_IO_SUCCESS) {
errnum = KCP_SYSERR_1;
goto ErrOut1;
}
attrSize = getAttrSize (PTAttr); /* get size of attributes */
errnum = TpWriteHdr (&fd, format, PTHdr, attrSize); /* write the header info */
if (errnum != KCP_SUCCESS) {
Kp_close (&fd);
goto ErrOut1;
}
#if !defined KCP_ICC_ONLY
switch (format) {
case PTTYPE_FUTF:
errnum = writeAttributes (&fd, PTAttr); /* write the attributes */
if (errnum != KCP_SUCCESS) {
break;
}
default:
break;
}
#endif
/* if PT active, write data to external format */
if (((PTstatus == KCP_PT_ACTIVE) || (PTstatus == KCP_SERIAL_PT)) && (errnum == KCP_SUCCESS)) {
errnum = TpWriteData (&fd, format, PTHdr, PTData);
}
(void) Kp_close (&fd);
/* if the result PT size is smaller than the memory block size
fill the end of the memory block with zeros */
nBytes = mBlkSize - resultSize;
if (nBytes > 0) {
memData = (KpChar_p)PTAddr + resultSize;
while (nBytes--) {
*memData++ = 0;
}
}
}
ErrOut1:
if (resizePTRefNum != 0) {
PTCheckOut (resizePTRefNum);
}
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);
}
