abg-comparison.h File Reference

#include <memory>
#include <ostream>
#include <unordered_map>
#include <unordered_set>
#include "abg-corpus.h"
#include "abg-diff-utils.h"
#include "abg-reporter.h"
#include "abg-suppression.h"

Include dependency graph for abg-comparison.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	array_diff
	The abstraction of a diff between two arrays. More...
class	base_diff
	An abstraction of a diff between two instances of class_decl::base_spec. More...
class	class_diff
	This type abstracts changes for a class_decl. More...
class	class_or_union_diff
	This is the base class of class_diff and union_diff. More...
class	corpus_diff
	An abstraction of a diff between between two abi corpus. More...
class	corpus_diff::diff_stats
	This is a document class that aims to capture statistics about the changes carried by a corpus_diff type. More...
class	decl_diff_base
	The base class of diff between decls. More...
class	diff
	The abstraction of a change between two ABI artifacts, a.k.a an artifact change. More...
class	diff_context
	The context of the diff. This type holds various bits of information that is going to be used throughout the diffing of two entities and the reporting that follows. More...
class	diff_maps
	This type contains maps. Each map associates a type name to a diff of that type. Not all kinds of diffs are present; only those that carry leaf changes are, for now. More...
class	diff_node_visitor
	The base class for the node visitors. These are the types used to visit each node traversed by the diff_traversable_base::traverse() method. More...
struct	diff_sptr_hasher
	Hasher for diff_sptr. More...
class	diff_traversable_base
	The base class for the diff classes that are to be traversed. More...
class	distinct_diff
	An abstraction of a diff between entities that are of a different kind (disctinct). More...
class	enum_diff
	Abstraction of a diff between two enums. More...
class	fn_parm_diff
	Abstraction of a diff between two function parameters. More...
class	function_decl_diff
	Abstraction of a diff between two function_decl. More...
class	function_type_diff
	Abstraction of a diff between two function types. More...
class	pointer_diff
	The abstraction of a diff between two pointers. More...
class	ptr_to_mbr_diff
	The abstraction of a diff between two ptr_to_mbr_type. More...
class	qualified_type_diff
	Abstraction of a diff between two qualified types. More...
class	reference_diff
	The abstraction of a diff between two references. More...
class	scope_diff
	An abstractions of the changes between two scopes. More...
class	subrange_diff
	The abstraction of the diff between two subrange types. More...
class	translation_unit_diff
	An abstraction of a diff between two translation units. More...
class	type_decl_diff
	Abstraction of a diff between two basic type declarations. More...
class	type_diff_base
	The base class of diff between types. More...
class	typedef_diff
	Abstraction of a diff between two typedef_decl. More...
class	union_diff
class	var_diff
	Abstracts a diff between two instances of var_decl. More...

Namespaces
namespace	abigail
	Toplevel namespace for libabigail.
namespace	abigail::comparison
	utilities to compare abi artifacts
namespace	abigail::comparison::filtering
	Facilities to walk, categorize and possibly filter nodes of the diff tree.

Typedefs
typedef shared_ptr< array_diff >	array_diff_sptr
	Convenience typedef for a shared pointer on a array_diff type. More...
typedef shared_ptr< base_diff >	base_diff_sptr
	Convenience typedef for a shared pointer to a base_diff type. More...
typedef vector< base_diff_sptr >	base_diff_sptrs_type
	Convenience typedef for a vector of base_diff_sptr. More...
typedef std::pair< enum_type_decl::enumerator, enum_type_decl::enumerator >	changed_enumerator
	Convenience typedef for a changed enumerator. The first element of the pair is the old enumerator and the second one is the new enumerator. More...
typedef vector< changed_enumerator >	changed_enumerators_type
	Convenience typedef for a vector of changed enumerators. More...
typedef pair< method_decl_sptr, method_decl_sptr >	changed_member_function_sptr
	Convenience typedef for a pair of class_decl::member_function_sptr representing a changed member function. The first element of the pair is the initial member function and the second element is the changed one. More...
typedef std::pair< var_decl *, var_decl * >	changed_var_ptr
	Convenience typedef for a pair of pointer to var_decl representing a var_decl change. The first member of the pair represents the initial variable and the second member represents the changed variable. More...
typedef std::pair< var_decl_sptr, var_decl_sptr >	changed_var_sptr
	Convenience typedef for a pair of var_decl_sptr representing a var_decl change. The first member of the pair represents the initial variable and the second member represents the changed variable. More...
typedef vector< changed_var_sptr >	changed_var_sptrs_type
	Convenience typedef for a vector of @changed_var_sptr.gg381. More...
typedef shared_ptr< class_diff >	class_diff_sptr
	Convenience typedef for a shared pointer on a class_diff type. More...
typedef shared_ptr< corpus_diff >	corpus_diff_sptr
	A convenience typedef for a shared pointer to corpus_diff. More...
typedef shared_ptr< decl_diff_base >	decl_diff_base_sptr
	Convenience typedef for a shared_ptr of decl_diff_base. More...
typedef vector< decl_diff_base_sptr >	decl_diff_base_sptrs_type
	Convenience typedef for a vector of decl_diff_base_sptr. More...
typedef vector< diff * >	diff_ptrs_type
	Convenience typedef for a vector of diff*. More...
typedef vector< diff_sptr >	diff_sptrs_type
	Convenience typedef for a vector of diff_sptr. More...
typedef shared_ptr< diff_traversable_base >	diff_traversable_base_sptr
	Convenience typedef for shared_ptr on diff_traversable_base. More...
typedef shared_ptr< distinct_diff >	distinct_diff_sptr
	Convenience typedef for a shared pointer to distinct_types_diff. More...
typedef shared_ptr< enum_diff >	enum_diff_sptr
typedef shared_ptr< fn_parm_diff >	fn_parm_diff_sptr
	Convenience typedef for a shared pointer to a fn_parm_diff type. More...
typedef shared_ptr< function_decl_diff >	function_decl_diff_sptr
	Convenience typedef for a shared pointer to a function_decl type. More...
typedef vector< function_decl_diff_sptr >	function_decl_diff_sptrs_type
	Convenience typedef for a vector of function_decl_diff_sptr. More...
typedef shared_ptr< function_type_diff >	function_type_diff_sptr
	A convenience typedef for a shared pointer to function_type_type_diff. More...
typedef shared_ptr< pointer_diff >	pointer_diff_sptr
	Convenience typedef for a shared pointer on a pointer_diff type. More...
typedef unordered_map< size_t, size_t >	pointer_map
	Convenience typedef for a map of pointer values. The Key is a pointer value and the value is potentially another pointer value associated to the first one. More...
typedef shared_ptr< ptr_to_mbr_diff >	ptr_to_mbr_diff_sptr
	Typedef of a shared_ptr to ptr_to_mbr_diff. More...
typedef class shared_ptr< qualified_type_diff >	qualified_type_diff_sptr
typedef shared_ptr< reference_diff >	reference_diff_sptr
	Convenience typedef for a shared pointer on a reference_diff type. More...
typedef shared_ptr< scope_diff >	scope_diff_sptr
	Convenience typedef for a shared pointer on a scope_diff. More...
typedef unordered_map< string, base_diff_sptr >	string_base_diff_sptr_map
	Convenience typedef for a map of string and base_diff_sptr. More...
typedef unordered_map< string, class_decl::base_spec_sptr >	string_base_sptr_map
	Convenience typedef for a map of string and class_decl::basse_spec_sptr. More...
typedef unordered_map< string, changed_enumerator >	string_changed_enumerator_map
	Convenience typedef for a map which value is a changed enumerator. The key is the name of the changed enumerator. More...
typedef unordered_map< string, changed_member_function_sptr >	string_changed_member_function_sptr_map
	Convenience typedef for a hash map of strings and changed member functions. More...
typedef unordered_map< string, decl_diff_base_sptr >	string_decl_diff_base_sptr_map
	Convenience typedef for a map which value is a decl_diff_base_sptr. The key of the map is the qualified name of the changed type. More...
typedef unordered_map< string, diff * >	string_diff_ptr_map
	Convenience typedef for a map which value is a diff*. The key of the map is the qualified name of the changed type. More...
typedef unordered_map< string, diff_sptr >	string_diff_sptr_map
	Convenience typedef for a map which value is a diff_sptr. The key of the map is the qualified name of the changed type. More...
typedef unordered_map< string, elf_symbol_sptr >	string_elf_symbol_map
	Convenience typedef for a map whose key is a string and whose value is an elf_symbol_sptr. More...
typedef unordered_map< string, enum_type_decl::enumerator >	string_enumerator_map
	Convenience typedef for a map which value is an enumerator. The key is the name of the enumerator. More...
typedef unordered_map< string, fn_parm_diff_sptr >	string_fn_parm_diff_sptr_map
	Convenience typedef for a map which value is a changed function parameter and which key is the name of the function parameter. More...
typedef unordered_map< string, function_decl_diff_sptr >	string_function_decl_diff_sptr_map
	Convenience typedef for a map which key is a string and which value is a function_decl_diff_sptr. More...
typedef unordered_map< string, const function_decl * >	string_function_ptr_map
	Convenience typedef for a map which key is a string and which value is a pointer to decl_base. More...
typedef unordered_map< string, method_decl_sptr >	string_member_function_sptr_map
	Convenience typedef for a hash map of strings and member functions. More...
typedef unordered_map< string, function_decl::parameter_sptr >	string_parm_map
	Convenience typedef for a map which value is a function parameter. The key is the name of the function parm. More...
typedef unordered_map< string, type_base_sptr >	string_type_base_sptr_map
	Convenience typedef for a map which key is a string and which value is a type_base_sptr. More...
typedef unordered_map< string, type_diff_base_sptr >	string_type_diff_base_sptr_map
	Convenience typedef for a map which value is a type_diff_base_sptr. The key of the map is the qualified name of the changed type. More...
typedef unordered_map< string, var_diff_sptr >	string_var_diff_ptr_map
	Convenience typedef for a map which key is a string and which value is a var_diff_sptr. More...
typedef unordered_map< string, var_diff_sptr >	string_var_diff_sptr_map
	Convenience typedef for a map whose key is a string and whose value is a changed variable of type var_diff_sptr. More...
typedef unordered_map< string, var_decl_sptr >	string_var_ptr_map
	Convenience typedef for a map which key is a string and which value is a point to var_decl. More...
typedef shared_ptr< subrange_diff >	subrange_diff_sptr
	A convenience typedef for a shared pointer to subrange_diff type. More...
typedef shared_ptr< translation_unit_diff >	translation_unit_diff_sptr
	Convenience typedef for a shared pointer on a translation_unit_diff type. More...
typedef shared_ptr< type_decl_diff >	type_decl_diff_sptr
	Convenience typedef for a shared pointer on a type_decl_diff type. More...
typedef shared_ptr< type_diff_base >	type_diff_base_sptr
	Convenience pointer for a shared pointer to a type_diff_base. More...
typedef vector< type_diff_base_sptr >	type_diff_base_sptrs_type
	Convenience typedef for a vector of type_diff_base_sptr. More...
typedef shared_ptr< typedef_diff >	typedef_diff_sptr
	Convenience typedef for a shared pointer on a typedef_diff type. More...
typedef shared_ptr< union_diff >	union_diff_sptr
typedef unordered_set< diff_sptr, diff_sptr_hasher >	unordered_diff_sptr_set
	Convenience typedef for an unoredered set of diff_sptr. More...
typedef unordered_map< unsigned, decl_base_sptr >	unsigned_decl_base_sptr_map
	Convenience typedef for a map which key is an unsigned integer and which value is a decl_base_sptr. More...
typedef unordered_map< unsigned, fn_parm_diff_sptr >	unsigned_fn_parm_diff_sptr_map
	Convenience typedef for a map which key is an integer and which value is a changed parameter. More...
typedef unordered_map< unsigned, function_decl::parameter_sptr >	unsigned_parm_map
	Convenience typedef for a map which key is an integer and which value is a parameter. More...
typedef unordered_map< unsigned, var_diff_sptr >	unsigned_var_diff_sptr_map
	Convenience typedef for a map whose key is an unsigned int and whose value is a changed variable of type var_diff_sptr. More...
typedef shared_ptr< var_diff >	var_diff_sptr
	Convenience typedef for a shared pointer to a var_diff type. More...
typedef vector< var_diff_sptr >	var_diff_sptrs_type
	Convenience typedef for a vector of var_diff_sptr. More...

Enumerations
enum	diff_category {   NO_CHANGE_CATEGORY , ACCESS_CHANGE_CATEGORY , COMPATIBLE_TYPE_CHANGE_CATEGORY , HARMLESS_DECL_NAME_CHANGE_CATEGORY ,   NON_VIRT_MEM_FUN_CHANGE_CATEGORY , STATIC_DATA_MEMBER_CHANGE_CATEGORY , HARMLESS_ENUM_CHANGE_CATEGORY , HARMLESS_SYMBOL_ALIAS_CHANGE_CATEGORY ,   HARMLESS_UNION_OR_CLASS_CHANGE_CATEGORY , HARMLESS_DATA_MEMBER_CHANGE_CATEGORY , SUPPRESSED_CATEGORY , PRIVATE_TYPE_CATEGORY ,   SIZE_OR_OFFSET_CHANGE_CATEGORY , VIRTUAL_MEMBER_CHANGE_CATEGORY , REFERENCE_LVALUENESS_CHANGE_CATEGORY , NON_COMPATIBLE_DISTINCT_CHANGE_CATEGORY ,   NON_COMPATIBLE_NAME_CHANGE_CATEGORY , REDUNDANT_CATEGORY , TYPE_DECL_ONLY_DEF_CHANGE_CATEGORY , FN_PARM_TYPE_TOP_CV_CHANGE_CATEGORY ,   FN_PARM_TYPE_CV_CHANGE_CATEGORY , FN_RETURN_TYPE_CV_CHANGE_CATEGORY , FN_PARM_ADD_REMOVE_CHANGE_CATEGORY , VAR_TYPE_CV_CHANGE_CATEGORY ,   VOID_PTR_TO_PTR_CHANGE_CATEGORY , BENIGN_INFINITE_ARRAY_CHANGE_CATEGORY , HAS_ALLOWED_CHANGE_CATEGORY , HAS_DESCENDANT_WITH_ALLOWED_CHANGE_CATEGORY ,   HAS_PARENT_WITH_ALLOWED_CHANGE_CATEGORY , EVERYTHING_CATEGORY }
	An enum for the different categories that a diff tree node falls into, regarding the kind of changes it represents. More...
enum	visiting_kind { DEFAULT_VISITING_KIND , SKIP_CHILDREN_VISITING_KIND , DO_NOT_MARK_VISITED_NODES_AS_VISITED }
	An enum for the different ways to visit a diff tree node. More...

Functions
void	apply_filters (corpus_diff_sptr diff_tree)
	Apply the diff tree filters that have been associated to the context of the a given corpus_diff tree. As a result, the nodes of the @diff tree are going to be categorized into one of several of the categories of diff_category. More...
void	apply_suppressions (const corpus_diff *diff_tree)
	Walk a corpus_diff tree and appply the suppressions carried by the context. If the suppression applies to a given node then categorize the node into the SUPPRESSED_CATEGORY category and propagate that categorization. More...
void	apply_suppressions (corpus_diff_sptr diff_tree)
	Walk a diff tree and appply the suppressions carried by the context. If the suppression applies to a given node than categorize the node into the SUPPRESSED_CATEGORY category and propagate that categorization. More...
void	apply_suppressions (diff *diff_tree)
	Walk a given diff-sub tree and appply the suppressions carried by the context. If the suppression applies to a given node than categorize the node into the SUPPRESSED_CATEGORY category and propagate that categorization. More...
void	apply_suppressions (diff_sptr diff_tree)
	Walk a given diff-sub tree and appply the suppressions carried by the context. If the suppression applies to a given node than categorize the node into the SUPPRESSED_CATEGORY category and propagate that categorization. More...
void	categorize_redundancy (corpus_diff *diff_tree)
	Walk a given corpus_diff tree to categorize each of the nodes with respect to the REDUNDANT_CATEGORY. More...
void	categorize_redundancy (corpus_diff_sptr diff_tree)
	Walk a given corpus_diff tree to categorize each of the nodes with respect to the REDUNDANT_CATEGORY. More...
void	categorize_redundancy (diff *diff_tree)
	Walk a given diff sub-tree to categorize each of the nodes with respect to the REDUNDANT_CATEGORY. More...
void	categorize_redundancy (diff_sptr diff_tree)
	Walk a given diff sub-tree to categorize each of the nodes with respect to the REDUNDANT_CATEGORY. More...
void	clear_redundancy_categorization (corpus_diff *diff_tree)
	Walk a given corpus_diff tree to clear the REDUNDANT_CATEGORY out of the category of the nodes. More...
void	clear_redundancy_categorization (corpus_diff_sptr diff_tree)
	Walk a given corpus_diff tree to clear the REDUNDANT_CATEGORY out of the category of the nodes. More...
void	clear_redundancy_categorization (diff *diff_tree)
	Walk a given diff sub-tree to clear the REDUNDANT_CATEGORY out of the category of the nodes. More...
void	clear_redundancy_categorization (diff_sptr diff_tree)
	Walk a given diff sub-tree to clear the REDUNDANT_CATEGORY out of the category of the nodes. More...
subrange_diff_sptr	compute_diff (array_type_def::subrange_sptr first, array_type_def::subrange_sptr second, diff_context_sptr ctxt)
	Compute the diff between two instances of subrange_diff. More...
array_diff_sptr	compute_diff (array_type_def_sptr first, array_type_def_sptr second, diff_context_sptr ctxt)
	Compute the diff between two arrays. More...
base_diff_sptr	compute_diff (const class_decl::base_spec_sptr first, const class_decl::base_spec_sptr second, diff_context_sptr ctxt)
	Constructs the diff object representing a diff between two base class specifications. More...
class_diff_sptr	compute_diff (const class_decl_sptr first, const class_decl_sptr second, diff_context_sptr ctxt)
	Compute the set of changes between two instances of class_decl. More...
corpus_diff_sptr	compute_diff (const corpus_group_sptr &f, const corpus_group_sptr &s, diff_context_sptr ctxt)
	Compute the diff between two instances of corpus_group. More...
corpus_diff_sptr	compute_diff (const corpus_sptr f, const corpus_sptr s, diff_context_sptr ctxt)
	Compute the diff between two instances of corpus. More...
diff_sptr	compute_diff (const decl_base_sptr first, const decl_base_sptr second, diff_context_sptr ctxt)
	Compute the difference between two decls. The decls can represent either type declarations, or non-type declaration. More...
enum_diff_sptr	compute_diff (const enum_type_decl_sptr first, const enum_type_decl_sptr second, diff_context_sptr ctxt)
	Compute the set of changes between two instances of enum_type_decl. More...
fn_parm_diff_sptr	compute_diff (const function_decl::parameter_sptr first, const function_decl::parameter_sptr second, diff_context_sptr ctxt)
	Compute the difference between two function_decl::parameter_sptr; that is, between two function parameters. Return a resulting fn_parm_diff_sptr that represents the changes. More...
function_decl_diff_sptr	compute_diff (const function_decl_sptr first, const function_decl_sptr second, diff_context_sptr ctxt)
	Compute the diff between two function_decl. More...
function_type_diff_sptr	compute_diff (const function_type_sptr first, const function_type_sptr second, diff_context_sptr ctxt)
	Compute the diff between two instances of function_type. More...
ptr_to_mbr_diff_sptr	compute_diff (const ptr_to_mbr_type_sptr &first, const ptr_to_mbr_type_sptr &second, diff_context_sptr &ctxt)
	Compute the diff between two ptr_to_mbr_type types. More...
qualified_type_diff_sptr	compute_diff (const qualified_type_def_sptr first, const qualified_type_def_sptr second, diff_context_sptr ctxt)
	Compute the diff between two qualified types. More...
scope_diff_sptr	compute_diff (const scope_decl_sptr first, const scope_decl_sptr second, scope_diff_sptr d, diff_context_sptr ctxt)
	Compute the diff between two scopes. More...
scope_diff_sptr	compute_diff (const scope_decl_sptr first_scope, const scope_decl_sptr second_scope, diff_context_sptr ctxt)
	Compute the diff between two scopes. More...
translation_unit_diff_sptr	compute_diff (const translation_unit_sptr first, const translation_unit_sptr second, diff_context_sptr ctxt)
	Compute the diff between two translation_units. More...
diff_sptr	compute_diff (const type_base_sptr first, const type_base_sptr second, diff_context_sptr ctxt)
	Compute the difference between two types. More...
type_decl_diff_sptr	compute_diff (const type_decl_sptr first, const type_decl_sptr second, diff_context_sptr ctxt)
	Compute a diff between two type_decl. More...
typedef_diff_sptr	compute_diff (const typedef_decl_sptr first, const typedef_decl_sptr second, diff_context_sptr ctxt)
	Compute a diff between two typedef_decl. More...
union_diff_sptr	compute_diff (const union_decl_sptr first, const union_decl_sptr second, diff_context_sptr ctxt)
	Compute the difference between two union_decl types. More...
var_diff_sptr	compute_diff (const var_decl_sptr first, const var_decl_sptr second, diff_context_sptr ctxt)
	Compute the diff between two instances of var_decl. More...
pointer_diff_sptr	compute_diff (pointer_type_def_sptr first, pointer_type_def_sptr second, diff_context_sptr ctxt)
	Compute the diff between between two pointers. More...
reference_diff_sptr	compute_diff (reference_type_def_sptr first, reference_type_def_sptr second, diff_context_sptr ctxt)
	Compute the diff between two references. More...
distinct_diff_sptr	compute_diff_for_distinct_kinds (const type_or_decl_base_sptr first, const type_or_decl_base_sptr second, diff_context_sptr ctxt)
	Try to diff entities that are of distinct kinds. More...
diff_category	get_default_harmful_categories_bitmap ()
	Getter of a bitmap made of the set of change categories that are considered harmful. More...
diff_category	get_default_harmless_categories_bitmap ()
	Getter of a bitmap made of the set of change categories that are considered harmless. More...
string	get_pretty_representation (diff *d)
	Get a copy of the pretty representation of a diff node. More...
const diff *	get_typedef_diff_underlying_type_diff (const diff *diff)
	Return the leaf underlying diff node of a typedef_diff node. More...
bool	has_basic_type_change_only (const diff *d)
	Test if a diff node is a decl diff that only carries a basic type change on its type diff sub-node. More...
const class_or_union_diff *	is_anonymous_class_or_union_diff (const diff *d)
	Test if a diff node is a class_or_union_diff between two anonymous classes or unions. More...
const subrange_diff *	is_anonymous_subrange_diff (const diff *d)
	Test if a diff node is a subrange_diff between two anonymous subranges. More...
const array_diff *	is_array_diff (const diff *diff)
	Test if a diff node is a array_diff node. More...
const base_diff *	is_base_diff (const diff *diff)
	Test if a diff node is about differences between two base class specifiers. More...
bool	is_child_node_of_base_diff (const diff *diff)
	Test if a diff node is a child node of a base diff node. More...
bool	is_child_node_of_function_parm_diff (const diff *diff)
	Test if a diff node is a child node of a function parameter diff node. More...
const class_diff *	is_class_diff (const diff *diff)
	Test if a diff node is a class_diff node. More...
const class_or_union_diff *	is_class_or_union_diff (const diff *d)
	Test if a diff node is a class_or_union_diff node. More...
const corpus_diff *	is_corpus_diff (const diff *diff)
	Test if a diff node is a corpus_diff node. More...
const decl_diff_base *	is_decl_diff (const diff *diff)
	Test if a diff node is about differences between declarations. More...
const type_decl_diff *	is_diff_of_basic_type (const diff *d)
	Test if a diff node represents a diff between two basic types. More...
const type_decl_diff *	is_diff_of_basic_type (const diff *diff, bool allow_indirect_type)
	Test if a diff node represents a diff between two basic types, or between pointers, references or qualified type to basic types. More...
const class_or_union_diff *	is_diff_of_class_or_union_type (const diff *d)
	Test if a diff node represents a diff between two class or union types. More...
bool	is_diff_of_variadic_parameter (const diff *d)
	Test if a diff node represents the difference between a variadic parameter and something else. More...
bool	is_diff_of_variadic_parameter (const diff_sptr &d)
	Test if a diff node represents the difference between a variadic parameter and something else. More...
bool	is_diff_of_variadic_parameter_type (const diff *d)
	Test if a diff node represents the difference between a variadic parameter type and something else. More...
bool	is_diff_of_variadic_parameter_type (const diff_sptr &d)
	Test if a diff node represents the difference between a variadic parameter type and something else. More...
const distinct_diff *	is_distinct_diff (const diff *diff)
	Test if a diff node is about differences between two diff nodes of different kinds. More...
const enum_diff *	is_enum_diff (const diff *diff)
	Test if a diff node is a enum_diff node. More...
const fn_parm_diff *	is_fn_parm_diff (const diff *diff)
	Test if a diff node is about differences between two function parameters. More...
const function_decl_diff *	is_function_decl_diff (const diff *diff)
	Test if a diff node is about differences between functions. More...
const function_type_diff *	is_function_type_diff (const diff *diff)
	Test if a diff node is a function_type_diff node. More...
const function_type_diff *	is_function_type_diff_with_local_changes (const diff *diff)
	Test if a given diff node carries a function type change with local changes. More...
bool	is_harmful_category (diff_category c)
	Test if an instance of diff_category (a category bit-field) is harmful or not. More...
const pointer_diff *	is_pointer_diff (const diff *diff)
	Test if a diff node is about differences between two pointers. More...
const qualified_type_diff *	is_qualified_type_diff (const diff *diff)
	Test if a diff node is about differences between two qualified types. More...
const reference_diff *	is_reference_diff (const diff *diff)
	Test if a diff node is about differences between two references. More...
const subrange_diff *	is_subrange_diff (const diff *diff)
	Test if a diff node is a subrange_diff node. More...
const type_diff_base *	is_type_diff (const diff *diff)
	Test if a diff node is about differences between types. More...
const typedef_diff *	is_typedef_diff (const diff *diff)
	Test if a diff node is a typedef_diff node. More...
const union_diff *	is_union_diff (const diff *diff)
	Test if a diff node is a union_diff node. More...
const var_diff *	is_var_diff (const diff *diff)
	Test if a diff node is about differences between variables. More...
diff_category	operator& (diff_category c1, diff_category c2)
visiting_kind	operator& (visiting_kind l, visiting_kind r)
	The overloaded and operator for visiting_kind. More...
diff_category &	operator&= (diff_category &c1, diff_category c2)
ostream &	operator<< (ostream &o, diff_category c)
	Serialize an instance of diff_category to an output stream. More...
diff_category	operator^ (diff_category c1, diff_category c2)
diff_category	operator| (diff_category c1, diff_category c2)
visiting_kind	operator| (visiting_kind l, visiting_kind r)
	The overloaded or operator for visiting_kind. More...
diff_category &	operator|= (diff_category &c1, diff_category c2)
diff_category	operator~ (diff_category c)
visiting_kind	operator~ (visiting_kind l)
	The overloaded 'bit inversion' operator for visiting_kind. More...
const diff *	peel_fn_parm_diff (const diff *dif)
	If a diff node is about changes between two function parameters get the diff node about changes between the types of the parameters. More...
const diff *	peel_pointer_diff (const diff *dif)
	If a diff node is about changes between two pointer types, get the diff node about changes between the underlying (pointed-to) types. More...
const diff *	peel_pointer_or_qualified_type_diff (const diff *dif)
	If a diff node is about changes between two pointer, reference or qualified types, get the diff node about changes between the underlying types. More...
const diff *	peel_qualified_diff (const diff *dif)
	If a diff node is about changes between two qualified types, get the diff node about changes between the underlying (non-qualified) types. More...
const diff *	peel_reference_diff (const diff *dif)
	If a diff node is about changes between two reference types, get the diff node about changes between the underlying (pointed-to) types. More...
const diff *	peel_typedef_diff (const diff *dif)
	If a diff node is about changes between two typedef types, get the diff node about changes between the underlying types. More...
const diff *	peel_typedef_or_qualified_type_diff (const diff *dif)
	If a diff node is about changes between two typedefs or qualified types, get the diff node about changes between the underlying types. More...
const diff *	peel_typedef_qualified_type_or_parameter_diff (const diff *dif)
	If a diff node is about changes between two typedefs or qualified types, get the diff node about changes between the underlying types. More...
void	print_category (diff_category c)
	Print a given category out to stdout for debuging purposes. More...
void	print_diff_tree (corpus_diff *diff_tree, std::ostream &out)
	Emit a textual representation of a corpus_diff tree to an output stream. More...
void	print_diff_tree (corpus_diff_sptr diff_tree, std::ostream &o)
	Emit a textual representation of a corpus_diff tree to an output stream. More...
void	print_diff_tree (diff *diff_tree, std::ostream &)
void	print_diff_tree (diff_sptr diff_tree, std::ostream &o)
	Emit a textual representation of a diff sub-tree to an output stream. More...
void	propagate_categories (corpus_diff *diff_tree)
	Visit all the nodes of a given corpus tree. For each node that has a particular category set, propagate that category set up to its parent nodes. More...
void	propagate_categories (corpus_diff_sptr diff_tree)
	Visit all the nodes of a given corpus tree. For each node that has a particular category set, propagate that category set up to its parent nodes. More...
void	propagate_categories (diff *diff_tree)
	Visit all the nodes of a given sub-tree. For each node that has a particular category set, propagate that category set up to its parent nodes. More...
void	propagate_categories (diff_sptr diff_tree)
	Visit all the nodes of a given sub-tree. For each node that has a particular category set, propagate that category set up to its parent nodes. More...