int XXSTRNFUNC (const OSUTF8CHAR* utf8str, size_t nbytes, XXTYPE* pvalue)
{
size_t i;
#ifndef XXUNSIGNED
OSBOOL minus = FALSE;
#endif
register XXTYPE value = 0, prevVal = 0;
*pvalue = 0;
/* Consume leading white space */
for (i = 0; i < nbytes; i++) {
if (!OS_ISSPACE (utf8str[i])) break;
}
if (i == nbytes) return RTERR_INVFORMAT;
/* Consume trailing white space */
for (; nbytes > 0; nbytes--) {
if (!OS_ISSPACE (utf8str[nbytes - 1])) break;
}
/* Check for '+' or '-' first character */
if (utf8str[i] == '+') {
i++;
if (i >= nbytes) return RTERR_INVFORMAT;
}
else if (utf8str[i] == '-') {
#ifndef XXUNSIGNED
minus = TRUE; i++;
if (i >= nbytes)
#endif
return RTERR_INVFORMAT;
}
/* Convert Unicode characters to an integer value */
for ( ; i < nbytes; i++, prevVal = value) {
if (OS_ISDIGIT (utf8str[i]))
value = (value * 10) + (utf8str[i] - '0');
else
return RTERR_INVCHAR;
if (value/10 != prevVal) /* test for int overflow */
return RTERR_TOOBIG;
}
/* If negative, negate number */
#ifndef XXUNSIGNED
if (minus) *pvalue = 0 - value; else
#endif
*pvalue = value;
return 0;
}
int xerDecUInt64 (OSCTXT* pctxt, OSUINT64* pvalue)
{
XMLCHAR* inpdata = (XMLCHAR*) ASN1BUFPTR (pctxt);
int i;
OSBOOL minus = FALSE;
register OSUINT64 value = 0, prevVal = 0;
*pvalue = 0;
/* Consume leading white space */
for (i = 0; inpdata[i] != 0; i++) {
if (!OS_ISSPACE (inpdata[i])) break;
}
/* Convert Unicode characters to an integer value */
for ( ; inpdata[i] != 0; i++, prevVal = value) {
if (OS_ISDIGIT (inpdata[i]))
value = (value * 10) + (inpdata[i] - '0');
else
return LOG_RTERR (pctxt, RTERR_INVCHAR);
if (value/10 != prevVal) /* test for int overflow AB, 09/27/02 */
return LOG_RTERR (pctxt, RTERR_TOOBIG);
}
*pvalue = value;
return (0);
}
int xmlDecBool (OSCTXT* pctxt, OSBOOL *pvalue)
{
XMLCHAR* inpdata = (XMLCHAR*) ASN1BUFPTR (pctxt);
/* Consume leading white space */
for (; *inpdata != 0 && OS_ISSPACE (*inpdata); inpdata++)
;
if (xerCmpText (inpdata, "true") || xerCmpText (inpdata, "1"))
*pvalue = TRUE;
else if (xerCmpText (inpdata, "false") || xerCmpText (inpdata, "0"))
*pvalue = FALSE;
else
return LOG_RTERR (pctxt, RTERR_BADVALUE);
return (0);
}
int xmlDecDynNamedBitStr
(OSCTXT* pctxt, ASN1DynBitStr* pvalue,
const XmlNamedBitsDict* pBitDict)
{
OSTOKENCTXT tokCtxt;
const OSUTF8CHAR* pToken;
OSOCTET* data;
OSUINT32 nbits = 0, bufsize;
XMLCHAR* inpdata = (XMLCHAR*) ASN1BUFPTR (pctxt);
OSBOOL namedstring = 0; /* named-bits or binary digits value */
/* check values is binary digits (1 & 0) */
while (*inpdata != 0) {
char c = (char)*inpdata;
if (!OS_ISSPACE (c)) {
if (c != '0' && c != '1') { namedstring= 1; break; }
}
inpdata ++;
}
if(!namedstring) {
/* Decode binary digit value */
return xmlDecDynBitStr(pctxt, pvalue);
}
/* Decode Named Bits value */
/* first, determine number of bits in the buffer */
pToken = rtxTokGetFirst (&tokCtxt, (OSUTF8CHAR*)ASN1BUFPTR (pctxt),
pctxt->buffer.size + 1, " \r\n\t\0", 5);
while (pToken != 0) {
int i;
for (i = 0; pBitDict[i].name != 0; i++) {
if (xerCmpText (pToken, pBitDict[i].name)) {
if (nbits <= pBitDict[i].bitnum)
nbits = pBitDict[i].bitnum + 1;
break;
}
}
if (pBitDict[i].name == 0) {
return LOG_RTERR (pctxt, RTERR_IDNOTFOU);
}
pToken = rtxTokGetNext (&tokCtxt);
}
/* allocate memory for bit string */
bufsize = (nbits + 7) / 8;
data = rtxMemAllocArray (pctxt, bufsize, OSOCTET);
if (data != 0) {
pvalue->data = data;
pvalue->numbits = nbits;
/* Convert characters to a bit string value */
pToken = rtxTokGetFirst (&tokCtxt, (OSUTF8CHAR*)ASN1BUFPTR (pctxt),
pctxt->buffer.size + 1, " \r\n\t\0", 5);
while (pToken != 0) {
int i;
for (i = 0; pBitDict[i].name != 0; i++) {
if (xerCmpText (pToken, pBitDict[i].name)) {
rtxSetBit (data, bufsize * 8, pBitDict[i].bitnum);
break;
}
}
pToken = rtxTokGetNext (&tokCtxt);
}
}
else
return LOG_RTERR (pctxt, RTERR_NOMEM);
return 0;
}
int xerDecReal (OSCTXT* pctxt, OSREAL* pvalue)
{
XMLCHAR* inpdata = (XMLCHAR*) ASN1BUFPTR (pctxt);
OSBOOL minus = FALSE;
OSREAL frac = 0.1, result = 0.0;
/* Consume leading white space */
for (; *inpdata != 0 && OS_ISSPACE (*inpdata); *inpdata++)
;
/* Check for special values - PLUS-INFINITY and MINUS-INFINITY */
if (xerCmpText (inpdata, "PLUS-INFINITY")) {
*pvalue = rtxGetPlusInfinity ();
return 0;
}
else if (xerCmpText (inpdata, "MINUS-INFINITY")) {
*pvalue = rtxGetMinusInfinity ();
return 0;
}
if (*inpdata == 0)
return LOG_RTERR (pctxt, RTERR_INVREAL);
/* Check for '-' first character */
if (*inpdata == '-') {
minus = TRUE; inpdata++;
if (*inpdata == 0)
return LOG_RTERR (pctxt, RTERR_INVREAL);
}
/* Convert integer part */
for ( ; *inpdata != 0 && *inpdata != '.'; inpdata++ ) {
if (OS_ISDIGIT (*inpdata))
result = (result * 10) + (*inpdata - '0');
else
return LOG_RTERR (pctxt, RTERR_INVREAL);
}
/* Convert fractional part */
if (*inpdata == '.') {
for (inpdata++ ; *inpdata != 0 &&
*inpdata != 'E' && *inpdata != 'e'; inpdata++, frac *= 0.1)
{
if (OS_ISDIGIT (*inpdata))
result += (*inpdata - '0') * frac;
else
return LOG_RTERR (pctxt, RTERR_INVREAL);
}
}
/* Convert exponent */
if (*inpdata == 'E' || *inpdata == 'e') {
/* To be clear, only 'E' should be accepted in XER,
but who knows?.. (AB) */
int sign, exp = 0;
inpdata++;
if (*inpdata == '+')
sign = 1;
else if (*inpdata == '-')
sign = -1;
else
return LOG_RTERR (pctxt, RTERR_INVREAL);
inpdata++;
if (*inpdata == 0)
return LOG_RTERR (pctxt, RTERR_INVREAL);
for ( ; *inpdata != 0; inpdata++ ) {
if (OS_ISDIGIT (*inpdata))
exp = (exp * 10) + (*inpdata - '0');
else
return LOG_RTERR (pctxt, RTERR_INVREAL);
}
result *= pow ((OSREAL)10.0, exp * sign);
}
/* If negative, negate number */
if (minus) result = 0 - result;
*pvalue = result;
return (0);
}
/*
* Starts parsing. The XML data being parsed should be set either set as
* a buffer in OSCTXT (pctxt->buffer) or read from its stream (pctxt->pStream).
*/
int rtSaxCParse (OSXMLREADER* pReader)
{
long len;
enum XML_Status stat = XML_STATUS_OK;
struct OSRTSTREAM* pStream;
XMLReaderImpl* readerImpl = (XMLReaderImpl*)(void*)pReader;
OSCTXT* pctxt;
OSSAXHandlerBase* pSaxBase;
if (pReader == 0 || pReader->pctxt == 0 || readerImpl->parser == 0)
return RTERR_NOTINIT;
pctxt = pReader->pctxt;
pStream = pctxt->pStream;
rtxErrReset (pctxt);
pSaxBase = (OSSAXHandlerBase*)readerImpl->userData;
if (pStream == 0) {
/* stream is not set - parse just a buffer */
stat = XML_Parse (readerImpl->parser, (char*)OSRTBUFPTR(pctxt),
(int)pctxt->buffer.size, TRUE);
return (stat == XML_STATUS_ERROR) ? RTERR_XMLPARSE : 0;
}
else { /* read from stream and parse */
do {
void* pbuf;
XML_Bool isFinal;
/* get the buffer to read in */
pbuf = XML_GetBuffer (readerImpl->parser, XML_BUF_SIZE);
/* read data to the buffer */
len = rtxStreamRead (pctxt, (OSOCTET*)pbuf, XML_BUF_SIZE);
if (len < 0)
break;
isFinal = (XML_Bool)(!len);
/* parse the data in the buffer */
if ((stat = XML_ParseBuffer (readerImpl->parser, len, isFinal)) == 0)
break;
/* the following code is necessary only if it is necessary to
* decode several XML documents consequently from one stream. */
if (pSaxBase->mState == OS_SAX_FINAL_STATE) {
/* if parsing is finished, but buffer is not empty we need
* to find the beginning of the next XML message and set
* this piece of data as pre-read buffer for BufferedStream.*/
XML_ParsingStatus status;
XML_GetParsingStatus(readerImpl->parser, &status);
if (status.parsing == XML_SUSPENDED) {
int offset, lenn;
/* Get buffer pointer, offset and length of remaining data.
Note, that patching of Expat is necessary to fix two problems:
1) even if parser is stopped by XML_StopParser, it will return
error "junk after end-of-document" if buffer is not empty;
2) XML_GetInputContext worked only if macro XML_CONTEXT_BYTES
was defined. But it could work even without it. */
const char * _pbuf =
XML_GetInputContext(readerImpl->parser, &offset, &lenn);
if (offset > 0 && lenn - offset > 0) {
int stat = 0;
const OSUTF8CHAR* prereadBuf = (const OSUTF8CHAR*)_pbuf + offset;
size_t prereadBufLen = (size_t)(lenn - offset), i;
/* check, is the buffer just whitespaces or not. If yes,
discard it */
for (i = 0; i < prereadBufLen; i++) {
if (!OS_ISSPACE (prereadBuf[i])) {
if (OSRTSTREAM_ID (pctxt) != OSRTSTRMID_DIRECTBUF) {
stat = rtxStreamBufferedCreate (pctxt,
OSRTSTRMCM_RESTORE_UNDERLAYING_AFTER_RESET);
if (stat < 0) len = stat;
}
if (stat == 0) {
stat = rtxStreamBufferedSetPreReadBuf (pctxt,
(const OSOCTET*)prereadBuf + i, prereadBufLen - i);
if (stat < 0) len = stat;
}
break;
}
}
}
stat = XML_STATUS_OK;
}
break;
}
} while (len > 0);
}
if (len < 0) {
return LOG_RTERR (pctxt, len);
}
else if (stat != XML_STATUS_OK) {
XML_LChar str[256];
len = RTERR_XMLPARSE;
EXML_ErrorString (readerImpl->parser,
XML_GetErrorCode (readerImpl->parser), str,
sizeof(str)/sizeof(str[0]));
LOG_RTERRNEW (pctxt, len);
rtxErrAddStrParm (pctxt, LSTRX (pctxt, str));
return len;
}
return 0;
}
/**
* utilIECStrToLong
*
* Converts an IEC string to a long value.
*
* @return Long value of string or 0 if conversion failed.
*/
IEC_UINT utilIECStrToLong(IEC_STRING OS_LPTR *inStr, IEC_UINT bUnsigned, IEC_CHAR *szBuffer, IEC_DINT *lpValue)
{
IEC_BOOL bNeg = FALSE;
IEC_CHAR *pStopChar;
IEC_UINT i;
IEC_INT base = 10;
IEC_INT iOffs = 0;
*lpValue = 0;
/* Strip leading white space
*/
for(i = 0; i < inStr->CurLen && OS_ISSPACE(inStr->Contents[i]); i++)
;
if (i == inStr->CurLen)
{
RETURN(ERR_ERROR);
}
/* Get a possible sign or radix prefix
*/
if (i < inStr->CurLen && inStr->Contents[i] == '-')
{
bNeg = TRUE;
i++;
}
else if (i < inStr->CurLen && inStr->Contents[i] == '+')
{
bNeg = FALSE;
i++;
}
else if (i + 1 < inStr->CurLen && inStr->Contents[i + 1] == '#')
{
if (inStr->Contents[i] == '2')
{
base = 2;
i += 2;
}
else if (inStr->Contents[i] == '8')
{
base = 8;
i += 2;
}
else
{
RETURN(ERR_ERROR);
}
}
else if (i + 2 < inStr->CurLen && inStr->Contents[i + 2] == '#')
{
if (inStr->Contents[i] == '1' && inStr->Contents[i + 1] == '6')
{
base = 16;
i += 3;
}
else
{
RETURN(ERR_ERROR);
}
}
if (i >= inStr->CurLen)
{
RETURN(ERR_ERROR);
}
/* Skip leading zero's
*/
for( ; i < inStr->CurLen && inStr->Contents[i] == '0'; i++)
;
if (i >= inStr->CurLen)
{
/* We have a zero
*/
RETURN(OK);
}
if (inStr->Contents[i] == 'x' || inStr->Contents[i] == 'X')
{
/* x will advice strtol to convert to a hexadecimal number
*/
RETURN(ERR_ERROR);
}
if (bNeg)
{
szBuffer[0] = '-';
iOffs = 1;
}
OS_MEMCPY(szBuffer + iOffs, inStr->Contents + i, inStr->CurLen - i);
szBuffer[inStr->CurLen - i + iOffs] = 0;
if (bUnsigned)
{
*lpValue = OS_STRTOUL(szBuffer, &pStopChar, base);
}
else
{
*lpValue = OS_STRTOL(szBuffer, &pStopChar, base);
}
if (*lpValue == 0)
{
/* We must not have a zero at this point, because the zero
* is handled above.
*/
RETURN(ERR_ERROR);
}
RETURN(OK);
}
