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

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

词法分析

开发平台：

Visual C++

MacOSPlatformUtils.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999-2000 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: MacOSPlatformUtils.cpp,v 1.18 2003/05/21 02:43:07 jberry Exp $
  59.  */
  62. // ---------------------------------------------------------------------------
  63. //  Includes
  64. // ---------------------------------------------------------------------------
  65. #include <cstring>
  66. #include <cstdlib>
  67. #include <cctype>
  68. #include <cstdio>
  69. #include <memory>
  70. #include <algorithm>
  72. #if defined(__APPLE__)
  73.     // Include from Frameworks Headers under ProjectBuilder
  74.     #include <Carbon/Carbon.h>
  75. #else
  76.     // Classic include styles
  77.     #include <Files.h>
  78.     #include <Gestalt.h>
  79.     #include <TextUtils.h>
  80.     #include <TextEncodingConverter.h>
  81.     #include <Multiprocessing.h>
  82.     #include <DriverSynchronization.h>
  83.     #include <DriverServices.h>
  84.     #include <CFString.h>
  85.     #include <URLAccess.h>
  86. #endif
  88. #include <xercesc/util/XercesDefs.hpp>
  89. #include <xercesc/util/Janitor.hpp>
  90. #include <xercesc/util/PlatformUtils.hpp>
  91. #include <xercesc/util/RuntimeException.hpp>
  92. #include <xercesc/util/XMLUniDefs.hpp>
  93. #include <xercesc/util/XMLUni.hpp>
  94. #include <xercesc/util/XMLString.hpp>
  95. #include <xercesc/util/Platforms/MacOS/MacOSPlatformUtils.hpp>
  96. #include <xercesc/util/Platforms/MacOS/MacCarbonFile.hpp>
  97. #include <xercesc/util/Platforms/MacOS/MacPosixFile.hpp>
  98. #include <xercesc/util/PanicHandler.hpp>
  100. #if (defined(XML_USE_INMEMORY_MSGLOADER) || defined(XML_USE_INMEM_MESSAGELOADER))
  101.    #include <xercesc/util/MsgLoaders/InMemory/InMemMsgLoader.hpp>
  102. #endif
  103. #if (defined(XML_USE_MACOS_UNICODECONVERTER) || defined(XML_USE_NATIVE_TRANSCODER))
  104.    #include <xercesc/util/Transcoders/MacOSUnicodeConverter/MacOSUnicodeConverter.hpp>
  105. #endif
  107. // Make up our minds about which netaccessor we'll use
  108. #if (defined(XML_USE_NETACCESSOR_URLACCESSCF) || (defined(XML_USE_NETACCESSOR_NATIVE) && TARGET_API_MAC_CARBON))
  109.     #define USE_URLACCESSCF
  110. #elif (defined(XML_USE_NETACCESSOR_URLACCESS) || (defined(XML_USE_NETACCESSOR_NATIVE) && !TARGET_API_MAC_CARBON))
  111.     #define USE_URLACCESS
  112. #endif
  114. #if defined(USE_URLACCESSCF)
  115.    #include <xercesc/util/NetAccessors/MacOSURLAccessCF/MacOSURLAccessCF.hpp>
  116. #elif defined(USE_URLACCESS)
  117.    #include <xercesc/util/NetAccessors/MacOSURLAccess/MacOSURLAccess.hpp>
  118. #endif
  120. XERCES_CPP_NAMESPACE_BEGIN
  122. //----------------------------------------------------------------------------
  123. // Function Prototypes
  124. //----------------------------------------------------------------------------
  125. XMLCh* ConvertColonToSlash(XMLCh* p, std::size_t charCount);
  126. XMLCh* ConvertSlashToColon(XMLCh* p, std::size_t charCount);
  127. char* ConvertSlashToColon(char* p, std::size_t charCount);
  129. XMLCh* XMLCreateFullPathFromFSRef_X(const FSRef& startingRef, MemoryManager* const manager);
  130. XMLCh* XMLCreateFullPathFromFSRef_Classic(const FSRef& startingRef, MemoryManager* const manager);
  131. XMLCh* XMLCreateFullPathFromFSSpec_Classic(const FSSpec& startingSpec,
  132.                                             MemoryManager* const manager);
  133. bool XMLParsePathToFSRef_X(const XMLCh* const pathName, FSRef& ref, MemoryManager* const manager);
  134. bool XMLParsePathToFSRef_Classic(const XMLCh* const pathName, FSRef& ref, MemoryManager* const manager);
  135. bool XMLParsePathToFSSpec_Classic(const XMLCh* const pathName, FSSpec& spec, MemoryManager* const manager);
  138. //----------------------------------------------------------------------------
  139. //  Local Data
  140. //
  141. //  gFileSystemCompatible
  142. //   This flag indicates whether the file system APIs meet our minimum
  143. //   requirements.
  144. //
  145. // gHasFSSpecAPIs
  146. //   True if the FSSpecAPIs are available. These are required.
  147. //
  148. // gHasF2TBAPIs
  149. //   True if the FS supports 2 terrabyte calls. These are required for
  150. //   use under Carbon.
  151. //
  152. // gHasHFSPlusAPIs
  153. //   True if the FS supports HFSPlus APIs. If this is true, then the
  154. //   new Fork calls are used, and all file name and path handling
  155. //   uses long unicode names. Note that once a file is opened with
  156. //   the fork calls, only fork calls may be used to access it.
  157. //
  158. // gHasFSPathAPIs
  159. //   True if the FS supports path creation APIs FSPathMakeRef and
  160. //  FSRefMakePath.
  161. //
  162. // gPathAPIsUsePosixPaths
  163. //   True if the path creation APIs FSPathMakeRef and FSRefMakePath
  164. //  use posix, rather than HFS, style paths. If so, these routines
  165. //  are used to support path creation and  interpretation.
  166. //
  167. // gHasMPAPIs
  168. //  True if the Multiprocessing APIs are available.
  169. //
  170. // gUsePosixFiles
  171. //   True if we're using XMLMacPosixFile rather than XMLMacCarbonFile.
  172. //----------------------------------------------------------------------------
  173. bool gFileSystemCompatible = false;
  174. bool gHasFSSpecAPIs = false;
  175. bool gHasFS2TBAPIs = false;
  176. bool gHasHFSPlusAPIs = false;
  177. bool gHasFSPathAPIs = false;
  178. bool gPathAPIsUsePosixPaths = false;
  179. bool gHasMPAPIs = false;
  180. bool gUsePosixFiles = false;
  183. // ---------------------------------------------------------------------------
  184. //  XMLPlatformUtils: The panic method
  185. // ---------------------------------------------------------------------------
  186. void 
  187. XMLPlatformUtils::panic(const PanicHandler::PanicReasons reason)
  188. {
  189.     if (fgUserPanicHandler)
  190. fgUserPanicHandler->panic(reason);
  191. else
  192. fgDefaultPanicHandler->panic(reason);
  193. }
  196. // ---------------------------------------------------------------------------
  197. //  XMLPlatformUtils: File Methods
  198. // ---------------------------------------------------------------------------
  199. unsigned int
  200. XMLPlatformUtils::curFilePos(const FileHandle theFile)
  201. {
  202. return reinterpret_cast<XMLMacAbstractFile*>(theFile)->currPos();
  203. }
  205. void
  206. XMLPlatformUtils::closeFile(const FileHandle theFile)
  207. {
  208.     reinterpret_cast<XMLMacAbstractFile*>(theFile)->close();
  209. }
  211. unsigned int
  212. XMLPlatformUtils::fileSize(const FileHandle theFile)
  213. {
  214.     return reinterpret_cast<XMLMacAbstractFile*>(theFile)->size();
  215. }
  218. FileHandle
  219. XMLPlatformUtils::openFile(const char* const fileName)
  220. {
  221.     // Check to make sure the file system is in a state where we can use it
  222.     if (!gFileSystemCompatible)
  223.         ThrowXML1(XMLPlatformUtilsException, XMLExcepts::File_CouldNotOpenFile, fileName);
  225.     Janitor<XMLMacAbstractFile> file(XMLMakeMacFile());
  226.     
  227.     return (file->open(fileName, false)) ? file.release() : NULL;
  228. }
  231. FileHandle
  232. XMLPlatformUtils::openFile(const XMLCh* const fileName)
  233. {
  234.     // Check to make sure the file system is in a state where we can use it
  235.     if (!gFileSystemCompatible)
  236.         ThrowXML1(XMLPlatformUtilsException, XMLExcepts::File_CouldNotOpenFile, fileName);
  238.     Janitor<XMLMacAbstractFile> file(XMLMakeMacFile());
  240.     return (file->open(fileName, false)) ? file.release() : NULL;
  241. }
  244. FileHandle
  245. XMLPlatformUtils::openFileToWrite(const char* const fileName)
  246. {
  247.     // Check to make sure the file system is in a state where we can use it
  248.     if (!gFileSystemCompatible)
  249.         ThrowXML1(XMLPlatformUtilsException, XMLExcepts::File_CouldNotOpenFile, fileName);
  251.     Janitor<XMLMacAbstractFile> file(XMLMakeMacFile());
  253.     return (file->open(fileName, true)) ? file.release() : NULL;
  254. }
  257. FileHandle
  258. XMLPlatformUtils::openFileToWrite(const XMLCh* const fileName)
  259. {
  260.     // Check to make sure the file system is in a state where we can use it
  261.     if (!gFileSystemCompatible)
  262.         ThrowXML1(XMLPlatformUtilsException, XMLExcepts::File_CouldNotOpenFile, fileName);
  264.     Janitor<XMLMacAbstractFile> file(XMLMakeMacFile());
  266.     return (file->open(fileName, true)) ? file.release() : NULL;
  267. }
  270. FileHandle
  271. XMLPlatformUtils::openStdInHandle()
  272. {
  273.     XMLCh stdinStr[] = {chLatin_s, chLatin_t, chLatin_d, chLatin_i, chLatin_n, chNull};
  274.     ThrowXML1(XMLPlatformUtilsException, XMLExcepts::File_CouldNotOpenFile, stdinStr);
  275.     return NULL;
  276. }
  279. unsigned int
  280. XMLPlatformUtils::readFileBuffer(   const FileHandle      theFile
  281.                                  ,  const unsigned int    toRead
  282.                                  ,        XMLByte* const  toFill)
  283. {
  284.     return reinterpret_cast<XMLMacAbstractFile*>(theFile)->read(toRead, toFill);
  285. }
  288. void
  289. XMLPlatformUtils::writeBufferToFile(   const   FileHandle   theFile
  290.                                     ,  const long     toWrite
  291.                                     ,  const XMLByte* const toFlush)
  292. {
  293.     return reinterpret_cast<XMLMacAbstractFile*>(theFile)->write(toWrite, toFlush);
  294. }
  297. void
  298. XMLPlatformUtils::resetFile(FileHandle theFile)
  299. {
  300.     reinterpret_cast<XMLMacAbstractFile*>(theFile)->reset();
  301. }
  304. // ---------------------------------------------------------------------------
  305. //  XMLPlatformUtils: File system methods
  306. // ---------------------------------------------------------------------------
  307. XMLCh*
  308. XMLPlatformUtils::getFullPath(const XMLCh* const srcPath,
  309.                               MemoryManager* const manager)
  310. {
  311.     XMLCh* path = NULL;
  313.     if (gHasHFSPlusAPIs)
  314.     {
  315.         FSRef ref;
  316.         if (   !XMLParsePathToFSRef(srcPath, ref, manager)
  317. || (path = XMLCreateFullPathFromFSRef(ref, manager)) == NULL
  318.    )
  319.             path = XMLString::replicate(srcPath, manager);
  320.     }
  321.     else
  322.     {
  323.         FSSpec spec;
  324.         if (   !XMLParsePathToFSSpec(srcPath, spec, manager)
  325.     || (path = XMLCreateFullPathFromFSSpec(spec, manager)) == NULL
  326.    )
  327.             path = XMLString::replicate(srcPath, manager);
  328.     }
  330.     return path;
  331. }
  334. bool
  335. XMLPlatformUtils::isRelative(const XMLCh* const toCheck)
  336. {
  337.     return (toCheck[0] != L'/');
  338. }
  341. XMLCh* XMLPlatformUtils::getCurrentDirectory(MemoryManager* const manager)
  342. {
  343. // Get a newly allocated path to the current directory
  344. FSSpec spec;
  345. XMLCh* path =
  346. (noErr == FSMakeFSSpec(0, 0, NULL, &spec))
  347. ? XMLCreateFullPathFromFSSpec(spec, manager)
  348. : NULL;
  350.     if (!path)
  351.  ThrowXML(XMLPlatformUtilsException,
  352.            XMLExcepts::File_CouldNotGetBasePathName);
  353.            
  354. return path;
  355. }
  358. inline bool XMLPlatformUtils::isAnySlash(XMLCh c) 
  359. {
  360. // We support only forward slash as a path delimiter
  361.     return (chForwardSlash == c);
  362. }
  365. // ---------------------------------------------------------------------------
  366. //  XMLPlatformUtils: Timing Methods
  367. // ---------------------------------------------------------------------------
  368. unsigned long
  369. XMLPlatformUtils::getCurrentMillis()
  370. {
  371. if ((void*)kUnresolvedCFragSymbolAddress != UpTime)
  372. {
  373. // Use Driver services routines, now in Carbon,
  374. // to get the elapsed milliseconds.
  375. AbsoluteTime time = UpTime();
  376. return AbsoluteToDuration(time);
  377. }
  378. else
  379. return TickCount() * 100 / 6;
  380. }
  383. // ---------------------------------------------------------------------------
  384. //  Mutex methods
  385. //
  386. // There are a number of choices for multi-threading on Mac OS. Traditionally
  387. // there was the Thread Manager, which provided cooperative multitasking on
  388. // 68K and PPC platforms, and preemptive multitasking on 68K platforms only.
  389. // The primary threading model supported under Carbon is the Multiprocessing
  390. // library, which as of version 2.0 provides a nice set of primitives. Under
  391. // Mac OS X, the Multiprocessing library is a thin veneer over pthreads.
  392. //
  393. // For lack of any really universal solutions, I've implemented these mutexes
  394. // atop the Multiprocessing library. The critical regions employed here
  395. // support recursive behavior, which is required by Xerces.
  396. //
  397. // Please note that, despite this implementation, there may be other barriers
  398. // to using Xerces in a multithreaded environment. The memory allocator
  399. // under Mac OS 9, for instance, is not thread safe.
  400. // ---------------------------------------------------------------------------
  402. void*
  403. XMLPlatformUtils::makeMutex()
  404. {
  405. if (gHasMPAPIs)
  406. {
  407. MPCriticalRegionID criticalRegion = NULL;
  408. OSStatus status = MPCreateCriticalRegion(&criticalRegion);
  409. return (status == noErr) ? (void*)(criticalRegion) : NULL;
  410. }
  411. else
  412. return (void*)1;
  413. }
  416. void
  417. XMLPlatformUtils::closeMutex(void* const mtxHandle)
  418. {
  419. if (gHasMPAPIs)
  420. {
  421. MPCriticalRegionID criticalRegion = reinterpret_cast<MPCriticalRegionID>(mtxHandle);
  422. OSStatus status = MPDeleteCriticalRegion(criticalRegion);
  423. status = noErr; // ignore any error and zap compiler warning
  424. }
  425. else
  426. ;
  427. }
  430. void
  431. XMLPlatformUtils::lockMutex(void* const mtxHandle)
  432. {
  433. if (gHasMPAPIs)
  434. {
  435. MPCriticalRegionID criticalRegion = reinterpret_cast<MPCriticalRegionID>(mtxHandle);
  436. OSStatus status = MPEnterCriticalRegion(criticalRegion, kDurationForever);
  437. status = noErr; // ignore any error and zap compiler warning
  438. }
  439. else
  440. ;
  441. }
  444. void
  445. XMLPlatformUtils::unlockMutex(void* const mtxHandle)
  446. {
  447. if (gHasMPAPIs)
  448. {
  449. MPCriticalRegionID criticalRegion = reinterpret_cast<MPCriticalRegionID>(mtxHandle);
  450. OSStatus status = MPExitCriticalRegion(criticalRegion);
  451. status = noErr; // ignore any error and zap compiler warning
  452. }
  453. else
  454. ;
  455. }
  458. // ---------------------------------------------------------------------------
  459. //  Miscellaneous synchronization methods
  460. //
  461. // Atomic manipulation is implemented atop routines that were traditionally
  462. // part of DriverServices, but are now a part of Carbon.
  463. // ---------------------------------------------------------------------------
  465. void*
  466. XMLPlatformUtils::compareAndSwap(       void**      toFill
  467.                                  , const void* const newValue
  468.                                  , const void* const toCompare)
  469. {
  470.     // Replace *toFill with newValue iff *toFill == toCompare,
  471.     // returning previous value of *toFill
  473.     Boolean success = CompareAndSwap(
  474.         reinterpret_cast<UInt32>(toCompare),
  475.         reinterpret_cast<UInt32>(newValue),
  476.         reinterpret_cast<UInt32*>(toFill));
  478.     return (success) ? const_cast<void*>(toCompare) : *toFill;
  479. }
  482. //
  483. // Atomic Increment and Decrement
  484. //
  485. // Apple's routines return the value as it was before the
  486. // operation, while these routines want to return it as it
  487. // is after. So we perform the translation before returning
  488. // the value.
  489. //
  490. int
  491. XMLPlatformUtils::atomicIncrement(int &location)
  492. {
  493.     return IncrementAtomic(reinterpret_cast<long*>(&location)) + 1;
  494. }
  497. int
  498. XMLPlatformUtils::atomicDecrement(int &location)
  499. {
  500.     return DecrementAtomic(reinterpret_cast<long*>(&location)) - 1;
  501. }
  504. // ---------------------------------------------------------------------------
  505. //  XMLPlatformUtils: Private Static Methods
  506. // ---------------------------------------------------------------------------
  508. //
  509. //  This method handles the MacOS basic init functions.
  510. //
  511. void
  512. XMLPlatformUtils::platformInit()
  513. {
  514. long value = 0;
  516. // Detect available functions
  518.     // Look for file system services
  519.     if (noErr == Gestalt(gestaltFSAttr, &value))
  520.     {
  521.         gHasFSSpecAPIs = (value & (1 << gestaltHasFSSpecCalls)) != 0;
  522.         gHasFS2TBAPIs = (value & (1 << gestaltFSSupports2TBVols)) != 0;
  523.         gHasHFSPlusAPIs = (value & (1 << gestaltHasHFSPlusAPIs)) != 0;
  525.         #if TARGET_API_MAC_CARBON
  526.         gHasFSPathAPIs = ((void*)kUnresolvedCFragSymbolAddress != FSPathMakeRef);
  527.         #else
  528.         gHasFSPathAPIs = false;
  529.         #endif
  531.         gPathAPIsUsePosixPaths = gHasFSPathAPIs
  532.  && (value & (1 << gestaltFSUsesPOSIXPathsForConversion));
  533.     }
  535. // We require FSSpecs at a minimum
  536.     gFileSystemCompatible = gHasFSSpecAPIs;
  538. // Determine which file system to use (posix or carbon file access)
  539. // If we're using Metrowerks MSL, we surely don't want posix paths,
  540. // as MSL doesn't use them.
  541. #if __MSL__ && (__MSL__ < 0x08000 || _MSL_CARBON_FILE_APIS)
  542. gUsePosixFiles = false;
  543. #else
  544. gUsePosixFiles = noErr == Gestalt(gestaltSystemVersion, &value)
  545.   && value >= 0x00001000
  546.   ;
  547. #endif
  549.     // Look for MP
  550. gHasMPAPIs = MPLibraryIsLoaded();
  551. }
  554. //
  555. //  This method handles the MacOS basic termination functions.
  556. //
  557. void
  558. XMLPlatformUtils::platformTerm()
  559. {
  560. }
  563. // ---------------------------------------------------------------------------
  564. //  XMLPlatformUtils: Private Static Methods
  565. // ---------------------------------------------------------------------------
  567. //
  568. //  This method is called by the platform independent part of this class
  569. //  during initialization. We have to create the type of net accessor that
  570. //  we want to use. If none, then just return zero.
  571. //
  572. XMLNetAccessor*
  573. XMLPlatformUtils::makeNetAccessor()
  574. {
  575.     // The selection of NetAcessor is made through
  576.     // the following preprocessor defines:
  577.     //
  578.     // XML_USE_NETACCESSOR_URLACCESS -- Use netaccessor based on URLAccess
  579.     // XML_USE_NETACCESSOR_URLACCESSCF -- Use netaccessor based on CFURLAccess (CoreFoundation based)
  580.     // XML_USE_NETACCESSOR_NATIVE -- In absence of above selections, chooses URLACCESSCF
  581.     //    if targetting Carbon, and URLAccess otherwise
  582.     //
  583.     // These choices are resolved at the ^^^top^^^ of this file.
  585. #if (defined(USE_URLACCESSCF))
  586.     // Use the URLAccess code that relies only on CoreFoundation
  587. return new MacOSURLAccessCF;
  588. #elif (defined(USE_URLACCESS))
  589. // Only try to use URLAccess if it's actually available
  590. if (URLAccessAvailable())
  591. return new MacOSURLAccess;
  592. #endif
  594. // No netaccessor available--we can live with it, but you won't
  595. // get net access.
  596. return 0;
  597. }
  600. //
  601. //  This method is called by the platform independent part of this class
  602. //  when client code asks to have one of the supported message sets loaded.
  603. //
  604. XMLMsgLoader*
  605. XMLPlatformUtils::loadAMsgSet(const XMLCh* const msgDomain)
  606. {
  607. #if (defined(XML_USE_INMEMORY_MSGLOADER) || defined(XML_USE_INMEM_MESSAGELOADER))
  608.     return new InMemMsgLoader(msgDomain);
  609. #else
  610.     #error You must provide a message loader
  611.     return 0;
  612. #endif
  613. }
  616. //
  617. //  This method is called very early in the bootstrapping process. This guy
  618. //  must create a transcoding service and return it. It cannot use any string
  619. //  methods, any transcoding services, throw any exceptions, etc... It just
  620. //  makes a transcoding service and returns it, or returns zero on failure.
  621. //
  622. XMLTransService*
  623. XMLPlatformUtils::makeTransService()
  624. {
  625. #if (defined(XML_USE_MACOS_UNICODECONVERTER) || defined(XML_USE_NATIVE_TRANSCODER))
  626.     if (MacOSUnicodeConverter::IsMacOSUnicodeConverterSupported())
  627.         return new MacOSUnicodeConverter;
  628. #else
  629.     #error You must provide a transcoding service implementation
  630. #endif
  632.     // If we got here it's because we didn't detect the Mac OS
  633.     // Unicode Converter or Text Encoding Converter routines
  634.     // that we require to function properly. Xerces will not
  635.     // survive this condition.
  636.     return NULL;
  637. }
  640. // ---------------------------------------------------------------------------
  641. // Utility Functions
  642. // ---------------------------------------------------------------------------
  644. XMLCh*
  645. CopyUniCharsToXMLChs(const UniChar* src, XMLCh* dst, std::size_t charCount, std::size_t maxChars)
  646. {
  647. // Ensure we don't step on anybody's toes
  648. std::size_t cnt = std::min(charCount, maxChars);
  650. // Copy the characters. UniChar is unsigned, so we shouldn't have
  651. // any sign extension problems.
  652. // To allow copy within a identical range, we copy backwards,
  653. // since XMLCh (may be) larger than UniChar.
  654. dst += cnt;
  655. src += cnt;
  656. for (; cnt > 0; --cnt)
  657. *--dst = *--src;
  659. return dst;
  660. }
  663. UniChar*
  664. CopyXMLChsToUniChars(const XMLCh* src, UniChar* dst, std::size_t charCount, std::size_t maxChars)
  665. {
  666. UniChar* dstBegin = dst;
  668. // Ensure we don't step on anybody's toes
  669. std::size_t cnt = std::min(charCount, maxChars);
  671. // Copy the characters. XMLCh's will be truncated on copy to UniChar's.
  672. // To allow copy within a identical range, we copy forwards,
  673. // since XMLCh (may be) larger than UniChar.
  674. for (; cnt > 0; --cnt)
  675. *dst++ = *src++;
  677. return dstBegin;
  678. }
  681. XMLCh*
  682. ConvertColonToSlash(XMLCh* p, std::size_t charCount)
  683. {
  684. XMLCh* start = p;
  685. for (; charCount > 0; --charCount)
  686. {
  687. XMLCh c = *p;
  688. if (c == ':')
  689. *p++ = '/';
  690. else
  691. p++;
  692. }
  693. return start;
  694. }
  697. XMLCh*
  698. ConvertSlashToColon(XMLCh* p, std::size_t charCount)
  699. {
  700. XMLCh* start = p;
  701. for (; charCount > 0; --charCount)
  702. {
  703. XMLCh c = *p;
  704. if (c == '/')
  705. *p++ = ':';
  706. else
  707. p++;
  708. }
  709. return start;
  710. }
  713. char*
  714. ConvertSlashToColon(char* p, std::size_t charCount)
  715. {
  716. char* start = p;
  717. for (; charCount > 0; --charCount)
  718. {
  719. char c = *p;
  720. if (c == '/')
  721. *p++ = ':';
  722. else
  723. p++;
  724. }
  725. return start;
  726. }
  729. // Factory method to make an appropriate subclass of XMLMacAbstractFile
  730. // for our use
  731. XMLMacAbstractFile*
  732. XMLMakeMacFile(void)
  733. {
  734. XMLMacAbstractFile* result = NULL;
  736. if (gUsePosixFiles)
  737. result = new XMLMacPosixFile;
  738. else
  739. result = new XMLMacCarbonFile;
  741. return result;
  742. }
  745. bool
  746. XMLParsePathToFSRef(const XMLCh* const pathName, FSRef& ref, MemoryManager* const manager)
  747. {
  748. bool result;
  750. // If FSPathMakeRef is available, we use it to parse the
  751. // path: this gives us "standard" path support under MacOS X.
  752. // Without this, our paths in that environment would always
  753. // have a volume name at their root...which would look
  754. // "normal" to Mac users, but not normal to unix users. Since
  755. // we're making "unix" paths, we'll stick with the unix
  756. // style paths. This also allows us to easilly take paths
  757. // off the command line.
  758. //
  759. // FSPathMakeRef is available on Mac OS X and in CarbonLib 1.1
  760. // and greater. But on classic under CarbonLib, it expects paths
  761. // to contain ':' separators, for which we're not prepared. Since
  762. // this isn't a case where we need to use it, we drop back to the
  763. // classic case for this.
  765. if (TARGET_API_MAC_CARBON && gHasFSPathAPIs && gPathAPIsUsePosixPaths)
  766. result = XMLParsePathToFSRef_X(pathName, ref, manager);
  767. else
  768. result = XMLParsePathToFSRef_Classic(pathName, ref, manager);
  770. return result;
  771. }
  774. bool
  775. XMLParsePathToFSRef_X(const XMLCh* const pathName, FSRef& ref, MemoryManager* const manager)
  776. {
  777. // Parse Path to FSRef using FSPathMakeRef as available under
  778. // Mac OS X and CarbonLib 1.1 and greater.
  780. OSStatus err = noErr;
  781. std::size_t pathLen = XMLString::stringLen(pathName);
  783.     // Transcode XMLCh into UniChar
  784. UniChar uniBuf[kMaxMacStaticPathChars];
  785. CopyXMLChsToUniChars(pathName, uniBuf, pathLen, kMaxMacStaticPathChars);
  787. // Transcode Unicode to UTF-8
  788. char utf8Buf[kMaxMacStaticPathChars];
  789. pathLen = TranscodeUniCharsToUTF8(uniBuf, utf8Buf, pathLen, kMaxMacStaticPathChars-1);
  791. // Terminate the path
  792. char* p = utf8Buf;
  793. p[pathLen++] = '';
  795. // If it's a relative path, pre-pend the current directory to the path.
  796. // FSPathMakeRef doesn't deal with relativity on the front of the path
  797. if (*p != '/')
  798. {
  799. // Right justify the user path to make room for the pre-pended path
  800. std::memmove(p + kMaxMacStaticPathChars - pathLen, p, pathLen);
  802. // Get the current directory
  803.         FSSpec spec;
  804. if (err == noErr)
  805. err = FSMakeFSSpec(0, 0, NULL, &spec);
  806.         if (err == noErr)
  807.             err = FSpMakeFSRef(&spec, &ref);
  809. // Get pathname to the current directory
  810. if (err == noErr)
  811. err = FSRefMakePath(&ref, reinterpret_cast<UInt8*>(p), kMaxMacStaticPathChars - pathLen - 1); // leave room for one '/'
  812. std::size_t prefixLen = std::strlen(p);
  814. // Now munge the two paths back together
  815. if (err == noErr)
  816. {
  817. p[prefixLen++] = '/';
  818. std::memmove(p + prefixLen, p + kMaxMacStaticPathChars - pathLen, pathLen);
  819. }
  821. // We now have a path from an absolute starting point
  822. }
  824. // Let the OS discover the location
  825. Boolean isDirectory = false;
  826. if (err == noErr)
  827. err = FSPathMakeRef(reinterpret_cast<UInt8*>(p), &ref, &isDirectory);
  829. // Return true on success
  830. return (err == noErr);
  831. }
  834. bool
  835. XMLParsePathToFSRef_Classic(const XMLCh* const pathName, FSRef& ref, MemoryManager* const manager)
  836. {
  837. // Parse Path to FSRef by stepping manually through path components.
  839. // Path's parsed in this way must always begin with a volume name.
  840. // This assumption would fail for standard unix paths under Mac OS X,
  841. // so for those cases we use the routine XMLParsePathToFSRef_Carbon
  842. // above.
  844.     const XMLCh* p = pathName;
  845.     const XMLCh* pEnd;
  846.     std::size_t segLen;
  848. const std::size_t kXMLBufCount = 256;
  849. XMLCh xmlBuf[kXMLBufCount];
  851.     OSErr err = noErr;
  853.     if (*p == L'/')
  854.     {
  855.         // Absolute name: grab the first component as volume name
  857.         // Find the end of the path segment
  858.         for (pEnd = ++p; *pEnd && *pEnd != L'/'; ++pEnd) ;
  859.         segLen = pEnd - p;
  861.         // Try to find a volume that matches this name
  862.         for (ItemCount volIndex = 1; err == noErr; ++volIndex)
  863.         {
  864.             HFSUniStr255 hfsStr;
  865.             hfsStr.length = 0;
  867.             // Get the volume name
  868.             err = FSGetVolumeInfo(
  869.                 0,
  870.                 volIndex,
  871.                 static_cast<FSVolumeRefNum*>(NULL),
  872.                 0,
  873.                 static_cast<FSVolumeInfo*>(NULL),
  874.                 &hfsStr,
  875.                 &ref
  876.                 );
  878.             // Compare against our path segment
  879.             if (err == noErr && segLen == hfsStr.length)
  880.             {
  881.              // Case-insensitive compare
  882.              if (XMLString::compareNIString(
  883. ConvertSlashToColon(
  884. CopyUniCharsToXMLChs(hfsStr.unicode, xmlBuf, segLen, kXMLBufCount),
  885. segLen),
  886. p, segLen) == 0)
  887.                     break;  // we found our volume
  888.             }
  889.         }
  891.         p = pEnd;
  892.     }
  893.     else
  894.     {
  895.         // Relative name, so get the default directory as parent ref
  896.         FSSpec spec;
  897.         err = FSMakeFSSpec(0, 0, NULL, &spec);
  898.         if (err == noErr)
  899.             err = FSpMakeFSRef(&spec, &ref);
  900.     }
  902.     // ref now refers to the a parent directory: parse the rest of the path
  903.     while (err == noErr && *p)
  904.     {
  905.         switch (*p)
  906.         {
  907.         case L'/':   // Just skip any number of path separators
  908.             ++p;
  909.             break;
  911.         case L'.':   // Potentially "current directory" or "parent directory"
  912.             if (p[1] == L'/' || p[1] == 0)       // "current directory"
  913.             {
  914.                 ++p;
  915.                 break;
  916.             }
  917.             else if (p[1] == L'.' && (p[2] == L'/' || p[2] == 0)) // "parent directory"
  918.             {
  919.                 p += 2;  // Get the parent of our parent
  921.                 FSCatalogInfo catalogInfo;
  922.                 err = FSGetCatalogInfo(
  923.                     &ref,
  924.                     kFSCatInfoParentDirID,
  925.                     &catalogInfo,
  926.                     static_cast<HFSUniStr255*>(NULL),
  927.                     static_cast<FSSpec*>(NULL),
  928.                     &ref
  929.                     );
  931.                 // Check that we didn't go too far
  932.                 if (err != noErr || catalogInfo.parentDirID == fsRtParID)
  933.                     return false;
  935.                 break;
  936.             }
  937.             else // some other sequence of periods...fall through and treat as segment
  938.                 ;
  940.         default:
  941.             // Find the end of the path segment
  942.             for (pEnd = p; *pEnd && *pEnd != L'/'; ++pEnd) ;
  943.             segLen = pEnd - p;
  945.             // pEnd now points either to '/' or NUL
  946.             // Create a new ref using this path segment
  947.             err = FSMakeFSRefUnicode(
  948.                 &ref,
  949.                 segLen,
  950.                 ConvertColonToSlash(
  951.                  CopyXMLChsToUniChars(p, reinterpret_cast<UniChar*>(xmlBuf), segLen, kXMLBufCount),
  952.                  segLen),
  953.                 kTextEncodingUnknown,
  954.                 &ref
  955.                 );
  957.             p = pEnd;
  958.             break;
  959.         }
  960.     }
  962.     return err == noErr;
  963. }
  966. bool
  967. XMLParsePathToFSSpec(const XMLCh* const pathName, FSSpec& spec,
  968.                             MemoryManager* const manager)
  969. {
  970. // Parse Path to an FSSpec
  972. // If we've got HFS+ APIs, do this in terms of refs so that
  973. // we can grandfather in the use of FSPathMakeRef under Mac OS X
  974. // and CarbonLib 1.1. Otherwise, do it the hard way.
  976. bool result = false;
  978. if (gHasHFSPlusAPIs)
  979. {
  980. // Parse to a ref
  981. FSRef ref;
  982. result = XMLParsePathToFSRef(pathName, ref, manager);
  984. // Down convert to a spec
  985. if (result)
  986. result = (noErr == FSGetCatalogInfo(&ref,
  987. kFSCatInfoNone,
  988. static_cast<FSCatalogInfo*>(NULL), // catalogInfo
  989. static_cast<HFSUniStr255*>(NULL), // outName
  990. &spec,
  991. static_cast<FSRef*>(NULL) // parentRef
  992. ));
  993. }
  994. else
  995. result = XMLParsePathToFSSpec_Classic(pathName, spec, manager);
  997. // Return true on success
  998. return result;
  999. }
  1002. bool
  1003. XMLParsePathToFSSpec_Classic(const XMLCh* const pathName, FSSpec& spec,
  1004.                             MemoryManager* const manager)
  1005. {
  1006. // Manually parse the path using FSSpec APIs.
  1008.     // Transcode the path into ascii
  1009.     const char* p = XMLString::transcode(pathName, manager);
  1010.     ArrayJanitor<const char> janPath(p, manager);
  1011.     const char* pEnd;
  1012.     std::size_t segLen;
  1014.     OSStatus err = noErr;
  1015.     Str255 name;  // Must be long enough for a partial pathname consisting of two segments (64 bytes)
  1017.     if (*p == '/')
  1018.     {
  1019.         // Absolute name: grab the first component as volume name
  1021.         // Find the end of the path segment
  1022.         for (pEnd = ++p; *pEnd && *pEnd != '/'; ++pEnd) ;
  1023.         segLen = pEnd - p;
  1025.         // Try to find a volume that matches this name
  1026.         for (ItemCount volIndex = 1; err == noErr; ++volIndex)
  1027.         {
  1028.             FSVolumeRefNum volRefNum;
  1030.             if (gHasFS2TBAPIs)
  1031.             {
  1032.                 XVolumeParam xVolParam;
  1033.                 name[0] = 0;
  1034.                 xVolParam.ioNamePtr  = name;
  1035.                 xVolParam.ioVRefNum  = 0;
  1036.                 xVolParam.ioXVersion = 0;
  1037.                 xVolParam.ioVolIndex = volIndex;
  1038.                 err = PBXGetVolInfoSync(&xVolParam);
  1039.                 volRefNum = xVolParam.ioVRefNum;
  1040.             }
  1041.             else
  1042.             {
  1043. #if !TARGET_API_MAC_CARBON
  1044.                 HParamBlockRec hfsParams;
  1045.                 name[0] = 0;
  1046.                 hfsParams.volumeParam.ioNamePtr  = name;
  1047.                 hfsParams.volumeParam.ioVRefNum  = 0;
  1048.                 hfsParams.volumeParam.ioVolIndex = volIndex;
  1049.                 err = PBHGetVInfoSync(&hfsParams);
  1050.                 volRefNum = hfsParams.volumeParam.ioVRefNum;
  1051. #else
  1052.                 err = nsvErr;
  1053. #endif
  1054.             }
  1056.             // Compare against our path segment
  1057.             if (err == noErr && segLen == StrLength(name))
  1058.             {
  1059.              // Case-insensitive compare
  1060.              if (XMLString::compareNIString(
  1061.              ConvertSlashToColon(reinterpret_cast<char*>(&name[1]), segLen),
  1062.              p, segLen) == 0)
  1063.                 {
  1064.                     // we found our volume: fill in the spec
  1065.                     err = FSMakeFSSpec(volRefNum, fsRtDirID, NULL, &spec);
  1066.                     break;
  1067.                 }
  1068.             }
  1069.         }
  1071.         p = pEnd;
  1072.     }
  1073.     else
  1074.     {
  1075.         // Relative name, so get the default directory as parent spec
  1076.         err = FSMakeFSSpec(0, 0, NULL, &spec);
  1077.     }
  1079.     // We now have a parent directory in the spec.
  1080.     while (err == noErr && *p)
  1081.     {
  1082.         switch (*p)
  1083.         {
  1084.         case '/':  // Just skip any number of path separators
  1085.             ++p;
  1086.             break;
  1088.         case L'.':  // Potentially "current directory" or "parent directory"
  1089.             if (p[1] == '/' || p[1] == 0)      // "current directory"
  1090.             {
  1091.                 ++p;
  1092.                 break;
  1093.             }
  1094.             else if (p[1] == '.' && (p[2] == '/' || p[2] == 0)) // "parent directory"
  1095.             {
  1096.                 p += 2;  // Get the parent of our parent
  1098.                 CInfoPBRec catInfo;
  1099.                 catInfo.dirInfo.ioNamePtr = NULL;
  1100.                 catInfo.dirInfo.ioVRefNum = spec.vRefNum;
  1101.                 catInfo.dirInfo.ioFDirIndex = -1;
  1102.                 catInfo.dirInfo.ioDrDirID = spec.parID;
  1103.                 err = PBGetCatInfoSync(&catInfo);
  1105.                 // Check that we didn't go too far
  1106.                 if (err != noErr || catInfo.dirInfo.ioDrParID == fsRtParID)
  1107.                     return false;
  1109.                 // Update our spec
  1110.                 if (err == noErr)
  1111.                     err = FSMakeFSSpec(spec.vRefNum, catInfo.dirInfo.ioDrDirID, NULL, &spec);
  1113.                 break;
  1114.             }
  1115.             else // some other sequence of periods...fall through and treat as segment
  1116.                 ;
  1118.         default:
  1119.             {
  1120.                 // Find the end of the path segment
  1121.                 for (pEnd = p; *pEnd && *pEnd != '/'; ++pEnd) ;
  1122.                 segLen = pEnd - p;
  1124.                 // Check for name length overflow
  1125.                 if (segLen > 31)
  1126.                     return false;
  1128.                 // Make a partial pathname from our current spec to the new object
  1129.                 unsigned char* partial = &name[1];
  1131.                 *partial++ = ':';       // Partial leads with :
  1132.                 const unsigned char* specName = spec.name; // Copy in spec name
  1133.                 for (int specCnt = *specName++; specCnt > 0; --specCnt)
  1134.                     *partial++ = *specName++;
  1136.                 *partial++ = ':';       // Separator
  1137.                 while (p != pEnd)       // Copy in new element
  1138.                 {
  1139.                  if (*p == ':') // Convert : to /
  1140.                  {
  1141.                  *partial++ = '/';
  1142.                  p++;
  1143.                  }
  1144.                  else
  1145.                  *partial++ = *p++;
  1146. }
  1148.                 name[0] = partial - &name[1];   // Set the name length
  1150.                 // Update the spec
  1151.                 err = FSMakeFSSpec(spec.vRefNum, spec.parID, name, &spec);
  1152.             }
  1153.             break;
  1154.         }
  1155.     }
  1157.     return err == noErr;
  1158. }
  1161. XMLCh*
  1162. XMLCreateFullPathFromFSRef(const FSRef& startingRef,
  1163.                             MemoryManager* const manager)
  1164. {
  1165. XMLCh* result = NULL;
  1167. // If FSRefMakePath is available, we use it to create the
  1168. // path: this gives us "standard" path support under MacOS X.
  1169. // Without this, our paths in that environment would always
  1170. // have a volume name at their root...which would look
  1171. // "normal" to Mac users, but not normal to unix users. Since
  1172. // we're making "unix" paths, we'll stick with the unix
  1173. // style paths. This also allows us to easilly take paths
  1174. // off the command line.
  1175. //
  1176. // FSRefMakePath is available on Mac OS X and in CarbonLib 1.1
  1177. // and greater. But we use it only on X since on Classic it
  1178. // makes paths with ':' separators, which really confuses us!
  1180. if (TARGET_API_MAC_CARBON && gHasFSPathAPIs && gPathAPIsUsePosixPaths)
  1181. result = XMLCreateFullPathFromFSRef_X(startingRef, manager);
  1182. else
  1183. result = XMLCreateFullPathFromFSRef_Classic(startingRef, manager);
  1185. return result;
  1186. }
  1189. XMLCh*
  1190. XMLCreateFullPathFromFSRef_X(const FSRef& startingRef,
  1191.                             MemoryManager* const manager)
  1192. {
  1193. // Create the path using FSRefMakePath as available on Mac OS X
  1194. // and under CarbonLib 1.1 and greater.
  1195. OSStatus err = noErr;
  1197. // Make the path in utf8 form
  1198. char utf8Buf[kMaxMacStaticPathChars];
  1199. utf8Buf[0] = '';
  1201. if (err == noErr)
  1202. err = FSRefMakePath(&startingRef, reinterpret_cast<UInt8*>(utf8Buf), kMaxMacStaticPathChars);
  1204. // Bail if path conversion failed
  1205. if (err != noErr)
  1206. return NULL;
  1208. // Transcode into UniChars
  1209. UniChar uniBuf[kMaxMacStaticPathChars];
  1210. std::size_t pathLen = TranscodeUTF8ToUniChars(utf8Buf, uniBuf, kMaxMacStaticPathChars-1);
  1211. uniBuf[pathLen++] = 0;
  1213. // Transcode into a dynamically allocated buffer of XMLChs
  1214. ArrayJanitor<XMLCh> result((XMLCh*) manager->allocate(pathLen * sizeof(XMLCh))/*new XMLCh[pathLen]*/,
  1215. manager);
  1216. if (result.get() != NULL)
  1217. CopyUniCharsToXMLChs(uniBuf, result.get(), pathLen, pathLen);
  1219. return result.release();
  1220. }
  1223. XMLCh*
  1224. XMLCreateFullPathFromFSRef_Classic(const FSRef& startingRef,
  1225.                             MemoryManager* const manager)
  1226. {
  1227. // Manually create the path using FSRef APIs.
  1228.     OSStatus err = noErr;
  1229.     FSCatalogInfo catalogInfo;
  1230.     HFSUniStr255 name;
  1231.     FSRef ref = startingRef;
  1233.     XMLCh buf[kMaxMacStaticPathChars];
  1234.     std::size_t bufPos   = kMaxMacStaticPathChars;
  1235.     std::size_t bufCnt   = 0;
  1237.     ArrayJanitor<XMLCh> result(NULL);
  1238.     std::size_t resultLen = 0;
  1240.     buf[--bufPos] = L'';
  1241.     ++bufCnt;
  1243. do
  1244. {
  1245. err = FSGetCatalogInfo(
  1246. &ref,
  1247. kFSCatInfoParentDirID,
  1248. &catalogInfo,
  1249. &name,
  1250. static_cast<FSSpec*>(NULL),
  1251. &ref
  1252. );
  1254. if (err == noErr)
  1255. {
  1256. // If there's not room in our static buffer for the new
  1257. // name plus separator, dump it to the dynamic result buffer.
  1258. if (bufPos < (std::size_t)name.length + 1)
  1259. {
  1260. ArrayJanitor<XMLCh> temp
  1261.                 (
  1262.                     (XMLCh*) manager->allocate((bufCnt + resultLen) * sizeof(XMLCh)) //new XMLCh[bufCnt + resultLen]
  1263.                     , manager
  1264.                 );
  1266. // Copy in the static buffer
  1267. std::memcpy(temp.get(), &buf[bufPos], bufCnt * sizeof(XMLCh));
  1269. // Copy in the old buffer
  1270. if (resultLen > 0)
  1271. std::memcpy(temp.get() + bufCnt, result.get(), resultLen * sizeof(XMLCh));
  1273. result.reset(temp.release());
  1274. resultLen += bufCnt;
  1276. bufPos = kMaxMacStaticPathChars;
  1277. bufCnt = 0;
  1278. }
  1280. // Prepend our new name and a '/'
  1281. bufPos -= name.length;
  1282. ConvertSlashToColon(
  1283. CopyUniCharsToXMLChs(name.unicode, &buf[bufPos], name.length, name.length),
  1284. name.length);
  1285. buf[--bufPos] = L'/';
  1286. bufCnt += (name.length + 1);
  1287. }
  1288. }
  1289. while (err == noErr && catalogInfo.parentDirID != fsRtParID);
  1291. // Composite existing buffer + any previous result buffer
  1292. ArrayJanitor<XMLCh> final
  1293.     (
  1294.         (XMLCh*) manager->allocate((bufCnt + resultLen) * sizeof(XMLCh))//new XMLCh[bufCnt + resultLen]
  1295.         , manager
  1296.     );
  1298. // Copy in the static buffer
  1299. std::memcpy(final.get(), &buf[bufPos], bufCnt * sizeof(XMLCh));
  1301. // Copy in the old buffer
  1302. if (resultLen > 0)
  1303. std::memcpy(final.get() + bufCnt, result.get(), resultLen * sizeof(XMLCh));
  1305.     return final.release();
  1306. }
  1309. XMLCh*
  1310. XMLCreateFullPathFromFSSpec(const FSSpec& startingSpec,
  1311.                             MemoryManager* const manager)
  1312. {
  1313. XMLCh* result = NULL;
  1315. // If FSRefs are available, do this operation in terms of refs...this
  1316. // allows us to grandfather in the use of FSPathMakeRef and FSRefMakePath
  1317. // if possible.
  1318. if (gHasHFSPlusAPIs)
  1319. {
  1320. OSStatus err = noErr;
  1321. FSRef ref;
  1323. // Up convert to FSRef
  1324. if (err == noErr)
  1325. err = FSpMakeFSRef(&startingSpec, &ref);
  1327. // Create the path
  1328. if (err == noErr)
  1329. result = XMLCreateFullPathFromFSRef(ref, manager);
  1330. }
  1331. else
  1332. {
  1333. // Create using FSSpecs only
  1334. result = XMLCreateFullPathFromFSSpec_Classic(startingSpec, manager);
  1335. }
  1337. return result;
  1338. }
  1341. XMLCh*
  1342. XMLCreateFullPathFromFSSpec_Classic(const FSSpec& startingSpec,
  1343.                                     MemoryManager* const manager)
  1344. {
  1345. // Manually create the path using FSSpec APIs.
  1346.     OSStatus err = noErr;
  1347.     FSSpec spec = startingSpec;
  1349.     char buf[kMaxMacStaticPathChars];
  1350.     std::size_t bufPos   = kMaxMacStaticPathChars;
  1351.     std::size_t bufCnt   = 0;
  1353.     ArrayJanitor<char> result(NULL);
  1354.     std::size_t resultLen = 0;
  1356.     buf[--bufPos] = '';
  1357.     ++bufCnt;
  1359. short index = 0;
  1360. do
  1361. {
  1362. CInfoPBRec catInfo;
  1363. catInfo.dirInfo.ioNamePtr = spec.name;
  1364. catInfo.dirInfo.ioVRefNum = spec.vRefNum;
  1365. catInfo.dirInfo.ioFDirIndex = index;
  1366. catInfo.dirInfo.ioDrDirID = spec.parID;
  1367. err = PBGetCatInfoSync(&catInfo);
  1369. if (err == noErr)
  1370. {
  1371. std::size_t nameLen = StrLength(spec.name);
  1373. // If there's not room in our static buffer for the new
  1374. // name plus separator, dump it to the dynamic result buffer.
  1375. if (bufPos < nameLen + 1)
  1376. {
  1377. ArrayJanitor<char> temp
  1378.                 (
  1379.                     (char*) manager->allocate((bufCnt + resultLen) * sizeof(char))//new char[bufCnt + resultLen]
  1380.                     , manager
  1381.                 );
  1383. // Copy in the static buffer
  1384. std::memcpy(temp.get(), &buf[bufPos], bufCnt);
  1386. // Copy in the old buffer
  1387. if (resultLen > 0)
  1388. std::memcpy(temp.get() + bufCnt, result.get(), resultLen);
  1390. result.reset(temp.release());
  1391. resultLen += bufCnt;
  1393. bufPos = kMaxMacStaticPathChars;
  1394. bufCnt = 0;
  1395. }
  1397. // Prepend our new name and a '/'
  1398. bufPos -= nameLen;
  1399. ConvertSlashToColon((char*)std::memcpy(&buf[bufPos], &spec.name[1], nameLen), nameLen);
  1400. buf[--bufPos] = '/';
  1401. bufCnt += (nameLen + 1);
  1403. // From here on out, ignore the input file name
  1404. index = -1;
  1406. // Move up to the parent
  1407. spec.parID = catInfo.dirInfo.ioDrParID;
  1408. }
  1409. }
  1410. while (err == noErr && spec.parID != fsRtParID);
  1412. // Composite existing buffer with any previous result buffer
  1413. ArrayJanitor<char> final
  1414.     (
  1415.         (char*) manager->allocate((bufCnt + resultLen) * sizeof(char))//new char[bufCnt + resultLen]
  1416.         , manager
  1417.     );
  1419. // Copy in the static buffer
  1420. std::memcpy(final.get(), &buf[bufPos], bufCnt);
  1422. // Copy in the old buffer
  1423. if (resultLen > 0)
  1424. std::memcpy(final.get() + bufCnt, result.get(), resultLen);
  1426.     // Cleanup and transcode to unicode
  1427.     return XMLString::transcode(final.get(), manager);
  1428. }
  1431. std::size_t
  1432. TranscodeUniCharsToUTF8(const UniChar* src, char* dst, std::size_t srcCnt, std::size_t maxChars)
  1433. {
  1434. std::size_t result = 0;
  1436.     // Use the text encoding converter to perform the format conversion.
  1437.     // Note that this is slightly heavyweight, but we're not in a performance
  1438.     // sensitive code-path.
  1440.     OSStatus err = noErr;
  1441.     TECObjectRef tec = 0;
  1442.     ByteCount bytesConsumed = 0;
  1443.     ByteCount bytesProduced = 0;
  1445.     TextEncoding inputEncoding = CreateTextEncoding(kTextEncodingUnicodeDefault,
  1446.                                         kTextEncodingDefaultVariant,
  1447.                                         kUnicode16BitFormat);
  1449.     TextEncoding outputEncoding = CreateTextEncoding(kTextEncodingUnicodeDefault,
  1450.                                         kTextEncodingDefaultVariant,
  1451.                                         kUnicodeUTF8Format);
  1453.     if (err == noErr)
  1454.         err = TECCreateConverter(&tec, inputEncoding, outputEncoding);
  1456.     if (err == noErr)
  1457.         err = TECConvertText(tec,
  1458.                     (ConstTextPtr) src,
  1459.                     srcCnt * sizeof(UniChar), // inputBufferLength
  1460.                     &bytesConsumed, // actualInputLength
  1461.                     (TextPtr) dst, // outputBuffer
  1462.                     maxChars * sizeof(char), // outputBufferLength
  1463.                     &bytesProduced); // actualOutputLength
  1465.     TECDisposeConverter(tec);
  1467.     result = bytesProduced;
  1469.     // Return number of chars in dst
  1470. return result;
  1471. }
  1474. std::size_t
  1475. TranscodeUTF8ToUniChars(const char* src, UniChar* dst, std::size_t maxChars)
  1476. {
  1477. std::size_t result = 0;
  1479.     // Use the text encoding converter to perform the format conversion.
  1480.     // Note that this is slightly heavyweight, but we're not in a performance
  1481.     // sensitive code-path.
  1483.     OSStatus err = noErr;
  1484.     TECObjectRef tec = 0;
  1485.     ByteCount bytesConsumed = 0;
  1486.     ByteCount bytesProduced = 0;
  1488.     TextEncoding inputEncoding = CreateTextEncoding(kTextEncodingUnicodeDefault,
  1489.                                         kTextEncodingDefaultVariant,
  1490.                                         kUnicodeUTF8Format);
  1492.     TextEncoding outputEncoding = CreateTextEncoding(kTextEncodingUnicodeDefault,
  1493.                                         kTextEncodingDefaultVariant,
  1494.                                         kUnicode16BitFormat);
  1496.     if (err == noErr)
  1497.         err = TECCreateConverter(&tec, inputEncoding, outputEncoding);
  1499.     if (err == noErr)
  1500.         err = TECConvertText(tec,
  1501.                     (ConstTextPtr) src,
  1502.                     std::strlen(src), // inputBufferLength
  1503.                     &bytesConsumed, // actualInputLength
  1504.                     (TextPtr) dst, // outputBuffer
  1505.                     maxChars * sizeof(UniChar), // outputBufferLength
  1506.                     &bytesProduced); // actualOutputLength
  1508.     TECDisposeConverter(tec);
  1510.     result = bytesProduced / sizeof(UniChar);
  1512.     // Return number of unicode characters in dst
  1513. return result;
  1514. }
  1516. #include <xercesc/util/LogicalPath.c>
  1518. XERCES_CPP_NAMESPACE_END