// ---------------------------------------------------------------------------
//
// main
//
// ---------------------------------------------------------------------------
int main(int argC, char* argV[])
{
// Check command line and extract arguments.
if (argC < 2)
{
usage();
return 1;
}
const char* xmlFile = 0;
AbstractDOMParser::ValSchemes valScheme = AbstractDOMParser::Val_Auto;
bool doNamespaces = false;
bool doSchema = false;
bool schemaFullChecking = false;
bool doList = false;
bool errorOccurred = false;
bool recognizeNEL = false;
bool printOutEncounteredEles = false;
char localeStr[65]; // We need 64 + 1 characters if we use strstr(.., .., 64)
memset(localeStr, 0, sizeof localeStr);
int argInd;
for (argInd = 1; argInd < argC; ++argInd)
{
// Break out on first parm not starting with a dash
if (argV[argInd][0] != '-')
break;
// Watch for special case help request
if (!strcmp(argV[argInd], "-?"))
{
usage();
return 2;
}
else if (!strncmp(argV[argInd], "-v=", 3)
|| !strncmp(argV[argInd], "-V=", 3))
{
const char* const parm = &argV[argInd][3];
if (!strcmp(parm, "never"))
valScheme = AbstractDOMParser::Val_Never;
else if (!strcmp(parm, "auto"))
valScheme = AbstractDOMParser::Val_Auto;
else if (!strcmp(parm, "always"))
valScheme = AbstractDOMParser::Val_Always;
else
{
cerr << "Unknown -v= value: " << parm << endl;
return 2;
}
}
else if (!strcmp(argV[argInd], "-n")
|| !strcmp(argV[argInd], "-N"))
{
doNamespaces = true;
}
else if (!strcmp(argV[argInd], "-s")
|| !strcmp(argV[argInd], "-S"))
{
doSchema = true;
}
else if (!strcmp(argV[argInd], "-f")
|| !strcmp(argV[argInd], "-F"))
{
schemaFullChecking = true;
}
else if (!strcmp(argV[argInd], "-l")
|| !strcmp(argV[argInd], "-L"))
{
doList = true;
}
else if (!strcmp(argV[argInd], "-special:nel"))
{
// turning this on will lead to non-standard compliance behaviour
// it will recognize the unicode character 0x85 as new line character
// instead of regular character as specified in XML 1.0
// do not turn this on unless really necessary
recognizeNEL = true;
}
else if (!strcmp(argV[argInd], "-p")
|| !strcmp(argV[argInd], "-P"))
{
printOutEncounteredEles = true;
}
else if (!strncmp(argV[argInd], "-locale=", 8))
{
// Get out the end of line
strncat(localeStr, &(argV[argInd][8]), 64);
}
else
{
cerr << "Unknown option '" << argV[argInd]
<< "', ignoring it\n" << endl;
}
}
//
// There should be only one and only one parameter left, and that
// should be the file name.
//
if (argInd != argC - 1)
{
usage();
return 1;
}
// Initialize the XML4C system
try
{
if (strlen(localeStr))
{
XMLPlatformUtils::Initialize(localeStr);
}
else
{
XMLPlatformUtils::Initialize();
}
if (recognizeNEL)
{
XMLPlatformUtils::recognizeNEL(recognizeNEL);
}
}
catch (const XMLException& toCatch)
{
cerr << "Error during initialization! :\n"
<< StrX(toCatch.getMessage()) << endl;
return 1;
}
// Instantiate the DOM parser.
static const XMLCh gLS[] = { chLatin_L, chLatin_S, chNull };
DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(gLS);
DOMBuilder *parser = ((DOMImplementationLS*)impl)->createDOMBuilder(DOMImplementationLS::MODE_SYNCHRONOUS, 0);
parser->setFeature(XMLUni::fgDOMNamespaces, doNamespaces);
parser->setFeature(XMLUni::fgXercesSchema, doSchema);
parser->setFeature(XMLUni::fgXercesSchemaFullChecking, schemaFullChecking);
if (valScheme == AbstractDOMParser::Val_Auto)
{
parser->setFeature(XMLUni::fgDOMValidateIfSchema, true);
}
else if (valScheme == AbstractDOMParser::Val_Never)
{
parser->setFeature(XMLUni::fgDOMValidation, false);
}
else if (valScheme == AbstractDOMParser::Val_Always)
{
parser->setFeature(XMLUni::fgDOMValidation, true);
}
// enable datatype normalization - default is off
parser->setFeature(XMLUni::fgDOMDatatypeNormalization, true);
// And create our error handler and install it
DOMCountErrorHandler errorHandler;
parser->setErrorHandler(&errorHandler);
//
// Get the starting time and kick off the parse of the indicated
// file. Catch any exceptions that might propogate out of it.
//
//unsigned long duration;
bool more = true;
ifstream fin;
// the input is a list file
if (doList)
fin.open(argV[argInd]);
if (fin.fail()) {
cerr <<"Cannot open the list file: " << argV[argInd] << endl;
return 2;
}
while (more)
{
char fURI[1000];
//initialize the array to zeros
memset(fURI,0,sizeof(fURI));
if (doList) {
if (! fin.eof() ) {
fin.getline (fURI, sizeof(fURI));
if (!*fURI)
continue;
else {
xmlFile = fURI;
cerr << "==Parsing== " << xmlFile << endl;
}
}
else
break;
}
else {
xmlFile = argV[argInd];
more = false;
}
//reset error count first
errorHandler.resetErrors();
XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument *doc = 0;
try
{
// reset document pool
parser->resetDocumentPool();
//const unsigned long startMillis = XMLPlatformUtils::getCurrentMillis();
doc = parser->parseURI(xmlFile);
//const unsigned long endMillis = XMLPlatformUtils::getCurrentMillis();
//duration = endMillis - startMillis;
}
catch (const XMLException& toCatch)
{
cerr << "\nError during parsing: '" << xmlFile << "'\n"
<< "Exception message is: \n"
<< StrX(toCatch.getMessage()) << "\n" << endl;
errorOccurred = true;
continue;
}
catch (const DOMException& toCatch)
{
const unsigned int maxChars = 2047;
XMLCh errText[maxChars + 1];
cerr << "\nDOM Error during parsing: '" << xmlFile << "'\n"
<< "DOMException code is: " << toCatch.code << endl;
if (DOMImplementation::loadDOMExceptionMsg(toCatch.code, errText, maxChars))
cerr << "Message is: " << StrX(errText) << endl;
errorOccurred = true;
continue;
}
catch (...)
{
cerr << "\nUnexpected exception during parsing: '" << xmlFile << "'\n";
errorOccurred = true;
continue;
}
//
// Extract the DOM tree, get the list of all the elements and report the
// length as the count of elements.
//
if (errorHandler.getSawErrors())
{
cout << "\nErrors occurred, no output available\n" << endl;
errorOccurred = true;
}
else
{
unsigned int elementCount = 0;
if (doc) {
elementCount = countChildElements((DOMNode*)doc->getDocumentElement(), printOutEncounteredEles);
// test getElementsByTagName and getLength
XMLCh xa[] = {chAsterisk, chNull};
if (elementCount != doc->getElementsByTagName(xa)->getLength()) {
cout << "\nErrors occurred, element count is wrong\n" << endl;
errorOccurred = true;
}
}
// Print out the stats that we collected and time taken.
cout << xmlFile << ": " << elementCount << " elems." << endl;
}
}
//
// Delete the parser itself. Must be done prior to calling Terminate, below.
//
parser->release();
// And call the termination method
XMLPlatformUtils::Terminate();
if (doList)
fin.close();
if (errorOccurred)
return 4;
else
return 0;
}
DOMDocument *CouchRunHttpServer::parsePrologue( std::string S_PrologueXMLFilename ){
bool recognizeNEL = false;
char localeStr[64];
memset(localeStr, 0, sizeof localeStr);
// Initialize the XML4C system
try {
if (strlen(localeStr)) {
XMLPlatformUtils::Initialize(localeStr);
}
else{
XMLPlatformUtils::Initialize();
}
if (recognizeNEL){
XMLPlatformUtils::recognizeNEL(recognizeNEL);
}
}
catch (const XMLException& toCatch){
XERCES_STD_QUALIFIER cerr << "Error during initialization! :\n"
<< StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
return NULL;
}
// Instantiate the DOM parser.
static const XMLCh gLS[] = { chLatin_L, chLatin_S, chNull };
DOMImplementation *impl =
DOMImplementationRegistry::getDOMImplementation(gLS);
DOMLSParser *parser =
((DOMImplementationLS*)impl)->createLSParser(DOMImplementationLS::MODE_SYNCHRONOUS, 0);
DOMConfiguration *config = parser->getDomConfig();
// enable datatype normalization - default is off
config->setParameter(XMLUni::fgDOMDatatypeNormalization, true);
// And create our error handler and install it
DOMCountErrorHandler errorHandler;
config->setParameter(XMLUni::fgDOMErrorHandler, &errorHandler);
//
// Get the starting time and kick off the parse of the indicated
// file. Catch any exceptions that might propogate out of it.
//
unsigned long duration;
const char *xmlFile = 0;
bool more = true;
XERCES_STD_QUALIFIER ifstream fin;
// Later possibly a list of prologue files rather than a single one
while (more){
xmlFile = S_PrologueXMLFilename.c_str();
more = false;
}
// Parse XML prologue file
// Reset error count first
errorHandler.resetErrors();
bool errorOccurred = false;
try{
// reset document pool
parser->resetDocumentPool();
const unsigned long startMillis = XMLPlatformUtils::getCurrentMillis();
XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument *doc = parser->parseURI(xmlFile);
const unsigned long endMillis = XMLPlatformUtils::getCurrentMillis();
duration = endMillis - startMillis;
// Print out the stats that we collected and time taken.
XERCES_STD_QUALIFIER cout << "Parsed "
<< xmlFile << ": " << duration << " ms."
<< XERCES_STD_QUALIFIER endl;
return doc;
}
catch (const XMLException& toCatch){
XERCES_STD_QUALIFIER cerr << "\nError during parsing: '" << xmlFile << "'\n"
<< "Exception message is: \n"
<< StrX(toCatch.getMessage()) << "\n"
<< XERCES_STD_QUALIFIER endl;
errorOccurred = true;
// continue;
}
catch (const DOMException& toCatch){
const unsigned int maxChars = 2047;
XMLCh errText[maxChars + 1];
XERCES_STD_QUALIFIER cerr << "\nDOM Error during parsing: '"
<< xmlFile << "'\n"
<< "DOMException code is: "
<< toCatch.code
<< XERCES_STD_QUALIFIER endl;
if (DOMImplementation::loadDOMExceptionMsg(toCatch.code, errText, maxChars))
XERCES_STD_QUALIFIER cerr << "Message is: "
<< StrX(errText)
<< XERCES_STD_QUALIFIER endl;
errorOccurred = true;
// continue;
}
catch (...){
XERCES_STD_QUALIFIER cerr << "\nUnexpected exception during parsing: '" << xmlFile << "'\n";
errorOccurred = true;
// continue;
}
return NULL;
}