Fixed pointer problems to work on DECstations.
[dyninst.git] / igen / tests / test2.C
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <assert.h>
4 extern "C" {
5 #include "thread/h/thread.h"
6 }
7 #include "test2.h"
8
9 union test__18 {
10     struct test__17 asyncUpcall;
11     struct test__16 triggerAsyncUpcall;
12     struct test__15 syncUpcall;
13     struct test__14 triggerSyncUpcall;
14     struct test__13 stringString;
15     struct test__11 retVector;
16     struct test__10 sumVector;
17     struct test__8 add;
18     struct test__5 intString;
19     struct test__3 nullStruct;
20     struct test__1 intNull;
21     struct test__0 nullNull;
22 };
23
24 int test::mainLoop(void)
25 {
26   unsigned int __len__;
27   unsigned int __tag__;
28   union test__18 __recvBuffer__;
29
30   __tag__ = MSG_TAG_ANY;
31   __len__ = sizeof(__recvBuffer__);
32   requestingThread = msg_recv(&__tag__, &__recvBuffer__, &__len__);
33   switch (__tag__) {
34         case test_triggerAsyncUpcall_REQ: {
35                     int __val__;
36             triggerAsyncUpcall(__recvBuffer__.triggerAsyncUpcall.val);
37         __val__ = msg_send(requestingThread, test_triggerAsyncUpcall_RESP, NULL, 0);
38             assert(__val__ == THR_OKAY);
39             break;
40          }
41
42         case test_triggerSyncUpcall_REQ: {
43                     int __val__;
44             triggerSyncUpcall(__recvBuffer__.triggerSyncUpcall.val);
45         __val__ = msg_send(requestingThread, test_triggerSyncUpcall_RESP, NULL, 0);
46             assert(__val__ == THR_OKAY);
47             break;
48          }
49
50         case test_stringString_REQ: {
51                     int __val__;
52             String __ret__;
53             __ret__ = stringString(__recvBuffer__.stringString.test__12);
54         __val__ = msg_send(requestingThread, test_stringString_RESP, (void *) &__ret__, sizeof(String));
55             assert(__val__ == THR_OKAY);
56             break;
57          }
58
59         case test_retVector_REQ: {
60                     int __val__;
61             int_Array __ret__;
62             __ret__ = retVector(__recvBuffer__.retVector.len,__recvBuffer__.retVector.start);
63         __val__ = msg_send(requestingThread, test_retVector_RESP, (void *) &__ret__, sizeof(int_Array));
64             assert(__val__ == THR_OKAY);
65             break;
66          }
67
68         case test_sumVector_REQ: {
69                     int __val__;
70             int __ret__;
71             __ret__ = sumVector(__recvBuffer__.sumVector.test__9);
72         __val__ = msg_send(requestingThread, test_sumVector_RESP, (void *) &__ret__, sizeof(int));
73             assert(__val__ == THR_OKAY);
74             break;
75          }
76
77         case test_add_REQ: {
78                     int __val__;
79             int __ret__;
80             __ret__ = add(__recvBuffer__.add.test__6,__recvBuffer__.add.test__7);
81         __val__ = msg_send(requestingThread, test_add_RESP, (void *) &__ret__, sizeof(int));
82             assert(__val__ == THR_OKAY);
83             break;
84          }
85
86         case test_intString_REQ: {
87                     int __val__;
88             int __ret__;
89             __ret__ = intString(__recvBuffer__.intString.test__4);
90         __val__ = msg_send(requestingThread, test_intString_RESP, (void *) &__ret__, sizeof(int));
91             assert(__val__ == THR_OKAY);
92             break;
93          }
94
95         case test_nullStruct_REQ: {
96                     int __val__;
97             nullStruct(__recvBuffer__.nullStruct.test__2);
98         __val__ = msg_send(requestingThread, test_nullStruct_RESP, NULL, 0);
99             assert(__val__ == THR_OKAY);
100             break;
101          }
102
103         case test_intNull_REQ: {
104                     int __val__;
105             int __ret__;
106             __ret__ = intNull();
107         __val__ = msg_send(requestingThread, test_intNull_RESP, (void *) &__ret__, sizeof(int));
108             assert(__val__ == THR_OKAY);
109             break;
110          }
111
112         case test_nullNull_REQ: {
113                     int __val__;
114             nullNull();
115         __val__ = msg_send(requestingThread, test_nullNull_RESP, NULL, 0);
116             assert(__val__ == THR_OKAY);
117             break;
118          }
119
120     default:
121             return(__tag__);
122   }
123   return(0);
124 }
125
126 void test::asyncUpcall(int x) {
127     struct test__17 test__20;
128     int __val__;
129     test__20.x = x;  
130     __val__ = msg_send(tid, test_asyncUpcall_REQ, (void *) &test__20, sizeof(test__20));
131     assert(__val__ == THR_OKAY);
132 }
133
134
135 void test::syncUpcall(int x) {
136     struct test__15 test__22;
137     unsigned int __tag__;
138     int __val__;
139     test__22.x = x;  
140     __val__ = msg_send(tid, test_syncUpcall_REQ, (void *) &test__22, sizeof(test__22));
141     assert(__val__ == THR_OKAY);
142     __tag__ = test_syncUpcall_RESP;
143     msg_recv(&__tag__, NULL, 0); 
144     assert(__tag__ == test_syncUpcall_RESP);
145 }
146
147
148 void testUser::triggerAsyncUpcall(int val) {
149     struct test__16 test__24;
150     unsigned int __tag__;
151     int __val__;
152     test__24.val = val;  
153     __val__ = msg_send(tid, test_triggerAsyncUpcall_REQ, (void *) &test__24, sizeof(test__24));
154     assert(__val__ == THR_OKAY);
155     __tag__ = test_triggerAsyncUpcall_RESP;
156     msg_recv(&__tag__, NULL, 0); 
157     assert(__tag__ == test_triggerAsyncUpcall_RESP);
158 }
159
160
161 void testUser::triggerSyncUpcall(int val) {
162     struct test__14 test__26;
163     unsigned int __tag__;
164     int __val__;
165     test__26.val = val;  
166     __val__ = msg_send(tid, test_triggerSyncUpcall_REQ, (void *) &test__26, sizeof(test__26));
167     assert(__val__ == THR_OKAY);
168     __tag__ = test_triggerSyncUpcall_RESP;
169     msg_recv(&__tag__, NULL, 0); 
170     assert(__tag__ == test_triggerSyncUpcall_RESP);
171 }
172
173
174 String testUser::stringString(String test__12) {
175     struct test__13 test__28;
176     unsigned int __tag__;
177     unsigned int __len__;
178     int __val__;
179     String test__27;
180     test__28.test__12 = test__12;  
181     __val__ = msg_send(tid, test_stringString_REQ, (void *) &test__28, sizeof(test__28));
182     assert(__val__ == THR_OKAY);
183     __tag__ = test_stringString_RESP;
184     __len__ = sizeof(test__27);
185     msg_recv(&__tag__, (void *) &test__27, &__len__); 
186     assert(__len__ == sizeof(test__27));
187     return(test__27);
188     assert(__tag__ == test_stringString_RESP);
189 }
190
191
192 int_Array testUser::retVector(int len,int start) {
193     struct test__11 test__30;
194     unsigned int __tag__;
195     unsigned int __len__;
196     int __val__;
197     int_Array test__29;
198     test__30.len = len;  
199     test__30.start = start;  
200     __val__ = msg_send(tid, test_retVector_REQ, (void *) &test__30, sizeof(test__30));
201     assert(__val__ == THR_OKAY);
202     __tag__ = test_retVector_RESP;
203     __len__ = sizeof(test__29);
204     msg_recv(&__tag__, (void *) &test__29, &__len__); 
205     assert(__len__ == sizeof(test__29));
206     return(test__29);
207     assert(__tag__ == test_retVector_RESP);
208 }
209
210
211 int testUser::sumVector(int_Array test__9) {
212     struct test__10 test__32;
213     unsigned int __tag__;
214     unsigned int __len__;
215     int __val__;
216     int test__31;
217     test__32.test__9 = test__9;  
218     __val__ = msg_send(tid, test_sumVector_REQ, (void *) &test__32, sizeof(test__32));
219     assert(__val__ == THR_OKAY);
220     __tag__ = test_sumVector_RESP;
221     __len__ = sizeof(test__31);
222     msg_recv(&__tag__, (void *) &test__31, &__len__); 
223     assert(__len__ == sizeof(test__31));
224     return(test__31);
225     assert(__tag__ == test_sumVector_RESP);
226 }
227
228
229 int testUser::add(int test__6,int test__7) {
230     struct test__8 test__34;
231     unsigned int __tag__;
232     unsigned int __len__;
233     int __val__;
234     int test__33;
235     test__34.test__6 = test__6;  
236     test__34.test__7 = test__7;  
237     __val__ = msg_send(tid, test_add_REQ, (void *) &test__34, sizeof(test__34));
238     assert(__val__ == THR_OKAY);
239     __tag__ = test_add_RESP;
240     __len__ = sizeof(test__33);
241     msg_recv(&__tag__, (void *) &test__33, &__len__); 
242     assert(__len__ == sizeof(test__33));
243     return(test__33);
244     assert(__tag__ == test_add_RESP);
245 }
246
247
248 int testUser::intString(String test__4) {
249     struct test__5 test__36;
250     unsigned int __tag__;
251     unsigned int __len__;
252     int __val__;
253     int test__35;
254     test__36.test__4 = test__4;  
255     __val__ = msg_send(tid, test_intString_REQ, (void *) &test__36, sizeof(test__36));
256     assert(__val__ == THR_OKAY);
257     __tag__ = test_intString_RESP;
258     __len__ = sizeof(test__35);
259     msg_recv(&__tag__, (void *) &test__35, &__len__); 
260     assert(__len__ == sizeof(test__35));
261     return(test__35);
262     assert(__tag__ == test_intString_RESP);
263 }
264
265
266 void testUser::nullStruct(intStruct test__2) {
267     struct test__3 test__38;
268     unsigned int __tag__;
269     int __val__;
270     test__38.test__2 = test__2;  
271     __val__ = msg_send(tid, test_nullStruct_REQ, (void *) &test__38, sizeof(test__38));
272     assert(__val__ == THR_OKAY);
273     __tag__ = test_nullStruct_RESP;
274     msg_recv(&__tag__, NULL, 0); 
275     assert(__tag__ == test_nullStruct_RESP);
276 }
277
278
279 int testUser::intNull(void) {
280     unsigned int __tag__;
281     unsigned int __len__;
282     int __val__;
283     int test__39;
284     __val__ = msg_send(tid, test_intNull_REQ, NULL, 0); 
285     assert(__val__ == THR_OKAY);
286     __tag__ = test_intNull_RESP;
287     __len__ = sizeof(test__39);
288     msg_recv(&__tag__, (void *) &test__39, &__len__); 
289     assert(__len__ == sizeof(test__39));
290     return(test__39);
291     assert(__tag__ == test_intNull_RESP);
292 }
293
294
295 void testUser::nullNull(void) {
296     unsigned int __tag__;
297     int __val__;
298     __val__ = msg_send(tid, test_nullNull_REQ, NULL, 0); 
299     assert(__val__ == THR_OKAY);
300     __tag__ = test_nullNull_RESP;
301     msg_recv(&__tag__, NULL, 0); 
302     assert(__tag__ == test_nullNull_RESP);
303 }
304
305 void testUser::awaitResponce(int __targetTag__) {
306     unsigned int __tag__;
307   union test__18 __recvBuffer__;
308   unsigned __len__ = sizeof(__recvBuffer__);
309   while (1) {
310   __tag__ = MSG_TAG_ANY;
311     requestingThread = msg_recv(&__tag__, (void *) &__recvBuffer__, &__len__); 
312     if (__tag__ == __targetTag__) return;
313     switch (__tag__) {
314         case test_asyncUpcall_REQ: {
315                         asyncUpcall(__recvBuffer__.asyncUpcall.x);
316             break;
317          }
318
319         case test_syncUpcall_REQ: {
320                     int __val__;
321             syncUpcall(__recvBuffer__.syncUpcall.x);
322         __val__ = msg_send(requestingThread, test_syncUpcall_RESP, NULL, 0);
323             assert(__val__ == THR_OKAY);
324             break;
325          }
326
327             default: 
328         abort();
329     }
330         if (__targetTag__ == -1) return;
331   }
332 }
333 int testUser::isValidUpCall(int tag) {
334     return((tag >= 2000) && (tag <= 2024));
335 }