Type.h revision fdfe2ff8c60c367a4eb7cecb4cbe1d62b41a8c20 
1#ifndef AIDL_TYPE_H
2#define AIDL_TYPE_H
3
4#include "AST.h"
5#include <string>
6#include <vector>
7
8using namespace std;
9
10class Type
11{
12public:
13    // kinds
14    enum {
15        BUILT_IN,
16        PARCELABLE,
17        INTERFACE,
18        GENERATED
19    };
20
21    // WriteToParcel flags
22    enum {
23        PARCELABLE_WRITE_RETURN_VALUE = 0x0001
24    };
25
26                    Type(const string& name, int kind, bool canWriteToParcel,
27                            bool canBeOut);
28                    Type(const string& package, const string& name,
29                            int kind, bool canWriteToParcel, bool canBeOut,
30                            const string& declFile = "", int declLine = -1);
31    virtual         ~Type();
32
33    inline string   Package() const             { return m_package; }
34    inline string   Name() const                { return m_name; }
35    inline string   QualifiedName() const       { return m_qualifiedName; }
36    inline int      Kind() const                { return m_kind; }
37    inline string   DeclFile() const            { return m_declFile; }
38    inline int      DeclLine() const            { return m_declLine; }
39    inline bool     CanBeMarshalled() const     { return m_canWriteToParcel; }
40    inline bool     CanBeOutParameter() const   { return m_canBeOut; }
41
42    virtual string  ImportType() const;
43    virtual string  CreatorName() const;
44    virtual string  InstantiableName() const;
45
46    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
47                                    Variable* parcel, int flags);
48    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
49                                    Variable* parcel, Variable** cl);
50    virtual void    ReadFromParcel(StatementBlock* addTo, Variable* v,
51                                    Variable* parcel, Variable** cl);
52
53    virtual bool    CanBeArray() const;
54
55    virtual void    WriteArrayToParcel(StatementBlock* addTo, Variable* v,
56                                    Variable* parcel, int flags);
57    virtual void    CreateArrayFromParcel(StatementBlock* addTo, Variable* v,
58                                    Variable* parcel, Variable** cl);
59    virtual void    ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
60                                    Variable* parcel, Variable** cl);
61
62    virtual void    WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
63                                    Variable* data, int flags);
64    virtual void    CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
65                                    Variable* data, Variable** cl);
66    virtual void    ReadFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
67                                    Variable* data, Variable** cl);
68
69
70protected:
71    void SetQualifiedName(const string& qualified);
72    Expression* BuildWriteToParcelFlags(int flags);
73
74private:
75    Type();
76    Type(const Type&);
77
78    string m_package;
79    string m_name;
80    string m_qualifiedName;
81    string m_declFile;
82    int m_declLine;
83    int m_kind;
84    bool m_canWriteToParcel;
85    bool m_canBeOut;
86};
87
88class BasicType : public Type
89{
90public:
91                    BasicType(const string& name, const string& marshallMethod,
92                              const string& unmarshallMethod,
93                              const string& writeArray,
94                              const string& createArray,
95                              const string& readArray);
96
97    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
98                                    Variable* parcel, int flags);
99    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
100                                    Variable* parcel, Variable** cl);
101
102    virtual bool    CanBeArray() const;
103
104    virtual void    WriteArrayToParcel(StatementBlock* addTo, Variable* v,
105                                    Variable* parcel, int flags);
106    virtual void    CreateArrayFromParcel(StatementBlock* addTo, Variable* v,
107                                    Variable* parcel, Variable** cl);
108    virtual void    ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
109                                    Variable* parcel, Variable** cl);
110
111private:
112    string m_marshallMethod;
113    string m_unmarshallMethod;
114    string m_writeArrayMethod;
115    string m_createArrayMethod;
116    string m_readArrayMethod;
117};
118
119class BooleanType : public Type
120{
121public:
122                    BooleanType();
123
124    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
125                                    Variable* parcel, int flags);
126    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
127                                    Variable* parcel, Variable** cl);
128
129    virtual bool    CanBeArray() const;
130
131    virtual void    WriteArrayToParcel(StatementBlock* addTo, Variable* v,
132                                    Variable* parcel, int flags);
133    virtual void    CreateArrayFromParcel(StatementBlock* addTo, Variable* v,
134                                    Variable* parcel, Variable** cl);
135    virtual void    ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
136                                    Variable* parcel, Variable** cl);
137};
138
139class CharType : public Type
140{
141public:
142                    CharType();
143
144    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
145                                    Variable* parcel, int flags);
146    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
147                                    Variable* parcel, Variable** cl);
148
149    virtual bool    CanBeArray() const;
150
151    virtual void    WriteArrayToParcel(StatementBlock* addTo, Variable* v,
152                                    Variable* parcel, int flags);
153    virtual void    CreateArrayFromParcel(StatementBlock* addTo, Variable* v,
154                                    Variable* parcel, Variable** cl);
155    virtual void    ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
156                                    Variable* parcel, Variable** cl);
157};
158
159
160class StringType : public Type
161{
162public:
163                    StringType();
164
165    virtual string  CreatorName() const;
166
167    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
168                                    Variable* parcel, int flags);
169    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
170                                    Variable* parcel, Variable** cl);
171
172    virtual bool    CanBeArray() const;
173
174    virtual void    WriteArrayToParcel(StatementBlock* addTo, Variable* v,
175                                    Variable* parcel, int flags);
176    virtual void    CreateArrayFromParcel(StatementBlock* addTo, Variable* v,
177                                    Variable* parcel, Variable** cl);
178    virtual void    ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
179                                    Variable* parcel, Variable** cl);
180
181    virtual void    WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
182                                    Variable* data, int flags);
183    virtual void    CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
184                                    Variable* data, Variable** cl);
185};
186
187class CharSequenceType : public Type
188{
189public:
190                    CharSequenceType();
191
192    virtual string  CreatorName() const;
193
194    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
195                                    Variable* parcel, int flags);
196    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
197                                    Variable* parcel, Variable** cl);
198};
199
200class RemoteExceptionType : public Type
201{
202public:
203                    RemoteExceptionType();
204
205    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
206                                    Variable* parcel, int flags);
207    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
208                                    Variable* parcel, Variable** cl);
209};
210
211class RuntimeExceptionType : public Type
212{
213public:
214                    RuntimeExceptionType();
215
216    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
217                                    Variable* parcel, int flags);
218    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
219                                    Variable* parcel, Variable** cl);
220};
221
222class IBinderType : public Type
223{
224public:
225                    IBinderType();
226
227    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
228                                    Variable* parcel, int flags);
229    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
230                                    Variable* parcel, Variable** cl);
231
232    virtual void    WriteArrayToParcel(StatementBlock* addTo, Variable* v,
233                                    Variable* parcel, int flags);
234    virtual void    CreateArrayFromParcel(StatementBlock* addTo, Variable* v,
235                                    Variable* parcel, Variable** cl);
236    virtual void    ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
237                                    Variable* parcel, Variable** cl);
238};
239
240class IInterfaceType : public Type
241{
242public:
243                    IInterfaceType();
244
245    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
246                                    Variable* parcel, int flags);
247    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
248                                    Variable* parcel, Variable** cl);
249};
250
251class BinderType : public Type
252{
253public:
254                    BinderType();
255
256    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
257                                    Variable* parcel, int flags);
258    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
259                                    Variable* parcel, Variable** cl);
260};
261
262class BinderProxyType : public Type
263{
264public:
265                    BinderProxyType();
266
267    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
268                                    Variable* parcel, int flags);
269    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
270                                    Variable* parcel, Variable** cl);
271};
272
273class ParcelType : public Type
274{
275public:
276                    ParcelType();
277
278    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
279                                    Variable* parcel, int flags);
280    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
281                                    Variable* parcel, Variable** cl);
282};
283
284class ParcelableInterfaceType : public Type
285{
286public:
287                    ParcelableInterfaceType();
288
289    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
290                                    Variable* parcel, int flags);
291    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
292                                    Variable* parcel, Variable** cl);
293};
294
295class MapType : public Type
296{
297public:
298                    MapType();
299
300    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
301                                    Variable* parcel, int flags);
302    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
303                                    Variable* parcel, Variable** cl);
304    virtual void    ReadFromParcel(StatementBlock* addTo, Variable* v,
305                                    Variable* parcel, Variable** cl);
306};
307
308class ListType : public Type
309{
310public:
311                    ListType();
312
313    virtual string  InstantiableName() const;
314
315    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
316                                    Variable* parcel, int flags);
317    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
318                                    Variable* parcel, Variable** cl);
319    virtual void    ReadFromParcel(StatementBlock* addTo, Variable* v,
320                                    Variable* parcel, Variable** cl);
321};
322
323class ParcelableType : public Type
324{
325public:
326                    ParcelableType(const string& package, const string& name,
327                            bool builtIn, const string& declFile, int declLine);
328
329    virtual string  CreatorName() const;
330
331    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
332                                    Variable* parcel, int flags);
333    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
334                                    Variable* parcel, Variable** cl);
335    virtual void    ReadFromParcel(StatementBlock* addTo, Variable* v,
336                                    Variable* parcel, Variable** cl);
337
338    virtual bool    CanBeArray() const;
339
340    virtual void    WriteArrayToParcel(StatementBlock* addTo, Variable* v,
341                                    Variable* parcel, int flags);
342    virtual void    CreateArrayFromParcel(StatementBlock* addTo, Variable* v,
343                                    Variable* parcel, Variable** cl);
344    virtual void    ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
345                                    Variable* parcel, Variable** cl);
346};
347
348class InterfaceType : public Type
349{
350public:
351                    InterfaceType(const string& package, const string& name,
352                            bool builtIn, bool oneway,
353                            const string& declFile, int declLine);
354
355    bool            OneWay() const;
356
357    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
358                                    Variable* parcel, int flags);
359    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
360                                    Variable* parcel, Variable** cl);
361
362private:
363    bool m_oneway;
364};
365
366
367class GenericType : public Type
368{
369public:
370                    GenericType(const string& package, const string& name,
371                                 const vector<Type*>& args);
372
373    string          GenericArguments() const;
374
375    virtual string  ImportType() const;
376
377    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
378                                    Variable* parcel, int flags);
379    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
380                                    Variable* parcel, Variable** cl);
381    virtual void    ReadFromParcel(StatementBlock* addTo, Variable* v,
382                                    Variable* parcel, Variable** cl);
383
384private:
385    string m_genericArguments;
386    string m_importName;
387    vector<Type*> m_args;
388};
389
390
391class GenericListType : public GenericType
392{
393public:
394                    GenericListType(const string& package, const string& name,
395                                 const vector<Type*>& args);
396
397    virtual string  CreatorName() const;
398    virtual string  InstantiableName() const;
399
400    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
401                                    Variable* parcel, int flags);
402    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
403                                    Variable* parcel, Variable** cl);
404    virtual void    ReadFromParcel(StatementBlock* addTo, Variable* v,
405                                    Variable* parcel, Variable** cl);
406
407private:
408    string m_creator;
409};
410
411class ClassLoaderType : public Type
412{
413public:
414                    ClassLoaderType();
415};
416
417class Namespace
418{
419public:
420            Namespace();
421            ~Namespace();
422    void    Add(Type* type);
423
424    // args is the number of template types (what is this called?)
425    void    AddGenericType(const string& package, const string& name, int args);
426
427    // lookup a specific class name
428    Type*   Find(const string& name) const;
429    Type*   Find(const char* package, const char* name) const;
430
431    // try to search by either a full name or a partial name
432    Type*   Search(const string& name);
433
434    void    Dump() const;
435
436private:
437    struct Generic {
438        string package;
439        string name;
440        string qualified;
441        int args;
442    };
443
444    const Generic* search_generic(const string& name) const;
445
446    vector<Type*> m_types;
447    vector<Generic> m_generics;
448};
449
450extern Namespace NAMES;
451
452extern Type* VOID_TYPE;
453extern Type* BOOLEAN_TYPE;
454extern Type* BYTE_TYPE;
455extern Type* CHAR_TYPE;
456extern Type* INT_TYPE;
457extern Type* LONG_TYPE;
458extern Type* FLOAT_TYPE;
459extern Type* DOUBLE_TYPE;
460extern Type* OBJECT_TYPE;
461extern Type* STRING_TYPE;
462extern Type* CHAR_SEQUENCE_TYPE;
463extern Type* TEXT_UTILS_TYPE;
464extern Type* REMOTE_EXCEPTION_TYPE;
465extern Type* RUNTIME_EXCEPTION_TYPE;
466extern Type* IBINDER_TYPE;
467extern Type* IINTERFACE_TYPE;
468extern Type* BINDER_NATIVE_TYPE;
469extern Type* BINDER_PROXY_TYPE;
470extern Type* PARCEL_TYPE;
471extern Type* PARCELABLE_INTERFACE_TYPE;
472
473extern Type* CONTEXT_TYPE;
474
475extern Type* RPC_SERVICE_BASE_TYPE;
476extern Type* RPC_DATA_TYPE;
477extern Type* RPC_BROKER_TYPE;
478extern Type* RPC_ENDPOINT_INFO_TYPE;
479extern Type* RPC_RESULT_HANDLER_TYPE;
480extern Type* RPC_ERROR_TYPE;
481extern Type* RPC_ERROR_LISTENER_TYPE;
482
483extern Expression* NULL_VALUE;
484extern Expression* THIS_VALUE;
485extern Expression* SUPER_VALUE;
486extern Expression* TRUE_VALUE;
487extern Expression* FALSE_VALUE;
488
489void register_base_types();
490
491#endif // AIDL_TYPE_H
492