Lines Matching refs:result
125 string*& result = priv_->map[str_value];
126 if (!result && !str_value.empty())
127 result = new string(str_value);
128 return interned_string(result);
414 string path, result;
828 // kinds of comparison should yield the same result, otherwise type
868 bool result = l.priv_->comparison_started(l, r);
869 return result ;
895 /// To break the cycle, we assume the result of the comparison is true
991 /// Return the result of the comparison of two (sub) types.
994 /// result of the comparison of two (sub) types.
1010 /// @param value the result of the comparison of @p l and @p r.
2214 int result = 0;
2219 ++result;
2221 return result;
2468 string result;
2471 result = get_id_string();
2476 result += ", ";
2483 result += ", ";
2484 result += (*i)->get_id_string();
2486 return result;
2508 string result;
2514 result += ", ";
2515 result += (*i)->get_id_string();
2518 return result;
3373 // We are looking at two types that are the result of
3378 // These are the result of an optimization which
3382 // always const. So as a result of the optimizaton
3415 // as well and we'll consider sorting the result as decls.
3471 /// @param result the resulting sorted vector.
3474 vector<type_base_sptr>& result)
3477 result.push_back(t);
3480 std::stable_sort(result.begin(), result.end(), comp);
4500 /// it's the result of decl_base::peek_qualified_name() that becomes
4516 /// it's the result of decl_base::peek_qualified_name() that becomes
4547 size_t result = 0;
4552 result = hash(t);
4559 return result;
5022 bool result = true;
5059 result = false;
5064 ABG_RETURN(result);
5119 bool result = true;
5137 result = false;
5180 result = false;
5187 result &= maybe_compare_as_member_decls(l, r, k);
5189 ABG_RETURN(result);
6662 decl_base_sptr result = t;
6677 result = is_decl(u);
6679 return result;
6741 qualified_type_def_sptr result = t;
6745 result =
6749 return result;
7264 array_type_def_sptr result
7268 return result;
7288 typedef_decl_sptr result
7292 return result;
7313 qualified_type_def_sptr result
7317 return result;
7334 type_base_sptr result;
7337 result = clone_typedef(is_typedef(t));
7339 result = clone_qualified_type(t);
7341 result = clone_array(t);
7346 add_decl_to_scope(is_decl(result), scope);
7348 return result;
7366 type_base_sptr result = clone_typedef_array_qualified_type(t);
7367 ABG_ASSERT(is_typedef_of_array(result) || is_array_type(result));
7370 if (typedef_decl_sptr type = is_typedef(result))
7380 else if (array_type_def_sptr type = is_array_type(result))
7448 return result;
7615 int result = 0;
7621 ++result;
7623 return result;
7633 int result = 0;
7639 ++result;
7641 return result;
7651 int result = 0;
7657 ++result;
7659 return result;
7934 bool result = true;
7938 result = false;
7952 result = false;
7965 result = false;
7972 ABG_RETURN(result);
8342 string result;
8347 result = get_type_name(t, qualified);
8351 result = d->get_qualified_name();
8353 result = d->get_name();
8359 return result;
8522 interned_string result;
8524 result =
8527 result =
8530 result =
8535 return result;
8693 /// @param internal true if the result is to be used for
8929 string result;
8932 result = get_pretty_representation(t, internal);
8934 result = get_pretty_representation(d, internal);
8939 return result;
9774 var_decl_sptr result = containing_class_or_union->find_data_member(name);
9775 return result;
10541 decl_base* result = look_through_decl_only(*d).get();
10542 if (!result)
10543 result = d;
10545 return result;
10559 decl_base_sptr result = look_through_decl_only(*d);
10560 if (!result)
10561 result = d;
10563 return result;
10728 array_type_def_sptr result;
10734 result = is_array_type(u);
10737 return result;
10869 string result;
10874 result = *c;
10876 result += "::" + *c;
10877 return result;
11091 union_decl_sptr result = lookup_type_in_map<union_decl>(loc, m);
11093 return result;
11426 type_base_sptr result;
11427 ((result = lookup_typedef_type(fqn, tu))
11428 || (result = lookup_class_type(fqn, tu))
11429 || (result = lookup_union_type(fqn, tu))
11430 || (result = lookup_enum_type(fqn, tu))
11431 || (result = lookup_qualified_type(fqn, tu))
11432 || (result = lookup_pointer_type(fqn, tu))
11433 || (result = lookup_reference_type(fqn, tu))
11434 || (result = lookup_array_type(fqn, tu))
11435 || (result = lookup_function_type(fqn, tu))
11436 || (result = lookup_basic_type(fqn, tu)));
11438 return result;
11686 type_base_sptr result;
11705 result = is_type(*i);
11721 result = lookup_type_in_scope(type, a, (*i).get());
11726 return result;
11870 type_decl_sptr result;
11876 if ((result = lookup_basic_type(type_name, **tu)))
11879 return result;
11896 union_decl_sptr result;
11902 if ((result = lookup_union_type(type_name, **tu)))
11905 return result;
11922 enum_type_decl_sptr result;
11928 if ((result = lookup_enum_type(type_name, **tu)))
11931 return result;
11946 typedef_decl_sptr result;
11952 if ((result = lookup_typedef_type(type_name, **tu)))
11955 return result;
11971 qualified_type_def_sptr result;
11977 if ((result = lookup_qualified_type(t_name, **tu)))
11980 return result;
11996 pointer_type_def_sptr result;
12002 if ((result = lookup_pointer_type(type_name, **tu)))
12005 return result;
12021 reference_type_def_sptr result;
12027 if ((result = lookup_reference_type(t_name, **tu)))
12030 return result;
12046 array_type_def_sptr result;
12052 if ((result = lookup_array_type(type_name, **tu)))
12055 return result;
12071 function_type_sptr result;
12077 if ((result = lookup_function_type(type_name, **tu)))
12080 return result;
12095 type_base_sptr result;
12101 if ((result = lookup_type(qn, **tu)))
12104 return result;
12147 function_type_sptr result;
12149 if ((result = lookup_function_type(fn_t, corpus)))
12150 return result;
12156 if ((result = synthesize_function_type_from_translation_unit(*fn_t,
12158 return result;
12160 return result;
12195 type_decl_sptr result;
12198 result = lookup_type_in_map<type_decl>(qualified_name, m);
12200 result = lookup_basic_type_through_translation_units(qualified_name, corp);
12202 return result;
12218 type_decl_sptr result;
12220 result = lookup_type_in_map<type_decl>(loc, m);
12222 return result;
12311 class_decl_sptr result = lookup_type_in_map<class_decl>(qualified_name, m);
12313 return result;
12339 /// @param result the vector of decl-only class types named @p
12342 /// @return true iff @p result was populated with the decl-only
12347 type_base_wptrs_type& result)
12361 result.push_back(type);
12364 return !result.empty();
12395 class_decl_sptr result = lookup_type_in_map<class_decl>(loc, m);
12397 return result;
12430 union_decl_sptr result = lookup_type_in_map<union_decl>(type_name, m);
12431 if (!result)
12432 result = lookup_union_type_through_translation_units(type_name, corp);
12434 return result;
12510 enum_type_decl_sptr result =
12512 if (!result)
12513 result = lookup_enum_type_through_translation_units(qualified_name, corp);
12515 return result;
12561 enum_type_decl_sptr result = lookup_type_in_map<enum_type_decl>(loc, m);
12563 return result;
12635 typedef_decl_sptr result =
12637 if (!result)
12638 result = lookup_typedef_type_through_translation_units(qualified_name,
12641 return result;
12656 typedef_decl_sptr result = lookup_type_in_map<typedef_decl>(loc, m);
12658 return result;
12691 type_base_sptr result = lookup_class_type(qualified_name, corp);
12692 if (!result)
12693 result = lookup_union_type(qualified_name, corp);
12695 if (!result)
12696 result = lookup_typedef_type(qualified_name, corp);
12697 return result;
12717 type_base_sptr result = lookup_class_or_typedef_type(qualified_name, corp);
12718 if (!result)
12719 result = lookup_enum_type(qualified_name, corp);
12721 return result;
12754 qualified_type_def_sptr result =
12757 if (!result)
12758 result = lookup_qualified_type_through_translation_units(qualified_name,
12761 return result;
12799 pointer_type_def_sptr result =
12801 if (!result)
12802 result = lookup_pointer_type_through_translation_units(qualified_name,
12805 return result;
12849 reference_type_def_sptr result =
12851 if (!result)
12852 result = lookup_reference_type_through_translation_units(qualified_name,
12855 return result;
12898 array_type_def_sptr result =
12900 if (!result)
12901 result = lookup_array_type_through_translation_units(qualified_name, corp);
12903 return result;
12969 function_type_sptr result =
12971 if (!result)
12972 result = lookup_function_type_through_translation_units(qualified_name,
12975 return result;
12995 type_base_sptr result;
12997 ((result = lookup_basic_type(n, corp))
12998 || (result = lookup_class_type(n, corp))
12999 || (result = lookup_union_type(n, corp))
13000 || (result = lookup_enum_type(n, corp))
13001 || (result = lookup_typedef_type(n, corp))
13002 || (result = lookup_qualified_type(n, corp))
13003 || (result = lookup_pointer_type(n, corp))
13004 || (result = lookup_reference_type(n, corp))
13005 || (result = lookup_array_type(n, corp))
13006 || (result= lookup_function_type(n, corp)));
13008 return result;
13028 type_base_sptr result;
13029 ((result = lookup_basic_type_per_location(loc, corp))
13030 || (result = lookup_class_type_per_location(loc, corp))
13031 || (result = lookup_union_type_per_location(loc, corp))
13032 || (result = lookup_enum_type_per_location(loc, corp))
13033 || (result = lookup_typedef_type_per_location(loc, corp)));
13035 return result;
13110 bool result = false;
13115 result = true;
13120 return result;
13169 bool result = false;
13174 result = true;
13179 return result;
13203 bool result = false;
13209 result = true;
13214 return result;
13736 type_base_sptr result;
13738 result = lookup_type(type, tu);
13740 if (!result)
13749 result.reset(new qualified_type_def(underlying_type,
13761 result.reset(new pointer_type_def(pointed_to_type,
13773 result.reset(new reference_type_def(pointed_to_type,
13781 result = synthesize_function_type_from_translation_unit(*f, tu);
13783 if (result)
13785 add_decl_to_scope(is_decl(result), tu.get_global_scope());
13786 canonicalize(result);
13790 if (result)
13791 tu.priv_->synthesized_types_.push_back(result);
13793 return result;
14193 type_base_sptr result;
14200 result = t;
14249 result = *it;
14268 if (result)
14272 result))
14282 << result.get()
14285 else //!result
14318 if (!result)
14321 result = t;
14325 return result;
14481 // emitted. This can be the case for the result of the
14599 bool result = (l.get_size_in_bits() == r.get_size_in_bits()
14601 if (!result)
14604 ABG_RETURN(result);
14667 bool result = v.visit_end(this);
14670 return result;
14686 /// @return the result of the bitwise OR.
14701 /// @return the result of the bitwise AND.
14716 /// @return the result of the bitwise one's complement operator.
14729 /// @return the result of the bitwise |=.
14743 /// @return the result of the bitwise &=.
14895 ///@param type the resulting @ref integral_type. Is set to the result
14985 string result;
14989 result += "signed ";
14991 result += "unsigned ";
15002 result += "short ";
15004 result += "long ";
15006 result += "long long ";
15011 result += "int";
15013 result += "char";
15015 result += "bool";
15017 result += "double";
15019 result += "float";
15021 result += "char16_t";
15023 result += "char32_t";
15025 result += "wchar_t";
15027 return result;
15116 bool result = false;
15120 result = equals(static_cast<const decl_base&>(l),
15123 if (!k && !result)
15128 result &= equals(static_cast<const type_base&>(l),
15131 ABG_RETURN(result);
15311 bool result = v.visit_end(this);
15314 return result;
15373 bool result = equals(static_cast<const scope_decl&>(l),
15377 if (!k && !result)
15380 result &= equals(static_cast<const type_base&>(l),
15384 ABG_RETURN(result);
15452 bool result = v.visit_end(this);
15455 return result;
15762 bool result = true;
15765 result = false;
15774 result = false;
15794 ABG_RETURN(result);
15948 bool result = v.visit_end(this);
15950 return result;
16244 bool result = l.get_pointed_to_type() == r.get_pointed_to_type();
16245 if (!result)
16256 ABG_RETURN(result);
16427 bool result = v.visit_end(this);
16429 return result;
16634 bool result = (l.get_pointed_to_type() == r.get_pointed_to_type());
16635 if (!result)
16642 ABG_RETURN(result);
16758 string result =
16765 return result;
16792 bool result = v.visit_end(this);
16794 return result;
17199 bool result = true;
17205 result = false;
17209 ABG_RETURN(result);
17212 ABG_RETURN(result);
17320 bool result = v.visit_end(this);
17322 return result;
17524 bool result = true;
17527 result = false;
17540 result = false;
17553 result = false;
17560 ABG_RETURN(result);
17789 bool result = v.visit_end(this);
17791 return result;
17934 bool result = v.visit_end(this);
17936 return result;
17956 bool result = false;
17959 result = true;
17972 result = true;
17984 result = true;
18001 result = true;
18019 return result;
18140 bool result = true;
18160 result = false;
18179 result = false;
18189 result = false;
18248 result = false;
18263 result = false;
18273 ABG_RETURN(result);
18625 bool result = true;
18631 result = false;
18642 result = false;
18649 ABG_RETURN(result);
18701 string result = "typedef ";
18703 result += get_qualified_name(internal);
18705 result += get_name();
18707 return result;
18752 bool result = v.visit_end(this);
18754 return result;
18939 bool result = true;
18945 result = false;
18963 result = false;
18971 result = false;
18977 bool symbols_are_equal = (s0 && s1 && result);
18994 result = false;
19004 result = false;
19019 result = false;
19026 ABG_RETURN(result);
19142 string result;
19145 result = "static ";
19166 result += decl->get_qualified_name(internal)
19177 result +=
19184 result += get_class_or_union_flat_representation
19187 result += " ";
19194 result += get_name();
19196 result += get_qualified_name(internal);
19200 result +=
19210 result += get_name();
19212 result += get_qualified_name(internal);
19215 return result;
19411 parameter_sptr result;
19415 result = get_parameters()[i + 1];
19420 result = get_parameters()[i];
19422 return result;
19511 // already been compared. If so, and if the result of the
19522 bool result = true;
19526 result = false;
19530 RETURN(result);
19544 result = false;
19548 RETURN(result);
19554 result = false;
19558 RETURN(result);
19594 result = false;
19604 RETURN(result);
19610 result = false;
19614 RETURN(result);
19624 result = false;
19634 RETURN(result);
19641 result = false;
19645 RETURN(result);
19650 // cache the result of this comparison -- in case we are asked in a
19657 l.get_environment().priv_->cache_type_comparison_result(l, r, result);
19659 RETURN(result);
20159 string result = mem_fn ? "method ": "function ";
20164 result += "virtual ";
20178 result += type->get_qualified_name(internal) + " ";
20180 result += get_pretty_representation_of_declarator(internal);
20182 return result;
20208 string result;
20212 result += mem_fn->get_type()->get_class_type()->get_qualified_name()
20216 result += get_qualified_name();
20218 result += "(";
20234 result += ", ";
20237 result += "...";
20243 result += get_type_name(type, /*qualified=*/true, internal);
20246 result += ")";
20251 result += " const";
20253 return result;
20442 bool result = true;
20451 result = false;
20466 result = false;
20476 result = false;
20483 bool symbols_are_equal = (s0 && s1 && result);
20506 result = false;
20516 result = false;
20527 result = false;
20536 result = false;
20558 result = false;
20566 ABG_RETURN(result);
20896 bool result = true;
20902 result = false;
20919 result = false;
20931 ABG_RETURN(result);
21055 string result = type_repr;
21059 result += " " + parm_name;
21061 return result;
21255 bool result = v.visit_end(this);
21257 return result;
21398 int result = 0;
21404 ++result;
21406 return result;
21416 int result = 0;
21422 ++result;
21424 return result;
21434 int result = 0;
21440 ++result;
21442 return result;
22009 bool result = true;
22016 result = false;
22020 RETURN(result);
22031 result = false;
22043 RETURN(result);
22057 result = false;
22061 RETURN(result);
22072 result = false;
22079 RETURN(result);
22088 result = false;
22092 RETURN(result);
22103 result = false;
22110 RETURN(result);
22114 RETURN(result);
22256 /// equal to the canonical type of ST1 as a result of that
22686 string result = cl;
22688 result += get_qualified_name(internal);
22690 result += get_name();
22692 return result;
23061 method_type_sptr result;
23063 result = dynamic_pointer_cast<method_type>(function_decl::get_type());
23064 return result;
23525 // compared. If so, and if the result of the comparison has been
23528 bool result = false;
23529 if (l.get_environment().priv_->is_type_comparison_cached(l, r, result))
23530 return result;
23541 bool result = true;
23546 result = false;
23548 ABG_RETURN(result);
23567 result = false;
23571 RETURN(result);
23582 result = false;
23592 RETURN(result);
23616 result = false;
23620 RETURN(result);
23646 result = false;
23649 RETURN(result);
23668 result = false;
23672 RETURN(result);
23678 // cache the result of this comparison -- in case we are asked in a
23685 l.get_environment().priv_->cache_type_comparison_result(l, r, result);
23687 RETURN(result);
23932 bool result = v.visit_end(this);
23934 return result;
24646 bool result = v.visit_end(this);
24648 return result;
24679 // compared. If so, and if the result of the comparison has been
24682 bool result = false;
24683 if (l.get_environment().priv_->is_type_comparison_cached(l, r, result))
24684 return result;
24690 bool result = equals(static_cast<const class_or_union&>(l),
24698 // cache the result of this comparison -- in case we are asked in a
24705 l.get_environment().priv_->cache_type_comparison_result(l, r, result);
24707 RETURN(result);
24913 bool result = false;
24927 result = true;
24931 return result;
25736 size_t result = 0;
25741 result = hash_type(t);
25751 result = h;
25760 result = h;
25771 result = h;
25783 result = h;
25789 result = d->get_hash();
25794 return result;