run copyright.sh for 2011.

[deliverable/binutils-gdb.git] / gdb / testsuite / gdb.cp / cpexprs.cc

/* This testcase is part of GDB, the GNU debugger.

   Copyright 2008, 2009, 2010, 2011 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
test_function (int argc, char* argv[]) // test_function
{ // test_function
  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;

  return 0;
}

int
main (int argc, char* argv[])
{
  int i;

  /* Call the test function repeatedly, enough times for all our tests
     without running forever if something goes wrong.  */
  for (i = 0; i < 1000; i++)
    test_function (argc, argv);

  return 0;
}