1 /*******************************************************************************
2 ################################################################################
3 # Copyright (c) [2017-2019] [Radisys] #
5 # Licensed under the Apache License, Version 2.0 (the "License"); #
6 # you may not use this file except in compliance with the License. #
7 # You may obtain a copy of the License at #
9 # http://www.apache.org/licenses/LICENSE-2.0 #
11 # Unless required by applicable law or agreed to in writing, software #
12 # distributed under the License is distributed on an "AS IS" BASIS, #
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
14 # See the License for the specific language governing permissions and #
15 # limitations under the License. #
16 ################################################################################
17 *******************************************************************************/
19 /********************************************************************20**
21 Name: System Services -- packing
25 Desc: Source code for System Services packing functions.
29 *********************************************************************21*/
32 /* header include files (.h) */
34 #include "envopt.h" /* environment options */
35 #include "envdep.h" /* environment dependent */
36 #include "envind.h" /* environment independent */
38 #include "gen.h" /* general layer */
39 #include "ssi.h" /* system services */
41 #include "ss_err.h" /* errors */
42 #include "ss_dep.h" /* implementation-specific */
43 #include "ss_queue.h" /* queues */
44 #include "ss_msg.h" /* messaging */
45 #include "ss_mem.h" /* memory management interface */
46 #include "ss_gen.h" /* general */
47 #include "cm_mem.h" /* memory management */
51 /* header/extern include files (.x) */
53 #include "gen.x" /* general layer */
54 #include "ssi.x" /* system services */
56 #include "ss_dep.x" /* implementation-specific */
57 #include "ss_queue.x" /* queues */
58 #include "ss_task.x" /* tasking */
59 #include "ss_timer.x" /* timers */
60 #include "ss_strm.x" /* STREAMS */
61 #include "ss_msg.x" /* messaging */
62 #include "ss_mem.x" /* memory management interface */
63 #include "ss_drvr.x" /* driver tasks */
64 #ifdef SS_LOCKLESS_MEMORY
67 #include "cm_mem_wl.x" /* common memory manager */
69 #include "cm_mem.x" /* common memory manager */
70 #endif /* SS_LOCKLESS_MEMORY */
71 #include "ss_gen.x" /* general */
79 * Desc: This function packs a signed 8 bit value into a message.
82 * RFAILED - failed, general (optional)
83 * ROUTRES - failed, out of resources (optional)
95 Buffer *mBuf /* message buffer */
100 Buffer *mBuf; /* message buffer */
103 S16 ret; /* return code */
104 ret = SAddPreMsg((Data) val, mBuf);
105 #if (ERRCLASS & ERRCLS_ADD_RES)
107 SSLOGERROR(ERRCLS_ADD_RES, ESS242, (ErrVal)ret, "SAddPreMsg() failed");
116 * Fun: oduUnpackUInt8
118 * Desc: This function packs an unsigned 8 bit value into a message.
121 * RFAILED - failed, general (optional)
122 * ROUTRES - failed, out of resources (optional)
133 uint8_t val, /* value */
134 Buffer *mBuf /* message buffer */
137 S16 oduUnpackUInt8(val, mBuf)
138 uint8_t val; /* value */
139 Buffer *mBuf; /* message buffer */
142 S16 ret; /* return code */
143 ret = SAddPreMsg((Data) val, mBuf);
144 #if (ERRCLASS & ERRCLS_ADD_RES)
146 SSLOGERROR(ERRCLS_ADD_RES, ESS243, (ErrVal)ret, "SAddPreMsg() failed");
149 } /* end of oduUnpackUInt8 */
155 * Desc: This function packs a signed 16 bit value into a message.
158 * RFAILED - failed, general (optional)
159 * ROUTRES - failed, out of resources (optional)
171 Buffer *mBuf /* message buffer */
174 S16 SPkS16(val, mBuf)
176 Buffer *mBuf; /* message buffer */
179 Data pkArray[2]; /* array for packing */
180 S16 ret; /* return code */
182 #ifndef FCSPKINT /* backward compatibility, packing order */
183 pkArray[0] = (Data) GetHiByte(val);
184 pkArray[1] = (Data) GetLoByte(val);
185 #else /* forward compatibility, packing order */
186 pkArray[1] = (Data) GetHiByte(val);
187 pkArray[0] = (Data) GetLoByte(val);
189 ret = SAddPreMsgMult(pkArray, (MsgLen) 2, mBuf);
190 #if (ERRCLASS & ERRCLS_ADD_RES)
192 SSLOGERROR(ERRCLS_ADD_RES, ESS244, (ErrVal)ret, "SAddPreMsgMult() failed");
195 } /* end of SPkS16 */
200 * Fun: oduUnpackUInt16
202 * Desc: This function packs an unsigned 16 bit value into a message.
205 * RFAILED - failed, general (optional)
206 * ROUTRES - failed, out of resources (optional)
217 uint16_t val, /* value */
218 Buffer *mBuf /* message buffer */
221 S16 oduUnpackUInt16(val, mBuf)
222 uint16_t val; /* value */
223 Buffer *mBuf; /* message buffer */
226 Data pkArray[2]; /* array for packing */
227 S16 ret; /* return code */
229 #ifndef FCSPKINT /* backward compatibility, packing order */
230 pkArray[0] = (Data) GetHiByte(val);
231 pkArray[1] = (Data) GetLoByte(val);
232 #else /* forward compatibility, packing order */
233 pkArray[1] = (Data) GetHiByte(val);
234 pkArray[0] = (Data) GetLoByte(val);
236 ret = SAddPreMsgMult(pkArray, (MsgLen) 2, mBuf);
237 #if (ERRCLASS & ERRCLS_ADD_RES)
239 SSLOGERROR(ERRCLS_ADD_RES, ESS245, (ErrVal)ret, "SAddPreMsgMult() failed");
242 } /* end of oduUnpackUInt16 */
249 * Desc: This function packs a signed 32 bit value into a message.
252 * RFAILED - failed, general (optional)
253 * ROUTRES - failed, out of resources (optional)
265 Buffer *mBuf /* message buffer */
268 S16 SPkS32(val, mBuf)
270 Buffer *mBuf; /* message buffer */
273 uint16_t tmp; /* temporary value */
274 Data pkArray[4]; /* packing array */
275 S16 ret; /* return code */
277 #ifndef FCSPKINT /* backward compatibility, packing order */
278 tmp = (uint16_t) GetHiWord(val);
279 pkArray[0] = (Data) GetHiByte(tmp);
280 pkArray[1] = (Data) GetLoByte(tmp);
281 tmp = (uint16_t) GetLoWord(val);
282 pkArray[2] = (Data) GetHiByte(tmp);
283 pkArray[3] = (Data) GetLoByte(tmp);
284 #else /* forward compatibility, packing order */
285 tmp = (uint16_t) GetHiWord(val);
286 pkArray[3] = (Data) GetHiByte(tmp);
287 pkArray[2] = (Data) GetLoByte(tmp);
288 tmp = (uint16_t) GetLoWord(val);
289 pkArray[1] = (Data) GetHiByte(tmp);
290 pkArray[0] = (Data) GetLoByte(tmp);
292 ret = SAddPreMsgMult(pkArray, (MsgLen) 4, mBuf);
293 #if (ERRCLASS & ERRCLS_ADD_RES)
295 SSLOGERROR(ERRCLS_ADD_RES, ESS246, (ErrVal)ret, "SAddPreMsgMult() failed");
298 } /* end of SPkS32 */
303 * Fun: oduUnpackUInt32
305 * Desc: This function packs an unsigned 32 bit value into a message.
308 * RFAILED - failed, general (optional)
309 * ROUTRES - failed, out of resources (optional)
320 uint32_t val, /* value */
321 Buffer *mBuf /* message buffer */
324 S16 oduUnpackUInt32(val, mBuf)
325 uint32_t val; /* value */
326 Buffer *mBuf; /* message buffer */
329 uint16_t tmp; /* temporary value */
330 Data pkArray[4]; /* packing array */
331 S16 ret; /* return code */
333 #ifndef FCSPKINT /* backward compatibility, packing order */
334 tmp = (uint16_t) GetHiWord(val);
335 pkArray[0] = (Data) GetHiByte(tmp);
336 pkArray[1] = (Data) GetLoByte(tmp);
337 tmp = (uint16_t) GetLoWord(val);
338 pkArray[2] = (Data) GetHiByte(tmp);
339 pkArray[3] = (Data) GetLoByte(tmp);
340 #else /* forward compatibility, packing order */
341 tmp = (uint16_t) GetHiWord(val);
342 pkArray[3] = (Data) GetHiByte(tmp);
343 pkArray[2] = (Data) GetLoByte(tmp);
344 tmp = (uint16_t) GetLoWord(val);
345 pkArray[1] = (Data) GetHiByte(tmp);
346 pkArray[0] = (Data) GetLoByte(tmp);
348 ret = SAddPreMsgMult(pkArray, (MsgLen) 4, mBuf);
349 #if (ERRCLASS & ERRCLS_ADD_RES)
351 SSLOGERROR(ERRCLS_ADD_RES, ESS247, (ErrVal)ret, "SAddPreMsgMult() failed");
354 } /* end of oduUnpackUInt32 */
356 /*ss038.103 1. Added Floating point support*/
362 * Desc: This function packs an 32 bit ieee-754 format float value into a message.
365 * RFAILED - failed, general (optional)
366 * ROUTRES - failed, out of resources (optional)
378 Buffer *mBuf /* message buffer */
381 S16 SPkF32(val, mBuf)
383 Buffer *mBuf; /* message buffer */
386 S16 ret; /* return code */
387 S8 tmpArray[15]; /* temporary array */
388 #ifdef FCSPKINT /* backward compatibility, packing order */
389 S32 tIdx = 14; /* counters */
390 S32 kIdx = 0; /* counters */
391 S8 pkArray[15]; /* packing array */
394 sprintf(tmpArray, "%.7e", val);
396 #ifndef FCSPKINT /* backward compatibility, packing order */
397 ret = SAddPreMsgMult((Data*)tmpArray, (MsgLen) 15, mBuf);
401 pkArray[kIdx] = tmpArray[tIdx];
404 ret = SAddPreMsgMult((Data*)pkArray, (MsgLen) 15, mBuf);
408 #if (ERRCLASS & ERRCLS_ADD_RES)
410 SSLOGERROR(ERRCLS_ADD_RES, ESS248, (ErrVal)ret, "SAddPreMsgMult() failed");
413 } /* end of SPkF32 */
419 * Desc: This function packs an 64 bit ieee-754 format float value into a message.
422 * RFAILED - failed, general (optional)
423 * ROUTRES - failed, out of resources (optional)
435 Buffer *mBuf /* message buffer */
438 S16 SPkF64(val, mBuf)
440 Buffer *mBuf; /* message buffer */
444 S16 ret; /* return code */
445 S8 tmpArray[25]; /* temporary array */
446 #ifdef FCSPKINT /* backward compatibility, packing order */
447 S32 tIdx = 24; /* counters */
448 S32 kIdx = 0; /* counters */
449 S8 pkArray[25]; /* packing array */
452 sprintf(tmpArray, "%.16le", val);
454 #ifndef FCSPKINT /* backward compatibility, packing order */
455 ret = SAddPreMsgMult((Data*)tmpArray, (MsgLen) 25, mBuf);
459 pkArray[kIdx] = tmpArray[tIdx];
462 ret = SAddPreMsgMult((Data*)pkArray, (MsgLen) 25, mBuf);
466 #if (ERRCLASS & ERRCLS_ADD_RES)
468 SSLOGERROR(ERRCLS_ADD_RES, ESS249, (ErrVal)ret, "SAddPreMsgMult() failed");
472 } /* end of SPkF64 */
473 #endif /* SS_FLOAT */
479 * Desc: This function unpacks a signed 8 bit value from a message.
492 S8 *val, /* pointer to value */
493 Buffer *mBuf /* message buffer */
496 S16 SUnpkS8(val, mBuf)
497 S8 *val; /* pointer to value */
498 Buffer *mBuf; /* message buffer */
501 Data tmp; /* temporary value */
502 S16 ret; /* return code */
504 /* ss021.103 - Addition of data pointer check */
505 #if (ERRCLASS & ERRCLS_INT_PAR)
506 /* check data pointer */
509 SSLOGERROR(ERRCLS_INT_PAR, ESS250, ERRZERO, "SUnpkS8 : Null value");
512 #endif /* ERRCLASS & ERRCLS_INT_PAR */
514 ret = SRemPreMsg(&tmp, mBuf);
515 #if (ERRCLASS & ERRCLS_DEBUG)
517 SSLOGERROR(ERRCLS_DEBUG, ESS251, (ErrVal)ret, "SRemPreMsg() failed");
521 } /* end of SUnpkS8 */
528 * Desc: This function unpacks an unsigned 8 bit value from a message.
541 uint8_t *val, /* pointer to value */
542 Buffer *mBuf /* message buffer */
545 S16 oduPackUInt8(val, mBuf)
546 uint8_t *val; /* pointer to value */
547 Buffer *mBuf; /* message buffer */
550 Data tmp; /* temporary value */
551 S16 ret; /* return code */
553 /* ss021.103 - Addition of data pointer check */
554 #if (ERRCLASS & ERRCLS_INT_PAR)
555 /* check data pointer */
558 SSLOGERROR(ERRCLS_INT_PAR, ESS252, ERRZERO, "oduPackUInt8 : Null value");
561 #endif /* ERRCLASS & ERRCLS_INT_PAR */
563 ret = SRemPreMsg(&tmp, mBuf);
564 #if (ERRCLASS & ERRCLS_DEBUG)
566 SSLOGERROR(ERRCLS_DEBUG, ESS253, (ErrVal)ret, "SRemPreMsg() failed");
568 *val = (uint8_t) tmp;
570 } /* end of oduPackUInt8 */
576 * Desc: This function unpacks a signed 16 bit value from a message.
589 S16 *val, /* pointer to value */
590 Buffer *mBuf /* message buffer */
593 S16 SUnpkS16(val, mBuf)
594 S16 *val; /* pointer to value */
595 Buffer *mBuf; /* message buffer */
598 uint16_t tmp16; /* temporary value */
599 Data unpkArray[2]; /* unpacking array */
600 S16 ret; /* return code */
602 /* ss021.103 - Addition of data pointer check */
603 #if (ERRCLASS & ERRCLS_INT_PAR)
604 /* check data pointer */
607 SSLOGERROR(ERRCLS_INT_PAR, ESS254, ERRZERO, "SUnpkS16 : Null value");
610 #endif /* ERRCLASS & ERRCLS_INT_PAR */
612 ret = SRemPreMsgMult(unpkArray, (MsgLen) 2, mBuf);
613 #if (ERRCLASS & ERRCLS_DEBUG)
615 SSLOGERROR(ERRCLS_DEBUG, ESS255, (ErrVal)ret, "SRemPreMsgMult() failed");
618 #ifndef FCSPKINT /* backward compatibility, packing order */
619 tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[1]);
620 tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[0]);
621 #else /* forward compatibility, packing order */
622 tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[0]);
623 tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[1]);
627 } /* end of SUnpkS16 */
634 * Desc: This function unpacks an unsigned 16 bit value from a message.
647 uint16_t *val, /* pointer to value */
648 Buffer *mBuf /* message buffer */
651 S16 oduPackUInt16(val, mBuf)
652 uint16_t *val; /* pointer to value */
653 Buffer *mBuf; /* message buffer */
656 uint16_t tmp16; /* temporary value */
657 Data unpkArray[2]; /* unpacking array */
658 S16 ret; /* return code */
660 /* ss021.103 - Addition of data pointer check */
661 #if (ERRCLASS & ERRCLS_INT_PAR)
662 /* check data pointer */
665 SSLOGERROR(ERRCLS_INT_PAR, ESS256, ERRZERO, "oduPackUInt16 : Null value");
668 #endif /* ERRCLASS & ERRCLS_INT_PAR */
670 ret = SRemPreMsgMult(unpkArray, (MsgLen) 2, mBuf);
671 #if (ERRCLASS & ERRCLS_DEBUG)
673 SSLOGERROR(ERRCLS_DEBUG, ESS257, (ErrVal)ret, "SRemPreMsgMult failed");
676 #ifndef FCSPKINT /* backward compatibility, packing order */
677 tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[1]);
678 tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[0]);
679 #else /* forward compatibility, packing order */
680 tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[0]);
681 tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[1]);
685 } /* end of oduPackUInt16 */
692 * Desc: This function unpacks a signed 32 bit value from a message.
705 S32 *val, /* pointer to value */
706 Buffer *mBuf /* message buffer */
709 S16 SUnpkS32(val, mBuf)
710 S32 *val; /* pointer to value */
711 Buffer *mBuf; /* message buffer */
714 uint16_t tmp16; /* temporary value */
715 uint32_t tmp32; /* temporary value */
716 Data unpkArray[4]; /* unpacking array */
717 S16 ret; /* return code */
719 /* ss021.103 - Addition of data pointer check */
720 #if (ERRCLASS & ERRCLS_INT_PAR)
721 /* check data pointer */
724 SSLOGERROR(ERRCLS_INT_PAR, ESS258, ERRZERO, "SUnpkS32 : Null value");
727 #endif /* ERRCLASS & ERRCLS_INT_PAR */
729 ret = SRemPreMsgMult(unpkArray, (MsgLen) 4, mBuf);
730 #if (ERRCLASS & ERRCLS_DEBUG)
732 SSLOGERROR(ERRCLS_DEBUG, ESS259, (ErrVal)ret, "SRemPreMsgMult() failed");
736 #ifndef FCSPKINT /* backward compatibility, packing order */
737 tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[3]);
738 tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[2]);
739 tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
740 tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[1]);
741 tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[0]);
742 tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
743 #else /* forward compatibility, packing order */
744 tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[0]);
745 tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[1]);
746 tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
747 tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[2]);
748 tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[3]);
749 tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
753 } /* end of SUnpkS32 */
760 * Desc: This function unpacks an unsigned 32 bit value from a message.
773 uint32_t *val, /* pointer to value */
774 Buffer *mBuf /* message buffer */
777 S16 oduPackUInt32(val, mBuf)
778 uint32_t *val; /* pointer to value */
779 Buffer *mBuf; /* message buffer */
782 uint16_t tmp16; /* temporary value */
783 uint32_t tmp32; /* temporary value */
784 Data unpkArray[4]; /* unpacking array */
786 S16 ret; /* return code */
787 #endif /* ERRCLASS */
789 /* ss021.103 - Addition of data pointer check */
790 #if (ERRCLASS & ERRCLS_INT_PAR)
791 /* check data pointer */
794 SSLOGERROR(ERRCLS_INT_PAR, ESS260, ERRZERO, "oduPackUInt32 : Null value");
797 #endif /* ERRCLASS & ERRCLS_INT_PAR */
799 ret = SRemPreMsgMult(unpkArray, (MsgLen) 4, mBuf);
800 #if (ERRCLASS & ERRCLS_DEBUG)
802 SSLOGERROR(ERRCLS_DEBUG, ESS261, (ErrVal)ret, "SRemPreMsgMult() failed");
807 #ifndef FCSPKINT /* backward compatibility, packing order */
808 tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[3]);
809 tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[2]);
810 tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
811 tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[1]);
812 tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[0]);
813 tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
814 #else /* forward compatibility, packing order */
815 tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[0]);
816 tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[1]);
817 tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
818 tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[2]);
819 tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[3]);
820 tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
824 } /* end of oduPackUInt32 */
826 /*ss038.103 1. Added Floating point support*/
832 * Desc: This function unpacks an 32 bit ieee-754 format float value from a message.
845 F32 *val, /* pointer to value */
846 Buffer *mBuf /* message buffer */
849 S16 SUnpkF32(val, mBuf)
850 F32 *val; /* pointer to value */
851 Buffer *mBuf; /* message buffer */
854 S16 ret; /* return code */
855 S8 tmpArray[15]; /* temporary array */
856 #ifndef FCSPKINT /* backward compatibility, packing order */
857 S32 tIdx = 14; /* temparory array index */
858 S32 kIdx = 0; /* unpacking array index */
859 S8 unpkArray[15]; /* unpacking array */
860 #endif /* FCSPKINT */
862 #if (ERRCLASS & ERRCLS_INT_PAR)
863 /* check data pointer */
866 SSLOGERROR(ERRCLS_INT_PAR, ESS262, ERRZERO, "SUnpkF32 : Null value");
869 #endif /* ERRCLASS & ERRCLS_INT_PAR */
871 ret = SRemPreMsgMult((Data*)tmpArray, (MsgLen) 15, mBuf);
872 #if (ERRCLASS & ERRCLS_DEBUG)
874 SSLOGERROR(ERRCLS_DEBUG, ESS263, (ErrVal)ret, "SRemPreMsgMult() failed");
877 #ifndef FCSPKINT /* backward compatibility, packing order */
880 unpkArray[kIdx] = tmpArray[tIdx];
883 sscanf(unpkArray, "%f", val);
885 sscanf(tmpArray, "%f", val);
890 } /* end of SUnpkF32 */
896 * Desc: This function unpacks an 64 bit ieee-754 format float value from a message.
909 F64 *val, /* pointer to value */
910 Buffer *mBuf /* message buffer */
913 S16 SUnpkF64(val, mBuf)
914 F64 *val; /* pointer to value */
915 Buffer *mBuf; /* message buffer */
919 S16 ret; /* return code */
920 S8 tmpArray[25]; /* temporary array */
921 #ifndef FCSPKINT /* backward compatibility, packing order */
922 S32 tIdx = 24; /* temparory array index */
923 S32 kIdx = 0; /* unpacking array index */
924 S8 unpkArray[25]; /* unpacking array */
925 #endif /* FCSPKINT */
927 #if (ERRCLASS & ERRCLS_INT_PAR)
928 /* check data pointer */
931 SSLOGERROR(ERRCLS_INT_PAR, ESS264, ERRZERO, "SUnpkF64 : Null value");
934 #endif /* ERRCLASS & ERRCLS_INT_PAR */
936 ret = SRemPreMsgMult((Data*)tmpArray, (MsgLen) 25, mBuf);
937 #if (ERRCLASS & ERRCLS_DEBUG)
939 SSLOGERROR(ERRCLS_DEBUG, ESS265, (ErrVal)ret, "SRemPreMsgMult() failed");
942 #ifndef FCSPKINT /* backward compatibility, packing order */
945 unpkArray[kIdx] = tmpArray[tIdx];
948 sscanf(unpkArray, "%lf", val);
950 sscanf(tmpArray, "%lf", val);
955 } /* end of SUnpkF64 */
956 #endif /* SS_FLOAT */
958 /**********************************************************************
960 **********************************************************************/