1#include <stddef.h>
2
3class foo {
4public:
5  foo  (int);
6  foo  (int, const char *);
7  foo  (foo&);
8  ~foo ();
9
10  void  operator *      (foo&);
11  void  operator %      (foo&);
12  void  operator -      (foo&);
13  void  operator >>     (foo&);
14  void  operator !=     (foo&);
15  void  operator >      (foo&);
16  void  operator >=     (foo&);
17  void  operator |      (foo&);
18  void  operator &&     (foo&);
19  void  operator !      (void);
20  void  operator ++     (int);
21  void  operator =      (foo&);
22  void  operator +=     (foo&);
23  void  operator *=     (foo&);
24  void  operator %=     (foo&);
25  void  operator >>=    (foo&);
26  void  operator |=     (foo&);
27  void  operator ,      (foo&);
28  void  operator /      (foo&);
29  void  operator +      (foo&);
30  void  operator <<     (foo&);
31  void  operator ==     (foo&);
32  void  operator <      (foo&);
33  void  operator <=     (foo&);
34  void  operator &      (foo&);
35  void  operator ^      (foo&);
36  void  operator ||     (foo&);
37  void  operator ~      (void);
38  void  operator --     (int);
39  foo*  operator ->     (void);
40  void  operator -=     (foo&);
41  void  operator /=     (foo&);
42  void  operator <<=    (foo&);
43  void  operator &=     (foo&);
44  void  operator ^=     (foo&);
45  void  operator ->*    (foo&);
46  void  operator []     (foo&);
47  void  operator ()     (foo&);
48  void* operator new    (size_t) throw ();
49  void  operator delete (void *);
50  /**/  operator int    ();
51  /**/  operator char*  ();
52
53  int foofunc (int); // forced to have int return type, which is required
54  int foofunc (int, signed char *); // forced to have int return type, which is required
55  int ifoo;
56  const char *ccpfoo;
57};
58
59#ifdef usestubs
60extern "C" {
61   void set_debug_traps();
62   void breakpoint();
63};
64#endif
65
66int main () {
67#ifdef usestubs
68   set_debug_traps();
69   breakpoint();
70#endif
71   int z=3;
72}
73
74foo::foo  (int i)                  { ifoo = i;}
75foo::foo  (int i, const char *ccp) { ifoo = i; ccpfoo = ccp; }
76foo::foo  (foo& afoo)              { afoo.ifoo = 0; }
77foo::~foo ()                       {}
78
79void  foo::operator *      (foo& afoo) { afoo.ifoo = 0; }
80void  foo::operator %      (foo& afoo) { afoo.ifoo = 0; }
81void  foo::operator -      (foo& afoo) { afoo.ifoo = 0; }
82void  foo::operator >>     (foo& afoo) { afoo.ifoo = 0; }
83void  foo::operator !=     (foo& afoo) { afoo.ifoo = 0; }
84void  foo::operator >      (foo& afoo) { afoo.ifoo = 0; }
85void  foo::operator >=     (foo& afoo) { afoo.ifoo = 0; }
86void  foo::operator |      (foo& afoo) { afoo.ifoo = 0; }
87void  foo::operator &&     (foo& afoo) { afoo.ifoo = 0; }
88void  foo::operator !      (void) {}
89void  foo::operator ++     (int ival) { ival = 0; }
90void  foo::operator =      (foo& afoo) { afoo.ifoo = 0; }
91void  foo::operator +=     (foo& afoo) { afoo.ifoo = 0; }
92void  foo::operator *=     (foo& afoo) { afoo.ifoo = 0; }
93void  foo::operator %=     (foo& afoo) { afoo.ifoo = 0; }
94void  foo::operator >>=    (foo& afoo) { afoo.ifoo = 0; }
95void  foo::operator |=     (foo& afoo) { afoo.ifoo = 0; }
96void  foo::operator ,      (foo& afoo) { afoo.ifoo = 0; }
97void  foo::operator /      (foo& afoo) { afoo.ifoo = 0; }
98void  foo::operator +      (foo& afoo) { afoo.ifoo = 0; }
99void  foo::operator <<     (foo& afoo) { afoo.ifoo = 0; }
100void  foo::operator ==     (foo& afoo) { afoo.ifoo = 0; }
101void  foo::operator <      (foo& afoo) { afoo.ifoo = 0; }
102void  foo::operator <=     (foo& afoo) { afoo.ifoo = 0; }
103void  foo::operator &      (foo& afoo) { afoo.ifoo = 0; }
104void  foo::operator ^      (foo& afoo) { afoo.ifoo = 0; }
105void  foo::operator ||     (foo& afoo) { afoo.ifoo = 0; }
106void  foo::operator ~      (void) {}
107void  foo::operator --     (int ival) { ival = 0; }
108foo*  foo::operator ->     (void) {return this;}
109void  foo::operator -=     (foo& afoo) { afoo.ifoo = 0; }
110void  foo::operator /=     (foo& afoo) { afoo.ifoo = 0; }
111void  foo::operator <<=    (foo& afoo) { afoo.ifoo = 0; }
112void  foo::operator &=     (foo& afoo) { afoo.ifoo = 0; }
113void  foo::operator ^=     (foo& afoo) { afoo.ifoo = 0; }
114void  foo::operator ->*    (foo& afoo) { afoo.ifoo = 0; }
115void  foo::operator []     (foo& afoo) { afoo.ifoo = 0; }
116void  foo::operator ()     (foo& afoo) { afoo.ifoo = 0; }
117void* foo::operator new    (size_t ival) throw () { ival = 0; return 0; }
118void  foo::operator delete (void *ptr) { ptr = 0; }
119/**/  foo::operator int    () { return 0; }
120/**/  foo::operator char*  () { return 0; }
121
122/* Some functions to test overloading by varying one argument type. */
123
124void overload1arg (void)		{          }
125void overload1arg (char arg)		{ arg = 0; }
126void overload1arg (signed char arg)	{ arg = 0; }
127void overload1arg (unsigned char arg)	{ arg = 0; }
128void overload1arg (short arg)		{ arg = 0; }
129void overload1arg (unsigned short arg)	{ arg = 0; }
130void overload1arg (int arg)		{ arg = 0; }
131void overload1arg (unsigned int arg)	{ arg = 0; }
132void overload1arg (long arg)		{ arg = 0; }
133void overload1arg (unsigned long arg)	{ arg = 0; }
134void overload1arg (float arg)		{ arg = 0; }
135void overload1arg (double arg)		{ arg = 0; }
136
137/* Some functions to test overloading by varying argument count. */
138
139void overloadargs (int a1)				{ a1 = 0; }
140void overloadargs (int a1, int a2)			{ a1 = a2 = 0; }
141void overloadargs (int a1, int a2, int a3)		{ a1 = a2 = a3 = 0; }
142void overloadargs (int a1, int a2, int a3, int a4)
143			{ a1 = a2 = a3 = a4 = 0; }
144void overloadargs (int a1, int a2, int a3, int a4, int a5)
145			{ a1 = a2 = a3 = a4 = a5 = 0; }
146void overloadargs (int a1, int a2, int a3, int a4, int a5, int a6)
147			{ a1 = a2 = a3 = a4 = a5 = a6 = 0; }
148void overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7)
149			{ a1 = a2 = a3 = a4 = a5 = a6 = a7 = 0; }
150void overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7,
151		   int a8)
152			{ a1 = a2 = a3 = a4 = a5 = a6 = a7 = a8 = 0; }
153void overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7,
154		   int a8, int a9)
155			{ a1 = a2 = a3 = a4 = a5 = a6 = a7 = a8 = a9 = 0; }
156void overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7,
157		   int a8, int a9, int a10)
158			{ a1 = a2 = a3 = a4 = a5 = a6 = a7 = a8 = a9 =
159			  a10 = 0; }
160void overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7,
161		   int a8, int a9, int a10, int a11)
162			{ a1 = a2 = a3 = a4 = a5 = a6 = a7 = a8 = a9 =
163			  a10 = a11 == 0; }
164
165/* Some hairy function definitions.
166   Use typedefs to help maintain sanity. */
167
168typedef int   (*PFPc_i)(char *);
169typedef short (*PFPl_s)(long *);
170typedef short (*PFPc_s)(char *);
171typedef int   (*PFl_i)(long);
172typedef PFl_i (*PFPc_PFl_i)(char *);
173typedef PFl_i (*PFPi_PFl_i)(int *);
174typedef PFl_i (*PFPFPc_i_PFl_i)(PFPc_i);
175typedef PFl_i (*PFs_PFl_i)(short);
176typedef int   (*PFPFPl_s_i)(PFPl_s);
177typedef int   (*PFPFPc_s_i)(PFPc_s);
178
179PFs_PFl_i hairyfunc1 (int arg)			{ arg = 0; return 0; }
180int       hairyfunc2 (PFPc_i arg)		{ arg = 0; return 0; }
181int	  hairyfunc3 (PFPFPl_s_i arg)		{ arg = 0; return 0; }
182int	  hairyfunc4 (PFPFPc_s_i arg)		{ arg = 0; return 0; }
183int	  hairyfunc5 (PFPc_PFl_i arg)		{ arg = 0; return 0; }
184int	  hairyfunc6 (PFPi_PFl_i arg)		{ arg = 0; return 0; }
185int	  hairyfunc7 (PFPFPc_i_PFl_i arg)	{ arg = 0; return 0; }
186
187/* gdb has two demanglers (one for g++ 2.95, one for g++ 3).
188   These marker functions help me figure out which demangler is in use. */
189
190char *	dm_type_char_star (char * p)		{ return p; }
191int	dm_type_foo_ref (foo & foo)		{ return foo.ifoo; }
192int *	dm_type_int_star (int * p)		{ return p; }
193long *	dm_type_long_star (long * p)		{ return p; }
194int	dm_type_unsigned_int (unsigned int i)	{ return i; }
195int	dm_type_void (void)			{ return 0; }
196void *	dm_type_void_star (void * p)		{ return p; }
197