--- /dev/null
+/*
+ * Copyright 1999-2002,2004 The Apache Software Foundation.
+ *
+ * Licensed 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.
+ */
+
+/*
+ * $Id$
+ */
+
+// ---------------------------------------------------------------------------
+// Includes
+// ---------------------------------------------------------------------------
+#include <xercesc/util/PlatformUtils.hpp>
+#include <xercesc/parsers/AbstractDOMParser.hpp>
+#include <xercesc/dom/DOMImplementation.hpp>
+#include <xercesc/dom/DOMImplementationLS.hpp>
+#include <xercesc/dom/DOMImplementationRegistry.hpp>
+#include <xercesc/dom/DOMBuilder.hpp>
+#include <xercesc/dom/DOMException.hpp>
+#include <xercesc/dom/DOMDocument.hpp>
+#include <xercesc/dom/DOMNodeList.hpp>
+#include <xercesc/dom/DOMError.hpp>
+#include <xercesc/dom/DOMLocator.hpp>
+#include <xercesc/dom/DOMNamedNodeMap.hpp>
+#include <xercesc/dom/DOMAttr.hpp>
+#include "DOMCount.hpp"
+#include <string.h>
+#include <stdlib.h>
+
+#if defined(XERCES_NEW_IOSTREAMS)
+#include <fstream>
+#else
+#include <fstream.h>
+#endif
+
+
+// ---------------------------------------------------------------------------
+// This is a simple program which invokes the DOMParser to build a DOM
+// tree for the specified input file. It then walks the tree and counts
+// the number of elements. The element count is then printed.
+// ---------------------------------------------------------------------------
+static void usage()
+{
+ XERCES_STD_QUALIFIER cout << "\nUsage:\n"
+ " DOMCount [options] <XML file | List file>\n\n"
+ "This program invokes the DOMBuilder, builds the DOM tree,\n"
+ "and then prints the number of elements found in each XML file.\n\n"
+ "Options:\n"
+ " -l Indicate the input file is a List File that has a list of xml files.\n"
+ " Default to off (Input file is an XML file).\n"
+ " -v=xxx Validation scheme [always | never | auto*].\n"
+ " -n Enable namespace processing. Defaults to off.\n"
+ " -s Enable schema processing. Defaults to off.\n"
+ " -f Enable full schema constraint checking. Defaults to off.\n"
+ " -locale=ll_CC specify the locale, default: en_US.\n"
+ " -p Print out names of elements and attributes encountered.\n"
+ " -? Show this help.\n\n"
+ " * = Default if not provided explicitly.\n"
+ << XERCES_STD_QUALIFIER endl;
+}
+
+
+
+// ---------------------------------------------------------------------------
+//
+// Recursively Count up the total number of child Elements under the specified Node.
+// Process attributes of the node, if any.
+//
+// ---------------------------------------------------------------------------
+static int countChildElements(DOMNode *n, bool printOutEncounteredEles)
+{
+ DOMNode *child;
+ int count = 0;
+ if (n) {
+ if (n->getNodeType() == DOMNode::ELEMENT_NODE)
+ {
+ if(printOutEncounteredEles) {
+ char *name = XMLString::transcode(n->getNodeName());
+ XERCES_STD_QUALIFIER cout <<"----------------------------------------------------------"<<XERCES_STD_QUALIFIER endl;
+ XERCES_STD_QUALIFIER cout <<"Encountered Element : "<< name << XERCES_STD_QUALIFIER endl;
+
+ XMLString::release(&name);
+
+ if(n->hasAttributes()) {
+ // get all the attributes of the node
+ DOMNamedNodeMap *pAttributes = n->getAttributes();
+ int nSize = pAttributes->getLength();
+ XERCES_STD_QUALIFIER cout <<"\tAttributes" << XERCES_STD_QUALIFIER endl;
+ XERCES_STD_QUALIFIER cout <<"\t----------" << XERCES_STD_QUALIFIER endl;
+ for(int i=0;i<nSize;++i) {
+ DOMAttr *pAttributeNode = (DOMAttr*) pAttributes->item(i);
+ // get attribute name
+ char *name = XMLString::transcode(pAttributeNode->getName());
+
+ XERCES_STD_QUALIFIER cout << "\t" << name << "=";
+ XMLString::release(&name);
+
+ // get attribute type
+ name = XMLString::transcode(pAttributeNode->getValue());
+ XERCES_STD_QUALIFIER cout << name << XERCES_STD_QUALIFIER endl;
+ XMLString::release(&name);
+ }
+ }
+ }
+ ++count;
+ }
+ for (child = n->getFirstChild(); child != 0; child=child->getNextSibling())
+ count += countChildElements(child, printOutEncounteredEles);
+ }
+ return count;
+}
+
+// ---------------------------------------------------------------------------
+//
+// 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[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
+ {
+ XERCES_STD_QUALIFIER cerr << "Unknown -v= value: " << parm << XERCES_STD_QUALIFIER 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
+ strcpy(localeStr, &(argV[argInd][8]));
+ }
+ else
+ {
+ XERCES_STD_QUALIFIER cerr << "Unknown option '" << argV[argInd]
+ << "', ignoring it\n" << XERCES_STD_QUALIFIER 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)
+ {
+ XERCES_STD_QUALIFIER cerr << "Error during initialization! :\n"
+ << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER 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;
+ XERCES_STD_QUALIFIER ifstream fin;
+
+ // the input is a list file
+ if (doList)
+ fin.open(argV[argInd]);
+
+ if (fin.fail()) {
+ XERCES_STD_QUALIFIER cerr <<"Cannot open the list file: " << argV[argInd] << XERCES_STD_QUALIFIER 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;
+ XERCES_STD_QUALIFIER cerr << "==Parsing== " << xmlFile << XERCES_STD_QUALIFIER 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)
+ {
+ 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;
+ }
+
+ //
+ // Extract the DOM tree, get the list of all the elements and report the
+ // length as the count of elements.
+ //
+ if (errorHandler.getSawErrors())
+ {
+ XERCES_STD_QUALIFIER cout << "\nErrors occurred, no output available\n" << XERCES_STD_QUALIFIER 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()) {
+ XERCES_STD_QUALIFIER cout << "\nErrors occurred, element count is wrong\n" << XERCES_STD_QUALIFIER endl;
+ errorOccurred = true;
+ }
+ }
+ // Print out the stats that we collected and time taken.
+ XERCES_STD_QUALIFIER cout << duration << XERCES_STD_QUALIFIER 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;
+}
+
+
+
+
+
+DOMCountErrorHandler::DOMCountErrorHandler() :
+
+ fSawErrors(false)
+{
+}
+
+DOMCountErrorHandler::~DOMCountErrorHandler()
+{
+}
+
+
+// ---------------------------------------------------------------------------
+// DOMCountHandlers: Overrides of the DOM ErrorHandler interface
+// ---------------------------------------------------------------------------
+bool DOMCountErrorHandler::handleError(const DOMError& domError)
+{
+ fSawErrors = true;
+ if (domError.getSeverity() == DOMError::DOM_SEVERITY_WARNING)
+ XERCES_STD_QUALIFIER cerr << "\nWarning at file ";
+ else if (domError.getSeverity() == DOMError::DOM_SEVERITY_ERROR)
+ XERCES_STD_QUALIFIER cerr << "\nError at file ";
+ else
+ XERCES_STD_QUALIFIER cerr << "\nFatal Error at file ";
+
+ XERCES_STD_QUALIFIER cerr << StrX(domError.getLocation()->getURI())
+ << ", line " << domError.getLocation()->getLineNumber()
+ << ", char " << domError.getLocation()->getColumnNumber()
+ << "\n Message: " << StrX(domError.getMessage()) << XERCES_STD_QUALIFIER endl;
+
+ return true;
+}
+
+void DOMCountErrorHandler::resetErrors()
+{
+ fSawErrors = false;
+}
projects / helm.git / blobdiff