Modified process status handling to provide appropriate tag
[dyninst.git] / igen / tests / test1.SRVR.C
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <assert.h>
4 #include "test1.h"
5
6 void testUser::verifyProtocolAndVersion() { abort(); }
7 int test::mainLoop(void)
8 {
9     unsigned int __tag__, __status__;
10     __xdrs__->x_op = XDR_DECODE;
11     xdrrec_skiprecord(__xdrs__);
12     __status__ = xdr_int(__xdrs__, &__tag__);
13         if (!__status__) return(-1);
14     switch (__tag__) {
15         case 0:
16             char *__ProtocolName__ = "test";
17             int __val__;
18             __xdrs__->x_op = XDR_ENCODE;
19             __val__ = 0;
20             xdr_int(__xdrs__, &__val__);
21             xdr_String(__xdrs__, &__ProtocolName__);
22             __val__ = 1;
23             xdr_int(__xdrs__, &__val__);
24             xdrrec_endofrecord(__xdrs__, TRUE);
25                 __versionVerifyDone__ = TRUE;
26             break;
27         case test_triggerAsyncUpcall_REQ: {
28                     extern xdr_void(XDR*, void*);
29             test__16 __recvBuffer__;
30             xdr_int(__xdrs__, &__recvBuffer__.val);
31             triggerAsyncUpcall(__recvBuffer__.val);
32             __xdrs__->x_op = XDR_ENCODE;
33             __tag__ = test_triggerAsyncUpcall_RESP;
34             xdr_int(__xdrs__, &__tag__);
35             xdrrec_endofrecord(__xdrs__, TRUE);
36             break;
37          }
38
39         case test_triggerSyncUpcall_REQ: {
40                     extern xdr_void(XDR*, void*);
41             test__14 __recvBuffer__;
42             xdr_int(__xdrs__, &__recvBuffer__.val);
43             triggerSyncUpcall(__recvBuffer__.val);
44             __xdrs__->x_op = XDR_ENCODE;
45             __tag__ = test_triggerSyncUpcall_RESP;
46             xdr_int(__xdrs__, &__tag__);
47             xdrrec_endofrecord(__xdrs__, TRUE);
48             break;
49          }
50
51         case test_stringString_REQ: {
52                     String __ret__;
53             extern xdr_String(XDR*, String*);
54             test__13 __recvBuffer__;
55             xdr_String(__xdrs__, &__recvBuffer__.test__12);
56             __ret__ = stringString(__recvBuffer__.test__12);
57             __xdrs__->x_op = XDR_ENCODE;
58             __tag__ = test_stringString_RESP;
59             xdr_int(__xdrs__, &__tag__);
60             xdr_String(__xdrs__,&__ret__);
61             xdrrec_endofrecord(__xdrs__, TRUE);
62             break;
63          }
64
65         case test_retVector_REQ: {
66                     int_Array __ret__;
67             extern xdr_int_Array(XDR*, int_Array*);
68             test__11 __recvBuffer__;
69             xdr_int(__xdrs__, &__recvBuffer__.len);
70             xdr_int(__xdrs__, &__recvBuffer__.start);
71             __ret__ = retVector(__recvBuffer__.len,__recvBuffer__.start);
72             __xdrs__->x_op = XDR_ENCODE;
73             __tag__ = test_retVector_RESP;
74             xdr_int(__xdrs__, &__tag__);
75             xdr_int_Array(__xdrs__,&__ret__);
76             xdrrec_endofrecord(__xdrs__, TRUE);
77             break;
78          }
79
80         case test_sumVector_REQ: {
81                     int __ret__;
82             extern xdr_int(XDR*, int*);
83             test__10 __recvBuffer__;
84             xdr_int_Array(__xdrs__, &__recvBuffer__.test__9);
85             __ret__ = sumVector(__recvBuffer__.test__9);
86             __xdrs__->x_op = XDR_ENCODE;
87             __tag__ = test_sumVector_RESP;
88             xdr_int(__xdrs__, &__tag__);
89             xdr_int(__xdrs__,&__ret__);
90             xdrrec_endofrecord(__xdrs__, TRUE);
91             break;
92          }
93
94         case test_add_REQ: {
95                     int __ret__;
96             extern xdr_int(XDR*, int*);
97             test__8 __recvBuffer__;
98             xdr_int(__xdrs__, &__recvBuffer__.test__6);
99             xdr_int(__xdrs__, &__recvBuffer__.test__7);
100             __ret__ = add(__recvBuffer__.test__6,__recvBuffer__.test__7);
101             __xdrs__->x_op = XDR_ENCODE;
102             __tag__ = test_add_RESP;
103             xdr_int(__xdrs__, &__tag__);
104             xdr_int(__xdrs__,&__ret__);
105             xdrrec_endofrecord(__xdrs__, TRUE);
106             break;
107          }
108
109         case test_intString_REQ: {
110                     int __ret__;
111             extern xdr_int(XDR*, int*);
112             test__5 __recvBuffer__;
113             xdr_String(__xdrs__, &__recvBuffer__.test__4);
114             __ret__ = intString(__recvBuffer__.test__4);
115             __xdrs__->x_op = XDR_ENCODE;
116             __tag__ = test_intString_RESP;
117             xdr_int(__xdrs__, &__tag__);
118             xdr_int(__xdrs__,&__ret__);
119             xdrrec_endofrecord(__xdrs__, TRUE);
120             break;
121          }
122
123         case test_nullStruct_REQ: {
124                     extern xdr_void(XDR*, void*);
125             test__3 __recvBuffer__;
126             xdr_intStruct(__xdrs__, &__recvBuffer__.test__2);
127             nullStruct(__recvBuffer__.test__2);
128             __xdrs__->x_op = XDR_ENCODE;
129             __tag__ = test_nullStruct_RESP;
130             xdr_int(__xdrs__, &__tag__);
131             xdrrec_endofrecord(__xdrs__, TRUE);
132             break;
133          }
134
135         case test_intNull_REQ: {
136                     int __ret__;
137             extern xdr_int(XDR*, int*);
138             __ret__ = intNull();
139             __xdrs__->x_op = XDR_ENCODE;
140             __tag__ = test_intNull_RESP;
141             xdr_int(__xdrs__, &__tag__);
142             xdr_int(__xdrs__,&__ret__);
143             xdrrec_endofrecord(__xdrs__, TRUE);
144             break;
145          }
146
147         case test_nullNull_REQ: {
148                     extern xdr_void(XDR*, void*);
149             nullNull();
150             __xdrs__->x_op = XDR_ENCODE;
151             __tag__ = test_nullNull_RESP;
152             xdr_int(__xdrs__, &__tag__);
153             xdrrec_endofrecord(__xdrs__, TRUE);
154             break;
155          }
156
157     default:
158             return(__tag__);
159   }
160   return(0);
161 }
162
163 void test::asyncUpcall(int x) {
164     unsigned int __tag__;
165     if (!__versionVerifyDone__) {
166         char *__ProtocolName__ = "test";
167         int __status__;
168         __xdrs__->x_op = XDR_DECODE;
169         xdrrec_skiprecord(__xdrs__);
170         __status__ = xdr_int(__xdrs__, &__tag__);
171         assert(__status__ && (__tag__ == 0));
172         __xdrs__->x_op = XDR_ENCODE;
173         xdr_int(__xdrs__, &__tag__);
174         xdr_String(__xdrs__, &__ProtocolName__);
175         __tag__ = 1;
176         xdr_int(__xdrs__, &__tag__);
177         xdrrec_endofrecord(__xdrs__, TRUE);
178         __versionVerifyDone__ = TRUE;
179     }
180     __tag__ = test_asyncUpcall_REQ;
181     __xdrs__->x_op = XDR_ENCODE;
182     xdr_int(__xdrs__, &__tag__);
183     xdr_int(__xdrs__, &x);
184     xdrrec_endofrecord(__xdrs__, TRUE);
185 }
186
187
188 void test::syncUpcall(int x) {
189     unsigned int __tag__;
190     if (!__versionVerifyDone__) {
191         char *__ProtocolName__ = "test";
192         int __status__;
193         __xdrs__->x_op = XDR_DECODE;
194         xdrrec_skiprecord(__xdrs__);
195         __status__ = xdr_int(__xdrs__, &__tag__);
196         assert(__status__ && (__tag__ == 0));
197         __xdrs__->x_op = XDR_ENCODE;
198         xdr_int(__xdrs__, &__tag__);
199         xdr_String(__xdrs__, &__ProtocolName__);
200         __tag__ = 1;
201         xdr_int(__xdrs__, &__tag__);
202         xdrrec_endofrecord(__xdrs__, TRUE);
203         __versionVerifyDone__ = TRUE;
204     }
205     __tag__ = test_syncUpcall_REQ;
206     __xdrs__->x_op = XDR_ENCODE;
207     xdr_int(__xdrs__, &__tag__);
208     xdr_int(__xdrs__, &x);
209     xdrrec_endofrecord(__xdrs__, TRUE);
210     __xdrs__->x_op = XDR_DECODE;
211     xdrrec_skiprecord(__xdrs__);
212     xdr_int(__xdrs__, &__tag__);
213     assert(__tag__ == test_syncUpcall_RESP);
214 }
215