gdb/testsuite/gdb.cp/overload.cc

   1 #include <stddef.h>
   2
   3 class foo {
   4 public:
   5   foo  (int);
   6   foo  (int, const char *);
   7   foo  (foo&);
   8   ~foo ();
   9   void foofunc (int);
  10   void foofunc (int, signed char *);
  11   int ifoo;
  12   const char *ccpfoo;
  13
  14 int overload1arg (void);
  15 int overload1arg (char);
  16 int overload1arg (signed char);
  17 int overload1arg (unsigned char);
  18 int overload1arg (short);
  19 int overload1arg (unsigned short);
  20 int overload1arg (int);
  21 int overload1arg (unsigned int);
  22 int overload1arg (long);
  23 int overload1arg (unsigned long);
  24 int overload1arg (float);
  25 int overload1arg (double);
  26
  27 int overload1arg (int*);
  28 int overload1arg (void*);
  29
  30 int overloadfnarg (void);
  31 int overloadfnarg (int);
  32 int overloadfnarg (int, int (*) (int));
  33
  34 int overloadargs (int a1);
  35 int overloadargs (int a1, int a2);
  36 int overloadargs (int a1, int a2, int a3);
  37 int overloadargs (int a1, int a2, int a3, int a4);
  38 int overloadargs (int a1, int a2, int a3, int a4, int a5);
  39 int overloadargs (int a1, int a2, int a3, int a4, int a5, int a6);
  40 int overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7);
  41 int overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8);
  42 int overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9);
  43 int overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7,
  44                    int a8, int a9, int a10);
  45 int overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7,
  46                    int a8, int a9, int a10, int a11);
  47
  48 };
  49
  50 struct K {
  51   static int staticoverload ();
  52   static int staticoverload (int);
  53   static int staticoverload (int, int);
  54 };
  55
  56 namespace N {
  57   int nsoverload () { return 1; }
  58   int nsoverload (int x) { return x; }
  59   int nsoverload (int x, int y) { return x + y; }
  60 };
  61
  62 int intToChar (char c) { return 297; }
  63
  64 void marker1()
  65 {}
  66
  67 // Now test how overloading and namespaces interact.
  68
  69 class dummyClass {};
  70
  71 dummyClass dummyInstance;
  72
  73 int overloadNamespace(int i)
  74 {
  75   return 1;
  76 }
  77
  78 int overloadNamespace(dummyClass d)
  79 {
  80   return 2;
  81 }
  82
  83 namespace XXX {
  84   int overloadNamespace (char c)
  85   {
  86     return 3;
  87   }
  88
  89   void marker2() {}
  90 }
  91
  92 class A {};
  93 class B: public A {};
  94 class C: public B {};
  95 class D: C {};
  96 class E {};
  97 class F {};
  98
  99 int bar (A) { return 11; }
 100 int bar (B) { return 22; }
 101
 102 int bar2 (E &, A &) { return 33; }
 103 int bar2 (F &, B &) { return 44; }
 104
 105 int intintfunc (int x) { return x; }
 106
 107 int main ()
 108 {
 109     char arg2 = 2;
 110     signed char arg3 =3;
 111     unsigned char arg4 =4;
 112     short arg5 =5;
 113     unsigned short arg6 =6;
 114     int arg7 =7;
 115     unsigned int arg8 =8;
 116     long arg9 =9;
 117     unsigned long arg10 =10;
 118     float arg11 =100.0;
 119     double arg12 = 200.0;
 120     int arg13 = 200;
 121     char arg14 = 'a';
 122
 123     A a;
 124     B b;
 125     C c;
 126     D d;
 127     E e;
 128     F f;
 129
 130     bar (a);
 131     bar (b);
 132     bar (c);
 133
 134     bar2 (e, b);
 135     bar2 (f, b);
 136
 137     char *str = (char *) "A";
 138     foo foo_instance1(111);
 139     foo foo_instance2(222, str);
 140     foo foo_instance3(foo_instance2);
 141
 142     // Some calls to ensure all the functions are emitted.
 143     K::staticoverload();
 144     K::staticoverload(2);
 145     K::staticoverload(2, 3);
 146     N::nsoverload();
 147     N::nsoverload(2);
 148     N::nsoverload(2, 3);
 149
 150     overloadNamespace (1);
 151     overloadNamespace (dummyInstance);
 152     XXX::overloadNamespace ('a');
 153
 154     // Verify that intToChar should work:
 155     intToChar(1);
 156
 157     marker1(); // marker1-returns-here
 158     XXX::marker2(); // marker1-returns-here
 159
 160     return 0;
 161 }
 162
 163 foo::foo  (int i)                  { ifoo = i; ccpfoo = NULL; }
 164 foo::foo  (int i, const char *ccp) { ifoo = i; ccpfoo = ccp; }
 165 foo::foo  (foo& afoo)              { ifoo = afoo.ifoo; ccpfoo = afoo.ccpfoo;}
 166 foo::~foo ()                       {}
 167
 168
 169 /* Some functions to test overloading by varying one argument type. */
 170
 171 int foo::overload1arg (void)                {  return 1; }
 172 int foo::overload1arg (char arg)            { arg = 0; return 2;}
 173 int foo::overload1arg (signed char arg)     { arg = 0; return 3;}
 174 int foo::overload1arg (unsigned char arg)   { arg = 0; return 4;}
 175 int foo::overload1arg (short arg)           { arg = 0; return 5;}
 176 int foo::overload1arg (unsigned short arg)  { arg = 0; return 6;}
 177 int foo::overload1arg (int arg)             { arg = 0; return 7;}
 178 int foo::overload1arg (unsigned int arg)    { arg = 0; return 8;}
 179 int foo::overload1arg (long arg)            { arg = 0; return 9;}
 180 int foo::overload1arg (unsigned long arg)   { arg = 0; return 10;}
 181 int foo::overload1arg (float arg)           { arg = 0; return 11;}
 182 int foo::overload1arg (double arg)          { arg = 0; return 12;}
 183 int foo::overload1arg (int* arg)            { arg = 0; return 13;}
 184 int foo::overload1arg (void* arg)           { arg = 0; return 14;}
 185
 186 /* Test to see that we can explicitly request overloaded functions
 187    with function pointers in the prototype. */
 188
 189 int foo::overloadfnarg (void) { return ifoo * 20; }
 190 int foo::overloadfnarg (int arg) { arg = 0; return 13;}
 191 int foo::overloadfnarg (int arg, int (*foo) (int))    { return foo(arg); }
 192
 193 /* Some functions to test overloading by varying argument count. */
 194
 195 int foo::overloadargs (int a1)
 196 { a1 = 0;
 197 return 1;}
 198
 199 int foo::overloadargs (int a1, int a2)
 200 { a1 = a2 = 0;
 201 return 2;}
 202
 203 int foo::overloadargs (int a1, int a2, int a3)
 204 { a1 = a2 = a3 = 0;
 205 return 3;}
 206
 207 int foo::overloadargs (int a1, int a2, int a3, int a4)
 208 { a1 = a2 = a3 = a4 = 0;
 209 return 4;}
 210
 211 int foo::overloadargs (int a1, int a2, int a3, int a4, int a5)
 212 { a1 = a2 = a3 = a4 = a5 = 0;
 213 return 5;}
 214
 215 int foo::overloadargs (int a1, int a2, int a3, int a4, int a5, int a6)
 216 { a1 = a2 = a3 = a4 = a5 = a6 = 0;
 217 return 6;}
 218
 219 int foo::overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7)
 220 { a1 = a2 = a3 = a4 = a5 = a6 = a7 = 0;
 221 return 7;}
 222
 223 int foo::overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7,
 224                    int a8)
 225 { a1 = a2 = a3 = a4 = a5 = a6 = a7 = a8 = 0;
 226 return 8;}
 227
 228 int foo::overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7,
 229                    int a8, int a9)
 230 {
 231   a1 = a2 = a3 = a4 = a5 = a6 = a7 = a8 = a9 = 0;
 232   return 9;
 233 }
 234
 235 int foo::overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7,
 236                    int a8, int a9, int a10)
 237                         { a1 = a2 = a3 = a4 = a5 = a6 = a7 = a8 = a9 =
 238                           a10 = 0; return 10;}
 239
 240 int foo::overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7,
 241                    int a8, int a9, int a10, int a11)
 242                         { a1 = a2 = a3 = a4 = a5 = a6 = a7 = a8 = a9 =
 243                           a10 = a11 = 0; return 11;}
 244
 245
 246
 247 int K::staticoverload () { return 1; }
 248 int K::staticoverload (int x) { return x; }
 249 int K::staticoverload (int x, int y) { return x + y; }