mirror of
git://sourceware.org/git/libabigail.git
synced 2024-12-18 16:04:34 +00:00
56d958641c
Bug URL: https://sourceware.org/bugzilla/show_bug.cgi?id=17649. abidiff stumbled accross a diff graph with cycles. And it kept walking that graph endlessly. Of course. It turned out on such graphs with cycles, the categorizing code that uses abigail::comparison::diff::traverse() to walk the graph and categorize the diff nodes was traversing the same class of equivalence of certain diff nodes more than once without even noticing. This patch changes the logic of the diff graph traversing code to make it always call diff_node_visitor::visit_begin() on the visitor for a diff node prior to visiting it (visiting means calling diff_node_visitor::visit()) and diff_node_visitor::visit_end() after visiting it. But when the diff node has already been visited and it's reached again by the traversing code (in case of a cycle) then the diff_node_visitor::visit_begin() is called, but diff_node_visitor::visit() is *NOT*. Then diff_node_visitor::visit_end() is called. In other words, even when the diff node is not visited (because it's already been visited) the pair diff_node_visitor::{visit_begin,visit_end}() is called. This avoids traversing the diff node (or rather the equivalence class of the diff node) more than once even in presence of cycles, but still gives a chance to custom visitors to detect that they are seeing a cycle and act accordingly if need be. This is a kind of cycle detection feature. Then the code of the (harmless and harmful categorization) filters has been adapted to always rely on the cycle detection feature. The code of the category propagation visitor has also been adapted to propagate the category of a given diff node to and from its canonical diff node. * include/abg-comp-filter.h (harm{less,ful}_filter::visit_end): Declare new methods. * include/abg-comparison.h (diff_context::maybe_apply_filters): Remove the traverse_nodes_once flag. * src/abg-comp-filter.cc (apply_filter): Force the traversing to operate in cycle avoidance mode. (harm{less,ful}_filter::visit): Update the category of the canonical node too. (harm{less,ful}_filter::visit_end): Define new method. * src/abg-comparison.cc (diff_context::maybe_apply_filters): Remove the traverse_nodes_once flag. Adjust. Simplify logic. (diff::traverse): Always call diff_node_visitor::{begin,end}. If the node has already been visited previously then do not call diff_node_visitor::visit() and do not visit the children nodes. (category_propagation_visitor::visit_end): If the node has already been visited, then propagate the category from the canonical nodes of the children nodes. (propagate_categories): Force the traversing to operate in cycle avoidance mode. Signed-off-by: Dodji Seketeli <dodji@redhat.com>
107 lines
3.0 KiB
C++
107 lines
3.0 KiB
C++
// -*- Mode: C++ -*-
|
|
//
|
|
// Copyright (C) 2013-2015 Red Hat, Inc.
|
|
//
|
|
// This file is part of the GNU Application Binary Interface Generic
|
|
// Analysis and Instrumentation Library (libabigail). This library 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 3, or (at your option) any
|
|
// later version.
|
|
|
|
// This library 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 Lesser Public License for more details.
|
|
|
|
// You should have received a copy of the GNU Lesser General Public
|
|
// License along with this program; see the file COPYING-LGPLV3. If
|
|
// not, see <http://www.gnu.org/licenses/>.
|
|
//
|
|
// Author: Dodji Seketeli
|
|
|
|
/// @file
|
|
///
|
|
/// This header declares filters for the diff trees resulting from
|
|
/// comparing ABI Corpora.
|
|
|
|
#ifndef __ABG_COMP_FILTER_H__
|
|
#define __ABG_COMP_FILTER_H__
|
|
|
|
#include "abg-comparison.h"
|
|
|
|
namespace abigail
|
|
{
|
|
namespace comparison
|
|
{
|
|
/// Facilities to walk, categorize and possibly filter nodes of the
|
|
/// diff tree.
|
|
namespace filtering
|
|
{
|
|
|
|
bool
|
|
has_harmless_name_change(decl_base_sptr f, decl_base_sptr s);
|
|
|
|
class filter_base;
|
|
/// Convenience typedef for a shared pointer to filter_base
|
|
typedef shared_ptr<filter_base> filter_base_sptr;
|
|
/// Convenience typedef for a vector of filter_base_sptr
|
|
typedef std::vector<filter_base_sptr> filters;
|
|
|
|
/// The base class for the diff tree node filter.
|
|
///
|
|
/// It's intended to walk a tree of diff nodes and tag each relevant
|
|
/// name into one or several categories depending on well choosen
|
|
/// properties of the diff nodes.
|
|
struct filter_base : public diff_node_visitor
|
|
{
|
|
friend void
|
|
apply_filter(filter_base_sptr f, diff_sptr deef);
|
|
}; //end class filter_base
|
|
|
|
void
|
|
apply_filter(filter_base& filter, diff_sptr d);
|
|
|
|
void
|
|
apply_filter(filter_base& filter, corpus_diff_sptr d);
|
|
|
|
void
|
|
apply_filter(filter_base_sptr filter, diff_sptr d);
|
|
|
|
class harmless_filter;
|
|
/// Convenience typedef for a shared pointer to a harmless_filter.
|
|
typedef shared_ptr<harmless_filter> harmless_filter_sptr;
|
|
|
|
/// A filter that walks the diff nodes tree and tags relevant diff
|
|
/// nodes into categories considered to represent harmless changes.
|
|
class harmless_filter : public filter_base
|
|
{
|
|
virtual bool
|
|
visit(diff*, bool);
|
|
|
|
virtual void
|
|
visit_end(diff*);
|
|
}; // end class harmless_filter
|
|
|
|
class harmful_filter;
|
|
/// A convenience typedef for a shared pointer to harmful_filter.
|
|
typedef shared_ptr<harmful_filter> harmful_filter_sptr;
|
|
|
|
/// A filter that walks the diff nodes tree and tags relevant diff
|
|
/// nodes into categories considered to represent potentially harmful
|
|
/// changes.
|
|
class harmful_filter : public filter_base
|
|
{
|
|
virtual bool
|
|
visit(diff*, bool);
|
|
|
|
virtual void
|
|
visit_end(diff*);
|
|
}; // end class harmful_filter
|
|
|
|
} // end namespace filtering
|
|
} // end namespace comparison
|
|
} // end namespace abigail
|
|
|
|
#endif // __ABG_COMP_FILTER_H__
|