//----------------------------------------------------------------------
//
//----------------------------------------------------------------------
void LNFXManager::_analyzeXML( const char* xml, size_t size )
{
XML::Document xmlDoc;
xmlDoc.Parse( xml, size );
// まずは Technique → Pass と作成して、コンパイルする。この中で Variable も作る
XML::Element* xmlElement = xmlDoc.FirstChildElement();
while ( xmlElement != NULL )
{
// <Technique>
if ( strcmp( xmlElement->Name(), TechniqueElementName ) == 0 ) {
_analyzeXMLTechniqueElement( xmlElement );
}
xmlElement = xmlElement->NextSiblingElement();
}
// 次に、作成済みの Variable にアノテーションを割り振る
xmlElement = xmlDoc.FirstChildElement();
while ( xmlElement != NULL )
{
// <Variable>
if ( strcmp( xmlElement->Name(), VariableElementName ) == 0 ) {
_analyzeXMLVariableElement( xmlElement );
}
xmlElement = xmlElement->NextSiblingElement();
}
}
/***************************************************************
* Function: CodeParser::parseCellArrayExpr()
* Purpose : Parse the XML code of a cell array expression
* Initial : Maxime Chevalier-Boisvert on February 23, 2009
****************************************************************
Revisions and bug fixes:
*/
Expression* CodeParser::parseCellArrayExpr(const XML::Element* pElement)
{
// Declare a vector to store the rows
CellArrayExpr::RowVector rowVector;
// For each child element
for (size_t i = 0; i < pElement->getNumChildren(); ++i)
{
// Declare a row to store elements
CellArrayExpr::Row row;
// Get a reference to this child element
XML::Element* pRowElem = pElement->getChildElement(i);
// If this is not a row element, throw an exception
if (pRowElem->getName() != "Row")
throw XML::ParseError("Invalid element found in cell array expression", pRowElem->getTextPos());
// For each expression in this row
for (size_t j = 0; j < pRowElem->getNumChildren(); ++j)
{
// Parse the expression and add it to the row
row.push_back(parseExpression(pRowElem->getChildElement(j)));
}
// Add the row to the vector
rowVector.push_back(row);
}
// Create and return the cell array expression
return new CellArrayExpr(rowVector);
}
/*!
* Unsafe load
*
* \throws ExceptionProtocol the content of the vector is not serializable
* \throws ExceptionInvalidArgument not a Vector
* \throws ExceptionRuntime impossible to read an XML element
* \throws ExceptionNotFound unknown type
*
* \param[in] el the element to load
*/
void Vector::Deserialize(xml::Element &el)
{
if (el.GetValue() != getClassName())
{
throw ExceptionInvalidArgument(StringUTF8("void Vector::Deserialize(xml::Element &el): ") +
_("Wrong XML element."));
}
std::multimap<int, SObject> xmllist;
for (xml::Element te = el.BeginElement(); te != el.EndElement(); ++te)
{
SObject d(nullptr);
try
{
d = DataFactory::CreateData(te);
}
catch (crn::Exception &)
{ // XXX throw?
CRNWarning(String(U"void Vector::Deserialize"
U"(xml::Element &el): ") + String(_("Unknown XML element: ")) +
te.GetValue());
}
if (!d)
continue;
int index;
try { index = te.GetAttribute<int>("vector_index", false); } catch (...) { index = int(xmllist.size()); }
xmllist.insert(std::make_pair(index, d));
}
Clear();
for (auto & elem : xmllist)
data.push_back(elem.second);
ShrinkToFit();
}
/***************************************************************
* Function: CodeParser::parseStmtList()
* Purpose : Parse the XML code of a statement list
* Initial : Maxime Chevalier-Boisvert on November 7, 2008
****************************************************************
Revisions and bug fixes:
*/
StmtSequence* CodeParser::parseStmtList(const XML::Element* pElement)
{
// Create a statement vector to store the statements
StmtSequence::StmtVector stmtVector;
// For each child element
for (size_t i = 0; i < pElement->getNumChildren(); ++i)
{
// Get this child element
XML::Element* pChildElement = pElement->getChildElement(i);
// If this is a variable declaration
if (pChildElement->getName() == "VariableDecl")
{
// Ignore for now
continue;
}
// Parse this statement
Statement* pStmt = parseStatement(pChildElement);
// Add the statement to the vector
stmtVector.push_back(pStmt);
}
// Return a new sequence statement
return new StmtSequence(stmtVector);
}
//----------------------------------------------------------------------
//
//----------------------------------------------------------------------
void LNFXManager::_analyzeXMLVariableElement( XML::Element* xmlElement )
{
// 属性
const char* attrName = xmlElement->Attribute( NameAttributeName );
const char* attrSemantic = xmlElement->Attribute( SemanticAttributeName );
const bool attrShared = xmlElement->BoolAttribute( SharedAttributeName );
const char* attrTexture = xmlElement->Attribute(TextureAttributeName);
LN_THROW_InvalidFormat(attrName);
// 適用試行
IAnnotatedObject* var = mBuilder->OnTrySetVariableParam( attrName, attrSemantic, attrShared, attrTexture );
if ( var != NULL )
{
// 子要素
XML::Element* xmlChild = xmlElement->FirstChildElement();
while ( xmlChild != NULL )
{
// <Annotation>
if ( strcmp( xmlChild->Name(), AnnotationElementName ) == 0 ) {
_analyzeXMLAnnotationElement( xmlChild, var );
}
xmlChild = xmlChild->NextSiblingElement();
}
}
}
/*!
* Initializes the object from an XML element. Unsafe.
*
* \throws ExceptionInvalidArgument not a StringUTF8
* \throws ExceptionDomain no CDATA found
*
* \param[in] el the XML element to read
*/
void StringUTF8::Deserialize(xml::Element &el)
{
if (el.GetValue() != "StringUTF8")
{
throw ExceptionInvalidArgument(StringUTF8("void StringUTF8::deserialize(xml::Element &el): ") +
_("Wrong XML element."));
}
xml::Node c(el.GetFirstChild());
if (!c)
return; // no content
xml::Text t(c.AsText()); // may throw
*this = t.GetValue();
ShrinkToFit();
}
/***************************************************************
* Function: CodeParser::parseScript()
* Purpose : Parse the XML code of a script
* Initial : Maxime Chevalier-Boisvert on November 4, 2008
****************************************************************
Revisions and bug fixes:
*/
IIRNode* CodeParser::parseScript(const XML::Element* pElement)
{
// Declare a pointer for the sequence statement
StmtSequence* pSequenceStmt = NULL;
// For each child element
for (size_t i = 0; i < pElement->getNumChildren(); ++i)
{
// Get a pointer to this element
XML::Element* pFuncElement = pElement->getChildElement(i);
// If this is a symbol table
if (pFuncElement->getName() == "Symboltable")
{
// Ignore for now
}
// If this is the statement list
else if (pFuncElement->getName() == "StmtList")
{
// If the statement list was already encountered, throw an exception
if (pSequenceStmt != NULL)
throw XML::ParseError("Duplicate statement list", pElement->getTextPos());
// Parse the statement list
pSequenceStmt = parseStmtList(pFuncElement);
}
// Otherwise
else
{
// This is an invalid element type, throw an exception
throw XML::ParseError("Invalid element type in script: \"" + pFuncElement->getName() + "\"", pFuncElement->getTextPos());
}
}
// If the statement list is missing, throw an exception
if (pSequenceStmt == NULL)
throw XML::ParseError("Missing statement list", pElement->getTextPos());
// Create and return a new program function object
return new ProgFunction(
"",
ProgFunction::ParamVector(),
ProgFunction::ParamVector(),
ProgFunction::FuncVector(),
pSequenceStmt,
true
);
}
/***************************************************************
* Function: CodeParser::parseLambdaExpr()
* Purpose : Parse the XML code of a lambda expression
* Initial : Maxime Chevalier-Boisvert on February 25, 2009
****************************************************************
Revisions and bug fixes:
*/
Expression* CodeParser::parseLambdaExpr(const XML::Element* pElement)
{
// Create a vector for the input parameters
LambdaExpr::ParamVector inParams;
// Declare a pointer for the body expression
Expression* pBodyExpr = NULL;
// For each child element
for (size_t i = 0; i < pElement->getNumChildren(); ++i)
{
// Get a pointer to this child element
XML::Element* pChildElem = pElement->getChildElement(i);
// If this is a symbol
if (pChildElem->getName() == "Name")
{
// Parse the symbol and add it to the input parameters
inParams.push_back(SymbolExpr::getSymbol(pChildElem->getStringAttrib("nameId")));
}
// Otherwise, it must be the body expression
else
{
// If the body expression was already parsed
if (pBodyExpr != NULL)
{
// Throw an exception
throw XML::ParseError("Duplicate body expression", pChildElem->getTextPos());
}
// Parse the body expression
pBodyExpr = parseExpression(pChildElem);
}
}
// If no body expression was found
if (pBodyExpr == NULL)
{
// Throw an exception
throw XML::ParseError("No body expression found", pElement->getTextPos());
}
// Create and return the new lambda expression
return new LambdaExpr(
inParams,
pBodyExpr
);
}
/*!
* Internal. Initializes some internal data from an XML element.
*
* \param[in] el the element that contains the serialized object
*/
void Savable::deserialize_internal_data(xml::Element &el)
{
// read name if any
const StringUTF8 nam = el.GetAttribute<StringUTF8>("name");
xml::Element udel(el.GetFirstChildElement("Map"));
while (udel)
{ // look for a map containing user data
const StringUTF8 role = udel.GetAttribute<StringUTF8>("role");
// check role
if (role == USERDATA_NAME)
{ // found the user data
if (!user_data)
{ // create the object if needed
user_data.reset(new Map());
}
else
{ // clear the current user data if needed
user_data->Clear();
}
// read the user data and quit the method
user_data->Deserialize(udel);
return;
}
udel = udel.GetNextSiblingElement("Map");
}
}
void PostgresProvider::Init(const xml::Element& rConfig)
{
// initialize connection
const xml::Element& rConnection = rConfig.GetChildElementByName("connection");
m_pImpl->m_sHost = rConnection.GetChildElementByName("host").GetTextValue();
m_pImpl->m_sPort = rConnection.GetChildElementByName("port").GetTextValue();
m_pImpl->m_sDataBase = rConnection.GetChildElementByName("db").GetTextValue();
m_pImpl->m_sLogin = rConnection.GetChildElementByName("login").GetTextValue();
m_pImpl->m_sPassword = rConnection.GetChildElementByName("password").GetTextValue();
STAFF_ASSERT(!m_pImpl->m_pConn, "Already connected");
m_pImpl->m_pConn = PQsetdbLogin(m_pImpl->m_sHost.c_str(), m_pImpl->m_sPort.c_str(), "", "",
m_pImpl->m_sDataBase.c_str(), m_pImpl->m_sLogin.c_str(),
m_pImpl->m_sPassword.c_str());
STAFF_ASSERT(m_pImpl->m_pConn, "Failed to set db login");
if (PQstatus(m_pImpl->m_pConn) != CONNECTION_OK)
{
std::string sError = std::string("Failed to login: "******"UTF8");
STAFF_ASSERT(nResult == 0, std::string("error setting encoding: ") + PQerrorMessage(m_pImpl->m_pConn));
}
/*!
* Dumps the object to an XML element. Unsafe.
*/
xml::Element FeatureExtractorProjection::serialize(xml::Element &parent) const
{
xml::Element el(parent.PushBackElement(GetClassName()));
el.SetAttribute("directions", int(dirs));
el.SetAttribute("size", size);
el.SetAttribute("maxval", maxval);
return el;
}
/*!
* Internal. Dumps some internal data to an XML element.
*
* \param[in] el the element that contains the serialized object
*/
void Savable::serialize_internal_data(xml::Element &el) const
{
el.SetAttribute("name", name.CStr());
if (user_data)
{
xml::Element udel = user_data->Serialize(el);
udel.SetAttribute("role", USERDATA_NAME);
}
}
static void showElement(Xml::Element elt, const String& indent="") {
cout << indent << "ELEMENT WITH TAG '" << elt.getElementTag() << "':\n";
// Show attributes
Xml::attribute_iterator ap = elt.attribute_begin();
for (; ap != elt.attribute_end(); ++ap)
cout << indent << " ATTR '" << ap->getName() << "'='"
<< ap->getValue() << "'\n";
// Show all contents
Xml::node_iterator p = elt.node_begin();
for (; p != elt.node_end(); ++p) {
cout << indent << p->getNodeTypeAsString() << endl;
if (p->getNodeType() == Xml::ElementNode)
showElement(Xml::Element::getAs(*p), indent + " ");
}
cout << indent << "END OF ELEMENT.\n";
}
void writeCppNs(xml::Element& node, const std::string& ns)
{
const std::string& realNs = (ns.substr(0, 2) == "::") ? ns.substr(2) : ns;
std::string startNs;
std::string endNs;
std::string::size_type pos = 0;
std::string::size_type prevPos = 0;
while((pos = realNs.find("::", pos)) != std::string::npos) {
startNs += "namespace " + realNs.substr(prevPos, pos - prevPos) + " {\n";
endNs += "}\n";
pos += 2;
prevPos = pos;
}
node.createElement("startCppNs", startNs);
node.createElement("endCppNs", endNs);
}
//----------------------------------------------------------------------
//
//----------------------------------------------------------------------
void LNFXManager::_analyzeXMLPassElement( XML::Element* xmlElement, IAnnotatedObject* parentTech )
{
// 属性
const char* attrName = xmlElement->Attribute(NameAttributeName);
LN_THROW_InvalidFormat(attrName);
IAnnotatedObject* pass = mBuilder->OnCreatePass( parentTech, attrName );
// 子要素
XML::Element* xmlChild = xmlElement->FirstChildElement();
while ( xmlChild != NULL )
{
// <VertexShader>
if ( strcmp( xmlChild->Name(), VertexShaderElementName ) == 0 ) {
attrName = xmlChild->Attribute( EntryPointAttributeName );
GLSLCode* code = _findShaderCode(attrName);
LN_THROW_InvalidFormat(code);
mBuilder->OnCreateVertexShader( pass, code->Code.c_str(), code->Code.size() );
}
// <PixelShader>
else if ( strcmp( xmlChild->Name(), PixelShaderElementName ) == 0 ) {
attrName = xmlChild->Attribute( EntryPointAttributeName );
GLSLCode* code = _findShaderCode(attrName);
LN_THROW_InvalidFormat(code);
mBuilder->OnCreatePixelShader( pass, code->Code.c_str(), code->Code.size() );
}
// <RenderState>
else if ( strcmp( xmlChild->Name(), RenderStateElementName ) == 0 ) {
attrName = xmlChild->Attribute(NameAttributeName);
LN_THROW_InvalidFormat(attrName);
const char* value = xmlChild->Attribute( ValueAttributeName );
mBuilder->OnSetRenderState( pass, attrName, value );
}
// <Annotation>
else if ( strcmp( xmlChild->Name(), AnnotationElementName ) == 0 ) {
_analyzeXMLAnnotationElement( xmlChild, pass );
}
xmlChild = xmlChild->NextSiblingElement();
}
// link
mBuilder->OnEndPass( pass );
}
/*!
* Unsafe save
* \throws ExceptionProtocol the content of the vector is not serializable
*
* \param[in] parent the parent element to which we will add the new element
* \return The newly created element, nullptr if failed.
*/
xml::Element Vector::Serialize(xml::Element &parent) const
{
xml::Element el(parent.PushBackElement(getClassName()));
for (size_t tmp = 0; tmp < data.size(); tmp++)
{
xml::Element item = crn::Serialize(*data[tmp], el);
item.SetAttribute("vector_index", int(tmp));
}
return el;
}
/*!
* Initializes the object from an XML element. Unsafe.
*
* \throws ExceptionInvalidArgument not a FeatureExtractorProjection
* \throws ExceptionNotFound attribute not found
* \throws ExceptionDomain wrong attribute
*/
void FeatureExtractorProjection::deserialize(xml::Element &el)
{
if (el.GetName() != GetClassName())
{
throw ExceptionInvalidArgument(StringUTF8("bool FeatureExtractorProjection::deserialize("
"xml::Element &el): ") + _("Wrong XML element."));
}
int d = el.GetAttribute<int>("direction", false); // may throw
int s = el.GetAttribute<int>("size", false); // may throw
int m = el.GetAttribute<int>("maxval", false); // may throw
dirs = Orientation(d);
size = s;
maxval = m;
}
/*!
* Creates and initializes a CRNData from an XML element
*
* \throws ExceptionInvalidArgument null XML element
* \throws ExceptionRuntime impossible to read the XML element
* \throws ExceptionNotFound unknown type
*
* \param[in] el the XML element to use for initialization
* \return a pointer to the newly created object, or nullptr if failed
*/
UObject DataFactory::CreateData(xml::Element &el)
{
if (!el)
{
throw ExceptionInvalidArgument(StringUTF8("SObject DataFactory::CreateData(xml::Element &el): ") +
_("Null XML element."));
}
const StringUTF8 typ = el.GetValue();
if (typ.IsEmpty())
{
throw ExceptionRuntime(StringUTF8("SObject DataFactory::CreateData(xml::Element &el): ") + _("Cannot read element."));
}
return getInstance().createObject(typ, el); // may throw
}
//----------------------------------------------------------------------
//
//----------------------------------------------------------------------
void LNFXManager::_analyzeXMLTechniqueElement( XML::Element* xmlElement )
{
// 属性
const char* attrName = xmlElement->Attribute( NameAttributeName );
LN_THROW_InvalidFormat(attrName);
IAnnotatedObject* tech = mBuilder->OnCreateTechnique( attrName );
// 子要素
XML::Element* xmlChild = xmlElement->FirstChildElement();
while ( xmlChild != NULL )
{
// <Pass>
if ( strcmp( xmlChild->Name(), PassElementName ) == 0 ) {
_analyzeXMLPassElement( xmlChild, tech );
}
// <Annotation>
else if ( strcmp( xmlChild->Name(), AnnotationElementName ) == 0 ) {
_analyzeXMLAnnotationElement( xmlChild, tech );
}
xmlChild = xmlChild->NextSiblingElement();
}
}
bool TextureAtlas::load()
{
if (mLoaded)
{
return true;
}
XML::Document xml(mPath);
if (!xml.isValid())
{
return false;
}
XML::Element e = xml.getElement("atlas");
std::string texturePath = e.attribute("texture");
GL_TextureManager::get().loadTexture(texturePath);
mTexture = GL_TextureManager::get().acquireTexture(texturePath);
for (e = e.first(); e.isValid(); e = e.next())
{
std::string key = e.name();
if (key.compare("image") == 0)
{
ImageRect imageRect;
e.attribute("x", imageRect.x);
e.attribute("y", imageRect.y);
e.attribute("w", imageRect.w);
e.attribute("h", imageRect.h);
mImageMap[e.attribute("name")] = imageRect;
}
}
mLoaded = true;
return true;
}
/***************************************************************
* Function: CodeParser::parseAssignStmt()
* Purpose : Parse the XML code of an assignment statement
* Initial : Maxime Chevalier-Boisvert on November 5, 2008
****************************************************************
Revisions and bug fixes:
*/
Statement* CodeParser::parseAssignStmt(const XML::Element* pElement)
{
// Get the element corresponding to the left-expression
XML::Element* pLeftElem = pElement->getChildElement(0);
// Create a vector to store the left expressions
AssignStmt::ExprVector leftExprs;
// If the left expression is a matrix expression
if (pLeftElem->getName() == "MatrixExpr")
{
// If the number of rows is not 1, throw an exception
if (pLeftElem->getNumChildren() != 1)
throw XML::ParseError("invalid matrix expression on assignment lhs");
// Get the row element
XML::Element* pRowElem = pLeftElem->getChildElement(0);
// For each left expression element
for (size_t i = 0; i < pRowElem->getNumChildren(); ++i)
{
// Get the child element for this expression
XML::Element* pExprElem = pRowElem->getChildElement(i);
// Parse this left-expression
leftExprs.push_back(parseExpression(pExprElem));
}
}
else
{
// Parse the left expression directly
leftExprs.push_back(parseExpression(pLeftElem));
}
// Parse the right expression
Expression* pRightExpr = parseExpression(pElement->getChildElement(1));
// Get the output suppression flag
bool suppressOut = pElement->getBoolAttrib("outputSuppressed");
// Create and return the new assignment statement object
return new AssignStmt(leftExprs, pRightExpr, suppressOut);
}
void writeParam(xml::Element& elemParams, xml::Element& elemParam, const Param& param)
{
elemParam.createElement("name", param.name);
elemParam.createElement("description", param.description);
elemParam.createElement("details", param.details);
xml::Element& elemOptions = elemParam.createElement("options");
for (StringMap::const_iterator itOption = param.options.begin();
itOption != param.options.end(); ++itOption)
elemOptions.createElement(itOption->first, itOption->second);
elemParam.createElement("dataType") << param.dataType;
std::string value = elemParams.getValue();
if (!value.empty())
value += ", ";
dataTypeToString(value, param.dataType, true);
value += " " + param.name;
elemParams.setValue(value);
}
/* Handle reading older formats/Versioning */
void InverseDynamicsTool::updateFromXMLNode(SimTK::Xml::Element& aNode, int versionNumber)
{
int documentVersion = versionNumber;
if ( documentVersion < XMLDocument::getLatestVersion()){
std::string newFileName = getDocumentFileName();
if (documentVersion < 20300){
std::string origFilename = getDocumentFileName();
newFileName=IO::replaceSubstring(newFileName, ".xml", "_v23.xml");
cout << "Old version setup file encountered. Converting to new file "<< newFileName << endl;
SimTK::Xml::Document doc = SimTK::Xml::Document(origFilename);
doc.writeToFile(newFileName);
}
/*if (documentVersion < 20201) {
AnalyzeTool updateAnalyzeTool(newFileName, false);
updateAnalyzeTool.print(newFileName);
}*/
if (documentVersion < 20202){
// get filename and use SimTK::Xml to parse it
SimTK::Xml::Document doc = SimTK::Xml::Document(newFileName);
Xml::Element oldRoot = doc.getRootElement();
SimTK::Xml::Document newDoc;
string prefix = "";
if (oldRoot.getElementTag()=="AnalyzeTool"){
// Make OpenSimDocument node and copy root underneath it
newDoc.getRootElement().setElementTag("OpenSimDocument");
newDoc.getRootElement().setAttributeValue("Version", "20201");
prefix = oldRoot.getRequiredAttributeValueAs<string>("name");
// Move all children of root to toolNode
newDoc.getRootElement().insertNodeAfter(newDoc.getRootElement().node_end(), oldRoot.clone());
}
else
newDoc = doc;
Xml::Element root = newDoc.getRootElement();
if (root.getElementTag()=="OpenSimDocument"){
int curVersion = root.getRequiredAttributeValueAs<int>("Version");
if (curVersion <= 20201) root.setAttributeValue("Version", "20300");
Xml::element_iterator iterTool(root.element_begin("AnalyzeTool"));
iterTool->setElementTag("InverseDynamicsTool");
prefix = iterTool->getRequiredAttributeValueAs<string>("name");
// Remove children <output_precision>, <initial_time>, <final_time>
Xml::element_iterator initTimeIter(iterTool->element_begin("initial_time"));
double tool_initial_time = initTimeIter->getValueAs<double>();
if (initTimeIter->isValid()) iterTool->eraseNode(initTimeIter);
Xml::element_iterator finalTimeIter(iterTool->element_begin("final_time"));
double tool_final_time = finalTimeIter->getValueAs<double>();
if (finalTimeIter->isValid()) iterTool->eraseNode(finalTimeIter);
Xml::element_iterator precisionIter(iterTool->element_begin("output_precision"));
if (precisionIter->isValid()) iterTool->eraseNode(precisionIter);
bool use_model_forces=false;
// Handle missing or uninitialized values after parsing the old InverseDynamics "Analysis"
// Find Analyses underneath it AnalyzeTool
Xml::element_iterator iterAnalysisSet(iterTool->element_begin("AnalysisSet"));
Xml::element_iterator iterObjects(iterAnalysisSet->element_begin("objects"));
Xml::element_iterator iterAnalysis(iterObjects->element_begin("InverseDynamics"));
if (iterAnalysis!= iterObjects->element_end()){
// move children to top level
Xml::element_iterator p = iterAnalysis->element_begin();
//std::vector<std::string> deprectaed({"on", "in_degrees", "step_interval"});
for (; p!= iterAnalysis->element_end(); ++p) {
// skip <on>, <step_interval>, <in_degrees>
if (p->getElementTag()=="on" ||
p->getElementTag()=="in_degrees" ||
p->getElementTag()=="step_interval" ||
p->getElementTag()=="start_time" ||
p->getElementTag()=="end_time")
continue;
else if (p->getElementTag()=="use_model_force_set"){
String use_model_forcesStr = p->getValueAs<String>();
use_model_forces = (use_model_forcesStr=="true");
}
else
iterTool->insertNodeAfter( iterTool->node_end(), p->clone());
}
// insert elements for "forces_to_exclude" & "time_range"
std::ostringstream stream;
stream << tool_initial_time << " " << tool_final_time;
iterTool->insertNodeAfter( iterTool->node_end(), Xml::Element("time_range", stream.str()));
iterTool->insertNodeAfter( iterTool->node_end(), Xml::Element("forces_to_exclude", use_model_forces?"":"Muscles"));
iterTool->insertNodeAfter( iterTool->node_end(), Xml::Element("output_gen_force_file", prefix+"_InverseDynamics.sto"));
iterTool->insertNodeAfter( iterTool->node_end(), Xml::Element("coordinates_in_degrees", "true"));
iterTool->eraseNode(iterAnalysisSet);
}
newDoc.writeToFile(newFileName);
setDocument(new XMLDocument(newFileName));
aNode = updDocument()->getRootDataElement();
}
}
}
Object::updateFromXMLNode(aNode, versionNumber);
}
FundamentalType (XML::Element<C> const& e)
{
std::basic_stringstream<C> s;
s << e.value ();
s >> x_;
}
/*!
* Dumps the object to an XML element. Unsafe.
*
* \param[in] parent the parent element to which we will add the new element
* \return The newly created element, nullptr if failed.
*/
xml::Element StringUTF8::Serialize(xml::Element &parent) const
{
xml::Element el(parent.PushBackElement("StringUTF8"));
el.PushBackText(*this);
return el;
}
/*!
* Dumps the object to an XML element. Unsafe.
*
* \param[in] parent the parent element to which we will add the new element
* \return The newly created element, nullptr if failed.
*/
xml::Element String::Serialize(xml::Element &parent) const
{
xml::Element el(parent.PushBackElement("String"));
el.PushBackText(CStr());
return el;
}
/***************************************************************
* Function: CodeParser::parseScript()
* Purpose : Parse the XML root element
* Initial : Maxime Chevalier-Boisvert on November 18, 2008
****************************************************************
Revisions and bug fixes:
*/
CompUnits CodeParser::parseXMLRoot(const XML::Element* pTreeRoot)
{
// Create a list to store parsed functions
CompUnits functionList;
// If the root tag is not the compilation units, throw an exception
if (pTreeRoot->getName() != "CompilationUnits")
{
// TODO: implement error list parsing
std::cout << "XML tree: " << pTreeRoot->toString(true, 0) << std::endl;
throw XML::ParseError("Expected compilation units: \"" + pTreeRoot->getName() + "\"", pTreeRoot->getTextPos());
}
// If the verbose output flag is set
if (ConfigManager::s_verboseVar.getBoolValue() == true)
{
// Log the number of compilation units
std::cout << "Number of compilation units: " << pTreeRoot->getNumChildren() << std::endl;
}
// For each compilation unit
for (size_t i = 0; i < pTreeRoot->getNumChildren(); ++i)
{
// Get a pointer to this element
XML::Element* pUnitElement = pTreeRoot->getChildElement(i);
// If this is a function list
if (pUnitElement->getName() == "FunctionList")
{
// Get the list of functions
const std::vector<XML::Node*>& functions = pUnitElement->getChildren();
// For each function
for (std::vector<XML::Node*>::const_iterator itr = functions.begin(); itr != functions.end(); ++itr)
{
// If this is not an XML element, throw an exception
if ((*itr)->getType() != XML::Node::ELEMENT)
throw XML::ParseError("Unexpected XML node type in function list");
// Get a pointer to this element
XML::Element* pFuncElement = (XML::Element*)*itr;
// If this ia a function declaration
if (pFuncElement->getName() == "Function")
{
// Parse the function
IIRNode* pNewNode = parseFunction(pFuncElement);
// Add the function to the list
functionList.push_back(pNewNode);
}
// If this is a symbol table
else if (pFuncElement->getName() == "Symboltable")
{
// Ignore for now
}
// Otherwise
else
{
// This is an invalid element, throw an exception
throw XML::ParseError("Invalid element in function list: \"" + pFuncElement->getName() + "\"", pFuncElement->getTextPos());
}
}
}
// If this is a script
else if (pUnitElement->getName() == "Script")
{
// Parse the script
IIRNode* pNewNode = parseScript(pUnitElement);
// Add the function to the list
functionList.push_back(pNewNode);
}
// Otherwise
else
{
// This is an invalid element, throw an exception
throw XML::ParseError("Invalid element in compilation unit list: \"" + pUnitElement->getName() + "\"", pUnitElement->getTextPos());
}
}
// If the verbose output flag is set
if (ConfigManager::s_verboseVar.getBoolValue() == true)
{
// Output parsed IIR
std::cout << std::endl;
std::cout << "Constructed IIR:" << std::endl;
for (CompUnits::iterator itr = functionList.begin(); itr != functionList.end(); ++itr)
std::cout << ((*itr) == NULL? "NULL":(*itr)->toString()) << std::endl << std::endl;
std::cout << std::endl;
// Log that the parsing was successful
std::cout << "Parsing successful" << std::endl;
}
// Return the parsed function list
return functionList;
}
// Read a hex + alpha colour from xml //
Colour Loader::readColour(const XML::Element& e) const {
const char* s = e.attribute("colour", "ffffff");
Colour c = Loader::parseHex(s);
c.a = e.attribute("alpha", 1.0f);
return c;
}
Parser (XML::Element<C> const& e)
: e_ (e.dom_element ()->getChildNodes ()), ei_ (0),
a_ (e.dom_element ()->getAttributes ()), ai_ (0)
{
}
/***************************************************************
* Function: CodeParser::parseFunction()
* Purpose : Parse the XML code of a function
* Initial : Maxime Chevalier-Boisvert on November 3, 2008
****************************************************************
Revisions and bug fixes:
*/
ProgFunction* CodeParser::parseFunction(const XML::Element* pElement)
{
// Get the function name
std::string funcName = pElement->getStringAttrib("name");
// Declare a pointer for the sequence statement
StmtSequence* pSequenceStmt = NULL;
// Declare vectors for the input and output parameters
ProgFunction::ParamVector inParams;
ProgFunction::ParamVector outParams;
// Declare a vector for the nested function list
ProgFunction::FuncVector nestedFuncs;
// For each child element
for (size_t i = 0; i < pElement->getNumChildren(); ++i)
{
// Get a pointer to this element
XML::Element* pFuncElement = pElement->getChildElement(i);
// If this is a symbol table
if (pFuncElement->getName() == "Symboltable")
{
// Ignore for now
}
// If this is a parameter declaration list
else if (pFuncElement->getName() == "ParamDeclList")
{
// Ignore for now
}
// If this is an input parameter list
else if (pFuncElement->getName() == "InputParamList")
{
// For each child element
for (size_t i = 0; i < pFuncElement->getNumChildren(); ++i)
{
// Get the parameter name
const std::string& paramName = pFuncElement->getChildElement(i)->getStringAttrib("nameId");
// Add the parameter to the list
inParams.push_back(SymbolExpr::getSymbol(paramName));
}
}
// If this is an output parameter list
else if (pFuncElement->getName() == "OutputParamList")
{
// For each child element
for (size_t i = 0; i < pFuncElement->getNumChildren(); ++i)
{
// Get the parameter name
const std::string& paramName = pFuncElement->getChildElement(i)->getStringAttrib("nameId");
// Add the parameter to the list
outParams.push_back(SymbolExpr::getSymbol(paramName));
}
}
// If this is a nested function list
else if (pFuncElement->getName() == "NestedFunctionList")
{
// For each child element
for (size_t i = 0; i < pFuncElement->getNumChildren(); ++i)
{
// Parse this function declaration
ProgFunction* pFunction = parseFunction(pFuncElement->getChildElement(i));
// Add the nested function to the list
nestedFuncs.push_back(pFunction);
}
}
// If this is the statement list
else if (pFuncElement->getName() == "StmtList")
{
// If the statement list was already encountered, throw an exception
if (pSequenceStmt != NULL)
throw XML::ParseError("Duplicate statement list", pElement->getTextPos());
// Parse the statement list
pSequenceStmt = parseStmtList(pFuncElement);
}
// Otherwise
else
{
// This is an invalid element type, throw an exception
throw XML::ParseError("Invalid element type in script: \"" + pFuncElement->getName() + "\"", pFuncElement->getTextPos());
}
}
// If the statement list is missing, throw an exception
if (pSequenceStmt == NULL)
throw XML::ParseError("Missing statement list", pElement->getTextPos());
// Create a new program function object
ProgFunction* pNewFunc = new ProgFunction(
funcName,
inParams,
outParams,
nestedFuncs,
pSequenceStmt
);
// For each nested function
for (ProgFunction::FuncVector::iterator nestItr = nestedFuncs.begin(); nestItr != nestedFuncs.end(); ++nestItr)
{
// Set the parent pointer to the newly created function object
(*nestItr)->setParent(pNewFunc);
}
// Return the new program function object
return pNewFunc;
}
