/* functions in other modules */
/* public variable declarations */
+uint16_t gTransId = 0;
/* private variable declarations */
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkDateTime
+S16 cmPkDateTime
(
DateTime *dateTime, /* date and time */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkDateTime(dateTime, mBuf)
-DateTime *dateTime; /* date and time */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkDateTime)
/*-- cm_gen_c_001.main_36 - added for micro seconds --*/
#ifdef SS_DATETIME_USEC
- CMCHKPK(SPkU32, dateTime->usec, mBuf);
+ CMCHKPK(oduUnpackUInt32, dateTime->usec, mBuf);
#endif /*-- SS_DATETIME_USEC --*/
- CMCHKPK(SPkU8, dateTime->tenths, mBuf);
- CMCHKPK(SPkU8, dateTime->sec, mBuf);
- CMCHKPK(SPkU8, dateTime->min, mBuf);
- CMCHKPK(SPkU8, dateTime->hour, mBuf);
- CMCHKPK(SPkU8, dateTime->year, mBuf);
- CMCHKPK(SPkU8, dateTime->day, mBuf);
- CMCHKPK(SPkU8, dateTime->month, mBuf);
-
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, dateTime->tenths, mBuf);
+ CMCHKPK(oduUnpackUInt8, dateTime->sec, mBuf);
+ CMCHKPK(oduUnpackUInt8, dateTime->min, mBuf);
+ CMCHKPK(oduUnpackUInt8, dateTime->hour, mBuf);
+ CMCHKPK(oduUnpackUInt8, dateTime->year, mBuf);
+ CMCHKPK(oduUnpackUInt8, dateTime->day, mBuf);
+ CMCHKPK(oduUnpackUInt8, dateTime->month, mBuf);
+
+ return ROK;
} /* end of cmPkDateTime */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkDuration
+S16 cmPkDuration
(
Duration *duration, /* duration */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkDuration(duration, mBuf)
-Duration *duration; /* duration */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkDuration)
- CMCHKPK(SPkU8, duration->tenths, mBuf);
- CMCHKPK(SPkU8, duration->secs, mBuf);
- CMCHKPK(SPkU8, duration->mins, mBuf);
- CMCHKPK(SPkU8, duration->hours, mBuf);
- CMCHKPK(SPkU8, duration->days, mBuf);
+ CMCHKPK(oduUnpackUInt8, duration->tenths, mBuf);
+ CMCHKPK(oduUnpackUInt8, duration->secs, mBuf);
+ CMCHKPK(oduUnpackUInt8, duration->mins, mBuf);
+ CMCHKPK(oduUnpackUInt8, duration->hours, mBuf);
+ CMCHKPK(oduUnpackUInt8, duration->days, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkDuration */
/*
*
-* Fun: cmPkPtr
+* Fun: oduPackPointer
*
* Desc: This function packs the pointer
*
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkPtr
+S16 oduPackPointer
(
PTR ptr, /* pointer */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkPtr(ptr, mBuf)
-PTR ptr; /* pointer */
-Buffer *mBuf; /* message buffer */
-#endif
{
Data pkArray[PTRSIZE]; /* array for packing */
S16 ret; /* return code */
- U16 tmp; /* temporary value */
+ uint16_t tmp; /* temporary value */
#if (defined(ALPHA) || defined(BIT_64))
- U32 tmp32;
+ uint32_t tmp32;
#endif
- TRC2(cmPkPtr)
ret = ROK;
switch (PTRSIZE)
case 4:
#ifndef FCSPKINT /* backward compatibility, packing order */
- tmp = (U16) GetHiWord(ptr);
+ tmp = (uint16_t) GetHiWord(ptr);
pkArray[0] = (Data) GetHiByte(tmp);
pkArray[1] = (Data) GetLoByte(tmp);
- tmp = (U16) GetLoWord(ptr);
+ tmp = (uint16_t) GetLoWord(ptr);
pkArray[2] = (Data) GetHiByte(tmp);
pkArray[3] = (Data) GetLoByte(tmp);
#else /* forward compatibility, packing order */
- tmp = (U16) GetHiWord(ptr);
+ tmp = (uint16_t) GetHiWord(ptr);
pkArray[3] = (Data) GetHiByte(tmp);
pkArray[2] = (Data) GetLoByte(tmp);
- tmp = (U16) GetLoWord(ptr);
+ tmp = (uint16_t) GetLoWord(ptr);
pkArray[1] = (Data) GetHiByte(tmp);
pkArray[0] = (Data) GetLoByte(tmp);
#endif
case 8:
#if (defined(ALPHA) || defined(BIT_64))
#ifndef FCSPKINT /* backward compatibility, packing order */
- tmp32 = (U32) GetHi32Bit(ptr);
- tmp = (U16) GetHiWord(tmp32);
+ tmp32 = (uint32_t) GetHi32Bit(ptr);
+ tmp = (uint16_t) GetHiWord(tmp32);
pkArray[0] = (Data) GetHiByte(tmp);
pkArray[1] = (Data) GetLoByte(tmp);
- tmp = (U16) GetLoWord(tmp32);
+ tmp = (uint16_t) GetLoWord(tmp32);
pkArray[2] = (Data) GetHiByte(tmp);
pkArray[3] = (Data) GetLoByte(tmp);
- tmp32 = (U32) GetLo32Bit(ptr);
- tmp = (U16) GetHiWord(tmp32);
+ tmp32 = (uint32_t) GetLo32Bit(ptr);
+ tmp = (uint16_t) GetHiWord(tmp32);
pkArray[4] = (Data) GetHiByte(tmp);
pkArray[5] = (Data) GetLoByte(tmp);
- tmp = (U16) GetLoWord(tmp32);
+ tmp = (uint16_t) GetLoWord(tmp32);
pkArray[6] = (Data) GetHiByte(tmp);
pkArray[7] = (Data) GetLoByte(tmp);
#else /* forward compatibility, packing order */
- tmp32 = (U32) GetHi32Bit(ptr);
- tmp = (U16) GetHiWord(tmp32);
+ tmp32 = (uint32_t) GetHi32Bit(ptr);
+ tmp = (uint16_t) GetHiWord(tmp32);
pkArray[7] = (Data) GetHiByte(tmp);
pkArray[6] = (Data) GetLoByte(tmp);
- tmp = (U16) GetLoWord(tmp32);
+ tmp = (uint16_t) GetLoWord(tmp32);
pkArray[5] = (Data) GetHiByte(tmp);
pkArray[4] = (Data) GetLoByte(tmp);
- tmp32 = (U32) GetLo32Bit(ptr);
- tmp = (U16) GetHiWord(tmp32);
+ tmp32 = (uint32_t) GetLo32Bit(ptr);
+ tmp = (uint16_t) GetHiWord(tmp32);
pkArray[3] = (Data) GetHiByte(tmp);
pkArray[2] = (Data) GetLoByte(tmp);
- tmp = (U16) GetLoWord(tmp32);
+ tmp = (uint16_t) GetLoWord(tmp32);
pkArray[1] = (Data) GetHiByte(tmp);
pkArray[0] = (Data) GetLoByte(tmp);
#endif
break;
#endif
default:
- /* no support for U64 */
+ /* no support for uint64_t */
ret = RFAILED;
}
- RETVALUE(ret);
-} /* end of cmPkPtr */
+ return (ret);
+} /* end of oduPackPointer */
\f
/*
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkEntityId
+S16 cmPkEntityId
(
EntityId *entityId, /* entity id */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkEntityId(entityId, mBuf)
-EntityId *entityId; /* entity id */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkEntityId)
CMCHKPK(cmPkInst, entityId->inst, mBuf);
CMCHKPK(cmPkEnt, entityId->ent, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkEntityId */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkElmntId
+S16 cmPkElmntId
(
ElmntId *elmntId, /* element id */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkElmntId(elmntId, mBuf)
-ElmntId *elmntId; /* element id */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkElmntId)
CMCHKPK(cmPkElmntInst3, elmntId->elmntInst3, mBuf);
CMCHKPK(cmPkElmntInst2, elmntId->elmntInst2, mBuf);
CMCHKPK(cmPkElmntInst1, elmntId->elmntInst1, mBuf);
CMCHKPK(cmPkElmnt, elmntId->elmnt, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkElmntId */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkMemoryId
+S16 cmPkMemoryId
(
MemoryId *memoryId, /* memoryId */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkMemoryId(memoryId, mBuf)
-MemoryId *memoryId; /* memoryId */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkMemoryId)
CMCHKPK(cmPkPool, memoryId->pool, mBuf);
CMCHKPK(cmPkRegion, memoryId->region, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkMemoryId */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkSystemId
+S16 cmPkSystemId
(
SystemId *systemId, /* system id */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkSystemId(systemId, mBuf)
-SystemId *systemId; /* system id */
-Buffer *mBuf; /* message buffer */
-#endif
{
Txt *p; /* part number string */
- TRC2(cmPkSystemId)
for (p = systemId->ptNmb; *p; p++);
CMCHKPK(SPkS16, systemId->mRev, mBuf);
CMCHKPK(SPkS16, systemId->mVer, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkSystemId */
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkProtAddr
+S16 cmPkProtAddr
(
ProtAddr *pAddr, /* protocol address */
Buffer *mBuf /* buffer */
)
-#else
-PUBLIC S16 cmPkProtAddr(pAddr, mBuf)
-ProtAddr *pAddr; /* protocol address */
-Buffer *mBuf; /* buffer */
-#endif
{
- U8 j; /* Index */
+ uint8_t j; /* Index */
- TRC3(cmPkProtAddr)
#ifdef CM_ARI2
- CMCHKPK(SPkU32, pAddr->autoSysId, mBuf);
- CMCHKPK(cmPkBool, pAddr->autoSysIdPres, mBuf);
+ CMCHKPK(oduUnpackUInt32, pAddr->autoSysId, mBuf);
+ CMCHKPK(oduPackBool, pAddr->autoSysIdPres, mBuf);
#endif /* CM_ARI2 */
for (j = pAddr->len; j; j--)
- CMCHKPK(SPkU8, pAddr->address[j - 1], mBuf);
+ CMCHKPK(oduUnpackUInt8, pAddr->address[j - 1], mBuf);
- CMCHKPK(SPkU8, pAddr->preLen, mBuf);
- CMCHKPK(SPkU8, pAddr->len, mBuf);
- CMCHKPK(SPkU16, pAddr->protType, mBuf);
+ CMCHKPK(oduUnpackUInt8, pAddr->preLen, mBuf);
+ CMCHKPK(oduUnpackUInt8, pAddr->len, mBuf);
+ CMCHKPK(oduUnpackUInt16, pAddr->protType, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkProtAddr */
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkProtAddrTbl
+S16 cmPkProtAddrTbl
(
ProtAddrTbl *protAddr, /* protocol address table */
Buffer *mBuf /* buffer */
)
-#else
-PUBLIC S16 cmPkProtAddrTbl(protAddr, mBuf)
-ProtAddrTbl *protAddr; /* protocol address table */
-Buffer *mBuf; /* buffer */
-#endif
{
- U8 i; /* index */
- U8 j; /* Index */
+ uint8_t i; /* index */
+ uint8_t j; /* Index */
ProtAddr *pAddr; /* protocol Address */
- TRC3(cmPkProtAddrTbl)
if (protAddr->count > MAX_PROT_ADDRS)
- RETVALUE(RFAILED);
+ return RFAILED;
for (i = protAddr->count; i; i--)
{
pAddr = &(protAddr->addr[i - 1]);
#ifdef CM_ARI2
- CMCHKPK(SPkU32, pAddr->autoSysId, mBuf);
- CMCHKPK(cmPkBool, pAddr->autoSysIdPres, mBuf);
+ CMCHKPK(oduUnpackUInt32, pAddr->autoSysId, mBuf);
+ CMCHKPK(oduPackBool, pAddr->autoSysIdPres, mBuf);
#endif /* CM_ARI2 */
for (j = pAddr->len; j; j--)
- CMCHKPK(SPkU8, pAddr->address[j - 1], mBuf);
+ CMCHKPK(oduUnpackUInt8, pAddr->address[j - 1], mBuf);
- CMCHKPK(SPkU8, pAddr->preLen, mBuf);
- CMCHKPK(SPkU8, pAddr->len, mBuf);
- CMCHKPK(SPkU16, pAddr->protType, mBuf);
+ CMCHKPK(oduUnpackUInt8, pAddr->preLen, mBuf);
+ CMCHKPK(oduUnpackUInt8, pAddr->len, mBuf);
+ CMCHKPK(oduUnpackUInt16, pAddr->protType, mBuf);
}
- CMCHKPK(SPkU8, protAddr->count, mBuf);
+ CMCHKPK(oduUnpackUInt8, protAddr->count, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkProtAddrTbl */
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkAddrs
+S16 cmPkAddrs
(
Addrs *addrs, /* address */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkAddrs(addrs, mBuf)
-Addrs *addrs; /* address */
-Buffer *mBuf; /* message buffer */
-#endif
{
- U8 i; /* loop counter */
+ uint8_t i; /* loop counter */
- TRC2(cmPkAddrs)
if (addrs->length > ADRLEN)
- RETVALUE(RFAILED);
+ return RFAILED;
for (i = addrs->length; i; i--)
{
- CMCHKPK(SPkU8, addrs->strg[i-1], mBuf);
+ CMCHKPK(oduUnpackUInt8, addrs->strg[i-1], mBuf);
}
- CMCHKPK(SPkU8, addrs->length, mBuf);
+ CMCHKPK(oduUnpackUInt8, addrs->length, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkAddrs */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkShrtAddrs
+S16 cmPkShrtAddrs
(
ShrtAddrs *addrs, /* address */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkShrtAddrs(addrs, mBuf)
-ShrtAddrs *addrs; /* address */
-Buffer *mBuf; /* message buffer */
-#endif
{
- U8 i; /* loop counter */
+ uint8_t i; /* loop counter */
- TRC2(cmPkShrtAddrs)
if (addrs->length > SHRTADRLEN)
- RETVALUE(RFAILED);
+ return RFAILED;
for (i = addrs->length; i; i--)
{
- CMCHKPK(SPkU8, addrs->strg[i-1], mBuf);
+ CMCHKPK(oduUnpackUInt8, addrs->strg[i-1], mBuf);
}
- CMCHKPK(SPkU8, addrs->length, mBuf);
+ CMCHKPK(oduUnpackUInt8, addrs->length, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkShrtAddrs */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkAddrMask
+S16 cmPkAddrMask
(
-U8 *mask, /* pointer to address mask array */
+uint8_t *mask, /* pointer to address mask array */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkAddrMask(mask, mBuf)
-U8 *mask; /* pointer to address mask array */
-Buffer *mBuf; /* message buffer */
-#endif
{
S16 i; /* counter */
- TRC2(cmPkAddrMask)
/* pack address mask */
for (i = (ADRLEN - 1); i >= 0; i--)
{
- CMCHKPK(SPkU8, mask[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, mask[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkAddrMask */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkBndCfg
+S16 cmPkBndCfg
(
BndCfg *bndCfg, /* bndCfg */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkBndCfg(bndCfg, mBuf)
-BndCfg *bndCfg; /* bndCfg */
-Buffer *mBuf; /* message buffer */
-#endif
{
Txt *p; /* temporary */
- TRC2(cmPkBndCfg)
CMCHKPK(cmPkSelector, bndCfg->selector, mBuf);
CMCHKPK(cmPkAddrs, &bndCfg->sapAdr, mBuf);
CMCHKPK(cmPkRegion, bndCfg->region, mBuf);
CMCHKPK(cmPkInst, bndCfg->inst, mBuf);
CMCHKPK(cmPkEnt, bndCfg->ent, mBuf);
- CMCHKPK(SPkU8, bndCfg->wdw, mBuf);
- CMCHKPK(SPkU8, bndCfg->flcTyp, mBuf);
- CMCHKPK(SPkU8, bndCfg->bufOwnshp, mBuf);
+ CMCHKPK(oduUnpackUInt8, bndCfg->wdw, mBuf);
+ CMCHKPK(oduUnpackUInt8, bndCfg->flcTyp, mBuf);
+ CMCHKPK(oduUnpackUInt8, bndCfg->bufOwnshp, mBuf);
for (p = bndCfg->usrId; *p; p++);
for (; p != bndCfg->usrId; p--);
CMCHKPK(cmPkTxt, *p, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkBndCfg */
\f
* File: cm_gen.c
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkPst
+S16 cmPkPst
(
Pst *pst,
Buffer *mBuf
)
-#else
-PUBLIC S16 cmPkPst(pst, mBuf)
-Pst *pst;
-Buffer *mBuf;
-#endif
{
- TRC2(cmPkPst)
CMCHKPK(cmPkEvent, pst->event, mBuf);
CMCHKPK(cmPkInst, pst->srcInst, mBuf);
CMCHKPK(cmPkIntfVer, pst->intfVer, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkPst */
/*
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkElmtHdr
+S16 cmPkElmtHdr
(
ElmtHdr *m, /* element header */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkElmtHdr(m, mBuf)
-ElmtHdr *m; /* element header */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkElmtHdr)
#if (LCAMT || ATM_BISUP)
- CMCHKPK(SPkU16, m->compInd, mBuf);
+ CMCHKPK(oduUnpackUInt16, m->compInd, mBuf);
#endif /* LCAMT || ATM_BISUP */
#if (LCAMT || ATM_BISUP)
/* Pack action indicator field */
if (m->pres)
{
- CMCHKPK(SPkU8, m->actnInd, mBuf);
+ CMCHKPK(oduUnpackUInt8, m->actnInd, mBuf);
}
#endif
/* Present */
- CMCHKPK(cmPkBool, m->pres, mBuf);
+ CMCHKPK(oduPackBool, m->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkElmtHdr */
\f
/*
*
- * Fun: cmPkTknU8
+ * Fun: cmPkTknUInt8
*
- * Desc: This function packs a token U8
+ * Desc: This function packs a token uint8_t
*
* Ret: ROK - ok
*
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkTknU8
+S16 cmPkTknUInt8
(
-TknU8 *tknU8, /* token U8 */
+TknUInt8 *tknUInt8, /* token uint8_t */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkTknU8(tknU8, mBuf)
-TknU8 *tknU8; /* token U8 */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkTknU8)
- if (tknU8->pres)
+ if (tknUInt8->pres)
{
/* Value */
- CMCHKPK(SPkU8, tknU8->val, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknUInt8->val, mBuf);
}
/* Token Header */
- CMCHKPK(SPkU8, tknU8->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknUInt8->pres, mBuf);
- RETVALUE(ROK);
-} /* end of cmPkTknU8 */
+ return ROK;
+} /* end of cmPkTknUInt8 */
\f
/*
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkTknS8
+S16 cmPkTknS8
(
TknS8 *tknS8, /* token S8 */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkTknS8(tknS8, mBuf)
-TknS8 *tknS8; /* token S8 */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkTknS8)
if (tknS8->pres)
{
}
/* Token Header */
- CMCHKPK(SPkU8, tknS8->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknS8->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknS8 */
\f
/*
*
- * Fun: cmPkTknU16
+ * Fun: cmPkTknUInt16
*
- * Desc: This function packs a token U16
+ * Desc: This function packs a token uint16_t
*
* Ret: ROK - ok
*
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkTknU16
+S16 cmPkTknUInt16
(
-TknU16 *tknU16, /* token U16 */
+TknUInt16 *tknUInt16, /* token uint16_t */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkTknU16(tknU16, mBuf)
-TknU16 *tknU16; /* token U16 */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkTknU16)
- if (tknU16->pres)
+ if (tknUInt16->pres)
{
/* Value */
- CMCHKPK(SPkU16, tknU16->val, mBuf);
+ CMCHKPK(oduUnpackUInt16, tknUInt16->val, mBuf);
}
/* Token Header */
- CMCHKPK(SPkU8, tknU16->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknUInt16->pres, mBuf);
- RETVALUE(ROK);
-} /* end of cmPkTknU16 */
+ return ROK;
+} /* end of cmPkTknUInt16 */
\f
/*
*
- * Fun: cmPkTknU32
+ * Fun: cmPkTknUInt32
*
- * Desc: This function packs a token U32
+ * Desc: This function packs a token uint32_t
*
* Ret: ROK - ok
*
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkTknU32
+S16 cmPkTknUInt32
(
-TknU32 *tknU32, /* token U32 */
+TknUInt32 *tknUInt32, /* token uint32_t */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkTknU32(tknU32, mBuf)
-TknU32 *tknU32; /* token U32 */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkTknU32)
- if (tknU32->pres)
+ if (tknUInt32->pres)
{
/* Value */
- CMCHKPK(SPkU32, tknU32->val, mBuf);
+ CMCHKPK(oduUnpackUInt32, tknUInt32->val, mBuf);
}
/* Token Header */
- CMCHKPK(SPkU8, tknU32->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknUInt32->pres, mBuf);
- RETVALUE(ROK);
-} /* end of cmPkTknU32 */
+ return ROK;
+} /* end of cmPkTknUInt32 */
\f
/*
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkTknStr
+S16 cmPkTknStr
(
TknStr *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkTknStr(tknStr, mBuf)
-TknStr *tknStr; /* token string */
-Buffer *mBuf; /* message buffer */
-#endif
{
Cntr i; /* counter */
- TRC2(cmPkTknStr)
if (tknStr->pres)
{
/* Value */
for (i = 0; i < (S16) tknStr->len; i++)
{
- CMCHKPK(SPkU8, tknStr->val[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->val[i], mBuf);
}
/* Length */
- CMCHKPK(SPkU8, tknStr->len, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->len, mBuf);
}
/* Token Header */
- CMCHKPK(SPkU8, tknStr->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStr */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkTknStrM
+S16 cmPkTknStrM
(
TknStrM *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkTknStrM(tknStr, mBuf)
-TknStrM *tknStr; /* token string */
-Buffer *mBuf; /* message buffer */
-#endif
{
Cntr i; /* counter */
- TRC2(cmPkTknStrM)
if(tknStr->pres)
{
/* Value */
for (i = 0; i < (S16) tknStr->len; i++)
{
- CMCHKPK(SPkU8, tknStr->val[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->val[i], mBuf);
}
/* Length */
- CMCHKPK(SPkU8, tknStr->len, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->len, mBuf);
}
/* Token Header */
- CMCHKPK(SPkU8, tknStr->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStrM */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkTknStrS
+S16 cmPkTknStrS
(
TknStrS *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkTknStrS(tknStr, mBuf)
-TknStrS *tknStr; /* token string */
-Buffer *mBuf; /* message buffer */
-#endif
{
Cntr i; /* counter */
- TRC2(cmPkTknStrS)
if(tknStr->pres)
{
/* Value */
for (i = 0; i < (S16) tknStr->len; i++)
{
- CMCHKPK(SPkU8, tknStr->val[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->val[i], mBuf);
}
/* Length */
- CMCHKPK(SPkU8, tknStr->len, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->len, mBuf);
}
/* Token Header */
- CMCHKPK(SPkU8, tknStr->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStrS */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkTknStrE
+S16 cmPkTknStrE
(
TknStrE *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkTknStrE(tknStr, mBuf)
-TknStrE *tknStr; /* token string */
-Buffer *mBuf; /* message buffer */
-#endif
{
Cntr i; /* counter */
- TRC2(cmPkTknStrE)
if(tknStr->pres)
{
/* Value */
for (i = 0; i < (S16) tknStr->len; i++)
{
- CMCHKPK(SPkU8, tknStr->val[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->val[i], mBuf);
}
/* Length */
- CMCHKPK(SPkU8, tknStr->len, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->len, mBuf);
}
/* Token Header */
- CMCHKPK(SPkU8, tknStr->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStrE */
#ifndef CMFILE_REORG_1
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkPnNodeId
+S16 cmPkPnNodeId
(
PnNodeId *src, /* source PNNI Node Id */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkPnNodeId (src, mBuf)
-PnNodeId *src; /* source PNNI Node Id */
-Buffer *mBuf; /* message buffer */
-#endif
{
S16 i;
- TRC3(cmPkPnNodeId);
for (i = PN_NODEID_LEN - 1; i >= 0; i--)
{
- CMCHKPK(SPkU8, src->id[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, src->id[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* cmPkPnNodeId */
#endif /* CMFILE_REORG_1 */
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkTknStr4
+S16 cmPkTknStr4
(
TknStr4 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkTknStr4(tknStr, mBuf)
-TknStr4 *tknStr; /* token string */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkTknStr4)
CMPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStr4 */
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkTknStr12
+S16 cmPkTknStr12
(
TknStr12 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkTknStr12(tknStr, mBuf)
-TknStr12 *tknStr; /* token string */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkTknStr12)
CMPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStr12 */
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkTknStr32
+S16 cmPkTknStr32
(
TknStr32 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkTknStr32(tknStr, mBuf)
-TknStr32 *tknStr; /* token string */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkTknStr32)
CMPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStr32 */
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkTknStr64
+S16 cmPkTknStr64
(
TknStr64 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkTknStr64(tknStr, mBuf)
-TknStr64 *tknStr; /* token string */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkTknStr64)
CMPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStr64 */
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkTknStr132
+S16 cmPkTknStr132
(
TknStr132 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkTknStr132(tknStr, mBuf)
-TknStr132 *tknStr; /* token string */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkTknStr132)
CMPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStr132 */
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkTknStr256
+S16 cmPkTknStr256
(
TknStr256 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkTknStr256(tknStr, mBuf)
-TknStr256 *tknStr; /* token string */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkTknStr256)
CMPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStr256 */
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkTknOid
+S16 cmPkTknOid
(
TknOid *tknOid, /* Object Identifier token */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkTknOid(tknOid, mBuf)
-TknOid *tknOid; /* Object Identifier token */
-Buffer *mBuf; /* message buffer */
-#endif
{
- U16 i;
+ uint16_t i;
- TRC2(cmPkTknOid)
if (tknOid->pres == TRUE)
{
/* Pack the value */
- for (i = 0; i < (U16)tknOid->len; i++)
+ for (i = 0; i < (uint16_t)tknOid->len; i++)
{
- /* cm_gen_c_001.main_33: changes for TknOid value from U16 to U32
- * with compilation flag TKNOID_U16 */
-#ifndef TKNOID_U16
- CMCHKPK(SPkU32, tknOid->val[i], mBuf);
+ /* cm_gen_c_001.main_33: changes for TknOid value from uint16_t to uint32_t
+ * with compilation flag TKNOID_UINT16 */
+#ifndef TKNOID_UINT16
+ CMCHKPK(oduUnpackUInt32, tknOid->val[i], mBuf);
#else
- CMCHKPK(SPkU16, tknOid->val[i], mBuf);
-#endif /* !TKNOID_U16 */
+ CMCHKPK(oduUnpackUInt16, tknOid->val[i], mBuf);
+#endif /* !TKNOID_UINT16 */
}
/* Pack the length */
- CMCHKPK(SPkU8, tknOid->len, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknOid->len, mBuf);
}
/* Pack the token header */
- CMCHKPK(SPkU8, tknOid->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknOid->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknOid */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkTknS32
+S16 cmPkTknS32
(
TknS32 *tknS32, /* token S32 */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkTknS32(tknS32, mBuf)
-TknS32 *tknS32; /* token S32 */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkTknS32)
if (tknS32->pres)
{
}
/* Token Header */
- CMCHKPK(SPkU8, tknS32->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknS32->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknS32 */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkHeader
+S16 cmPkHeader
(
Header *header, /* header */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkHeader(header, mBuf)
-Header *header; /* header */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkHeader)
#ifdef LMINT3
CMCHKPK(cmPkMemoryId, &header->response.mem, mBuf);
#endif /* LMINT3 */
CMCHKPK(cmPkElmntId, &header->elmId, mBuf);
CMCHKPK(cmPkEntityId, &header->entId, mBuf);
- CMCHKPK(SPkU16, header->seqNmb, mBuf);
- CMCHKPK(SPkU8, header->version, mBuf);
- CMCHKPK(SPkU8, header->msgType, mBuf);
- CMCHKPK(SPkU16, header->msgLen, mBuf);
+ CMCHKPK(oduUnpackUInt16, header->seqNmb, mBuf);
+ CMCHKPK(oduUnpackUInt8, header->version, mBuf);
+ CMCHKPK(oduUnpackUInt8, header->msgType, mBuf);
+ CMCHKPK(oduUnpackUInt16, header->msgLen, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkHeader */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkCmStatus
+S16 cmPkCmStatus
(
CmStatus *sta, /* status structure */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkCmStatus(sta, mBuf)
-CmStatus *sta; /* status structure */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkCmStatus)
- CMCHKPK(SPkU16, sta->reason, mBuf);
- CMCHKPK(SPkU16, sta->status, mBuf);
+ CMCHKPK(oduUnpackUInt16, sta->reason, mBuf);
+ CMCHKPK(oduUnpackUInt16, sta->status, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkCmStatus */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkCmAlarm
+S16 cmPkCmAlarm
(
CmAlarm *alarm, /* alarm structure */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkCmAlarm(alarm, mBuf)
-CmAlarm *alarm; /* alarm structure */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkCmAlarm)
- CMCHKPK(SPkU16, alarm->cause, mBuf);
- CMCHKPK(SPkU16, alarm->event, mBuf);
- CMCHKPK(SPkU16, alarm->category, mBuf);
+ CMCHKPK(oduUnpackUInt16, alarm->cause, mBuf);
+ CMCHKPK(oduUnpackUInt16, alarm->event, mBuf);
+ CMCHKPK(oduUnpackUInt16, alarm->category, mBuf);
CMCHKPK(cmPkDateTime, &alarm->dt, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkCmAlarm */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkSmCfg
+S16 cmPkSmCfg
(
SmCfg *smCfg, /* stack manager */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkSmCfg(smCfg, mBuf)
-SmCfg *smCfg; /* stack manager */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkSmCfg)
CMCHKPK(cmPkSelector, smCfg->selector, mBuf);
CMCHKPK(cmPkRoute, smCfg->route, mBuf);
CMCHKPK(cmPkInst, smCfg->inst, mBuf);
CMCHKPK(cmPkEnt, smCfg->ent, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkSmCfg */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkTmrCfg
+S16 cmPkTmrCfg
(
TmrCfg *tmrCfg, /* timer configuration */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkTmrCfg(tmrCfg, mBuf)
-TmrCfg *tmrCfg; /* timer configuration */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkTmrCfg)
- CMCHKPK(SPkU16, tmrCfg->val, mBuf);
- CMCHKPK(cmPkBool, tmrCfg->enb, mBuf);
+ CMCHKPK(oduUnpackUInt16, tmrCfg->val, mBuf);
+ CMCHKPK(oduPackBool, tmrCfg->enb, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTmrCfg */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkTknBuf
+S16 cmPkTknBuf
(
TknBuf *tknBuf, /* token string */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkTknBuf(tknBuf, mBuf)
-TknBuf *tknBuf; /* token string */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkTknBuf)
if(tknBuf->pres)
{
SFndLenMsg(tknBuf->val, &msgLen);
if( SCatMsg(mBuf, tknBuf->val, M2M1) != ROK )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmPkMsgLen(msgLen, mBuf);
SPutMsg(tknBuf->val);
}
/* Token Header */
- CMCHKPK(SPkU8, tknBuf->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknBuf->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknBuf */
#ifdef TDS_ROLL_UPGRADE_SUPPORT
*
*/
-#ifdef ANSI
-PUBLIC S16 cmPkIntf
+S16 cmPkIntf
(
CmIntf *intf, /* interface info */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmPkIntf(intf, mBuf)
-CmIntf *intf; /* interface info */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmPkIntf)
CMCHKPK(cmPkIntfId, intf->intfId, mBuf);
CMCHKPK(cmPkIntfVer, intf->intfVer, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkIntf */
#endif /* TDS_ROLL_UPGRADE_SUPPORT */
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkDateTime
+S16 cmUnpkDateTime
(
DateTime *dateTime, /* date/time structure */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkDateTime(dateTime, mBuf)
-DateTime *dateTime; /* date/time structure */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpDateTime)
- CMCHKUNPK(SUnpkU8, &dateTime->month, mBuf);
- CMCHKUNPK(SUnpkU8, &dateTime->day, mBuf);
- CMCHKUNPK(SUnpkU8, &dateTime->year, mBuf);
- CMCHKUNPK(SUnpkU8, &dateTime->hour, mBuf);
- CMCHKUNPK(SUnpkU8, &dateTime->min, mBuf);
- CMCHKUNPK(SUnpkU8, &dateTime->sec, mBuf);
- CMCHKUNPK(SUnpkU8, &dateTime->tenths, mBuf);
+ CMCHKUNPK(oduPackUInt8, &dateTime->month, mBuf);
+ CMCHKUNPK(oduPackUInt8, &dateTime->day, mBuf);
+ CMCHKUNPK(oduPackUInt8, &dateTime->year, mBuf);
+ CMCHKUNPK(oduPackUInt8, &dateTime->hour, mBuf);
+ CMCHKUNPK(oduPackUInt8, &dateTime->min, mBuf);
+ CMCHKUNPK(oduPackUInt8, &dateTime->sec, mBuf);
+ CMCHKUNPK(oduPackUInt8, &dateTime->tenths, mBuf);
/*-- added for micro seconds --*/
#ifdef SS_DATETIME_USEC
- CMCHKUNPK(SUnpkU32, &dateTime->usec, mBuf);
+ CMCHKUNPK(oduPackUInt32, &dateTime->usec, mBuf);
#endif /*-- SS_DATETIME_USEC --*/
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkDateTime */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkDuration
+S16 cmUnpkDuration
(
Duration *duration, /* duration structure */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkDuration(duration, mBuf)
-Duration *duration; /* duration structure */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpDuration)
- CMCHKUNPK(SUnpkU8, &duration->days, mBuf);
- CMCHKUNPK(SUnpkU8, &duration->hours, mBuf);
- CMCHKUNPK(SUnpkU8, &duration->mins, mBuf);
- CMCHKUNPK(SUnpkU8, &duration->secs, mBuf);
- CMCHKUNPK(SUnpkU8, &duration->tenths, mBuf);
+ CMCHKUNPK(oduPackUInt8, &duration->days, mBuf);
+ CMCHKUNPK(oduPackUInt8, &duration->hours, mBuf);
+ CMCHKUNPK(oduPackUInt8, &duration->mins, mBuf);
+ CMCHKUNPK(oduPackUInt8, &duration->secs, mBuf);
+ CMCHKUNPK(oduPackUInt8, &duration->tenths, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkDuration */
/*
*
-* Fun: cmUnpkPtr
+* Fun: oduUnpackPointer
*
* Desc: This function is used to Unpack Ptr type
*
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkPtr
+S16 oduUnpackPointer
(
PTR *ptr, /* duration structure */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkPtr(ptr, mBuf)
-PTR *ptr; /* duration structure */
-Buffer *mBuf; /* message buffer */
-#endif
{
- U16 tmp16; /* temporary value */
- U32 tmp32; /* temporary value */
- Data unpkArray[PTRSIZE]; /* unpacking array */
- S16 ret; /* return code */
+ uint16_t tmp16 =0; /* temporary value */
+ uint32_t tmp32 =0; /* temporary value */
+ Data unpkArray[PTRSIZE]; /* unpacking array */
+ S16 ret =ROK; /* return code */
#if (defined(ALPHA) || defined(BIT_64))
- U64 tmp64;
+ uint64_t tmp64 =0;
#endif
- TRC2(cmUnpkPtr)
switch (PTRSIZE)
{
case 2:
ret = SRemPreMsgMult(unpkArray, (MsgLen) 2, mBuf);
if (ret != ROK)
- RETVALUE(ret);
+ return (ret);
tmp16 = 0;
#ifndef FCSPKINT /* backward compatibility, packing order */
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[1]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[0]);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[1]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[0]);
#else /* forward compatibility, packing order */
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[0]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[1]);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[0]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[1]);
#endif
*ptr = tmp16;
break;
case 4:
ret = SRemPreMsgMult(unpkArray, (MsgLen) 4, mBuf);
if (ret != ROK)
- RETVALUE(ret);
+ return (ret);
tmp16 = 0;
tmp32 = 0;
#ifndef FCSPKINT /* backward compatibility, packing order */
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[3]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[2]);
- tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[1]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[0]);
- tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[3]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[2]);
+ tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[1]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[0]);
+ tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
#else /* forward compatibility, packing order */
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[0]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[1]);
- tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[2]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[3]);
- tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[0]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[1]);
+ tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[2]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[3]);
+ tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
#endif
*ptr = tmp32;
break;
#if(defined(ALPHA) || defined(BIT_64))
ret = SRemPreMsgMult(unpkArray, (MsgLen) 8, mBuf);
if (ret != ROK)
- RETVALUE(ret);
+ return (ret);
tmp16 = 0;
tmp32 = 0;
tmp64 = 0;
#ifndef FCSPKINT /* backward compatibility, packing order */
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[7]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[6]);
- tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[5]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[4]);
- tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
- tmp64 = (U64) PutHi32Bit(tmp64, tmp32);
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[3]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[2]);
- tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[1]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[0]);
- tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
- tmp64 = (U64) PutLo32Bit(tmp64, tmp32);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[7]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[6]);
+ tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[5]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[4]);
+ tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
+ tmp64 = (uint64_t) PutHi32Bit(tmp64, tmp32);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[3]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[2]);
+ tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[1]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[0]);
+ tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
+ tmp64 = (uint64_t) PutLo32Bit(tmp64, tmp32);
#else /* forward compatibility, packing order */
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[0]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[1]);
- tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[2]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[3]);
- tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
- tmp64 = (U64) PutHi32Bit(tmp64, tmp32);
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[4]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[5]);
- tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[6]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[7]);
- tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
- tmp64 = (U64) PutLo32Bit(tmp64, tmp32);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[0]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[1]);
+ tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[2]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[3]);
+ tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
+ tmp64 = (uint64_t) PutHi32Bit(tmp64, tmp32);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[4]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[5]);
+ tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[6]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[7]);
+ tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
+ tmp64 = (uint64_t) PutLo32Bit(tmp64, tmp32);
#endif
*ptr = tmp64;
break;
#endif
default:
- /* no support for U64 */
+ /* no support for uint64_t */
ret = RFAILED;
}
- RETVALUE(ret);
-} /* end of cmUnpkPtr */
+ return (ret);
+} /* end of oduUnpackPointer */
\f
/*
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkEntityId
+S16 cmUnpkEntityId
(
EntityId *entityId, /* entity id */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkEntityId(entityId, mBuf)
-EntityId *entityId; /* entity id */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpkEntityId)
CMCHKUNPK(cmUnpkEnt, &entityId->ent, mBuf);
CMCHKUNPK(cmUnpkInst, &entityId->inst, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkEntityId */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkElmntId
+S16 cmUnpkElmntId
(
ElmntId *elmntId, /* element id */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkElmntId(elmntId, mBuf)
-ElmntId *elmntId; /* element id */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpkElmntId)
CMCHKUNPK(cmUnpkElmnt, &elmntId->elmnt, mBuf);
CMCHKUNPK(cmUnpkElmntInst1, &elmntId->elmntInst1, mBuf);
CMCHKUNPK(cmUnpkElmntInst2, &elmntId->elmntInst2, mBuf);
CMCHKUNPK(cmUnpkElmntInst3, &elmntId->elmntInst3, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkElmntId */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkMemoryId
+S16 cmUnpkMemoryId
(
MemoryId *memoryId, /* memoryId */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkMemoryId(memoryId, mBuf)
-MemoryId *memoryId; /* memoryId */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpkMemoryId)
CMCHKUNPK(cmUnpkRegion, &memoryId->region, mBuf);
CMCHKUNPK(cmUnpkPool, &memoryId->pool, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkMemoryId */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkSystemId
+S16 cmUnpkSystemId
(
SystemId *systemId, /* system id */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkSystemId(systemId, mBuf)
-SystemId *systemId; /* system id */
-Buffer *mBuf; /* message buffer */
-#endif
{
S16 i; /* loop counter */
MsgLen len;
- TRC2(cmUnpkSystemId)
CMCHKUNPK(SUnpkS16, &systemId->mVer, mBuf);
CMCHKUNPK(SUnpkS16, &systemId->mRev, mBuf);
CMCHKUNPK(cmUnpkTxt, &systemId->ptNmb[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkSystemId */
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkProtAddr
+S16 cmUnpkProtAddr
(
ProtAddr *pAddr, /* protocol address */
Buffer *mBuf /* buffer */
)
-#else
-PUBLIC S16 cmUnpkProtAddr(pAddr, mBuf)
-ProtAddr *pAddr; /* protocol address table */
-Buffer *mBuf; /* buffer */
-#endif
{
- U8 j; /* Index */
+ uint8_t j; /* Index */
- TRC3(cmUnpkProtAddr)
- CMCHKUNPK(SUnpkU16, &(pAddr->protType), mBuf);
- CMCHKUNPK(SUnpkU8, &(pAddr->len), mBuf);
- CMCHKUNPK(SUnpkU8, &(pAddr->preLen), mBuf);
+ CMCHKUNPK(oduPackUInt16, &(pAddr->protType), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(pAddr->len), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(pAddr->preLen), mBuf);
for (j =0; j < pAddr->len; j++)
- CMCHKUNPK(SUnpkU8, &pAddr->address[j], mBuf);
+ CMCHKUNPK(oduPackUInt8, &pAddr->address[j], mBuf);
#ifdef CM_ARI2
- CMCHKUNPK(cmUnpkBool, &(pAddr->autoSysIdPres), mBuf);
- CMCHKUNPK(SUnpkU32, &(pAddr->autoSysId), mBuf);
+ CMCHKUNPK(oduUnpackBool, &(pAddr->autoSysIdPres), mBuf);
+ CMCHKUNPK(oduPackUInt32, &(pAddr->autoSysId), mBuf);
#endif /* CM_ARI2 */
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkProtAddr */
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkProtAddrTbl
+S16 cmUnpkProtAddrTbl
(
ProtAddrTbl *protAddr, /* protocol address table */
Buffer *mBuf /* buffer */
)
-#else
-PUBLIC S16 cmUnpkProtAddrTbl(protAddr, mBuf)
-ProtAddrTbl *protAddr; /* protocol address table */
-Buffer *mBuf; /* buffer */
-#endif
{
- U8 i; /* index */
- U8 j; /* Index */
+ uint8_t i; /* index */
+ uint8_t j; /* Index */
ProtAddr *pAddr; /* Protocol Address */
- TRC3(cmUnpkProtAddrTbl)
- CMCHKUNPK(SUnpkU8, &protAddr->count, mBuf);
+ CMCHKUNPK(oduPackUInt8, &protAddr->count, mBuf);
for (i = 0; i < protAddr->count; i++)
{
pAddr = &(protAddr->addr[i]);
- CMCHKUNPK(SUnpkU16, &(pAddr->protType), mBuf);
- CMCHKUNPK(SUnpkU8, &(pAddr->len), mBuf);
- CMCHKUNPK(SUnpkU8, &(pAddr->preLen), mBuf);
+ CMCHKUNPK(oduPackUInt16, &(pAddr->protType), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(pAddr->len), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(pAddr->preLen), mBuf);
for (j =0; j < pAddr->len; j++)
- CMCHKUNPK(SUnpkU8, &pAddr->address[j], mBuf);
+ CMCHKUNPK(oduPackUInt8, &pAddr->address[j], mBuf);
#ifdef CM_ARI2
- CMCHKUNPK(cmUnpkBool, &(pAddr->autoSysIdPres), mBuf);
- CMCHKUNPK(SUnpkU32, &(pAddr->autoSysId), mBuf);
+ CMCHKUNPK(oduUnpackBool, &(pAddr->autoSysIdPres), mBuf);
+ CMCHKUNPK(oduPackUInt32, &(pAddr->autoSysId), mBuf);
#endif /* CM_ARI2 */
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkProtAddrTbl */
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkAddrs
+S16 cmUnpkAddrs
(
Addrs *addrs, /* address */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkAddrs(addrs, mBuf)
-Addrs *addrs; /* address */
-Buffer *mBuf; /* message buffer */
-#endif
{
- U8 i; /* loop counter */
+ uint8_t i; /* loop counter */
- TRC2(cmUnpAddrs)
- CMCHKUNPK(SUnpkU8, &addrs->length, mBuf);
+ CMCHKUNPK(oduPackUInt8, &addrs->length, mBuf);
if (addrs->length > ADRLEN)
- RETVALUE(RFAILED);
+ return RFAILED;
for(i = 0; i < addrs->length; i++)
{
- CMCHKUNPK(SUnpkU8, &addrs->strg[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, &addrs->strg[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkAddrs */
/*
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkShrtAddrs
+S16 cmUnpkShrtAddrs
(
ShrtAddrs *addrs, /* address */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkShrtAddrs(addrs, mBuf)
-ShrtAddrs *addrs; /* address */
-Buffer *mBuf; /* message buffer */
-#endif
{
- U8 i; /* loop counter */
+ uint8_t i; /* loop counter */
- TRC2(cmUnpShrtAddrs)
- CMCHKUNPK(SUnpkU8, &addrs->length, mBuf);
+ CMCHKUNPK(oduPackUInt8, &addrs->length, mBuf);
if (addrs->length > SHRTADRLEN)
- RETVALUE(RFAILED);
+ return RFAILED;
for(i = 0; i < addrs->length; i++)
{
- CMCHKUNPK(SUnpkU8, &addrs->strg[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, &addrs->strg[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkShrtAddrs */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkAddrMask
+S16 cmUnpkAddrMask
(
-U8 *mask, /* pointer to address mask */
+uint8_t *mask, /* pointer to address mask */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkAddrMask(mask, mBuf)
-U8 *mask; /* pointer to address mask */
-Buffer *mBuf; /* message buffer */
-#endif
{
S16 i; /* counter */
- TRC2(cmUnpAddrMask)
/* unpack address mask */
for (i = 0; i< ADRLEN; i++)
{
- CMCHKUNPK(SUnpkU8, &mask[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, &mask[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkAddrMask */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkBndCfg
+S16 cmUnpkBndCfg
(
BndCfg *bndCfg, /* bndCfg */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkBndCfg(bndCfg, mBuf)
-BndCfg *bndCfg; /* bndCfg */
-Buffer *mBuf; /* message buffer */
-#endif
{
S16 i; /* loop counter */
- TRC2(cmUnpBndCfg)
for (i = 0; bndCfg->usrId[i]; i++);
CMCHKUNPK(cmUnpkTxt, bndCfg->usrId+i, mBuf);
- CMCHKUNPK(SUnpkU8, &bndCfg->bufOwnshp, mBuf);
- CMCHKUNPK(SUnpkU8, &bndCfg->flcTyp, mBuf);
- CMCHKUNPK(SUnpkU8, &bndCfg->wdw, mBuf);
+ CMCHKUNPK(oduPackUInt8, &bndCfg->bufOwnshp, mBuf);
+ CMCHKUNPK(oduPackUInt8, &bndCfg->flcTyp, mBuf);
+ CMCHKUNPK(oduPackUInt8, &bndCfg->wdw, mBuf);
CMCHKUNPK(cmUnpkEnt, &bndCfg->ent, mBuf);
CMCHKUNPK(cmUnpkInst, &bndCfg->inst, mBuf);
CMCHKUNPK(cmUnpkRegion, &bndCfg->region, mBuf);
CMCHKUNPK(cmUnpkAddrs, &bndCfg->sapAdr, mBuf);
CMCHKUNPK(cmUnpkSelector, &bndCfg->selector, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkBndCfg */
\f
* File: cm_gen.c
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkPst
+S16 cmUnpkPst
(
Pst *pst,
Buffer *mBuf
)
-#else
-PUBLIC S16 cmUnpkPst(pst, mBuf)
-Pst *pst;
-Buffer *mBuf;
-#endif
{
- TRC2(cmUnpkPst)
#ifdef TDS_ROLL_UPGRADE_SUPPORT
CMCHKUNPK(cmUnpkIntfVer, &pst->intfVer, mBuf);
CMCHKUNPK(cmUnpkInst, &pst->srcInst, mBuf);
CMCHKUNPK(cmUnpkEvent, &pst->event, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkPst */
/*
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkElmtHdr
+S16 cmUnpkElmtHdr
(
ElmtHdr *m, /* element header */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkElmtHdr(m, mBuf)
-ElmtHdr *m; /* element header */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpElmtHdr)
/* Present */
- CMCHKUNPK(cmUnpkBool, &m->pres , mBuf);
+ CMCHKUNPK(oduUnpackBool, &m->pres , mBuf);
#if (LCAMT || ATM_BISUP)
/* Unpack action indicator field */
if (m->pres)
{
- CMCHKUNPK(SUnpkU8, &m->actnInd, mBuf);
+ CMCHKUNPK(oduPackUInt8, &m->actnInd, mBuf);
}
#endif
#if (LCAMT || ATM_BISUP)
- CMCHKUNPK(SUnpkU16, &m->compInd, mBuf);
+ CMCHKUNPK(oduPackUInt16, &m->compInd, mBuf);
#endif /* LCAMT || ATM_BISUP */
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkElmtHdr */
\f
/*
*
-* Fun: cmUnpkTknU8
+* Fun: cmUnpkTknUInt8
*
-* Desc: This function unpacks a token U8
+* Desc: This function unpacks a token uint8_t
*
* Ret: ROK - ok
*
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkTknU8
+S16 cmUnpkTknUInt8
(
-TknU8 *tknU8, /* token U8 */
+TknUInt8 *tknUInt8, /* token uint8_t */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkTknU8(tknU8, mBuf)
-TknU8 *tknU8; /* token U8 */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpTknU8)
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknU8->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknUInt8->pres, mBuf);
- if (tknU8->pres)
+ if (tknUInt8->pres)
{
/* Value */
- CMCHKUNPK(SUnpkU8, &tknU8->val, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknUInt8->val, mBuf);
}
- RETVALUE(ROK);
-} /* end of cmUnpkTknU8 */
+ return ROK;
+} /* end of cmUnpkTknUInt8 */
\f
/*
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkTknS8
+S16 cmUnpkTknS8
(
TknS8 *tknS8, /* token S8 */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkTknS8(tknS8, mBuf)
-TknS8 *tknS8; /* token S8 */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpTknS8)
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknS8->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknS8->pres, mBuf);
if (tknS8->pres)
{
CMCHKUNPK(SUnpkS8, &tknS8->val, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknS8 */
\f
/*
*
-* Fun: cmUnpkTknU16
+* Fun: cmUnpkTknUInt16
*
-* Desc: This function unpacks a token U16
+* Desc: This function unpacks a token uint16_t
*
* Ret: ROK - ok
*
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkTknU16
+S16 cmUnpkTknUInt16
(
-TknU16 *tknU16, /* token U16 */
+TknUInt16 *tknUInt16, /* token uint16_t */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkTknU16(tknU16, mBuf)
-TknU16 *tknU16; /* token U16 */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpTknU16)
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknU16->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknUInt16->pres, mBuf);
- if (tknU16->pres)
+ if (tknUInt16->pres)
{
/* Value */
- CMCHKUNPK(SUnpkU16, &tknU16->val, mBuf);
+ CMCHKUNPK(oduPackUInt16, &tknUInt16->val, mBuf);
}
- RETVALUE(ROK);
-} /* end of cmUnpkTknU16 */
+ return ROK;
+} /* end of cmUnpkTknUInt16 */
\f
/*
*
-* Fun: cmUnpkTknU32
+* Fun: cmUnpkTknUInt32
*
-* Desc: This function unpacks a token U32
+* Desc: This function unpacks a token uint32_t
*
* Ret: ROK - ok
*
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkTknU32
+S16 cmUnpkTknUInt32
(
-TknU32 *tknU32, /* token U32 */
+TknUInt32 *tknUInt32, /* token uint32_t */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkTknU32(tknU32, mBuf)
-TknU32 *tknU32; /* token U32 */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpTknU32)
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknU32->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknUInt32->pres, mBuf);
- if (tknU32->pres)
+ if (tknUInt32->pres)
{
/* Value */
- CMCHKUNPK(SUnpkU32, &tknU32->val, mBuf);
+ CMCHKUNPK(oduPackUInt32, &tknUInt32->val, mBuf);
}
- RETVALUE(ROK);
-} /* end of cmUnpkTknU32 */
+ return ROK;
+} /* end of cmUnpkTknUInt32 */
/*
*
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkTknStr
+S16 cmUnpkTknStr
(
TknStr *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkTknStr(tknStr, mBuf)
-TknStr *tknStr; /* token string */
-Buffer *mBuf; /* message buffer */
-#endif
{
Cntr i; /* counter */
- TRC2(cmUnpTknStr)
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
if (tknStr->pres)
{
/* Length */
- CMCHKUNPK(SUnpkU8, &tknStr->len, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->len, mBuf);
/* Value */
for (i = (tknStr->len - 1); i >= 0; i--)
{
- CMCHKUNPK(SUnpkU8, &tknStr->val[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->val[i], mBuf);
}
}
else
tknStr->len = 0;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStr */
/*
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkTknStrM
+S16 cmUnpkTknStrM
(
TknStrM *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkTknStrM(tknStr, mBuf)
-TknStrM *tknStr; /* token string */
-Buffer *mBuf; /* message buffer */
-#endif
{
Cntr i; /* counter */
- TRC2(cmUnpTknStrM)
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
if (tknStr->pres)
{
/* Length */
- CMCHKUNPK(SUnpkU8, &tknStr->len, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->len, mBuf);
/* Value */
for (i = (tknStr->len - 1); i >= 0; i--)
{
- CMCHKUNPK(SUnpkU8, &tknStr->val[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->val[i], mBuf);
}
}
else
tknStr->len = 0;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStrM */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkTknStrS
+S16 cmUnpkTknStrS
(
TknStrS *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkTknStrS(tknStr, mBuf)
-TknStrS *tknStr; /* token string */
-Buffer *mBuf; /* message buffer */
-#endif
{
Cntr i; /* counter */
- TRC2(cmUnpTknStrS)
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
if (tknStr->pres)
{
/* Length */
- CMCHKUNPK(SUnpkU8, &tknStr->len, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->len, mBuf);
/* Value */
for (i = (tknStr->len - 1); i >= 0; i--)
{
- CMCHKUNPK(SUnpkU8, &tknStr->val[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->val[i], mBuf);
}
}
else
tknStr->len = 0;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStrS */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkTknStrE
+S16 cmUnpkTknStrE
(
TknStrE *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkTknStrE(tknStr, mBuf)
-TknStrE *tknStr; /* token string */
-Buffer *mBuf; /* message buffer */
-#endif
{
Cntr i; /* counter */
- TRC2(cmUnpTknStrE)
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
if (tknStr->pres)
{
/* Length */
- CMCHKUNPK(SUnpkU8, &tknStr->len, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->len, mBuf);
/* Value */
for (i = (tknStr->len - 1); i >= 0; i--)
{
- CMCHKUNPK(SUnpkU8, &tknStr->val[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->val[i], mBuf);
}
}
else
tknStr->len = 0;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStrE */
#ifndef CMFILE_REORG_1
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkPnNodeId
+S16 cmUnpkPnNodeId
(
PnNodeId *dst, /* source PNNI Node Id */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkPnNodeId (dst, mBuf)
-PnNodeId *dst; /* source PNNI Node Id */
-Buffer *mBuf; /* message buffer */
-#endif
{
S16 i;
- TRC3(cmUnpkPnNodeId);
for (i = 0; i < PN_NODEID_LEN; i++)
{
- CMCHKUNPK(SUnpkU8, &dst->id[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, &dst->id[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkPnNodeId */
#endif /* CMFILE_REORG_1 */
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkTknStr4
+S16 cmUnpkTknStr4
(
TknStr4 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkTknStr4(tknStr, mBuf)
-TknStr4 *tknStr; /* token string */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpkTknStr4)
CMUNPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStr4 */
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkTknStr12
+S16 cmUnpkTknStr12
(
TknStr12 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkTknStr12(tknStr, mBuf)
-TknStr12 *tknStr; /* token string */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpkTknStr12)
CMUNPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStr12 */
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkTknStr32
+S16 cmUnpkTknStr32
(
TknStr32 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkTknStr32(tknStr, mBuf)
-TknStr32 *tknStr; /* token string */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpkTknStr32)
CMUNPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStr32 */
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkTknStr64
+S16 cmUnpkTknStr64
(
TknStr64 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkTknStr64(tknStr, mBuf)
-TknStr64 *tknStr; /* token string */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpkTknStr64)
CMUNPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStr64 */
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkTknStr132
+S16 cmUnpkTknStr132
(
TknStr132 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkTknStr132(tknStr, mBuf)
-TknStr132 *tknStr; /* token string */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpkTknStr132)
CMUNPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStr132 */
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkTknStr256
+S16 cmUnpkTknStr256
(
TknStr256 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkTknStr256(tknStr, mBuf)
-TknStr256 *tknStr; /* token string */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpkTknStr256)
CMUNPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStr256 */
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkTknOid
+S16 cmUnpkTknOid
(
TknOid *tknOid, /* Object Identifier token */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkTknOid(tknOid, mBuf)
-TknOid *tknOid; /* Object Identifier token */
-Buffer *mBuf; /* message buffer */
-#endif
{
- U16 i;
+ uint16_t i;
- TRC2(cmUnpkTknOid)
/* Unpack the token header */
- CMCHKUNPK(SUnpkU8, &tknOid->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknOid->pres, mBuf);
if (tknOid->pres == TRUE)
{
/* Unpack the length */
- CMCHKUNPK(SUnpkU8, &tknOid->len, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknOid->len, mBuf);
/* Pack the value */
- for (i = 1; i <= (U16)tknOid->len; i++)
+ for (i = 1; i <= (uint16_t)tknOid->len; i++)
{
- /* cm_gen_c_001.main_33: changes for TknOid value from U16 to U32
- * with compilation flag TKNOID_U16 */
-#ifndef TKNOID_U16
- CMCHKUNPK(SUnpkU32, &tknOid->val[tknOid->len - i], mBuf);
+ /* cm_gen_c_001.main_33: changes for TknOid value from uint16_t to uint32_t
+ * with compilation flag TKNOID_UINT16 */
+#ifndef TKNOID_UINT16
+ CMCHKUNPK(oduPackUInt32, &tknOid->val[tknOid->len - i], mBuf);
#else
- CMCHKUNPK(SUnpkU16, &tknOid->val[tknOid->len - i], mBuf);
-#endif /* !TKNOID_U16 */
+ CMCHKUNPK(oduPackUInt16, &tknOid->val[tknOid->len - i], mBuf);
+#endif /* !TKNOID_UINT16 */
}
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknOid */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkTknS32
+S16 cmUnpkTknS32
(
TknS32 *tknS32, /* token S32 */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkTknS32(tknS32, mBuf)
-TknS32 *tknS32; /* token S32 */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpTknS32)
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknS32->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknS32->pres, mBuf);
if (tknS32->pres)
{
CMCHKUNPK(SUnpkS32, &tknS32->val, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknS32 */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkHeader
+S16 cmUnpkHeader
(
Header *header, /* header structure */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkHeader(header, mBuf)
-Header *header; /* header structure */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpHeader)
- CMCHKUNPK(SUnpkU16, &header->msgLen, mBuf);
- CMCHKUNPK(SUnpkU8, &header->msgType, mBuf);
- CMCHKUNPK(SUnpkU8, &header->version, mBuf);
- CMCHKUNPK(SUnpkU16, &header->seqNmb, mBuf);
+ CMCHKUNPK(oduPackUInt16, &header->msgLen, mBuf);
+ CMCHKUNPK(oduPackUInt8, &header->msgType, mBuf);
+ CMCHKUNPK(oduPackUInt8, &header->version, mBuf);
+ CMCHKUNPK(oduPackUInt16, &header->seqNmb, mBuf);
CMCHKUNPK(cmUnpkEntityId, &header->entId, mBuf);
CMCHKUNPK(cmUnpkElmntId, &header->elmId, mBuf);
#ifdef LMINT3
CMCHKUNPK(cmUnpkMemoryId, &header->response.mem, mBuf);
#endif /* LMINT3 */
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkHeader */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkCmStatus
+S16 cmUnpkCmStatus
(
CmStatus *sta, /* status structure */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkCmStatus(sta, mBuf)
-CmStatus *sta; /* status structure */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpkCmStatus)
- CMCHKUNPK(SUnpkU16, &sta->status, mBuf);
- CMCHKUNPK(SUnpkU16, &sta->reason, mBuf);
+ CMCHKUNPK(oduPackUInt16, &sta->status, mBuf);
+ CMCHKUNPK(oduPackUInt16, &sta->reason, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkCmStatus */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkCmAlarm
+S16 cmUnpkCmAlarm
(
CmAlarm *alarm, /* alarm structure */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkCmAlarm(alarm, mBuf)
-CmAlarm *alarm; /* alarm structure */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpkCmAlarm)
CMCHKUNPK(cmUnpkDateTime, &alarm->dt, mBuf);
- CMCHKUNPK(SUnpkU16, &alarm->category, mBuf);
- CMCHKUNPK(SUnpkU16, &alarm->event, mBuf);
- CMCHKUNPK(SUnpkU16, &alarm->cause, mBuf);
+ CMCHKUNPK(oduPackUInt16, &alarm->category, mBuf);
+ CMCHKUNPK(oduPackUInt16, &alarm->event, mBuf);
+ CMCHKUNPK(oduPackUInt16, &alarm->cause, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkCmAlarm */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkSmCfg
+S16 cmUnpkSmCfg
(
SmCfg *smCfg, /* stack manager */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkSmCfg(smCfg, mBuf)
-SmCfg *smCfg; /* stack manager */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpSmCfg)
CMCHKUNPK(cmUnpkEnt, &smCfg->ent, mBuf);
CMCHKUNPK(cmUnpkInst, &smCfg->inst, mBuf);
CMCHKUNPK(cmUnpkRoute, &smCfg->route, mBuf);
CMCHKUNPK(cmUnpkSelector, &smCfg->selector, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkSmCfg */
\f
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkTmrCfg
+S16 cmUnpkTmrCfg
(
TmrCfg *tmrCfg, /* timer configuration */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkTmrCfg(tmrCfg, mBuf)
-TmrCfg *tmrCfg; /* timer configuration */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpTmrCfg)
- CMCHKUNPK(cmUnpkBool, &tmrCfg->enb, mBuf);
- CMCHKUNPK(SUnpkU16, &tmrCfg->val, mBuf);
+ CMCHKUNPK(oduUnpackBool, &tmrCfg->enb, mBuf);
+ CMCHKUNPK(oduPackUInt16, &tmrCfg->val, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTmrCfg */
/*
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkTknBuf
+S16 cmUnpkTknBuf
(
TknBuf *tknBuf, /* token string */
Buffer **tBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkTknBuf(tknBuf, tBuf)
-TknBuf *tknBuf; /* token string */
-Buffer **tBuf; /* message buffer */
-#endif
{
Buffer *mBuf;
- TRC2(cmUnpkTknBuf)
mBuf = *tBuf;
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknBuf->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknBuf->pres, mBuf);
if(tknBuf->pres)
{
{
if( SSegMsg(mBuf, msgLen, &tknBuf->val) != ROK )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
*tBuf = mBuf;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknBuf */
#ifdef TDS_ROLL_UPGRADE_SUPPORT
*
*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkIntf
+S16 cmUnpkIntf
(
CmIntf *intf, /* interface info */
Buffer *mBuf /* message buffer */
)
-#else
-PUBLIC S16 cmUnpkIntf(intf, mBuf)
-CmIntf *intf; /* interface info */
-Buffer *mBuf; /* message buffer */
-#endif
{
- TRC2(cmUnpkIntf)
CMCHKUNPK(cmUnpkIntfVer, &intf->intfVer, mBuf);
CMCHKUNPK(cmUnpkIntfId, &intf->intfId, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkIntf */
#endif /* TDS_ROLL_UPGRADE_SUPPORT */
+/*
+*
+* Fun: getTransId
+*
+* Desc: This function return the transaction ID used for interface transactions
+*
+* Ret: gTransId
+*
+* File: cm_gen.c
+*
+*/
+uint16_t getTransId()
+{
+ gTransId = (gTransId%65535) + 1;
+ return gTransId;
+}
/**********************************************************************
End of file
**********************************************************************/
Code Review / o-du / l2.git / blobdiff