Lines Matching refs:name
43 /// qualified name of a tree of decls and types. It used by the
531 /// Getter for the map that associates the name of a basic type to the
537 /// Getter for the map that associates the name of a basic type to the
544 /// Getter for the map that associates the name of a class type to the
551 /// Getter for the map that associates the name of a class type to the
558 /// Getter for the map that associates the name of a union type to the
565 /// Getter for the map that associates the name of a union type to the
572 /// Getter for the map that associates the name of an enum type to the
579 /// Getter for the map that associates the name of an enum type to the
586 /// Getter for the map that associates the name of a typedef to the
593 /// Getter for the map that associates the name of a typedef to the
600 /// Getter for the map that associates the name of a qualified type to
606 /// Getter for the map that associates the name of a qualified type to
612 /// Getter for the map that associates the name of a pointer type to
619 /// Getter for the map that associates the name of a pointer type to
626 /// Getter for the map that associates the name of a reference type to
633 /// Getter for the map that associates the name of a reference type to
640 /// Getter for the map that associates the name of an array type to
647 /// Getter for the map that associates the name of an array type to
654 /// Getter for the map that associates the name of a subrange type to
661 /// Getter for the map that associates the name of a subrange type to
668 /// Getter for the map that associates the name of a function type to
675 /// Getter for the map that associates the name of a function type to
1713 // found with the given name, the dynamic linker searches for
1714 // the first symbol with that name with type other than
1716 // STT_COMMON definition of that name that has the largest size.
1789 /// @param n the name of the symbol.
1846 /// @param n the name of the symbol.
1891 /// are not taken into account. Only the name, type, and version of
1940 /// Getter for the name of the @ref elf_symbol.
1942 /// @return a reference to the name of the @ref symbol.
1947 /// Setter for the name of the current intance of @ref elf_symbol.
1949 /// @param n the new name.
2149 /// @name Elf symbol aliases
2268 /// For that, locate the new main symbol by name and update all references to
2271 /// @param name the name of the main symbol
2275 elf_symbol::update_main_symbol(const std::string& name)
2278 if (!has_aliases() || get_name() == name)
2286 if (a->get_name() == name)
2314 /// symbol with the same name. Those exist in relocatable files. The
2333 /// symbol with the same name. Those exist in relocatable files. The
2386 /// concatenation of the name of the symbol, the '@' character, and
2391 /// returns the name of the symbol.
2415 /// From the aliases of the current symbol, lookup one with a given name.
2417 /// @param name the name of symbol alias we are looking for.
2419 /// @return the symbol alias that has the name @p name, or nil if none
2422 elf_symbol::get_alias_from_name(const string& name) const
2424 if (name == get_name())
2430 if (a->get_name() == name)
2460 /// @param include_symbol_itself if set to true, then the name of the
2492 /// @param include_symbol_itself if set to true, then the name of the
2521 /// Given the ID of a symbol, get the name and the version of said
2526 /// @param name the symbol name extracted from the ID. This is set
2532 string& name,
2535 name.clear(), ver.clear();
2540 name = id;
2544 name = id.substr(0, i);
2959 /// @param v the name of the version.
2974 /// Cast the version_type into a string that is its name.
2976 /// @return the name of the version.
2980 /// Getter for the version name.
2982 /// @return the version name.
2987 /// Setter for the version name.
2989 /// @param s the version name.
3227 /// same location), it's their qualified name that is used for the
3300 /// qualified name that is used for the lexicographic sort.
3567 /// unresolved decl-only class against a definition of the same name.
3591 /// unresolved decl-only class against a definition of the same name.
3815 /// @param 'name', the textual representation of the type as returned
3823 /// representation @p name, or nullptr if no type with that
3826 environment::get_canonical_types(const char* name)
3828 auto ti = get_canonical_types_map().find(name);
3837 /// @param 'name', the textual representation of the type as returned
3842 /// all have the same textual representation @p 'name'. That vector
3845 /// @return the canonical type which has the representation @p name,
3849 environment::get_canonical_type(const char* name, unsigned index)
3851 vector<type_base_sptr> *types = get_canonical_types(name);
4353 // This temporary qualified name is the cache used for the qualified
4354 // name before the type associated to this decl (if applicable) is
4358 // This is the fully qualified name of the decl. It contains the
4359 // name of the decl and the qualified name of its scope. So if in
4361 // somewhere in the name, there is going to by an
4367 // Unline qualified_name_, scoped_name_ contains the name of the
4368 // decl and the name of its scope; not the qualified name of the
4388 priv(interned_string name, interned_string linkage_name, visibility vis)
4391 name_(name),
4392 qualified_name_(name),
4412 /// @param name the name of the declaration.
4417 /// @param linkage_name the linkage name of the declaration.
4421 const string& name,
4426 priv_(new priv(e.intern(name), e.intern(linkage_name), vis))
4436 /// @param name the name of the declaration being constructed.
4440 /// @param linkage_name the linkage name of the declaration being
4445 const interned_string& name,
4450 priv_(new priv(name, linkage_name, vis))
4469 /// Getter for the qualified name.
4472 /// the qualified name.
4474 /// @return the qualified name.
4479 /// Clear the qualified name of this decl.
4481 /// This is useful to ensure that the cache for the qualified name of
4488 /// Setter for the qualified name.
4490 /// @param n the new qualified name.
4495 /// Getter of the temporary qualified name of the current declaration.
4497 /// This temporary qualified name is used as a qualified name cache by
4501 /// the qualified name cached.
4503 /// @return the temporary qualified name.
4508 /// Setter for the temporary qualified name of the current
4511 ///@param n the new temporary qualified name.
4513 /// This temporary qualified name is used as a qualified name cache by
4517 /// the qualified name cached.
4642 /// Setter for the name of the decl.
4644 /// @param n the new name to set.
4655 /// name. This can usually happen for enum or struct types.
4665 /// name. This can usually happen for enum or struct types.
4719 /// anonymous anymore. It's name is going to be the name of the
4729 // not anonymous anymore. Its name is the typedef name.
4747 /// Getter for the mangled name.
4749 /// @return the new mangled name.
4754 /// Setter for the linkage name.
4756 /// @param m the new linkage name.
4790 /// Return a copy of the qualified name of the parent of the current
4793 /// @return the newly-built qualified name of the of the current decl.
4798 /// Getter for the name of the current decl.
4800 /// @return the name of the current decl.
4805 /// Compute the qualified name of the decl.
4807 /// @param qn the resulting qualified name.
4834 /// basically the fully qualified name of the decl optionally prefixed
4853 string name = get_generic_anonymous_internal_type_name(this);
4855 name = get_qualified_parent_name() + "::" + name;
4856 return name;
4864 /// Return the qualified name of the decl.
4866 /// This is the fully qualified name of the decl. It's made of the
4867 /// concatenation of the name of the decl with the qualified name of
4878 /// @return the resulting qualified name.
4883 /// Return the scoped name of the decl.
4885 /// This is made of the concatenation of the name of the decl with the
4886 /// name of its scope. It doesn't contain the qualified name of its
4892 /// @return the scoped name of the decl.
5067 /// Get the name of a decl for the purpose of comparing two decl
5073 /// shall have the same name for the purpose of comparison.
5076 /// non-qualified name should be taken into account.
5083 // The decl is anonymous. It should have the same name ass the
5146 // This is the qualified name of the decls that we want to compare.
5147 // We want to use the "internal" version of the qualified name as
5153 /// compare their name component by component by properly handling
5156 /// Otherwise, let's just compare their name, the obvious way.
5192 /// Return true iff the two decls have the same name.
7451 /// Update the qualified name of a given sub-tree.
7453 /// @param d the sub-tree for which to update the qualified name.
7461 /// Update the qualified name of a given sub-tree.
7463 /// @param d the sub-tree for which to update the qualified name.
7503 /// @param the name of the scope decl.
7509 const string& name,
7513 decl_base(env, name, locus, /*mangled_name=*/name, vis),
7689 /// Note that this function updates the qualified name of the member
7730 /// Find a member type of a given name, inside the current @ref
7733 /// @param name the name of the member type to look for.
7736 /// type of name @p name, for the current scope.
7738 scope_decl::find_member_type(const string& name) const
7741 if (get_type_name(t, /*qualified*/false) == name)
7831 /// Note that this function updates the qualified name of the inserted
8330 /// Build and return a copy of the name of an ABI artifact that is
8333 /// @param tod the ABI artifact to get the name for.
8335 /// @param qualified if yes, return the qualified name of @p tod;
8336 /// otherwise, return the non-qualified name;
8338 /// @return the name of @p tod.
8362 /// Build and return a copy of the name of an ABI artifact that is
8365 /// @param tod the ABI artifact to get the name for.
8367 /// @param qualified if yes, return the qualified name of @p tod;
8368 /// otherwise, return the non-qualified name;
8370 /// @return the name of @p tod.
8375 /// Build and return a qualified name from a name and its scope.
8377 /// The name is supposed to be for an entity that is part of the
8382 /// @param name of the name to consider.
8384 /// @return a copy of the string that represents the qualified name.
8386 build_qualified_name(const scope_decl* scope, const string& name)
8388 if (name.empty())
8396 qualified_name = name;
8398 qualified_name = qualified_name + "::" + name;
8403 /// Build and return the qualified name of a type in its scope.
8474 /// Get the name of a given type and return a copy of it.
8478 /// @param qualified if true then return the qualified name of the
8486 /// @return a copy of the type name if the type has a name, or the
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
8509 /// structs will be have a generic name of "__anonymous_struct__", all
8510 /// anonymous unions will have a generic name of
8513 /// That generic name can be used as a hash to put all anonymous types
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
8554 string name;
8558 return name;
8562 name = int_type.to_string(/*internal=*/true);
8564 return name;
8567 /// Get the name of a given type and return a copy of it.
8571 /// @param qualified if true then return the qualified name of the
8579 /// @return a copy of the type name if the type has a name, or the
8593 // name for internal purpose. This to allow them to be compared
8616 /// Get the name of a given type and return a copy of it.
8620 /// @param qualified if true then return the qualified name of the
8628 /// @return a copy of the type name if the type has a name, or the
8634 /// Get the name of the pointer to a given type.
8638 /// @param qualified this is true if the resulting name should be of a
8641 /// @param internal true if the name is for libabigail-internal
8644 /// @return the name (string representation) of the pointer.
8656 /// Get the name of the reference to a given type.
8660 /// @param qualified this is true if the resulting name should be of a
8663 /// @param internal true if the name is for libabigail-internal
8666 /// @return the name (string representation) of the reference.
8674 string name = get_type_name(pointed_to_type, qualified, internal);
8676 name = name + "&";
8678 name = name + "&&";
8680 return env.intern(name);
8683 /// Get the name of a qualified type, given the underlying type and
8688 /// @param quals the CV qualifiers of the name.
8691 /// name of @p underlying_type.
8696 /// @return the name (string representation) of the qualified type.
8705 string name = get_type_name(underlying_type, qualified, internal);
8708 // We are asked to return the internal name, that might be used
8712 // foo"), and the name of foo, which is just "foo".
8725 name += " ";
8726 name += quals_repr;
8729 name = quals_repr + " " + name;
8732 return env.intern(name);
8735 /// Get the name of a given function type and return a copy of it.
8744 /// @return a copy of the function type name
8750 /// Get the name of a given function type and return a copy of it.
8759 /// @return a copy of the function type name
8772 /// Get the name of a given function type and return a copy of it.
8781 /// @return a copy of the function type name
8787 // When the function name is used for internal purposes (e.g, for
8818 /// Get the name of a given method type and return a copy of it.
8827 /// @return a copy of the function type name
8833 /// Get the name of a given method type and return a copy of it.
8842 /// @return a copy of the function type name
8853 /// Get the name of a given method type and return a copy of it.
8862 /// @return a copy of the function type name
8868 // When the function name is used for internal purposes (e.g, for
9173 string name = cou.get_qualified_name();
9176 repr += name;
9288 /// Otherwise, this just shows the name of the artifact as returned by
9304 string name = c->get_qualified_name();
9306 o << name;
9363 string name = e->get_qualified_name();
9365 o << name
9391 /// Get a given data member, referred to by its name, of a class type.
9395 /// @param member_name name of the data member to get.
9406 /// Get a given data member, referred to by its name, of a class type.
9410 /// @param member_name name of the data member to get.
9763 /// @param name the name of the data member to look for.
9766 const string& name)
9774 var_decl_sptr result = containing_class_or_union->find_data_member(name);
9966 /// The typedef s_type becomes the name of the originally anonymous
10782 /// qualified C++ type name, starting from a given position. The
10783 /// delimiter returned separates a type name from the name of its
10791 /// delimiter is returned, because the type name in this case is:
10796 /// foo<p1, bar::name>::some_type
10800 /// @param fqn the fully qualified name of the type to consider.
10835 /// Decompose a fully qualified name into the list of its components.
10837 /// @param fqn the fully qualified name to decompose.
10859 /// Turn a set of qualified name components (that name a type) into a
10860 /// qualified name string.
10862 /// @param comps the name components
10864 /// @return the resulting string, which would be the qualified name of
10905 /// Lookup all the type*s* that have a given fully qualified name.
10907 /// @param type_name the fully qualified name of the type to
10924 /// Lookup a type (with a given name) in a map that associates a type
10925 /// name to a type. If there are several types with a given name,
10933 /// @param type_name the name of the type to lookup.
10948 // Walk the types that have the name "type_name" and return the
10957 // ... or return the last type with the name "type_name" that
10971 /// @param type_name the name of the basic type to look for.
10989 /// @param type_name the name of the basic type to look for.
11009 /// @param fqn the fully qualified name of the class type node to look
11030 /// @param type_name the name of the class type to look for.
11048 /// @param type_name the name of the union type to look for.
11066 /// @param fqn the fully qualified name of the type to lookup.
11116 /// @param type_name the name of the enum type to look for.
11134 /// @param type_name the name of the enum type to look for.
11153 /// @param type_name the name of the typedef type to look for.
11173 /// @param type_name the name of the typedef type to look for.
11193 /// @param type_name the name of the qualified type to look for.
11239 /// @param type_name the name of the pointer type to look for.
11260 /// @param type_name the name of the pointer type to look for.
11301 /// @param type_name the name of the reference type to look for.
11346 /// @param type_name the name of the array type to look for.
11366 /// @param type_name the name of the type to lookup.
11417 /// @param fqn the fully qualified name of the type to lookup.
11444 /// @param fqn the fully qualified name of the type to lookup.
11459 /// @param fqn the components of the fully qualified name of the node
11476 /// sequence to find the type with a given name.
11481 /// their name. Looking up a type from those maps is thus much
11484 /// @param fqn the fully qualified name of the type to lookup.
11500 /// @param fqn the fuly qualified name of the @var_decl to lookup.
11515 /// A generic function (template) to get the name of a node, whatever
11523 /// @param node the node to get the name from.
11525 /// @return the name of the node.
11530 /// Gets the name of a class_decl node.
11532 /// @param node the decl_base node to get the name from.
11534 /// @return the name of the node.
11540 /// Gets the name of a type_base node.
11542 /// @param node the type_base node to get the name from.
11544 /// @return the name of the node.
11550 /// Gets the name of a var_decl node.
11552 /// @param node the var_decl node to get the name from.
11554 /// @return the name of the node.
11575 /// @param fqn the components of the fully qualified name of the node
11639 /// sequence to find the type with a given name.
11644 /// their name. Looking up a type from those maps is thus much
11647 /// @param comps the components of the fully qualified name of the
11661 /// sequence to find the type with a given name.
11666 /// their name. Looking up a type from those maps is thus much
11732 /// sequence to find the type with a given name.
11737 /// their name. Looking up a type from those maps is thus much
11768 /// sequence to find the type with a given name.
11776 /// map of types, indexed by their name. Looking up a type from those
11778 /// qualified name of the node to look up.
11794 /// @param comps the components of the fully qualified name of the
11808 /// @param fqn the components of the fully qualified name of the node
11825 /// @param fqn the components of the fully qualified name of the node
11842 /// sequence and lookup the types to find one that has a given name.
11844 /// @param fqn the components of the fully qualified name of the class
11859 /// @param fqn the components of the fully qualified name of the basic
11885 /// @param fqn the components of the fully qualified name of the union
11911 /// @param fqn the components of the fully qualified name of the enum
11937 /// @param @param qn the fully qualified name of the typedef type to lookup.
11961 /// @param @param qn the fully qualified name of the qualified type to
11986 /// @param @param qn the fully qualified name of the pointer type to
12011 /// @param @param qn the fully qualified name of the reference type to
12036 /// @param @param qn the fully qualified name of the array type to
12061 /// @param @param qn the fully qualified name of the function type to
12086 /// @param @param qn the fully qualified name of the type to lookup.
12109 /// @param type_name the name of the type to look for.
12164 /// qualified name as a giventype.
12171 /// @param t the type which has the same qualified name as the type we
12180 /// qualified name.
12187 /// @param qualified_name the qualified name of the basic type to look
12240 /// qualified name.
12247 /// @param qualified_name the qualified name of the basic type to look
12259 /// qualified name as a given type.
12266 /// @param t the class decl type which has the same qualified name as
12278 /// qualified name.
12285 /// @param qualified_name the qualified name of the type to look for.
12296 /// qualified name.
12303 /// @param qualified_name the qualified name of the type to look for.
12317 /// given qualified name.
12319 /// @param qualified_name the qualified name of the type to look for.
12333 /// given qualified name and that are declaration-only.
12335 /// @param qualified_name the qualified name of the type to look for.
12368 /// given qualified name.
12370 /// @param qualified_name the qualified name of the type to look for.
12374 /// @return the vector of class types that which name is @p qualified_name.
12415 /// qualified name.
12422 /// @param qualified_name the qualified name of the type to look for.
12438 /// qualified name.
12445 /// @param qualified_name the qualified name of the type to look for.
12456 /// qualified name as a given enum type.
12463 /// @param t the enum type which has the same qualified name as the
12475 /// qualified name.
12482 /// @param qualified_name the qualified name of the enum type to look
12494 /// qualified name.
12501 /// @param qualified_name the qualified name of the enum type to look
12519 /// given qualified name.
12521 /// @param qualified_name the qualified name of the type to look for.
12525 /// @return the vector of enum types that which name is @p qualified_name.
12535 /// given qualified name.
12537 /// @param qualified_name the qualified name of the type to look for.
12541 /// @return the vector of enum types that which name is @p qualified_name.
12581 /// same qualified name as a given typedef type.
12588 /// @param t the typedef type which has the same qualified name as the
12600 /// same qualified name as a given typedef type.
12607 /// @param t the typedef type which has the same qualified name as the
12619 /// given qualified name.
12626 /// @param qualified_name the qualified name of the typedef type to
12676 /// has a given qualified name.
12683 /// @param qualified_name the name of the type to find.
12701 /// a given qualified name.
12708 /// @param qualified_name the qualified name of the type to look for.
12725 /// same qualified name as a given type.
12727 /// @param t the type which has the same qualified name as the
12741 /// given qualified name.
12743 /// @param qualified_name the qualified name of the type to look for.
12765 /// qualified name as a given pointer type.
12767 /// @param t the pointer type which has the same qualified name as the
12781 /// qualified name.
12788 /// @param qualified_name the qualified name of the pointer type to
12809 /// same qualified name as a given reference type.
12816 /// @param t the reference type which has the same qualified name as
12830 /// given qualified name.
12837 /// @param qualified_name the qualified name of the reference type to
12859 /// qualified name.
12866 /// @param qualified_name the qualified name of the array type to look
12880 /// qualified name as a given array type.
12887 /// @param t the type which has the same qualified name as the type we
12907 /// qualified name as a given function type.
12914 /// @param t the function type which has the same qualified name as
12928 /// qualified name as a given function type.
12935 /// @param t the function type which has the same qualified name as
12951 /// qualified name.
12958 /// @param qualified_name the qualified name of the function type to
12979 /// qualified name.
12986 /// @param qualified_name the qualified name of the function type to
13045 /// @param qualified_name the qualified name of the function type to
13065 /// @param qualified_name the qualified name of the function type to
13079 /// Update the map that associates a fully qualified name of a given
13086 /// fully qualified name of a type to the type itself.
13088 /// @param use_type_name_as_key if true, use the name of the type as
13217 /// Update the map that associates the fully qualified name of a basic
13221 /// name was already existing in that map.
13223 /// If no type with this name did already exist in the per-corpus type
13261 /// Update the map that associates the fully qualified name of a class
13265 /// name was already existing in that map.
13267 /// If no type with this name did already exist in the per-corpus type
13304 /// Update the map that associates the fully qualified name of a union
13308 /// name was already existing in that map.
13310 /// If no type with this name did already exist in the per-corpus type
13347 /// Update the map that associates the fully qualified name of an enum
13351 /// name was already existing in that map.
13353 /// If no type with this name did already exist in the per-corpus type
13391 /// Update the map that associates the fully qualified name of a
13395 /// name was already existing in that map.
13397 /// If no type with this name did already exist in the per-corpus type
13434 /// Update the map that associates the fully qualified name of a
13438 /// name was already existing in that map.
13440 /// If no type with this name did already exist in the per-corpus type
13467 /// Update the map that associates the fully qualified name of a
13471 /// name was already existing in that map.
13473 /// If no type with this name did already exist in the per-corpus type
13500 /// Update the map that associates the fully qualified name of a
13504 /// name was already existing in that map.
13506 /// If no type with this name did already exist in the per-corpus type
13533 /// Update the map that associates the fully qualified name of a type
13537 /// name was already existing in that map.
13539 /// If no type with this name did already exist in the per-corpus type
13576 /// Update the map that associates the fully qualified name of a type
13580 /// name was already existing in that map.
13582 /// If no type with this name did already exist in the per-corpus type
13620 /// Update the map that associates the fully qualified name of a
13624 /// name was already existing in that map.
13626 /// If no type with this name did already exist in the per-corpus type
13654 /// Update the map that associates the fully qualified name of a type
13658 /// name was already existing in that map.
13660 /// If no type with this name did already exist in the per-corpus type
13695 /// Update the map that associates the fully qualified name of a type
13699 /// name was already existing in that map.
13701 /// If no type with this name did already exist in the per-corpus type
13884 /// Demangle a C++ mangled name and return the resulting string
13886 /// @param mangled_name the C++ mangled name to demangle.
13888 /// @return the resulting mangled name.
13943 /// Two types T1 and T2 (who are presumably of the same name and kind)
13983 // typedef name.
14151 // name.
14166 // have a linkage name. If it does in the future, then me must be
14167 // mindful that the linkage name respects the type identity
14292 // the canonical types of the same name that come from
14785 /// @param type_name the type name to parse.
14932 /// @param the name of the integral type to parse to initialize the
15046 /// @param name the name of the type declaration.
15059 const string& name,
15070 decl_base(env, name, locus, linkage_name, vis),
15078 if (parse_integral_type(name, int_type))
15084 // Set the name of this type_decl to the canonical string
15215 /// Implementation for the virtual qualified name builder for @ref
15219 /// qualified name.
15230 /// Implementation for the virtual qualified name builder for @ref
15234 /// qualified name.
15327 /// @param name the name of the type.
15337 const string& name,
15346 decl_base(env, name, locus, "", vis),
15348 scope_decl(env, name, locus)
15468 /// @param name the name of the namespace.
15474 const string& name,
15487 decl_base(env, name, locus, "", vis),
15488 scope_decl(env, name, locus)
15609 // internal name.
15612 // name.
15631 /// Build the name of the current instance of qualified type.
15633 /// @param fully_qualified if true, build a fully qualified name.
15640 /// @return a copy of the newly-built name.
15689 interned_string name = type->get_environment().intern(build_name(false));
15690 set_name(name);
15715 interned_string name = env.intern("void");
15716 set_name(name);
15850 /// Implementation for the virtual qualified name builder for @ref
15854 /// qualified name.
15865 /// Implementation of the virtual qualified name builder/getter.
15872 /// @return the resulting qualified name.
15882 // temporary name that is not cached because the structure of
15883 // this type (and so its name) can change until its
15887 // We are asked to return a temporary *internal* name.
15896 // We are asked to return a temporary non-internal name.
15905 // the definitive name and cache it.
15992 interned_string name = get_environment().intern(build_name(false));
15993 set_name(name);
15996 // Now that the name has been updated, we need to update the
16165 string name = (pto ? pto->get_name() : string("void")) + "*";
16166 set_name(env.intern(name));
16195 string name = string("void") + "*";
16196 set_name(env.intern(name));
16213 string name = (pto ? pto->get_name() : string("void")) + "*";
16214 set_name(env.intern(name));
16318 /// Build and return the qualified name of the current instance of
16321 /// @param qn output parameter. The resulting qualified name.
16331 /// Build, cache and return the qualified name of the current instance
16343 /// @return the resulting qualified name.
16365 // (and so its name) can change. So let's invalidate the
16366 // cache where we store its name at each invocation of this
16390 // (and so its name) can change. So let's invalidate the
16391 // cache where we store its name at each invocation of this
16517 string name;
16521 name = string(pto->get_name()) + "&";
16524 name = string(get_type_name(is_function_type(pointed_to),
16528 name += "&";
16530 set_name(env.intern(name));
16570 string name = "void&";
16572 name += "&";
16574 set_name(env.intern(name));
16596 string name = string(pto->get_name()) + "&";
16598 name += "&";
16600 set_name(env.intern(name));
16699 /// Build and return the qualified name of the current instance of the
16703 /// name of the current instance of @ref reference_type_def.
16713 /// Build, cache and return the qualified name of the current instance
16722 /// @return the newly-built qualified name of the current instance of
16966 /// @param name the name of the subrange type.
16977 const string& name,
16988 decl_base(env, name, loc, ""),
16998 /// @param name the name of the subrange type.
17009 const string& name,
17018 decl_base(env, name, loc, ""),
17028 /// @param name of the name of type.
17037 const string& name,
17043 decl_base(env, name, loc, ""),
17287 string name = get_name();
17290 if (name.empty())
17702 /// Build and return the qualified name of the current instance of the
17706 /// name of the current instance of @ref array_type_def.
17716 /// Compute the qualified name of the array.
17723 /// @return the resulting qualified name.
17829 /// @param name the name of the type declaration.
17837 /// @param linkage_name the linkage name of the enum.
17840 enum_type_decl::enum_type_decl(const string& name,
17854 name, locus, linkage_name, vis),
17943 /// Test if two enums differ, but not by a name change.
17949 /// @return true iff @p l differs from @p r by anything but a name
18062 /// looking at is present in the enum with a different name. An
18063 /// enumerator with the same value but with a different name is named
18098 /// a different name.
18352 priv(const string& name,
18355 : name_(name),
18372 /// @param name the name of the enumerator.
18375 enum_type_decl::enumerator::enumerator(const string& name,
18377 : priv_(new priv(name, value))
18425 /// Getter for the name of the current instance of
18428 /// @return a reference to the name of the current instance of
18434 /// Getter for the qualified name of the current instance of
18436 /// builds the qualified name, caches it and return a reference to the
18437 /// cached qualified name. Subsequent invocations just return the
18445 /// @return the qualified name of the current instance of
18460 /// Setter for the name of @ref enum_type_decl::enumerator.
18462 /// @param n the new name.
18513 /// @param name the name of the typedef.
18519 /// @param linkage_name the mangled name of the typedef.
18522 typedef_decl::typedef_decl(const string& name,
18535 name, locus, linkage_name, vis),
18543 /// @param name the name of the typedef.
18549 /// @param mangled_name the mangled name of the typedef.
18552 typedef_decl::typedef_decl(const string& name,
18563 decl_base(env, name, locus, mangled_name, vis),
18786 /// @param name the name of the variable declaration
18792 /// @param linkage_name the linkage name of the variable.
18797 var_decl::var_decl(const string& name,
18805 decl_base(type->get_environment(), name, locus, linkage_name, vis),
18850 /// involves comparing their underlying elf symbols. The decl name
19048 /// concatenation of the symbol name and its version. Otherwise, the
19049 /// ID is the linkage name if its non-null. Otherwise, it's the
19083 /// Get the qualified name of a given variable or data member.
19087 /// data member, then the qualified name is actually the flat
19090 /// name of an *anonymous* data member is empty, by construction, e.g:
19108 /// @return the resulting qualified name.
19156 string name;
19158 name = get_name();
19160 name = get_qualified_name(internal);
19167 + " " + name + t->get_subrange_representation();
19190 // It doesn't make sense to name the member of an
19193 // its non-qualified name.
19206 // It doesn't make sense to name the member of an
19209 // its non-qualified name.
19218 /// Get a name that is valid even for an anonymous data member.
19225 /// Otherwise, just return the name of the current @ref var_decl.
19227 /// @param qualified if true, return the qualified name. This doesn't
19233 string name;
19239 name = get_pretty_representation(/*internal=*/false, qualified);
19241 name = get_name();
19243 return name;
19294 /// of parameters (where each parameter also carries the name of the
19562 // that is the same as the method class name; we can recurse for
19695 /// Get the name of the current @ref function_type.
19697 /// The name is retrieved from a cache. If the cache is empty, this
19698 /// function computes the name of the type, stores it in the cache and
19703 /// name is never cached.
19705 /// @param internal if true then it means the function type name is
19710 /// @return the name of the function type.
20071 /// @param name the name of the function.
20079 /// @param mangled_name the linkage name of the function.
20084 function_decl::function_decl(const string& name,
20093 decl_base(function_type->get_environment(), name, locus, mangled_name, vis),
20107 /// @param name the name of the function declaration.
20116 /// @param linkage_name the mangled name of the function declaration.
20122 function_decl::function_decl(const string& name,
20131 decl_base(fn_type->get_environment(), name, locus, linkage_name, vis),
20315 /// name for the function thus becomes irrelevant in the comparison.
20613 /// concatenation of the symbol name and its version. Otherwise, the
20614 /// ID is the linkage name if its non-null. Otherwise, it's the
20632 // Let's use the full symbol name with its version as ID.
20751 const string& name,
20756 decl_base(type->get_environment(), name, loc),
20764 const string& name,
20770 decl_base(type->get_environment(), name, loc),
20778 const string& name,
20784 decl_base(type->get_environment(), name, loc),
20808 /// @return a copy of the type name of the parameter.
20844 /// Get a name uniquely identifying the parameter in the function.
20846 ///@return the unique parm name id.
21012 /// Compute the qualified name of the parameter.
21019 /// @param qn the resulting qualified name.
21072 /// @param name the identifier of the class.
21092 class_or_union::class_or_union(const environment& env, const string& name,
21103 decl_base(env, name, locus, name, vis),
21105 scope_type_decl(env, name, size_in_bits, align_in_bits, locus, vis),
21131 /// @param name the name of the class.
21142 class_or_union::class_or_union(const environment& env, const string& name,
21150 decl_base(env, name, locus, name, vis),
21152 scope_type_decl(env, name, size_in_bits, align_in_bits, locus, vis),
21160 /// @param name the name of the @ref class_or_union.
21164 class_or_union::class_or_union(const environment& env, const string& name,
21171 decl_base(env, name, location(), name),
21173 scope_type_decl(env, name, 0, 0, location()),
21509 /// Find a data member of a given name in the current @ref class_or_union.
21511 /// @param name the name of the data member to find in the current
21517 class_or_union::find_data_member(const string& name) const
21522 if ((*i)->get_name() == name)
21525 // We haven't found a data member with the name 'name'. Let's look
21534 if (var_decl_sptr data_member = type->find_data_member(name))
21568 /// non-empty name, then it tries to find a data member which has the
21569 /// same name as the argument.
21571 /// If it has an empty name, then the @ref var_decl is considered as
21576 /// @param v this carries either the name of the data member we need
21631 // Update the map of linkage name -> member functions. It's useful,
21645 /// Find a method, using its linkage name as a key.
21647 /// @param linkage_name the linkage name of the method to find.
21656 /// Find a method, using its linkage name as a key.
21658 /// @param linkage_name the linkage name of the method to find.
21671 /// Find a method, using its linkage name as a key.
21673 /// @param linkage_name the linkage name of the method to find.
21964 // class definition of the same name.
22340 /// @param name the identifier of the class.
22362 class_decl::class_decl(const environment& env, const string& name,
22375 decl_base(env, name, locus, name, vis),
22377 class_or_union(env, name, size_in_bits, align_in_bits,
22388 /// @param name the identifier of the class.
22413 class_decl::class_decl(const environment& env, const string& name,
22425 decl_base(env, name, locus,
22427 // have a linkage name. Also, the anonymous class does
22428 // have an internal-only unique name that is generally
22430 // unique internal-only name, when used as a linkage
22431 // name might introduce spurious comparison false
22433 /*linkage_name=*/is_anonymous ? string() : name,
22436 class_or_union(env, name, size_in_bits, align_in_bits,
22448 /// @param name the name of the class.
22459 class_decl::class_decl(const environment& env, const string& name,
22469 decl_base(env, name, locus, name, vis),
22471 class_or_union(env, name, size_in_bits, align_in_bits,
22482 /// @param name the name of the class.
22496 class_decl:: class_decl(const environment& env, const string& name,
22506 decl_base(env, name, locus,
22508 // have a linkage name. Also, the anonymous class does
22509 // have an internal-only unique name that is generally
22511 // unique internal-only name, when used as a linkage
22512 // name might introduce spurious comparison false
22514 /*linkage_name=*/ is_anonymous ? string() : name,
22517 class_or_union(env, name, size_in_bits, align_in_bits,
22530 /// @param name the name of the class.
22534 class_decl::class_decl(const environment& env, const string& name,
22542 decl_base(env, name, location(), name),
22544 class_or_union(env, name, is_declaration_only),
22598 /// Find a base class of a given qualified name for the current class.
22600 /// @param qualified_name the qualified name of the base class to look for.
22603 /// class of name @p qualified_name, if found.
22675 // it has a name, which is the typedef name.
22929 /// @param name the name of the method.
22938 /// @param linkage_name the mangled name of the method.
22943 method_decl::method_decl(const string& name,
22954 decl_base(type->get_environment(), name, locus, linkage_name, vis),
22955 function_decl(name, static_pointer_cast<function_type>(type),
22965 /// @param name the name of the method.
22975 /// @param linkage_name the mangled name of the method.
22980 method_decl::method_decl(const string& name,
22991 decl_base(type->get_environment(), name, locus, linkage_name, vis),
22992 function_decl(name, static_pointer_cast<function_type>
23002 /// @param name the name of the method.
23012 /// @param linkage_name the mangled name of the method.
23017 method_decl::method_decl(const string& name,
23028 decl_base(type->get_environment(), name, locus, linkage_name, vis),
23029 function_decl(name, static_pointer_cast<function_type>
23037 /// Set the linkage name of the method.
23039 /// @param l the new linkage name of the method.
23153 /// by the name of their ELF symbol. If they don't have elf
23214 /// by the name of their ELF symbol. If they don't have elf
23407 /// linkage name into account.
23414 /// name or symbol into account.
23448 /// linkage name or the symbol of the methods into account.
23628 // be equal if we don't take into account their symbol name or
23629 // their linkage name. This is because two destructor functions
23630 // clones (for instance) might have different linkage name, but
24313 /// @param name the name of the union type.
24326 union_decl::union_decl(const environment& env, const string& name,
24334 decl_base(env, name, locus, name, vis),
24336 class_or_union(env, name, size_in_bits, 0,
24346 /// @param name the name of the union type.
24362 union_decl::union_decl(const environment& env, const string& name,
24371 decl_base(env, name, locus,
24373 // have a linkage name. Also, the anonymous class does
24374 // have an internal-only unique name that is generally
24376 // unique internal-only name, when used as a linkage
24377 // name might introduce spurious comparison false
24379 /*linkage_name=*/is_anonymous ? string() : name,
24382 class_or_union(env, name, size_in_bits, 0,
24393 /// @param name the name of the union type.
24400 union_decl::union_decl(const environment& env, const string& name,
24409 decl_base(env, name, locus, name, vis),
24411 class_or_union(env, name, size_in_bits,
24421 /// @param name the name of the union type.
24431 union_decl::union_decl(const environment& env, const string& name,
24440 decl_base(env, name, locus,
24442 // have a linkage name. Also, the anonymous class does
24443 // have an internal-only unique name that is generally
24445 // unique internal-only name, when used as a linkage
24446 // name might introduce spurious comparison false
24448 /*linkage_name=*/is_anonymous ? string() : name,
24451 class_or_union(env, name, size_in_bits,
24462 /// @param name the name of the union type.
24467 const string& name,
24475 decl_base(env, name, location(), name),
24477 class_or_union(env, name, is_declaration_only)
24805 /// @param name the name of the template decl.
24812 const string& name,
24816 decl_base(env, name, locus, /*mangled_name=*/"", vis),
24960 /// @param name the name of the template parameter.
24966 const string& name,
24972 decl_base(enclosing_tdecl->get_environment(), name, locus),
24974 type_decl(enclosing_tdecl->get_environment(), name, 0, 0, locus),
25038 /// @param name the name of the template parameter.
25046 const string& name,
25050 decl_base(type->get_environment(), name, locus, ""),
25119 /// @param name the name of the template parameter.
25125 const string& name,
25131 decl_base(enclosing_tdecl->get_environment(), name, locus),
25133 type_decl(enclosing_tdecl->get_environment(), name,
25134 0, 0, locus, name, VISIBILITY_DEFAULT),
25135 type_tparameter(index, enclosing_tdecl, name, locus),
25136 template_decl(enclosing_tdecl->get_environment(), name, locus),
25682 /// its sub-types. That is, if the type has changed but its type name
25986 /// name. In the indirect types case, the size of the underlying type
25990 /// they have the same kind, name and size. Two class types have
25991 /// similar structure if they have the same name, size, and if the
26016 /// the same name. In the indirect types case, the size of the
26020 /// they have the same kind, name and size. Two class types have
26021 /// similar structure if they have the same name, size, and if the
26202 /// The data member is designated by its name.
26206 /// @param dm_name the name of the data member to lookup.
26209 /// data member with that name was found.
26247 /// Build the internal name of the underlying type of an enum.
26249 /// @param base_name the (unqualified) name of the enum the underlying
26726 /// Update the qualified parent name, qualified name and scoped name
26772 /// udpate of the qualified name of a given sub-tree.
26782 /// udpate of the qualified name of a given sub-tree.