powerguru-commit
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Powerguru-commit] [SCM] powerguru branch, master, updated. 11d4afbbf83e


From: Rob Savoye
Subject: [Powerguru-commit] [SCM] powerguru branch, master, updated. 11d4afbbf83e2e9cdfc48b93edc475ac68b94408
Date: Sun, 25 Nov 2018 00:33:22 -0500 (EST)

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "powerguru".

The branch, master has been updated
       via  11d4afbbf83e2e9cdfc48b93edc475ac68b94408 (commit)
       via  244bf646bdc67fa800102f8ea6ac427635f9aeff (commit)
       via  cc8f09bc4290d60f1c4df80ea7b09064639cf04c (commit)
       via  51abc5a0b42fa8096a7cf333acdebab577fb99da (commit)
       via  c3f1d6c1d28ec641da0e44a217a356f8c21882de (commit)
       via  39ac05b50242c28c0fff6eaea4d53436d1d40718 (commit)
       via  d16ac0e0c02e7f03d33fafc49d47ccc14676339f (commit)
      from  b5ff0e87cd976125141b4416a9bd1d472c396f2b (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
http://git.savannah.gnu.org/cgit/powerguru.git/commit/?id=11d4afbbf83e2e9cdfc48b93edc475ac68b94408


commit 11d4afbbf83e2e9cdfc48b93edc475ac68b94408
Author: Rob Savoye <address@hidden>
Date:   Sat Nov 24 22:20:00 2018 -0700

    Tweak capitalization

diff --git a/testsuite/libtests/test.xml b/testsuite/libtests/test.xml
new file mode 100644
index 0000000..7b03f48
--- /dev/null
+++ b/testsuite/libtests/test.xml
@@ -0,0 +1,5 @@
+<one>One
+  <two foo="Bar">Two
+    <three>Three</three>
+  </two>
+</one>

http://git.savannah.gnu.org/cgit/powerguru.git/commit/?id=244bf646bdc67fa800102f8ea6ac427635f9aeff


commit 244bf646bdc67fa800102f8ea6ac427635f9aeff
Author: Rob Savoye <address@hidden>
Date:   Sat Nov 24 21:07:28 2018 -0700

    The beginnings of major refactoring.

diff --git a/lib/xml.cc b/lib/xml.cc
index 1f93df9..643a5a4 100644
--- a/lib/xml.cc
+++ b/lib/xml.cc
@@ -34,298 +34,76 @@
 
 #include "xml.h"
 #include "log.h"
-#include "err.h"
-#include "msgs.h"
-
-using namespace std;
 
 extern LogFile dbglogfile;
 
-XMLAttr::XMLAttr() : _name(0), _value(0)
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-}
-
-const char *
-XMLAttr::nameGet(void)
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-    return (const char *)_name;
-}
-
-void
-XMLAttr::nameSet(const xmlChar *name)
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-    _name = name;
-}
-
-const char *
-XMLAttr::valueGet(void)
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-    return (const char *)_value;
-}
-
-void
-XMLAttr::valueSet(const xmlChar *val)
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-    _value = val;
-}
-
-XMLAttr::~XMLAttr()
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-}
-
 // XMLNode methods. An XMLNode holds all the info for an XML node,
 // including it's children and attributes.
-XMLNode::XMLNode() : _name(0), _value(0)
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-}
-
-vector<XMLNode *>
-XMLNode::childrenGet(void)
-{
-    return _children;
-}
-
-vector<XMLAttr *>
-XMLNode::attributesGet(void)
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-    return _attributes;
-}
-
+// XMLNode::XMLNode()
+// {
+//     // DEBUGLOG_REPORT_FUNCTION;
+// }
+
+// XMLNode::~XMLNode()
+// {
+//     // DEBUGLOG_REPORT_FUNCTION;
+//     unsigned int i;
+// }
+
+// Convert a raw XML node to a C++ representation
 XMLNode *
-XMLNode::childGet(int x)
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-    return _children[x];
-}
-
-void
-XMLNode::childAdd(XMLNode *node)
+XML::extractNode(xmlNodePtr node)
 {
-    // DEBUGLOG_REPORT_FUNCTION;
-    _children.push_back(node);
-}
-
-XMLAttr *
-XMLNode::attribGet(int x)
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-    return _attributes[x];
-}
-
-void
-XMLNode::attribAdd(XMLAttr *attr)
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-    _attributes.push_back(attr);
-}
-
-XMLNode *
-XMLNode::operator [] (int x)
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-    return _children[x];
-}
-
-XMLNode *
-XMLNode::operator = (XMLNode &node)
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-    _name = node._name;
-    _value = node._value;
-    _children = node._children;
-    _attributes = node._attributes;
-    return this;
-}
-
-XMLNode *
-XMLNode::operator = (XMLNode *node)
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-    _name = node->_name;
-    _value = node->_value;
-    _children = node->_children;
-    _attributes = node->_attributes;
-    return this;
-}
-
-const char *
-XMLNode::nameGet(void)
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-    return (const char *)_name;
-}
-
-void
-XMLNode::nameSet(const xmlChar *name)
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-    _name = name;
-}
-
-const char *
-XMLNode::valueGet(void)
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-    return (const char *)_value;
-}
-
-void
-XMLNode::valueSet(const xmlChar *val)
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-    _value = val;
-}
-
-
-XMLNode::~XMLNode()
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-    unsigned int i;
-  
-    for (i=0; i<_children.size(); i++) {
-//     if (_children[i]->_name) {
-//       delete _children[i]->_name;
-//     }
-//     if (_children[i]->_value) {
-//       delete _children[i]->_value;
-//     }
-        delete _children[i];
-    }
-
-    for (i=0; i<_attributes.size(); i++) {
-        //     if (_attributes[i]->_name) {
-//       delete _attributes[i]->_name;
-//     }
-//     if (_attributes[i]->_value) {
-//       delete _attributes[i]->_value;
-//     }
-        delete _attributes[i];
-    }
-
-    _children.clear();
-    _attributes.clear();
-}
-
-int
-XMLNode::childrenSize(void)
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-    return _children.size();  
-}
-
-bool
-XMLNode::hasContent(void)
-{
-    return (_value > 0) ? true : false;
-}
-
-bool
-XMLNode::hasChildren(void)
-{
-    return (_children.size() > 0) ? true : false;
-}
-
-bool
-XMLNode::hasAttributes(void)
-{
-    return (_attributes.size() > 0) ? true : false;
-}
-
-int
-XMLNode::attributesSize(void)
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-    return _attributes.size();
-}
-
-// XML Constructor
-XML::XML()
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-}
-
-// Parse the ASCII XML string into memory
-XML::XML(string xml_in)
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-    parseXML(xml_in);
-}
-
-XML::XML(struct node *childNode)
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-}
-
-XML::~XML()
-{
-    // DEBUGLOG_REPORT_FUNCTION;
-}
-
-XMLNode*
-XML::extractNode(xmlNodePtr node, bool mem)
-{
-    // DEBUGLOG_REPORT_FUNCTION;
+    DEBUGLOG_REPORT_FUNCTION;
     xmlAttrPtr attr;
     xmlNodePtr childnode;
     xmlChar *ptr = NULL;
-    XMLNode *element, *child;
+    XMLNode *child;
     int len;
 
-    element = new XMLNode;
-    memset(element, 0, sizeof (XMLNode));
-            
-    //  dbglogfile << "\rCreated new element for " << (const char *)node->name 
<< " at " << element << endl;
+    // dbglogfile << "\rCreated new element for " << (const char *)node->name 
<< " at " << element << std::endl;
+
+    dbglogfile << "extracting node " << node->name << std::endl;
 
-    dbglogfile << "extracting node " << (const char *)node->name << endl;
+    XMLNode *xml = new XMLNode;
+    std::string name;
+    std::string value;
 
     // See if we have any Attributes (properties)
-    attr = node->properties;
-    while (attr != NULL) {
+    if (attr = node->properties) {
+        // extract all the attributes for this node
+        while (attr != NULL) {
+            name = reinterpret_cast<const char *>(attr->name);
+            value = reinterpret_cast<const char *>(attr->children->content);
+            xml->attribAdd(name, value);
+            attr = attr->next;
 #if 0
-        dbglogfile << " extractNode " << (const char *)node->name
-                   << " has property "
-                   << (const char *)attr->name << " value is "
-                   << (const char *)attr->children->content << endl;
+            dbglogfile << "FIXME: attribute " << node->name
+                       << " has property "
+                       << name << " value is "
+                       << value << std::endl;
 #endif
-        XMLAttr *attrib = new XMLAttr;
-        memset(attrib, 0, sizeof (XMLAttr));
-        attrib->nameSet(xmlStrdup(attr->name));
-        attrib->valueSet(xmlStrdup(attr->children->content));
-#if 0
-        dbglogfile << "\tPushing attribute " << (const char *)attr->name
-                   << " for element "
-                   << (const char *)node->name << " has value "
-                   << (const char *)attr->children->content << endl;
-#endif
-        element->attribAdd(attrib);
-        attr = attr->next;
+        }
     }
 
-    element->nameSet(xmlStrdup(node->name));
+    name = reinterpret_cast<const char *>(node->name);
+    xml->nameSet(name);
     if (node->children) {
         //ptr = node->children->content;
         ptr = xmlNodeGetContent(node->children);
         if (ptr != NULL) {
-            if ((strchr((const char *)ptr, '\n') == 0) && (ptr[0] != 0))
-                {
-                    if (node->children->content == NULL) {
-                        //dbglogfile << "Node " << (const char *)node->name << 
" has no contents" << endl;
-                    } else {
-#if 0
-                        dbglogfile << "extractChildNode from text for " << 
(const char *)node->name
-                                   << " has contents " << (const char *)ptr << 
endl;
+            if ((strchr((const char *)ptr, '\n') == 0) && (ptr[0] != 0)) {
+                if (node->children->content == NULL) {
+                    dbglogfile << "FIXME: Node " << name << " has no contents" 
<< std::endl;
+                } else {
+                    value = reinterpret_cast<const char 
*>(node->children->content);
+#if 1
+                    dbglogfile << "extractChildNode from text for " << name
+                               << " has contents " << value << std::endl;
 #endif
-                        element->valueSet(xmlStrdup(ptr));
-                    }
+                    xml->valueSet(value);
                 }
+            }
             xmlFree(ptr);
         }
     }
@@ -335,36 +113,35 @@ XML::extractNode(xmlNodePtr node, bool mem)
 
     while (childnode != NULL) {
         if (childnode->type == XML_ELEMENT_NODE) {
-            //dbglogfile << "\t\t extracting node " << (const char 
*)childnode->name << endl;
-            child = extractNode(childnode, mem);
+            dbglogfile << "\t\t extracting node " << (const char 
*)childnode->name << std::endl;
+            XMLNode *child = extractNode(childnode);
             //if (child->_value.get_type() != as_value::UNDEFINED) {
 #if 0
-            if (child->valueGet() != "") {
+            if (!child->valueGet().empty() {
                 dbglogfile << "\tPushing childNode " << child->nameGet()
                            << " value " << child->valueGet()
                            <<  " on element "
-                           <<  element << endl;
+                           <<  xml << std::endl;
             } else {
                 dbglogfile << "\tPushing childNode " << 
child->nameGet().c_str()
-                           << endl;
+                           << std::endl;
             }
 #endif
-            element->childAdd(child);
+            xml->childAdd(child);
         }
         childnode = childnode->next;
     }
 
-    return element;
+    return xml;
 }
 
+#if 0
 // Read in an XML document from the specified source
 bool
-XML::parseDoc(xmlDocPtr document, bool mem)
+XML::parseRoot(xmlDocPtr document)
 {
-    // DEBUGLOG_REPORT_FUNCTION;
-    XMLNode *top;
+    DEBUGLOG_REPORT_FUNCTION;
     xmlNodePtr cur;
-    Msgs msg;
   
     if (document == 0) {
         dbglogfile << "ERROR: Can't load XML file!";
@@ -374,28 +151,28 @@ XML::parseDoc(xmlDocPtr document, bool mem)
     cur = xmlDocGetRootElement(document);
   
     if (cur != NULL) {
-        top = extractNode(cur, mem);
         //    msg.dump(top);
-        msg.process(top);
-        _nodes = top;
-        cur = cur->next;
+        // msg.process(top);
+        //node = _nodes->push_back(extractNode(cur));
+        //cur = cur->next;
     }  
 
     return true;
 }
+#endif
 
 // This reads in an XML file from disk and parses into into a memory resident
 // tree which can be walked through later.
 bool
-XML::parseXML(string xml_in)
+XML::parseMem(const std::string &xml_in)
 {
-    // DEBUGLOG_REPORT_FUNCTION;
+    DEBUGLOG_REPORT_FUNCTION;
     bool          ret = true;
 
-    dbglogfile << "Parse XML from memory: " << xml_in.c_str() << endl;
+    dbglogfile << "Parse XML from memory: " << xml_in.c_str() << std::endl;
 
     if (xml_in.size() == 0) {
-        dbglogfile << "ERROR: XML data is empty!" << endl;
+        dbglogfile << "ERROR: XML data is empty!" << std::endl;
         return false;
     }
 
@@ -415,12 +192,12 @@ XML::parseXML(string xml_in)
             node = processNode(reader, node);
         }
         xmlFreeTextReader(reader);
-        if (ret != false) {
-            dbglogfile << "couldn't parse" << xml_in << endl;
+        if (ret != false) {xg
+            dbglogfile << "couldn't parse" << xml_in << std::endl;
             return false;
         }
     } else {
-        dbglogfile << "Unable to open " << xml_in << endl;
+        dbglogfile << "Unable to open " << xml_in << std::endl;
         return false;
     }
     xmlCleanupParser();
@@ -431,10 +208,11 @@ XML::parseXML(string xml_in)
   
     _doc = xmlParseMemory(xml_in.c_str(), xml_in.size());
     if (_doc == 0) {
-        dbglogfile << "ERROR: Can't parse XML data!" << endl;
+        dbglogfile << "ERROR: Can't parse XML data!" << std::endl;
         return false;
     }
-    ret = parseDoc(_doc, true);
+    //ret = parseRoot(_doc);
+    //ret = xmlDocGetRootElement(_doc);
     xmlCleanupParser();
     xmlFreeDoc(_doc);
     xmlMemoryDump();
@@ -476,11 +254,11 @@ const char *tabs[] = {
 #ifdef USE_XMLREADER
 // This is an xmlReader (SAX) based parser. For some reason it core dumps
 // when compiled with GCC 3.x, but works just fine with GCC 4.x.
-XMLNode*
-XML::processNode(xmlTextReaderPtr reader, XMLNode *node)
+const XMLNode &
+XML::processNode(xmlTextReaderPtr reader, XMLNode &node)
 {
-    // DEBUGLOG_REPORT_FUNCTION;
-    // dbglogfile << " node is " << node << endl;
+    DEBUGLOG_REPORT_FUNCTION;
+    // dbglogfile << " node is " << node << std::endl;
     static XMLNode *parent[10];
     xmlChar *name, *value;
     int   depth;
@@ -512,7 +290,7 @@ XML::processNode(xmlTextReaderPtr reader, XMLNode *node)
       case XML_READER_TYPE_NONE:
           break;
       case XML_READER_TYPE_SIGNIFICANT_WHITESPACE: // This is an empty text 
node
-          //dbglogfile << "Whitespace at depth " << depth << endl;
+          //dbglogfile << "Whitespace at depth " << depth << std::endl;
           break;
       case XML_READER_TYPE_END_ELEMENT:
           if (depth == 0) {          // This is the last node in the file
@@ -521,7 +299,7 @@ XML::processNode(xmlTextReaderPtr reader, XMLNode *node)
           }
           parent[depth]->_children.push_back(element);
           //      dbglogfile << "Pushing element XXX on node "
-          //                 << node->_name << parent[depth]->_name << endl;
+          //                 << node->_name << parent[depth]->_name << 
std::endl;
           //       dbglogfile << "End element at depth %d is %s for parent %s 
%p\n", depth, name,
 //               parent[depth]->_name, parent[depth]);
           element = parent[depth];
@@ -585,15 +363,15 @@ XML::processNode(xmlTextReaderPtr reader, XMLNode *node)
 // This reads in an XML file from disk and parses into into a memory resident
 // tree which can be walked through later.
 bool
-XML::load(const char *filespec)
+XML::parseFile(const std::string &filespec)
 {
-    // DEBUGLOG_REPORT_FUNCTION;
-    bool ret = true;
-    dbglogfile << "Load disk XML file: " << filespec << endl;
+    DEBUGLOG_REPORT_FUNCTION;
+    dbglogfile << "Load disk XML file: " << filespec << std::endl;
   
     //dbglogfile << %s: mem is %d\n", __FUNCTION__, mem);
 
 #ifdef USE_XMLREADER
+    bool ret = true;
     XMLNode *node = 0;
     xmlTextReaderPtr reader;  
   
@@ -606,11 +384,11 @@ XML::load(const char *filespec)
         }
         xmlFreeTextReader(reader);
         if (ret != false) {
-            dbglogfile << "couldn't parse" << filespec << endl;
+            dbglogfile << "couldn't parse" << filespec << std::endl;
             return false;
         }
     } else {
-        dbglogfile << "ERROR: Unable to open %s\n" << filespec << endl;
+        dbglogfile << "ERROR: Unable to open %s\n" << filespec << std::endl;
         return false;
     }
     xmlCleanupParser();
@@ -618,12 +396,13 @@ XML::load(const char *filespec)
 #else
 #ifdef USE_DOM
     xmlInitParser();
-    _doc = xmlParseFile(filespec);
+    _doc = xmlParseFile(filespec.c_str());
     if (_doc == 0) {
-        dbglogfile << "ERROR: Can't load XML file: " << filespec << endl;
+        dbglogfile << "ERROR: Can't load XML file: " << filespec << std::endl;
         return false;
     }
-    ret = parseDoc(_doc, false);
+    //_nodes = extractNode(xmlDocGetRootElement(_doc));
+    _nodes = extractNode(xmlDocGetRootElement(_doc));
     xmlCleanupParser();
     xmlFreeDoc(_doc);
     xmlMemoryDump();
@@ -634,35 +413,28 @@ XML::load(const char *filespec)
 #endif
 }
 
-XMLNode *
-XML::operator [] (int x) {
-    // DEBUGLOG_REPORT_FUNCTION;
-    return _nodes.childGet(x);
-}
+// const XMLNode &
+// XML::operator [] (int x) {
+//     // DEBUGLOG_REPORT_FUNCTION;
+//     return _nodes->childGet(x);
+// }
 
-bool
-XML::hasChildren(void)
-{
-    return (_nodes.childrenSize() > 0)? true : false;
-}
-
-const char *
-XML::nodeNameGet(void)
-{
-    return (const char *)_nodes.nameGet();
-}
+// bool
+// XML::hasChildren(void)
+// {
+//     return (_nodes->childrenSize() > 0)? true : false;
+// }
 
-int
-XML::size(void)
-{
-    return _nodes.size();
-}
+// const std::string &
+// XML::nodeNameGet(void)
+// {
+//     return _nodes->nameGet();
+// }
 
-XML *
-XML::operator = (XMLNode *node)
+void
+XMLNode::operator = (XMLNode &node)
 {
-    _nodes = node;    
-    return this;
+    _name = node.nameGet();
 }
 
 int
diff --git a/lib/xml.h b/lib/xml.h
index 549ef7b..8d9a39e 100644
--- a/lib/xml.h
+++ b/lib/xml.h
@@ -26,87 +26,88 @@
 
 #include <cstring>
 #include <vector>
+#include <map>
 #include <libxml/xmlmemory.h>
 #include <libxml/parser.h>
 #include <libxml/xmlreader.h>
 #include <libxml/xmlstring.h>
 #include "xml.h"
 #include "log.h"
-#include "err.h"
 
+#if 0
 // This holds the data (name & value) for an XML node's attributes.
 class XMLAttr {
 public:
-  XMLAttr();
-  ~XMLAttr();
-  const char *nameGet(void);
-  void nameSet(const xmlChar *name);
-  const char *valueGet(void);
-  void valueSet(const xmlChar *val);
- private:
-  const xmlChar *_name;
-  const xmlChar *_value;
+    XMLAttr();
+    ~XMLAttr();
+    const std::string &nameGet(void);
+    void nameSet(const std::string &name);
+    const std::string &valueGet(void);
+    void valueSet(const std::string &val);
+private:
+    std::string _name;
+    std::string _value;
 };
+#endif
 
 // This holds the data (name & value) for an XML node.
 class XMLNode
 {
 public:
-  XMLNode();
-  ~XMLNode();
+    XMLNode() {};
+    ~XMLNode() {};
 
-  int size(void) { return _children.size(); }
-  XMLNode *operator [] (int x);
-  XMLNode *operator = (XMLNode &node);
-  XMLNode *operator = (XMLNode *node);
+    XMLNode *childGet(int x) { return _children[x]; }
+    XMLNode *operator [] (int x) { return _children[x]; }
+    void operator = (XMLNode &node);
 
-  const char *nameGet(void);
-  //  void nameSet(std::string name);
-  void nameSet(const xmlChar *name);
-  const char *valueGet(void);
-  //  void valueSet(std::string val);
-  void valueSet(const xmlChar *val);
-  
-  std::vector<XMLNode *> childrenGet(void);
-  XMLNode *childGet(int x);
-  void childAdd(XMLNode *node);
-  
-  std::vector<XMLAttr *> attributesGet(void);
-  XMLAttr *attribGet(int x);
-  void attribAdd(XMLAttr *attr);
-  int childrenSize(void);
-  int attributesSize(void);
-  bool hasContent(void);
-  bool hasChildren(void);
-  bool hasAttributes(void);
- private:
-  const xmlChar         *_name;
-  const xmlChar         *_value;
-  std::vector<XMLNode *> _children;
-  std::vector<XMLAttr *> _attributes;
+    const std::string &nameGet(void) { return _name; }
+    void nameSet(const std::string &name) { _name = name; }
+    const std::string &valueGet(void) { return _value; }
+    void valueSet(const std::string &val) { _value = val; }
+    void childAdd(XMLNode *node) { _children.push_back(node);} ;
+    std::string &attribGet(const std::string &name) { return 
_attributes[name]; };
+    void attribAdd(const std::string &name, const std::string &value) {
+        _attributes[name] = value;
+    }
+
+    int childrenSize(void) { return _children.size(); };
+    bool hasContent(void);
+    bool hasChildren(void) { return (_children.size() > 0)? true : false; };
+    bool hasAttributes(void) { return (_attributes.size() > 0)? true : false;};
+private:
+    std::string _name;
+    std::string _value;
+    std::vector<XMLNode *> _children;
+    std::map<std::string, std::string> _attributes;
 };
 
 // This is the top level for parsing an XML network message or file.
 class XML {
- public:
-  XML();
-  XML(std::string xml_in);
-  XML(struct node * childNode);
-  ~XML();
+public:
+    XML() {} ;
+    XML(const std::string &xml_in) {};
+    XML(struct node * childNode) {};
+    ~XML() {};
+
+    // bool parseRoot(xmlDocPtr document);
+    bool parseMem(const std::string &ml_in);
+    bool parseFile(const std::string &filespec);
+
+    const std::string &nameGet(void) { return _nodes->nameGet(); }
+    void nameSet(const std::string &name) { _nodes->nameSet(name); }
+    bool hasChildren(void) {  return _nodes->hasChildren(); }
+    bool hasAttributes(void) { return _nodes->hasAttributes(); }
+    //XMLNode *processNode(xmlTextReaderPtr reader);
+    //const std::string &nodeNameGet(void) { return nameGet(); }
 
-  bool parseDoc(xmlDocPtr document, bool mem);
-  bool parseXML(std::string xml_in);
-  bool load(const char *filespec);
-  bool hasChildren(void);
-  XMLNode *extractNode(xmlNodePtr node, bool mem);
-  XMLNode *processNode(xmlTextReaderPtr reader, XMLNode *node);
-  const char *nodeNameGet(void);
-  int size(void);  
-  XMLNode *operator [] (int x);
-  XML *operator = (XMLNode *node);
+    XMLNode *childGet(int x) { return _nodes->childGet(x); };
+    //XMLNode *operator [] (int x) { return _nodes[x]; };
+    //const XML &operator = (const XMLNode &node);
 private:
-  xmlDocPtr     _doc;
-  XMLNode       _nodes;
+    XMLNode *extractNode(xmlNodePtr node);
+    xmlDocPtr     _doc;
+    XMLNode       *_nodes;
 };
 
 int memadjust(int x);

http://git.savannah.gnu.org/cgit/powerguru.git/commit/?id=cc8f09bc4290d60f1c4df80ea7b09064639cf04c


commit cc8f09bc4290d60f1c4df80ea7b09064639cf04c
Author: Rob Savoye <address@hidden>
Date:   Sat Nov 24 21:03:06 2018 -0700

    Add more XML tests

diff --git a/testsuite/libtests/xml-test.cc b/testsuite/libtests/xml-test.cc
index b7d69c6..44d39ac 100644
--- a/testsuite/libtests/xml-test.cc
+++ b/testsuite/libtests/xml-test.cc
@@ -98,22 +98,59 @@ xml_tests(void) {
     } else {
         runtest.fail ("XML::parseFile()");
     }
-    const std::string name = xml.nodeNameGet();
+    std::string name = xml.nameGet();
     if (name == "one") {
-        runtest.pass ("XML::nodeNameGet()");
+        runtest.pass ("XML::nameGet(file)");
     } else {
-        runtest.fail ("XML::nodeNameGet()");
+        runtest.fail ("XML::nameGet(file)");
     }
 
     std::string testxml = 
"<one2><two2>two2<three2>three2</three2></two2></one2>";
-    //XMLNode *testnode = new XMLNode;
-    // xmlNodePtr
     if (xml.parseMem(testxml)) {
         runtest.pass ("XML::parseMem()");
     } else {
         runtest.fail ("XML::parseMem()");
     }
+    // 
+    name = xml.nameGet();
+    if (name == "one2") {
+        runtest.pass ("XML::nameGet(memory)");
+    } else {
+        runtest.fail ("XML::nameGet(memory)");
+    }
+
+    if (xml.hasChildren()) {
+        runtest.pass ("XML::hasChildren()");
+    } else {
+        runtest.fail ("XML::hasChildren()");
+    }
+
+    if (!xml.hasAttributes()) {
+        runtest.pass ("XML::hasAttributes()");
+    } else {
+        runtest.fail ("XML::hasAttributes()");
+    }
+    // Get first child element
+    XMLNode *child = xml.childGet(0);
+    if (child->nameGet() == "two") {
+        runtest.pass ("XML::nameGet(child)");
+    } else {
+        runtest.fail ("XML::nameGet(child)");
+    }
+    
+    if (child->hasAttributes() && (child->attribGet("foo") == "bar")) {
+        runtest.pass ("XML::attribGet()");
+    } else {
+        runtest.fail ("XML::attribGet()");
+    }
 
+    // Get the child of the child
+    child = child->childGet(0);
+    if (child->nameGet() == "three") {
+        runtest.pass ("XML::nameGet(child)");
+    } else {
+        runtest.fail ("XML::nameGet(child)");
+    }    
 }
 
 void

http://git.savannah.gnu.org/cgit/powerguru.git/commit/?id=51abc5a0b42fa8096a7cf333acdebab577fb99da


commit 51abc5a0b42fa8096a7cf333acdebab577fb99da
Author: Rob Savoye <address@hidden>
Date:   Sat Nov 24 11:26:26 2018 -0700

    Pass in the source directory so the tests can find cnned data files.

diff --git a/testsuite/libtests/Makefile.am b/testsuite/libtests/Makefile.am
index b665acb..e392fda 100644
--- a/testsuite/libtests/Makefile.am
+++ b/testsuite/libtests/Makefile.am
@@ -17,29 +17,32 @@
 
 ## Process this file with automake to generate Makefile.in
 
-AUTOMAKE_OPTIONS = dejagnu
+AUTOMAKE_OPTIONS = dejagnu subdir-objects
 
-# __USLC__ makes MySQL++ use the std namespace
-AM_CXXFLAGS = -g -D__USLC__
+AM_CPPFLAGS = -I$(top_srcdir) -I$(top_srcdir)/lib $(LIBXML_CPPFLAGS) 
$(PQ_CPPFLAGS) -DSRCDIR=\"$(srcdir)\"
 
-AM_INCLUDES =  $(MYSQLH) # $(INCLTDL)
+if BUILD_LIBXML
+noinst_PROGRAMS =  xml-test # tcpip tutil childtcpip
+else
+noinst_PROGRAMS =  tcpip tutil childtcpip
+endif
 
-noinst_PROGRAMS = tcpip tutil childtcpip
+LOG = ../../lib/log.lo
 
-AM_CPPFLAGS = -I$(top_srcdir)/lib
+if BUILD_LIBXML
+xml_test_SOURCES = xml-test.cc ../../lib/xml.cc
+xml_test_LDADD = $(LIBXML_LIBS) $(LOG)
+endif
 
-LOG = ../../lib/log.lo ../../lib/err.lo
-# Tcpip.C test case
-tcpip_SOURCES = tcpip-test.cc
-tcpip_LDADD =  ../../lib/tcpip.lo ../../lib/tcputil.lo $(LOG) # 
../../lib/libpguru.la
-tcpip_DEPENDENCIES = ../../lib/tcpip.lo ../../lib/tcputil.lo $(LOG) # 
../../lib/libpguru.la
+# FIXME: don't build till the code in lib is fixed.
+# tcpip_SOURCES = tcpip-test.cc
+# tcpip_LDADD =  ../../lib/tcpip.lo ../../lib/tcputil.lo $(LOG) # 
../../lib/libpguru.la
+# tcpip_DEPENDENCIES = ../../lib/tcpip.lo ../../lib/tcputil.lo $(LOG) # 
../../lib/libpguru.la
 
-#
-tutil_SOURCES = tcputil-test.cc
-tutil_LDADD = ../../lib/tcputil.lo  $(LOG) # ../../lib/libpguru.la
-tutil_DEPENDENCIES = ../../lib/tcputil.lo $(LOG) # ../../lib/libpguru.la
+# tutil_SOURCES = tcputil-test.cc
+# tutil_LDADD = ../../lib/tcputil.lo  $(LOG) # ../../lib/libpguru.la
+# tutil_DEPENDENCIES = ../../lib/tcputil.lo $(LOG) # ../../lib/libpguru.la
 
-#
-childtcpip_SOURCES = childtcpip.cc
-childtcpip_LDADD = ../../lib/tcpip.lo ../../lib/tcputil.lo $(LOG) # 
../../lib/libpguru.la
-childtcpip_DEPENDENCIES = ../../lib/tcpip.lo ../../lib/tcputil.lo $(LOG) # 
../../lib/libpguru.la
+# childtcpip_SOURCES = childtcpip.cc
+# childtcpip_LDADD = ../../lib/tcpip.lo ../../lib/tcputil.lo $(LOG) # 
../../lib/libpguru.la
+# childtcpip_DEPENDENCIES = ../../lib/tcpip.lo ../../lib/tcputil.lo $(LOG) # 
../../lib/libpguru.la

http://git.savannah.gnu.org/cgit/powerguru.git/commit/?id=c3f1d6c1d28ec641da0e44a217a356f8c21882de


commit c3f1d6c1d28ec641da0e44a217a356f8c21882de
Author: Rob Savoye <address@hidden>
Date:   Sat Nov 24 11:25:40 2018 -0700

    Add test case for the XML/XMLNODE classes.

diff --git a/testsuite/libtests/xml-test.cc b/testsuite/libtests/xml-test.cc
new file mode 100644
index 0000000..b7d69c6
--- /dev/null
+++ b/testsuite/libtests/xml-test.cc
@@ -0,0 +1,152 @@
+// 
+//   Copyright (C) 2018 Free Software Foundation, Inc.
+//
+//   This program is free software; you can redistribute it and/or modify
+//   it under the terms of the GNU 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 General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program; if not, write to the Free Software
+//   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+//
+
+// This is generated by autoconf
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <unistd.h>
+#include <vector>
+#include <libxml/xmlmemory.h>
+#include <libxml/parser.h>
+#include <libxml/xmlreader.h>
+#include <libxml/xmlstring.h>
+
+#include "dejagnu.h"
+#include "xml.h"
+
+int verbosity;
+static void usage (void);
+bool waitforgdb = false;
+
+TestState runtest;
+
+void xmlnode_tests(void);
+void xml_tests(void);
+
+int
+main(int argc, char *argv[])
+{
+    int c;
+    bool dump = false;
+    char buffer[300];
+    std::string filespec;
+    
+    int retries = 3;
+
+    memset(buffer, 0, 300);
+    
+    while ((c = getopt (argc, argv, "hdvsm:")) != -1) {
+        switch (c) {
+          case 'h':
+            usage ();
+            break;
+            
+          case 'd':
+            dump = true;
+            break;
+            
+          case 's':
+            waitforgdb = true;
+            break;
+                                                                               
 
+          case 'v':
+            verbosity++;
+            break;
+            
+          default:
+            usage ();
+            break;
+        }
+    }
+    
+    // get the file name from the command line
+    if (optind < argc) {
+        filespec = argv[optind];
+        std::cout << "Will use \"" << filespec << "\" for test " << std::endl;
+    }
+
+    xml_tests();
+}
+
+void
+xml_tests(void) {
+
+    XML xml;
+
+    std::string xmlfile = SRCDIR;
+    xmlfile += "/test.xml";
+    
+    if (xml.parseFile(xmlfile)) {
+        runtest.pass ("XML::parseFile()");
+    } else {
+        runtest.fail ("XML::parseFile()");
+    }
+    const std::string name = xml.nodeNameGet();
+    if (name == "one") {
+        runtest.pass ("XML::nodeNameGet()");
+    } else {
+        runtest.fail ("XML::nodeNameGet()");
+    }
+
+    std::string testxml = 
"<one2><two2>two2<three2>three2</three2></two2></one2>";
+    //XMLNode *testnode = new XMLNode;
+    // xmlNodePtr
+    if (xml.parseMem(testxml)) {
+        runtest.pass ("XML::parseMem()");
+    } else {
+        runtest.fail ("XML::parseMem()");
+    }
+
+}
+
+void
+xmlnode_tests(void) {
+
+    XMLNode node;
+}
+
+void
+cntrlc_handler (int sig)
+{
+    std::cerr << "Got a ^C !" << std::endl;
+}
+
+void
+alarm_handler (int sig)
+{
+    std::cerr << "Got an alarm signal !" << std::endl;
+    std::cerr << "This is OK, we use it to end this test case." << std::endl;
+}
+
+static void
+usage (void)
+{
+    std::vector<XMLNode> child;
+    XMLNode foo;
+    child.push_back(foo);
+    const XMLNode &bar = child[0];
+          
+    std::cerr << "This program tests the XML processing code." << std::endl;
+    std::cerr << "Usage: ./xml [h]" << std::endl;
+    std::cerr << "-h\tHelp" << std::endl;
+    std::cerr << "-d\tDump parsed data" << std::endl;
+    exit (-1);
+}
+

http://git.savannah.gnu.org/cgit/powerguru.git/commit/?id=39ac05b50242c28c0fff6eaea4d53436d1d40718


commit 39ac05b50242c28c0fff6eaea4d53436d1d40718
Author: Rob Savoye <address@hidden>
Date:   Fri Nov 23 11:38:18 2018 -0700

    Remove using pdev namespace, remove err.h

diff --git a/devices/outbackpower.cc b/devices/outbackpower.cc
index 862a603..94d9e65 100644
--- a/devices/outbackpower.cc
+++ b/devices/outbackpower.cc
@@ -24,14 +24,12 @@
 #include <vector>
 #include <map>
 
-#include "err.h"
 #include "log.h"
 #include "console.h"
 #include "outbackpower.h"
 #include "database.h"
 
 using namespace std;
-using namespace pdev;
 
 const int PACKET_SIZE = 49;
 
@@ -91,9 +89,6 @@ outback::commInit(string filespec)
         exit(0);
     }    
 
-#if 0
-    Open(filespec);
-#else
     try {
         Open(filespec);
     }
@@ -101,7 +96,6 @@ outback::commInit(string filespec)
         dbglogfile << catch_err << endl;
         exit(1);
     }
-#endif
   
     return commInit(GetFD());
 }
@@ -712,10 +706,25 @@ outback::exportMeterData(meter_data_t *data)
     // The Voltage coming in from the PV panels before MPPT
     data->pv_volts_in = _pv_input_voltage;
 
-  
     return data;
 }
 
+#ifdef BUILD_OUTBACK
+// Talk to an Outback Power Systems device
+        con.Puts("PowerGuru - Outback Mode\r\n");
+        //outback outdev("/dev/pts/7");
+        outback outdev(filespec);
+        if (poll) {
+            // outdev.poll();
+#if defined(HAVE_MARIADB) && defined(HAVE_POSTGRESQL)
+        } else {
+            if (outdev.main(con, pdb) == ERROR) {
+                dbglogfile << "ERROR: Main Loop exited with an error!" << endl;
+            }
+#endif
+        }
+#endif
+
 // local Variables:
 // mode: C++
 // indent-tabs-mode: nil
diff --git a/devices/outbackpower.h b/devices/outbackpower.h
index b16550b..165aba9 100644
--- a/devices/outbackpower.h
+++ b/devices/outbackpower.h
@@ -34,8 +34,6 @@
 // series. Each packet is 49 bytes, and is transmitted as ASCII
 // numerals for portability, with an ASCII comma character
 // seperating each field.
-namespace pdev
-{
 
 // Outback FX Inverter protocol
 struct outback_fx
@@ -352,9 +350,6 @@ private:
     int _checksum;
 };
 
-// end of namespace pdev
-}
-
 // __OUTBACK_POWER_H__
 #endif
 
diff --git a/devices/ownet.cc b/devices/ownet.cc
index 08e1667..ca2169f 100644
--- a/devices/ownet.cc
+++ b/devices/ownet.cc
@@ -20,7 +20,6 @@
 # include "config.h"
 #endif
 
-#include "err.h"
 #include "log.h"
 #include "ownet.h"
 #include <string>
diff --git a/devices/ownet.h b/devices/ownet.h
index 2e07432..f28079d 100644
--- a/devices/ownet.h
+++ b/devices/ownet.h
@@ -235,7 +235,7 @@ public:
             std::string dev = *it + "temperature";
             if (OW_present(dev.c_str()) == 0) {
                 dbglogfile << "Temperature sensor found: " << *it << std::endl;
-                temperature_t *temp= new temperature_t[1];
+                temperature_t *temp = new temperature_t[1];
                 memset(temp, 0, sizeof(temperature_t));
                 temp->temp = std::stof(getValue(*it, "temperature"));
                 temp->lowtemp = std::stof(getValue(*it, "templow"));
@@ -255,6 +255,7 @@ public:
             } else {
                 dbglogfile << "Temperature sensor not found!" << std::endl;
             }
+            std::lock_guard<std::mutex> guard(_mutex);
             _sensors[*it] = data;
         }
     }
diff --git a/devices/xanbus.cc b/devices/xanbus.cc
index efb82ef..e519cd1 100644
--- a/devices/xanbus.cc
+++ b/devices/xanbus.cc
@@ -23,7 +23,6 @@
 #include <vector>
 #include <map>
 
-#include "err.h"
 #include "log.h"
 #include "console.h"
 #include "xanbus.h"
diff --git a/devices/xanbus.h b/devices/xanbus.h
index 21afdcb..47185b3 100644
--- a/devices/xanbus.h
+++ b/devices/xanbus.h
@@ -24,7 +24,6 @@
 #include <cstring>
 #include <vector>
 #include <map>
-#include "err.h"
 #include <console.h>
 
 #include "serial.h"
diff --git a/devices/xantrex-trace.cc b/devices/xantrex-trace.cc
index 58391fb..5511647 100644
--- a/devices/xantrex-trace.cc
+++ b/devices/xantrex-trace.cc
@@ -24,7 +24,6 @@
 #include <vector>
 #include <map>
 
-#include "err.h"
 #include "log.h"
 #include "console.h"
 #include "xantrex-trace.h"
@@ -1580,6 +1579,68 @@ XantrexUI::exportMeterData(meter_data_t *data)
     return data;
 }
 
+#ifdef BUILD_XANTREX
+    if (xantrexmode) {
+        XantrexUI ui;
+        // Open a console for user input
+        con.Open();
+        if (poll) {
+            // Open the serial port
+            try {
+                ui.Open(filespec);
+            }
+            catch (ErrCond catch_err) {
+                cerr << catch_err << endl;
+                exit(1);
+            }
+            //
+            for (i=0; i<1000; i++) {
+                //display = ui.MenuHeadingPlus();
+#if 0
+                ch = con.Getc();
+                switch (ch) {
+                    // Toggle the DTR state, which is as close as we get to
+                    // flow control.
+                  case 'Q':
+                  case 'q':
+                      return SUCCESS;
+                      break;
+                  case '?':
+                      con.Puts("PowerGuru - Outback Mode\r\n");
+                      con.Puts("\t? - help\r\n");
+                      con.Puts("\tq - Quit\r\n");
+                      con.Puts("\tQ - Quit\r\n");
+                      sleep(2);
+                  default:
+                      break;
+                };
+#endif
+
+                vector<meter_data_t *> data = ui.PollMeters(1);
+//           ui.MenuHeadingPlus();
+//           ui.MenuHeadingMinus();
+#if defined(HAVE_MARIADB) && defined(HAVE_POSTGRESQL)
+                pdb.queryInsert(data);
+#if 0
+                for (i=0; i<data->size(); i++) {
+                    //cout << "Inverter/Charger amps: " << 
data[i]->inverter_amps << endl;
+                    cout << "Input amps AC: " << data[i]->input_amps << endl;
+                    cout << "Load  amps AC: " << data[i]->load_amps << endl;
+                    cout << "Battery actual volts DC: " << 
data[i]->actual_volts << endl;
+                    cout << "Battery TempComp volts DC: " << 
data[i]->tempcomp_volts << endl;
+                    cout << "Inverter volts AC: " << data[i]->inverter_volts 
<< endl;
+                    cout << "Grid (AC1) volts AC: " << data[i]->ac1 << endl;
+                    cout << "Generator (AC2) volts AC: " << data[i]->ac2 << 
endl;
+                    cout << "Read Frequency Hertz: " << data[i]->hertz << endl;
+                    //pdb.queryInsert(data[i]);
+                    //delete data[i];
+                }
+#endif
+#endif
+                //sleep(1);
+                cout << endl;
+            }
+
 // local Variables:
 // mode: C++
 // indent-tabs-mode: nil
diff --git a/devices/xantrex-trace.h b/devices/xantrex-trace.h
index 471bc9b..83ce318 100644
--- a/devices/xantrex-trace.h
+++ b/devices/xantrex-trace.h
@@ -24,7 +24,6 @@
 #include <cstring>
 #include <vector>
 #include <map>
-#include "err.h"
 #include <console.h>
 
 #include "serial.h"

http://git.savannah.gnu.org/cgit/powerguru.git/commit/?id=d16ac0e0c02e7f03d33fafc49d47ccc14676339f


commit d16ac0e0c02e7f03d33fafc49d47ccc14676339f
Author: Rob Savoye <address@hidden>
Date:   Fri Nov 23 09:33:24 2018 -0700

    Using std::thread n C++11 now.

diff --git a/lib/thread.cc b/lib/thread.cc
deleted file mode 100644
index 45108d4..0000000
--- a/lib/thread.cc
+++ /dev/null
@@ -1,54 +0,0 @@
-// 
-// Copyright (C) 2005, 2006 - 2018
-//      Free Software Foundation, Inc.
-// 
-// This program is free software; you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation; either version 3 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 General Public License for more details.
-// 
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-#include "thread.h"
-
-
-Thread::Thread (void)
-{
-
-}
-
-Thread::~Thread (void)
-{
-}
-
-bool
-Thread::StartThread (void)
-{
-}
-
-bool
-Thread::DetachThread(void)
-{
-}
-
-bool
-Thread::SuspendThread (void)
-{
-}
-
-bool
-Thread::KillThread(void)
-{
-}
-
-// local Variables:
-// mode: C++
-// indent-tabs-mode: nil
-// End:
diff --git a/lib/thread.h b/lib/thread.h
deleted file mode 100644
index b2f34bc..0000000
--- a/lib/thread.h
+++ /dev/null
@@ -1,37 +0,0 @@
-// 
-// Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
-//      Free Software Foundation, Inc.
-// 
-// This program is free software; you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation; either version 3 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 General Public License for more details.
-// 
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-#include <stdlib.h>
-#include <sys/types.h>
-
-class Thread {
-private:
-    bool initialized;
-public:
-    Thread (void);
-    ~Thread (void);
-    bool StartThread (void);
-    bool DetachThread(void);
-    bool SuspendThread (void);
-    bool KillThread(void);
-}
-    
-// local Variables:
-// mode: C++
-// indent-tabs-mode: nil
-// End:

-----------------------------------------------------------------------

Summary of changes:
 devices/outbackpower.cc        |  23 ++-
 devices/outbackpower.h         |   5 -
 devices/ownet.cc               |   1 -
 devices/ownet.h                |   3 +-
 devices/xanbus.cc              |   1 -
 devices/xanbus.h               |   1 -
 devices/xantrex-trace.cc       |  63 +++++-
 devices/xantrex-trace.h        |   1 -
 lib/thread.cc                  |  54 -----
 lib/thread.h                   |  37 ----
 lib/xml.cc                     | 434 ++++++++++-------------------------------
 lib/xml.h                      | 115 +++++------
 testsuite/libtests/Makefile.am |  41 ++--
 testsuite/libtests/test.xml    |   5 +
 testsuite/libtests/xml-test.cc | 189 ++++++++++++++++++
 15 files changed, 457 insertions(+), 516 deletions(-)
 delete mode 100644 lib/thread.cc
 delete mode 100644 lib/thread.h
 create mode 100644 testsuite/libtests/test.xml
 create mode 100644 testsuite/libtests/xml-test.cc


hooks/post-receive
-- 
powerguru



reply via email to

[Prev in Thread] Current Thread [Next in Thread]