/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* $Id$
*/
#include <limits.h>
#include <errno.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#include <float.h>
#include <xercesc/framework/psvi/XSValue.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/XMLStringTokenizer.hpp>
#include <xercesc/util/XMLBigDecimal.hpp>
#include <xercesc/util/XMLBigInteger.hpp>
#include <xercesc/util/XMLFloat.hpp>
#include <xercesc/util/XMLDouble.hpp>
#include <xercesc/util/XMLDateTime.hpp>
#include <xercesc/util/HexBin.hpp>
#include <xercesc/util/Base64.hpp>
#include <xercesc/util/XMLUri.hpp>
#include <xercesc/util/XMLChar.hpp>
#include <xercesc/util/Janitor.hpp>
#include <xercesc/util/XMLInitializer.hpp>
#include <xercesc/util/regx/RegularExpression.hpp>
#include <xercesc/validators/schema/SchemaSymbols.hpp>
#include <xercesc/util/OutOfMemoryException.hpp>
#include <xercesc/util/TransService.hpp>
#include <xercesc/util/NumberFormatException.hpp>
XERCES_CPP_NAMESPACE_BEGIN
/*** issues
*
* 1. For float, double, datetime family, the validation is almost similar to getActualValue
*
*
* DataType DataGroup
* num dtm str validation canonical actual-value
* ======================================================================================================
* dt_string str [2] Char NA content
* dt_boolean str {true, false, 1, 0} {true, false} bool
* dt_decimal num lexical only yes double
* dt_float num lexical/value yes double
* dt_double num lexical/value yes double
* ---------------------------------------------------------------------------------------------------------
* 5 dt_duration dtm yes NA struct datetime
* dt_dateTime dtm yes yes struct datetime
* dt_time dtm yes yes struct datetime
* dt_date dtm yes NA struct datetime
* dt_gYearMonth dtm yes NA struct datetime
* ---------------------------------------------------------------------------------------------------------
* 10 dt_gYear dtm yes NA struct datetime
* dt_gMonthDay dtm yes NA struct datetime
* dt_gDay dtm yes NA struct datetime
* dt_gMonth dtm yes NA struct datetime
* dt_hexBinary str decoding ([a-f]) unsigned long ?
* ---------------------------------------------------------------------------------------------------------
* 15 dt_base64Binary str decoding NA (errata?) unsigned long ?
* dt_anyURI str yes NA content
* dt_QName str a:b , [6]QName NA content
* dt_NOTATION str [6]QName NA content
* dt_normalizedString str no #xD #xA #x9 NA content
* ---------------------------------------------------------------------------------------------------------
* 20 dt_token str no #xD #xA #x9 traling NA content
* dt_language str language id NA content
* dt_NMTOKEN str [7] Nmtoken NA content
* dt_NMTOKENS str [8] Nmtokens NA content
* dt_Name str [5] Name NA content
* ---------------------------------------------------------------------------------------------------------
* 25 dt_NCName str [4] NCName NA content
* dt_ID str [4] NCName NA content
* dt_IDREF str [4] NCName NA content
* dt_IDREFS str ws seped IDREF NA content
* dt_ENTITY str [4] NCName NA content
* ---------------------------------------------------------------------------------------------------------
* 30 dt_ENTITIES str ws seped ENTITY NA content
* dt_integer num lexical yes long
* dt_nonPositiveInteger num lexical yes long
* dt_negativeInteger num lexical yes long
* dt_long num lexical yes long
* ---------------------------------------------------------------------------------------------------------
* 35 dt_int num lexical yes int
* dt_short num lexical yes short
* dt_byte num lexical yes char
* dt_nonNegativeInteger num lexical yes unsigned long
* dt_unsignedLong num lexical yes unsigned long
* ---------------------------------------------------------------------------------------------------------
* 40 dt_unsignedInt num lexical yes unsigned int
* dt_unsignedShort num lexical yes unsigned short
* dt_unsignedByte num lexical yes unsigned char
* dt_positiveInteger num lexical yes unsigned long
*
***/
const XSValue::DataGroup XSValue::inGroup[XSValue::dt_MAXCOUNT] =
{
dg_strings, dg_strings, dg_numerics, dg_numerics, dg_numerics,
dg_datetimes, dg_datetimes, dg_datetimes, dg_datetimes, dg_datetimes,
dg_datetimes, dg_datetimes, dg_datetimes, dg_datetimes, dg_strings,
dg_strings, dg_strings, dg_strings, dg_strings, dg_strings,
dg_strings, dg_strings, dg_strings, dg_strings, dg_strings,
dg_strings, dg_strings, dg_strings, dg_strings, dg_strings,
dg_strings, dg_numerics, dg_numerics, dg_numerics, dg_numerics,
dg_numerics, dg_numerics, dg_numerics, dg_numerics, dg_numerics,
dg_numerics, dg_numerics, dg_numerics, dg_numerics
};
const bool XSValue::numericSign[XSValue::dt_MAXCOUNT] =
{
true, true, true, true, true,
true, true, true, true, true,
true, true, true, true, true,
true, true, true, true, true,
true, true, true, true, true,
true, true, true, true, true,
true, true, true, true, true,
true, true, true, false, false,
false, false, false, false
};
// ---------------------------------------------------------------------------
// Local static functions
// ---------------------------------------------------------------------------
static RegularExpression* sXSValueRegEx = 0;
ValueHashTableOf<XSValue::DataType>* XSValue::fDataTypeRegistry = 0;
void XMLInitializer::initializeXSValue()
{
sXSValueRegEx = new RegularExpression(
XMLUni::fgLangPattern, SchemaSymbols::fgRegEx_XOption);
XSValue::initializeRegistry();
}
void XMLInitializer::terminateXSValue()
{
delete XSValue::fDataTypeRegistry;
XSValue::fDataTypeRegistry = 0;
delete sXSValueRegEx;
sXSValueRegEx = 0;
}
XSValue::DataType XSValue::getDataType(const XMLCh* const dtString)
{
if (fDataTypeRegistry->containsKey(dtString)) {
return fDataTypeRegistry->get(dtString);
}
return dt_MAXCOUNT;
}
void XSValue::initializeRegistry()
{
//using the XMLPlatformUtils::fgMemoryManager
fDataTypeRegistry = new ValueHashTableOf<XSValue::DataType>(43);
if (fDataTypeRegistry) {
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_STRING, XSValue::dt_string);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_BOOLEAN, XSValue::dt_boolean);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_DECIMAL, XSValue::dt_decimal);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_FLOAT, XSValue::dt_float);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_DOUBLE, XSValue::dt_double);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_DURATION, XSValue::dt_duration);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_DATETIME, XSValue::dt_dateTime);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_TIME, XSValue::dt_time);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_DATE, XSValue::dt_date);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_YEARMONTH, XSValue::dt_gYearMonth);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_YEAR, XSValue::dt_gYear);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_MONTHDAY, XSValue::dt_gMonthDay);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_DAY, XSValue::dt_gDay);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_MONTH, XSValue::dt_gMonth);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_HEXBINARY, XSValue::dt_hexBinary);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_BASE64BINARY, XSValue::dt_base64Binary);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_ANYURI, XSValue::dt_anyURI);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_QNAME, XSValue::dt_QName);
fDataTypeRegistry->put((void*) XMLUni::fgNotationString, XSValue::dt_NOTATION);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_NORMALIZEDSTRING, XSValue::dt_normalizedString);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_TOKEN, XSValue::dt_token);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_LANGUAGE, XSValue::dt_language);
fDataTypeRegistry->put((void*) XMLUni::fgNmTokenString, XSValue::dt_NMTOKEN);
fDataTypeRegistry->put((void*) XMLUni::fgNmTokensString, XSValue::dt_NMTOKENS);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_NAME, XSValue::dt_Name);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_NCNAME, XSValue::dt_NCName);
fDataTypeRegistry->put((void*) XMLUni::fgIDString, XSValue::dt_ID);
fDataTypeRegistry->put((void*) XMLUni::fgIDRefString, XSValue::dt_IDREF);
fDataTypeRegistry->put((void*) XMLUni::fgIDRefsString, XSValue::dt_IDREFS);
fDataTypeRegistry->put((void*) XMLUni::fgEntityString, XSValue::dt_ENTITY);
fDataTypeRegistry->put((void*) XMLUni::fgEntitiesString, XSValue::dt_ENTITIES);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_INTEGER, XSValue::dt_integer);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_NONPOSITIVEINTEGER, XSValue::dt_nonPositiveInteger);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_NEGATIVEINTEGER, XSValue::dt_negativeInteger);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_LONG, XSValue::dt_long);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_INT, XSValue::dt_int);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_SHORT, XSValue::dt_short);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_BYTE, XSValue::dt_byte);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_NONNEGATIVEINTEGER, XSValue::dt_nonNegativeInteger);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_ULONG, XSValue::dt_unsignedLong);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_UINT, XSValue::dt_unsignedInt);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_USHORT, XSValue::dt_unsignedShort);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_UBYTE, XSValue::dt_unsignedByte);
fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_POSITIVEINTEGER, XSValue::dt_positiveInteger);
}
}
static bool checkTimeZoneError(XSValue::DataType const &datatype
, SchemaDateTimeException const &e )
{
return (((datatype == XSValue::dt_dateTime) || (datatype == XSValue::dt_time) || (datatype == XSValue::dt_date)) &&
((e.getCode() == XMLExcepts::DateTime_tz_noUTCsign) ||
(e.getCode() == XMLExcepts::DateTime_tz_stuffAfterZ) ||
(e.getCode() == XMLExcepts::DateTime_tz_invalid) ||
(e.getCode() == XMLExcepts::DateTime_tz_hh_invalid)));
}
// ---------------------------------------------------------------------------
// Local Data
// ---------------------------------------------------------------------------
static const XMLCh Separator_20[] = {chSpace, chNull};
static const XMLCh Separator_ws[] = {chSpace, chLF, chCR, chHTab, chNull};
// ---------------------------------------------------------------------------
// XSValue: Constructors and Destructor
// ---------------------------------------------------------------------------
XSValue::XSValue(DataType const dt
, MemoryManager* const manager)
:fMemAllocated(false)
,fMemoryManager(manager)
{
fData.f_datatype = dt;
}
XSValue::~XSValue()
{
if (fMemAllocated)
fMemoryManager->deallocate(fData.fValue.f_byteVal);
}
// ---------------------------------------------------------------------------
// XSValue: Public Interface
//
// No exception is thrown from these methods
//
// ---------------------------------------------------------------------------
bool XSValue::validate(const XMLCh* const content
, DataType datatype
, Status& status
, XMLVersion version
, MemoryManager* const manager)
{
if (!content ||
!*content ||
((version == ver_10) && (XMLChar1_0::isAllSpaces(content, XMLString::stringLen(content)))) ||
((version == ver_11) && (XMLChar1_1::isAllSpaces(content, XMLString::stringLen(content)))) ) {
switch (datatype) {
case XSValue::dt_string:
case XSValue::dt_normalizedString:
case XSValue::dt_token:
case XSValue::dt_anyURI:
case XSValue::dt_hexBinary:
case XSValue::dt_base64Binary:
status = st_Init;
return true;
break;
default:
status = st_NoContent;
return false;
break;
}
}
status = st_Init;
switch (inGroup[datatype]) {
case XSValue::dg_numerics:
return validateNumerics(content, datatype, status, manager);
break;
case XSValue::dg_datetimes:
return validateDateTimes(content, datatype, status, manager);
break;
case XSValue::dg_strings:
return validateStrings(content, datatype, status, version, manager);
break;
default:
status = st_UnknownType;
return false;
break;
}
return false;
}
XMLCh*
XSValue::getCanonicalRepresentation(const XMLCh* const content
, DataType datatype
, Status& status
, XMLVersion version
, bool toValidate
, MemoryManager* const manager)
{
if (!content ||
!*content ||
((version == ver_10) && (XMLChar1_0::isAllSpaces(content, XMLString::stringLen(content)))) ||
((version == ver_11) && (XMLChar1_1::isAllSpaces(content, XMLString::stringLen(content)))) ) {
status = st_NoContent;
return 0;
}
status = st_Init;
switch (inGroup[datatype]) {
case XSValue::dg_numerics:
return getCanRepNumerics(content, datatype, status, toValidate, manager);
break;
case XSValue::dg_datetimes:
return getCanRepDateTimes(content, datatype, status, toValidate, manager);
break;
case XSValue::dg_strings:
return getCanRepStrings(content, datatype, status, version, toValidate, manager);
break;
default:
status = st_UnknownType;
return 0;
break;
}
return 0;
}
XSValue* XSValue::getActualValue(const XMLCh* const content
, DataType datatype
, Status& status
, XMLVersion version
, bool toValidate
, MemoryManager* const manager)
{
if (!content ||
!*content ||
((version == ver_10) && (XMLChar1_0::isAllSpaces(content, XMLString::stringLen(content)))) ||
((version == ver_11) && (XMLChar1_1::isAllSpaces(content, XMLString::stringLen(content)))) ) {
status = st_NoContent;
return 0;
}
status = st_Init;
switch (inGroup[datatype]) {
case XSValue::dg_numerics:
return getActValNumerics(content, datatype, status, toValidate, manager);
break;
case XSValue::dg_datetimes:
return getActValDateTimes(content, datatype, status, manager);
break;
case XSValue::dg_strings:
return getActValStrings(content, datatype, status, version, toValidate, manager);
break;
default:
status = st_UnknownType;
return 0;
break;
}
return 0;
}
// ---------------------------------------------------------------------------
// XSValue: Helpers
// ---------------------------------------------------------------------------
/***
*
* Boundary checking is done against Schema Type's lexcial space
***/
bool
XSValue::validateNumerics(const XMLCh* const content
, DataType datatype
, Status& status
, MemoryManager* const manager)
{
try {
switch (datatype) {
case XSValue::dt_decimal:
XMLBigDecimal::parseDecimal(content, manager);
break;
case XSValue::dt_float:
{
//XMLFloat takes care of 0, -0, -INF, INF and NaN
//XMLFloat::checkBoundary() handles error and outofbound issues
XMLFloat data(content, manager);
break;
}
case XSValue::dt_double:
{
//XMLDouble takes care of 0, -0, -INF, INF and NaN
//XMLDouble::checkBoundary() handles error and outofbound issues
XMLDouble data(content, manager);
break;
}
/***
* For all potentially unrepresentable types
*
* For dt_long, dt_unsignedLong, doing lexical space
* checking ensures consistent behaviour on 32/64 boxes
*
***/
case XSValue::dt_integer:
case XSValue::dt_negativeInteger:
case XSValue::dt_nonPositiveInteger:
case XSValue::dt_nonNegativeInteger:
case XSValue::dt_positiveInteger:
case XSValue::dt_long:
case XSValue::dt_unsignedLong:
{
XMLCh* compareData = (XMLCh*) manager->allocate((XMLString::stringLen(content) + 1) * sizeof(XMLCh));
ArrayJanitor<XMLCh> janName(compareData, manager);
int signValue = 0;
XMLBigInteger::parseBigInteger(content, compareData, signValue, manager);
switch (datatype) {
case XSValue::dt_integer:
//error: no
break;
case XSValue::dt_negativeInteger:
// error: > -1
if (XMLBigInteger::compareValues(compareData
, signValue
, &(XMLUni::fgNegOne[1])
, -1
, manager)
== XMLNumber::GREATER_THAN)
{
status = st_FOCA0002;
return false;
}
break;
case XSValue::dt_nonPositiveInteger:
// error: > 0
if (XMLBigInteger::compareValues(compareData
, signValue
, XMLUni::fgValueZero
, 0
, manager)
== XMLNumber::GREATER_THAN)
{
status = st_FOCA0002;
return false;
}
break;
case XSValue::dt_nonNegativeInteger:
// error: < 0
if (XMLBigInteger::compareValues(compareData
, signValue
, XMLUni::fgValueZero
, 0
, manager)
== XMLNumber::LESS_THAN)
{
status = st_FOCA0002;
return false;
}
break;
case XSValue::dt_positiveInteger:
// error: < 1
if (XMLBigInteger::compareValues(compareData
, signValue
, XMLUni::fgValueOne
, 1
, manager)
== XMLNumber::LESS_THAN)
{
status = st_FOCA0002;
return false;
}
break;
case XSValue::dt_long:
// error: < -9223372036854775808 || > 9223372036854775807
if ((XMLBigInteger::compareValues(compareData
, signValue
, &(XMLUni::fgLongMinInc[1])
, -1
, manager)
== XMLNumber::LESS_THAN) ||
(XMLBigInteger::compareValues(compareData
, signValue
, XMLUni::fgLongMaxInc
, 1
, manager)
== XMLNumber::GREATER_THAN))
{
status = st_FOCA0002;
return false;
}
break;
case XSValue::dt_unsignedLong:
// error: < 0 || > 18446744073709551615
if ((XMLBigInteger::compareValues(compareData
, signValue
, XMLUni::fgValueZero
, 0
, manager)
== XMLNumber::LESS_THAN) ||
(XMLBigInteger::compareValues(compareData
, signValue
, XMLUni::fgULongMaxInc
, 1
, manager)
== XMLNumber::GREATER_THAN))
{
status = st_FOCA0002;
return false;
}
break;
default:
status = st_NotSupported;
return false;
break;
}
break;
}
case XSValue::dt_int:
case XSValue::dt_short:
case XSValue::dt_byte:
case XSValue::dt_unsignedInt:
case XSValue::dt_unsignedShort:
case XSValue::dt_unsignedByte:
{
t_value actVal;
if ( !getActualNumericValue(
content
, status
, actVal
, manager
, datatype
)
)
{
return false;
}
break;
}
default:
return false;
} // end switch
}
catch (const NumberFormatException&)
{
//getActValue()/getCanonical() need to know the failure details
//if validation is required
status = st_FOCA0002;
return false;
}
return true; //both valid chars and within boundary
}
bool XSValue::validateDateTimes(const XMLCh* const input_content
, DataType datatype
, Status& status
, MemoryManager* const manager)
{
XMLCh* content = XMLString::replicate(input_content, manager);
ArrayJanitor<XMLCh> janTmpName(content, manager);
XMLString::trim(content);
try
{
XMLDateTime coreDate = XMLDateTime(content, manager);
switch (datatype) {
case XSValue::dt_duration:
coreDate.parseDuration();
break;
case XSValue::dt_dateTime:
coreDate.parseDateTime();
break;
case XSValue::dt_time:
coreDate.parseTime();
break;
case XSValue::dt_date:
coreDate.parseDate();
break;
case XSValue::dt_gYearMonth:
coreDate.parseYearMonth();
break;
case XSValue::dt_gYear:
coreDate.parseYear();
break;
case XSValue::dt_gMonthDay:
coreDate.parseMonthDay();
break;
case XSValue::dt_gDay:
coreDate.parseDay();
break;
case XSValue::dt_gMonth:
coreDate.parseMonth();
break;
default:
return false;
break;
}
}
catch (const SchemaDateTimeException &e)
{
status = checkTimeZoneError(datatype, e)? XSValue::st_FODT0003 : st_FOCA0002;
return false;
}
catch (const NumberFormatException&)
{
//getActValue()/getCanonical() need to know the failure details
//if validation is required
status = st_FOCA0002;
return false;
}
return true; //parsing succeed
}
bool XSValue::validateStrings(const XMLCh* const content
, DataType datatype
, Status& status
, XMLVersion version
, MemoryManager* const manager)
{
bool isValid = true;
switch (datatype) {
case XSValue::dt_boolean:
{
XMLSize_t i = 0;
XMLCh* tmpStrValue = XMLString::replicate(content, manager);
ArrayJanitor<XMLCh> janTmpName(tmpStrValue, manager);
XMLString::trim(tmpStrValue);
for (; i < XMLUni::fgBooleanValueSpaceArraySize; i++) {
if (XMLString::equals(tmpStrValue, XMLUni::fgBooleanValueSpace[i]))
break;
}
if (XMLUni::fgBooleanValueSpaceArraySize == i) {
isValid = false;
}
break;
}
case XSValue::dt_hexBinary:
{
XMLCh* tmpStrValue = XMLString::replicate(content, manager);
ArrayJanitor<XMLCh> janTmpName(tmpStrValue, manager);
XMLString::trim(tmpStrValue);
if (HexBin::getDataLength(tmpStrValue) == -1) {
isValid = false;
}
}
break;
case XSValue::dt_base64Binary:
if (Base64::getDataLength(content, manager) == -1) {
isValid = false;
}
break;
case XSValue::dt_anyURI:
if (XMLUri::isValidURI(true, content, true) == false) {
isValid = false;
}
break;
case XSValue::dt_QName:
{
XMLCh* tmpStrValue = XMLString::replicate(content, manager);
ArrayJanitor<XMLCh> janTmpName(tmpStrValue, manager);
XMLString::trim(tmpStrValue);
isValid = (version == ver_10) ?
XMLChar1_0::isValidQName(tmpStrValue, XMLString::stringLen(tmpStrValue)) :
XMLChar1_1::isValidQName(tmpStrValue, XMLString::stringLen(tmpStrValue));
}
break;
case XSValue::dt_NOTATION:
{
XMLCh* tmpStrValue = XMLString::replicate(content, manager);
ArrayJanitor<XMLCh> janTmpName(tmpStrValue, manager);
XMLString::trim(tmpStrValue);
if ( XMLString::isValidNOTATION(tmpStrValue, manager) == false) {
isValid = false;
}
}
break;
case XSValue::dt_string:
{
const XMLCh* rawPtr = content;
if (version == ver_10) {
while (*rawPtr)
if (!XMLChar1_0::isXMLChar(*rawPtr++)) {
isValid = false;
break;
}
}
else {
while (*rawPtr)
if (!XMLChar1_1::isXMLChar(*rawPtr++)) {
isValid = false;
break;
}
}
break;
}
case XSValue::dt_normalizedString:
{
const XMLCh* rawPtr = content;
if (version == ver_10) {
while (*rawPtr) {
if (!XMLChar1_0::isXMLChar(*rawPtr)) {
isValid = false;
break;
}
else if (*rawPtr == chCR || *rawPtr == chLF || *rawPtr == chHTab) {
isValid = false;
break;
}
else {
rawPtr++;
}
}
}
else {
while (*rawPtr) {
if (!XMLChar1_1::isXMLChar(*rawPtr)) {
isValid = false;
break;
}
else if (*rawPtr == chCR || *rawPtr == chLF || *rawPtr == chHTab) {
isValid = false;
break;
}
else {
rawPtr++;
}
}
}
break;
}
case XSValue::dt_token:
case XSValue::dt_language:
{
XMLSize_t strLen = XMLString::stringLen(content);
const XMLCh* rawPtr = content;
bool inWS = false;
if (version == ver_10) {
// Check leading/Trailing white space
if (XMLChar1_0::isWhitespace(content[0]) ||
XMLChar1_0::isWhitespace(content[strLen - 1]) ) {
isValid = false;
}
else {
while (*rawPtr) {
if (!XMLChar1_0::isXMLChar(*rawPtr)) {
isValid = false;
break;
}
else if (*rawPtr == chCR || *rawPtr == chLF || *rawPtr == chHTab) {
isValid = false;
break;
}
else if (XMLChar1_0::isWhitespace(*rawPtr)) {
if (inWS) {
isValid = false;
break;
}
else {
inWS = true;
}
}
else {
inWS = false;
}
rawPtr++;
}
}
}
else {
// Check leading/Trailing white space
if (XMLChar1_1::isWhitespace(content[0]) ||
XMLChar1_1::isWhitespace(content[strLen - 1]) ) {
isValid = false;
}
else {
while (*rawPtr) {
if (!XMLChar1_1::isXMLChar(*rawPtr)) {
isValid = false;
break;
}
else if (*rawPtr == chCR || *rawPtr == chLF || *rawPtr == chHTab) {
isValid = false;
break;
}
else if (XMLChar1_1::isWhitespace(*rawPtr)) {
if (inWS) {
isValid = false;
break;
}
else {
inWS = true;
}
}
else {
inWS = false;
}
rawPtr++;
}
}
}
if (isValid == true && datatype == XSValue::dt_language) {
if (!sXSValueRegEx) {
status = st_CantCreateRegEx;
isValid = false;
}
else
{
if (sXSValueRegEx->matches(content, manager) == false)
{
isValid = false;
}
}
}
break;
}
case XSValue::dt_NMTOKEN:
isValid = (version == ver_10) ?
XMLChar1_0::isValidNmtoken(content, XMLString::stringLen(content)) :
XMLChar1_1::isValidNmtoken(content, XMLString::stringLen(content));
break;
case XSValue::dt_NMTOKENS:
// [8] Nmtokens ::= Nmtoken (#x20 Nmtoken)*
{
XMLStringTokenizer tokenizer(content, Separator_20, manager);
if (version == ver_10) {
while (tokenizer.hasMoreTokens()) {
const XMLCh* token = tokenizer.nextToken();
if (!XMLChar1_0::isValidNmtoken(token, XMLString::stringLen(token))) {
isValid = false;
break;
}
}
}
else {
while (tokenizer.hasMoreTokens()) {
const XMLCh* token = tokenizer.nextToken();
if (!XMLChar1_1::isValidNmtoken(token, XMLString::stringLen(token))) {
isValid = false;
break;
}
}
}
break;
}
case XSValue::dt_Name:
isValid = (version == ver_10) ?
XMLChar1_0::isValidName(content) :
XMLChar1_1::isValidName(content);
break;
case XSValue::dt_NCName:
case XSValue::dt_ID:
case XSValue::dt_IDREF:
case XSValue::dt_ENTITY:
isValid = (version == ver_10) ?
XMLChar1_0::isValidNCName(content, XMLString::stringLen(content)) :
XMLChar1_1::isValidNCName(content, XMLString::stringLen(content));
break;
case XSValue::dt_ENTITIES:
case XSValue::dt_IDREFS:
{
XMLStringTokenizer tokenizer(content, Separator_ws, manager);
if (version == ver_10 ) {
while (tokenizer.hasMoreTokens()) {
const XMLCh* token = tokenizer.nextToken();
if (!XMLChar1_0::isValidNCName(token, XMLString::stringLen(token))) {
isValid = false;
break;
}
}
}
else {
while (tokenizer.hasMoreTokens()) {
const XMLCh* token = tokenizer.nextToken();
if (!XMLChar1_1::isValidNCName(token, XMLString::stringLen(token))) {
isValid = false;
break;
}
}
}
}
break;
default:
status = st_NotSupported;
isValid = false;
break;
}
if (isValid == false && status == st_Init) {
status = st_FOCA0002;
}
return isValid;
}
XMLCh* XSValue::getCanRepNumerics(const XMLCh* const content
, DataType datatype
, Status& status
, bool toValidate
, MemoryManager* const manager)
{
try
{
// getCanonicalRepresentation does lexical space validation only
// (no range checking), therefore if validation is required,
// we need to pass the content to the validate interface for complete checking
if (toValidate && !validateNumerics(content, datatype, status, manager))
return 0;
XMLCh* retVal = 0;
if (datatype == XSValue::dt_decimal)
{
retVal = XMLBigDecimal::getCanonicalRepresentation(content, manager);
if (!retVal)
status = st_FOCA0002;
return retVal;
}
else if (datatype == XSValue::dt_float || datatype == XSValue::dt_double )
{
// In XML4C, no float or double is treated as out of range
// it gets converted to INF, -INF or zero.
// The getCanonical method should treat double & float the
// same way as the rest of XML4C for consistentcy so need
// to getActualValue and see if it was converted.
XSValue* xsval = getActValNumerics(content, datatype, status, false, manager);
if (!xsval) {
status = st_FOCA0002;
return retVal;
}
DoubleFloatType enumVal;
if (datatype == XSValue::dt_float) {
enumVal = xsval->fData.fValue.f_floatType.f_floatEnum;
}
else {
enumVal = xsval->fData.fValue.f_doubleType.f_doubleEnum;
}
delete xsval;
switch(enumVal) {
case DoubleFloatType_NegINF:
retVal = XMLString::replicate(XMLUni::fgNegINFString, manager);
break;
case DoubleFloatType_PosINF:
retVal = XMLString::replicate(XMLUni::fgPosINFString, manager);
break;
case DoubleFloatType_NaN:
retVal = XMLString::replicate(XMLUni::fgNaNString, manager);
break;
case DoubleFloatType_Zero:
retVal = XMLString::replicate(XMLUni::fgPosZeroString, manager);
break;
default: //DoubleFloatType_Normal
retVal = XMLAbstractDoubleFloat::getCanonicalRepresentation(content, manager);
if (!retVal)
status = st_FOCA0002;
break;
}
return retVal;
}
else
{
retVal = XMLBigInteger::getCanonicalRepresentation(content, manager, datatype == XSValue::dt_nonPositiveInteger);
if (!retVal)
status = st_FOCA0002;
return retVal;
}
}
catch (const NumberFormatException&)
{
status = st_FOCA0002;
}
return 0;
}
XMLCh* XSValue::getCanRepDateTimes(const XMLCh* const input_content
, DataType datatype
, Status& status
, bool toValidate
, MemoryManager* const manager)
{
XMLCh* content = XMLString::replicate(input_content, manager);
ArrayJanitor<XMLCh> janTmpName(content, manager);
XMLString::trim(content);
try
{
XMLDateTime coreDate = XMLDateTime(content, manager);
switch (datatype) {
case XSValue::dt_dateTime:
//we need this parsing
coreDate.parseDateTime();
return coreDate.getDateTimeCanonicalRepresentation(manager);
break;
case XSValue::dt_time:
// we need this parsing
coreDate.parseTime();
return coreDate.getTimeCanonicalRepresentation(manager);
break;
case XSValue::dt_date:
// we need this parsing
coreDate.parseDate();
return coreDate.getDateCanonicalRepresentation(manager);
break;
case XSValue::dt_duration:
case XSValue::dt_gYearMonth:
case XSValue::dt_gYear:
case XSValue::dt_gMonthDay:
case XSValue::dt_gDay:
case XSValue::dt_gMonth:
{
if (!(toValidate && !validateDateTimes(content, datatype, status, manager)))
status = st_NoCanRep;
return 0;
}
break;
default:
return 0;
break;
}
}
catch (SchemaDateTimeException &e)
{
status = checkTimeZoneError(datatype, e)? XSValue::st_FODT0003 : st_FOCA0002;
}
catch (const NumberFormatException&)
{
status = st_FOCA0002;
}
return 0;
}
XMLCh* XSValue::getCanRepStrings(const XMLCh* const content
, DataType datatype
, Status& status
, XMLVersion version
, bool toValidate
, MemoryManager* const manager)
{
switch (datatype) {
case XSValue::dt_boolean:
{
XMLCh* tmpStrValue = XMLString::replicate(content, manager);
ArrayJanitor<XMLCh> janTmpName(tmpStrValue, manager);
XMLString::trim(tmpStrValue);
//always validate before getting canRep
if (XMLString::equals(tmpStrValue, XMLUni::fgBooleanValueSpace[0]) ||
XMLString::equals(tmpStrValue, XMLUni::fgBooleanValueSpace[2]) )
{
return XMLString::replicate(XMLUni::fgBooleanValueSpace[0], manager);
}
else if (XMLString::equals(tmpStrValue, XMLUni::fgBooleanValueSpace[1]) ||
XMLString::equals(tmpStrValue, XMLUni::fgBooleanValueSpace[3]) )
{
return XMLString::replicate(XMLUni::fgBooleanValueSpace[1], manager);
}
else
{
status = st_FOCA0002;
return 0;
}
}
break;
case XSValue::dt_hexBinary:
{
//HexBin::getCanonicalRepresentation does validation automatically
XMLCh* tmpStrValue = XMLString::replicate(content, manager);
ArrayJanitor<XMLCh> janTmpName(tmpStrValue, manager);
XMLString::trim(tmpStrValue);
XMLCh* canRep = HexBin::getCanonicalRepresentation(tmpStrValue, manager);
if (!canRep)
status = st_FOCA0002;
return canRep;
break;
}
case XSValue::dt_base64Binary:
{
//Base64::getCanonicalRepresentation does validation automatically
XMLCh* canRep = Base64::getCanonicalRepresentation(content, manager);
if (!canRep)
status = st_FOCA0002;
return canRep;
break;
}
case XSValue::dt_anyURI:
case XSValue::dt_QName:
case XSValue::dt_NOTATION:
case XSValue::dt_string:
case XSValue::dt_normalizedString:
case XSValue::dt_token:
case XSValue::dt_language:
case XSValue::dt_NMTOKEN:
case XSValue::dt_NMTOKENS:
case XSValue::dt_Name:
case XSValue::dt_NCName:
case XSValue::dt_ID:
case XSValue::dt_IDREF:
case XSValue::dt_ENTITY:
case XSValue::dt_ENTITIES:
case XSValue::dt_IDREFS:
if (toValidate && !validateStrings(content, datatype, status, version, manager))
status = st_FOCA0002;
else
status = st_NoCanRep;
return 0;
break;
default:
return 0;
break;
}
return 0;
}
XSValue*
XSValue::getActValNumerics(const XMLCh* const content
, DataType datatype
, Status& status
, bool toValidate
, MemoryManager* const manager)
{
try {
switch (datatype) {
case XSValue::dt_decimal:
{
if (toValidate) {
XMLBigDecimal::parseDecimal(content, manager);
}
//Prepare the double value
XMLDouble data(content, manager);
if (data.isDataConverted())
{
status = st_FOCA0001;
return 0;
}
XSValue* retVal = new (manager) XSValue(dt_decimal, manager);
retVal->fData.fValue.f_decimal.f_dvalue = data.getValue();
return retVal;
break;
}
case XSValue::dt_float:
{
//XMLFloat takes care of 0, -0, -INF, INF and NaN
//XMLFloat::checkBoundary() handles error and outofbound issues
XMLFloat data(content, manager);
XSValue* retVal = new (manager) XSValue(dt_float, manager);
if (data.isDataConverted())
{
retVal->fData.fValue.f_floatType.f_float = 0.0;
retVal->fData.fValue.f_floatType.f_floatEnum = DoubleFloatType_Zero;
switch(data.getType()) {
case XMLAbstractDoubleFloat::NegINF:
retVal->fData.fValue.f_floatType.f_floatEnum = DoubleFloatType_NegINF;
break;
case XMLAbstractDoubleFloat::PosINF:
retVal->fData.fValue.f_floatType.f_floatEnum = DoubleFloatType_PosINF;
break;
case XMLAbstractDoubleFloat::NaN:
retVal->fData.fValue.f_floatType.f_floatEnum = DoubleFloatType_NaN;
break;
default:
break;
}
}
else {
retVal->fData.fValue.f_floatType.f_floatEnum = DoubleFloatType_Normal;
retVal->fData.fValue.f_floatType.f_float = (float) data.getValue();
}
return retVal;
break;
}
case XSValue::dt_double:
{
//XMLDouble takes care of 0, -0, -INF, INF and NaN
//XMLDouble::checkBoundary() handles error and outofbound issues
XMLDouble data(content, manager);
XSValue* retVal = new (manager) XSValue(dt_double, manager);
if (data.isDataConverted())
{
retVal->fData.fValue.f_doubleType.f_double = 0.0;
retVal->fData.fValue.f_doubleType.f_doubleEnum = DoubleFloatType_Zero;
switch(data.getType()) {
case XMLAbstractDoubleFloat::NegINF:
retVal->fData.fValue.f_doubleType.f_doubleEnum = DoubleFloatType_NegINF;
break;
case XMLAbstractDoubleFloat::PosINF:
retVal->fData.fValue.f_doubleType.f_doubleEnum = DoubleFloatType_PosINF;
break;
case XMLAbstractDoubleFloat::NaN:
retVal->fData.fValue.f_doubleType.f_doubleEnum = DoubleFloatType_NaN;
break;
default:
break;
}
}
else {
retVal->fData.fValue.f_doubleType.f_doubleEnum = DoubleFloatType_Normal;
retVal->fData.fValue.f_doubleType.f_double = data.getValue();
}
return retVal;
break;
}
case XSValue::dt_integer:
case XSValue::dt_negativeInteger:
case XSValue::dt_nonPositiveInteger:
case XSValue::dt_nonNegativeInteger:
case XSValue::dt_positiveInteger:
case XSValue::dt_long:
case XSValue::dt_int:
case XSValue::dt_short:
case XSValue::dt_byte:
case XSValue::dt_unsignedLong:
case XSValue::dt_unsignedInt:
case XSValue::dt_unsignedShort:
case XSValue::dt_unsignedByte:
{
t_value actVal;
if ( !getActualNumericValue(
content
, status
, actVal
, manager
, datatype
)
)
{
//status has been set by getActualNumericValue
return 0;
}
XSValue* retVal = new (manager) XSValue(datatype, manager);
switch (datatype) {
case XSValue::dt_integer:
retVal->fData.fValue.f_long = actVal.f_long;
break;
case XSValue::dt_negativeInteger:
retVal->fData.fValue.f_long = actVal.f_long;
break;
case XSValue::dt_nonPositiveInteger:
retVal->fData.fValue.f_long = actVal.f_long;
break;
case XSValue::dt_nonNegativeInteger:
retVal->fData.fValue.f_long = actVal.f_ulong;
break;
case XSValue::dt_positiveInteger:
retVal->fData.fValue.f_long = actVal.f_ulong;
break;
case XSValue::dt_long:
retVal->fData.fValue.f_long = actVal.f_long;
break;
case XSValue::dt_int:
retVal->fData.fValue.f_int = (int) actVal.f_long;
break;
case XSValue::dt_short:
retVal->fData.fValue.f_short = (short) actVal.f_long;
break;
case XSValue::dt_byte:
retVal->fData.fValue.f_char = (char) actVal.f_long;
break;
case XSValue::dt_unsignedLong:
retVal->fData.fValue.f_ulong = actVal.f_ulong;
break;
case XSValue::dt_unsignedInt:
retVal->fData.fValue.f_uint = (unsigned int) actVal.f_ulong;
break;
case XSValue::dt_unsignedShort:
retVal->fData.fValue.f_ushort = (unsigned short) actVal.f_ulong;
break;
case XSValue::dt_unsignedByte:
retVal->fData.fValue.f_uchar = (unsigned char) actVal.f_ulong;
break;
default:
return 0;
break;
}
return retVal;
break;
}
default:
return 0;
break;
} // end switch
}
catch (const NumberFormatException&)
{
status = st_FOCA0002;
}
return 0;
}
XSValue*
XSValue::getActValDateTimes(const XMLCh* const input_content
, DataType datatype
, Status& status
, MemoryManager* const manager)
{
XMLCh* content = XMLString::replicate(input_content, manager);
ArrayJanitor<XMLCh> janTmpName(content, manager);
XMLString::trim(content);
try
{
//Need not check if validation is requested since
//parsing functions below does the validation automatically
XMLDateTime coreDate = XMLDateTime(content, manager);
switch (datatype) {
case XSValue::dt_duration:
coreDate.parseDuration();
break;
case XSValue::dt_dateTime:
coreDate.parseDateTime();
break;
case XSValue::dt_time:
coreDate.parseTime();
coreDate.fValue[XMLDateTime::CentYear] = 0;
coreDate.fValue[XMLDateTime::Month] = 0;
coreDate.fValue[XMLDateTime::Day] = 0;
break;
case XSValue::dt_date:
coreDate.parseDate();
coreDate.fValue[XMLDateTime::Hour] = 0;
coreDate.fValue[XMLDateTime::Minute] = 0;
break;
case XSValue::dt_gYearMonth:
coreDate.parseYearMonth();
coreDate.fValue[XMLDateTime::Day] = 0;
coreDate.fValue[XMLDateTime::Hour] = 0;
coreDate.fValue[XMLDateTime::Minute] = 0;
break;
case XSValue::dt_gYear:
coreDate.parseYear();
coreDate.fValue[XMLDateTime::Month] = 0;
coreDate.fValue[XMLDateTime::Day] = 0;
coreDate.fValue[XMLDateTime::Hour] = 0;
coreDate.fValue[XMLDateTime::Minute] = 0;
break;
case XSValue::dt_gMonthDay:
coreDate.parseMonthDay();
coreDate.fValue[XMLDateTime::CentYear] = 0;
coreDate.fValue[XMLDateTime::Hour] = 0;
coreDate.fValue[XMLDateTime::Minute] = 0;
break;
case XSValue::dt_gDay:
coreDate.parseDay();
coreDate.fValue[XMLDateTime::CentYear] = 0;
coreDate.fValue[XMLDateTime::Month] = 0;
coreDate.fValue[XMLDateTime::Hour] = 0;
coreDate.fValue[XMLDateTime::Minute] = 0;
break;
case XSValue::dt_gMonth:
coreDate.parseMonth();
coreDate.fValue[XMLDateTime::CentYear] = 0;
coreDate.fValue[XMLDateTime::Day] = 0;
coreDate.fValue[XMLDateTime::Hour] = 0;
coreDate.fValue[XMLDateTime::Minute] = 0;
break;
default:
return 0;
break;
}
XSValue* retVal = new (manager) XSValue(datatype, manager);
retVal->fData.fValue.f_datetime.f_year = coreDate.fValue[XMLDateTime::CentYear];
retVal->fData.fValue.f_datetime.f_month = coreDate.fValue[XMLDateTime::Month];
retVal->fData.fValue.f_datetime.f_day = coreDate.fValue[XMLDateTime::Day];
retVal->fData.fValue.f_datetime.f_hour = coreDate.fValue[XMLDateTime::Hour];
retVal->fData.fValue.f_datetime.f_min = coreDate.fValue[XMLDateTime::Minute];
retVal->fData.fValue.f_datetime.f_second = coreDate.fValue[XMLDateTime::Second];
retVal->fData.fValue.f_datetime.f_milisec = coreDate.fMilliSecond;
return retVal;
}
catch (SchemaDateTimeException const &e)
{
status = checkTimeZoneError(datatype, e)? XSValue::st_FODT0003 : st_FOCA0002;
}
catch (const NumberFormatException&)
{
status = st_FOCA0002;
}
return 0;
}
XSValue*
XSValue::getActValStrings(const XMLCh* const content
, DataType datatype
, Status& status
, XMLVersion version
, bool toValidate
, MemoryManager* const manager)
{
switch (datatype) {
case XSValue::dt_boolean:
{
XMLCh* tmpStrValue = XMLString::replicate(content, manager);
ArrayJanitor<XMLCh> janTmpName(tmpStrValue, manager);
XMLString::trim(tmpStrValue);
//do validation here more efficiently
if (XMLString::equals(tmpStrValue, XMLUni::fgBooleanValueSpace[0]) ||
XMLString::equals(tmpStrValue, XMLUni::fgBooleanValueSpace[2]) )
{
XSValue* retVal = new (manager) XSValue(dt_boolean, manager);
retVal->fData.fValue.f_bool = false;
return retVal;
}
else if (XMLString::equals(tmpStrValue, XMLUni::fgBooleanValueSpace[1]) ||
XMLString::equals(tmpStrValue, XMLUni::fgBooleanValueSpace[3]) )
{
XSValue* retVal = new (manager) XSValue(dt_boolean, manager);
retVal->fData.fValue.f_bool = true;
return retVal;
}
else
{
status = st_FOCA0002;
return 0;
}
}
break;
case XSValue::dt_hexBinary:
{
XMLCh* tmpStrValue = XMLString::replicate(content, manager);
ArrayJanitor<XMLCh> janTmpName(tmpStrValue, manager);
XMLString::trim(tmpStrValue);
XMLByte* decodedData = HexBin::decodeToXMLByte(tmpStrValue, manager);
if (!decodedData)
{
status = st_FOCA0002;
return 0;
}
XSValue* retVal = new (manager) XSValue(dt_hexBinary, manager);
retVal->fData.fValue.f_byteVal = decodedData;
retVal->fMemAllocated = true;
return retVal;
break;
}
case XSValue::dt_base64Binary:
{
XMLSize_t len = 0;
XMLByte* decodedData = Base64::decodeToXMLByte(content, &len, manager);
if (!decodedData)
{
status = st_FOCA0002;
return 0;
}
XSValue* retVal = new (manager) XSValue(dt_base64Binary, manager);
retVal->fData.fValue.f_byteVal = decodedData;
retVal->fMemAllocated = true;
return retVal;
break;
}
case XSValue::dt_anyURI:
case XSValue::dt_QName:
case XSValue::dt_NOTATION:
case XSValue::dt_string:
case XSValue::dt_normalizedString:
case XSValue::dt_token:
case XSValue::dt_language:
case XSValue::dt_NMTOKEN:
case XSValue::dt_NMTOKENS:
case XSValue::dt_Name:
case XSValue::dt_NCName:
case XSValue::dt_ID:
case XSValue::dt_IDREF:
case XSValue::dt_ENTITY:
case XSValue::dt_ENTITIES:
case XSValue::dt_IDREFS:
if (toValidate && !validateStrings(content, datatype, status, version, manager))
status = st_FOCA0002;
else
status = st_NoActVal;
return 0;
break;
default:
return 0;
break;
}
return 0;
}
// ---------------------------------------------------------------------------
// Utilities
// ---------------------------------------------------------------------------
bool XSValue::getActualNumericValue(const XMLCh* const content
, Status& status
, t_value& retVal
, MemoryManager* const manager
, DataType datatype)
{
char *nptr = XMLString::transcode(content, manager);
ArrayJanitor<char> jan(nptr, manager);
char *endptr = 0;
errno = 0;
if (XSValue::numericSign[datatype])
{
retVal.f_long = strtol(nptr, &endptr, (int)10);
}
else
{
if (XMLString::indexOf(content, chDash) != -1)
{
status = st_FOCA0002; //invalid lexcial value
return false;
}
retVal.f_ulong = strtoul(nptr, &endptr, (int)10);
}
// need to check out-of-bounds before checking erange...
switch (datatype) {
case XSValue::dt_nonPositiveInteger:
if (retVal.f_long > 0)
{
status = st_FOCA0002;
return false;
}
break;
case XSValue::dt_negativeInteger:
if (retVal.f_long >= 0)
{
status = st_FOCA0002;
return false;
}
break;
case XSValue::dt_int:
// strtol will set value to LONG_MIN/LONG_MAX if ERANGE error
if ((retVal.f_long < INT_MIN) ||
(retVal.f_long > INT_MAX) ||
(errno == ERANGE))
{
status = st_FOCA0002;
return false;
}
break;
case XSValue::dt_short:
if ((retVal.f_long < SHRT_MIN) ||
(retVal.f_long > SHRT_MAX))
{
status = st_FOCA0002;
return false;
}
break;
case XSValue::dt_byte:
if ((retVal.f_long < SCHAR_MIN) ||
(retVal.f_long > SCHAR_MAX))
{
status = st_FOCA0002;
return false;
}
break;
case XSValue::dt_unsignedInt:
// strtoul will set value to LONG_INT if ERANGE error
if ((retVal.f_ulong > UINT_MAX) ||
(errno == ERANGE))
{
status = st_FOCA0002;
return false;
}
break;
case XSValue::dt_unsignedShort:
if (retVal.f_ulong > USHRT_MAX)
{
status = st_FOCA0002;
return false;
}
break;
case XSValue::dt_unsignedByte:
if (retVal.f_ulong > UCHAR_MAX)
{
status = st_FOCA0002;
return false;
}
break;
case XSValue::dt_positiveInteger:
if (retVal.f_ulong == 0)
{
status = st_FOCA0002;
return false;
}
break;
default:
break;
} // end switch
// check if overflow/underflow occurs
if (errno == ERANGE)
{
status = st_FOCA0003;
return false;
}
// check if all chars are valid char. If they are, endptr will
// pointer to the null terminator, or all of the remaining
// characters will be whitespace characters.
while (*endptr != '\0')
{
const char ch = *endptr;
if (ch == '\t' || ch == '\n' || ch == '\r' || ch == ' ')
{
++endptr;
}
else
{
status = st_FOCA0002;
return false;
}
}
return true;
}
XERCES_CPP_NAMESPACE_END