made the output of igen pass through g++ -Wall.
[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.2  1994/01/26 06:50:11  hollings
6  * made the output of igen pass through g++ -Wall.
7  *
8  * Revision 1.1  1994/01/25  20:48:44  hollings
9  * new utility for interfaces.
10  *
11 */
12
13 #include "util/h/list.h"
14 #include "util/h/stringPool.h"
15
16 class typeDefn;         // forward decl
17 class remoteFunc;
18
19 extern stringPool pool;
20 extern List<typeDefn*> types;
21
22 class interfaceSpec {
23   public:
24     interfaceSpec(char *n, int v, int lowTag) {
25         name = n;
26         version = v;
27         baseTag = boundTag = lowTag;
28     }
29     void newMethod(remoteFunc*f) { methods.add(f); }
30     void genClass();
31     void generateStubs();
32     void generateClientCode();
33     void generateThreadLoop();
34     void generateXDRLoop();
35     void generateServerCode();
36     void genWaitLoop();
37     void genProtoVerify();
38     void generateBundlers();
39     void genIncludes();
40     int getNextTag();
41     char *genVariable();
42     char *getName() { return(name); }
43   private:
44     char *name;
45     char *unionName;
46     int version;
47     int baseTag;
48     int boundTag;
49     List <remoteFunc *> methods;
50 };
51
52 extern class interfaceSpec *currentInterface;
53
54 class argument {
55   public:
56     argument(char *t, char *n,  List<char *> *s) {
57         type = t;
58         name = n;
59         stars = s;
60     }
61     argument(char *t) {
62         type = t;
63         name = currentInterface->genVariable();
64     }
65     char *type;
66     char *name;
67     List<char *> *stars;
68 };
69
70 class field {
71   public:
72       field(char *t, char *n) {
73           type = t;
74           name = n;
75       }
76       char *getName() { return(name); }
77       char *getType() { return(type); }
78       void genBundler() {
79           printf("    xdr_%s(__xdrs__, &(__ptr__->%s));\n", type, name);
80       }
81       void genHeader() {
82           printf("    %s %s;\n", type, name);
83       }
84   private: 
85       char *type;
86       char *name;
87 };
88
89 class typeDefn {
90    public:
91        typeDefn(char *i, List<field *> f) {
92            name = pool.findAndAdd(i);
93            fields = f;
94            userDefined = TRUE;
95            arrayType = FALSE;
96            types.add(this, name);
97        }
98        typeDefn(char *i) {
99            name = pool.findAndAdd(i);
100            userDefined = FALSE;
101            arrayType = FALSE;
102            types.add(this, name);
103        }
104        typeDefn(char *i, char *t) {     // for arrays types.
105            name = pool.findAndAdd(i);
106            userDefined = TRUE;
107            arrayType = TRUE;
108            type = t;
109            types.add(this, name);
110        }
111        char *name;
112        char *type;
113        Boolean userDefined;
114        Boolean arrayType;
115        List<field *> fields;
116        void genHeader();
117        void genBundler();
118 };
119
120 enum upCallType { notUpcall, syncUpcall, asyncUpcall };
121
122 class interfaceSpec;
123
124 union parseStack {
125     char *cp;
126     int i;
127     float f;
128     argument *arg;
129     field *field;
130     enum upCallType uc;
131     List<argument*> *args;
132     List<field*> *fields;
133     List<char*> *cl;
134     interfaceSpec *spec;
135 };
136
137
138 class remoteFunc {
139   public:
140       remoteFunc(interfaceSpec *sp,
141                  List<char *> *st, 
142                  char *n, char *r, 
143                  List <argument *> a, 
144                  enum upCallType uc) {
145           spec = sp;
146           name = n;
147           retType = r;
148           structName = spec->genVariable();
149           args = a;
150           upcall = uc;
151       }
152       void genSwitch(Boolean);
153       void genStub(char *interfaceName, Boolean forUpcalls);
154       void genXDRStub(char *);
155       void genThreadStub(char *);
156       void genHeader();
157       void genMethodHeader(char *className);
158       char *name;
159       char *retType;
160       char *structName;
161       List <argument *> args;
162       enum upCallType upcall;
163   private:
164       interfaceSpec *spec;
165 };
166