blob: f966bff152cc57e703dc5357545b2b0bf0a717c0 [file] [log] [blame]
/*
* Copyright (C) 2016 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.
*/
#ifndef AST_H_
#define AST_H_
#include <android-base/macros.h>
#include <hidl-hash/Hash.h>
#include <hidl-util/FQName.h>
#include <functional>
#include <map>
#include <set>
#include <string>
#include <vector>
#include "Scope.h"
#include "Type.h"
namespace android {
struct Coordinator;
struct ConstantExpression;
struct EnumValue;
struct Formatter;
struct Interface;
struct Location;
struct Method;
struct NamedType;
template <class T>
struct NamedReference;
struct Type;
struct AST {
AST(const Coordinator* coordinator, const Hash* fileHash);
bool setPackage(const char *package);
bool addImport(const char *import);
// package and version really.
FQName package() const;
bool isInterface() const;
bool containsInterfaces() const;
// Adds package, version and scope stack to local name
FQName makeFullName(const char* localName, Scope* scope) const;
void addScopedType(NamedType* type, Scope* scope);
const std::string& getFilename() const;
const Hash* getFileHash() const;
// Look up local identifier.
// It could be plain identifier or enum value as described by lookupEnumValue.
LocalIdentifier* lookupLocalIdentifier(const Reference<LocalIdentifier>& ref, Scope* scope);
// Look up an enum value by "FQName:valueName".
EnumValue* lookupEnumValue(const FQName& fqName, std::string* errorMsg, Scope* scope);
// Look up a type by FQName, "pure" names, i.e. those without package
// or version are first looked up in the current scope chain.
// After that lookup proceeds to imports.
Type* lookupType(const FQName& fqName, Scope* scope);
void addImportedAST(AST *ast);
// Calls all passes after parsing required before
// being ready to generate output.
status_t postParse();
// Recursive pass on constant expression tree
status_t constantExpressionRecursivePass(
const std::function<status_t(ConstantExpression*)>& func, bool processBeforeDependencies);
// Recursive tree pass that looks up all referenced types
status_t lookupTypes();
// Recursive tree pass that looks up all referenced local identifiers
status_t lookupLocalIdentifiers();
// Recursive tree pass that validates that all defined types
// have unique names in their scopes.
status_t validateDefinedTypesUniqueNames() const;
// Recursive tree pass that completes type declarations
// that depend on super types
status_t resolveInheritance();
// Recursive tree pass that evaluates constant expressions
status_t evaluate();
// Recursive tree pass that validates all type-related
// syntax restrictions
status_t validate() const;
// Recursive tree pass that ensures that type definitions and references
// are acyclic and reorderes type definitions in reversed topological order.
status_t topologicalReorder();
// Recursive tree pass that ensures that constant expressions
// are acyclic.
status_t checkAcyclicConstantExpressions() const;
// Recursive tree pass that checks C++ forward declaration restrictions.
status_t checkForwardReferenceRestrictions() const;
status_t gatherReferencedTypes();
status_t generateCppSource(Formatter& out) const;
status_t generateInterfaceHeader(Formatter& out) const;
status_t generateHwBinderHeader(Formatter& out) const;
status_t generateStubHeader(Formatter& out) const;
status_t generateProxyHeader(Formatter& out) const;
status_t generatePassthroughHeader(Formatter& out) const;
status_t generateCppImplHeader(Formatter& out) const;
status_t generateCppImplSource(Formatter& out) const;
status_t generateCppAdapterHeader(Formatter& out) const;
status_t generateCppAdapterSource(Formatter& out) const;
status_t generateJava(Formatter& out, const std::string& limitToType) const;
status_t generateJavaTypes(Formatter& out, const std::string& limitToType) const;
status_t generateVts(Formatter& out) const;
void getImportedPackages(std::set<FQName> *importSet) const;
// Run getImportedPackages on this, then run getImportedPackages on
// each AST in each package referenced in importSet.
void getImportedPackagesHierarchy(std::set<FQName> *importSet) const;
bool isJavaCompatible() const;
// Return the set of FQNames for those interfaces and types that are
// actually referenced in the AST, not merely imported.
const std::set<FQName>& getImportedNames() const {
return mImportedNames;
}
// Warning: this only includes names explicitly referenced in code.
// It does not include all names which are imported.
//
// Currently, there is one valid usecase for this: importing exactly
// the names which need to be imported in generated code. If you import
// based on getAllImportedNamesGranular instead, you will import things
// that aren't actually used in the resultant code.
//
// Get transitive closure of imported interface/types. This will add
// everything exported by a package even if only a single type from
// that package was explicitly imported!
void getAllImportedNames(std::set<FQName> *allImportSet) const;
// Get imported types, this includes those explicitly imported as well
// as all types defined in imported packages.
void getAllImportedNamesGranular(std::set<FQName> *allImportSet) const;
void appendToExportedTypesVector(
std::vector<const Type *> *exportedTypes) const;
// used by the parser.
void addSyntaxError();
size_t syntaxErrors() const;
bool isIBase() const;
// or nullptr if not isInterface
const Interface *getInterface() const;
// types or Interface base name (e.x. Foo)
std::string getBaseName() const;
Scope* getRootScope();
static void generateCppPackageInclude(Formatter& out, const FQName& package,
const std::string& klass);
void addDefinedTypes(std::set<FQName> *definedTypes) const;
void addReferencedTypes(std::set<FQName> *referencedTypes) const;
void addToImportedNamesGranular(const FQName &fqName);
private:
const Coordinator* mCoordinator;
const Hash* mFileHash;
RootScope mRootScope;
FQName mPackage;
// A set of all external interfaces/types that are _actually_ referenced
// in this AST, this is a subset of those specified in import statements.
// Note that this set only resolves to the granularity of either an
// interface type or a whole package.
std::set<FQName> mImportedNames;
// This is the set of actually imported types.
std::set<FQName> mImportedNamesGranular;
// Warning: this only includes names explicitly referenced in code.
// It does not include all names which are imported.
//
// A set of all ASTs we explicitly or implicitly (types.hal) import.
std::set<AST *> mImportedASTs;
// If a single type (instead of the whole AST) is imported, the AST will be
// present as a key to this map, with the value being a list of types
// imported from this AST. If an AST appears in mImportedASTs but not in
// mImportedTypes, then the whole AST is imported.
std::map<AST *, std::set<Type *>> mImportedTypes;
// Types keyed by full names defined in this AST.
std::map<FQName, Type *> mDefinedTypesByFullName;
// used by the parser.
size_t mSyntaxErrors = 0;
std::set<FQName> mReferencedTypeNames;
// Helper functions for lookupType.
Type* lookupTypeLocally(const FQName& fqName, Scope* scope);
status_t lookupAutofilledType(const FQName &fqName, Type **returnedType);
Type *lookupTypeFromImports(const FQName &fqName);
// Find a type matching fqName (which may be partial) and if found
// return the associated type and fill in the full "matchingName".
// Only types defined in this very AST are considered.
Type *findDefinedType(const FQName &fqName, FQName *matchingName) const;
void getPackageComponents(std::vector<std::string> *components) const;
void getPackageAndVersionComponents(
std::vector<std::string> *components, bool cpp_compatible) const;
std::string makeHeaderGuard(const std::string &baseName,
bool indicateGenerated = true) const;
void enterLeaveNamespace(Formatter &out, bool enter) const;
static void generateCheckNonNull(Formatter &out, const std::string &nonNull);
status_t generateTypeSource(
Formatter &out, const std::string &ifaceName) const;
// a method, and in which interface is it originally defined.
// be careful of the case where method.isHidlReserved(), where interface
// is effectively useless.
using MethodGenerator = std::function<status_t(const Method *, const Interface *)>;
void generateTemplatizationLink(Formatter& out) const;
void generateCppTag(Formatter& out, const std::string& tag) const;
status_t generateMethods(Formatter &out,
const MethodGenerator &gen,
bool includeParents = true) const;
status_t generateStubImplMethod(Formatter &out,
const std::string &className,
const Method *method) const;
status_t generatePassthroughMethod(Formatter &out,
const Method *method) const;
status_t generateStaticProxyMethodSource(Formatter &out,
const std::string &className,
const Method *method) const;
status_t generateProxyMethodSource(Formatter &out,
const std::string &className,
const Method *method,
const Interface *superInterface) const;
void generateAdapterMethod(Formatter& out, const Method* method) const;
void generateFetchSymbol(Formatter &out, const std::string &ifaceName) const;
status_t generateProxySource(
Formatter &out, const FQName &fqName) const;
status_t generateStubSource(
Formatter &out, const Interface *iface) const;
status_t generateStubSourceForMethod(Formatter &out,
const Method *method,
const Interface *superInterface) const;
status_t generateStaticStubMethodSource(Formatter &out,
const FQName &fqName,
const Method *method) const;
status_t generatePassthroughSource(Formatter &out) const;
status_t generateInterfaceSource(Formatter &out) const;
enum InstrumentationEvent {
SERVER_API_ENTRY = 0,
SERVER_API_EXIT,
CLIENT_API_ENTRY,
CLIENT_API_EXIT,
SYNC_CALLBACK_ENTRY,
SYNC_CALLBACK_EXIT,
ASYNC_CALLBACK_ENTRY,
ASYNC_CALLBACK_EXIT,
PASSTHROUGH_ENTRY,
PASSTHROUGH_EXIT,
};
void generateCppAtraceCall(
Formatter &out,
InstrumentationEvent event,
const Method *method) const;
void generateCppInstrumentationCall(
Formatter &out,
InstrumentationEvent event,
const Method *method) const;
void declareCppReaderLocals(Formatter& out, const std::vector<NamedReference<Type>*>& arg,
bool forResults) const;
void emitCppReaderWriter(Formatter& out, const std::string& parcelObj, bool parcelObjIsPointer,
const NamedReference<Type>* arg, bool isReader, Type::ErrorMode mode,
bool addPrefixToName) const;
void emitCppResolveReferences(Formatter& out, const std::string& parcelObj,
bool parcelObjIsPointer, const NamedReference<Type>* arg,
bool isReader, Type::ErrorMode mode, bool addPrefixToName) const;
void emitJavaReaderWriter(Formatter& out, const std::string& parcelObj,
const NamedReference<Type>* arg, bool isReader,
bool addPrefixToName) const;
status_t emitTypeDeclarations(Formatter &out) const;
status_t emitJavaTypeDeclarations(Formatter &out) const;
status_t emitVtsTypeDeclarations(Formatter &out) const;
DISALLOW_COPY_AND_ASSIGN(AST);
};
} // namespace android
#endif // AST_H_