346 lines
11 KiB
C++
346 lines
11 KiB
C++
/*
|
|
* Copyright (C) 2019, The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include "parser.h"
|
|
|
|
#include <queue>
|
|
|
|
#include "aidl_language_y.h"
|
|
#include "logging.h"
|
|
|
|
void yylex_init(void**);
|
|
void yylex_destroy(void*);
|
|
void yyset_in(FILE* f, void*);
|
|
int yyparse(Parser*);
|
|
YY_BUFFER_STATE yy_scan_buffer(char*, size_t, void*);
|
|
void yy_delete_buffer(YY_BUFFER_STATE, void*);
|
|
|
|
// For each union, generate nested "Tag" enum type so that "Tag" can be used as a valid type.
|
|
// union Foo { int a; int b; } => union Foo { ... enum Tag { a, b }}
|
|
struct UnionTagGenerater : AidlVisitor {
|
|
void Visit(const AidlUnionDecl& decl) override {
|
|
std::vector<std::unique_ptr<AidlEnumerator>> enumerators;
|
|
for (const auto& field : decl.GetFields()) {
|
|
enumerators.push_back(std::make_unique<AidlEnumerator>(AIDL_LOCATION_HERE, field->GetName(),
|
|
nullptr, field->GetComments()));
|
|
}
|
|
auto tag_enum = std::make_unique<AidlEnumDeclaration>(AIDL_LOCATION_HERE, "Tag", &enumerators,
|
|
decl.GetPackage(), Comments{});
|
|
// Tag for @FixedSize union is limited to "byte" type so that it can be passed via FMQ with
|
|
// with lower overhead.
|
|
std::shared_ptr<AidlConstantValue> backing_type{
|
|
AidlConstantValue::String(AIDL_LOCATION_HERE, decl.IsFixedSize() ? "\"byte\"" : "\"int\"")};
|
|
std::vector<std::unique_ptr<AidlAnnotation>> annotations;
|
|
annotations.push_back(
|
|
AidlAnnotation::Parse(AIDL_LOCATION_HERE, "Backing", {{"type", backing_type}}, Comments{}));
|
|
tag_enum->Annotate(std::move(annotations));
|
|
const_cast<AidlUnionDecl&>(decl).AddType(std::move(tag_enum));
|
|
}
|
|
};
|
|
|
|
const AidlDocument* Parser::Parse(const std::string& filename,
|
|
const android::aidl::IoDelegate& io_delegate,
|
|
AidlTypenames& typenames, bool is_preprocessed) {
|
|
auto clean_path = android::aidl::IoDelegate::CleanPath(filename);
|
|
// reuse pre-parsed document from typenames
|
|
for (auto& doc : typenames.AllDocuments()) {
|
|
if (doc->GetLocation().GetFile() == clean_path) {
|
|
return doc.get();
|
|
}
|
|
}
|
|
// Make sure we can read the file first, before trashing previous state.
|
|
unique_ptr<string> raw_buffer = io_delegate.GetFileContents(clean_path);
|
|
if (raw_buffer == nullptr) {
|
|
AIDL_ERROR(clean_path) << "Error while opening file for parsing";
|
|
return nullptr;
|
|
}
|
|
|
|
// We're going to scan this buffer in place, and yacc demands we put two
|
|
// nulls at the end.
|
|
raw_buffer->append(2u, '\0');
|
|
|
|
Parser parser(clean_path, *raw_buffer, is_preprocessed);
|
|
|
|
if (yy::parser(&parser).parse() != 0 || parser.HasError()) {
|
|
return nullptr;
|
|
}
|
|
|
|
// Preprocess parsed document before adding to typenames.
|
|
UnionTagGenerater v;
|
|
VisitTopDown(v, *parser.document_);
|
|
|
|
// transfer ownership to AidlTypenames and return the raw pointer
|
|
const AidlDocument* result = parser.document_.get();
|
|
if (!typenames.AddDocument(std::move(parser.document_))) {
|
|
return nullptr;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void Parser::SetTypeParameters(AidlTypeSpecifier* type,
|
|
std::vector<std::unique_ptr<AidlTypeSpecifier>>* type_args) {
|
|
if (type->IsArray()) {
|
|
AIDL_ERROR(type) << "Must specify type parameters (<>) before array ([]).";
|
|
AddError();
|
|
}
|
|
if (!type->SetTypeParameters(type_args)) {
|
|
AIDL_ERROR(type) << "Can only specify one set of type parameters.";
|
|
AddError();
|
|
delete type_args;
|
|
}
|
|
}
|
|
|
|
void Parser::CheckValidTypeName(const AidlToken& token, const AidlLocation& loc) {
|
|
if (!is_preprocessed_ && token.GetText().find('.') != std::string::npos) {
|
|
AIDL_ERROR(loc) << "Type name can't be qualified. Use `package`.";
|
|
AddError();
|
|
}
|
|
}
|
|
|
|
void Parser::SetPackage(const std::string& package) {
|
|
if (is_preprocessed_) {
|
|
AIDL_ERROR(package) << "Preprocessed file can't declare package.";
|
|
AddError();
|
|
}
|
|
package_ = package;
|
|
}
|
|
|
|
bool CheckNoRecursiveDefinition(const AidlNode& node) {
|
|
struct Visitor : AidlVisitor {
|
|
enum {
|
|
NOT_STARTED = 0,
|
|
STARTED = 1,
|
|
FINISHED = 2,
|
|
};
|
|
std::map<const AidlParcelable*, int> visited;
|
|
std::vector<std::string> path;
|
|
bool found_cycle = false;
|
|
|
|
void Visit(const AidlStructuredParcelable& t) override { FindCycle(&t); }
|
|
void Visit(const AidlUnionDecl& t) override { FindCycle(&t); }
|
|
void Visit(const AidlParcelable& t) override { FindCycle(&t); }
|
|
|
|
bool FindCycle(const AidlParcelable* p) {
|
|
// no need to search further
|
|
if (found_cycle) {
|
|
return true;
|
|
}
|
|
// we just found a cycle
|
|
if (visited[p] == STARTED) {
|
|
path.push_back(p->GetName());
|
|
AIDL_ERROR(p) << p->GetName()
|
|
<< " is a recursive parcelable: " << android::base::Join(path, "->");
|
|
return (found_cycle = true);
|
|
}
|
|
// we arrived here with a different route.
|
|
if (visited[p] == FINISHED) {
|
|
return false;
|
|
}
|
|
// start DFS
|
|
visited[p] = STARTED;
|
|
path.push_back(p->GetName());
|
|
for (const auto& f : p->GetFields()) {
|
|
const auto& ref = f->GetType();
|
|
if (!ref.IsArray() && !ref.IsHeapNullable()) {
|
|
const auto& type = ref.GetDefinedType();
|
|
if (type && type->AsParcelable()) {
|
|
if (FindCycle(type->AsParcelable())) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
path.pop_back();
|
|
visited[p] = FINISHED;
|
|
return false;
|
|
}
|
|
} v;
|
|
VisitTopDown(v, node);
|
|
return !v.found_cycle;
|
|
}
|
|
|
|
// Each Visit*() method can use Scope() to get its scope(AidlDefinedType)
|
|
class ScopedVisitor : public AidlVisitor {
|
|
protected:
|
|
const AidlDefinedType* Scope() const {
|
|
AIDL_FATAL_IF(scope_.empty(), AIDL_LOCATION_HERE) << "Scope is empty";
|
|
return scope_.back();
|
|
}
|
|
void PushScope(const AidlDefinedType* scope) { scope_.push_back(scope); }
|
|
void PopScope() { scope_.pop_back(); }
|
|
// Keep user defined type as a defining scope
|
|
void VisitScopedTopDown(const AidlNode& node) {
|
|
std::function<void(const AidlNode&)> top_down = [&](const AidlNode& a) {
|
|
a.DispatchVisit(*this);
|
|
auto defined_type = AidlCast<AidlDefinedType>(a);
|
|
if (defined_type) PushScope(defined_type);
|
|
a.TraverseChildren(top_down);
|
|
if (defined_type) PopScope();
|
|
};
|
|
top_down(node);
|
|
}
|
|
|
|
private:
|
|
std::vector<const AidlDefinedType*> scope_ = {};
|
|
};
|
|
|
|
class TypeReferenceResolver : public ScopedVisitor {
|
|
public:
|
|
TypeReferenceResolver(TypeResolver& resolver) : resolver_(resolver) {}
|
|
|
|
void Visit(const AidlTypeSpecifier& t) override {
|
|
// We're visiting the same node again. This can happen when two constant references
|
|
// point to an ancestor of this node.
|
|
if (t.IsResolved()) {
|
|
return;
|
|
}
|
|
AidlTypeSpecifier& type = const_cast<AidlTypeSpecifier&>(t);
|
|
if (!resolver_(Scope(), &type)) {
|
|
AIDL_ERROR(type) << "Failed to resolve '" << type.GetUnresolvedName() << "'";
|
|
success_ = false;
|
|
return;
|
|
}
|
|
|
|
// In case a new document is imported for the type reference, enqueue it for type resolution.
|
|
auto resolved = t.GetDefinedType();
|
|
if (resolved) {
|
|
queue_.push(&resolved->GetDocument());
|
|
}
|
|
}
|
|
|
|
bool Resolve(const AidlDocument& document) {
|
|
queue_.push(&document);
|
|
while (!queue_.empty()) {
|
|
auto doc = queue_.front();
|
|
queue_.pop();
|
|
// Skip the doc if it's visited already.
|
|
if (!visited_.insert(doc).second) {
|
|
continue;
|
|
}
|
|
VisitScopedTopDown(*doc);
|
|
}
|
|
return success_;
|
|
}
|
|
|
|
private:
|
|
TypeResolver& resolver_;
|
|
bool success_ = true;
|
|
std::queue<const AidlDocument*> queue_ = {};
|
|
std::set<const AidlDocument*> visited_ = {};
|
|
};
|
|
|
|
class ConstantReferenceResolver : public ScopedVisitor {
|
|
public:
|
|
ConstantReferenceResolver() = default;
|
|
|
|
void Visit(const AidlConstantReference& v) override {
|
|
if (IsCircularReference(&v)) {
|
|
success_ = false;
|
|
return;
|
|
}
|
|
|
|
const AidlConstantValue* resolved = v.Resolve(Scope());
|
|
if (!resolved) {
|
|
AIDL_ERROR(v) << "Unknown reference '" << v.Literal() << "'";
|
|
success_ = false;
|
|
return;
|
|
}
|
|
|
|
// On error, skip recursive visiting to avoid redundant messages
|
|
if (!success_) {
|
|
return;
|
|
}
|
|
// resolve recursive references
|
|
PushConstRef(&v);
|
|
VisitScopedTopDown(*resolved);
|
|
PopConstRef();
|
|
}
|
|
|
|
bool Resolve(const AidlDocument& document) {
|
|
VisitScopedTopDown(document);
|
|
return success_;
|
|
}
|
|
|
|
private:
|
|
void PushConstRef(const AidlConstantReference* ref) {
|
|
stack_.push_back(ref);
|
|
if (ref->GetRefType()) {
|
|
PushScope(ref->GetRefType()->GetDefinedType());
|
|
}
|
|
}
|
|
|
|
void PopConstRef() {
|
|
if (stack_.back()->GetRefType()) {
|
|
PopScope();
|
|
}
|
|
stack_.pop_back();
|
|
}
|
|
|
|
bool IsCircularReference(const AidlConstantReference* ref) {
|
|
auto it =
|
|
std::find_if(stack_.begin(), stack_.end(), [&](const auto& elem) { return elem == ref; });
|
|
if (it == stack_.end()) {
|
|
return false;
|
|
}
|
|
std::vector<std::string> path;
|
|
while (it != stack_.end()) {
|
|
path.push_back((*it)->Literal());
|
|
++it;
|
|
}
|
|
path.push_back(ref->Literal());
|
|
AIDL_ERROR(ref) << "Found a circular reference: " << android::base::Join(path, " -> ");
|
|
return true;
|
|
}
|
|
|
|
bool success_ = true;
|
|
std::vector<const AidlConstantReference*> stack_ = {};
|
|
};
|
|
|
|
// Resolve references(types/constants) in the "main" document.
|
|
bool ResolveReferences(const AidlDocument& document, TypeResolver& type_resolver) {
|
|
// Types are resolved first before resolving constant references so that every referenced document
|
|
// gets imported.
|
|
if (!TypeReferenceResolver(type_resolver).Resolve(document)) {
|
|
return false;
|
|
}
|
|
if (!ConstantReferenceResolver().Resolve(document)) {
|
|
return false;
|
|
}
|
|
if (!CheckNoRecursiveDefinition(document)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
Parser::Parser(const std::string& filename, std::string& raw_buffer, bool is_preprocessed)
|
|
: filename_(filename), is_preprocessed_(is_preprocessed) {
|
|
yylex_init(&scanner_);
|
|
buffer_ = yy_scan_buffer(&raw_buffer[0], raw_buffer.length(), scanner_);
|
|
}
|
|
|
|
Parser::~Parser() {
|
|
yy_delete_buffer(buffer_, scanner_);
|
|
yylex_destroy(scanner_);
|
|
}
|
|
|
|
void Parser::MakeDocument(const AidlLocation& location, const Comments& comments,
|
|
std::vector<std::string> imports,
|
|
std::vector<std::unique_ptr<AidlDefinedType>> defined_types) {
|
|
AIDL_FATAL_IF(document_.get(), location);
|
|
document_ = std::make_unique<AidlDocument>(location, comments, std::move(imports),
|
|
std::move(defined_types), is_preprocessed_);
|
|
}
|