XmlNode *ConfigCtx::parseFile(const char *configFilePath, const char *rootTag) { char achError[4096]; XmlTreeBuilder tb; XmlNode *pRoot = tb.parse(configFilePath, achError, 4095); if (pRoot == NULL) { LS_ERROR(this, "%s", achError); return NULL; } // basic validation if (strcmp(pRoot->getName(), rootTag) != 0) { LS_ERROR(this, "%s: root tag expected: <%s>, real root tag : <%s>!\n", configFilePath, rootTag, pRoot->getName()); delete pRoot; return NULL; } #ifdef TEST_OUTPUT_PLAIN_CONF char sPlainFile[512] = {0}; strcpy(sPlainFile, configFilePath); strcat(sPlainFile, ".txt"); // plainconf::testOutputConfigFile( pRoot, sPlainFile ); #endif return pRoot; }
void plainconf::addModuleWithParam(XmlNode *pCurNode, const char *moduleName, const char *param) { XmlNode *pModuleNode = NULL; XmlNodeList::const_iterator iter; const XmlNodeList *pModuleList = pCurNode->getChildren("module"); if (pModuleList) { for (iter = pModuleList->begin(); iter != pModuleList->end(); ++iter) { if (strcasecmp((*iter)->getChildValue("name", 1), moduleName) == 0) { pModuleNode = (*iter); break; } } } if (!pModuleNode) { pModuleNode = new XmlNode; //XmlNode *pParamNode = new XmlNode; const char *attr = NULL; pModuleNode->init("module", &attr); pModuleNode->setValue(moduleName, strlen(moduleName)); pCurNode->addChild(pModuleNode->getName(), pModuleNode); logToMem(LOG_LEVEL_INFO, "[%s:%s]addModuleWithParam ADD module %s", pCurNode->getName(), pCurNode->getValue(), moduleName); } appendModuleParam(pModuleNode, param); }
void plainconf::appendModuleParam(XmlNode *pModuleNode, const char *param) { XmlNode *pParamNode = pModuleNode->getChild("param"); if (pParamNode == NULL) { pParamNode = new XmlNode; const char *attr = NULL; pParamNode->init("param", &attr); pParamNode->setValue(param, strlen(param)); pModuleNode->addChild(pParamNode->getName(), pParamNode); } else { AutoStr2 totalValue = pParamNode->getValue(); totalValue.append("\n", 1); totalValue.append(param, strlen(param)); pParamNode->setValue(totalValue.c_str(), totalValue.len()); } logToMem(LOG_LEVEL_INFO, "[%s:%s] module [%s] add param [%s]", pModuleNode->getParent()->getName(), ((pModuleNode->getParent()->getValue()) ? pModuleNode->getParent()->getValue() : ""), pModuleNode->getValue(), param); }
/*** * We try to make log available even if errorlog is not setup. * So, at the beginning, we put the logs to StringList plainconf::errorLogList by call logToMem() * once flushErrorLog() is called, it means errorlog is setup, and this function will save all * the buffered logs to errorlog file. * Then if logToMem still be called, it should not access the stringlist anymore, * but just access the errorlog directly. */ void plainconf::logToMem(char errorLevel, const char *format, ...) { char buf[512]; sprintf(buf, "%c[PlainConf] ", errorLevel); int len = strlen(buf); if (gModuleList.size() > 0) { XmlNode *pCurNode = (XmlNode *)gModuleList.back(); sprintf(buf + len, "[%s:%s] ", pCurNode->getName(), ((pCurNode->getValue() == NULL) ? "" : pCurNode->getValue())); } len = strlen(buf); va_list ap; va_start(ap, format); int ret = vsnprintf(buf + len, 512 - len, format, ap); va_end(ap); if (!bErrorLogSetup) errorLogList.add(buf, ret + len); else { if (errorLevel == LOG_LEVEL_ERR) LS_ERROR(buf + 1); else LS_INFO(buf + 1); } }
XmlNode TinyXmlInterface::addNode(TiXmlNode* n) { if (!n) throw CasadiException("Error in TinyXmlInterface::addNode: Node is 0"); XmlNode ret; // Save name ret.setName(n->Value()); // Save attributes int type = n->Type(); if (type == TiXmlNode::TINYXML_ELEMENT) { if (n->ToElement()!=0) { for (TiXmlAttribute* pAttrib=n->ToElement()->FirstAttribute(); pAttrib; pAttrib=pAttrib->Next()) { ret.setAttribute(pAttrib->Name(), pAttrib->Value()); } } } else if (type == TiXmlNode::TINYXML_DOCUMENT) { // do nothing } else { throw CasadiException("TinyXmlInterface::addNode"); } // Count the number of children int num_children = 0; for (TiXmlNode* child = n->FirstChild(); child != 0; child= child->NextSibling()) { num_children++; } ret.children_.reserve(num_children); // add children int ch = 0; for (TiXmlNode* child = n->FirstChild(); child != 0; child= child->NextSibling(), ++ch) { int childtype = child->Type(); if (childtype == TiXmlNode::TINYXML_ELEMENT) { XmlNode newnode = addNode(child); ret.children_.push_back(newnode); ret.child_indices_[newnode.getName()] = ch; } else if (childtype == TiXmlNode::TINYXML_COMMENT) { ret.comment_ = child->Value(); } else if (childtype == TiXmlNode::TINYXML_TEXT) { ret.text_ = child->ToText()->Value(); } else if (childtype == TiXmlNode::TINYXML_DECLARATION) { cout << "Warning: Skipped TiXmlNode::TINYXML_DECLARATION" << endl; } else { throw CasadiException("Error in TinyXmlInterface::addNode: Unknown node type"); } } // Note: Return value optimization return ret; }
bool MameXmlReader::load(const char* buffer, const unsigned int size) { XmlNode node; assert(buffer); assert(size); if (m_reader.load(buffer, size)) { // Comprobamos si el primer nodo es "mame" node = m_reader.getRootElement(); if (node.getName() == "mame") { m_loaded = true; return true; } } return false; }
void plainconf::saveUnknownItems(const char *fileName, int lineNumber, XmlNode *pCurNode, const char *name, const char *value) { //if not inside a "module" and without a "::", treated as error if (strcasecmp(pCurNode->getName(), "module") != 0 && strstr(name, "::") == NULL) { logToMem(LOG_LEVEL_ERR, "Not support [%s %s] in file %s:%d", name, value, fileName, lineNumber); return ; } char newvalue[4096] = {0}; XmlNode *pParamNode = new XmlNode; const char *attr = NULL; pParamNode->init(UNKNOWN_KEYWORDS, &attr); strcpy(newvalue, name); strcat(newvalue, " "); strcat(newvalue, value); pParamNode->setValue(newvalue, strlen(newvalue)); pCurNode->addChild(pParamNode->getName(), pParamNode); }
/////////////////////////////////////////////////////////////////////////////////////////////////// //parse data schema from node //src data node //dst schema node bool XmlSchema::parseNodeStruct(XmlNode* dst, XmlNode* src) { assert(dst != NULL); assert(src != NULL); NodeIterator nodeIterator; AttributeIterator attriIterator; for (XmlAttribute* attribute = src->getFirstAttribute(attriIterator); attribute != NULL; attribute = src->getNextAttribute(attriIterator)) { XmlNode* structure = dst->findChild(attribute->getName()); if (structure == NULL) { //first time show up structure = dst->addChild(attribute->getName()); structure->addAttribute(ATTR_TYPE, guessType(attribute->getString())); structure->addAttribute(ATTR_ATTRIBUTE, T("true")); } } for (XmlNode* child = src->getFirstChild(nodeIterator); child != NULL; child = src->getNextChild(nodeIterator)) { if (child->getType() != ELEMENT) { continue; } XmlNode* structure = dst->findChild(child->getName()); if (structure == NULL) { //first time show up bool recursive = false; const XmlNode* parent = dst; while (parent != NULL) { if (Strcmp(parent->getName(), child->getName()) == 0) { recursive = true; break; } parent = parent->getParent(); } structure = dst->addChild(child->getName()); if (recursive) { structure->addAttribute(ATTR_RECURSIVE, T("true")); } else if (!child->hasChild() && !child->hasAttribute()) { //simple type, must have a type attribute structure->addAttribute(ATTR_TYPE, guessType(child->getString())); } } else if (structure->findAttribute(ATTR_ATTRIBUTE) != NULL) { //child and attribute can't have same name return false; } XmlAttribute* multiple = structure->findAttribute(ATTR_MULTIPLE); if (multiple == NULL || !multiple->getBool()) { NodeIterator iter; if (src->findFirstChild(child->getName(), iter) != NULL && src->findNextChild(child->getName(), iter) != NULL) { if (multiple == NULL) { multiple = structure->addAttribute(ATTR_MULTIPLE); } multiple->setBool(true); } } if (!structure->findAttribute(ATTR_RECURSIVE) && (child->hasChild() || child->hasAttribute())) { parseNodeStruct(structure, child); } } return true; }
void plainconf::parseLine(const char *fileName, int lineNumber, const char *sLine) { const int MAX_NAME_LENGTH = 4096; char name[MAX_NAME_LENGTH] = {0}; char value[MAX_NAME_LENGTH] = {0}; const char *attr = NULL; XmlNode *pNode = NULL; XmlNode *pCurNode = (XmlNode *)gModuleList.back(); const char *p = sLine; const char *pEnd = sLine + strlen(sLine); bool bNameSet = false; for (; p < pEnd; ++p) { //"{" is a beginning of a block only if it is the last char of a line if (*p == '{' && pEnd - p == 1) { if (strlen(name) > 0) { const char *pRealname = getRealName(name); if (pRealname) { pNode = new XmlNode; pNode->init(pRealname, &attr); //Remove space in the end of the value such as "module cache {", value will be "cache" removeSpace(value, 1); if (strlen(value) > 0) pNode->setValue(value, strlen(value)); pCurNode->addChild(pNode->getName(), pNode); gModuleList.push_back(pNode); pCurNode = pNode; clearNameAndValue(name, value); break; } else { logToMem(LOG_LEVEL_ERR, "parseline find block name [%s] is NOT keyword in %s:%d", name, fileName, lineNumber); break; } } else { logToMem(LOG_LEVEL_ERR, "parseline found '{' without a block name in %s:%d", fileName, lineNumber); break; } } else if (*p == '}' && p == sLine) { if (gModuleList.size() > 1) { gModuleList.pop_back(); clearNameAndValue(name, value); if (*(p + 1)) { ++p; trimWhiteSpace(&p); parseLine(fileName, lineNumber, p); break; } } else { logToMem(LOG_LEVEL_ERR, "parseline found more '}' in %s:%d", fileName, lineNumber); clearNameAndValue(name, value); break; } } else if ((*p == ' ' || *p == '\t') && value[0] == 0) { bNameSet = true; continue; } else { if (!bNameSet) strcatchr(name, *p, MAX_NAME_LENGTH); else strcatchr(value, *p, MAX_NAME_LENGTH); } } if (name[0] != 0) { const char *pRealname = getRealName(name); if (pRealname) { assert(pNode == NULL); pNode = new XmlNode; pNode->init(pRealname, &attr); if (strlen(value) > 0) pNode->setValue(value, strlen(value)); pCurNode->addChild(pNode->getName(), pNode); } else { //There is no special case in server level //if (memcmp(pCurNode->getName(), SERVER_ROOT_XML_NAME, sizeof(SERVER_ROOT_XML_NAME) - 1) != 0) saveUnknownItems(fileName, lineNumber, pCurNode, name, value); //else // logToMem(LOG_LEVEL_ERR, "%s Server level find unknown keyword [%s], ignored.", SERVER_ROOT_XML_NAME, name ); } } }