sXml.cpp

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
/*
 Xml library based on TinyXml2
 First version : november 2012
 Author : Bastien Bourineau
*/
 
 
#include <scolPlugin.h>
#include "tinyxml2.h"
#include <string>
#include <set>
#include <scolMemoryHelper.hpp>
 
#ifdef _DEBUG
  //#define _SCOL_DEBUG_ 1
#endif
 
#ifdef SCOL_STATIC
extern cbmachine        ww;
extern mmachine mm;
#else
cbmachine       ww;
mmachine mm;
#endif
 
class SXml
{
public:
  SXml(tinyxml2::XMLDocument* doc)
  {
    xmlDoc = doc;
  }
 
  ~SXml()
  {
    SAFE_DELETE(xmlDoc);
    nodeslist.clear();
  }
 
  bool AddNode(tinyxml2::XMLNode* xmlNode)
  {
    std::pair<std::set<tinyxml2::XMLNode*>::iterator, bool> ret;
    ret = nodeslist.insert(xmlNode);
 
    return ret.second;
  }
 
  void RemoveNode(tinyxml2::XMLNode* xmlNode)
  {
    nodeslist.erase(xmlNode);
    
    // remove childs
    for(tinyxml2::XMLNode* child = xmlNode->FirstChild(); child != 0; child = child->NextSibling())
    {
      RemoveNode(child);
    }
  }
  
  bool NodeExist(tinyxml2::XMLNode* xmlNode)
  {
    std::set<tinyxml2::XMLNode*>::iterator it = nodeslist.find(xmlNode);
    if (it != nodeslist.end())
      return true;
 
    return false;
  }
  
  tinyxml2::XMLDocument* GetDocument()
  {
    return xmlDoc;
  }
 
  std::string ToString()
  {
    tinyxml2::XMLPrinter stream;
    xmlDoc->Print(&stream);
    return stream.CStr();
  }
 
private:
  tinyxml2::XMLDocument* xmlDoc;
  std::set<tinyxml2::XMLNode*> nodeslist;
};
 
int OBJTYPSXML;
 
inline tinyxml2::XMLNode* GetXmlNode(mmachine m, int ixmlnode)
{
  tinyxml2::XMLNode* xmlNode = MMgetPointer<tinyxml2::XMLNode*>(m, MTOP(MMfetch(m, MTOP(ixmlnode), 0)));
  SXml* sXmlDoc = MMgetPointer<SXml*>(m, MTOP(MMfetch(m, MTOP(ixmlnode), 1)));
  if (!xmlNode || !sXmlDoc)
  {
                return 0;
        }
 
  int objDoc = OBJfindTH(m, OBJTYPSXML, SCOL_PTR sXmlDoc);
  if (objDoc == NIL || (MMgetPointer<SXml*>(m, objDoc) == 0))
  {
                return 0;
        }
 
  if (sXmlDoc->NodeExist(xmlNode))
    return xmlNode;
  
  return 0;
}
 
int destroyXmlObj(mmachine m, SCOL_PTR_TYPE handsys, int objm)
{
  SXml* xmlDoc = MMgetPointer<SXml*>(m, MTOP(objm));
  SAFE_DELETE(xmlDoc);
 
  MMsetPointer<SXml*>(m, MTOP(objm), 0);
  return 0;
}
 
int _CreateXml(mmachine m)
{
        #ifdef  _SCOL_DEBUG_
                MMechostr(MSKDEBUG,"_CreateXml\n");
        #endif
 
  // channel test
        if (MMget(m, 0) == NIL)
    return 0;
 
  tinyxml2::XMLDocument* xmlDoc = new tinyxml2::XMLDocument();
  if (!xmlDoc)
  {
    MMechostr(MSKDEBUG, "_CreateXml : New XMLDocument failed.\n");
                MMset(m, 0, NIL);
                return 0;
        }
 
  SXml* sXmlDoc = new SXml(xmlDoc);
  if (!sXmlDoc)
  {
    MMechostr(MSKDEBUG, "_CreateXml : New SXml failed.\n");
    SAFE_DELETE(xmlDoc); 
                MMset(m, 0, NIL);
                return 0;
        }
 
        // Allocate a block in the stack for a table of ObjSXML object
  if ((MMpushPointer(m, sXmlDoc) != 0))
  {
    SAFE_DELETE(sXmlDoc);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
        // Create a new object
        return OBJcreate(m, OBJTYPSXML, SCOL_PTR sXmlDoc, NIL, 0);
}
 
int _OpenXml(mmachine m)
{
        #ifdef  _SCOL_DEBUG_
                MMechostr(MSKDEBUG,"_OpenXml\n");
        #endif
 
  int ifile = MMpull(m);
  if (MMget(m, 0) == NIL)
  {
    MMechostr(MSKDEBUG, "_OpenXml : Channel nil.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (ifile == NIL)
  {
    MMechostr(MSKDEBUG, "_OpenXml : File nil.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  std::string path = MMstartstr(m, MTOP(ifile));
 
  tinyxml2::XMLDocument* xmlDoc = new tinyxml2::XMLDocument();
  if (!xmlDoc)
  {
    MMechostr(MSKDEBUG, "_OpenXml : New XMLDocument failed.\n");
                MMset(m, 0, NIL);
                return 0;
        }
 
  if(xmlDoc->LoadFile(path.c_str()) != tinyxml2::XML_SUCCESS)
  {
    MMechostr(MSKDEBUG, "_OpenXml : load of %s failed\n", path.c_str());
    // this crash //MMechostr(MSKDEBUG, "on : %s\n", xmlDoc->GetErrorStr1());
                SAFE_DELETE(xmlDoc); 
                MMset(m, 0, NIL);
    return 0;
  }
 
  SXml* sXmlDoc = new SXml(xmlDoc);
  if (!sXmlDoc)
  {
    MMechostr(MSKDEBUG, "_OpenXml : New SXml failed.\n");
    SAFE_DELETE(xmlDoc); 
                MMset(m, 0, NIL);
                return 0;
        }
 
        // Allocate a block in the stack for a table of ObjSXML objects
  if ((MMpushPointer(m, sXmlDoc) != 0))
  {
    SAFE_DELETE(sXmlDoc);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
        // Create a new object
        return OBJcreate(m, OBJTYPSXML, SCOL_PTR sXmlDoc, NIL, 0);
}
 
int _OpenXmlS(mmachine m)
{
        #ifdef  _SCOL_DEBUG_
                MMechostr(MSKDEBUG,"_OpenXmlS\n");
        #endif
 
  int icont = MMpull(m);
  if ((MMget(m, 0) == NIL) || (icont == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  std::string content = MMstartstr(m, MTOP(icont));
 
  tinyxml2::XMLDocument* xmlDoc = new tinyxml2::XMLDocument();
  if (!xmlDoc)
  {
    MMechostr(MSKDEBUG, "_OpenXmlS : New XMLDocument failed.\n");
                MMset(m, 0, NIL);
                return 0;
        }
 
  if(xmlDoc->Parse(content.c_str()) != tinyxml2::XML_NO_ERROR)
  {
    MMechostr(MSKDEBUG, "_OpenXmlS : load of content failed\n");
                SAFE_DELETE(xmlDoc); 
                MMset(m, 0, NIL);
    return 0;
  }
 
  SXml* sXmlDoc = new SXml(xmlDoc);
  if (!sXmlDoc)
  {
    MMechostr(MSKDEBUG, "_OpenXmlS : New SXml failed.\n");
    SAFE_DELETE(xmlDoc); 
                MMset(m, 0, NIL);
                return 0;
        }
 
        // Allocate a block in the stack for a table of ObjSXML objects
  if ((MMpushPointer(m, sXmlDoc) != 0))
  {
    SAFE_DELETE(sXmlDoc);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
        // Create a new object
        return OBJcreate(m, OBJTYPSXML, SCOL_PTR sXmlDoc, NIL, 0);
}
 
int _SaveXml(mmachine m)
{
        #ifdef  _SCOL_DEBUG_
                MMechostr(MSKDEBUG,"_SaveXml\n");
        #endif
 
  int ifile = MMpull(m);
  int ixml = MMpull(m);
  if ((ixml == NIL) || (ifile == NIL))
  {
    MMechostr(MSKDEBUG, "_SaveXml : param nil.\n");
    MMpush(m, NIL);
    return 0;
  }
  std::string path = MMstartstr(m, MTOP(ifile));
 
  SXml* sXmlDoc = MMgetPointer<SXml*>(m, MTOP(ixml));
  if (!sXmlDoc)
  {
    MMechostr(MSKDEBUG, "_SaveXml : bad ObjSXML object.\n");
                MMpush(m, NIL);
                return 0;
        }
  
  if(sXmlDoc->GetDocument()->SaveFile(path.c_str()) != tinyxml2::XML_NO_ERROR)
  {
    MMechostr(MSKDEBUG, "_SaveXml : error on save file.\n");
                MMpush(m, NIL);
                return 0;
  }
 
  MMpush(m, ITOM(1));
        return 0;
}
 
int _DestroyXml(mmachine m)
{
#ifdef  _SCOL_DEBUG_
MMechostr(MSKDEBUG, "_DestroyXml\n");
#endif
 
  int mlTab = MMget(m, 0);
  if (mlTab == NIL)
  {
    MMechostr(MSKDEBUG, "_DestroyXml : object NIL");
    MMset(m, 0, NIL);
    return 0;
  }
 
  OBJdelTM(m, OBJTYPSXML, mlTab);       
 
        MMset(m, 0, ITOM(0));
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
        return 0;
}
 
int _GetXmlRootNodes(mmachine m)
{
        #ifdef  _SCOL_DEBUG_
                MMechostr(MSKDEBUG,"_GetXmlRootNodes\n");
        #endif
 
  int ixml = MMpull(m);
  if (ixml == NIL)
  {
    MMpush(m, NIL);
    return 0;
  }
  
  SXml* sXmlDoc = MMgetPointer<SXml*>(m, MTOP(ixml));
  if (!sXmlDoc)
  {
    MMechostr(MSKDEBUG, "_GetXmlRootNodes : bad ObjSXML object.\n");
                MMpush(m, NIL);
                return 0;
        }
 
  int k = 0;
  unsigned int count = 0;
  tinyxml2::XMLNode* child = 0;
 
  // get the node list
  for(child = sXmlDoc->GetDocument()->FirstChild(); child != 0; child = child->NextSibling())
  {
    //verify if the node is not a text or other
    tinyxml2::XMLElement* xmlElem = child->ToElement();
    if (!xmlElem)
      continue;
 
    sXmlDoc->AddNode(child);
 
    if ((MMpushPointer(m, child) != 0))
      return MERRMEM;
 
    if ((MMpushPointer(m, sXmlDoc) != 0))
      return MERRMEM;
 
    MMpush(m, 2*2);
    MBdeftab(m);
 
    count++;
  }
 
  if (MMpush(m, NIL))
    return MERRMEM;
 
        for(unsigned int j = 0; j < count; j++)
        {
                if (MMpush(m, 2*2))
      return MERRMEM;
                if ((k = MBdeftab(m)))
      return k;
        }
 
  return 0;
}
 
int _GetXmlNodeChilds(mmachine m)
{
        #ifdef  _SCOL_DEBUG_
                MMechostr(MSKDEBUG,"_GetXmlNodeChilds\n");
        #endif
 
  int ixmlnode = MMpull(m);
  if (ixmlnode == NIL)
  {
    MMpush(m, NIL);
    return 0;
  }
  
  tinyxml2::XMLNode* xmlNode = GetXmlNode(m, ixmlnode);
  if (!xmlNode)
  {
    MMechostr(MSKDEBUG, "_GetXmlNodeChilds : bad ObjSXMLNode object.\n");
                MMpush(m, NIL);
                return 0;
        }
 
  SXml* sXmlDoc = MMgetPointer<SXml*>(m, MTOP(MMfetch(m, MTOP(ixmlnode), 1)));
  if (!sXmlDoc)
  {
    MMechostr(MSKDEBUG, "_GetXmlNodeChilds : bad ObjSXMLNode object.\n");
                MMpush(m, NIL);
                return 0;
        }
 
  int k = 0;
  unsigned int count = 0;
  tinyxml2::XMLNode* child = 0;
 
  // get the node list
  for(child = xmlNode->FirstChild(); child != 0; child = child->NextSibling())
  {
    //verify if the node is not a text or other
    tinyxml2::XMLElement* xmlElem = child->ToElement();
    if (!xmlElem)
      continue;
 
    sXmlDoc->AddNode(child);
 
    if ((MMpushPointer(m, child) != 0))
      return MERRMEM;
 
    if ((MMpushPointer(m, sXmlDoc) != 0))
      return MERRMEM;
 
    MMpush(m, 2 * 2);
    MBdeftab(m);
 
    count++;
  }
 
  if (MMpush(m, NIL))
    return MERRMEM;
 
        for(unsigned int j = 0; j < count; j++)
        {
                if (MMpush(m, 2*2))
      return MERRMEM;
                if (k = MBdeftab(m))
      return k;
        }
 
  return 0;
}
 
int _GetXmlNodeValue(mmachine m)
{
        #ifdef  _SCOL_DEBUG_
                MMechostr(MSKDEBUG,"_GetXmlNodeValue\n");
        #endif
 
  int ixmlnode = MMpull(m);
  if (ixmlnode == NIL)
  {
    MMpush(m, NIL);
    return 0;
  }
  
  tinyxml2::XMLNode* xmlNode = GetXmlNode(m, ixmlnode);
  if (!xmlNode)
  {
    MMechostr(MSKDEBUG, "_GetXmlNodeValue : bad ObjSXMLNode object.\n");
                MMpush(m, NIL);
                return 0;
        }
 
  Mpushstrbloc(m, (char*)xmlNode->Value());
  return 0;
}
 
int _SetXmlNodeValue(mmachine m)
{
        #ifdef  _SCOL_DEBUG_
                MMechostr(MSKDEBUG,"_SetXmlNodeValue\n");
        #endif
 
  int ivalue = MMpull(m); 
  int ixmlnode = MMget(m, 0);
  if ((ixmlnode == NIL) || (ivalue == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
  std::string value = MMstartstr(m, MTOP(ivalue));
 
  tinyxml2::XMLNode* xmlNode = GetXmlNode(m, ixmlnode);
  if (!xmlNode)
  {
    MMechostr(MSKDEBUG, "_SetXmlNodeValue : bad ObjSXMLNode object.\n");
    MMset(m, 0, NIL);
    return 0;
        }
 
  xmlNode->SetValue(value.c_str());
 
  return 0;
}
 
int _GetXmlNodeContent(mmachine m)
{
        #ifdef  _SCOL_DEBUG_
                MMechostr(MSKDEBUG,"_GetXmlNodeValue\n");
        #endif
 
  int ixmlnode = MMpull(m);
  if (ixmlnode == NIL)
  {
    MMpush(m, NIL);
    return 0;
  }
  
  tinyxml2::XMLNode* xmlNode = GetXmlNode(m, ixmlnode);
  if (!xmlNode)
  {
    MMechostr(MSKDEBUG, "_GetXmlNodeContent : bad ObjSXMLNode object.\n");
                MMpush(m, NIL);
                return 0;
        }
 
  xmlNode = xmlNode->FirstChild();
  // no content
  if (!xmlNode)
  {
                MMpush(m, NIL);
                return 0;
        }
 
  tinyxml2::XMLText* xmlText = xmlNode->ToText();
  // not a content type
  if (!xmlText)
  {
                MMpush(m, NIL);
                return 0;
        }
 
  Mpushstrbloc(m, (char*)xmlText->Value());
  return 0;
}
 
int _SetXmlNodeContent(mmachine m)
{
        #ifdef  _SCOL_DEBUG_
                MMechostr(MSKDEBUG,"_SetXmlNodeContent\n");
        #endif
 
  int icontent = MMpull(m); 
  int ixmlnode = MMget(m, 0);
  if (ixmlnode == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  std::string content = (icontent == NIL) ? "" : MMstartstr(m, MTOP(icontent));
  
  tinyxml2::XMLNode* xmlNode = GetXmlNode(m, ixmlnode);
  if (!xmlNode)
  {
    MMechostr(MSKDEBUG, "_SetXmlNodeContent : bad ObjSXMLNode object.\n");
    MMset(m, 0, NIL);
    return 0;
        }
  
  tinyxml2::XMLNode* xmlContentNode = xmlNode->FirstChild();
  tinyxml2::XMLText* xmlText = 0;
  // no content
  if (!xmlContentNode)
  {
    if (content.empty())
    {
      return 0;
    }
    else
    {
      // add a node for content
      xmlText = xmlNode->GetDocument()->NewText("");
      xmlNode->InsertFirstChild(xmlText);
    }
        }
  else
  {
    xmlText = xmlContentNode->ToText();
  }
 
  // not a content type
  if (!xmlText)
  {
                MMset(m, 0, NIL);
                return 0;
        }
  else
  {
    //remove the node if empty text
    if (content.empty())
    {
      xmlNode->DeleteChild(xmlContentNode);
      return 0;
    }
  }
  
  xmlText->SetCData(true);
  xmlText->SetValue(content.c_str());
  return 0;
}
 
int _GetXmlNodeAttributes(mmachine m)
{
        #ifdef  _SCOL_DEBUG_
                MMechostr(MSKDEBUG,"_GetXmlNodeAttributes\n");
        #endif
 
  int ixmlnode = MMpull(m);
  if (ixmlnode == NIL)
  {
    MMpush(m, NIL);
    return 0;
  }
  
  tinyxml2::XMLNode* xmlNode = GetXmlNode(m, ixmlnode);
  if (!xmlNode)
  {
    MMechostr(MSKDEBUG, "_GetXmlNodeAttributes : bad ObjSXMLNode object.\n");
                MMpush(m, NIL);
                return 0;
        }
 
  tinyxml2::XMLElement* xmlElem = xmlNode->ToElement();
  if (!xmlElem)
  {
    MMechostr(MSKDEBUG, "_GetXmlNodeAttributes : Can not convert ObjXMLNode %s to Element.\n", xmlNode->Value());
                MMpush(m, NIL);
                return 0;
        }
 
  int k = 0;
  unsigned int count = 0;
  const tinyxml2::XMLAttribute* xmlAttrib = 0;
 
  // get the attributes list
  for(xmlAttrib = xmlElem->FirstAttribute(); xmlAttrib != 0; xmlAttrib = xmlAttrib->Next(), count++)
  {
    Mpushstrbloc(m, (char*)xmlAttrib->Name());
    Mpushstrbloc(m, (char*)xmlAttrib->Value());
    MMpush(m, 2*2);
    if (k = MBdeftab(m))
      return k;
  }
 
  if (MMpush(m, NIL))
    return MERRMEM;
 
        for(unsigned int j = 0; j < count; j++)
        {
                if (MMpush(m, 2*2))
      return MERRMEM;
                if (k = MBdeftab(m))
      return k;
        }
 
  return 0;
}
 
int _SetXmlNodeAttributes(mmachine m)
{
        #ifdef  _SCOL_DEBUG_
                MMechostr(MSKDEBUG,"_GetXmlNodeAttributes\n");
        #endif
 
  int iattributes = MMpull(m); 
  int ixmlnode = MMget(m, 0);
  if (ixmlnode == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  
  tinyxml2::XMLNode* xmlNode = GetXmlNode(m, ixmlnode);
  if (!xmlNode)
  {
    MMechostr(MSKDEBUG, "_SetXmlNodeAttributes : bad ObjSXMLNode object.\n");
                MMset(m, 0, NIL);
                return 0;
        }
  
  tinyxml2::XMLElement* xmlElem = xmlNode->ToElement();
  if (!xmlElem)
  {
    MMechostr(MSKDEBUG, "_SetXmlNodeAttributes : Can not convert ObjXMLNode %s to Element.\n", xmlNode->Value());
                MMset(m, 0, NIL);
                return 0;
        }
 
  const tinyxml2::XMLAttribute* xmlAttrib = 0;
 
  // remove all attributes
  // get the attributes list
  for(xmlAttrib = xmlElem->FirstAttribute(); xmlAttrib != 0; xmlAttrib = xmlAttrib->Next())
  {
    xmlElem->DeleteAttribute(xmlAttrib->Name());
  }
 
  int q = 0;
  int iname = 0;
  int ivalue = 0;
  while (iattributes != NIL)
        {
                q = MMfetch(m, MTOP(iattributes), 0);
                if (q != NIL)
    {
                        iname = MMfetch(m, MTOP(q), 0);
      ivalue = MMfetch(m, MTOP(q), 1);
      // bad parameter cancel
      if (iname == NIL)
        continue;
 
      std::string sname = MMstartstr(m, MTOP(iname));
      std::string svalue = "";
      if (ivalue != NIL)
        svalue = MMstartstr(m, MTOP(ivalue));
 
      xmlElem->SetAttribute(sname.c_str(), svalue.c_str());
    }
 
                iattributes = MMfetch(m, MTOP(iattributes), 1);
        };
  
  return 0;
}
 
int _RemoveXmlNode(mmachine m)
{
        #ifdef  _SCOL_DEBUG_
                MMechostr(MSKDEBUG,"_RemoveXmlNode\n");
        #endif
 
  int ixmlnode = MMpull(m);
  if (ixmlnode == NIL)
  {
    MMpush(m, NIL);
    return 0;
  }
  
  tinyxml2::XMLNode* xmlNode = GetXmlNode(m, ixmlnode);
  if (!xmlNode)
  {
    MMechostr(MSKDEBUG, "_RemoveXmlNode : bad ObjSXMLNode object.\n");
                MMpush(m, NIL);
                return 0;
        }
  
  SXml* sXmlDoc = MMgetPointer<SXml*>(m, MTOP(MMfetch(m, MTOP(ixmlnode), 1)));
  if (!sXmlDoc)
  {
    MMechostr(MSKDEBUG, "_RemoveXmlNode : bad ObjSXMLNode object.\n");
                MMpush(m, NIL);
                return 0;
        }
 
  sXmlDoc->RemoveNode(xmlNode);
  sXmlDoc->GetDocument()->DeleteNode(xmlNode);
  MMstore(m, MTOP(ixmlnode), 0, 0);
  MMstore(m, MTOP(ixmlnode), 1, 0);
 
  MMpush(m, ITOM(1));
  return 0;
}
 
int _AddXmlRootNode(mmachine m)
{
        #ifdef  _SCOL_DEBUG_
                MMechostr(MSKDEBUG,"_AddXmlRootNode\n");
        #endif
 
  int ivalue = MMpull(m); 
  int ixml = MMpull(m);
  if ((ixml == NIL) || (ivalue == NIL))
  {
    MMpush(m, NIL);
    return 0;
  }
  std::string value = MMstartstr(m, MTOP(ivalue));
  
  SXml* sXmlDoc = MMgetPointer<SXml*>(m, MTOP(ixml));
  if (!sXmlDoc)
  {
    MMechostr(MSKDEBUG, "_AddXmlRootNode : bad ObjSXML object.\n");
                MMpush(m, NIL);
                return 0;
        }
  
  tinyxml2::XMLNode* nXmlNode = sXmlDoc->GetDocument()->NewElement(value.c_str());
  sXmlDoc->GetDocument()->InsertEndChild(nXmlNode);
  sXmlDoc->AddNode(nXmlNode);
 
  if ((MMpushPointer(m, nXmlNode) != 0))
    return MERRMEM;
 
  if ((MMpushPointer(m, sXmlDoc) != 0))
    return MERRMEM;
 
  int k = MMpush(m, 2 * 2);
  MBdeftab(m);
 
  return k;
}
 
int _AddXmlNode(mmachine m)
{
        #ifdef  _SCOL_DEBUG_
                MMechostr(MSKDEBUG,"_AddXmlNode\n");
        #endif
 
  int ivalue = MMpull(m); 
  int ixmlnode = MMpull(m);
  if ((ixmlnode == NIL) || (ivalue == NIL))
  {
    MMpush(m, NIL);
    return 0;
  }
  std::string value = MMstartstr(m, MTOP(ivalue));
  
  tinyxml2::XMLNode* xmlNode = GetXmlNode(m, ixmlnode);
  if (!xmlNode)
  {
    MMechostr(MSKDEBUG, "_AddXmlNode : bad ObjSXMLNode object.\n");
                MMpush(m, NIL);
                return 0;
        }
  
  SXml* sXmlDoc = MMgetPointer<SXml*>(m, MTOP(MMfetch(m, MTOP(ixmlnode), 1)));
  if (!sXmlDoc)
  {
    MMechostr(MSKDEBUG, "_AddXmlNode : bad ObjSXMLNode object.\n");
                MMpush(m, NIL);
                return 0;
        }
 
  tinyxml2::XMLNode* nXmlNode = xmlNode->GetDocument()->NewElement(value.c_str());
  xmlNode->InsertEndChild(nXmlNode);
  sXmlDoc->AddNode(nXmlNode);
 
  if ((MMpushPointer(m, nXmlNode) != 0))
    return MERRMEM;
 
  if ((MMpushPointer(m, sXmlDoc) != 0))
    return MERRMEM;
 
  int k = MMpush(m, 2 * 2);
  MBdeftab(m);
 
  return k;
}
 
int _GetXmlContent(mmachine m)
{
        #ifdef  _SCOL_DEBUG_
                MMechostr(MSKDEBUG, "_GetXmlContent\n");
        #endif
 
  int ixml = MMpull(m);
  if (ixml == NIL)
  {
    MMechostr(MSKDEBUG, "_GetXmlContent : param nil.\n");
    MMpush(m, NIL);
    return 0;
  }
 
  SXml* sXmlDoc = MMgetPointer<SXml*>(m, MTOP(ixml));
  if (!sXmlDoc)
  {
    MMechostr(MSKDEBUG, "_GetXmlContent : bad ObjSXML object.\n");
                MMpush(m, NIL);
                return 0;
        }
  
  std::string content = sXmlDoc->ToString();
 
  Mpushstrbloc(m, (char*)content.c_str());
        return 0;
}
 
 
// Scol / Package **************************************************************
static NativeDefinition sxmlDef[] =
{
  {"ObjSXML",                  TYPTYPE,  NULL,                                        NULL},
  {"ObjSXMLNode",              TYPTYPE,  NULL,                                        NULL},
  {"_CreateXml",               1,        "fun [Chn] ObjSXML",                         _CreateXml},
  {"_OpenXml",                 2,        "fun [Chn P] ObjSXML",                       _OpenXml},
  {"_OpenXmlS",                2,        "fun [Chn S] ObjSXML",                       _OpenXmlS},
  {"_SaveXml",                 2,        "fun [ObjSXML W] I",                         _SaveXml},
  {"_DestroyXml",              1,        "fun [ObjSXML] I",                           _DestroyXml},
  {"_GetXmlRootNodes",         1,        "fun [ObjSXML] [ObjSXMLNode r1]",            _GetXmlRootNodes},
  {"_GetXmlNodeChilds",        1,        "fun [ObjSXMLNode] [ObjSXMLNode r1]",        _GetXmlNodeChilds},
  {"_GetXmlNodeValue",         1,        "fun [ObjSXMLNode] S",                       _GetXmlNodeValue},
  {"_SetXmlNodeValue",         2,        "fun [ObjSXMLNode S] ObjSXMLNode",           _SetXmlNodeValue},
  {"_GetXmlNodeContent",       1,        "fun [ObjSXMLNode] S",                       _GetXmlNodeContent},
  {"_SetXmlNodeContent",       2,        "fun [ObjSXMLNode S] ObjSXMLNode",           _SetXmlNodeContent},
  {"_GetXmlNodeAttributes",    1,        "fun [ObjSXMLNode] [[S S] r1]",              _GetXmlNodeAttributes},
  {"_SetXmlNodeAttributes",    2,        "fun [ObjSXMLNode [[S S] r1]] ObjSXMLNode",  _SetXmlNodeAttributes},
  {"_RemoveXmlNode",           1,        "fun [ObjSXMLNode] I",                       _RemoveXmlNode},
  {"_AddXmlRootNode",          2,        "fun [ObjSXML S] ObjSXMLNode",               _AddXmlRootNode},
  {"_AddXmlNode",              2,        "fun [ObjSXMLNode S] ObjSXMLNode",           _AddXmlNode},
  {"_GetXmlContent",           1,        "fun [ObjSXML] S",                           _GetXmlContent}
};
 
// Everything inside _cond and _endcond is ignored by doxygen
 
int InitSXML(mmachine m)
{
  OBJTYPSXML = OBJregister(0, 1, destroyXmlObj, "OBJTYPSXML");
  return PKhardpak2(m, "sXml.pkg-1.0", sizeof(sxmlDef)/sizeof(sxmlDef[0]), sxmlDef);
}
 
#ifndef SCOL_STATIC
extern "C" SCOL_EXPORT int ScolLoadPlugin(mmachine m, cbmachine w)
#else
extern "C" SCOL_EXPORT int ScolSxmlLoadPlugin(mmachine m, cbmachine w)
#endif
{
        SCOLinitplugin(w);
  return InitSXML(m);
}
 
 
#ifndef SCOL_STATIC
extern "C" SCOL_EXPORT int ScolUnloadPlugin()
#else
extern "C" SCOL_EXPORT int ScolSxmlUnloadPlugin()
#endif
{
        return 0;
}