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