]>
Commit | Line | Data |
---|---|---|
113ee09a TV |
1 | # cpexprs.exp - C++ expressions tests |
2 | # | |
1d506c26 | 3 | # Copyright 2008-2024 Free Software Foundation, Inc. |
113ee09a TV |
4 | # |
5 | # Contributed by Red Hat, originally written by Keith Seitz. | |
6 | # | |
7 | # This program is free software; you can redistribute it and/or modify | |
8 | # it under the terms of the GNU General Public License as published by | |
9 | # the Free Software Foundation; either version 3 of the License, or | |
10 | # (at your option) any later version. | |
11 | # | |
12 | # This program is distributed in the hope that it will be useful, | |
13 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | # GNU General Public License for more details. | |
16 | # | |
17 | # You should have received a copy of the GNU General Public License | |
18 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
19 | ||
20 | # This file is part of the gdb testsuite. | |
21 | ||
22 | # A helper proc which sets a breakpoint at FUNC and attempts to | |
23 | # run to the breakpoint. | |
24 | proc test_breakpoint {func} { | |
25 | global DEC | |
26 | ||
27 | # Return to the top of the test function every time. | |
28 | delete_breakpoints | |
29 | if { ! [gdb_breakpoint test_function] } { | |
30 | fail "set test_function breakpoint for $func" | |
31 | } elseif { [gdb_test "continue" \ | |
32 | "Continuing.\r\n\r\nBreakpoint $DEC+,.*test_function.*" \ | |
cce0ae56 | 33 | "continue to test_function for $func"] != 0 } { |
113ee09a TV |
34 | } else { |
35 | gdb_breakpoint "$func" | |
36 | set i [expr {[string last : $func] + 1}] | |
37 | set efunc [string_to_regexp [string range $func $i end]] | |
38 | gdb_test "continue" \ | |
39 | "Continuing.\r\n\r\nBreakpoint $DEC+,.*$efunc.*" \ | |
40 | "continue to $func" | |
41 | } | |
42 | } | |
43 | ||
44 | # Add a function to the list of tested functions | |
45 | # FUNC is the name of the function (which will be passed to gdb commands) | |
46 | # TYPE is the type of the function, as expected from the "print" command | |
47 | # PRINT is the name of the function, as expected result of the print command | |
48 | # *OR* "-", indicating that FUNC should be used (needed for virtual/inherited | |
49 | # funcs) | |
50 | # LST is either the expected result of the list command (the comment from | |
51 | # the source code) *OR* "-", in which case FUNC will be used | |
52 | # | |
53 | # Usage: | |
54 | # add NAME TYPE PRINT LST | |
55 | # add NAME TYPE PRINT - | |
56 | proc add_type_regexp {func type print lst} { | |
57 | global all_functions CONVAR ADDR | |
58 | ||
59 | set all_functions($func,type) $type | |
60 | if {$print == "-"} { | |
61 | set print $func | |
62 | } | |
63 | ||
64 | # An exception: since gdb canonicalizes C++ output, | |
65 | # "(void)" must be mutated to "()". | |
66 | regsub {\(void\)} $print {()} print | |
67 | ||
68 | set all_functions($func,print) \ | |
69 | "$CONVAR = {$type} $ADDR <[string_to_regexp $print].*>" | |
70 | if {$lst == "-"} { | |
71 | set lst "$func" | |
72 | } | |
73 | set all_functions($func,list) ".*// [string_to_regexp $lst]" | |
74 | } | |
75 | ||
76 | proc add {func type print lst} { | |
77 | add_type_regexp $func [string_to_regexp $type] $print $lst | |
78 | } | |
79 | ||
80 | proc get {func cmd} { | |
81 | global all_functions | |
82 | return $all_functions($func,$cmd) | |
83 | } | |
84 | ||
85 | # Returns a list of function names for a given command | |
86 | proc get_functions {cmd} { | |
87 | global all_functions | |
88 | set result {} | |
89 | foreach i [array names all_functions *,$cmd] { | |
90 | if {$all_functions($i) != ""} { | |
91 | set idx [string last , $i] | |
92 | if {$idx != -1} { | |
93 | lappend result [string range $i 0 [expr {$idx - 1}]] | |
94 | } | |
95 | } | |
96 | } | |
97 | ||
98 | return [lsort $result] | |
99 | } | |
100 | ||
101 | # Some convenience variables for this test | |
102 | set DEC {[0-9]}; # a decimal number | |
103 | set HEX {[0-9a-fA-F]}; # a hexidecimal number | |
104 | set CONVAR "\\\$$DEC+"; # convenience variable regexp | |
105 | set ADDR "0x$HEX+"; # address | |
106 | ||
107 | # An array of functions/methods that we are testing... | |
108 | # Each element consists is indexed by NAME,COMMAND, where | |
109 | # NAME is the function name and COMMAND is the gdb command that | |
110 | # we are testing. The value of the array for any index pair is | |
111 | # the expected result of running COMMAND with the NAME as argument. | |
112 | ||
113 | # The array holding all functions/methods to test. Valid subindexes | |
114 | # are (none need character escaping -- "add" will take care of that): | |
115 | ||
116 | # add name type print_name list | |
117 | # NAME,type: value is type of function | |
118 | # NAME,print: value is print name of function (careful w/inherited/virtual!) | |
119 | # NAME,list: value is comment in source code on first line of function | |
120 | # (without the leading "//") | |
121 | array set all_functions {} | |
122 | ||
123 | # "Normal" functions/methods | |
124 | add {test_function} \ | |
125 | {int (int, char **)} \ | |
126 | - \ | |
127 | - | |
128 | add {derived::a_function} \ | |
129 | {void (const derived * const)} \ | |
130 | - \ | |
131 | - | |
132 | add {base1::a_function} \ | |
133 | {void (const base1 * const)} \ | |
134 | - \ | |
135 | - | |
136 | add {base2::a_function} \ | |
137 | {void (const base2 * const)} \ | |
138 | - \ | |
139 | - | |
140 | ||
141 | # Constructors | |
142 | ||
143 | # On targets using the ARM EABI, the constructor is expected to return | |
144 | # "this". | |
145 | proc ctor_ret { type } { | |
146 | if { [istarget arm*-*eabi*] || [is_aarch32_target] } { | |
147 | return "$type *" | |
148 | } else { | |
149 | return "void " | |
150 | } | |
151 | } | |
152 | ||
153 | proc ctor_prefix { type } { | |
154 | set ret [ctor_ret $type] | |
155 | return "${ret}($type * const" | |
156 | } | |
157 | ||
158 | proc ctor { type arglist } { | |
159 | if { $arglist != "" } { | |
160 | set arglist ", $arglist" | |
161 | } | |
162 | return "[ctor_prefix $type]$arglist)" | |
163 | } | |
164 | ||
165 | add {derived::derived} \ | |
166 | [ctor derived ""] \ | |
167 | - \ | |
168 | - | |
169 | add_type_regexp {base1::base1(void)} \ | |
170 | "[string_to_regexp [ctor_prefix base1]], (const )?void \\*\\*( const)?\\)" \ | |
171 | - \ | |
172 | - | |
173 | add {base1::base1(int)} \ | |
174 | [ctor base1 "int"] \ | |
175 | - \ | |
176 | - | |
177 | add_type_regexp {base2::base2} \ | |
178 | "[string_to_regexp [ctor_prefix base2]], (const )?void \\*\\*( const)?\\)" \ | |
179 | - \ | |
180 | - | |
181 | add {base::base(void)} \ | |
182 | [ctor base ""] \ | |
183 | - \ | |
184 | - | |
185 | add {base::base(int)} \ | |
186 | [ctor base "int"] \ | |
187 | - \ | |
188 | - | |
189 | ||
190 | # Destructors | |
191 | ||
192 | # On targets using the ARM EABI, some destructors are expected | |
193 | # to return "this". Others are void. For internal reasons, | |
194 | # GCC returns void * instead of $type *; RealView appears to do | |
195 | # the same. | |
196 | proc dtor { type } { | |
197 | if { [istarget arm*-*eabi*] || [is_aarch32_target] } { | |
198 | set ret "void *" | |
199 | } else { | |
200 | set ret "void " | |
201 | } | |
202 | return "${ret}($type * const)" | |
203 | } | |
204 | ||
205 | add {base::~base} \ | |
206 | [dtor base] \ | |
207 | - \ | |
208 | - | |
209 | ||
210 | # Overloaded methods (all are const) | |
211 | add {base::overload(void) const} \ | |
212 | {int (const base * const)} \ | |
213 | - \ | |
214 | {base::overload(void) const} | |
215 | add {base::overload(int) const} \ | |
216 | {int (const base * const, int)} \ | |
217 | - \ | |
218 | - | |
219 | add {base::overload(short) const} \ | |
220 | {int (const base * const, short)} \ | |
221 | - \ | |
222 | - | |
223 | add {base::overload(long) const} \ | |
224 | {int (const base * const, long)} \ | |
225 | - \ | |
226 | - | |
227 | add {base::overload(char*) const} \ | |
228 | {int (const base * const, char *)} \ | |
229 | - \ | |
230 | - | |
231 | add {base::overload(base&) const} \ | |
232 | {int (const base * const, base &)} \ | |
233 | - \ | |
234 | - | |
235 | ||
236 | # Operators | |
237 | add {base::operator+} \ | |
238 | {int (const base * const, const base &)} \ | |
239 | - \ | |
240 | - | |
241 | add {base::operator++} \ | |
242 | {base (base * const)} \ | |
243 | - \ | |
244 | - | |
245 | add {base::operator+=} \ | |
246 | {base (base * const, const base &)} \ | |
247 | - \ | |
248 | - | |
249 | add {base::operator-} \ | |
250 | {int (const base * const, const base &)} \ | |
251 | - \ | |
252 | - | |
253 | add {base::operator--} \ | |
254 | {base (base * const)} \ | |
255 | - \ | |
256 | - | |
257 | add {base::operator-=} \ | |
258 | {base (base * const, const base &)} \ | |
259 | - \ | |
260 | - | |
261 | add {base::operator*} \ | |
262 | {int (const base * const, const base &)} \ | |
263 | - \ | |
264 | - | |
265 | add {base::operator*=} \ | |
266 | {base (base * const, const base &)} \ | |
267 | - \ | |
268 | - | |
269 | add {base::operator/} \ | |
270 | {int (const base * const, const base &)} \ | |
271 | - \ | |
272 | - | |
273 | add {base::operator/=} \ | |
274 | {base (base * const, const base &)} \ | |
275 | - \ | |
276 | - | |
277 | add {base::operator%} \ | |
278 | {int (const base * const, const base &)} \ | |
279 | - \ | |
280 | - | |
281 | add {base::operator%=} \ | |
282 | {base (base * const, const base &)} \ | |
283 | - \ | |
284 | - | |
285 | add {base::operator<} \ | |
286 | {bool (const base * const, const base &)} \ | |
287 | - \ | |
288 | - | |
289 | add {base::operator<=} \ | |
290 | {bool (const base * const, const base &)} \ | |
291 | - \ | |
292 | - | |
293 | add {base::operator>} \ | |
294 | {bool (const base * const, const base &)} \ | |
295 | - \ | |
296 | - | |
297 | add {base::operator>=} \ | |
298 | {bool (const base * const, const base &)} \ | |
299 | - \ | |
300 | - | |
301 | add {base::operator!=} \ | |
302 | {bool (const base * const, const base &)} \ | |
303 | - \ | |
304 | - | |
305 | add {base::operator==} \ | |
306 | {bool (const base * const, const base &)} \ | |
307 | - \ | |
308 | - | |
309 | add {base::operator!} \ | |
310 | {bool (const base * const)} \ | |
311 | - \ | |
312 | - | |
313 | add {base::operator&&} \ | |
314 | {bool (const base * const, const base &)} \ | |
315 | - \ | |
316 | - | |
317 | add {base::operator||} \ | |
318 | {bool (const base * const, const base &)} \ | |
319 | - \ | |
320 | - | |
321 | add {base::operator<<} \ | |
322 | {int (const base * const, int)} \ | |
323 | - \ | |
324 | - | |
325 | add {base::operator<<=} \ | |
326 | {base (base * const, int)} \ | |
327 | - \ | |
328 | - | |
329 | add {base::operator>>} \ | |
330 | {int (const base * const, int)} \ | |
331 | - \ | |
332 | - | |
333 | add {base::operator>>=} \ | |
334 | {base (base * const, int)} \ | |
335 | - \ | |
336 | - | |
337 | add {base::operator~} \ | |
338 | {int (const base * const)} \ | |
339 | - \ | |
340 | - | |
341 | add {base::operator&} \ | |
342 | {int (const base * const, const base &)} \ | |
343 | - \ | |
344 | - | |
345 | add {base::operator&=} \ | |
346 | {base (base * const, const base &)} \ | |
347 | - \ | |
348 | - | |
349 | add {base::operator|} \ | |
350 | {int (const base * const, const base &)} \ | |
351 | - \ | |
352 | - | |
353 | add {base::operator|=} \ | |
354 | {base (base * const, const base &)} \ | |
355 | - \ | |
356 | - | |
357 | add {base::operator^} \ | |
358 | {int (const base * const, const base &)} \ | |
359 | - \ | |
360 | - | |
361 | add {base::operator^=} \ | |
362 | {base (base * const, const base &)} \ | |
363 | - \ | |
364 | - | |
365 | add {base::operator=} \ | |
366 | {base (base * const, const base &)} \ | |
367 | - \ | |
368 | - | |
369 | add {base::operator()} \ | |
370 | {void (const base * const)} \ | |
371 | - \ | |
372 | - | |
373 | add {base::operator[]} \ | |
374 | {int (const base * const, int)} \ | |
375 | - \ | |
376 | - | |
377 | add {base::operator new} \ | |
378 | {void *(size_t)} \ | |
379 | - \ | |
380 | - | |
381 | add {base::operator delete} \ | |
382 | {void (void *)} \ | |
383 | - \ | |
384 | - | |
385 | add {base::operator new[]} \ | |
386 | {void *(size_t)} \ | |
387 | - \ | |
388 | - | |
389 | add {base::operator delete[]} \ | |
390 | {void (void *)} \ | |
391 | - \ | |
392 | - | |
393 | add {base::operator char*} \ | |
394 | {char *(const base * const)} \ | |
395 | - \ | |
396 | - | |
397 | add {base::operator fluff*} \ | |
398 | {fluff *(const base * const)} \ | |
399 | - \ | |
400 | - | |
401 | add {base::operator fluff**} \ | |
402 | {fluff **(const base * const)} \ | |
403 | - \ | |
404 | - | |
405 | add {base::operator int} \ | |
406 | {int (const base * const)} \ | |
407 | - \ | |
408 | - | |
409 | add {base::operator fluff const* const*} \ | |
410 | {const fluff * const *(const base * const)} \ | |
411 | - \ | |
412 | - | |
413 | ||
414 | # Templates | |
415 | add {tclass<char>::do_something} \ | |
416 | {void (tclass<char> * const)} \ | |
417 | - \ | |
418 | - | |
419 | add {tclass<int>::do_something} \ | |
420 | {void (tclass<int> * const)} \ | |
421 | - \ | |
422 | - | |
423 | add {tclass<long>::do_something} \ | |
424 | {void (tclass<long> * const)} \ | |
425 | - \ | |
426 | - | |
427 | add {tclass<short>::do_something} \ | |
428 | {void (tclass<short> * const)} \ | |
429 | - \ | |
430 | - | |
431 | add {tclass<base>::do_something} \ | |
432 | {void (tclass<base> * const)} \ | |
433 | - \ | |
434 | - | |
435 | add {flubber<int, int, int, int, int>} \ | |
436 | {void (void)} \ | |
437 | - \ | |
438 | flubber | |
439 | add {flubber<int, int, int, int, short>} \ | |
440 | {void (void)} \ | |
441 | - \ | |
442 | flubber | |
443 | add {flubber<int, int, int, int, long>} \ | |
444 | {void (void)} \ | |
445 | - \ | |
446 | flubber | |
447 | add {flubber<int, int, int, int, char>} \ | |
448 | {void (void)} \ | |
449 | - \ | |
450 | flubber | |
451 | add {flubber<int, int, int, short, int>} \ | |
452 | {void (void)} \ | |
453 | - \ | |
454 | flubber | |
455 | add {flubber<int, int, int, short, short>} \ | |
456 | {void (void)} \ | |
457 | - \ | |
458 | flubber | |
459 | add {flubber<int, int, int, short, long>} \ | |
460 | {void (void)} \ | |
461 | - \ | |
462 | flubber | |
463 | add {flubber<int, int, int, short, char>} \ | |
464 | {void (void)} \ | |
465 | - \ | |
466 | flubber | |
467 | add {flubber<int, int, int, long, int>} \ | |
468 | {void (void)} \ | |
469 | - \ | |
470 | flubber | |
471 | add {flubber<int, int, int, long, short>} \ | |
472 | {void (void)} \ | |
473 | - \ | |
474 | flubber | |
475 | add {flubber<int, int, int, long, long>} \ | |
476 | {void (void)} \ | |
477 | - \ | |
478 | flubber | |
479 | add {flubber<int, int, int, long, char>} \ | |
480 | {void (void)} \ | |
481 | - \ | |
482 | flubber | |
483 | add {flubber<int, int, int, char, int>} \ | |
484 | {void (void)} \ | |
485 | - \ | |
486 | flubber | |
487 | add {flubber<int, int, int, char, short>} \ | |
488 | {void (void)} \ | |
489 | - \ | |
490 | flubber | |
491 | add {flubber<int, int, int, char, long>} \ | |
492 | {void (void)} \ | |
493 | - \ | |
494 | flubber | |
495 | add {flubber<int, int, int, char, char>} \ | |
496 | {void (void)} \ | |
497 | - \ | |
498 | flubber | |
499 | add {flubber<int, int, short, int, int>} \ | |
500 | {void (void)} \ | |
501 | - \ | |
502 | flubber | |
503 | add {flubber<int, int, short, int, short>} \ | |
504 | {void (void)} \ | |
505 | - \ | |
506 | flubber | |
507 | add {flubber<int, int, short, int, long>} \ | |
508 | {void (void)} \ | |
509 | - \ | |
510 | flubber | |
511 | add {flubber<int, int, short, int, char>} \ | |
512 | {void (void)} \ | |
513 | - \ | |
514 | flubber | |
515 | add {flubber<int, int, short, short, int>} \ | |
516 | {void (void)} \ | |
517 | - \ | |
518 | flubber | |
519 | add {flubber<short, int, short, int, short>} \ | |
520 | {void (void)} \ | |
521 | - \ | |
522 | flubber | |
523 | add {flubber<long, short, long, short, long>} \ | |
524 | {void (void)} \ | |
525 | - \ | |
526 | flubber | |
527 | add {tclass<base>::do_something} \ | |
528 | {void (tclass<base> * const)} \ | |
529 | - \ | |
530 | {tclass<T>::do_something} | |
531 | add {policy1::policy} \ | |
532 | [ctor "policy<int, operation_1<void*> >" "int"] \ | |
533 | {policy<int, operation_1<void*> >::policy} \ | |
534 | {policy<T, Policy>::policy} | |
535 | add {policy2::policy} \ | |
536 | [ctor "policy<int, operation_2<void*> >" int] \ | |
537 | {policy<int, operation_2<void*> >::policy} \ | |
538 | {policy<T, Policy>::policy} | |
539 | add {policy3::policy} \ | |
540 | [ctor "policy<int, operation_3<void*> >" "int"] \ | |
541 | {policy<int, operation_3<void*> >::policy} \ | |
542 | {policy<T, Policy>::policy} | |
543 | add {policy4::policy} \ | |
544 | [ctor "policy<int, operation_4<void*> >" "int"] \ | |
545 | {policy<int, operation_4<void*> >::policy} \ | |
546 | {policy<T, Policy>::policy} | |
547 | add {policy1::function} \ | |
548 | {void (void)} \ | |
549 | {operation_1<void*>::function} \ | |
550 | {operation_1<T>::function} | |
551 | add {policy2::function} \ | |
552 | {void (void)} \ | |
553 | {operation_2<void*>::function} \ | |
554 | {operation_2<T>::function} | |
555 | add {policy3::function} \ | |
556 | {void (void)} \ | |
557 | {operation_3<void*>::function} \ | |
558 | {operation_3<T>::function} | |
559 | add {policy4::function} \ | |
560 | {void (void)} \ | |
561 | {operation_4<void*>::function} \ | |
562 | {operation_4<T>::function} | |
563 | add {policyd<int, operation_1<int> >::policyd} \ | |
564 | [ctor "policyd<int, operation_1<int> >" "int"] \ | |
565 | - \ | |
566 | {policyd<T, Policy>::policyd} | |
567 | add {policyd1::policyd} \ | |
568 | [ctor "policyd<int, operation_1<int> >" "int"] \ | |
569 | {policyd<int, operation_1<int> >::policyd} \ | |
570 | {policyd<T, Policy>::policyd} | |
571 | add {policyd<int, operation_1<int> >::~policyd} \ | |
572 | [dtor "policyd<int, operation_1<int> >"] \ | |
573 | - \ | |
574 | {policyd<T, Policy>::~policyd} | |
575 | add {policyd1::~policyd} \ | |
576 | [dtor "policyd<int, operation_1<int> >"] \ | |
577 | {policyd<int, operation_1<int> >::~policyd} \ | |
578 | {policyd<T, Policy>::~policyd} | |
579 | add {policyd<long, operation_1<long> >::policyd} \ | |
580 | [ctor "policyd<long, operation_1<long> >" "long"] \ | |
581 | - \ | |
582 | {policyd<T, Policy>::policyd} | |
583 | add {policyd2::policyd} \ | |
584 | [ctor "policyd<long, operation_1<long> >" "long"] \ | |
585 | {policyd<long, operation_1<long> >::policyd} \ | |
586 | {policyd<T, Policy>::policyd} | |
587 | add {policyd<long, operation_1<long> >::~policyd} \ | |
588 | [dtor "policyd<long, operation_1<long> >"] \ | |
589 | - \ | |
590 | {policyd<T, Policy>::~policyd} | |
591 | add {policyd2::~policyd} \ | |
592 | [dtor "policyd<long, operation_1<long> >"] \ | |
593 | {policyd<long, operation_1<long> >::~policyd} \ | |
594 | {policyd<T, Policy>::~policyd} | |
595 | add {policyd<char, operation_1<char> >::policyd} \ | |
596 | [ctor "policyd<char, operation_1<char> >" "char"] \ | |
597 | - \ | |
598 | {policyd<T, Policy>::policyd} | |
599 | add {policyd3::policyd} \ | |
600 | [ctor "policyd<char, operation_1<char> >" "char"] \ | |
601 | {policyd<char, operation_1<char> >::policyd} \ | |
602 | {policyd<T, Policy>::policyd} | |
603 | add {policyd<char, operation_1<char> >::~policyd} \ | |
604 | [dtor "policyd<char, operation_1<char> >"] \ | |
605 | - \ | |
606 | {policyd<T, Policy>::~policyd} | |
607 | add {policyd3::~policyd} \ | |
608 | [dtor "policyd<char, operation_1<char> >"] \ | |
609 | {policyd<char, operation_1<char> >::~policyd} \ | |
610 | {policyd<T, Policy>::~policyd} | |
611 | add {policyd<base, operation_1<base> >::policyd} \ | |
612 | [ctor "policyd<base, operation_1<base> >" "base"] \ | |
613 | - \ | |
614 | {policyd<T, Policy>::policyd} | |
615 | add {policyd4::policyd} \ | |
616 | [ctor "policyd<base, operation_1<base> >" "base"] \ | |
617 | {policyd<base, operation_1<base> >::policyd} \ | |
618 | {policyd<T, Policy>::policyd} | |
619 | add {policyd<base, operation_1<base> >::~policyd} \ | |
620 | [dtor "policyd<base, operation_1<base> >"] \ | |
621 | - \ | |
622 | {policyd<T, Policy>::~policyd} | |
623 | add {policyd4::~policyd} \ | |
624 | [dtor "policyd<base, operation_1<base> >"] \ | |
625 | {policyd<base, operation_1<base> >::~policyd} \ | |
626 | {policyd<T, Policy>::~policyd} | |
627 | add {policyd<tclass<int>, operation_1<tclass<int> > >::policyd} \ | |
628 | [ctor "policyd<tclass<int>, operation_1<tclass<int> > >" "tclass<int>"] \ | |
629 | - \ | |
630 | {policyd<T, Policy>::policyd} | |
631 | add {policyd5::policyd} \ | |
632 | [ctor "policyd<tclass<int>, operation_1<tclass<int> > >" "tclass<int>"] \ | |
633 | {policyd<tclass<int>, operation_1<tclass<int> > >::policyd} \ | |
634 | {policyd<T, Policy>::policyd} | |
635 | add {policyd<tclass<int>, operation_1<tclass<int> > >::~policyd} \ | |
636 | [dtor "policyd<tclass<int>, operation_1<tclass<int> > >"] \ | |
637 | - \ | |
638 | {policyd<T, Policy>::~policyd} | |
639 | add {policyd5::~policyd} \ | |
640 | [dtor "policyd<tclass<int>, operation_1<tclass<int> > >"] \ | |
641 | {policyd<tclass<int>, operation_1<tclass<int> > >::~policyd} \ | |
642 | {policyd<T, Policy>::~policyd} | |
643 | add {policyd<int, operation_1<int> >::function} \ | |
644 | {void (void)} \ | |
645 | {operation_1<int>::function}\ | |
646 | {operation_1<T>::function} | |
647 | add {policyd1::function} \ | |
648 | {void (void)} \ | |
649 | {operation_1<int>::function} \ | |
650 | {operation_1<T>::function} | |
651 | add {policyd2::function} \ | |
652 | {void (void)} \ | |
653 | {operation_1<long>::function} \ | |
654 | {operation_1<T>::function} | |
655 | add {policyd<char, operation_1<char> >::function} \ | |
656 | {void (void)} \ | |
657 | {operation_1<char>::function} \ | |
658 | {operation_1<T>::function} | |
659 | add {policyd3::function} \ | |
660 | {void (void)} \ | |
661 | {operation_1<char>::function} \ | |
662 | {operation_1<T>::function} | |
663 | add {policyd<base, operation_1<base> >::function} \ | |
664 | {void (void)} \ | |
665 | {operation_1<base>::function} \ | |
666 | {operation_1<T>::function} | |
667 | add {policyd4::function} \ | |
668 | {void (void)} \ | |
669 | {operation_1<base>::function} \ | |
670 | {operation_1<T>::function} | |
671 | add {policyd<tclass<int>, operation_1<tclass<int> > >::function} \ | |
672 | {void (void)} \ | |
673 | {operation_1<tclass<int> >::function} \ | |
674 | {operation_1<T>::function} | |
675 | add {policyd5::function} \ | |
676 | {void (void)} \ | |
677 | {operation_1<tclass<int> >::function} \ | |
678 | {operation_1<T>::function} | |
679 | ||
680 | # Start the test | |
0b94d2b9 | 681 | if {![allow_cplus_tests]} { continue } |
113ee09a TV |
682 | |
683 | # | |
684 | # test running programs | |
685 | # | |
686 | ||
687 | standard_testfile cpexprs.cc | |
688 | ||
113ee09a TV |
689 | # Include required flags. |
690 | set flags "$flags debug c++" | |
691 | ||
692 | if {[prepare_for_testing "failed to prepare" $testfile $srcfile "$flags"]} { | |
693 | return -1 | |
694 | } | |
695 | ||
696 | if {![runto_main]} { | |
697 | perror "couldn't run to breakpoint" | |
698 | continue | |
699 | } | |
700 | ||
701 | # Set the listsize to one. This will help with testing "list". | |
702 | gdb_test "set listsize 1" | |
703 | ||
704 | # "print METHOD" | |
705 | foreach name [get_functions print] { | |
706 | gdb_test "print $name" [get $name print] | |
707 | } | |
708 | ||
709 | # "list METHOD" | |
710 | foreach name [get_functions list] { | |
711 | gdb_test "list $name" [get $name list] | |
712 | } | |
713 | ||
714 | # Running to breakpoint -- use any function we can "list" | |
715 | foreach name [get_functions list] { | |
716 | # Skip "test_function", since test_breakpoint uses it | |
717 | if {[string compare $name "test_function"] != 0} { | |
718 | test_breakpoint $name | |
719 | } | |
720 | } | |
721 | ||
722 | # Test c/v gets recognized even without quoting. | |
723 | foreach cv {{} { const} { volatile} { const volatile}} { | |
724 | set test "p 'CV::m(int)$cv'" | |
4707199b SM |
725 | set correct dummy_value |
726 | ||
113ee09a TV |
727 | gdb_test_multiple $test $test { |
728 | -re "( = {.*} 0x\[0-9a-f\]+ <CV::m.*>)\r\n$gdb_prompt $" { | |
729 | # = {void (CV * const, CV::t)} 0x400944 <CV::m(int)> | |
730 | set correct $expect_out(1,string) | |
731 | pass $test | |
732 | } | |
733 | } | |
734 | gdb_test "p CV::m(int)$cv" [string_to_regexp $correct] | |
735 | } | |
736 | ||
737 | # Test TYPENAME:: gets recognized even in parentheses. | |
738 | gdb_test "p CV_f(int)" { = {int \(int\)} 0x[0-9a-f]+ <CV_f\(int\)>} | |
739 | gdb_test "p CV_f(CV::t)" { = {int \(int\)} 0x[0-9a-f]+ <CV_f\(int\)>} | |
740 | gdb_test "p CV_f(CV::i)" " = 43" | |
741 | ||
742 | gdb_test "p CV_f('cpexprs.cc'::CV::t)" \ | |
743 | { = {int \(int\)} 0x[0-9a-f]+ <CV_f\(int\)>} | |
744 | ||
745 | # Make sure conversion operator names are canonicalized and properly | |
746 | # "spelled." | |
747 | gdb_test "p base::operator const fluff * const *" \ | |
748 | [get "base::operator fluff const* const*" print] \ | |
749 | "canonicalized conversion operator name 1" | |
750 | gdb_test "p base::operator const fluff* const*" \ | |
751 | [get "base::operator fluff const* const*" print] \ | |
752 | "canonicalized conversion operator name 2" | |
753 | gdb_test "p base::operator derived*" \ | |
754 | "There is no field named operator derived\\*" \ | |
755 | "undefined conversion operator" | |
756 | ||
757 | gdb_exit | |
758 | return 0 |