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

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

词法分析

开发平台：

Visual C++

XMLUri.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) 1999, 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: XMLUri.cpp,v 1.12 2003/05/16 06:01:53 knoaman Exp $
  59.  */
  61. // ---------------------------------------------------------------------------
  62. //  Includes
  63. // ---------------------------------------------------------------------------
  64. #include <xercesc/util/PlatformUtils.hpp>
  65. #include <xercesc/util/Janitor.hpp>
  66. #include <xercesc/util/XMLURL.hpp>
  67. #include <xercesc/util/XMLUri.hpp>
  68. #include <xercesc/util/XMLString.hpp>
  69. #include <xercesc/util/XMLUniDefs.hpp>
  70. #include <xercesc/util/XMLUni.hpp>
  72. XERCES_CPP_NAMESPACE_BEGIN
  74. // ---------------------------------------------------------------------------
  75. //  XMLUri: static data
  76. // ---------------------------------------------------------------------------
  78. //      Amended by RFC2732
  79. //      reserved      = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" |
  80. //                      "$" | "," | "[" | "]"
  81. //
  82. const XMLCh XMLUri::RESERVED_CHARACTERS[] =
  83. {
  84.     chSemiColon, chForwardSlash, chQuestion, chColon, chAt,
  85.     chAmpersand, chEqual, chPlus, chDollarSign, chComma, chNull
  86. };
  88. //
  89. //      mark          = "-" | "_" | "." | "!" | "~" | "*" | "'" |
  90. //                      "(" | ")"
  91. //
  92. const XMLCh XMLUri::MARK_CHARACTERS[] =
  93. {
  94.     chDash, chUnderscore, chPeriod, chBang, chTilde,
  95.     chAsterisk, chSingleQuote, chOpenParen, chCloseParen, chNull
  96. };
  98. //
  99. //      scheme        = alpha *( alpha | digit | "+" | "-" | "." )
  100. //
  101. const XMLCh XMLUri::SCHEME_CHARACTERS[] =
  102. {
  103.     chPlus, chDash, chPeriod, chNull
  104. };
  106. //
  107. //      userinfo      = *( unreserved | escaped |
  108. //                         ";" | ":" | "&" | "=" | "+" | "$" | "," )
  109. //
  110. const XMLCh XMLUri::USERINFO_CHARACTERS[] =
  111. {
  112.     chSemiColon, chColon, chAmpersand, chEqual, chPlus,
  113.     chDollarSign, chPeriod, chNull
  114. };
  116. // ---------------------------------------------------------------------------
  117. //  Local methods and data
  118. // ---------------------------------------------------------------------------
  119. static const int BUF_LEN = 64;
  120. static XMLCh value1[BUF_LEN+1];
  122. //
  123. // "Scheme"
  124. // "SchemeSpecificPart"
  125. // "Parameters"
  126. // "UserInfo"
  127. // "Host"
  128. // "Port"
  129. // "Path"
  130. // "Query"
  131. // "Fragment"
  132. //
  133. static const XMLCh errMsg_SCHEME[] =
  134. {
  135.     chLatin_S, chLatin_c, chLatin_h, chLatin_e,
  136.     chLatin_m, chLatin_e, chNull
  137. };
  139. static const XMLCh errMsg_SCHEMESPART[] =
  140. {
  141.     chLatin_S, chLatin_c, chLatin_h, chLatin_e, chLatin_m, chLatin_e,
  142.     chLatin_S, chLatin_p, chLatin_e, chLatin_c, chLatin_i, chLatin_f,
  143.     chLatin_i, chLatin_c, chLatin_P, chLatin_a, chLatin_r, chLatin_t,
  144.     chNull
  145. };
  147. static const XMLCh errMsg_PARAMS[] =
  148. {
  149.     chLatin_P, chLatin_a, chLatin_r, chLatin_a, chLatin_m,
  150.     chLatin_e, chLatin_t, chLatin_e, chLatin_r, chLatin_s, chNull
  151. };
  153. static const XMLCh errMsg_USERINFO[] =
  154. {
  155.     chLatin_U, chLatin_s, chLatin_e, chLatin_r,
  156.     chLatin_i, chLatin_n, chLatin_f, chLatin_o, chNull
  157. };
  159. static const XMLCh errMsg_HOST[] =
  160. {
  161.     chLatin_H, chLatin_o, chLatin_s, chLatin_t, chNull
  162. };
  164. static const XMLCh errMsg_PORT[] =
  165. {
  166.     chLatin_P, chLatin_o, chLatin_r, chLatin_t, chNull
  167. };
  169. static const XMLCh errMsg_PATH[] =
  170. {
  171.     chLatin_P, chLatin_a, chLatin_t, chLatin_h, chNull
  172. };
  174. static const XMLCh errMsg_QUERY[] =
  175. {
  176.     chLatin_Q, chLatin_u, chLatin_e, chLatin_r, chLatin_y, chNull
  177. };
  179. static const XMLCh errMsg_FRAGMENT[] =
  180. {
  181.     chLatin_F, chLatin_r, chLatin_a, chLatin_g,
  182.     chLatin_m, chLatin_e, chLatin_n, chLatin_t, chNull
  183. };
  185. //
  186. //  "//"
  187. //  "/"
  188. //  "./"
  189. //  "/."
  190. //  "/../"
  191. //  "/.."
  192. //
  193. static const XMLCh DOUBLE_SLASH[] =
  194. {
  195.     chForwardSlash, chForwardSlash, chNull
  196. };
  198. static const XMLCh SINGLE_SLASH[] =
  199. {
  200.     chForwardSlash, chNull
  201. };
  203. static const XMLCh SLASH_DOT_SLASH[] =
  204. {
  205.     chForwardSlash, chPeriod, chForwardSlash, chNull
  206. };
  208. static const XMLCh SLASH_DOT[] =
  209. {
  210.     chForwardSlash, chPeriod, chNull
  211. };
  213. static const XMLCh SLASH_DOTDOT_SLASH[] =
  214. {
  215.     chForwardSlash, chPeriod, chPeriod, chForwardSlash, chNull
  216. };
  218. static const XMLCh SLASH_DOTDOT[] =
  219. {
  220.     chForwardSlash, chPeriod, chPeriod, chNull
  221. };
  223. //
  224. //  ":/?#"
  225. //
  226. // REVISIT: why?
  227. static const XMLCh SCHEME_SEPARATORS[] =
  228. {
  229.     chColon, chForwardSlash, chQuestion, chPound, chNull
  230. };
  232. //
  233. //  "?#"
  234. //
  235. static const XMLCh PATH_SEPARATORS[] =
  236. {
  237.     chQuestion, chPound, chNull
  238. };
  240. // ---------------------------------------------------------------------------
  241. //  XMLUri: Constructors and Helper methods
  242. // ---------------------------------------------------------------------------
  243. // ctor# 2
  244. XMLUri::XMLUri(const XMLCh* const uriSpec,
  245.                MemoryManager* const manager)
  246. : fScheme(0)
  247. , fUserInfo(0)
  248. , fHost(0)
  249. , fPort(-1)
  250. , fPath(0)
  251. , fQueryString(0)
  252. , fFragment(0)
  253. , fURIText(0)
  254. , fMemoryManager(manager)
  255. {
  256.     try {
  257.         initialize((XMLUri *)0, uriSpec);
  258.     }
  259.     catch (...)
  260.     {
  261.         cleanUp();
  262.         throw;
  263.     }
  264. }
  266. // ctor# 7 relative ctor
  267. XMLUri::XMLUri(const XMLUri* const      baseURI
  268.               , const XMLCh* const   uriSpec
  269.               , MemoryManager* const manager)
  270. : fScheme(0)
  271. , fUserInfo(0)
  272. , fHost(0)
  273. , fPort(-1)
  274. , fPath(0)
  275. , fQueryString(0)
  276. , fFragment(0)
  277. , fURIText(0)
  278. , fMemoryManager(manager)
  279. {
  280.     try {
  281.         initialize(baseURI, uriSpec);
  282.     }
  283.     catch (...)
  284.     {
  285.         cleanUp();
  286.         throw;
  287.     }
  288. }
  290. //Copy constructor
  291. XMLUri::XMLUri(const XMLUri& toCopy)
  292. : fScheme(0)
  293. , fUserInfo(0)
  294. , fHost(0)
  295. , fPort(-1)
  296. , fPath(0)
  297. , fQueryString(0)
  298. , fFragment(0)
  299. , fURIText(0)
  300. , fMemoryManager(toCopy.fMemoryManager)
  301. {
  302.     try {
  303.         initialize(toCopy);
  304.     }
  305.     catch (...)
  306.     {
  307.         cleanUp();
  308.         throw;
  309.     }
  311. }
  313. XMLUri& XMLUri::operator=(const XMLUri& toAssign)
  314. {
  315.     try {
  316.         initialize(toAssign);
  317.     }
  318.     catch (...)
  319.     {
  320.         cleanUp();
  321.         throw;
  322.     }
  323.     return *this;
  324. }
  326. XMLUri::~XMLUri()
  327. {
  328.     cleanUp();
  329. }
  331. void XMLUri::cleanUp()
  332. {
  333.     if (fScheme)
  334.         fMemoryManager->deallocate(fScheme);//delete[] fScheme;
  336.     if (fUserInfo)
  337.         fMemoryManager->deallocate(fUserInfo);//delete[] fUserInfo;
  339.     if (fHost)
  340.         fMemoryManager->deallocate(fHost);//delete[] fHost;
  342.     if (fPath)
  343.         fMemoryManager->deallocate(fPath);//delete[] fPath;
  345.     if (fQueryString)
  346.         fMemoryManager->deallocate(fQueryString);//delete[] fQueryString;
  348.     if (fFragment)
  349.         fMemoryManager->deallocate(fFragment);//delete[] fFragment;
  351.     fMemoryManager->deallocate(fURIText);//delete[] fURIText;
  352. }
  354. void XMLUri::initialize(const XMLUri& toCopy)
  355. {
  356.     //
  357.     // assuming that all fields from the toCopy are valid,
  358.     // therefore need NOT to go through various setXXX() methods
  359.     //
  360.     fMemoryManager = toCopy.fMemoryManager;
  361.     fScheme = XMLString::replicate(toCopy.fScheme, fMemoryManager);
  362. fUserInfo = XMLString::replicate(toCopy.fUserInfo, fMemoryManager);
  363. fHost = XMLString::replicate(toCopy.fHost, fMemoryManager);
  364. fPort = toCopy.fPort;
  365. fPath = XMLString::replicate(toCopy.fPath, fMemoryManager);
  366. fQueryString = XMLString::replicate(toCopy.fQueryString, fMemoryManager);
  367. fFragment = XMLString::replicate(toCopy.fFragment, fMemoryManager);
  368. }
  370. void XMLUri::initialize(const XMLUri* const baseURI
  371.                       , const XMLCh*  const uriSpec)
  372. {
  374.     // get a trimmed version of uriSpec
  375.     // uriSpec will NO LONGER be used in this function.
  376.     //
  377.     XMLCh* trimedUriSpec = XMLString::replicate(uriSpec, fMemoryManager);
  378.     XMLString::trim(trimedUriSpec);
  379.     ArrayJanitor<XMLCh> janName(trimedUriSpec, fMemoryManager);
  380.     int trimedUriSpecLen = XMLString::stringLen(trimedUriSpec);
  382.     if ( !baseURI &&
  383.         (!trimedUriSpec || trimedUriSpecLen == 0))
  384.     {
  385.         ThrowXML1(MalformedURLException
  386.                , XMLExcepts::XMLNUM_URI_Component_Empty
  387.                , errMsg_PARAMS);
  388.     }
  390. // just make a copy of the base if spec is empty
  391. if (!trimedUriSpec || trimedUriSpecLen == 0)
  392.     {
  393.         initialize(*baseURI);
  394.         return;
  395. }
  397. int index = 0;
  399. // Check for scheme, which must be before `/'. Also handle names with
  400. // DOS drive letters ('D:'), so 1-character schemes are not allowed.
  401.     int colonIdx = XMLString::indexOf(trimedUriSpec, chColon);
  402.     int slashIdx = XMLString::indexOf(trimedUriSpec, chForwardSlash);
  404. if ((colonIdx < 2)                         ||
  405.         (colonIdx > slashIdx && slashIdx != -1) )
  406.     {
  407.         int fragmentIdx = XMLString::indexOf(trimedUriSpec, chPound);  //'#'
  408.         // A standalone base is a valid URI according to spec
  409.         if ( !baseURI && fragmentIdx != 0 )
  410.         {
  411.             ThrowXML(MalformedURLException, XMLExcepts::XMLNUM_URI_No_Scheme);
  412.         }
  413.     }
  414. else
  415.     {
  416.         initializeScheme(trimedUriSpec);
  417.         index = XMLString::stringLen(fScheme)+1;
  418.     }
  420.     // It's an error if we stop here
  421.     if (index == trimedUriSpecLen)
  422.     {
  423.         ThrowXML1(MalformedURLException
  424.                 , XMLExcepts::XMLNUM_URI_Component_Empty
  425.                 , errMsg_PATH);
  426. }
  428. // two slashes means generic URI syntax, so we get the authority
  429.     XMLCh* authUriSpec = (XMLCh*) fMemoryManager->allocate
  430.     (
  431.         (trimedUriSpecLen+1) * sizeof(XMLCh)
  432.     );//new XMLCh[trimedUriSpecLen+1];
  433.     ArrayJanitor<XMLCh> authName(authUriSpec, fMemoryManager);
  434.     XMLString::subString(authUriSpec, trimedUriSpec, index, trimedUriSpecLen);
  436.     if (((index+1) < trimedUriSpecLen) &&
  437.         XMLString::startsWith(authUriSpec, DOUBLE_SLASH))
  438.     {
  439.         index += 2;
  440.         int startPos = index;
  442.         // get authority - everything up to path, query or fragment
  443.         XMLCh testChar;
  444.         while (index < trimedUriSpecLen)
  445.         {
  446.             testChar = trimedUriSpec[index];
  447.             if (testChar == chForwardSlash ||
  448.                 testChar == chQuestion     ||
  449.                 testChar == chPound         )
  450.             {
  451.                 break;
  452.             }
  454.             index++;
  455.         }
  457.         // if we found authority, parse it out, otherwise we set the
  458.         // host to empty string
  459.         if (index > startPos)
  460.         {
  461.             XMLString::subString(authUriSpec, trimedUriSpec, startPos, index);
  462.             initializeAuthority(authUriSpec);
  463.         }
  464.         else
  465.         {
  466.             //fHost = 0;
  467.             setHost(0);
  468.         }
  469.     }
  471.     // we need to check if index has exceed the lenght or not
  472.     if (index >= trimedUriSpecLen)
  473.         return;
  475.     XMLCh* pathUriSpec = (XMLCh*) fMemoryManager->allocate
  476.     (
  477.         (trimedUriSpecLen+1) * sizeof(XMLCh)
  478.     );//new XMLCh[trimedUriSpecLen+1];
  479.     ArrayJanitor<XMLCh> pathUriSpecName(pathUriSpec, fMemoryManager);
  480.     XMLString::subString(pathUriSpec, trimedUriSpec, index, trimedUriSpecLen);
  482. initializePath(pathUriSpec);
  484. // Resolve relative URI to base URI - see RFC 2396 Section 5.2
  485. // In some cases, it might make more sense to throw an exception
  486. // (when scheme is specified is the string spec and the base URI
  487. // is also specified, for example), but we're just following the
  488. // RFC specifications
  489. if ( baseURI )
  490.     {
  491.         // check to see if this is the current doc - RFC 2396 5.2 #2
  492.         // note that this is slightly different from the RFC spec in that
  493.         // we don't include the check for query string being null
  494.         // - this handles cases where the urispec is just a query
  495.         // string or a fragment (e.g. "?y" or "#s") -
  496.         // see <http://www.ics.uci.edu/~fielding/url/test1.html> which
  497.         // identified this as a bug in the RFC
  498.         if ((!fPath || !*fPath) &&
  499.             fScheme == 0 &&
  500.             fHost == 0)
  501.         {
  502.             fScheme = XMLString::replicate(baseURI->getScheme(), fMemoryManager);
  503.             fMemoryManager->deallocate(fUserInfo);//delete [] fUserInfo;
  504.             fUserInfo = XMLString::replicate(baseURI->getUserInfo(), fMemoryManager);
  505.             fHost = XMLString::replicate(baseURI->getHost(), fMemoryManager);
  506.             fPort = baseURI->getPort();
  507.             fMemoryManager->deallocate(fPath);//delete [] fPath;
  508.             fPath = XMLString::replicate(baseURI->getPath(), fMemoryManager);
  510.             if ( !fQueryString )
  511.             {
  512.                 fQueryString = XMLString::replicate(baseURI->getQueryString(), fMemoryManager);
  513.             }
  514.             return;
  515.         }
  517.         // check for scheme - RFC 2396 5.2 #3
  518.         // if we found a scheme, it means absolute URI, so we're done
  519.         if (fScheme == 0)
  520.         {
  521.             fScheme = XMLString::replicate(baseURI->getScheme(), fMemoryManager);
  522.         }
  523.         else
  524.         {
  525.             return;
  526.         }
  528.         // check for authority - RFC 2396 5.2 #4
  529.         // if we found a host, then we've got a network path, so we're done
  530.         if (fHost == 0)
  531.         {
  532.             fMemoryManager->deallocate(fUserInfo);//delete [] fUserInfo;
  533.             fUserInfo = XMLString::replicate(baseURI->getUserInfo(), fMemoryManager);
  534.             fHost = XMLString::replicate(baseURI->getHost(), fMemoryManager);
  535.             fPort = baseURI->getPort();
  536.         }
  537.         else
  538.         {
  539.             return;
  540.         }
  542.         // check for absolute path - RFC 2396 5.2 #5
  543.         if ((fPath && *fPath) &&
  544.             XMLString::startsWith(fPath, SINGLE_SLASH))
  545.         {
  546.             return;
  547.         }
  549.         // if we get to this point, we need to resolve relative path
  550.         // RFC 2396 5.2 #6
  552.         XMLCh* basePath = XMLString::replicate(baseURI->getPath(), fMemoryManager);
  553.         ArrayJanitor<XMLCh> basePathName(basePath, fMemoryManager);
  555.         int bufLen = trimedUriSpecLen+XMLString::stringLen(fPath)+XMLString::stringLen(basePath)+1;
  556.         XMLCh* path = (XMLCh*) fMemoryManager->allocate(bufLen * sizeof(XMLCh));//new XMLCh[bufLen];
  557.         ArrayJanitor<XMLCh> pathName(path, fMemoryManager);
  558.         path[0] = 0;
  560.         XMLCh* tmp1 = (XMLCh*) fMemoryManager->allocate(bufLen * sizeof(XMLCh));//new XMLCh[bufLen];
  561.         ArrayJanitor<XMLCh> tmp1Name(tmp1, fMemoryManager);
  562.         XMLCh* tmp2 = (XMLCh*) fMemoryManager->allocate(bufLen * sizeof(XMLCh));//new XMLCh[bufLen];
  563.         ArrayJanitor<XMLCh> tmp2Name(tmp2, fMemoryManager);
  565.         // 6a - get all but the last segment of the base URI path
  566.         if (basePath)
  567.         {
  568.             int lastSlash = XMLString::lastIndexOf(basePath, chForwardSlash);
  569.             if (lastSlash != -1)
  570.             {
  571.                 XMLString::subString(path, basePath, 0, lastSlash+1);
  572.             }
  573.         }
  575.         // 6b - append the relative URI path
  576.         XMLString::catString(path, fPath);
  578.         // 6c - remove all "./" where "." is a complete path segment
  579.         index = -1;
  580.         while ((index = XMLString::patternMatch(path, SLASH_DOT_SLASH)) != -1)
  581.         {
  582.             XMLString::subString(tmp1, path, 0, index);
  583.             XMLString::subString(tmp2, path, index+2, XMLString::stringLen(path));
  585.             path[0] = 0;
  586.             XMLString::catString(path, tmp1);
  587.             XMLString::catString(path, tmp2);
  588.         }
  590.         // 6d - remove "." if path ends with "." as a complete path segment
  591.         if (XMLString::endsWith(path, SLASH_DOT))
  592.         {
  593.             path[XMLString::stringLen(path) - 1] = chNull;
  594.         }
  596.         // 6e - remove all "<segment>/../" where "<segment>" is a complete
  597.         // path segment not equal to ".."
  598.         index = -1;
  599.         int segIndex = -1;
  600. int offset = 1;
  602.         while ((index = XMLString::patternMatch(&(path[offset]), SLASH_DOTDOT_SLASH)) != -1)
  603.         {
  604. // Undo offset
  605. index += offset;
  607. // Find start of <segment> within substring ending at found point.
  608. XMLString::subString(tmp1, path, 0, index-1);
  609. segIndex = XMLString::lastIndexOf(tmp1, chForwardSlash);
  611. // Ensure <segment> exists and != ".."
  612.             if (segIndex != -1                &&
  613.                 (path[segIndex+1] != chPeriod ||
  614.                  path[segIndex+2] != chPeriod ||
  615.  segIndex + 3 != index))
  616.             {
  618.                 XMLString::subString(tmp1, path, 0, segIndex);
  619.                 XMLString::subString(tmp2, path, index+3, XMLString::stringLen(path));
  621.                 path[0] = 0;
  622.                 XMLString::catString(path, tmp1);
  623.                 XMLString::catString(path, tmp2);
  625.                 offset = (segIndex == 0 ? 1 : segIndex);
  626.             }
  627.             else
  628.             {
  629.                 offset += 4;
  630.             }
  631.         }// while
  633.         // 6f - remove ending "<segment>/.." where "<segment>" is a
  634.         // complete path segment
  635.         if (XMLString::endsWith(path, SLASH_DOTDOT))
  636.         {
  637. // Find start of <segment> within substring ending at found point.
  638.             index = XMLString::stringLen(path) - 3;
  639. XMLString::subString(tmp1, path, 0, index-1);
  640. segIndex = XMLString::lastIndexOf(tmp1, chForwardSlash);
  642.             if (segIndex != -1                &&
  643.                 (path[segIndex+1] != chPeriod ||
  644.                  path[segIndex+2] != chPeriod ||
  645.  segIndex + 3 != index))
  646.             {
  647.                 path[segIndex+1] = chNull;
  648.             }
  649.         }
  651.         if (getPath())
  652.             fMemoryManager->deallocate(fPath);//delete [] fPath;
  654.         fPath = XMLString::replicate(path, fMemoryManager);
  656.     }
  657. }
  659. // ---------------------------------------------------------------------------
  660. //  Components initialization
  661. // ---------------------------------------------------------------------------
  663. //
  664. // authority     = server | reg_name
  665. // server        = [ [ userinfo "@" ] hostport ]
  666. // hostport      = host [ ":" port ]
  667. //
  668. // reg_name      = 1*( unreserved | escaped | "$" | "," |
  669. //                    ";" | ":" | "@" | "&" | "=" | "+" )
  670. //
  671. // userinfo      = *( unreserved | escaped |
  672. //                 ";" | ":" | "&" | "=" | "+" | "$" | "," )
  673. //
  675. void XMLUri::initializeAuthority(const XMLCh* const uriSpec)
  676. {
  678.     int index = 0;
  679. int start = 0;
  680.     const int end = XMLString::stringLen(uriSpec);
  682.     //
  683.     // server = [ [ userinfo "@" ] hostport ]
  684. // userinfo is everything up @,
  685.     //
  686.     XMLCh* userinfo = (XMLCh*) fMemoryManager->allocate
  687.     (
  688.         (end+1) * sizeof(XMLCh)
  689.     );//new XMLCh[end+1];
  690.     ArrayJanitor<XMLCh> userName(userinfo, fMemoryManager);
  691.     index = XMLString::indexOf(&(uriSpec[start]), chAt);
  693.     if ( index != -1)
  694.     {
  695.         XMLString::subString(userinfo, &(uriSpec[start]), 0, index);
  696.         index++; // skip the @
  697. start += index;
  698.     }
  699.     else
  700.     {
  701.         XMLString::copyString(userinfo, XMLUni::fgZeroLenString);
  702.     }
  704.     //
  705.     // hostport = host [ ":" port ]
  706. // host is everything up to ':'
  707.     //
  708. XMLCh* host = (XMLCh*) fMemoryManager->allocate
  709.     (
  710.         (end+1) * sizeof(XMLCh)
  711.     );//new XMLCh[end+1];
  712.     ArrayJanitor<XMLCh> hostName(host, fMemoryManager);
  713.     index = XMLString::indexOf(&(uriSpec[start]), chColon);
  715.     if ( index != -1)
  716.     {
  717.         XMLString::subString(host, &(uriSpec[start]), 0, index);
  718.         index++;  // skip the :
  719. start +=index;
  720.     }
  721.     else
  722.     {
  723.         XMLString::subString(host, &(uriSpec[start]), 0, end-start);
  724. start=end;
  725.     }
  727.     // port is everything after ":"
  729.     XMLCh* portStr = (XMLCh*) fMemoryManager->allocate
  730.     (
  731.         (end+1) * sizeof(XMLCh)
  732.     );//new XMLCh[end+1];
  733.     ArrayJanitor<XMLCh> portName(portStr, fMemoryManager);
  734.     int port = -1;
  736.     if ((host && *host) &&   // non empty host
  737.         (index != -1)                    &&   // ":" found
  738.         (start < end)                     )   // ":" is not the last
  739.     {
  740.         XMLString::subString(portStr, &(uriSpec[start]), 0, end-start);
  742.         if (portStr && *portStr)
  743.         {
  744.             try
  745.             {
  746.                 port = XMLString::parseInt(portStr);
  747.             }
  748.             catch (...)
  749.             {
  750.                 throw;
  751.             }
  752.         }
  753.     } // if > 0
  755.     // The order is important, do not change
  756.     //
  757.     setHost(host);
  758.     setPort(port);
  759. setUserInfo(userinfo);
  760. }
  762. // scheme = alpha *( alpha | digit | "+" | "-" | "." )
  763. void XMLUri::initializeScheme(const XMLCh* const uriSpec)
  764. {
  765.     const XMLCh* tmpPtr = XMLString::findAny(uriSpec, SCHEME_SEPARATORS);
  767.     if ( !tmpPtr )
  768.     {
  769.         ThrowXML(MalformedURLException, XMLExcepts::XMLNUM_URI_No_Scheme);
  770.     }
  771. else
  772.     {
  773.         XMLCh* scheme = (XMLCh*) fMemoryManager->allocate
  774.         (
  775.             (XMLString::stringLen(uriSpec) + 1) * sizeof(XMLCh)
  776.         );//new XMLCh[XMLString::stringLen(uriSpec)+1];
  777.         ArrayJanitor<XMLCh> tmpName(scheme, fMemoryManager);
  778.         XMLString::subString(scheme, uriSpec, 0, (tmpPtr - uriSpec));
  779.         setScheme(scheme);
  780. }
  782. }
  784. void XMLUri::initializePath(const XMLCh* const uriSpec)
  785. {
  786. if ( !uriSpec )
  787.     {
  788.         ThrowXML1(MalformedURLException
  789.                 , XMLExcepts::XMLNUM_URI_Component_Empty
  790.                 , errMsg_PATH);
  791. }
  793. int index = 0;
  794. int start = 0;
  795.     int end = XMLString::stringLen(uriSpec);
  796. XMLCh testChar;
  798. // path - everything up to query string or fragment
  799. while (index < end)
  800.     {
  801.         testChar = uriSpec[index];
  802.         if (testChar == chQuestion || testChar == chPound)
  803.         {
  804.             break;
  805.         }
  807.         // check for valid escape sequence
  808.         if (testChar == chPercent)
  809.         {
  810.             if (index+2 >= end ||
  811.                 !XMLString::isHex(uriSpec[index+1]) ||
  812.                 !XMLString::isHex(uriSpec[index+2]))
  813.             {
  814.                 XMLString::moveChars(value1, &(uriSpec[index]), 3);
  815.                 value1[3] = chNull;
  816.                 ThrowXML2(MalformedURLException
  817.                         , XMLExcepts::XMLNUM_URI_Component_Invalid_EscapeSequence
  818.                         , errMsg_PATH
  819.                         , value1);
  820.             }
  821.         }
  822.         else if (!isReservedCharacter(testChar) &&
  823.                  !isUnreservedCharacter(testChar))
  824.         {
  825.             value1[0] = testChar;
  826.             value1[1] = chNull;
  827.             ThrowXML2(MalformedURLException
  828.                     , XMLExcepts::XMLNUM_URI_Component_Invalid_Char
  829.                     , errMsg_PATH
  830.                     , value1);
  831.         }
  833.         index++;
  834.     }//while (index < end)
  836.     if (getPath())
  837.     {
  838.         fMemoryManager->deallocate(fPath);//delete [] fPath;
  839.     }
  841.     fPath = (XMLCh*) fMemoryManager->allocate((index+1) * sizeof(XMLCh));//new XMLCh[index+1];
  842.     XMLString::subString(fPath, uriSpec, start, index);
  844. // query - starts with ? and up to fragment or end
  845. if (testChar == chQuestion)
  846.     {
  847.         index++;
  848.         start = index;
  849.         while (index < end)
  850.         {
  851.             testChar = uriSpec[index];
  852.             if (testChar == chPound)
  853.             {
  854.                 break;
  855.             }
  857.             if (testChar == chPercent)
  858.             {
  859.                 if (index+2 >= end ||
  860.                     !XMLString::isHex(uriSpec[index+1]) ||
  861.                     !XMLString::isHex(uriSpec[index+2]))
  862.                 {
  863.                     XMLString::moveChars(value1, &(uriSpec[index]), 3);
  864.                     value1[3] = chNull;
  865.                     ThrowXML2(MalformedURLException
  866.                             , XMLExcepts::XMLNUM_URI_Component_Invalid_EscapeSequence
  867.                             , errMsg_QUERY
  868.                             , value1);
  869.                 }
  870.             }
  871.             else if (!isReservedCharacter(testChar) &&
  872.                      !isUnreservedCharacter(testChar))
  873.             {
  874.                 value1[0] = testChar;
  875.                 value1[1] = chNull;
  876.                 ThrowXML2(MalformedURLException
  877.                         , XMLExcepts::XMLNUM_URI_Component_Invalid_Char
  878.                         , errMsg_QUERY
  879.                         , value1);
  880.             }
  881.             index++;
  882.         }
  884.         if (getQueryString())
  885.         {
  886.             fMemoryManager->deallocate(fQueryString);//delete [] fQueryString;
  887.         }
  889.         fQueryString = (XMLCh*) fMemoryManager->allocate
  890.         (
  891.             (index - start + 1) * sizeof(XMLCh)
  892.         );//new XMLCh[index - start + 1];
  893.         XMLString::subString(fQueryString, uriSpec, start, index);
  894.     }
  896. // fragment - starts with #
  897. if (testChar == chPound)
  898.     {
  899.         index++;
  900.         start = index;
  901.         while (index < end)
  902.         {
  903.             testChar = uriSpec[index];
  905.             if (testChar == chPercent)
  906.             {
  907.                 if (index+2 >= end ||
  908.                     !XMLString::isHex(uriSpec[index+1]) ||
  909.                     !XMLString::isHex(uriSpec[index+2]))
  910.                 {
  911.                     XMLString::moveChars(value1, &(uriSpec[index]), 3);
  912.                     value1[3] = chNull;
  913.                     ThrowXML2(MalformedURLException
  914.                             , XMLExcepts::XMLNUM_URI_Component_Invalid_EscapeSequence
  915.                             , errMsg_FRAGMENT
  916.                             , value1);
  917.                 }
  918.             }
  919.             else if (!isReservedCharacter(testChar) &&
  920.                      !isUnreservedCharacter(testChar))
  921.             {
  922.                 value1[0] = testChar;
  923.                 value1[1] = chNull;
  924.                 ThrowXML2(MalformedURLException
  925.                         , XMLExcepts::XMLNUM_URI_Component_Invalid_Char
  926.                         , errMsg_FRAGMENT
  927.                         , value1);
  928.             }
  930.             index++;
  932.         }
  934.         if (getFragment())
  935.             fMemoryManager->deallocate(fFragment);//delete [] fFragment;
  937.         //make sure that there is something following the '#'
  938.         if (index > start)
  939.         {
  940.             fFragment = (XMLCh*) fMemoryManager->allocate
  941.             (
  942.                 (index - start + 1) * sizeof(XMLCh)
  943.             );//new XMLCh[index - start + 1];
  944.             XMLString::subString(fFragment, uriSpec, start, index);
  945.         }
  946.         else
  947.         {
  948.             // RFC 2396, 4.0. URI Reference
  949.             // URI-reference = [absoulteURI | relativeURI] [# fragment]
  950.             //
  951.             // RFC 2396, 4.1. Fragment Identifier
  952.             // fragment = *uric
  953.             //
  954.             // empty fragment is valid
  955.             fFragment = 0;
  956.         }
  957.     }
  959. }
  961. // ---------------------------------------------------------------------------
  962. //  Setter
  963. // ---------------------------------------------------------------------------
  964. void XMLUri::setScheme(const XMLCh* const newScheme)
  965. {
  966.     if ( !newScheme )
  967.     {
  968.         ThrowXML1(MalformedURLException
  969.                 , XMLExcepts::XMLNUM_URI_Component_Set_Null
  970.                 , errMsg_SCHEME);
  971.     }
  973.     if (!isConformantSchemeName(newScheme))
  974.     {
  975.         ThrowXML2(MalformedURLException
  976.                 , XMLExcepts::XMLNUM_URI_Component_Not_Conformant
  977.                 , errMsg_SCHEME
  978.                 , newScheme);
  979.     }
  981.     if (getScheme())
  982.     {
  983.         fMemoryManager->deallocate(fScheme);//delete [] fScheme;
  984.     }
  986.     fScheme = XMLString::replicate(newScheme, fMemoryManager);
  987.     XMLString::lowerCase(fScheme);
  988. }
  990. //
  991. // server = [ [ userinfo "@" ] hostport ]
  992. // hostport = host [":" port]
  993. //
  994. // setUserInfo(), setHost() and setPort() are closely related
  995. // three methods, in a word, userinfo and port has dependency
  996. // on host.
  997. //
  998. // if host is not present, userinfo must be null and port = -1
  999. //
  1000. void XMLUri::setUserInfo(const XMLCh* const newUserInfo)
  1001. {
  1002.     if ( newUserInfo &&
  1003.          !getHost()    )
  1004.     {
  1005.         ThrowXML2(MalformedURLException
  1006.                 , XMLExcepts::XMLNUM_URI_NullHost
  1007.                 , errMsg_USERINFO
  1008.                 , newUserInfo);
  1009.     }
  1011.     try
  1012.     {
  1013.         isConformantUserInfo(newUserInfo);
  1014.     }
  1015.     catch (...)
  1016.     {
  1017.         throw;
  1018.     }
  1020.     if (getUserInfo())
  1021.     {
  1022.         fMemoryManager->deallocate(fUserInfo);//delete [] fUserInfo;
  1023.     }
  1025.     //sometimes we get passed a empty string rather than a null.
  1026.     //Other procedures rely on it being null
  1027.     if(newUserInfo && *newUserInfo) {
  1028.         fUserInfo = XMLString::replicate(newUserInfo, fMemoryManager);
  1029.     }
  1031. }
  1033. void XMLUri::setHost(const XMLCh* const newHost)
  1034. {
  1035.     if ( !newHost ||
  1036.         XMLString::isAllWhiteSpace(newHost))
  1037.     {
  1038.         if (getHost())
  1039.             fMemoryManager->deallocate(fHost);//delete [] fHost;
  1041.         fHost = 0;
  1042.         setUserInfo(0);
  1043.         setPort(-1);
  1045.         return;
  1046.     }
  1048.     if (!isWellFormedAddress(newHost))
  1049.     {
  1050.         ThrowXML2(MalformedURLException
  1051.                 , XMLExcepts::XMLNUM_URI_Component_Not_Conformant
  1052.                 , errMsg_HOST
  1053.                 , newHost);
  1054.     }
  1056.     if (getHost())
  1057.     {
  1058.         fMemoryManager->deallocate(fHost);//delete [] fHost;
  1059.     }
  1061.     fHost = XMLString::replicate(newHost, fMemoryManager);
  1062. }
  1064. void XMLUri::setPort(int newPort)
  1065. {
  1066.     if (newPort >= 0 && newPort <= 65535)
  1067.     {
  1068.         if (!getHost())
  1069.         {
  1070.             XMLString::binToText(newPort, value1, BUF_LEN, 10);
  1071.             ThrowXML2(MalformedURLException
  1072.                     , XMLExcepts::XMLNUM_URI_NullHost
  1073.                     , errMsg_PORT
  1074.                     , value1);
  1075.         }
  1076.     }
  1077.     else if (newPort != -1)
  1078.     {
  1079.         XMLString::binToText(newPort, value1, BUF_LEN, 10);
  1080.         ThrowXML1(MalformedURLException
  1081.                 , XMLExcepts::XMLNUM_URI_PortNo_Invalid
  1082.                 , value1);
  1083.     }
  1085.     fPort = newPort;
  1087. }
  1089. //
  1090. // setPath(), setQueryString() and setFragment() are closely
  1091. // related three methods as well.
  1092. //
  1093. void XMLUri::setPath(const XMLCh* const newPath)
  1094. {
  1095.     if (!newPath)
  1096.     {
  1097.         if (getPath())
  1098.             fMemoryManager->deallocate(fPath);//delete [] fPath;
  1100.         fPath = 0;
  1101.         setQueryString(0);
  1102.         setFragment(0);
  1103.     }
  1104.     else
  1105.     {
  1106.       initializePath(newPath);
  1107.     }
  1108.   }
  1110. //
  1111. // fragment = *uric
  1112. //
  1113. void XMLUri::setFragment(const XMLCh* const newFragment)
  1114. {
  1115. if ( !newFragment )
  1116.     {
  1117.         if (getFragment())
  1118.             fMemoryManager->deallocate(fFragment);//delete [] fFragment;
  1120.         fFragment = 0;
  1121. }
  1122. else if (!isGenericURI())
  1123.     {
  1124.         ThrowXML2(MalformedURLException
  1125.                 , XMLExcepts::XMLNUM_URI_Component_for_GenURI_Only
  1126.                 , errMsg_FRAGMENT
  1127.                 , newFragment);
  1128. }
  1129. else if ( !getPath() )
  1130.     {
  1131.         ThrowXML2(MalformedURLException
  1132.                , XMLExcepts::XMLNUM_URI_NullPath
  1133.                , errMsg_FRAGMENT
  1134.                , newFragment);
  1135. }
  1136. else if (!isURIString(newFragment))
  1137.     {
  1138.         ThrowXML1(MalformedURLException
  1139.                 , XMLExcepts::XMLNUM_URI_Component_Invalid_Char
  1140.                 , errMsg_FRAGMENT);
  1141. }
  1142. else
  1143.     {
  1144.         if (getFragment())
  1145.         {
  1146.             fMemoryManager->deallocate(fFragment);//delete [] fFragment;
  1147.         }
  1149.         fFragment = XMLString::replicate(newFragment, fMemoryManager);
  1150. }
  1151. }
  1153. //
  1154. // query = *uric
  1155. //
  1156. void XMLUri::setQueryString(const XMLCh* const newQueryString)
  1157. {
  1158. if ( !newQueryString )
  1159.     {
  1160.         if (getQueryString())
  1161.             fMemoryManager->deallocate(fQueryString);//delete [] fQueryString;
  1163.         fQueryString = 0;
  1164. }
  1165. else if (!isGenericURI())
  1166.     {
  1167.         ThrowXML2(MalformedURLException
  1168.                 , XMLExcepts::XMLNUM_URI_Component_for_GenURI_Only
  1169.                 , errMsg_QUERY
  1170.                 , newQueryString);
  1171. }
  1172. else if ( !getPath() )
  1173.     {
  1174.         ThrowXML2(MalformedURLException
  1175.                 , XMLExcepts::XMLNUM_URI_NullPath
  1176.                 , errMsg_QUERY
  1177.                 , newQueryString);
  1178. }
  1179. else if (!isURIString(newQueryString))
  1180.     {
  1181.         ThrowXML2(MalformedURLException
  1182.                , XMLExcepts::XMLNUM_URI_Component_Invalid_Char
  1183.                , errMsg_QUERY
  1184.                , newQueryString);
  1185. }
  1186. else
  1187.     {
  1188.         if (getQueryString())
  1189.         {
  1190.             fMemoryManager->deallocate(fQueryString);//delete [] fQueryString;
  1191.         }
  1193.         fQueryString = XMLString::replicate(newQueryString, fMemoryManager);
  1194. }
  1195. }
  1197. // ---------------------------------------------------------------------------
  1198. //  XMLUri: Public, static methods
  1199. // ---------------------------------------------------------------------------
  1201. //
  1202. //  scheme = alpha *( alpha | digit | "+" | "-" | "." )
  1203. //  alphanum = alpha | digit
  1204. //
  1205. bool XMLUri::isConformantSchemeName(const XMLCh* const scheme)
  1206. {
  1207. if ( !scheme )
  1208.         return false;
  1210.     const XMLCh* tmpStr = scheme;
  1211.     if (!XMLString::isAlpha(*tmpStr))     // first: alpha
  1212.         return false;
  1214.     // second onwards: ( alpha | digit | "+" | "-" | "." )
  1215.     tmpStr++;
  1216.     while (*tmpStr)
  1217.     {
  1218.         if ( !XMLString::isAlphaNum(*tmpStr) &&
  1219.              (XMLString::indexOf(SCHEME_CHARACTERS, *tmpStr) == -1))
  1220.             return false;
  1222.         tmpStr++;
  1223.     }
  1225.     return true;
  1226. }
  1228. //
  1229. // userinfo = *( unreserved | escaped |
  1230. //              ";" | ":" | "&" | "=" | "+" | "$" | "," )
  1231. //
  1232. void XMLUri::isConformantUserInfo(const XMLCh* const userInfo)
  1233. {
  1234. if ( !userInfo )
  1235.         return;
  1237.     const XMLCh* tmpStr = userInfo;
  1238.     while (*tmpStr)
  1239.     {
  1240.         if ( isUnreservedCharacter(*tmpStr) ||
  1241.             (XMLString::indexOf(USERINFO_CHARACTERS, *tmpStr) != -1))
  1242.         {
  1243.             tmpStr++;
  1244.         }
  1245.         else if (*tmpStr == chPercent)               // '%'
  1246.         {
  1247.             if (XMLString::isHex(*(tmpStr+1)) &&     // 1st hex
  1248.                 XMLString::isHex(*(tmpStr+2))  )     // 2nd hex
  1249.             {
  1250.                 tmpStr+=3;
  1251.             }
  1252.             else
  1253.             {
  1254.                 value1[0] = chPercent;
  1255.                 value1[1] = *(tmpStr+1);
  1256.                 value1[2] = *(tmpStr+2);
  1257.                 value1[3] = chNull;
  1259.                 ThrowXML2(MalformedURLException
  1260.                         , XMLExcepts::XMLNUM_URI_Component_Invalid_EscapeSequence
  1261.                         , errMsg_USERINFO
  1262.                         , value1);
  1263.             }
  1264.         }
  1265.         else
  1266.         {
  1267.             ThrowXML2(MalformedURLException
  1268.                     , XMLExcepts::XMLNUM_URI_Component_Invalid_Char
  1269.                     , errMsg_USERINFO
  1270.                     , userInfo);
  1271.         }
  1272.     } //while
  1274.     return;
  1275. }
  1277. //
  1278. // uric     = reserved | unreserved | escaped
  1279. // escaped  = "%" hex hex
  1280. // hex      = digit | "A" | "B" | "C" | "D" | "E" | "F" |
  1281. //                    "a" | "b" | "c" | "d" | "e" | "f"
  1282. //
  1283. bool XMLUri::isURIString(const XMLCh* const uricString)
  1284. {
  1285. if (!uricString || !*uricString)
  1286.         return false;
  1288.     const XMLCh* tmpStr = uricString;
  1289.     while (*tmpStr)
  1290.     {
  1291.         if (isReservedCharacter(*tmpStr)    ||
  1292.             isUnreservedCharacter(*tmpStr)   )
  1293.         {
  1294.             tmpStr++;
  1295.         }
  1296.         else if (*tmpStr == chPercent)               // '%'
  1297.         {
  1298.             if (XMLString::isHex(*(tmpStr+1)) &&     // 1st hex
  1299.                 XMLString::isHex(*(tmpStr+2))  )     // 2nd hex
  1300.             {
  1301.                 tmpStr+=3;
  1302.             }
  1303.             else
  1304.             {
  1305.                 return false;
  1306.             }
  1307.         }
  1308.         else
  1309.         {
  1310.             return false;
  1311.         }
  1312.     }
  1314.     return true;
  1315. }
  1317. //
  1318. //  host          = hostname | IPv4address
  1319. //
  1320. //  hostname      = *( domainlabel "." ) toplabel [ "." ]
  1321. //  domainlabel   = alphanum | alphanum *( alphanum | "-" ) alphanum
  1322. //  toplabel      = alpha | alpha *( alphanum | "-" ) alphanum
  1323. //
  1324. //  IPv4address   = 1*digit "." 1*digit "." 1*digit "." 1*digit
  1325. //
  1326. bool XMLUri::isWellFormedAddress(const XMLCh* const addrString)
  1327. {
  1328. if (!addrString)
  1329.         return false;
  1331.     //
  1332.     // check length
  1333.     //
  1334.     XMLCh* tmpAddr = XMLString::replicate(addrString, XMLPlatformUtils::fgMemoryManager);
  1335.     ArrayJanitor<XMLCh>  janName(tmpAddr, XMLPlatformUtils::fgMemoryManager);
  1336.     XMLString::trim(tmpAddr);
  1337.     if ((!tmpAddr || !*tmpAddr) ||
  1338.         (XMLString::stringLen(tmpAddr) > 255) )
  1339.         return false;
  1341.     //
  1342.     // the frist letter shall NOT be "." or "-"
  1343.     //
  1344. if (*addrString == chPeriod ||
  1345.         *addrString == chDash    )
  1346.         return false;
  1348. // rightmost domain label starting with digit indicates IP address
  1349. // since top level domain label can only start with an alpha
  1350. // see RFC 2396 Section 3.2.2
  1351.     int addrStrLen = XMLString::stringLen(addrString);
  1352.     int lastPeriodPos = XMLString::lastIndexOf(addrString, chPeriod);
  1354.     // if the string ends with "."
  1355.     // get the second last "."
  1356.     if (lastPeriodPos + 1 == addrStrLen)
  1357.     {
  1358.         XMLCh* tmp2 = (XMLCh*) XMLPlatformUtils::fgMemoryManager->allocate
  1359.         (
  1360.             addrStrLen * sizeof(XMLCh)
  1361.         );//new XMLCh[addrStrLen];
  1362.         XMLString::subString(tmp2, addrString, 0, lastPeriodPos);
  1363.         lastPeriodPos = XMLString::lastIndexOf(tmp2, chPeriod);
  1364.         XMLPlatformUtils::fgMemoryManager->deallocate(tmp2);//delete [] tmp2;
  1366.         if ( XMLString::isDigit(addrString[lastPeriodPos + 1]))
  1367. return false;
  1368.     }
  1370. if (XMLString::isDigit(addrString[lastPeriodPos + 1]))
  1371.     {
  1372.         //
  1373.         // IPv4address   = 1*digit "." 1*digit "." 1*digit "." 1*digit
  1374.         //
  1375.         // make sure that
  1376.         // 1) we see only digits and dot separators,
  1377.         // 2) that any dot separator is preceded and followed by a digit
  1378.         // 3) that we find 3 dots
  1380.         int numDots = 0;
  1381.         for (int i = 0; i < addrStrLen; i++)
  1382.         {
  1383.             if (addrString[i] == chPeriod)
  1384.             {
  1385.                 if (((i > 0)  &&
  1386.                     (!XMLString::isDigit(addrString[i-1]))) ||
  1387.                     ((i + 1 < addrStrLen) &&
  1388.                     (!XMLString::isDigit(addrString[i+1])))  )
  1389.                 {
  1390.                     return false;
  1391.                 }
  1392.                 numDots++;
  1393.             }
  1394.             else if (!XMLString::isDigit(addrString[i]))
  1395.             {
  1396.                 return false;
  1397.             }
  1398.         } //for
  1400.         if (numDots != 3)
  1401.         {
  1402.             return false;
  1403.         }
  1404.     } // end of IPv4address
  1405. else
  1406.     {
  1407.         //
  1408.         //  hostname      = *( domainlabel "." ) toplabel [ "." ]
  1409.         //  domainlabel   = alphanum | alphanum *( alphanum | "-" ) alphanum
  1410.         //  toplabel      = alpha | alpha *( alphanum | "-" ) alphanum
  1411.         //
  1412.         // domain labels can contain alphanumerics and '-"
  1413.         // but must start and end with an alphanumeric
  1414.         for (int i = 0; i < addrStrLen; i++)
  1415.         {
  1416.             if (addrString[i] == chPeriod)
  1417.             {
  1418.               if (((i > 0)  &&
  1419.                    (!XMLString::isAlphaNum(addrString[i-1]))) ||
  1420.                   ((i + 1 < addrStrLen) &&
  1421.                    (!XMLString::isAlphaNum(addrString[i+1])))  )
  1422.                 {
  1423.                     return false;
  1424.                 }
  1425.             }
  1426.             else if (!XMLString::isAlphaNum(addrString[i]) &&
  1427.                       addrString[i] != chDash)
  1428.             {
  1429.                 return false;
  1430.             }
  1431.         } //for
  1432.     }
  1434.     return true;
  1435. }
  1437. bool XMLUri::isGenericURI()
  1438. {
  1439.     return (getHost() != 0);
  1440. }
  1443. //
  1444. //  This method will take the broken out parts of the URI and build up the
  1445. //  full text. We don't do this unless someone asks us to, since its often
  1446. //  never required.
  1447. //
  1448. void XMLUri::buildFullText()
  1449. {
  1450.     // Calculate the worst case size of the buffer required
  1451.     unsigned int bufSize = XMLString::stringLen(fScheme) + 1
  1452.                            + XMLString::stringLen(fFragment) + 1
  1453.                            + XMLString::stringLen(fHost) + 2
  1454.                            + XMLString::stringLen(fPath)
  1455.                            + XMLString::stringLen(fQueryString) + 1
  1456.                            + XMLString::stringLen(fUserInfo) + 1
  1457.                            + 32;
  1459.     // Clean up the existing buffer and allocate another
  1460.     fMemoryManager->deallocate(fURIText);//delete [] fURIText;
  1461.     fURIText = (XMLCh*) fMemoryManager->allocate(bufSize * sizeof(XMLCh));//new XMLCh[bufSize];
  1462.     *fURIText = 0;
  1464.     XMLCh* outPtr = fURIText;
  1465.     if (fScheme != 0)
  1466.     {
  1467.         XMLString::catString(fURIText, getScheme());
  1468.         outPtr += XMLString::stringLen(fURIText);
  1469.         *outPtr++ = chColon;
  1470.         *outPtr++ = chForwardSlash;
  1471.         *outPtr++ = chForwardSlash;
  1472.     }
  1474.     if (fUserInfo)
  1475.     {
  1476.         XMLString::copyString(outPtr, fUserInfo);
  1477.         outPtr += XMLString::stringLen(fUserInfo);
  1480.         /*REVISIT dont have password field in uri - is this right??
  1481.         if (fPassword)
  1482.         {
  1483.             *outPtr++ = chColon;
  1484.             XMLString::copyString(outPtr, fPassword);
  1485.             outPtr += XMLString::stringLen(fPassword);
  1486.         }
  1487.         */
  1488.         *outPtr++ = chAt;
  1489.     }
  1491.     if (fHost)
  1492.     {
  1493.         XMLString::copyString(outPtr, fHost);
  1494.         outPtr += XMLString::stringLen(fHost);
  1496.         //
  1497.         //  If the port is -1, then we don't put it in. Else we need
  1498.         //  to because it was explicitly provided.
  1499.         //
  1500.         if (fPort != -1)
  1501.         {
  1502.             *outPtr++ = chColon;
  1504.             XMLCh tmpBuf[16];
  1505.             XMLString::binToText(fPort, tmpBuf, 16, 10);
  1506.             XMLString::copyString(outPtr, tmpBuf);
  1507.             outPtr += XMLString::stringLen(tmpBuf);
  1508.         }
  1509.     }
  1511.     if (fPath)
  1512.     {
  1513.         XMLString::copyString(outPtr, fPath);
  1514.         outPtr += XMLString::stringLen(fPath);
  1515.     }
  1517.     if (fQueryString)
  1518.     {
  1519.         *outPtr++ = chQuestion;
  1520.         XMLString::copyString(outPtr, fQueryString);
  1521.         outPtr += XMLString::stringLen(fQueryString);
  1522.     }
  1524.     if (fFragment)
  1525.     {
  1526.         *outPtr++ = chPound;
  1527.         XMLString::copyString(outPtr, fFragment);
  1528.         outPtr += XMLString::stringLen(fFragment);
  1529.     }
  1531.     // Cap it off in case the last op was not a string copy
  1532.     *outPtr = 0;
  1533. }
  1535. XERCES_CPP_NAMESPACE_END