1/* This testcase is part of GDB, the GNU debugger.
2
3   Copyright 2017-2023 Free Software Foundation, Inc.
4
5   This program is free software; you can redistribute it and/or modify
6   it under the terms of the GNU General Public License as published by
7   the Free Software Foundation; either version 3 of the License, or
8   (at your option) any later version.
9
10   This program is distributed in the hope that it will be useful,
11   but WITHOUT ANY WARRANTY; without even the implied warranty of
12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13   GNU General Public License for more details.
14
15   You should have received a copy of the GNU General Public License
16   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
17
18#include <cstddef>
19
20/* Code for operator() tests.  */
21
22struct test_unique_op_call
23{
24  void operator() (int);
25};
26
27void
28test_unique_op_call::operator() (int)
29{}
30
31struct test_op_call
32{
33  void operator() ();
34  void operator() (int);
35  void operator() (long);
36
37  template<typename T>
38  void operator() (T *);
39};
40
41void
42test_op_call::operator() (int)
43{}
44
45void
46test_op_call::operator() ()
47{}
48
49void
50test_op_call::operator() (long)
51{}
52
53template<typename T>
54void
55test_op_call::operator() (T *t)
56{
57}
58
59/* Code for operator[] tests.  */
60
61struct test_unique_op_array
62{
63  void operator[] (int);
64};
65
66void
67test_unique_op_array::operator[] (int)
68{}
69
70struct test_op_array
71{
72  void operator[] (int);
73  void operator[] (long);
74
75  template<typename T>
76  void operator[] (T *);
77};
78
79void
80test_op_array::operator[] (int)
81{}
82
83void
84test_op_array::operator[] (long)
85{}
86
87template<typename T>
88void
89test_op_array::operator[] (T *t)
90{}
91
92/* Code for operator new tests.  */
93
94static int dummy;
95
96struct test_op_new
97{
98  void *operator new (size_t);
99};
100
101void *
102test_op_new::operator new (size_t)
103{
104  return &dummy;
105}
106
107/* Code for operator delete tests.  */
108
109struct test_op_delete
110{
111  void operator delete (void *);
112};
113
114void
115test_op_delete::operator delete (void *)
116{
117}
118
119/* Code for operator new[] tests.  */
120
121struct test_op_new_array
122{
123  void *operator new[] (size_t);
124};
125
126void *
127test_op_new_array::operator new[] (size_t)
128{
129  return &dummy;
130}
131
132/* Code for operator delete[] tests.  */
133
134struct test_op_delete_array
135{
136  void operator delete[] (void *);
137};
138
139void
140test_op_delete_array::operator delete[] (void *)
141{
142}
143
144/* Code for user-defined conversion tests.  */
145
146struct test_op_conversion_res;
147
148struct test_op_conversion
149{
150  operator const volatile test_op_conversion_res **() const volatile;
151};
152
153test_op_conversion::operator const volatile test_op_conversion_res **()
154  const volatile
155{
156  return NULL;
157}
158
159/* Code for the assignment operator tests.  */
160
161struct test_op_assign
162{
163  test_op_assign operator= (const test_op_assign &);
164};
165
166test_op_assign
167test_op_assign::operator= (const test_op_assign &)
168{
169  return test_op_assign ();
170}
171
172/* Code for the arrow operator tests.  */
173
174struct test_op_arrow
175{
176  test_op_arrow operator-> ();
177};
178
179test_op_arrow
180test_op_arrow::operator-> ()
181{
182  return test_op_arrow ();
183}
184
185/* Code for the logical/arithmetic operators tests.  */
186
187struct E
188{
189};
190
191#define GEN_OP(NS, ...)				\
192  namespace test_ops {				\
193    void operator __VA_ARGS__ {}		\
194  }						\
195  namespace test_op_ ## NS {			\
196    void operator __VA_ARGS__ {}		\
197  }
198
199GEN_OP (PLUS_A,    +=  (E, E)  )
200GEN_OP (PLUS,      +   (E, E)  )
201GEN_OP (MINUS_A,   -=  (E, E)  )
202GEN_OP (MINUS,     -   (E, E)  )
203GEN_OP (MOD_A,     %=  (E, E)  )
204GEN_OP (MOD,       %   (E, E)  )
205GEN_OP (EQ,        ==  (E, E)  )
206GEN_OP (NEQ,       !=  (E, E)  )
207GEN_OP (LAND,      &&  (E, E)  )
208GEN_OP (LOR,       ||  (E, E)  )
209GEN_OP (SL_A,      <<= (E, E)  )
210GEN_OP (SR_A,      >>= (E, E)  )
211GEN_OP (SL,        <<  (E, E)  )
212GEN_OP (SR,        >>  (E, E)  )
213GEN_OP (OE,        |=  (E, E)  )
214GEN_OP (BIT_O,     |   (E, E)  )
215GEN_OP (XOR_A,     ^=  (E, E)  )
216GEN_OP (XOR,       ^   (E, E)  )
217GEN_OP (BIT_AND_A, &=  (E, E)  )
218GEN_OP (BIT_AND,   &   (E, E)  )
219GEN_OP (LT,        <   (E, E)  )
220GEN_OP (LTE,       <=  (E, E)  )
221GEN_OP (GTE,       >=  (E, E)  )
222GEN_OP (GT,        >   (E, E)  )
223GEN_OP (MUL_A,     *=  (E, E)  )
224GEN_OP (MUL,       *   (E, E)  )
225GEN_OP (DIV_A,     /=  (E, E)  )
226GEN_OP (DIV,       /   (E, E)  )
227GEN_OP (NEG,       ~   (E)      )
228GEN_OP (NOT,       !   (E)      )
229GEN_OP (PRE_INC,   ++  (E)      )
230GEN_OP (POST_INC,  ++  (E, int) )
231GEN_OP (PRE_DEC,   --  (E)      )
232GEN_OP (POST_DEC,  --  (E, int) )
233GEN_OP (COMMA,     ,   (E, E)  )
234
235int
236main ()
237{
238  test_op_call opcall;
239  opcall ();
240  opcall (1);
241  opcall (1l);
242  opcall ((int *) 0);
243
244  test_unique_op_call opcall2;
245  opcall2 (1);
246
247  test_op_array op_array;
248  op_array[1];
249  op_array[1l];
250  op_array[(int *) 0];
251
252  test_unique_op_array unique_op_array;
253  unique_op_array[1];
254
255  return 0;
256}
257