diff options
author | Hugo Parente Lima <hugo.pl@gmail.com> | 2012-03-13 10:48:37 -0300 |
---|---|---|
committer | Hugo Parente Lima <hugo.pl@gmail.com> | 2012-03-13 10:48:37 -0300 |
commit | 14e2207a58e79360bd48507b5e386ec944d8dd74 (patch) | |
tree | 2e903282fef303d610ebfb6b7913e9a0b5a84825 /ApiExtractor/abstractmetabuilder.h | |
parent | 744d018dd857543f93f3961cf9e7f70adcc7ce65 (diff) |
Move ApiExtractor into ApiExtractor directory to ease the merge into Shiboken.
Diffstat (limited to 'ApiExtractor/abstractmetabuilder.h')
-rw-r--r-- | ApiExtractor/abstractmetabuilder.h | 271 |
1 files changed, 271 insertions, 0 deletions
diff --git a/ApiExtractor/abstractmetabuilder.h b/ApiExtractor/abstractmetabuilder.h new file mode 100644 index 000000000..b4a2863ac --- /dev/null +++ b/ApiExtractor/abstractmetabuilder.h @@ -0,0 +1,271 @@ +/* + * This file is part of the API Extractor project. + * + * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). + * + * Contact: PySide team <contact@pyside.org> + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + */ + +#ifndef ABSTRACTMETABUILDER_H +#define ABSTRACTMETABUILDER_H + +#include "parser/codemodel.h" +#include "abstractmetalang.h" +#include "typesystem.h" +#include "typeparser.h" + +#include <QSet> +#include <QFileInfo> + +class TypeDatabase; + +class APIEXTRACTOR_API AbstractMetaBuilder +{ +public: + enum RejectReason { + NotInTypeSystem, + GenerationDisabled, + RedefinedToNotClass, + UnmatchedArgumentType, + UnmatchedReturnType, + ApiIncompatible, + NoReason + }; + + AbstractMetaBuilder(); + virtual ~AbstractMetaBuilder(); + + AbstractMetaClassList classes() const + { + return m_metaClasses; + } + AbstractMetaClassList templates() const + { + return m_templates; + } + /** + * Sorts a list of classes topologically, if an AbstractMetaClass object + * is passed the list of classes will be its inner classes, otherwise + * the list will be the module global classes. + * \return a list of classes sorted topologically + */ + AbstractMetaClassList classesTopologicalSorted(const AbstractMetaClass* cppClass = 0) const; + + FileModelItem model() const + { + return m_dom; + } + + void setModel(FileModelItem item) + { + m_dom = item; + } + + ScopeModelItem popScope() + { + return m_scopes.takeLast(); + } + + void pushScope(ScopeModelItem item) + { + m_scopes << item; + } + + ScopeModelItem currentScope() const + { + return m_scopes.last(); + } + + void dumpLog(); + + bool build(QIODevice* input); + void setLogDirectory(const QString& logDir); + + void figureOutEnumValuesForClass(AbstractMetaClass *metaClass, QSet<AbstractMetaClass *> *classes); + int figureOutEnumValue(const QString &name, int value, AbstractMetaEnum *meta_enum, AbstractMetaFunction *metaFunction = 0); + void figureOutEnumValues(); + void figureOutDefaultEnumArguments(); + + void addAbstractMetaClass(AbstractMetaClass *cls); + AbstractMetaClass *traverseTypeAlias(TypeAliasModelItem item); + AbstractMetaClass *traverseClass(ClassModelItem item); + AbstractMetaClass* currentTraversedClass(ScopeModelItem item); + void traverseScopeMembers(ScopeModelItem item, AbstractMetaClass* metaClass); + void traverseClassMembers(ClassModelItem scopeItem); + void traverseNamespaceMembers(NamespaceModelItem scopeItem); + bool setupInheritance(AbstractMetaClass *metaClass); + AbstractMetaClass *traverseNamespace(NamespaceModelItem item); + AbstractMetaEnum *traverseEnum(EnumModelItem item, AbstractMetaClass *enclosing, const QSet<QString> &enumsDeclarations); + void traverseEnums(ScopeModelItem item, AbstractMetaClass *parent, const QStringList &enumsDeclarations); + void traverseFunctions(ScopeModelItem item, AbstractMetaClass *parent); + void applyFunctionModifications(AbstractMetaFunction* func); + void traverseFields(ScopeModelItem item, AbstractMetaClass *parent); + void traverseStreamOperator(FunctionModelItem functionItem); + void traverseOperatorFunction(FunctionModelItem item); + AbstractMetaFunction* traverseFunction(const AddedFunction& addedFunc); + AbstractMetaFunction* traverseFunction(const AddedFunction& addedFunc, AbstractMetaClass* metaClass); + AbstractMetaFunction *traverseFunction(FunctionModelItem function); + AbstractMetaField *traverseField(VariableModelItem field, const AbstractMetaClass *cls); + void checkFunctionModifications(); + void registerHashFunction(FunctionModelItem functionItem); + void registerToStringCapability(FunctionModelItem functionItem); + + /** + * A conversion operator function should not have its owner class as + * its return type, but unfortunately it does. This function fixes the + * return type of operator functions of this kind making the return type + * be the same as it is supposed to generate when used in C++. + * If the returned type is a wrapped C++ class, this method also adds the + * conversion operator to the collection of external conversions of the + * said class. + * \param metaFunction conversion operator function to be fixed. + */ + void fixReturnTypeOfConversionOperator(AbstractMetaFunction* metaFunction); + + void parseQ_Property(AbstractMetaClass *metaClass, const QStringList &declarations); + void setupEquals(AbstractMetaClass *metaClass); + void setupComparable(AbstractMetaClass *metaClass); + void setupClonable(AbstractMetaClass *cls); + void setupExternalConversion(AbstractMetaClass* cls); + void setupFunctionDefaults(AbstractMetaFunction *metaFunction, AbstractMetaClass *metaClass); + + QString fixDefaultValue(ArgumentModelItem item, AbstractMetaType *type, + AbstractMetaFunction *fnc, AbstractMetaClass *, + int argumentIndex); + AbstractMetaType* translateType(double vr, const AddedFunction::TypeInfo& typeInfo); + AbstractMetaType *translateType(const TypeInfo &type, bool *ok, bool resolveType = true, bool resolveScope = true); + + int findOutValueFromString(const QString& stringValue, bool& ok); + + void decideUsagePattern(AbstractMetaType *type); + + const AbstractMetaFunctionList globalFunctions() const + { + return m_globalFunctions; + } + + const AbstractMetaEnumList globalEnums() const + { + return m_globalEnums; + } + + AbstractMetaClassList getBaseClasses(const AbstractMetaClass* metaClass) const; + bool ancestorHasPrivateCopyConstructor(const AbstractMetaClass* metaClass) const; + + bool inheritTemplate(AbstractMetaClass *subclass, + const AbstractMetaClass *templateClass, + const TypeParser::Info &info); + AbstractMetaType *inheritTemplateType(const QList<AbstractMetaType *> &templateTypes, const AbstractMetaType *metaType, bool *ok = 0); + + bool isQObject(const QString &qualifiedName); + bool isEnum(const QStringList &qualifiedName); + + void fixQObjectForScope(TypeDatabase* types, NamespaceModelItem item); + + // QtScript + QSet<QString> qtMetaTypeDeclaredTypeNames() const + { + return m_qmetatypeDeclaredTypenames; + } + + /** + * AbstractMetaBuilder should know what's the global header being used, + * so any class declared under this header wont have the include file + * filled. + */ + void setGlobalHeader(const QString& globalHeader); + +protected: + AbstractMetaClass *argumentToClass(ArgumentModelItem); + + virtual AbstractMetaClass *createMetaClass() + { + return new AbstractMetaClass(); + } + + virtual AbstractMetaEnum *createMetaEnum() + { + return new AbstractMetaEnum(); + } + + virtual AbstractMetaEnumValue *createMetaEnumValue() + { + return new AbstractMetaEnumValue(); + } + + virtual AbstractMetaField *createMetaField() + { + return new AbstractMetaField(); + } + + virtual AbstractMetaFunction *createMetaFunction() + { + return new AbstractMetaFunction(); + } + + virtual AbstractMetaArgument *createMetaArgument() + { + return new AbstractMetaArgument(); + } + + virtual AbstractMetaType *createMetaType() + { + return new AbstractMetaType(); + } + + FileModelItem m_dom; + +private: + void sortLists(); + AbstractMetaArgumentList reverseList(const AbstractMetaArgumentList& list); + void setInclude(TypeEntry* te, const QString& fileName) const; + void fixArgumentNames(AbstractMetaFunction* func); + void fillAddedFunctions(AbstractMetaClass* metaClass); + + AbstractMetaClassList m_metaClasses; + AbstractMetaClassList m_templates; + AbstractMetaFunctionList m_globalFunctions; + AbstractMetaEnumList m_globalEnums; + + QSet<const TypeEntry *> m_usedTypes; + + QMap<QString, RejectReason> m_rejectedClasses; + QMap<QString, RejectReason> m_rejectedEnums; + QMap<QString, RejectReason> m_rejectedFunctions; + QMap<QString, RejectReason> m_rejectedFields; + + QList<AbstractMetaEnum *> m_enums; + + QList<QPair<AbstractMetaArgument *, AbstractMetaFunction *> > m_enumDefaultArguments; + + QHash<QString, AbstractMetaEnumValue *> m_enumValues; + + AbstractMetaClass *m_currentClass; + QList<ScopeModelItem> m_scopes; + QString m_namespacePrefix; + + QSet<AbstractMetaClass *> m_setupInheritanceDone; + + // QtScript + QSet<QString> m_qmetatypeDeclaredTypenames; + + QString m_logDirectory; + QFileInfo m_globalHeader; +}; + +#endif // ABSTRACTMETBUILDER_H |