//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
/*
* 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.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
/*
* 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.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
/*
* 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.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;
}