Lines Matching defs:internal
24 #include "abg-internal.h"
42 /// This internal type is a tree walking that is used to set the
438 /// Insert the triplet representing a source locus into our internal
2819 repr = "internal visibility";
2909 else if (s == "internal-visibility")
3217 return (get_pretty_representation(f, /*internal=*/false)
3218 < get_pretty_representation(s, /*internal=*/false));
3272 && (get_pretty_representation(f, /*internal=*/false)
3273 == get_pretty_representation(s, /*internal=*/false)))
3276 return (get_pretty_representation(f, /*internal=*/false)
3277 < get_pretty_representation(s, /*internal=*/false));
3365 string s1 = get_pretty_representation(f, /*internal=*/false);
3366 string s2 = get_pretty_representation(s, /*internal=*/false);
3408 s1 = get_pretty_representation(peeled_f, /*internal=*/false);
3409 s2 = get_pretty_representation(peeled_s, /*internal=*/false);
3525 /// Note that this function must only be called by internal code of
3816 /// by type_or_decl_base::get_pretty_representation(/*internal=*/true,
3838 /// by type_or_decl_base::get_pretty_representation(/*internal=*/true,
4809 /// @param internal set to true if the call is intended for an
4810 /// internal use (for technical use inside the library itself), false
4814 decl_base::get_qualified_name(interned_string& qn, bool internal) const
4815 {qn = get_qualified_name(internal);}
4820 /// @param internal set to true if the call is intended to get a
4826 /// call is meant for internal use (for technical use inside the
4837 decl_base::get_pretty_representation(bool internal,
4840 if (internal
4845 // want an *internal* pretty representation for it. All
4847 // the same internal representation for type canonicalization to
4860 return get_qualified_name(internal);
4873 /// @param internal set to true if the call is intended for an
4874 /// internal use (for technical use inside the library itself), false
4880 decl_base::get_qualified_name(bool /*internal*/) const
5093 : d.get_qualified_name(/*internal=*/true);
5147 // We want to use the "internal" version of the qualified name as
5274 r = "internal";
8481 /// @param internal set to true if the call is intended for an
8482 /// internal use (for technical use inside the library itself), false
8489 get_type_name(const type_base_sptr& t, bool qualified, bool internal)
8490 {return get_type_name(t.get(), qualified, internal);}
8493 /// anonymous internal type name.
8498 /// anonymous internal type name.
8505 /// Return the generic internal name of an anonymous type.
8507 /// For internal purposes, we want to define a generic name for all
8538 /// Get the internal name for a given integral type.
8541 /// long' have the same internal name. This is so that they can all
8549 /// @return the internal name for @p t if it's an integral type, or
8562 name = int_type.to_string(/*internal=*/true);
8574 /// @param internal set to true if the call is intended for an
8575 /// internal use (for technical use inside the library itself), false
8582 get_type_name(const type_base* t, bool qualified, bool internal)
8589 return fn_type->get_cached_name(internal);
8592 // All anonymous types of a given kind get to have the same internal
8593 // name for internal purpose. This to allow them to be compared
8595 if (internal)
8605 return d->get_qualified_name(internal);
8612 return d->get_qualified_name(internal);
8623 /// @param internal set to true if the call is intended for an
8624 /// internal use (for technical use inside the library itself), false
8631 get_type_name(const type_base& t, bool qualified, bool internal)
8632 {return get_type_name(&t, qualified, internal);}
8641 /// @param internal true if the name is for libabigail-internal
8647 bool qualified, bool internal)
8650 string tn = get_type_name(pointed_to_type, qualified, internal);
8663 /// @param internal true if the name is for libabigail-internal
8670 bool qualified, bool internal)
8674 string name = get_type_name(pointed_to_type, qualified, internal);
8693 /// @param internal true if the result is to be used for
8694 /// libabigail-internal purposes.
8700 bool qualified, bool internal)
8705 string name = get_type_name(underlying_type, qualified, internal);
8707 if (quals_repr.empty() && internal)
8708 // We are asked to return the internal name, that might be used
8739 /// @param internal set to true if the call is intended for an
8740 /// internal use (for technical use inside the library itself), false
8747 bool internal)
8748 {return get_function_type_name(fn_type.get(), internal);}
8754 /// @param internal set to true if the call is intended for an
8755 /// internal use (for technical use inside the library itself), false
8762 bool internal)
8767 return get_method_type_name(method, internal);
8769 return get_function_type_name(*fn_type, internal);
8776 /// @param internal set to true if the call is intended for an
8777 /// internal use (for technical use inside the library itself), false
8784 bool internal)
8787 // When the function name is used for internal purposes (e.g, for
8792 internal
8797 o << get_pretty_representation(return_type, internal);
8809 if (internal)
8811 o << get_pretty_representation(type, internal);
8822 /// @param internal set to true if the call is intended for an
8823 /// internal use (for technical use inside the library itself), false
8830 bool internal)
8831 {return get_method_type_name(fn_type.get(), internal);}
8837 /// @param internal set to true if the call is intended for an
8838 /// internal use (for technical use inside the library itself), false
8845 bool internal)
8848 return get_method_type_name(*fn_type, internal);
8857 /// @param internal set to true if the call is intended for an
8858 /// internal use (for technical use inside the library itself), false
8865 bool internal)
8868 // When the function name is used for internal purposes (e.g, for
8873 internal
8879 o << return_type->get_cached_pretty_representation(internal);
8888 o << " (" << class_type->get_qualified_name(internal) << "::*)"
8900 if (internal)
8903 o << type->get_cached_pretty_representation(internal);
8919 /// @param internal set to true if the call is intended for an
8920 /// internal use (for technical use inside the library itself), false
8927 get_pretty_representation(const type_or_decl_base* tod, bool internal)
8932 result = get_pretty_representation(t, internal);
8934 result = get_pretty_representation(d, internal);
8947 /// @param internal set to true if the call is intended for an
8948 /// internal use (for technical use inside the library itself), false
8955 get_pretty_representation(const type_or_decl_base_sptr& tod, bool internal)
8956 {return get_pretty_representation(tod.get(), internal);}
8962 /// @param internal set to true if the call is intended for an
8963 /// internal use (for technical use inside the library itself), false
8969 get_pretty_representation(const decl_base* d, bool internal)
8973 return d->get_pretty_representation(internal);
8980 /// @param internal set to true if the call is intended for an
8981 /// internal use (for technical use inside the library itself), false
8987 get_pretty_representation(const type_base* t, bool internal)
8992 return get_pretty_representation(fn_type, internal);
8996 return get_pretty_representation(d, internal);
9003 /// @param internal set to true if the call is intended for an
9004 /// internal use (for technical use inside the library itself), false
9010 get_pretty_representation(const decl_base_sptr& d, bool internal)
9011 {return get_pretty_representation(d.get(), internal);}
9017 /// @param internal set to true if the call is intended for an
9018 /// internal use (for technical use inside the library itself), false
9024 get_pretty_representation(const type_base_sptr& t, bool internal)
9025 {return get_pretty_representation(t.get(), internal);}
9031 /// @param internal set to true if the call is intended for an
9032 /// internal use (for technical use inside the library itself), false
9039 bool internal)
9040 {return get_pretty_representation(fn_type.get(), internal);}
9046 /// @param internal set to true if the call is intended for an
9047 /// internal use (for technical use inside the library itself), false
9053 get_pretty_representation(const function_type* fn_type, bool internal)
9059 return get_pretty_representation(method, internal);
9061 return get_pretty_representation(*fn_type, internal);
9068 /// @param internal set to true if the call is intended for an
9069 /// internal use (for technical use inside the library itself), false
9075 get_pretty_representation(const function_type& fn_type, bool internal)
9078 o << "function type " << get_function_type_name(fn_type, internal);
9086 /// @param internal set to true if the call is intended for an
9087 /// internal use (for technical use inside the library itself), false
9093 get_pretty_representation(const method_type& method, bool internal)
9096 o << "method type " << get_method_type_name(method, internal);
9104 /// @param internal set to true if the call is intended for an
9105 /// internal use (for technical use inside the library itself), false
9111 get_pretty_representation(const method_type* method, bool internal)
9115 return get_pretty_representation(*method, internal);
9122 /// @param internal set to true if the call is intended for an
9123 /// internal use (for technical use inside the library itself), false
9129 get_pretty_representation(const method_type_sptr method, bool internal)
9130 {return get_pretty_representation(method.get(), internal);}
9152 bool internal,
9161 if (!internal && clazz->is_struct())
9201 real_indent, one_line, internal, qualified_names);
9208 repr += (*dm)->get_pretty_representation(internal,
9213 real_indent+ (*dm)->get_pretty_representation(internal,
9247 bool internal,
9252 internal, qualified_names);
9276 bool internal,
9281 internal,
9337 << m->get_pretty_representation(/*internal=*/false,
9352 o << " " << f->get_pretty_representation(/*internal=*/false,
9367 << e->get_underlying_type()->get_pretty_representation(/*internal=*/false,
9387 return artifact->get_pretty_representation(/*internal=*/true,
14175 // internal use, not for a user-facing purpose.
14179 // pretty representation to be the same. Hence the 'internal'
14184 string repr = t->get_cached_pretty_representation(/*internal=*/true);
14551 /// @param internal if true, then the pretty representation is to be
14552 /// used for purpuses that are internal to the libabigail library
14556 type_base::get_cached_pretty_representation(bool internal) const
14558 if (internal)
14562 string r = ir::get_pretty_representation(this, internal);
14570 string r = ir::get_pretty_representation(this, internal);
14976 /// @param internal if true the string representation is to be used
14977 /// for internal purposes. In general, it means it's for type
14983 integral_type::to_string(bool internal) const
14992 if (!internal)
14998 // same size. If they don't have the same internal string
15221 /// @param internal set to true if the call is intended for an
15222 /// internal use (for technical use inside the library itself), false
15227 bool internal) const
15228 {qualified_name = get_qualified_name(internal);}
15236 /// @param internal set to true if the call is intended for an
15237 /// internal use (for technical use inside the library itself), false
15241 type_decl::get_qualified_name(bool internal) const
15246 if (internal)
15264 return decl_base::get_qualified_name(/*internal=*/false);
15270 /// @param internal set to true if the call is intended to get a
15276 /// call is meant for internal use (for technical use inside the
15285 type_decl::get_pretty_representation(bool internal,
15288 if (internal)
15293 return get_qualified_name(internal);
15496 /// @param internal set to true if the call is intended to get a
15502 /// call is meant for internal use (for technical use inside the
15511 namespace_decl::get_pretty_representation(bool internal,
15515 "namespace " + scope_decl::get_pretty_representation(internal,
15609 // internal name.
15611 // Once the type is canonicalized, this is used as the internal
15635 /// @param internal set to true if the call is intended for an
15636 /// internal use (for technical use inside the library itself), false
15642 qualified_type_def::build_name(bool fully_qualified, bool internal) const
15654 internal);
15856 /// @param internal set to true if the call is intended for an
15857 /// internal use (for technical use inside the library itself), false
15862 bool internal) const
15863 {qualified_name = get_qualified_name(internal);}
15867 /// @param internal set to true if the call is intended for an
15868 /// internal use (for technical use inside the library itself), false
15874 qualified_type_def::get_qualified_name(bool internal) const
15885 if (internal)
15887 // We are asked to return a temporary *internal* name.
15891 env.intern(build_name(true, /*internal=*/true));
15896 // We are asked to return a temporary non-internal name.
15898 (env.intern(build_name(true, /*internal=*/false)));
15906 if (internal)
15911 /*internal=*/true));
15919 /*internal=*/false)));
16323 /// @param internal set to true if the call is intended for an
16324 /// internal use (for technical use inside the library itself), false
16328 pointer_type_def::get_qualified_name(interned_string& qn, bool internal) const
16329 {qn = get_qualified_name(internal);}
16338 /// @param internal set to true if the call is intended for an
16339 /// internal use (for technical use inside the library itself), false
16345 pointer_type_def::get_qualified_name(bool internal) const
16350 if (internal)
16359 /*internal=*/true);
16372 /*internal=*/true);
16384 /*internal=*/false));
16397 /*internal=*/false));
16705 /// @param internal set to true if the call is intended for an
16706 /// internal use (for technical use inside the library itself), false
16710 reference_type_def::get_qualified_name(interned_string& qn, bool internal) const
16711 {qn = get_qualified_name(internal);}
16717 /// @param internal set to true if the call is intended for an
16718 /// internal use (for technical use inside the library itself), false
16725 reference_type_def::get_qualified_name(bool internal) const
16733 internal));
16740 /// @param internal set to true if the call is intended to get a
16746 /// call is meant for internal use (for technical use inside the
16755 reference_type_def::get_pretty_representation(bool internal,
16763 internal);
17272 /// @param internal set to true if the call is intended to get a
17278 /// call is meant for internal use (for technical use inside the
17438 /// @param internal set to true if the call is intended for an
17439 /// internal use (for technical use inside the library itself), false
17443 get_type_representation(const array_type_def& a, bool internal)
17455 << e_type ? e_type->get_pretty_representation(internal):string("void");
17459 if (internal)
17463 /*internal=*/true)
17468 ? get_type_name(e_type, /*qualified=*/true, /*internal=*/false)
17479 /// @param internal set to true if the call is intended to get a
17485 /// call is meant for internal use (for technical use inside the
17488 /// @param internal set to true if the call is intended for an
17489 /// internal use (for technical use inside the library itself), false
17495 array_type_def::get_pretty_representation(bool internal,
17497 {return get_type_representation(*this, internal);}
17708 /// @param internal set to true if the call is intended for an
17709 /// internal use (for technical use inside the library itself), false
17713 array_type_def::get_qualified_name(interned_string& qn, bool internal) const
17714 {qn = get_qualified_name(internal);}
17718 /// @param internal set to true if the call is intended for an
17719 /// internal use (for technical use inside the library itself), false
17725 array_type_def::get_qualified_name(bool internal) const
17730 if (internal)
17736 env.intern(get_type_representation(*this, /*internal=*/true));
17742 env.intern(get_type_representation(*this, /*internal=*/true));
17752 (*this, /*internal=*/false)));
17759 /*internal=*/false)));
17882 /// @param internal set to true if the call is intended to get a
17888 /// call is meant for internal use (for technical use inside the
17897 enum_type_decl::get_pretty_representation(bool internal,
17902 if (internal && get_is_anonymous())
17903 r += get_type_name(this, qualified_name, /*internal=*/true);
17905 r += decl_base::get_pretty_representation(internal,
18440 /// @param internal set to true if the call is intended for an
18441 /// internal use (for technical use inside the library itself), false
18448 enum_type_decl::enumerator::get_qualified_name(bool internal) const
18453 get_enum_type()->get_qualified_name(internal)
18681 /// @param internal set to true if the call is intended to get a
18687 /// call is meant for internal use (for technical use inside the
18697 typedef_decl::get_pretty_representation(bool internal,
18703 result += get_qualified_name(internal);
19105 /// @param internal if true then this is for a purpose to the library,
19110 var_decl::get_qualified_name(bool internal) const
19116 string r = get_pretty_representation(internal);
19120 return decl_base::get_qualified_name(internal);
19125 /// @param internal set to true if the call is intended to get a
19131 /// call is meant for internal use (for technical use inside the
19140 var_decl::get_pretty_representation(bool internal, bool qualified_name) const
19160 name = get_qualified_name(internal);
19166 result += decl->get_qualified_name(internal)
19180 "", /*one_line=*/true, internal);
19186 "", /*one_line=*/true, internal);
19188 if (!internal
19196 result += get_qualified_name(internal);
19201 get_type_declaration(get_type())->get_qualified_name(internal)
19204 if (!internal
19212 result += get_qualified_name(internal);
19238 // the 'internal' version of the pretty presentation.
19239 name = get_pretty_representation(/*internal=*/false, qualified);
19705 /// @param internal if true then it means the function type name is
19706 /// going to be used for purposes that are internal to libabigail
19712 function_type::get_cached_name(bool internal) const
19714 if (internal)
19720 get_function_type_name(this, /*internal=*/true);
19727 /*internal=*/true);
19737 get_function_type_name(this, /*internal=*/false);
19743 get_function_type_name(this, /*internal=*/false);
19766 /// @param internal set to true if the call is intended to get a
19772 /// call is meant for internal use (for technical use inside the
19779 function_type::get_pretty_representation(bool internal,
19781 {return ir::get_pretty_representation(this, internal);}
19994 /// @param internal set to true if the call is intended to get a
20000 /// call is meant for internal use (for technical use inside the
20007 method_type::get_pretty_representation(bool internal,
20009 {return ir::get_pretty_representation(*this, internal);}
20141 /// @param internal set to true if the call is intended to get a
20147 /// call is meant for internal use (for technical use inside the
20153 function_decl::get_pretty_representation(bool internal,
20178 result += type->get_qualified_name(internal) + " ";
20180 result += get_pretty_representation_of_declarator(internal);
20190 /// @param internal set to true if the call is intended to get a
20196 /// call is meant for internal use (for technical use inside the
20203 function_decl::get_pretty_representation_of_declarator (bool internal) const
20241 if (internal)
20243 result += get_type_name(type, /*qualified=*/true, internal);
21014 /// @param internal set to true if the call is intended for an
21015 /// internal use (for technical use inside the library itself), false
21022 bool /*internal*/) const
21028 /// @param internal set to true if the call is intended to get a
21034 /// call is meant for internal use (for technical use inside the
21041 function_decl::parameter::get_pretty_representation(bool internal,
21053 type_repr = ir::get_pretty_representation(t, internal);
21557 if ((*it)->get_pretty_representation(/*internal=*/false, true)
21558 == v->get_pretty_representation(/*internal=*/false, true))
22428 // have an internal-only unique name that is generally
22430 // unique internal-only name, when used as a linkage
22509 // have an internal-only unique name that is generally
22511 // unique internal-only name, when used as a linkage
22651 /// @param internal set to true if the call is intended to get a
22657 /// call is meant for internal use (for technical use inside the
22666 class_decl::get_pretty_representation(bool internal,
22670 if (!internal && is_struct())
22673 // When computing the pretty representation for internal purposes,
22678 if (internal && !get_name().empty())
22679 return cl + get_type_name(this, qualified_name, /*internal=*/true);
22682 internal);
22688 result += get_qualified_name(internal);
24374 // have an internal-only unique name that is generally
24376 // unique internal-only name, when used as a linkage
24443 // have an internal-only unique name that is generally
24445 // unique internal-only name, when used as a linkage
24485 /// @param internal set to true if the call is intended to get a
24491 /// call is meant for internal use (for technical use inside the
24500 union_decl::get_pretty_representation(bool internal,
24506 if (internal && !get_name().empty())
24508 get_type_name(this, qualified_name, /*internal=*/true);
24512 internal);
24518 repr += get_qualified_name(internal);
25699 string repr1 = get_pretty_representation(t1, /*internal=*/false),
25700 repr2 = get_pretty_representation(t2, /*internal=*/false);
25748 string repr = v->get_pretty_representation(/*internal=*/true);
25757 string repr = f->get_pretty_representation(/*internal=*/true);
25958 fr = f.get_pretty_representation(/*internal=*/true),
25959 sr = s.get_pretty_representation(/*internal=*/true);
26247 /// Build the internal name of the underlying type of an enum.