Lines Matching refs:diff
18 #include "abg-diff-utils.h"
49 class diff;
51 /// Convenience typedef for a shared_ptr for the @ref diff class
52 typedef shared_ptr<diff> diff_sptr;
54 /// Convenience typedef for a weak_ptr for the @ref diff class
55 typedef weak_ptr<diff> diff_wptr;
69 /// Convenience typedef for a vector of @ref diff*.
70 typedef vector<diff*> diff_ptrs_type;
178 /// Convenience typedef for a map which value is a diff*. The key of
180 typedef unordered_map<string, diff*> string_diff_ptr_map;
279 /// An enum for the different ways to visit a diff tree node.
308 /// The base class for the diff classes that are to be traversed.
316 /// An enum for the different categories that a diff tree node falls
328 /// enumerator classifies diff nodes as harmless or harmful.
339 /// This means the diff node does not carry any (meaningful) change,
343 /// This means the diff node (or at least one of its descendant
348 /// This means the diff node (or at least one of its descendant
353 /// This means that a diff node in the sub-tree carries a harmless
358 /// This means that a diff node in the sub-tree carries an addition
362 /// This means that a diff node in the sub-tree carries an addition
366 /// This means that a diff node in the sub-tree carries an addition
370 /// This means that a diff node in the sub-tree carries an a symbol
374 /// This means that a diff node in the sub-tree carries a harmless
378 /// This means that a diff node in the sub-tree carries a harmless
384 /// This means that a diff node was marked as suppressed by a
388 /// This means that a diff node was warked as being for a private
389 /// type. That is, the diff node is meant to be suppressed by a
394 /// This means the diff node (or at least one of its descendant
400 /// This means that a diff node in the sub-tree carries an
404 /// A diff node in this category is redundant. That means it's
405 /// present as a child of a other nodes in the diff tree.
408 /// This means that a diff node in the sub-tree carries a type that
412 /// A diff node in this category is a function parameter type which
416 /// A diff node in this category has a function parameter type with a
420 /// A diff node in this category is a function return type with a
424 /// A diff node in this category is a function (or function type)
428 /// A diff node in this category is for a variable which type holds
432 /// A diff node in this category carries a change from void pointer
436 /// A diff node in this category carries a change in the size of the
501 /// diff of that type. Not all kinds of diffs are present; only those
587 insert_diff_node(const diff *d,
591 lookup_impacted_interfaces(const diff *d) const;
597 /// The context of the diff. This type holds various bits of
613 const diff*
614 has_diff_for(const diff* d) const;
628 add_diff(const diff* d);
671 initialize_canonical_diff(const diff_sptr diff);
676 diff*
677 diff_has_been_visited(const diff*) const;
683 mark_diff_as_visited(const diff*);
689 mark_last_diff_visited_per_class_of_equivalence(const diff*);
694 const diff*
695 get_last_visited_diff_of_class_of_equivalence(const diff*);
728 maybe_apply_filters(diff_sptr diff);
731 maybe_apply_filters(corpus_diff_sptr diff);
893 /// In the grand scheme of things, a diff is strongly typed; for
898 /// from the @ref diff parent class.
908 /// In other word, the class_diff change might have a child diff node
919 /// diff::children_nodes() member function which returns generic diff
920 /// nodes. This second way enables us to walk the diff nodes graph in
921 /// a generic way, regardless of the types of the diff nodes.
923 /// Said otherwise, there are two views for a given diff node. There
933 /// deletions) for two constructs that are to be diff'ed. The two
934 /// constructs are called the "subjects" of the diff.
935 class diff : public diff_traversable_base
940 diff();
946 diff(type_or_decl_base_sptr first_subject,
949 diff(type_or_decl_base_sptr first_subject,
963 set_canonical_diff(diff *);
972 const vector<diff*>&
975 const diff*
978 diff* get_canonical_diff() const;
1055 /// This constructs the relation between this diff node and its
1056 /// detail diff nodes, in the generic view of the diff node.
1058 /// Each specific typed diff node should implement how the typed
1064 /// this diff. A length of zero means that the current instance of
1065 /// @ref diff doesn't carry any change.
1071 /// Pure interface to know if the current instance of @diff carries
1073 /// diff object itself, as opposed to a change that is carried by
1080 /// Pure interface to report the diff in a serialized form that is
1094 };// end class diff
1106 /// The base class of diff between types.
1107 class type_diff_base : public diff
1127 /// The base class of diff between decls.
1128 class decl_diff_base : public diff
1147 get_pretty_representation(diff*);
1154 /// An abstraction of a diff between entities that are of a different
1156 class distinct_diff : public diff
1207 /// Abstracts a diff between two instances of @ref var_decl
1258 /// The abstraction of a diff between two pointers.
1315 /// The abstraction of a diff between two references.
1372 /// The abstraction of a diff between two arrays.
1426 /// Abstraction of a diff between two qualified types.
1483 /// Abstraction of a diff between two enums.
1799 /// An abstraction of a diff between two instances of class_decl::base_spec.
1800 class base_diff : public diff
1856 class scope_diff : public diff
1960 /// Abstraction of a diff between two function parameters.
2012 /// Abstraction of a diff between two function types.
2086 /// Abstraction of a diff between two function_decl.
2143 /// Abstraction of a diff between two basic type declarations.
2188 /// Abstraction of a diff between two typedef_decl.
2241 const diff*
2242 get_typedef_diff_underlying_type_diff(const diff* diff);
2250 /// An abstraction of a diff between two translation units.
2289 /// An abstraction of a diff between between two abi corpus.
2318 const vector<diff*>&
2632 set_current_topmost_iface_diff(diff*);
2634 diff*
2638 visit_begin(diff*);
2644 visit_end(diff*);
2650 visit(diff*, bool);
2696 propagate_categories(diff* diff_tree);
2708 apply_suppressions(diff* diff_tree);
2720 print_diff_tree(diff* diff_tree, std::ostream&);
2735 categorize_redundancy(diff* diff_tree);
2747 clear_redundancy_categorization(diff* diff_tree);
2762 is_diff_of_variadic_parameter_type(const diff*);
2768 is_diff_of_variadic_parameter(const diff*);
2774 is_type_diff(const diff* diff);
2777 is_decl_diff(const diff* diff);
2780 is_diff_of_basic_type(const diff* diff);
2783 is_diff_of_basic_type(const diff* diff, bool);
2786 is_diff_of_class_or_union_type(const diff *d);
2789 has_basic_type_change_only(const diff* diff);
2792 is_enum_diff(const diff *diff);
2795 is_class_diff(const diff* diff);
2798 is_union_diff(const diff* diff);
2801 is_class_or_union_diff(const diff* d);
2804 is_anonymous_class_or_union_diff(const diff* d);
2807 is_array_diff(const diff* diff);
2810 is_function_type_diff(const diff* diff);
2813 is_function_type_diff_with_local_changes(const diff* diff);
2816 is_typedef_diff(const diff *diff);
2819 is_var_diff(const diff* diff);
2822 is_function_decl_diff(const diff* diff);
2825 is_pointer_diff(const diff* diff);
2828 is_reference_diff(const diff* diff);
2831 is_qualified_type_diff(const diff* diff);
2834 is_fn_parm_diff(const diff* diff);
2837 is_base_diff(const diff* diff);
2840 is_distinct_diff(const diff *diff);
2843 is_child_node_of_function_parm_diff(const diff* diff);
2846 is_child_node_of_base_diff(const diff* diff);
2849 is_corpus_diff(const diff* diff);
2851 const diff*
2852 peel_typedef_diff(const diff* dif);
2854 const diff*
2855 peel_pointer_diff(const diff* dif);
2857 const diff*
2858 peel_reference_diff(const diff* dif);
2860 const diff*
2861 peel_qualified_diff(const diff* dif);
2863 const diff*
2864 peel_fn_parm_diff(const diff* dif);
2866 const diff*
2867 peel_pointer_or_qualified_type_diff(const diff* dif);
2869 const diff*
2870 peel_typedef_or_qualified_type_diff(const diff* dif);
2872 const diff*
2873 peel_typedef_qualified_type_or_parameter_diff(const diff *dif);