Type.h revision 6c0236c53a30ea9fef28ee7c95a4dce2fa5ce2e1 
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 canWriteToRpcData, bool canBeOut);
28                    Type(const string& package, const string& name,
29                            int kind, bool canWriteToParcel, bool canWriteToRpcData, 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     CanWriteToParcel() const    { return m_canWriteToParcel; }
40    inline bool     CanWriteToRpcData() const   { return m_canWriteToRpcData; }
41    inline bool     CanBeOutParameter() const   { return m_canBeOut; }
42
43    virtual string  ImportType() const;
44    virtual string  CreatorName() const;
45    virtual string  InstantiableName() const;
46
47    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
48                                    Variable* parcel, int flags);
49    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
50                                    Variable* parcel, Variable** cl);
51    virtual void    ReadFromParcel(StatementBlock* addTo, Variable* v,
52                                    Variable* parcel, Variable** cl);
53
54    virtual bool    CanBeArray() const;
55
56    virtual void    WriteArrayToParcel(StatementBlock* addTo, Variable* v,
57                                    Variable* parcel, int flags);
58    virtual void    CreateArrayFromParcel(StatementBlock* addTo, Variable* v,
59                                    Variable* parcel, Variable** cl);
60    virtual void    ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
61                                    Variable* parcel, Variable** cl);
62
63    virtual void    WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
64                                    Variable* data, int flags);
65    virtual void    CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
66                                    Variable* data, Variable** cl);
67
68protected:
69    void SetQualifiedName(const string& qualified);
70    Expression* BuildWriteToParcelFlags(int flags);
71
72private:
73    Type();
74    Type(const Type&);
75
76    string m_package;
77    string m_name;
78    string m_qualifiedName;
79    string m_declFile;
80    int m_declLine;
81    int m_kind;
82    bool m_canWriteToParcel;
83    bool m_canWriteToRpcData;
84    bool m_canBeOut;
85};
86
87class BasicType : public Type
88{
89public:
90                    BasicType(const string& name,
91                              const string& marshallParcel,
92                              const string& unmarshallParcel,
93                              const string& writeArrayParcel,
94                              const string& createArrayParcel,
95                              const string& readArrayParcel,
96                              const string& marshallRpc,
97                              const string& unmarshallRpc,
98                              const string& writeArrayRpc,
99                              const string& createArrayRpc,
100                              const string& readArrayRpc);
101
102    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
103                                    Variable* parcel, int flags);
104    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
105                                    Variable* parcel, Variable** cl);
106
107    virtual bool    CanBeArray() const;
108
109    virtual void    WriteArrayToParcel(StatementBlock* addTo, Variable* v,
110                                    Variable* parcel, int flags);
111    virtual void    CreateArrayFromParcel(StatementBlock* addTo, Variable* v,
112                                    Variable* parcel, Variable** cl);
113    virtual void    ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
114                                    Variable* parcel, Variable** cl);
115
116    virtual void    WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
117                                    Variable* data, int flags);
118    virtual void    CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
119                                    Variable* data, Variable** cl);
120
121private:
122    string m_marshallParcel;
123    string m_unmarshallParcel;
124    string m_writeArrayParcel;
125    string m_createArrayParcel;
126    string m_readArrayParcel;
127    string m_marshallRpc;
128    string m_unmarshallRpc;
129    string m_writeArrayRpc;
130    string m_createArrayRpc;
131    string m_readArrayRpc;
132};
133
134class BooleanType : public Type
135{
136public:
137                    BooleanType();
138
139    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
140                                    Variable* parcel, int flags);
141    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
142                                    Variable* parcel, Variable** cl);
143
144    virtual bool    CanBeArray() const;
145
146    virtual void    WriteArrayToParcel(StatementBlock* addTo, Variable* v,
147                                    Variable* parcel, int flags);
148    virtual void    CreateArrayFromParcel(StatementBlock* addTo, Variable* v,
149                                    Variable* parcel, Variable** cl);
150    virtual void    ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
151                                    Variable* parcel, Variable** cl);
152
153    virtual void    WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
154                                    Variable* data, int flags);
155    virtual void    CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
156                                    Variable* data, Variable** cl);
157};
158
159class CharType : public Type
160{
161public:
162                    CharType();
163
164    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
165                                    Variable* parcel, int flags);
166    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
167                                    Variable* parcel, Variable** cl);
168
169    virtual bool    CanBeArray() const;
170
171    virtual void    WriteArrayToParcel(StatementBlock* addTo, Variable* v,
172                                    Variable* parcel, int flags);
173    virtual void    CreateArrayFromParcel(StatementBlock* addTo, Variable* v,
174                                    Variable* parcel, Variable** cl);
175    virtual void    ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
176                                    Variable* parcel, Variable** cl);
177
178    virtual void    WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
179                                    Variable* data, int flags);
180    virtual void    CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
181                                    Variable* data, Variable** cl);
182};
183
184
185class StringType : public Type
186{
187public:
188                    StringType();
189
190    virtual string  CreatorName() const;
191
192    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
193                                    Variable* parcel, int flags);
194    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
195                                    Variable* parcel, Variable** cl);
196
197    virtual bool    CanBeArray() const;
198
199    virtual void    WriteArrayToParcel(StatementBlock* addTo, Variable* v,
200                                    Variable* parcel, int flags);
201    virtual void    CreateArrayFromParcel(StatementBlock* addTo, Variable* v,
202                                    Variable* parcel, Variable** cl);
203    virtual void    ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
204                                    Variable* parcel, Variable** cl);
205
206    virtual void    WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
207                                    Variable* data, int flags);
208    virtual void    CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
209                                    Variable* data, Variable** cl);
210};
211
212class CharSequenceType : public Type
213{
214public:
215                    CharSequenceType();
216
217    virtual string  CreatorName() const;
218
219    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
220                                    Variable* parcel, int flags);
221    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
222                                    Variable* parcel, Variable** cl);
223};
224
225class RemoteExceptionType : public Type
226{
227public:
228                    RemoteExceptionType();
229
230    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
231                                    Variable* parcel, int flags);
232    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
233                                    Variable* parcel, Variable** cl);
234};
235
236class RuntimeExceptionType : public Type
237{
238public:
239                    RuntimeExceptionType();
240
241    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
242                                    Variable* parcel, int flags);
243    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
244                                    Variable* parcel, Variable** cl);
245};
246
247class IBinderType : public Type
248{
249public:
250                    IBinderType();
251
252    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
253                                    Variable* parcel, int flags);
254    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
255                                    Variable* parcel, Variable** cl);
256
257    virtual void    WriteArrayToParcel(StatementBlock* addTo, Variable* v,
258                                    Variable* parcel, int flags);
259    virtual void    CreateArrayFromParcel(StatementBlock* addTo, Variable* v,
260                                    Variable* parcel, Variable** cl);
261    virtual void    ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
262                                    Variable* parcel, Variable** cl);
263};
264
265class IInterfaceType : public Type
266{
267public:
268                    IInterfaceType();
269
270    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
271                                    Variable* parcel, int flags);
272    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
273                                    Variable* parcel, Variable** cl);
274};
275
276class BinderType : public Type
277{
278public:
279                    BinderType();
280
281    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
282                                    Variable* parcel, int flags);
283    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
284                                    Variable* parcel, Variable** cl);
285};
286
287class BinderProxyType : public Type
288{
289public:
290                    BinderProxyType();
291
292    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
293                                    Variable* parcel, int flags);
294    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
295                                    Variable* parcel, Variable** cl);
296};
297
298class ParcelType : public Type
299{
300public:
301                    ParcelType();
302
303    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
304                                    Variable* parcel, int flags);
305    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
306                                    Variable* parcel, Variable** cl);
307};
308
309class ParcelableInterfaceType : public Type
310{
311public:
312                    ParcelableInterfaceType();
313
314    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
315                                    Variable* parcel, int flags);
316    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
317                                    Variable* parcel, Variable** cl);
318};
319
320class MapType : public Type
321{
322public:
323                    MapType();
324
325    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
326                                    Variable* parcel, int flags);
327    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
328                                    Variable* parcel, Variable** cl);
329    virtual void    ReadFromParcel(StatementBlock* addTo, Variable* v,
330                                    Variable* parcel, Variable** cl);
331};
332
333class ListType : public Type
334{
335public:
336                    ListType();
337
338    virtual string  InstantiableName() const;
339
340    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
341                                    Variable* parcel, int flags);
342    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
343                                    Variable* parcel, Variable** cl);
344    virtual void    ReadFromParcel(StatementBlock* addTo, Variable* v,
345                                    Variable* parcel, Variable** cl);
346
347    virtual void    WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
348                                    Variable* data, int flags);
349    virtual void    CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
350                                    Variable* data, Variable** cl);
351};
352
353class ParcelableType : public Type
354{
355public:
356                    ParcelableType(const string& package, const string& name,
357                            bool builtIn, const string& declFile, int declLine);
358                    ParcelableType(const string& package, const string& name,
359                            bool builtIn, bool canWriteToRpcData,
360                            const string& declFile = "", int declLine = -1);
361
362    virtual string  CreatorName() const;
363
364    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
365                                    Variable* parcel, int flags);
366    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
367                                    Variable* parcel, Variable** cl);
368    virtual void    ReadFromParcel(StatementBlock* addTo, Variable* v,
369                                    Variable* parcel, Variable** cl);
370
371    virtual bool    CanBeArray() const;
372
373    virtual void    WriteArrayToParcel(StatementBlock* addTo, Variable* v,
374                                    Variable* parcel, int flags);
375    virtual void    CreateArrayFromParcel(StatementBlock* addTo, Variable* v,
376                                    Variable* parcel, Variable** cl);
377    virtual void    ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
378                                    Variable* parcel, Variable** cl);
379};
380
381class FlattenableType : public Type
382{
383public:
384                    FlattenableType(const string& package, const string& name,
385                            bool builtIn, const string& declFile, int declLine);
386
387    virtual string  CreatorName() const;
388
389    virtual void    WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
390                                    Variable* data, int flags);
391    virtual void    CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
392                                    Variable* data, Variable** cl);
393
394    virtual bool    CanBeArray() const;
395};
396
397class InterfaceType : public Type
398{
399public:
400                    InterfaceType(const string& package, const string& name,
401                            bool builtIn, bool oneway,
402                            const string& declFile, int declLine);
403
404    bool            OneWay() const;
405
406    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
407                                    Variable* parcel, int flags);
408    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
409                                    Variable* parcel, Variable** cl);
410
411private:
412    bool m_oneway;
413};
414
415
416class GenericType : public Type
417{
418public:
419                    GenericType(const string& package, const string& name,
420                                 const vector<Type*>& args);
421
422    const vector<Type*>& GenericArgumentTypes() const;
423    string          GenericArguments() const;
424
425    virtual string  ImportType() const;
426
427    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
428                                    Variable* parcel, int flags);
429    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
430                                    Variable* parcel, Variable** cl);
431    virtual void    ReadFromParcel(StatementBlock* addTo, Variable* v,
432                                    Variable* parcel, Variable** cl);
433
434private:
435    string m_genericArguments;
436    string m_importName;
437    vector<Type*> m_args;
438};
439
440class RpcDataType : public ParcelableType
441{
442public:
443                    RpcDataType();
444
445    virtual void    WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
446                                    Variable* data, int flags);
447    virtual void    CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
448                                    Variable* data, Variable** cl);
449};
450
451class ClassLoaderType : public Type
452{
453public:
454                    ClassLoaderType();
455};
456
457class GenericListType : public GenericType
458{
459public:
460                    GenericListType(const string& package, const string& name,
461                                 const vector<Type*>& args);
462
463    virtual string  CreatorName() const;
464    virtual string  InstantiableName() const;
465
466    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
467                                    Variable* parcel, int flags);
468    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
469                                    Variable* parcel, Variable** cl);
470    virtual void    ReadFromParcel(StatementBlock* addTo, Variable* v,
471                                    Variable* parcel, Variable** cl);
472
473    virtual void    WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
474                                    Variable* data, int flags);
475    virtual void    CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
476                                    Variable* data, Variable** cl);
477
478private:
479    string m_creator;
480};
481
482class Namespace
483{
484public:
485            Namespace();
486            ~Namespace();
487    void    Add(Type* type);
488
489    // args is the number of template types (what is this called?)
490    void    AddGenericType(const string& package, const string& name, int args);
491
492    // lookup a specific class name
493    Type*   Find(const string& name) const;
494    Type*   Find(const char* package, const char* name) const;
495
496    // try to search by either a full name or a partial name
497    Type*   Search(const string& name);
498
499    void    Dump() const;
500
501private:
502    struct Generic {
503        string package;
504        string name;
505        string qualified;
506        int args;
507    };
508
509    const Generic* search_generic(const string& name) const;
510
511    vector<Type*> m_types;
512    vector<Generic> m_generics;
513};
514
515extern Namespace NAMES;
516
517extern Type* VOID_TYPE;
518extern Type* BOOLEAN_TYPE;
519extern Type* BYTE_TYPE;
520extern Type* CHAR_TYPE;
521extern Type* INT_TYPE;
522extern Type* LONG_TYPE;
523extern Type* FLOAT_TYPE;
524extern Type* DOUBLE_TYPE;
525extern Type* OBJECT_TYPE;
526extern Type* STRING_TYPE;
527extern Type* CHAR_SEQUENCE_TYPE;
528extern Type* TEXT_UTILS_TYPE;
529extern Type* REMOTE_EXCEPTION_TYPE;
530extern Type* RUNTIME_EXCEPTION_TYPE;
531extern Type* IBINDER_TYPE;
532extern Type* IINTERFACE_TYPE;
533extern Type* BINDER_NATIVE_TYPE;
534extern Type* BINDER_PROXY_TYPE;
535extern Type* PARCEL_TYPE;
536extern Type* PARCELABLE_INTERFACE_TYPE;
537
538extern Type* CONTEXT_TYPE;
539
540extern Type* RPC_DATA_TYPE;
541extern Type* RPC_ERROR_TYPE;
542extern Type* RPC_CONTEXT_TYPE;
543extern Type* EVENT_FAKE_TYPE;
544
545extern Expression* NULL_VALUE;
546extern Expression* THIS_VALUE;
547extern Expression* SUPER_VALUE;
548extern Expression* TRUE_VALUE;
549extern Expression* FALSE_VALUE;
550
551void register_base_types();
552
553#endif // AIDL_TYPE_H
554