gnu/dist/gdb6/gdb/testsuite/gdb.cp/templates.cc

   1 /* This test code is from Wendell Baker (wbaker@comet.berkeley.edu) */
   2
   3 #include <stddef.h>
   4
   5 int a_i;
   6 char a_c;
   7 double a_d;
   8
   9 typedef void *Pix;
  10
  11 int
  12 f(int i)
  13 { return 0; }
  14
  15 int
  16 f(int i, char c)
  17 { return 0; }
  18
  19 int
  20 f(int i, char c, double d)
  21 { return 0; }
  22
  23 int
  24 f(int i, char c, double d, char *cs)
  25 { return 0; }
  26
  27 int
  28 f(int i, char c, double d, char *cs, void (*fig)(int, char))
  29 { return 0; }
  30
  31 int
  32 f(int i, char c, double d, char *cs, void (*fig)(char, int))
  33 { return 0; }
  34
  35 class R {
  36 public:
  37     int i;
  38 };
  39 class S {
  40 public:
  41     int i;
  42 };
  43 class T {
  44 public:
  45     int i;
  46 };
  47
  48 char g(char, const char, volatile char)
  49 { return 'c'; }
  50 char g(R, char&, const char&, volatile char&)
  51 { return 'c'; }
  52 char g(char*, const char*, volatile char*)
  53 { return 'c'; }
  54 char g(S, char*&, const char*&, volatile char*&)
  55 { return 'c'; }
  56
  57 signed char g(T,signed char, const signed char, volatile signed char)
  58 { return 'c'; }
  59 signed char g(T, R, signed char&, const signed char&, volatile signed char&)
  60 { return 'c'; }
  61 signed char g(T, signed char*, const signed char*, volatile signed char*)
  62 { return 'c'; }
  63 signed char g(T, S, signed char*&, const signed char*&, volatile signed char*&)
  64 { return 'c'; }
  65
  66 unsigned char g(unsigned char, const unsigned char, volatile unsigned char)
  67 { return 'c'; }
  68 unsigned char g(R, unsigned char&, const unsigned char&, volatile unsigned char&)
  69 { return 'c'; }
  70 unsigned char g(unsigned char*, const unsigned char*, volatile unsigned char*)
  71 { return 'c'; }
  72 unsigned char g(S, unsigned char*&, const unsigned char*&, volatile unsigned char*&)
  73 { return 'c'; }
  74
  75 short g(short, const short, volatile short)
  76 { return 0; }
  77 short g(R, short&, const short&, volatile short&)
  78 { return 0; }
  79 short g(short*, const short*, volatile short*)
  80 { return 0; }
  81 short g(S, short*&, const short*&, volatile short*&)
  82 { return 0; }
  83
  84 signed short g(T, signed short, const signed short, volatile signed short)
  85 { return 0; }
  86 signed short g(T, R, signed short&, const signed short&, volatile signed short&)
  87 { return 0; }
  88 signed short g(T, signed short*, const signed short*, volatile signed short*)
  89 { return 0; }
  90 signed short g(T, S, double, signed short*&, const signed short*&, volatile signed short*&)
  91 { return 0; }
  92
  93 unsigned short g(unsigned short, const unsigned short, volatile unsigned short)
  94 { return 0; }
  95 unsigned short g(R, unsigned short&, const unsigned short&, volatile unsigned short&)
  96 { return 0; }
  97 unsigned short g(unsigned short*, const unsigned short*, volatile unsigned short*)
  98 { return 0; }
  99 unsigned short g(S, unsigned short*&, const unsigned short*&, volatile unsigned short*&)
 100 { return 0; }
 101
 102 int g(int, const int, volatile int)
 103 { return 0; }
 104 int g(R, int&, const int&, volatile int&)
 105 { return 0; }
 106 int g(int*, const int*, volatile int*)
 107 { return 0; }
 108 int g(S, int*&, const int*&, volatile int*&)
 109 { return 0; }
 110
 111 signed int g(T, signed int, const signed int, volatile signed int)
 112 { return 0; }
 113 signed int g(T, R, signed int&, const signed int&, volatile signed int&)
 114 { return 0; }
 115 signed int g(T, signed int*, const signed int*, volatile signed int*)
 116 { return 0; }
 117 signed int g(T, S, signed int*&, const signed int*&, volatile signed int*&)
 118 { return 0; }
 119
 120 unsigned int g(unsigned int, const unsigned int, volatile unsigned int)
 121 { return 0; }
 122 unsigned int g(R, unsigned int&, const unsigned int&, volatile unsigned int&)
 123 { return 0; }
 124 unsigned int g(unsigned int*, const unsigned int*, volatile unsigned int*)
 125 { return 0; }
 126 unsigned int g(S, unsigned int*&, const unsigned int*&, volatile unsigned int*&)
 127 { return 0; }
 128
 129 long g(long, const long, volatile long)
 130 { return 0; }
 131 long g(R, long&, const long&, volatile long&)
 132 { return 0; }
 133 long g(long*, const long*, volatile long*)
 134 { return 0; }
 135 long g(S, long*&, const long*&, volatile long*&)
 136 { return 0; }
 137
 138 signed long g(T, signed long, const signed long, volatile signed long)
 139 { return 0; }
 140 signed long g(T, R, signed long&, const signed long&, volatile signed long&)
 141 { return 0; }
 142 signed long g(T, signed long*, const signed long*, volatile signed long*)
 143 { return 0; }
 144 signed long g(T, S, signed long*&, const signed long*&, volatile signed long*&)
 145 { return 0; }
 146
 147 unsigned long g(unsigned long, const unsigned long, volatile unsigned long)
 148 { return 0; }
 149 unsigned long g(S, unsigned long&, const unsigned long&, volatile unsigned long&)
 150 { return 0; }
 151 unsigned long g(unsigned long*, const unsigned long*, volatile unsigned long*)
 152 { return 0; }
 153 unsigned long g(S, unsigned long*&, const unsigned long*&, volatile unsigned long*&)
 154 { return 0; }
 155
 156 #ifdef __GNUC__
 157 long long g(long long, const long long, volatile long long)
 158 { return 0; }
 159 long long g(S, long long&, const long long&, volatile long long&)
 160 { return 0; }
 161 long long g(long long*, const long long*, volatile long long*)
 162 { return 0; }
 163 long long g(R, long long*&, const long long*&, volatile long long*&)
 164 { return 0; }
 165
 166 signed long long g(T, signed long long, const signed long long, volatile signed long long)
 167 { return 0; }
 168 signed long long g(T, R, signed long long&, const signed long long&, volatile signed long long&)
 169 { return 0; }
 170 signed long long g(T, signed long long*, const signed long long*, volatile signed long long*)
 171 { return 0; }
 172 signed long long g(T, S, signed long long*&, const signed long long*&, volatile signed long long*&)
 173 { return 0; }
 174
 175 unsigned long long g(unsigned long long, const unsigned long long, volatile unsigned long long)
 176 { return 0; }
 177 unsigned long long g(R, unsigned long long*, const unsigned long long*, volatile unsigned long long*)
 178 { return 0; }
 179 unsigned long long g(unsigned long long&, const unsigned long long&, volatile unsigned long long&)
 180 { return 0; }
 181 unsigned long long g(S, unsigned long long*&, const unsigned long long*&, volatile unsigned long long*&)
 182 { return 0; }
 183 #endif
 184
 185 float g(float, const float, volatile float)
 186 { return 0; }
 187 float g(char, float&, const float&, volatile float&)
 188 { return 0; }
 189 float g(float*, const float*, volatile float*)
 190 { return 0; }
 191 float g(char, float*&, const float*&, volatile float*&)
 192 { return 0; }
 193
 194 double g(double, const double, volatile double)
 195 { return 0; }
 196 double g(char, double&, const double&, volatile double&)
 197 { return 0; }
 198 double g(double*, const double*, volatile double*)
 199 { return 0; }
 200 double g(char, double*&, const double*&, volatile double*&)
 201 { return 0; }
 202
 203 #ifdef __GNUC__
 204 long double g(long double, const long double, volatile long double)
 205 { return 0; }
 206 long double g(char, long double&, const long double&, volatile long double&)
 207 { return 0; }
 208 long double g(long double*, const long double*, volatile long double*)
 209 { return 0; }
 210 long double g(char, long double*&, const long double*&, volatile long double*&)
 211 { return 0; }
 212 #endif
 213
 214 class c {
 215 public:
 216     c(int) {};
 217     int i;
 218 };
 219
 220 class c g(c, const c, volatile c)
 221 { return 0; }
 222 c g(char, c&, const c&, volatile c&)
 223 { return 0; }
 224 c g(c*, const c*, volatile c*)
 225 { return 0; }
 226 c g(char, c*&, const c*&, volatile c*&)
 227 { return 0; }
 228
 229 /*
 230 void h(char = 'a')
 231 { }
 232 void h(char, signed char = 'a')
 233 { }
 234 void h(unsigned char = 'a')
 235 { }
 236 */
 237 /*
 238 void h(char = (char)'a')
 239 { }
 240 void h(char, signed char = (signed char)'a')
 241 { }
 242 void h(unsigned char = (unsigned char)'a')
 243 { }
 244
 245
 246 void h(short = (short)43)
 247 { }
 248 void h(char, signed short = (signed short)43)
 249 { }
 250 void h(unsigned short = (unsigned short)43)
 251 { }
 252
 253 void h(int = (int)43)
 254 { }
 255 void h(char, signed int = (signed int)43)
 256 { }
 257 void h(unsigned int = (unsigned int)43)
 258 { }
 259
 260
 261 void h(long = (long)43)
 262 { }
 263 void h(char, signed long = (signed long)43)
 264 { }
 265 void h(unsigned long = (unsigned long)43)
 266 { }
 267
 268 #ifdef __GNUC__
 269 void h(long long = 43)
 270 { }
 271 void h(char, signed long long = 43)
 272 { }
 273 void h(unsigned long long = 43)
 274 { }
 275 #endif
 276
 277 void h(float = 4.3e-10)
 278 { }
 279 void h(double = 4.3)
 280 { }
 281 #ifdef __GNUC__
 282 void h(long double = 4.33e33)
 283 { }
 284 #endif
 285 */
 286
 287 /* An unneeded printf() definition - actually, just a stub - used to occupy
 288    this space.  It has been removed and replaced with this comment which
 289    exists to occupy some lines so that templates.exp won't need adjustment.  */
 290
 291 class T1 {
 292 public:
 293     static void* operator new(size_t) throw ();
 294     static void operator delete(void *pointer);
 295
 296     void operator=(const T1&);
 297     T1& operator=(int);
 298
 299     int operator==(int) const;
 300     int operator==(const T1&) const;
 301     int operator!=(int) const;
 302     int operator!=(const T1&) const;
 303
 304     int operator<=(int) const;
 305     int operator<=(const T1&) const;
 306     int operator<(int) const;
 307     int operator<(const T1&) const;
 308     int operator>=(int) const;
 309     int operator>=(const T1&) const;
 310     int operator>(int) const;
 311     int operator>(const T1&) const;
 312
 313     void operator+(int) const;
 314     T1& operator+(const T1&) const;
 315     void operator+=(int) const;
 316     T1& operator+=(const T1&) const;
 317
 318     T1& operator++() const;
 319
 320     void operator-(int) const;
 321     T1& operator-(const T1&) const;
 322     void operator-=(int) const;
 323     T1& operator-=(const T1&) const;
 324
 325     T1& operator--() const;
 326
 327     void operator*(int) const;
 328     T1& operator*(const T1&) const;
 329     void operator*=(int) const;
 330     T1& operator*=(const T1&) const;
 331
 332     void operator/(int) const;
 333     T1& operator/(const T1&) const;
 334     void operator/=(int) const;
 335     T1& operator/=(const T1&) const;
 336
 337     void operator%(int) const;
 338     T1& operator%(const T1&) const;
 339     void operator%=(int) const;
 340     T1& operator%=(const T1&) const;
 341
 342     void operator&&(int) const;
 343     T1& operator&&(const T1&) const;
 344
 345     void operator||(int) const;
 346     T1& operator||(const T1&) const;
 347
 348     void operator&(int) const;
 349     T1& operator&(const T1&) const;
 350     void operator&=(int) const;
 351     T1& operator&=(const T1&) const;
 352
 353     void operator|(int) const;
 354     T1& operator|(const T1&) const;
 355     void operator|=(int) const;
 356     T1& operator|=(const T1&) const;
 357
 358     void operator^(int) const;
 359     T1& operator^(const T1&) const;
 360     void operator^=(int) const;
 361     T1& operator^=(const T1&) const;
 362
 363     T1& operator!() const;
 364     T1& operator~() const;
 365 };
 366
 367 void*
 368 T1::operator new(size_t) throw ()
 369 { return 0; }
 370
 371 void
 372 T1::operator delete(void *pointer)
 373 { }
 374
 375 class T2 {
 376 public:
 377     T2(int i): integer(i)
 378         { }
 379     int integer;
 380 };
 381
 382 int operator==(const T2&, const T2&)
 383 { return 0; }
 384 int operator==(const T2&, char)
 385 { return 0; }
 386 int operator!=(const T2&, const T2&)
 387 { return 0; }
 388 int operator!=(const T2&, char)
 389 { return 0; }
 390
 391 int operator<=(const T2&, const T2&)
 392 { return 0; }
 393 int operator<=(const T2&, char)
 394 { return 0; }
 395 int operator<(const T2&, const T2&)
 396 { return 0; }
 397 int operator<(const T2&, char)
 398 { return 0; }
 399 int operator>=(const T2&, const T2&)
 400 { return 0; }
 401 int operator>=(const T2&, char)
 402 { return 0; }
 403 int operator>(const T2&, const T2&)
 404 { return 0; }
 405 int operator>(const T2&, char)
 406 { return 0; }
 407
 408 T2 operator+(const T2 t, int i)
 409 { return t.integer + i; }
 410 T2 operator+(const T2 a, const T2& b)
 411 { return a.integer + b.integer; }
 412 T2& operator+=(T2& t, int i)
 413 { t.integer += i; return t; }
 414 T2& operator+=(T2& a, const T2& b)
 415 { a.integer += b.integer; return a; }
 416
 417 T2 operator-(const T2 t, int i)
 418 { return t.integer - i; }
 419 T2 operator-(const T2 a, const T2& b)
 420 { return a.integer - b.integer; }
 421 T2& operator-=(T2& t, int i)
 422 { t.integer -= i; return t; }
 423 T2& operator-=(T2& a, const T2& b)
 424 { a.integer -= b.integer; return a; }
 425
 426 T2 operator*(const T2 t, int i)
 427 { return t.integer * i; }
 428 T2 operator*(const T2 a, const T2& b)
 429 { return a.integer * b.integer; }
 430 T2& operator*=(T2& t, int i)
 431 { t.integer *= i; return t; }
 432 T2& operator*=(T2& a, const T2& b)
 433 { a.integer *= b.integer; return a; }
 434
 435 T2 operator/(const T2 t, int i)
 436 { return t.integer / i; }
 437 T2 operator/(const T2 a, const T2& b)
 438 { return a.integer / b.integer; }
 439 T2& operator/=(T2& t, int i)
 440 { t.integer /= i; return t; }
 441 T2& operator/=(T2& a, const T2& b)
 442 { a.integer /= b.integer; return a; }
 443
 444 T2 operator%(const T2 t, int i)
 445 { return t.integer % i; }
 446 T2 operator%(const T2 a, const T2& b)
 447 { return a.integer % b.integer; }
 448 T2& operator%=(T2& t, int i)
 449 { t.integer %= i; return t; }
 450 T2& operator%=(T2& a, const T2& b)
 451 { a.integer %= b.integer; return a; }
 452
 453 template<class T>
 454 class T5 {
 455 public:
 456     T5(int);
 457     T5(const T5<T>&);
 458     ~T5();
 459     static void* operator new(size_t) throw ();
 460     static void operator delete(void *pointer);
 461     int value();
 462
 463     static T X;
 464     T x;
 465     int val;
 466 };
 467
 468 template<class T>
 469 T5<T>::T5(int v)
 470 { val = v; }
 471
 472 template<class T>
 473 T5<T>::T5(const T5<T>&)
 474 {}
 475
 476 template<class T>
 477 T5<T>::~T5()
 478 {}
 479
 480 template<class T>
 481 void*
 482 T5<T>::operator new(size_t) throw ()
 483 { return 0; }
 484
 485 template<class T>
 486 void
 487 T5<T>::operator delete(void *pointer)
 488 { }
 489
 490 template<class T>
 491 int
 492 T5<T>::value()
 493 { return val; }
 494
 495
 496 #if ! defined(__GNUC__) || defined(GCC_BUG)
 497 template<class T>
 498 T T5<T>::X;
 499 #endif
 500
 501
 502
 503
 504 T5<char> t5c(1);
 505 T5<int> t5i(2);
 506 T5<int (*)(char, void *)> t5fi1(3);
 507 T5<int (*)(int, double **, void *)> t5fi2(4);
 508
 509
 510
 511
 512
 513
 514 class x {
 515 public:
 516     int (*manage[5])(double,
 517                      void *(*malloc)(unsigned size),
 518                      void (*free)(void *pointer));
 519     int (*device[5])(int open(const char *, unsigned mode, unsigned perms, int extra),
 520                      int *(*read)(int fd, void *place, unsigned size),
 521                      int *(*write)(int fd, void *place, unsigned size),
 522                      void (*close)(int fd));
 523 };
 524 T5<x> t5x(5);
 525
 526 #if !defined(__GNUC__) || (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 6)
 527 template class T5<char>;
 528 template class T5<int>;
 529 template class T5<int (*)(char, void *)>;
 530 template class T5<int (*)(int, double **, void *)>;
 531 template class T5<x>;
 532 #endif
 533
 534 class T7 {
 535 public:
 536     static int get();
 537     static void put(int);
 538 };
 539
 540 int
 541 T7::get()
 542 { return 1; }
 543
 544 void
 545 T7::put(int i)
 546 {
 547     // nothing
 548 }
 549
 550 // More template kinds.  GDB 4.16 didn't handle these, but
 551 // Wildebeest does.  Note: Assuming HP aCC is used to compile
 552 // this file; with g++ or HP cfront or other compilers the
 553 // demangling may not get done correctly.
 554
 555 // Ordinary template, to be instantiated with different types
 556 template<class T>
 557 class Foo {
 558 public:
 559   int x;
 560   T t;
 561   T foo (int, T);
 562 };
 563
 564
 565 template<class T> T Foo<T>::foo (int i, T tt)
 566 {
 567   return tt;
 568 }
 569
 570 // Template with int parameter
 571
 572 template<class T, int sz>
 573 class Bar {
 574 public:
 575   int x;
 576   T t;
 577   T bar (int, T);
 578 };
 579
 580
 581 template<class T, int sz> T Bar<T, sz>::bar (int i, T tt)
 582 {
 583   if (i < sz)
 584     return tt;
 585   else
 586     return 0;
 587 }
 588
 589 // function template with int parameter
 590 template<class T> int dummy (T tt, int i)
 591 {
 592   return tt;
 593 }
 594
 595 // Template with partial specializations
 596 template<class T1, class T2>
 597 class Spec {
 598 public:
 599   int x;
 600   T1 spec (T2);
 601 };
 602
 603 template<class T1, class T2>
 604 T1 Spec<T1, T2>::spec (T2 t2)
 605 {
 606   return 0;
 607 }
 608
 609 template<class T>
 610 class Spec<T, T*> {
 611 public:
 612   int x;
 613   T spec (T*);
 614 };
 615
 616 template<class T>
 617 T Spec<T, T*>::spec (T * tp)
 618 {
 619   return *tp;
 620 }
 621
 622 // Template with char parameter
 623 template<class T, char sz>
 624 class Baz {
 625 public:
 626   int x;
 627   T t;
 628   T baz (int, T);
 629 };
 630
 631 template<class T, char sz> T Baz<T, sz>::baz (int i, T tt)
 632 {
 633   if (i < sz)
 634     return tt;
 635   else
 636     return 0;
 637 }
 638
 639 // Template with char * parameter
 640 template<class T, char * sz>
 641 class Qux {
 642 public:
 643   int x;
 644   T t;
 645   T qux (int, T);
 646 };
 647
 648 template<class T, char * sz> T Qux<T, sz>::qux (int i, T tt)
 649 {
 650   if (sz[0] == 'q')
 651     return tt;
 652   else
 653     return 0;
 654 }
 655
 656 // Template with a function pointer parameter
 657 template<class T, int (*f)(int) >
 658 class Qux1 {
 659 public:
 660   int x;
 661   T t;
 662   T qux (int, T);
 663 };
 664
 665 template<class T, int (*f)(int)> T Qux1<T, f>::qux (int i, T tt)
 666 {
 667   if (f != 0)
 668     return tt;
 669   else
 670     return 0;
 671 }
 672
 673 // Some functions to provide as arguments to template
 674 int gf1 (int a) {
 675   return a * 2 + 13;
 676 }
 677 int gf2 (int a) {
 678   return a * 2 + 26;
 679 }
 680
 681 char string[3];
 682
 683
 684 // Template for nested instantiations
 685
 686 template<class T>
 687 class Garply {
 688 public:
 689   int x;
 690   T t;
 691   T garply (int, T);
 692 };
 693
 694 template<class T> T Garply<T>::garply (int i, T tt)
 695 {
 696   if (i > x)
 697     return tt;
 698   else
 699     {
 700       x += i;
 701       return tt;
 702     }
 703 }
 704
 705
 706 int main()
 707 {
 708     int i;
 709 #ifdef usestubs
 710     set_debug_traps();
 711     breakpoint();
 712 #endif
 713     i = i + 1;
 714
 715     // New tests added here
 716
 717   Foo<int> fint={0,0};
 718   Foo<char> fchar={0,0};
 719   Foo<volatile char *> fvpchar = {0, 0};
 720
 721   Bar<int, 33> bint;
 722   Bar<int, (4 > 3)> bint2;
 723
 724   Baz<int, 's'> bazint;
 725   Baz<char, 'a'> bazint2;
 726
 727   Qux<char, string> quxint2;
 728   Qux<int, string> quxint;
 729
 730   Qux1<int, gf1> qux11;
 731
 732   int x = fint.foo(33, 47);
 733   char c = fchar.foo(33, 'x');
 734   volatile char * cp = fvpchar.foo(33, 0);
 735
 736   int y = dummy<int> (400, 600);
 737
 738   int z = bint.bar(55, 66);
 739   z += bint2.bar(55, 66);
 740
 741   c = bazint2.baz(4, 'y');
 742   c = quxint2.qux(4, 'z');
 743
 744   y = bazint.baz(4,3);
 745   y = quxint.qux(4, 22);
 746   y += qux11.qux(4, 22);
 747
 748   y *= gf1(y) - gf2(y);
 749
 750   Spec<int, char> sic;
 751   Spec<int, int *> siip;
 752
 753   sic.spec ('c');
 754   siip.spec (&x);
 755
 756   Garply<int> f;
 757   Garply<char> fc;
 758   f.x = 13;
 759
 760   Garply<Garply<char> > nf;
 761   nf.x = 31;
 762
 763   x = f.garply (3, 4);
 764
 765   fc = nf.garply (3, fc);
 766
 767   y = x + fc.x;
 768
 769
 770   return 0;
 771
 772 }
 773
 774
 775
 776
 777
 778
 779
 780
 781
 782
 783
 784
 785