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