1#include <stddef.h>
2
3class foo {
4public:
5  foo  (int);
6  foo  (int, const char *);
7  foo  (foo&);
8  ~foo ();
9  void foofunc (int);
10  void foofunc (int, signed char *);
11  int ifoo;
12  const char *ccpfoo;
13
14int overload1arg (void);
15int overload1arg (char);
16int overload1arg (signed char);
17int overload1arg (unsigned char);
18int overload1arg (short);
19int overload1arg (unsigned short);
20int overload1arg (int);
21int overload1arg (unsigned int);
22int overload1arg (long);
23int overload1arg (unsigned long);
24int overload1arg (float);
25int overload1arg (double);
26
27int overloadfnarg (void);
28int overloadfnarg (int);
29int overloadfnarg (int, int (*) (int));
30
31int overloadargs (int a1);
32int overloadargs (int a1, int a2);
33int overloadargs (int a1, int a2, int a3);
34int overloadargs (int a1, int a2, int a3, int a4);
35int overloadargs (int a1, int a2, int a3, int a4, int a5);
36int overloadargs (int a1, int a2, int a3, int a4, int a5, int a6);
37int overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7);
38int overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8);
39int overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9);
40int overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7,
41                   int a8, int a9, int a10);
42int overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7,
43                   int a8, int a9, int a10, int a11);
44
45
46};
47
48int intToChar (char c)
49{
50  return 297;
51}
52
53void marker1()
54{}
55
56// Now test how overloading and namespaces interact.
57
58class dummyClass {};
59
60dummyClass dummyInstance;
61
62int overloadNamespace(int i)
63{
64  return 1;
65}
66
67int overloadNamespace(dummyClass d)
68{
69  return 2;
70}
71
72namespace XXX {
73  int overloadNamespace (char c)
74  {
75    return 3;
76  }
77
78  void marker2() {}
79}
80
81int main ()
82{
83    char arg2 = 2;
84    signed char arg3 =3;
85    unsigned char arg4 =4;
86    short arg5 =5;
87    unsigned short arg6 =6;
88    int arg7 =7;
89    unsigned int arg8 =8;
90    long arg9 =9;
91    unsigned long arg10 =10;
92    float arg11 =100.0;
93    double arg12 = 200.0;
94
95    char *str = (char *) "A";
96    foo foo_instance1(111);
97    foo foo_instance2(222, str);
98    foo foo_instance3(foo_instance2);
99
100    #ifdef usestubs
101       set_debug_traps();
102       breakpoint();
103    #endif
104
105    // Verify that intToChar should work:
106    intToChar(1);
107
108    marker1(); // marker1-returns-here
109    XXX::marker2(); // marker1-returns-here
110    return 0;
111}
112
113foo::foo  (int i)                  { ifoo = i; ccpfoo = NULL; }
114foo::foo  (int i, const char *ccp) { ifoo = i; ccpfoo = ccp; }
115foo::foo  (foo& afoo)              { ifoo = afoo.ifoo; ccpfoo = afoo.ccpfoo;}
116foo::~foo ()                       {}
117
118
119/* Some functions to test overloading by varying one argument type. */
120
121int foo::overload1arg (void)                {  return 1; }
122int foo::overload1arg (char arg)            { arg = 0; return 2;}
123int foo::overload1arg (signed char arg)     { arg = 0; return 3;}
124int foo::overload1arg (unsigned char arg)   { arg = 0; return 4;}
125int foo::overload1arg (short arg)           { arg = 0; return 5;}
126int foo::overload1arg (unsigned short arg)  { arg = 0; return 6;}
127int foo::overload1arg (int arg)             { arg = 0; return 7;}
128int foo::overload1arg (unsigned int arg)    { arg = 0; return 8;}
129int foo::overload1arg (long arg)            { arg = 0; return 9;}
130int foo::overload1arg (unsigned long arg)   { arg = 0; return 10;}
131int foo::overload1arg (float arg)           { arg = 0; return 11;}
132int foo::overload1arg (double arg)          { arg = 0; return 12;}
133
134/* Test to see that we can explicitly request overloaded functions
135   with function pointers in the prototype. */
136
137int foo::overloadfnarg (void) { return ifoo * 20; }
138int foo::overloadfnarg (int arg) { arg = 0; return 13;}
139int foo::overloadfnarg (int arg, int (*foo) (int))    { return foo(arg); }
140
141/* Some functions to test overloading by varying argument count. */
142
143int foo::overloadargs (int a1)
144{ a1 = 0;
145return 1;}
146
147int foo::overloadargs (int a1, int a2)
148{ a1 = a2 = 0;
149return 2;}
150
151int foo::overloadargs (int a1, int a2, int a3)
152{ a1 = a2 = a3 = 0;
153return 3;}
154
155int foo::overloadargs (int a1, int a2, int a3, int a4)
156{ a1 = a2 = a3 = a4 = 0;
157return 4;}
158
159int foo::overloadargs (int a1, int a2, int a3, int a4, int a5)
160{ a1 = a2 = a3 = a4 = a5 = 0;
161return 5;}
162
163int foo::overloadargs (int a1, int a2, int a3, int a4, int a5, int a6)
164{ a1 = a2 = a3 = a4 = a5 = a6 = 0;
165return 6;}
166
167int foo::overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7)
168{ a1 = a2 = a3 = a4 = a5 = a6 = a7 = 0;
169return 7;}
170
171int foo::overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7,
172                   int a8)
173{ a1 = a2 = a3 = a4 = a5 = a6 = a7 = a8 = 0;
174return 8;}
175
176int foo::overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7,
177                   int a8, int a9)
178{
179  a1 = a2 = a3 = a4 = a5 = a6 = a7 = a8 = a9 = 0;
180  return 9;
181}
182
183int foo::overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7,
184                   int a8, int a9, int a10)
185                        { a1 = a2 = a3 = a4 = a5 = a6 = a7 = a8 = a9 =
186                          a10 = 0; return 10;}
187
188int foo::overloadargs (int a1, int a2, int a3, int a4, int a5, int a6, int a7,
189                   int a8, int a9, int a10, int a11)
190                        { a1 = a2 = a3 = a4 = a5 = a6 = a7 = a8 = a9 =
191                          a10 = a11 = 0; return 11;}
192
193
194
195