示例#1
0
// ---------------------------------------------------------------------------
//  Program entry point
// ---------------------------------------------------------------------------
int main(int argC, char* argV[])
{
    // Initialize the XML4C2 system
    try
    {
         XMLPlatformUtils::Initialize();
    }
    catch (const XMLException& toCatch)
    {
         XERCES_STD_QUALIFIER cerr << "Error during initialization! Message:\n"
              << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
         return 1;
    }

    SAXParser::ValSchemes    valScheme = SAXParser::Val_Auto;
    bool doNamespaces       = false;
    bool doSchema           = false;
    bool schemaFullChecking = false;

    int argInd;
    for (argInd = 1; argInd < argC; argInd++)
    {
        // Break out on first parm not starting with a dash
        if (argV[argInd][0] != '-')
        {
            usage();
            XMLPlatformUtils::Terminate();
            return 1;
        }

        // Watch for special case help request
        if (!strcmp(argV[argInd], "-?"))
        {
            usage();
            XMLPlatformUtils::Terminate();
            return 1;
        }
         else if (!strncmp(argV[argInd], "-v=", 3)
              ||  !strncmp(argV[argInd], "-V=", 3))
        {
            const char* const parm = &argV[argInd][3];

            if (!strcmp(parm, "never"))
                valScheme = SAXParser::Val_Never;
            else if (!strcmp(parm, "auto"))
                valScheme = SAXParser::Val_Auto;
            else if (!strcmp(parm, "always"))
                valScheme = SAXParser::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
        {
            XERCES_STD_QUALIFIER cerr << "Unknown option '" << argV[argInd]
                 << "', ignoring it\n" << XERCES_STD_QUALIFIER endl;
        }
    }

    //
    //  Create a SAX parser object. Then, according to what we were told on
    //  the command line, set it to validate or not.
    //
    SAXParser* parser = new SAXParser;
    parser->setValidationScheme(valScheme);
    parser->setDoNamespaces(doNamespaces);
    parser->setDoSchema(doSchema);
    parser->setValidationSchemaFullChecking(schemaFullChecking);

    //
    //  Create our SAX handler object and install it on the parser, as the
    //  document and error handlers.
    //
    MemParseHandlers handler;
    parser->setDocumentHandler(&handler);
    parser->setErrorHandler(&handler);

    //
    //  Create MemBufferInputSource from the buffer containing the XML
    //  statements.
    //
    //  NOTE: We are using strlen() here, since we know that the chars in
    //  our hard coded buffer are single byte chars!!! The parameter wants
    //  the number of BYTES, not chars, so when you create a memory buffer
    //  give it the byte size (which just happens to be the same here.)
    //
    MemBufInputSource* memBufIS = new MemBufInputSource
    (
        (const XMLByte*)gXMLInMemBuf
        , strlen(gXMLInMemBuf)
        , gMemBufId
        , false
    );

    //
    //  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;
    int errorCount = 0;
    int errorCode = 0;
    try
    {
        const unsigned long startMillis = XMLPlatformUtils::getCurrentMillis();
        parser->parse(*memBufIS);
        const unsigned long endMillis = XMLPlatformUtils::getCurrentMillis();
        duration = endMillis - startMillis;
        errorCount = parser->getErrorCount();
    }
    catch (const OutOfMemoryException&)
    {
        XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
        errorCode = 5;
    }
    catch (const XMLException& e)
    {
        XERCES_STD_QUALIFIER cerr << "\nError during parsing memory stream:\n"
             << "Exception message is:  \n"
             << StrX(e.getMessage()) << "\n" << XERCES_STD_QUALIFIER endl;
        errorCode = 4;
    }
    if(errorCode) {
        XMLPlatformUtils::Terminate();
        return errorCode;
    }

    // Print out the stats that we collected and time taken.
    if (!errorCount) {
        XERCES_STD_QUALIFIER cout << "\nFinished parsing the memory buffer containing the following "
             << "XML statements:\n\n"
             << gXMLInMemBuf
             << "\n\n\n"
             << "Parsing took " << duration << " ms ("
             << handler.getElementCount() << " elements, "
             << handler.getAttrCount() << " attributes, "
             << handler.getSpaceCount() << " spaces, "
             << handler.getCharacterCount() << " characters).\n" << XERCES_STD_QUALIFIER endl;
    }

    //
    //  Delete the parser itself.  Must be done prior to calling Terminate, below.
    //
    delete parser;

    delete memBufIS;

    // And call the termination method
    XMLPlatformUtils::Terminate();

    if (errorCount > 0)
        return 4;
    else
        return 0;
}
示例#2
0
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
#else
int main (int argc, char* argv[]) {
  //int nlhs;
  //mxArray *plhs[3];
  //int nrhs;
  //const mxArray *prhs[];
#endif

#ifdef MAT
  if (nrhs < 1) {
#else
  if (argc < 1) {
#endif
    cout << "XML corpus file required";
    exit(1);
  }

  // get the corpus file name
#ifdef MAT
  int strlen = mxGetN(prhs[0])+1;
  char* corpus_file = (char*)mxCalloc(strlen, sizeof(char)); //mxCalloc is similar to malloc in C
  mxGetString(prhs[0], corpus_file, strlen);
#else
  char* corpus_file = argv[1];
#endif

#ifdef DEBUG
  cout << "Parsing document: " <<  corpus_file << "\n";
#endif

  try {
    XMLPlatformUtils::Initialize();
  }
  catch (const XMLException& toCatch) {
    char* message = XMLString::transcode(toCatch.getMessage());
    cout << "Error during initialization! :\n"
	 << message << "\n";
    XMLString::release(&message);
    exit(1);//return 1;
  }
  
  SAXParser* parser = new SAXParser();
  parser->setValidationScheme(SAXParser::Val_Always);
  parser->setDoNamespaces(true);    // optional
  
  MovieSAXHandler* content = new MovieSAXHandler();
  ErrorHandler* errHandler = (ErrorHandler*) content;
  parser->setDocumentHandler(content);
  parser->setErrorHandler(errHandler);
  
  try {
    parser->parse(corpus_file);
  }
  catch (const XMLException& toCatch) {
    char* message = XMLString::transcode(toCatch.getMessage());
    cout << "Exception message is: \n"
	 << message << "\n";
    XMLString::release(&message);
    exit(1);//return -1;
  }
  catch (const SAXParseException& toCatch) {
    char* message = XMLString::transcode(toCatch.getMessage());
    cout << "Exception message is: \n"
                 << message << "\n";
    XMLString::release(&message);
    exit(1);//return -1;
  }
  catch (...) {
    cout << "Unexpected Exception \n" ;
    exit(1);//return -1;
  }

#ifdef DEBUG
  
  cout << "Printing the inverted index: \n";
  
  cout << InvertedIndex::instance() << "\n";

    
#endif

#ifdef MAT

  // call this function to output all the matrices to the MATLAB environment.
  MATProcedure(nlhs, plhs, nrhs, prhs);

#else
  
  // call this function to output features to files
  OUTProcedure();

#endif

#ifdef DEBUG
  cout << "Done \n";
#endif

  delete InvertedIndex::instance();
  delete parser;
  delete content;

}
// ---------------------------------------------------------------------------
//  Program entry point
// ---------------------------------------------------------------------------
int main(int argC, char* argV[])
{
    // Initialize the XML4C system
    try
    {
         XMLPlatformUtils::Initialize();
    }

    catch (const XMLException& toCatch)
    {
         XERCES_STD_QUALIFIER cerr   << "Error during initialization! Message:\n"
                << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
         return 1;
    }

    // Check command line and extract arguments.
    if (argC < 2)
    {
        usage();
        XMLPlatformUtils::Terminate();
        return 1;
    }

    // We only have one required parameter, which is the file to process
    if ((argC != 2) || (*(argV[1]) == '-'))
    {
        usage();
        XMLPlatformUtils::Terminate();
        return 1;
    }

    const char*              xmlFile   = argV[1];
    SAXParser::ValSchemes    valScheme = SAXParser::Val_Auto;

    //
    //  Create a DTD validator to be used for our validation work. Then create
    //  a SAX parser object and pass it our validator. Then, according to what
    //  we were told on the command line, set it to validate or not. He owns
    //  the validator, so we have to allocate it.
    //
    int errorCount = 0;
    DTDValidator* valToUse = new DTDValidator;
    SAXParser* parser = new SAXParser(valToUse);
    parser->setValidationScheme(valScheme);

    //
    //  Get the starting time and kick off the parse of the indicated
    //  file. Catch any exceptions that might propogate out of it.
    //
    int errorCode = 0;
    try
    {
        parser->parse(xmlFile);
        errorCount = parser->getErrorCount();
    }
    catch (const OutOfMemoryException&)
    {
        XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
        errorCode = 5;
    }
    catch (const XMLException& e)
    {
        XERCES_STD_QUALIFIER cerr << "\nError during parsing: '" << xmlFile << "'\n"
             << "Exception message is:  \n"
             << StrX(e.getMessage()) << "\n" << XERCES_STD_QUALIFIER endl;
        errorCode = 4;
    }
    if(errorCode) {
        XMLPlatformUtils::Terminate();
        return errorCode;
    }

    if (!errorCount) {
        //
        //  Now we will get an enumerator for the element pool from the validator
        //  and enumerate the elements, printing them as we go. For each element
        //  we get an enumerator for its attributes and print them also.
        //
        DTDGrammar* grammar = (DTDGrammar*) valToUse->getGrammar();
        NameIdPoolEnumerator<DTDElementDecl> elemEnum = grammar->getElemEnumerator();
        if (elemEnum.hasMoreElements())
        {
            XERCES_STD_QUALIFIER cout << "\nELEMENTS:\n----------------------------\n";
            while(elemEnum.hasMoreElements())
            {
                const DTDElementDecl& curElem = elemEnum.nextElement();
                XERCES_STD_QUALIFIER cout << "  Name: " << StrX(curElem.getFullName()) << "\n";

                XERCES_STD_QUALIFIER cout << "  Content Model: "
                     << StrX(curElem.getFormattedContentModel())
                     << "\n";

                // Get an enumerator for this guy's attributes if any
                if (curElem.hasAttDefs())
                {
                    XERCES_STD_QUALIFIER cout << "  Attributes:\n";
                    XMLAttDefList& attList = curElem.getAttDefList();
                    for (unsigned int i=0; i<attList.getAttDefCount(); i++)
                    {
                        const XMLAttDef& curAttDef = attList.getAttDef(i);
                        XERCES_STD_QUALIFIER cout << "    Name:" << StrX(curAttDef.getFullName())
                             << ", Type: ";

                        // Get the type and display it
                        const XMLAttDef::AttTypes type = curAttDef.getType();
                        switch(type)
                        {
                            case XMLAttDef::CData :
                                XERCES_STD_QUALIFIER cout << "CDATA";
                                break;

                            case XMLAttDef::ID :
                                XERCES_STD_QUALIFIER cout << "ID";
                                break;

                            case XMLAttDef::IDRef :
                            case XMLAttDef::IDRefs :
                                XERCES_STD_QUALIFIER cout << "IDREF(S)";
                                break;

                            case XMLAttDef::Entity :
                            case XMLAttDef::Entities :
                                XERCES_STD_QUALIFIER cout << "ENTITY(IES)";
                                break;

                            case XMLAttDef::NmToken :
                            case XMLAttDef::NmTokens :
                                XERCES_STD_QUALIFIER cout << "NMTOKEN(S)";
                                break;

                            case XMLAttDef::Notation :
                                XERCES_STD_QUALIFIER cout << "NOTATION";
                                break;

                            case XMLAttDef::Enumeration :
                                XERCES_STD_QUALIFIER cout << "ENUMERATION";
                                break;
                            default:
                                break;
                        }

                        XERCES_STD_QUALIFIER cout << "\n";
                    }
                }
                XERCES_STD_QUALIFIER cout << XERCES_STD_QUALIFIER endl;
            }
        }
         else
        {
            XERCES_STD_QUALIFIER cout << "The validator has no elements to display\n" << XERCES_STD_QUALIFIER endl;
        }
    }
    else
        XERCES_STD_QUALIFIER cout << "\nErrors occurred, no output available\n" << XERCES_STD_QUALIFIER endl;

    //
    //  Delete the parser itself.  Must be done prior to calling Terminate, below.
    //
    delete parser;

    // And call the termination method
    XMLPlatformUtils::Terminate();

    if (errorCount > 0)
        return 4;
    else
        return 0;
}
//------------------------------------------------------------------------
//
//  parse   - This is the method that is invoked by the rest of
//            the test program to actually parse an XML file.
//
//------------------------------------------------------------------------
int ThreadParser::parse(int fileNum)
{
    MemBufInputSource *mbis = 0;
    InFileInfo        *fInfo = &gRunInfo.files[fileNum];
    bool              errors = false;

    fCheckSum = 0;

    if (gRunInfo.inMemory) {
        mbis = new  MemBufInputSource((const XMLByte *) fInfo->fileContent,
                                       fInfo->fileSize,
                                       fInfo->uFileName,
                                       false);
    }

    try
    {
        if (gRunInfo.dom) {
            // Do a DOM parse
            fXercesDOMParser->resetDocumentPool();
            if (gRunInfo.inMemory)
                fXercesDOMParser->parse(*mbis);
            else
                fXercesDOMParser->parse(fInfo->fileName);
            fDoc = fXercesDOMParser->getDocument();
            domCheckSum(fDoc);
        }
        else if (gRunInfo.sax) {
            // Do a SAX1 parse
            if (gRunInfo.inMemory)
                fSAXParser->parse(*mbis);
            else
                fSAXParser->parse(fInfo->fileName);
        }
        else {
            // Do a SAX2 parse
            if (gRunInfo.inMemory)
                fSAX2Parser->parse(*mbis);
            else
                fSAX2Parser->parse(fInfo->fileName);
        }
    }
    catch (const OutOfMemoryException&)
    {
	    fprintf(stderr, " during parsing: %s\n OutOfMemoryException.\n", fInfo->fileName);
	    errors = true;
    }
    catch (const XMLException& e)
    {
        char *exceptionMessage = XMLString::transcode(e.getMessage());
        fprintf(stderr, " during parsing: %s\n Exception message is: %s\n",
            fInfo->fileName, exceptionMessage);
        XMLString::release(&exceptionMessage);
        errors = true;
    }
    catch (const DOMException& toCatch)
    {
        fprintf(stderr, " during parsing: %s\n DOMException code is: %i\n",
            fInfo->fileName, toCatch.code);
        errors = true;
    }
    catch (const SAXParseException& e)
    {
        char *exceptionMessage = XMLString::transcode(e.getMessage());
        fprintf(stderr, " during parsing: %s\n Exception message is: %s\n",
            fInfo->fileName, exceptionMessage);
        XMLString::release(&exceptionMessage);
        errors = true;
    }
    catch (...)
    {
        fprintf(stderr, "Unexpected exception during parsing\n");
        errors = true;
    }

    delete mbis;
    if (errors) {
        fflush(stderr);
        return 0;  // if errors occurred, return zero as if checksum = 0;
    }
    return fCheckSum;
}
示例#5
0
// FIX20110421(ExpSS)
WorldXMLReader::WorldXMLReader(FilenameDB &fdb, X3DDB &x3ddb, SimpleShapeDB &ssdb)
	: m_fdb(fdb), m_x3ddb(x3ddb), m_ssdb(ssdb), m_world(NULL), m_currobj(NULL), m_failed(0), m_current(NULL)
#else
	  WorldXMLReader::WorldXMLReader(FilenameDB &fdb, X3DDB &x3ddb)
	  : m_fdb(fdb), m_x3ddb(x3ddb), m_world(NULL), m_currobj(NULL), m_failed(0), m_current(NULL)
#endif
{
}

#define FREE(P) if (P) { delete P; P = NULL; }
 
WorldXMLReader::~WorldXMLReader()
{
	FREE(m_world);
}


bool WorldXMLReader::read(const char *fname)
{
	int c;
	// Initialization of counter
	Parts::initCounter();
	SSimObj::initCounter();

	// Initialization of XML library
	XMLPlatformUtils::Initialize();

	// Clear the entity names which are already read
	m_objNames.clear();

	SAXParser *parser = new SAXParser();
	parser->setDocumentHandler(this);

	bool ret = false;
	try {
		char buf[4096];
		const char *fpath = m_fdb.getPath(fname, buf);
		if (fpath != NULL) {
			setFilename(fpath);

			parser->parse(fpath);
		} else {
			NOFILE_ERR(fname);
		}

		if (m_failed > 0) {
			goto err;
		}
	} catch(const XMLException &e) {
		char *msg = XMLString::transcode(e.getMessage());
		LOG_ERR(("parse error :%s", fname));
		LOG_ERR(("%s", msg));
		XMLString::release(&msg);
		goto err;
	}

#if 1
	// Execute after the load of attribution of SimObj
	// Loading of X3D file is executed here
	c = 0;
	for (TaskC::iterator i=m_tasks.begin(); i!=m_tasks.end(); i++)
		{
			std::vector<ReadTask *> taskCol = i->second;
			std::vector<ReadTask *>::iterator j;
			for (j=taskCol.begin(); j!=taskCol.end(); j++)
				{
					ReadTask *t = *j;
					if (t)
						{
							//				printf("[%d] calling X3DReadTask ... \n", c++);
							t->execute();
							// Process of the execution
							// --> EntityXMLReader.cpp: X3DReadTask::execute()
							// ----> X3DFileReader::read()
							// ------> X3DSimObjCreator::createSSimObjFromX3D()
							// The last line actually loads X3D file
						}

					delete t;
				}
		}
	m_tasks.clear();	
#else
	// orig
	for (TaskC::iterator i=m_tasks.begin(); i!=m_tasks.end(); i++) {
		ReadTask *t = *i;
		t->execute();
		delete t;
	}
#endif
	m_tasks.clear();

	//	printf("\n***** world dump (2) [%s:%d] *****\n", __FILE__, __LINE__);
	//	m_world->dump();

	if (m_world) {
		m_world->setup();
	} else {
		LOG_ERR(("%s : no world", fname));
		goto err;
	}

	ret = true;
 err:
	delete parser;
	//CJNIUtil::destroy();

	return ret;
}
示例#6
0
int mitsuba_app(int argc, char **argv) {
	int optchar;
	char *end_ptr = NULL;

	try {
		/* Default settings */
		int nprocs_avail = getCoreCount(), nprocs = nprocs_avail;
		int numParallelScenes = 1;
		std::string nodeName = getHostName(),
					networkHosts = "", destFile="";
		bool quietMode = false, progressBars = true, skipExisting = false;
		ELogLevel logLevel = EInfo;
		ref<FileResolver> fileResolver = Thread::getThread()->getFileResolver();
		bool treatWarningsAsErrors = false;
		std::map<std::string, std::string, SimpleStringOrdering> parameters;
		int blockSize = 32;
		int flushTimer = -1;

		if (argc < 2) {
			help();
			return 0;
		}

		optind = 1;
		/* Parse command-line arguments */
		while ((optchar = getopt(argc, argv, "a:c:D:s:j:n:o:r:b:p:qhzvtwx")) != -1) {
			switch (optchar) {
				case 'a': {
						std::vector<std::string> paths = tokenize(optarg, ";");
						for (int i=(int) paths.size()-1; i>=0; --i)
							fileResolver->prependPath(paths[i]);
					}
					break;
				case 'c':
					networkHosts = networkHosts + std::string(";") + std::string(optarg);
					break;
				case 'w':
					treatWarningsAsErrors = true;
					break;
				case 'D': {
						std::vector<std::string> param = tokenize(optarg, "=");
						if (param.size() != 2)
							SLog(EError, "Invalid parameter specification \"%s\"", optarg);
						parameters[param[0]] = param[1];
					}
					break;
				case 's': {
						std::ifstream is(optarg);
						if (is.fail())
							SLog(EError, "Could not open host file!");
						std::string host;
						while (is >> host) {
							if (host.length() < 1 || host.c_str()[0] == '#')
								continue;
							networkHosts = networkHosts + std::string(";") + host;
						}
					}
					break;
				case 'n':
					nodeName = optarg;
					break;
				case 'o':
					destFile = optarg;
					break;
				case 'v':
					if (logLevel != EDebug)
						logLevel = EDebug;
					else
						logLevel = ETrace;
					break;
				case 'x':
					skipExisting = true;
					break;
				case 'p':
					nprocs = strtol(optarg, &end_ptr, 10);
					if (*end_ptr != '\0')
						SLog(EError, "Could not parse the processor count!");
					break;
				case 'j':
					numParallelScenes = strtol(optarg, &end_ptr, 10);
					if (*end_ptr != '\0')
						SLog(EError, "Could not parse the parallel scene count!");
					break;
				case 'r':
					flushTimer = strtol(optarg, &end_ptr, 10);
					if (*end_ptr != '\0')
						SLog(EError, "Could not parse the '-r' parameter argument!");
					break;
				case 'b':
					blockSize = strtol(optarg, &end_ptr, 10);
					if (*end_ptr != '\0')
						SLog(EError, "Could not parse the block size!");
					if (blockSize < 2 || blockSize > 128)
						SLog(EError, "Invalid block size (should be in the range 2-128)");
					break;
				case 'z':
					progressBars = false;
					break;
				case 'q':
					quietMode = true;
					break;
				case 'h':
				default:
					help();
					return 0;
			}
		}

		ProgressReporter::setEnabled(progressBars);

		/* Initialize OpenMP */
		Thread::initializeOpenMP(nprocs);

		/* Configure the logging subsystem */
		ref<Logger> log = Thread::getThread()->getLogger();
		log->setLogLevel(logLevel);
		log->setErrorLevel(treatWarningsAsErrors ? EWarn : EError);

		/* Disable the default appenders */
		for (size_t i=0; i<log->getAppenderCount(); ++i) {
			Appender *appender = log->getAppender(i);
			if (appender->getClass()->derivesFrom(MTS_CLASS(StreamAppender)))
				log->removeAppender(appender);
		}

		log->addAppender(new StreamAppender(formatString("mitsuba.%s.log", nodeName.c_str())));
		if (!quietMode)
			log->addAppender(new StreamAppender(&std::cout));

		SLog(EInfo, "Mitsuba version %s, Copyright (c) " MTS_YEAR " Wenzel Jakob",
				Version(MTS_VERSION).toStringComplete().c_str());

		/* Configure the scheduling subsystem */
		Scheduler *scheduler = Scheduler::getInstance();
		bool useCoreAffinity = nprocs == nprocs_avail;
		for (int i=0; i<nprocs; ++i)
			scheduler->registerWorker(new LocalWorker(useCoreAffinity ? i : -1,
				formatString("wrk%i", i)));
		std::vector<std::string> hosts = tokenize(networkHosts, ";");

		/* Establish network connections to nested servers */
		for (size_t i=0; i<hosts.size(); ++i) {
			const std::string &hostName = hosts[i];
			ref<Stream> stream;

			if (hostName.find("@") == std::string::npos) {
				int port = MTS_DEFAULT_PORT;
				std::vector<std::string> tokens = tokenize(hostName, ":");
				if (tokens.size() == 0 || tokens.size() > 2) {
					SLog(EError, "Invalid host specification '%s'!", hostName.c_str());
				} else if (tokens.size() == 2) {
					port = strtol(tokens[1].c_str(), &end_ptr, 10);
					if (*end_ptr != '\0')
						SLog(EError, "Invalid host specification '%s'!", hostName.c_str());
				}
				stream = new SocketStream(tokens[0], port);
			} else {
				std::string path = "~/mitsuba"; // default path if not specified
				std::vector<std::string> tokens = tokenize(hostName, "@:");
				if (tokens.size() < 2 || tokens.size() > 3) {
					SLog(EError, "Invalid host specification '%s'!", hostName.c_str());
				} else if (tokens.size() == 3) {
					path = tokens[2];
				}
				std::vector<std::string> cmdLine;
				cmdLine.push_back(formatString("bash -c 'cd %s; . setpath.sh; mtssrv -ls'", path.c_str()));
				stream = new SSHStream(tokens[0], tokens[1], cmdLine);
			}
			try {
				scheduler->registerWorker(new RemoteWorker(formatString("net%i", i), stream));
			} catch (std::runtime_error &e) {
				if (hostName.find("@") != std::string::npos) {
#if defined(__WINDOWS__)
					SLog(EWarn, "Please ensure that passwordless authentication "
						"using plink.exe and pageant.exe is enabled (see the documentation for more information)");
#else
					SLog(EWarn, "Please ensure that passwordless authentication "
						"is enabled (e.g. using ssh-agent - see the documentation for more information)");
#endif
				}
				throw e;
			}
		}

		scheduler->start();

#if !defined(__WINDOWS__)
			/* Initialize signal handlers */
			struct sigaction sa;
			sa.sa_handler = signalHandler;
			sigemptyset(&sa.sa_mask);
			sa.sa_flags = 0;
			if (sigaction(SIGHUP, &sa, NULL))
				SLog(EError, "Could not install a custom signal handler!");
			if (sigaction(SIGFPE, &sa, NULL))
				SLog(EError, "Could not install a custom signal handler!");
#endif

		/* Prepare for parsing scene descriptions */
		SAXParser* parser = new SAXParser();
		fs::path schemaPath = fileResolver->resolveAbsolute("data/schema/scene.xsd");

		/* Check against the 'scene.xsd' XML Schema */
		parser->setDoSchema(true);
		parser->setValidationSchemaFullChecking(true);
		parser->setValidationScheme(SAXParser::Val_Always);
		parser->setExternalNoNamespaceSchemaLocation(schemaPath.c_str());

		/* Set the handler */
		SceneHandler *handler = new SceneHandler(parameters);
		parser->setDoNamespaces(true);
		parser->setDocumentHandler(handler);
		parser->setErrorHandler(handler);

		renderQueue = new RenderQueue();

		ref<FlushThread> flushThread;
		if (flushTimer > 0) {
			flushThread = new FlushThread(flushTimer);
			flushThread->start();
		}

		int jobIdx = 0;
		for (int i=optind; i<argc; ++i) {
			fs::path
				filename = fileResolver->resolve(argv[i]),
				filePath = fs::absolute(filename).parent_path(),
				baseName = filename.stem();
			ref<FileResolver> frClone = fileResolver->clone();
			frClone->prependPath(filePath);
			Thread::getThread()->setFileResolver(frClone);

			SLog(EInfo, "Parsing scene description from \"%s\" ..", argv[i]);

			parser->parse(filename.c_str());
			ref<Scene> scene = handler->getScene();

			scene->setSourceFile(filename);
			scene->setDestinationFile(destFile.length() > 0 ?
				fs::path(destFile) : (filePath / baseName));
			scene->setBlockSize(blockSize);

			if (scene->destinationExists() && skipExisting)
				continue;

			ref<RenderJob> thr = new RenderJob(formatString("ren%i", jobIdx++),
				scene, renderQueue, -1, -1, -1, true, flushTimer > 0);
			thr->start();

			renderQueue->waitLeft(numParallelScenes-1);
			if (i+1 < argc && numParallelScenes == 1)
				Statistics::getInstance()->resetAll();
		}

		/* Wait for all render processes to finish */
		renderQueue->waitLeft(0);
		if (flushThread)
			flushThread->quit();
		renderQueue = NULL;

		delete handler;
		delete parser;

		Statistics::getInstance()->printStats();
	} catch (const std::exception &e) {
		std::cerr << "Caught a critical exception: " << e.what() << endl;
		return -1;
	} catch (...) {
		std::cerr << "Caught a critical exception of unknown type!" << endl;
		return -1;
	}

	return 0;
}
示例#7
0
void WorldXMLReader::startElement(const XMLCh * const tagName_,
								  xercesc::AttributeList &attrs)
{
	char *tagName = XMLString::transcode(tagName_);
	// std::cout << tagName << std::endl;

	if (strcmp(tagName, "world") == 0 || strcmp(tagName, "World") == 0) {
		if (!m_world) {
			if (char *n = GET_VALUE(attrs, "name")) {
				m_world = new SSimWorld(n);
				RELEASE(n);
			} 
			else {
				NOATTR_ERR("world", "name", attrs);
			}

		}

		if (char *fname = GET_VALUE(attrs, "inherit")) {
			SAXParser *parser = new SAXParser();
			parser->setDocumentHandler(this);

			char buf[4096];
			const char *fpath = m_fdb.getPath(fname, buf);
			if (fpath != NULL) {
				S last = setFilename(fpath);
				parser->parse(fpath);
				delete parser;
				setFilename(last);
			} else {
				NOFILE_ERR(fname);
			}

			RELEASE(fname);
		}
	} else if (strcmp(tagName, "gravity") == 0 || strcmp(tagName, "Gravity") == 0) {
		if (m_world) {
			dReal x=0.0, y=0.0, z=0.0;
			char *p;
			p = GET_VALUE(attrs, "x");
			if (p) {
				x = atof(p);
				RELEASE(p);
			} else {
				NOATTR_ERR("gravity", "x", attrs);
			}
			p = GET_VALUE(attrs, "y");
			if (p) {
				y = atof(p);
				RELEASE(p);
			} else {
				NOATTR_ERR("gravity", "y", attrs);
			}
      
			p = GET_VALUE(attrs, "z");
			if (p) {
				z = atof(p);
				RELEASE(p);
			} else {
				NOATTR_ERR("gravity", "z", attrs);
			}
#if 0
			std::cout << "x = "  << x << std::endl;
			std::cout << "y = "  << y << std::endl;
			std::cout << "z = "  << z << std::endl;
#endif
			m_world->set(ODEWorld::Gravity(x, y, z), 0.0);
		}
	}
	else if (strcmp(tagName, "worldparam") == 0 || strcmp(tagName, "worldParam") == 0) {
		char *erp = GET_VALUE(attrs, "erp");
		if (erp) {
			m_world->setERP(atof(erp));
			RELEASE(erp);
		} 
		char *cfm = GET_VALUE(attrs, "cfm");
		if (cfm) {
			m_world->setCFM(atof(cfm));
			RELEASE(cfm);
		} 
		if (char *autostep = GET_VALUE(attrs, "autostep")) {
			if (strcmp(autostep, "false") == 0) {
				m_world->setAutoStep(false);
				RELEASE(autostep);
			}
		}
		if (char *quickstep = GET_VALUE(attrs, "quickstep")) {
			if (strcmp(quickstep, "true") == 0) {
				m_world->setQuickStep(true);
				RELEASE(quickstep);
			}
		}
		if (char *stepsize = GET_VALUE(attrs, "stepsize")) {
			m_world->setStepSize(atof(stepsize));
			RELEASE(stepsize);
		}
	}
	else if (strcmp(tagName, "collisionparam") == 0 || strcmp(tagName, "collisionParam") == 0) {

		char *mu = GET_VALUE(attrs, "mu");
		if (mu) {
			m_world->setCollisionParam("mu",atof(mu));
			RELEASE(mu);
		} 
		char *mu2 = GET_VALUE(attrs, "mu2");
		if (mu2) {
			m_world->setCollisionParam("mu2",atof(mu2));
			RELEASE(mu2);
		} 
		char *slip1 = GET_VALUE(attrs, "slip1");
		if (slip1) {
			m_world->setCollisionParam("slip1", atof(slip1));
			RELEASE(slip1);
		} 
		char *slip2 = GET_VALUE(attrs, "slip2");
		if (slip2) {
			m_world->setCollisionParam("slip2", atof(slip2));
			RELEASE(slip2);
		} 
		char *soft_erp = GET_VALUE(attrs, "soft_erp");
		if (soft_erp) {
			m_world->setCollisionParam("soft_erp", atof(soft_erp));
			RELEASE(soft_erp);
		} 
		char *soft_cfm = GET_VALUE(attrs, "soft_cfm");
		if (soft_cfm) {
			m_world->setCollisionParam("soft_cfm", atof(soft_cfm));
			RELEASE(soft_cfm);
		} 
		char *bounce = GET_VALUE(attrs, "bounce");
		if (bounce) {
			m_world->setCollisionParam("bounce", atof(bounce));
			RELEASE(bounce);
		} 
		char *bounce_vel = GET_VALUE(attrs, "bounce_vel");
		if (bounce_vel) {
			m_world->setCollisionParam("bounce_vel", atof(bounce_vel));
			RELEASE(bounce);
		} 


	}
	else if (strcmp(tagName, "instanciate") == 0) {
		ODEWorld *w = m_world->odeWorld();
		SSimObj *obj;

		// To check whether the type is robot or not
		char *type = GET_VALUE(attrs, "type");

		if (!type)  obj = new SSimObj(w->space());

		else if (strcmp(type,"Robot") == 0) {
			SRobotObj *robj = new SRobotObj(w->space());
			obj = (SSimObj*)robj;
			RELEASE(type);
		}
		else{
			obj = new SSimObj(w->space());
			RELEASE(type);
		}

		if (char *fname = GET_VALUE(attrs, "class")) {
			assert(m_world);
			assert(w);

			// Read contents of the entity from XML file
			// EntityXMLReader read(m_fdb, *obj, *w, m_x3ddb);
			EntityXMLReader read(m_fdb, *obj, *w, m_x3ddb, m_ssdb);

			read.setReadTaskContainer(this);
			read(fname);

		} 
		
		else {
			NOATTR_ERR("instanciate", "class", attrs);
		}
		m_currobj = obj;
	}
	else if (strcmp(tagName, "set-attr-value") == 0) {
		if (m_currobj) {
			char *n = GET_VALUE(attrs, "name");
			char *v = GET_VALUE(attrs, "value");
			if (!n) {
				NOATTR_ERR("set-attr-value", "name", attrs);
			}
			if (!v) {
				NOATTR_ERR("set-attr-value", "value", attrs);
			}
			if (n && v) {
				m_currobj->setAttrValue(n, v);
			}
		}
	}
	// Creation of new entity
	else if (strcmp(tagName, "entity") == 0 || strcmp(tagName, "Entity") == 0) {
		ODEWorld *w = m_world->odeWorld();

		// Set a new version flag later than v2.1
		m_world->setV21(true);

		// Create ODE world and space
		dWorldID world = w->world();
		dSpaceID space = w->space();

		char *entityName = GET_VALUE(attrs, "name");
		if (!entityName) {
			LOG_ERR(("Entity has no name"));
			assert(entityName); 
		}
		SSimEntity *ent;

		char *robot = GET_VALUE(attrs, "robot");
		if (robot && strcmp(robot, "true") == 0) {
			ent = new SSimRobotEntity(world, space, entityName);
			ent->setIsRobot(true);
		}
		else{
			ent = new SSimEntity(world, space, entityName);
		}

		static int eid = 0;
		ent->setID(eid);
		eid++;

		// Check whether it is agent or normal entity
		char *ag = GET_VALUE(attrs, "agent");
		if (ag && strcmp(ag, "true") == 0) {
			ent->setIsAgent(true);
		}
		m_current = ent;
	}

	else if (strcmp(tagName, "x3d") == 0 || strcmp(tagName, "X3D") == 0) {
		if (m_current != NULL) {

			char *scale = GET_VALUE(attrs, "scale");
	    
			Vector3d sc(1.0, 1.0, 1.0);
			if (scale) {
				char *scalex = strtok(scale, " ");
				char *scaley = strtok(NULL, " ");
				char *scalez = strtok(NULL, "");

				if (scalex == NULL || scaley == NULL || scalez == NULL) {
					LOG_ERR(("scale setting failed (%s)",m_current->name().c_str()));
				}
				else{
					sc.set(atof(scalex), atof(scaley), atof(scalez));
				}
			}
	    
			m_current->setScale(sc);
		}

		// Find the target XML file from current directory or SIGVERSE_DATADIR
		std::string tmp_fname = GET_VALUE(attrs, "filename");
		std::string path = getenv("SIGVERSE_DATADIR");
		std::string fname = "./" + tmp_fname;
		FILE *fp;
		if ((fp = fopen(fname.c_str(), "r")) == NULL) {
			fname = path + "/shape/" + tmp_fname;
			if ((fp = fopen(fname.c_str(), "r")) == NULL) {
				LOG_ERR(("cannot find shape file. [%s]", fname.c_str()));
				assert(fp != NULL);
			}
		}

		m_current->setShapeFile(tmp_fname);

		bool b = false;

		// Preparation of JNI
		char *cfg = getenv("SIGVERSE_X3DPARSER_CONFIG");
		if (cfg == NULL || strlen(cfg) == 0) {
			b = CJNIUtil::init("X3DParser.cfg");
		}
		else{
			b = CJNIUtil::init(cfg);
		}
	
		if (!b) {
			fprintf(stderr, "cannot read x3d config file");
			exit(1);
		}

		CX3DParser parser;
		parser.parse((char*)fname.c_str());
		//sread.read(fname.c_str());
		ODEWorld *w = m_world->odeWorld();
		//SSimObjBuilder builder(*m_currobj, *w);
		//m_current = dynamic_cast<SSimRobotEntity*>(m_current);
		//SSimRobotEntity *tmp;
		//m_current = dynamic_cast<SSimRobotEntity*>(m_current);
		//m_current = tmp;
		ShapeFileReader sread(m_current);
		LOG_SYS(("Creating object \"%s\"",m_current->name().c_str()));
		LOG_SYS(("Reading shape file [%s]", fname.c_str())); 
    
		if (m_current->isRobot()) {
			if (!sread.createRobotObj(&parser)) {
				LOG_ERR(("Failed to read robot shape file [%s]", fname.c_str())); 
			}
		}
		else{
			if (!sread.createObj(&parser)) {
				LOG_ERR(("Failed to read shape file [%s]", fname.c_str())); 
			}
		}

	} //   else if (strcmp(tagName, "x3d") == 0 || strcmp(tagName, "X3D") == 0) {
	else if (strcmp(tagName, "attribute") == 0 || strcmp(tagName, "Attribute") == 0) {
		if (m_current) {
			char *position  = GET_VALUE(attrs, "position");	 // entity position
			char *direction = GET_VALUE(attrs, "direction");	 // entity direction
			char *mass      = GET_VALUE(attrs, "mass");	 // entity mass
			char *collision = GET_VALUE(attrs, "collision");	 // collision detection flag
			char *quaternion= GET_VALUE(attrs, "quaternion");	 // quaternion
      
			if (position) {
				char *x = strtok(position, " ");
				char *y = strtok(NULL, " ");
				char *z = strtok(NULL, "");
				Vector3d pos(atof(x), atof(y), atof(z));
				if (m_current->isRobot()) {
					SSimRobotEntity *tmp_ent = (SSimRobotEntity*)m_current;
					tmp_ent->setInitPosition(pos);
				}
				else{
					m_current->setInitPosition(pos);
				}
			}
			//[ToDo]
			if (direction) {
			}
			//[ToDo]
			if (mass) {
				m_current->setMass(atof(mass));
			}
			if (collision) {
				if (strcmp(collision, "true") == 0) {
					if (m_current->isRobot()) {
						SSimRobotEntity *tmp_ent = (SSimRobotEntity*)m_current;
						tmp_ent->setCollision(true);
					}
					else{
						m_current->setCollision(true);
					}
				}
			}
			//[Todo]
			if (quaternion) {
			}
		}
	}
  
	// Added by okamoto on 2012-08-11
	// Reading and setting of camera parameter
	else if (strcmp(tagName, "camera") == 0 || strcmp(tagName, "Camera") == 0) {
		if (m_currobj) {
			char *cid  = GET_VALUE(attrs, "id");          // id number 
			char *link = GET_VALUE(attrs, "link");        // link name 
			char *fov  = GET_VALUE(attrs, "fov");	      // field of view
			char *as   = GET_VALUE(attrs, "aspectRatio"); // aspect ratio
			int iid    = -1;

			std::string id = cid;
			double dfov, das;
			// Whether value is specified by users
			bool isid   = false;
			bool islink = false;
			bool isfov  = false;
			bool isas   = false;

			if (link) islink = true;
			if (fov)  isfov  = true;
			if (as)   isas   = true;

			if (!cid) {
				LOG_ERR(("Cannot find camera ID."));
			}
			else {
				isid = true;
				iid = atoi(cid);
			}
			// Add camera ID
			m_currobj->addCameraID(iid);

			// Setting of camera parameters
			Value *vfov  = new DoubleValue();
			Value *vas   = new DoubleValue();
			Value *vlink = new StringValue();

			// Setting of each attributions
			std::string sfov  = "FOV"         + id;
			std::string sas   = "aspectRatio" + id;
			std::string slink = "elnk"        + id;
			vfov ->setString(sfov. c_str());
			vas  ->setString(sas.  c_str());	    
			vlink->setString(slink.c_str());	    

			// Add attribution info to entity
			m_currobj->push(new Attribute(sfov, vfov, "camera"));
			m_currobj->push(new Attribute(sas,  vas,  "camera"));
			if (iid > 2)
				m_currobj->push(new Attribute(slink, vlink, "camera"));

			if (isfov)
				m_currobj->setAttrValue(sfov.c_str(), fov);
			else 
				m_currobj->setAttrValue(sfov.c_str(), "45.0"); // default value

			if (isas)
				m_currobj->setAttrValue(sas.c_str(), as);
			else
				m_currobj->setAttrValue(sas.c_str(), "1.5");   // default value

			if (islink)
				m_currobj->setAttrValue(slink.c_str(), link);
			else
				m_currobj->setAttrValue(slink.c_str(), "body");// default value

			char *position = GET_VALUE(attrs, "position");
	    
			std::string epx = "epx" + id;
			std::string epy = "epy" + id;
			std::string epz = "epz" + id;
	    
			if (position) {
				std::string x = strtok(position, " ");
				std::string y = strtok(NULL, " ");
				std::string z = strtok(NULL, "");
				Vector3d pos(atof(x.c_str()), atof(y.c_str()), atof(z.c_str()));
	      
				if (iid > 2) {
					Value *v_x = new DoubleValue();
					Value *v_y = new DoubleValue();
					Value *v_z = new DoubleValue();

					v_x->setString(epx.c_str());
					v_y->setString(epy.c_str());
					v_z->setString(epz.c_str());

					// [Comment] Is it OK to execute new here?
					m_currobj->push(new Attribute(epx, v_x, "camera"));
					m_currobj->push(new Attribute(epy, v_y, "camera"));
					m_currobj->push(new Attribute(epz, v_z, "camera"));

				}
				m_currobj->setAttrValue(epx.c_str(), x.c_str());
				m_currobj->setAttrValue(epy.c_str(), y.c_str());
				m_currobj->setAttrValue(epz.c_str(), z.c_str());
				RELEASE(position);
			}

			else {
				// Default values
				m_currobj->setAttrValue(epx.c_str(), "0.0");
				m_currobj->setAttrValue(epy.c_str(), "0.0");
				m_currobj->setAttrValue(epz.c_str(), "0.0");
			}

			// camera direction
			char *direction  = GET_VALUE(attrs, "direction");
			char *quaternion = GET_VALUE(attrs, "quaternion");   // aspect ratio

			std::string evx = "evx" + id;
			std::string evy = "evy" + id;
			std::string evz = "evz" + id;

			std::string quw = "quw" + id;
			std::string qux = "qux" + id;
			std::string quy = "quy" + id;
			std::string quz = "quz" + id;

			if (direction && quaternion) {
				LOG_MSG(("cannot set camera quaternion and direction simultaneously")); 
			}

			if (direction) {
				std::string vx = strtok(direction, " ");
				std::string vy = strtok(NULL, " ");
				std::string vz = strtok(NULL, "");
				Vector3d dir(atof(vx.c_str()), atof(vy.c_str()), atof(vz.c_str()));
	
				if (iid > 2) {
					Value *v_x = new DoubleValue();
					Value *v_y = new DoubleValue();
					Value *v_z = new DoubleValue();

					v_x->setString(evx.c_str());
					v_y->setString(evy.c_str());
					v_z->setString(evz.c_str());
					// [Comment] Is it OK to execute new here?
					m_currobj->push(new Attribute(evx, v_x, "camera"));
					m_currobj->push(new Attribute(evy, v_y, "camera"));
					m_currobj->push(new Attribute(evz, v_z, "camera"));

				}
				m_currobj->setAttrValue(evx.c_str(), vx.c_str());
				m_currobj->setAttrValue(evy.c_str(), vy.c_str());
				m_currobj->setAttrValue(evz.c_str(), vz.c_str());	      
				RELEASE(direction);
			}
			else {
				Vector3d dir(0.0, 0.0, 1.0);
				m_currobj->setAttrValue(evx.c_str(), "0.0");
				m_currobj->setAttrValue(evy.c_str(), "0.0");
				m_currobj->setAttrValue(evz.c_str(), "1.0");	      
			}

			Value *q_w = new DoubleValue();
			Value *q_x = new DoubleValue();
			Value *q_y = new DoubleValue();
			Value *q_z = new DoubleValue();
      
			q_w->setString(quw.c_str());
			q_x->setString(qux.c_str());
			q_y->setString(quy.c_str());
			q_z->setString(quz.c_str());
      
			m_currobj->push(new Attribute(quw, q_w, "camera"));
			m_currobj->push(new Attribute(qux, q_x, "camera"));
			m_currobj->push(new Attribute(quy, q_y, "camera"));
			m_currobj->push(new Attribute(quz, q_z, "camera"));
      
			if (quaternion) {
				std::string qw = strtok(quaternion, " ");
				std::string qx = strtok(NULL, " ");
				std::string qy = strtok(NULL, " ");
				std::string qz = strtok(NULL, "");

				m_currobj->setAttrValue(quw.c_str(), qw.c_str());
				m_currobj->setAttrValue(qux.c_str(), qx.c_str());
				m_currobj->setAttrValue(quy.c_str(), qy.c_str());
				m_currobj->setAttrValue(quz.c_str(), qz.c_str());	      
				RELEASE(quaternion);
			}
			else {
				m_currobj->setAttrValue(quw.c_str(), "1.0");
				m_currobj->setAttrValue(qux.c_str(), "0.0");
				m_currobj->setAttrValue(quy.c_str(), "0.0");
				m_currobj->setAttrValue(quz.c_str(), "0.0");
			}
			//RELEASE(id.c_str());
			if (isid)   RELEASE(cid);
			if (islink) RELEASE(link);
			if (isfov)  RELEASE(fov);
			if (isas)   RELEASE(as);
		} // if (m_currobj)
	}
	RELEASE(tagName);
}
int main (int argC,  char *argV[]) 
{

    MemoryMonitor *staticMemMonitor = new MemoryMonitor();

    // Initialize the XML4C system
    try
    {
        XMLPlatformUtils::Initialize(XMLUni::fgXercescDefaultLocale, 0, 0, staticMemMonitor);
    }
    catch (const XMLException& toCatch)
    {
         char *msg = XMLString::transcode(toCatch.getMessage());
         XERCES_STD_QUALIFIER cerr << "Error during initialization! :\n"
              << msg << XERCES_STD_QUALIFIER endl;
         XMLString::release(&msg);
         return 1;
    }

    // Check command line and extract arguments.
    if (argC < 2)
    {
        usage();
        return 1;
    }

    const char*                xmlFile = 0;
    AbstractDOMParser::ValSchemes domBuilderValScheme = AbstractDOMParser::Val_Auto;
    bool                       doNamespaces       = false;
    bool                       doSchema           = false;
    bool                       schemaFullChecking = false;
    bool                       doList = false;
    bool                       errorOccurred = false;
    int                        numReps =1;

    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"))
                domBuilderValScheme = AbstractDOMParser::Val_Never;
            else if (!strcmp(parm, "auto"))
                domBuilderValScheme = AbstractDOMParser::Val_Auto;
            else if (!strcmp(parm, "always"))
                domBuilderValScheme = 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 (!strncmp(argV[argInd], "-r=", 3)
              ||  !strncmp(argV[argInd], "-R=", 3))
        {
            const char* const numStr = &argV[argInd][3];
            XMLCh* numXStr = XMLString::transcode(numStr);
            numReps = XMLString::parseInt(numXStr);
            XMLString::release(&numXStr);
        }
         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;
    }

    // Instantiate the DOM domBuilder with its memory manager.
    MemoryMonitor *domBuilderMemMonitor = new MemoryMonitor();
    static const XMLCh gLS[] = { chLatin_L, chLatin_S, chNull };
    DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(gLS);
    DOMBuilder        *domBuilder = ((DOMImplementationLS*)impl)->createDOMBuilder(DOMImplementationLS::MODE_SYNCHRONOUS, 0, domBuilderMemMonitor);
    DOMBuilderHandler domBuilderHandler;
    domBuilder->setErrorHandler(&domBuilderHandler);

    // Instantiate the SAX2 domBuilder with its memory manager.
    MemoryMonitor *sax2MemMonitor = new MemoryMonitor();
    SAX2XMLReader *sax2parser = XMLReaderFactory::createXMLReader(sax2MemMonitor);
    SAXErrorHandler saxErrorHandler;
    sax2parser->setErrorHandler(&saxErrorHandler);

    // Instantiate the deprecated DOM parser with its memory manager.
    MemoryMonitor *depDOMMemMonitor = new MemoryMonitor();
    DOMParser *depDOMParser = new (depDOMMemMonitor)DOMParser(0, depDOMMemMonitor);
    depDOMParser->setErrorHandler(&saxErrorHandler);

    // Instantiate the SAX 1 parser with its memory manager.
    MemoryMonitor *sax1MemMonitor = new MemoryMonitor();
    SAXParser *saxParser = new (sax1MemMonitor) SAXParser(0, sax1MemMonitor);
    saxParser->setErrorHandler(&saxErrorHandler);

    // set features 
    domBuilder->setFeature(XMLUni::fgDOMNamespaces, doNamespaces);
    sax2parser->setFeature(XMLUni::fgSAX2CoreNameSpaces, doNamespaces);
    depDOMParser->setDoNamespaces(doNamespaces);
    saxParser->setDoNamespaces(doNamespaces);

    domBuilder->setFeature(XMLUni::fgXercesSchema, doSchema);
    sax2parser->setFeature(XMLUni::fgXercesSchema, doSchema);
    depDOMParser->setDoSchema(doSchema);
    saxParser->setDoSchema(doSchema);

    domBuilder->setFeature(XMLUni::fgXercesSchemaFullChecking, schemaFullChecking);
    sax2parser->setFeature(XMLUni::fgXercesSchemaFullChecking, schemaFullChecking);
    depDOMParser->setValidationSchemaFullChecking(schemaFullChecking);
    saxParser->setValidationSchemaFullChecking(schemaFullChecking);

    if (domBuilderValScheme == AbstractDOMParser::Val_Auto)
    {
        domBuilder->setFeature(XMLUni::fgDOMValidateIfSchema, true);
        sax2parser->setFeature(XMLUni::fgSAX2CoreValidation, true);
        sax2parser->setFeature(XMLUni::fgXercesDynamic, true);
        depDOMParser->setValidationScheme(DOMParser::Val_Auto);
        saxParser->setValidationScheme(SAXParser::Val_Auto);
    }
    else if (domBuilderValScheme == AbstractDOMParser::Val_Never)
    {
        domBuilder->setFeature(XMLUni::fgDOMValidation, false);
        sax2parser->setFeature(XMLUni::fgSAX2CoreValidation, false);
        depDOMParser->setValidationScheme(DOMParser::Val_Never);
        saxParser->setValidationScheme(SAXParser::Val_Never);
    }
    else if (domBuilderValScheme == AbstractDOMParser::Val_Always)
    {
        domBuilder->setFeature(XMLUni::fgDOMValidation, true);
        sax2parser->setFeature(XMLUni::fgSAX2CoreValidation, true);
        sax2parser->setFeature(XMLUni::fgXercesDynamic, false);
        depDOMParser->setValidationScheme(DOMParser::Val_Always);
        saxParser->setValidationScheme(SAXParser::Val_Always);
    }

    // enable datatype normalization - default is off
    domBuilder->setFeature(XMLUni::fgDOMDatatypeNormalization, true);

    XERCES_STD_QUALIFIER ifstream fin;
    bool more = true;

    // 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;
        }

        // parse numReps times (in case we need it for some reason)
        for (int i=0; i<numReps; i++)
        {

            XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument *doc = 0;

            try
            {
                // reset document pool
                domBuilder->resetDocumentPool();

                doc = domBuilder->parseURI(xmlFile);
                sax2parser->parse(xmlFile);
                depDOMParser->parse(xmlFile);
                saxParser->parse(xmlFile);
            }
            catch (const OutOfMemoryException&)
            {
                XERCES_STD_QUALIFIER cerr << "OutOfMemoryException during parsing: '" << xmlFile << "'\n" << XERCES_STD_QUALIFIER endl;;
                continue;
            }
            catch (const XMLException& toCatch)
            {
                char *msg = XMLString::transcode(toCatch.getMessage()); 
                XERCES_STD_QUALIFIER cerr << "\nError during parsing: '" << xmlFile << "'\n"
                    << "Exception message is:  \n"
                    << msg << "\n" << XERCES_STD_QUALIFIER endl;
                XMLString::release(&msg);
                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))
                {
                    char * msg = XMLString::transcode(errText); 
                    XERCES_STD_QUALIFIER cerr << "Message is: " << msg << XERCES_STD_QUALIFIER endl;

                    continue;
                }
            }
            catch (...)
            {
                XERCES_STD_QUALIFIER cerr << "\nUnexpected exception during parsing: '" << xmlFile << "'\n";
                continue;
            }

        }
    }

    //
    //  Delete the domBuilder itself.  Must be done prior to calling Terminate, below.
    //
    domBuilder->release();
    delete sax2parser;
    delete depDOMParser;
    delete saxParser;

    XERCES_STD_QUALIFIER cout << "At destruction, domBuilderMemMonitor has " << domBuilderMemMonitor->getTotalMemory() << " bytes." << XERCES_STD_QUALIFIER endl;
    XERCES_STD_QUALIFIER cout << "At destruction, sax2MemMonitor has " << sax2MemMonitor->getTotalMemory() << " bytes." << XERCES_STD_QUALIFIER endl;
    XERCES_STD_QUALIFIER cout << "At destruction, depDOMMemMonitor has " << depDOMMemMonitor->getTotalMemory() << " bytes." << XERCES_STD_QUALIFIER endl;
    XERCES_STD_QUALIFIER cout << "At destruction, sax1MemMonitor has " << sax1MemMonitor->getTotalMemory() << " bytes." << XERCES_STD_QUALIFIER endl;
    delete domBuilderMemMonitor;
    delete sax2MemMonitor;
    delete depDOMMemMonitor;
    delete sax1MemMonitor;

    XMLPlatformUtils::Terminate();
    XERCES_STD_QUALIFIER cout << "At destruction, staticMemMonitor has " << staticMemMonitor->getTotalMemory() << " bytes." << XERCES_STD_QUALIFIER endl;
    delete staticMemMonitor;
    return 0;
}
示例#9
0
void process(char* const xmlFile)
{
    //
    //  Create a Schema validator to be used for our validation work. Then create
    //  a SAX parser object and pass it our validator. Then, according to what
    //  we were told on the command line, set it to validate or not. He owns
    //  the validator, so we have to allocate it.
    //
    SAXParser parser;
    parser.setValidationScheme(SAXParser::Val_Always);
    parser.setDoNamespaces(true);
    parser.setDoSchema(true);

	parser.parse(xmlFile);

    if (parser.getErrorCount())
	{
        XERCES_STD_QUALIFIER cout << "\nErrors occurred, no output available\n" << XERCES_STD_QUALIFIER endl;
		return;
	}

	if (!parser.getValidator().handlesSchema())
	{
		XERCES_STD_QUALIFIER cout << "\n Non schema document, no output available\n" << XERCES_STD_QUALIFIER endl;
		return;
	}

	Grammar* rootGrammar = parser.getRootGrammar();
	if (!rootGrammar || rootGrammar->getGrammarType() != Grammar::SchemaGrammarType)
	{
		XERCES_STD_QUALIFIER cout << "\n Non schema grammar, no output available\n" << XERCES_STD_QUALIFIER endl;
		return;
	}

	//
	//  Now we will get an enumerator for the element pool from the validator
	//  and enumerate the elements, printing them as we go. For each element
	//  we get an enumerator for its attributes and print them also.
	//

	SchemaGrammar* grammar = (SchemaGrammar*) rootGrammar;
	RefHash3KeysIdPoolEnumerator<SchemaElementDecl> elemEnum = grammar->getElemEnumerator();

	if (!elemEnum.hasMoreElements())
	{
		XERCES_STD_QUALIFIER cout << "\nThe validator has no elements to display\n" << XERCES_STD_QUALIFIER endl;
		return;
	}

	while(elemEnum.hasMoreElements())
	{
		const SchemaElementDecl& curElem = elemEnum.nextElement();

		// Name
		XERCES_STD_QUALIFIER cout << "Name:\t\t\t" << StrX(curElem.getFullName()) << "\n";

		// Model Type
		XERCES_STD_QUALIFIER cout << "Model Type:\t\t";
		switch( curElem.getModelType() )
		{
		case SchemaElementDecl::Empty:          XERCES_STD_QUALIFIER cout << "Empty";         break;
		case SchemaElementDecl::Any:            XERCES_STD_QUALIFIER cout << "Any";           break;
		case SchemaElementDecl::Mixed_Simple:   XERCES_STD_QUALIFIER cout << "Mixed_Simple";  break;
		case SchemaElementDecl::Mixed_Complex:  XERCES_STD_QUALIFIER cout << "Mixed_Complex"; break;
		case SchemaElementDecl::Children:       XERCES_STD_QUALIFIER cout << "Children";      break;
		case SchemaElementDecl::Simple:         XERCES_STD_QUALIFIER cout << "Simple";        break;
        case SchemaElementDecl::ElementOnlyEmpty:    XERCES_STD_QUALIFIER cout << "ElementOnlyEmpty";    break;

		default:                                XERCES_STD_QUALIFIER cout << "Unknown";       break;
		}

		XERCES_STD_QUALIFIER cout << "\n";

		// Create Reason
		XERCES_STD_QUALIFIER cout << "Create Reason:\t";
		switch( curElem.getCreateReason() )
		{
		case XMLElementDecl::NoReason:          XERCES_STD_QUALIFIER cout << "Empty";            break;
		case XMLElementDecl::Declared:          XERCES_STD_QUALIFIER cout << "Declared";         break;
		case XMLElementDecl::AttList:           XERCES_STD_QUALIFIER cout << "AttList";          break;
		case XMLElementDecl::InContentModel:    XERCES_STD_QUALIFIER cout << "InContentModel";   break;
		case XMLElementDecl::AsRootElem:        XERCES_STD_QUALIFIER cout << "AsRootElem";       break;
		case XMLElementDecl::JustFaultIn:       XERCES_STD_QUALIFIER cout << "JustFaultIn";      break;

		default:                            XERCES_STD_QUALIFIER cout << "Unknown";  break;
		}

		XERCES_STD_QUALIFIER cout << "\n";

		// Content Spec Node
		processContentSpecNode( curElem.getContentSpec() );

		// Misc Flags
		int mflags = curElem.getMiscFlags();
		if( mflags !=0 )
		{
			XERCES_STD_QUALIFIER cout << "Misc. Flags:\t";
		}

        if ( mflags & SchemaSymbols::XSD_NILLABLE )
			XERCES_STD_QUALIFIER cout << "Nillable ";

		if ( mflags & SchemaSymbols::XSD_ABSTRACT )
			XERCES_STD_QUALIFIER cout << "Abstract ";

		if ( mflags & SchemaSymbols::XSD_FIXED )
			XERCES_STD_QUALIFIER cout << "Fixed ";

		if( mflags !=0 )
		{
			XERCES_STD_QUALIFIER cout << "\n";
		}

		// Substitution Name
		SchemaElementDecl* subsGroup = curElem.getSubstitutionGroupElem();
		if( subsGroup )
		{
			const XMLCh* uriText = parser.getURIText(subsGroup->getURI());
			XERCES_STD_QUALIFIER cout << "Substitution Name:\t" << StrX(uriText)
			     << "," << StrX(subsGroup->getBaseName()) << "\n";
		}

		// Content Model
		const XMLCh* fmtCntModel = curElem.getFormattedContentModel();
		if( fmtCntModel != NULL )
		{
			XERCES_STD_QUALIFIER cout << "Content Model:\t" << StrX(fmtCntModel) << "\n";
		}

		const ComplexTypeInfo* ctype = curElem.getComplexTypeInfo();
		if( ctype != NULL)
		{
			XERCES_STD_QUALIFIER cout << "ComplexType:\n";
			XERCES_STD_QUALIFIER cout << "\tTypeName:\t" << StrX(ctype->getTypeName()) << "\n";

			ContentSpecNode* cSpecNode = ctype->getContentSpec();
			processContentSpecNode(cSpecNode, true );
		}

		// Datatype
		DatatypeValidator* dtValidator = curElem.getDatatypeValidator();
		processDatatypeValidator( dtValidator );

		// Get an enumerator for this guy's attributes if any
		if ( curElem.hasAttDefs() )
		{
			processAttributes( curElem.getAttDefList() );
		}

		XERCES_STD_QUALIFIER cout << "--------------------------------------------";
		XERCES_STD_QUALIFIER cout << XERCES_STD_QUALIFIER endl;

    }

    return;
}
示例#10
0
// ---------------------------------------------------------------------------
//  Program entry point
// ---------------------------------------------------------------------------
int main(int argc, char* args[])
{
    // Initialize the XML4C system
    try
    {
         XMLPlatformUtils::Initialize();
    }
    catch (const XMLException& toCatch)
    {
        XERCES_STD_QUALIFIER cerr << "Error during initialization! Message:\n"
             << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
        return 1;
    }

    // We only have one parameter, which is the file to process
    // We only have one required parameter, which is the file to process
    if ((argc != 2) || (*(args[1]) == '-'))
    {
        usage();
        XMLPlatformUtils::Terminate();
        return 1;
    }

    const char*              xmlFile = args[1];

    //
    //  Create a SAX parser object. Then, according to what we were told on
    //  the command line, set it to validate or not.
    //
    SAXParser* parser = new SAXParser;

    //
    //  Create our SAX handler object and install it on the parser, as the
    //  document, entity and error handlers.
    //
    RedirectHandlers handler;
    parser->setDocumentHandler(&handler);
    parser->setErrorHandler(&handler);
    //Use the new XML Entity Resolver
    //parser->setEntityResolver(&handler);
    parser->setXMLEntityResolver(&handler);    

    //
    //  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;
    int errorCount = 0;
    int errorCode = 0;
    try
    {
        const unsigned long startMillis = XMLPlatformUtils::getCurrentMillis();
        parser->parse(xmlFile);
        const unsigned long endMillis = XMLPlatformUtils::getCurrentMillis();
        duration = endMillis - startMillis;
        errorCount = parser->getErrorCount();
    }
    catch (const OutOfMemoryException&)
    {
        XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
        errorCode = 5;
    }
    catch (const XMLException& e)
    {
        XERCES_STD_QUALIFIER cerr << "\nError during parsing: '" << xmlFile << "'\n"
                << "Exception message is:  \n"
                << StrX(e.getMessage()) << "\n" << XERCES_STD_QUALIFIER endl;
        errorCode = 4;
    }

    if(errorCode) {
        XMLPlatformUtils::Terminate();
        return errorCode;
    }

    // Print out the stats that we collected and time taken.
    if (!errorCount) {
        XERCES_STD_QUALIFIER cout << xmlFile << ": " << duration << " ms ("
             << handler.getElementCount() << " elems, "
             << handler.getAttrCount() << " attrs, "
             << handler.getSpaceCount() << " spaces, "
             << handler.getCharacterCount() << " chars)" << XERCES_STD_QUALIFIER endl;
    }

    //
    //  Delete the parser itself.  Must be done prior to calling Terminate, below.
    //
    delete parser;

    XMLPlatformUtils::Terminate();

    if (errorCount > 0)
        return 4;
    else
        return 0;
}
示例#11
0
// ---------------------------------------------------------------------------
//  Program entry point
// ---------------------------------------------------------------------------
int main(int argC, char* argV[])
{

    // Check command line and extract arguments.
    if (argC < 2)
    {
        usage();
        return 1;
    }

    const char*              xmlFile = 0;
    SAXParser::ValSchemes    valScheme = SAXParser::Val_Auto;
    bool                     doNamespaces       = false;
    bool                     doSchema           = false;
    bool                     schemaFullChecking = false;
    bool                     doList = false;
    bool                     errorOccurred = false;
    bool                     recognizeNEL = 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 = SAXParser::Val_Never;
            else if (!strcmp(parm, "auto"))
                valScheme = SAXParser::Val_Auto;
            else if (!strcmp(parm, "always"))
                valScheme = SAXParser::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 (!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 at least one parameter left, and that
    //  should be the file name(s).
    //
    if (argInd == argC)
    {
        usage();
        return 1;
    }

    // Initialize the XML4C2 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! Message:\n"
            << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
        return 1;
    }

    //
    //  Create a SAX parser object. Then, according to what we were told on
    //  the command line, set it to validate or not.
    //
    SAXParser* parser = new SAXParser;

    parser->setValidationScheme(valScheme);
    parser->setDoNamespaces(doNamespaces);
    parser->setDoSchema(doSchema);
    parser->setValidationSchemaFullChecking(schemaFullChecking);

    //
    //  Create our SAX handler object and install it on the parser, as the
    //  document and error handler.
    //
    SAXCountHandlers handler;
    parser->setDocumentHandler(&handler);
    parser->setErrorHandler(&handler);


    //
    //  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;

    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 (true)
    {
        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 {
            if (argInd < argC)
            {
                 xmlFile = argV[argInd];
                 argInd++;
            }
            else
                break;
        }

        //reset error count first
        handler.resetErrors();

        try
        {
            const unsigned long startMillis = XMLPlatformUtils::getCurrentMillis();
            parser->parse(xmlFile);
            const unsigned long endMillis = XMLPlatformUtils::getCurrentMillis();
            duration = endMillis - startMillis;
        }
        catch (const OutOfMemoryException&)
        {
            XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
            errorOccurred = true;
            continue;
        }
        catch (const XMLException& e)
        {
            XERCES_STD_QUALIFIER cerr << "\nError during parsing: '" << xmlFile << "'\n"
                << "Exception message is:  \n"
                << StrX(e.getMessage()) << "\n" << XERCES_STD_QUALIFIER endl;
            errorOccurred = true;
            continue;
        }

        catch (...)
        {
            XERCES_STD_QUALIFIER cerr << "\nUnexpected exception during parsing: '" << xmlFile << "'\n";
            errorOccurred = true;
            continue;
        }


        // Print out the stats that we collected and time taken
        if (!handler.getSawErrors())
        {
            XERCES_STD_QUALIFIER cout << xmlFile << ": " << duration << " ms ("
                << handler.getElementCount() << " elems, "
                << handler.getAttrCount() << " attrs, "
                << handler.getSpaceCount() << " spaces, "
                << handler.getCharacterCount() << " chars)" << XERCES_STD_QUALIFIER endl;
        }
        else
            errorOccurred = true;
    }

    if (doList)
        fin.close();

    //
    //  Delete the parser itself.  Must be done prior to calling Terminate, below.
    //
    delete parser;

    // And call the termination method
    XMLPlatformUtils::Terminate();

    if (errorOccurred)
        return 4;
    else
        return 0;

}