Subversion Repositories openrisc

// { dg-do assemble  }
// { dg-options "" }

// GROUPS passed operators
// Check that the & operator, when applied to a global function
// or member function returns a proper value as long as the context
// in which the result of & is used requires a pointer to a specific
// unambigous (function-pointer) type.
//
// This test fails (in test5()) when compiled with g++ 1.34.1.

extern "C" int printf (const char *, ...); 

int function (char c);
int function (float f);

class base {
        int filler;
public:
        int method (char);
        int method (float);
};

void* vp;

typedef int (*ptr_to_func_of_char)(char);
typedef int (*ptr_to_func_of_float)(float);
typedef int (base::*ptr_to_method_of_char)(char);
typedef int (base::*ptr_to_method_of_float)(float);

int test2 (void*);
int test3 (void*);
int test4 (void*);
int test5 (void*);

base* base_ptr;

int fail ()
{
  printf ("FAIL\n");
  return 1;
}

int main ()
{
        base_ptr = new base;

        ptr_to_func_of_char p0 = &function;
        vp = (void*) p0;
        if (test2 (vp))
                return fail ();
        ptr_to_func_of_float p1 = &function;
        vp = (void*) p1;
        if (test3 (vp))
                return fail ();
        ptr_to_method_of_char p2 = &base::method;
        vp = (void*) p2; // { dg-warning "converting" } 
        if (test4 (vp))
                return fail ();
        ptr_to_method_of_float p3 = &base::method;
        vp = (void*) p3; // { dg-warning "converting" } 
        if (test5 (vp))
                return fail ();

        printf ("PASS\n");
        return 0;
}

int test2 (void* vp)
{
        char ch = 'x';

        return (((ptr_to_func_of_char)vp)(ch) !=  9901);
}

int test3 (void* vp)
{
        float flt = 9.9;

        return (((ptr_to_func_of_float)vp)(flt) !=  9902);
}

int test4 (void* vp)
{
        char ch = 'x';
        ptr_to_method_of_char p = (ptr_to_method_of_char) vp; // { dg-error "invalid cast" } bad type conversion

        return ((base_ptr->*p)(ch) !=  9904);
}

int test5 (void* vp)
{
        float flt = 9.9;
        ptr_to_method_of_float p = (ptr_to_method_of_float) vp; // { dg-error "invalid cast" } bad type conversion

        if ((base_ptr->*p)(flt) !=  9905) {
                return 1;
        } else
                return 0;
}

int function (char c)
{
        c = c;
        return 9901;
}

int function (float f)
{
        f = f;
        return 9902;
}

int base::method (char c)
{
        c = c;
        return 9904;
}

int base::method (float f)
{
        f = f;
        return 9905;
}