changed output file definitions to declarations,
[dyninst.git] / igen / src / parse.h
1 /*
2  * parse.h - define the classes that are used in parsing an interface.
3  *
4  * $Log: parse.h,v $
5  * Revision 1.9  1994/07/28 22:28:07  krisna
6  * changed output file definitions to declarations,
7  * xdr_array changes to conform to prototype
8  * changed "," to "<<"
9  *
10  * Revision 1.8  1994/06/02  23:34:27  markc
11  * New igen features: error checking, synchronous upcalls.
12  *
13  * Revision 1.7  1994/04/01  04:58:10  markc
14  * Added checks in genBundler.
15  *
16  * Revision 1.6  1994/03/07  02:35:18  markc
17  * Added code to detect failures for xdr code.  Provides member instance
18  * callErr which is set to -1 on failures.
19  *
20  * Revision 1.5  1994/02/24  05:14:33  markc
21  * Man page for igen.
22  * Initial version for solaris2.2.
23  * Dependencies changed.
24  * Added pvm support, virtual function support, inclusion of data members,
25  * separate client and header include files.
26  *
27  * Revision 1.4  1994/02/08  00:17:56  hollings
28  * Fixed pointer problems to work on DECstations.
29  *
30  * Revision 1.3  1994/01/31  20:05:59  hollings
31  * Added code to check the protocol name and version tests are run
32  * before any upcalls get invoked.
33  *
34  * Revision 1.2  1994/01/26  06:50:11  hollings
35  * made the output of igen pass through g++ -Wall.
36  *
37  * Revision 1.1  1994/01/25  20:48:44  hollings
38  * new utility for interfaces.
39  *
40 */
41
42 #include "util/h/list.h"
43 #include "util/h/stringPool.h"
44
45 #include <iostream.h>
46 #include <fstream.h>
47
48 // the files to write the generated code to
49 extern ofstream dot_h;
50 extern ofstream dot_c;
51 extern ofstream srvr_dot_c;
52 extern ofstream srvr_dot_h;
53 extern ofstream clnt_dot_c;
54 extern ofstream clnt_dot_h;
55
56 class typeDefn;         // forward decl
57 class remoteFunc;
58
59 extern void dump_to_dot_h(char *);
60 extern stringPool pool;
61 extern List<typeDefn*> types;
62 extern typeDefn *foundType;
63
64 void addCMember (char *type, char *name, List<char*>*);
65 void addSMember (char *type, char *name, List<char*>*);
66 void buildPVMfilters();
67 void buildPVMincludes();
68 void buildPVMargs();
69 void genPVMServerCons(char *);
70 void genXDRServerCons(char *);
71 class interfaceSpec {
72   public:
73     interfaceSpec(char *n, int v, int lowTag) {
74         name = n;
75         version = v;
76         baseTag = boundTag = lowTag;
77     }
78     void newMethod(remoteFunc*f) { methods.add(f); }
79     void genClass();
80     void generateStubs(ofstream &ofile);
81     void genErrHandler(ofstream &ofile, Boolean client);
82     void generateClientCode();
83     void generateThreadLoop();
84     void generateXDRLoop();
85     void generatePVMLoop();
86     void generateServerCode();
87     void genWaitLoop();
88     void genProtoVerify();
89     void genProtoVerifyPVM();
90     void generateBundlers();
91     void genIncludes(ofstream &output);
92     void genXDRServerVerifyProtocol();
93     void genXDRLookForVerify();
94     int getNextTag();
95     char *genVariable();
96     char *getName() { return(name); }
97     int getVersion() { return(version); }
98   private:
99     char *name;
100     char *unionName;
101     int version;
102     int baseTag;
103     int boundTag;
104     List <remoteFunc *> methods;
105 };
106
107 extern class interfaceSpec *currentInterface;
108
109 class argument {
110   public:
111     argument(char *t, char *n,  List<char *> *s, int m) {
112         type = t;
113         name = n;
114         stars = s;
115         mallocs = m;
116     }
117     argument(char *t) {
118         type = t;
119         name = currentInterface->genVariable();
120         mallocs = 0;
121     }
122     char *type;
123     char *name;
124     int mallocs;
125     List<char *> *stars;
126 };
127
128 class field {
129   public:
130       field(char *t, char *n) {
131           type = t;
132           name = n;
133       }
134       char *getName() { return(name); }
135       char *getType() { return(type); }
136       void genBundler(ofstream &ofile) {
137           if (generateXDR) {
138             ofile << "    if (!xdr_" << type << "(__xdrs__, &(__ptr__->" << name << "))) return FALSE;\n";
139           } else if (generatePVM) {
140             ofile << "    IGEN_pvm_" << type << "(__dir__, &(__ptr__->" << name << "));\n";
141           }
142       }
143       void genHeader(ofstream &ofile) {
144           ofile << "    " << type << " " << name << ";\n";
145       }
146   private: 
147       char *type;
148       char *name;
149 };
150
151 class typeDefn {
152    public:
153        typeDefn(char *i, List<field *> f) {
154            name = pool.findAndAdd(i);
155            fields = f;
156            userDefined = TRUE;
157            arrayType = FALSE;
158            types.add(this, name);
159        }
160        typeDefn(char *i) {
161            name = pool.findAndAdd(i);
162            userDefined = FALSE;
163            arrayType = FALSE;
164            types.add(this, name);
165        }
166        typeDefn(char *i, char *t) {     // for arrays types.
167            name = pool.findAndAdd(i);
168            userDefined = TRUE;
169            arrayType = TRUE;
170            type = t;
171            types.add(this, name);
172        }
173        char *name;
174        char *type;
175        Boolean userDefined;
176        Boolean arrayType;
177        List<field *> fields;
178        void genHeader();
179        void genBundler();
180 };
181
182
183 enum upCallType { syncUpcall,       // from server to client, sync (not allowed)
184                   asyncUpcall,      // from server to client, async
185                   syncCall,         // from client to server, sync
186                   asyncCall         // from client to server, async
187                   };
188
189 class interfaceSpec;
190
191 struct type_data {
192   char *cp;
193   int mallocs;
194   int structs;
195 };
196
197 typedef struct type_data type_data;
198
199 struct func_data {
200   enum upCallType uc;
201   int virtual_f;
202 };
203
204 typedef struct func_data func_data;
205
206 union parseStack {
207     type_data td;
208     char *cp;
209     int i;
210     float f;
211     argument *arg;
212     field *fld;
213     func_data fd;
214     List<argument*> *args;
215     List<field*> *fields;
216     List<char*> *cl;
217     interfaceSpec *spec;
218 };
219
220
221 class remoteFunc {
222   public:
223       remoteFunc(interfaceSpec *sp,
224                  List<char *> *st, 
225                  char *n, char *r, 
226                  List <argument *> a, 
227                  enum upCallType uc,
228                  int v_f,
229                  int rs=0) {
230           spec = sp;
231           name = n;
232           retType = r;
233           structName = spec->genVariable();
234           args = a;
235           upcall = uc;
236           retStructs = rs;
237           virtual_f = v_f;
238       }
239       void genSwitch(Boolean, char*, ofstream &);
240       void genStub(char *interfaceName, Boolean forUpcalls, ofstream &ofile);
241       void genXDRStub(char *, ofstream &ofile);
242       void genPVMStub(char *, ofstream &ofile);
243       void genThreadStub(char *, ofstream &outfile);
244       void genHeader();
245       void genMethodHeader(char *className, int in_client, ofstream &output);
246       char *name;
247       char *retType;
248       char *structName;
249       List <argument *> args;
250       enum upCallType upcall;
251       int retStructs;
252       int virtual_f;
253   private:
254       interfaceSpec *spec;
255 };
256