Type.h revision 7db766c3fec2795b08d237f29b972f474983684b 
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
359    virtual string  CreatorName() const;
360
361    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
362                                    Variable* parcel, int flags);
363    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
364                                    Variable* parcel, Variable** cl);
365    virtual void    ReadFromParcel(StatementBlock* addTo, Variable* v,
366                                    Variable* parcel, Variable** cl);
367
368    virtual bool    CanBeArray() const;
369
370    virtual void    WriteArrayToParcel(StatementBlock* addTo, Variable* v,
371                                    Variable* parcel, int flags);
372    virtual void    CreateArrayFromParcel(StatementBlock* addTo, Variable* v,
373                                    Variable* parcel, Variable** cl);
374    virtual void    ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
375                                    Variable* parcel, Variable** cl);
376};
377
378class FlattenableType : public Type
379{
380public:
381                    FlattenableType(const string& package, const string& name,
382                            bool builtIn, const string& declFile, int declLine);
383
384    virtual string  CreatorName() const;
385
386    virtual void    WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
387                                    Variable* data, int flags);
388    virtual void    CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
389                                    Variable* data, Variable** cl);
390
391    virtual bool    CanBeArray() const;
392};
393
394class InterfaceType : public Type
395{
396public:
397                    InterfaceType(const string& package, const string& name,
398                            bool builtIn, bool oneway,
399                            const string& declFile, int declLine);
400
401    bool            OneWay() const;
402
403    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
404                                    Variable* parcel, int flags);
405    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
406                                    Variable* parcel, Variable** cl);
407
408private:
409    bool m_oneway;
410};
411
412
413class GenericType : public Type
414{
415public:
416                    GenericType(const string& package, const string& name,
417                                 const vector<Type*>& args);
418
419    const vector<Type*>& GenericArgumentTypes() const;
420    string          GenericArguments() const;
421
422    virtual string  ImportType() const;
423
424    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
425                                    Variable* parcel, int flags);
426    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
427                                    Variable* parcel, Variable** cl);
428    virtual void    ReadFromParcel(StatementBlock* addTo, Variable* v,
429                                    Variable* parcel, Variable** cl);
430
431private:
432    string m_genericArguments;
433    string m_importName;
434    vector<Type*> m_args;
435};
436
437
438class GenericListType : public GenericType
439{
440public:
441                    GenericListType(const string& package, const string& name,
442                                 const vector<Type*>& args);
443
444    virtual string  CreatorName() const;
445    virtual string  InstantiableName() const;
446
447    virtual void    WriteToParcel(StatementBlock* addTo, Variable* v,
448                                    Variable* parcel, int flags);
449    virtual void    CreateFromParcel(StatementBlock* addTo, Variable* v,
450                                    Variable* parcel, Variable** cl);
451    virtual void    ReadFromParcel(StatementBlock* addTo, Variable* v,
452                                    Variable* parcel, Variable** cl);
453
454    virtual void    WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
455                                    Variable* data, int flags);
456    virtual void    CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
457                                    Variable* data, Variable** cl);
458
459private:
460    string m_creator;
461};
462
463class RpcDataType : public Type
464{
465public:
466                    RpcDataType();
467
468    virtual void    WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
469                                    Variable* data, int flags);
470    virtual void    CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
471                                    Variable* data, Variable** cl);
472};
473
474class ClassLoaderType : public Type
475{
476public:
477                    ClassLoaderType();
478};
479
480class Namespace
481{
482public:
483            Namespace();
484            ~Namespace();
485    void    Add(Type* type);
486
487    // args is the number of template types (what is this called?)
488    void    AddGenericType(const string& package, const string& name, int args);
489
490    // lookup a specific class name
491    Type*   Find(const string& name) const;
492    Type*   Find(const char* package, const char* name) const;
493
494    // try to search by either a full name or a partial name
495    Type*   Search(const string& name);
496
497    void    Dump() const;
498
499private:
500    struct Generic {
501        string package;
502        string name;
503        string qualified;
504        int args;
505    };
506
507    const Generic* search_generic(const string& name) const;
508
509    vector<Type*> m_types;
510    vector<Generic> m_generics;
511};
512
513extern Namespace NAMES;
514
515extern Type* VOID_TYPE;
516extern Type* BOOLEAN_TYPE;
517extern Type* BYTE_TYPE;
518extern Type* CHAR_TYPE;
519extern Type* INT_TYPE;
520extern Type* LONG_TYPE;
521extern Type* FLOAT_TYPE;
522extern Type* DOUBLE_TYPE;
523extern Type* OBJECT_TYPE;
524extern Type* STRING_TYPE;
525extern Type* CHAR_SEQUENCE_TYPE;
526extern Type* TEXT_UTILS_TYPE;
527extern Type* REMOTE_EXCEPTION_TYPE;
528extern Type* RUNTIME_EXCEPTION_TYPE;
529extern Type* IBINDER_TYPE;
530extern Type* IINTERFACE_TYPE;
531extern Type* BINDER_NATIVE_TYPE;
532extern Type* BINDER_PROXY_TYPE;
533extern Type* PARCEL_TYPE;
534extern Type* PARCELABLE_INTERFACE_TYPE;
535
536extern Type* CONTEXT_TYPE;
537
538extern Type* RPC_SERVICE_BASE_TYPE;
539extern Type* RPC_DATA_TYPE;
540extern Type* RPC_BROKER_TYPE;
541extern Type* RPC_ENDPOINT_INFO_TYPE;
542extern Type* RPC_RESULT_HANDLER_TYPE;
543extern Type* RPC_ERROR_TYPE;
544extern Type* RPC_ERROR_LISTENER_TYPE;
545
546extern Expression* NULL_VALUE;
547extern Expression* THIS_VALUE;
548extern Expression* SUPER_VALUE;
549extern Expression* TRUE_VALUE;
550extern Expression* FALSE_VALUE;
551
552void register_base_types();
553
554#endif // AIDL_TYPE_H
555