Home | History | Annotate | Download | only in aidl 
      1 /*
      2  * Copyright (C) 2015, The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *     http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include "generate_cpp.h"
     18 
     19 #include <cctype>
     20 #include <cstring>
     21 #include <memory>
     22 #include <random>
     23 #include <set>
     24 #include <string>
     25 
     26 #include <android-base/stringprintf.h>
     27 
     28 #include "aidl_language.h"
     29 #include "ast_cpp.h"
     30 #include "code_writer.h"
     31 #include "logging.h"
     32 #include "os.h"
     33 
     34 using android::base::StringPrintf;
     35 using std::string;
     36 using std::unique_ptr;
     37 using std::vector;
     38 using std::set;
     39 
     40 namespace android {
     41 namespace aidl {
     42 namespace cpp {
     43 namespace internals {
     44 namespace {
     45 
     46 const char kAndroidStatusVarName[] = "_aidl_ret_status";
     47 const char kCodeVarName[] = "_aidl_code";
     48 const char kFlagsVarName[] = "_aidl_flags";
     49 const char kDataVarName[] = "_aidl_data";
     50 const char kErrorLabel[] = "_aidl_error";
     51 const char kImplVarName[] = "_aidl_impl";
     52 const char kReplyVarName[] = "_aidl_reply";
     53 const char kReturnVarName[] = "_aidl_return";
     54 const char kStatusVarName[] = "_aidl_status";
     55 const char kAndroidParcelLiteral[] = "::android::Parcel";
     56 const char kAndroidStatusLiteral[] = "::android::status_t";
     57 const char kAndroidStatusOk[] = "::android::OK";
     58 const char kBinderStatusLiteral[] = "::android::binder::Status";
     59 const char kIBinderHeader[] = "binder/IBinder.h";
     60 const char kIInterfaceHeader[] = "binder/IInterface.h";
     61 const char kParcelHeader[] = "binder/Parcel.h";
     62 const char kStatusHeader[] = "binder/Status.h";
     63 const char kStrongPointerHeader[] = "utils/StrongPointer.h";
     64 
     65 unique_ptr<AstNode> BreakOnStatusNotOk() {
     66   IfStatement* ret = new IfStatement(new Comparison(
     67       new LiteralExpression(kAndroidStatusVarName), "!=",
     68       new LiteralExpression(kAndroidStatusOk)));
     69   ret->OnTrue()->AddLiteral("break");
     70   return unique_ptr<AstNode>(ret);
     71 }
     72 
     73 unique_ptr<AstNode> GotoErrorOnBadStatus() {
     74   IfStatement* ret = new IfStatement(new Comparison(
     75       new LiteralExpression(kAndroidStatusVarName), "!=",
     76       new LiteralExpression(kAndroidStatusOk)));
     77   ret->OnTrue()->AddLiteral(StringPrintf("goto %s", kErrorLabel));
     78   return unique_ptr<AstNode>(ret);
     79 }
     80 
     81 
     82 unique_ptr<AstNode> ReturnOnStatusNotOk() {
     83   IfStatement* ret = new IfStatement(new Comparison(
     84       new LiteralExpression(kAndroidStatusVarName), "!=",
     85       new LiteralExpression(kAndroidStatusOk)));
     86   ret->OnTrue()->AddLiteral(StringPrintf("return %s", kAndroidStatusVarName));
     87   return unique_ptr<AstNode>(ret);
     88 }
     89 
     90 string UpperCase(const std::string& s) {
     91   string result = s;
     92   for (char& c : result)
     93     c = toupper(c);
     94   return result;
     95 }
     96 
     97 string BuildVarName(const AidlArgument& a) {
     98   string prefix = "out_";
     99   if (a.GetDirection() & AidlArgument::IN_DIR) {
    100     prefix = "in_";
    101   }
    102   return prefix + a.GetName();
    103 }
    104 
    105 ArgList BuildArgList(const TypeNamespace& types,
    106                      const AidlMethod& method,
    107                      bool for_declaration) {
    108   // Build up the argument list for the server method call.
    109   vector<string> method_arguments;
    110   for (const unique_ptr<AidlArgument>& a : method.GetArguments()) {
    111     string literal;
    112     if (for_declaration) {
    113       // Method declarations need types, pointers to out params, and variable
    114       // names that match the .aidl specification.
    115       const Type* type = a->GetType().GetLanguageType<Type>();
    116 
    117       literal = type->CppType();
    118 
    119       if (a->IsOut()) {
    120         literal = literal + "*";
    121       } else {
    122         // We pass in parameters that are not primitives by const reference.
    123         // Arrays of primitives are not primitives.
    124         if (!type->IsCppPrimitive() || a->GetType().IsArray()) {
    125           literal = "const " + literal + "&";
    126         }
    127       }
    128 
    129       literal += " " + a->GetName();
    130     } else {
    131       if (a->IsOut()) { literal = "&"; }
    132       literal += BuildVarName(*a);
    133     }
    134     method_arguments.push_back(literal);
    135   }
    136 
    137   const Type* return_type = method.GetType().GetLanguageType<Type>();
    138 
    139   if (return_type != types.VoidType()) {
    140     string literal;
    141     if (for_declaration) {
    142       literal = StringPrintf(
    143           "%s* %s", return_type->CppType().c_str(),
    144           kReturnVarName);
    145     } else {
    146       literal = string{"&"} + kReturnVarName;
    147     }
    148     method_arguments.push_back(literal);
    149   }
    150 
    151   return ArgList(method_arguments);
    152 }
    153 
    154 unique_ptr<Declaration> BuildMethodDecl(const AidlMethod& method,
    155                                         const TypeNamespace& types,
    156                                         bool for_interface) {
    157   uint32_t modifiers = 0;
    158   if (for_interface) {
    159     modifiers |= MethodDecl::IS_VIRTUAL;
    160     modifiers |= MethodDecl::IS_PURE_VIRTUAL;
    161   } else {
    162     modifiers |= MethodDecl::IS_OVERRIDE;
    163   }
    164 
    165   return unique_ptr<Declaration>{
    166       new MethodDecl{kBinderStatusLiteral,
    167                      method.GetName(),
    168                      BuildArgList(types, method, true /* for method decl */),
    169                      modifiers}};
    170 }
    171 
    172 unique_ptr<CppNamespace> NestInNamespaces(
    173     vector<unique_ptr<Declaration>> decls,
    174     const vector<string>& package) {
    175   if (package.empty()) {
    176     // We should also be checking this before we get this far, but do it again
    177     // for the sake of unit tests and meaningful errors.
    178     LOG(FATAL) << "C++ generation requires a package declaration "
    179                   "for namespacing";
    180   }
    181   auto it = package.crbegin();  // Iterate over the namespaces inner to outer
    182   unique_ptr<CppNamespace> inner{new CppNamespace{*it, std::move(decls)}};
    183   ++it;
    184   for (; it != package.crend(); ++it) {
    185     inner.reset(new CppNamespace{*it, std::move(inner)});
    186   }
    187   return inner;
    188 }
    189 
    190 unique_ptr<CppNamespace> NestInNamespaces(unique_ptr<Declaration> decl,
    191                                           const vector<string>& package) {
    192   vector<unique_ptr<Declaration>> decls;
    193   decls.push_back(std::move(decl));
    194   return NestInNamespaces(std::move(decls), package);
    195 }
    196 
    197 bool DeclareLocalVariable(const TypeNamespace& types, const AidlArgument& a,
    198                           StatementBlock* b) {
    199   const Type* cpp_type = a.GetType().GetLanguageType<Type>();
    200   if (!cpp_type) { return false; }
    201 
    202   string type = cpp_type->CppType();
    203 
    204   b->AddLiteral(type + " " + BuildVarName(a));
    205   return true;
    206 }
    207 
    208 string ClassName(const AidlInterface& interface, ClassNames type) {
    209   string c_name = interface.GetName();
    210 
    211   if (c_name.length() >= 2 && c_name[0] == 'I' && isupper(c_name[1]))
    212     c_name = c_name.substr(1);
    213 
    214   switch (type) {
    215     case ClassNames::CLIENT:
    216       c_name = "Bp" + c_name;
    217       break;
    218     case ClassNames::SERVER:
    219       c_name = "Bn" + c_name;
    220       break;
    221     case ClassNames::INTERFACE:
    222       c_name = "I" + c_name;
    223       break;
    224     case ClassNames::BASE:
    225       break;
    226   }
    227   return c_name;
    228 }
    229 
    230 string BuildHeaderGuard(const AidlInterface& interface,
    231                         ClassNames header_type) {
    232   string class_name = ClassName(interface, header_type);
    233   for (size_t i = 1; i < class_name.size(); ++i) {
    234     if (isupper(class_name[i])) {
    235       class_name.insert(i, "_");
    236       ++i;
    237     }
    238   }
    239   string ret = StringPrintf("AIDL_GENERATED_%s_%s_H_",
    240                             interface.GetPackage().c_str(),
    241                             class_name.c_str());
    242   for (char& c : ret) {
    243     if (c == '.') {
    244       c = '_';
    245     }
    246     c = toupper(c);
    247   }
    248   return ret;
    249 }
    250 
    251 unique_ptr<Declaration> DefineClientTransaction(const TypeNamespace& types,
    252                                                 const AidlInterface& interface,
    253                                                 const AidlMethod& method) {
    254   const string i_name = ClassName(interface, ClassNames::INTERFACE);
    255   const string bp_name = ClassName(interface, ClassNames::CLIENT);
    256   unique_ptr<MethodImpl> ret{new MethodImpl{
    257       kBinderStatusLiteral, bp_name, method.GetName(),
    258       ArgList{BuildArgList(types, method, true /* for method decl */)}}};
    259   StatementBlock* b = ret->GetStatementBlock();
    260 
    261   // Declare parcels to hold our query and the response.
    262   b->AddLiteral(StringPrintf("%s %s", kAndroidParcelLiteral, kDataVarName));
    263   // Even if we're oneway, the transact method still takes a parcel.
    264   b->AddLiteral(StringPrintf("%s %s", kAndroidParcelLiteral, kReplyVarName));
    265 
    266   // Declare the status_t variable we need for error handling.
    267   b->AddLiteral(StringPrintf("%s %s = %s", kAndroidStatusLiteral,
    268                              kAndroidStatusVarName,
    269                              kAndroidStatusOk));
    270   // We unconditionally return a Status object.
    271   b->AddLiteral(StringPrintf("%s %s", kBinderStatusLiteral, kStatusVarName));
    272 
    273   // Add the name of the interface we're hoping to call.
    274   b->AddStatement(new Assignment(
    275       kAndroidStatusVarName,
    276       new MethodCall(StringPrintf("%s.writeInterfaceToken",
    277                                   kDataVarName),
    278                      "getInterfaceDescriptor()")));
    279   b->AddStatement(GotoErrorOnBadStatus());
    280 
    281   // Serialization looks roughly like:
    282   //     _aidl_ret_status = _aidl_data.WriteInt32(in_param_name);
    283   //     if (_aidl_ret_status != ::android::OK) { goto error; }
    284   for (const AidlArgument* a : method.GetInArguments()) {
    285     const Type* type = a->GetType().GetLanguageType<Type>();
    286     string method = type->WriteToParcelMethod();
    287 
    288     string var_name = ((a->IsOut()) ? "*" : "") + a->GetName();
    289     var_name = type->WriteCast(var_name);
    290     b->AddStatement(new Assignment(
    291         kAndroidStatusVarName,
    292         new MethodCall(StringPrintf("%s.%s", kDataVarName, method.c_str()),
    293                        ArgList(var_name))));
    294     b->AddStatement(GotoErrorOnBadStatus());
    295   }
    296 
    297   // Invoke the transaction on the remote binder and confirm status.
    298   string transaction_code = StringPrintf(
    299       "%s::%s", i_name.c_str(), UpperCase(method.GetName()).c_str());
    300 
    301   vector<string> args = {transaction_code, kDataVarName,
    302                          StringPrintf("&%s", kReplyVarName)};
    303 
    304   if (interface.IsOneway() || method.IsOneway()) {
    305     args.push_back("::android::IBinder::FLAG_ONEWAY");
    306   }
    307 
    308   b->AddStatement(new Assignment(
    309       kAndroidStatusVarName,
    310       new MethodCall("remote()->transact",
    311                      ArgList(args))));
    312   b->AddStatement(GotoErrorOnBadStatus());
    313 
    314   if (!interface.IsOneway() && !method.IsOneway()) {
    315     // Strip off the exception header and fail if we see a remote exception.
    316     // _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
    317     // if (_aidl_ret_status != ::android::OK) { goto error; }
    318     // if (!_aidl_status.isOk()) { return _aidl_ret_status; }
    319     b->AddStatement(new Assignment(
    320         kAndroidStatusVarName,
    321         StringPrintf("%s.readFromParcel(%s)", kStatusVarName, kReplyVarName)));
    322     b->AddStatement(GotoErrorOnBadStatus());
    323     IfStatement* exception_check = new IfStatement(
    324         new LiteralExpression(StringPrintf("!%s.isOk()", kStatusVarName)));
    325     b->AddStatement(exception_check);
    326     exception_check->OnTrue()->AddLiteral(
    327         StringPrintf("return %s", kStatusVarName));
    328   }
    329 
    330   // Type checking should guarantee that nothing below emits code until "return
    331   // status" if we are a oneway method, so no more fear of accessing reply.
    332 
    333   // If the method is expected to return something, read it first by convention.
    334   const Type* return_type = method.GetType().GetLanguageType<Type>();
    335   if (return_type != types.VoidType()) {
    336     string method_call = return_type->ReadFromParcelMethod();
    337     b->AddStatement(new Assignment(
    338         kAndroidStatusVarName,
    339         new MethodCall(StringPrintf("%s.%s", kReplyVarName,
    340                                     method_call.c_str()),
    341                        ArgList(kReturnVarName))));
    342     b->AddStatement(GotoErrorOnBadStatus());
    343   }
    344 
    345   for (const AidlArgument* a : method.GetOutArguments()) {
    346     // Deserialization looks roughly like:
    347     //     _aidl_ret_status = _aidl_reply.ReadInt32(out_param_name);
    348     //     if (_aidl_status != ::android::OK) { goto _aidl_error; }
    349     string method =
    350       a->GetType().GetLanguageType<Type>()->ReadFromParcelMethod();
    351 
    352     b->AddStatement(new Assignment(
    353         kAndroidStatusVarName,
    354         new MethodCall(StringPrintf("%s.%s", kReplyVarName,
    355                                     method.c_str()),
    356                        ArgList(a->GetName()))));
    357     b->AddStatement(GotoErrorOnBadStatus());
    358   }
    359 
    360   // If we've gotten to here, one of two things is true:
    361   //   1) We've read some bad status_t
    362   //   2) We've only read status_t == OK and there was no exception in the
    363   //      response.
    364   // In both cases, we're free to set Status from the status_t and return.
    365   b->AddLiteral(StringPrintf("%s:\n", kErrorLabel), false /* no semicolon */);
    366   b->AddLiteral(
    367       StringPrintf("%s.setFromStatusT(%s)", kStatusVarName,
    368                    kAndroidStatusVarName));
    369   b->AddLiteral(StringPrintf("return %s", kStatusVarName));
    370 
    371   return unique_ptr<Declaration>(ret.release());
    372 }
    373 
    374 }  // namespace
    375 
    376 unique_ptr<Document> BuildClientSource(const TypeNamespace& types,
    377                                        const AidlInterface& interface) {
    378   vector<string> include_list = {
    379       HeaderFile(interface, ClassNames::CLIENT, false),
    380       kParcelHeader
    381   };
    382   vector<unique_ptr<Declaration>> file_decls;
    383 
    384   // The constructor just passes the IBinder instance up to the super
    385   // class.
    386   const string i_name = ClassName(interface, ClassNames::INTERFACE);
    387   file_decls.push_back(unique_ptr<Declaration>{new ConstructorImpl{
    388       ClassName(interface, ClassNames::CLIENT),
    389       ArgList{StringPrintf("const ::android::sp<::android::IBinder>& %s",
    390                            kImplVarName)},
    391       { "BpInterface<" + i_name + ">(" + kImplVarName + ")" }}});
    392 
    393   // Clients define a method per transaction.
    394   for (const auto& method : interface.GetMethods()) {
    395     unique_ptr<Declaration> m = DefineClientTransaction(
    396         types, interface, *method);
    397     if (!m) { return nullptr; }
    398     file_decls.push_back(std::move(m));
    399   }
    400   return unique_ptr<Document>{new CppSource{
    401       include_list,
    402       NestInNamespaces(std::move(file_decls), interface.GetSplitPackage())}};
    403 }
    404 
    405 namespace {
    406 
    407 bool HandleServerTransaction(const TypeNamespace& types,
    408                              const AidlMethod& method,
    409                              StatementBlock* b) {
    410   // Declare all the parameters now.  In the common case, we expect no errors
    411   // in serialization.
    412   for (const unique_ptr<AidlArgument>& a : method.GetArguments()) {
    413     if (!DeclareLocalVariable(types, *a, b)) { return false; }
    414   }
    415 
    416   // Declare a variable to hold the return value.
    417   const Type* return_type = method.GetType().GetLanguageType<Type>();
    418   if (return_type != types.VoidType()) {
    419     b->AddLiteral(StringPrintf(
    420         "%s %s", return_type->CppType().c_str(),
    421         kReturnVarName));
    422   }
    423 
    424   // Check that the client is calling the correct interface.
    425   IfStatement* interface_check = new IfStatement(
    426       new MethodCall(StringPrintf("%s.checkInterface",
    427                                   kDataVarName), "this"),
    428       true /* invert the check */);
    429   b->AddStatement(interface_check);
    430   interface_check->OnTrue()->AddStatement(
    431       new Assignment(kAndroidStatusVarName, "::android::BAD_TYPE"));
    432   interface_check->OnTrue()->AddLiteral("break");
    433 
    434   // Deserialize each "in" parameter to the transaction.
    435   for (const AidlArgument* a : method.GetInArguments()) {
    436     // Deserialization looks roughly like:
    437     //     _aidl_ret_status = _aidl_data.ReadInt32(&in_param_name);
    438     //     if (_aidl_ret_status != ::android::OK) { break; }
    439     const Type* type = a->GetType().GetLanguageType<Type>();
    440     string readMethod = type->ReadFromParcelMethod();
    441 
    442     b->AddStatement(new Assignment{
    443         kAndroidStatusVarName,
    444         new MethodCall{string(kDataVarName) + "." + readMethod,
    445                        "&" + BuildVarName(*a)}});
    446     b->AddStatement(BreakOnStatusNotOk());
    447   }
    448 
    449   // Call the actual method.  This is implemented by the subclass.
    450   vector<unique_ptr<AstNode>> status_args;
    451   status_args.emplace_back(new MethodCall(
    452           method.GetName(),
    453           BuildArgList(types, method, false /* not for method decl */)));
    454   b->AddStatement(new Statement(new MethodCall(
    455       StringPrintf("%s %s", kBinderStatusLiteral, kStatusVarName),
    456       ArgList(std::move(status_args)))));
    457 
    458   // Write exceptions during transaction handling to parcel.
    459   if (!method.IsOneway()) {
    460     b->AddStatement(new Assignment(
    461         kAndroidStatusVarName,
    462         StringPrintf("%s.writeToParcel(%s)", kStatusVarName, kReplyVarName)));
    463     b->AddStatement(BreakOnStatusNotOk());
    464     IfStatement* exception_check = new IfStatement(
    465         new LiteralExpression(StringPrintf("!%s.isOk()", kStatusVarName)));
    466     b->AddStatement(exception_check);
    467     exception_check->OnTrue()->AddLiteral("break");
    468   }
    469 
    470   // If we have a return value, write it first.
    471   if (return_type != types.VoidType()) {
    472     string writeMethod =
    473         string(kReplyVarName) + "->" +
    474         return_type->WriteToParcelMethod();
    475     b->AddStatement(new Assignment{
    476         kAndroidStatusVarName, new MethodCall{writeMethod,
    477         ArgList{return_type->WriteCast(kReturnVarName)}}});
    478     b->AddStatement(BreakOnStatusNotOk());
    479   }
    480 
    481   // Write each out parameter to the reply parcel.
    482   for (const AidlArgument* a : method.GetOutArguments()) {
    483     // Serialization looks roughly like:
    484     //     _aidl_ret_status = data.WriteInt32(out_param_name);
    485     //     if (_aidl_ret_status != ::android::OK) { break; }
    486     const Type* type = a->GetType().GetLanguageType<Type>();
    487     string writeMethod = type->WriteToParcelMethod();
    488 
    489     b->AddStatement(new Assignment{
    490         kAndroidStatusVarName,
    491         new MethodCall{string(kReplyVarName) + "->" + writeMethod,
    492                        type->WriteCast(BuildVarName(*a))}});
    493     b->AddStatement(BreakOnStatusNotOk());
    494   }
    495 
    496   return true;
    497 }
    498 
    499 }  // namespace
    500 
    501 unique_ptr<Document> BuildServerSource(const TypeNamespace& types,
    502                                        const AidlInterface& interface) {
    503   const string bn_name = ClassName(interface, ClassNames::SERVER);
    504   vector<string> include_list{
    505       HeaderFile(interface, ClassNames::SERVER, false),
    506       kParcelHeader
    507   };
    508   unique_ptr<MethodImpl> on_transact{new MethodImpl{
    509       kAndroidStatusLiteral, bn_name, "onTransact",
    510       ArgList{{StringPrintf("uint32_t %s", kCodeVarName),
    511                StringPrintf("const %s& %s", kAndroidParcelLiteral,
    512                             kDataVarName),
    513                StringPrintf("%s* %s", kAndroidParcelLiteral, kReplyVarName),
    514                StringPrintf("uint32_t %s", kFlagsVarName)}}
    515       }};
    516 
    517   // Declare the status_t variable
    518   on_transact->GetStatementBlock()->AddLiteral(
    519       StringPrintf("%s %s = %s", kAndroidStatusLiteral, kAndroidStatusVarName,
    520                    kAndroidStatusOk));
    521 
    522   // Add the all important switch statement, but retain a pointer to it.
    523   SwitchStatement* s = new SwitchStatement{kCodeVarName};
    524   on_transact->GetStatementBlock()->AddStatement(s);
    525 
    526   // The switch statement has a case statement for each transaction code.
    527   for (const auto& method : interface.GetMethods()) {
    528     StatementBlock* b = s->AddCase("Call::" + UpperCase(method->GetName()));
    529     if (!b) { return nullptr; }
    530 
    531     if (!HandleServerTransaction(types, *method, b)) { return nullptr; }
    532   }
    533 
    534   // The switch statement has a default case which defers to the super class.
    535   // The superclass handles a few pre-defined transactions.
    536   StatementBlock* b = s->AddCase("");
    537   b->AddLiteral(StringPrintf(
    538                 "%s = ::android::BBinder::onTransact(%s, %s, "
    539                 "%s, %s)", kAndroidStatusVarName, kCodeVarName,
    540                 kDataVarName, kReplyVarName, kFlagsVarName));
    541 
    542   // If we saw a null reference, we can map that to an appropriate exception.
    543   IfStatement* null_check = new IfStatement(
    544       new LiteralExpression(string(kAndroidStatusVarName) +
    545                             " == ::android::UNEXPECTED_NULL"));
    546   on_transact->GetStatementBlock()->AddStatement(null_check);
    547   null_check->OnTrue()->AddStatement(new Assignment(
    548       kAndroidStatusVarName,
    549       StringPrintf("%s::fromExceptionCode(%s::EX_NULL_POINTER)"
    550                    ".writeToParcel(%s)",
    551                    kBinderStatusLiteral, kBinderStatusLiteral,
    552                    kReplyVarName)));
    553 
    554   // Finally, the server's onTransact method just returns a status code.
    555   on_transact->GetStatementBlock()->AddLiteral(
    556       StringPrintf("return %s", kAndroidStatusVarName));
    557 
    558   return unique_ptr<Document>{new CppSource{
    559       include_list,
    560       NestInNamespaces(std::move(on_transact), interface.GetSplitPackage())}};
    561 }
    562 
    563 unique_ptr<Document> BuildInterfaceSource(const TypeNamespace& /* types */,
    564                                           const AidlInterface& interface) {
    565   vector<string> include_list{
    566       HeaderFile(interface, ClassNames::INTERFACE, false),
    567       HeaderFile(interface, ClassNames::CLIENT, false),
    568   };
    569 
    570   string fq_name = ClassName(interface, ClassNames::INTERFACE);
    571   if (!interface.GetPackage().empty()) {
    572     fq_name = interface.GetPackage() + "." + fq_name;
    573   }
    574 
    575   unique_ptr<ConstructorDecl> meta_if{new ConstructorDecl{
    576       "IMPLEMENT_META_INTERFACE",
    577       ArgList{vector<string>{ClassName(interface, ClassNames::BASE),
    578                              '"' + fq_name + '"'}}}};
    579 
    580   return unique_ptr<Document>{new CppSource{
    581       include_list,
    582       NestInNamespaces(std::move(meta_if), interface.GetSplitPackage())}};
    583 }
    584 
    585 unique_ptr<Document> BuildClientHeader(const TypeNamespace& types,
    586                                        const AidlInterface& interface) {
    587   const string i_name = ClassName(interface, ClassNames::INTERFACE);
    588   const string bp_name = ClassName(interface, ClassNames::CLIENT);
    589 
    590   unique_ptr<ConstructorDecl> constructor{new ConstructorDecl{
    591       bp_name,
    592       ArgList{StringPrintf("const ::android::sp<::android::IBinder>& %s",
    593                            kImplVarName)},
    594       ConstructorDecl::IS_EXPLICIT
    595   }};
    596   unique_ptr<ConstructorDecl> destructor{new ConstructorDecl{
    597       "~" + bp_name,
    598       ArgList{},
    599       ConstructorDecl::IS_VIRTUAL | ConstructorDecl::IS_DEFAULT}};
    600 
    601   vector<unique_ptr<Declaration>> publics;
    602   publics.push_back(std::move(constructor));
    603   publics.push_back(std::move(destructor));
    604 
    605   for (const auto& method: interface.GetMethods()) {
    606     publics.push_back(BuildMethodDecl(*method, types, false));
    607   }
    608 
    609   unique_ptr<ClassDecl> bp_class{
    610       new ClassDecl{bp_name,
    611                     "::android::BpInterface<" + i_name + ">",
    612                     std::move(publics),
    613                     {}
    614       }};
    615 
    616   return unique_ptr<Document>{new CppHeader{
    617       BuildHeaderGuard(interface, ClassNames::CLIENT),
    618       {kIBinderHeader,
    619        kIInterfaceHeader,
    620        "utils/Errors.h",
    621        HeaderFile(interface, ClassNames::INTERFACE, false)},
    622       NestInNamespaces(std::move(bp_class), interface.GetSplitPackage())}};
    623 }
    624 
    625 unique_ptr<Document> BuildServerHeader(const TypeNamespace& /* types */,
    626                                        const AidlInterface& interface) {
    627   const string i_name = ClassName(interface, ClassNames::INTERFACE);
    628   const string bn_name = ClassName(interface, ClassNames::SERVER);
    629 
    630   unique_ptr<Declaration> on_transact{new MethodDecl{
    631       kAndroidStatusLiteral, "onTransact",
    632       ArgList{{StringPrintf("uint32_t %s", kCodeVarName),
    633                StringPrintf("const %s& %s", kAndroidParcelLiteral,
    634                             kDataVarName),
    635                StringPrintf("%s* %s", kAndroidParcelLiteral, kReplyVarName),
    636                StringPrintf("uint32_t %s = 0", kFlagsVarName)}},
    637       MethodDecl::IS_OVERRIDE
    638   }};
    639 
    640   std::vector<unique_ptr<Declaration>> publics;
    641   publics.push_back(std::move(on_transact));
    642 
    643   unique_ptr<ClassDecl> bn_class{
    644       new ClassDecl{bn_name,
    645                     "::android::BnInterface<" + i_name + ">",
    646                     std::move(publics),
    647                     {}
    648       }};
    649 
    650   return unique_ptr<Document>{new CppHeader{
    651       BuildHeaderGuard(interface, ClassNames::SERVER),
    652       {"binder/IInterface.h",
    653        HeaderFile(interface, ClassNames::INTERFACE, false)},
    654       NestInNamespaces(std::move(bn_class), interface.GetSplitPackage())}};
    655 }
    656 
    657 unique_ptr<Document> BuildInterfaceHeader(const TypeNamespace& types,
    658                                           const AidlInterface& interface) {
    659   set<string> includes = { kIBinderHeader, kIInterfaceHeader,
    660                            kStatusHeader, kStrongPointerHeader };
    661 
    662   for (const auto& method : interface.GetMethods()) {
    663     for (const auto& argument : method->GetArguments()) {
    664       const Type* type = argument->GetType().GetLanguageType<Type>();
    665       type->GetHeaders(&includes);
    666     }
    667 
    668     const Type* return_type = method->GetType().GetLanguageType<Type>();
    669     return_type->GetHeaders(&includes);
    670   }
    671 
    672   unique_ptr<ClassDecl> if_class{
    673       new ClassDecl{ClassName(interface, ClassNames::INTERFACE),
    674                     "::android::IInterface"}};
    675   if_class->AddPublic(unique_ptr<Declaration>{new ConstructorDecl{
    676       "DECLARE_META_INTERFACE",
    677       ArgList{vector<string>{ClassName(interface, ClassNames::BASE)}}}});
    678 
    679   unique_ptr<Enum> constant_enum{new Enum{"", "int32_t"}};
    680   for (const auto& constant : interface.GetConstants()) {
    681     constant_enum->AddValue(
    682         constant->GetName(), std::to_string(constant->GetValue()));
    683   }
    684   if (constant_enum->HasValues()) {
    685     if_class->AddPublic(std::move(constant_enum));
    686   }
    687 
    688   unique_ptr<Enum> call_enum{new Enum{"Call"}};
    689   for (const auto& method : interface.GetMethods()) {
    690     // Each method gets an enum entry and pure virtual declaration.
    691     if_class->AddPublic(BuildMethodDecl(*method, types, true));
    692     call_enum->AddValue(
    693         UpperCase(method->GetName()),
    694         StringPrintf("::android::IBinder::FIRST_CALL_TRANSACTION + %d",
    695                      method->GetId()));
    696   }
    697   if_class->AddPublic(std::move(call_enum));
    698 
    699   return unique_ptr<Document>{new CppHeader{
    700       BuildHeaderGuard(interface, ClassNames::INTERFACE),
    701       vector<string>(includes.begin(), includes.end()),
    702       NestInNamespaces(std::move(if_class), interface.GetSplitPackage())}};
    703 }
    704 
    705 bool WriteHeader(const CppOptions& options,
    706                  const TypeNamespace& types,
    707                  const AidlInterface& interface,
    708                  const IoDelegate& io_delegate,
    709                  ClassNames header_type) {
    710   unique_ptr<Document> header;
    711   switch (header_type) {
    712     case ClassNames::INTERFACE:
    713       header = BuildInterfaceHeader(types, interface);
    714       break;
    715     case ClassNames::CLIENT:
    716       header = BuildClientHeader(types, interface);
    717       break;
    718     case ClassNames::SERVER:
    719       header = BuildServerHeader(types, interface);
    720       break;
    721     default:
    722       LOG(FATAL) << "aidl internal error";
    723   }
    724   if (!header) {
    725     LOG(ERROR) << "aidl internal error: Failed to generate header.";
    726     return false;
    727   }
    728 
    729   const string header_path = options.OutputHeaderDir() + OS_PATH_SEPARATOR +
    730                              HeaderFile(interface, header_type);
    731   unique_ptr<CodeWriter> code_writer(io_delegate.GetCodeWriter(header_path));
    732   header->Write(code_writer.get());
    733 
    734   const bool success = code_writer->Close();
    735   if (!success) {
    736     io_delegate.RemovePath(header_path);
    737   }
    738 
    739   return success;
    740 }
    741 
    742 }  // namespace internals
    743 
    744 using namespace internals;
    745 
    746 string HeaderFile(const AidlInterface& interface,
    747                   ClassNames class_type,
    748                   bool use_os_sep) {
    749   string file_path = interface.GetPackage();
    750   for (char& c: file_path) {
    751     if (c == '.') {
    752       c = (use_os_sep) ? OS_PATH_SEPARATOR : '/';
    753     }
    754   }
    755   if (!file_path.empty()) {
    756     file_path += (use_os_sep) ? OS_PATH_SEPARATOR : '/';
    757   }
    758   file_path += ClassName(interface, class_type);
    759   file_path += ".h";
    760 
    761   return file_path;
    762 }
    763 
    764 bool GenerateCpp(const CppOptions& options,
    765                  const TypeNamespace& types,
    766                  const AidlInterface& interface,
    767                  const IoDelegate& io_delegate) {
    768   auto interface_src = BuildInterfaceSource(types, interface);
    769   auto client_src = BuildClientSource(types, interface);
    770   auto server_src = BuildServerSource(types, interface);
    771 
    772   if (!interface_src || !client_src || !server_src) {
    773     return false;
    774   }
    775 
    776   if (!io_delegate.CreatedNestedDirs(options.OutputHeaderDir(),
    777                                      interface.GetSplitPackage())) {
    778     LOG(ERROR) << "Failed to create directory structure for headers.";
    779     return false;
    780   }
    781 
    782   if (!WriteHeader(options, types, interface, io_delegate,
    783                    ClassNames::INTERFACE) ||
    784       !WriteHeader(options, types, interface, io_delegate,
    785                    ClassNames::CLIENT) ||
    786       !WriteHeader(options, types, interface, io_delegate,
    787                    ClassNames::SERVER)) {
    788     return false;
    789   }
    790 
    791   unique_ptr<CodeWriter> writer = io_delegate.GetCodeWriter(
    792       options.OutputCppFilePath());
    793   interface_src->Write(writer.get());
    794   client_src->Write(writer.get());
    795   server_src->Write(writer.get());
    796 
    797   const bool success = writer->Close();
    798   if (!success) {
    799     io_delegate.RemovePath(options.OutputCppFilePath());
    800   }
    801 
    802   return success;
    803 }
    804 
    805 }  // namespace cpp
    806 }  // namespace aidl
    807 }  // namespace android
    808