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

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

词法分析

开发平台：

Visual C++

XMLURL.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999-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: XMLURL.cpp,v 1.7 2003/05/16 06:01:53 knoaman Exp $
  59.  */
  62. // ---------------------------------------------------------------------------
  63. //  Includes
  64. // ---------------------------------------------------------------------------
  65. #include <xercesc/util/BinFileInputStream.hpp>
  66. #include <xercesc/util/Janitor.hpp>
  67. #include <xercesc/util/PlatformUtils.hpp>
  68. #include <xercesc/util/RuntimeException.hpp>
  69. #include <xercesc/util/TransService.hpp>
  70. #include <xercesc/util/XMLURL.hpp>
  71. #include <xercesc/util/XMLNetAccessor.hpp>
  72. #include <xercesc/util/XMLString.hpp>
  73. #include <xercesc/util/XMLUniDefs.hpp>
  74. #include <xercesc/util/XMLUni.hpp>
  75. #include <xercesc/util/XMLUri.hpp>
  77. XERCES_CPP_NAMESPACE_BEGIN
  81. // ---------------------------------------------------------------------------
  82. //  Local types
  83. //
  84. //  TypeEntry
  85. //      This structure defines a single entry in the list of URL types. Each
  86. //      entry indicates the prefix for that type of URL, and the SourceTypes
  87. //      value it maps to.
  88. // ---------------------------------------------------------------------------
  89. struct ProtoEntry
  90. {
  91.     XMLURL::Protocols   protocol;
  92.     const XMLCh*        prefix;
  93.     unsigned int        defPort;
  94. };
  97. // ---------------------------------------------------------------------------
  98. //  Local data
  99. //
  100. //  gXXXString
  101. //      These are the strings for our prefix types. They all have to be
  102. //      Unicode strings all the time, so we can't just do regular strings.
  103. //
  104. //  gProtoList
  105. //      The list of URL types that we support and some info related to each
  106. //      one.
  107. //
  108. //  gMaxProtoLen
  109. //      The length of the longest protocol string
  110. //
  111. //      NOTE:!!! Be sure to keep this up to date if new protocols are added!
  112. // ---------------------------------------------------------------------------
  113. static const XMLCh  gFileString[] =
  114. {
  115.         chLatin_f, chLatin_i, chLatin_l, chLatin_e, chNull
  116. };
  118. static const XMLCh gFTPString[]  =
  119. {
  120.         chLatin_f, chLatin_t, chLatin_p, chNull
  121. };
  123. static const XMLCh gHTTPString[] =
  124. {
  125.         chLatin_h, chLatin_t, chLatin_t, chLatin_p, chNull
  126. };
  128. static ProtoEntry gProtoList[XMLURL::Protocols_Count] =
  129. {
  130.         { XMLURL::File     , gFileString    , 0  }
  131.     ,   { XMLURL::HTTP     , gHTTPString    , 80 }
  132.     ,   { XMLURL::FTP      , gFTPString     , 21 }
  133. };
  135. // !!! Keep these up to date with list above!
  136. static const unsigned int gMaxProtoLen = 4;
  139. // ---------------------------------------------------------------------------
  140. //  Local methods
  141. // ---------------------------------------------------------------------------
  142. static bool isHexDigit(const XMLCh toCheck)
  143. {
  144.     if ((toCheck >= chDigit_0) && (toCheck <= chDigit_9)
  145.     ||  (toCheck >= chLatin_A) && (toCheck <= chLatin_Z)
  146.     ||  (toCheck >= chLatin_a) && (toCheck <= chLatin_z))
  147.     {
  148.         return true;
  149.     }
  150.     return false;
  151. }
  153. static unsigned int xlatHexDigit(const XMLCh toXlat)
  154. {
  155.     if ((toXlat >= chDigit_0) && (toXlat <= chDigit_9))
  156.         return (unsigned int)(toXlat - chDigit_0);
  158.     if ((toXlat >= chLatin_A) && (toXlat <= chLatin_Z))
  159.         return (unsigned int)(toXlat - chLatin_A) + 10;
  161.     return (unsigned int)(toXlat - chLatin_a) + 10;
  162. }
  166. // ---------------------------------------------------------------------------
  167. //  XMLURL: Public, static methods
  168. // ---------------------------------------------------------------------------
  169. XMLURL::Protocols XMLURL::lookupByName(const XMLCh* const protoName)
  170. {
  171.     for (unsigned int index = 0; index < XMLURL::Protocols_Count; index++)
  172.     {
  173.         if (!XMLString::compareIString(gProtoList[index].prefix, protoName))
  174.             return gProtoList[index].protocol;
  175.     }
  176.     return XMLURL::Unknown;
  177. }
  181. // ---------------------------------------------------------------------------
  182. //  XMLURL: Constructors and Destructor
  183. // ---------------------------------------------------------------------------
  184. XMLURL::XMLURL(MemoryManager* const manager) :
  186.     fMemoryManager(manager)
  187.     , fFragment(0)
  188.     , fHost(0)
  189.     , fPassword(0)
  190.     , fPath(0)
  191.     , fPortNum(0)
  192.     , fProtocol(XMLURL::Unknown)
  193.     , fQuery(0)
  194.     , fUser(0)
  195.     , fURLText(0)
  196.     , fHasInvalidChar(false)
  197. {
  198. }
  200. XMLURL::XMLURL(const XMLCh* const    baseURL
  201.              , const XMLCh* const    relativeURL
  202.              , MemoryManager* const manager) :
  204.     fMemoryManager(manager)
  205.     , fFragment(0)
  206.     , fHost(0)
  207.     , fPassword(0)
  208.     , fPath(0)
  209.     , fPortNum(0)
  210.     , fProtocol(XMLURL::Unknown)
  211.     , fQuery(0)
  212.     , fUser(0)
  213.     , fURLText(0)
  214.     , fHasInvalidChar(false)
  215. {
  216. try
  217. {
  218. setURL(baseURL, relativeURL);
  219. }
  220.     catch(...)
  221.     {
  222.         cleanup();
  223.         throw;
  224.     }
  225. }
  227. XMLURL::XMLURL(const XMLCh* const  baseURL
  228.              , const char* const   relativeURL
  229.              , MemoryManager* const manager) :
  231.     fMemoryManager(manager)
  232.     , fFragment(0)
  233.     , fHost(0)
  234.     , fPassword(0)
  235.     , fPath(0)
  236.     , fPortNum(0)
  237.     , fProtocol(XMLURL::Unknown)
  238.     , fQuery(0)
  239.     , fUser(0)
  240.     , fURLText(0)
  241.     , fHasInvalidChar(false)
  242. {
  243.     XMLCh* tmpRel = XMLString::transcode(relativeURL, fMemoryManager);
  244.     ArrayJanitor<XMLCh> janRel(tmpRel, fMemoryManager);
  245. try
  246. {
  247. setURL(baseURL, tmpRel);
  248. }
  249.     catch(...)
  250.     {
  251.         cleanup();
  252.         throw;
  253.     }
  254. }
  256. XMLURL::XMLURL(const XMLURL&         baseURL
  257.              , const XMLCh* const    relativeURL) :
  259.     fMemoryManager(baseURL.fMemoryManager)
  260.     , fFragment(0)
  261.     , fHost(0)
  262.     , fPassword(0)
  263.     , fPath(0)
  264.     , fPortNum(0)
  265.     , fProtocol(XMLURL::Unknown)
  266.     , fQuery(0)
  267.     , fUser(0)
  268.     , fURLText(0)
  269.     , fHasInvalidChar(false)
  270. {
  271. try
  272. {
  273. setURL(baseURL, relativeURL);
  274. }
  275.     catch(...)
  276.     {
  277.         cleanup();
  278.         throw;
  279.     }
  280. }
  282. XMLURL::XMLURL(const  XMLURL&        baseURL
  283.              , const char* const     relativeURL) :
  285.     fMemoryManager(baseURL.fMemoryManager)
  286.     , fFragment(0)
  287.     , fHost(0)
  288.     , fPassword(0)
  289.     , fPath(0)
  290.     , fPortNum(0)
  291.     , fProtocol(XMLURL::Unknown)
  292.     , fQuery(0)
  293.     , fUser(0)
  294.     , fURLText(0)
  295.     , fHasInvalidChar(false)
  296. {
  297.     XMLCh* tmpRel = XMLString::transcode(relativeURL, fMemoryManager);
  298.     ArrayJanitor<XMLCh> janRel(tmpRel, fMemoryManager);
  299. try
  300. {
  301. setURL(baseURL, tmpRel);
  302. }
  303.     catch(...)
  304.     {
  305.         cleanup();
  306.         throw;
  307.     }
  309. }
  311. XMLURL::XMLURL(const XMLCh* const urlText,
  312.                MemoryManager* const manager) :
  314.     fMemoryManager(manager)
  315.     , fFragment(0)
  316.     , fHost(0)
  317.     , fPassword(0)
  318.     , fPath(0)
  319.     , fPortNum(0)
  320.     , fProtocol(XMLURL::Unknown)
  321.     , fQuery(0)
  322.     , fUser(0)
  323.     , fURLText(0)
  324.     , fHasInvalidChar(false)
  325. {
  326. try
  327. {
  328.     setURL(urlText);
  329. }
  330.     catch(...)
  331.     {
  332.         cleanup();
  333.         throw;
  334.     }
  335. }
  337. XMLURL::XMLURL(const char* const urlText,
  338.                MemoryManager* const manager) :
  340.     fMemoryManager(manager)
  341.     , fFragment(0)
  342.     , fHost(0)
  343.     , fPassword(0)
  344.     , fPath(0)
  345.     , fPortNum(0)
  346.     , fProtocol(XMLURL::Unknown)
  347.     , fQuery(0)
  348.     , fUser(0)
  349.     , fURLText(0)
  350.     , fHasInvalidChar(false)
  351. {
  352.     XMLCh* tmpText = XMLString::transcode(urlText, fMemoryManager);
  353.     ArrayJanitor<XMLCh> janRel(tmpText, fMemoryManager);
  354. try
  355. {
  356.     setURL(tmpText);
  357. }
  358.     catch(...)
  359.     {
  360.         cleanup();
  361.         throw;
  362.     }
  363. }
  365. XMLURL::XMLURL(const XMLURL& toCopy) :
  367.     fMemoryManager(toCopy.fMemoryManager)
  368.     , fFragment(0)
  369.     , fHost(0)
  370.     , fPassword(0)
  371.     , fPath(0)
  372.     , fPortNum(toCopy.fPortNum)
  373.     , fProtocol(toCopy.fProtocol)
  374.     , fQuery(0)
  375.     , fUser(0)
  376.     , fURLText(0)
  377.     , fHasInvalidChar(toCopy.fHasInvalidChar)
  378. {
  379.     try
  380.     {
  381.         fFragment = XMLString::replicate(toCopy.fFragment, fMemoryManager);
  382.         fHost = XMLString::replicate(toCopy.fHost, fMemoryManager);
  383.         fPassword = XMLString::replicate(toCopy.fPassword, fMemoryManager);
  384.         fPath = XMLString::replicate(toCopy.fPath, fMemoryManager);
  385.         fQuery = XMLString::replicate(toCopy.fQuery, fMemoryManager);
  386.         fUser = XMLString::replicate(toCopy.fUser, fMemoryManager);
  387.         fURLText = XMLString::replicate(toCopy.fURLText, fMemoryManager);
  388.     }
  389.     catch(...)
  390.     {
  391.         cleanup();
  392.     }
  393. }
  395. XMLURL::~XMLURL()
  396. {
  397.     cleanup();
  398. }
  401. // ---------------------------------------------------------------------------
  402. //  XMLURL: Public operators
  403. // ---------------------------------------------------------------------------
  404. XMLURL& XMLURL::operator=(const XMLURL& toAssign)
  405. {
  406.     if (this == &toAssign)
  407.         return *this;
  409.     // Clean up our stuff
  410.     cleanup();
  412.     // And copy his stuff
  413.     fFragment = XMLString::replicate(toAssign.fFragment, fMemoryManager);
  414.     fHost = XMLString::replicate(toAssign.fHost, fMemoryManager);
  415.     fPassword = XMLString::replicate(toAssign.fPassword, fMemoryManager);
  416.     fPath = XMLString::replicate(toAssign.fPath, fMemoryManager);
  417.     fProtocol = toAssign.fProtocol;
  418.     fQuery = XMLString::replicate(toAssign.fQuery, fMemoryManager);
  419.     fUser = XMLString::replicate(toAssign.fUser, fMemoryManager);
  420.     fURLText = XMLString::replicate(toAssign.fURLText, fMemoryManager);
  422.     return *this;
  423. }
  425. bool XMLURL::operator==(const XMLURL& toCompare) const
  426. {
  427.     //
  428.     //  Compare the two complete URLs (which have been processed the same
  429.     //  way so they should now be the same even if they came in via different
  430.     //  relative parts.
  431.     //
  432.     if (!XMLString::equals(getURLText(), toCompare.getURLText()))
  433.         return false;
  435.     return true;
  436. }
  440. // ---------------------------------------------------------------------------
  441. //  XMLURL: Getter methods
  442. // ---------------------------------------------------------------------------
  443. unsigned int XMLURL::getPortNum() const
  444. {
  445.     //
  446.     //  If it was not provided explicitly, then lets return the default one
  447.     //  for the protocol.
  448.     //
  449.     if (!fPortNum)
  450.     {
  451.         if (fProtocol == Unknown)
  452.             return 0;
  453.         return gProtoList[fProtocol].defPort;
  454.     }
  455.     return fPortNum;
  456. }
  459. const XMLCh* XMLURL::getProtocolName() const
  460. {
  461.     // Check to see if its ever been set
  462.     if (fProtocol == Unknown)
  463.         ThrowXML(MalformedURLException, XMLExcepts::URL_NoProtocolPresent);
  465.     return gProtoList[fProtocol].prefix;
  466. }
  469. // ---------------------------------------------------------------------------
  470. //  XMLURL: Setter methods
  471. // ---------------------------------------------------------------------------
  472. void XMLURL::setURL(const XMLCh* const urlText)
  473. {
  474.     //
  475.     //  Try to parse the URL.
  476.     //
  477.     cleanup();
  478.     parse(urlText);
  479. }
  481. void XMLURL::setURL(const XMLCh* const    baseURL
  482.                   , const XMLCh* const    relativeURL)
  483. {
  484.     cleanup();
  486.     // Parse our URL string
  487.     parse(relativeURL);
  489. //
  490. //  If its relative and the base is non-null and non-empty, then
  491. //  parse the base URL string and conglomerate them.
  492. //
  493. if (isRelative() && baseURL)
  494. {
  495. if (*baseURL)
  496. {
  497. XMLURL basePart(baseURL, fMemoryManager);
  498. if (!conglomerateWithBase(basePart, false))
  499. {
  500. cleanup();
  501. ThrowXML(MalformedURLException, XMLExcepts::URL_RelativeBaseURL);
  502. }
  503. }
  504. }
  505. }
  507. void XMLURL::setURL(const XMLURL&         baseURL
  508.                   , const XMLCh* const    relativeURL)
  509. {
  510.     cleanup();
  512. // Parse our URL string
  513.     parse(relativeURL);
  515.     // If its relative, then conglomerate with the base URL
  516.     if (isRelative())
  517. conglomerateWithBase(baseURL);
  518. }
  521. // ---------------------------------------------------------------------------
  522. //  XMLURL: Miscellaneous methods
  523. // ---------------------------------------------------------------------------
  524. bool XMLURL::isRelative() const
  525. {
  526.     // If no protocol then relative
  527.     if (fProtocol == Unknown)
  528.         return true;
  530.     // If no path, or the path is not absolute, then relative
  531.     if (!fPath)
  532.         return true;
  534.     if (*fPath != chForwardSlash)
  535.         return true;
  537.     return false;
  538. }
  541. bool XMLURL::hasInvalidChar() const {
  542.     return fHasInvalidChar;
  543. }
  546. BinInputStream* XMLURL::makeNewStream() const
  547. {
  548.     //
  549.     //  If its a local host, then we short circuit it and use our own file
  550.     //  stream support. Otherwise, we just let it fall through and let the
  551.     //  installed network access object provide a stream.
  552.     //
  553.     if (fProtocol == XMLURL::File)
  554.     {
  555.         if (!fHost || !XMLString::compareIString(fHost, XMLUni::fgLocalHostString))
  556.         {
  558.             XMLCh* realPath = XMLString::replicate(fPath, fMemoryManager);
  559.             ArrayJanitor<XMLCh> basePathName(realPath, fMemoryManager);
  561.             //
  562.             // Need to manually replace any character reference %xx first
  563.             // HTTP protocol will be done automatically by the netaccessor
  564.             //
  565.             int end = XMLString::stringLen(realPath);
  566.             int percentIndex = XMLString::indexOf(realPath, chPercent, 0);
  568.             while (percentIndex != -1) {
  570.                 if (percentIndex+2 >= end ||
  571.                     !isHexDigit(realPath[percentIndex+1]) ||
  572.                     !isHexDigit(realPath[percentIndex+2]))
  573.                 {
  574.                     XMLCh value1[4];
  575.                     XMLString::moveChars(value1, &(realPath[percentIndex]), 3);
  576.                     value1[3] = chNull;
  577.                     ThrowXML2(MalformedURLException
  578.                             , XMLExcepts::XMLNUM_URI_Component_Invalid_EscapeSequence
  579.                             , realPath
  580.                             , value1);
  581.                 }
  583.                 unsigned int value = (xlatHexDigit(realPath[percentIndex+1]) * 16) + xlatHexDigit(realPath[percentIndex+2]);
  585.                 realPath[percentIndex] = XMLCh(value);
  587.                 int i =0;
  588.                 for (i = percentIndex + 1; i < end - 2 ; i++)
  589.                     realPath[i] = realPath[i+2];
  590.                 realPath[i] = chNull;
  591.                 end = i;
  593.                 percentIndex = XMLString::indexOf(realPath, chPercent, percentIndex);
  594.             }
  597.             BinFileInputStream* retStrm = new (fMemoryManager) BinFileInputStream(realPath);
  598.             if (!retStrm->getIsOpen())
  599.             {
  600.                 delete retStrm;
  601.                 return 0;
  602.             }
  603.             return retStrm;
  604.         }
  605.     }
  607.     //
  608.     //  If we don't have have an installed net accessor object, then we
  609.     //  have to just throw here.
  610.     //
  611.     if (!XMLPlatformUtils::fgNetAccessor)
  612.         ThrowXML(MalformedURLException, XMLExcepts::URL_UnsupportedProto);
  614.     // Else ask the net accessor to create the stream
  615.     return XMLPlatformUtils::fgNetAccessor->makeNew(*this);
  616. }
  618. void XMLURL::makeRelativeTo(const XMLCh* const baseURLText)
  619. {
  620.     // If this one is not relative, don't bother
  621.     if (!isRelative())
  622.         return;
  624.     XMLURL baseURL(baseURLText, fMemoryManager);
  625.     conglomerateWithBase(baseURL);
  626. }
  628. void XMLURL::makeRelativeTo(const XMLURL& baseURL)
  629. {
  630.     // If this one is not relative, don't bother
  631.     if (!isRelative())
  632.         return;
  633.     conglomerateWithBase(baseURL);
  634. }
  639. // ---------------------------------------------------------------------------
  640. //  XMLURL: Private helper methods
  641. // ---------------------------------------------------------------------------
  643. //
  644. //  This method will take the broken out parts of the URL and build up the
  645. //  full text. We don't do this unless someone asks us to, since its often
  646. //  never required.
  647. //
  648. void XMLURL::buildFullText()
  649. {
  650.     // Calculate the worst case size of the buffer required
  651.     unsigned int bufSize = gMaxProtoLen + 1
  652.                            + XMLString::stringLen(fFragment) + 1
  653.                            + XMLString::stringLen(fHost) + 2
  654.                            + XMLString::stringLen(fPassword) + 1
  655.                            + XMLString::stringLen(fPath)
  656.                            + XMLString::stringLen(fQuery) + 1
  657.                            + XMLString::stringLen(fUser) + 1
  658.                            + 32;
  660.     // Clean up the existing buffer and allocate another
  661.     fMemoryManager->deallocate(fURLText);//delete [] fURLText;
  662.     fURLText = (XMLCh*) fMemoryManager->allocate((bufSize) * sizeof(XMLCh));//new XMLCh[bufSize];
  663.     *fURLText = 0;
  665.     XMLCh* outPtr = fURLText;
  666.     if (fProtocol != Unknown)
  667.     {
  668.         XMLString::catString(fURLText, getProtocolName());
  669.         outPtr += XMLString::stringLen(fURLText);
  670.         *outPtr++ = chColon;
  671.         *outPtr++ = chForwardSlash;
  672.         *outPtr++ = chForwardSlash;
  673.     }
  675.     if (fUser)
  676.     {
  677.         XMLString::copyString(outPtr, fUser);
  678.         outPtr += XMLString::stringLen(fUser);
  680.         if (fPassword)
  681.         {
  682.             *outPtr++ = chColon;
  683.             XMLString::copyString(outPtr, fPassword);
  684.             outPtr += XMLString::stringLen(fPassword);
  685.         }
  687.         *outPtr++ = chAt;
  688.     }
  690.     if (fHost)
  691.     {
  692.         XMLString::copyString(outPtr, fHost);
  693.         outPtr += XMLString::stringLen(fHost);
  695.         //
  696.         //  If the port is zero, then we don't put it in. Else we need
  697.         //  to because it was explicitly provided.
  698.         //
  699.         if (fPortNum)
  700.         {
  701.             *outPtr++ = chColon;
  703.             XMLCh tmpBuf[16];
  704.             XMLString::binToText(fPortNum, tmpBuf, 16, 10);
  705.             XMLString::copyString(outPtr, tmpBuf);
  706.             outPtr += XMLString::stringLen(tmpBuf);
  707.         }
  708.     }
  710.     if (fPath)
  711.     {
  712.         XMLString::copyString(outPtr, fPath);
  713.         outPtr += XMLString::stringLen(fPath);
  714.     }
  716.     if (fQuery)
  717.     {
  718.         *outPtr++ = chQuestion;
  719.         XMLString::copyString(outPtr, fQuery);
  720.         outPtr += XMLString::stringLen(fQuery);
  721.     }
  723.     if (fFragment)
  724.     {
  725.         *outPtr++ = chPound;
  726.         XMLString::copyString(outPtr, fFragment);
  727.         outPtr += XMLString::stringLen(fFragment);
  728.     }
  730.     // Cap it off in case the last op was not a string copy
  731.     *outPtr = 0;
  732. }
  735. //
  736. //  Just a central place to handle cleanup, since its done from a number
  737. //  of different spots.
  738. //
  739. void XMLURL::cleanup()
  740. {
  741.     fMemoryManager->deallocate(fFragment);//delete [] fFragment;
  742.     fMemoryManager->deallocate(fHost);//delete [] fHost;
  743.     fMemoryManager->deallocate(fPassword);//delete [] fPassword;
  744.     fMemoryManager->deallocate(fPath);//delete [] fPath;
  745.     fMemoryManager->deallocate(fQuery);//delete [] fQuery;
  746.     fMemoryManager->deallocate(fUser);//delete [] fUser;
  747.     fMemoryManager->deallocate(fURLText);//delete [] fURLText;
  749.     fFragment = 0;
  750.     fHost = 0;
  751.     fPassword = 0;
  752.     fPath = 0;
  753.     fQuery = 0;
  754.     fUser = 0;
  755.     fURLText = 0;
  757.     fProtocol = Unknown;
  758.     fPortNum = 0;
  759. }
  762. //This function  has been modified to take a bool parameter and the
  763. //functionality inside looks irrational but is only to make
  764. //solaris 2.7 CC 5.0 optimized build happy.
  766. bool XMLURL::conglomerateWithBase(const XMLURL& baseURL, bool useExceptions)
  767. {
  768.     // The base URL cannot be relative
  769.     if (baseURL.isRelative())
  770.     {
  771.         if (useExceptions)
  772. ThrowXML(MalformedURLException, XMLExcepts::URL_RelativeBaseURL);
  773.         else
  774.             return false;
  775.     }
  777.     //
  778.     //  Check a special case. If all we have is a fragment, then we want
  779.     //  to just take the base host and path, plus our fragment.
  780.     //
  781.     if ((fProtocol == Unknown)
  782.     &&  !fHost
  783.     &&  !fPath
  784.     &&  fFragment)
  785.     {
  786.         // Just in case, make sure we don't leak the user or password values
  787.         fMemoryManager->deallocate(fUser);//delete [] fUser;
  788.         fUser = 0;
  789.         fMemoryManager->deallocate(fPassword);//delete [] fPassword;
  790.         fPassword = 0;
  792.         // Copy over the protocol and port number as is
  793.         fProtocol = baseURL.fProtocol;
  794.         fPortNum = baseURL.fPortNum;
  796.         // Replicate the base fields that are provided
  797.         fHost = XMLString::replicate(baseURL.fHost, fMemoryManager);
  798.         fUser = XMLString::replicate(baseURL.fUser, fMemoryManager);
  799.         fPassword = XMLString::replicate(baseURL.fPassword, fMemoryManager);
  800.         fPath = XMLString::replicate(baseURL.fPath, fMemoryManager);
  801.         return true;
  802.     }
  804.     //
  805.     //  All we have to do is run up through our fields and, for each one
  806.     //  that we don't have, use the based URL's. Once we hit one field
  807.     //  that we have, we stop.
  808.     //
  809.     if (fProtocol != Unknown)
  810.         return true;
  811.     fProtocol = baseURL.fProtocol;
  813.     //
  814.     //  If the protocol is not file, and we either already have our own
  815.     //  host, or the base does not have one, then we are done.
  816.     //
  817.     if (fProtocol != File)
  818.     {
  819.         if (fHost || !baseURL.fHost)
  820.             return true;
  821.     }
  823.     // Replicate all of the hosty stuff if the base has one
  824.     if (baseURL.fHost)
  825.     {
  826.         // Just in case, make sure we don't leak a user or password field
  827.         fMemoryManager->deallocate(fUser);//delete [] fUser;
  828.         fUser = 0;
  829.         fMemoryManager->deallocate(fPassword);//delete [] fPassword;
  830.         fPassword = 0;
  831.         fMemoryManager->deallocate(fHost);//delete [] fHost;
  832.         fHost = 0;
  834.         fHost = XMLString::replicate(baseURL.fHost, fMemoryManager);
  835.         fUser = XMLString::replicate(baseURL.fUser, fMemoryManager);
  836.         fPassword = XMLString::replicate(baseURL.fPassword, fMemoryManager);
  838.         fPortNum = baseURL.fPortNum;
  839.     }
  841.     // If we have a path and its absolute, then we are done
  842.     const bool hadPath = (fPath != 0);
  843.     if (hadPath)
  844.     {
  845.         if (*fPath == chForwardSlash)
  846.             return true;
  847.     }
  849.     // Its a relative path, so weave them together.
  850.     if (baseURL.fPath) {
  851.         XMLCh* temp = XMLPlatformUtils::weavePaths(baseURL.fPath, fPath);
  852.         fMemoryManager->deallocate(fPath);//delete [] fPath;
  853.         fPath = temp;
  854.     }
  856.     // If we had any original path, then we are done
  857.     if (hadPath)
  858.         return true;
  860.     // We had no original path, so go on to deal with the query/fragment parts
  861.     if (fQuery || !baseURL.fQuery)
  862.         return true;
  863.     fQuery = XMLString::replicate(baseURL.fQuery, fMemoryManager);
  865.     if (fFragment || !baseURL.fFragment)
  866.         return true;
  867.     fFragment = XMLString::replicate(baseURL.fFragment, fMemoryManager);
  868. return true;
  869. }
  872. void XMLURL::parse(const XMLCh* const urlText)
  873. {
  874.     // Simplify things by checking for the psycho scenarios first
  875.     if (!*urlText)
  876.         ThrowXML(MalformedURLException, XMLExcepts::URL_NoProtocolPresent);
  878.     // Before we start, check if this urlText contains valid uri characters
  879.     if (!XMLUri::isURIString(urlText))
  880.         fHasInvalidChar = true;
  881.     else
  882.         fHasInvalidChar = false;
  884.     //
  885.     //  The first thing we will do is to check for a file name, so that
  886.     //  we don't waste time thinking its a URL. If its in the form x:
  887.     //  or x:/ and x is an ASCII letter, then assume that's the deal.
  888.     //
  889.     if (((*urlText >= chLatin_A) && (*urlText <= chLatin_Z))
  890.     ||  ((*urlText >= chLatin_a) && (*urlText <= chLatin_z)))
  891.     {
  892.         if (*(urlText + 1) == chColon)
  893.         {
  894.             if ((*(urlText + 2) == chForwardSlash)
  895.             ||  (*(urlText + 2) == chBackSlash))
  896.             {
  897.                 ThrowXML(MalformedURLException, XMLExcepts::URL_NoProtocolPresent);
  898.             }
  899.         }
  900.     }
  902.     // Get a copy of the URL that we can modify
  903.     XMLCh* srcCpy = XMLString::replicate(urlText, fMemoryManager);
  904.     ArrayJanitor<XMLCh> janSrcCopy(srcCpy, fMemoryManager);
  906.     //
  907.     //  Get a pointer now that we can run up thrown the source as we parse
  908.     //  bits and pieces out of it.
  909.     //
  910.     XMLCh* srcPtr = srcCpy;
  912.     // Run up past any spaces
  913.     while (*srcPtr)
  914.     {
  915.         if (!XMLPlatformUtils::fgTransService->isSpace(*srcPtr))
  916.             break;
  917.         srcPtr++;
  918.     }
  920.     // Make sure it wasn't all space
  921.     if (!*srcPtr)
  922.         ThrowXML(MalformedURLException, XMLExcepts::URL_NoProtocolPresent);
  924.     //
  925.     //  Ok, the next thing we have to do is to find either a / or : character.
  926.     //  If the : is first, we assume we have a protocol. If the / is first,
  927.     //  then we skip to the host processing.
  928.     //
  929.     static const XMLCh listOne[]    = { chColon, chForwardSlash, chNull };
  930.     static const XMLCh listTwo[]    = { chAt, chNull };
  931.     static const XMLCh listThree[]  = { chColon, chNull };
  932.     static const XMLCh listFour[]   = { chForwardSlash, chNull };
  933.     static const XMLCh listFive[]   = { chPound, chQuestion, chNull };
  934.     static const XMLCh listSix[]    = { chPound, chNull };
  935.     XMLCh* ptr1 = XMLString::findAny(srcPtr, listOne);
  936.     XMLCh* ptr2;
  938.     // If we found a protocol, then deal with it
  939.     if (ptr1)
  940.     {
  941.         if (*ptr1 == chColon)
  942.         {
  943.             // Cap the string at the colon
  944.             *ptr1 = 0;
  946.             // And try to find it in our list of protocols
  947.             fProtocol = lookupByName(srcPtr);
  949.             if (fProtocol == Unknown)
  950.             {
  951.                 ThrowXML1
  952.                 (
  953.                     MalformedURLException
  954.                     , XMLExcepts::URL_UnsupportedProto1
  955.                     , srcPtr
  956.                 );
  957.             }
  959.             // And move our source pointer up past what we've processed
  960.             srcPtr = (ptr1 + 1);
  961.         }
  962.     }
  964.     //
  965.     //  Ok, next we need to see if we have any host part. If the next
  966.     //  two characters are //, then we need to check, else move on.
  967.     //
  968.     if ((*srcPtr == chForwardSlash) && (*(srcPtr + 1) == chForwardSlash))
  969.     {
  970.         // Move up past the slashes
  971.         srcPtr += 2;
  973.         //
  974.         //  If we aren't at the end of the string, then there has to be a
  975.         //  host part at this point. we will just look for the next / char
  976.         //  or end of string and make all of that the host for now.
  977.         //
  978.         if (*srcPtr)
  979.         {
  980.             // Search from here for a / character
  981.             ptr1 = XMLString::findAny(srcPtr, listFour);
  983.             //
  984.             //  If we found something, then the host is between where
  985.             //  we are and what we found. Else the host is the rest of
  986.             //  the content and we are done. If its empty, leave it null.
  987.             //
  988.             if (ptr1)
  989.             {
  990.                 if (ptr1 != srcPtr)
  991.                 {
  992.                     fMemoryManager->deallocate(fHost);//delete [] fHost;
  993.                     fHost = (XMLCh*) fMemoryManager->allocate
  994.                     (
  995.                         (ptr1 - srcPtr + 1) * sizeof(XMLCh)
  996.                     );//new XMLCh[(ptr1 - srcPtr) + 1];
  997.                     ptr2 = fHost;
  998.                     while (srcPtr < ptr1)
  999.                         *ptr2++ = *srcPtr++;
  1000.                     *ptr2 = 0;
  1001.                 }
  1002.             }
  1003.              else
  1004.             {
  1005.                 fMemoryManager->deallocate(fHost);//delete [] fHost;
  1006.                 fHost = XMLString::replicate(srcPtr, fMemoryManager);
  1008.                 // Update source pointer to the end
  1009.                 srcPtr += XMLString::stringLen(fHost);
  1010.             }
  1011.         }
  1012.     }
  1013.     else
  1014.     {
  1015.         //
  1016.         // http protocol requires two forward slashes
  1017.         // we didn't get them, so throw an exception
  1018.         //
  1019.         if (fProtocol == HTTP) {
  1020.             ThrowXML
  1021.                 (
  1022.                     MalformedURLException
  1023.                     , XMLExcepts::URL_ExpectingTwoSlashes
  1024.                 );
  1025.         }
  1026.     }
  1028.     //
  1029.     //  If there was a host part, then we have to grovel through it for
  1030.     //  all the bits and pieces it can hold.
  1031.     //
  1032.     if (fHost)
  1033.     {
  1034.         //
  1035.         //  Look for a '@' character, which indicates a user name. If we
  1036.         //  find one, then everything between the start of the host data
  1037.         //  and the character is the user name.
  1038.         //
  1039.         ptr1 = XMLString::findAny(fHost, listTwo);
  1040.         if (ptr1)
  1041.         {
  1042.             // Get this info out as the user name
  1043.             *ptr1 = 0;
  1044.             fMemoryManager->deallocate(fUser);//delete [] fUser;
  1045.             fUser = XMLString::replicate(fHost, fMemoryManager);
  1046.             ptr1++;
  1048.             // And now cut these chars from the host string
  1049.             XMLString::cut(fHost, ptr1 - fHost);
  1051.             // Is there a password inside the user string?
  1052.             ptr2 = XMLString::findAny(fUser, listThree);
  1053.             if (ptr2)
  1054.             {
  1055.                 // Remove it from the user name string
  1056.                 *ptr2 = 0;
  1058.                 // And copy out the remainder to the password field
  1059.                 ptr2++;
  1060.                 fMemoryManager->deallocate(fPassword);//delete [] fPassword;
  1061.                 fPassword = XMLString::replicate(ptr2, fMemoryManager);
  1062.             }
  1063.         }
  1065.         //
  1066.         //  Ok, so now we are at the actual host name, if any. If we are
  1067.         //  not at the end of the host data, then lets see if we have a
  1068.         //  port trailing the
  1069.         //
  1070.         ptr1 = XMLString::findAny(fHost, listThree);
  1071.         if (ptr1)
  1072.         {
  1073.             // Remove it from the host name
  1074.             *ptr1 = 0;
  1076.             // Try to convert it to a numeric port value and store it
  1077.             ptr1++;
  1078.             if (!XMLString::textToBin(ptr1, fPortNum))
  1079.                 ThrowXML(MalformedURLException, XMLExcepts::URL_BadPortField);
  1080.         }
  1082.         // If the host ended up empty, then toss is
  1083.         if (!*fHost)
  1084.         {
  1085.             delete[] fHost;
  1086.             fHost = 0;
  1087.         }
  1088.     }
  1090.     // If we are at the end, then we are done now
  1091.     if (!*srcPtr)
  1092. {
  1093.         return;
  1094. }
  1096.     //
  1097.     //  Next is the path part. It can be absolute, i.e. starting with a
  1098.     //  forward slash character, or relative. Its basically everything up
  1099.     //  to the end of the string or to any trailing query or fragment.
  1100.     //
  1101.     ptr1 = XMLString::findAny(srcPtr, listFive);
  1102.     if (!ptr1)
  1103.     {
  1104.         fMemoryManager->deallocate(fPath);//delete [] fPath;
  1105.         fPath = XMLString::replicate(srcPtr, fMemoryManager);
  1106.         return;
  1107.     }
  1109.     // Everything from where we are to what we found is the path
  1110.     if (ptr1 > srcPtr)
  1111.     {
  1112.         fMemoryManager->deallocate(fPath);//delete [] fPath;
  1113.         fPath = (XMLCh*) fMemoryManager->allocate
  1114.         (
  1115.             (ptr1 - srcPtr + 1) * sizeof(XMLCh)
  1116.         );//new XMLCh[(ptr1 - srcPtr) + 1];
  1117.         ptr2 = fPath;
  1118.         while (srcPtr < ptr1)
  1119.             *ptr2++ = *srcPtr++;
  1120.         *ptr2 = 0;
  1121.     }
  1123.     //
  1124.     //  If we found a fragment, then it is the rest of the string and we
  1125.     //  are done.
  1126.     //
  1127.     if (*srcPtr == chPound)
  1128.     {
  1129.         srcPtr++;
  1130.         fMemoryManager->deallocate(fFragment);//delete [] fFragment;
  1131.         fFragment = XMLString::replicate(srcPtr, fMemoryManager);
  1132.         return;
  1133.     }
  1135.     //
  1136.     //  The query is either the rest of the string, or up to the fragment
  1137.     //  separator.
  1138.     //
  1139.     srcPtr++;
  1140.     ptr1 = XMLString::findAny(srcPtr, listSix);
  1141.     fMemoryManager->deallocate(fQuery);//delete [] fQuery;
  1142.     if (!ptr1)
  1143.     {
  1144.         fQuery = XMLString::replicate(srcPtr, fMemoryManager);
  1145.         return;
  1146.     }
  1147.      else
  1148.     {
  1149.         fQuery = (XMLCh*) fMemoryManager->allocate
  1150.         (
  1151.             (ptr1 - srcPtr + 1) * sizeof(XMLCh)
  1152.         );//new XMLCh[(ptr1 - srcPtr) + 1];
  1153.         ptr2 = fQuery;
  1154.         while (srcPtr < ptr1)
  1155.             *ptr2++ = *srcPtr++;
  1156.         *ptr2 = 0;
  1157.     }
  1159.     // If we are not at the end now, then everything else is the fragment
  1160.     if (*srcPtr == chPound)
  1161.     {
  1162.         srcPtr++;
  1163.         fMemoryManager->deallocate(fFragment);//delete [] fFragment;
  1164.         fFragment = XMLString::replicate(srcPtr, fMemoryManager);
  1165.     }
  1166. }
  1169. XERCES_CPP_NAMESPACE_END