Lines Matching refs:first
358 /// qualified names of their first subjects.
379 /// qualified names of their first subjects.
537 /// Return the first underlying type that is not a qualified type.
540 /// @return the first underlying type that is not a qualified type, or
571 type_or_decl_base_sptr first = d->first_subject();
572 ABG_ASSERT(first);
577 if (decl_base_sptr decl = is_decl(first))
933 /// Getter for the first corpus of the corpus diff of the current context.
935 /// @return the first corpus of the corpus diff of the current
984 /// @param first the first decl to consider.
988 /// @return a pointer to the diff for @p first @p second if found,
991 diff_context::has_diff_for(const type_or_decl_base_sptr first,
995 priv_->types_or_decls_diff_map.find(std::make_pair(first, second));
1003 /// @param first the first type to consider.
1007 /// @return a pointer to the diff for @p first @p second if found,
1010 diff_context::has_diff_for_types(const type_base_sptr first,
1012 {return has_diff_for(first, second);}
1079 /// @param first the first decl to consider.
1085 diff_context::add_diff(type_or_decl_base_sptr first,
1088 {priv_->types_or_decls_diff_map[std::make_pair(first, second)] = d;}
1116 /// @param first the first subject of the diff.
1121 /// two diff subjects @p first and @p second. If no canonical diff
1125 diff_context::get_canonical_diff_for(const type_or_decl_base_sptr first,
1127 {return has_diff_for(first, second);}
1144 /// @param first the first subject of the diff.
1150 diff_context::set_canonical_diff_for(const type_or_decl_base_sptr first,
1155 if (!has_diff_for(first, second))
1157 add_diff(first, second, d);
1166 /// @param first the first subject of the diff.
1174 diff_context::set_or_get_canonical_diff_for(const type_or_decl_base_sptr first,
1180 diff_sptr canonical = get_canonical_diff_for(first, second);
1184 set_canonical_diff_for(first, second, canonical);
1233 /// @return the first diff node against which @p d is redundant.
1252 /// @return the first diff node against which @p d is redundant.
1826 /// declarations; the first and the second one.
1828 /// @param first_subject the first decl (subject) of the diff.
1843 /// declarations; the first and the second one.
1845 /// @param first_subject the first decl (subject) of the diff.
1939 /// Getter of the first subject of the diff.
1941 /// @return the first subject of the diff.
2087 /// node first.
2468 /// @param first_subject the first subject of the diff.
2520 ABG_ASSERT(entities_are_of_distinct_kinds(first(), second()));
2531 /// @param first the first entity to consider for the diff.
2539 distinct_diff::distinct_diff(type_or_decl_base_sptr first,
2542 : diff(first, second, ctxt),
2544 {ABG_ASSERT(entities_are_of_distinct_kinds(first, second));}
2546 /// Getter for the first subject of the diff.
2548 /// @return the first subject of the diff.
2550 distinct_diff::first() const
2578 type_base_sptr fs = strip_typedef(is_type(first())),
2594 /// @param first the first argument to test for similarity in kind.
2600 distinct_diff::entities_are_of_distinct_kinds(type_or_decl_base_sptr first,
2603 if (!!first != !!second)
2605 if (!first && !second)
2609 if (first == second)
2612 const type_or_decl_base &f = *first, &s = *second;
2620 {return first() != second();}
2647 /// @param first the first entity to consider for the diff.
2656 compute_diff_for_distinct_kinds(const type_or_decl_base_sptr first,
2660 if (!distinct_diff::entities_are_of_distinct_kinds(first, second))
2663 distinct_diff_sptr result(new distinct_diff(first, second, ctxt));
2679 /// @param first the first representation of decl to consider in the
2687 ///@return the diff of the two types @p first and @p second if and
2692 try_to_diff(const type_or_decl_base_sptr first,
2697 dynamic_pointer_cast<DiffType>(first))
2712 /// @param first the first representation of decl to consider in the
2721 try_to_diff<class_decl>(const type_or_decl_base_sptr first,
2726 dynamic_pointer_cast<class_decl>(first))
2753 /// @param first the first entity to consider for the diff.
2762 try_to_diff_distinct_kinds(const type_or_decl_base_sptr first,
2765 {return compute_diff_for_distinct_kinds(first, second, ctxt);}
2776 /// @param first the first type decl to consider for the diff
2785 compute_diff_for_types(const type_or_decl_base_sptr& first,
2789 type_or_decl_base_sptr f = first;
3090 /// @param first the first decl to consider for the diff
3098 compute_diff_for_decls(const decl_base_sptr first,
3105 ((d = try_to_diff<function_decl>(first, second, ctxt))
3106 || (d = try_to_diff<var_decl>(first, second, ctxt))
3107 || (d = try_to_diff_distinct_kinds(first, second, ctxt)));
3120 /// @param first the first decl to consider.
3129 compute_diff(const decl_base_sptr first,
3133 if (!first || !second)
3137 if (is_type(first) && is_type(second))
3138 d = compute_diff_for_types(first, second, ctxt);
3140 d = compute_diff_for_decls(first, second, ctxt);
3150 /// @param first the first type to consider.
3159 compute_diff(const type_base_sptr first,
3163 decl_base_sptr f = get_type_declaration(first),
3215 /// @param first the first instance of @ref var_decl to consider in
3225 var_diff::var_diff(var_decl_sptr first,
3229 : decl_diff_base(first, second, ctxt),
3233 /// Getter for the first @ref var_decl of the diff.
3235 /// @return the first @ref var_decl of the diff.
3303 /// @param first the first @ref var_decl to consider for the diff.
3311 compute_diff(const var_decl_sptr first,
3315 var_diff_sptr d(new var_diff(first, second, diff_sptr(), ctxt));
3336 /// @param first the first pointer to consider for the diff.
3341 pointer_diff::pointer_diff(pointer_type_def_sptr first,
3345 : type_diff_base(first, second, ctxt),
3349 /// Getter for the first subject of a pointer diff
3351 /// @return the first pointer considered in this pointer diff.
3434 /// @param first the pointer to consider for the diff.
3442 compute_diff(pointer_type_def_sptr first,
3446 diff_sptr d = compute_diff_for_types(first->get_pointed_to_type(),
3449 pointer_diff_sptr result(new pointer_diff(first, second, d, ctxt));
3470 /// @param first the first array_type of the diff.
3478 array_diff::array_diff(const array_type_def_sptr first,
3482 : type_diff_base(first, second, ctxt),
3486 /// Getter for the first array of the diff.
3488 /// @return the first array of the diff.
3589 /// @param first the first array to consider for the diff.
3595 compute_diff(array_type_def_sptr first,
3599 diff_sptr d = compute_diff_for_types(first->get_element_type(),
3602 array_diff_sptr result(new array_diff(first, second, d, ctxt));
3621 /// @param first the first reference_type of the diff.
3626 reference_diff::reference_diff(const reference_type_def_sptr first,
3630 : type_diff_base(first, second, ctxt),
3634 /// Getter for the first reference of the diff.
3636 /// @return the first reference of the diff.
3721 /// @param first the first reference to consider for the diff.
3727 compute_diff(reference_type_def_sptr first,
3731 diff_sptr d = compute_diff_for_types(first->get_pointed_to_type(),
3734 reference_diff_sptr result(new reference_diff(first, second, d, ctxt));
3753 /// @param first the first qualified type of the diff.
3758 qualified_type_diff::qualified_type_diff(qualified_type_def_sptr first,
3762 : type_diff_base(first, second, ctxt),
3766 /// Getter for the first qualified type of the diff.
3768 /// @return the first qualified type of the diff.
3868 /// @param first the first qualified type to consider for the diff.
3874 compute_diff(const qualified_type_def_sptr first,
3878 diff_sptr d = compute_diff_for_types(first->get_underlying_type(),
3881 qualified_type_diff_sptr result(new qualified_type_diff(first, second,
3960 priv_->changed_enumerators_[j->first] =
3980 /// @param first the first enum type of the diff.
3988 enum_diff::enum_diff(const enum_type_decl_sptr first,
3992 : type_diff_base(first, second, ctxt),
3996 /// @return the first enum of the diff.
4080 /// @param first a pointer to the first enum_type_decl to consider.
4084 /// @return the resulting diff of the two enums @p first and @p
4089 compute_diff(const enum_type_decl_sptr first,
4093 diff_sptr ud = compute_diff_for_types(first->get_underlying_type(),
4096 enum_diff_sptr d(new enum_diff(first, second, ud, ctxt));
4097 if (first != second)
4099 compute_diff(first->get_enumerators().begin(),
4100 first->get_enumerators().end(),
4743 priv_->deleted_dm_by_offset_.find(i->first);
4748 priv_->changed_dm_[i->first] =
4758 priv_->deleted_dm_by_offset_.erase(i->first);
4759 priv_->inserted_dm_by_offset_.erase(i->first);
4833 /// @param first_scope the first @ref class_or_union of the diff node.
4878 /// @return the first @ref class_or_union involved in the diff.
5017 first_class_or_union()->find_data_member(it->first);
5385 to_delete.push_back(i->first);
5408 to_delete.push_back(i->first);
5498 /// @param first_scope the first class of the diff.
5582 /// @return the first class invoveld in the diff.
5654 /// @param first the first class_decl to consider.
5662 compute_diff(const class_decl_sptr first,
5666 class_decl_sptr f = is_class_type(look_through_decl_only_class(first)),
5674 if (!ctxt->get_canonical_diff_for(first, second))
5676 // Either first or second is a decl-only class; let's set the
5680 ctxt->set_canonical_diff_for(first, second, canonical_diff);
5774 /// @param first the first base spec to consider.
5782 base_diff::base_diff(class_decl::base_spec_sptr first,
5786 : diff(first, second, ctxt),
5790 /// Getter for the first base spec of the diff object.
5792 /// @return the first base specifier for the diff object.
5876 /// @param first the first base class specification.
5884 compute_diff(const class_decl::base_spec_sptr first,
5888 class_diff_sptr cl = compute_diff(first->get_base_class(),
5891 base_diff_sptr changes(new base_diff(first, second, cl, ctxt));
5934 /// @param first_union the first object of the comparison.
5949 /// @return the first object of the comparison.
5993 /// @param first the first @ref union_decl to consider.
5999 compute_diff(const union_decl_sptr first,
6003 union_diff_sptr changes(new union_diff(first, second, ctxt));
6035 compute_diff(first->get_non_static_data_members().begin(),
6036 first->get_non_static_data_members().end(),
6043 compute_diff(first->get_mem_fns().begin(),
6044 first->get_mem_fns().end(),
6050 compute_diff(first->get_member_function_templates().begin(),
6051 first->get_member_function_templates().end(),
6205 priv_->inserted_types_.find(i->first);
6207 priv_->removed_types_[i->first] = i->second;
6215 priv_->inserted_decls_.find(i->first);
6217 priv_->removed_decls_[i->first] = i->second;
6227 priv_->deleted_types_.find(i->first);
6229 priv_->added_types_[i->first] = i->second;
6237 priv_->deleted_decls_.find(i->first);
6239 priv_->added_decls_[i->first] = i->second;
6266 /// @param first_scope the first scope to consider for the diff.
6281 /// Getter for the first scope of the diff.
6283 /// @return the first scope of the diff.
6343 /// @param i the index (in the edit script) of an element of the first
6356 /// to this instance. It returns the scope member (of the first scope
6360 /// @param i the iterator of an element of the first scope that has
6363 /// @return the scope member of the first scope of this diff that has
6401 /// from the first scope to the other.
6407 /// from the first scope to the other.
6484 /// @param first the first scope to consider in computing the diff.
6487 /// computation. The second scope is diffed against the first scope.
6497 compute_diff(const scope_decl_sptr first,
6502 ABG_ASSERT(d->first_scope() == first && d->second_scope() == second);
6504 compute_diff(first->get_member_decls().begin(),
6505 first->get_member_decls().end(),
6521 /// @param first_scope the first scope to consider in computing the diff.
6524 /// computation. The second scope is diffed against the first scope.
6546 /// @param first the first subject of the diff.
6554 fn_parm_diff::fn_parm_diff(const function_decl::parameter_sptr first,
6557 : decl_diff_base(first, second, ctxt),
6560 ABG_ASSERT(first->get_index() == second->get_index());
6561 priv_->type_diff = compute_diff(first->get_type(),
6567 /// Getter for the first subject of this diff node.
6569 /// @return the first function_decl::parameter_sptr subject of this
6665 /// @param first the first subject of the diff.
6673 compute_diff(const function_decl::parameter_sptr first,
6677 if (!first || !second)
6680 fn_parm_diff_sptr result(new fn_parm_diff(first, second, ctxt));
6808 /// @param first the first @ref function_type subject of the diff to
6819 function_type_diff::function_type_diff(const function_type_sptr first,
6822 : type_diff_base(first, second, ctxt),
6826 /// Getter for the first subject of the diff.
6828 /// @return the first function type involved in the diff.
6958 /// @param first the first @ref function_type to consider for the diff.
6966 compute_diff(const function_type_sptr first,
6970 if (!first || !second)
6972 // TODO: implement this for either first or second being NULL.
6976 function_type_diff_sptr result(new function_type_diff(first, second, ctxt));
6978 diff_utils::compute_diff(first->get_first_parm(),
6979 first->get_parameters().end(),
7014 /// @param first the first function considered by the diff.
7022 function_decl_diff::function_decl_diff(const function_decl_sptr first,
7025 : decl_diff_base(first, second, ctxt),
7030 /// @return the first function considered by the diff.
7098 /// @param first the first function_decl to consider for the diff
7106 compute_diff(const function_decl_sptr first,
7110 if (!first || !second)
7112 // TODO: implement this for either first or second being NULL.
7116 function_type_diff_sptr type_diff = compute_diff(first->get_type(),
7120 function_decl_diff_sptr result(new function_decl_diff(first, second,
7137 /// @param first the first subject of the diff.
7145 type_decl_diff::type_decl_diff(const type_decl_sptr first,
7148 : type_diff_base(first, second, ctxt)
7151 /// Getter for the first subject of the type_decl_diff.
7153 /// @return the first type_decl involved in the diff.
7225 /// @param first a pointer to the first type_decl to
7234 compute_diff(const type_decl_sptr first,
7238 type_decl_diff_sptr result(new type_decl_diff(first, second, ctxt));
7267 /// @param first the first subject of the diff.
7272 /// That is the diff between the underlying types of @p first and @p
7279 typedef_diff::typedef_diff(const typedef_decl_sptr first,
7283 : type_diff_base(first, second, ctxt),
7289 /// @return the first subject of the diff.
7376 /// @param first a pointer to the first typedef_decl to consider.
7384 compute_diff(const typedef_decl_sptr first,
7388 diff_sptr d = compute_diff_for_types(first->get_underlying_type(),
7391 typedef_diff_sptr result(new typedef_diff(first, second, d, ctxt));
7402 /// diff nodes to get the first one that is not a a @ref typedef_diff
7433 /// @param first the first translation unit to consider for this diff.
7441 translation_unit_diff::translation_unit_diff(translation_unit_sptr first,
7444 : scope_diff(first->get_global_scope(), second->get_global_scope(), ctxt),
7445 priv_(new priv(first, second))
7449 /// Getter for the first translation unit of this diff.
7451 /// @return the first translation unit of this diff.
7491 /// @param first the first translation_unit to consider.
7500 compute_diff(const translation_unit_sptr first,
7504 ABG_ASSERT(first && second);
7509 // TODO: handle first or second having empty contents.
7510 translation_unit_diff_sptr tu_diff(new translation_unit_diff(first, second,
7514 compute_diff(static_pointer_cast<scope_decl>(first->get_global_scope()),
8813 changed_fns_map_[j->first] = d;
8831 to_delete.push_back(i->first);
8846 to_delete.push_back(i->first);
8858 to_delete.push_back(i->first);
8935 to_delete.push_back(i->first);
8949 to_delete.push_back(i->first);
8961 to_delete.push_back(i->first);
9255 suppressed_added_fns_[e->first] = e->second;
9264 suppressed_deleted_fns_[e->first] = e->second;
9274 suppressed_added_unrefed_fn_syms_[e->first] = e->second;
9284 suppressed_deleted_unrefed_fn_syms_[e->first] = e->second;
9303 suppressed_added_fns_[e->first] = e->second;
9317 suppressed_deleted_fns_[e->first] = e->second;
9327 suppressed_deleted_unreachable_types_[e->first] = e->second;
9336 suppressed_added_unreachable_types_[e->first] = e->second;
9349 suppressed_added_vars_[e->first] = e->second;
9358 suppressed_deleted_vars_[e->first] = e->second;
9368 suppressed_added_unrefed_var_syms_[e->first] = e->second;
9378 suppressed_deleted_unrefed_var_syms_[e->first] = e->second;
9698 /// Upon the first invocation of this method, if the vector is empty,
10281 /// @param first the first corpus of the diff.
10289 corpus_diff::corpus_diff(corpus_sptr first,
10292 : priv_(new priv(first, second, ctxt))
10307 /// @return the first corpus of the diff.
10424 /// Getter for the variables that got deleted from the first subject
10694 /// applies the filters and suppressions only the first time it is
10696 /// corpus_diff::diff_stats that was cached after the first
10943 /// @param f the first @ref corpus to consider for the diff.
11031 /// @param f the first @ref corpus_group to consider for the diff.
11363 // the first time, then update its canonical node's category too.
11371 // first time, then let's look at the children of 'd' and
12380 /// returns the first diff node about types that are not typedefs.
12399 /// returns the first diff node about types that are not pointers.
12419 /// returns the first diff node about types that are not references.
12439 /// returns the first diff node about types that are not qualified.
12474 /// returns the first diff node about types that are not pointer,
12503 /// returns the first diff node about types that are not typedef or
12530 /// returns the first diff node about types that are neither typedef,