xml-parser: new module for parsing XML

Only recognition (but not parsing) of valgrind's XML format implemented.

Author: kdudka

src/CMakeLists.txt

@@ -39,6 +39,7 @@ add_library(cs STATIC
     parser-common.cc
     shared-string.cc
     version.cc
+    xml-parser.cc
 )
 
 # link cslib.a and boost libraries

src/abstract-parser.cc

@@ -22,6 +22,7 @@
 #include "csparser.hh"
 #include "gcc-parser.hh"
 #include "json-parser.hh"
+#include "xml-parser.hh"
 
 AbstractParser* createParser(InStream &input)
 {
@@ -37,6 +38,10 @@ AbstractParser* createParser(InStream &input)
             // JSON
             return new JsonParser(input);
 
+        case '<':
+            // XML
+            return new XmlParser(input);
+
         case 'E':
         case '#':
             // Coverity

src/xml-parser.cc

@@ -0,0 +1,129 @@
+/*
+ * Copyright (C) 2011-2021 Red Hat, Inc.
+ *
+ * This file is part of csdiff.
+ *
+ * csdiff 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
+ * any later version.
+ *
+ * csdiff 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 csdiff.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "xml-parser.hh"
+
+#include "abstract-tree.hh"
+
+#include <boost/property_tree/xml_parser.hpp>
+
+/// tree decoder for valgrind XML output
+class ValgrindTreeDecoder: public AbstractTreeDecoder {
+    public:
+        virtual bool readNode(Defect *def, pt::ptree::const_iterator defIter);
+
+        virtual void readRoot(
+                const pt::ptree       **pDefList,
+                const pt::ptree        *root);
+};
+
+void ValgrindTreeDecoder::readRoot(
+                const pt::ptree       **pDefList,
+                const pt::ptree        *root)
+{
+    // TODO: read path to the binary and command-line args
+    *pDefList = root;
+}
+
+bool ValgrindTreeDecoder::readNode(Defect *pDef, pt::ptree::const_iterator defIter)
+{
+    // TODO
+    (void) pDef;
+    (void) defIter;
+    assert(!"implemented");
+    return false;
+}
+
+struct XmlParser::Private {
+    InStream                       &input;
+    AbstractTreeDecoder            *decoder = nullptr;
+    pt::ptree                       root;
+    const pt::ptree                *defList = nullptr;
+    pt::ptree::const_iterator       defIter = root.end();
+
+    Private(InStream &input):
+        input(input)
+    {
+    }
+
+    ~Private()
+    {
+        delete this->decoder;
+    }
+};
+
+XmlParser::XmlParser(InStream &input):
+    d(new Private(input))
+{
+    try {
+        // parse XML
+        read_xml(d->input.str(), d->root);
+
+        // recognize inner format of the XML document
+        pt::ptree *node = nullptr;
+        if (findChildOf(&node, d->root, "valgrindoutput"))
+            // valgrind XML format
+            d->decoder = new ValgrindTreeDecoder;
+        else
+            throw pt::ptree_error("unknown XML format");
+
+        // process the root node
+        d->decoder->readRoot(&d->defList, node);
+
+        // initialize the traversal through the list of defects/issues
+        d->defIter = d->defList->begin();
+    }
+    catch (pt::file_parser_error &e) {
+        d->input.handleError(e.message(), e.line());
+    }
+    catch (pt::ptree_error &e) {
+        d->input.handleError(e.what());
+    }
+}
+
+XmlParser::~XmlParser()
+{
+    delete d;
+}
+
+bool XmlParser::hasError() const
+{
+    return d->input.anyError();
+}
+
+bool XmlParser::getNext(Defect *pDef)
+{
+    if (!d->defList)
+        // initialization failed, error has already been reported
+        return false;
+
+    while (d->defList->end() != d->defIter) {
+        // get the current node and move to the next one
+        try {
+            if (d->decoder->readNode(pDef, d->defIter++))
+                return true;
+        }
+        catch (pt::ptree_error &e) {
+            d->input.handleError(e.what());
+        }
+    }
+
+    // EOF
+    return false;
+}

src/xml-parser.hh

@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2021 Red Hat, Inc.
+ *
+ * This file is part of csdiff.
+ *
+ * csdiff 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
+ * any later version.
+ *
+ * csdiff 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 csdiff.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef H_GUARD_XML_PARSER_H
+#define H_GUARD_XML_PARSER_H
+
+#include "abstract-parser.hh"
+
+class XmlParser: public AbstractParser {
+    public:
+        XmlParser(InStream &input);
+
+        virtual ~XmlParser();
+        virtual bool getNext(Defect *);
+        virtual bool hasError() const;
+
+    private:
+        XmlParser(const Parser &);
+        XmlParser& operator=(const Parser &);
+
+        struct Private;
+        Private *d;
+};
+
+#endif /* H_GUARD_XML_PARSER_H */