void DocumentConverter::ParseException(const VXIchar * message) const
{
if (message == NULL) throw SAXParseException(NULL, *locator);
VXIcharToXMLCh text(message);
throw SAXParseException(text.c_str(), *locator);
}
void SAXParser::error( const unsigned int
, const XMLCh* const
, const XMLErrorReporter::ErrTypes errType
, const XMLCh* const errorText
, const XMLCh* const systemId
, const XMLCh* const publicId
, const XMLFileLoc lineNum
, const XMLFileLoc colNum)
{
SAXParseException toThrow = SAXParseException
(
errorText
, publicId
, systemId
, lineNum
, colNum
, fMemoryManager
);
if (!fErrorHandler)
{
if (errType == XMLErrorReporter::ErrType_Fatal)
throw toThrow;
else
return;
}
if (errType == XMLErrorReporter::ErrType_Warning)
fErrorHandler->warning(toThrow);
else if (errType == XMLErrorReporter::ErrType_Fatal)
fErrorHandler->fatalError(toThrow);
else
fErrorHandler->error(toThrow);
}
//------------------------------------------
void skXMLErrorHandler::fatalError (const SAXParseException& toCatch)
//------------------------------------------
{
cerr << "Fatal Error at file \"" << DOMString(toCatch.getSystemId())
<< "\", line " << toCatch.getLineNumber()
<< ", column " << toCatch.getColumnNumber()
<< "\n Message: " << DOMString(toCatch.getMessage()) << endl;
throw SAXParseException(toCatch);
}
//------------------------------------------
void skXMLErrorHandler::error (const SAXParseException& toCatch)
//------------------------------------------
{
cerr << "Error at file \"" << DOMString(toCatch.getSystemId())
<< "\", line " << toCatch.getLineNumber()
<< ", column " << toCatch.getColumnNumber()
<< "\n Message: " << DOMString(toCatch.getMessage()) << endl;
throw SAXParseException(toCatch); // Copy the 'toCatch' object before throwing -
// otherwise we would be throwing a reference to
// a local object that gets destroyed before
// the catch.
}
void ParserEngine::handleEndElement(void* userData, const XML_Char* name)
{
ParserEngine* pThis = reinterpret_cast<ParserEngine*>(userData);
if (pThis->_pContentHandler)
{
try
{
pThis->_pNamespaceStrategy->endElement(name, pThis->_pContentHandler);
}
catch (XMLException& exc)
{
throw SAXParseException(exc.message(), pThis->locator());
}
}
}
void ParserEngine::handleStartElement(void* userData, const XML_Char* name, const XML_Char** atts)
{
ParserEngine* pThis = reinterpret_cast<ParserEngine*>(userData);
if (pThis->_pContentHandler)
{
try
{
pThis->_pNamespaceStrategy->startElement(name, atts, XML_GetSpecifiedAttributeCount(pThis->_parser)/2, pThis->_pContentHandler);
}
catch (XMLException& exc)
{
throw SAXParseException(exc.message(), pThis->locator());
}
}
}
// ---------------------------------------------------------------------------
// XercesDOMParser: Implementation of the XMLErrorReporter interface
// ---------------------------------------------------------------------------
void XercesDOMParser::error( const unsigned int
, const XMLCh* const
, const XMLErrorReporter::ErrTypes errType
, const XMLCh* const errorText
, const XMLCh* const systemId
, const XMLCh* const publicId
, const XMLFileLoc lineNum
, const XMLFileLoc colNum)
{
SAXParseException toThrow = SAXParseException
(
errorText
, publicId
, systemId
, lineNum
, colNum
, getMemoryManager()
);
//
// If there is an error handler registered, call it, otherwise ignore
// all but the fatal errors.
//
if (!fErrorHandler)
{
if (errType == XMLErrorReporter::ErrType_Fatal)
throw toThrow;
return;
}
if (errType == XMLErrorReporter::ErrType_Warning)
fErrorHandler->warning(toThrow);
else if (errType >= XMLErrorReporter::ErrType_Fatal)
fErrorHandler->fatalError(toThrow);
else
fErrorHandler->error(toThrow);
}
void ParserEngine::handleError(int errorNo)
{
try
{
switch (errorNo)
{
case XML_ERROR_NO_MEMORY:
throw XMLException("No memory");
case XML_ERROR_SYNTAX:
throw SAXParseException("Syntax error", locator());
case XML_ERROR_NO_ELEMENTS:
throw SAXParseException("No element found", locator());
case XML_ERROR_INVALID_TOKEN:
throw SAXParseException("Invalid token", locator());
case XML_ERROR_UNCLOSED_TOKEN:
throw SAXParseException("Unclosed token", locator());
case XML_ERROR_PARTIAL_CHAR:
throw SAXParseException("Partial character", locator());
case XML_ERROR_TAG_MISMATCH:
throw SAXParseException("Tag mismatch", locator());
case XML_ERROR_DUPLICATE_ATTRIBUTE:
throw SAXParseException("Duplicate attribute", locator());
case XML_ERROR_JUNK_AFTER_DOC_ELEMENT:
throw SAXParseException("Junk after document element", locator());
case XML_ERROR_PARAM_ENTITY_REF:
throw SAXParseException("Illegal parameter entity reference", locator());
case XML_ERROR_UNDEFINED_ENTITY:
throw SAXParseException("Undefined entity", locator());
case XML_ERROR_RECURSIVE_ENTITY_REF:
throw SAXParseException("Recursive entity reference", locator());
case XML_ERROR_ASYNC_ENTITY:
throw SAXParseException("Asynchronous entity", locator());
case XML_ERROR_BAD_CHAR_REF:
throw SAXParseException("Reference to invalid character number", locator());
case XML_ERROR_BINARY_ENTITY_REF:
throw SAXParseException("Reference to binary entity", locator());
case XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF:
throw SAXParseException("Reference to external entity in attribute", locator());
case XML_ERROR_MISPLACED_XML_PI:
throw SAXParseException("XML processing instruction not at start of external entity", locator());
case XML_ERROR_UNKNOWN_ENCODING:
throw SAXParseException("Unknown encoding", locator());
case XML_ERROR_INCORRECT_ENCODING:
throw SAXParseException("Encoding specified in XML declaration is incorrect", locator());
case XML_ERROR_UNCLOSED_CDATA_SECTION:
throw SAXParseException("Unclosed CDATA section", locator());
case XML_ERROR_EXTERNAL_ENTITY_HANDLING:
throw SAXParseException("Error in processing external entity reference", locator());
case XML_ERROR_NOT_STANDALONE:
throw SAXParseException("Document is not standalone", locator());
case XML_ERROR_UNEXPECTED_STATE:
throw SAXParseException("Unexpected parser state - please send a bug report", locator());
case XML_ERROR_ENTITY_DECLARED_IN_PE:
throw SAXParseException("Entity declared in parameter entity", locator());
case XML_ERROR_FEATURE_REQUIRES_XML_DTD:
throw SAXParseException("Requested feature requires XML_DTD support in Expat", locator());
case XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING:
throw SAXParseException("Cannot change setting once parsing has begun", locator());
case XML_ERROR_UNBOUND_PREFIX:
throw SAXParseException("Unbound prefix", locator());
case XML_ERROR_UNDECLARING_PREFIX:
throw SAXParseException("Must not undeclare prefix", locator());
case XML_ERROR_INCOMPLETE_PE:
throw SAXParseException("Incomplete markup in parameter entity", locator());
case XML_ERROR_XML_DECL:
throw SAXParseException("XML declaration not well-formed", locator());
case XML_ERROR_TEXT_DECL:
throw SAXParseException("Text declaration not well-formed", locator());
case XML_ERROR_PUBLICID:
throw SAXParseException("Illegal character(s) in public identifier", locator());
case XML_ERROR_SUSPENDED:
throw SAXParseException("Parser suspended", locator());
case XML_ERROR_NOT_SUSPENDED:
throw SAXParseException("Parser not suspended", locator());
case XML_ERROR_ABORTED:
throw SAXParseException("Parsing aborted", locator());
case XML_ERROR_FINISHED:
throw SAXParseException("Parsing finished", locator());
case XML_ERROR_SUSPEND_PE:
throw SAXParseException("Cannot suspend in external parameter entity", locator());
}
throw XMLException("Unknown Expat error code");
}
catch (SAXException& exc)
{
if (_pErrorHandler) _pErrorHandler->error(exc);
throw;
}
catch (Poco::Exception& exc)
{
if (_pErrorHandler) _pErrorHandler->fatalError(SAXParseException("Fatal error", locator(), exc));
throw;
}
}
void EventParser::fatalError(const SAXParseException& e)
{
throw SAXParseException(e);
}
void EventParser::warning(const SAXParseException& e)
{
throw SAXParseException(e);
}
