xref: /third_party/libabigail/src/abg-ir.cc

141 /// Equality operator.
144 /// equality operator.
147 /// right-hand-side of the equality operator.
151 operator==(const std::string& l, const interned_string& r)
152 {return r.operator==(l);}
155 operator!=(const std::string& l, const interned_string& r)
158 /// Streaming operator.
168 operator<<(std::ostream& o, const interned_string& s)
174 /// Concatenation operator.
185 operator+(const interned_string& s1,const std::string& s2)
188 /// Concatenation operator.
199 operator+(const std::string& s1, const interned_string& s2)
357   operator==(const expanded_location& l) const
365   operator<(const expanded_location& l) const
686   /// Comparison operator for two instances of @ref type_base.
697   operator()(type_base *l, type_base *r) const
707   /// Comparison operator for two instances of @ref type_base.
718   operator()(const type_base_sptr &l, const type_base_sptr &r) const
719   {return operator()(l.get(), r.get());}
721   /// Comparison operator for two instances of @ref type_base.
732   operator()(const type_base_wptr &l, const type_base_wptr &r) const
733   {return operator()(type_base_sptr(l), type_base_sptr(r));}
1400 translation_unit::operator==(const translation_unit& other)const
1408 /// Inequality operator.
1415 translation_unit::operator!=(const translation_unit& o) const
1416 {return ! operator==(o);}
1645 /// A deep comparison operator for pointers to translation units.
1653 operator==(const translation_unit_sptr& l, const translation_unit_sptr& r)
1664 /// A deep inequality operator for pointers to translation units.
1672 operator!=(const translation_unit_sptr& l, const translation_unit_sptr& r)
1673 {return !operator==(l, r);}
2576 elf_symbol::operator==(const elf_symbol& other) const
2608 /// Equality operator for smart pointers to elf_symbol.
2616 operator==(const elf_symbol_sptr& lhs, const elf_symbol_sptr& rhs)
2627 /// Inequality operator for smart pointers to elf_symbol.
2635 operator!=(const elf_symbol_sptr& lhs, const elf_symbol_sptr& rhs)
2636 {return !operator==(lhs, rhs);}
2715 operator<<(std::ostream& o, elf_symbol::type t)
2765 operator<<(std::ostream& o, elf_symbol::binding b)
2803 operator<<(std::ostream& o, elf_symbol::visibility v)
2977 elf_symbol::version::operator const string&() const
3018 elf_symbol::version::operator==(const elf_symbol::version& o) const
3021 /// Inequality operator.
3027 elf_symbol::version::operator!=(const version& o) const
3028 {return !operator==(o);}
3036 elf_symbol::version::operator=(const elf_symbol::version& o)
3103 dm_context_rel::operator==(const dm_context_rel& o) const
3105   if (!context_rel::operator==(o))
3113 dm_context_rel::operator!=(const dm_context_rel& o) const
3114 {return !operator==(o);}
3232   /// The "Less Than" comparison operator of this functor.
3240   operator()(const decl_base *f,
3280   /// The "Less Than" comparison operator of this functor.
3288   operator()(const decl_base_sptr &f,
3290   {return operator()(f.get(), s.get());}
3325   /// The "Less Than" comparison operator of this functor.
3333   operator()(const type_base_sptr &f,
3335   {return operator()(f.get(), s.get());}
3337   /// The "Less Than" comparison operator of this functor.
3345   operator()(const type_base *f,
4000 /// bitwise "OR" operator for the type_or_decl_base::type_or_decl_kind
4003 operator|(type_or_decl_base::type_or_decl_kind l,
4010 /// bitwise "|=" operator for the type_or_decl_base::type_or_decl_kind
4013 operator|=(type_or_decl_base::type_or_decl_kind& l,
4020 /// bitwise "AND" operator for the
4023 operator&(type_or_decl_base::type_or_decl_kind l,
4030 /// bitwise "A&=" operator for the
4033 operator&=(type_or_decl_base::type_or_decl_kind& l,
4277 /// Non-member equality operator for the @type_or_decl_base type.
4285 operator==(const type_or_decl_base& lr, const type_or_decl_base& rr)
4311 /// Non-member equality operator for the @type_or_decl_base type.
4319 operator==(const type_or_decl_base_sptr& l, const type_or_decl_base_sptr& r)
4330 /// Non-member inequality operator for the @type_or_decl_base type.
4334 /// @param r the right-hand operator of the equality.
4338 operator!=(const type_or_decl_base_sptr& l, const type_or_decl_base_sptr& r)
4339 {return !operator==(l, r);}
4972 operator|(change_kind l, change_kind r)
4979 operator&(change_kind l, change_kind r)
4986 operator|=(change_kind& l, change_kind r)
4993 operator&=(change_kind& l, change_kind r)
5200 decl_base::operator==(const decl_base& other) const
5203 /// Inequality operator.
5211 decl_base::operator!=(const decl_base& other) const
5212 {return !operator==(other);}
5248 /// Streaming operator for the decl_base::visibility.
5256 operator<<(std::ostream& o, decl_base::visibility v)
5280 /// Streaming operator for decl_base::binding.
5288 operator<<(std::ostream& o, decl_base::binding b)
5323 operator==(const decl_base_sptr& l, const decl_base_sptr& r)
5333 /// Inequality operator of shared_ptr of @ref decl_base.
5335 /// This is a deep equality operator, that is, it compares the
5344 operator!=(const decl_base_sptr& l, const decl_base_sptr& r)
5345 {return !operator==(l, r);}
5359 operator==(const type_base_sptr& l, const type_base_sptr& r)
5381 operator!=(const type_base_sptr& l, const type_base_sptr& r)
5382 {return !operator==(l, r);}
7476 canonical_type_hash::operator()(const type_base_sptr& l) const
7477 {return operator()(l.get());}
7485 canonical_type_hash::operator()(const type_base *l) const
7936   if (!l.decl_base::operator==(r))
7981 scope_decl::operator==(const decl_base& o) const
7990 /// Equality operator for @ref scope_decl_sptr.
7992 /// @param l the left hand side operand of the equality operator.
7994 /// @pram r the right hand side operand of the equalify operator.
7998 operator==(const scope_decl_sptr& l, const scope_decl_sptr& r)
8007 /// Inequality operator for @ref scope_decl_sptr.
8009 /// @param l the left hand side operand of the equality operator.
8011 /// @pram r the right hand side operand of the equalify operator.
8015 operator!=(const scope_decl_sptr& l, const scope_decl_sptr& r)
8016 {return !operator==(l, r);}
14611 type_base::operator==(const type_base& other) const
14614 /// Inequality operator.
14621 type_base::operator!=(const type_base& other) const
14622 {return !operator==(other);}
14680 /// Bitwise OR operator for integral_type::modifiers_type.
14688 operator|(integral_type::modifiers_type l, integral_type::modifiers_type r)
14695 /// Bitwise AND operator for integral_type::modifiers_type.
14703 operator&(integral_type::modifiers_type l, integral_type::modifiers_type r)
14710 /// Bitwise one's complement operator for integral_type::modifiers_type.
14716 /// @return the result of the bitwise one's complement operator.
14718 operator~(integral_type::modifiers_type l)
14723 /// Bitwise |= operator for integral_type::modifiers_type.
14731 operator|=(integral_type::modifiers_type& l, integral_type::modifiers_type r)
14737 /// Bitwise &= operator for integral_type::modifiers_type.
14745 operator&=(integral_type::modifiers_type& l, integral_type::modifiers_type r)
14963 /// Equality operator for the @ref integral_type.
14970 integral_type::operator==(const integral_type&other) const
15035 integral_type::operator string() const
15136 /// This operator re-uses the overload that takes a decl_base.
15142 type_decl::operator==(const type_base& o) const
15156 type_decl::operator==(const decl_base& o) const
15172 type_decl::operator==(const type_decl& o) const
15178 /// Inequality operator.
15184 type_decl::operator!=(const type_decl& o) const
15185 {return !operator==(o);}
15187 /// Equality operator for @ref type_decl_sptr.
15195 operator==(const type_decl_sptr& l, const type_decl_sptr& r)
15204 /// Inequality operator for @ref type_decl_sptr.
15212 operator!=(const type_decl_sptr& l, const type_decl_sptr& r)
15213 {return !operator==(l, r);}
15387 /// Equality operator between two scope_type_decl.
15394 scope_type_decl::operator==(const decl_base& o) const
15402 /// Equality operator between two scope_type_decl.
15404 /// This re-uses the equality operator that takes a decl_base.
15410 scope_type_decl::operator==(const type_base& o) const
15525 namespace_decl::operator==(const decl_base& o) const
15530   return scope_decl::operator==(*other);
15797 /// Equality operator for qualified types.
15805 qualified_type_def::operator==(const decl_base& o) const
15814 /// Equality operator for qualified types.
15817 /// Also, this re-uses the equality operator above that takes a
15824 qualified_type_def::operator==(const type_base& o) const
15832 /// Equality operator for qualified types.
15835 /// Also, this re-uses the equality operator above that takes a
15842 qualified_type_def::operator==(const qualified_type_def& o) const
16006 /// Non-member equality operator for @ref qualified_type_def
16008 /// @param l the left-hand side of the equality operator
16010 /// @param r the right-hand side of the equality operator
16014 operator==(const qualified_type_def_sptr& l, const qualified_type_def_sptr& r)
16024 /// Non-member inequality operator for @ref qualified_type_def
16026 /// @param l the left-hand side of the equality operator
16028 /// @param r the right-hand side of the equality operator
16032 operator!=(const qualified_type_def_sptr& l, const qualified_type_def_sptr& r)
16033 {return ! operator==(l, r);}
16035 /// Overloaded bitwise OR operator for cv qualifiers.
16037 operator|(qualified_type_def::CV lhs, qualified_type_def::CV rhs)
16043 /// Overloaded bitwise |= operator for cv qualifiers.
16045 operator|=(qualified_type_def::CV& l, qualified_type_def::CV r)
16051 /// Overloaded bitwise &= operator for cv qualifiers.
16053 operator&=(qualified_type_def::CV& l, qualified_type_def::CV r)
16059 /// Overloaded bitwise AND operator for CV qualifiers.
16061 operator&(qualified_type_def::CV lhs, qualified_type_def::CV rhs)
16067 /// Overloaded bitwise inverting operator for CV qualifiers.
16069 operator~(qualified_type_def::CV q)
16072 /// Streaming operator for qualified_type_decl::CV
16080 operator<<(std::ostream& o, qualified_type_def::CV cv)
16264 pointer_type_def::operator==(const decl_base& o) const
16281 pointer_type_def::operator==(const type_base& other) const
16298 pointer_type_def::operator==(const pointer_type_def& other) const
16447 operator==(const pointer_type_def_sptr& l, const pointer_type_def_sptr& r)
16469 operator!=(const pointer_type_def_sptr& l, const pointer_type_def_sptr& r)
16470 {return !operator==(l, r);}
16645 /// Equality operator of the @ref reference_type_def type.
16652 reference_type_def::operator==(const decl_base& o) const
16661 /// Equality operator of the @ref reference_type_def type.
16668 reference_type_def::operator==(const type_base& o) const
16676 /// Equality operator of the @ref reference_type_def type.
16683 reference_type_def::operator==(const reference_type_def& o) const
16812 operator==(const reference_type_def_sptr& l, const reference_type_def_sptr& r)
16834 operator!=(const reference_type_def_sptr& l, const reference_type_def_sptr& r)
16835 {return !operator==(l, r);}
16923 /// Equality operator of the bound value.
16929 array_type_def::subrange_type::bound_value::operator==(const bound_value& v) const
17215 /// Equality operator.
17222 array_type_def::subrange_type::operator==(const decl_base& o) const
17231 /// Equality operator.
17238 array_type_def::subrange_type::operator==(const type_base& o) const
17246 /// Equality operator.
17253 array_type_def::subrange_type::operator==(const subrange_type& o) const
17256   return operator==(t);
17259 /// Inequality operator.
17266 array_type_def::subrange_type::operator!=(const subrange_type& o) const
17267 {return !operator==(o);}
17622 array_type_def::operator==(const decl_base& o) const
17632 array_type_def::operator==(const type_base& o) const
17999   if (!(l.decl_base::operator==(r) && l.type_base::operator==(r)))
18004 	  if (!l.decl_base::operator==(r))
18006 	  if (!l.type_base::operator==(r))
18186   if (!(def1->decl_base::operator==(*def2)
18187 	&& def1->type_base::operator==(*def2)))
18192 	  if (!def1->decl_base::operator==(*def2))
18194 	  if (!def1->type_base::operator==(*def2))
18276 /// Equality operator.
18283 enum_type_decl::operator==(const decl_base& o) const
18291 /// Equality operator.
18298 enum_type_decl::operator==(const type_base& o) const
18306 /// Equality operator for @ref enum_type_decl_sptr.
18314 operator==(const enum_type_decl_sptr& l, const enum_type_decl_sptr& r)
18324 /// Inequality operator for @ref enum_type_decl_sptr.
18332 operator!=(const enum_type_decl_sptr& l, const enum_type_decl_sptr& r)
18333 {return !operator==(l, r);}
18389 /// Assignment operator of the @ref enum_type_decl::enumerator type.
18393 enum_type_decl::enumerator::operator=(const enumerator& o)
18401 /// Equality operator
18409 enum_type_decl::enumerator::operator==(const enumerator& other) const
18416 /// Inequality operator.
18422 enum_type_decl::enumerator::operator!=(const enumerator& other) const
18423 {return !operator==(other);}
18629   if (!(l.decl_base::operator==(r)))
18652 /// Equality operator
18656 typedef_decl::operator==(const decl_base& o) const
18664 /// Equality operator
18671 typedef_decl::operator==(const type_base& o) const
18988       bool decl_bases_different = !l.decl_base::operator==(r);
19002     if (!l.decl_base::operator==(r))
19029 /// Comparison operator of @ref var_decl.
19035 var_decl::operator==(const decl_base& o) const
19483 /// This is a subroutine of the equality operator of function_type.
19524   if (!l.type_base::operator==(r))
19749 /// Equality operator for function_type.
19755 function_type::operator==(const type_base& other) const
20497       bool decl_bases_different = !l.decl_base::operator==(r);
20514     if (!l.decl_base::operator==(r))
20569 /// Comparison operator for @ref function_decl.
20577 function_decl::operator==(const decl_base& other) const
20691 /// A deep comparison operator for a shared pointer to @ref function_decl
20698 /// @param l the left-hand side argument of the equality operator.
20700 /// @param r the right-hand side argument of the equality operator.
20704 operator==(const function_decl_sptr& l, const function_decl_sptr& r)
20714 /// A deep inequality operator for smart pointers to functions.
20716 /// @param l the left-hand side argument of the inequality operator.
20718 /// @pram r the right-hand side argument of the inequality operator.
20722 operator!=(const function_decl_sptr& l, const function_decl_sptr& r)
20723 {return !operator==(l, r);}
20935 function_decl::parameter::operator==(const parameter& o) const
20939 function_decl::parameter::operator==(const decl_base& o) const
20945   return function_decl::parameter::operator==(*p);
20948 /// Non-member equality operator for @ref function_decl::parameter.
20950 /// @param l the left-hand side of the equality operator
20952 /// @param r the right-hand side of the equality operator
20956 operator==(const function_decl::parameter_sptr& l,
20966 /// Non-member inequality operator for @ref function_decl::parameter.
20968 /// @param l the left-hand side of the equality operator
20970 /// @param r the right-hand side of the equality operator
20974 operator!=(const function_decl::parameter_sptr& l,
20976 {return !operator==(l, r);}
21802 /// Equality operator.
21808 class_or_union::operator==(const decl_base& other) const
21832 /// Equality operator.
21838 class_or_union::operator==(const type_base& other) const
21846 /// Equality operator.
21852 class_or_union::operator==(const class_or_union& other) const
21855   return class_or_union::operator==(o);
21974 	      if (!(l.decl_base::operator==(r)
21975 		       && l.type_base::operator==(r)))
21995   if (!(l.decl_base::operator==(r) && l.type_base::operator==(r)))
22876   if (!l.member_base::operator==(r))
22886 /// Comparison operator for @ref class_decl::base_spec.
22894 class_decl::base_spec::operator==(const decl_base& other) const
22905 /// Comparison operator for @ref class_decl::base_spec.
22913 class_decl::base_spec::operator==(const member_base& other) const
22920   return operator==(static_cast<const decl_base&>(*o));
23079 /// Equality operator for @ref method_decl_sptr.
23081 /// This is a deep equality operator, as it compares the @ref
23084 /// @param l the left-hand side argument of the equality operator.
23086 /// @param r the righ-hand side argument of the equality operator.
23090 operator==(const method_decl_sptr& l, const method_decl_sptr& r)
23100 /// Inequality operator for @ref method_decl_sptr.
23102 /// This is a deep equality operator, as it compares the @ref
23105 /// @param l the left-hand side argument of the equality operator.
23107 /// @param r the righ-hand side argument of the equality operator.
23111 operator!=(const method_decl_sptr& l, const method_decl_sptr& r)
23112 {return !operator==(l, r);}
23151   /// The less than operator.  First, it sorts the methods by their
23165   operator()(const method_decl& f,
23212   /// The less than operator.  First, it sorts the methods by their
23224   operator()(const method_decl_sptr f,
23226   {return operator()(*f, *s);}
23713 /// Comparison operator for @ref class_decl.
23720 class_decl::operator==(const decl_base& other) const
23748 /// Equality operator for class_decl.
23750 /// Re-uses the equality operator that takes a decl_base.
23756 class_decl::operator==(const type_base& other) const
23764 /// Comparison operator for @ref class_decl.
23771 class_decl::operator==(const class_decl& other) const
23789 operator==(const class_decl_sptr& l, const class_decl_sptr& r)
23811 operator!=(const class_decl_sptr& l, const class_decl_sptr& r)
23812 {return !operator==(l, r);}
23817 /// @param l the left-hand-side operand of the operator
23819 /// @param r the right-hand-side operand of the operator.
23823 operator==(const class_or_union_sptr& l, const class_or_union_sptr& r)
23836 /// @param l the left-hand-side operand of the operator
23838 /// @param r the right-hand-side operand of the operator.
23842 operator!=(const class_or_union_sptr& l, const class_or_union_sptr& r)
23843 {return !operator==(l, r);}
23945 member_base::operator==(const member_base& o) const
23951 /// Equality operator for smart pointers to @ref
23962 operator==(const class_decl::base_spec_sptr& l,
23973 /// Inequality operator for smart pointers to @ref
23984 operator!=(const class_decl::base_spec_sptr& l,
23986 {return !operator==(l, r);}
24012 member_function_template::operator==(const member_base& other) const
24021 	    && member_base::operator==(o)))
24028 	    return ftdecl->function_tdecl::operator==(*other_ftdecl);
24036 /// Equality operator for smart pointers to @ref
24046 operator==(const member_function_template_sptr& l,
24057 /// Inequality operator for smart pointers to @ref
24067 operator!=(const member_function_template_sptr& l,
24069 {return !operator==(l, r);}
24095 /// Equality operator of the the @ref member_class_template class.
24101 member_class_template::operator==(const member_base& other) const
24108       if (!member_base::operator==(o))
24111       return as_class_tdecl()->class_tdecl::operator==(o);
24117 /// Comparison operator for the @ref member_class_template
24125 member_class_template::operator==(const member_class_template& other) const
24131 /// Comparison operator for the @ref member_class_template
24134 /// @param l the first argument of the operator.
24136 /// @param r the second argument of the operator.
24140 operator==(const member_class_template_sptr& l,
24151 /// Inequality operator for the @ref member_class_template
24154 /// @param l the first argument of the operator.
24156 /// @param r the second argument of the operator.
24160 operator!=(const member_class_template_sptr& l,
24162 {return !operator==(l, r);}
24188 /// Streaming operator for class_decl::access_specifier.
24196 operator<<(std::ostream& o, access_specifier a)
24526 /// Comparison operator for @ref union_decl.
24533 union_decl::operator==(const decl_base& other) const
24541 /// Equality operator for union_decl.
24543 /// Re-uses the equality operator that takes a decl_base.
24549 union_decl::operator==(const type_base& other) const
24557 /// Comparison operator for @ref union_decl.
24564 union_decl::operator==(const union_decl& other) const
24742 /// @param l the left-hand-side operand of the operator
24744 /// @param r the right-hand-side operand of the operator.
24748 operator==(const union_decl_sptr& l, const union_decl_sptr& r)
24761 /// @param l the left-hand-side operand of the operator
24763 /// @param r the right-hand-side operand of the operator.
24767 operator!=(const union_decl_sptr& l, const union_decl_sptr& r)
24768 {return !operator==(l, r);}
24826 /// Equality operator.
24832 template_decl::operator==(const template_decl& o) const
24905 template_parameter::operator==(const template_parameter& o) const
24934 /// Inequality operator.
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))
24990       return template_parameter::operator==(o);
24997 type_tparameter::operator==(const template_parameter& other) const
25009 type_tparameter::operator==(const type_tparameter& other) const
25075 non_type_tparameter::operator==(const decl_base& other) const
25077   if (!decl_base::operator==(other))
25084       return (template_parameter::operator==(o)
25092 non_type_tparameter::operator==(const template_parameter& other) const
25143 template_tparameter::operator==(const type_base& other) const
25149       return (type_tparameter::operator==(o)
25150 	      && template_decl::operator==(o));
25157 template_tparameter::operator==(const template_parameter& o) const
25170 template_tparameter::operator==(const template_decl& o) const
25176       return type_base::operator==(other);
25361 /// Comparison operator for the @ref function_tdecl type.
25367 function_tdecl::operator==(const decl_base& other) const
25375 /// Comparison operator for the @ref function_tdecl type.
25381 function_tdecl::operator==(const template_decl& other) const
25389 /// Comparison operator for the @ref function_tdecl type.
25395 function_tdecl::operator==(const function_tdecl& o) const
25398 	&& template_decl::operator==(o)
25399 	&& scope_decl::operator==(o)
25525 class_tdecl::operator==(const decl_base& other) const
25531       if (!(template_decl::operator==(o)
25532 	    && scope_decl::operator==(o)
25539       return get_pattern()->decl_base::operator==(*o.get_pattern());
25546 class_tdecl::operator==(const template_decl& other) const
25558 class_tdecl::operator==(const class_tdecl& o) const

Indexes created Thu Nov 07 10:32:03 CST 2024