xsvalue.cpp

来自「IBM的解析xml的工具Xerces的源代码」· C++ 代码 · 共 1,743 行 · 第 1/5 页

    switch (inGroup[datatype])
    {
    case XSValue::dg_numerics :
        return validateNumerics(content, datatype, status, version, manager);
        break;
    case XSValue::dg_datetimes:
        return validateDateTimes(content, datatype, status, version, manager);
        break;
    case XSValue::dg_strings:
        return validateStrings(content, datatype, status, version, manager);
        break;
    default:
        status = st_UnknownType;
        return false;
        break;
    }
 
}

XMLCh* 
XSValue::getCanonicalRepresentation(const XMLCh*         const content    
                                  ,       DataType             datatype
                                  ,       Status&              status
                                  ,       XMLVersion           version
                                  ,       bool                 toValidate
                                  ,       MemoryManager* const manager)
{
 
    if (!content || !*content)
    {
        status=st_NoContent;
        return 0;
    }
    
    switch (inGroup[datatype])
    {
    case XSValue::dg_numerics :
        return getCanRepNumerics(content, datatype,  status, version, toValidate, manager);
        break;
    case XSValue::dg_datetimes:
        return getCanRepDateTimes(content, datatype,  status, version, toValidate, manager);
        break;
    case XSValue::dg_strings:
        return getCanRepStrings(content, datatype,  status, version, toValidate, manager);
        break;
    default:
        status = st_UnknownType;
        return 0;
        break;
    }

}

XSValue* XSValue::getActualValue(const XMLCh*         const content    
                               ,       DataType             datatype
                               ,       Status&              status
                               ,       XMLVersion           version
                               ,       bool                 toValidate
                               ,       MemoryManager* const manager)
{

    if (!content || !*content)
    {
        status=st_NoContent;
        return 0;
    }


    switch (inGroup[datatype])
    {
    case XSValue::dg_numerics :
        return getActValNumerics(content, datatype,  status, version, manager);
        break;
    case XSValue::dg_datetimes:
        return getActValDateTimes(content, datatype,  status, version, manager);
        break;
    case XSValue::dg_strings:
        return getActValStrings(content, datatype,  status, version, toValidate, manager);
        break;
    default:
        status = st_UnknownType;
        return 0;
        break;
    }
    
}

// ---------------------------------------------------------------------------
//  XSValue: Helpers
// --------------------------------------------------------------------------- 

/***
 *
 *  Boundary checking is done against Schema Type's lexcial space
 ***/
bool 
XSValue::validateNumerics(const XMLCh*         const content    
                        ,       DataType             datatype
                        ,       Status&              status
                        ,       XMLVersion           version
                        ,       MemoryManager* const manager)
{

    try {

        if (datatype == XSValue::dt_decimal)
        {
            XMLBigDecimal::parseDecimal(content, manager); 
            //error: no
        }
        else if (datatype == XSValue::dt_float)
        {
            //XMLFloat takes care of 0, -0, -INF, INF and NaN
            //XMLFloat::checkBoundary() handles error and outofbound issues
            XMLFloat data(content, manager);
            if (data.isDataConverted())
            {
                status = st_InvalidRange;
                return false;
            }
        }
        else if (datatype == XSValue::dt_double)
        {
            //XMLDouble takes care of 0, -0, -INF, INF and NaN
            //XMLDouble::checkBoundary() handles error and outofbound issues
            XMLDouble  data(content, manager);
            if (data.isDataConverted())
            {
                status = st_InvalidRange;
                return false;
            }
        }
        /***
         *   For all potentially unrepresentable types
         *   
         *   For dt_long, dt_unsignedLong, doing lexical space
         *   checking ensures consistent behaviour on 32/64 boxes
         *
         ***/
        else if (datatype == XSValue::dt_integer            ||
                 datatype == XSValue::dt_negativeInteger    ||
                 datatype == XSValue::dt_nonPositiveInteger ||
                 datatype == XSValue::dt_nonNegativeInteger ||
                 datatype == XSValue::dt_positiveInteger    ||
                 datatype == XSValue::dt_long               ||
                 datatype == 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_InvalidRange;
                        return false;
                    }
                }
                break;
            case XSValue::dt_nonPositiveInteger:
                // error: > 0
                {
                    if (XMLBigInteger::compareValues(compareData
                                                   , signValue
                                                   , XMLUni::fgValueZero
                                                   , 0
                                                   , manager) 
                                                   == XMLNumber::GREATER_THAN)
                    {
                        status = st_InvalidRange;
                        return false;
                    }
                }
                break;
            case XSValue::dt_nonNegativeInteger:
                // error: < 0
                {
                    if (XMLBigInteger::compareValues(compareData
                                                   , signValue
                                                   , XMLUni::fgValueZero
                                                   , 0
                                                   , manager) 
                                                   == XMLNumber::LESS_THAN)
                    {
                        status = st_InvalidRange;
                        return false;
                    }
                }
                break;
            case XSValue::dt_positiveInteger:
                // error: < 1
                {
                    if (XMLBigInteger::compareValues(compareData
                                                   , signValue
                                                   , XMLUni::fgValueOne
                                                   , 1
                                                   , manager) 
                                                   == XMLNumber::LESS_THAN)
                    {
                        status = st_InvalidRange;
                        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_InvalidRange;
                        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_InvalidRange;
                        return false;
                    }
                }
                break;
            default:
                return false;
                break;
            }

        }
        /***
         *   For all singed integer types
         ***/
        else if (datatype == XSValue::dt_int   ||
                 datatype == XSValue::dt_short ||
                 datatype == XSValue::dt_byte   )
        {
            t_value   actVal;

            if ( !getActualValue( 
                                  content
                                , status
                                , version
                                , convert_2_long
                                , actVal
                                , base_decimal
                                , manager
                                 )
                )
                return false;

            switch (datatype)
            { 
            case XSValue::dt_int:
                // error: < INT_MIN || > INT_MAX
                // strtol() won't overflow for INT_MIN-1 or INT_MAX+1 on 64 box
                {
                    if ((actVal.f_long < INT_MIN) || 
                        (actVal.f_long > INT_MAX)  )
                    {
                        status = st_InvalidRange;
                        return false;
                    }
                }
                break;
            case XSValue::dt_short:
                // error: < SHRT_MIN || > SHRT_MAX
                {
                    if ((actVal.f_long < SHRT_MIN) || 
                        (actVal.f_long > SHRT_MAX)  )
                    {
                        status = st_InvalidRange;
                        return false;
                    }
                }
                break;
            case XSValue::dt_byte:
                // error: < SCHAR_MIN || > SCHAR_MAX
                {
                    if ((actVal.f_long < SCHAR_MIN) || 
                        (actVal.f_long > SCHAR_MAX)  )
                    {
                        status = st_InvalidRange;
                        return false;
                    }
                }
                break;
            default:
                return false;
                break;
            } 
        }
        /***
         *   For all unsinged integer types
         ***/
        else
        {
            t_value   actVal;

            if ( !getActualValue( 
                                  content
                                , status
                                , version
                                , convert_2_ulong
                                , actVal
                                , base_decimal
                                , manager
                                 )
                )
                return false;

            switch (datatype)
            {