Lines Matching defs:second
116 sorted.push_back(i->second);
134 sorted.push_back(i->second);
153 sorted.push_back(i->second);
183 sorted.push_back(i->second);
204 sorted.push_back(i->second);
227 sorted.push_back(i->second);
246 sorted.push_back(i->second);
268 sorted.push_back(i->second);
289 sorted.push_back(i->second);
309 sorted.push_back(i->second);
328 sorted.push_back(i->second);
350 sorted.push_back(i->second);
371 sorted.push_back(i->second);
392 sorted.push_back(i->second);
412 sorted.push_back(i->second);
426 sorted.push_back(i->second);
447 sorted.push_back(i->second);
468 sorted.push_back(i->second);
487 sorted.push_back(i->second);
531 sorted.push_back(i->second);
574 type_or_decl_base_sptr second = d->first_subject();
575 ABG_ASSERT(second);
579 if ((decl = is_decl(second)))
945 /// Getter for the second corpus of the corpus diff of the current
948 /// @return the second corpus of the corpus diff of the current
986 /// @param second the second decl to consider.
988 /// @return a pointer to the diff for @p first @p second if found,
992 const type_or_decl_base_sptr second) const
995 priv_->types_or_decls_diff_map.find(std::make_pair(first, second));
997 return i->second;
1005 /// @param second the second type to consider.
1007 /// @return a pointer to the diff for @p first @p second if found,
1011 const type_base_sptr second) const
1012 {return has_diff_for(first, second);}
1081 /// @param second the second decl to consider.
1086 type_or_decl_base_sptr second,
1088 {priv_->types_or_decls_diff_map[std::make_pair(first, second)] = d;}
1118 /// @param second the second subject of the diff.
1121 /// two diff subjects @p first and @p second. If no canonical diff
1126 const type_or_decl_base_sptr second) const
1127 {return has_diff_for(first, second);}
1146 /// @param second the second subject of the diff.
1151 const type_or_decl_base_sptr second,
1155 if (!has_diff_for(first, second))
1157 add_diff(first, second, d);
1168 /// @param second the second subject of the diff.
1175 const type_or_decl_base_sptr second,
1180 diff_sptr canonical = get_canonical_diff_for(first, second);
1184 set_canonical_diff_for(first, second, canonical);
1243 return reinterpret_cast<diff*>(it->second);
1826 /// declarations; the first and the second one.
1830 /// @param second_subject the second decl (subject) of the diff.
1843 /// declarations; the first and the second one.
1847 /// @param second_subject the second decl (subject) of the diff.
1946 /// Getter of the second subject of the diff.
1948 /// @return the second subject of the diff.
2470 /// @param second_subject the second subject of the diff.
2520 ABG_ASSERT(entities_are_of_distinct_kinds(first(), second()));
2533 /// @param second the second entity to consider for the diff.
2540 type_or_decl_base_sptr second,
2542 : diff(first, second, ctxt),
2544 {ABG_ASSERT(entities_are_of_distinct_kinds(first, second));}
2553 /// Getter for the second subject of the diff.
2555 /// @return the second subject of the diff.
2557 distinct_diff::second() const
2579 ss = strip_typedef(is_type(second()));
2596 /// @param second the second argument to test for similarity in kind.
2601 type_or_decl_base_sptr second)
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();}
2649 /// @param second the second entity to consider for the diff.
2657 const type_or_decl_base_sptr second,
2660 if (!distinct_diff::entities_are_of_distinct_kinds(first, second))
2663 distinct_diff_sptr result(new distinct_diff(first, second, ctxt));
2682 /// @param second the second representation of decl to consider in the
2687 ///@return the diff of the two types @p first and @p second if and
2693 const type_or_decl_base_sptr second,
2700 dynamic_pointer_cast<DiffType>(second);
2715 /// @param second the second representation of decl to consider in the
2722 const type_or_decl_base_sptr second,
2728 class_decl_sptr s = dynamic_pointer_cast<class_decl>(second);
2755 /// @param second the second entity to consider for the diff.
2763 const type_or_decl_base_sptr second,
2765 {return compute_diff_for_distinct_kinds(first, second, ctxt);}
2778 /// @param second the second type decl to consider for the diff.
2786 const type_or_decl_base_sptr& second,
2790 type_or_decl_base_sptr s = second;
3092 /// @param second the second decl to consider for the diff.
3099 const decl_base_sptr second,
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)));
3122 /// @param second the second decl to consider.
3130 const decl_base_sptr second,
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);
3152 /// @param second the second type to consider.
3160 const type_base_sptr second,
3164 s = get_type_declaration(second);
3218 /// @param second the second instance of @ref var_decl to consider in
3226 var_decl_sptr second,
3229 : decl_diff_base(first, second, ctxt),
3240 /// Getter for the second @ref var_decl of the diff.
3242 /// @return the second @ref var_decl of the diff.
3305 /// @param second the second @ref var_decl to consider for the diff.
3312 const var_decl_sptr second,
3315 var_diff_sptr d(new var_diff(first, second, diff_sptr(), ctxt));
3338 /// @param second the secon pointer to consider for the diff.
3342 pointer_type_def_sptr second,
3345 : type_diff_base(first, second, ctxt),
3356 /// Getter for the second subject of a pointer diff
3358 /// @return the second pointer considered in this pointer diff.
3436 /// @param second the pointer to consider for the diff.
3443 pointer_type_def_sptr second,
3447 second->get_pointed_to_type(),
3449 pointer_diff_sptr result(new pointer_diff(first, second, d, ctxt));
3472 /// @param second the second array_type of the diff.
3479 const array_type_def_sptr second,
3482 : type_diff_base(first, second, ctxt),
3493 /// Getter for the second array of the diff.
3495 /// @return for the second array of the diff.
3591 /// @param second the second array to consider for the diff.
3596 array_type_def_sptr second,
3600 second->get_element_type(),
3602 array_diff_sptr result(new array_diff(first, second, d, ctxt));
3623 /// @param second the second reference_type of the diff.
3627 const reference_type_def_sptr second,
3630 : type_diff_base(first, second, ctxt),
3641 /// Getter for the second reference of the diff.
3643 /// @return for the second reference of the diff.
3723 /// @param second the second reference to consider for the diff.
3728 reference_type_def_sptr second,
3732 second->get_pointed_to_type(),
3734 reference_diff_sptr result(new reference_diff(first, second, d, ctxt));
3755 /// @param second the second qualified type of the diff.
3759 qualified_type_def_sptr second,
3762 : type_diff_base(first, second, ctxt),
3773 /// Getter for the second qualified type of the diff.
3775 /// @return the second qualified type of the diff.
3870 /// @param second the second qualified type to consider for the diff.
3875 const qualified_type_def_sptr second,
3879 second->get_underlying_type(),
3881 qualified_type_diff_sptr result(new qualified_type_diff(first, second,
3959 if (j->second != n)
3961 std::make_pair(j->second, n);
3982 /// @param second the second enum type of the diff.
3989 const enum_type_decl_sptr second,
3992 : type_diff_base(first, second, ctxt),
4001 /// @return the second enum of the diff.
4082 /// @param second a pointer to the second enum_type_decl to consider.
4085 /// second.
4090 const enum_type_decl_sptr second,
4094 second->get_underlying_type(),
4096 enum_diff_sptr d(new enum_diff(first, second, ud, ctxt));
4097 if (first != second)
4101 second->get_enumerators().begin(),
4102 second->get_enumerators().end(),
4134 : it->second->second_subject());
4157 return it->second->second_var();
4181 : dynamic_pointer_cast<decl_base>(it->second->second_subject()));
4196 if (is_member_decl(i->second)
4197 && !get_member_is_static(i->second))
4215 if (is_member_decl(i->second)
4216 && !get_member_is_static(i->second))
4271 diff_sptr diff = i->second;
4364 method_decl_sptr f = i->second,
4365 s = i->second;
4397 method_decl_sptr f = i->second,
4398 s = i->second;
4496 if (*j->second != *d)
4498 compute_diff(j->second, d, context());
4600 if (is_anonymous_data_member(it->second))
4603 string deleted_dm_name = it->second->get_name();
4618 replaced_dm = is_var_decl(it->second);
4702 if (*j->second != *d)
4704 var_decl_sptr old_dm = is_var_decl(j->second);
4724 unsigned offset = get_data_member_offset(i->second);
4725 priv_->deleted_dm_by_offset_[offset] = i->second;
4733 unsigned offset = get_data_member_offset(i->second);
4734 priv_->inserted_dm_by_offset_[offset] = i->second;
4746 var_decl_sptr old_dm = is_var_decl(j->second);
4747 var_decl_sptr new_dm = is_var_decl(i->second);
4761 (i->second->first_var()->get_anon_dm_reliable_name());
4763 (i->second->second_var()->get_anon_dm_reliable_name());
4808 if (*j->second != *d)
4810 compute_diff(j->second, d, context());
4835 /// @param second_scope the second @ref class_or_union of the diff node.
4883 /// @return the second @ref class_or_union involved in the diff.
5019 changed_var_sptr changed_dm(dm, is_data_member(it->second));
5163 if (get_member_function_is_dtor(i->second)
5164 && get_member_function_is_virtual(i->second))
5215 if (j->second != b)
5217 compute_diff(j->second, b, context());
5285 if (*j->second != *mem_fn)
5287 compute_diff(static_pointer_cast<function_decl>(j->second),
5349 if (get_member_function_is_virtual(i->second))
5351 if (get_member_function_is_dtor(i->second))
5372 (!i->second->get_linkage_name().empty())
5373 ? i->second->get_linkage_name()
5374 : i->second->get_pretty_representation();
5383 if (!i->second->get_symbol()
5384 || s->lookup_function_symbol(*i->second->get_symbol()))
5402 if (get_member_function_is_virtual(i->second))
5406 if (!i->second->get_symbol()
5407 || f->lookup_function_symbol(*i->second->get_symbol()))
5454 : it->second->second_base();
5500 /// @param second_scope the second class of the diff.
5587 /// Getter of the second class involved in the diff.
5589 /// @return the second class invoveld in the diff
5656 /// @param second the second class_decl to consider.
5663 const class_decl_sptr second,
5667 s = is_class_type(look_through_decl_only_class(second));
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);
5776 /// @param second the second base spec to consider.
5783 class_decl::base_spec_sptr second,
5786 : diff(first, second, ctxt),
5797 /// Getter for the second base spec of the diff object.
5799 /// @return the second base specifier for the diff object.
5878 /// @param second the second base class specification.
5885 const class_decl::base_spec_sptr second,
5889 second->get_base_class(),
5891 base_diff_sptr changes(new base_diff(first, second, cl, ctxt));
5936 /// @param second_union the second object of the comparison.
5954 /// @return the second object of the comparison.
5995 /// @param second the second @ref union_decl to consider.
6000 const union_decl_sptr second,
6003 union_diff_sptr changes(new union_diff(first, second, ctxt));
6037 second->get_non_static_data_members().begin(),
6038 second->get_non_static_data_members().end(),
6045 second->get_mem_fns().begin(),
6046 second->get_mem_fns().end(),
6052 second->get_member_function_templates().begin(),
6053 second->get_member_function_templates().end(),
6166 if (*j->second != *decl)
6168 compute_diff(j->second, decl, context());
6182 if (*j->second != *decl)
6184 compute_diff(j->second, decl, context());
6207 priv_->removed_types_[i->first] = i->second;
6217 priv_->removed_decls_[i->first] = i->second;
6229 priv_->added_types_[i->first] = i->second;
6239 priv_->added_decls_[i->first] = i->second;
6268 /// @param second_scope the second scope to consider for the diff.
6288 /// Getter for the second scope of the diff.
6290 /// @return the second scope of the diff.
6370 /// to this instance. It returns the scope member (of the second
6374 /// @param i the index of an element of the second scope this diff
6377 /// @return the scope member of the second scope of this diff that has
6387 /// to this instance. It returns the scope member (of the second
6391 /// @param i the iterator of an element of the second scope this diff
6394 /// @return the scope member of the second scope of this diff that has
6486 /// @param second the second scope to consider in the diff
6487 /// computation. The second scope is diffed against the first scope.
6498 const scope_decl_sptr second,
6502 ABG_ASSERT(d->first_scope() == first && d->second_scope() == second);
6506 second->get_member_decls().begin(),
6507 second->get_member_decls().end(),
6523 /// @param second_scope the second scope to consider in the diff
6524 /// computation. The second scope is diffed against the first scope.
6548 /// @param second the second subject of the diff.
6555 const function_decl::parameter_sptr second,
6557 : decl_diff_base(first, second, ctxt),
6560 ABG_ASSERT(first->get_index() == second->get_index());
6562 second->get_type(),
6575 /// Getter for the second subject of this diff node.
6577 /// @return the second function_decl::parameter_sptr subject of this
6667 /// @param second the second subject of the diff.
6674 const function_decl::parameter_sptr second,
6677 if (!first || !second)
6680 fn_parm_diff_sptr result(new fn_parm_diff(first, second, ctxt));
6734 if (*k->second != *parm)
6736 compute_diff(k->second, parm, context());
6747 if (*k->second != *parm
6748 && (k->second->get_name_id() != parm_name))
6750 compute_diff(k->second, parm, context());
6752 priv_->deleted_parms_.erase(k->second->get_name_id());
6811 /// @param second the second @ref function_type subject of the diff to
6820 const function_type_sptr second,
6822 : type_diff_base(first, second, ctxt),
6833 /// Getter for the second subject of the diff.
6835 /// @return the second function type involved in the diff.
6960 /// @param second the second @ref function_type to consider for the diff.
6967 const function_type_sptr second,
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));
6980 second->get_first_parm(),
6981 second->get_parameters().end(),
7016 /// @param second the second function considered by the diff.
7023 const function_decl_sptr second,
7025 : decl_diff_base(first, second, ctxt),
7035 /// @return the second function considered by the diff.
7100 /// @param second the second function_decl to consider for the diff
7107 const function_decl_sptr second,
7110 if (!first || !second)
7112 // TODO: implement this for either first or second being NULL.
7117 second->get_type(),
7120 function_decl_diff_sptr result(new function_decl_diff(first, second,
7139 /// @param second the second subject of the diff.
7146 const type_decl_sptr second,
7148 : type_diff_base(first, second, ctxt)
7158 /// Getter for the second subject of the type_decl_diff.
7160 /// @return the second type_decl involved in the diff.
7228 /// @param second a pointer to the second type_decl to consider.
7235 const type_decl_sptr second,
7238 type_decl_diff_sptr result(new type_decl_diff(first, second, ctxt));
7269 /// @param second the second subject of the diff.
7273 /// second.
7280 const typedef_decl_sptr second,
7283 : type_diff_base(first, second, ctxt),
7294 /// Getter for the second typedef_decl involved in the diff.
7296 /// @return the second subject of the diff.
7343 decl_base_sptr second = second_typedef_decl();
7344 return !(*first_typedef_decl() == *second);
7378 /// @param second a pointer to the second typedef_decl to consider.
7385 const typedef_decl_sptr second,
7389 second->get_underlying_type(),
7391 typedef_diff_sptr result(new typedef_diff(first, second, d, ctxt));
7435 /// @param second the second translation unit to consider for this diff.
7442 translation_unit_sptr second,
7444 : scope_diff(first->get_global_scope(), second->get_global_scope(), ctxt),
7445 priv_(new priv(first, second))
7456 /// Getter for the second translation unit of this diff.
7458 /// @return the second translation unit of this diff.
7493 /// @param second the second translation_unit to consider.
7501 const translation_unit_sptr second,
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,
7515 static_pointer_cast<scope_decl>(second->get_global_scope()),
7785 i->second.insert(impacted_iface);
7805 return &i->second;
8809 function_decl_sptr f(j->second, noop_deleter());
8812 if (*j->second != *added_fn)
8830 if (second_->lookup_function_symbol(*i->second->get_symbol()))
8845 if (first_->lookup_function_symbol(*i->second->get_symbol()))
8847 else if (! i->second->get_symbol()->get_version().is_empty()
8848 && i->second->get_symbol()->get_version().is_default())
8856 if (first_->lookup_function_symbol(i->second->get_symbol()->get_name(),
8902 ABG_ASSERT(is_member_decl(k->second)
8903 && get_member_is_static(k->second));
8911 if (*j->second != *added_var)
8913 var_decl_sptr f(j->second, noop_deleter());
8934 if (second_->lookup_variable_symbol(*i->second->get_symbol()))
8948 if (first_->lookup_variable_symbol(*i->second->get_symbol()))
8950 else if (! i->second->get_symbol()->get_version().is_empty()
8951 && i->second->get_symbol()->get_version().is_default())
8959 if (first_->lookup_variable_symbol(i->second->get_symbol()->get_name(),
9151 decl_base_sptr old_type = is_decl(j->second);
9252 if (function_is_suppressed(e->second, fn_suppr,
9255 suppressed_added_fns_[e->first] = e->second;
9261 if (function_is_suppressed(e->second, fn_suppr,
9264 suppressed_deleted_fns_[e->first] = e->second;
9271 if (fn_suppr->suppresses_function_symbol(e->second,
9274 suppressed_added_unrefed_fn_syms_[e->first] = e->second;
9281 if (fn_suppr->suppresses_function_symbol(e->second,
9284 suppressed_deleted_unrefed_fn_syms_[e->first] = e->second;
9295 if (is_member_function(e->second)
9296 && get_member_function_is_virtual(e->second))
9298 function_decl *f = e->second;
9303 suppressed_added_fns_[e->first] = e->second;
9309 if (is_member_function(e->second)
9310 && get_member_function_is_virtual(e->second))
9312 function_decl *f = e->second;
9317 suppressed_deleted_fns_[e->first] = e->second;
9326 if (type_suppr->suppresses_type(e->second, ctxt))
9327 suppressed_deleted_unreachable_types_[e->first] = e->second;
9335 if (type_suppr->suppresses_type(e->second, ctxt))
9336 suppressed_added_unreachable_types_[e->first] = e->second;
9346 if (variable_is_suppressed(e->second, var_suppr,
9349 suppressed_added_vars_[e->first] = e->second;
9355 if (variable_is_suppressed(e->second, var_suppr,
9358 suppressed_deleted_vars_[e->first] = e->second;
9365 if (var_suppr->suppresses_variable_symbol(e->second,
9368 suppressed_added_unrefed_var_syms_[e->first] = e->second;
9375 if (var_suppr->suppresses_variable_symbol(e->second,
9378 suppressed_deleted_unrefed_var_syms_[e->first] = e->second;
9589 if (const var_diff* d = is_var_diff(i->second)) \
9593 if (i->second->has_local_changes()) \
9595 if (!i->second->get_canonical_diff()->to_be_reported()) \
10283 /// @param second the second corpus of the diff.
10290 corpus_sptr second,
10292 : priv_(new priv(first, second, ctxt))
10312 /// @return the second corpus of the diff.
10945 /// @param s the second @ref corpus to consider for the diff.
11033 /// @param s the second @ref corpus_group to consider for the diff.