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 
287 /* An unneeded printf() definition - actually, just a stub - used to occupy
288    this space.  It has been removed and replaced with this comment which
289    exists to occupy some lines so that templates.exp won't need adjustment.  */
290 
291 class T1 {
292 public:
293     static void* operator new(size_t) throw ();
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*
368 T1::operator new(size_t) throw ()
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();
459     static void* operator new(size_t) throw ();
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*
482 T5<T>::operator new(size_t) throw ()
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));
519     int (*device[5])(int open(const char *, unsigned mode, unsigned perms, int extra),
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__ == 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={0,0};
718   Foo<char> fchar={0,0};
719   Foo<volatile char *> fvpchar = {0, 0};
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 
786