Convert document item structs to classes
This is the least-complete first run for any of these structs, but this
shift is going to be particularly gnarly, so we need to be
extra-incremental about it.
Change-Id: I7295add8b9a1291f229743f8c36d941569a16ab6
Test: unit tests
Bug: 24410295
Signed-off-by: Casey Dahlin <sadmac@google.com>
diff --git a/aidl.cpp b/aidl.cpp
index b1decb9..55f8ba6 100644
--- a/aidl.cpp
+++ b/aidl.cpp
@@ -146,15 +146,15 @@
return 0;
}
-int check_filenames(const std::string& filename, const document_item_type* items) {
+int check_filenames(const std::string& filename, const AidlDocumentItem* items) {
int err = 0;
while (items) {
if (items->item_type == USER_DATA_TYPE) {
- user_data_type* p = (user_data_type*)items;
+ const AidlParcelable* p = reinterpret_cast<const AidlParcelable*>(items);
err |= check_filename(filename, p->package, &p->name);
}
else if (items->item_type == INTERFACE_TYPE_BINDER) {
- interface_type* c = (interface_type*)items;
+ const AidlInterface* c = reinterpret_cast<const AidlInterface*>(items);
err |= check_filename(filename, c->package, &c->name);
}
else {
@@ -179,16 +179,16 @@
}
bool gather_types(const std::string& filename,
- const document_item_type* all_items,
+ const AidlDocumentItem* all_items,
TypeNamespace* types) {
bool success = true;
- for (const document_item_type* item = all_items; item; item = item->next) {
+ for (const AidlDocumentItem* item = all_items; item; item = item->next) {
if (item->item_type == USER_DATA_TYPE) {
- user_data_type* p = (user_data_type*)item;
+ AidlParcelable* p = (AidlParcelable*)item;
success &= types->AddParcelableType(p, filename);
} else if (item->item_type == INTERFACE_TYPE_BINDER) {
- interface_type* c = (interface_type*)item;
+ AidlInterface* c = (AidlInterface*)item;
success &= types->AddBinderType(c, filename);
} else {
LOG(FATAL) << "internal error";
@@ -198,7 +198,7 @@
}
int check_types(const string& filename,
- interface_type* c,
+ AidlInterface* c,
TypeNamespace* types) {
int err = 0;
@@ -234,7 +234,7 @@
}
void generate_dep_file(const JavaOptions& options,
- const document_item_type* items,
+ const AidlDocumentItem* items,
const std::vector<std::unique_ptr<AidlImport>>& imports) {
/* we open the file in binary mode to ensure that the same output is
* generated on all platforms !!
@@ -333,14 +333,14 @@
}
string generate_outputFileName(const JavaOptions& options,
- const document_item_type* items) {
+ const AidlDocumentItem* items) {
// items has already been checked to have only one interface.
if (items->item_type == INTERFACE_TYPE_BINDER) {
- interface_type* type = (interface_type*)items;
+ AidlInterface* type = (AidlInterface*)items;
return generate_outputFileName2(options, type->name, type->package);
} else if (items->item_type == USER_DATA_TYPE) {
- user_data_type* type = (user_data_type*)items;
+ AidlParcelable* type = (AidlParcelable*)items;
return generate_outputFileName2(options, type->name, type->package);
}
@@ -400,12 +400,11 @@
//printf("%s:%d:...%s...%s...%s...\n", filename.c_str(), lineno,
// type, packagename, classname);
- document_item_type* doc;
+ AidlDocumentItem* doc;
if (0 == strcmp("parcelable", type)) {
- user_data_type* parcl = new user_data_type();
- memset(parcl, 0, sizeof(user_data_type));
- parcl->document_item.item_type = USER_DATA_TYPE;
+ AidlParcelable* parcl = new AidlParcelable();
+ parcl->item_type = USER_DATA_TYPE;
parcl->keyword_token.lineno = lineno;
parcl->keyword_token.data = cpp_strdup(type);
parcl->package = packagename ? cpp_strdup(packagename) : NULL;
@@ -414,12 +413,11 @@
parcl->semicolon_token.lineno = lineno;
parcl->semicolon_token.data = cpp_strdup(";");
parcl->parcelable = true;
- doc = (document_item_type*)parcl;
+ doc = (AidlDocumentItem*)parcl;
}
else if (0 == strcmp("interface", type)) {
- interface_type* iface = new interface_type();
- memset(iface, 0, sizeof(interface_type));
- iface->document_item.item_type = INTERFACE_TYPE_BINDER;
+ AidlInterface* iface = new AidlInterface();
+ iface->item_type = INTERFACE_TYPE_BINDER;
iface->interface_token.lineno = lineno;
iface->interface_token.data = cpp_strdup(type);
iface->package = packagename ? cpp_strdup(packagename) : NULL;
@@ -429,7 +427,7 @@
iface->open_brace_token.data = cpp_strdup("{");
iface->close_brace_token.lineno = lineno;
iface->close_brace_token.data = cpp_strdup("}");
- doc = (document_item_type*)iface;
+ doc = (AidlDocumentItem*)iface;
}
else {
fprintf(stderr, "%s:%d: bad type in line: %s\n",
@@ -518,7 +516,7 @@
const std::string& input_file_name,
const IoDelegate& io_delegate,
TypeNamespace* types,
- interface_type** returned_interface,
+ AidlInterface** returned_interface,
std::vector<std::unique_ptr<AidlImport>>* returned_imports) {
int err = 0;
@@ -536,7 +534,7 @@
return 1;
}
- document_item_type* parsed_doc = p.GetDocument();
+ AidlDocumentItem* parsed_doc = p.GetDocument();
// We could in theory declare parcelables in the same file as the interface.
// In practice, those parcelables would have to have the same name as
// the interface, since this was originally written to support Java, with its
@@ -549,7 +547,7 @@
cerr << "aidl expects exactly one interface per input file";
return 1;
}
- interface_type* interface = (interface_type*)parsed_doc;
+ AidlInterface* interface = (AidlInterface*)parsed_doc;
err |= check_filename(input_file_name.c_str(),
interface->package, &interface->name);
@@ -626,7 +624,7 @@
int compile_aidl_to_cpp(const CppOptions& options,
const IoDelegate& io_delegate) {
- interface_type* interface = nullptr;
+ AidlInterface* interface = nullptr;
std::vector<std::unique_ptr<AidlImport>> imports;
unique_ptr<cpp::TypeNamespace> types(new cpp::TypeNamespace());
int err = internals::load_and_validate_aidl(
@@ -648,7 +646,7 @@
int compile_aidl_to_java(const JavaOptions& options,
const IoDelegate& io_delegate) {
- interface_type* interface = nullptr;
+ AidlInterface* interface = nullptr;
std::vector<std::unique_ptr<AidlImport>> imports;
unique_ptr<java::JavaTypeNamespace> types(new java::JavaTypeNamespace());
int err = internals::load_and_validate_aidl(
@@ -662,7 +660,7 @@
if (err != 0) {
return err;
}
- document_item_type* parsed_doc = (document_item_type*)interface;
+ AidlDocumentItem* parsed_doc = (AidlDocumentItem*)interface;
string output_file_name = options.output_file_name_;
// if needed, generate the output file name from the base folder
@@ -698,10 +696,10 @@
Parser p{io_delegate};
if (!p.ParseFile(options.files_to_preprocess_[i]))
return 1;
- document_item_type* doc = p.GetDocument();
+ AidlDocumentItem* doc = p.GetDocument();
string line;
if (doc->item_type == USER_DATA_TYPE) {
- user_data_type* parcelable = (user_data_type*)doc;
+ AidlParcelable* parcelable = (AidlParcelable*)doc;
if (parcelable->parcelable) {
line = "parcelable ";
}
@@ -712,7 +710,7 @@
line += parcelable->name.data;
} else {
line = "interface ";
- interface_type* iface = (interface_type*)doc;
+ AidlInterface* iface = (AidlInterface*)doc;
if (iface->package) {
line += iface->package;
line += '.';
diff --git a/aidl.h b/aidl.h
index 0ceb3e2..404d652 100644
--- a/aidl.h
+++ b/aidl.h
@@ -39,7 +39,7 @@
const std::string& input_file_name,
const IoDelegate& io_delegate,
TypeNamespace* types,
- interface_type** returned_interface,
+ AidlInterface** returned_interface,
std::vector<std::unique_ptr<AidlImport>>* returned_imports);
} // namespace internals
diff --git a/aidl_language.h b/aidl_language.h
index 708c813..186b22a 100644
--- a/aidl_language.h
+++ b/aidl_language.h
@@ -134,36 +134,54 @@
};
enum {
- USER_DATA_TYPE = 12,
- INTERFACE_TYPE_BINDER
+ USER_DATA_TYPE = 12,
+ INTERFACE_TYPE_BINDER
};
-struct document_item_type {
- unsigned item_type;
- struct document_item_type* next;
+class AidlDocumentItem : public AidlNode {
+ public:
+ AidlDocumentItem() = default;
+ virtual ~AidlDocumentItem() = default;
+
+ AidlDocumentItem* next;
+ unsigned item_type;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(AidlDocumentItem);
};
+class AidlParcelable : public AidlDocumentItem {
+ public:
+ AidlParcelable() = default;
+ virtual ~AidlParcelable() = default;
-struct user_data_type {
- document_item_type document_item;
- buffer_type keyword_token; // only the first one
- char* package;
- buffer_type name;
- buffer_type semicolon_token;
- bool parcelable;
+ buffer_type keyword_token; // only the first one
+ char* package;
+ buffer_type name;
+ buffer_type semicolon_token;
+ bool parcelable;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(AidlParcelable);
};
-struct interface_type {
- document_item_type document_item;
- buffer_type interface_token;
- bool oneway;
- buffer_type oneway_token;
- char* package;
- buffer_type name;
- buffer_type open_brace_token;
- std::vector<std::unique_ptr<AidlMethod>>* methods;
- buffer_type close_brace_token;
- buffer_type* comments_token; // points into this structure, DO NOT DELETE
+class AidlInterface : public AidlDocumentItem {
+ public:
+ explicit AidlInterface() = default;
+ virtual ~AidlInterface() = default;
+
+ buffer_type interface_token;
+ bool oneway;
+ buffer_type oneway_token;
+ char* package;
+ buffer_type name;
+ buffer_type open_brace_token;
+ std::vector<std::unique_ptr<AidlMethod>>* methods;
+ buffer_type close_brace_token;
+ buffer_type* comments_token; // points into this structure, DO NOT DELETE
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(AidlInterface);
};
@@ -181,13 +199,13 @@
unsigned GetLine() const { return line_; }
const AidlDocumentItem* GetDocument() { return document_.get(); };
void SetDocument(AidlDocumentItem* doc) {
- document_.reset(doc);
+ document_ = std::unique_ptr<AidlDocumentItem>(doc);
}
void SetFilename(const std::string& filename) { filename_ = filename; }
private:
- std::unique_ptr<document_item_type> document_;
+ std::unique_ptr<AidlDocumentItem> document_;
std::string from_;
std::string filename_;
std::string needed_class_;
@@ -211,12 +229,12 @@
const std::string& Package() const { return package_; }
void *Scanner() const { return scanner_; }
- void SetDocument(document_item_type *items) { document_ = items; };
+ void SetDocument(AidlDocumentItem *items) { document_ = items; };
void AddImport(std::vector<std::string>* terms, unsigned line);
void SetPackage(std::vector<std::string>* terms);
- document_item_type *GetDocument() const { return document_; }
+ AidlDocumentItem *GetDocument() const { return document_; }
const std::vector<std::unique_ptr<AidlImport>>& GetImports() { return imports_; }
void ReleaseImports(std::vector<std::unique_ptr<AidlImport>>* ret) {
@@ -230,7 +248,7 @@
std::string filename_;
std::string package_;
void *scanner_ = nullptr;
- document_item_type* document_ = nullptr;
+ AidlDocumentItem* document_ = nullptr;
std::vector<std::unique_ptr<AidlImport>> imports_;
std::unique_ptr<std::string> raw_buffer_;
YY_BUFFER_STATE buffer_;
diff --git a/aidl_language_y.y b/aidl_language_y.y
index 400d694..426c23a 100644
--- a/aidl_language_y.y
+++ b/aidl_language_y.y
@@ -30,9 +30,9 @@
AidlMethod* method;
std::vector<std::unique_ptr<AidlMethod>>* methods;
std::vector<std::string>* strvec;
- interface_type* interface_obj;
- user_data_type* user_data;
- document_item_type* document_item;
+ AidlInterface* interface_obj;
+ AidlParcelable* user_data;
+ AidlDocumentItem* document_item;
}
%token<buffer> IDENTIFIER IDVALUE GENERIC PARCELABLE ONEWAY INTERFACE ';' '{' '}'
@@ -70,117 +70,98 @@
{ ps->AddImport($2, @1.begin.line); };
package_name
- : IDENTIFIER
- {
+ : IDENTIFIER {
$$ = new std::vector<std::string>();
$$->push_back($1.data);
}
| package_name '.' IDENTIFIER
{ $$->push_back($3.data); };
-document_items:
- { $$ = NULL; }
- | document_items declaration {
- if ($2 == NULL) {
- // error cases only
- $$ = $1;
- } else {
- document_item_type* p = $1;
- while (p && p->next) {
- p=p->next;
- }
- if (p) {
- p->next = (document_item_type*)$2;
- $$ = $1;
- } else {
- $$ = (document_item_type*)$2;
- }
- }
- }
- | document_items error {
- fprintf(stderr, "%s:%d: syntax error don't know what to do with \"%s\"\n",
- ps->FileName().c_str(),
- $2.lineno, $2.data);
- $$ = $1;
- }
- ;
+document_items
+ : { $$ = NULL; }
+ | document_items declaration {
+ $$ = $1;
+ AidlDocumentItem **pos = &$$;
+ while (*pos)
+ pos = &(*pos)->next;
+ if ($2)
+ *pos = $2;
+ }
+ | document_items error {
+ fprintf(stderr, "%s:%d: syntax error don't know what to do with \"%s\"\n",
+ ps->FileName().c_str(),
+ $2.lineno, $2.data);
+ $$ = $1;
+ };
-declaration:
- parcelable_decl { $$ = (document_item_type*)$1; }
- | interface_decl { $$ = (document_item_type*)$1; }
- ;
+declaration
+ : parcelable_decl
+ { $$ = $1; }
+ | interface_decl
+ { $$ = $1; };
-parcelable_decl:
- PARCELABLE IDENTIFIER ';' {
- user_data_type* b = new user_data_type();
- b->document_item.item_type = USER_DATA_TYPE;
- b->document_item.next = NULL;
- b->keyword_token = $1;
- b->name = $2;
- b->package =
- cpp_strdup(ps->Package().c_str());
- b->semicolon_token = $3;
- b->parcelable = true;
- $$ = b;
- }
- | PARCELABLE ';' {
- fprintf(stderr, "%s:%d syntax error in parcelable declaration. Expected type name.\n",
- ps->FileName().c_str(), $1.lineno);
- $$ = NULL;
- }
- | PARCELABLE error ';' {
- fprintf(stderr, "%s:%d syntax error in parcelable declaration. Expected type name, saw \"%s\".\n",
- ps->FileName().c_str(), $2.lineno, $2.data);
- $$ = NULL;
- }
- ;
+parcelable_decl
+ : PARCELABLE IDENTIFIER ';' {
+ AidlParcelable* b = new AidlParcelable();
+ b->item_type = USER_DATA_TYPE;
+ b->keyword_token = $1;
+ b->name = $2;
+ b->package = cpp_strdup(ps->Package().c_str());
+ b->semicolon_token = $3;
+ b->parcelable = true;
+ $$ = b;
+ }
+ | PARCELABLE ';' {
+ fprintf(stderr, "%s:%d syntax error in parcelable declaration. Expected type name.\n",
+ ps->FileName().c_str(), $1.lineno);
+ $$ = NULL;
+ }
+ | PARCELABLE error ';' {
+ fprintf(stderr, "%s:%d syntax error in parcelable declaration. Expected type name, saw \"%s\".\n",
+ ps->FileName().c_str(), $2.lineno, $2.data);
+ $$ = NULL;
+ };
-interface_header:
- INTERFACE {
- interface_type* c = new interface_type();
- c->document_item.item_type = INTERFACE_TYPE_BINDER;
- c->document_item.next = NULL;
- c->interface_token = $1;
- c->oneway = false;
- memset(&c->oneway_token, 0, sizeof(buffer_type));
- c->comments_token = &c->interface_token;
- $$ = c;
- }
- | ONEWAY INTERFACE {
- interface_type* c = new interface_type();
- c->document_item.item_type = INTERFACE_TYPE_BINDER;
- c->document_item.next = NULL;
- c->interface_token = $2;
- c->oneway = true;
- c->oneway_token = $1;
- c->comments_token = &c->oneway_token;
- $$ = c;
- }
- ;
+interface_header
+ : INTERFACE {
+ AidlInterface* c = new AidlInterface();
+ c->item_type = INTERFACE_TYPE_BINDER;
+ c->interface_token = $1;
+ c->oneway = false;
+ memset(&c->oneway_token, 0, sizeof(buffer_type));
+ c->comments_token = &c->interface_token;
+ $$ = c;
+ }
+ | ONEWAY INTERFACE {
+ AidlInterface* c = new AidlInterface();
+ c->item_type = INTERFACE_TYPE_BINDER;
+ c->interface_token = $2;
+ c->oneway = true;
+ c->oneway_token = $1;
+ c->comments_token = &c->oneway_token;
+ $$ = c;
+ };
-interface_decl:
- interface_header IDENTIFIER '{' methods '}' {
- interface_type* c = $1;
- c->name = $2;
- c->package =
- cpp_strdup(ps->Package().c_str());
- c->open_brace_token = $3;
- c->methods = $4;
- c->close_brace_token = $5;
- $$ = c;
- }
- | INTERFACE error '{' methods '}' {
- fprintf(stderr, "%s:%d: syntax error in interface declaration. Expected type name, saw \"%s\"\n",
- ps->FileName().c_str(), $2.lineno, $2.data);
- $$ = NULL;
- }
- | INTERFACE error '}' {
- fprintf(stderr, "%s:%d: syntax error in interface declaration. Expected type name, saw \"%s\"\n",
- ps->FileName().c_str(), $2.lineno, $2.data);
- $$ = NULL;
- }
-
- ;
+interface_decl
+ : interface_header IDENTIFIER '{' methods '}' {
+ AidlInterface* c = $1;
+ c->name = $2;
+ c->package = cpp_strdup(ps->Package().c_str());
+ c->open_brace_token = $3;
+ c->methods = $4;
+ c->close_brace_token = $5;
+ $$ = c;
+ }
+ | INTERFACE error '{' methods '}' {
+ fprintf(stderr, "%s:%d: syntax error in interface declaration. Expected type name, saw \"%s\"\n",
+ ps->FileName().c_str(), $2.lineno, $2.data);
+ $$ = NULL;
+ }
+ | INTERFACE error '}' {
+ fprintf(stderr, "%s:%d: syntax error in interface declaration. Expected type name, saw \"%s\"\n",
+ ps->FileName().c_str(), $2.lineno, $2.data);
+ $$ = NULL;
+ };
methods
:
@@ -273,14 +254,6 @@
#include <ctype.h>
#include <stdio.h>
-void init_buffer_type(buffer_type* buf, int lineno)
-{
- buf->lineno = lineno;
- buf->token = 0;
- buf->data = NULL;
- buf->extra = NULL;
-}
-
void yy::parser::error(const yy::parser::location_type& l, const std::string& errstr)
{
ps->ReportError(errstr);
diff --git a/generate_cpp.cpp b/generate_cpp.cpp
index e9a3aaa..1ce0868 100644
--- a/generate_cpp.cpp
+++ b/generate_cpp.cpp
@@ -103,7 +103,7 @@
enum class ClassNames { BASE, CLIENT, SERVER, INTERFACE };
-string ClassName(const interface_type& interface, ClassNames type) {
+string ClassName(const AidlInterface& interface, ClassNames type) {
string c_name = interface.name.Literal();
if (c_name.length() >= 2 && c_name[0] == 'I' && isupper(c_name[1]))
@@ -126,19 +126,19 @@
}
unique_ptr<Document> BuildClientSource(const TypeNamespace& types,
- const interface_type& parsed_doc) {
+ const AidlInterface& parsed_doc) {
unique_ptr<CppNamespace> ns{new CppNamespace{"android"}};
return unique_ptr<Document>{new CppSource{ {}, std::move(ns)}};
}
unique_ptr<Document> BuildServerSource(const TypeNamespace& types,
- const interface_type& parsed_doc) {
+ const AidlInterface& parsed_doc) {
unique_ptr<CppNamespace> ns{new CppNamespace{"android"}};
return unique_ptr<Document>{new CppSource{ {}, std::move(ns)}};
}
unique_ptr<Document> BuildInterfaceSource(const TypeNamespace& types,
- const interface_type& parsed_doc) {
+ const AidlInterface& parsed_doc) {
const string i_name = ClassName(parsed_doc, ClassNames::INTERFACE);
const string bp_name = ClassName(parsed_doc, ClassNames::CLIENT);
vector<string> include_list{i_name + ".h", bp_name + ".h"};
@@ -159,7 +159,7 @@
}
unique_ptr<Document> BuildClientHeader(const TypeNamespace& types,
- const interface_type& parsed_doc) {
+ const AidlInterface& parsed_doc) {
const string i_name = ClassName(parsed_doc, ClassNames::INTERFACE);
const string bp_name = ClassName(parsed_doc, ClassNames::CLIENT);
@@ -192,7 +192,7 @@
}
unique_ptr<Document> BuildServerHeader(const TypeNamespace& types,
- const interface_type& parsed_doc) {
+ const AidlInterface& parsed_doc) {
const string i_name = ClassName(parsed_doc, ClassNames::INTERFACE);
const string bn_name = ClassName(parsed_doc, ClassNames::SERVER);
@@ -222,7 +222,7 @@
}
unique_ptr<Document> BuildInterfaceHeader(const TypeNamespace& types,
- const interface_type& parsed_doc) {
+ const AidlInterface& parsed_doc) {
unique_ptr<ClassDecl> if_class{
new ClassDecl{ClassName(parsed_doc, ClassNames::INTERFACE),
"public android::IInterface"}};
@@ -262,7 +262,7 @@
bool GenerateCpp(const CppOptions& options,
const TypeNamespace& types,
- const interface_type& parsed_doc) {
+ const AidlInterface& parsed_doc) {
bool success = true;
success &= GenerateCppForFile(options.ClientCppFileName(),
diff --git a/generate_cpp.h b/generate_cpp.h
index a09c874..8dc152b 100644
--- a/generate_cpp.h
+++ b/generate_cpp.h
@@ -27,7 +27,7 @@
bool GenerateCpp(const CppOptions& options,
const cpp::TypeNamespace& types,
- const interface_type& parsed_doc);
+ const AidlInterface& parsed_doc);
} // namespace cpp
} // namespace aidl
diff --git a/generate_cpp_unittest.cpp b/generate_cpp_unittest.cpp
index 91a1354..f6bb7c1 100644
--- a/generate_cpp_unittest.cpp
+++ b/generate_cpp_unittest.cpp
@@ -34,11 +34,11 @@
namespace cpp {
namespace internals {
unique_ptr<Document> BuildInterfaceSource(const TypeNamespace& types,
- const interface_type& parsed_doc);
+ const AidlInterface& parsed_doc);
unique_ptr<Document> BuildClientHeader(const TypeNamespace& types,
- const interface_type& parsed_doc);
+ const AidlInterface& parsed_doc);
unique_ptr<Document> BuildInterfaceHeader(const TypeNamespace& types,
- const interface_type& parsed_doc);
+ const AidlInterface& parsed_doc);
}
namespace {
@@ -115,13 +115,13 @@
class TrivialInterfaceASTTest : public ::testing::Test {
protected:
- interface_type* Parse() {
+ AidlInterface* Parse() {
FakeIoDelegate io_delegate;
io_delegate.SetFileContents("IPingResponder.aidl", kTrivialInterfaceAIDL);
cpp::TypeNamespace types;
- interface_type* ret = nullptr;
+ AidlInterface* ret = nullptr;
std::vector<std::unique_ptr<AidlImport>> imports;
int err = ::android::aidl::internals::load_and_validate_aidl(
{}, // no preprocessed files
@@ -149,7 +149,7 @@
};
TEST_F(TrivialInterfaceASTTest, GeneratesClientHeader) {
- interface_type* interface = Parse();
+ AidlInterface* interface = Parse();
ASSERT_NE(interface, nullptr);
TypeNamespace types;
unique_ptr<Document> doc = internals::BuildClientHeader(types, *interface);
@@ -157,7 +157,7 @@
}
TEST_F(TrivialInterfaceASTTest, GeneratesInterfaceHeader) {
- interface_type* interface = Parse();
+ AidlInterface* interface = Parse();
ASSERT_NE(interface, nullptr);
TypeNamespace types;
unique_ptr<Document> doc = internals::BuildInterfaceHeader(types, *interface);
@@ -165,7 +165,7 @@
}
TEST_F(TrivialInterfaceASTTest, GeneratesInterfaceSource) {
- interface_type* interface = Parse();
+ AidlInterface* interface = Parse();
ASSERT_NE(interface, nullptr);
TypeNamespace types;
unique_ptr<Document> doc = internals::BuildInterfaceSource(types, *interface);
diff --git a/generate_java.cpp b/generate_java.cpp
index 3d780d7..d71f8cc 100644
--- a/generate_java.cpp
+++ b/generate_java.cpp
@@ -49,11 +49,11 @@
int
generate_java(const string& filename, const string& originalSrc,
- interface_type* iface, JavaTypeNamespace* types)
+ AidlInterface* iface, JavaTypeNamespace* types)
{
Class* cl;
- if (iface->document_item.item_type == INTERFACE_TYPE_BINDER) {
+ if (iface->item_type == INTERFACE_TYPE_BINDER) {
cl = generate_binder_interface_class(iface, types);
}
diff --git a/generate_java.h b/generate_java.h
index 5affbf1..2f06323 100644
--- a/generate_java.h
+++ b/generate_java.h
@@ -17,10 +17,10 @@
class JavaTypeNamespace;
int generate_java(const string& filename, const string& originalSrc,
- interface_type* iface, java::JavaTypeNamespace* types);
+ AidlInterface* iface, java::JavaTypeNamespace* types);
android::aidl::java::Class* generate_binder_interface_class(
- const interface_type* iface, java::JavaTypeNamespace* types);
+ const AidlInterface* iface, java::JavaTypeNamespace* types);
} // namespace java
diff --git a/generate_java_binder.cpp b/generate_java_binder.cpp
index b7ae470..1dc5dc7 100644
--- a/generate_java_binder.cpp
+++ b/generate_java_binder.cpp
@@ -514,7 +514,7 @@
}
Class*
-generate_binder_interface_class(const interface_type* iface,
+generate_binder_interface_class(const AidlInterface* iface,
JavaTypeNamespace* types)
{
const InterfaceType* interfaceType = static_cast<const InterfaceType*>(
diff --git a/type_cpp.cpp b/type_cpp.cpp
index b4f8ab3..6f80845 100644
--- a/type_cpp.cpp
+++ b/type_cpp.cpp
@@ -61,14 +61,14 @@
new Type("double", "double", "readDouble", "writeDouble"));
}
-bool TypeNamespace::AddParcelableType(const user_data_type* p,
+bool TypeNamespace::AddParcelableType(const AidlParcelable* p,
const string& filename) {
// TODO Support parcelables b/23600712
LOG(ERROR) << "Passing parcelables in unimplemented in C++ generation.";
return true;
}
-bool TypeNamespace::AddBinderType(const interface_type* b,
+bool TypeNamespace::AddBinderType(const AidlInterface* b,
const string& filename) {
// TODO Support passing binders b/24470875
LOG(ERROR) << "Passing binders is unimplemented in C++ generation.";
diff --git a/type_cpp.h b/type_cpp.h
index 5b4bba4..26f288d 100644
--- a/type_cpp.h
+++ b/type_cpp.h
@@ -64,9 +64,9 @@
TypeNamespace();
virtual ~TypeNamespace() = default;
- bool AddParcelableType(const user_data_type* p,
+ bool AddParcelableType(const AidlParcelable* p,
const std::string& filename) override;
- bool AddBinderType(const interface_type* b,
+ bool AddBinderType(const AidlInterface* b,
const std::string& filename) override;
bool AddContainerType(const std::string& type_name) override;
diff --git a/type_java.cpp b/type_java.cpp
index bd1b700..8953adc 100644
--- a/type_java.cpp
+++ b/type_java.cpp
@@ -955,7 +955,7 @@
return Find(s);
}
-bool JavaTypeNamespace::AddParcelableType(const user_data_type* p,
+bool JavaTypeNamespace::AddParcelableType(const AidlParcelable* p,
const std::string& filename) {
Type* type =
new UserDataType(this, p->package ? p->package : "", p->name.data, false,
@@ -963,7 +963,7 @@
return Add(type);
}
-bool JavaTypeNamespace::AddBinderType(const interface_type* b,
+bool JavaTypeNamespace::AddBinderType(const AidlInterface* b,
const std::string& filename) {
// for interfaces, add the stub, proxy, and interface types.
Type* type =
diff --git a/type_java.h b/type_java.h
index fc2b33d..39a3d8e 100644
--- a/type_java.h
+++ b/type_java.h
@@ -404,9 +404,9 @@
JavaTypeNamespace();
virtual ~JavaTypeNamespace();
- bool AddParcelableType(const user_data_type* p,
+ bool AddParcelableType(const AidlParcelable* p,
const string& filename) override;
- bool AddBinderType(const interface_type* b,
+ bool AddBinderType(const AidlInterface* b,
const string& filename) override;
bool AddContainerType(const string& type_name) override;
diff --git a/type_java_unittest.cpp b/type_java_unittest.cpp
index bba0c88..7fa05c6 100644
--- a/type_java_unittest.cpp
+++ b/type_java_unittest.cpp
@@ -29,13 +29,12 @@
namespace java {
namespace {
-user_data_type* MakeFakeUserDataType(const std::string& package,
+AidlParcelable* MakeFakeUserDataType(const std::string& package,
const std::string& class_name) {
// This leaks memory, like all usages of these structs.
// See b/24410295
- user_data_type* parcl = new user_data_type();
- memset(parcl, 0, sizeof(user_data_type));
- parcl->document_item.item_type = USER_DATA_TYPE;
+ AidlParcelable* parcl = new AidlParcelable();
+ parcl->item_type = USER_DATA_TYPE;
parcl->package = cpp_strdup(package.c_str());
parcl->name.data = cpp_strdup(class_name.c_str());
return parcl;
diff --git a/type_namespace.h b/type_namespace.h
index ee4b29b..4c0d15f 100644
--- a/type_namespace.h
+++ b/type_namespace.h
@@ -43,9 +43,9 @@
class TypeNamespace {
public:
// Load this TypeNamespace with user defined types.
- virtual bool AddParcelableType(const user_data_type* p,
+ virtual bool AddParcelableType(const AidlParcelable* p,
const std::string& filename) = 0;
- virtual bool AddBinderType(const interface_type* b,
+ virtual bool AddBinderType(const AidlInterface* b,
const std::string& filename) = 0;
// We dynamically create container types as we discover them in the parse
// tree. Returns false iff this is an invalid type. Silently discards