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