Home | History | Annotate | Download | only in aidl 
      1 #include "Type.h"
      2 
      3 #include <sys/types.h>
      4 
      5 Namespace NAMES;
      6 
      7 Type* VOID_TYPE;
      8 Type* BOOLEAN_TYPE;
      9 Type* BYTE_TYPE;
     10 Type* CHAR_TYPE;
     11 Type* INT_TYPE;
     12 Type* LONG_TYPE;
     13 Type* FLOAT_TYPE;
     14 Type* DOUBLE_TYPE;
     15 Type* STRING_TYPE;
     16 Type* OBJECT_TYPE;
     17 Type* CHAR_SEQUENCE_TYPE;
     18 Type* TEXT_UTILS_TYPE;
     19 Type* REMOTE_EXCEPTION_TYPE;
     20 Type* RUNTIME_EXCEPTION_TYPE;
     21 Type* IBINDER_TYPE;
     22 Type* IINTERFACE_TYPE;
     23 Type* BINDER_NATIVE_TYPE;
     24 Type* BINDER_PROXY_TYPE;
     25 Type* PARCEL_TYPE;
     26 Type* PARCELABLE_INTERFACE_TYPE;
     27 Type* CONTEXT_TYPE;
     28 Type* MAP_TYPE;
     29 Type* LIST_TYPE;
     30 Type* CLASSLOADER_TYPE;
     31 Type* RPC_DATA_TYPE;
     32 Type* RPC_ERROR_TYPE;
     33 Type* EVENT_FAKE_TYPE;
     34 
     35 Expression* NULL_VALUE;
     36 Expression* THIS_VALUE;
     37 Expression* SUPER_VALUE;
     38 Expression* TRUE_VALUE;
     39 Expression* FALSE_VALUE;
     40 
     41 void
     42 register_base_types()
     43 {
     44     VOID_TYPE = new BasicType("void",
     45             "XXX", "XXX", "XXX", "XXX", "XXX",
     46             "XXX", "XXX", "XXX", "XXX", "XXX");
     47     NAMES.Add(VOID_TYPE);
     48 
     49     BOOLEAN_TYPE = new BooleanType();
     50     NAMES.Add(BOOLEAN_TYPE);
     51 
     52     BYTE_TYPE = new BasicType("byte",
     53             "writeByte", "readByte", "writeByteArray", "createByteArray", "readByteArray",
     54             "putByte", "getByte", "putByteArray", "createByteArray", "getByteArray");
     55     NAMES.Add(BYTE_TYPE);
     56 
     57     CHAR_TYPE = new CharType();
     58     NAMES.Add(CHAR_TYPE);
     59 
     60     INT_TYPE = new BasicType("int",
     61             "writeInt", "readInt", "writeIntArray", "createIntArray", "readIntArray",
     62             "putInteger", "getInteger", "putIntegerArray", "createIntegerArray", "getIntegerArray");
     63     NAMES.Add(INT_TYPE);
     64 
     65     LONG_TYPE = new BasicType("long",
     66             "writeLong", "readLong", "writeLongArray", "createLongArray", "readLongArray",
     67             "putLong", "getLong", "putLongArray", "createLongArray", "getLongArray");
     68     NAMES.Add(LONG_TYPE);
     69 
     70     FLOAT_TYPE = new BasicType("float",
     71             "writeFloat", "readFloat", "writeFloatArray", "createFloatArray", "readFloatArray",
     72             "putFloat", "getFloat", "putFloatArray", "createFloatArray", "getFloatArray");
     73     NAMES.Add(FLOAT_TYPE);
     74 
     75     DOUBLE_TYPE = new BasicType("double",
     76             "writeDouble", "readDouble", "writeDoubleArray", "createDoubleArray", "readDoubleArray",
     77             "putDouble", "getDouble", "putDoubleArray", "createDoubleArray", "getDoubleArray");
     78     NAMES.Add(DOUBLE_TYPE);
     79 
     80     STRING_TYPE = new StringType();
     81     NAMES.Add(STRING_TYPE);
     82 
     83     OBJECT_TYPE = new Type("java.lang", "Object", Type::BUILT_IN, false, false, false);
     84     NAMES.Add(OBJECT_TYPE);
     85 
     86     CHAR_SEQUENCE_TYPE = new CharSequenceType();
     87     NAMES.Add(CHAR_SEQUENCE_TYPE);
     88 
     89     MAP_TYPE = new MapType();
     90     NAMES.Add(MAP_TYPE);
     91 
     92     LIST_TYPE = new ListType();
     93     NAMES.Add(LIST_TYPE);
     94 
     95     TEXT_UTILS_TYPE = new Type("android.text", "TextUtils", Type::BUILT_IN, false, false, false);
     96     NAMES.Add(TEXT_UTILS_TYPE);
     97 
     98     REMOTE_EXCEPTION_TYPE = new RemoteExceptionType();
     99     NAMES.Add(REMOTE_EXCEPTION_TYPE);
    100 
    101     RUNTIME_EXCEPTION_TYPE = new RuntimeExceptionType();
    102     NAMES.Add(RUNTIME_EXCEPTION_TYPE);
    103 
    104     IBINDER_TYPE = new IBinderType();
    105     NAMES.Add(IBINDER_TYPE);
    106 
    107     IINTERFACE_TYPE = new IInterfaceType();
    108     NAMES.Add(IINTERFACE_TYPE);
    109 
    110     BINDER_NATIVE_TYPE = new BinderType();
    111     NAMES.Add(BINDER_NATIVE_TYPE);
    112 
    113     BINDER_PROXY_TYPE = new BinderProxyType();
    114     NAMES.Add(BINDER_PROXY_TYPE);
    115 
    116     PARCEL_TYPE = new ParcelType();
    117     NAMES.Add(PARCEL_TYPE);
    118 
    119     PARCELABLE_INTERFACE_TYPE = new ParcelableInterfaceType();
    120     NAMES.Add(PARCELABLE_INTERFACE_TYPE);
    121 
    122     CONTEXT_TYPE = new Type("android.content", "Context", Type::BUILT_IN, false, false, false);
    123     NAMES.Add(CONTEXT_TYPE);
    124 
    125     RPC_DATA_TYPE = new RpcDataType();
    126     NAMES.Add(RPC_DATA_TYPE);
    127 
    128     RPC_ERROR_TYPE = new UserDataType("android.support.place.rpc", "RpcError",
    129                                     true, __FILE__, __LINE__);
    130     NAMES.Add(RPC_ERROR_TYPE);
    131 
    132     EVENT_FAKE_TYPE = new Type("event", Type::BUILT_IN, false, false, false);
    133     NAMES.Add(EVENT_FAKE_TYPE);
    134 
    135     CLASSLOADER_TYPE = new ClassLoaderType();
    136     NAMES.Add(CLASSLOADER_TYPE);
    137 
    138     NULL_VALUE = new LiteralExpression("null");
    139     THIS_VALUE = new LiteralExpression("this");
    140     SUPER_VALUE = new LiteralExpression("super");
    141     TRUE_VALUE = new LiteralExpression("true");
    142     FALSE_VALUE = new LiteralExpression("false");
    143 
    144     NAMES.AddGenericType("java.util", "List", 1);
    145     NAMES.AddGenericType("java.util", "Map", 2);
    146 }
    147 
    148 static Type*
    149 make_generic_type(const string& package, const string& name,
    150                     const vector<Type*>& args)
    151 {
    152     if (package == "java.util" && name == "List") {
    153         return new GenericListType("java.util", "List", args);
    154     }
    155     return NULL;
    156     //return new GenericType(package, name, args);
    157 }
    158 
    159 // ================================================================
    160 
    161 Type::Type(const string& name, int kind, bool canWriteToParcel, bool canWriteToRpcData,
    162         bool canBeOut)
    163     :m_package(),
    164      m_name(name),
    165      m_declFile(""),
    166      m_declLine(-1),
    167      m_kind(kind),
    168      m_canWriteToParcel(canWriteToParcel),
    169      m_canWriteToRpcData(canWriteToRpcData),
    170      m_canBeOut(canBeOut)
    171 {
    172     m_qualifiedName = name;
    173 }
    174 
    175 Type::Type(const string& package, const string& name,
    176             int kind, bool canWriteToParcel, bool canWriteToRpcData,
    177             bool canBeOut, const string& declFile, int declLine)
    178     :m_package(package),
    179      m_name(name),
    180      m_declFile(declFile),
    181      m_declLine(declLine),
    182      m_kind(kind),
    183      m_canWriteToParcel(canWriteToParcel),
    184      m_canWriteToRpcData(canWriteToRpcData),
    185      m_canBeOut(canBeOut)
    186 {
    187     if (package.length() > 0) {
    188         m_qualifiedName = package;
    189         m_qualifiedName += '.';
    190     }
    191     m_qualifiedName += name;
    192 }
    193 
    194 Type::~Type()
    195 {
    196 }
    197 
    198 bool
    199 Type::CanBeArray() const
    200 {
    201     return false;
    202 }
    203 
    204 string
    205 Type::ImportType() const
    206 {
    207     return m_qualifiedName;
    208 }
    209 
    210 string
    211 Type::CreatorName() const
    212 {
    213     return "";
    214 }
    215 
    216 string
    217 Type::RpcCreatorName() const
    218 {
    219     return "";
    220 }
    221 
    222 string
    223 Type::InstantiableName() const
    224 {
    225     return QualifiedName();
    226 }
    227 
    228 
    229 void
    230 Type::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    231 {
    232     fprintf(stderr, "aidl:internal error %s:%d qualifiedName=%sn",
    233             __FILE__, __LINE__, m_qualifiedName.c_str());
    234     addTo->Add(new LiteralExpression("/* WriteToParcel error "
    235                 + m_qualifiedName + " */"));
    236 }
    237 
    238 void
    239 Type::CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
    240 {
    241     fprintf(stderr, "aidl:internal error %s:%d qualifiedName=%s\n",
    242             __FILE__, __LINE__, m_qualifiedName.c_str());
    243     addTo->Add(new LiteralExpression("/* CreateFromParcel error "
    244                 + m_qualifiedName + " */"));
    245 }
    246 
    247 void
    248 Type::ReadFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
    249 {
    250     fprintf(stderr, "aidl:internal error %s:%d qualifiedName=%s\n",
    251             __FILE__, __LINE__, m_qualifiedName.c_str());
    252     addTo->Add(new LiteralExpression("/* ReadFromParcel error "
    253                 + m_qualifiedName + " */"));
    254 }
    255 
    256 void
    257 Type::WriteArrayToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    258 {
    259     fprintf(stderr, "aidl:internal error %s:%d qualifiedName=%s\n",
    260             __FILE__, __LINE__, m_qualifiedName.c_str());
    261     addTo->Add(new LiteralExpression("/* WriteArrayToParcel error "
    262                 + m_qualifiedName + " */"));
    263 }
    264 
    265 void
    266 Type::CreateArrayFromParcel(StatementBlock* addTo, Variable* v,
    267                             Variable* parcel, Variable**)
    268 {
    269     fprintf(stderr, "aidl:internal error %s:%d qualifiedName=%s\n",
    270             __FILE__, __LINE__, m_qualifiedName.c_str());
    271     addTo->Add(new LiteralExpression("/* CreateArrayFromParcel error "
    272                 + m_qualifiedName + " */"));
    273 }
    274 
    275 void
    276 Type::ReadArrayFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
    277 {
    278     fprintf(stderr, "aidl:internal error %s:%d qualifiedName=%s\n",
    279             __FILE__, __LINE__, m_qualifiedName.c_str());
    280     addTo->Add(new LiteralExpression("/* ReadArrayFromParcel error "
    281                 + m_qualifiedName + " */"));
    282 }
    283 
    284 void
    285 Type::WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
    286         Variable* data, int flags)
    287 {
    288     fprintf(stderr, "aidl:internal error %s:%d qualifiedName=%s\n",
    289             __FILE__, __LINE__, m_qualifiedName.c_str());
    290     addTo->Add(new LiteralExpression("/* WriteToRpcData error "
    291                 + m_qualifiedName + " */"));
    292 }
    293 
    294 void
    295 Type::CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v, Variable* data,
    296         Variable** cl)
    297 {
    298     fprintf(stderr, "aidl:internal error %s:%d qualifiedName=%s\n",
    299             __FILE__, __LINE__, m_qualifiedName.c_str());
    300     addTo->Add(new LiteralExpression("/* ReadFromRpcData error "
    301                 + m_qualifiedName + " */"));
    302 }
    303 
    304 void
    305 Type::SetQualifiedName(const string& qualified)
    306 {
    307     m_qualifiedName = qualified;
    308 }
    309 
    310 Expression*
    311 Type::BuildWriteToParcelFlags(int flags)
    312 {
    313     if (flags == 0) {
    314         return new LiteralExpression("0");
    315     }
    316     if ((flags&PARCELABLE_WRITE_RETURN_VALUE) != 0) {
    317         return new FieldVariable(PARCELABLE_INTERFACE_TYPE,
    318                 "PARCELABLE_WRITE_RETURN_VALUE");
    319     }
    320     return new LiteralExpression("0");
    321 }
    322 
    323 // ================================================================
    324 
    325 BasicType::BasicType(const string& name, const string& marshallParcel,
    326           const string& unmarshallParcel, const string& writeArrayParcel,
    327           const string& createArrayParcel, const string& readArrayParcel,
    328           const string& marshallRpc, const string& unmarshallRpc,
    329           const string& writeArrayRpc, const string& createArrayRpc, const string& readArrayRpc)
    330     :Type(name, BUILT_IN, true, true, false),
    331      m_marshallParcel(marshallParcel),
    332      m_unmarshallParcel(unmarshallParcel),
    333      m_writeArrayParcel(writeArrayParcel),
    334      m_createArrayParcel(createArrayParcel),
    335      m_readArrayParcel(readArrayParcel),
    336      m_marshallRpc(marshallRpc),
    337      m_unmarshallRpc(unmarshallRpc),
    338      m_writeArrayRpc(writeArrayRpc),
    339      m_createArrayRpc(createArrayRpc),
    340      m_readArrayRpc(readArrayRpc)
    341 {
    342 }
    343 
    344 void
    345 BasicType::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    346 {
    347     addTo->Add(new MethodCall(parcel, m_marshallParcel, 1, v));
    348 }
    349 
    350 void
    351 BasicType::CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
    352 {
    353     addTo->Add(new Assignment(v, new MethodCall(parcel, m_unmarshallParcel)));
    354 }
    355 
    356 bool
    357 BasicType::CanBeArray() const
    358 {
    359     return true;
    360 }
    361 
    362 void
    363 BasicType::WriteArrayToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    364 {
    365     addTo->Add(new MethodCall(parcel, m_writeArrayParcel, 1, v));
    366 }
    367 
    368 void
    369 BasicType::CreateArrayFromParcel(StatementBlock* addTo, Variable* v,
    370                             Variable* parcel, Variable**)
    371 {
    372     addTo->Add(new Assignment(v, new MethodCall(parcel, m_createArrayParcel)));
    373 }
    374 
    375 void
    376 BasicType::ReadArrayFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
    377 {
    378     addTo->Add(new MethodCall(parcel, m_readArrayParcel, 1, v));
    379 }
    380 
    381 void
    382 BasicType::WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
    383         Variable* data, int flags)
    384 {
    385     addTo->Add(new MethodCall(data, m_marshallRpc, 2, k, v));
    386 }
    387 
    388 void
    389 BasicType::CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v, Variable* data,
    390         Variable** cl)
    391 {
    392     addTo->Add(new Assignment(v, new MethodCall(data, m_unmarshallRpc, 1, k)));
    393 }
    394 
    395 // ================================================================
    396 
    397 BooleanType::BooleanType()
    398     :Type("boolean", BUILT_IN, true, true, false)
    399 {
    400 }
    401 
    402 void
    403 BooleanType::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    404 {
    405     addTo->Add(new MethodCall(parcel, "writeInt", 1,
    406                 new Ternary(v, new LiteralExpression("1"),
    407                     new LiteralExpression("0"))));
    408 }
    409 
    410 void
    411 BooleanType::CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
    412 {
    413     addTo->Add(new Assignment(v, new Comparison(new LiteralExpression("0"),
    414                     "!=", new MethodCall(parcel, "readInt"))));
    415 }
    416 
    417 bool
    418 BooleanType::CanBeArray() const
    419 {
    420     return true;
    421 }
    422 
    423 void
    424 BooleanType::WriteArrayToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    425 {
    426     addTo->Add(new MethodCall(parcel, "writeBooleanArray", 1, v));
    427 }
    428 
    429 void
    430 BooleanType::CreateArrayFromParcel(StatementBlock* addTo, Variable* v,
    431                             Variable* parcel, Variable**)
    432 {
    433     addTo->Add(new Assignment(v, new MethodCall(parcel, "createBooleanArray")));
    434 }
    435 
    436 void
    437 BooleanType::ReadArrayFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
    438 {
    439     addTo->Add(new MethodCall(parcel, "readBooleanArray", 1, v));
    440 }
    441 
    442 void
    443 BooleanType::WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
    444         Variable* data, int flags)
    445 {
    446     addTo->Add(new MethodCall(data, "putBoolean", 2, k, v));
    447 }
    448 
    449 void
    450 BooleanType::CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v, Variable* data,
    451         Variable** cl)
    452 {
    453     addTo->Add(new Assignment(v, new MethodCall(data, "getBoolean", 1, k)));
    454 }
    455 
    456 // ================================================================
    457 
    458 CharType::CharType()
    459     :Type("char", BUILT_IN, true, true, false)
    460 {
    461 }
    462 
    463 void
    464 CharType::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    465 {
    466     addTo->Add(new MethodCall(parcel, "writeInt", 1,
    467                     new Cast(INT_TYPE, v)));
    468 }
    469 
    470 void
    471 CharType::CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
    472 {
    473     addTo->Add(new Assignment(v, new MethodCall(parcel, "readInt"), this));
    474 }
    475 
    476 bool
    477 CharType::CanBeArray() const
    478 {
    479     return true;
    480 }
    481 
    482 void
    483 CharType::WriteArrayToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    484 {
    485     addTo->Add(new MethodCall(parcel, "writeCharArray", 1, v));
    486 }
    487 
    488 void
    489 CharType::CreateArrayFromParcel(StatementBlock* addTo, Variable* v,
    490                             Variable* parcel, Variable**)
    491 {
    492     addTo->Add(new Assignment(v, new MethodCall(parcel, "createCharArray")));
    493 }
    494 
    495 void
    496 CharType::ReadArrayFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
    497 {
    498     addTo->Add(new MethodCall(parcel, "readCharArray", 1, v));
    499 }
    500 
    501 void
    502 CharType::WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
    503         Variable* data, int flags)
    504 {
    505     addTo->Add(new MethodCall(data, "putChar", 2, k, v));
    506 }
    507 
    508 void
    509 CharType::CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v, Variable* data,
    510         Variable** cl)
    511 {
    512     addTo->Add(new Assignment(v, new MethodCall(data, "getChar", 1, k)));
    513 }
    514 
    515 // ================================================================
    516 
    517 StringType::StringType()
    518     :Type("java.lang", "String", BUILT_IN, true, true, false)
    519 {
    520 }
    521 
    522 string
    523 StringType::CreatorName() const
    524 {
    525     return "android.os.Parcel.STRING_CREATOR";
    526 }
    527 
    528 void
    529 StringType::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    530 {
    531     addTo->Add(new MethodCall(parcel, "writeString", 1, v));
    532 }
    533 
    534 void
    535 StringType::CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
    536 {
    537     addTo->Add(new Assignment(v, new MethodCall(parcel, "readString")));
    538 }
    539 
    540 bool
    541 StringType::CanBeArray() const
    542 {
    543     return true;
    544 }
    545 
    546 void
    547 StringType::WriteArrayToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    548 {
    549     addTo->Add(new MethodCall(parcel, "writeStringArray", 1, v));
    550 }
    551 
    552 void
    553 StringType::CreateArrayFromParcel(StatementBlock* addTo, Variable* v,
    554                             Variable* parcel, Variable**)
    555 {
    556     addTo->Add(new Assignment(v, new MethodCall(parcel, "createStringArray")));
    557 }
    558 
    559 void
    560 StringType::ReadArrayFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
    561 {
    562     addTo->Add(new MethodCall(parcel, "readStringArray", 1, v));
    563 }
    564 
    565 void
    566 StringType::WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
    567         Variable* data, int flags)
    568 {
    569     addTo->Add(new MethodCall(data, "putString", 2, k, v));
    570 }
    571 
    572 void
    573 StringType::CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
    574         Variable* data, Variable**)
    575 {
    576     addTo->Add(new Assignment(v, new MethodCall(data, "getString", 1, k)));
    577 }
    578 
    579 // ================================================================
    580 
    581 CharSequenceType::CharSequenceType()
    582     :Type("java.lang", "CharSequence", BUILT_IN, true, true, false)
    583 {
    584 }
    585 
    586 string
    587 CharSequenceType::CreatorName() const
    588 {
    589     return "android.os.Parcel.STRING_CREATOR";
    590 }
    591 
    592 void
    593 CharSequenceType::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    594 {
    595     // if (v != null) {
    596     //     parcel.writeInt(1);
    597     //     v.writeToParcel(parcel);
    598     // } else {
    599     //     parcel.writeInt(0);
    600     // }
    601     IfStatement* elsepart = new IfStatement();
    602     elsepart->statements->Add(new MethodCall(parcel, "writeInt", 1,
    603                                 new LiteralExpression("0")));
    604     IfStatement* ifpart = new IfStatement;
    605     ifpart->expression = new Comparison(v, "!=", NULL_VALUE);
    606     ifpart->elseif = elsepart;
    607     ifpart->statements->Add(new MethodCall(parcel, "writeInt", 1,
    608                                 new LiteralExpression("1")));
    609     ifpart->statements->Add(new MethodCall(TEXT_UTILS_TYPE, "writeToParcel",
    610                                 3, v, parcel, BuildWriteToParcelFlags(flags)));
    611 
    612     addTo->Add(ifpart);
    613 }
    614 
    615 void
    616 CharSequenceType::CreateFromParcel(StatementBlock* addTo, Variable* v,
    617                                 Variable* parcel, Variable**)
    618 {
    619     // if (0 != parcel.readInt()) {
    620     //     v = TextUtils.createFromParcel(parcel)
    621     // } else {
    622     //     v = null;
    623     // }
    624     IfStatement* elsepart = new IfStatement();
    625     elsepart->statements->Add(new Assignment(v, NULL_VALUE));
    626 
    627     IfStatement* ifpart = new IfStatement();
    628     ifpart->expression = new Comparison(new LiteralExpression("0"), "!=",
    629                 new MethodCall(parcel, "readInt"));
    630     ifpart->elseif = elsepart;
    631     ifpart->statements->Add(new Assignment(v,
    632                 new MethodCall(TEXT_UTILS_TYPE,
    633                                     "CHAR_SEQUENCE_CREATOR.createFromParcel", 1, parcel)));
    634 
    635     addTo->Add(ifpart);
    636 }
    637 
    638 
    639 // ================================================================
    640 
    641 RemoteExceptionType::RemoteExceptionType()
    642     :Type("android.os", "RemoteException", BUILT_IN, false, false, false)
    643 {
    644 }
    645 
    646 void
    647 RemoteExceptionType::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    648 {
    649     fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
    650 }
    651 
    652 void
    653 RemoteExceptionType::CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
    654 {
    655     fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
    656 }
    657 
    658 // ================================================================
    659 
    660 RuntimeExceptionType::RuntimeExceptionType()
    661     :Type("java.lang", "RuntimeException", BUILT_IN, false, false, false)
    662 {
    663 }
    664 
    665 void
    666 RuntimeExceptionType::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    667 {
    668     fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
    669 }
    670 
    671 void
    672 RuntimeExceptionType::CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
    673 {
    674     fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
    675 }
    676 
    677 
    678 // ================================================================
    679 
    680 IBinderType::IBinderType()
    681     :Type("android.os", "IBinder", BUILT_IN, true, false, false)
    682 {
    683 }
    684 
    685 void
    686 IBinderType::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    687 {
    688     addTo->Add(new MethodCall(parcel, "writeStrongBinder", 1, v));
    689 }
    690 
    691 void
    692 IBinderType::CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
    693 {
    694     addTo->Add(new Assignment(v, new MethodCall(parcel, "readStrongBinder")));
    695 }
    696 
    697 void
    698 IBinderType::WriteArrayToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    699 {
    700     addTo->Add(new MethodCall(parcel, "writeBinderArray", 1, v));
    701 }
    702 
    703 void
    704 IBinderType::CreateArrayFromParcel(StatementBlock* addTo, Variable* v,
    705                             Variable* parcel, Variable**)
    706 {
    707     addTo->Add(new Assignment(v, new MethodCall(parcel, "createBinderArray")));
    708 }
    709 
    710 void
    711 IBinderType::ReadArrayFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
    712 {
    713     addTo->Add(new MethodCall(parcel, "readBinderArray", 1, v));
    714 }
    715 
    716 
    717 // ================================================================
    718 
    719 IInterfaceType::IInterfaceType()
    720     :Type("android.os", "IInterface", BUILT_IN, false, false, false)
    721 {
    722 }
    723 
    724 void
    725 IInterfaceType::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    726 {
    727     fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
    728 }
    729 
    730 void
    731 IInterfaceType::CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
    732 {
    733     fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
    734 }
    735 
    736 
    737 // ================================================================
    738 
    739 BinderType::BinderType()
    740     :Type("android.os", "Binder", BUILT_IN, false, false, false)
    741 {
    742 }
    743 
    744 void
    745 BinderType::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    746 {
    747     fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
    748 }
    749 
    750 void
    751 BinderType::CreateFromParcel(StatementBlock* addTo, Variable* v,
    752                                     Variable* parcel, Variable**)
    753 {
    754     fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
    755 }
    756 
    757 
    758 // ================================================================
    759 
    760 BinderProxyType::BinderProxyType()
    761     :Type("android.os", "BinderProxy", BUILT_IN, false, false, false)
    762 {
    763 }
    764 
    765 void
    766 BinderProxyType::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    767 {
    768     fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
    769 }
    770 
    771 void
    772 BinderProxyType::CreateFromParcel(StatementBlock* addTo, Variable* v,
    773                                     Variable* parcel, Variable**)
    774 {
    775     fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
    776 }
    777 
    778 
    779 // ================================================================
    780 
    781 ParcelType::ParcelType()
    782     :Type("android.os", "Parcel", BUILT_IN, false, false, false)
    783 {
    784 }
    785 
    786 void
    787 ParcelType::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    788 {
    789     fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
    790 }
    791 
    792 void
    793 ParcelType::CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
    794 {
    795     fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
    796 }
    797 
    798 // ================================================================
    799 
    800 ParcelableInterfaceType::ParcelableInterfaceType()
    801     :Type("android.os", "Parcelable", BUILT_IN, false, false, false)
    802 {
    803 }
    804 
    805 void
    806 ParcelableInterfaceType::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    807 {
    808     fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
    809 }
    810 
    811 void
    812 ParcelableInterfaceType::CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
    813 {
    814     fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
    815 }
    816 
    817 // ================================================================
    818 
    819 MapType::MapType()
    820     :Type("java.util", "Map", BUILT_IN, true, false, true)
    821 {
    822 }
    823 
    824 void
    825 MapType::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    826 {
    827     addTo->Add(new MethodCall(parcel, "writeMap", 1, v));
    828 }
    829 
    830 static void EnsureClassLoader(StatementBlock* addTo, Variable** cl)
    831 {
    832     // We don't want to look up the class loader once for every
    833     // collection argument, so ensure we do it at most once per method.
    834     if (*cl == NULL) {
    835         *cl = new Variable(CLASSLOADER_TYPE, "cl");
    836         addTo->Add(new VariableDeclaration(*cl,
    837                 new LiteralExpression("this.getClass().getClassLoader()"),
    838                 CLASSLOADER_TYPE));
    839     }
    840 }
    841 
    842 void
    843 MapType::CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable** cl)
    844 {
    845     EnsureClassLoader(addTo, cl);
    846     addTo->Add(new Assignment(v, new MethodCall(parcel, "readHashMap", 1, *cl)));
    847 }
    848 
    849 void
    850 MapType::ReadFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable** cl)
    851 {
    852     EnsureClassLoader(addTo, cl);
    853     addTo->Add(new MethodCall(parcel, "readMap", 2, v, *cl));
    854 }
    855 
    856 
    857 // ================================================================
    858 
    859 ListType::ListType()
    860     :Type("java.util", "List", BUILT_IN, true, true, true)
    861 {
    862 }
    863 
    864 string
    865 ListType::InstantiableName() const
    866 {
    867     return "java.util.ArrayList";
    868 }
    869 
    870 void
    871 ListType::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    872 {
    873     addTo->Add(new MethodCall(parcel, "writeList", 1, v));
    874 }
    875 
    876 void
    877 ListType::CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable** cl)
    878 {
    879     EnsureClassLoader(addTo, cl);
    880     addTo->Add(new Assignment(v, new MethodCall(parcel, "readArrayList", 1, *cl)));
    881 }
    882 
    883 void
    884 ListType::ReadFromParcel(StatementBlock* addTo, Variable* v,
    885                     Variable* parcel, Variable** cl)
    886 {
    887     EnsureClassLoader(addTo, cl);
    888     addTo->Add(new MethodCall(parcel, "readList", 2, v, *cl));
    889 }
    890 
    891 void
    892 ListType::WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
    893         Variable* data, int flags)
    894 {
    895     addTo->Add(new MethodCall(data, "putList", 2, k, v));
    896 }
    897 
    898 void
    899 ListType::CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v, Variable* data,
    900         Variable** cl)
    901 {
    902     addTo->Add(new Assignment(v, new MethodCall(data, "getList", 1, k)));
    903 }
    904 
    905 // ================================================================
    906 
    907 UserDataType::UserDataType(const string& package, const string& name,
    908                         bool builtIn, bool canWriteToParcel, bool canWriteToRpcData,
    909                         const string& declFile, int declLine)
    910     :Type(package, name, builtIn ? BUILT_IN : USERDATA, canWriteToParcel, canWriteToRpcData,
    911             true, declFile, declLine)
    912 {
    913 }
    914 
    915 string
    916 UserDataType::CreatorName() const
    917 {
    918     return QualifiedName() + ".CREATOR";
    919 }
    920 
    921 string
    922 UserDataType::RpcCreatorName() const
    923 {
    924     return QualifiedName() + ".RPC_CREATOR";
    925 }
    926 
    927 void
    928 UserDataType::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    929 {
    930     // if (v != null) {
    931     //     parcel.writeInt(1);
    932     //     v.writeToParcel(parcel);
    933     // } else {
    934     //     parcel.writeInt(0);
    935     // }
    936     IfStatement* elsepart = new IfStatement();
    937     elsepart->statements->Add(new MethodCall(parcel, "writeInt", 1,
    938                                 new LiteralExpression("0")));
    939     IfStatement* ifpart = new IfStatement;
    940     ifpart->expression = new Comparison(v, "!=", NULL_VALUE);
    941     ifpart->elseif = elsepart;
    942     ifpart->statements->Add(new MethodCall(parcel, "writeInt", 1,
    943                                 new LiteralExpression("1")));
    944     ifpart->statements->Add(new MethodCall(v, "writeToParcel", 2,
    945                                 parcel, BuildWriteToParcelFlags(flags)));
    946 
    947     addTo->Add(ifpart);
    948 }
    949 
    950 void
    951 UserDataType::CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
    952 {
    953     // if (0 != parcel.readInt()) {
    954     //     v = CLASS.CREATOR.createFromParcel(parcel)
    955     // } else {
    956     //     v = null;
    957     // }
    958     IfStatement* elsepart = new IfStatement();
    959     elsepart->statements->Add(new Assignment(v, NULL_VALUE));
    960 
    961     IfStatement* ifpart = new IfStatement();
    962     ifpart->expression = new Comparison(new LiteralExpression("0"), "!=",
    963                 new MethodCall(parcel, "readInt"));
    964     ifpart->elseif = elsepart;
    965     ifpart->statements->Add(new Assignment(v,
    966                 new MethodCall(v->type, "CREATOR.createFromParcel", 1, parcel)));
    967 
    968     addTo->Add(ifpart);
    969 }
    970 
    971 void
    972 UserDataType::ReadFromParcel(StatementBlock* addTo, Variable* v,
    973                     Variable* parcel, Variable**)
    974 {
    975     // TODO: really, we don't need to have this extra check, but we
    976     // don't have two separate marshalling code paths
    977     // if (0 != parcel.readInt()) {
    978     //     v.readFromParcel(parcel)
    979     // }
    980     IfStatement* ifpart = new IfStatement();
    981     ifpart->expression = new Comparison(new LiteralExpression("0"), "!=",
    982                 new MethodCall(parcel, "readInt"));
    983     ifpart->statements->Add(new MethodCall(v, "readFromParcel", 1, parcel));
    984     addTo->Add(ifpart);
    985 }
    986 
    987 bool
    988 UserDataType::CanBeArray() const
    989 {
    990     return true;
    991 }
    992 
    993 void
    994 UserDataType::WriteArrayToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
    995 {
    996     addTo->Add(new MethodCall(parcel, "writeTypedArray", 2, v,
    997                 BuildWriteToParcelFlags(flags)));
    998 }
    999 
   1000 void
   1001 UserDataType::CreateArrayFromParcel(StatementBlock* addTo, Variable* v,
   1002                             Variable* parcel, Variable**)
   1003 {
   1004     string creator = v->type->QualifiedName() + ".CREATOR";
   1005     addTo->Add(new Assignment(v, new MethodCall(parcel,
   1006                 "createTypedArray", 1, new LiteralExpression(creator))));
   1007 }
   1008 
   1009 void
   1010 UserDataType::ReadArrayFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
   1011 {
   1012     string creator = v->type->QualifiedName() + ".CREATOR";
   1013     addTo->Add(new MethodCall(parcel, "readTypedArray", 2,
   1014                     v, new LiteralExpression(creator)));
   1015 }
   1016 
   1017 void
   1018 UserDataType::WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
   1019                                     Variable* data, int flags)
   1020 {
   1021     // data.putFlattenable(k, v);
   1022     addTo->Add(new MethodCall(data, "putFlattenable", 2, k, v));
   1023 }
   1024 
   1025 void
   1026 UserDataType::CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
   1027                                     Variable* data, Variable** cl)
   1028 {
   1029     // data.getFlattenable(k, CLASS.RPC_CREATOR);
   1030     addTo->Add(new Assignment(v, new MethodCall(data, "getFlattenable", 2, k,
   1031                 new FieldVariable(v->type, "RPC_CREATOR"))));
   1032 }
   1033 
   1034 // ================================================================
   1035 
   1036 InterfaceType::InterfaceType(const string& package, const string& name,
   1037                         bool builtIn, bool oneway,
   1038                         const string& declFile, int declLine)
   1039     :Type(package, name, builtIn ? BUILT_IN : INTERFACE, true, false, false,
   1040                         declFile, declLine)
   1041     ,m_oneway(oneway)
   1042 {
   1043 }
   1044 
   1045 bool
   1046 InterfaceType::OneWay() const
   1047 {
   1048     return m_oneway;
   1049 }
   1050 
   1051 void
   1052 InterfaceType::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
   1053 {
   1054     // parcel.writeStrongBinder(v != null ? v.asBinder() : null);
   1055     addTo->Add(new MethodCall(parcel, "writeStrongBinder", 1,
   1056                 new Ternary(
   1057                     new Comparison(v, "!=", NULL_VALUE),
   1058                     new MethodCall(v, "asBinder"),
   1059                     NULL_VALUE)));
   1060 }
   1061 
   1062 void
   1063 InterfaceType::CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
   1064 {
   1065     // v = Interface.asInterface(parcel.readStrongBinder());
   1066     string type = v->type->QualifiedName();
   1067     type += ".Stub";
   1068     addTo->Add(new Assignment(v,
   1069                 new MethodCall( NAMES.Find(type), "asInterface", 1,
   1070                     new MethodCall(parcel, "readStrongBinder"))));
   1071 }
   1072 
   1073 
   1074 // ================================================================
   1075 
   1076 GenericType::GenericType(const string& package, const string& name,
   1077                          const vector<Type*>& args)
   1078     :Type(package, name, BUILT_IN, true, true, true)
   1079 {
   1080     m_args = args;
   1081 
   1082     m_importName = package + '.' + name;
   1083 
   1084     string gen = "<";
   1085     int N = args.size();
   1086     for (int i=0; i<N; i++) {
   1087         Type* t = args[i];
   1088         gen += t->QualifiedName();
   1089         if (i != N-1) {
   1090             gen += ',';
   1091         }
   1092     }
   1093     gen += '>';
   1094     m_genericArguments = gen;
   1095     SetQualifiedName(m_importName + gen);
   1096 }
   1097 
   1098 const vector<Type*>&
   1099 GenericType::GenericArgumentTypes() const
   1100 {
   1101     return m_args;
   1102 }
   1103 
   1104 string
   1105 GenericType::GenericArguments() const
   1106 {
   1107     return m_genericArguments;
   1108 }
   1109 
   1110 string
   1111 GenericType::ImportType() const
   1112 {
   1113     return m_importName;
   1114 }
   1115 
   1116 void
   1117 GenericType::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
   1118 {
   1119     fprintf(stderr, "implement GenericType::WriteToParcel\n");
   1120 }
   1121 
   1122 void
   1123 GenericType::CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
   1124 {
   1125     fprintf(stderr, "implement GenericType::CreateFromParcel\n");
   1126 }
   1127 
   1128 void
   1129 GenericType::ReadFromParcel(StatementBlock* addTo, Variable* v,
   1130                             Variable* parcel, Variable**)
   1131 {
   1132     fprintf(stderr, "implement GenericType::ReadFromParcel\n");
   1133 }
   1134 
   1135 
   1136 // ================================================================
   1137 
   1138 GenericListType::GenericListType(const string& package, const string& name,
   1139                          const vector<Type*>& args)
   1140     :GenericType(package, name, args),
   1141      m_creator(args[0]->CreatorName())
   1142 {
   1143 }
   1144 
   1145 string
   1146 GenericListType::CreatorName() const
   1147 {
   1148     return "android.os.Parcel.arrayListCreator";
   1149 }
   1150 
   1151 string
   1152 GenericListType::InstantiableName() const
   1153 {
   1154     return "java.util.ArrayList" + GenericArguments();
   1155 }
   1156 
   1157 void
   1158 GenericListType::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
   1159 {
   1160     if (m_creator == STRING_TYPE->CreatorName()) {
   1161         addTo->Add(new MethodCall(parcel, "writeStringList", 1, v));
   1162     } else if (m_creator == IBINDER_TYPE->CreatorName()) {
   1163         addTo->Add(new MethodCall(parcel, "writeBinderList", 1, v));
   1164     } else {
   1165         // parcel.writeTypedListXX(arg);
   1166         addTo->Add(new MethodCall(parcel, "writeTypedList", 1, v));
   1167     }
   1168 }
   1169 
   1170 void
   1171 GenericListType::CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
   1172 {
   1173     if (m_creator == STRING_TYPE->CreatorName()) {
   1174         addTo->Add(new Assignment(v,
   1175                    new MethodCall(parcel, "createStringArrayList", 0)));
   1176     } else if (m_creator == IBINDER_TYPE->CreatorName()) {
   1177         addTo->Add(new Assignment(v,
   1178                    new MethodCall(parcel, "createBinderArrayList", 0)));
   1179     } else {
   1180         // v = _data.readTypedArrayList(XXX.creator);
   1181         addTo->Add(new Assignment(v,
   1182                    new MethodCall(parcel, "createTypedArrayList", 1,
   1183                    new LiteralExpression(m_creator))));
   1184     }
   1185 }
   1186 
   1187 void
   1188 GenericListType::ReadFromParcel(StatementBlock* addTo, Variable* v,
   1189                             Variable* parcel, Variable**)
   1190 {
   1191     if (m_creator == STRING_TYPE->CreatorName()) {
   1192         addTo->Add(new MethodCall(parcel, "readStringList", 1, v));
   1193     } else if (m_creator == IBINDER_TYPE->CreatorName()) {
   1194         addTo->Add(new MethodCall(parcel, "readBinderList", 1, v));
   1195     } else {
   1196         // v = _data.readTypedList(v, XXX.creator);
   1197         addTo->Add(new MethodCall(parcel, "readTypedList", 2,
   1198                        v,
   1199                        new LiteralExpression(m_creator)));
   1200     }
   1201 }
   1202 
   1203 void
   1204 GenericListType::WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
   1205         Variable* data, int flags)
   1206 {
   1207     Type* generic = GenericArgumentTypes()[0];
   1208     if (generic == RPC_DATA_TYPE) {
   1209         addTo->Add(new MethodCall(data, "putRpcDataList", 2, k, v));
   1210     } else if (generic->RpcCreatorName() != "") {
   1211         addTo->Add(new MethodCall(data, "putFlattenableList", 2, k, v));
   1212     } else {
   1213         addTo->Add(new MethodCall(data, "putList", 2, k, v));
   1214     }
   1215 }
   1216 
   1217 void
   1218 GenericListType::CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
   1219         Variable* data, Variable** cl)
   1220 {
   1221     Type* generic = GenericArgumentTypes()[0];
   1222     if (generic == RPC_DATA_TYPE) {
   1223         addTo->Add(new Assignment(v, new MethodCall(data, "getRpcDataList", 2, k)));
   1224     } else if (generic->RpcCreatorName() != "") {
   1225         addTo->Add(new Assignment(v, new MethodCall(data, "getFlattenableList", 2, k,
   1226                         new LiteralExpression(generic->RpcCreatorName()))));
   1227     } else {
   1228         string classArg = GenericArgumentTypes()[0]->QualifiedName();
   1229         classArg += ".class";
   1230         addTo->Add(new Assignment(v, new MethodCall(data, "getList", 2, k,
   1231                         new LiteralExpression(classArg))));
   1232     }
   1233 }
   1234 
   1235 
   1236 // ================================================================
   1237 
   1238 RpcDataType::RpcDataType()
   1239     :UserDataType("android.support.place.rpc", "RpcData", true, true, true)
   1240 {
   1241 }
   1242 
   1243 void
   1244 RpcDataType::WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
   1245         Variable* data, int flags)
   1246 {
   1247     addTo->Add(new MethodCall(data, "putRpcData", 2, k, v));
   1248 }
   1249 
   1250 void
   1251 RpcDataType::CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v, Variable* data,
   1252         Variable** cl)
   1253 {
   1254     addTo->Add(new Assignment(v, new MethodCall(data, "getRpcData", 1, k)));
   1255 }
   1256 
   1257 
   1258 // ================================================================
   1259 
   1260 ClassLoaderType::ClassLoaderType()
   1261     :Type("java.lang", "ClassLoader", BUILT_IN, false, false, false)
   1262 {
   1263 }
   1264 
   1265 
   1266 // ================================================================
   1267 
   1268 Namespace::Namespace()
   1269 {
   1270 }
   1271 
   1272 Namespace::~Namespace()
   1273 {
   1274     int N = m_types.size();
   1275     for (int i=0; i<N; i++) {
   1276         delete m_types[i];
   1277     }
   1278 }
   1279 
   1280 void
   1281 Namespace::Add(Type* type)
   1282 {
   1283     Type* t = Find(type->QualifiedName());
   1284     if (t == NULL) {
   1285         m_types.push_back(type);
   1286     }
   1287 }
   1288 
   1289 void
   1290 Namespace::AddGenericType(const string& package, const string& name, int args)
   1291 {
   1292     Generic g;
   1293         g.package = package;
   1294         g.name = name;
   1295         g.qualified = package + '.' + name;
   1296         g.args = args;
   1297     m_generics.push_back(g);
   1298 }
   1299 
   1300 Type*
   1301 Namespace::Find(const string& name) const
   1302 {
   1303     int N = m_types.size();
   1304     for (int i=0; i<N; i++) {
   1305         if (m_types[i]->QualifiedName() == name) {
   1306             return m_types[i];
   1307         }
   1308     }
   1309     return NULL;
   1310 }
   1311 
   1312 Type*
   1313 Namespace::Find(const char* package, const char* name) const
   1314 {
   1315     string s;
   1316     if (package != NULL) {
   1317         s += package;
   1318         s += '.';
   1319     }
   1320     s += name;
   1321     return Find(s);
   1322 }
   1323 
   1324 static string
   1325 normalize_generic(const string& s)
   1326 {
   1327     string r;
   1328     int N = s.size();
   1329     for (int i=0; i<N; i++) {
   1330         char c = s[i];
   1331         if (!isspace(c)) {
   1332             r += c;
   1333         }
   1334     }
   1335     return r;
   1336 }
   1337 
   1338 Type*
   1339 Namespace::Search(const string& name)
   1340 {
   1341     // an exact match wins
   1342     Type* result = Find(name);
   1343     if (result != NULL) {
   1344         return result;
   1345     }
   1346 
   1347     // try the class names
   1348     // our language doesn't allow you to not specify outer classes
   1349     // when referencing an inner class.  that could be changed, and this
   1350     // would be the place to do it, but I don't think the complexity in
   1351     // scoping rules is worth it.
   1352     int N = m_types.size();
   1353     for (int i=0; i<N; i++) {
   1354         if (m_types[i]->Name() == name) {
   1355             return m_types[i];
   1356         }
   1357     }
   1358 
   1359     // we got to here and it's not a generic, give up
   1360     if (name.find('<') == name.npos) {
   1361         return NULL;
   1362     }
   1363 
   1364     // remove any whitespace
   1365     string normalized = normalize_generic(name);
   1366 
   1367     // find the part before the '<', find a generic for it
   1368     ssize_t baseIndex = normalized.find('<');
   1369     string base(normalized.c_str(), baseIndex);
   1370     const Generic* g = search_generic(base);
   1371     if (g == NULL) {
   1372         return NULL;
   1373     }
   1374 
   1375     // For each of the args, do a recursive search on it.  We don't allow
   1376     // generics within generics like Java does, because we're really limiting
   1377     // them to just built-in container classes, at least for now.  Our syntax
   1378     // ensures this right now as well.
   1379     vector<Type*> args;
   1380     size_t start = baseIndex + 1;
   1381     size_t end = start;
   1382     while (normalized[start] != '\0') {
   1383         end = normalized.find(',', start);
   1384         if (end == normalized.npos) {
   1385             end = normalized.find('>', start);
   1386         }
   1387         string s(normalized.c_str()+start, end-start);
   1388         Type* t = this->Search(s);
   1389         if (t == NULL) {
   1390             // maybe we should print a warning here?
   1391             return NULL;
   1392         }
   1393         args.push_back(t);
   1394         start = end+1;
   1395     }
   1396 
   1397     // construct a GenericType, add it to our name set so they always get
   1398     // the same object, and return it.
   1399     result = make_generic_type(g->package, g->name, args);
   1400     if (result == NULL) {
   1401         return NULL;
   1402     }
   1403 
   1404     this->Add(result);
   1405     return this->Find(result->QualifiedName());
   1406 }
   1407 
   1408 const Namespace::Generic*
   1409 Namespace::search_generic(const string& name) const
   1410 {
   1411     int N = m_generics.size();
   1412 
   1413     // first exact match
   1414     for (int i=0; i<N; i++) {
   1415         const Generic& g = m_generics[i];
   1416         if (g.qualified == name) {
   1417             return &g;
   1418         }
   1419     }
   1420 
   1421     // then name match
   1422     for (int i=0; i<N; i++) {
   1423         const Generic& g = m_generics[i];
   1424         if (g.name == name) {
   1425             return &g;
   1426         }
   1427     }
   1428 
   1429     return NULL;
   1430 }
   1431 
   1432 void
   1433 Namespace::Dump() const
   1434 {
   1435     int n = m_types.size();
   1436     for (int i=0; i<n; i++) {
   1437         Type* t = m_types[i];
   1438         printf("type: package=%s name=%s qualifiedName=%s\n",
   1439                 t->Package().c_str(), t->Name().c_str(),
   1440                 t->QualifiedName().c_str());
   1441     }
   1442 }
   1443