lnk/microser
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

自主协议库编译通过

Browse Source
This commit is contained in:
lnk
2026-06-15 15:48:16 +08:00
parent d3579a2aa7
commit 7205cb5cb9
621 changed files with 224958 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

729
mmslib/mmsl/mmsdtext.c Normal file
View File

@@ -0,0 +1,729 @@
/************************************************************************/
/* SISCO SOFTWARE MODULE HEADER *****************************************/
/************************************************************************/
/* (c) Copyright Systems Integration Specialists Company, Inc., */
/* 2004-2004 All Rights Reserved */
/* */
/* MODULE NAME : mmsdtext.c */
/* PRODUCT(S) : MMSEASE-LITE */
/* */
/* MODULE DESCRIPTION : */
/* Functions to convert local data to text. */
/* */
/* GLOBAL FUNCTIONS DEFINED IN THIS MODULE : */
/* ms_local_to_text */
/* */
/* MODIFICATION LOG : */
/* Date Who Rev Comments */
/* -------- --- ------ ------------------------------------------- */
/* 05/13/08 JRB 04 Fix fraction & add qflags in LocToTextUtc. */
/* 09/01/04 JRB 03 Add mmsdefs.h, mms_vvar.h (don't know how */
/* it compiled before without them). */
/* 08/06/04 JRB 02 Cast 1-st arg in call to LocToTextUtf8. */
/* 01/23/04 JRB 01 New. Possible replacement for sxaLocalToText.*/
/************************************************************************/
#include "glbtypes.h"
#include "sysincs.h"
#include "time.h"
#include "time_str.h"
#include "mem_chk.h"
#include "mms_log.h"
#include "mmslog.h"
#include "mmsdefs.h"
#include "mms_vvar.h" /* need RUNTIME_TYPE */
/************************************************************************/
/* For debug version, use a static pointer to avoid duplication of */
/* __FILE__ strings. */
#ifdef DEBUG_SISCO
SD_CONST static ST_CHAR *SD_CONST thisFileName = __FILE__;
#endif
#define TEMP_DATA_BUF_SIZE (100*1024)
#define DATA_SEPARATOR '\n' /* newline */
/************************************************************************/
/* AddString */
/* Copy "Src" string to end of the "Dst" string. */
/************************************************************************/
static ST_RET AddString (ST_CHAR *Src, ST_CHAR *Dst, ST_UINT DstSize, ST_UINT *pDstLen)
{
ST_UINT tmpDstLen = *pDstLen;
/* Watch out for overrun */
if ((tmpDstLen + strlen (Src) + 1) > DstSize)
{
MLOG_NERR0 ("Local->Text buffer overrun");
return (SD_FAILURE);
}
/* Add separator after each string. Later strip off last separator. */
strcpy (&Dst[tmpDstLen],Src);
tmpDstLen += strlen (Src);
Dst[tmpDstLen++] = DATA_SEPARATOR;
*pDstLen = tmpDstLen; /* update caller's buf len */
return (SD_SUCCESS);
}
/************************************************************************/
/* LocToTextInt8 () */
/************************************************************************/
static ST_RET LocToTextInt8 (ST_INT8 *pSrc, RUNTIME_TYPE *rt, ST_CHAR *text)
{
sprintf (text,"%d", (int) *pSrc);
return (SD_SUCCESS);
}
/************************************************************************/
/* LocToTextInt16 () */
/************************************************************************/
static ST_RET LocToTextInt16 (ST_INT16 *pSrc, RUNTIME_TYPE *rt, ST_CHAR *text)
{
sprintf (text,"%d",(int) *pSrc);
return (SD_SUCCESS);
}
/************************************************************************/
/* LocToTextInt32 () */
/************************************************************************/
static ST_RET LocToTextInt32 (ST_INT32 *pSrc, RUNTIME_TYPE *rt, ST_CHAR *text)
{
sprintf (text,"%ld",*pSrc);
return (SD_SUCCESS);
}
/************************************************************************/
/* LocToTextInt64 () */
/************************************************************************/
#if defined(INT64_SUPPORT)
static ST_RET LocToTextInt64 (ST_INT64 *pSrc, RUNTIME_TYPE *rt, ST_CHAR *text)
{
#ifdef _WIN32
sprintf (text,"%I64d",*pSrc);
#elif defined(_AIX) || defined(__hpux) || defined(linux) || defined(sun) || defined(__LYNX)
sprintf (text,"%lld",*pSrc);
#elif (defined(__alpha) && !defined(__VMS))
sprintf (text,"%ld",*pSrc);
#else
#error Missing INT64 code for this platform.
#endif
return (SD_SUCCESS);
}
#endif
/************************************************************************/
/* LocToTextUint8 () */
/************************************************************************/
static ST_RET LocToTextUint8 (ST_UINT8 *pSrc, RUNTIME_TYPE *rt, ST_CHAR *text)
{
sprintf (text,"%u",(unsigned) *pSrc);
return (SD_SUCCESS);
}
/************************************************************************/
/* LocToTextUint16 () */
/************************************************************************/
static ST_RET LocToTextUint16 (ST_UINT16 *pSrc, RUNTIME_TYPE *rt, ST_CHAR *text)
{
sprintf (text,"%u",(unsigned) *pSrc);
return (SD_SUCCESS);
}
/************************************************************************/
/* LocToTextUint32 () */
/************************************************************************/
static ST_RET LocToTextUint32 (ST_UINT32 *pSrc, RUNTIME_TYPE *rt, ST_CHAR *text)
{
sprintf (text,"%lu",(unsigned long) *pSrc);
return (SD_SUCCESS);
}
/************************************************************************/
/* LocToTextUint64 () */
/************************************************************************/
#if defined(INT64_SUPPORT)
static ST_RET LocToTextUint64 (ST_UINT64 *pSrc, RUNTIME_TYPE *rt, ST_CHAR *text)
{
#ifdef _WIN32
sprintf (text,"%I64u", *pSrc);
#elif defined(_AIX) || defined(__hpux) || defined(linux) || defined(sun) || defined(__LYNX)
sprintf (text,"%llu", *pSrc);
#elif (defined(__alpha) && !defined(__VMS))
sprintf (text,"%lu", *pSrc);
#else
#error Missing INT64 code for this platform.
#endif
return (SD_SUCCESS);
}
#endif
/************************************************************************/
/* LocToTextBcd1 () */
/************************************************************************/
static ST_RET LocToTextBcd1 (ST_INT8 *pSrc, RUNTIME_TYPE *rt, ST_CHAR *text)
{
sprintf (text,"%d", (int) *pSrc);
return (SD_SUCCESS);
}
/************************************************************************/
/* LocToTextBcd2 () */
/************************************************************************/
static ST_RET LocToTextBcd2 (ST_INT16 *pSrc, RUNTIME_TYPE *rt, ST_CHAR *text)
{
sprintf (text,"%d",(int) *pSrc);
return (SD_SUCCESS);
}
/************************************************************************/
/* LocToTextBcd4 () */
/************************************************************************/
static ST_RET LocToTextBcd4 (ST_INT32 *pSrc, RUNTIME_TYPE *rt, ST_CHAR *text)
{
sprintf (text,"%ld",*pSrc);
return (SD_SUCCESS);
}
/************************************************************************/
/* LocToTextBool () */
/************************************************************************/
static ST_RET LocToTextBool (ST_BOOLEAN *pSrc, RUNTIME_TYPE *rt, ST_CHAR *text)
{
sprintf (text,"%u",(unsigned) *pSrc);
return (SD_SUCCESS);
}
/************************************************************************/
/* LocToTextFlt () */
/************************************************************************/
static ST_RET LocToTextFlt (ST_FLOAT *pSrc, RUNTIME_TYPE *rt, ST_CHAR *text)
{
#if defined(_WIN32) || defined(__QNX__)
/* 7 significant digits */
/*gcvt((ST_DOUBLE) *pSrc, 7, text);*/
sprintf (text, "%.4f", (ST_DOUBLE) (*pSrc));
#else
sprintf (text, "%.7g", (ST_DOUBLE) (*pSrc));
#endif
return (SD_SUCCESS);
}
/************************************************************************/
/* LocToTextDbl () */
/************************************************************************/
static ST_RET LocToTextDbl (ST_DOUBLE *pSrc, RUNTIME_TYPE *rt, ST_CHAR *text)
{
#if defined(_WIN32) || defined(__QNX__)
/* 16 significant digits */
gcvt(*pSrc, 16, text);
#else
sprintf (text, "%.16g", *pSrc);
#endif
return (SD_SUCCESS);
}
/************************************************************************/
/* LocToTextOct */
/************************************************************************/
static ST_RET LocToTextOct (ST_UCHAR *pSrc, RUNTIME_TYPE *rt, ST_CHAR *text)
{
int i, k;
int numBytes;
ST_INT16 *sp;
ST_CHAR *destBuf;
text[0] = 0;
numBytes = rt->u.p.el_len;
if (numBytes < 0) /* a variable length octet string */
{
sp = (ST_INT16 *) pSrc;
numBytes = *sp;
k=2;
}
else
k=0;
/* We take 3 bytes per octet, make sure it fits */
if (numBytes > TEMP_DATA_BUF_SIZE/3)
{
MLOG_NERR1 ("Octet String (%d bytes) too long to encode", numBytes);
return SD_FAILURE;
}
destBuf = text;
for (i = 0; i < numBytes; ++i, ++k)
{
sprintf (destBuf, "%02x ", (unsigned int) pSrc[k]);
destBuf += 3;
}
/* Eliminate the trailing space */
*(destBuf - 1) = 0;
#ifdef WIN32 //renxiaobao mod
if(text[0]==0) strcpy(destBuf,"0");
#endif
return (SD_SUCCESS);
}
/************************************************************************/
/* LocToTextBs */
/************************************************************************/
static ST_RET LocToTextBs (ST_UCHAR *pSrc, RUNTIME_TYPE *rt, ST_CHAR *text)
{
int i;
int j;
int k;
int numBits;
ST_INT16 *sp;
ST_CHAR *destBuf;
ST_UCHAR mask;
text[0] = 0;
numBits = rt->u.p.el_len;
/* We take 1 dest byte per bit, make sure it fits */
if (numBits > TEMP_DATA_BUF_SIZE-1)
{
MLOG_NERR1 ("Bit String (%d bits) too long to encode", numBits);
return (SD_FAILURE);
}
if (numBits < 0) /* a variable length bit string */
{
sp = (ST_INT16 *) pSrc;
numBits = *sp;
k=2;
}
else
k=0;
destBuf = text;
for (i = 0; i < numBits; ++k) /* for each byte, while bits remain */
{
mask = 0x80;
for (j = 0; j < 8 && i < numBits; ++i, ++j)
{
if (pSrc[k] & mask)
destBuf[i] = '1';
else
destBuf[i] = '0';
mask >>= 1;
}
}
destBuf[i] = 0;
#ifdef WIN32 //renxiaobao mod
if(text[0]==0) strcpy(destBuf,"0");
#endif
return (SD_SUCCESS);
}
/************************************************************************/
/* LocToTextBtime4 */
/************************************************************************/
static ST_RET LocToTextBtime4 (ST_INT32 *pSrc, RUNTIME_TYPE *rt, ST_CHAR *text)
{
if (Btime4ValsToString (text, *pSrc))
{
MLOG_NERR0 ("Btime4 String conversion error.");
return (SD_FAILURE);
}
return (SD_SUCCESS);
}
/************************************************************************/
/* LocToTextBtime6 */
/************************************************************************/
static ST_RET LocToTextBtime6 (ST_INT32 *pSrc, RUNTIME_TYPE *rt, ST_CHAR *text)
{
ST_INT32 *pDays, *pMsec;
pMsec = pSrc;
pDays = (pSrc+1);
if (Btime6ValsToString (text, *pDays, *pMsec))
{
MLOG_NERR0 ("Btime6 String conversion error.");
return (SD_FAILURE);
}
return (SD_SUCCESS);
}
/************************************************************************/
/* LocToTextGtime */
/************************************************************************/
static ST_RET LocToTextGtime (time_t *pSrc, RUNTIME_TYPE *rt, ST_CHAR *text)
{
if (tstrTimeToString (*pSrc, text))
{
MLOG_NERR0 ("Time to String conversion error");
return (SD_FAILURE);
}
return (SD_SUCCESS);
}
/************************************************************************/
/* LocToTextUtc */
/************************************************************************/
#ifdef WIN32
//void printf_utctime(char *buf,void *utctime);//lnk<6E><6B><EFBFBD><EFBFBD>ɾ<EFBFBD><C9BE><EFBFBD><EFBFBD>ԭǰ<D4AD>ó<EFBFBD><C3B3><EFBFBD>δʹ<CEB4><CAB9>
#endif
static ST_RET LocToTextUtc (MMS_UTC_TIME *pSrc, RUNTIME_TYPE *rt, ST_CHAR *text)
{
#ifdef WIN32
char tmpbuf[128];
//printf_utctime(text,pSrc);
strcpy(text, "");//lnk<6E><6B><EFBFBD><EFBFBD><EFBFBD>޸ģ<DEB8>ԭǰ<D4AD>ó<EFBFBD><C3B3><EFBFBD>δʹ<CEB4><CAB9>
/* sprintf (tmpbuf," %02x",pSrc->qflags);*/ /*renxiaobao ʱ<><CAB1>Ʒ<EFBFBD><C6B7>*/
/* strcat(text,tmpbuf);*/
#else
sprintf (text,"UTC TIME seconds=%lu, fraction=%lu, qflags=%lu",
pSrc->secs, pSrc->fraction, pSrc->qflags);
#endif
return (SD_SUCCESS);
}
/************************************************************************/
/* LocToTextUtf8 */
/************************************************************************/
#ifdef WIN32
//void utf8_convert_gb2312(char *pOut, char *pText, int pLen); //lnk<6E><6B><EFBFBD><EFBFBD>ɾ<EFBFBD><C9BE><EFBFBD><EFBFBD>ԭǰ<D4AD>ó<EFBFBD><C3B3><EFBFBD>δʹ<CEB4><CAB9>
#endif
static ST_RET LocToTextUtf8 (ST_UCHAR *pSrc, RUNTIME_TYPE *rt, ST_CHAR *text)
{
#ifdef WIN32
int len =strlen((char *)pSrc);
//if(len) utf8_convert_gb2312(text,(char *)pSrc,len);//lnk<6E><6B><EFBFBD><EFBFBD><EFBFBD>޸ģ<DEB8>ԭǰ<D4AD>ó<EFBFBD><C3B3><EFBFBD>δʹ<CEB4><CAB9>
if (len) {
memcpy(text, pSrc, len);
text[len] = 0;
}
else strcpy(text," ");
return (SD_SUCCESS);
#endif
sprintf (text,"UTF8string: can't display");
return (SD_SUCCESS);
}
/************************************************************************/
/* ms_local_to_text */
/* NOTE: tmpBuf is passed to most "LocToText.." static functions. These */
/* functions must NOT write past end of tmpBuf. */
/************************************************************************/
ST_CHAR *ms_local_to_text (ST_CHAR *datptr, SD_CONST RUNTIME_TYPE *rt_head, ST_INT rt_num,
ST_CHAR *textBuf, ST_UINT textBufSize)
{
RUNTIME_TYPE *rt_ptr;
RUNTIME_TYPE *rt_end;
ST_RET uDataRet;
ST_INT arr_loop_level,total_len;
ST_INT arr_loops[ASN1_MAX_LEVEL];
ST_CHAR *ret_ptr;
static ST_CHAR tmpBuf[TEMP_DATA_BUF_SIZE];
ST_UINT nStrLen = 0; /* Current text total length */
tmpBuf[0] = 0;/*renxiaobao add*/
nStrLen = 0;
arr_loop_level = 0;
rt_ptr = (RUNTIME_TYPE *) rt_head; /* point to head rt_block */
rt_end = rt_ptr + rt_num; /* done when pointer is here */
uDataRet = SD_SUCCESS;
while (rt_ptr < rt_end && uDataRet == SD_SUCCESS)
{
if (rt_ptr->el_tag == RT_ARR_END) /* treat case of array ending */
{
if (--arr_loops[arr_loop_level] > 0) /* if need to do next ar elmnt */
rt_ptr -= rt_ptr->u.arr.num_rt_blks; /* mv rt_ptr to start of arr */
else
--arr_loop_level;
}
if (rt_ptr->el_tag == RT_ARR_START) /* treat case of array starting */
{
/* initialize the loop counter for the array */
++arr_loop_level;
arr_loops[arr_loop_level] = rt_ptr->u.arr.num_elmnts;
}
switch (rt_ptr->el_tag)
{
case RT_ARR_START :
break; /* do nothing */
case RT_ARR_END : /* array done */
break; /* do nothing */
case RT_STR_START :
uDataRet = AddString ("{", textBuf, textBufSize, &nStrLen);
break;
case RT_STR_END : /* structure done */
uDataRet = AddString ("}", textBuf, textBufSize, &nStrLen);
break;
case RT_BOOL :
uDataRet = LocToTextBool ((ST_BOOLEAN *) datptr, rt_ptr, tmpBuf);
if (uDataRet==SD_SUCCESS) /* If converted OK, add to working text*/
uDataRet = AddString (tmpBuf, textBuf, textBufSize, &nStrLen);
break;
case RT_BIT_STRING :
uDataRet = LocToTextBs ((ST_UCHAR *) datptr, rt_ptr, tmpBuf);
if (uDataRet==SD_SUCCESS) /* If converted OK, add to working text*/
uDataRet = AddString (tmpBuf, textBuf, textBufSize, &nStrLen);
break;
case RT_INTEGER :
switch (rt_ptr->u.p.el_len) /* determine length */
{
case 1 : /* one byte int */
uDataRet = LocToTextInt8 ((ST_INT8 *) datptr, rt_ptr, tmpBuf);
break;
case 2 : /* two byte int */
uDataRet = LocToTextInt16 ((ST_INT16 *) datptr, rt_ptr, tmpBuf);
break;
case 4 : /* four byte integer */
uDataRet = LocToTextInt32 ((ST_INT32 *) datptr, rt_ptr, tmpBuf);
break;
#ifdef INT64_SUPPORT
case 8 : /* eight byte integer */
uDataRet = LocToTextInt64 ((ST_INT64 *) datptr, rt_ptr, tmpBuf);
break;
#endif
default:
uDataRet = SD_FAILURE;
break;
}
if (uDataRet==SD_SUCCESS) /* If converted OK, add to working text*/
uDataRet = AddString (tmpBuf, textBuf, textBufSize, &nStrLen);
break;
case RT_UNSIGNED :
switch (rt_ptr->u.p.el_len) /* determine length */
{
case 1 : /* one byte int */
uDataRet = LocToTextUint8 ((ST_UCHAR *) datptr, rt_ptr, tmpBuf);
break;
case 2 : /* two byte int */
uDataRet = LocToTextUint16 ((ST_UINT16 *) datptr, rt_ptr, tmpBuf);
break;
case 4 : /* four byte integer */
uDataRet = LocToTextUint32 ((ST_UINT32 *) datptr, rt_ptr, tmpBuf);
break;
#ifdef INT64_SUPPORT
case 8 : /* eight byte integer */
uDataRet = LocToTextUint64 ((ST_UINT64 *) datptr, rt_ptr, tmpBuf);
break;
#endif /* INT64_SUPPORT */
default:
uDataRet = SD_FAILURE;
break;
}
if (uDataRet==SD_SUCCESS) /* If converted OK, add to working text*/
uDataRet = AddString (tmpBuf, textBuf, textBufSize, &nStrLen);
break;
#ifdef FLOAT_DATA_SUPPORT
case RT_FLOATING_POINT :
if (rt_ptr->u.p.el_len != sizeof (ST_FLOAT))
uDataRet = LocToTextDbl ((ST_DOUBLE *) datptr, rt_ptr, tmpBuf);
else
uDataRet = LocToTextFlt ((ST_FLOAT *) datptr, rt_ptr, tmpBuf);
if (uDataRet==SD_SUCCESS) /* If converted OK, add to working text*/
uDataRet = AddString (tmpBuf, textBuf, textBufSize, &nStrLen);
break;
#endif
case RT_OCTET_STRING :
uDataRet = LocToTextOct ((ST_UCHAR *) datptr, rt_ptr, tmpBuf);
if (uDataRet==SD_SUCCESS) /* If converted OK, add to working text*/
uDataRet = AddString (tmpBuf, textBuf, textBufSize, &nStrLen);
break;
case RT_VISIBLE_STRING : /* No conversion needed. Just add to working text*/
#ifdef WIN32 //renxiaobao mod
if(datptr[0]==0) uDataRet = AddString (" ", textBuf, textBufSize, &nStrLen);
else
#endif
uDataRet = AddString (datptr, textBuf, textBufSize, &nStrLen);
break;
#ifdef TIME_DATA_SUPPORT
case RT_GENERAL_TIME :
uDataRet = LocToTextGtime ((time_t *) datptr, rt_ptr, tmpBuf);
if (uDataRet==SD_SUCCESS) /* If converted OK, add to working text*/
uDataRet = AddString (tmpBuf, textBuf, textBufSize, &nStrLen);
break;
#endif
#ifdef BTOD_DATA_SUPPORT
case RT_BINARY_TIME :
switch (rt_ptr->u.p.el_len) /* determine length */
{
case 4:
uDataRet = LocToTextBtime4 ((ST_INT32 *) datptr, rt_ptr, tmpBuf);
break;
case 6:
uDataRet = LocToTextBtime6 ((ST_INT32 *) datptr, rt_ptr, tmpBuf);
break;
default:
uDataRet = SD_FAILURE;
break;
}
if (uDataRet==SD_SUCCESS) /* If converted OK, add to working text*/
uDataRet = AddString (tmpBuf, textBuf, textBufSize, &nStrLen);
break;
#endif
case RT_BCD :
if (rt_ptr->u.p.el_len <= 2)
uDataRet = LocToTextBcd1 ((ST_INT8 *) datptr, rt_ptr, tmpBuf);
else if (rt_ptr->u.p.el_len <= 4)
uDataRet = LocToTextBcd2 ((ST_INT16 *) datptr, rt_ptr, tmpBuf);
else if (rt_ptr->u.p.el_len <= 8)
uDataRet = LocToTextBcd4 ((ST_INT32 *) datptr, rt_ptr, tmpBuf);
else
uDataRet = SD_FAILURE;
if (uDataRet==SD_SUCCESS) /* If converted OK, add to working text*/
uDataRet = AddString (tmpBuf, textBuf, textBufSize, &nStrLen);
break;
case RT_UTC_TIME :
uDataRet = LocToTextUtc ((MMS_UTC_TIME *) datptr, rt_ptr, tmpBuf);
if (uDataRet==SD_SUCCESS) /* If converted OK, add to working text*/
uDataRet = AddString (tmpBuf, textBuf, textBufSize, &nStrLen);
break;
case RT_UTF8_STRING :
uDataRet = LocToTextUtf8 ((ST_UCHAR *) datptr, rt_ptr, tmpBuf);
if (uDataRet==SD_SUCCESS) /* If converted OK, add to working text*/
uDataRet = AddString (tmpBuf, textBuf, textBufSize, &nStrLen);
break;
default : /* should not be any other tag */
MLOG_ERR1 ("Invalid tag: %d", (int) rt_ptr->el_tag);
uDataRet = SD_FAILURE;
break;
}
if(strlen (tmpBuf)>sizeof (tmpBuf))
{
total_len = strlen (tmpBuf);
}
assert (strlen (tmpBuf) < sizeof (tmpBuf)); /* Must not exceed buffer*/
datptr += rt_ptr->el_size; /* Adjust data pointer */
rt_ptr++; /* point to next rt element */
}
assert (nStrLen <= textBufSize); /* checked in AddString so this should never fail*/
if (uDataRet)
ret_ptr = NULL;
else
{
textBuf [--nStrLen] = '\0'; /* replace last '\n' with '\0' */
ret_ptr = textBuf;
}
return (ret_ptr);
}
#if defined(WIN32)
char *va_data_to_text (char **va_data,RUNTIME_TYPE **rt_head, RUNTIME_TYPE *rt_end,int read_num)
{
static char ret_text[128];
static char ret_text_buf[12800];
RUNTIME_TYPE *rt_ptr;
char *datptr,done;
ST_RET uDataRet;
static int arr_loop_level;
static int arr_loops[ASN1_MAX_LEVEL];
rt_ptr = *rt_head;
datptr = *va_data;
ret_text_buf[0] = 0;
ret_text[0] = 0;
if(read_num==0) arr_loop_level = 0;
done = 0;
while(rt_ptr<rt_end)
{
if(rt_ptr->el_tag == RT_ARR_END)
{
if(--arr_loops[arr_loop_level] > 0) rt_ptr -= rt_ptr->u.arr.num_rt_blks;
else --arr_loop_level;
}
if (rt_ptr->el_tag == RT_ARR_START)
{
++arr_loop_level;arr_loops[arr_loop_level] = rt_ptr->u.arr.num_elmnts;
}
switch (rt_ptr->el_tag)
{
case RT_ARR_START : break;
case RT_ARR_END : break;
case RT_STR_START : break;
case RT_STR_END : break;
case RT_BOOL :
uDataRet = LocToTextBool ((ST_BOOLEAN *)datptr, rt_ptr, ret_text);
done = 1;
break;
case RT_BIT_STRING :
uDataRet = LocToTextBs ((ST_UCHAR *) datptr, rt_ptr, ret_text);
done = 1;
break;
case RT_INTEGER :
if (rt_ptr->u.p.el_len==1) uDataRet = LocToTextInt8 ((ST_INT8 *) datptr, rt_ptr, ret_text);
else if(rt_ptr->u.p.el_len==2) uDataRet = LocToTextInt16((ST_INT16 *) datptr, rt_ptr, ret_text);
else if(rt_ptr->u.p.el_len==4) uDataRet = LocToTextInt32((ST_INT32 *) datptr, rt_ptr, ret_text);
done = 1;
break;
case RT_UNSIGNED :
if (rt_ptr->u.p.el_len==1) uDataRet = LocToTextUint8 ((ST_UINT8 *) datptr, rt_ptr, ret_text);
else if(rt_ptr->u.p.el_len==2) uDataRet = LocToTextUint16((ST_UINT16 *) datptr, rt_ptr, ret_text);
else if(rt_ptr->u.p.el_len==4) uDataRet = LocToTextUint32((ST_UINT32 *) datptr, rt_ptr, ret_text);
done = 1;
break;
case RT_FLOATING_POINT :
if (rt_ptr->u.p.el_len != sizeof (ST_FLOAT))
uDataRet = LocToTextDbl ((ST_DOUBLE *) datptr, rt_ptr, ret_text);
else
uDataRet = LocToTextFlt ((ST_FLOAT *) datptr, rt_ptr, ret_text);
done = 1;
break;
case RT_OCTET_STRING :
uDataRet = LocToTextOct ((ST_UCHAR *) datptr, rt_ptr, ret_text);
done = 1;
break;
case RT_VISIBLE_STRING :
strcpy(ret_text,datptr);
done = 1;
break;
case RT_GENERAL_TIME :
uDataRet = LocToTextGtime ((time_t *) datptr, rt_ptr, ret_text);
done = 1;
break;
case RT_BINARY_TIME :
if (rt_ptr->u.p.el_len==4) LocToTextBtime4 ((ST_INT32 *) datptr, rt_ptr, ret_text);
else if(rt_ptr->u.p.el_len==6) LocToTextBtime6 ((ST_INT32 *) datptr, rt_ptr, ret_text);
done = 1;
break;
case RT_BCD :
if(rt_ptr->u.p.el_len <= 2)
uDataRet = LocToTextBcd1 ((ST_INT8 *) datptr, rt_ptr, ret_text);
else if (rt_ptr->u.p.el_len <= 4)
uDataRet = LocToTextBcd2 ((ST_INT16 *) datptr, rt_ptr, ret_text);
else if (rt_ptr->u.p.el_len <= 8)
uDataRet = LocToTextBcd4 ((ST_INT32 *) datptr, rt_ptr, ret_text);
done = 1;
break;
case RT_UTC_TIME :
uDataRet = LocToTextUtc ((MMS_UTC_TIME *) datptr, rt_ptr, ret_text);
done = 1;
break;
case RT_UTF8_STRING :
uDataRet = LocToTextUtf8 ((ST_UCHAR *) datptr, rt_ptr, ret_text);
done = 1;
break;
default :
break;
}
datptr += rt_ptr->el_size;
rt_ptr++;
if(done) strcat(ret_text_buf,ret_text);
if((read_num>=0)&&(done)) break;
done=0;
}
*rt_head=rt_ptr;
*va_data=datptr;
return ret_text_buf;
}
#endif