PlatformUtils.hpp
上传用户:zhuqijet
上传日期:2013-06-25
资源大小:10074k
文件大小:31k
源码类别:

词法分析

开发平台:

Visual C++

  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999-2003 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.  */
  56. /*
  57.  * $Id: PlatformUtils.hpp,v 1.16 2003/05/22 22:54:25 neilg Exp $
  58.  */
  59. #if !defined(PLATFORMUTILS_HPP)
  60. #define PLATFORMUTILS_HPP
  61. #include <xercesc/util/XMLException.hpp>
  62. #include <xercesc/util/PanicHandler.hpp>
  63. XERCES_CPP_NAMESPACE_BEGIN
  64. class XMLMsgLoader;
  65. class XMLNetAccessor;
  66. class XMLTransService;
  67. class MemoryManager;
  68. //
  69. //  For internal use only
  70. //
  71. //  This class provides a simple abstract API via which lazily evaluated
  72. //  data can be cleaned up.
  73. //
  74. class XMLUTIL_EXPORT XMLDeleter
  75. {
  76. public :
  77.     virtual ~XMLDeleter();
  78. protected :
  79.     XMLDeleter();
  80. private :
  81.     XMLDeleter(const XMLDeleter&);
  82.     XMLDeleter& operator=(const XMLDeleter&);
  83. };
  84. /**
  85.   * Utilities that must be implemented in a platform-specific way.
  86.   *
  87.   * This class contains methods that must be implemented in a platform
  88.   * specific manner. The actual implementations of these methods are
  89.   * available in the per-platform files indide <code>src/util/Platforms
  90.   * </code>.
  91.   */
  92. class XMLUTIL_EXPORT XMLPlatformUtils
  93. {
  94. public :
  95.     /** @name Public Static Data */
  96.     //@{
  97.     /** The network accessor
  98.       *
  99.       * This is provided by the per-platform driver, so each platform can
  100.       * choose what actual implementation it wants to use. The object must
  101.       * be dynamically allocated.
  102.       *
  103.       * <i>Note that you may optionally, if your platform driver does not
  104.       * install a network accessor, set it manually from your client code
  105.       * after calling Initialize(). This works because this object is
  106.       * not required during initialization, and only comes into play during
  107.       * actual XML parsing.</i>
  108.       */
  109.     static XMLNetAccessor*      fgNetAccessor;
  110.     /** The transcoding service.
  111.       *
  112.       * This is provided by the per platform driver, so each platform can
  113.       * choose what implemenation it wants to use. When the platform
  114.       * independent initialization code needs to get a transcoding service
  115.       * object, it will call <code>makeTransService()</code> to ask the
  116.       * per-platform code to create one. Only one transcoding service
  117.       * object is reqeusted per-process, so it is shared and synchronized
  118.       * among parser instances within that process.
  119.       */
  120.     static XMLTransService*     fgTransService;
  121.     /** The Panic Handler
  122.       *
  123.       *   This is the application provided panic handler. 
  124.       */
  125.     static PanicHandler*        fgUserPanicHandler;
  126.     
  127.     /** The Panic Handler
  128.       *
  129.       *   This is the default panic handler. 
  130.       */    
  131.     static PanicHandler*        fgDefaultPanicHandler;
  132.     /** The configurable memory manager
  133.       *
  134.       *   This is the pluggable memory manager. If it is not provided by an
  135.       *   application, a default implementation is used.
  136.       */
  137.     static MemoryManager*       fgMemoryManager;
  138.     
  139.     //@}
  140.     /** @name Initialization amd Panic methods */
  141.     //@{
  142.     /** Perform per-process parser initialization
  143.       *
  144.       * Initialization <b>must</b> be called first in any client code.
  145.       *
  146.       * The locale is set iff the Initialize() is invoked for the very first time,
  147.       * to ensure that each and every message loaders, in the process space, share
  148.       * the same locale.
  149.       *
  150.       * All subsequent invocations of Initialize(), with a different locale, have
  151.       * no effect on the message loaders, either instantiated, or to be instantiated.
  152.       *
  153.       * To set to a different locale, client application needs to Terminate() (or
  154.       * multiple Terminate() in the case where multiple Initialize() have been invoked
  155.       * before), followed by Initialize(new_locale).
  156.       *
  157.       * The default locale is "en_US".
  158.       *
  159.       * nlsHome: user specified location where MsgLoader retrieves error message files.
  160.       *          the discussion above with regard to locale, applies to this nlsHome
  161.       *          as well.
  162.       *
  163.       * panicHandler: application's panic handler, application owns this handler.
  164.       *               Application shall make sure that the plugged panic handler persists 
  165.       *               through the call to XMLPlatformUtils::terminate().       
  166.       *
  167.       * memoryManager: plugged-in memory manager which is owned by user
  168.       *                applications. Applications must make sure that the
  169.       *                plugged-in memory manager persisit through the call to
  170.       *                XMLPlatformUtils::terminate()
  171.       */
  172.     static void Initialize(const char*          const locale = XMLUni::fgXercescDefaultLocale
  173.                          , const char*          const nlsHome = 0
  174.                          ,       PanicHandler*  const panicHandler = 0
  175.                          ,       MemoryManager* const memoryManager = 0);
  176.     /** Perform per-process parser termination
  177.       *
  178.       * The termination call is currently optional, to aid those dynamically
  179.       * loading the parser to clean up before exit, or to avoid spurious
  180.       * reports from leak detectors.
  181.       */
  182.     static void Terminate();
  183.     /** The panic mechanism.
  184.       *
  185.       * If, during initialization, we cannot even get far enough along
  186.       * to get transcoding up or get message loading working, we call
  187.       * this method.</p>
  188.       *
  189.       * Each platform can implement it however they want. This method will
  190.       * delegate the panic handling to a user specified panic handler or
  191.       * in the absence of it, the default panic handler.
  192.       *
  193.       * In case the default panic handler does not support a particular
  194.       * platform, the platform specific panic hanlding shall be implemented
  195.       * here </p>.
  196.       * 
  197.       * @param reason The enumeration that defines the cause of the failure
  198.       */
  199.     static void panic
  200.     (
  201.         const   PanicHandler::PanicReasons    reason
  202.     );
  203.     
  204.     //@}
  205.     /** @name File Methods */
  206.     //@{
  207.     /** Get the current file position
  208.       *
  209.       * This must be implemented by the per-platform driver, which should
  210.       * use local file services to deterine the current position within
  211.       * the passed file.
  212.       *
  213.       * Since the file API provided here only reads, if the host platform
  214.       * supports separate read/write positions, only the read position is
  215.       * of any interest, and hence should be the one returned.
  216.       *
  217.       * @param theFile The file handle
  218.       */
  219.     static unsigned int curFilePos(FileHandle theFile);
  220.     /** Closes the file handle
  221.       *
  222.       * This must be implemented by the per-platform driver, which should
  223.       * use local file services to close the passed file handle, and to
  224.       * destroy the passed file handle and any allocated data or system
  225.       * resources it contains.
  226.       *
  227.       * @param theFile The file handle to close
  228.       */
  229.     static void closeFile(FileHandle theFile);
  230.     /** Returns the file size
  231.       *
  232.       * This must be implemented by the per-platform driver, which should
  233.       * use local file services to determine the current size of the file
  234.       * represented by the passed handle.
  235.       *
  236.       * @param theFile The file handle whose size you want
  237.       *
  238.       * @return Returns the size of the file in bytes
  239.       */
  240.     static unsigned int fileSize(FileHandle theFile);
  241.     /** Opens the file
  242.       *
  243.       * This must be implemented by the per-platform driver, which should
  244.       * use local file services to open passed file. If it fails, a
  245.       * null handle pointer should be returned.
  246.       *
  247.       * @param fileName The string containing the name of the file
  248.       *
  249.       * @return The file handle of the opened file
  250.       */
  251.     static FileHandle openFile(const char* const fileName);
  252.     /** Opens a named file
  253.       *
  254.       * This must be implemented by the per-platform driver, which should
  255.       * use local file services to open the passed file. If it fails, a
  256.       * null handle pointer should be returned.
  257.       *
  258.       * @param fileName The string containing the name of the file
  259.       *
  260.       * @return The file handle of the opened file
  261.       */
  262.     static FileHandle openFile(const XMLCh* const fileName);
  263.     /** Open a named file to write
  264.       *
  265.       * This must be implemented by the per-platform driver, which should
  266.       * use local file services to open passed file. If it fails, a
  267.       * null handle pointer should be returned.
  268.       *
  269.       * @param fileName The string containing the name of the file
  270.       *
  271.       * @return The file handle of the opened file
  272.       */
  273.     static FileHandle openFileToWrite(const char* const fileName);
  274.     /** Open a named file to write
  275.       *
  276.       * This must be implemented by the per-platform driver, which should
  277.       * use local file services to open the passed file. If it fails, a
  278.       * null handle pointer should be returned.
  279.       *
  280.       * @param fileName The string containing the name of the file
  281.       *
  282.       * @return The file handle of the opened file
  283.       */
  284.     static FileHandle openFileToWrite(const XMLCh* const fileName);
  285.     /** Opens the standard input as a file
  286.       *
  287.       * This must be implemented by the per-platform driver, which should
  288.       * use local file services to open a handle to the standard input.
  289.       * It should be a copy of the standard input handle, since it will
  290.       * be closed later!
  291.       *
  292.       * @return The file handle of the standard input stream
  293.       */
  294.     static FileHandle openStdInHandle();
  295.     /** Reads the file buffer
  296.       *
  297.       * This must be implemented by the per-platform driver, which should
  298.       * use local file services to read up to 'toRead' bytes of data from
  299.       * the passed file, and return those bytes in the 'toFill' buffer. It
  300.       * is not an error not to read the requested number of bytes. When the
  301.       * end of file is reached, zero should be returned.
  302.       *
  303.       * @param theFile The file handle to be read from.
  304.       * @param toRead The maximum number of byte to read from the current
  305.       * position
  306.       * @param toFill The byte buffer to fill
  307.       *
  308.       * @return Returns the number of bytes read from the stream or file
  309.       */
  310.     static unsigned int readFileBuffer
  311.     (
  312.                 FileHandle      theFile
  313.         , const unsigned int    toRead
  314.         ,       XMLByte* const  toFill
  315.     );
  316.     /** Writes the buffer to the file
  317.       *
  318.       * This must be implemented by the per-platform driver, which should
  319.       * use local file services to write up to 'toWrite' bytes of data to
  320.       * the passed file. Unless exception raised by local file services,
  321.       * 'toWrite' bytes of data is to be written to the passed file.
  322.       *
  323.       * @param theFile The file handle to be written to.
  324.       * @param toWrite The maximum number of byte to write from the current
  325.       * position
  326.       * @param toFlush The byte buffer to flush
  327.       *
  328.       * @return void
  329.       */
  330.     static void writeBufferToFile
  331.     (
  332.           FileHandle     const  theFile
  333.         , long                  toWrite
  334.         , const XMLByte* const  toFlush
  335.     );
  336.     /** Resets the file handle
  337.       *
  338.       * This must be implemented by the per-platform driver which will use
  339.       * local file services to reset the file position to the start of the
  340.       * the file.
  341.       *
  342.       * @param theFile The file handle that you want to reset
  343.       */
  344.     static void resetFile(FileHandle theFile);
  345.     //@}
  346.     /** @name File System Methods */
  347.     //@{
  348.     /** Gets the full path from a relative path
  349.       *
  350.       * This must be implemented by the per-platform driver. It should
  351.       * complete a relative path using the 'current directory', or whatever
  352.       * the local equivalent of a current directory is. If the passed
  353.       * source path is actually fully qualified, then a straight copy of it
  354.       * will be returned.
  355.       *
  356.       * @param srcPath The path of the file for which you want the full path
  357.       *
  358.       * @return Returns the fully qualified path of the file name including
  359.       *         the file name. This is dyanmically allocated and must be
  360.       *         deleted  by the caller when its no longer needed! The memory
  361.       *         returned will beallocated using the static memory manager, if
  362.       *         user do not supply a memory manager. Users then need to make
  363.       *         sure to use either the default or user specific memory manager
  364.       *         to deallocate the memory.
  365.       */
  366.     static XMLCh* getFullPath
  367.     (
  368.         const XMLCh* const srcPath
  369.         , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
  370.     );
  371.     /** Gets the current working directory 
  372.       *
  373.       * This must be implemented by the per-platform driver. It returns 
  374.       * the current working directory is. 
  375.       *
  376.       * @return Returns the current working directory. 
  377.       *         This is dyanmically allocated and must be deleted
  378.       *         by the caller when its no longer needed! The memory returned
  379.       *         will be allocated using the static memory manager, if users
  380.       *         do not supply a memory manager. Users then need to make sure
  381.       *         to use either the default or user specific memory manager to
  382.       *         deallocate the memory.
  383.       */
  384.     static XMLCh* getCurrentDirectory
  385.     (
  386.         MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
  387.     );
  388.     /** Check if a charater is a slash
  389.       *
  390.       * This must be implemented by the per-platform driver. 
  391.       *
  392.       * @param c the character to be examined
  393.       *
  394.       * @return true  if the character examined is a slash
  395.       *         false otherwise
  396.       */
  397.     static inline bool isAnySlash(XMLCh c);
  398.     
  399.     /** Remove occurences of the pair of dot slash 
  400.       *
  401.       * To remove the sequence, dot slash if it is part of the sequence,
  402.       * slash dot slash.
  403.       *
  404.       * @param srcPath The path for which you want to remove the dot slash sequence.
  405.       *
  406.       * @return 
  407.       */
  408.     static void   removeDotSlash(XMLCh* const srcPath);
  409.     /** Remove occurences of the dot dot slash 
  410.       *
  411.       * To remove the sequence, slash dot dot slash and its preceding path segment
  412.       * if and only if the preceding path segment is not slash dot dot slash.
  413.       *
  414.       * @param srcPath The path for which you want to remove the slash dot
  415.       *        dot slash sequence and its preceding path segment.
  416.       *
  417.       * @return 
  418.       */
  419.     static void   removeDotDotSlash(XMLCh* const srcPath);
  420.     /** Determines if a path is relative or absolute
  421.       *
  422.       * This must be implemented by the per-platform driver, which should
  423.       * determine whether the passed path is relative or not. The concept
  424.       * of relative and absolute might be... well relative on different
  425.       * platforms. But, as long as the determination is made consistently
  426.       * and in coordination with the weavePaths() method, it should work
  427.       * for any platform.
  428.       *
  429.       * @param toCheck The file name which you want to check
  430.       *
  431.       * @return Returns true if the filename appears to be relative
  432.       */
  433.     static bool isRelative(const XMLCh* const toCheck);
  434.     /** Utility to join two paths
  435.       *
  436.       * This must be implemented by the per-platform driver, and should
  437.       * weave the relative path part together with the base part and return
  438.       * a new path that represents this combination.
  439.       *
  440.       * If the relative part turns out to be fully qualified, it will be
  441.       * returned as is. If it is not, then it will be woven onto the
  442.       * passed base path, by removing one path component for each leading
  443.       * "../" (or whatever is the equivalent in the local system) in the
  444.       * relative path.
  445.       *
  446.       * @param basePath The string containing the base path
  447.       * @param relativePath The string containing the relative path
  448.       *
  449.       * @return Returns a string containing the 'woven' path. It should
  450.       * be dynamically allocated and becomes the responsibility of the
  451.       * caller to delete.
  452.       */
  453.     static XMLCh* weavePaths
  454.     (
  455.         const   XMLCh* const    basePath
  456.         , const XMLCh* const    relativePath
  457.     );
  458.     //@}
  459.     /** @name Timing Methods */
  460.     //@{
  461.     /** Gets the system time in milliseconds
  462.       *
  463.       * This must be implemented by the per-platform driver, which should
  464.       * use local services to return the current value of a running
  465.       * millisecond timer. Note that the value returned is only as accurate
  466.       * as the millisecond time of the underyling host system.
  467.       *
  468.       * @return Returns the system time as an unsigned long
  469.       */
  470.     static unsigned long getCurrentMillis();
  471.     //@}
  472.     /** @name Mutex Methods */
  473.     //@{
  474.     /** Closes a mutex handle
  475.       *
  476.       * Each per-platform driver must implement this. Only it knows what
  477.       * the actual content of the passed mutex handle is.
  478.       *
  479.       * @param mtxHandle The mutex handle that you want to close
  480.       */
  481.     static void closeMutex(void* const mtxHandle);
  482.     /** Locks a mutex handle
  483.       *
  484.       * Each per-platform driver must implement this. Only it knows what
  485.       * the actual content of the passed mutex handle is.
  486.       *
  487.       * @param mtxHandle The mutex handle that you want to lock
  488.       */
  489.     static void lockMutex(void* const mtxHandle);
  490.     /** Make a new mutex
  491.       *
  492.       * Each per-platform driver must implement this. Only it knows what
  493.       * the actual content of the passed mutex handle is. The returned
  494.       * handle pointer will be eventually passed to closeMutex() which is
  495.       * also implemented by the platform driver.
  496.       */
  497.     static void* makeMutex();
  498.     /** Unlocks a mutex
  499.       *
  500.       * Each per-platform driver must implement this. Only it knows what
  501.       * the actual content of the passed mutex handle is.
  502.       *
  503.       * Note that, since the underlying system synchronization services
  504.       * are used, Xerces cannot guarantee that lock/unlock operaitons are
  505.       * correctly enforced on a per-thread basis or that incorrect nesting
  506.       * of lock/unlock operations will be caught.
  507.       *
  508.       * @param mtxHandle The mutex handle that you want to unlock
  509.       */
  510.     static void unlockMutex(void* const mtxHandle);
  511.     //@}
  512.     /** @name External Message Support */
  513.     //@{
  514.     /** Loads the message set from among the available domains
  515.       *
  516.       * The returned object must be dynamically allocated and the caller
  517.       * becomes responsible for cleaning it up.
  518.       *
  519.       * @param msgDomain The message domain which you want to load
  520.       */
  521.     static XMLMsgLoader* loadMsgSet(const XMLCh* const msgDomain);
  522.     //@}
  523.     /** @name Miscellaneous synchronization methods */
  524.     //@{
  525.     /** Conditionally updates or returns a single word variable atomically
  526.       *
  527.       * This must be implemented by the per-platform driver. The
  528.       * compareAndSwap subroutine performs an atomic operation which
  529.       * compares the contents of a single word variable with a stored old
  530.       * value. If the values are equal, a new value is stored in the single
  531.       * word variable and TRUE is returned; otherwise, the old value is set
  532.       * to the current value of the single word variable and FALSE is
  533.       * returned.
  534.       *
  535.       * The compareAndSwap subroutine is useful when a word value must be
  536.       * updated only if it has not been changed since it was last read.
  537.       *
  538.       * Note: The word containing the single word variable must be aligned
  539.       * on a full word boundary.
  540.       *
  541.       * @param toFill Specifies the address of the single word variable
  542.       * @param newValue Specifies the new value to be conditionally assigned
  543.       * to the single word variable.
  544.       * @param toCompare Specifies the address of the old value to be checked
  545.       * against (and conditionally updated with) the value of the single word
  546.       * variable.
  547.       *
  548.       * @return Returns the new value assigned to the single word variable
  549.       */
  550.     static void* compareAndSwap
  551.     (
  552.                 void**      toFill
  553.         , const void* const newValue
  554.         , const void* const toCompare
  555.     );
  556.     //@}
  557.     /** @name Atomic Increment and Decrement */
  558.     //@{
  559.     /** Increments a single word variable atomically.
  560.       *
  561.       * This must be implemented by the per-platform driver. The
  562.       * atomicIncrement subroutine increments one word in a single atomic
  563.       * operation. This operation is useful when a counter variable is shared
  564.       * between several threads or processes. When updating such a counter
  565.       * variable, it is important to make sure that the fetch, update, and
  566.       * store operations occur atomically (are not interruptible).
  567.       *
  568.       * @param location Specifies the address of the word variable to be
  569.       * incremented.
  570.       *
  571.       * @return The function return value is positive if the result of the
  572.       * operation was positive. Zero if the result of the operation was zero.
  573.       * Negative if the result of the operation was negative. Except for the
  574.       * zero case, the value returned may differ from the actual result of
  575.       * the operation - only the sign and zero/nonzero state is guaranteed
  576.       * to be correct.
  577.       */
  578.     static int atomicIncrement(int& location);
  579.     /** Decrements a single word variable atomically.
  580.       *
  581.       * This must be implemented by the per-platform driver. The
  582.       * atomicDecrement subroutine increments one word in a single atomic
  583.       * operation. This operation is useful when a counter variable is shared
  584.       * between several threads or processes. When updating such a counter
  585.       * variable, it is important to make sure that the fetch, update, and
  586.       * store operations occur atomically (are not interruptible).
  587.       *
  588.       * @param location Specifies the address of the word variable to be
  589.       * decremented.
  590.       *
  591.       * @return The function return value is positive if the result of the
  592.       * operation was positive. Zero if the result of the operation was zero.
  593.       * Negative if the result of the operation was negative. Except for the
  594.       * zero case, the value returned may differ from the actual result of the
  595.       * operation - only the sign and zero/nonzero state is guaranteed to be
  596.       * correct.
  597.       */
  598.     static int atomicDecrement(int& location);
  599.     //@}
  600.     /** @name NEL Character Handling  */
  601.     //@{
  602. /**
  603.       * This function enables the recognition of NEL(0x85) char and LSEP (0x2028) as newline chars
  604.       * which is disabled by default.
  605.       * It is only called once per process. Once it is set, any subsequent calls
  606.       * will result in exception being thrown.
  607.       *
  608.       * Note: 1. Turning this option on will make the parser non compliant to XML 1.0.
  609.       *       2. This option has no effect to document conforming to XML 1.1 compliant,
  610.       *          which always recognize these two chars (0x85 and 0x2028) as newline characters.
  611.       *
  612.       */
  613.     static void recognizeNEL(bool state);
  614.     /**
  615.       * Return the value of fgNEL flag.
  616.       */
  617.     static bool isNELRecognized();
  618.     //@}
  619.     /** @name Strict IANA Encoding Checking */
  620.     //@{
  621. /**
  622.       * This function enables/disables strict IANA encoding names checking.
  623.       *
  624.       * The strict checking is disabled by default.
  625.       *
  626.       * @param state If true, a strict IANA encoding name check is performed,
  627.       *              otherwise, no checking.
  628.       *
  629.       */
  630.     static void strictIANAEncoding(const bool state);
  631.     /**
  632.       * Returns whether a strict IANA encoding name check is enabled or
  633.       * disabled.
  634.       */
  635.     static bool isStrictIANAEncoding();
  636.     //@}
  637.     /**
  638.       * Aligns the specified pointer per platform block allocation
  639.   * requirements.
  640.   *
  641.   * The results of this function may be altered by defining
  642.   * XML_PLATFORM_NEW_BLOCK_ALIGNMENT.
  643.   */
  644. static inline size_t alignPointerForNewBlockAllocation(size_t ptrSize);
  645. private :
  646.     /** @name Private static methods */
  647.     //@{
  648.     /** Loads a message set from the available domains
  649.       *
  650.       * @param msgDomain The message domain containing the message to be
  651.       * loaded
  652.       */
  653.     static XMLMsgLoader* loadAMsgSet(const XMLCh* const msgDomain);
  654.     /** Creates a net accessor object.
  655.       *
  656.       * Each per-platform driver must implement this method. However,
  657.       * having a Net Accessor is optional and this method can return a
  658.       * null pointer if remote access via HTTP and FTP URLs is not required.
  659.       *
  660.       * @return An object derived from XMLNetAccessor. It must be dynamically
  661.       *         allocated, since it will be deleted later.
  662.       */
  663.     static XMLNetAccessor* makeNetAccessor();
  664.     /** Creates a Transoding service
  665.       *
  666.       * Each per-platform driver must implement this method and return some
  667.       * derivative of the XMLTransService class. This object serves as the
  668.       * transcoder factory for this process. The object must be dynamically
  669.       * allocated and the caller is responsible for cleaning it up.
  670.       *
  671.       * @return A dynamically allocated object of some class derived from
  672.       *         the XMLTransService class.
  673.       */
  674.     static XMLTransService* makeTransService();
  675.     /** Does initialization for a particular platform
  676.       *
  677.       * Each per-platform driver must implement this to do any low level
  678.       * system initialization required. It <b>cannot</b> use any XML
  679.       * parser or utilities services!
  680.       */
  681.     static void platformInit();
  682.     /** Does termination for a particular platform
  683.       *
  684.       * Each per-platform driver must implement this to do any low level
  685.       * system resource cleanup required. It <b>cannot</b> use any XML
  686.       * parser or utilities services!
  687.       */
  688.     static void platformTerm();
  689.     /** Search for sequence, slash dot dot slash
  690.       *
  691.       * @param srcPath the path to search
  692.       *
  693.       * @return   the position of the first occurence of slash dot dot slash
  694.       *            -1 if no such sequence is found
  695.       */
  696.     static int  searchSlashDotDotSlash(XMLCh* const srcPath);
  697.     //@}
  698.     /** @name Private static methods */
  699.     //@{
  700.     /**
  701.       * Indicates whether the memory manager was supplied by the user
  702.       * or not. Users own the memory manager, and if none is supplied,
  703.       * Xerces uses a default one that it owns and is responsible for
  704.       * deleting in Terminate().
  705.       */
  706.     static bool fgMemMgrAdopted;
  707.     //@}
  708. };
  709. MakeXMLException(XMLPlatformUtilsException, XMLUTIL_EXPORT)
  710. // ---------------------------------------------------------------------------
  711. //  XMLPlatformUtils: alignPointerForNewBlockAllocation
  712. // ---------------------------------------------------------------------------
  713. //  Calculate alignment required by platform for a new
  714. // block allocation. We use this in our custom allocators
  715. // to ensure that returned blocks are properly aligned.
  716. // Note that, although this will take a pointer and return the position
  717. // at which it should be placed for correct alignment, in our code
  718. // we normally use size_t parameters to discover what the alignment
  719. // of header blocks should be.  Thus, if this is to be
  720. // used for the former purpose, to make compilers happy
  721. // some casting will be necessary - neilg.
  722. inline size_t
  723. XMLPlatformUtils::alignPointerForNewBlockAllocation(size_t ptrSize)
  724. {
  725. // Macro XML_PLATFORM_NEW_BLOCK_ALIGNMENT may be defined
  726. // as needed to dictate alignment requirements on a
  727. // per-architecture basis. In the absense of that we
  728. // take an educated guess.
  729. #ifdef XML_PLATFORM_NEW_BLOCK_ALIGNMENT
  730. size_t alignment = XML_PLATFORM_NEW_BLOCK_ALIGNMENT;
  731. #else
  732. size_t alignment = (sizeof(void*) >= sizeof(double)) ? sizeof(void*) : sizeof(double);
  733. #endif
  734. // Calculate current alignment of pointer
  735. size_t current = ptrSize % alignment;
  736. // Adjust pointer alignment as needed
  737. return (current == 0)
  738.  ? ptrSize
  739.  : (ptrSize + alignment - current);
  740. }
  741. // ---------------------------------------------------------------------------
  742. //  XMLDeleter: Public Destructor
  743. // ---------------------------------------------------------------------------
  744. inline XMLDeleter::~XMLDeleter()
  745. {
  746. }
  747. // ---------------------------------------------------------------------------
  748. //  XMLDeleter: Hidden constructors and operators
  749. // ---------------------------------------------------------------------------
  750. inline XMLDeleter::XMLDeleter()
  751. {
  752. }
  753. XERCES_CPP_NAMESPACE_END
  754. #endif