1 files changed, 431 insertions, 0 deletions
diff --git a/gdb/testsuite/gdb.cp/cpexprs.cc b/gdb/testsuite/gdb.cp/cpexprs.cc
new file mode 100644
index 0000000..2bca4cd
--- /dev/null
+++ b/gdb/testsuite/gdb.cp/cpexprs.cc
@@ -0,0 +1,431 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 2008, 2009, 2010 Free Software Foundation, Inc.
+
+   Contributed by Red Hat, originally written by Keith Seitz.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   Please email any bugs, comments, and/or additions to this file to:
+   bug-gdb@gnu.org  */
+
+#include <stdlib.h>
+#include <iostream>
+
+// Forward decls
+class base;
+class derived;
+
+// A simple template with specializations
+template <typename T>
+class tclass
+{
+public:
+  void do_something () { } // tclass<T>::do_something
+};
+
+template <>
+void tclass<char>::do_something () { } // tclass<char>::do_something
+
+template <>
+void tclass<int>::do_something () { } // tclass<int>::do_something
+
+template<>
+void tclass<long>::do_something () { } // tclass<long>::do_something
+
+template<>
+void tclass<short>::do_something () { } // tclass<short>::do_something
+
+// A simple template with multiple template parameters
+template <class A, class B, class C, class D, class E>
+void flubber (void) // flubber
+{
+  A a;
+  B b;
+  C c;
+  D d;
+  E e;
+
+  ++a;
+  ++b;
+  ++c;
+  ++d;
+  ++e;
+}
+
+// Some contrived policies
+template <class T>
+struct operation_1
+{
+  static void function (void) { } // operation_1<T>::function
+};
+
+template <class T>
+struct operation_2
+{
+  static void function (void) { } // operation_2<T>::function
+};
+
+template <class T>
+struct operation_3
+{
+  static void function (void) { } // operation_3<T>::function
+};
+
+template <class T>
+struct operation_4
+{
+  static void function (void) { } // operation_4<T>::function
+};
+
+// A policy-based class w/ and w/o default policy
+template <class T, class Policy>
+class policy : public Policy
+{
+public:
+  policy (T obj) : obj_ (obj) { } // policy<T, Policy>::policy
+
+private:
+  T obj_;
+};
+
+template <class T, class Policy = operation_1<T> >
+class policyd : public Policy
+{
+public:
+  policyd (T obj) : obj_ (obj) { } // policyd<T, Policy>::policyd
+  ~policyd (void) { } // policyd<T, Policy>::~policyd
+
+private:
+  T obj_;
+};
+
+typedef policy<int, operation_1<void*> > policy1;
+typedef policy<int, operation_2<void*> > policy2;
+typedef policy<int, operation_3<void*> > policy3;
+typedef policy<int, operation_4<void*> > policy4;
+
+typedef policyd<int> policyd1;
+typedef policyd<long> policyd2;
+typedef policyd<char> policyd3;
+typedef policyd<base> policyd4;
+typedef policyd<tclass<int> > policyd5;
+
+class fluff { };
+static fluff *g_fluff = new fluff ();
+
+class base
+{
+protected:
+  int foo_;
+
+public:
+  base (void) : foo_ (42) { } // base::base(void)
+  base (int foo) : foo_ (foo) { } // base::base(int)
+  ~base (void) { } // base::~base
+
+  // Some overloaded methods
+  int overload (void) const { return 0; } // base::overload(void) const
+  int overload (int i) const { return 1; } // base::overload(int) const
+  int overload (short s) const { return 2; } // base::overload(short) const
+  int overload (long l) const { return 3; } // base::overload(long) const
+  int overload (char* a) const { return 4; } // base::overload(char*) const
+  int overload (base& b) const { return 5; } // base::overload(base&) const
+
+  // Operators
+  int operator+ (base const& o) const // base::operator+
+  { return foo_ + o.foo_; }
+
+  base operator++ (void) // base::operator++
+  { ++foo_; return *this; }
+
+  base operator+=(base const& o) // base::operator+=
+  { foo_ += o.foo_; return *this; }
+
+  int operator- (base const& o) const // base::operator-
+  { return foo_ - o.foo_; }
+
+  base operator-- (void) // base::operator--
+  { --foo_; return *this; }
+
+  base operator-= (base const& o) // base::operator-=
+  { foo_ -= o.foo_; return *this; }
+
+  int operator* (base const& o) const // base::operator*
+  { return foo_ * o.foo_; }
+
+  base operator*= (base const& o) // base::operator*=
+  { foo_ *= o.foo_; return *this; }
+
+  int operator/ (base const& o) const // base::operator/
+  { return foo_ / o.foo_; }
+
+  base operator/= (base const& o) // base::operator/=
+  { foo_ /= o.foo_; return *this; }
+
+  int operator% (base const& o) const // base::operator%
+  { return foo_ % o.foo_; }
+  
+  base operator%= (base const& o) // base::operator%=
+  { foo_ %= o.foo_; return *this; }
+
+  bool operator< (base const& o) const // base::operator<
+  { return foo_ < o.foo_; }
+
+  bool operator<= (base const& o) const // base::operator<=
+  { return foo_ <= o.foo_; }
+
+  bool operator> (base const& o) const // base::operator>
+  { return foo_ > o.foo_; }
+
+  bool operator>= (base const& o) const // base::operator>=
+  { return foo_ >= o.foo_; }
+
+  bool operator!= (base const& o) const // base::operator!=
+  { return foo_ != o.foo_; }
+
+  bool operator== (base const& o) const // base::operator==
+  { return foo_ == o.foo_; }
+
+  bool operator! (void) const // base::operator!
+  { return !foo_; }
+
+  bool operator&& (base const& o) const // base::operator&&
+  { return foo_ && o.foo_; }
+
+  bool operator|| (base const& o) const // base::operator||
+  { return foo_ || o.foo_; }
+
+  int operator<< (int value) const // base::operator<<
+  { return foo_  << value; }
+
+  base operator<<= (int value) // base::operator<<=
+  { foo_ <<= value; return *this; }
+
+  int operator>> (int value) const // base::operator>>
+  { return foo_  >> value; }
+
+  base operator>>= (int value) // base::operator>>=
+  { foo_ >>= value; return *this; }
+
+  int operator~ (void) const // base::operator~
+  { return ~foo_; }
+
+  int operator& (base const& o) const // base::operator&
+  { return foo_ & o.foo_; }
+
+  base operator&= (base const& o) // base::operator&=
+  { foo_ &= o.foo_; return *this; }
+
+  int operator| (base const& o) const // base::operator|
+  { return foo_ | o.foo_; }
+
+  base operator|= (base const& o) // base::operator|=
+  { foo_ |= o.foo_; return *this; }
+  
+  int operator^ (base const& o) const // base::operator^
+  { return foo_ ^ o.foo_; }
+
+  base operator^= (base const& o) // base::operator^=
+  { foo_ ^= o.foo_; return *this; }
+
+  base operator= (base const& o) // base::operator=
+  { foo_ = o.foo_; return *this; }
+
+  void operator() (void) const // base::operator()
+  { return; }
+
+  int operator[] (int idx) const // base::operator[]
+  { return idx; }
+
+  void* operator new (size_t size) throw () // base::operator new
+  { return malloc (size); }
+
+  void operator delete (void* ptr) // base::operator delete
+  { free (ptr); }
+
+  void* operator new[] (size_t size) throw () // base::operator new[]
+  { return malloc (size); }
+
+  void operator delete[] (void* ptr) // base::operator delete[]
+  { free (ptr); }
+
+  base const* operator-> (void) const // base::opeartor->
+  { return this; }
+
+  int operator->* (base const& b) const // base::operator->*
+  {  return foo_ * b.foo_; }
+
+  operator char* () const { return const_cast<char*> ("hello"); } // base::operator char*
+  operator int () const { return 21; } // base::operator int
+  operator fluff* () const { return new fluff (); } // base::operator fluff*
+  operator fluff** () const { return &g_fluff; } // base::operator fluff**
+};
+
+class base1 : public virtual base
+{
+public:
+  base1 (void) : foo_ (21) { } // base1::base1(void)
+  base1 (int a) : foo_(a) { } // base1::base1(int)
+  void a_function (void) const { } // base1::a_function
+
+protected:
+  int foo_;
+};
+
+class base2 : public virtual base
+{
+public:
+  base2 () : foo_ (3) { } // base2::base2
+
+protected:
+  void a_function (void) const { } // base2::a_function
+  int foo_;
+};
+
+class derived : public base1, public base2
+{
+  public:
+  derived(void) : foo_ (4) { } // derived::derived
+  void a_function (void) const // derived::a_function
+  { 
+    this->base1::a_function ();
+    this->base2::a_function ();
+  }
+
+  protected:
+  int foo_;
+};
+
+int
+main (int argc, char* argv[]) // main
+{ // main
+  derived d;
+  void (derived::*pfunc) (void) const = &derived::a_function;
+  (d.*pfunc) ();
+
+  base a (1), b (3), c (8);
+  (void) a.overload ();
+  (void) a.overload (static_cast<int> (0));
+  (void) a.overload (static_cast<short> (0));
+  (void) a.overload (static_cast<long> (0));
+  (void) a.overload (static_cast<char*> (0));
+  (void) a.overload (a);
+
+  int r;
+  r = b + c;
+  ++a;
+  a += b;
+  r = b - c;
+  --a;
+  a -= b;
+  r = b * c;
+  a *= b;
+  r = b / c;
+  a /= b;
+  r = b % c;
+  a %= b;
+  bool x = (b < c);
+  x = (b <= c);
+  x = (b > c);
+  x = (b >= c);
+  x = (b != c);
+  x = (b == c);
+  x = (!b);
+  x = (b && c);
+  x = (b || c);
+  r = b << 2;
+  a <<= 1;
+  r = b >> 2;
+  a >>= 1;
+  r = ~b;
+  r = b & c;
+  a &= c;
+  r = b | c;
+  a |= c;
+  r = b ^ c;
+  a ^= c;
+  a = c;
+  a ();
+  int i = a[3];
+  derived* f = new derived ();
+  derived* g = new derived[3];
+  delete f;
+  delete[] g;
+  a->overload ();
+  r = a->*b;
+
+  tclass<char> char_tclass;
+  tclass<int> int_tclass;
+  tclass<short> short_tclass;
+  tclass<long> long_tclass;
+  tclass<base> base_tclass;
+  char_tclass.do_something ();
+  int_tclass.do_something ();
+  short_tclass.do_something ();
+  long_tclass.do_something ();
+  base_tclass.do_something ();
+
+  flubber<int, int, int, int, int> ();
+  flubber<int, int, int, int, short> ();
+  flubber<int, int, int, int, long> ();
+  flubber<int, int, int, int, char> ();
+  flubber<int, int, int, short, int> ();
+  flubber<int, int, int, short, short> ();
+  flubber<int, int, int, short, long> ();
+  flubber<int, int, int, short, char> ();
+  flubber<int, int, int, long, int> ();
+  flubber<int, int, int, long, short> ();
+  flubber<int, int, int, long, long> ();
+  flubber<int, int, int, long, char> ();
+  flubber<int, int, int, char, int> ();
+  flubber<int, int, int, char, short> ();
+  flubber<int, int, int, char, long> ();
+  flubber<int, int, int, char, char> ();
+  flubber<int, int, short, int, int> ();
+  flubber<int, int, short, int, short> ();
+  flubber<int, int, short, int, long> ();
+  flubber<int, int, short, int, char> ();
+  flubber<int, int, short, short, int> ();
+  flubber<short, int, short, int, short> ();
+  flubber<long, short, long, short, long> ();
+
+  policy1 p1 (1);
+  p1.function ();
+  policy2 p2 (2);
+  p2.function ();
+  policy3 p3 (3);
+  p3.function ();
+  policy4 p4 (4);
+  p4.function ();
+
+  policyd1 pd1 (5);
+  pd1.function ();
+  policyd2 pd2 (6);
+  pd2.function ();
+  policyd3 pd3 (7);
+  pd3.function ();
+  policyd4 pd4 (d);
+  pd4.function ();
+  policyd5 pd5 (int_tclass);
+  pd5.function ();
+
+  base1 b1 (3);
+
+  r = a;
+  char* str = a;
+  fluff* flp = a;
+  fluff** flpp = a;
+}
+