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