SAXPrint

最新推荐文章于 2024-07-25 14:26:06 发布

zhujun012

最新推荐文章于 2024-07-25 14:26:06 发布

阅读量457

点赞数

文章标签： output permissions apache schema file express

本文链接：https://blog.csdn.net/zhujun012/article/details/6137277

版权

//SAXPrint.hpp

/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/*
* $Log$
* Revision 1.7 2004/09/08 13:55:34 peiyongz
* Apache License Version 2.0
*
* Revision 1.6 2003/05/30 09:36:36 gareth
* Use new macros for iostream.h and std:: issues.
*
* Revision 1.5 2003/02/05 18:53:24 tng
* [Bug 11915] Utility for freeing memory.
*
* Revision 1.4 2000/03/02 19:53:49 roddey
* This checkin includes many changes done while waiting for the
* 1.1.0 code to be finished. I can't list them all here, but a list is
* available elsewhere.
*
* Revision 1.3 2000/02/11 02:47:15 abagchi
* Removed StrX::transcode
*
* Revision 1.2 2000/02/06 07:47:24 rahulj
* Year 2K copyright swat.
*
* Revision 1.1.1.1 1999/11/09 01:09:29 twl
* Initial checkin
*
* Revision 1.6 1999/11/08 20:43:41 rahul
* Swat for adding in Product name and CVS comment log variable.
*
*/

// ---------------------------------------------------------------------------
// Includes for all the program files to see
// ---------------------------------------------------------------------------
#include <string.h>
#if defined(XERCES_NEW_IOSTREAMS)
#include <iostream>
#else
#include <iostream.h>
#endif
#include <stdlib.h>
#include "SAXPrintHandlers.hpp"

// ---------------------------------------------------------------------------
// This is a simple class that lets us do easy (though not terribly efficient)
// trancoding of XMLCh data to local code page for display.
// ---------------------------------------------------------------------------
class StrX
{
public :
    // -----------------------------------------------------------------------
    // Constructors and Destructor
    // -----------------------------------------------------------------------
    StrX(const XMLCh* const toTranscode)
    {
        // Call the private transcoding method
        fLocalForm = XMLString::transcode(toTranscode);
    }

    ~StrX()
    {
        XMLString::release(&fLocalForm);
    }

    // -----------------------------------------------------------------------
    // Getter methods
    // -----------------------------------------------------------------------
    const char* localForm() const
    {
        return fLocalForm;
    }

private :
    // -----------------------------------------------------------------------
    // Private data members
    //
    // fLocalForm
    //      This is the local code page form of the string.
    // -----------------------------------------------------------------------
    char*   fLocalForm;
};

inline XERCES_STD_QUALIFIER ostream& operator<<(XERCES_STD_QUALIFIER ostream& target, const StrX& toDump)
{
target << toDump.localForm();
return target;
}

//SAXPrint.cpp

/*
* $Log$
* Revision 1.25 2004/09/08 13:55:34 peiyongz
* Apache License Version 2.0
*
* Revision 1.24 2004/09/02 14:59:29 cargilld
* Add OutOfMemoryException block to samples.
*
* Revision 1.23 2004/02/06 15:04:16 cargilld
* Misc 390 changes.
*
* Revision 1.22 2003/08/07 21:21:38 neilg
* fix segmentation faults that may arise when the parser throws exceptions during document parsing. In general, XMLPlatformUtils::Terminate() should not be called from within a catch statement.
*
* Revision 1.21 2003/05/30 09:36:36 gareth
* Use new macros for iostream.h and std:: issues.
*
* Revision 1.20 2002/04/17 20:18:08 tng
* [Bug 7493] The word "occured" is misspelled and it is a global error.
*
* Revision 1.19 2002/02/01 22:41:17 peiyongz
* sane_include
*
* Revision 1.18 2001/10/29 17:02:57 tng
* Fix typo in samples.
*
* Revision 1.17 2001/10/25 15:18:33 tng
* delete the parser before XMLPlatformUtils::Terminate.
*
* Revision 1.16 2001/10/19 19:02:43 tng
* [Bug 3909] return non-zero an exit code when error was encounted.
* And other modification for consistent help display and return code across samples.
*
* Revision 1.15 2001/08/01 19:11:01 tng
* Add full schema constraint checking flag to the samples and the parser.
*
* Revision 1.14 2001/05/11 13:24:58 tng
* Copyright update.
*
* Revision 1.13 2001/05/03 16:00:21 tng
* Schema: samples update with schema
*
* Revision 1.12 2000/06/16 20:25:43 rahulj
* Add the -v=always option to force validation checking. Need this
* option for running the conformance tests.
*
* Revision 1.11 2000/05/31 18:36:26 rahulj
* Matched the command line options supported by DOMPrint.
*
* Revision 1.10 2000/04/12 22:58:27 roddey
* Added support for 'auto validate' mode.
*
* Revision 1.9 2000/04/06 19:09:51 roddey
* Some more improvements to output formatting. Now it will correctly
* handle doing the 'replacement char' style of dealing with chars
* that are unrepresentable.
*
* Revision 1.8 2000/04/05 00:20:32 roddey
* More updates for the low level formatted output support
*
* Revision 1.7 2000/03/28 19:43:11 roddey
* Fixes for signed/unsigned warnings. New work for two way transcoding
* stuff.
*
* Revision 1.6 2000/03/03 01:29:31 roddey
* Added a scanReset()/parseReset() method to the scanner and
* parsers, to allow for reset after early exit from a progressive parse.
* Added calls to new Terminate() call to all of the samples. Improved
* documentation in SAX and DOM parsers.
*
* Revision 1.5 2000/03/02 19:53:49 roddey
* This checkin includes many changes done while waiting for the
* 1.1.0 code to be finished. I can't list them all here, but a list is
* available elsewhere.
*
* Revision 1.4 2000/02/11 02:39:43 abagchi
* Removed StrX::transcode
*
* Revision 1.3 2000/02/06 07:47:24 rahulj
* Year 2K copyright swat.
*
* Revision 1.2 2000/01/12 00:27:01 roddey
* Updates to work with the new URL and input source scheme.
*
* Revision 1.1.1.1 1999/11/09 01:09:28 twl
* Initial checkin
*
* Revision 1.7 1999/11/08 20:43:41 rahul
* Swat for adding in Product name and CVS comment log variable.
*
*/

// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/util/TransService.hpp>
#include <xercesc/parsers/SAXParser.hpp>
#include "SAXPrint.hpp"
#include <xercesc/util/OutOfMemoryException.hpp>

// ---------------------------------------------------------------------------
// Local data
//
// doNamespaces
//      Indicates whether namespace processing should be enabled or not.
//      Defaults to disabled.
//
// doSchema
//      Indicates whether schema processing should be enabled or not.
//      Defaults to disabled.
//
// schemaFullChecking
//      Indicates whether full schema constraint checking should be enabled or not.
//      Defaults to disabled.
//
// encodingName
//      The encoding we are to output in. If not set on the command line,
//      then it is defaulted to LATIN1.
//
// xmlFile
//      The path to the file to parser. Set via command line.
//
// valScheme
//      Indicates what validation scheme to use. It defaults to 'auto', but
//      can be set via the -v= command.
// ---------------------------------------------------------------------------
static bool                     doNamespaces        = false;
static bool                     doSchema            = false;
static bool                     schemaFullChecking = false;
static const char*              encodingName    = "LATIN1";
static XMLFormatter::UnRepFlags unRepFlags      = XMLFormatter::UnRep_CharRef;
static char*                    xmlFile         = 0;
static SAXParser::ValSchemes    valScheme       = SAXParser::Val_Auto;

// ---------------------------------------------------------------------------
// Local helper methods
// ---------------------------------------------------------------------------
static void usage()
{
 XERCES_STD_QUALIFIER cout << "/nUsage:/n"
 " SAXPrint [options] <XML file>/n/n"
 "This program invokes the SAX Parser, and then prints the/n"
 "data returned by the various SAX handlers for the specified/n"
 "XML file./n/n"
 "Options:/n"
 " -u=xxx Handle unrepresentable chars [fail | rep | ref*]./n"
 " -v=xxx Validation scheme [always | never | auto*]./n"
 " -n Enable namespace processing./n"
 " -s Enable schema processing./n"
 " -f Enable full schema constraint checking./n"
 " -x=XXX Use a particular encoding for output (LATIN1*)./n"
 " -? Show this help./n/n"
 " * = Default if not provided explicitly./n/n"
 "The parser has intrinsic support for the following encodings:/n"
 " UTF-8, USASCII, ISO8859-1, UTF-16[BL]E, UCS-4[BL]E,/n"
 " WINDOWS-1252, IBM1140, IBM037, IBM1047./n"
 << XERCES_STD_QUALIFIER endl;
}

// ---------------------------------------------------------------------------
// Program entry point
// ---------------------------------------------------------------------------
int main(int argC, char* argV[])
{
    // Initialize the XML4C2 system
    try
    {
         XMLPlatformUtils::Initialize();
    }

catch (const XMLException& toCatch)
 {
 XERCES_STD_QUALIFIER cerr << "Error during initialization! :/n"
 << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
 return 1;
 }

// Check command line and extract arguments.
 if (argC < 2)
 {
 usage();
 XMLPlatformUtils::Terminate();
 return 1;
 }

int parmInd;
 for (parmInd = 1; parmInd < argC; parmInd++)
 {
 // Break out on first parm not starting with a dash
 if (argV[parmInd][0] != '-')
 break;

        // Watch for special case help request
        if (!strcmp(argV[parmInd], "-?"))
        {
            usage();
            XMLPlatformUtils::Terminate();
            return 2;
        }
         else if (!strncmp(argV[parmInd], "-v=", 3)
              || !strncmp(argV[parmInd], "-V=", 3))
        {
            const char* const parm = &argV[parmInd][3];

if (!strcmp(parm, "never"))
 valScheme = SAXParser::Val_Never;
 else if (!strcmp(parm, "auto"))
 valScheme = SAXParser::Val_Auto;
 else if (!strcmp(parm, "always"))
 valScheme = SAXParser::Val_Always;
 else
 {
 XERCES_STD_QUALIFIER cerr << "Unknown -v= value: " << parm << XERCES_STD_QUALIFIER endl;
 XMLPlatformUtils::Terminate();
 return 2;
 }
 }
 else if (!strcmp(argV[parmInd], "-n")
 || !strcmp(argV[parmInd], "-N"))
 {
 doNamespaces = true;
 }
 else if (!strcmp(argV[parmInd], "-s")
 || !strcmp(argV[parmInd], "-S"))
 {
 doSchema = true;
 }
 else if (!strcmp(argV[parmInd], "-f")
 || !strcmp(argV[parmInd], "-F"))
 {
 schemaFullChecking = true;
 }
 else if (!strncmp(argV[parmInd], "-x=", 3)
 || !strncmp(argV[parmInd], "-X=", 3))
 {
 // Get out the encoding name
 encodingName = &argV[parmInd][3];
 }
 else if (!strncmp(argV[parmInd], "-u=", 3)
 || !strncmp(argV[parmInd], "-U=", 3))
 {
 const char* const parm = &argV[parmInd][3];

if (!strcmp(parm, "fail"))
 unRepFlags = XMLFormatter::UnRep_Fail;
 else if (!strcmp(parm, "rep"))
 unRepFlags = XMLFormatter::UnRep_Replace;
 else if (!strcmp(parm, "ref"))
 unRepFlags = XMLFormatter::UnRep_CharRef;
 else
 {
 XERCES_STD_QUALIFIER cerr << "Unknown -u= value: " << parm << XERCES_STD_QUALIFIER endl;
 XMLPlatformUtils::Terminate();
 return 2;
 }
 }
 else
 {
 XERCES_STD_QUALIFIER cerr << "Unknown option '" << argV[parmInd]
 << "', ignoring it/n" << XERCES_STD_QUALIFIER endl;
 }
 }

    //
    // And now we have to have only one parameter left and it must be
    // the file name.
    //
    if (parmInd + 1 != argC)
    {
        usage();
        XMLPlatformUtils::Terminate();
        return 1;
    }
    xmlFile = argV[parmInd];
    int errorCount = 0;

    //
    // Create a SAX parser object. Then, according to what we were told on
    // the command line, set it to validate or not.
    //
    SAXParser* parser = new SAXParser;
    parser->setValidationScheme(valScheme);
    parser->setDoNamespaces(doNamespaces);
    parser->setDoSchema(doSchema);
    parser->setValidationSchemaFullChecking(schemaFullChecking);

//
 // Create the handler object and install it as the document and error
 // handler for the parser-> Then parse the file and catch any exceptions
 // that propogate out
 //
 int errorCode = 0;
 try
 {
 SAXPrintHandlers handler(encodingName, unRepFlags);
 parser->setDocumentHandler(&handler);
 parser->setErrorHandler(&handler);
 parser->parse(xmlFile);
 errorCount = parser->getErrorCount();
 }
 catch (const OutOfMemoryException&)
 {
 XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
 errorCode = 5;
 }
 catch (const XMLException& toCatch)
 {
 XERCES_STD_QUALIFIER cerr << "/nAn error occurred/n Error: "
 << StrX(toCatch.getMessage())
 << "/n" << XERCES_STD_QUALIFIER endl;
 errorCode = 4;
 }
 if(errorCode) {
 XMLPlatformUtils::Terminate();
 return errorCode;
 }

    //
    // Delete the parser itself. Must be done prior to calling Terminate, below.
    //
    delete parser;

// And call the termination method
XMLPlatformUtils::Terminate();

    if (errorCount > 0)
        return 4;
    else
        return 0;
}

//SAXPrintHandlers.hpp

/*
* $Log$
* Revision 1.11 2004/09/08 13:55:34 peiyongz
* Apache License Version 2.0
*
* Revision 1.10 2004/02/15 19:43:15 amassari
* Removed cause for warnings in VC 7.1
*
* Revision 1.9 2002/11/05 21:46:20 tng
* Explicit code using namespace in application.
*
* Revision 1.8 2002/02/01 22:41:17 peiyongz
* sane_include
*
* Revision 1.7 2000/10/10 23:55:59 andyh
* XMLFormatter patch, contributed by Bill Schindler. Fix problems with
* output to multi-byte encodings.
*
* Revision 1.6 2000/04/06 19:09:52 roddey
* Some more improvements to output formatting. Now it will correctly
* handle doing the 'replacement char' style of dealing with chars
* that are unrepresentable.
*
* Revision 1.5 2000/04/05 00:20:32 roddey
* More updates for the low level formatted output support
*
* Revision 1.4 2000/03/28 19:43:12 roddey
* Fixes for signed/unsigned warnings. New work for two way transcoding
* stuff.
*
* Revision 1.3 2000/03/02 19:53:49 roddey
* This checkin includes many changes done while waiting for the
* 1.1.0 code to be finished. I can't list them all here, but a list is
* available elsewhere.
*
* Revision 1.2 2000/02/06 07:47:24 rahulj
* Year 2K copyright swat.
*
* Revision 1.1.1.1 1999/11/09 01:09:29 twl
* Initial checkin
*
* Revision 1.8 1999/11/08 20:43:42 rahul
* Swat for adding in Product name and CVS comment log variable.
*
*/

#include <xercesc/sax/HandlerBase.hpp>
#include <xercesc/framework/XMLFormatter.hpp>

XERCES_CPP_NAMESPACE_USE

class SAXPrintHandlers : public HandlerBase, private XMLFormatTarget
{
public:
    // -----------------------------------------------------------------------
    // Constructors
    // -----------------------------------------------------------------------
    SAXPrintHandlers
    (
        const   char* const                 encodingName
        , const XMLFormatter::UnRepFlags    unRepFlags
    );
    ~SAXPrintHandlers();

    // -----------------------------------------------------------------------
    // Implementations of the format target interface
    // -----------------------------------------------------------------------
    void writeChars
    (
        const   XMLByte* const toWrite
    );

    void writeChars
    (
        const   XMLByte* const toWrite
        , const unsigned int    count
        , XMLFormatter* const   formatter
    );

    // -----------------------------------------------------------------------
    // Implementations of the SAX DocumentHandler interface
    // -----------------------------------------------------------------------
    void endDocument();

void endElement(const XMLCh* const name);

void characters(const XMLCh* const chars, const unsigned int length);

    void ignorableWhitespace
    (
        const   XMLCh* const    chars
        , const unsigned int    length
    );

    void processingInstruction
    (
        const   XMLCh* const    target
        , const XMLCh* const    data
    );

void startDocument();

void startElement(const XMLCh* const name, AttributeList& attributes);

    // -----------------------------------------------------------------------
    // Implementations of the SAX ErrorHandler interface
    // -----------------------------------------------------------------------
    void warning(const SAXParseException& exc);
    void error(const SAXParseException& exc);
    void fatalError(const SAXParseException& exc);

    // -----------------------------------------------------------------------
    // Implementation of the SAX DTDHandler interface
    // -----------------------------------------------------------------------
    void notationDecl
    (
        const   XMLCh* const    name
        , const XMLCh* const    publicId
        , const XMLCh* const    systemId
    );

    void unparsedEntityDecl
    (
        const   XMLCh* const    name
        , const XMLCh* const    publicId
        , const XMLCh* const    systemId
        , const XMLCh* const    notationName
    );

private :
    // -----------------------------------------------------------------------
    // Private data members
    //
    // fFormatter
    //      This is the formatter object that is used to output the data
    //      to the target. It is set up to format to the standard output
    //      stream.
    // -----------------------------------------------------------------------
    XMLFormatter    fFormatter;
};

//SAXPrintHandlers.cpp

/*
* $Log$
* Revision 1.19 2005/01/12 20:43:21 cargilld
* Remove warning messages.
*
* Revision 1.18 2004/09/08 13:55:34 peiyongz
* Apache License Version 2.0
*
* Revision 1.17 2003/05/30 09:36:36 gareth
* Use new macros for iostream.h and std:: issues.
*
* Revision 1.16 2003/03/17 21:03:45 peiyongz
* Bug#17983
*
* Revision 1.15 2002/02/01 22:41:17 peiyongz
* sane_include
*
* Revision 1.14 2001/05/11 13:24:58 tng
* Copyright update.
*
* Revision 1.13 2001/05/03 16:00:25 tng
* Schema: samples update with schema
*
* Revision 1.12 2000/10/10 23:55:58 andyh
* XMLFormatter patch, contributed by Bill Schindler. Fix problems with
* output to multi-byte encodings.
*
* Revision 1.11 2000/07/25 22:41:32 aruna1
* Char definitions in XMLUni moved to XMLUniDefs
*
* Revision 1.10 2000/06/17 01:58:06 rahulj
* Now output the PI's with no space between ? and target.
*
* Revision 1.9 2000/05/31 23:58:19 rahulj
* Needed an explicit char* cast to get it working under Solaris.
*
* Revision 1.8 2000/04/07 23:25:53 roddey
* A couple more tweaks of the event handler output.
*
* Revision 1.7 2000/04/06 19:09:51 roddey
* Some more improvements to output formatting. Now it will correctly
* handle doing the 'replacement char' style of dealing with chars
* that are unrepresentable.
*
* Revision 1.6 2000/04/05 00:20:32 roddey
* More updates for the low level formatted output support
*
* Revision 1.5 2000/03/28 19:43:11 roddey
* Fixes for signed/unsigned warnings. New work for two way transcoding
* stuff.
*
* Revision 1.4 2000/03/02 19:53:49 roddey
* This checkin includes many changes done while waiting for the
* 1.1.0 code to be finished. I can't list them all here, but a list is
* available elsewhere.
*
* Revision 1.3 2000/02/11 03:05:35 abagchi
* Removed second parameter from call to StrX constructor
*
* Revision 1.2 2000/02/06 07:47:24 rahulj
* Year 2K copyright swat.
*
* Revision 1.1.1.1 1999/11/09 01:09:29 twl
* Initial checkin
*
* Revision 1.11 1999/11/08 20:43:42 rahul
* Swat for adding in Product name and CVS comment log variable.
*
*/

// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
#include <xercesc/util/XMLUniDefs.hpp>
#include <xercesc/sax/AttributeList.hpp>
#include "SAXPrint.hpp"

// ---------------------------------------------------------------------------
// Local const data
//
// Note: This is the 'safe' way to do these strings. If you compiler supports
//        L"" style strings, and portability is not a concern, you can use
//        those types constants directly.
// ---------------------------------------------------------------------------
static const XMLCh gEndElement[] = { chOpenAngle, chForwardSlash, chNull };
static const XMLCh gEndPI[] = { chQuestion, chCloseAngle, chNull };
static const XMLCh gStartPI[] = { chOpenAngle, chQuestion, chNull };
static const XMLCh gXMLDecl1[] =
{
        chOpenAngle, chQuestion, chLatin_x, chLatin_m, chLatin_l
    ,   chSpace, chLatin_v, chLatin_e, chLatin_r, chLatin_s, chLatin_i
    ,   chLatin_o, chLatin_n, chEqual, chDoubleQuote, chDigit_1, chPeriod
    ,   chDigit_0, chDoubleQuote, chSpace, chLatin_e, chLatin_n, chLatin_c
    ,   chLatin_o, chLatin_d, chLatin_i, chLatin_n, chLatin_g, chEqual
    ,   chDoubleQuote, chNull
};

static const XMLCh gXMLDecl2[] =
{
chDoubleQuote, chQuestion, chCloseAngle
, chLF, chNull
};

// ---------------------------------------------------------------------------
// SAXPrintHandlers: Constructors and Destructor
// ---------------------------------------------------------------------------
SAXPrintHandlers::SAXPrintHandlers( const char* const encodingName
, const XMLFormatter::UnRepFlags unRepFlags) :

fFormatter
 (
 encodingName
 , 0
 , this
 , XMLFormatter::NoEscapes
 , unRepFlags
 )
{
 //
 // Go ahead and output an XML Decl with our known encoding. This
 // is not the best answer, but its the best we can do until we
 // have SAX2 support.
 //
 fFormatter << gXMLDecl1 << fFormatter.getEncodingName() << gXMLDecl2;
}

SAXPrintHandlers::~SAXPrintHandlers()
{
}

// ---------------------------------------------------------------------------
// SAXPrintHandlers: Overrides of the output formatter target interface
// ---------------------------------------------------------------------------
void SAXPrintHandlers::writeChars(const XMLByte* const /* toWrite */)
{
}

void SAXPrintHandlers::writeChars(const XMLByte* const toWrite,
                                  const unsigned int count,
                                  XMLFormatter* const /* formatter */)
{
    // For this one, just dump them to the standard output
    // Surprisingly, Solaris was the only platform on which
    // required the char* cast to print out the string correctly.
    // Without the cast, it was printing the pointer value in hex.
    // Quite annoying, considering every other platform printed
    // the string with the explicit cast to char* below.
    XERCES_STD_QUALIFIER cout.write((char *) toWrite, (int) count);
XERCES_STD_QUALIFIER cout.flush();
}

// ---------------------------------------------------------------------------
// SAXPrintHandlers: Overrides of the SAX ErrorHandler interface
// ---------------------------------------------------------------------------
void SAXPrintHandlers::error(const SAXParseException& e)
{
 XERCES_STD_QUALIFIER cerr << "/nError at file " << StrX(e.getSystemId())
 << ", line " << e.getLineNumber()
 << ", char " << e.getColumnNumber()
 << "/n Message: " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
}

void SAXPrintHandlers::fatalError(const SAXParseException& e)
{
 XERCES_STD_QUALIFIER cerr << "/nFatal Error at file " << StrX(e.getSystemId())
 << ", line " << e.getLineNumber()
 << ", char " << e.getColumnNumber()
 << "/n Message: " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
}

void SAXPrintHandlers::warning(const SAXParseException& e)
{
 XERCES_STD_QUALIFIER cerr << "/nWarning at file " << StrX(e.getSystemId())
 << ", line " << e.getLineNumber()
 << ", char " << e.getColumnNumber()
 << "/n Message: " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
}

// ---------------------------------------------------------------------------
// SAXPrintHandlers: Overrides of the SAX DTDHandler interface
// ---------------------------------------------------------------------------
void SAXPrintHandlers::unparsedEntityDecl(const     XMLCh* const /* name */
                                          , const   XMLCh* const /* publicId */
                                          , const   XMLCh* const /* systemId */
                                          , const   XMLCh* const /* notationName */)
{
    // Not used at this time
}

void SAXPrintHandlers::notationDecl(const   XMLCh* const /* name */
                                    , const XMLCh* const /* publicId */
                                    , const XMLCh* const /* systemId */)
{
    // Not used at this time
}

// ---------------------------------------------------------------------------
// SAXPrintHandlers: Overrides of the SAX DocumentHandler interface
// ---------------------------------------------------------------------------
void SAXPrintHandlers::characters(const     XMLCh* const    chars
                                  , const   unsigned int    length)
{
    fFormatter.formatBuf(chars, length, XMLFormatter::CharEscapes);
}

void SAXPrintHandlers::endDocument()
{
}

void SAXPrintHandlers::endElement(const XMLCh* const name)
{
// No escapes are legal here
fFormatter << XMLFormatter::NoEscapes << gEndElement << name << chCloseAngle;
}

void SAXPrintHandlers::ignorableWhitespace( const   XMLCh* const chars
                                            ,const unsigned int length)
{
    fFormatter.formatBuf(chars, length, XMLFormatter::NoEscapes);
}

void SAXPrintHandlers::processingInstruction(const XMLCh* const target
 , const XMLCh* const data)
{
 fFormatter << XMLFormatter::NoEscapes << gStartPI << target;
 if (data)
 fFormatter << chSpace << data;
 fFormatter << XMLFormatter::NoEscapes << gEndPI;
}

void SAXPrintHandlers::startDocument()
{
}

void SAXPrintHandlers::startElement(const XMLCh* const name
 , AttributeList& attributes)
{
 // The name has to be representable without any escapes
 fFormatter << XMLFormatter::NoEscapes
 << chOpenAngle << name;

unsigned int len = attributes.getLength();
 for (unsigned int index = 0; index < len; index++)
 {
 //
 // Again the name has to be completely representable. But the
 // attribute can have refs and requires the attribute style
 // escaping.
 //
 fFormatter << XMLFormatter::NoEscapes
 << chSpace << attributes.getName(index)
 << chEqual << chDoubleQuote
 << XMLFormatter::AttrEscapes
 << attributes.getValue(index)
 << XMLFormatter::NoEscapes
 << chDoubleQuote;
 }
 fFormatter << chCloseAngle;
}

zhujun012

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SAXPrint

 //SAXPrint.hpp /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership
复制链接

扫一扫