static int
compare_tfunc(struct ty_func *dest, struct ty_func *src) {
struct sym_entry *sd;
struct sym_entry *ss;
int i;
if (dest->nargs == -1 || src->nargs == -1) {
/* This is a mere declaration like void foo(); - assume equal */
return 0;
}
if (dest->nargs != src->nargs) {
return -1;
}
if (dest->ret && src->ret) {
if (compare_types(dest->ret, src->ret, CMPTY_SIGN|CMPTY_CONST)
== -1) {
return -1;
}
}
/* XXX this is a kludge ... use func data instead */
sd = dest->scope->slist;
ss = src->scope->slist;
for (i = 0; i < dest->nargs; ++i) {
struct decl *d1;
struct decl *d2;
struct type *t1;
struct type *t2;
static struct vreg dummyvr;
d1 = sd->dec;
d2 = ss->dec;
t1 = d1->dtype;
t2 = d2->dtype;
if (is_transparent_union(t1) && is_transparent_union(t2)) {
} else if (is_transparent_union(t1)) {
dummyvr.type = t2;
t1 = get_transparent_union_type(d1->tok, t1, &dummyvr);
if (t1 == NULL) {
return -1;
}
} else if (is_transparent_union(t2)) {
dummyvr.type = t1;
t2 = get_transparent_union_type(d2->tok, t2, &dummyvr);
if (t2 == NULL) {
return -1;
}
}
if (compare_types(t1, t2, CMPTY_SIGN|CMPTY_CONST) == -1) {
return -1;
}
sd = sd->next;
ss = ss->next;
}
return 0;
}
char *redhttp_negotiate_choose(redhttp_negotiate_t ** server, redhttp_negotiate_t ** client)
{
const char *best_type = NULL;
redhttp_negotiate_t *s, *c;
int best_score = -1;
char *result = NULL;
for (s = *server; s; s = s->next) {
for (c = *client; c; c = c->next) {
if (compare_types(s->type, c->type)) {
int score = s->q * c->q;
if (score > best_score) {
best_score = score;
best_type = s->type;
break;
}
}
}
}
// Copy best match into the result buffer
if (best_type) {
result = redhttp_strdup(best_type);
}
return result;
}
virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
{
if (int(vals.size()) != get_arity())
{
return false;
}
return compare_types(m_types, vals) || detail::compare_types_cast(m_dummy_func, vals, t_conversions);
}
bool compare_decl(SgFunctionDeclaration* f_func_dec, SgFunctionDeclaration* c_func_dec)
{
// check for number of arguments
if (f_func_dec->get_args().size() != c_func_dec->get_args().size()) {
std::cout << " compare_decl(): Different number of arguments, returning false" << std::endl;
return false;
}
// check for matching return types
SgType* f_return_type = f_func_dec->get_orig_return_type();
SgType* c_return_type = c_func_dec->get_orig_return_type();
if (f_return_type != c_return_type) {
std::cout << " compare_decl(): Different return types, returning false" << std::endl;
return false;
}
else {
std::cout << " compare_decl(): Return types match" << std::endl;
}
const SgInitializedNamePtrList & f_name_list = f_func_dec->get_args();
const SgInitializedNamePtrList & c_name_list = c_func_dec->get_args();
bool found = false;
// TODO - make sure same # of arguments
// Is done at the top of the function
//--------------------------
int i = 0;
BOOST_FOREACH(SgInitializedName* f_name, f_name_list)
{
if (compare_types(f_name, c_name_list[i])) {
found = true;
}
else {
std::cout << " compare_decl(): returning false" << std::endl;
return false;
}
i++;
}
std::cout << " compare_decl(): returning true" << std::endl;
return found;
}
void
compare_files(const unity_file &base, const unity_file &other, delta_store &store) {
// Those modification objects can be applied to another unity_file if they have the right related elements
// Two modifications with disjoint list of related elements will be applicable together,
// this will be the basis of conflict resolution in three-way merges.
bool layout_modified = false;
if (base.unity_version != other.unity_version)
store.modify_unity_version(base.unity_version, other.unity_version);
if (base.magic_int_1 != other.magic_int_1)
store.modify_file_magic(1, base.magic_int_1, other.magic_int_1);
if (base.magic_int_2 != other.magic_int_2)
store.modify_file_magic(2, base.magic_int_2, other.magic_int_2);
if (base.magic_int_3 != other.magic_int_3)
store.modify_file_magic(3, base.magic_int_3, other.magic_int_3);
if (base.file_layout.metadata_size != other.file_layout.metadata_size)
layout_modified = true;
if (base.file_layout.assets_start != other.file_layout.assets_start)
layout_modified = true;
if (base.file_layout.previews_start != other.file_layout.previews_start)
layout_modified = true;
if (base.file_layout.file_endianness != other.file_layout.file_endianness)
layout_modified = true;
{ // types
std::vector<identified_type> base_identified_types(identify_types(base));
std::vector<identified_type> other_identified_types(identify_types(other));
for (const identified_type &base_identified_type : base_identified_types) {
bool match_found = false;
for (const identified_type &other_identified_type : other_identified_types)
if (base_identified_type.identity == other_identified_type.identity) {
match_found = true;
store.set_current_type(base_identified_type.identity);
compare_types(base_identified_type.type, other_identified_type.type, store);
break;
}
if (!match_found)
store.remove_type(base_identified_type.identity, base_identified_type.type);
}
for (const identified_type &other_identified_type : other_identified_types) {
bool match_found = false;
for (const identified_type &base_identified_type : base_identified_types)
if (base_identified_type.identity == other_identified_type.identity) {
match_found = true;
break;
}
if (!match_found)
store.add_type(other_identified_type.identity, other_identified_type.type);
}
}
{ // assets
for (std::size_t base_asset_index = 0; base_asset_index < base.assets.size(); ++base_asset_index) {
const int base_asset_id(base.assets.get_id_at(base_asset_index));
const unity_asset &base_asset(base.assets.at(base_asset_index));
if (other.assets.has_id(base_asset_id)) {
const unity_asset &other_asset(other.assets.get_by_id(base_asset_id));
const type_identity &base_asset_identity(get_type_identity(base, base_asset.type_id));
const type_identity &other_asset_identity(get_type_identity(other, other_asset.type_id));
store.set_current_asset(base_asset_id);
if (base_asset_identity != other_asset_identity)
store.modify_asset_type(base_asset_id, base_asset_identity, other_asset_identity);
if (base_asset.type_id_2 != other_asset.type_id_2)
store.modify_asset_type_2(base_asset_id, base_asset.type_id_2, other_asset.type_id_2);
base_asset.value->compare(*other_asset.value, store);
if (
base_asset.file_layout.offset != other_asset.file_layout.offset
|| base_asset.file_layout.size != other_asset.file_layout.size) {
layout_modified = true;
}
} else {
store.remove_asset(base_asset_id, get_type_identity(base, base_asset.type_id), *base_asset.value);
}
}
for (std::size_t other_asset_index = 0; other_asset_index < other.assets.size(); ++other_asset_index) {
const int other_asset_id(other.assets.get_id_at(other_asset_index));
const unity_asset &other_asset(other.assets.at(other_asset_index));
if (!base.assets.has_id(other_asset_id))
store.add_asset(other_asset_id, get_type_identity(other, other_asset.type_id), *other_asset.value);
}
}
{ // file-references
for (const unity_file_reference &base_file_reference : base.file_references) {
bool match_found = false;
for (const unity_file_reference &other_file_reference : other.file_references)
if (base_file_reference.file_guid == other_file_reference.file_guid) {
match_found = true;
if (base_file_reference.properties != other_file_reference.properties)
store.modify_file_reference(base_file_reference.file_guid, base_file_reference.properties, other_file_reference.properties);
break;
}
if (!match_found)
store.remove_file_reference(base_file_reference);
}
for (const unity_file_reference &other_file_reference : other.file_references) {
bool match_found = false;
for (const unity_file_reference &base_file_reference : base.file_references)
if (base_file_reference.file_guid == other_file_reference.file_guid) {
match_found = true;
break;
}
if (!match_found)
store.add_file_reference(other_file_reference);;
}
}
{ // previews
for (const unity_preview &base_preview : base.previews) {
bool match_found = false;
for (const unity_preview &other_preview : other.previews)
if (base_preview.asset_id == other_preview.asset_id) {
match_found = true;
if (!are_previews_equal(base_preview, other_preview))
store.modify_preview(base_preview, other_preview);
if (
base_preview.file_layout.offset != other_preview.file_layout.offset
|| base_preview.file_layout.size != other_preview.file_layout.size) {
layout_modified = true;
}
break;
}
if (!match_found)
store.remove_preview(base_preview);
}
for (const unity_preview &other_preview : other.previews) {
bool match_found = false;
for (const unity_preview &base_preview : base.previews)
if (base_preview.asset_id == other_preview.asset_id) {
match_found = true;
break;
}
if (!match_found)
store.add_preview(other_preview);
}
}
if (layout_modified)
store.mark_modified_layout();
}
static void
check_main(struct token *t, struct type *ty) {
static struct type *maindef = NULL;
struct ty_func *tfunc = ty->tlist->tfunc;
struct sym_entry *se;
struct type *tytmp;
if (maindef != NULL) return;
if (ty->name[0] != 'm' || strcmp(ty->name + 1, "ain") != 0) {
return;
}
maindef = ty;
/* XXX why is it always null??? */
if (ty->code != TY_INT
|| ty->tlist->next != NULL) {
warningfl(t,
"Illegal return type for main(). ISO C says it must be `int'!");
return;
} else if (ty->storage == TOK_KEY_STATIC) {
warningfl(t, "Static (file scope) declaration of main()");
return;
}
switch (tfunc->nargs) {
case 0:
case -1:
/* int main(void) or int main() */
break;
case 1:
warningfl(t,
"main() should take no, two or three arguments");
break;
case 2:
case 3:
/* XXX check arg1 + 2 = int,char** */
se = tfunc->scope->slist;
tytmp = make_basic_type(TY_INT);
if (compare_types(se->dec->dtype, tytmp,
CMPTY_SIGN|CMPTY_CONST) != 0) {
warningfl(t, "First argument of main is not \
`int' as it should be");
}
tytmp = n_xmemdup(make_basic_type(TY_CHAR), sizeof *tytmp);
append_typelist(tytmp, TN_POINTER_TO, 0, NULL, NULL);
append_typelist(tytmp, TN_POINTER_TO, 0, NULL, NULL);
if (compare_types(se->next->dec->dtype, tytmp,
CMPTY_SIGN|CMPTY_CONST) != 0) {
warningfl(t, "Second argument of main is not \
`char **' as it should be");
}
free(tytmp);
if (tfunc->nargs == 3) {
/* XXX check arg3 = char** */
}
}
bool ME_runner_qq_Spin1_ZZ_4l::is_my_type(const process_description &in)
{
return compare_types(in, me);
}
bool ME_runner_no_Spin1_2f_4lA::is_my_type(const process_description &in)
{
return compare_types(in, me);
}
bool ME_runner_all_bkg_2f_ttbb_2::is_my_type(const process_description &in)
{
return compare_types(in, me);
}