开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 词法分析 > 查看源码
XMLDateTime.cpp
资源名称：xerces-c-src_2_3_0.zip　[点击查看]
上传用户：zhuqijet
上传日期：2013-06-25
资源大小：10074k
文件大小：40k
源码类别：

词法分析

开发平台：

Visual C++

XMLDateTime.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2001 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 2001, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  57. /*
  58.  * $Id: XMLDateTime.cpp,v 1.12 2003/05/22 02:10:52 knoaman Exp $
  59.  * $Log: XMLDateTime.cpp,v $
  60.  * Revision 1.12  2003/05/22 02:10:52  knoaman
  61.  * Default the memory manager.
  62.  *
  63.  * Revision 1.11  2003/05/18 14:02:05  knoaman
  64.  * Memory manager implementation: pass per instance manager.
  65.  *
  66.  * Revision 1.10  2003/05/15 19:07:46  knoaman
  67.  * Partial implementation of the configurable memory manager.
  68.  *
  69.  * Revision 1.9  2003/05/15 16:32:19  gareth
  70.  * We did not allow dateTimes with a timezone due to the last seconds fix.
  71.  *
  72.  * Revision 1.8  2003/03/23 22:54:49  peiyongz
  73.  * invalid second values
  74.  *
  75.  * Revision 1.7  2003/02/22 22:49:09  peiyongz
  76.  * Schema Errata E2-45 24:00:00 allowed
  77.  *
  78.  * Revision 1.6  2003/02/02 23:54:43  peiyongz
  79.  * getFormattedString() added to return original and converted value.
  80.  *
  81.  * Revision 1.5  2003/01/30 21:55:22  tng
  82.  * Performance: create getRawData which is similar to toString but return the internal data directly, user is not required to delete the returned memory.
  83.  *
  84.  * Revision 1.4  2002/11/28 20:39:27  peiyongz
  85.  * Schema Errata: E2-23 seconds part shall have at least one digit after the dot
  86.  *                           if it appears.
  87.  *
  88.  * Revision 1.3  2002/11/06 22:22:21  peiyongz
  89.  * Schema-Errata: E2-12: gMonth
  90.  *
  91.  * Revision 1.2  2002/11/04 15:22:05  tng
  92.  * C++ Namespace Support.
  93.  *
  94.  * Revision 1.1.1.1  2002/02/01 22:22:14  peiyongz
  95.  * sane_include
  96.  *
  97.  * Revision 1.4  2001/11/14 22:04:03  peiyongz
  98.  * Patch to apply check on Year and more rigorous on other fields as well.
  99.  *
  100.  * Revision 1.3  2001/11/12 20:36:54  peiyongz
  101.  * SchemaDateTimeException defined
  102.  *
  103.  * Revision 1.2  2001/11/09 20:41:45  peiyongz
  104.  * Fix: compilation error on Solaris and AIX.
  105.  *
  106.  * Revision 1.1  2001/11/07 19:16:03  peiyongz
  107.  * DateTime Port
  108.  *
  109.  *
  110.  */
  112. // ---------------------------------------------------------------------------
  113. //  Includes
  114. // ---------------------------------------------------------------------------
  115. #include <stdlib.h>
  116. #include <xercesc/util/XMLDateTime.hpp>
  117. #include <xercesc/util/XMLString.hpp>
  118. #include <xercesc/util/XMLUni.hpp>
  119. #include <xercesc/util/Janitor.hpp>
  121. XERCES_CPP_NAMESPACE_BEGIN
  123. //
  124. // constants used to process raw data (fBuffer)
  125. //
  126. // [-]{CCYY-MM-DD}'T'{HH:MM:SS.MS}['Z']
  127. //                                [{+|-}hh:mm']
  128. //
  130. static const XMLCh DURATION_STARTER     = chLatin_P;              // 'P'
  131. static const XMLCh DURATION_Y           = chLatin_Y;              // 'Y'
  132. static const XMLCh DURATION_M           = chLatin_M;              // 'M'
  133. static const XMLCh DURATION_D           = chLatin_D;              // 'D'
  134. static const XMLCh DURATION_H           = chLatin_H;              // 'H'
  135. static const XMLCh DURATION_S           = chLatin_S;              // 'S'
  137. static const XMLCh DATE_SEPARATOR       = chDash;                 // '-'
  138. static const XMLCh TIME_SEPARATOR       = chColon;                // ':'
  139. static const XMLCh TIMEZONE_SEPARATOR   = chColon;                // ':'
  140. static const XMLCh DATETIME_SEPARATOR   = chLatin_T;              // 'T'
  141. static const XMLCh MILISECOND_SEPARATOR = chPeriod;               // '.'
  143. static const XMLCh UTC_STD_CHAR         = chLatin_Z;              // 'Z'
  144. static const XMLCh UTC_POS_CHAR         = chPlus;                 // '+'
  145. static const XMLCh UTC_NEG_CHAR         = chDash;                 // '-'
  147. static const XMLCh UTC_SET[]            = {UTC_STD_CHAR           //"Z+-"
  148.                                          , UTC_POS_CHAR
  149.                                          , UTC_NEG_CHAR
  150.                                          , chNull};
  152. static const int YMD_MIN_SIZE    = 10;   // CCYY-MM-DD
  153. static const int YMONTH_MIN_SIZE = 7;    // CCYY_MM
  154. static const int TIME_MIN_SIZE   = 8;    // hh:mm:ss
  155. static const int TIMEZONE_SIZE   = 5;    // hh:mm
  156. static const int DAY_SIZE        = 5;    // ---DD
  157. //static const int MONTH_SIZE      = 6;    // --MM--
  158. static const int MONTHDAY_SIZE   = 7;    // --MM-DD
  159. static const int NOT_FOUND       = -1;
  161. //define constants to be used in assigning default values for
  162. //all date/time excluding duration
  163. static const int YEAR_DEFAULT  = 2000;
  164. static const int MONTH_DEFAULT = 01;
  165. static const int DAY_DEFAULT   = 15;
  167. // order-relation on duration is a partial order. The dates below are used to
  168. // for comparison of 2 durations, based on the fact that
  169. // duration x and y is x<=y iff s+x<=s+y
  170. // see 3.2.6 duration W3C schema datatype specs
  171. //
  172. // the dates are in format: {CCYY,MM,DD, H, S, M, MS, timezone}
  173. static const int DATETIMES[][XMLDateTime::TOTAL_SIZE] =
  174. {
  175.     {1696, 9, 1, 0, 0, 0, 0, XMLDateTime::UTC_STD},
  176. {1697, 2, 1, 0, 0, 0, 0, XMLDateTime::UTC_STD},
  177. {1903, 3, 1, 0, 0, 0, 0, XMLDateTime::UTC_STD},
  178. {1903, 7, 1, 0, 0, 0, 0, XMLDateTime::UTC_STD}
  179. };
  181. // ---------------------------------------------------------------------------
  182. //  local methods
  183. // ---------------------------------------------------------------------------
  184. static inline int fQuotient(int a, int b)
  185. {
  186.     div_t div_result = div(a, b);
  187.     return div_result.quot;
  188. }
  190. static inline int fQuotient(int temp, int low, int high)
  191. {
  192.     return fQuotient(temp - low, high - low);
  193. }
  195. static inline int mod(int a, int b, int quotient)
  196. {
  197. return (a - quotient*b) ;
  198. }
  200. static inline int modulo (int temp, int low, int high)
  201. {
  202.     //modulo(a - low, high - low) + low
  203.     int a = temp - low;
  204.     int b = high - low;
  205.     return (mod (a, b, fQuotient(a, b)) + low) ;
  206. }
  208. static inline bool isLeapYear(int year)
  209. {
  210.     return((year%4 == 0) && ((year%100 != 0) || (year%400 == 0)));
  211. }
  213. static int maxDayInMonthFor(int year, int month)
  214. {
  216.     if ( month == 4 || month == 6 || month == 9 || month == 11 )
  217.     {
  218.         return 30;
  219.     }
  220.     else if ( month==2 )
  221.     {
  222.         if ( isLeapYear(year) )
  223.             return 29;
  224.         else
  225.             return 28;
  226.     }
  227.     else
  228.     {
  229.         return 31;
  230.     }
  232. }
  234. // ---------------------------------------------------------------------------
  235. //  static methods : for duration
  236. // ---------------------------------------------------------------------------
  237. /**
  238.  * Compares 2 given durations. (refer to W3C Schema Datatypes "3.2.6 duration")
  239.  *
  240.  * 3.2.6.2 Order relation on duration
  241.  *
  242.  *     In general, the order-relation on duration is a partial order since there is no
  243.  *  determinate relationship between certain durations such as one month (P1M) and 30 days (P30D).
  244.  *  The order-relation of two duration values x and y is x < y iff s+x < s+y for each qualified
  245.  *  dateTime s in the list below.
  246.  *
  247.  *     These values for s cause the greatest deviations in the addition of dateTimes and durations
  248.  *
  249.  **/
  250. int XMLDateTime::compare(const XMLDateTime* const pDate1
  251.                        , const XMLDateTime* const pDate2
  252.                        , bool  strict)
  253. {
  254.     //REVISIT: this is unoptimazed vs of comparing 2 durations
  255.     //         Algorithm is described in 3.2.6.2 W3C Schema Datatype specs
  256.     //
  258.     int resultA, resultB = INDETERMINATE;
  260.     //try and see if the objects are equal
  261.     if ( (resultA = compareOrder(pDate1, pDate2)) == EQUAL)
  262.         return EQUAL;
  264.     //long comparison algorithm is required
  265.     XMLDateTime tempA(XMLPlatformUtils::fgMemoryManager), *pTempA = &tempA;
  266.     XMLDateTime tempB(XMLPlatformUtils::fgMemoryManager), *pTempB = &tempB;
  268.     addDuration(pTempA, pDate1, 0);
  269.     addDuration(pTempB, pDate2, 0);
  270.     resultA = compareOrder(pTempA, pTempB);
  271.     if ( resultA == INDETERMINATE )
  272.         return INDETERMINATE;
  274.     addDuration(pTempA, pDate1, 1);
  275.     addDuration(pTempB, pDate2, 1);
  276.     resultB = compareOrder(pTempA, pTempB);
  277.     resultA = compareResult(resultA, resultB, strict);
  278.     if ( resultA == INDETERMINATE )
  279.         return INDETERMINATE;
  281.     addDuration(pTempA, pDate1, 2);
  282.     addDuration(pTempB, pDate2, 2);
  283.     resultB = compareOrder(pTempA, pTempB);
  284.     resultA = compareResult(resultA, resultB, strict);
  285.     if ( resultA == INDETERMINATE )
  286.         return INDETERMINATE;
  288.     addDuration(pTempA, pDate1, 3);
  289.     addDuration(pTempB, pDate2, 3);
  290.     resultB = compareOrder(pTempA, pTempB);
  291.     resultA = compareResult(resultA, resultB, strict);
  293.     return resultA;
  295. }
  297. //
  298. // Form a new XMLDateTime with duration and baseDate array
  299. // Note: C++        Java
  300. //       fNewDate   duration
  301. //       fDuration  date
  302. //
  304. void XMLDateTime::addDuration(XMLDateTime*             fNewDate
  305.                             , const XMLDateTime* const fDuration
  306.                             , int index)
  308. {
  310.     //REVISIT: some code could be shared between normalize() and this method,
  311.     //         however is it worth moving it? The structures are different...
  312.     //
  314.     fNewDate->reset();
  315.     //add months (may be modified additionaly below)
  316.     int temp = DATETIMES[index][Month] + fDuration->fValue[Month];
  317.     fNewDate->fValue[Month] = modulo(temp, 1, 13);
  318.     int carry = fQuotient(temp, 1, 13);
  320.     //add years (may be modified additionaly below)
  321.     fNewDate->fValue[CentYear] = DATETIMES[index][CentYear] + fDuration->fValue[CentYear] + carry;
  323.     //add seconds
  324.     temp = DATETIMES[index][Second] + fDuration->fValue[Second];
  325.     carry = fQuotient (temp, 60);
  326.     fNewDate->fValue[Second] =  mod(temp, 60, carry);
  328.     //add minutes
  329.     temp = DATETIMES[index][Minute] + fDuration->fValue[Minute] + carry;
  330.     carry = fQuotient(temp, 60);
  331.     fNewDate->fValue[Minute] = mod(temp, 60, carry);
  333.     //add hours
  334.     temp = DATETIMES[index][Hour] + fDuration->fValue[Hour] + carry;
  335.     carry = fQuotient(temp, 24);
  336.     fNewDate->fValue[Hour] = mod(temp, 24, carry);
  338.     fNewDate->fValue[Day] = DATETIMES[index][Day] + fDuration->fValue[Day] + carry;
  340.     while ( true )
  341.     {
  342.         temp = maxDayInMonthFor(fNewDate->fValue[CentYear], fNewDate->fValue[Month]);
  343.         if ( fNewDate->fValue[Day] < 1 )
  344.         { //original fNewDate was negative
  345.             fNewDate->fValue[Day] += maxDayInMonthFor(fNewDate->fValue[CentYear], fNewDate->fValue[Month]-1);
  346.             carry = -1;
  347.         }
  348.         else if ( fNewDate->fValue[Day] > temp )
  349.         {
  350.             fNewDate->fValue[Day] -= temp;
  351.             carry = 1;
  352.         }
  353.         else
  354.         {
  355.             break;
  356.         }
  358.         temp = fNewDate->fValue[Month] + carry;
  359.         fNewDate->fValue[Month] = modulo(temp, 1, 13);
  360.         fNewDate->fValue[CentYear] += fQuotient(temp, 1, 13);
  361.     }
  363.     //fNewDate->fValue[utc] = UTC_STD_CHAR;
  364.     fNewDate->fValue[utc] = UTC_STD;
  365. }
  367. int XMLDateTime::compareResult(short resultA
  368.                              , short resultB
  369.                              , bool strict)
  370. {
  372.     if ( resultB == INDETERMINATE )
  373.     {
  374.         return INDETERMINATE;
  375.     }
  376.     else if ( (resultA != resultB) &&
  377.               strict                )
  378.     {
  379.         return INDETERMINATE;
  380.     }
  381.     else if ( (resultA != resultB) &&
  382.               !strict               )
  383.     {
  384.         if ( (resultA != EQUAL) &&
  385.              (resultB != EQUAL)  )
  386.         {
  387.             return INDETERMINATE;
  388.         }
  389.         else
  390.         {
  391.             return (resultA != EQUAL)? resultA : resultB;
  392.         }
  393.     }
  395.     return resultA;
  397. }
  399. // ---------------------------------------------------------------------------
  400. //  static methods : for others
  401. // ---------------------------------------------------------------------------
  402. int XMLDateTime::compare(const XMLDateTime* const pDate1
  403.                        , const XMLDateTime* const pDate2)
  404. {
  406.     if (pDate1->fValue[utc] == pDate2->fValue[utc])
  407.     {
  408.         return XMLDateTime::compareOrder(pDate1, pDate2);
  409.     }
  411.     short c1, c2;
  413.     if ( pDate1->isNormalized())
  414.     {
  415.         c1 = compareResult(pDate1, pDate2, false, UTC_POS);
  416.         c2 = compareResult(pDate1, pDate2, false, UTC_NEG);
  417.         return getRetVal(c1, c2);
  418.     }
  419.     else if ( pDate2->isNormalized())
  420.     {
  421.         c1 = compareResult(pDate1, pDate2, true, UTC_POS);
  422.         c2 = compareResult(pDate1, pDate2, true, UTC_NEG);
  423.         return getRetVal(c1, c2);
  424.     }
  426.     return INDETERMINATE;
  427. }
  429. int XMLDateTime::compareResult(const XMLDateTime* const pDate1
  430.                              , const XMLDateTime* const pDate2
  431.                              , bool  set2Left
  432.                              , int   utc_type)
  433. {
  434.     XMLDateTime tmpDate = (set2Left ? *pDate1 : *pDate2);
  436.     tmpDate.fTimeZone[hh] = 14;
  437.     tmpDate.fTimeZone[mm] = 0;
  438.     tmpDate.fValue[utc] = utc_type;
  439.     tmpDate.normalize();
  441.     return (set2Left? XMLDateTime::compareOrder(&tmpDate, pDate2) :
  442.                       XMLDateTime::compareOrder(pDate1, &tmpDate));
  443. }
  445. int XMLDateTime::compareOrder(const XMLDateTime* const lValue
  446.                             , const XMLDateTime* const rValue)
  447. {
  448.     //
  449.     // If any of the them is not normalized() yet,
  450.     // we need to do something here.
  451.     //
  452.     XMLDateTime lTemp = *lValue;
  453.     XMLDateTime rTemp = *rValue;
  455.     lTemp.normalize();
  456.     rTemp.normalize();
  458.     for ( int i = 0 ; i < TOTAL_SIZE; i++ )
  459.     {
  460.         if ( lTemp.fValue[i] < rTemp.fValue[i] )
  461.         {
  462.             return LESS_THAN;
  463.         }
  464.         else if ( lTemp.fValue[i] > rTemp.fValue[i] )
  465.         {
  466.             return GREATER_THAN;
  467.         }
  468.     }
  470.     return EQUAL;
  471. }
  473. // ---------------------------------------------------------------------------
  474. //  ctor and dtor
  475. // ---------------------------------------------------------------------------
  476. XMLDateTime::~XMLDateTime()
  477. {
  478.     if (fBuffer)
  479.         fMemoryManager->deallocate(fBuffer);//delete[] fBuffer;
  480. }
  482. XMLDateTime::XMLDateTime(MemoryManager* const manager)
  483. : fBuffer(0)
  484. , fMemoryManager(manager)
  485. {
  486.     reset();
  487. }
  489. XMLDateTime::XMLDateTime(const XMLCh* const aString,
  490.                          MemoryManager* const manager)
  491. : fBuffer(0)
  492. , fMemoryManager(manager)
  493. {
  494.     setBuffer(aString);
  495. }
  497. // -----------------------------------------------------------------------
  498. // Copy ctor and Assignment operators
  499. // -----------------------------------------------------------------------
  501. XMLDateTime::XMLDateTime(const XMLDateTime &toCopy)
  502. : fBuffer(0)
  503. , fMemoryManager(toCopy.fMemoryManager)
  504. {
  505.     copy(toCopy);
  506. }
  508. XMLDateTime& XMLDateTime::operator=(const XMLDateTime& rhs)
  509. {
  510.     if (this == &rhs)
  511.         return *this;
  513.     copy(rhs);
  514.     return *this;
  515. }
  517. // -----------------------------------------------------------------------
  518. // Implementation of Abstract Interface
  519. // -----------------------------------------------------------------------
  521. //
  522. // We may simply return the handle to fBuffer, but
  523. // for the sake of consistency, we return a duplicated copy
  524. // and the caller is responsible for the release of the buffer
  525. // just like any other things in the XMLNumber family.
  526. //
  527. XMLCh*  XMLDateTime::toString() const
  528. {
  529.     assertBuffer();
  531.     // Return data using global operator new
  532.     XMLCh* retBuf = XMLString::replicate(fBuffer);
  533.     return retBuf;
  534. }
  536. //
  537. // We may simply return the handle to fBuffer
  538. //
  539. XMLCh*  XMLDateTime::getRawData() const
  540. {
  541.     assertBuffer();    
  542.     return fBuffer;
  543. }
  546. const XMLCh*  XMLDateTime::getFormattedString() const
  547. {
  548.     return getRawData();
  549. }
  551. int XMLDateTime::getSign() const
  552. {
  553.     return 0;
  554. }
  556. // ---------------------------------------------------------------------------
  557. //  Parsers
  558. // ---------------------------------------------------------------------------
  560. //
  561. // [-]{CCYY-MM-DD}'T'{HH:MM:SS.MS}[TimeZone]
  562. //
  563. void XMLDateTime::parseDateTime()
  564. {
  565.     initParser();
  566.     getDate();
  568.     //fStart is supposed to point to 'T'
  569.     if (fBuffer[fStart++] != DATETIME_SEPARATOR)
  570.         ThrowXML1(SchemaDateTimeException
  571.                 , XMLExcepts::DateTime_dt_missingT
  572.                 , fBuffer);
  574.     getTime();
  575.     validateDateTime();
  576.     normalize();
  577. }
  579. //
  580. // [-]{CCYY-MM-DD}[TimeZone]
  581. //
  582. void XMLDateTime::parseDate()
  583. {
  584.     initParser();
  585.     getDate();
  586.     parseTimeZone();
  587.     validateDateTime();
  588.     normalize();
  589. }
  591. void XMLDateTime::parseTime()
  592. {
  593.     initParser();
  595.     // time initialize to default values
  596.     fValue[CentYear]= YEAR_DEFAULT;
  597.     fValue[Month]   = MONTH_DEFAULT;
  598.     fValue[Day]     = DAY_DEFAULT;
  600.     getTime();
  602.     validateDateTime();
  603.     normalize();
  604. }
  606. //
  607. // {---DD}[TimeZone]
  608. //  01234
  609. //
  610. void XMLDateTime::parseDay()
  611. {
  612.     initParser();
  614.     if (fBuffer[0] != DATE_SEPARATOR ||
  615.         fBuffer[1] != DATE_SEPARATOR ||
  616.         fBuffer[2] != DATE_SEPARATOR  )
  617.     {
  618.         ThrowXML1(SchemaDateTimeException
  619.                 , XMLExcepts::DateTime_gDay_invalid
  620.                 , fBuffer);
  621.     }
  623.     //initialize values
  624.     fValue[CentYear] = YEAR_DEFAULT;
  625.     fValue[Month]    = MONTH_DEFAULT;
  626.     fValue[Day]      = parseInt(fStart+3, fStart+5);
  628.     if ( DAY_SIZE < fEnd )
  629.     {
  630.         int sign = findUTCSign(DAY_SIZE);
  631.         if ( sign < 0 )
  632.         {
  633.             ThrowXML1(SchemaDateTimeException
  634.                     , XMLExcepts::DateTime_gDay_invalid
  635.                     , fBuffer);
  636.         }
  637.         else
  638.         {
  639.             getTimeZone(sign);
  640.         }
  641.     }
  643.     validateDateTime();
  644.     normalize();
  645. }
  647. //
  648. // {--MM--}[TimeZone]
  649. // {--MM}[TimeZone]
  650. //  012345
  651. //
  652. void XMLDateTime::parseMonth()
  653. {
  654.     initParser();
  656.     if (fBuffer[0] != DATE_SEPARATOR ||
  657.         fBuffer[1] != DATE_SEPARATOR  )
  658.     {
  659.         ThrowXML1(SchemaDateTimeException
  660.                 , XMLExcepts::DateTime_gMth_invalid
  661.                 , fBuffer);
  662.     }
  664.     //set constants
  665.     fValue[CentYear] = YEAR_DEFAULT;
  666.     fValue[Day]      = DAY_DEFAULT;
  667.     fValue[Month]    = parseInt(2, 4);
  669.     // REVISIT: allow both --MM and --MM-- now. 
  670.     // need to remove the following lines to disallow --MM-- 
  671.     // when the errata is officially in the rec. 
  672.     fStart = 4;
  673.     if ( fEnd >= fStart+2 && fBuffer[fStart] == DATE_SEPARATOR && fBuffer[fStart+1] == DATE_SEPARATOR ) 
  674.     { 
  675.         fStart += 2; 
  676.     } 
  678.     //
  679.     // parse TimeZone if any
  680.     //
  681.     if ( fStart < fEnd )
  682.     {
  683.         int sign = findUTCSign(fStart);
  684.         if ( sign < 0 )
  685.         {
  686.             ThrowXML1(SchemaDateTimeException
  687.                     , XMLExcepts::DateTime_gMth_invalid
  688.                     , fBuffer);
  689.         }
  690.         else
  691.         {
  692.             getTimeZone(sign);
  693.         }
  694.     }
  696.     validateDateTime();
  697.     normalize();
  698. }
  700. //
  701. //[-]{CCYY}[TimeZone]
  702. // 0  1234
  703. //
  704. void XMLDateTime::parseYear()
  705. {
  706.     initParser();
  708.     // skip the first '-' and search for timezone
  709.     //
  710.     int sign = findUTCSign((fBuffer[0] == chDash) ? 1 : 0);
  712.     if (sign == NOT_FOUND)
  713.     {
  714.         fValue[CentYear] = parseIntYear(fEnd);
  715.     }
  716.     else
  717.     {
  718.         fValue[CentYear] = parseIntYear(sign);
  719.         getTimeZone(sign);
  720.     }
  722.     //initialize values
  723.     fValue[Month] = MONTH_DEFAULT;
  724.     fValue[Day]   = DAY_DEFAULT;   //java is 1
  726.     validateDateTime();
  727.     normalize();
  728. }
  730. //
  731. //{--MM-DD}[TimeZone]
  732. // 0123456
  733. //
  734. void XMLDateTime::parseMonthDay()
  735. {
  736.     initParser();
  738.     if (fBuffer[0] != DATE_SEPARATOR ||
  739.         fBuffer[1] != DATE_SEPARATOR ||
  740.         fBuffer[4] != DATE_SEPARATOR )
  741.     {
  742.         ThrowXML1(SchemaDateTimeException
  743.                 , XMLExcepts::DateTime_gMthDay_invalid
  744.                 , fBuffer);
  745.     }
  748.     //initialize
  749.     fValue[CentYear] = YEAR_DEFAULT;
  750.     fValue[Month]    = parseInt(2, 4);
  751.     fValue[Day]      = parseInt(5, 7);
  753.     if ( MONTHDAY_SIZE < fEnd )
  754.     {
  755.         int sign = findUTCSign(MONTHDAY_SIZE);
  756.         if ( sign<0 )
  757.         {
  758.             ThrowXML1(SchemaDateTimeException
  759.                     , XMLExcepts::DateTime_gMthDay_invalid
  760.                     , fBuffer);
  761.         }
  762.         else
  763.         {
  764.             getTimeZone(sign);
  765.         }
  766.     }
  768.     validateDateTime();
  769.     normalize();
  770. }
  772. void XMLDateTime::parseYearMonth()
  773. {
  774.     initParser();
  776.     // get date
  777.     getYearMonth();
  778.     fValue[Day] = DAY_DEFAULT;
  779.     parseTimeZone();
  781.     validateDateTime();
  782.     normalize();
  783. }
  785. //
  786. //PnYn MnDTnH nMnS: -P1Y2M3DT10H30M
  787. //
  788. // [-]{'P'{[n'Y'][n'M'][n'D']['T'][n'H'][n'M'][n'S']}}
  789. //
  790. //  Note: the n above shall be >= 0
  791. //        if no time element found, 'T' shall be absent
  792. //
  793. void XMLDateTime::parseDuration()
  794. {
  795.     initParser();
  797.     // must start with '-' or 'P'
  798.     //
  799.     XMLCh c = fBuffer[fStart++];
  800.     if ( (c != DURATION_STARTER) &&
  801.          (c != chDash)            )
  802.     {
  803.         ThrowXML1(SchemaDateTimeException
  804.                 , XMLExcepts::DateTime_dur_Start_dashP
  805.                 , fBuffer);
  806.     }
  808.     // 'P' must ALWAYS be present in either case
  809.     if ( (c == chDash) &&
  810.          (fBuffer[fStart++]!= DURATION_STARTER ))
  811.     {
  812.         ThrowXML1(SchemaDateTimeException
  813.                 , XMLExcepts::DateTime_dur_noP
  814.                 , fBuffer);
  815.     }
  817.     // java code
  818.     //date[utc]=(c=='-')?'-':0;
  819.     //fValue[utc] = UTC_STD;
  820.     fValue[utc] = (fBuffer[0] == chDash? UTC_NEG : UTC_STD);
  822.     int negate = ( fBuffer[0] == chDash ? -1 : 1);
  824.     //
  825.     // No negative value is allowed after 'P'
  826.     //
  827.     // eg P-1234, invalid
  828.     //
  829.     if (indexOf(fStart, fEnd, chDash) != NOT_FOUND)
  830.     {
  831.         ThrowXML1(SchemaDateTimeException
  832.                 , XMLExcepts::DateTime_dur_DashNotFirst
  833.                 , fBuffer);
  834.     }
  836.     //at least one number and designator must be seen after P
  837.     bool designator = false;
  839.     int endDate = indexOf(fStart, fEnd, DATETIME_SEPARATOR);
  840.     if ( endDate == NOT_FOUND )
  841.     {
  842.         endDate = fEnd;  // 'T' absent
  843.     }
  845.     //find 'Y'
  846.     int end = indexOf(fStart, endDate, DURATION_Y);
  847.     if ( end != NOT_FOUND )
  848.     {
  849.         //scan year
  850.         fValue[CentYear] = negate * parseInt(fStart, end);
  851.         fStart = end+1;
  852.         designator = true;
  853.     }
  855.     end = indexOf(fStart, endDate, DURATION_M);
  856.     if ( end != NOT_FOUND )
  857.     {
  858.         //scan month
  859.         fValue[Month] = negate * parseInt(fStart, end);
  860.         fStart = end+1;
  861.         designator = true;
  862.     }
  864.     end = indexOf(fStart, endDate, DURATION_D);
  865.     if ( end != NOT_FOUND )
  866.     {
  867.         //scan day
  868.         fValue[Day] = negate * parseInt(fStart,end);
  869.         fStart = end+1;
  870.         designator = true;
  871.     }
  873.     if ( (fEnd == endDate) &&   // 'T' absent
  874.          (fStart != fEnd)   )   // something after Day
  875.     {
  876.         ThrowXML1(SchemaDateTimeException
  877.                 , XMLExcepts::DateTime_dur_inv_b4T
  878.                 , fBuffer);
  879.     }
  881.     if ( fEnd != endDate ) // 'T' present
  882.     {
  883.         //scan hours, minutes, seconds
  884.         //
  886.         // skip 'T' first
  887.         end = indexOf(++fStart, fEnd, DURATION_H);
  888.         if ( end != NOT_FOUND )
  889.         {
  890.             //scan hours
  891.             fValue[Hour] = negate * parseInt(fStart, end);
  892.             fStart = end+1;
  893.             designator = true;
  894.         }
  896.         end = indexOf(fStart, fEnd, DURATION_M);
  897.         if ( end != NOT_FOUND )
  898.         {
  899.             //scan min
  900.             fValue[Minute] = negate * parseInt(fStart, end);
  901.             fStart = end+1;
  902.             designator = true;
  903.         }
  905.         end = indexOf(fStart, fEnd, DURATION_S);
  906.         if ( end != NOT_FOUND )
  907.         {
  908.             //scan seconds
  909.             int mlsec = indexOf (fStart, end, MILISECOND_SEPARATOR);
  911.             /***
  912.              * Schema Errata: E2-23
  913.              * at least one digit must follow the decimal point if it appears. 
  914.              * That is, the value of the seconds component must conform 
  915.              * to the following pattern: [0-9]+(.[0-9]+)? 
  916.              */
  917.             if ( mlsec != NOT_FOUND )
  918.             {
  919.                 /***
  920.                  * make usure there is something after the '.' and before the end.
  921.                  */
  922.                 if ( mlsec+1 == end )
  923.                 {
  924.                     ThrowXML1(SchemaDateTimeException
  925.                             , XMLExcepts::DateTime_dur_inv_seconds
  926.                             ,fBuffer);
  927.                 }
  929.                 fValue[Second]     = negate * parseInt(fStart, mlsec);
  930.                 fValue[MiliSecond] = negate * parseInt(mlsec+1, end);
  931.             }
  932.             else
  933.             {
  934.                 fValue[Second] = negate * parseInt(fStart,end);
  935.             }
  937.             fStart = end+1;
  938.             designator = true;
  939.         }
  941.         // no additional data should appear after last item
  942.         // P1Y1M1DT is illigal value as well
  943.         if ( (fStart != fEnd) ||
  944.               fBuffer[--fStart] == DATETIME_SEPARATOR )
  945.         {
  946.             ThrowXML1(SchemaDateTimeException
  947.                     , XMLExcepts::DateTime_dur_NoTimeAfterT
  948.                     ,fBuffer);
  949.         }
  950.     }
  952.     if ( !designator )
  953.     {
  954.         ThrowXML1(SchemaDateTimeException
  955.                 , XMLExcepts::DateTime_dur_NoElementAtAll
  956.                 , fBuffer);
  957.     }
  959. }
  961. // ---------------------------------------------------------------------------
  962. //  Scanners
  963. // ---------------------------------------------------------------------------
  965. //
  966. // [-]{CCYY-MM-DD}
  967. //
  968. // Note: CCYY could be more than 4 digits
  969. //       Assuming fStart point to the beginning of the Date Section
  970. //       fStart updated to point to the position right AFTER the second 'D'
  971. //       Since the lenght of CCYY might be variable, we can't check format upfront
  972. //
  973. void XMLDateTime::getDate()
  974. {
  976.     // Ensure enough chars in buffer
  977.     if ( (fStart+YMD_MIN_SIZE) > fEnd)
  978.         ThrowXML1(SchemaDateTimeException
  979.                 , XMLExcepts::DateTime_date_incomplete
  980.                 , fBuffer);
  982.     getYearMonth();    // Scan YearMonth and
  983.                        // fStart point to the next '-'
  985.     if (fBuffer[fStart++] != DATE_SEPARATOR)
  986.     {
  987.         ThrowXML1(SchemaDateTimeException
  988.                 , XMLExcepts::DateTime_date_invalid
  989.                 , fBuffer);
  990.         //("CCYY-MM must be followed by '-' sign");
  991.     }
  993.     fValue[Day] = parseInt(fStart, fStart+2);
  994.     fStart += 2 ;  //fStart points right after the Day
  996.     return;
  997. }
  999. //
  1000. // hh:mm:ss[.msssss]['Z']
  1001. // hh:mm:ss[.msssss][['+'|'-']hh:mm]
  1002. // 012345678
  1003. //
  1004. // Note: Assuming fStart point to the beginning of the Time Section
  1005. //       fStart updated to point to the position right AFTER the second 's'
  1006. //                                                  or ms if any
  1007. //
  1008. void XMLDateTime::getTime()
  1009. {
  1011.     // Ensure enough chars in buffer
  1012.     if ( (fStart+TIME_MIN_SIZE) > fEnd)
  1013.         ThrowXML1(SchemaDateTimeException
  1014.                 , XMLExcepts::DateTime_time_incomplete
  1015.                 , fBuffer);
  1016.         //"Imcomplete Time Format"
  1018.     // check (fixed) format first
  1019.     if ((fBuffer[fStart + 2] != TIME_SEPARATOR) ||
  1020.         (fBuffer[fStart + 5] != TIME_SEPARATOR)  )
  1021.     {
  1022.         ThrowXML1(SchemaDateTimeException
  1023.                 , XMLExcepts::DateTime_time_invalid
  1024.                 , fBuffer);
  1025.         //("Error in parsing time" );
  1026.     }
  1028.     //
  1029.     // get hours, minute and second
  1030.     //
  1031.     fValue[Hour]   = parseInt(fStart + 0, fStart + 2);
  1032.     fValue[Minute] = parseInt(fStart + 3, fStart + 5);
  1033.     fValue[Second] = parseInt(fStart + 6, fStart + 8);
  1034.     fStart += 8;
  1036.     // to see if any ms and/or utc part after that
  1037.     if (fStart >= fEnd)
  1038.         return;
  1040.     //find UTC sign if any
  1041.     int sign = findUTCSign(fStart);
  1043.     //parse miliseconds
  1044.     int milisec = (fBuffer[fStart] == MILISECOND_SEPARATOR)? fStart : NOT_FOUND;
  1045.     if ( milisec != NOT_FOUND )
  1046.     {
  1047.         fStart++;   // skip the '.'
  1048.         // make sure we have some thing between the '.' and fEnd
  1049.         if (fStart >= fEnd)
  1050.         {
  1051.             ThrowXML1(SchemaDateTimeException
  1052.                     , XMLExcepts::DateTime_ms_noDigit
  1053.                     , fBuffer);
  1054.             //("ms shall be present once '.' is present" );
  1055.         }
  1057.         if ( sign == NOT_FOUND )
  1058.         {
  1059.             fValue[MiliSecond] = parseInt(fStart, fEnd);  //get ms between '.' and fEnd
  1060.             fStart = fEnd;
  1061.         }
  1062.         else
  1063.         {
  1064.             fValue[MiliSecond] = parseInt(fStart, sign);  //get ms between UTC sign and fEnd
  1065.         }
  1066. }
  1067.     else if(sign == 0 || sign != fStart)
  1068.     {
  1069.         // seconds has more than 2 digits
  1070.         ThrowXML1(SchemaDateTimeException
  1071.                 , XMLExcepts::DateTime_min_invalid
  1072.                 , fBuffer);
  1073.     }
  1075.     //parse UTC time zone (hh:mm)
  1076.     if ( sign > 0 ) {
  1077.         getTimeZone(sign);
  1078.     }
  1080. }
  1082. //
  1083. // [-]{CCYY-MM}
  1084. //
  1085. // Note: CCYY could be more than 4 digits
  1086. //       fStart updated to point AFTER the second 'M' (probably meet the fEnd)
  1087. //
  1088. void XMLDateTime::getYearMonth()
  1089. {
  1091.     // Ensure enough chars in buffer
  1092.     if ( (fStart+YMONTH_MIN_SIZE) > fEnd)
  1093.         ThrowXML1(SchemaDateTimeException
  1094.                 , XMLExcepts::DateTime_ym_incomplete
  1095.                 , fBuffer);
  1096.         //"Imcomplete YearMonth Format";
  1098.     // skip the first leading '-'
  1099.     int start = ( fBuffer[0] == chDash ) ? fStart + 1 : fStart;
  1101.     //
  1102.     // search for year separator '-'
  1103.     //
  1104.     int yearSeparator = indexOf(start, fEnd, DATE_SEPARATOR);
  1105.     if ( yearSeparator == NOT_FOUND)
  1106.         ThrowXML1(SchemaDateTimeException
  1107.                 , XMLExcepts::DateTime_ym_invalid
  1108.                 , fBuffer);
  1109.         //("Year separator is missing or misplaced");
  1111.     fValue[CentYear] = parseIntYear(yearSeparator);
  1112.     fStart = yearSeparator + 1;  //skip the '-' and point to the first M
  1114.     //
  1115.     //gonna check we have enough byte for month
  1116.     //
  1117.     if ((fStart + 2) > fEnd )
  1118.         ThrowXML1(SchemaDateTimeException
  1119.                 , XMLExcepts::DateTime_ym_noMonth
  1120.                 , fBuffer);
  1121.         //"no month in buffer"
  1123.     fValue[Month] = parseInt(fStart, yearSeparator + 3);
  1124.     fStart += 2;  //fStart points right after the MONTH
  1126.     return;
  1127. }
  1129. void XMLDateTime::parseTimeZone()
  1130. {
  1131.     if ( fStart < fEnd )
  1132.     {
  1133.         int sign = findUTCSign(fStart);
  1134.         if ( sign < 0 )
  1135.         {
  1136.             ThrowXML1(SchemaDateTimeException
  1137.                     , XMLExcepts::DateTime_tz_noUTCsign
  1138.                     , fBuffer);
  1139.             //("Error in month parsing");
  1140.         }
  1141.         else
  1142.         {
  1143.             getTimeZone(sign);
  1144.         }
  1145.     }
  1147.     return;
  1148. }
  1150. //
  1151. // 'Z'
  1152. // ['+'|'-']hh:mm
  1153. //
  1154. // Note: Assuming fStart points to the beginning of TimeZone section
  1155. //       fStart updated to meet fEnd
  1156. //
  1157. void XMLDateTime::getTimeZone(const int sign)
  1158. {
  1160.     if ( fBuffer[sign] == UTC_STD_CHAR )
  1161.     {
  1162.         if ((sign + 1) != fEnd )
  1163.         {
  1164.             ThrowXML1(SchemaDateTimeException
  1165.                     , XMLExcepts::DateTime_tz_stuffAfterZ
  1166.                     , fBuffer);
  1167.             //"Error in parsing time zone");
  1168.         }
  1170.         return;
  1171.     }
  1173.     //
  1174.     // otherwise, it has to be this format
  1175.     // '[+|-]'hh:mm
  1176.     //    1   23456 7
  1177.     //   sign      fEnd
  1178.     //
  1179.     if ( ( ( sign + TIMEZONE_SIZE + 1) != fEnd )      ||
  1180.          ( fBuffer[sign + 3] != TIMEZONE_SEPARATOR ) )
  1181.     {
  1182.         ThrowXML1(SchemaDateTimeException
  1183.                 , XMLExcepts::DateTime_tz_invalid
  1184.                 , fBuffer);
  1185.         //("Error in parsing time zone");
  1186.     }
  1188.     fTimeZone[hh] = parseInt(sign+1, sign+3);
  1189.     fTimeZone[mm] = parseInt(sign+4, fEnd);
  1190.         
  1191.     return;
  1192. }
  1194. // ---------------------------------------------------------------------------
  1195. //  Validator and normalizer
  1196. // ---------------------------------------------------------------------------
  1198. /**
  1199.  * If timezone present - normalize dateTime  [E Adding durations to dateTimes]
  1200.  *
  1201.  * @param date   CCYY-MM-DDThh:mm:ss+03
  1202.  * @return CCYY-MM-DDThh:mm:ssZ
  1203.  */
  1204. void XMLDateTime::normalize()
  1205. {
  1207.     if ((fValue[utc] == UTC_UNKNOWN) ||
  1208.         (fValue[utc] == UTC_STD)      )
  1209.         return;
  1211.     int negate = (fValue[utc] == UTC_POS)? -1: 1;
  1213.     // add mins
  1214.     int temp = fValue[Minute] + negate * fTimeZone[mm];
  1215.     int carry = fQuotient(temp, 60);
  1216.     fValue[Minute] = mod(temp, 60, carry);
  1218.     //add hours
  1219.     temp = fValue[Hour] + negate * fTimeZone[hh] + carry;
  1220.     carry = fQuotient(temp, 24);
  1221.     fValue[Hour] = mod(temp, 24, carry);
  1223.     fValue[Day] += carry;
  1225.     while (1)
  1226.     {
  1227.         temp = maxDayInMonthFor(fValue[CentYear], fValue[Month]);
  1228.         if (fValue[Day] < 1)
  1229.         {
  1230.             fValue[Day] += maxDayInMonthFor(fValue[CentYear], fValue[Month] - 1);
  1231.             carry = -1;
  1232.         }
  1233.         else if ( fValue[Day] > temp )
  1234.         {
  1235.             fValue[Day] -= temp;
  1236.             carry = 1;
  1237.         }
  1238.         else
  1239.         {
  1240.             break;
  1241.         }
  1243.         temp = fValue[Month] + carry;
  1244.         fValue[Month] = modulo(temp, 1, 13);
  1245.         fValue[CentYear] += fQuotient(temp, 1, 13);
  1246.     }
  1248.     // set to normalized
  1249.     fValue[utc] = UTC_STD;
  1251.     return;
  1252. }
  1254. void XMLDateTime::validateDateTime() const
  1255. {
  1257.     //REVISIT: should we throw an exception for not valid dates
  1258.     //          or reporting an error message should be sufficient?
  1259.     if ( fValue[CentYear] == 0 )
  1260.     {
  1261.         ThrowXML1(SchemaDateTimeException
  1262.                 , XMLExcepts::DateTime_year_zero
  1263.                 , fBuffer);
  1264.         //"The year "0000" is an illegal year value");
  1265.     }
  1267.     if ( fValue[Month] < 1  ||
  1268.          fValue[Month] > 12  )
  1269.     {
  1270.         ThrowXML1(SchemaDateTimeException
  1271.                 , XMLExcepts::DateTime_mth_invalid
  1272.                 , fBuffer);
  1273. //"The month must have values 1 to 12");
  1274.     }
  1276.     //validate days
  1277.     if ( fValue[Day] > maxDayInMonthFor( fValue[CentYear], fValue[Month]) ||
  1278.          fValue[Day] == 0 )
  1279.     {
  1280.         ThrowXML1(SchemaDateTimeException
  1281.                 , XMLExcepts::DateTime_day_invalid
  1282.                 , fBuffer);
  1283.         //"The day must have values 1 to 31");
  1284.     }
  1286.     //validate hours
  1287.     if ((fValue[Hour] < 0)  ||
  1288.         (fValue[Hour] > 24) ||
  1289.         ((fValue[Hour] == 24) && ((fValue[Minute] !=0) ||
  1290.                                   (fValue[Second] !=0) ||
  1291.                                   (fValue[MiliSecond] !=0))))
  1292.     {
  1293.         ThrowXML1(SchemaDateTimeException
  1294.                 , XMLExcepts::DateTime_hour_invalid
  1295.                 , fBuffer);
  1296.         //("Hour must have values 0-23");
  1297.     }
  1299.     //validate minutes
  1300.     if ( fValue[Minute] < 0 ||
  1301.          fValue[Minute] > 59 )
  1302.     {
  1303.         ThrowXML1(SchemaDateTimeException
  1304.                 , XMLExcepts::DateTime_min_invalid
  1305.                 , fBuffer);
  1306.         //"Minute must have values 0-59");
  1307.     }
  1309.     //validate seconds
  1310.     if ( fValue[Second] < 0 ||
  1311.          fValue[Second] > 60 )
  1312.     {
  1313.         ThrowXML1(SchemaDateTimeException
  1314.                 , XMLExcepts::DateTime_second_invalid
  1315.                 , fBuffer);
  1316.         //"Second must have values 0-60");
  1317.     }
  1319.     //validate time-zone hours
  1320.     if ( (abs(fTimeZone[hh]) > 14) ||
  1321.          ((abs(fTimeZone[hh]) == 14) && (fTimeZone[mm] != 0)) )
  1322.     {
  1323.         ThrowXML1(SchemaDateTimeException
  1324.                 , XMLExcepts::DateTime_tz_hh_invalid
  1325.                 , fBuffer);
  1326.         //"Time zone should have range -14..+14");
  1327.     }
  1329.     //validate time-zone minutes
  1330.     if ( abs(fTimeZone[mm]) > 59 )
  1331.     {
  1332.         ThrowXML1(SchemaDateTimeException
  1333.                 , XMLExcepts::DateTime_min_invalid
  1334.                 , fBuffer);
  1335.         //("Minute must have values 0-59");
  1336.     }
  1338.     return;
  1339. }
  1341. // -----------------------------------------------------------------------
  1342. // locator and converter
  1343. // -----------------------------------------------------------------------
  1344. int XMLDateTime::indexOf(const int start, const int end, const XMLCh ch) const
  1345. {
  1346.     for ( int i = start; i < end; i++ )
  1347.         if ( fBuffer[i] == ch )
  1348.             return i;
  1350.     return NOT_FOUND;
  1351. }
  1353. int XMLDateTime::findUTCSign (const int start)
  1354. {
  1355.     int  pos;
  1356.     for ( int index = start; index < fEnd; index++ )
  1357.     {
  1358.         pos = XMLString::indexOf(UTC_SET, fBuffer[index]);
  1359.         if ( pos != NOT_FOUND)
  1360.         {
  1361.             fValue[utc] = pos+1;   // refer to utcType, there is 1 diff
  1362.             return index;
  1363.         }
  1364.     }
  1366.     return NOT_FOUND;
  1367. }
  1369. //
  1370. // Note:
  1371. //    start: starting point in fBuffer
  1372. //    end:   ending point in fBuffer (exclusive)
  1373. //    fStart NOT updated
  1374. //
  1375. int XMLDateTime::parseInt(const int start, const int end) const
  1376. {
  1378.     XMLCh* strToScan = (XMLCh*) fMemoryManager->allocate
  1379.     (
  1380.         (end - start + 1) * sizeof(XMLCh)
  1381.     );//new XMLCh[end - start + 1];
  1382.     ArrayJanitor<XMLCh>  jname(strToScan, fMemoryManager);
  1383.     XMLString::subString(strToScan, fBuffer, start, end);
  1385.     unsigned int retVal;
  1386.     XMLString::textToBin(strToScan, retVal);
  1388.     return (int) retVal;
  1389. }
  1391. //
  1392. // [-]CCYY
  1393. //
  1394. // Note: start from fStart
  1395. //       end (exclusive)
  1396. //       fStart NOT updated
  1397. //
  1398. int XMLDateTime::parseIntYear(const int end) const
  1399. {
  1400.     // skip the first leading '-'
  1401.     int start = ( fBuffer[0] == chDash ) ? fStart + 1 : fStart;
  1403.     int length = end - start;
  1404.     if (length < 4)
  1405.     {
  1406.         ThrowXML1(SchemaDateTimeException
  1407.                 , XMLExcepts::DateTime_year_tooShort
  1408.                 , fBuffer);
  1409.         //"Year must have 'CCYY' format");
  1410.     }
  1411.     else if (length > 4 &&
  1412.              fBuffer[start] == chDigit_0)
  1413.     {
  1414.         ThrowXML1(SchemaDateTimeException
  1415.                 , XMLExcepts::DateTime_year_leadingZero
  1416.                 , fBuffer);
  1417.         //"Leading zeros are required if the year value would otherwise have fewer than four digits;
  1418.         // otherwise they are forbidden");
  1419.     }
  1421.     bool negative = (fBuffer[0] == chDash);
  1422.     int  yearVal = parseInt((negative ? 1 : 0), end);
  1423.     return ( negative ? (-1) * yearVal : yearVal );
  1424. }
  1426. XERCES_CPP_NAMESPACE_END