void XMLRuntime::read(const string& filename, FreeAX25::Runtime::Configuration& config) {
XercesDOMParser parser;
parser.setValidationScheme(XercesDOMParser::Val_Always);
parser.setDoNamespaces(true);
parser.setDoSchema(true);
parser.setDoXInclude(true);
parser.setHandleMultipleImports(true);
parser.setValidationSchemaFullChecking(true);
parser.setCreateEntityReferenceNodes(false);
parser.setIncludeIgnorableWhitespace(false);
DOMTreeErrorReporter errReporter;
parser.setErrorHandler(&errReporter);
parser.parse(filename.c_str());
if (errReporter.getSawErrors())
throw exception();
// Now read configuration from the DOM Tree:
XERCES_CPP_NAMESPACE::DOMDocument* doc = parser.getDocument();
assert(doc != nullptr);
auto rootElement = doc->getDocumentElement();
auto configName = rootElement->getAttribute(toX("name"));
config.setId(fmX(configName));
{ // Get settings:
auto nodeList = rootElement->getElementsByTagName(toX("Settings"));
if (nodeList->getLength() > 0)
readSettings(
"",
static_cast<DOMElement*>(nodeList->item(0)),
config.settings);
}
{ // Get plugins:
auto nodeList = rootElement->getElementsByTagName(toX("Plugins"));
if (nodeList->getLength() > 0)
readPlugins(
"",
static_cast<DOMElement*>(nodeList->item(0)),
config.plugins);
}
}
// ---------------------------------------------------------------------------
//
// main
//
// ---------------------------------------------------------------------------
int main(int argC, char* argV[])
{
int retval = 0;
// Initialize the XML4C2 system
try
{
XMLPlatformUtils::Initialize();
}
catch(const XMLException &toCatch)
{
XERCES_STD_QUALIFIER cerr << "Error during Xerces-c Initialization.\n"
<< " Exception message:"
<< StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
return 1;
}
// Check command line and extract arguments.
if (argC < 2)
{
usage();
XMLPlatformUtils::Terminate();
return 1;
}
// See if non validating dom parser configuration is requested.
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"))
gValScheme = XercesDOMParser::Val_Never;
else if (!strcmp(parm, "auto"))
gValScheme = XercesDOMParser::Val_Auto;
else if (!strcmp(parm, "always"))
gValScheme = XercesDOMParser::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"))
{
gDoNamespaces = true;
}
else if (!strcmp(argV[parmInd], "-s")
|| !strcmp(argV[parmInd], "-S"))
{
gDoSchema = true;
}
else if (!strcmp(argV[parmInd], "-f")
|| !strcmp(argV[parmInd], "-F"))
{
gSchemaFullChecking = true;
}
else if (!strcmp(argV[parmInd], "-e")
|| !strcmp(argV[parmInd], "-E"))
{
gDoCreate = true;
}
else if (!strncmp(argV[parmInd], "-wenc=", 6))
{
// Get out the encoding name
gOutputEncoding = XMLString::transcode( &(argV[parmInd][6]) );
}
else if (!strncmp(argV[parmInd], "-wfile=", 7))
{
goutputfile = &(argV[parmInd][7]);
}
else if (!strncmp(argV[parmInd], "-wddc=", 6))
{
const char* const parm = &argV[parmInd][6];
if (!strcmp(parm, "on"))
gDiscardDefaultContent = true;
else if (!strcmp(parm, "off"))
gDiscardDefaultContent = false;
else
{
XERCES_STD_QUALIFIER cerr << "Unknown -wddc= value: " << parm << XERCES_STD_QUALIFIER endl;
XMLPlatformUtils::Terminate();
return 2;
}
}
else if (!strncmp(argV[parmInd], "-wscs=", 6))
{
const char* const parm = &argV[parmInd][6];
if (!strcmp(parm, "on"))
gSplitCdataSections = true;
else if (!strcmp(parm, "off"))
gSplitCdataSections = false;
else
{
XERCES_STD_QUALIFIER cerr << "Unknown -wscs= value: " << parm << XERCES_STD_QUALIFIER endl;
XMLPlatformUtils::Terminate();
return 2;
}
}
else if (!strncmp(argV[parmInd], "-wflt=", 6))
{
const char* const parm = &argV[parmInd][6];
if (!strcmp(parm, "on"))
gUseFilter = true;
else if (!strcmp(parm, "off"))
gUseFilter = false;
else
{
XERCES_STD_QUALIFIER cerr << "Unknown -wflt= value: " << parm << XERCES_STD_QUALIFIER endl;
XMLPlatformUtils::Terminate();
return 2;
}
}
else if (!strncmp(argV[parmInd], "-wfpp=", 6))
{
const char* const parm = &argV[parmInd][6];
if (!strcmp(parm, "on"))
gFormatPrettyPrint = true;
else if (!strcmp(parm, "off"))
gFormatPrettyPrint = false;
else
{
XERCES_STD_QUALIFIER cerr << "Unknown -wfpp= value: " << parm << XERCES_STD_QUALIFIER endl;
XMLPlatformUtils::Terminate();
return 2;
}
}
else if (!strncmp(argV[parmInd], "-wbom=", 6))
{
const char* const parm = &argV[parmInd][6];
if (!strcmp(parm, "on"))
gWriteBOM = true;
else if (!strcmp(parm, "off"))
gWriteBOM = false;
else
{
XERCES_STD_QUALIFIER cerr << "Unknown -wbom= 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;
}
gXmlFile = argV[parmInd];
//
// Create our parser, then attach an error handler to the parser.
// The parser will call back to methods of the ErrorHandler if it
// discovers errors during the course of parsing the XML document.
//
XercesDOMParser *parser = new XercesDOMParser;
parser->setValidationScheme(gValScheme);
parser->setDoNamespaces(gDoNamespaces);
parser->setDoSchema(gDoSchema);
parser->setValidationSchemaFullChecking(gSchemaFullChecking);
parser->setCreateEntityReferenceNodes(gDoCreate);
DOMTreeErrorReporter *errReporter = new DOMTreeErrorReporter();
parser->setErrorHandler(errReporter);
//
// Parse the XML file, catching any XML exceptions that might propogate
// out of it.
//
bool errorsOccured = false;
try
{
parser->parse(gXmlFile);
}
catch (const OutOfMemoryException&)
{
XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
errorsOccured = true;
}
catch (const XMLException& e)
{
XERCES_STD_QUALIFIER cerr << "An error occurred during parsing\n Message: "
<< StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
errorsOccured = true;
}
catch (const DOMException& e)
{
const unsigned int maxChars = 2047;
XMLCh errText[maxChars + 1];
XERCES_STD_QUALIFIER cerr << "\nDOM Error during parsing: '" << gXmlFile << "'\n"
<< "DOMException code is: " << e.code << XERCES_STD_QUALIFIER endl;
if (DOMImplementation::loadDOMExceptionMsg(e.code, errText, maxChars))
XERCES_STD_QUALIFIER cerr << "Message is: " << StrX(errText) << XERCES_STD_QUALIFIER endl;
errorsOccured = true;
}
catch (...)
{
XERCES_STD_QUALIFIER cerr << "An error occurred during parsing\n " << XERCES_STD_QUALIFIER endl;
errorsOccured = true;
}
// If the parse was successful, output the document data from the DOM tree
if (!errorsOccured && !errReporter->getSawErrors())
{
DOMPrintFilter *myFilter = 0;
try
{
// get a serializer, an instance of DOMWriter
XMLCh tempStr[100];
XMLString::transcode("LS", tempStr, 99);
DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(tempStr);
DOMWriter *theSerializer = ((DOMImplementationLS*)impl)->createDOMWriter();
// set user specified output encoding
theSerializer->setEncoding(gOutputEncoding);
// plug in user's own filter
if (gUseFilter)
{
// even we say to show attribute, but the DOMWriter
// will not show attribute nodes to the filter as
// the specs explicitly says that DOMWriter shall
// NOT show attributes to DOMWriterFilter.
//
// so DOMNodeFilter::SHOW_ATTRIBUTE has no effect.
// same DOMNodeFilter::SHOW_DOCUMENT_TYPE, no effect.
//
myFilter = new DOMPrintFilter(DOMNodeFilter::SHOW_ELEMENT |
DOMNodeFilter::SHOW_ATTRIBUTE |
DOMNodeFilter::SHOW_DOCUMENT_TYPE);
theSerializer->setFilter(myFilter);
}
// plug in user's own error handler
DOMErrorHandler *myErrorHandler = new DOMPrintErrorHandler();
theSerializer->setErrorHandler(myErrorHandler);
// set feature if the serializer supports the feature/mode
if (theSerializer->canSetFeature(XMLUni::fgDOMWRTSplitCdataSections, gSplitCdataSections))
theSerializer->setFeature(XMLUni::fgDOMWRTSplitCdataSections, gSplitCdataSections);
if (theSerializer->canSetFeature(XMLUni::fgDOMWRTDiscardDefaultContent, gDiscardDefaultContent))
theSerializer->setFeature(XMLUni::fgDOMWRTDiscardDefaultContent, gDiscardDefaultContent);
if (theSerializer->canSetFeature(XMLUni::fgDOMWRTFormatPrettyPrint, gFormatPrettyPrint))
theSerializer->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint, gFormatPrettyPrint);
if (theSerializer->canSetFeature(XMLUni::fgDOMWRTBOM, gWriteBOM))
theSerializer->setFeature(XMLUni::fgDOMWRTBOM, gWriteBOM);
//
// Plug in a format target to receive the resultant
// XML stream from the serializer.
//
// StdOutFormatTarget prints the resultant XML stream
// to stdout once it receives any thing from the serializer.
//
XMLFormatTarget *myFormTarget;
if (goutputfile)
myFormTarget = new LocalFileFormatTarget(goutputfile);
else
myFormTarget = new StdOutFormatTarget();
// get the DOM representation
DOMNode *doc = parser->getDocument();
//
// do the serialization through DOMWriter::writeNode();
//
theSerializer->writeNode(myFormTarget, *doc);
delete theSerializer;
//
// Filter, formatTarget and error handler
// are NOT owned by the serializer.
//
delete myFormTarget;
delete myErrorHandler;
if (gUseFilter)
delete myFilter;
}
catch (const OutOfMemoryException&)
{
XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
retval = 5;
}
catch (XMLException& e)
{
XERCES_STD_QUALIFIER cerr << "An error occurred during creation of output transcoder. Msg is:"
<< XERCES_STD_QUALIFIER endl
<< StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
retval = 4;
}
}
else
retval = 4;
//
// Clean up the error handler. The parser does not adopt handlers
// since they could be many objects or one object installed for multiple
// handlers.
//
delete errReporter;
//
// Delete the parser itself. Must be done prior to calling Terminate, below.
//
delete parser;
// And call the termination method
XMLPlatformUtils::Terminate();
XMLString::release(&gOutputEncoding);
return retval;
}
int parseTEI( const char* xmlFile, bool english, SentenceList& sentenceList )
{
try
{
XMLPlatformUtils::Initialize();
}
catch(const XMLException &toCatch)
{
std::cerr << "Error during Xerces-c Initialization.\n"
<< " Exception message:"
<< StrX(toCatch.getMessage()) << std::endl;
return 1;
}
//
// Create our parser, then attach an error handler to the parser.
// The parser will call back to methods of the ErrorHandler if it
// discovers errors during the course of parsing the XML document.
//
XercesDOMParser *parser = new XercesDOMParser;
parser->setValidationScheme(XercesDOMParser::Val_Never);
parser->setDoNamespaces(false);
parser->setDoSchema(false);
parser->setValidationSchemaFullChecking(false);
parser->setCreateEntityReferenceNodes(false);
DOMTreeErrorReporter *errReporter = new DOMTreeErrorReporter();
parser->setErrorHandler(errReporter);
//
// Parse the XML file, catching any XML exceptions that might propogate
// out of it.
//
bool errorsOccured = false;
try
{
parser->parse(xmlFile);
}
catch (const XMLException& e)
{
std::cerr << "An error occurred during parsing\n Message: "
<< StrX(e.getMessage()) << std::endl;
errorsOccured = true;
}
catch (const DOMException& e)
{
const unsigned int maxChars = 2047;
XMLCh errText[maxChars + 1];
std::cerr << "\nDOM Error during parsing: '" << xmlFile << "'\n"
<< "DOMException code is: " << e.code << std::endl;
if (DOMImplementation::loadDOMExceptionMsg(e.code, errText, maxChars))
std::cerr << "Message is: " << StrX(errText) << std::endl;
errorsOccured = true;
}
catch (...)
{
std::cerr << "An error occurred during parsing\n " << std::endl;
errorsOccured = true;
}
if (errorsOccured || errReporter->getSawErrors())
return -1;
// get the DOM representation
DOMNode *doc = parser->getDocument();
sentenceList.clear();
buildSentenceListFromDOMTree(doc,sentenceList,english);
delete errReporter;
// Delete the parser itself. Must be done prior to calling Terminate, below.
delete parser;
// And call the termination method
XMLPlatformUtils::Terminate();
return 0;
}
