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