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
  97 int bar (A) { return 11; }
  98 int bar (B) { return 22; }
  99
 100 int intintfunc (int x) { return x; }
 101
 102 int main ()
 103 {
 104     char arg2 = 2;
 105     signed char arg3 =3;
 106     unsigned char arg4 =4;
 107     short arg5 =5;
 108     unsigned short arg6 =6;
 109     int arg7 =7;
 110     unsigned int arg8 =8;
 111     long arg9 =9;
 112     unsigned long arg10 =10;
 113     float arg11 =100.0;
 114     double arg12 = 200.0;
 115     int arg13 = 200;
 116     char arg14 = 'a';
 117
 118     A a;
 119     B b;
 120     C c;
 121     D d;
 122
 123     bar (a);
 124     bar (b);
 125     bar (c);
 126
 127     char *str = (char *) "A";
 128     foo foo_instance1(111);
 129     foo foo_instance2(222, str);
 130     foo foo_instance3(foo_instance2);
 131
 132     // Some calls to ensure all the functions are emitted.
 133     K::staticoverload();
 134     K::staticoverload(2);
 135     K::staticoverload(2, 3);
 136     N::nsoverload();
 137     N::nsoverload(2);
 138     N::nsoverload(2, 3);
 139
 140     overloadNamespace (1);
 141     overloadNamespace (dummyInstance);
 142     XXX::overloadNamespace ('a');
 143
 144     // Verify that intToChar should work:
 145     intToChar(1);
 146
 147     marker1(); // marker1-returns-here
 148     XXX::marker2(); // marker1-returns-here
 149
 150     return 0;
 151 }
 152
 153 foo::foo  (int i)                  { ifoo = i; ccpfoo = NULL; }
 154 foo::foo  (int i, const char *ccp) { ifoo = i; ccpfoo = ccp; }
 155 foo::foo  (foo& afoo)              { ifoo = afoo.ifoo; ccpfoo = afoo.ccpfoo;}
 156 foo::~foo ()                       {}
 157
 158
 159 /* Some functions to test overloading by varying one argument type. */
 160
 161 int foo::overload1arg (void)                {  return 1; }
 162 int foo::overload1arg (char arg)            { arg = 0; return 2;}
 163 int foo::overload1arg (signed char arg)     { arg = 0; return 3;}
 164 int foo::overload1arg (unsigned char arg)   { arg = 0; return 4;}
 165 int foo::overload1arg (short arg)           { arg = 0; return 5;}
 166 int foo::overload1arg (unsigned short arg)  { arg = 0; return 6;}
 167 int foo::overload1arg (int arg)             { arg = 0; return 7;}
 168 int foo::overload1arg (unsigned int arg)    { arg = 0; return 8;}
 169 int foo::overload1arg (long arg)            { arg = 0; return 9;}
 170 int foo::overload1arg (unsigned long arg)   { arg = 0; return 10;}
 171 int foo::overload1arg (float arg)           { arg = 0; return 11;}
 172 int foo::overload1arg (double arg)          { arg = 0; return 12;}
 173 int foo::overload1arg (int* arg)            { arg = 0; return 13;}
 174 int foo::overload1arg (void* arg)           { arg = 0; return 14;}
 175
 176 /* Test to see that we can explicitly request overloaded functions
 177    with function pointers in the prototype. */
 178
 179 int foo::overloadfnarg (void) { return ifoo * 20; }
 180 int foo::overloadfnarg (int arg) { arg = 0; return 13;}
 181 int foo::overloadfnarg (int arg, int (*foo) (int))    { return foo(arg); }
 182
 183 /* Some functions to test overloading by varying argument count. */
 184
 185 int foo::overloadargs (int a1)
 186 { a1 = 0;
 187 return 1;}
 188
 189 int foo::overloadargs (int a1, int a2)
 190 { a1 = a2 = 0;
 191 return 2;}
 192
 193 int foo::overloadargs (int a1, int a2, int a3)
 194 { a1 = a2 = a3 = 0;
 195 return 3;}
 196
 197 int foo::overloadargs (int a1, int a2, int a3, int a4)
 198 { a1 = a2 = a3 = a4 = 0;
 199 return 4;}
 200
 201 int foo::overloadargs (int a1, int a2, int a3, int a4, int a5)
 202 { a1 = a2 = a3 = a4 = a5 = 0;
 203 return 5;}
 204
 205 int foo::overloadargs (int a1, int a2, int a3, int a4, int a5, int a6)
 206 { a1 = a2 = a3 = a4 = a5 = a6 = 0;
 207 return 6;}
 208
 209 int foo::overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7)
 210 { a1 = a2 = a3 = a4 = a5 = a6 = a7 = 0;
 211 return 7;}
 212
 213 int foo::overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7,
 214                    int a8)
 215 { a1 = a2 = a3 = a4 = a5 = a6 = a7 = a8 = 0;
 216 return 8;}
 217
 218 int foo::overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7,
 219                    int a8, int a9)
 220 {
 221   a1 = a2 = a3 = a4 = a5 = a6 = a7 = a8 = a9 = 0;
 222   return 9;
 223 }
 224
 225 int foo::overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7,
 226                    int a8, int a9, int a10)
 227                         { a1 = a2 = a3 = a4 = a5 = a6 = a7 = a8 = a9 =
 228                           a10 = 0; return 10;}
 229
 230 int foo::overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7,
 231                    int a8, int a9, int a10, int a11)
 232                         { a1 = a2 = a3 = a4 = a5 = a6 = a7 = a8 = a9 =
 233                           a10 = a11 = 0; return 11;}
 234
 235
 236
 237 int K::staticoverload () { return 1; }
 238 int K::staticoverload (int x) { return x; }
 239 int K::staticoverload (int x, int y) { return x + y; }