VXIlogResult SBlogErrorMapper::InitializeXMLParser() { if( initialized ) return VXIlog_RESULT_SUCCESS; // Log to voiceglue if (voiceglue_loglevel() >= LOG_INFO) { std::ostringstream logstring; logstring << "SBlogMapper: XMLPlatformUtils::Initialize()"; voiceglue_log ((char) LOG_INFO, logstring); }; // Initialize the SAX parser try { XMLPlatformUtils::Initialize(); } catch (const XMLException& exception) { showExceptionMsg(exception); return VXIlog_RESULT_FAILURE; } initialized = 1; parser = new SAXParser(); //parser->setDoValidation(false); ausmarton parser->setValidationScheme(SAXParser::Val_Never); parser->setDoNamespaces(false); // Register our own handler class (callback) xmlHandler = new MySAXHandler(); ErrorHandler* errHandler = (ErrorHandler*) xmlHandler; parser->setDocumentHandler((DocumentHandler *)xmlHandler); parser->setErrorHandler(errHandler); return VXIlog_RESULT_SUCCESS; }
void OptionsIO::loadConfiguration() { OptionsCont& oc = OptionsCont::getOptions(); if (!oc.exists("configuration-file") || !oc.isSet("configuration-file")) { return; } std::string path = oc.getString("configuration-file"); if (!FileHelpers::exists(path)) { throw ProcessError("Could not find configuration '" + oc.getString("configuration-file") + "'."); } PROGRESS_BEGIN_MESSAGE("Loading configuration"); // build parser SAXParser parser; parser.setValidationScheme(SAXParser::Val_Auto); parser.setDoNamespaces(false); parser.setDoSchema(false); // start the parsing OptionsLoader handler; try { parser.setDocumentHandler(&handler); parser.setErrorHandler(&handler); parser.parse(path.c_str()); if (handler.errorOccured()) { throw ProcessError("Could not load configuration '" + path + "'."); } } catch (const XMLException& e) { throw ProcessError("Could not load configuration '" + path + "':\n " + TplConvert<XMLCh>::_2str(e.getMessage())); } oc.relocateFiles(path); PROGRESS_DONE_MESSAGE(); }
int InstallationParser::parse() { if (initialization() == 1) // Problem during the initialisation. return(1); SAXParser* parser = new SAXParser(); parser->setDoValidation(true); parser->setDoNamespaces(true); InstallationSAXHandler* handler = new InstallationSAXHandler(); parser->setDocumentHandler(handler); parser->setErrorHandler(handler); try { const char* file = xmlFile.c_str(); // Name of the descriptor file in the current directory. parser->parse(file); // Parsing procedure. handler->get_pkgname(pkgname); // Result of the parsing. handler->get_pkgUUID(pkgUUID); handler->get_implementations(codefiles); // Result of the parsing. } catch (const XMLException& toCatch) { // File not found for the parsing. std::cerr << "\nFile not found : '" << xmlFile << "'\n"; std::cerr << "Exception message is : \n" << toCatch.getMessage() << "\n"; return(4); } int err = handler->get_error(); // The error codes are got from the handler object. delete(handler); // Object deleted. delete(parser); // Object deleted. return(err); // 0, 2 or 3 is returned. }
int main(int argc, const char ** argv) { for (int i = 1; i < argc; ++i) { tagNames.push_back(argv[i]); } try { XMLPlatformUtils::Initialize(); } catch (const XMLException& e) { return 1; } leveldb::Options options; options.create_if_missing = true; leveldb::DB::Open(options, "leveldb", &db); SAXParser *parser = new SAXParser(); MySAXHandler *handler = new MySAXHandler(); parser->setDocumentHandler(handler); ZeroPaddedStdInInputSource src; parser->parse(src); ZeroSeparatedBinFileInputStream::next(); handler->setComments(); parser->parse(src); ZeroSeparatedBinFileInputStream::next(); handler->setUsers(); parser->parse(src); delete db; return 0; }
bool Kumu::XMLElement::ParseString(const char* document, ui32_t doc_len) { if ( doc_len == 0 ) return false; init_xml_dom(); int errorCount = 0; SAXParser* parser = new SAXParser(); parser->setValidationScheme(SAXParser::Val_Always); parser->setDoNamespaces(true); // optional MyTreeHandler* docHandler = new MyTreeHandler(this); parser->setDocumentHandler(docHandler); parser->setErrorHandler(docHandler); try { MemBufInputSource xmlSource(reinterpret_cast<const XMLByte*>(document), static_cast<const unsigned int>(doc_len), "pidc_rules_file"); parser->parse(xmlSource); } catch (const XMLException& e) { char* message = XMLString::transcode(e.getMessage()); DefaultLogSink().Error("Parser error: %s\n", message); XMLString::release(&message); errorCount++; } catch (const SAXParseException& e) { char* message = XMLString::transcode(e.getMessage()); DefaultLogSink().Error("Parser error: %s at line %d\n", message, e.getLineNumber()); XMLString::release(&message); errorCount++; } catch (...) { DefaultLogSink().Error("Unexpected XML parser error\n"); errorCount++; } if ( errorCount == 0 ) m_NamespaceOwner = (void*)docHandler->TakeNamespaceMap(); delete parser; delete docHandler; return errorCount > 0 ? false : true; }
/* Read the file. */ bool GQCFileData::Read(const std::string &fileName) { Clear(); // Initialize the XML4C2 system try { XMLPlatformUtils::Initialize(); } catch (const XMLException&) { return false; } bool status = false; SAXParser* parser = new SAXParser; parser->setValidationScheme(SAXParser::Val_Never); parser->setLoadExternalDTD(false); parser->setDoNamespaces(false); parser->setDoSchema(false); parser->setValidationSchemaFullChecking(false); SAXGenericReportHandlers handler(this); parser->setDocumentHandler(&handler); parser->setErrorHandler(&handler); try { parser->parse(fileName.c_str()); int errorCount = parser->getErrorCount(); if (errorCount == 0) { status = true; } } catch (...) { status = false; } delete parser; XMLPlatformUtils::Terminate(); return status; }
bool streamXML(const string& filename, XMLStream& stream) { try { XMLPlatformUtils::Initialize(); } catch (const XMLException& toCatch) { char* message = XMLString::transcode(toCatch.getMessage()); cerr << "XML initialization failed: " << message << endl; return false; } SAXParser parser; parser.setDoValidation(true); // optional. parser.setDoNamespaces(true); // optional StreamHandler docHandler(stream); parser.setDocumentHandler(&docHandler); parser.setErrorHandler((ErrorHandler*)&docHandler); try { parser.parse(filename.c_str()); } catch (const XMLException& toCatch) { char* message = XMLString::transcode(toCatch.getMessage()); cerr << "XML Exception: " << message << endl; return false; } catch (const SAXParseException& toCatch) { char* message = XMLString::transcode(toCatch.getMessage()); cerr << "XML Parsing exception: " << message << endl; return false; } catch (const SAXException& e) { char* message = XMLString::transcode(e.getMessage()); cerr << "Bad file format exception: " << message << endl; return false; } catch (...) { cerr << "Unexpected Exception \n" ; return false; } return true; }
// --------------------------------------------------------------------------- // 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; } int parmInd; for (parmInd = 1; parmInd < argC; parmInd++) { // Break out on first parm not starting with a dash if (argV[parmInd][0] != '-') break; // Watch for special case help request if (!strcmp(argV[parmInd], "-?")) { usage(); XMLPlatformUtils::Terminate(); return 2; } else if (!strncmp(argV[parmInd], "-v=", 3) || !strncmp(argV[parmInd], "-V=", 3)) { const char* const parm = &argV[parmInd][3]; if (!strcmp(parm, "never")) 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; XMLPlatformUtils::Terminate(); return 2; } } else if (!strcmp(argV[parmInd], "-n") || !strcmp(argV[parmInd], "-N")) { doNamespaces = true; } else if (!strcmp(argV[parmInd], "-s") || !strcmp(argV[parmInd], "-S")) { doSchema = true; } else if (!strcmp(argV[parmInd], "-f") || !strcmp(argV[parmInd], "-F")) { schemaFullChecking = true; } else { XERCES_STD_QUALIFIER cerr << "Unknown option '" << argV[parmInd] << "', ignoring it\n" << XERCES_STD_QUALIFIER endl; } } // // Create a SAX parser object. Then, according to what we were told on // the command line, set the options. // 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. We are responsible for cleaning them // up, but since its just stack based here, there's nothing special // to do. // StdInParseHandlers handler; parser->setDocumentHandler(&handler); parser->setErrorHandler(&handler); unsigned long duration; int errorCount = 0; // create a faux scope so that 'src' destructor is called before // XMLPlatformUtils::Terminate { // // Kick off the parse and catch any exceptions. Create a standard // input input source and tell the parser to parse from that. // StdInInputSource src; try { const unsigned long startMillis = XMLPlatformUtils::getCurrentMillis(); parser->parse(src); const unsigned long endMillis = XMLPlatformUtils::getCurrentMillis(); duration = endMillis - startMillis; errorCount = parser->getErrorCount(); } catch (const OutOfMemoryException&) { XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl; errorCount = 2; return 4; } catch (const XMLException& e) { XERCES_STD_QUALIFIER cerr << "\nError during parsing: \n" << StrX(e.getMessage()) << "\n" << XERCES_STD_QUALIFIER endl; errorCount = 1; return 4; } // Print out the stats that we collected and time taken if (!errorCount) { XERCES_STD_QUALIFIER cout << StrX(src.getSystemId()) << ": " << 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->setHandleMultipleImports (true); 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; }
// --------------------------------------------------------------------------- // 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); parser->setEntityResolver(&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; }
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 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; }
// --------------------------------------------------------------------------- // 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! :\n" << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl; return 1; } // Check command line and extract arguments. if (argC < 2) { usage(); XMLPlatformUtils::Terminate(); return 1; } // See if non validating dom parser configuration is requested. int parmInd; for (parmInd = 1; parmInd < argC; parmInd++) { // Break out on first parm not starting with a dash if (argV[parmInd][0] != '-') break; // Watch for special case help request if (!strcmp(argV[parmInd], "-?")) { usage(); XMLPlatformUtils::Terminate(); return 2; } else if (!strncmp(argV[parmInd], "-v=", 3) || !strncmp(argV[parmInd], "-V=", 3)) { const char* const parm = &argV[parmInd][3]; if (!strcmp(parm, "never")) 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; XMLPlatformUtils::Terminate(); return 2; } } else if (!strcmp(argV[parmInd], "-n") || !strcmp(argV[parmInd], "-N")) { doNamespaces = true; } else if (!strcmp(argV[parmInd], "-s") || !strcmp(argV[parmInd], "-S")) { doSchema = true; } else if (!strcmp(argV[parmInd], "-f") || !strcmp(argV[parmInd], "-F")) { schemaFullChecking = true; } else { XERCES_STD_QUALIFIER cerr << "Unknown option '" << argV[parmInd] << "', ignoring it\n" << XERCES_STD_QUALIFIER endl; } } // // And now we have to have only one parameter left and it must be // the file name. // if (parmInd + 1 != argC) { usage(); XMLPlatformUtils::Terminate(); return 1; } xmlFile = argV[parmInd]; int errorCount = 0; // // Create a SAX parser object to use and create our SAX event handlers // and plug them in. // SAXParser* parser = new SAXParser; PParseHandlers handler; parser->setDocumentHandler(&handler); parser->setErrorHandler(&handler); parser->setValidationScheme(valScheme); parser->setDoNamespaces(doNamespaces); parser->setDoSchema(doSchema); parser->setValidationSchemaFullChecking(schemaFullChecking); // // Ok, lets do the progressive parse loop. On each time around the // loop, we look and see if the handler has found what its looking // for. When it does, we fall out then. // unsigned long duration; int errorCode = 0; try { // Create a progressive scan token XMLPScanToken token; const unsigned long startMillis = XMLPlatformUtils::getCurrentMillis(); if (!parser->parseFirst(xmlFile, token)) { XERCES_STD_QUALIFIER cerr << "scanFirst() failed\n" << XERCES_STD_QUALIFIER endl; XMLPlatformUtils::Terminate(); return 1; } // // We started ok, so lets call scanNext() until we find what we want // or hit the end. // bool gotMore = true; while (gotMore && !parser->getErrorCount()) gotMore = parser->parseNext(token); const unsigned long endMillis = XMLPlatformUtils::getCurrentMillis(); duration = endMillis - startMillis; errorCount = parser->getErrorCount(); // // Reset the parser-> In this simple progrma, since we just exit // now, its not technically required. But, in programs which // would remain open, you should reset after a progressive parse // in case you broke out before the end of the file. This insures // that all opened files, sockets, etc... are closed. // parser->parseReset(token); } catch (const OutOfMemoryException&) { XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl; errorCode = 5; } catch (const XMLException& toCatch) { XERCES_STD_QUALIFIER cerr << "\nAn error occurred: '" << xmlFile << "'\n" << "Exception message is: \n" << StrX(toCatch.getMessage()) << "\n" << XERCES_STD_QUALIFIER endl; errorCode = 4; } if(errorCode) { XMLPlatformUtils::Terminate(); return errorCode; } 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; // And call the termination method XMLPlatformUtils::Terminate(); if (errorCount > 0) return 4; else return 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; }
// 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; }
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); }