Commit | Line | Data |
---|---|---|
c906108c SS |
1 | /* This test code is from Wendell Baker (wbaker@comet.berkeley.edu) */ |
2 | ||
3 | #include <stddef.h> | |
4 | ||
5 | int a_i; | |
6 | char a_c; | |
7 | double a_d; | |
8 | ||
9 | typedef void *Pix; | |
10 | ||
11 | int | |
12 | f(int i) | |
13 | { return 0; } | |
14 | ||
15 | int | |
16 | f(int i, char c) | |
17 | { return 0; } | |
18 | ||
19 | int | |
20 | f(int i, char c, double d) | |
21 | { return 0; } | |
22 | ||
23 | int | |
24 | f(int i, char c, double d, char *cs) | |
25 | { return 0; } | |
26 | ||
27 | int | |
28 | f(int i, char c, double d, char *cs, void (*fig)(int, char)) | |
29 | { return 0; } | |
30 | ||
31 | int | |
32 | f(int i, char c, double d, char *cs, void (*fig)(char, int)) | |
33 | { return 0; } | |
34 | ||
35 | class R { | |
36 | public: | |
37 | int i; | |
38 | }; | |
39 | class S { | |
40 | public: | |
41 | int i; | |
42 | }; | |
43 | class T { | |
44 | public: | |
45 | int i; | |
46 | }; | |
47 | ||
48 | char g(char, const char, volatile char) | |
49 | { return 'c'; } | |
50 | char g(R, char&, const char&, volatile char&) | |
51 | { return 'c'; } | |
52 | char g(char*, const char*, volatile char*) | |
53 | { return 'c'; } | |
54 | char g(S, char*&, const char*&, volatile char*&) | |
55 | { return 'c'; } | |
56 | ||
57 | signed char g(T,signed char, const signed char, volatile signed char) | |
58 | { return 'c'; } | |
59 | signed char g(T, R, signed char&, const signed char&, volatile signed char&) | |
60 | { return 'c'; } | |
61 | signed char g(T, signed char*, const signed char*, volatile signed char*) | |
62 | { return 'c'; } | |
63 | signed char g(T, S, signed char*&, const signed char*&, volatile signed char*&) | |
64 | { return 'c'; } | |
65 | ||
66 | unsigned char g(unsigned char, const unsigned char, volatile unsigned char) | |
67 | { return 'c'; } | |
68 | unsigned char g(R, unsigned char&, const unsigned char&, volatile unsigned char&) | |
69 | { return 'c'; } | |
70 | unsigned char g(unsigned char*, const unsigned char*, volatile unsigned char*) | |
71 | { return 'c'; } | |
72 | unsigned char g(S, unsigned char*&, const unsigned char*&, volatile unsigned char*&) | |
73 | { return 'c'; } | |
74 | ||
75 | short g(short, const short, volatile short) | |
76 | { return 0; } | |
77 | short g(R, short&, const short&, volatile short&) | |
78 | { return 0; } | |
79 | short g(short*, const short*, volatile short*) | |
80 | { return 0; } | |
81 | short g(S, short*&, const short*&, volatile short*&) | |
82 | { return 0; } | |
83 | ||
84 | signed short g(T, signed short, const signed short, volatile signed short) | |
85 | { return 0; } | |
86 | signed short g(T, R, signed short&, const signed short&, volatile signed short&) | |
87 | { return 0; } | |
88 | signed short g(T, signed short*, const signed short*, volatile signed short*) | |
89 | { return 0; } | |
90 | signed short g(T, S, double, signed short*&, const signed short*&, volatile signed short*&) | |
91 | { return 0; } | |
92 | ||
93 | unsigned short g(unsigned short, const unsigned short, volatile unsigned short) | |
94 | { return 0; } | |
95 | unsigned short g(R, unsigned short&, const unsigned short&, volatile unsigned short&) | |
96 | { return 0; } | |
97 | unsigned short g(unsigned short*, const unsigned short*, volatile unsigned short*) | |
98 | { return 0; } | |
99 | unsigned short g(S, unsigned short*&, const unsigned short*&, volatile unsigned short*&) | |
100 | { return 0; } | |
101 | ||
102 | int g(int, const int, volatile int) | |
103 | { return 0; } | |
104 | int g(R, int&, const int&, volatile int&) | |
105 | { return 0; } | |
106 | int g(int*, const int*, volatile int*) | |
107 | { return 0; } | |
108 | int g(S, int*&, const int*&, volatile int*&) | |
109 | { return 0; } | |
110 | ||
111 | signed int g(T, signed int, const signed int, volatile signed int) | |
112 | { return 0; } | |
113 | signed int g(T, R, signed int&, const signed int&, volatile signed int&) | |
114 | { return 0; } | |
115 | signed int g(T, signed int*, const signed int*, volatile signed int*) | |
116 | { return 0; } | |
117 | signed int g(T, S, signed int*&, const signed int*&, volatile signed int*&) | |
118 | { return 0; } | |
119 | ||
120 | unsigned int g(unsigned int, const unsigned int, volatile unsigned int) | |
121 | { return 0; } | |
122 | unsigned int g(R, unsigned int&, const unsigned int&, volatile unsigned int&) | |
123 | { return 0; } | |
124 | unsigned int g(unsigned int*, const unsigned int*, volatile unsigned int*) | |
125 | { return 0; } | |
126 | unsigned int g(S, unsigned int*&, const unsigned int*&, volatile unsigned int*&) | |
127 | { return 0; } | |
128 | ||
129 | long g(long, const long, volatile long) | |
130 | { return 0; } | |
131 | long g(R, long&, const long&, volatile long&) | |
132 | { return 0; } | |
133 | long g(long*, const long*, volatile long*) | |
134 | { return 0; } | |
135 | long g(S, long*&, const long*&, volatile long*&) | |
136 | { return 0; } | |
137 | ||
138 | signed long g(T, signed long, const signed long, volatile signed long) | |
139 | { return 0; } | |
140 | signed long g(T, R, signed long&, const signed long&, volatile signed long&) | |
141 | { return 0; } | |
142 | signed long g(T, signed long*, const signed long*, volatile signed long*) | |
143 | { return 0; } | |
144 | signed long g(T, S, signed long*&, const signed long*&, volatile signed long*&) | |
145 | { return 0; } | |
146 | ||
147 | unsigned long g(unsigned long, const unsigned long, volatile unsigned long) | |
148 | { return 0; } | |
149 | unsigned long g(S, unsigned long&, const unsigned long&, volatile unsigned long&) | |
150 | { return 0; } | |
151 | unsigned long g(unsigned long*, const unsigned long*, volatile unsigned long*) | |
152 | { return 0; } | |
153 | unsigned long g(S, unsigned long*&, const unsigned long*&, volatile unsigned long*&) | |
154 | { return 0; } | |
155 | ||
156 | #ifdef __GNUC__ | |
157 | long long g(long long, const long long, volatile long long) | |
158 | { return 0; } | |
159 | long long g(S, long long&, const long long&, volatile long long&) | |
160 | { return 0; } | |
161 | long long g(long long*, const long long*, volatile long long*) | |
162 | { return 0; } | |
163 | long long g(R, long long*&, const long long*&, volatile long long*&) | |
164 | { return 0; } | |
165 | ||
166 | signed long long g(T, signed long long, const signed long long, volatile signed long long) | |
167 | { return 0; } | |
168 | signed long long g(T, R, signed long long&, const signed long long&, volatile signed long long&) | |
169 | { return 0; } | |
170 | signed long long g(T, signed long long*, const signed long long*, volatile signed long long*) | |
171 | { return 0; } | |
172 | signed long long g(T, S, signed long long*&, const signed long long*&, volatile signed long long*&) | |
173 | { return 0; } | |
174 | ||
175 | unsigned long long g(unsigned long long, const unsigned long long, volatile unsigned long long) | |
176 | { return 0; } | |
177 | unsigned long long g(R, unsigned long long*, const unsigned long long*, volatile unsigned long long*) | |
178 | { return 0; } | |
179 | unsigned long long g(unsigned long long&, const unsigned long long&, volatile unsigned long long&) | |
180 | { return 0; } | |
181 | unsigned long long g(S, unsigned long long*&, const unsigned long long*&, volatile unsigned long long*&) | |
182 | { return 0; } | |
183 | #endif | |
184 | ||
185 | float g(float, const float, volatile float) | |
186 | { return 0; } | |
187 | float g(char, float&, const float&, volatile float&) | |
188 | { return 0; } | |
189 | float g(float*, const float*, volatile float*) | |
190 | { return 0; } | |
191 | float g(char, float*&, const float*&, volatile float*&) | |
192 | { return 0; } | |
193 | ||
194 | double g(double, const double, volatile double) | |
195 | { return 0; } | |
196 | double g(char, double&, const double&, volatile double&) | |
197 | { return 0; } | |
198 | double g(double*, const double*, volatile double*) | |
199 | { return 0; } | |
200 | double g(char, double*&, const double*&, volatile double*&) | |
201 | { return 0; } | |
202 | ||
203 | #ifdef __GNUC__ | |
204 | long double g(long double, const long double, volatile long double) | |
205 | { return 0; } | |
206 | long double g(char, long double&, const long double&, volatile long double&) | |
207 | { return 0; } | |
208 | long double g(long double*, const long double*, volatile long double*) | |
209 | { return 0; } | |
210 | long double g(char, long double*&, const long double*&, volatile long double*&) | |
211 | { return 0; } | |
212 | #endif | |
213 | ||
214 | class c { | |
215 | public: | |
216 | c(int) {}; | |
217 | int i; | |
218 | }; | |
219 | ||
220 | class c g(c, const c, volatile c) | |
221 | { return 0; } | |
222 | c g(char, c&, const c&, volatile c&) | |
223 | { return 0; } | |
224 | c g(c*, const c*, volatile c*) | |
225 | { return 0; } | |
226 | c g(char, c*&, const c*&, volatile c*&) | |
227 | { return 0; } | |
228 | ||
229 | /* | |
230 | void h(char = 'a') | |
231 | { } | |
232 | void h(char, signed char = 'a') | |
233 | { } | |
234 | void h(unsigned char = 'a') | |
235 | { } | |
236 | */ | |
237 | /* | |
238 | void h(char = (char)'a') | |
239 | { } | |
240 | void h(char, signed char = (signed char)'a') | |
241 | { } | |
242 | void h(unsigned char = (unsigned char)'a') | |
243 | { } | |
244 | ||
245 | ||
246 | void h(short = (short)43) | |
247 | { } | |
248 | void h(char, signed short = (signed short)43) | |
249 | { } | |
250 | void h(unsigned short = (unsigned short)43) | |
251 | { } | |
252 | ||
253 | void h(int = (int)43) | |
254 | { } | |
255 | void h(char, signed int = (signed int)43) | |
256 | { } | |
257 | void h(unsigned int = (unsigned int)43) | |
258 | { } | |
259 | ||
260 | ||
261 | void h(long = (long)43) | |
262 | { } | |
263 | void h(char, signed long = (signed long)43) | |
264 | { } | |
265 | void h(unsigned long = (unsigned long)43) | |
266 | { } | |
267 | ||
268 | #ifdef __GNUC__ | |
269 | void h(long long = 43) | |
270 | { } | |
271 | void h(char, signed long long = 43) | |
272 | { } | |
273 | void h(unsigned long long = 43) | |
274 | { } | |
275 | #endif | |
276 | ||
277 | void h(float = 4.3e-10) | |
278 | { } | |
279 | void h(double = 4.3) | |
280 | { } | |
281 | #ifdef __GNUC__ | |
282 | void h(long double = 4.33e33) | |
283 | { } | |
284 | #endif | |
285 | */ | |
286 | void printf(const char *format, ... ) | |
287 | { | |
288 | // elipsis | |
289 | } | |
290 | ||
291 | class T1 { | |
292 | public: | |
cce74817 | 293 | static void* operator new(size_t) throw (); |
c906108c SS |
294 | static void operator delete(void *pointer); |
295 | ||
296 | void operator=(const T1&); | |
297 | T1& operator=(int); | |
298 | ||
299 | int operator==(int) const; | |
300 | int operator==(const T1&) const; | |
301 | int operator!=(int) const; | |
302 | int operator!=(const T1&) const; | |
303 | ||
304 | int operator<=(int) const; | |
305 | int operator<=(const T1&) const; | |
306 | int operator<(int) const; | |
307 | int operator<(const T1&) const; | |
308 | int operator>=(int) const; | |
309 | int operator>=(const T1&) const; | |
310 | int operator>(int) const; | |
311 | int operator>(const T1&) const; | |
312 | ||
313 | void operator+(int) const; | |
314 | T1& operator+(const T1&) const; | |
315 | void operator+=(int) const; | |
316 | T1& operator+=(const T1&) const; | |
317 | ||
318 | T1& operator++() const; | |
319 | ||
320 | void operator-(int) const; | |
321 | T1& operator-(const T1&) const; | |
322 | void operator-=(int) const; | |
323 | T1& operator-=(const T1&) const; | |
324 | ||
325 | T1& operator--() const; | |
326 | ||
327 | void operator*(int) const; | |
328 | T1& operator*(const T1&) const; | |
329 | void operator*=(int) const; | |
330 | T1& operator*=(const T1&) const; | |
331 | ||
332 | void operator/(int) const; | |
333 | T1& operator/(const T1&) const; | |
334 | void operator/=(int) const; | |
335 | T1& operator/=(const T1&) const; | |
336 | ||
337 | void operator%(int) const; | |
338 | T1& operator%(const T1&) const; | |
339 | void operator%=(int) const; | |
340 | T1& operator%=(const T1&) const; | |
341 | ||
342 | void operator&&(int) const; | |
343 | T1& operator&&(const T1&) const; | |
344 | ||
345 | void operator||(int) const; | |
346 | T1& operator||(const T1&) const; | |
347 | ||
348 | void operator&(int) const; | |
349 | T1& operator&(const T1&) const; | |
350 | void operator&=(int) const; | |
351 | T1& operator&=(const T1&) const; | |
352 | ||
353 | void operator|(int) const; | |
354 | T1& operator|(const T1&) const; | |
355 | void operator|=(int) const; | |
356 | T1& operator|=(const T1&) const; | |
357 | ||
358 | void operator^(int) const; | |
359 | T1& operator^(const T1&) const; | |
360 | void operator^=(int) const; | |
361 | T1& operator^=(const T1&) const; | |
362 | ||
363 | T1& operator!() const; | |
364 | T1& operator~() const; | |
365 | }; | |
366 | ||
367 | void* | |
cce74817 | 368 | T1::operator new(size_t) throw () |
c906108c SS |
369 | { return 0; } |
370 | ||
371 | void | |
372 | T1::operator delete(void *pointer) | |
373 | { } | |
374 | ||
375 | class T2 { | |
376 | public: | |
377 | T2(int i): integer(i) | |
378 | { } | |
379 | int integer; | |
380 | }; | |
381 | ||
382 | int operator==(const T2&, const T2&) | |
383 | { return 0; } | |
384 | int operator==(const T2&, char) | |
385 | { return 0; } | |
386 | int operator!=(const T2&, const T2&) | |
387 | { return 0; } | |
388 | int operator!=(const T2&, char) | |
389 | { return 0; } | |
390 | ||
391 | int operator<=(const T2&, const T2&) | |
392 | { return 0; } | |
393 | int operator<=(const T2&, char) | |
394 | { return 0; } | |
395 | int operator<(const T2&, const T2&) | |
396 | { return 0; } | |
397 | int operator<(const T2&, char) | |
398 | { return 0; } | |
399 | int operator>=(const T2&, const T2&) | |
400 | { return 0; } | |
401 | int operator>=(const T2&, char) | |
402 | { return 0; } | |
403 | int operator>(const T2&, const T2&) | |
404 | { return 0; } | |
405 | int operator>(const T2&, char) | |
406 | { return 0; } | |
407 | ||
408 | T2 operator+(const T2 t, int i) | |
409 | { return t.integer + i; } | |
410 | T2 operator+(const T2 a, const T2& b) | |
411 | { return a.integer + b.integer; } | |
412 | T2& operator+=(T2& t, int i) | |
413 | { t.integer += i; return t; } | |
414 | T2& operator+=(T2& a, const T2& b) | |
415 | { a.integer += b.integer; return a; } | |
416 | ||
417 | T2 operator-(const T2 t, int i) | |
418 | { return t.integer - i; } | |
419 | T2 operator-(const T2 a, const T2& b) | |
420 | { return a.integer - b.integer; } | |
421 | T2& operator-=(T2& t, int i) | |
422 | { t.integer -= i; return t; } | |
423 | T2& operator-=(T2& a, const T2& b) | |
424 | { a.integer -= b.integer; return a; } | |
425 | ||
426 | T2 operator*(const T2 t, int i) | |
427 | { return t.integer * i; } | |
428 | T2 operator*(const T2 a, const T2& b) | |
429 | { return a.integer * b.integer; } | |
430 | T2& operator*=(T2& t, int i) | |
431 | { t.integer *= i; return t; } | |
432 | T2& operator*=(T2& a, const T2& b) | |
433 | { a.integer *= b.integer; return a; } | |
434 | ||
435 | T2 operator/(const T2 t, int i) | |
436 | { return t.integer / i; } | |
437 | T2 operator/(const T2 a, const T2& b) | |
438 | { return a.integer / b.integer; } | |
439 | T2& operator/=(T2& t, int i) | |
440 | { t.integer /= i; return t; } | |
441 | T2& operator/=(T2& a, const T2& b) | |
442 | { a.integer /= b.integer; return a; } | |
443 | ||
444 | T2 operator%(const T2 t, int i) | |
445 | { return t.integer % i; } | |
446 | T2 operator%(const T2 a, const T2& b) | |
447 | { return a.integer % b.integer; } | |
448 | T2& operator%=(T2& t, int i) | |
449 | { t.integer %= i; return t; } | |
450 | T2& operator%=(T2& a, const T2& b) | |
451 | { a.integer %= b.integer; return a; } | |
452 | ||
453 | template<class T> | |
454 | class T5 { | |
455 | public: | |
456 | T5(int); | |
457 | T5(const T5<T>&); | |
458 | ~T5(); | |
cce74817 | 459 | static void* operator new(size_t) throw (); |
c906108c SS |
460 | static void operator delete(void *pointer); |
461 | int value(); | |
462 | ||
463 | static T X; | |
464 | T x; | |
465 | int val; | |
466 | }; | |
467 | ||
468 | template<class T> | |
469 | T5<T>::T5(int v) | |
470 | { val = v; } | |
471 | ||
472 | template<class T> | |
473 | T5<T>::T5(const T5<T>&) | |
474 | {} | |
475 | ||
476 | template<class T> | |
477 | T5<T>::~T5() | |
478 | {} | |
479 | ||
480 | template<class T> | |
481 | void* | |
cce74817 | 482 | T5<T>::operator new(size_t) throw () |
c906108c SS |
483 | { return 0; } |
484 | ||
485 | template<class T> | |
486 | void | |
487 | T5<T>::operator delete(void *pointer) | |
488 | { } | |
489 | ||
490 | template<class T> | |
491 | int | |
492 | T5<T>::value() | |
493 | { return val; } | |
494 | ||
495 | ||
496 | #if ! defined(__GNUC__) || defined(GCC_BUG) | |
497 | template<class T> | |
498 | T T5<T>::X; | |
499 | #endif | |
500 | ||
501 | ||
502 | ||
503 | ||
504 | T5<char> t5c(1); | |
505 | T5<int> t5i(2); | |
506 | T5<int (*)(char, void *)> t5fi1(3); | |
507 | T5<int (*)(int, double **, void *)> t5fi2(4); | |
508 | ||
509 | ||
510 | ||
511 | ||
512 | ||
513 | ||
514 | class x { | |
515 | public: | |
516 | int (*manage[5])(double, | |
517 | void *(*malloc)(unsigned size), | |
518 | void (*free)(void *pointer)); | |
a0b3c4fd | 519 | int (*device[5])(int open(const char *, unsigned mode, unsigned perms, int extra), |
c906108c SS |
520 | int *(*read)(int fd, void *place, unsigned size), |
521 | int *(*write)(int fd, void *place, unsigned size), | |
522 | void (*close)(int fd)); | |
523 | }; | |
524 | T5<x> t5x(5); | |
525 | ||
526 | #if !defined(__GNUC__) || (__GNUC__ >= 2 && __GNUC_MINOR__ >= 6) | |
527 | template class T5<char>; | |
528 | template class T5<int>; | |
529 | template class T5<int (*)(char, void *)>; | |
530 | template class T5<int (*)(int, double **, void *)>; | |
531 | template class T5<x>; | |
532 | #endif | |
533 | ||
534 | class T7 { | |
535 | public: | |
536 | static int get(); | |
537 | static void put(int); | |
538 | }; | |
539 | ||
540 | int | |
541 | T7::get() | |
542 | { return 1; } | |
543 | ||
544 | void | |
545 | T7::put(int i) | |
546 | { | |
547 | // nothing | |
548 | } | |
549 | ||
550 | // More template kinds. GDB 4.16 didn't handle these, but | |
551 | // Wildebeest does. Note: Assuming HP aCC is used to compile | |
552 | // this file; with g++ or HP cfront or other compilers the | |
553 | // demangling may not get done correctly. | |
554 | ||
555 | // Ordinary template, to be instantiated with different types | |
556 | template<class T> | |
557 | class Foo { | |
558 | public: | |
559 | int x; | |
560 | T t; | |
561 | T foo (int, T); | |
562 | }; | |
563 | ||
564 | ||
565 | template<class T> T Foo<T>::foo (int i, T tt) | |
566 | { | |
567 | return tt; | |
568 | } | |
569 | ||
570 | // Template with int parameter | |
571 | ||
572 | template<class T, int sz> | |
573 | class Bar { | |
574 | public: | |
575 | int x; | |
576 | T t; | |
577 | T bar (int, T); | |
578 | }; | |
579 | ||
580 | ||
581 | template<class T, int sz> T Bar<T, sz>::bar (int i, T tt) | |
582 | { | |
583 | if (i < sz) | |
584 | return tt; | |
585 | else | |
586 | return 0; | |
587 | } | |
588 | ||
589 | // function template with int parameter | |
590 | template<class T> int dummy (T tt, int i) | |
591 | { | |
592 | return tt; | |
593 | } | |
594 | ||
595 | // Template with partial specializations | |
596 | template<class T1, class T2> | |
597 | class Spec { | |
598 | public: | |
599 | int x; | |
600 | T1 spec (T2); | |
601 | }; | |
602 | ||
603 | template<class T1, class T2> | |
604 | T1 Spec<T1, T2>::spec (T2 t2) | |
605 | { | |
606 | return 0; | |
607 | } | |
608 | ||
609 | template<class T> | |
610 | class Spec<T, T*> { | |
611 | public: | |
612 | int x; | |
613 | T spec (T*); | |
614 | }; | |
615 | ||
616 | template<class T> | |
617 | T Spec<T, T*>::spec (T * tp) | |
618 | { | |
619 | return *tp; | |
620 | } | |
621 | ||
622 | // Template with char parameter | |
623 | template<class T, char sz> | |
624 | class Baz { | |
625 | public: | |
626 | int x; | |
627 | T t; | |
628 | T baz (int, T); | |
629 | }; | |
630 | ||
631 | template<class T, char sz> T Baz<T, sz>::baz (int i, T tt) | |
632 | { | |
633 | if (i < sz) | |
634 | return tt; | |
635 | else | |
636 | return 0; | |
637 | } | |
638 | ||
639 | // Template with char * parameter | |
640 | template<class T, char * sz> | |
641 | class Qux { | |
642 | public: | |
643 | int x; | |
644 | T t; | |
645 | T qux (int, T); | |
646 | }; | |
647 | ||
648 | template<class T, char * sz> T Qux<T, sz>::qux (int i, T tt) | |
649 | { | |
650 | if (sz[0] == 'q') | |
651 | return tt; | |
652 | else | |
653 | return 0; | |
654 | } | |
655 | ||
656 | // Template with a function pointer parameter | |
657 | template<class T, int (*f)(int) > | |
658 | class Qux1 { | |
659 | public: | |
660 | int x; | |
661 | T t; | |
662 | T qux (int, T); | |
663 | }; | |
664 | ||
665 | template<class T, int (*f)(int)> T Qux1<T, f>::qux (int i, T tt) | |
666 | { | |
667 | if (f != 0) | |
668 | return tt; | |
669 | else | |
670 | return 0; | |
671 | } | |
672 | ||
673 | // Some functions to provide as arguments to template | |
674 | int gf1 (int a) { | |
675 | return a * 2 + 13; | |
676 | } | |
677 | int gf2 (int a) { | |
678 | return a * 2 + 26; | |
679 | } | |
680 | ||
681 | char string[3]; | |
682 | ||
683 | ||
684 | // Template for nested instantiations | |
685 | ||
686 | template<class T> | |
687 | class Garply { | |
688 | public: | |
689 | int x; | |
690 | T t; | |
691 | T garply (int, T); | |
692 | }; | |
693 | ||
694 | template<class T> T Garply<T>::garply (int i, T tt) | |
695 | { | |
696 | if (i > x) | |
697 | return tt; | |
698 | else | |
699 | { | |
700 | x += i; | |
701 | return tt; | |
702 | } | |
703 | } | |
704 | ||
705 | ||
706 | int main() | |
707 | { | |
708 | int i; | |
709 | #ifdef usestubs | |
710 | set_debug_traps(); | |
711 | breakpoint(); | |
712 | #endif | |
713 | i = i + 1; | |
714 | ||
715 | // New tests added here | |
716 | ||
717 | Foo<int> fint; | |
718 | Foo<char> fchar; | |
a0b3c4fd | 719 | Foo<volatile char *> fvpchar = {0, 0}; |
c906108c SS |
720 | |
721 | Bar<int, 33> bint; | |
722 | Bar<int, (4 > 3)> bint2; | |
723 | ||
724 | Baz<int, 's'> bazint; | |
725 | Baz<char, 'a'> bazint2; | |
726 | ||
727 | Qux<char, string> quxint2; | |
728 | Qux<int, string> quxint; | |
729 | ||
730 | Qux1<int, gf1> qux11; | |
731 | ||
732 | int x = fint.foo(33, 47); | |
733 | char c = fchar.foo(33, 'x'); | |
734 | volatile char * cp = fvpchar.foo(33, 0); | |
735 | ||
736 | int y = dummy<int> (400, 600); | |
737 | ||
738 | int z = bint.bar(55, 66); | |
739 | z += bint2.bar(55, 66); | |
740 | ||
741 | c = bazint2.baz(4, 'y'); | |
742 | c = quxint2.qux(4, 'z'); | |
743 | ||
744 | y = bazint.baz(4,3); | |
745 | y = quxint.qux(4, 22); | |
746 | y += qux11.qux(4, 22); | |
747 | ||
748 | y *= gf1(y) - gf2(y); | |
749 | ||
750 | Spec<int, char> sic; | |
751 | Spec<int, int *> siip; | |
752 | ||
753 | sic.spec ('c'); | |
754 | siip.spec (&x); | |
755 | ||
756 | Garply<int> f; | |
757 | Garply<char> fc; | |
758 | f.x = 13; | |
759 | ||
760 | Garply<Garply<char> > nf; | |
761 | nf.x = 31; | |
762 | ||
763 | x = f.garply (3, 4); | |
764 | ||
765 | fc = nf.garply (3, fc); | |
766 | ||
767 | y = x + fc.x; | |
768 | ||
769 | ||
770 | return 0; | |
771 | ||
772 | } | |
773 | ||
774 | ||
775 | ||
776 | ||
777 | ||
778 | ||
779 | ||
780 | ||
781 | ||
782 | ||
783 | ||
784 | ||
785 |