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