Lines Matching defs:other

281 /// To implement that optimization, we need, among other things to
896 /// for now. Comparing the other sub-types of l & r will tell us later
1395 /// @param other the other tu to compare against.
1400 translation_unit::operator==(const translation_unit& other)const
1402 if (get_address_size() != other.get_address_size())
1405 return *get_global_scope() == *other.get_global_scope();
1704 // treated just as other symbols with index SHN_COMMON. If the
1714 // the first symbol with that name with type other than
2311 /// Return true if this common common symbol has other common instances.
2321 /// @return true iff the current common symbol has other common
2348 /// @param common the other common instance to add.
2439 /// @param other the elf symbol to get the potential aliases from.
2441 /// @return the alias of @p other that texually equals the current
2444 elf_symbol::get_alias_which_equals(const elf_symbol& other) const
2446 for (elf_symbol_sptr a = other.get_next_alias();
2571 /// @param other the symbol to compare against.
2574 /// other.
2576 elf_symbol::operator==(const elf_symbol& other) const
2578 bool are_equal = textually_equals(*this, other);
2580 are_equal = bool(get_alias_which_equals(other));
2586 /// @param o the other symbol to test against.
3014 /// @param o the other version to compare the current one to.
3032 /// @param o the other version to assign to this one.
3952 // instance. In other words, this is the "this pointer" of the
4615 /// other hand, the value of the 'location' attribute of an XML
4825 /// In other words if the argument for this parameter is true then the
5084 // other anymous types of the same kind.
5129 // that are aliases of each other.
5200 decl_base::operator==(const decl_base& other) const
5201 {return equals(*this, other, 0);}
5205 /// @param other to other instance of @ref decl_base to compare the
5209 /// different from @p other.
5211 decl_base::operator!=(const decl_base& other) const
5212 {return !operator==(other);}
6650 /// that case. It might contain code to strip other cases like this
7983 const scope_decl* other = dynamic_cast<const scope_decl*>(&o);
7984 if (!other)
7987 return equals(*this, *other, 0);
9581 /// - or if one type is a typedef of the other one.
9619 /// - or if one type is a typedef of the other one.
10715 /// of the underlying type of the current typedef. In other words, if
14178 // other as a struct, but are otherwise equivalent, we want their
14265 // abixml representation of the first corpus. In other
14386 // exported in the other class, and the canonical
14611 type_base::operator==(const type_base& other) const
14612 {return equals(*this, other, 0);}
14616 ///@param other the instance of @ref type_base to compare the current
14619 /// @return true iff the current instance is different from @p other.
14621 type_base::operator!=(const type_base& other) const
14622 {return !operator==(other);}
14965 /// @param other the other integral type to compare against.
14967 /// @return true iff @p other equals the current instance of @ref
14970 integral_type::operator==(const integral_type&other) const
14971 {return base_ == other.base_ && modifiers_ == other.modifiers_;}
15140 /// @param o the other type_decl to check agains.
15144 const decl_base* other = dynamic_cast<const decl_base*>(&o);
15145 if (!other)
15147 return *this == *other;
15154 /// @param o the other type_decl to check against.
15158 const type_decl* other = dynamic_cast<const type_decl*>(&o);
15159 if (!other)
15161 return try_canonical_compare(this, other);
15168 /// @param o the other type_decl to check against.
15174 const decl_base& other = o;
15175 return *this == other;
15180 /// @param o the other type to compare against.
15275 /// In other words if the argument for this parameter is true then the
15396 const scope_type_decl* other = dynamic_cast<const scope_type_decl*>(&o);
15397 if (!other)
15399 return try_canonical_compare(this, other);
15406 /// @param o the other scope_type_decl to compare against.
15412 const decl_base* other = dynamic_cast<const decl_base*>(&o);
15413 if (!other)
15416 return *this == *other;
15501 /// In other words if the argument for this parameter is true then the
15527 const namespace_decl* other = dynamic_cast<const namespace_decl*>(&o);
15528 if (!other)
15530 return scope_decl::operator==(*other);
15801 ///@param o the other qualified type to compare against.
15807 const qualified_type_def* other =
15809 if (!other)
15811 return try_canonical_compare(this, other);
15820 ///@param o the other qualified type to compare against.
15826 const decl_base* other = dynamic_cast<const decl_base*>(&o);
15827 if (!other)
15829 return *this == *other;
15838 ///@param o the other qualified type to compare against.
15844 const decl_base* other = dynamic_cast<const decl_base*>(&o);
15845 if (!other)
15847 return *this == *other;
15989 // Now we need to update other properties that depend on the new underlying type.
16266 const pointer_type_def* other = is_pointer_type(&o);
16267 if (!other)
16269 return try_canonical_compare(this, other);
16277 /// @param other the other type to compare against.
16279 /// @return true iff @p other equals the current instance.
16281 pointer_type_def::operator==(const type_base& other) const
16283 const decl_base* o = is_decl(&other);
16294 /// @param other the other type to compare against.
16296 /// @return true iff @p other equals the current instance.
16298 pointer_type_def::operator==(const pointer_type_def& other) const
16300 const decl_base& o = other;
16647 /// @param o the other instance of @ref reference_type_def to compare
16654 const reference_type_def* other =
16656 if (!other)
16658 return try_canonical_compare(this, other);
16663 /// @param o the other instance of @ref reference_type_def to compare
16670 const decl_base* other = dynamic_cast<const decl_base*>(&o);
16671 if (!other)
16673 return *this == *other;
16678 /// @param o the other instance of @ref reference_type_def to compare
16685 const decl_base* other = dynamic_cast<const decl_base*>(&o);
16686 if (!other)
16688 return *this == *other;
16745 /// In other words if the argument for this parameter is true then the
16925 /// @param v the other bound value to compare with.
17217 /// @param o the other subrange to test against.
17224 const subrange_type* other =
17226 if (!other)
17228 return try_canonical_compare(this, other);
17233 /// @param o the other subrange to test against.
17240 const decl_base* other = dynamic_cast<const decl_base*>(&o);
17241 if (!other)
17243 return *this == *other;
17248 /// @param o the other subrange to test against.
17261 /// @param o the other subrange to test against.
17277 /// In other words if the argument for this parameter is true then the
17484 /// In other words if the argument for this parameter is true then the
17624 const array_type_def* other =
17626 if (!other)
17628 return try_canonical_compare(this, other);
17634 const decl_base* other = dynamic_cast<const decl_base*>(&o);
17635 if (!other)
17637 return *this == *other;
17887 /// In other words if the argument for this parameter is true then the
18158 // One enum is decl-only while the other is not.
18278 /// @param o the other enum to test against.
18293 /// @param o the other enum to test against.
18300 const decl_base* other = dynamic_cast<const decl_base*>(&o);
18301 if (!other)
18303 return *this == *other;
18382 /// @param other enumerator to copy.
18383 enum_type_decl::enumerator::enumerator(const enumerator& other)
18384 : priv_(new priv(other.get_name(),
18385 other.get_value(),
18386 other.get_enum_type()))
18403 /// @param other the enumerator to compare to the current
18406 /// @return true if @p other equals the current instance of
18409 enum_type_decl::enumerator::operator==(const enumerator& other) const
18412 names_equal = (get_name() == other.get_name());
18413 return names_equal && (get_value() == other.get_value());
18418 /// @param other the other instance to compare against.
18420 /// @return true iff @p other is different from the current instance.
18422 enum_type_decl::enumerator::operator!=(const enumerator& other) const
18423 {return !operator==(other);}
18654 /// @param o the other typedef_decl to test against.
18658 const typedef_decl* other = dynamic_cast<const typedef_decl*>(&o);
18659 if (!other)
18661 return try_canonical_compare(this, other);
18666 /// @param o the other typedef_decl to test against.
18673 const decl_base* other = dynamic_cast<const decl_base*>(&o);
18674 if (!other)
18676 return *this == *other;
18686 /// In other words if the argument for this parameter is true then the
18959 // compare them. And then compare the other parts.
19037 const var_decl* other = dynamic_cast<const var_decl*>(&o);
19038 if (!other)
19041 return equals(*this, *other, 0);
19130 /// In other words if the argument for this parameter is true then the
19751 /// @param o the other function_type to compare against.
19755 function_type::operator==(const type_base& other) const
19757 const function_type* o = dynamic_cast<const function_type*>(&other);
19771 /// In other words if the argument for this parameter is true then the
19999 /// In other words if the argument for this parameter is true then the
20146 /// In other words if the argument for this parameter is true then the
20187 /// return type and the other specifiers of the beginning of the
20195 /// In other words if the argument for this parameter is true then the
20447 ; // the types are equal, let's move on to compare the other
20571 /// @param other the other instance of @ref function_decl to compare
20575 /// @p other.
20577 function_decl::operator==(const decl_base& other) const
20579 const function_decl* o = dynamic_cast<const function_decl*>(&other);
21033 /// In other words if the argument for this parameter is true then the
21276 /// now. Support for the other kinds of declaration is left as an
21287 // other kinds of IR node, we need more work.
21302 /// In the future, if there are other properties of this relationship
21804 /// @param other the other @ref class_or_union to compare against.
21806 /// @return true iff @p other equals the current @ref class_or_union.
21808 class_or_union::operator==(const decl_base& other) const
21810 const class_or_union* op = dynamic_cast<const class_or_union*>(&other);
21822 // Likewise for the other class.
21834 /// @param other the other @ref class_or_union to compare against.
21836 /// @return true iff @p other equals the current @ref class_or_union.
21838 class_or_union::operator==(const type_base& other) const
21840 const decl_base* o = dynamic_cast<const decl_base*>(&other);
21848 /// @param other the other @ref class_or_union to compare against.
21850 /// @return true iff @p other equals the current @ref class_or_union.
21852 class_or_union::operator==(const class_or_union& other) const
21854 const decl_base& o = other;
22267 /// In other words, during type canonicalization, if ST1' depends on a
22276 /// have its propagated canonical type cleared. In other words, its
22656 /// In other words if the argument for this parameter is true then the
22888 /// @param other the instance of @ref class_decl::base_spec to compare
22892 /// equals @p other.
22894 class_decl::base_spec::operator==(const decl_base& other) const
22897 dynamic_cast<const class_decl::base_spec*>(&other);
22907 /// @param other the instance of @ref class_decl::base_spec to compare
22911 /// equals @p other.
22913 class_decl::base_spec::operator==(const member_base& other) const
22916 dynamic_cast<const class_decl::base_spec*>(&other);
23444 /// Test if a given method is equivalent to at least of other method
23607 // functions can be clones of other functions that are among those
23631 // are still equivalent if their other properties are the same.
23715 /// @param other the instance of @ref class_decl to compare against.
23718 /// other.
23720 class_decl::operator==(const decl_base& other) const
23722 const class_decl* op = is_class_type(&other);
23736 // Likewise for the other type.
23752 /// @param other the other class_decl to compare against.
23754 /// @return true iff the current instance equals the other one.
23756 class_decl::operator==(const type_base& other) const
23758 const decl_base* o = is_decl(&other);
23766 /// @param other the instance of @ref class_decl to compare against.
23769 /// other.
23771 class_decl::operator==(const class_decl& other) const
23773 const decl_base& o = other;
24012 member_function_template::operator==(const member_base& other) const
24017 dynamic_cast<const member_function_template&>(other);
24097 /// @param other the other @ref member_class_template to compare against.
24099 /// @return true iff the current instance equals @p other.
24101 member_class_template::operator==(const member_base& other) const
24106 dynamic_cast<const member_class_template&>(other);
24120 /// @param other the other instance of @ref
24125 member_class_template::operator==(const member_class_template& other) const
24127 const decl_base* o = dynamic_cast<const decl_base*>(&other);
24490 /// In other words if the argument for this parameter is true then the
24528 /// @param other the instance of @ref union_decl to compare against.
24531 /// other.
24533 union_decl::operator==(const decl_base& other) const
24535 const union_decl* op = dynamic_cast<const union_decl*>(&other);
24545 /// @param other the other union_decl to compare against.
24547 /// @return true iff the current instance equals the other one.
24549 union_decl::operator==(const type_base& other) const
24551 const decl_base *o = dynamic_cast<const decl_base*>(&other);
24559 /// @param other the instance of @ref union_decl to compare against.
24562 /// other.
24564 union_decl::operator==(const union_decl& other) const
24566 const decl_base& o = other;
24828 /// @param o the other instance to compare against.
24936 /// @param other the other instance to compare against.
24938 /// @return true iff the other instance is different from the current
24941 template_parameter::operator!=(const template_parameter& other) const
24942 {return !operator==(other);}
24982 type_tparameter::operator==(const type_base& other) const
24984 if (!type_decl::operator==(other))
24989 const type_tparameter& o = dynamic_cast<const type_tparameter&>(other);
24997 type_tparameter::operator==(const template_parameter& other) const
25001 const type_base& o = dynamic_cast<const type_base&>(other);
25009 type_tparameter::operator==(const type_tparameter& other) const
25010 {return *this == static_cast<const type_base&>(other);}
25075 non_type_tparameter::operator==(const decl_base& other) const
25077 if (!decl_base::operator==(other))
25083 dynamic_cast<const non_type_tparameter&>(other);
25092 non_type_tparameter::operator==(const template_parameter& other) const
25096 const decl_base& o = dynamic_cast<const decl_base&>(other);
25143 template_tparameter::operator==(const type_base& other) const
25148 dynamic_cast<const template_tparameter&>(other);
25161 const template_tparameter& other =
25163 return *this == static_cast<const type_base&>(other);
25174 const template_tparameter& other =
25176 return type_base::operator==(other);
25363 /// @param other the other instance of @ref function_tdecl to compare against.
25367 function_tdecl::operator==(const decl_base& other) const
25369 const function_tdecl* o = dynamic_cast<const function_tdecl*>(&other);
25377 /// @param other the other instance of @ref function_tdecl to compare against.
25381 function_tdecl::operator==(const template_decl& other) const
25383 const function_tdecl* o = dynamic_cast<const function_tdecl*>(&other);
25391 /// @param o the other instance of @ref function_tdecl to compare against.
25525 class_tdecl::operator==(const decl_base& other) const
25529 const class_tdecl& o = dynamic_cast<const class_tdecl&>(other);
25546 class_tdecl::operator==(const template_decl& other) const
25550 const class_tdecl& o = dynamic_cast<const class_tdecl&>(other);
25728 /// type and the hash of the other properties of the decl is computed.
26340 /// In other words, after invoking this funciton,