1/* This testcase is part of GDB, the GNU debugger.
2
3   Copyright 2017-2020 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/* Code for the all-param-prefixes test.  */
19
20void
21param_prefixes_test_long (long)
22{}
23
24void
25param_prefixes_test_intp_intr (int *, int&)
26{}
27
28/* Code for the overload test.  */
29
30void
31overload_ambiguous_test (long)
32{}
33
34void
35overload_ambiguous_test (int, int)
36{}
37
38void
39overload_ambiguous_test (int, long)
40{}
41
42/* Code for the overload-2 test.  */
43
44/* Generate functions/methods all with the same name, in different
45   scopes, but all with different parameters.  */
46
47struct overload2_arg1 {};
48struct overload2_arg2 {};
49struct overload2_arg3 {};
50struct overload2_arg4 {};
51struct overload2_arg5 {};
52struct overload2_arg6 {};
53struct overload2_arg7 {};
54struct overload2_arg8 {};
55struct overload2_arg9 {};
56struct overload2_arga {};
57
58#define GEN_OVERLOAD2_FUNCTIONS(ARG1, ARG2)		\
59  void							\
60  overload2_function (ARG1)				\
61  {}							\
62							\
63  struct struct_overload2_test				\
64  {							\
65    void overload2_function (ARG2);			\
66  };							\
67							\
68  void							\
69  struct_overload2_test::overload2_function (ARG2)	\
70  {}
71
72/* In the global namespace.  */
73GEN_OVERLOAD2_FUNCTIONS( overload2_arg1, overload2_arg2)
74
75namespace
76{
77  /* In an anonymous namespace.  */
78  GEN_OVERLOAD2_FUNCTIONS (overload2_arg3, overload2_arg4)
79}
80
81namespace ns_overload2_test
82{
83  /* In a namespace.  */
84  GEN_OVERLOAD2_FUNCTIONS (overload2_arg5, overload2_arg6)
85
86  namespace
87  {
88    /* In a nested anonymous namespace.  */
89    GEN_OVERLOAD2_FUNCTIONS (overload2_arg7, overload2_arg8)
90
91    namespace ns_overload2_test
92    {
93      /* In a nested namespace.  */
94      GEN_OVERLOAD2_FUNCTIONS (overload2_arg9, overload2_arga)
95    }
96  }
97}
98
99/* Code for the overload-3 test.  */
100
101#define GEN_OVERLOAD3_FUNCTIONS(ARG1, ARG2)		\
102  void							\
103  overload3_function (ARG1)				\
104  {}							\
105  void							\
106  overload3_function (ARG2)				\
107  {}							\
108							\
109  struct struct_overload3_test				\
110  {							\
111    void overload3_function (ARG1);			\
112    void overload3_function (ARG2);			\
113  };							\
114							\
115  void							\
116  struct_overload3_test::overload3_function (ARG1)	\
117  {}							\
118  void							\
119  struct_overload3_test::overload3_function (ARG2)	\
120  {}
121
122/* In the global namespace.  */
123GEN_OVERLOAD3_FUNCTIONS (int, long)
124
125namespace
126{
127  /* In an anonymous namespace.  */
128  GEN_OVERLOAD3_FUNCTIONS (int, long)
129}
130
131namespace ns_overload3_test
132{
133  /* In a namespace.  */
134  GEN_OVERLOAD3_FUNCTIONS (int, long)
135
136  namespace
137  {
138    /* In a nested anonymous namespace.  */
139    GEN_OVERLOAD3_FUNCTIONS (int, long)
140
141    namespace ns_overload3_test
142    {
143      /* In a nested namespace.  */
144      GEN_OVERLOAD3_FUNCTIONS (int, long)
145    }
146  }
147}
148
149/* Code for the template-overload tests.  */
150
151template <typename T>
152struct template_struct
153{
154  T template_overload_fn (T);
155};
156
157template <typename T>
158T template_struct<T>::template_overload_fn (T t)
159{
160  return t;
161}
162
163template_struct<int> template_struct_int;
164template_struct<long> template_struct_long;
165
166/* Code for the template2-ret-type tests.  */
167
168template <typename T>
169struct template2_ret_type {};
170
171template <typename T>
172struct template2_struct
173{
174  template <typename T2, typename T3>
175  T template2_fn (T = T (), T2 t2 = T2 (), T3 t3 = T3 ());
176};
177
178template <typename T>
179template <typename T2, typename T3>
180T template2_struct<T>::template2_fn (T t, T2 t2, T3 t3)
181{
182  return T ();
183}
184
185template2_struct<template2_ret_type<int> > template2_struct_inst;
186
187/* Code for the const-overload tests.  */
188
189struct struct_with_const_overload
190{
191  void const_overload_fn ();
192  void const_overload_fn () const;
193};
194
195void
196struct_with_const_overload::const_overload_fn ()
197{}
198
199void
200struct_with_const_overload::const_overload_fn () const
201{}
202
203void
204not_overloaded_fn ()
205{}
206
207/* Code for the incomplete-scope-colon tests.  */
208
209struct struct_incomplete_scope_colon_test
210{
211  void incomplete_scope_colon_test ();
212};
213
214void
215struct_incomplete_scope_colon_test::incomplete_scope_colon_test ()
216{}
217
218namespace ns_incomplete_scope_colon_test
219{
220  void incomplete_scope_colon_test () {}
221}
222
223namespace ns2_incomplete_scope_colon_test
224{
225  struct struct_in_ns2_incomplete_scope_colon_test
226  {
227    void incomplete_scope_colon_test ();
228  };
229
230  void
231  struct_in_ns2_incomplete_scope_colon_test::incomplete_scope_colon_test ()
232  {}
233}
234
235/* Code for the anon-ns tests.  */
236
237namespace
238{
239  void anon_ns_function ()
240  {}
241
242  struct anon_ns_struct
243  {
244    void anon_ns_function ();
245  };
246
247  void
248  anon_ns_struct::anon_ns_function ()
249  {}
250}
251
252namespace the_anon_ns_wrapper_ns
253{
254
255namespace
256{
257  void anon_ns_function ()
258  {}
259
260  struct anon_ns_struct
261  {
262    void anon_ns_function ();
263  };
264
265  void
266  anon_ns_struct::anon_ns_function ()
267  {}
268}
269
270} /* the_anon_ns_wrapper_ns */
271
272/* Code for the global-ns-scope-op tests.  */
273
274void global_ns_scope_op_function ()
275{
276}
277
278/* Add a function with the same name to a namespace.  We want to test
279   that "b ::global_ns_function" does NOT select it.  */
280namespace the_global_ns_scope_op_ns
281{
282  void global_ns_scope_op_function ()
283  {
284  }
285}
286
287/* Code for the ambiguous-prefix tests.  */
288
289/* Create a few functions/methods with the same "ambiguous_prefix_"
290   prefix.  They in different scopes, but "b ambiguous_prefix_<tab>"
291   should list them all, and figure out the LCD is
292   ambiguous_prefix_.  */
293
294void ambiguous_prefix_global_func ()
295{
296}
297
298namespace the_ambiguous_prefix_ns
299{
300  void ambiguous_prefix_ns_func ()
301  {
302  }
303}
304
305struct the_ambiguous_prefix_struct
306{
307  void ambiguous_prefix_method ();
308};
309
310void
311the_ambiguous_prefix_struct::ambiguous_prefix_method ()
312{
313}
314
315/* Code for the function-labels test.  */
316
317int
318function_with_labels (int i)
319{
320  if (i > 0)
321    {
322    label1:
323      return i + 20;
324    }
325  else
326    {
327    label2:
328      return i + 10;
329    }
330}
331
332/* Code for the no-data-symbols and if-expression tests.  */
333
334int code_data = 0;
335
336int another_data = 0;
337
338/* A function that has a same "code" prefix as the global above.  We
339   want to ensure that completing on "b code" doesn't offer the data
340   symbol.  */
341void
342code_function ()
343{
344}
345
346/* Code for the operator< tests.  */
347
348enum foo_enum
349  {
350    foo_value
351  };
352
353bool operator<(foo_enum lhs, foo_enum rhs)
354{
355 label1:
356	return false;
357}
358
359/* Code for the in-source-file-unconstrained /
360   in-source-file-ambiguous tests.  */
361
362int
363file_constrained_test_cpls_function (int i)
364{
365  if (i > 0)
366    {
367    label1:
368      return i + 20;
369    }
370  else
371    {
372    label2:
373      return i + 10;
374    }
375}
376
377
378int
379main ()
380{
381  template2_struct_inst.template2_fn<int, int> ();
382  template_struct_int.template_overload_fn(0);
383  template_struct_long.template_overload_fn(0);
384
385  return 0;
386}
387