毕业设计64XML Parser源程序清单

Attributes.hpp#ifndef ATTRIBUTES_HPP#define ATTRIBUTES_HPPclass SAX2_EXPORT Attributes{public:// Constructors and Destructor/** Default constructor */Attributes(){}/** Destructor */virtual ~Attributes(){}virtual unsigned int getLength() const = 0;virtual const XMLCh* getURI(const unsigned int index) const = 0;virtual const XMLCh* getLocalName(const unsigned int index) const = 0;virtual const XMLCh* getQName(const unsigned int index) const = 0;virtual const XMLCh* getType(const unsigned int index) const = 0;virtual const XMLCh* getValue(const unsigned int index) const = 0;virtual int getIndex(const XMLCh* const uri, const XMLCh* const localPart ) const = 0 ;virtual int getIndex(const XMLCh* const qName ) const = 0 ;virtual const XMLCh* getType(const XMLCh* const uri, const XMLCh* const localPart ) const = 0 ;virtual const XMLCh* getType(const XMLCh* const qName) const = 0;virtual const XMLCh* getValue(const XMLCh* const uri, const XMLCh* const localPart ) const = 0 ;virtual const XMLCh* getValue(const XMLCh* const qName) const = 0; private :/* Constructors and operators *//* Copy constructor */Attributes(const Attributes&);/* Assignment operator */Attributes& operator=(const Attributes&);};#endifDefaultHandler.hpp#ifndef DEFAULTHANDLER_HPP#define DEFAULTHANDLER_HPP#include ContentHandler.hpp#include ErrorHandler.hpp#include SAXParseException.hppclass Locator;class Attributes;class SAX2_EXPORT DefaultHandler :public ContentHandler,public ErrorHandler,{public:virtual void characters(const XMLCh* const chars, const unsigned int length);virtual void endDocument();virtual void endElement(const XMLCh* const uri,const XMLCh* const localname,const XMLCh* const qname);virtual void ignorableWhitespace(const XMLCh* const chars, const unsigned int length);virtual void processingInstruction(const XMLCh* const target, const XMLCh* const data);virtual void resetDocument();virtual void setDocumentLocator(const Locator* const locator); virtual void startDocument();virtual void startElement(const XMLCh* const uri,const XMLCh* const localname,const XMLCh* const qname, const Attributes& attrs);virtual void startPrefixMapping(const XMLCh* const prefix,const XMLCh* const uri) ;virtual void endPrefixMapping(const XMLCh* const prefix) ;virtual void error(const SAXParseException& exception);virtual void fatalError(const SAXParseException& exception);virtual void warning(const SAXParseException& exception);virtual void resetErrors();// HandlerBase: Inline default implementationsinline void DefaultHandler::characters(const XMLCh* const,const unsigned int){}inline void DefaultHandler::endDocument(){}inline void DefaultHandler::endElement(const XMLCh* const, const XMLCh* const, const XMLCh* const){}inline void DefaultHandler::error(const SAXParseException&){}inline void DefaultHandler::fatalError(const SAXParseException& exception){throw exception;}inline voidDefaultHandler::ignorableWhitespace( const XMLCh* const, const unsigned int){}DefaultHandler::processingInstruction( const XMLCh* const, const XMLCh* const){}inline void DefaultHandler::resetErrors(){}inline void DefaultHandler::resetDocument(){}inline void DefaultHandler::setDocumentLocator(const Locator* const) {}inline void DefaultHandler::startDocument(){}inline voidDefaultHandler::startElement( const XMLCh* const, const XMLCh* const, const XMLCh* const, const Attributes&){}inline void DefaultHandler::warning(const SAXParseException&){}inline void DefaultHandler::startPrefixMapping ( const XMLCh* const,const XMLCh* const){}inline void DefaultHandler::endPrefixMapping ( const XMLCh* const) {}#endif // ! DEFAULTHANDLER_HPPContentHandler.hpp#ifndef CONTENTHANDLER_HPP#define CONTENTHANDLER_HPPclass Attributes;class Locator;class SAX2_EXPORT ContentHandler{public:/** Default constructor */ContentHandler(){}/** Destructor */virtual ~ContentHandler(){}virtual void characters(const XMLCh* const chars, const unsigned int length) = 0;virtual void endDocument () = 0;virtual void endElement(const XMLCh* const uri,const XMLCh* const localname,const XMLCh* const qname) = 0;virtual void ignorableWhitespace(const XMLCh* const chars, const unsigned int length) = 0;virtual void processingInstruction(const XMLCh* const target, const XMLCh* const data) = 0;virtual void setDocumentLocator(const Locator* const locator) = 0; virtual void startDocument() = 0;virtual void startElement(const XMLCh* const uri,const XMLCh* const localname,const XMLCh* const qname,const Attributes& attrs) = 0;virtual void startPrefixMapping(const XMLCh* const prefix,const XMLCh* const uri) = 0 ;virtual void endPrefixMapping(const XMLCh* const prefix) = 0 ;private :/* Unimplemented Constructors and operators *//* Copy constructor */ContentHandler(const ContentHandler&);/** Assignment operator */ContentHandler& operator=(const ContentHandler&); };#endifErrorHandler.hpp#ifndef ERRORHANDLER_HPP#define ERRORHANDLER_HPPclass SAXParseException;class SAX_EXPORT ErrorHandler{public:/** @name Constructors and Destructor *///@{/** Default constructor */ErrorHandler(){}/** Desctructor */virtual ~ErrorHandler(){}//@}/** @name The error handler interface *///@{virtual void warning(const SAXParseException& exception) = 0;virtual void error(const SAXParseException& exception) = 0;virtual void fatalError(const SAXParseException& exception) = 0; /*** Reset the Error handler object on its reuse** <p>This method helps in reseting the Error handler object* implementational defaults each time the Error handler is begun.</p>**/virtual void resetErrors() = 0;//@}private :/* Unimplemented constructors and operators *//* Copy constructor */ErrorHandler(const ErrorHandler&);/* Assignment operator */ErrorHandler& operator=(const ErrorHandler&);};#endifInputSource .hpp#ifndef INPUTSOURCE_HPP#define INPUTSOURCE_HPPclass BinInputStream;class SAX_EXPORT InputSource : public XMemory{public://-----------------------------------------------------------------------// All constructors are hidden, just the destructor is available /** Destructor*/virtual ~InputSource();virtual BinInputStream* makeStream() const = 0;virtual const XMLCh* getEncoding() const;virtual const XMLCh* getPublicId() const;virtual const XMLCh* getSystemId() const;virtual const bool getIssueFatalErrorIfNotFound() const;MemoryManager* getMemoryManager() const;virtual void setEncoding(const XMLCh* const encodingStr);virtual void setPublicId(const XMLCh* const publicId);virtual void setSystemId(const XMLCh* const systemId);virtual void setIssueFatalErrorIfNotFound(const bool flag) protected :// Hidden constructors/** Default constructor */InputSource(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);/** Constructor with a system identifier as XMLCh type.* @param systemId The system identifier (URI).*/InputSource(const XMLCh* const systemId,MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);/** Constructor with a system and public identifiers* @param systemId The system identifier (URI).* @param publicId The public identifier as in the entity definition.*/InputSource(const XMLCh* const systemId, const XMLCh* const publicId, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);/** Constructor witha system identifier as string* @param systemId The system identifier (URI).*/InputSource(const char* const systemId,MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);/** Constructor witha system and public identifiers. Both as string * @param systemId The system identifier (URI).* @param publicId The public identifier as in the entity definition.*/InputSource(const char* const systemId, const char* const publicId, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);private:// Unimplemented constructors and operatorsInputSource(const InputSource&);InputSource& operator=(const InputSource&);// Private data members// fEncoding// This is the encoding to use. Usually this is null, which means // to use the information found in the file itself. But, if set, // this encoding will be used without question.// fPublicId// This is the optional public id for the input source. It can // be null if none is desired.// fSystemId// This is the system id for the input source. This is what is // actually used to open the source.// fFatalErrorIfNotFoundMemoryManager* fMemoryManager;XMLCh* fEncoding;XMLCh* fPublicId;XMLCh* fSystemId;bool fFatalErrorIfNotFound;};// InputSource: Getter methodsinline const XMLCh* InputSource::getEncoding() const{return fEncoding;}inline const XMLCh* InputSource::getPublicId() const{return fPublicId;}inline const XMLCh* InputSource::getSystemId() const{return fSystemId;}inline const bool InputSource::getIssueFatalErrorIfNotFound() const {return fFatalErrorIfNotFound;}inline MemoryManager* InputSource::getMemoryManager() const{return fMemoryManager;}// InputSource: Setter methodsinline void InputSource::setIssueFatalErrorIfNotFound(const bool flag){fFatalErrorIfNotFound = flag;}#endifSAXException.hpp#include "SAXException.hpp"// SAXNotSupportedException Constructors SAXNotSupportedException::SAXNotSupportedException(): SAXException(){}SAXNotSupportedException::SAXNotSupportedException(const XMLCh* const msg): SAXException(msg){}SAXNotSupportedException::SAXNotSupportedException(const char* const msg): SAXException(msg){}SAXNotSupportedException::SAXNotSupportedException(const SAXException& toCopy): SAXException(toCopy){}// SAXNotRecognizedException Constructors SAXNotRecognizedException::SAXNotRecognizedException() : SAXException(){}SAXNotRecognizedException::SAXNotRecognizedException(const XMLCh* const msg): SAXException(msg){}SAXNotRecognizedException::SAXNotRecognizedException(const char* const msg): SAXException(msg){}SAXNotRecognizedException::SAXNotRecognizedException(const SAXException& toCopy): SAXException(toCopy){}SAXParseException.hpp#ifndef SAXPARSEEXCEPTION_HPP#define SAXPARSEEXCEPTION_HPPclass Locator;/*** Encapsulate an XML parse error or warning.** <p>This exception will include information for locating the error * in the original XML document. Note that although the application * will receive a SAXParseException as the argument to the handlers * in the ErrorHandler interface, the application is not actually * required to throw the exception; instead, it can simply read the * information in it and take a different action.</p>** <p>Since this exception is a subclass of SAXException, it* inherits the ability to wrap another exception.</p>*/class SAX_EXPORT SAXParseException : public SAXException{public:/** @name Constructors and Destructor *///@{/*** Create a new SAXParseException from a message and a Locator. ** <p>This constructor is especially useful when an application is * creating its own exception from within a DocumentHandler* callback.</p>*/SAXParseException(const XMLCh* const message, const Locator& locator);/*** Create a new SAXParseException.** <p>This constructor is most useful for parser writers.</p>** <p>If the system identifier is a URL, the parser must resolve it * fully before creating the exception.</p>** @param message The error or warning message.* @param publicId The public identifer of the entity that generated * the error or warning.* @param systemId The system identifer of the entity that generated * the error or warning.* @param lineNumber The line number of the end of the text that * caused the error or warning.* @param columnNumber The column number of the end of the text that * caused the error or warning.* @see Parser#setLocale*/SAXParseException(const XMLCh* const message, const XMLCh* const publicId, const XMLCh* const systemId, const XMLSSize_t lineNumber, const XMLSSize_t columnNumber);/*** Copy constructor** @param toCopy The object to be copied*/SAXParseException(const SAXParseException& toCopy);/*** Destructor*/~SAXParseException();//@}/** @name Assignment operator *///@{/*** Assignment operator** @param toAssign The object to be copied through assignment**/SAXParseException& operator=(const SAXParseException& toAssign); //@}/** @name Getter methods *///@{/*** The column number of the end of the text where the exception occurred.** <p>The first column in a line is position 1.</p>** @return An integer representing the column number, or -1* if none is available.* @see Locator#getColumnNumber*/XMLSSize_t getColumnNumber() const;/*** The line number of the end of the text where the exception occurred. * @return An integer representing the line number, or -1* if none is available.* @see Locator#getLineNumber*/XMLSSize_t getLineNumber() const;/*** Get the public identifier of the entity where the exception occurred.** @return A string containing the public identifier, or null* if none is available.* @see Locator#getPublicId*/const XMLCh* getPublicId() const;/*** Get the system identifier of the entity where the exception occurred.* <p>If the system identifier is a URL, it will be resolved* fully.</p>* @return A string containing the system identifier, or null* if none is available.* @see Locator#getSystemId*/const XMLCh* getSystemId() const;//@}private:/* Data Members *//* The column in the source text where the error occured. */XMLSSize_t fColumnNumber;/* The line in the source text where the error occured. */XMLSSize_t fLineNumber;/* The public id of the file where the error occured. */XMLCh* fPublicId;/* The system id of the file where the error occured. */XMLCh* fSystemId;};#endifXMLPScanToken.hpp#if !defined(XMLPSCANTOKEN_HPP)#define XMLPSCANTOKEN_HPPclass XMLScanner;class XMLPARSER_EXPORT XMLPScanToken{public ://-----------------------------------------------------------------------// Constructors and Destructor//-----------------------------------------------------------------------/** @name Constructor */XMLPScanToken();XMLPScanToken(const XMLPScanToken& toCopy);/** @name Destructor */~XMLPScanToken();//-----------------------------------------------------------------------// Public operators//-----------------------------------------------------------------------XMLPScanToken& operator=(const XMLPScanToken& toCopy);protected :friend class XMLScanner;void set(const XMLUInt32 scannerId, const XMLUInt32 sequenceId);private ://-----------------------------------------------------------------------// Private data members//// fScannerId// This field is set to the id of the scanner, to catch problems// where a token is gotten from one scanner and passed to another.// Each scanner is assigned an incrementing id.//// fSequenceId// In order to avoid problems such as calling scanNext() without // a call to scanFirst() and such, this value is set when scanFirst()// is called and matches this token to the current sequence id of// the scanner.//-----------------------------------------------------------------------XMLUInt32 fScannerId;XMLUInt32 fSequenceId;};//---------------------------------------------------------------------------// XMLPScanToken: Constructors and Operators//---------------------------------------------------------------------------inline XMLPScanToken::XMLPScanToken() :fScannerId(0), fSequenceId(0){}inline XMLPScanToken::XMLPScanToken(const XMLPScanToken& toCopy) : fScannerId(toCopy.fScannerId), fSequenceId(toCopy.fSequenceId){}inline XMLPScanToken::~XMLPScanToken(){}//---------------------------------------------------------------------------// XMLPScanToken: Public operators//---------------------------------------------------------------------------inline XMLPScanToken& XMLPScanToken::operator=(const XMLPScanToken& toCopy){if (this == &toCopy)return *this;fScannerId = toCopy.fScannerId;fSequenceId = toCopy.fSequenceId;return *this;}//---------------------------------------------------------------------------// XMLPScanToken: Hidden methods//---------------------------------------------------------------------------inline void XMLPScanToken::set( const XMLUInt32 scannerId, const XMLUInt32 sequenceId){fScannerId = scannerId;fSequenceId = sequenceId;}#endifXMLReaderFactory.hpp#ifndef XMLREADERFACTORY_HPP#define XMLREADERFACTORY_HPP#include "SAXException.hpp"class MemoryManager;class SAX2_EXPORT XMLReaderFactory{protected: // really should be private, but that causes compiler warnings.XMLReaderFactory() ;~XMLReaderFactory() ;public:static SAX2XMLReader * createXMLReader(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager) ;static SAX2XMLReader * createXMLReader(const XMLCh* className) ; };inline SAX2XMLReader * XMLReaderFactory::createXMLReader(MemoryManager* const manager){return (SAX2XMLReader*)(new (manager) SAX2XMLReaderImpl(manager));}inline SAX2XMLReader * XMLReaderFactory::createXMLReader(const XMLCh * className){throw SAXNotSupportedException();return 0;}#endifSAX2XMLReader.hpp#ifndef SAX2XMLReader_HPP#define SAX2XMLReader_HPP#include "XMLPScanToken.hpp"class ContentHandler ;class InputSource;class ErrorHandler;class SAX2_EXPORT SAX2XMLReader{public:SAX2XMLReader(){}/** The destructor */virtual ~SAX2XMLReader(){}// The XMLReader interfacevirtual ContentHandler* getContentHandler() const = 0 ;virtual ErrorHandler* getErrorHandler() const = 0 ;virtual bool getFeature(const XMLCh* const name) const = 0;virtual void* getProperty(const XMLCh* const name) const = 0 ; virtual void setContentHandler(ContentHandler* const handler) = 0; virtual void setErrorHandler(ErrorHandler* const handler) = 0; virtual void setFeature(const XMLCh* const name, const bool value) = 0;virtual void setProperty(const XMLCh* const name, void* value) = 0 ;virtual void parse(const InputSource& source) = 0;virtual void parse(const XMLCh* const systemId) = 0;virtual void parse(const char* const systemId) = 0;virtual int getErrorCount() const = 0 ;virtual bool getExitOnFirstFatalError() const = 0;/*** Returns the string corresponding to a URI id from the URI stringpool.* @param uriId id of the string in the URI string pool.* @return URI string corresponding to the URI id.*/virtual const XMLCh* getURIText(unsigned int uriId) const = 0; /*** Returns the current src offset within the input source.* @return offset within the input source*/virtual unsigned int getSrcOffset() const = 0;virtual void setExitOnFirstFatalError(const bool newState) = 0; // Progressive scan methods/** @name Progressive scan methods *//** Begin a progressive parse operation* This method is used to start a progressive parse on a XML file. * To continue parsing, subsequent calls must be to the parseNext * method.* It scans through the prolog and returns a token to be used on * subsequent scanNext() calls. If the return value is true, then the* token is legal and ready for further use. If it returns false, then* the scan of the prolog failed and the token is not going to work on* subsequent scanNext() calls.*/virtual bool parseFirst(const XMLCh* const systemId, XMLPScanToken& toFill) = 0;/** Begin a progressive parse operation* This method is used to start a progressive parse on a XML file. * To continue parsing, subsequent calls must be to the parseNext * method.* It scans through the prolog and returns a token to be used on * subsequent scanNext() calls. If the return value is true, then the* token is legal and ready for further use. If it returns false, then* the scan of the prolog failed and the token is not going to work on* subsequent scanNext() calls.*/virtual bool parseFirst(const char* const systemId, XMLPScanToken& toFill) = 0;/** Begin a progressive parse operation* This method is used to start a progressive parse on a XML file. * To continue parsing, subsequent calls must be to the parseNext * method.* It scans through the prolog and returns a token to be used on * subsequent scanNext() calls. If the return value is true, then the* token is legal and ready for further use. If it returns false, then* the scan of the prolog failed and the token is not going to work on* subsequent scanNext() calls.virtual bool parseFirst(const InputSource& source, XMLPScanToken& toFill) = 0/** Continue a progressive parse operation* This method is used to continue with progressive parsing of * XML files started by a call to 'parseFirst' method.* It parses the XML file and stops as soon as it comes across * a XML token (as defined in the XML specification). Relevant * callback handlers are invoked as required by the SAX* specification.*/virtual bool parseNext(XMLPScanToken& token) = 0;/** Reset the parser after a progressive parse*/virtual void parseReset(XMLPScanToken& token) = 0;private :/* The copy constructor, you cannot call this directly */SAX2XMLReader(const SAX2XMLReader&);/* The assignment operator, you cannot call this directly */SAX2XMLReader& operator=(const SAX2XMLReader&);};#endifSAX2CountHandlers .hpp#include "Attributes.hpp"#include "DefaultHandler.hpp"class SAX2CountHandlers : public DefaultHandler{public:// Constructors and DestructorSAX2CountHandlers();~SAX2CountHandlers();// Getter methodsunsigned int getElementCount() const{return fElementCount;}unsigned int getAttrCount() const{return fAttrCount;}unsigned int getCharacterCount() const{return fCharacterCount;}bool getSawErrors() const{return fSawErrors;}unsigned int getSpaceCount() const{return fSpaceCount;}// Handlers for the SAX ContentHandler interfacevoid startElement(const XMLCh* const uri, const XMLCh* const localname, const XMLCh* const qname, const Attributes& attrs);void characters(const XMLCh* const chars, const unsigned int length);void ignorableWhitespace(const XMLCh* const chars, const unsigned int length);void resetDocument();// Handlers for the SAX ErrorHandler interfacevoid warning(const SAXParseException& exception);void error(const SAXParseException& exception);void fatalError(const SAXParseException& exception);void resetErrors();private:// Private data members// fAttrCount// fCharacterCount// fElementCount// fSpaceCount// These are just counters that are run upwards based on the input// from the document handlers.// fSawErrors// This is set by the error handlers, and is queryable later to// see if any errors occured.unsigned int fAttrCount;unsigned int fCharacterCount;unsigned int fElementCount;unsigned int fSpaceCount;bool fSawErrors;};SAX2CountHandlers.cpp#include "SAX2Count.hpp"#include "Attributes.hpp"#include "SAXParseException.hpp"#include "SAXException.hpp"// SAX2CountHandlers: Constructors and DestructorSAX2CountHandlers::SAX2CountHandlers() :fElementCount(0), fAttrCount(0), fCharacterCount(0), fSpaceCount(0), fSawErrors(false){}SAX2CountHandlers::~SAX2CountHandlers(){}void SAX2CountHandlers::startElement(const XMLCh* const uri, const XMLCh* const localname, const XMLCh* const qname, const Attributes& attrs){fElementCount++;fAttrCount += attrs.getLength();}void SAX2CountHandlers::characters( const XMLCh* const chars, const unsigned int length){fCharacterCount += length;}void SAX2CountHandlers::ignorableWhitespace( const XMLCh* const chars, const unsigned int length) {fSpaceCount += length;}void SAX2CountHandlers::resetDocument(){fAttrCount = 0;fCharacterCount = 0;fElementCount = 0;fSpaceCount = 0;}// SAX2CountHandlers: Overrides of the SAX ErrorHandler interfacevoid SAX2CountHandlers::error(const SAXParseException& e){fSawErrors = true;cerr << "\nError at file " << StrX(e.getSystemId()) << ", line " << e.getLineNumber()<< ", char " << e.getColumnNumber()<< "\n Message: " << StrX(e.getMessage()) << endl;}void SAX2CountHandlers::fatalError(const SAXParseException& e) {fSawErrors = true;cerr << "\nFatal Error at file " << StrX(e.getSystemId()) << ", line " << e.getLineNumber()<< ", char " << e.getColumnNumber()<< "\n Message: " << StrX(e.getMessage()) << endl;}void SAX2CountHandlers::warning(const SAXParseException& e) {cerr << "\nWarning at file " << StrX(e.getSystemId()) << ", line " << e.getLineNumber()<< ", char " << e.getColumnNumber()<< "\n Message: " << StrX(e.getMessage()) << endl;}void SAX2CountHandlers::resetErrors(){fSawErrors = false;}#include <stdlib.h>#include <string.h>#include <iostream.h>#include "SAX2CountHandlers.hpp"#include "XMLReaderFactory.hpp"#include "SAX2XMLReader.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 DestructorStrX(const XMLCh* const toTranscode){// Call the private transcoding methodfLocalForm = XMLString::transcode(toTranscode);}~StrX(){XMLString::release(&fLocalForm);}// Getter methodsconst char* localForm() const{return fLocalForm;}private :// Private data members// fLocalForm// This is the local code page form of the string.char* fLocalForm;};inline ostream& operator<<(ostream& target, const StrX& toDump) {target << toDump.localForm();return target;}。