diff options
Diffstat (limited to 'tools/porting')
74 files changed, 33686 insertions, 0 deletions
diff --git a/tools/porting/porting.pro b/tools/porting/porting.pro new file mode 100644 index 0000000..65d9262 --- /dev/null +++ b/tools/porting/porting.pro @@ -0,0 +1,2 @@ +TEMPLATE = subdirs +SUBDIRS = src diff --git a/tools/porting/src/ast.cpp b/tools/porting/src/ast.cpp new file mode 100644 index 0000000..9c15620 --- /dev/null +++ b/tools/porting/src/ast.cpp @@ -0,0 +1,1215 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "ast.h" +#include <QStringList> +#include <stdio.h> + +QT_BEGIN_NAMESPACE + +int AST::N = 0; + +// ------------------------------------------------------------------------ +AST::AST(int startToken, int count) + : m_scope(0), + m_startToken(startToken), + m_endToken(startToken + count), + m_parent(0), + m_children(0) +{ + ++N; +} + +void AST::setParent(AST *parent) +{ + if (m_parent) + m_parent->removeChild(this); + + m_parent = parent; + + if (m_parent) + m_parent->appendChild(this); +} + +void AST::appendChild(AST *child) +{ + m_children = snoc(m_children, child, _pool); +} + +void AST::removeChild(AST *child) +{ + fprintf(stderr, "AST::removeChild child: %p not implemented yet\n", child); +} + +// ------------------------------------------------------------------------ +NameAST::NameAST() + : m_global(false), m_unqualifiedName(0), m_classOrNamespaceNameList(0) +{ +} + +void NameAST::setGlobal(bool b) +{ + m_global = b; +} + +void NameAST::setUnqualifiedName(ClassOrNamespaceNameAST *unqualifiedName) +{ + m_unqualifiedName = unqualifiedName; + if (m_unqualifiedName) m_unqualifiedName->setParent(this); +} + +void NameAST::addClassOrNamespaceName(ClassOrNamespaceNameAST *classOrNamespaceName) +{ + if(!classOrNamespaceName) + return; + + classOrNamespaceName->setParent(this); + m_classOrNamespaceNameList = snoc(m_classOrNamespaceNameList, classOrNamespaceName, _pool); +} + +// ------------------------------------------------------------------------ +DeclarationAST::DeclarationAST() +{ +} + +// ------------------------------------------------------------------------ +LinkageBodyAST::LinkageBodyAST() + : m_declarationList(0) +{ +} + +void LinkageBodyAST::addDeclaration(DeclarationAST *ast) +{ + if(!ast) + return; + + ast->setParent(this); + m_declarationList = snoc(m_declarationList, ast, _pool); +} + +// ------------------------------------------------------------------------ +LinkageSpecificationAST::LinkageSpecificationAST() + : m_externType(0), + m_linkageBody(0), + m_declaration(0) +{ +} + +void LinkageSpecificationAST::setExternType(AST *externType) +{ + m_externType = externType; + if (m_externType) m_externType->setParent(this); +} + +void LinkageSpecificationAST::setLinkageBody(LinkageBodyAST *linkageBody) +{ + m_linkageBody = linkageBody; + if (m_linkageBody) m_linkageBody->setParent(this); +} + +void LinkageSpecificationAST::setDeclaration(DeclarationAST *decl) +{ + m_declaration = decl; + if (m_declaration) m_declaration->setParent(this); +} + +// ------------------------------------------------------------------------ +TranslationUnitAST::TranslationUnitAST() + : m_declarationList(0) +{ + //kdDebug(9007) << "++ TranslationUnitAST::TranslationUnitAST()" << endl; +} + +void TranslationUnitAST::addDeclaration(DeclarationAST *ast) +{ + if(!ast) + return; + + ast->setParent(this); + m_declarationList = snoc(m_declarationList, ast, _pool); +} + +// ------------------------------------------------------------------------ +NamespaceAST::NamespaceAST() + : m_namespaceName(0), + m_linkageBody(0) +{ +} + +void NamespaceAST::setNamespaceName(AST *namespaceName) +{ + m_namespaceName = namespaceName; + if (m_namespaceName) m_namespaceName->setParent(this); +} + +void NamespaceAST::setLinkageBody(LinkageBodyAST *linkageBody) +{ + m_linkageBody = linkageBody; + if (m_linkageBody) m_linkageBody->setParent(this); +} + + +// ------------------------------------------------------------------------ +NamespaceAliasAST::NamespaceAliasAST() + : m_namespaceName(0), + m_aliasName(0) +{ +} + +void NamespaceAliasAST::setNamespaceName(AST *namespaceName) +{ + m_namespaceName = namespaceName; + if (m_namespaceName) m_namespaceName->setParent(this); +} + +void NamespaceAliasAST::setAliasName(NameAST *name) +{ + m_aliasName = name; + if (m_aliasName) m_aliasName->setParent(this); +} + +// ------------------------------------------------------------------------ +UsingAST::UsingAST() + : m_typeName(0), + m_name(0) +{ +} + +void UsingAST::setTypeName(AST *typeName) +{ + m_typeName = typeName; + if (m_typeName) m_typeName->setParent(this); +} + +void UsingAST::setName(NameAST *name) +{ + m_name = name; + if (m_name) m_name->setParent(this); +} + +// ------------------------------------------------------------------------ +UsingDirectiveAST::UsingDirectiveAST() + : m_name(0) +{ +} + +void UsingDirectiveAST::setName(NameAST *name) +{ + m_name = name; + if (m_name) m_name->setParent(this); +} + +TypedefAST::TypedefAST() + : m_typeSpec(0), + m_initDeclaratorList(0) +{ +} + +void TypeSpecifierAST::setName(NameAST *name) +{ + m_name = name; + if (m_name) m_name->setParent(this); +} + +void TypedefAST::setTypeSpec(TypeSpecifierAST *typeSpec) +{ + m_typeSpec = typeSpec; + if (m_typeSpec) m_typeSpec->setParent(this); +} + +void TypedefAST::setInitDeclaratorList(InitDeclaratorListAST *initDeclaratorList) +{ + m_initDeclaratorList = initDeclaratorList; + if (m_initDeclaratorList) m_initDeclaratorList->setParent(this); +} + +// ------------------------------------------------------------------------ +TemplateArgumentListAST::TemplateArgumentListAST() + : m_argumentList(0) +{ +} + +void TemplateArgumentListAST::addArgument(AST *arg) +{ + if(!arg) + return; + + arg->setParent(this); + m_argumentList = snoc(m_argumentList, arg, _pool); +} + +// ------------------------------------------------------------------------ +TemplateDeclarationAST::TemplateDeclarationAST() + : m_exported(0), + m_templateParameterList(0), + m_declaration(0) +{ +} + +void TemplateDeclarationAST::setExported(AST *exported) +{ + m_exported = exported; + if (m_exported) m_exported->setParent(this); +} + +void TemplateDeclarationAST::setTemplateParameterList(TemplateParameterListAST *templateParameterList) +{ + m_templateParameterList = templateParameterList; + if (m_templateParameterList) m_templateParameterList->setParent(this); +} + +void TemplateDeclarationAST::setDeclaration(DeclarationAST *declaration) +{ + m_declaration = declaration; + if (m_declaration) m_declaration->setParent(this); +} + +// ------------------------------------------------------------------------ +ClassOrNamespaceNameAST::ClassOrNamespaceNameAST() + : m_name(0), m_templateArgumentList(0) +{ +} + +void ClassOrNamespaceNameAST::setName(AST *name) +{ + m_name = name; + if (m_name) m_name->setParent(this); +} + +void ClassOrNamespaceNameAST::setTemplateArgumentList(TemplateArgumentListAST *templateArgumentList) +{ + m_templateArgumentList = templateArgumentList; + if (m_templateArgumentList) m_templateArgumentList->setParent(this); +} + +// ------------------------------------------------------------------------ +TypeSpecifierAST::TypeSpecifierAST() + : m_name(0), m_cvQualify(0), m_cv2Qualify(0) + +{ +} + +void TypeSpecifierAST::setCvQualify(AST *cvQualify) +{ + m_cvQualify = cvQualify; + if (m_cvQualify) m_cvQualify->setParent(this); +} + +void TypeSpecifierAST::setCv2Qualify(AST *cv2Qualify) +{ + m_cv2Qualify = cv2Qualify; + if (m_cv2Qualify) m_cv2Qualify->setParent(this); +} + +// ------------------------------------------------------------------------ +ClassSpecifierAST::ClassSpecifierAST() + : m_winDeclSpec(0), + m_classKey(0), + m_baseClause(0), + m_declarationList(0) +{ +} + +void ClassSpecifierAST::setClassKey(AST *classKey) +{ + m_classKey = classKey; + if (m_classKey) m_classKey->setParent(this); +} + +void ClassSpecifierAST::addDeclaration(DeclarationAST *declaration) +{ + if(!declaration) + return; + + declaration->setParent(this); + m_declarationList = snoc(m_declarationList, declaration, _pool); +} + +void ClassSpecifierAST::setBaseClause(BaseClauseAST *baseClause) +{ + m_baseClause = baseClause; + if (m_baseClause) m_baseClause->setParent(this); +} + +// ------------------------------------------------------------------------ +EnumSpecifierAST::EnumSpecifierAST() + : m_enumeratorList(0) +{ +} + +void EnumSpecifierAST::addEnumerator(EnumeratorAST *enumerator) +{ + if(!enumerator) + return; + + enumerator->setParent(this); + m_enumeratorList = snoc(m_enumeratorList, enumerator, _pool); +} + + +// ------------------------------------------------------------------------ +ElaboratedTypeSpecifierAST::ElaboratedTypeSpecifierAST() + : m_kind(0) +{ +} + +void ElaboratedTypeSpecifierAST::setKind(AST *kind) +{ + m_kind = kind; + if (m_kind) m_kind->setParent(this); +} + +// ------------------------------------------------------------------------ +EnumeratorAST::EnumeratorAST() + : m_id(0), + m_expression(0) +{ +} + +void EnumeratorAST::setId(AST *id) +{ + m_id = id; + if (m_id) m_id->setParent(this); +} + +void EnumeratorAST::setExpression(AbstractExpressionAST *expression) +{ + m_expression = expression; + if (m_expression) m_expression->setParent(this); +} + +// ------------------------------------------------------------------------ +BaseClauseAST::BaseClauseAST() + : m_baseSpecifierList(0) +{ +} + +void BaseClauseAST::addBaseSpecifier(BaseSpecifierAST *baseSpecifier) +{ + if(!baseSpecifier) + return; + + baseSpecifier->setParent(this); + m_baseSpecifierList = snoc(m_baseSpecifierList, baseSpecifier, _pool); +} + +// ------------------------------------------------------------------------ +BaseSpecifierAST::BaseSpecifierAST() + : m_isVirtual(0), m_access(0), m_name(0) + +{ +} + +void BaseSpecifierAST::setIsVirtual(AST *isVirtual) +{ + m_isVirtual = isVirtual; + if (m_isVirtual) m_isVirtual->setParent(this); +} + +void BaseSpecifierAST::setAccess(AST *access) +{ + m_access = access; + if (m_access) m_access->setParent(this); +} + +void BaseSpecifierAST::setName(NameAST *name) +{ + m_name = name; + if (m_name) m_name->setParent(this); +} + +// ------------------------------------------------------------------------ +SimpleDeclarationAST::SimpleDeclarationAST() + : m_functionSpecifier(0), + m_storageSpecifier(0), + m_typeSpec(0), + m_initDeclaratorList(0), + m_winDeclSpec(0) +{ +} + +void SimpleDeclarationAST::setFunctionSpecifier(AST *functionSpecifier) +{ + m_functionSpecifier = functionSpecifier; + if (m_functionSpecifier) m_functionSpecifier->setParent(this); +} + +void SimpleDeclarationAST::setStorageSpecifier(AST *storageSpecifier) +{ + m_storageSpecifier = storageSpecifier; + if (m_storageSpecifier) m_storageSpecifier->setParent(this); +} + +void SimpleDeclarationAST::setTypeSpec(TypeSpecifierAST *typeSpec) +{ + m_typeSpec = typeSpec; + if (m_typeSpec) m_typeSpec->setParent(this); +} + +void SimpleDeclarationAST::setInitDeclaratorList(InitDeclaratorListAST *initDeclaratorList) +{ + m_initDeclaratorList = initDeclaratorList; + if (m_initDeclaratorList) m_initDeclaratorList->setParent(this); +} + +void SimpleDeclarationAST::setWinDeclSpec(AST *winDeclSpec) +{ + m_winDeclSpec = winDeclSpec; + if (m_winDeclSpec) m_winDeclSpec->setParent(this); +} + +// ------------------------------------------------------------------------ +InitDeclaratorListAST::InitDeclaratorListAST() + : m_initDeclaratorList(0) +{ +} + +void InitDeclaratorListAST::addInitDeclarator(InitDeclaratorAST *decl) +{ + if(!decl) + return; + + decl->setParent(this); + m_initDeclaratorList = snoc(m_initDeclaratorList, decl, _pool); +} + +// ------------------------------------------------------------------------ +DeclaratorAST::DeclaratorAST() + : m_ptrOpList(0), + m_subDeclarator(0), + m_declaratorId(0), + m_bitfieldInitialization(0), + m_arrayDimensionList(0), + m_parameterDeclarationClause(0), + m_constant(0), + m_exceptionSpecification(0) +{ +} + +void DeclaratorAST::setSubDeclarator(DeclaratorAST *subDeclarator) +{ + m_subDeclarator = subDeclarator; + if (m_subDeclarator) m_subDeclarator->setParent(this); +} + +void DeclaratorAST::setDeclaratorId(NameAST *declaratorId) +{ + m_declaratorId = declaratorId; + if (m_declaratorId) m_declaratorId->setParent(this); +} + +void DeclaratorAST::setBitfieldInitialization(AST *bitfieldInitialization) +{ + m_bitfieldInitialization = bitfieldInitialization; + if (m_bitfieldInitialization) m_bitfieldInitialization->setParent(this); +} + +void DeclaratorAST::addArrayDimension(AST *arrayDimension) +{ + if(!arrayDimension) + return; + + arrayDimension->setParent(this); + m_arrayDimensionList = snoc(m_arrayDimensionList, arrayDimension, _pool); +} + +void DeclaratorAST::setParameterDeclarationClause(ParameterDeclarationClauseAST *parameterDeclarationClause) +{ + m_parameterDeclarationClause = parameterDeclarationClause; + if (m_parameterDeclarationClause) m_parameterDeclarationClause->setParent(this); +} + +void DeclaratorAST::setConstant(AST *constant) +{ + m_constant = constant; + if (m_constant) m_constant->setParent(this); +} + +void DeclaratorAST::setExceptionSpecification(AST *exceptionSpecification) +{ + m_exceptionSpecification = exceptionSpecification; + if (m_exceptionSpecification) m_exceptionSpecification->setParent(this); +} + +void DeclaratorAST::addPtrOp(AST *ptrOp) +{ + if(!ptrOp) + return; + + ptrOp->setParent(this); + m_ptrOpList = snoc(m_ptrOpList, ptrOp, _pool); +} + +// -------------------------------------------------------------------------- +InitDeclaratorAST::InitDeclaratorAST() + : m_declarator(0), + m_initializer(0) +{ +} + +void InitDeclaratorAST::setDeclarator(DeclaratorAST *declarator) +{ + m_declarator = declarator; + if (m_declarator) m_declarator->setParent(this); +} + +void InitDeclaratorAST::setInitializer(AST *initializer) +{ + m_initializer = initializer; + if (m_initializer) m_initializer->setParent(this); +} + +// -------------------------------------------------------------------------- +FunctionDefinitionAST::FunctionDefinitionAST() + : m_functionSpecifier(0), + m_storageSpecifier(0), + m_typeSpec(0), + m_initDeclarator(0), + m_functionBody(0), + m_winDeclSpec(0) +{ +} + +void FunctionDefinitionAST::setFunctionSpecifier(AST *functionSpecifier) +{ + m_functionSpecifier = functionSpecifier; + if (m_functionSpecifier) m_functionSpecifier->setParent(this); +} + +void FunctionDefinitionAST::setStorageSpecifier(AST *storageSpecifier) +{ + m_storageSpecifier = storageSpecifier; + if (m_storageSpecifier) m_storageSpecifier->setParent(this); +} + +void FunctionDefinitionAST::setTypeSpec(TypeSpecifierAST *typeSpec) +{ + m_typeSpec = typeSpec; + if (m_typeSpec) m_typeSpec->setParent(this); +} + +void FunctionDefinitionAST::setInitDeclarator(InitDeclaratorAST *initDeclarator) +{ + m_initDeclarator = initDeclarator; + if (m_initDeclarator) m_initDeclarator->setParent(this); +} + +void FunctionDefinitionAST::setFunctionBody(StatementListAST *functionBody) +{ + m_functionBody = functionBody; + if (m_functionBody) m_functionBody->setParent(this); +} + +void FunctionDefinitionAST::setWinDeclSpec(AST *winDeclSpec) +{ + m_winDeclSpec = winDeclSpec; + if (m_winDeclSpec) m_winDeclSpec->setParent(this); +} + +// -------------------------------------------------------------------------- +StatementListAST::StatementListAST() + : m_statementList(0) +{ +} + +void StatementListAST::addStatement(StatementAST *statement) +{ + if(!statement) + return; + + statement->setParent(this); + m_statementList = snoc(m_statementList, statement, _pool); +} + +// -------------------------------------------------------------------------- +IfStatementAST::IfStatementAST() + : m_condition(0), + m_statement(0), + m_elseStatement(0) +{ +} + +void IfStatementAST::setCondition(ConditionAST *condition) +{ + m_condition = condition; + if (m_condition) m_condition->setParent(this); +} + +void IfStatementAST::setStatement(StatementAST *statement) +{ + m_statement = statement; + if (m_statement) m_statement->setParent(this); +} + +void IfStatementAST::setElseStatement(StatementAST *elseStatement) +{ + m_elseStatement = elseStatement; + if (m_elseStatement) m_elseStatement->setParent(this); +} + +// -------------------------------------------------------------------------- +WhileStatementAST::WhileStatementAST() + : m_condition(0), + m_statement(0) +{ +} + +void WhileStatementAST::setCondition(ConditionAST *condition) +{ + m_condition = condition; + if (m_condition) m_condition->setParent(this); +} + +void WhileStatementAST::setStatement(StatementAST *statement) +{ + m_statement = statement; + if (m_statement) m_statement->setParent(this); +} + +// -------------------------------------------------------------------------- +DoStatementAST::DoStatementAST() + : m_condition(0), + m_statement(0) +{ +} + +void DoStatementAST::setCondition(ConditionAST *condition) +{ + m_condition = condition; + if (m_condition) m_condition->setParent(this); +} + +void DoStatementAST::setStatement(StatementAST *statement) +{ + m_statement = statement; + if (m_statement) m_statement->setParent(this); +} + +// -------------------------------------------------------------------------- +ForStatementAST::ForStatementAST() + : m_condition(0), + m_initStatement(0), + m_statement(0), + m_expression(0) +{ +} + +void ForStatementAST::setCondition(ConditionAST *condition) +{ + m_condition = condition; + if (m_condition) m_condition->setParent(this); +} + +void ForStatementAST::setExpression(AbstractExpressionAST *expression) +{ + m_expression = expression; + if (m_expression) m_expression->setParent(this); +} + +void ForStatementAST::setStatement(StatementAST *statement) +{ + m_statement = statement; + if (m_statement) m_statement->setParent(this); +} + +void ForStatementAST::setInitStatement(StatementAST *initStatement) +{ + m_initStatement = initStatement; + if (m_initStatement) m_initStatement->setParent(this); +} + +// -------------------------------------------------------------------------- +SwitchStatementAST::SwitchStatementAST() + : m_condition(0), + m_statement(0) +{ +} + +void SwitchStatementAST::setCondition(ConditionAST *condition) +{ + m_condition = condition; + if (m_condition) m_condition->setParent(this); +} + +void SwitchStatementAST::setStatement(StatementAST *statement) +{ + m_statement = statement; + if (m_statement) m_statement->setParent(this); +} + +// -------------------------------------------------------------------------- +DeclarationStatementAST::DeclarationStatementAST() + : m_declaration(0) +{ +} + +void DeclarationStatementAST::setDeclaration(DeclarationAST *declaration) +{ + m_declaration = declaration; + if (m_declaration) m_declaration->setParent(this); +} + +// -------------------------------------------------------------------------- +LabeledStatementAST::LabeledStatementAST() + : m_statement(0), m_expression(0) +{ +} + +void LabeledStatementAST::setStatement(StatementAST *statement) +{ + m_statement = statement; + if (m_statement) m_statement->setParent(this); +} + +void LabeledStatementAST::setExpression(AbstractExpressionAST *expression) +{ + m_expression = expression; + if (m_expression) m_expression->setParent(this); +} + +// -------------------------------------------------------------------------- +ExpressionStatementAST::ExpressionStatementAST() + : m_expression(0) +{ +} + +void ExpressionStatementAST::setExpression(AbstractExpressionAST *expression) +{ + m_expression = expression; + if (m_expression) m_expression->setParent(this); +} + + +// -------------------------------------------------------------------------- +ParameterDeclarationAST::ParameterDeclarationAST() + : m_typeSpec(0), + m_declarator(0), + m_expression(0) +{ +} + +void ParameterDeclarationAST::setTypeSpec(TypeSpecifierAST *typeSpec) +{ + m_typeSpec = typeSpec; + if (m_typeSpec) m_typeSpec->setParent(this); +} + +void ParameterDeclarationAST::setDeclarator(DeclaratorAST *declarator) +{ + m_declarator = declarator; + if (m_declarator) m_declarator->setParent(this); +} + +void ParameterDeclarationAST::setExpression(AbstractExpressionAST *expression) +{ + m_expression = expression; + if (m_expression) m_expression->setParent(this); +} + +// -------------------------------------------------------------------------- +ParameterDeclarationListAST::ParameterDeclarationListAST() + : m_parameterList(0) +{ +} + +void ParameterDeclarationListAST::addParameter(ParameterDeclarationAST *parameter) +{ + if(!parameter) + return; + + parameter->setParent(this); + m_parameterList = snoc(m_parameterList, parameter, _pool); +} + +// -------------------------------------------------------------------------- +ParameterDeclarationClauseAST::ParameterDeclarationClauseAST() + : m_parameterDeclarationList(0), + m_ellipsis(0) +{ +} + +void ParameterDeclarationClauseAST::setParameterDeclarationList(ParameterDeclarationListAST *parameterDeclarationList) +{ + m_parameterDeclarationList = parameterDeclarationList; + if (m_parameterDeclarationList) m_parameterDeclarationList->setParent(this); +} + +void ParameterDeclarationClauseAST::setEllipsis(AST *ellipsis) +{ + m_ellipsis = ellipsis; + if (m_ellipsis) m_ellipsis->setParent(this); +} + +// -------------------------------------------------------------------------- +AccessDeclarationAST::AccessDeclarationAST() + : m_accessList(0) +{ +} + +void AccessDeclarationAST::addAccess(AST *access) +{ + if(!access) + return; + + access->setParent(this); + m_accessList = snoc(m_accessList, access, _pool); +} + +// -------------------------------------------------------------------------- +TypeParameterAST::TypeParameterAST() + : m_kind(0), m_templateParameterList(0), + m_name(0), m_typeId(0) + +{ +} + +void TypeParameterAST::setKind(AST *kind) +{ + m_kind = kind; +} + +void TypeParameterAST::setTemplateParameterList(TemplateParameterListAST *templateParameterList) +{ + m_templateParameterList = templateParameterList; + if (m_templateParameterList) m_templateParameterList->setParent(this); +} + +void TypeParameterAST::setName(NameAST *name) +{ + m_name = name; + if (m_name) m_name->setParent(this); +} + +void TypeParameterAST::setTypeId(AST *typeId) +{ + m_typeId = typeId; + if (m_typeId) m_typeId->setParent(this); +} + +// -------------------------------------------------------------------------- +TemplateParameterAST::TemplateParameterAST() + : m_typeParameter(0), + m_typeValueParameter(0) +{ +} + +void TemplateParameterAST::setTypeParameter(TypeParameterAST *typeParameter) +{ + m_typeParameter = typeParameter; + if (m_typeParameter) m_typeParameter->setParent(this); +} + +void TemplateParameterAST::setTypeValueParameter(ParameterDeclarationAST *typeValueParameter) +{ + m_typeValueParameter = typeValueParameter; + if (m_typeValueParameter) m_typeValueParameter->setParent(this); +} + +// -------------------------------------------------------------------------- +TemplateParameterListAST::TemplateParameterListAST() + : m_templateParameterList(0) +{ +} + +void TemplateParameterListAST::addTemplateParameter(TemplateParameterAST *templateParameter) +{ + if(!templateParameter) + return; + + templateParameter->setParent(this); + m_templateParameterList = snoc(m_templateParameterList, templateParameter, _pool); +} + +// -------------------------------------------------------------------------- +ConditionAST::ConditionAST() + : m_typeSpec(0), + m_declarator(0), + m_expression(0) +{ +} + +void ConditionAST::setTypeSpec(TypeSpecifierAST *typeSpec) +{ + m_typeSpec = typeSpec; + if (m_typeSpec) m_typeSpec->setParent(this); +} + +void ConditionAST::setDeclarator(DeclaratorAST *declarator) +{ + m_declarator = declarator; + if (m_declarator) m_declarator->setParent(this); +} + +void ConditionAST::setExpression(AbstractExpressionAST *expression) +{ + m_expression = expression; + if (m_expression) m_expression->setParent(this); +} + +void ClassSpecifierAST::setWinDeclSpec(AST *winDeclSpec) +{ + m_winDeclSpec = winDeclSpec; + if (m_winDeclSpec) m_winDeclSpec->setParent(this); +} + +// -------------------------------------------------------------------------- +ReturnStatementAST::ReturnStatementAST() + : m_expression(0) +{ +} + +void ReturnStatementAST::setExpression(AbstractExpressionAST *expression) +{ + m_expression = expression; + if (m_expression) m_expression->setParent(this); +} + +// -------------------------------------------------------------------------- +BinaryExpressionAST::BinaryExpressionAST() + : m_op(0), m_left(0), m_right(0) +{ +} + +void BinaryExpressionAST::setOp(AST *op) +{ + m_op = op; + if (m_op) + m_op->setParent(this); +} + +void BinaryExpressionAST::setLeftExpression(AbstractExpressionAST *left) +{ + m_left = left; + if (m_left) + m_left->setParent(this); +} + +void BinaryExpressionAST::setRightExpression(AbstractExpressionAST *right) +{ + m_right = right; + if (m_right) + m_right->setParent(this); +} + +// -------------------------------------------------------------------------- +ConditionalExpressionAST::ConditionalExpressionAST() + : m_condition(0), m_left(0), m_right(0) +{ +} + +void ConditionalExpressionAST::setCondition(AbstractExpressionAST *condition) +{ + m_condition = condition; + if (m_condition) + m_condition->setParent(this); +} + +void ConditionalExpressionAST::setLeftExpression(AbstractExpressionAST *left) +{ + m_left = left; + if (m_left) + m_left->setParent(this); +} + +void ConditionalExpressionAST::setRightExpression(AbstractExpressionAST *right) +{ + m_right = right; + if (m_right) + m_right->setParent(this); +} + +// -------------------------------------------------------------------------- +CppCastExpressionAST::CppCastExpressionAST() + : m_castOp(0), m_typeId(0), m_expression(0) +{ +} + +void CppCastExpressionAST::setCastOp(AST *castOp) +{ + m_castOp = castOp; + if (m_castOp) + m_castOp->setParent(this); +} + +void CppCastExpressionAST::setTypeId(AST *typeId) +{ + m_typeId = typeId; + if (m_typeId) + m_typeId->setParent(this); +} + +void CppCastExpressionAST::setExpression(AbstractExpressionAST *expression) +{ + m_expression = expression; + if (m_expression) + m_expression->setParent(this); +} + +// -------------------------------------------------------------------------- +SubscriptingAST::SubscriptingAST() + : m_expression(0), m_subscript(0) +{ +} + +void SubscriptingAST::setSubscript(AbstractExpressionAST *subscript) +{ + m_subscript = subscript; + if (m_subscript) + m_subscript->setParent(this); +} + +void SubscriptingAST::setExpression(AbstractExpressionAST *expression) +{ + m_expression = expression; + if (m_expression) + m_expression->setParent(this); +} + +// -------------------------------------------------------------------------- +FunctionCallAST::FunctionCallAST() + : m_expression(0), m_arguments(0) +{ +} + +void FunctionCallAST::setExpression(AbstractExpressionAST *expression) +{ + m_expression = expression; + if (m_expression) + m_expression->setParent(this); +} + +void FunctionCallAST::setArguments(AbstractExpressionAST *arguments) +{ + m_arguments = arguments; + if (m_arguments) + m_arguments->setParent(this); +} + +// -------------------------------------------------------------------------- +ExplicitTypeConversionAST::ExplicitTypeConversionAST() +{ +} + +// -------------------------------------------------------------------------- +PseudoDestructorCallAST::PseudoDestructorCallAST() +{ +} + +// -------------------------------------------------------------------------- +ClassMemberAccessAST::ClassMemberAccessAST() + : m_op(0), m_expression(0), m_templ(0), m_name(0) +{ +} + +void ClassMemberAccessAST::setOp(AST *op) +{ + m_op = op; + if (m_op) + m_op->setParent(this); +} + +void ClassMemberAccessAST::setExpression(AbstractExpressionAST *expression) +{ + m_expression = expression; + if (m_expression) + m_expression->setParent(this); +} + +void ClassMemberAccessAST::setName(NameAST *name) +{ + m_name = name; + if (m_name) + m_name->setParent(this); +} + +// -------------------------------------------------------------------------- +IncrDecrAST::IncrDecrAST() + : m_op(0), m_expression(0) +{ +} + +void IncrDecrAST::setOp(AST *op) +{ + m_op = op; + if (m_op) + m_op->setParent(this); +} + +void IncrDecrAST::setExpression(AbstractExpressionAST *expression) +{ + m_expression = expression; + if (m_expression) + m_expression->setParent(this); +} + +// -------------------------------------------------------------------------- +TypeIdentificationAST::TypeIdentificationAST() +{ +} + +// -------------------------------------------------------------------------- +TypeIdAST::TypeIdAST() + : m_typeSpecifier(0), m_declarator(0) +{ +} + +void TypeIdAST::setTypeSpecifier(TypeSpecifierAST *typeSpecifier) +{ + m_typeSpecifier = typeSpecifier; + if (m_typeSpecifier) + m_typeSpecifier->setParent(this); +} + +void TypeIdAST::setDeclarator(DeclaratorAST *declarator) +{ + m_declarator = declarator; + if (m_declarator) + m_declarator->setParent(this); +} + +// -------------------------------------------------------------------------- +AbstractExpressionAST::AbstractExpressionAST() +{ + m_symbol = 0; +} + +QT_END_NAMESPACE diff --git a/tools/porting/src/ast.h b/tools/porting/src/ast.h new file mode 100644 index 0000000..e164ed4 --- /dev/null +++ b/tools/porting/src/ast.h @@ -0,0 +1,1598 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef AST_H +#define AST_H + +#include "smallobject.h" +#include "list.h" + +QT_BEGIN_NAMESPACE + +class AST; +class NameAST; +class TypeIdAST; +class TypeSpecifierAST; +class DeclaratorAST; + +class Symbol; +class Scope; + +enum NodeType +{ + NodeType_Generic = 0, + + NodeType_TemplateArgumentList = 1000, + NodeType_ClassOrNamespaceName, + NodeType_Name, + NodeType_Declaration, + NodeType_TypeSpecifier, + NodeType_BaseSpecifier, + NodeType_BaseClause, + NodeType_ClassSpecifier, + NodeType_Enumerator, + NodeType_EnumSpecifier, + NodeType_ElaboratedTypeSpecifier, + NodeType_LinkageBody, + NodeType_LinkageSpecification, + NodeType_Namespace, + NodeType_NamespaceAlias, + NodeType_Using, + NodeType_UsingDirective, + NodeType_InitDeclaratorList, + NodeType_Typedef, + NodeType_Declarator, + NodeType_InitDeclarator, + NodeType_TemplateDeclaration, + NodeType_SimpleDeclaration, + NodeType_Statement, + NodeType_StatementList, + NodeType_IfStatement, + NodeType_WhileStatement, + NodeType_DoStatement, + NodeType_ForStatement, + NodeType_SwitchStatement, + NodeType_DeclarationStatement, + NodeType_LabeledStatement, + NodeType_ReturnStatement, + NodeType_TranslationUnit, + NodeType_FunctionDefinition, + NodeType_ExpressionStatement, + NodeType_ParameterDeclaration, + NodeType_ParameterDeclarationList, + NodeType_ParameterDeclarationClause, + NodeType_AccessDeclaration, + NodeType_TypeParameter, + NodeType_TemplateParameter, + NodeType_TemplateParameterList, + NodeType_Condition, + + NodeType_TypeId, + + NodeType_Expression = 2000, + NodeType_BinaryExpression, + NodeType_PrimaryExpression, + +// +// postfix expression +// + NodeType_PostfixExpression, + NodeType_Subscripting, + NodeType_FunctionCall, + NodeType_ExplicitTypeConversion, + NodeType_PseudoConstructorCall, + NodeType_ClassMemberAccess, + NodeType_IncrDecr, + NodeType_CppCastExpression, + NodeType_TypeIdentification, + + NodeType_UnaryExpression, + NodeType_NewExpression, + NodeType_NewTypeId, + NodeType_NewDeclarator, + NodeType_NewInitializer, + NodeType_DeleteExpression, + NodeType_CastExpression, + NodeType_ConditionalExpression, + NodeType_ThrowExpression, + + NodeType_Custom = 3000 +}; + + +template <typename T> +inline int length(List<T> *e) +{ + return e ? e->size() : 0; +} + +class AST +{ +public: + enum { Type=NodeType_Generic }; + + pool *_pool; + + static int N; + +public: + AST(int startToken=0, int count=1); + virtual ~AST() { --N; } + + inline int startToken() const + { return m_startToken; } + + inline int endToken() const + { return m_endToken; } + + inline void setPosition(int startToken, int endToken) + { + m_startToken = startToken; + m_endToken = endToken; + } + + inline int nodeType() const + { return m_nodeType; } + + inline void setNodeType(int nodeType) + { m_nodeType = nodeType; } + + inline AST *parent() const + { return m_parent; } + + void setParent(AST *parent); + + inline List<AST *> *children() const + { return m_children; } + + void appendChild(AST *child); + void removeChild(AST *child); + +// ### move + inline Scope *scope() const + { + if (m_scope) + return m_scope; + + return m_parent ? m_parent->scope() : 0; + } + + inline void setScope(Scope *scope) + { m_scope = scope; } + +private: + Scope *m_scope; + int m_nodeType; + int m_startToken; + int m_endToken; + AST *m_parent; + List<AST *> *m_children; + +private: + AST(const AST &source); + void operator = (const AST &source); +}; + +class AbstractExpressionAST: public AST +{ +public: + enum { Type = NodeType_Expression }; + + AbstractExpressionAST(); + + inline Symbol *symbol() const + { return m_symbol; } + + inline void setSymbol(Symbol *symbol) + { m_symbol = symbol; } + +private: + Symbol *m_symbol; +}; + +// ### remove me +template <int kind, class Base = AbstractExpressionAST> +class ExpressionAST: public Base +{ +public: + enum { Type = kind }; + +public: + inline ExpressionAST() {} + +private: + ExpressionAST(const ExpressionAST &source); + void operator = (const ExpressionAST &source); +}; + +class BinaryExpressionAST: public AbstractExpressionAST +{ +public: + enum { Type = NodeType_BinaryExpression }; + +public: + BinaryExpressionAST(); + + inline AST *op() const + { return m_op; } + + inline AbstractExpressionAST *leftExpression() const + { return m_left; } + + inline AbstractExpressionAST *rightExpression() const + { return m_right; } + + void setOp(AST *op); + void setLeftExpression(AbstractExpressionAST *left); + void setRightExpression(AbstractExpressionAST *right); + +private: + AST *m_op; + AbstractExpressionAST *m_left; + AbstractExpressionAST *m_right; + +private: + BinaryExpressionAST(const BinaryExpressionAST &source); + void operator = (const BinaryExpressionAST &source); +}; + +class ConditionalExpressionAST: public AbstractExpressionAST +{ +public: + enum { Type = NodeType_ConditionalExpression }; + +public: + ConditionalExpressionAST(); + + inline AbstractExpressionAST *condition() const + { return m_condition; } + + inline AbstractExpressionAST *leftExpression() const + { return m_left; } + + inline AbstractExpressionAST *rightExpression() const + { return m_right; } + + void setCondition(AbstractExpressionAST *condition); + void setLeftExpression(AbstractExpressionAST *left); + void setRightExpression(AbstractExpressionAST *right); + +private: + AbstractExpressionAST *m_condition; + AbstractExpressionAST *m_left; + AbstractExpressionAST *m_right; + +private: + ConditionalExpressionAST(const ConditionalExpressionAST& source); + void operator = (const ConditionalExpressionAST &source); +}; + + +// +// postfix expression +// + +class SubscriptingAST: public AbstractExpressionAST +{ +public: + enum { Type = NodeType_Subscripting }; + +public: + SubscriptingAST(); + + inline AbstractExpressionAST *expression() const + { return m_expression; } + + inline AbstractExpressionAST *subscript() const + { return m_subscript; } + + void setExpression(AbstractExpressionAST *expression); + void setSubscript(AbstractExpressionAST *subscript); + +private: + AbstractExpressionAST *m_expression; + AbstractExpressionAST *m_subscript; + +private: + SubscriptingAST(const SubscriptingAST &source); + void operator = (const SubscriptingAST &source); +}; + +class FunctionCallAST: public AbstractExpressionAST +{ +public: + enum { Type = NodeType_FunctionCall }; + +public: + FunctionCallAST(); + + inline AbstractExpressionAST *expression() const + { return m_expression; } + + inline AbstractExpressionAST *arguments() const + { return m_arguments; } + + void setExpression(AbstractExpressionAST *expression); + void setArguments(AbstractExpressionAST *arguments); + +private: + AbstractExpressionAST *m_expression; + AbstractExpressionAST *m_arguments; + +private: + FunctionCallAST(const FunctionCallAST &source); + void operator = (const FunctionCallAST &source); +}; + +class ExplicitTypeConversionAST: public AbstractExpressionAST +{ +public: + enum { Type = NodeType_ExplicitTypeConversion }; + +public: + ExplicitTypeConversionAST(); + +private: + ExplicitTypeConversionAST(const ExplicitTypeConversionAST &source); + void operator = (const ExplicitTypeConversionAST &source); +}; + +class PseudoDestructorCallAST: public AbstractExpressionAST +{ +public: + enum { Type = NodeType_PseudoConstructorCall }; + +public: + PseudoDestructorCallAST(); + +private: + PseudoDestructorCallAST(const PseudoDestructorCallAST &source); + void operator = (const PseudoDestructorCallAST &source); +}; + +class ClassMemberAccessAST: public AbstractExpressionAST +{ +public: + enum { Type = NodeType_ClassMemberAccess }; + +public: + ClassMemberAccessAST(); + + inline AST *op() const + { return m_op; } + + inline AbstractExpressionAST *expression() const + { return m_expression; } + + inline NameAST *name() const + { return m_name; } + + void setOp(AST *op); + void setExpression(AbstractExpressionAST *expression); + void setName(NameAST *name); + +private: + AST *m_op; + AbstractExpressionAST *m_expression; + AST *m_templ; + NameAST *m_name; + +private: + ClassMemberAccessAST(const ClassMemberAccessAST &source); + void operator = (const ClassMemberAccessAST &source); +}; + +class IncrDecrAST: public AbstractExpressionAST +{ +public: + enum { Type = NodeType_IncrDecr }; + +public: + IncrDecrAST(); + + inline AST *op() const + { return m_op; } + + inline AbstractExpressionAST *expression() const + { return m_expression; } + + void setOp(AST *op); + void setExpression(AbstractExpressionAST *expression); + +private: + AST *m_op; + AbstractExpressionAST *m_expression; + +private: + IncrDecrAST(const IncrDecrAST &source); + void operator = (const IncrDecrAST &source); +}; + +class CppCastExpressionAST: public AbstractExpressionAST +{ +public: + enum { Type = NodeType_CppCastExpression }; + +public: + CppCastExpressionAST(); + + inline AST *castOp() const + { return m_castOp; } + + inline AST *typeId() const + { return m_typeId; } + + inline AbstractExpressionAST *expression() const + { return m_expression; } + + void setCastOp(AST *castOp); + void setTypeId(AST *typeId); + void setExpression(AbstractExpressionAST *expression); + +private: + AST *m_castOp; + AST *m_typeId; + AbstractExpressionAST *m_expression; + +private: + CppCastExpressionAST(const CppCastExpressionAST &source); + void operator = (const CppCastExpressionAST &source); +}; + +class TypeIdentificationAST: public AbstractExpressionAST +{ +public: + enum { Type = NodeType_TypeIdentification }; + +public: + TypeIdentificationAST(); + +private: + TypeIdentificationAST(const TypeIdentificationAST &source); + void operator = (const TypeIdentificationAST &source); +}; + +class TypeIdAST: public AST +{ +public: + enum { Type = NodeType_TypeId }; + +public: + TypeIdAST(); + + inline TypeSpecifierAST *typeSpecifier() const + { return m_typeSpecifier; } + + inline DeclaratorAST *declarator() const + { return m_declarator; } + + void setTypeSpecifier(TypeSpecifierAST *typeSpecifier); + void setDeclarator(DeclaratorAST *declarator); + +private: + TypeSpecifierAST *m_typeSpecifier; + DeclaratorAST *m_declarator; + +private: + TypeIdAST(const TypeIdAST &source); + void operator = (const TypeIdAST &source); +}; + +class StatementAST: public AST +{ +public: + enum { Type = NodeType_Statement }; +}; + +class TemplateArgumentListAST: public AST +{ +public: + enum { Type = NodeType_TemplateArgumentList }; + +public: + TemplateArgumentListAST(); + + void addArgument(AST *arg); + inline List<AST *> *argumentList() const { return m_argumentList; } + +private: + List<AST *> *m_argumentList; + +private: + TemplateArgumentListAST(const TemplateArgumentListAST &source); + void operator = (const TemplateArgumentListAST &source); +}; + +class ClassOrNamespaceNameAST: public AST +{ +public: + enum { Type = NodeType_ClassOrNamespaceName }; + +public: + ClassOrNamespaceNameAST(); + + inline AST *name() const { return m_name; } + void setName(AST *name); + + inline TemplateArgumentListAST *templateArgumentList() const { return m_templateArgumentList; } + void setTemplateArgumentList(TemplateArgumentListAST *templateArgumentList); + +private: + AST* m_name; + TemplateArgumentListAST* m_templateArgumentList; + +private: + ClassOrNamespaceNameAST(const ClassOrNamespaceNameAST &source); + void operator = (const ClassOrNamespaceNameAST &source); +}; + +class NameAST: public AST +{ +public: + enum { Type = NodeType_Name }; + +public: + NameAST(); + + inline bool isGlobal() const { return m_global; } + void setGlobal(bool b); + + void addClassOrNamespaceName(ClassOrNamespaceNameAST *classOrNamespaceName); + inline List<ClassOrNamespaceNameAST *> *classOrNamespaceNameList() const { return m_classOrNamespaceNameList; } + + inline ClassOrNamespaceNameAST *unqualifiedName() const { return m_unqualifiedName; } + void setUnqualifiedName(ClassOrNamespaceNameAST *unqualifiedName); + +private: + bool m_global; + ClassOrNamespaceNameAST* m_unqualifiedName; + List<ClassOrNamespaceNameAST *> *m_classOrNamespaceNameList; + +private: + NameAST(const NameAST &source); + void operator = (const NameAST &source); +}; + +class TypeParameterAST: public AST +{ +public: + enum { Type = NodeType_TypeParameter }; + +public: + TypeParameterAST(); + + inline AST *kind() const { return m_kind; } + void setKind(AST *kind); + + inline class TemplateParameterListAST *templateParameterList() const { return m_templateParameterList; } + void setTemplateParameterList(class TemplateParameterListAST *templateParameterList); + + inline NameAST *name() const { return m_name; } + void setName(NameAST *name); + + inline AST *typeId() const { return m_typeId; } + void setTypeId(AST *typeId); + +private: + AST* m_kind; + class TemplateParameterListAST *m_templateParameterList; + NameAST* m_name; + AST* m_typeId; + +private: + TypeParameterAST(const TypeParameterAST &source); + void operator = (const TypeParameterAST &source); +}; + +class DeclarationAST: public AST +{ +public: + enum { Type = NodeType_Declaration }; + +public: + DeclarationAST(); + +private: + DeclarationAST(const DeclarationAST &source); + void operator = (const DeclarationAST &source); +}; + +class AccessDeclarationAST: public DeclarationAST +{ +public: + enum { Type = NodeType_AccessDeclaration }; + +public: + AccessDeclarationAST(); + + inline List<AST *> *accessList() const { return m_accessList; } + void addAccess(AST *access); + +private: + List<AST *> *m_accessList; + +private: + AccessDeclarationAST(const AccessDeclarationAST &source); + void operator = (const AccessDeclarationAST &source); +}; + +class TypeSpecifierAST: public AST +{ +public: + enum { Type = NodeType_TypeSpecifier }; + +public: + TypeSpecifierAST(); + + inline virtual NameAST *name() const { return m_name; } + virtual void setName(NameAST *name); + + inline AST *cvQualify() const { return m_cvQualify; } + void setCvQualify(AST *cvQualify); + + inline AST *cv2Qualify() const { return m_cv2Qualify; } + void setCv2Qualify(AST *cv2Qualify); + +private: + NameAST* m_name; + AST* m_cvQualify; + AST* m_cv2Qualify; + +private: + TypeSpecifierAST(const TypeSpecifierAST &source); + void operator = (const TypeSpecifierAST &source); +}; + +class BaseSpecifierAST: public AST +{ +public: + enum { Type = NodeType_BaseSpecifier }; + +public: + BaseSpecifierAST(); + + inline AST *isVirtual() const { return m_isVirtual; } + void setIsVirtual(AST *isVirtual); + + inline AST *access() const { return m_access; } + void setAccess(AST *access); + + inline NameAST *name() const { return m_name; } + void setName(NameAST *name); + +private: + AST* m_isVirtual; + AST* m_access; + NameAST* m_name; + +private: + BaseSpecifierAST(const BaseSpecifierAST &source); + void operator = (const BaseSpecifierAST &source); +}; + +class BaseClauseAST: public AST +{ +public: + enum { Type = NodeType_BaseClause }; + +public: + BaseClauseAST(); + + void addBaseSpecifier(BaseSpecifierAST *baseSpecifier); + inline List<BaseSpecifierAST *> *baseSpecifierList() const { return m_baseSpecifierList; } + +private: + List<BaseSpecifierAST *> *m_baseSpecifierList; + +private: + BaseClauseAST(const BaseClauseAST &source); + void operator = (const BaseClauseAST &source); +}; + +class ClassSpecifierAST: public TypeSpecifierAST +{ +public: + enum { Type = NodeType_ClassSpecifier }; + +public: + ClassSpecifierAST(); + + inline AST *winDeclSpec() const { return m_winDeclSpec; } + void setWinDeclSpec(AST *winDeclSpec); + + inline AST *classKey() const { return m_classKey; } + void setClassKey(AST *classKey); + + inline BaseClauseAST *baseClause() const { return m_baseClause; } + void setBaseClause(BaseClauseAST *baseClause); + + inline List<DeclarationAST *> *declarationList() const { return m_declarationList; } + void addDeclaration(DeclarationAST *declaration); + +private: + AST* m_winDeclSpec; + AST* m_classKey; + BaseClauseAST* m_baseClause; + List<DeclarationAST *> *m_declarationList; + +private: + ClassSpecifierAST(const ClassSpecifierAST &source); + void operator = (const ClassSpecifierAST &source); +}; + +class EnumeratorAST: public AST +{ +public: + enum { Type = NodeType_Enumerator }; + +public: + EnumeratorAST(); + + inline AST *id() const { return m_id; } + void setId(AST *id); + + inline AbstractExpressionAST *expression() const { return m_expression; } + void setExpression(AbstractExpressionAST *expr); + +private: + AST* m_id; + AbstractExpressionAST* m_expression; + +private: + EnumeratorAST(const EnumeratorAST &source); + void operator = (const EnumeratorAST &source); +}; + +class EnumSpecifierAST: public TypeSpecifierAST +{ +public: + enum { Type = NodeType_EnumSpecifier }; + +public: + EnumSpecifierAST(); + + void addEnumerator(EnumeratorAST *enumerator); + inline List<EnumeratorAST *> *enumeratorList() const { return m_enumeratorList; } + +private: + List<EnumeratorAST *> *m_enumeratorList; + +private: + EnumSpecifierAST(const EnumSpecifierAST &source); + void operator = (const EnumSpecifierAST &source); +}; + +class ElaboratedTypeSpecifierAST: public TypeSpecifierAST +{ +public: + enum { Type = NodeType_ElaboratedTypeSpecifier }; + +public: + ElaboratedTypeSpecifierAST(); + + inline AST *kind() const { return m_kind; } + void setKind(AST *kind); + +private: + AST* m_kind; + +private: + ElaboratedTypeSpecifierAST(const ElaboratedTypeSpecifierAST &source); + void operator = (const ElaboratedTypeSpecifierAST &source); +}; + + +class LinkageBodyAST: public AST +{ +public: + enum { Type = NodeType_LinkageBody }; + +public: + LinkageBodyAST(); + + void addDeclaration(DeclarationAST *ast); + inline List<DeclarationAST *> *declarationList() const { return m_declarationList; } + +private: + List<DeclarationAST *> *m_declarationList; + +private: + LinkageBodyAST(const LinkageBodyAST &source); + void operator = (const LinkageBodyAST &source); +}; + +class LinkageSpecificationAST: public DeclarationAST +{ +public: + enum { Type = NodeType_LinkageSpecification }; + +public: + LinkageSpecificationAST(); + + inline AST *externType() const { return m_externType; } + void setExternType(AST *externType); + + inline LinkageBodyAST *linkageBody() const { return m_linkageBody; } + void setLinkageBody(LinkageBodyAST *linkageBody); + + inline DeclarationAST *declaration() const { return m_declaration; } + void setDeclaration(DeclarationAST *decl); + +private: + AST* m_externType; + LinkageBodyAST* m_linkageBody; + DeclarationAST* m_declaration; + +private: + LinkageSpecificationAST(const LinkageSpecificationAST &source); + void operator = (const LinkageSpecificationAST &source); +}; + +class NamespaceAST: public DeclarationAST +{ +public: + enum { Type = NodeType_Namespace }; + +public: + NamespaceAST(); + + inline AST *namespaceName() const { return m_namespaceName; } + void setNamespaceName(AST *namespaceName); + + inline LinkageBodyAST *linkageBody() const { return m_linkageBody; } + void setLinkageBody(LinkageBodyAST *linkageBody); + +private: + AST* m_namespaceName; + LinkageBodyAST* m_linkageBody; + +private: + NamespaceAST(const NamespaceAST &source); + void operator = (const NamespaceAST &source); +}; + +class NamespaceAliasAST: public DeclarationAST +{ +public: + enum { Type = NodeType_NamespaceAlias }; + +public: + NamespaceAliasAST(); + + inline AST *namespaceName() const { return m_namespaceName; } + void setNamespaceName(AST *name); + + inline NameAST *aliasName() const { return m_aliasName; } + void setAliasName(NameAST *name); + +private: + AST* m_namespaceName; + NameAST* m_aliasName; + +private: + NamespaceAliasAST(const NamespaceAliasAST &source); + void operator = (const NamespaceAliasAST &source); +}; + +class UsingAST: public DeclarationAST +{ +public: + enum { Type = NodeType_Using }; + +public: + UsingAST(); + + inline AST *typeName() const { return m_typeName; } + void setTypeName(AST *typeName); + + inline NameAST *name() const { return m_name; } + void setName(NameAST *name); + +private: + AST* m_typeName; + NameAST* m_name; + +private: + UsingAST(const UsingAST &source); + void operator = (const UsingAST &source); +}; + +class UsingDirectiveAST: public DeclarationAST +{ +public: + enum { Type = NodeType_UsingDirective }; + +public: + UsingDirectiveAST(); + + inline NameAST *name() const { return m_name; } + void setName(NameAST *name); + +private: + NameAST* m_name; + +private: + UsingDirectiveAST(const UsingDirectiveAST &source); + void operator = (const UsingDirectiveAST &source); +}; + +class DeclaratorAST: public AST +{ +public: + enum { Type = NodeType_Declarator }; + +public: + DeclaratorAST(); + + inline List<AST *> *ptrOpList() const { return m_ptrOpList; } + void addPtrOp(AST *ptrOp); + + inline DeclaratorAST *subDeclarator() const { return m_subDeclarator; } + void setSubDeclarator(DeclaratorAST *subDeclarator); + + inline NameAST *declaratorId() const { return m_declaratorId; } + void setDeclaratorId(NameAST *declaratorId); + + inline AST *bitfieldInitialization() const { return m_bitfieldInitialization; } + void setBitfieldInitialization(AST *bitfieldInitialization); + + inline List<AST *> *arrayDimensionList() const { return m_arrayDimensionList; } + void addArrayDimension(AST *arrayDimension); + + inline class ParameterDeclarationClauseAST *parameterDeclarationClause() const { return m_parameterDeclarationClause; } + void setParameterDeclarationClause(class ParameterDeclarationClauseAST *parameterDeclarationClause); + + // ### replace 'constant' with cvQualify + inline AST *constant() const { return m_constant; } + void setConstant(AST *constant); + + inline AST *exceptionSpecification() const { return m_exceptionSpecification; } + void setExceptionSpecification(AST *exceptionSpecification); + +private: + List<AST *> *m_ptrOpList; + DeclaratorAST * m_subDeclarator; + NameAST* m_declaratorId; + AST* m_bitfieldInitialization; + List<AST *> *m_arrayDimensionList; + class ParameterDeclarationClauseAST * m_parameterDeclarationClause; + AST* m_constant; + AST* m_exceptionSpecification; + +private: + DeclaratorAST(const DeclaratorAST &source); + void operator = (const DeclaratorAST &source); +}; + +class ParameterDeclarationAST: public AST +{ +public: + enum { Type = NodeType_ParameterDeclaration }; + +public: + ParameterDeclarationAST(); + + inline TypeSpecifierAST *typeSpec() const { return m_typeSpec; } + void setTypeSpec(TypeSpecifierAST *typeSpec); + + inline DeclaratorAST *declarator() const { return m_declarator; } + void setDeclarator(DeclaratorAST *declarator); + + inline AbstractExpressionAST *expression() const { return m_expression; } + void setExpression(AbstractExpressionAST *expression); + +private: + TypeSpecifierAST* m_typeSpec; + DeclaratorAST* m_declarator; + AbstractExpressionAST* m_expression; + +private: + ParameterDeclarationAST(const ParameterDeclarationAST &source); + void operator = (const ParameterDeclarationAST &source); +}; + +class ParameterDeclarationListAST: public AST +{ +public: + enum { Type = NodeType_ParameterDeclarationList }; + +public: + ParameterDeclarationListAST(); + + inline List<ParameterDeclarationAST *> *parameterList() const { return m_parameterList; } + void addParameter(ParameterDeclarationAST *parameter); + +private: + List<ParameterDeclarationAST *> *m_parameterList; + +private: + ParameterDeclarationListAST(const ParameterDeclarationListAST &source); + void operator = (const ParameterDeclarationListAST &source); +}; + +class ParameterDeclarationClauseAST: public AST +{ +public: + enum { Type = NodeType_ParameterDeclarationClause }; + +public: + ParameterDeclarationClauseAST(); + + inline ParameterDeclarationListAST *parameterDeclarationList() const { return m_parameterDeclarationList; } + void setParameterDeclarationList(ParameterDeclarationListAST *parameterDeclarationList); + + inline AST *ellipsis() const { return m_ellipsis; } + void setEllipsis(AST *ellipsis); + +private: + ParameterDeclarationListAST* m_parameterDeclarationList; + AST* m_ellipsis; + +private: + ParameterDeclarationClauseAST(const ParameterDeclarationClauseAST &source); + void operator = (const ParameterDeclarationClauseAST &source); +}; + + +class InitDeclaratorAST: public AST +{ +public: + enum { Type = NodeType_InitDeclarator }; + +public: + InitDeclaratorAST(); + + inline DeclaratorAST *declarator() const { return m_declarator; } + void setDeclarator(DeclaratorAST *declarator); + + inline AST *initializer() const { return m_initializer; } + void setInitializer(AST *initializer); + +private: + DeclaratorAST* m_declarator; + AST* m_initializer; + +private: + InitDeclaratorAST(const InitDeclaratorAST &source); + void operator = (const InitDeclaratorAST &source); +}; + +class InitDeclaratorListAST: public AST +{ +public: + enum { Type = NodeType_InitDeclaratorList }; + +public: + InitDeclaratorListAST(); + + inline List<InitDeclaratorAST *> *initDeclaratorList() const { return m_initDeclaratorList; } + void addInitDeclarator(InitDeclaratorAST *decl); + +private: + List<InitDeclaratorAST *> *m_initDeclaratorList; + +private: + InitDeclaratorListAST(const InitDeclaratorListAST &source); + void operator = (const InitDeclaratorListAST &source); +}; + +class TypedefAST: public DeclarationAST +{ +public: + enum { Type = NodeType_Typedef }; + +public: + TypedefAST(); + + inline TypeSpecifierAST *typeSpec() const { return m_typeSpec; } + void setTypeSpec(TypeSpecifierAST *typeSpec); + + inline InitDeclaratorListAST *initDeclaratorList() const { return m_initDeclaratorList; } + void setInitDeclaratorList(InitDeclaratorListAST *initDeclaratorList); + +private: + TypeSpecifierAST* m_typeSpec; + InitDeclaratorListAST* m_initDeclaratorList; + +private: + void operator = (const TypedefAST &source); +}; + +class TemplateParameterAST: public AST +{ +public: + enum { Type = NodeType_TemplateParameter }; + +public: + TemplateParameterAST(); + + inline TypeParameterAST *typeParameter() const { return m_typeParameter; } + void setTypeParameter(TypeParameterAST *typeParameter); + + inline ParameterDeclarationAST *typeValueParameter() const { return m_typeValueParameter; } + void setTypeValueParameter(ParameterDeclarationAST *typeValueParameter); + +private: + TypeParameterAST* m_typeParameter; + ParameterDeclarationAST* m_typeValueParameter; + +private: + TemplateParameterAST(const TemplateParameterAST &source); + void operator = (const TemplateParameterAST &source); +}; + +class TemplateParameterListAST: public AST +{ +public: + enum { Type = NodeType_TemplateParameterList }; + +public: + TemplateParameterListAST(); + + inline List<TemplateParameterAST *> *templateParameterList() const { return m_templateParameterList; } + void addTemplateParameter(TemplateParameterAST *templateParameter); + +private: + List<TemplateParameterAST *> *m_templateParameterList; + +private: + TemplateParameterListAST(const TemplateParameterListAST &source); + void operator = (const TemplateParameterListAST &source); +}; + +class TemplateDeclarationAST: public DeclarationAST +{ +public: + enum { Type = NodeType_TemplateDeclaration }; + +public: + TemplateDeclarationAST(); + + inline AST *exported() const { return m_exported; } + void setExported(AST *exported); + + inline TemplateParameterListAST *templateParameterList() const { return m_templateParameterList; } + void setTemplateParameterList(TemplateParameterListAST *templateParameterList); + + inline DeclarationAST *declaration() const { return m_declaration; } + void setDeclaration(DeclarationAST *declaration); + +private: + AST* m_exported; + TemplateParameterListAST* m_templateParameterList; + DeclarationAST* m_declaration; + +private: + TemplateDeclarationAST(const TemplateDeclarationAST &source); + void operator = (const TemplateDeclarationAST &source); +}; + +class SimpleDeclarationAST: public DeclarationAST +{ +public: + enum { Type = NodeType_SimpleDeclaration }; + +public: + SimpleDeclarationAST(); + + inline AST *functionSpecifier() const { return m_functionSpecifier; } + void setFunctionSpecifier(AST *functionSpecifier); + + inline AST *storageSpecifier() const { return m_storageSpecifier; } + void setStorageSpecifier(AST *storageSpecifier); + + inline TypeSpecifierAST *typeSpec() const { return m_typeSpec; } + void setTypeSpec(TypeSpecifierAST *typeSpec); + + inline InitDeclaratorListAST *initDeclaratorList() const { return m_initDeclaratorList; } + void setInitDeclaratorList(InitDeclaratorListAST *initDeclaratorList); + + inline AST *winDeclSpec() const { return m_winDeclSpec; } + void setWinDeclSpec(AST *winDeclSpec); + +private: + AST* m_functionSpecifier; + AST* m_storageSpecifier; + TypeSpecifierAST* m_typeSpec; + InitDeclaratorListAST* m_initDeclaratorList; + AST* m_winDeclSpec; + +private: + SimpleDeclarationAST(const SimpleDeclarationAST &source); + void operator = (const SimpleDeclarationAST &source); +}; + +class ExpressionStatementAST: public StatementAST +{ +public: + enum { Type = NodeType_ExpressionStatement }; + +public: + ExpressionStatementAST(); + + inline AbstractExpressionAST *expression() const { return m_expression; } + void setExpression(AbstractExpressionAST *expression); + +private: + AbstractExpressionAST* m_expression; + +private: + ExpressionStatementAST(const ExpressionStatementAST &source); + void operator = (const ExpressionStatementAST &source); +}; + +class ReturnStatementAST: public StatementAST +{ +public: + enum { Type = NodeType_ReturnStatement }; + +public: + ReturnStatementAST(); + + inline AbstractExpressionAST *expression() const { return m_expression; } + void setExpression(AbstractExpressionAST *expression); + +private: + AbstractExpressionAST* m_expression; + +private: + ReturnStatementAST(const ReturnStatementAST &source); + void operator = (const ReturnStatementAST &source); +}; + + +class ConditionAST: public AST +{ +public: + enum { Type = NodeType_Condition }; + +public: + ConditionAST(); + + inline TypeSpecifierAST *typeSpec() const { return m_typeSpec; } + void setTypeSpec(TypeSpecifierAST *typeSpec); + + inline DeclaratorAST *declarator() const { return m_declarator; } + void setDeclarator(DeclaratorAST *declarator); + + inline AbstractExpressionAST *expression() const { return m_expression; } + void setExpression(AbstractExpressionAST *expression); + +private: + TypeSpecifierAST* m_typeSpec; + DeclaratorAST* m_declarator; + AbstractExpressionAST* m_expression; + +private: + ConditionAST(const ConditionAST &source); + void operator = (const ConditionAST &source); +}; + +class IfStatementAST: public StatementAST +{ +public: + enum { Type = NodeType_IfStatement }; + +public: + IfStatementAST(); + + inline ConditionAST *condition() const { return m_condition; } + void setCondition(ConditionAST *condition); + + inline StatementAST *statement() const { return m_statement; } + void setStatement(StatementAST *statement); + + inline StatementAST *elseStatement() const { return m_elseStatement; } + void setElseStatement(StatementAST *statement); + +private: + ConditionAST* m_condition; + StatementAST* m_statement; + StatementAST* m_elseStatement; + +private: + IfStatementAST(const IfStatementAST &source); + void operator = (const IfStatementAST &source); +}; + +class WhileStatementAST: public StatementAST +{ +public: + enum { Type = NodeType_WhileStatement }; + +public: + WhileStatementAST(); + + inline ConditionAST *condition() const { return m_condition; } + void setCondition(ConditionAST *condition); + + inline StatementAST *statement() const { return m_statement; } + void setStatement(StatementAST *statement); + +private: + ConditionAST* m_condition; + StatementAST* m_statement; + +private: + WhileStatementAST(const WhileStatementAST &source); + void operator = (const WhileStatementAST &source); +}; + +class DoStatementAST: public StatementAST +{ +public: + enum { Type = NodeType_DoStatement }; + +public: + DoStatementAST(); + + inline ConditionAST *condition() const { return m_condition; } + void setCondition(ConditionAST *condition); + + inline StatementAST *statement() const { return m_statement; } + void setStatement(StatementAST *statement); + +private: + ConditionAST* m_condition; + StatementAST* m_statement; + +private: + DoStatementAST(const DoStatementAST &source); + void operator = (const DoStatementAST &source); +}; + +class ForStatementAST: public StatementAST +{ +public: + enum { Type = NodeType_ForStatement }; + +public: + ForStatementAST(); + + inline StatementAST *initStatement() const { return m_initStatement; } + void setInitStatement(StatementAST *statement); + + inline ConditionAST *condition() const { return m_condition; } + void setCondition(ConditionAST *condition); + + inline AbstractExpressionAST *expression() const { return m_expression; } + void setExpression(AbstractExpressionAST *expression); + + inline StatementAST *statement() const { return m_statement; } + void setStatement(StatementAST *statement); + +private: + ConditionAST* m_condition; + StatementAST* m_initStatement; + StatementAST* m_statement; + AbstractExpressionAST* m_expression; + +private: + ForStatementAST(const ForStatementAST &source); + void operator = (const ForStatementAST &source); +}; + +class SwitchStatementAST: public StatementAST +{ +public: + enum { Type = NodeType_SwitchStatement }; + +public: + SwitchStatementAST(); + + inline ConditionAST *condition() const { return m_condition; } + void setCondition(ConditionAST *condition); + + inline StatementAST *statement() const { return m_statement; } + void setStatement(StatementAST *statement); + +private: + ConditionAST* m_condition; + StatementAST* m_statement; + +private: + SwitchStatementAST(const SwitchStatementAST &source); + void operator = (const SwitchStatementAST &source); +}; + +class StatementListAST: public StatementAST +{ +public: + enum { Type = NodeType_StatementList }; + +public: + StatementListAST(); + + inline List<StatementAST *> *statementList() const { return m_statementList; } + void addStatement(StatementAST *statement); + +private: + List<StatementAST *> *m_statementList; + +private: + StatementListAST(const StatementListAST &source); + void operator = (const StatementListAST &source); +}; + +class DeclarationStatementAST: public StatementAST +{ +public: + enum { Type = NodeType_DeclarationStatement }; + +public: + DeclarationStatementAST(); + + inline DeclarationAST *declaration() const { return m_declaration; } + void setDeclaration(DeclarationAST *declaration); + +private: + DeclarationAST* m_declaration; + +private: + DeclarationStatementAST(const DeclarationStatementAST &source); + void operator = (const DeclarationStatementAST &source); +}; + +/* + LabeledStatementAST: + case constant-expression : statement + default : statement (expression is 0) +*/ +class LabeledStatementAST: public StatementAST +{ +public: + enum { Type = NodeType_LabeledStatement }; +public: + LabeledStatementAST(); + + inline StatementAST *statement() const { return m_statement; } + void setStatement(StatementAST *statement); + + inline AbstractExpressionAST *expression() const { return m_expression; } + void setExpression(AbstractExpressionAST *expression); +private: + StatementAST* m_statement; + AbstractExpressionAST *m_expression; + +private: + LabeledStatementAST(const LabeledStatementAST &source); + void operator = (const LabeledStatementAST &source); +}; + +class FunctionDefinitionAST: public DeclarationAST +{ +public: + enum { Type = NodeType_FunctionDefinition }; + +public: + FunctionDefinitionAST(); + + inline AST *functionSpecifier() const { return m_functionSpecifier; } + void setFunctionSpecifier(AST *functionSpecifier); + + inline AST *storageSpecifier() const { return m_storageSpecifier; } + void setStorageSpecifier(AST *storageSpecifier); + + inline TypeSpecifierAST *typeSpec() const { return m_typeSpec; } + void setTypeSpec(TypeSpecifierAST *typeSpec); + + inline InitDeclaratorAST *initDeclarator() const { return m_initDeclarator; } + void setInitDeclarator(InitDeclaratorAST *initDeclarator); + + inline StatementListAST *functionBody() const { return m_functionBody; } + void setFunctionBody(StatementListAST *functionBody); + + inline AST *winDeclSpec() const { return m_winDeclSpec; } + void setWinDeclSpec(AST *winDeclSpec); + +private: + AST* m_functionSpecifier; + AST* m_storageSpecifier; + TypeSpecifierAST* m_typeSpec; + InitDeclaratorAST* m_initDeclarator; + StatementListAST* m_functionBody; + AST* m_winDeclSpec; + +private: + FunctionDefinitionAST(const FunctionDefinitionAST &source); + void operator = (const FunctionDefinitionAST &source); +}; + +class TranslationUnitAST: public AST +{ +public: + enum { Type = NodeType_TranslationUnit }; + +public: + TranslationUnitAST(); + + void addDeclaration(DeclarationAST *ast); + inline List<DeclarationAST *> *declarationList() const { return m_declarationList; } + +private: + List<DeclarationAST *> *m_declarationList; + +private: + TranslationUnitAST(const TranslationUnitAST &source); + void operator = (const TranslationUnitAST &source); +}; + +template <class T> T* CreateNode(pool *p) +{ + T* node = new (p->allocate(sizeof(T))) T; + node->setNodeType(T::Type); + node->_pool = p; + return node; +} + +template <int kind> ExpressionAST<kind> *CreateExpression(pool *p) +{ + ExpressionAST<kind>* node = new (p->allocate(sizeof(ExpressionAST<kind>))) ExpressionAST<kind>; + node->setNodeType(kind); + node->_pool = p; + return node; +} + +/* +template <typename T> +inline List<T *> *snoc(List<T *> *e, T *d, pool *p) +{ if (!e) e = new (p->allocate(sizeof(List<T*>))) List<T *>(p); e->append(d); return e; } +*/ + +//Workaround for ICE on MSVC, use macro instead of template. +#define SNOC(ListType, ListValueType) \ +inline ListType *snoc(ListType *e, ListValueType *d, pool *p) \ +{ if (!e) e = new (p->allocate(sizeof(ListType))) ListType(p); e->append(d); return e; } + +SNOC(List<AST *>, AST) +SNOC(List<ClassOrNamespaceNameAST *>, ClassOrNamespaceNameAST) +SNOC(List<BaseSpecifierAST *>, BaseSpecifierAST) +SNOC(List<DeclarationAST *>, DeclarationAST) +SNOC(List<EnumeratorAST *>, EnumeratorAST) +SNOC(List<ParameterDeclarationAST *>, ParameterDeclarationAST) +SNOC(List<InitDeclaratorAST *>, InitDeclaratorAST) +SNOC(List<TemplateParameterAST *>, TemplateParameterAST) +SNOC(List<StatementAST *>, StatementAST) + +QT_END_NAMESPACE + +#endif // AST_H diff --git a/tools/porting/src/codemodel.cpp b/tools/porting/src/codemodel.cpp new file mode 100644 index 0000000..906fd03 --- /dev/null +++ b/tools/porting/src/codemodel.cpp @@ -0,0 +1,91 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "codemodel.h" + +#include <QList> +#include <QByteArray> +#include <QtDebug> + +QT_BEGIN_NAMESPACE + +namespace CodeModel { + +BuiltinType BuiltinType::Bool("bool", 0 ); +BuiltinType BuiltinType::Void("void", 0 ); +BuiltinType BuiltinType::Char("char", 0 ); +BuiltinType BuiltinType::Short("short", 0 ); +BuiltinType BuiltinType::Int("int", 0 ); +BuiltinType BuiltinType::Long("long", 0 ); +BuiltinType BuiltinType::Double("double", 0 ); +BuiltinType BuiltinType::Float("float", 0 ); +BuiltinType BuiltinType::Unsigned("unsigned", 0 ); +BuiltinType BuiltinType::Signed("signed", 0 ); + +void Scope::addScope(Scope *scope) +{ + scope->setParent(this); + m_scopes.add(scope); +} + +void Scope::addType(Type *type) +{ + if (ClassType *klass = type->toClassType()) + klass->setParent(this); + m_types.add(type); +} + +void Scope::addMember(Member *member) +{ + member->setParent(this); + m_members.add(member); +} + +void Scope::addNameUse(NameUse *nameUse) +{ + nameUse->setParent(this); + m_nameUses.add(nameUse); +} + +} //namepsace CodeModel + +QT_END_NAMESPACE diff --git a/tools/porting/src/codemodel.h b/tools/porting/src/codemodel.h new file mode 100644 index 0000000..298a25d --- /dev/null +++ b/tools/porting/src/codemodel.h @@ -0,0 +1,777 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef CODEMODEL_H +#define CODEMODEL_H + +#include "smallobject.h" +#include "tokenengine.h" + +#include <QByteArray> +#include <QList> +#include <QMap> +#include <QHash> + +QT_BEGIN_NAMESPACE + +namespace CodeModel +{ + +// types +struct Type; +struct EnumType; +struct EnumeratorType; +struct ClassType; +struct BuiltinType; +struct PointerType; +struct ReferenceType; +struct GenericType; +struct AliasType; +struct FunctionType; +struct UnknownType; + +// Scopes contain child scopes, members and types. +struct Scope; +struct ClassScope; +struct NamespaceScope; +struct BlockScope; + +// Members introduces names into scopes, and are also linked to a specific +// token in a source file. +struct Member; +struct FunctionMember; +struct VariableMember; +struct UsingDeclarationMember; +struct NamespaceMember; +struct TypeMember; + +// Name uses links uses of a name to its declaration (a Member), and also to a +// token in a source file. +struct NameUse; + +struct Argument; +struct UsingDirectiveLink; + +template <typename CollectedType> +class Collection: public QMultiHash<QByteArray, CollectedType *> +{ +public: + void add(CollectedType *collectedItem) + { this->insert(collectedItem->name(), collectedItem); } +}; + +typedef Collection<Scope> ScopeCollection; +typedef Collection<Member> MemberCollection; +typedef Collection<Type> TypeCollection; +typedef Collection<NameUse> NameUseCollection; +typedef Collection<Argument> ArgumentCollection; + +struct SemanticInfo +{ + CodeModel::NamespaceScope *codeModel; + + // tokenindex -> NameUse* map. Use map here bacause we expect name uses to + // be sparesly distributed among the tokens. + QMap<int, NameUse*> nameUses; +}; + + +struct Item +{ + Item() {} + virtual ~Item() {} + virtual QByteArray name() const = 0; +}; + +struct Type: public Item +{ + virtual QByteArray name() const =0; + + virtual EnumType *toEnumType() const + { return 0; } + + virtual ClassType *toClassType() const + { return 0; } + + virtual UnknownType *toUnknownType() const + { return 0; } + + virtual BuiltinType *toBuiltinType() const + { return 0; } + + virtual PointerType *toPointerType() const + { return 0; } + + virtual ReferenceType *toReferenceType() const + { return 0; } + + virtual GenericType *toGenericType() const + { return 0; } + + virtual AliasType *toAliasType() const + { return 0; } +}; + +struct Scope: public Item +{ + Scope() + : m_parent(0) {} + + void setParent(Scope *parent) + { m_parent = parent; } + + Scope *parent() const + { return m_parent; } + + QByteArray name() const + { return m_name; } + + void setName(const QByteArray &name) + { m_name=name; } + + virtual NamespaceScope *toNamespaceScope() const + { return 0; } + + virtual ClassScope *toClassScope() const + { return 0; } + + virtual BlockScope *toBlockScope() const + { return 0; } + + const Collection<Scope> scopes() const + { return m_scopes; } + const Collection<Type> types() const + { return m_types; } + const Collection<Member> members() const + { return m_members; } + const Collection<NameUse> nameUses() const + { return m_nameUses; } + + void addScope(Scope *scope); + void addType(Type *type); + void addMember(Member *member); + void addNameUse(NameUse *nameUse); +private: + Scope *m_parent; + QByteArray m_name; + Collection<Scope> m_scopes; + Collection<Type> m_types; + Collection<Member> m_members; + Collection<NameUse> m_nameUses; +}; + +struct Member: public Item +{ + enum Binding // ### not used yet + { + Static, + Instance + }; + + enum Access // ### not used yet + { + Public, + Protected, + Private + }; + + Member() + : m_binding(Static), m_access(Public), + m_parent(0), m_constant(0), m_static(0) {} + + QByteArray name() const + { return m_name; } + + void setName(const QByteArray &name) + { m_name = name; } + + TokenEngine::TokenRef nameToken() const + { return m_nameToken; } + + void setNameToken(TokenEngine::TokenRef nameToken) + { m_nameToken = nameToken; } + + Binding binding() const + { return m_binding; } + + void setBinding(Binding binding) + { m_binding = binding; } + + Access access() const + { return m_access; } + + void setAccess(Access access) + { m_access = access; } + + bool isConstant() const + { return m_constant; } + + void setConstant(bool b) + { m_constant = b; } + + bool isStatic() const + { return m_static; } + + void setStatic(bool b) + { m_static = b; } + + Scope *parent() const + { return m_parent; } + + void setParent(Scope *parent) + { m_parent = parent; } + + virtual FunctionMember *toFunctionMember() const + { return 0; } + + virtual VariableMember *toVariableMember() const + { return 0; } + + virtual UsingDeclarationMember *toUsingDeclarationMember() const + { return 0; } + + virtual NamespaceMember *toNamespaceMember() const + { return 0; } + + virtual TypeMember *toTypeMember() const + { return 0; } + + private: + Binding m_binding; + Access m_access; + Scope *m_parent; + QByteArray m_name; + TokenEngine::TokenRef m_nameToken; + uint m_constant : 1; + uint m_static : 1; +}; + +struct ClassScope: public Scope +{ + const Collection<Type> baseClasses() const + { return m_baseClasses; } + + void addBaseClass(Type *baseClass) + { + Q_ASSERT(baseClass->toClassType()); + m_baseClasses.add(baseClass); + } + + virtual ClassScope *toClassScope() const + { return const_cast<ClassScope*>(this); } + +private: + Collection<Type> m_baseClasses; +}; + +struct UsingDirectiveLinkable : public Scope +{ + const QList<UsingDirectiveLink *> usingDirectiveLinks() const + { return m_usingDirectiveLinks; } + + void addUsingDirectiveLink(UsingDirectiveLink *usingDirectiveLink) + { m_usingDirectiveLinks.append(usingDirectiveLink); } +private: + QList<UsingDirectiveLink *> m_usingDirectiveLinks; +}; + +struct NamespaceScope: public UsingDirectiveLinkable +{ + NamespaceScope() {} + + virtual NamespaceScope *toNamespaceScope() const + { return const_cast<NamespaceScope*>(this); } +}; + +struct BlockScope: public UsingDirectiveLinkable +{ + BlockScope() {} + + virtual BlockScope *toBlockScope() const + { return const_cast<BlockScope*>(this); } +}; + +struct EnumType: public Type +{ + EnumType() + : m_parent(0) {} + + QByteArray name() const + { return m_name; } + + void setName(const QByteArray &name) + { m_name = name; } + + Scope *parent() const + { return m_parent; } + + void setParent(Scope *parent) + { m_parent = parent; } + + virtual EnumType *toEnumType() const + { return const_cast<EnumType*>(this); } + +private: + Scope *m_parent; + QByteArray m_name; +}; + +struct UnknownType: public Type +{ + UnknownType() + : m_parent(0) {} + + QByteArray name() const + { return m_name; } + + void setName(const QByteArray &name) + { m_name = name; } + + Scope *parent() const + { return m_parent; } + + void setParent(Scope *parent) + { m_parent = parent; } + + virtual UnknownType *toUnknownType() const + { return const_cast<UnknownType*>(this); } + +private: + Scope *m_parent; + QByteArray m_name; +}; + +struct ClassType: public Type +{ + ClassType() + : m_parent(0), m_scope(0) {} + + ClassScope *scope() const + { return m_scope; } + + void setScope(ClassScope *scope) + { m_scope = scope; } + + QByteArray name() const + { return m_scope ? m_scope->name() : /*anonymous*/ QByteArray(); } + + Scope *parent() const + { return m_parent; } + + void setParent(Scope *parent) + { m_parent = parent; } + + virtual ClassType *toClassType() const + { return const_cast<ClassType*>(this); } + +private: + Scope *m_parent; + ClassScope *m_scope; + +}; + +struct BuiltinType: public Type +{ +protected: + BuiltinType(const QByteArray &name, Scope *parent) + : m_name(name), m_parent(parent) {} + +public: + QByteArray name() const + { return m_name; } + + Scope *parent() const + { return m_parent; } + + virtual BuiltinType *toBuiltinType() const + { return const_cast<BuiltinType*>(this); } + + static BuiltinType Bool; + static BuiltinType Void; + static BuiltinType Char; + static BuiltinType Short; + static BuiltinType Int; + static BuiltinType Long; + static BuiltinType Double; + static BuiltinType Float; + static BuiltinType Unsigned; + static BuiltinType Signed; + // ### more + +private: + QByteArray m_name; + Scope *m_parent; +}; + +struct PointerType: public Type +{ + PointerType() + : m_parent(0), m_baseType(0) {} + + Type *baseType() const + { return m_baseType; } + + void setBaseType(Type *baseType) + { m_baseType = baseType; } + + QByteArray name() const + { return m_baseType->name(); } + + Scope *parent() const + { return m_parent; } + + void setParent(Scope *parent) + { m_parent = parent; } + + virtual PointerType *toPointerType() const + { return const_cast<PointerType*>(this); } + +private: + Scope *m_parent; + Type *m_baseType; +}; + +struct ReferenceType: public Type +{ + ReferenceType() + : m_parent(0), m_baseType(0) {} + + Type *baseType() const + { return m_baseType; } + + void setBaseType(Type *baseType) + { m_baseType = baseType; } + + QByteArray name() const + { return m_baseType->name(); } + + Scope *parent() const + { return m_parent; } + + void setParent(Scope *parent) + { m_parent = parent; } + + virtual ReferenceType *toReferenceType() const + { return const_cast<ReferenceType*>(this); } + +private: + Scope *m_parent; + Type *m_baseType; +}; + +struct GenericType: public Type // ### implement me +{ + virtual GenericType *toGenericType() const + { return const_cast<GenericType*>(this); } +}; + +struct AliasType: public Type // ### implement me +{ + AliasType () + : m_parent(0) {} + + QByteArray name() const + { return m_name; } + + Scope *parent() const + { return m_parent; } + + virtual AliasType *toAliasType() const + { return const_cast<AliasType*>(this); } +private: + QByteArray m_name; + Scope *m_parent; +}; + +struct Argument: public Item +{ + Argument() + : m_parent(0), m_type(0) {} + + Type *type() const + { return m_type; } + + void setType(Type *type) + { m_type = type; } + + QByteArray name() const + { return m_name; } + + void setName(const QByteArray &name) + { m_name = name; } + + TokenEngine::TokenRef nameToken() const + { return m_nameToken; } + + void setNameToken(TokenEngine::TokenRef nameToken) + { m_nameToken = nameToken; } + + virtual FunctionMember *parent() const + { return m_parent; } + + void setParent(FunctionMember *parent) + { m_parent = parent; } + +private: + FunctionMember *m_parent; + Type *m_type; + QByteArray m_name; + TokenEngine::TokenRef m_nameToken; +}; + +struct FunctionMember: public Member +{ + inline FunctionMember() + : m_returnType(0), + m_functionBodyScope(0), + m_signal(0), + m_virtual(0), m_abstract(0) { m_slot = 0; } + + virtual FunctionMember *toFunctionMember() const + { return const_cast<FunctionMember*>(this); } + + Type *returnType() const + { return m_returnType; } + + void setReturnType(Type *type) + { m_returnType = type; } + + const Collection<Argument> arguments() const + { return m_arguments; } + + void addArgument(Argument *argument) + { m_arguments.insert(argument->name(), argument); } + + void setFunctionBodyScope(BlockScope *functionBodyScope) + { m_functionBodyScope = functionBodyScope; } + + BlockScope *functionBodyScope() const + {return m_functionBodyScope;} + + bool isSignal() const + { return m_signal; } + + void setSignal(bool b) + { m_signal = b; } + + bool isSlot() const + { return m_slot; } + + void setSlot(bool b) + { m_slot = b; } + + bool isVirtual() const + { return m_virtual; } + + void setVirtual(bool b) + { m_virtual = b; } + + bool isAbstract() const + { return m_abstract; } + + void setAbstract(bool b) + { m_abstract = b; } + +private: + Type *m_returnType; + Collection<Argument> m_arguments; + BlockScope *m_functionBodyScope; + uint m_signal: 1; + uint m_slot: 1; + uint m_virtual: 1; + uint m_abstract: 1; +}; + +struct VariableMember: public Member +{ + VariableMember() + : m_type(0) {} + + Type *type() const + { return m_type; } + + void setType(Type *type) + { m_type = type; } + + virtual VariableMember *toVariableMember() const + { return const_cast<VariableMember*>(this); } + +private: + Type *m_type; +}; + +struct UsingDeclarationMember: public Member +{ + UsingDeclarationMember() + : m_member(0) {} + + virtual UsingDeclarationMember *toUsingDeclarationMember() const + { return const_cast<UsingDeclarationMember*>(this); } + + Member *member() const + { return m_member; } + + void setMember(Member *member) + { m_member = member; } + +private: + Member *m_member; +}; + +struct NamespaceMember: public Member +{ + NamespaceMember() + :m_namespaceScope(0) {} + + virtual NamespaceMember *toNamespaceMember() const + { return const_cast<NamespaceMember*>(this); } + + NamespaceScope *namespaceScope() const + { return m_namespaceScope; } + + void setNamespaceScope(NamespaceScope *namespaceScope) + { m_namespaceScope = namespaceScope; } +private: + NamespaceScope *m_namespaceScope; +}; + +struct TypeMember: public Member +{ + TypeMember() + :m_type(0) {} + + virtual TypeMember *toTypeMember() const + { return const_cast<TypeMember*>(this); } + + Type *type() const + { return m_type; } + + void setType(Type *type) + { m_type = type; } +private: + Type *m_type; + +}; + +struct NameUse: public Item +{ + NameUse() + : m_declaration(0), m_parent(0) {} + + QByteArray name() const + { return m_name; } + + void setName(const QByteArray &name) + { m_name = name; } + + TokenEngine::TokenRef nameToken() const + { return m_nameToken; } + + void setNameToken(TokenEngine::TokenRef nameToken) + { m_nameToken = nameToken; } + + Scope *parent() const + { return m_parent; } + + void setParent(Scope *parent) + { m_parent = parent; } + + Member *declaration() const + { return m_declaration; } + + void setDeclaration(Member *parent) + { m_declaration = parent; } + +private: + QByteArray m_name; + TokenEngine::TokenRef m_nameToken; + Member *m_declaration; + Scope *m_parent; +}; + +struct UsingDirectiveLink: public Item +{ + UsingDirectiveLink() + : m_parent(0), m_targetNamespace(0), m_insertionNamespace(0) {} + + QByteArray name() const + { return QByteArray(); } + + Scope *parent() const + { return m_parent; } + + void setParent(Scope *parent) + { m_parent = parent; } + + NamespaceScope *targetNamespace() const + { return m_targetNamespace; } + + void setTargetNamespace(NamespaceScope *targetNamespace) + { m_targetNamespace = targetNamespace; } + + NamespaceScope *insertionNamespace() const + { return m_insertionNamespace; } + + void setInsertionNamespace(NamespaceScope *insertionNamespace) + { m_insertionNamespace = insertionNamespace; } +private: + Scope *m_parent; + // targetNamespace is the namespace specified by the using directive. + NamespaceScope *m_targetNamespace; + // m_insertionNamespace is the namespace where the names from + // targetNamespace will be inserted. The C++ standard (7.3.4.1) + // defines this as the nearest namespace that includes both m_parent + // and m_targetNamespace. + NamespaceScope *m_insertionNamespace; +}; + +template <class T> +T *Create(TypedPool<CodeModel::Item> *p) +{ + return new (p->allocate(sizeof(T))) T(); +} + +} // namespace CodeModel + +QT_END_NAMESPACE + +#endif // CODEMODEL_H diff --git a/tools/porting/src/codemodelattributes.cpp b/tools/porting/src/codemodelattributes.cpp new file mode 100644 index 0000000..405da33 --- /dev/null +++ b/tools/porting/src/codemodelattributes.cpp @@ -0,0 +1,195 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "codemodelattributes.h" +#include "tokenengine.h" + +QT_BEGIN_NAMESPACE + +using namespace CodeModel; +using namespace TokenEngine; + +/* + Walk the codemodel. +*/ +void CodeModelAttributes::createAttributes(TranslationUnit translationUnit) +{ + m_translationUnit = translationUnit; + parseScope(const_cast<CodeModel::NamespaceScope *>(translationUnit.codeModel())); +} + +/* + Create attributes for each name use and assign to the token. +*/ +void CodeModelAttributes::parseNameUse(CodeModel::NameUse *nameUse) +{ + // Get the container for this token. + TokenRef ref = nameUse->nameToken(); + const int containerIndex = ref.containerIndex(); + TokenAttributes *attributes = ref.tokenContainer().tokenAttributes(); + + if (!areAttributesEnabled(attributes)) + return; + + // Test if the nameUse refers to a UnknownType. If so we add and + // "unknown" attribute. + if (TypeMember *typeMember = nameUse->declaration()->toTypeMember()) { + if (typeMember->type()->toUnknownType()) { + attributes->addAttribute(containerIndex, "unknown", nameUse->name()); + return; + } + } + + // Add attributes this namnUse. + attributes->addAttribute(containerIndex, "nameUse", nameUse->name()); + attributes->addAttribute(containerIndex, "parentScope", + nameUse->declaration()->parent()->name() ); + if (CodeModel::Scope * skop = nameUse->declaration()->parent()->parent()) { + attributes->addAttribute(containerIndex, "grandParentScope", skop->name()); + } + + createNameTypeAttribute(nameUse); +} + +/* + Create attributes for members and assign to token. +*/ +void CodeModelAttributes::parseMember(CodeModel::Member *member) +{ + if(!member || member->name() == QByteArray()) + return; + + //get the container for this token + TokenRef ref = member->nameToken(); + const int containerIndex = ref.containerIndex(); + TokenAttributes *attributes = ref.tokenContainer().tokenAttributes(); + + if (areAttributesEnabled(attributes)) { + //add attributes for this declaration + static const QByteArray textDeclaration = "declaration"; + attributes->addAttribute(containerIndex, textDeclaration, member->name()); + createNameTypeAttribute(member); + } + CodeModelWalker::parseMember(member); +} + +void CodeModelAttributes::parseFunctionMember(CodeModel::FunctionMember *member) +{ + CodeModel::ArgumentCollection arguments = member->arguments(); + CodeModel::ArgumentCollection::ConstIterator it = arguments.constBegin(); + TokenRef ref = member->nameToken(); + TokenAttributes *attributes = ref.tokenContainer().tokenAttributes(); + + if (areAttributesEnabled(attributes)) { + while (it != arguments.constEnd()) { + const int containerIndex = (*it)->nameToken().containerIndex(); + const QByteArray name = (*it)->name(); + attributes->addAttribute(containerIndex, "declaration", name); + attributes->addAttribute(containerIndex, "nameType", "variable"); + ++it; + } + } + CodeModelWalker::parseFunctionMember(member); +} + +/* + NameType attributes gives information on what kind of member this is. +*/ +void CodeModelAttributes::createNameTypeAttribute(CodeModel::Member *member) +{ + if(!member) + return; + //get the container for the token accosiated with this member. + TokenRef ref = member->nameToken(); + const int containerIndex = ref.containerIndex(); + TokenAttributes *attributes = ref.tokenContainer().tokenAttributes(); + + createNameTypeAttributeAtIndex(attributes, containerIndex, member); +} + +/* + A NameUse has the same NameType as the declaration it is referring to. +*/ +void CodeModelAttributes::createNameTypeAttribute(CodeModel::NameUse *nameUse) +{ + if(!nameUse) + return; + + //get the container for the token accosiated with this NameUse. + TokenRef ref = nameUse->nameToken(); + const int containerIndex = ref.containerIndex(); + TokenAttributes *attributes = ref.tokenContainer().tokenAttributes(); + + createNameTypeAttributeAtIndex(attributes, containerIndex, nameUse->declaration()); +} + +void CodeModelAttributes::createNameTypeAttributeAtIndex(TokenEngine::TokenAttributes *attributes, + int index, CodeModel::Member *member) +{ + QByteArray nameType = "unknown"; + if (member->toFunctionMember()) { + nameType = "function"; + } else if (CodeModel::VariableMember *variableMember = member->toVariableMember()) { + if (variableMember->type()->toEnumType()) + nameType = "enumerator"; + else + nameType = "variable"; + } else if (CodeModel::TypeMember *typeMember = member->toTypeMember()) { + if (CodeModel::Type *type = typeMember->type()) { + if (type->toClassType()) { + nameType = "class"; + } else if (type->toEnumType()) { + nameType = "enum"; + } + } + } + attributes->addAttribute(index, "nameType", nameType); +} + +bool CodeModelAttributes::areAttributesEnabled(const TokenAttributes *attributes) const +{ + static const QByteArray tstCreateAttributes("CreateAttributes"); + static const QByteArray tstTrue("True"); + return (attributes->attribute(tstCreateAttributes) == tstTrue); +} + + +QT_END_NAMESPACE diff --git a/tools/porting/src/codemodelattributes.h b/tools/porting/src/codemodelattributes.h new file mode 100644 index 0000000..ed8fae4 --- /dev/null +++ b/tools/porting/src/codemodelattributes.h @@ -0,0 +1,72 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef CODEMODELATTRIBUTES_H +#define CODEMODELATTRIBUTES_H + +#include "codemodelwalker.h" +#include "translationunit.h" + +QT_BEGIN_NAMESPACE + +class CodeModelAttributes : public CodeModelWalker +{ +public: + void createAttributes(TranslationUnit translationUnit); +protected: + void parseNameUse(CodeModel::NameUse *); + void parseMember(CodeModel::Member *member); + void parseFunctionMember(CodeModel::FunctionMember *member); + + void createNameTypeAttribute(CodeModel::Member *member); + void createNameTypeAttribute(CodeModel::NameUse *nameUse); + +private: + void createNameTypeAttributeAtIndex(TokenEngine::TokenAttributes *attributes, + int index, CodeModel::Member *member); + bool areAttributesEnabled(const TokenEngine::TokenAttributes *attributes) const; + + TranslationUnit m_translationUnit; +}; + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/codemodelwalker.cpp b/tools/porting/src/codemodelwalker.cpp new file mode 100644 index 0000000..654d1d7 --- /dev/null +++ b/tools/porting/src/codemodelwalker.cpp @@ -0,0 +1,125 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "codemodelwalker.h" + +QT_BEGIN_NAMESPACE +using namespace CodeModel; + +void CodeModelWalker::parseScope(CodeModel::Scope *scope) +{ + if(!scope) + return; + + if(scope->toClassScope()) + parseClassScope(scope->toClassScope()); + if(scope->toNamespaceScope()) + parseNamespaceScope(scope->toNamespaceScope()); + if(scope->toBlockScope()) + parseBlockScope(scope->toBlockScope()); + + + { + MemberCollection collection = scope->members(); + MemberCollection::ConstIterator it = collection.constBegin(); + while(it != collection.constEnd()) + parseMember(*it++); + } + { + ScopeCollection collection = scope->scopes(); + ScopeCollection::ConstIterator it = collection.constBegin(); + while(it != collection.constEnd()) + parseScope(*it++); + } + { + NameUseCollection collection = scope->nameUses(); + NameUseCollection::ConstIterator it = collection.constBegin(); + while(it != collection.constEnd()) + parseNameUse(*it++); + } +} + +void CodeModelWalker::parseType(CodeModel::Type *type) +{ + if(!type) + return; + if (type->toEnumType()) + parseEnumType(type->toEnumType()); + else if (type->toClassType()) + parseClassType(type->toClassType()); + else if (type->toBuiltinType()) + parseBuiltinType(type->toBuiltinType()); + else if (type->toPointerType()) + parsePointerType(type->toPointerType()); + else if (type->toReferenceType()) + parseReferenceType(type->toReferenceType()); + else if (type->toGenericType()) + parseGenericType(type->toGenericType()); + else if (type->toAliasType()) + parseAliasType(type->toAliasType()); + else if (type->toUnknownType()) + parseUnknownType(type->toUnknownType()); +} + +void CodeModelWalker::parseMember(CodeModel::Member *member) +{ + if(!member) + return; + + if (member->toFunctionMember()) + parseFunctionMember(member->toFunctionMember()); + else if (member->toVariableMember()) + parseVariableMember(member->toVariableMember()); + else if (member->toUsingDeclarationMember()) + parseUsingDeclarationMember(member->toUsingDeclarationMember()); + else if (member->toTypeMember()) + parseTypeMember(member->toTypeMember()); +} + +void CodeModelWalker::parseFunctionMember(CodeModel::FunctionMember *member) +{ + if(!member) + return; + if(member->functionBodyScope()) + parseScope(member->functionBodyScope()); +} + +QT_END_NAMESPACE diff --git a/tools/porting/src/codemodelwalker.h b/tools/porting/src/codemodelwalker.h new file mode 100644 index 0000000..2d7381a --- /dev/null +++ b/tools/porting/src/codemodelwalker.h @@ -0,0 +1,80 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef CODEMODELWALKER_H +#define CODEMODELWALKER_H + +#include "codemodel.h" + +QT_BEGIN_NAMESPACE + +class CodeModelWalker +{ +public: + virtual ~CodeModelWalker(){}; + virtual void parseScope(CodeModel::Scope *scope); + virtual void parseClassScope(CodeModel::ClassScope *){}; + virtual void parseNamespaceScope(CodeModel::NamespaceScope *){}; + virtual void parseBlockScope(CodeModel::BlockScope *){}; + + virtual void parseType(CodeModel::Type *type); + virtual void parseEnumType(CodeModel::EnumType *){}; + virtual void parseClassType(CodeModel::ClassType *){}; + virtual void parseUnknownType(CodeModel::UnknownType *){}; + virtual void parseBuiltinType(CodeModel::BuiltinType *){}; + virtual void parsePointerType(CodeModel::PointerType *){}; + virtual void parseReferenceType(CodeModel::ReferenceType *){}; + virtual void parseGenericType(CodeModel::GenericType *){}; + virtual void parseAliasType(CodeModel::AliasType *){}; + + virtual void parseMember(CodeModel::Member *member); + virtual void parseFunctionMember(CodeModel::FunctionMember *); + virtual void parseVariableMember(CodeModel::VariableMember *){}; + virtual void parseUsingDeclarationMember(CodeModel::UsingDeclarationMember *){}; + virtual void parseTypeMember(CodeModel::TypeMember *){}; + + virtual void parseArgument(CodeModel::Argument *){}; + virtual void parseNameUse(CodeModel::NameUse *){}; +}; + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/cpplexer.cpp b/tools/porting/src/cpplexer.cpp new file mode 100644 index 0000000..c431924 --- /dev/null +++ b/tools/porting/src/cpplexer.cpp @@ -0,0 +1,1297 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "cpplexer.h" +#include <QChar> +#include <ctype.h> + +QT_BEGIN_NAMESPACE + +using namespace TokenEngine; + +CppLexer::CppLexer() + : m_buffer(0), m_ptr(0), m_len(0) +{ + setupScanTable(); +} + +void CppLexer::setupScanTable() +{ + s_scan_keyword_table[0] = &CppLexer::scanKeyword0; + s_scan_keyword_table[1] = &CppLexer::scanKeyword0; + s_scan_keyword_table[2] = &CppLexer::scanKeyword2; + s_scan_keyword_table[3] = &CppLexer::scanKeyword3; + s_scan_keyword_table[4] = &CppLexer::scanKeyword4; + s_scan_keyword_table[5] = &CppLexer::scanKeyword5; + s_scan_keyword_table[6] = &CppLexer::scanKeyword6; + s_scan_keyword_table[7] = &CppLexer::scanKeyword7; + s_scan_keyword_table[8] = &CppLexer::scanKeyword8; + s_scan_keyword_table[9] = &CppLexer::scanKeyword9; + s_scan_keyword_table[10] = &CppLexer::scanKeyword10; + s_scan_keyword_table[11] = &CppLexer::scanKeyword11; + s_scan_keyword_table[12] = &CppLexer::scanKeyword12; + s_scan_keyword_table[13] = &CppLexer::scanKeyword0; + s_scan_keyword_table[14] = &CppLexer::scanKeyword14; + s_scan_keyword_table[15] = &CppLexer::scanKeyword0; + s_scan_keyword_table[16] = &CppLexer::scanKeyword16; + + memset(s_attr_table, 0, 256); + + for (int i=0; i<128; ++i) { + switch (i) { + case ':': + case '*': + case '/': + case '%': + case '^': + case '=': + case '!': + case '&': + case '|': + case '+': + case '<': + case '>': + case '-': + case '.': + s_scan_table[i] = &CppLexer::scanOperator; + break; + + case '\r': + case '\n': + s_scan_table[i] = &CppLexer::scanNewline; + break; + + case '\'': + s_scan_table[i] = &CppLexer::scanCharLiteral; + break; + + case '"': + s_scan_table[i] = &CppLexer::scanStringLiteral; + break; + + default: + if (isspace(i)) { + s_scan_table[i] = &CppLexer::scanWhiteSpaces; + s_attr_table[i] |= A_Whitespace; + } else if (isalpha(i) || i == '_') { + s_scan_table[i] = &CppLexer::scanIdentifier; + s_attr_table[i] |= A_Alpha; + } else if (isdigit(i)) { + s_scan_table[i] = &CppLexer::scanNumberLiteral; + s_attr_table[i] |= A_Digit; + } else + s_scan_table[i] = &CppLexer::scanChar; + } + } + + s_scan_table[128] = &CppLexer::scanUnicodeChar; +} + +QVector<Type> CppLexer::lex(TokenSectionSequence tokenSectionSequence) +{ + QVector<Type> tokenTypes; + tokenTypes.reserve(tokenSectionSequence.count()); + TokenSectionSequenceIterator it(tokenSectionSequence); + while(it.nextToken()) { + tokenTypes.append(identify(it.tokenTempRef())); + } + return tokenTypes; +} + +Type CppLexer::identify(const TokenTempRef &tokenTempRef) +{ + Q_ASSERT(tokenTempRef.length() >= 0 ); + m_buffer = tokenTempRef.constData(); + m_len = tokenTempRef.length(); + m_ptr = 0; + const unsigned char ch = m_buffer[0]; + int kind = 0; + (this->*s_scan_table[ch < 128 ? ch : 128])(&kind); + return (Type)kind; +} + +void CppLexer::scanKeyword0(int *kind) +{ + *kind = Token_identifier; +} + +void CppLexer::scanKeyword2(int *kind) +{ + switch (m_buffer[m_ptr]) { + case 'i': + if (m_buffer[m_ptr+1] == 'f') + { + *kind = Token_if; + return; + } + break; + + case 'd': + if (m_buffer[m_ptr+1] == 'o') + { + *kind = Token_do; + return; + } + break; + + case 'o': + if (m_buffer[m_ptr+1] == 'r') + { + *kind = Token_or; + return; + } + break; + + } + *kind = Token_identifier; +} + +void CppLexer::scanKeyword3(int *kind) +{ + switch (m_buffer[m_ptr]) { + case 'a': + if (m_buffer[m_ptr+1] == 'n' && + m_buffer[m_ptr+2] == 'd') + { + *kind = Token_and; + return; + } + if (m_buffer[m_ptr+1] == 's' && + m_buffer[m_ptr+2] == 'm') + { + *kind = Token_asm; + return; + } + break; + + case 'f': + if (m_buffer[m_ptr+1] == 'o' && + m_buffer[m_ptr+2] == 'r') + { + *kind = Token_for; + return; + } + break; + + case 'i': + if (m_buffer[m_ptr+1] == 'n' && + m_buffer[m_ptr+2] == 't') + { + *kind = Token_int; + return; + } + break; + + case 'n': + if (m_buffer[m_ptr+1] == 'e' && + m_buffer[m_ptr+2] == 'w') + { + *kind = Token_new; + return; + } + if (m_buffer[m_ptr+1] == 'o' && + m_buffer[m_ptr+2] == 't') + { + *kind = Token_not; + return; + } + break; + + case 't': + if (m_buffer[m_ptr+1] == 'r' && + m_buffer[m_ptr+2] == 'y') + { + *kind = Token_try; + return; + } + break; + + case 'x': + if (m_buffer[m_ptr+1] == 'o' && + m_buffer[m_ptr+2] == 'r') + { + *kind = Token_xor; + return; + } + break; + + } + *kind = Token_identifier; +} + +void CppLexer::scanKeyword4(int *kind) +{ + switch (m_buffer[m_ptr]) { + case 'a': + if (m_buffer[m_ptr+1] == 'u' && + m_buffer[m_ptr+2] == 't' && + m_buffer[m_ptr+3] == 'o') + { + *kind = Token_auto; + return; + } + break; + + case 'c': + if (m_buffer[m_ptr+1] == 'a' && + m_buffer[m_ptr+2] == 's' && + m_buffer[m_ptr+3] == 'e') + { + *kind = Token_case; + return; + } + if (m_buffer[m_ptr+1] == 'h' && + m_buffer[m_ptr+2] == 'a' && + m_buffer[m_ptr+3] == 'r') + { + *kind = Token_char; + return; + } + break; + + case 'b': + if (m_buffer[m_ptr+1] == 'o' && + m_buffer[m_ptr+2] == 'o' && + m_buffer[m_ptr+3] == 'l') + { + *kind = Token_bool; + return; + } + break; + + case 'e': + if (m_buffer[m_ptr+1] == 'l' && + m_buffer[m_ptr+2] == 's' && + m_buffer[m_ptr+3] == 'e') + { + *kind = Token_else; + return; + } + if (m_buffer[m_ptr+1] == 'm' && + m_buffer[m_ptr+2] == 'i' && + m_buffer[m_ptr+3] == 't') + { + *kind = Token_emit; + return; + } + if (m_buffer[m_ptr+1] == 'n' && + m_buffer[m_ptr+2] == 'u' && + m_buffer[m_ptr+3] == 'm') + { + *kind = Token_enum; + return; + } + break; + + case 'g': + if (m_buffer[m_ptr+1] == 'o' && + m_buffer[m_ptr+2] == 't' && + m_buffer[m_ptr+3] == 'o') + { + *kind = Token_goto; + return; + } + break; + + case 'l': + if (m_buffer[m_ptr+1] == 'o' && + m_buffer[m_ptr+2] == 'n' && + m_buffer[m_ptr+3] == 'g') + { + *kind = Token_long; + return; + } + break; + + case 't': + if (m_buffer[m_ptr+1] == 'h' && + m_buffer[m_ptr+2] == 'i' && + m_buffer[m_ptr+3] == 's') + { + *kind = Token_this; + return; + } + break; + + case 'v': + if (m_buffer[m_ptr+1] == 'o' && + m_buffer[m_ptr+2] == 'i' && + m_buffer[m_ptr+3] == 'd') + { + *kind = Token_void; + return; + } + break; + + } + *kind = Token_identifier; +} + +void CppLexer::scanKeyword5(int *kind) +{ + switch (m_buffer[m_ptr]) { + case 'c': + if (m_buffer[m_ptr+1] == 'a' && + m_buffer[m_ptr+2] == 't' && + m_buffer[m_ptr+3] == 'c' && + m_buffer[m_ptr+4] == 'h') + { + *kind = Token_catch; + return; + } + if (m_buffer[m_ptr+1] == 'l' && + m_buffer[m_ptr+2] == 'a' && + m_buffer[m_ptr+3] == 's' && + m_buffer[m_ptr+4] == 's') + { + *kind = Token_class; + return; + } + if (m_buffer[m_ptr+1] == 'o' && + m_buffer[m_ptr+2] == 'm' && + m_buffer[m_ptr+3] == 'p' && + m_buffer[m_ptr+4] == 'l') + { + *kind = Token_compl; + return; + } + if (m_buffer[m_ptr+1] == 'o' && + m_buffer[m_ptr+2] == 'n' && + m_buffer[m_ptr+3] == 's' && + m_buffer[m_ptr+4] == 't') + { + *kind = Token_const; + return; + } + break; + + case 'b': + if (m_buffer[m_ptr+1] == 'i' && + m_buffer[m_ptr+2] == 't' && + m_buffer[m_ptr+3] == 'o' && + m_buffer[m_ptr+4] == 'r') + { + *kind = Token_bitor; + return; + } + if (m_buffer[m_ptr+1] == 'r' && + m_buffer[m_ptr+2] == 'e' && + m_buffer[m_ptr+3] == 'a' && + m_buffer[m_ptr+4] == 'k') + { + *kind = Token_break; + return; + } + break; + + case 'f': + if (m_buffer[m_ptr+1] == 'l' && + m_buffer[m_ptr+2] == 'o' && + m_buffer[m_ptr+3] == 'a' && + m_buffer[m_ptr+4] == 't') + { + *kind = Token_float; + return; + } + break; + + case 'o': + if (m_buffer[m_ptr+1] == 'r' && + m_buffer[m_ptr+2] == '_' && + m_buffer[m_ptr+3] == 'e' && + m_buffer[m_ptr+4] == 'q') + { + *kind = Token_or_eq; + return; + } + break; + + case 's': + if (m_buffer[m_ptr+1] == 'h' && + m_buffer[m_ptr+2] == 'o' && + m_buffer[m_ptr+3] == 'r' && + m_buffer[m_ptr+4] == 't') + { + *kind = Token_short; + return; + } + if (m_buffer[m_ptr+1] == 'l' && + m_buffer[m_ptr+2] == 'o' && + m_buffer[m_ptr+3] == 't' && + m_buffer[m_ptr+4] == 's') + { + *kind = Token_slots; + return; + } + break; + + case 'u': + if (m_buffer[m_ptr+1] == 'n' && + m_buffer[m_ptr+2] == 'i' && + m_buffer[m_ptr+3] == 'o' && + m_buffer[m_ptr+4] == 'n') + { + *kind = Token_union; + return; + } + if (m_buffer[m_ptr+1] == 's' && + m_buffer[m_ptr+2] == 'i' && + m_buffer[m_ptr+3] == 'n' && + m_buffer[m_ptr+4] == 'g') + { + *kind = Token_using; + return; + } + break; + + case 't': + if (m_buffer[m_ptr+1] == 'h' && + m_buffer[m_ptr+2] == 'r' && + m_buffer[m_ptr+3] == 'o' && + m_buffer[m_ptr+4] == 'w') + { + *kind = Token_throw; + return; + } + break; + + case 'w': + if (m_buffer[m_ptr+1] == 'h' && + m_buffer[m_ptr+2] == 'i' && + m_buffer[m_ptr+3] == 'l' && + m_buffer[m_ptr+4] == 'e') + { + *kind = Token_while; + return; + } + break; + + } + *kind = Token_identifier; +} + +void CppLexer::scanKeyword6(int *kind) +{ + switch (m_buffer[m_ptr]) { + case 'a': + if (m_buffer[m_ptr+1] == 'n' && + m_buffer[m_ptr+2] == 'd' && + m_buffer[m_ptr+3] == '_' && + m_buffer[m_ptr+4] == 'e' && + m_buffer[m_ptr+5] == 'q') + { + *kind = Token_and_eq; + return; + } + break; + + case 'b': + if (m_buffer[m_ptr+1] == 'i' && + m_buffer[m_ptr+2] == 't' && + m_buffer[m_ptr+3] == 'a' && + m_buffer[m_ptr+4] == 'n' && + m_buffer[m_ptr+5] == 'd') + { + *kind = Token_bitand; + return; + } + break; + + case 'e': + if (m_buffer[m_ptr+1] == 'x' && + m_buffer[m_ptr+2] == 'p' && + m_buffer[m_ptr+3] == 'o' && + m_buffer[m_ptr+4] == 'r' && + m_buffer[m_ptr+5] == 't') + { + *kind = Token_export; + return; + } + if (m_buffer[m_ptr+1] == 'x' && + m_buffer[m_ptr+2] == 't' && + m_buffer[m_ptr+3] == 'e' && + m_buffer[m_ptr+4] == 'r' && + m_buffer[m_ptr+5] == 'n') + { + *kind = Token_extern; + return; + } + break; + + case 'd': + if (m_buffer[m_ptr+1] == 'e' && + m_buffer[m_ptr+2] == 'l' && + m_buffer[m_ptr+3] == 'e' && + m_buffer[m_ptr+4] == 't' && + m_buffer[m_ptr+5] == 'e') + { + *kind = Token_delete; + return; + } + if (m_buffer[m_ptr+1] == 'o' && + m_buffer[m_ptr+2] == 'u' && + m_buffer[m_ptr+3] == 'b' && + m_buffer[m_ptr+4] == 'l' && + m_buffer[m_ptr+5] == 'e') + { + *kind = Token_double; + return; + } + break; + + case 'f': + if (m_buffer[m_ptr+1] == 'r' && + m_buffer[m_ptr+2] == 'i' && + m_buffer[m_ptr+3] == 'e' && + m_buffer[m_ptr+4] == 'n' && + m_buffer[m_ptr+5] == 'd') + { + *kind = Token_friend; + return; + } + break; + + case 'i': + if (m_buffer[m_ptr+1] == 'n' && + m_buffer[m_ptr+2] == 'l' && + m_buffer[m_ptr+3] == 'i' && + m_buffer[m_ptr+4] == 'n' && + m_buffer[m_ptr+5] == 'e') + { + *kind = Token_inline; + return; + } + break; + + case 'K': + if (m_buffer[m_ptr+1] == '_' && + m_buffer[m_ptr+2] == 'D' && + m_buffer[m_ptr+3] == 'C' && + m_buffer[m_ptr+4] == 'O' && + m_buffer[m_ptr+5] == 'P') + { + *kind = Token_K_DCOP; + return; + } + break; + + case 'n': + if (m_buffer[m_ptr+1] == 'o' && + m_buffer[m_ptr+2] == 't' && + m_buffer[m_ptr+3] == '_' && + m_buffer[m_ptr+4] == 'e' && + m_buffer[m_ptr+5] == 'q') + { + *kind = Token_not_eq; + return; + } + break; + + case 'p': + if (m_buffer[m_ptr+1] == 'u' && + m_buffer[m_ptr+2] == 'b' && + m_buffer[m_ptr+3] == 'l' && + m_buffer[m_ptr+4] == 'i' && + m_buffer[m_ptr+5] == 'c') + { + *kind = Token_public; + return; + } + break; + + case 's': + if (m_buffer[m_ptr+1] == 'i' && + m_buffer[m_ptr+2] == 'g' && + m_buffer[m_ptr+3] == 'n' && + m_buffer[m_ptr+4] == 'e' && + m_buffer[m_ptr+5] == 'd') + { + *kind = Token_signed; + return; + } + if (m_buffer[m_ptr+1] == 'i' && + m_buffer[m_ptr+2] == 'z' && + m_buffer[m_ptr+3] == 'e' && + m_buffer[m_ptr+4] == 'o' && + m_buffer[m_ptr+5] == 'f') + { + *kind = Token_sizeof; + return; + } + if (m_buffer[m_ptr+1] == 't' && + m_buffer[m_ptr+2] == 'a' && + m_buffer[m_ptr+3] == 't' && + m_buffer[m_ptr+4] == 'i' && + m_buffer[m_ptr+5] == 'c') + { + *kind = Token_static; + return; + } + if (m_buffer[m_ptr+1] == 't' && + m_buffer[m_ptr+2] == 'r' && + m_buffer[m_ptr+3] == 'u' && + m_buffer[m_ptr+4] == 'c' && + m_buffer[m_ptr+5] == 't') + { + *kind = Token_struct; + return; + } + if (m_buffer[m_ptr+1] == 'w' && + m_buffer[m_ptr+2] == 'i' && + m_buffer[m_ptr+3] == 't' && + m_buffer[m_ptr+4] == 'c' && + m_buffer[m_ptr+5] == 'h') + { + *kind = Token_switch; + return; + } + break; + + case 'r': + if (m_buffer[m_ptr+1] == 'e' && + m_buffer[m_ptr+2] == 't' && + m_buffer[m_ptr+3] == 'u' && + m_buffer[m_ptr+4] == 'r' && + m_buffer[m_ptr+5] == 'n') + { + *kind = Token_return; + return; + } + break; + + case 't': + if (m_buffer[m_ptr+1] == 'y' && + m_buffer[m_ptr+2] == 'p' && + m_buffer[m_ptr+3] == 'e' && + m_buffer[m_ptr+4] == 'i' && + m_buffer[m_ptr+5] == 'd') + { + *kind = Token_typeid; + return; + } + break; + + case 'x': + if (m_buffer[m_ptr+1] == 'o' && + m_buffer[m_ptr+2] == 'r' && + m_buffer[m_ptr+3] == '_' && + m_buffer[m_ptr+4] == 'e' && + m_buffer[m_ptr+5] == 'q') + { + *kind = Token_xor_eq; + return; + } + break; + + case 'k': + if (m_buffer[m_ptr+1] == '_' && + m_buffer[m_ptr+2] == 'd' && + m_buffer[m_ptr+3] == 'c' && + m_buffer[m_ptr+4] == 'o' && + m_buffer[m_ptr+5] == 'p') + { + *kind = Token_k_dcop; + return; + } + break; + + } + *kind = Token_identifier; +} + +void CppLexer::scanKeyword7(int *kind) +{ + switch (m_buffer[m_ptr]) { + case 'd': + if (m_buffer[m_ptr+1] == 'e' && + m_buffer[m_ptr+2] == 'f' && + m_buffer[m_ptr+3] == 'a' && + m_buffer[m_ptr+4] == 'u' && + m_buffer[m_ptr+5] == 'l' && + m_buffer[m_ptr+6] == 't') + { + *kind = Token_default; + return; + } + break; + + case 'm': + if (m_buffer[m_ptr+1] == 'u' && + m_buffer[m_ptr+2] == 't' && + m_buffer[m_ptr+3] == 'a' && + m_buffer[m_ptr+4] == 'b' && + m_buffer[m_ptr+5] == 'l' && + m_buffer[m_ptr+6] == 'e') + { + *kind = Token_mutable; + return; + } + break; + + case 'p': + if (m_buffer[m_ptr+1] == 'r' && + m_buffer[m_ptr+2] == 'i' && + m_buffer[m_ptr+3] == 'v' && + m_buffer[m_ptr+4] == 'a' && + m_buffer[m_ptr+5] == 't' && + m_buffer[m_ptr+6] == 'e') + { + *kind = Token_private; + return; + } + break; +#if 0 + case 's': + if (m_buffer[m_ptr+1] == 'i' && + m_buffer[m_ptr+2] == 'g' && + m_buffer[m_ptr+3] == 'n' && + m_buffer[m_ptr+4] == 'a' && + m_buffer[m_ptr+5] == 'l' && + m_buffer[m_ptr+6] == 's') + { + *kind = Token_signals; + return; + } + break; +#endif + case 't': + if (m_buffer[m_ptr+1] == 'y' && + m_buffer[m_ptr+2] == 'p' && + m_buffer[m_ptr+3] == 'e' && + m_buffer[m_ptr+4] == 'd' && + m_buffer[m_ptr+5] == 'e' && + m_buffer[m_ptr+6] == 'f') + { + *kind = Token_typedef; + return; + } + break; + + case 'v': + if (m_buffer[m_ptr+1] == 'i' && + m_buffer[m_ptr+2] == 'r' && + m_buffer[m_ptr+3] == 't' && + m_buffer[m_ptr+4] == 'u' && + m_buffer[m_ptr+5] == 'a' && + m_buffer[m_ptr+6] == 'l') + { + *kind = Token_virtual; + return; + } + break; + } + *kind = Token_identifier; +} + +void CppLexer::scanKeyword8(int *kind) +{ + switch (m_buffer[m_ptr]) { + case '_': + if (m_buffer[m_ptr+1] == '_' && + m_buffer[m_ptr+2] == 't' && + m_buffer[m_ptr+3] == 'y' && + m_buffer[m_ptr+4] == 'p' && + m_buffer[m_ptr+5] == 'e' && + m_buffer[m_ptr+6] == 'o' && + m_buffer[m_ptr+7] == 'f') + { + *kind = Token___typeof; + return; + } + break; + + case 'c': + if (m_buffer[m_ptr+1] == 'o' && + m_buffer[m_ptr+2] == 'n' && + m_buffer[m_ptr+3] == 't' && + m_buffer[m_ptr+4] == 'i' && + m_buffer[m_ptr+5] == 'n' && + m_buffer[m_ptr+6] == 'u' && + m_buffer[m_ptr+7] == 'e') + { + *kind = Token_continue; + return; + } + break; + + case 'e': + if (m_buffer[m_ptr+1] == 'x' && + m_buffer[m_ptr+2] == 'p' && + m_buffer[m_ptr+3] == 'l' && + m_buffer[m_ptr+4] == 'i' && + m_buffer[m_ptr+5] == 'c' && + m_buffer[m_ptr+6] == 'i' && + m_buffer[m_ptr+7] == 't') + { + *kind = Token_explicit; + return; + } + break; + + case 'o': + if (m_buffer[m_ptr+1] == 'p' && + m_buffer[m_ptr+2] == 'e' && + m_buffer[m_ptr+3] == 'r' && + m_buffer[m_ptr+4] == 'a' && + m_buffer[m_ptr+5] == 't' && + m_buffer[m_ptr+6] == 'o' && + m_buffer[m_ptr+7] == 'r') + { + *kind = Token_operator; + return; + } + break; + + case 'Q': + if (m_buffer[m_ptr+1] == '_' && + m_buffer[m_ptr+2] == 'O' && + m_buffer[m_ptr+3] == 'B' && + m_buffer[m_ptr+4] == 'J' && + m_buffer[m_ptr+5] == 'E' && + m_buffer[m_ptr+6] == 'C' && + m_buffer[m_ptr+7] == 'T') + { + *kind = Token_Q_OBJECT; + return; + } + break; + + case 'r': + if (m_buffer[m_ptr+1] == 'e' && + m_buffer[m_ptr+2] == 'g' && + m_buffer[m_ptr+3] == 'i' && + m_buffer[m_ptr+4] == 's' && + m_buffer[m_ptr+5] == 't' && + m_buffer[m_ptr+6] == 'e' && + m_buffer[m_ptr+7] == 'r') + { + *kind = Token_register; + return; + } + break; + + case 'u': + if (m_buffer[m_ptr+1] == 'n' && + m_buffer[m_ptr+2] == 's' && + m_buffer[m_ptr+3] == 'i' && + m_buffer[m_ptr+4] == 'g' && + m_buffer[m_ptr+5] == 'n' && + m_buffer[m_ptr+6] == 'e' && + m_buffer[m_ptr+7] == 'd') + { + *kind = Token_unsigned; + return; + } + break; + + case 't': + if (m_buffer[m_ptr+1] == 'e' && + m_buffer[m_ptr+2] == 'm' && + m_buffer[m_ptr+3] == 'p' && + m_buffer[m_ptr+4] == 'l' && + m_buffer[m_ptr+5] == 'a' && + m_buffer[m_ptr+6] == 't' && + m_buffer[m_ptr+7] == 'e') + { + *kind = Token_template; + return; + } + if (m_buffer[m_ptr+1] == 'y' && + m_buffer[m_ptr+2] == 'p' && + m_buffer[m_ptr+3] == 'e' && + m_buffer[m_ptr+4] == 'n' && + m_buffer[m_ptr+5] == 'a' && + m_buffer[m_ptr+6] == 'm' && + m_buffer[m_ptr+7] == 'e') + { + *kind = Token_typename; + return; + } + break; + + case 'v': + if (m_buffer[m_ptr+1] == 'o' && + m_buffer[m_ptr+2] == 'l' && + m_buffer[m_ptr+3] == 'a' && + m_buffer[m_ptr+4] == 't' && + m_buffer[m_ptr+5] == 'i' && + m_buffer[m_ptr+6] == 'l' && + m_buffer[m_ptr+7] == 'e') + { + *kind = Token_volatile; + return; + } + break; + + } + *kind = Token_identifier; +} + +void CppLexer::scanKeyword9(int *kind) +{ + switch (m_buffer[m_ptr]) { + case 'p': + if (m_buffer[m_ptr+1] == 'r' && + m_buffer[m_ptr+2] == 'o' && + m_buffer[m_ptr+3] == 't' && + m_buffer[m_ptr+4] == 'e' && + m_buffer[m_ptr+5] == 'c' && + m_buffer[m_ptr+6] == 't' && + m_buffer[m_ptr+7] == 'e' && + m_buffer[m_ptr+8] == 'd') + { + *kind = Token_protected; + return; + } + break; + + case 'n': + if (m_buffer[m_ptr+1] == 'a' && + m_buffer[m_ptr+2] == 'm' && + m_buffer[m_ptr+3] == 'e' && + m_buffer[m_ptr+4] == 's' && + m_buffer[m_ptr+5] == 'p' && + m_buffer[m_ptr+6] == 'a' && + m_buffer[m_ptr+7] == 'c' && + m_buffer[m_ptr+8] == 'e') + { + *kind = Token_namespace; + return; + } + break; + + } + *kind = Token_identifier; +} + +void CppLexer::scanKeyword10(int *kind) +{ + switch (m_buffer[m_ptr]) { + case 'c': + if (m_buffer[m_ptr+1] == 'o' && + m_buffer[m_ptr+2] == 'n' && + m_buffer[m_ptr+3] == 's' && + m_buffer[m_ptr+4] == 't' && + m_buffer[m_ptr+5] == '_' && + m_buffer[m_ptr+6] == 'c' && + m_buffer[m_ptr+7] == 'a' && + m_buffer[m_ptr+8] == 's' && + m_buffer[m_ptr+9] == 't') + { + *kind = Token_const_cast; + return; + } + break; + + } + *kind = Token_identifier; +} + +void CppLexer::scanKeyword11(int *kind) +{ + switch (m_buffer[m_ptr]) { + case 's': + if (m_buffer[m_ptr+1] == 't' && + m_buffer[m_ptr+2] == 'a' && + m_buffer[m_ptr+3] == 't' && + m_buffer[m_ptr+4] == 'i' && + m_buffer[m_ptr+5] == 'c' && + m_buffer[m_ptr+6] == '_' && + m_buffer[m_ptr+7] == 'c' && + m_buffer[m_ptr+8] == 'a' && + m_buffer[m_ptr+9] == 's' && + m_buffer[m_ptr+10] == 't') + { + *kind = Token_static_cast; + return; + } + break; + + } + *kind = Token_identifier; +} + +void CppLexer::scanKeyword12(int *kind) +{ + switch (m_buffer[m_ptr]) { + case 'd': + if (m_buffer[m_ptr+1] == 'y' && + m_buffer[m_ptr+2] == 'n' && + m_buffer[m_ptr+3] == 'a' && + m_buffer[m_ptr+4] == 'm' && + m_buffer[m_ptr+5] == 'i' && + m_buffer[m_ptr+6] == 'c' && + m_buffer[m_ptr+7] == '_' && + m_buffer[m_ptr+8] == 'c' && + m_buffer[m_ptr+9] == 'a' && + m_buffer[m_ptr+10] == 's' && + m_buffer[m_ptr+11] == 't') + { + *kind = Token_dynamic_cast; + return; + } + break; + + } + *kind = Token_identifier; +} + +void CppLexer::scanKeyword14(int *kind) +{ + switch (m_buffer[m_ptr]) { + case 'k': + if (m_buffer[m_ptr+1] == '_' && + m_buffer[m_ptr+2] == 'd' && + m_buffer[m_ptr+3] == 'c' && + m_buffer[m_ptr+4] == 'o' && + m_buffer[m_ptr+5] == 'p' && + m_buffer[m_ptr+6] == '_' && + m_buffer[m_ptr+7] == 's' && + m_buffer[m_ptr+8] == 'i' && + m_buffer[m_ptr+9] == 'g' && + m_buffer[m_ptr+10] == 'n' && + m_buffer[m_ptr+11] == 'a' && + m_buffer[m_ptr+12] == 'l' && + m_buffer[m_ptr+13] == 's') + { + *kind = Token_k_dcop_signals; + return; + } + break; + + } + *kind = Token_identifier; +} + +void CppLexer::scanKeyword16(int *kind) +{ + switch (m_buffer[m_ptr]) { + case 'r': + if (m_buffer[m_ptr+1] == 'e' && + m_buffer[m_ptr+2] == 'i' && + m_buffer[m_ptr+3] == 'n' && + m_buffer[m_ptr+4] == 't' && + m_buffer[m_ptr+5] == 'e' && + m_buffer[m_ptr+6] == 'r' && + m_buffer[m_ptr+7] == 'p' && + m_buffer[m_ptr+8] == 'r' && + m_buffer[m_ptr+9] == 'e' && + m_buffer[m_ptr+10] == 't' && + m_buffer[m_ptr+11] == '_' && + m_buffer[m_ptr+12] == 'c' && + m_buffer[m_ptr+13] == 'a' && + m_buffer[m_ptr+14] == 's' && + m_buffer[m_ptr+15] == 't') + { + *kind = Token_reinterpret_cast; + return; + } + break; + + } + *kind = Token_identifier; +} + + + +void CppLexer::scanChar(int *kind) +{ + *kind = m_buffer[m_ptr++]; +} + +void CppLexer::scanWhiteSpaces(int *kind) +{ + *kind = Token_whitespaces; +} + +void CppLexer::scanNewline(int *kind) +{ + *kind = '\n'; +} + +void CppLexer::scanUnicodeChar(int *kind) +{ + *kind = m_buffer[0]; +} + +void CppLexer::scanCharLiteral(int *kind) +{ + *kind = Token_char_literal; +} + +void CppLexer::scanStringLiteral(int *kind) +{ + *kind = Token_string_literal; +} + +void CppLexer::scanIdentifier(int *kind) +{ + if (m_len <16) + (this->*s_scan_keyword_table[m_len])(kind); + else + (this->*s_scan_keyword_table[0])(kind); +} + +void CppLexer::scanNumberLiteral(int *kind) +{ + *kind = Token_number_literal; +} + +void CppLexer::scanOperator(int *kind) +{ + switch (m_buffer[m_ptr]) { + case ':': + if (m_buffer[m_ptr+1] == ':') { + *kind = Token_scope; + return; + } + break; + + case '*': + case '/': + case '%': + case '^': + if (m_buffer[m_ptr+1] == '=') { + *kind = Token_assign; + return; + } + break; + + case '=': + case '!': + if (m_buffer[m_ptr+1] == '=') { + *kind = Token_eq; + return; + } + break; + + case '&': + if (m_buffer[m_ptr+1] == '&') { + *kind = Token_and; + return; + } else if (m_buffer[m_ptr+1] == '=') { + *kind = Token_assign; + return; + } + break; + + case '|': + if (m_buffer[m_ptr+1] == '|' ) { + *kind = Token_or; + return; + } else if (m_buffer[m_ptr+1] == '=') { + *kind = Token_assign; + return; + } + break; + + case '+': + if (m_buffer[m_ptr+1] == '+' ) { + *kind = Token_incr; + return; + } else if (m_buffer[m_ptr+1] == '=') { + *kind = Token_assign; + return; + } + break; + + case '<': + if (m_buffer[m_ptr+1] == '<') { + if (m_buffer[m_ptr+2] == '=') { + *kind = Token_assign; + return; + } + *kind = Token_shift; + return; + } else if (m_buffer[m_ptr+1] == '=') { + *kind = Token_leq; + return; + } + break; + + case '>': + if (m_buffer[m_ptr+1] == '>') { + if (m_buffer[m_ptr+2] == '=') { + *kind = Token_assign; + return; + } + *kind = Token_shift; + return; + } else if (m_buffer[m_ptr+1] == '=') { + *kind = Token_geq; + return; + } + break; + + case '-': + if (m_buffer[m_ptr+1] == '>') { + if (m_buffer[m_ptr+2] == '*') { + *kind = Token_ptrmem; + return; + } + *kind = Token_arrow; + return; + } else if (m_buffer[m_ptr+1] == '-') { + *kind = Token_decr; + return; + } else if (m_buffer[m_ptr+1] == '=') { + *kind = Token_assign; + return; + } + break; + + case '.': + if (m_buffer[m_ptr+1] == '.' && m_buffer[m_ptr+2] == '.') { + *kind = Token_ellipsis; + return; + } else if (m_buffer[m_ptr+1] == '*') { + *kind = Token_ptrmem; + return; + } + break; + + } + + *kind = m_buffer[m_ptr++]; +} + +QT_END_NAMESPACE diff --git a/tools/porting/src/cpplexer.h b/tools/porting/src/cpplexer.h new file mode 100644 index 0000000..3941d96 --- /dev/null +++ b/tools/porting/src/cpplexer.h @@ -0,0 +1,107 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef CPPLEXER_H +#define CPPLEXER_H + +#include "tokenengine.h" +#include "tokens.h" +#include <QVector> + +QT_BEGIN_NAMESPACE + +class CppLexer +{ +public: + CppLexer(); + typedef void (CppLexer::*scan_fun_ptr)(int *kind); + QVector<Type> lex(TokenEngine::TokenSectionSequence tokenContainer); +private: + Type identify(const TokenEngine::TokenTempRef &tokenTempRef); + void setupScanTable(); + + void scanChar(int *kind); + void scanUnicodeChar(int *kind); + void scanNewline(int *kind); + void scanWhiteSpaces(int *kind); + void scanCharLiteral(int *kind); + void scanStringLiteral(int *kind); + void scanNumberLiteral(int *kind); + void scanIdentifier(int *kind); + void scanPreprocessor(int *kind); + void scanOperator(int *kind); + + void scanKeyword0(int *kind); + void scanKeyword2(int *kind); + void scanKeyword3(int *kind); + void scanKeyword4(int *kind); + void scanKeyword5(int *kind); + void scanKeyword6(int *kind); + void scanKeyword7(int *kind); + void scanKeyword8(int *kind); + void scanKeyword9(int *kind); + void scanKeyword10(int *kind); + void scanKeyword11(int *kind); + void scanKeyword12(int *kind); + void scanKeyword14(int *kind); + void scanKeyword16(int *kind); + + CppLexer::scan_fun_ptr s_scan_table[128+1]; + int s_attr_table[256]; + CppLexer::scan_fun_ptr s_scan_keyword_table[17]; + + enum + { + A_Alpha = 0x01, + A_Digit = 0x02, + A_Alphanum = A_Alpha | A_Digit, + A_Whitespace = 0x04 + }; + + const char *m_buffer; + int m_ptr; + int m_len; +}; + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/errors.cpp b/tools/porting/src/errors.cpp new file mode 100644 index 0000000..d08ecbd --- /dev/null +++ b/tools/porting/src/errors.cpp @@ -0,0 +1,51 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "errors.h" + +QT_BEGIN_NAMESPACE + +QT_STATIC_CONST_IMPL Error Errors::InternalError = Error( 1, -1, QLatin1String("Internal Error") ); +QT_STATIC_CONST_IMPL Error Errors::SyntaxError = Error( 2, -1, QLatin1String("Syntax Error before '%1'") ); +QT_STATIC_CONST_IMPL Error Errors::ParseError = Error( 3, -1, QLatin1String("Parse Error before '%1'") ); + +QT_END_NAMESPACE diff --git a/tools/porting/src/errors.h b/tools/porting/src/errors.h new file mode 100644 index 0000000..dde2ae4 --- /dev/null +++ b/tools/porting/src/errors.h @@ -0,0 +1,71 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef ERRORS_H +#define ERRORS_H + +#include <QString> + +QT_BEGIN_NAMESPACE + +class Error +{ +public: + int code; + int level; + QString text; + + inline Error(int c, int l, const QString &s) + : code(c), level(l), text(s) {} +}; + +class Errors +{ +public: + QT_STATIC_CONST Error InternalError; + QT_STATIC_CONST Error SyntaxError; + QT_STATIC_CONST Error ParseError; +}; + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/fileporter.cpp b/tools/porting/src/fileporter.cpp new file mode 100644 index 0000000..afd3b4e --- /dev/null +++ b/tools/porting/src/fileporter.cpp @@ -0,0 +1,369 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "preprocessorcontrol.h" +#include "fileporter.h" +#include "replacetoken.h" +#include "logger.h" +#include "tokenizer.h" +#include "filewriter.h" +#include <QFile> +#include <QDir> +#include <QFileInfo> +#include <QHash> +#include <QtDebug> + +QT_BEGIN_NAMESPACE + +using namespace TokenEngine; +using namespace Rpp; + +FilePorter::FilePorter(PreprocessorCache &preprocessorCache) +:preprocessorCache(preprocessorCache) +,tokenReplacementRules(PortingRules::instance()->getTokenReplacementRules()) +,headerReplacements(PortingRules::instance()->getHeaderReplacements()) +,replaceToken(tokenReplacementRules) +{ + foreach (const QString &headerName, PortingRules::instance()->getHeaderList(PortingRules::Qt4)) { + qt4HeaderNames.insert(headerName.toLatin1()); + } +} + +/* + Ports a file given by fileName, which should be an absolute file path. +*/ +void FilePorter::port(QString fileName) +{ + // Get file tokens from cache. + TokenContainer sourceTokens = preprocessorCache.sourceTokens(fileName); + if(sourceTokens.count() == 0) + return; + + Logger::instance()->beginSection(); + + // Get include directive replacements. + const Rpp::Source * source = preprocessorCache.sourceTree(fileName); + PreprocessReplace preprocessReplace(source, PortingRules::instance()->getHeaderReplacements()); + TextReplacements sourceReplacements = preprocessReplace.getReplacements(); + + // Get token replacements. + sourceReplacements += replaceToken.getTokenTextReplacements(sourceTokens); + + // Apply the replacements to the source text. + QByteArray portedContents = sourceReplacements.apply(sourceTokens.fullText()); + + // Add include directives for classes that are no longer implicitly + // included via other headers. This step needs to be done after the token + // replacements, since we need to know which new class names that has been + // inserted in the source. + portedContents = includeAnalyse(portedContents); + + // Check if any changes has been made. + if(portedContents == sourceTokens.fullText()) { + Logger::instance()->addEntry( + new PlainLogEntry(QLatin1String("Info"), QLatin1String("Porting"), QLatin1String("No changes made to file ") + fileName)); + Logger::instance()->commitSection(); + return; + } + + // Write file, commit log if write was successful. + FileWriter::WriteResult result = FileWriter::instance()->writeFileVerbously(fileName, portedContents); + Logger *logger = Logger::instance(); + if (result == FileWriter::WriteSucceeded) { + logger->commitSection(); + } else if (result == FileWriter::WriteFailed) { + logger->revertSection(); + logger->addEntry( + new PlainLogEntry(QLatin1String("Error"), QLatin1String("Porting"), QLatin1String("Error writing to file ") + fileName)); + } else if (result == FileWriter::WriteSkipped) { + logger->revertSection(); + logger->addEntry( + new PlainLogEntry(QLatin1String("Error"), QLatin1String("Porting"), QLatin1String("User skipped file ") + fileName)); + } else { + // Internal error. + logger->revertSection(); + const QString errorString = QLatin1String("Internal error in qt3to4 - FileWriter returned invalid result code while writing to ") + fileName; + logger->addEntry(new PlainLogEntry(QLatin1String("Error"), QLatin1String("Porting"), errorString)); + } +} + +QSet<QByteArray> FilePorter::usedQtModules() +{ + return m_usedQtModules; +} + +TextReplacements FilePorter::includeDirectiveReplacements() +{ + return TextReplacements(); +} + +QByteArray FilePorter::includeAnalyse(QByteArray fileContents) +{ + // Tokenize file contents agein, since it has changed. + QVector<TokenEngine::Token> tokens = tokenizer.tokenize(fileContents); + TokenEngine::TokenContainer tokenContainer(fileContents, tokens); + IncludeDirectiveAnalyzer includeDirectiveAnalyzer(tokenContainer); + + // Get list of used classes. + QSet<QByteArray> classes = includeDirectiveAnalyzer.usedClasses(); + + // Iterate class list and find which modules are used. This info is used elswhere + // by when porting the .pro file. + const QHash<QByteArray, QByteArray> classLibraryList = PortingRules::instance()->getClassLibraryList(); + foreach (const QByteArray &className, classes) { + m_usedQtModules.insert(classLibraryList.value(className)); + } + + // Get list of included headers. + QSet<QByteArray> headers = includeDirectiveAnalyzer.includedHeaders(); + + // Find classes that is missing an include directive and that has a needHeader rule. + const QHash<QByteArray, QByteArray> neededHeaders = PortingRules::instance()->getNeededHeaders(); + QList<QByteArray> insertHeaders; + foreach (const QByteArray &className, classes) { + if (!headers.contains((className.toLower() + QByteArray(".h"))) && + !headers.contains(className)) { + const QByteArray insertHeader = neededHeaders.value(className); + if (insertHeader != QByteArray()) + insertHeaders.append((QByteArray("#include <") + insertHeader + QByteArray(">"))); + } + } + + const QByteArray lineEnding = detectLineEndings(fileContents); + + // Insert include directives undeclared classes. + int insertCount = insertHeaders.count(); + if (insertCount > 0) { + QByteArray insertText; + QByteArray logText; + + insertText += QByteArray("//Added by qt3to4:") + lineEnding; + logText += QByteArray("In file "); + logText += Logger::instance()->globalState.value(QLatin1String("currentFileName")).toLocal8Bit(); + logText += QByteArray(": Added the following include directives:\n"); + foreach (const QByteArray &headerName, insertHeaders) { + insertText = insertText + headerName + lineEnding; + logText += QByteArray("\t"); + logText += headerName + QByteArray(" "); + } + + const int insertLine = 0; + Logger::instance()->updateLineNumbers(insertLine, insertCount + 1); + const int insertPos = includeDirectiveAnalyzer.insertPos(); + fileContents.insert(insertPos, insertText); + Logger::instance()->addEntry(new PlainLogEntry(QLatin1String("Info"), QLatin1String("Porting"), QString::fromLatin1(logText.constData()))); + } + + return fileContents; +} + +PreprocessReplace::PreprocessReplace(const Rpp::Source *source, const QHash<QByteArray, QByteArray> &headerReplacements) +:headerReplacements(headerReplacements) +{ + // Walk preprocessor tree. + evaluateItem(source); +} + +TextReplacements PreprocessReplace::getReplacements() +{ + return replacements; +} +/* + Replaces headers no longer present with support headers. +*/ +void PreprocessReplace::evaluateIncludeDirective(const Rpp::IncludeDirective *directive) +{ + const QByteArray headerPathName = directive->filename(); + const TokenEngine::TokenList headerPathTokens = directive->filenameTokens(); + + // Get the file name part of the file path. + const QByteArray headerFileName = QFileInfo(QString::fromLatin1(headerPathName.constData())).fileName().toUtf8(); + + // Check if we should replace the filename. + QByteArray replacement = headerReplacements.value(headerFileName); + + // Also check lower-case version to catch incorrectly capitalized file names on Windows. + if (replacement.isEmpty()) + replacement = headerReplacements.value(headerFileName.toLower()); + + const int numTokens = headerPathTokens.count(); + if (numTokens > 0 && !replacement.isEmpty()) { + // Here we assume that the last token contains a part of the file name. + const TokenEngine::Token lastToken = headerPathTokens.token(numTokens -1); + int endPos = lastToken.start + lastToken.length; + // If the file name is specified in quotes, then the quotes will be a part + // of the token. Decrement endpos to leave out the ending quote when replacing. + if (directive->includeType() == IncludeDirective::QuoteInclude) + --endPos; + const int length = headerFileName.count(); + const int startPos = endPos - length; + replacements.insert(replacement, startPos, length); + addLogSourceEntry(QString::fromLatin1((headerFileName + QByteArray(" -> ") + replacement).constData()), + headerPathTokens.tokenContainer(0), headerPathTokens.containerIndex(0)); + } +} + +/* + Replace line comments containing MOC_SKIP_BEGIN with #ifdef Q_MOC_RUN and MOC_SKIP_END with #endif +*/ +void PreprocessReplace::evaluateText(const Rpp::Text *textLine) +{ + if (textLine->count() < 1) + return; + + const TokenEngine::TokenContainer container = textLine->text().tokenContainer(0); + foreach (Rpp::Token *token, textLine->tokenList()) { + if (token->toLineComment()) { + const int tokenIndex = token->index(); + const QByteArray text = container.text(tokenIndex); + const TokenEngine::Token containerToken = container.token(tokenIndex); + + if (text.contains(QByteArray("MOC_SKIP_BEGIN"))) { + replacements.insert(QByteArray("#ifndef Q_MOC_RUN"), containerToken.start, containerToken.length); + addLogSourceEntry(QLatin1String("MOC_SKIP_BEGIN -> #ifndef Q_MOC_RUN"), container, tokenIndex); + } + if (text.contains(QByteArray("MOC_SKIP_END"))) { + replacements.insert(QByteArray("#endif"), containerToken.start, containerToken.length); + addLogSourceEntry(QLatin1String("MOC_SKIP_END -> #endif"), container, tokenIndex); + } + } + } +} + +IncludeDirectiveAnalyzer::IncludeDirectiveAnalyzer(const TokenEngine::TokenContainer &fileContents) +:fileContents(fileContents) +{ + const QVector<Type> lexical = RppLexer().lex(fileContents); + source = Preprocessor().parse(fileContents, lexical, &mempool); + foundInsertPos = false; + foundQtHeader = false; + ifSectionCount = 0; + insertTokenIndex = 0; + + evaluateItem(source); +} + +/* + Returns a position indicating where new include directives should be inserted. +*/ +int IncludeDirectiveAnalyzer::insertPos() +{ + const TokenEngine::Token insertToken = fileContents.token(insertTokenIndex); + return insertToken.start; +} + +/* + Returns a set of all headers included from this file. +*/ +QSet<QByteArray> IncludeDirectiveAnalyzer::includedHeaders() +{ + return m_includedHeaders; +} + +/* + Returns a list of used Qt classes. +*/ +QSet<QByteArray> IncludeDirectiveAnalyzer::usedClasses() +{ + return m_usedClasses; +} + +/* + Set insetionTokenindex to a token near other #include directives, preferably + just after a block of include directives that includes other Qt headers. +*/ +void IncludeDirectiveAnalyzer::evaluateIncludeDirective(const IncludeDirective *directive) +{ + const QByteArray filename = directive->filename(); + if (filename.isEmpty()) + return; + + m_includedHeaders.insert(filename); + + if (foundInsertPos || ifSectionCount > 1) + return; + + const bool isQtHeader = (filename.at(0) == 'q' || filename.at(0) == 'Q'); + if (!isQtHeader && foundQtHeader) { + foundInsertPos = true; + return; + } + + if (isQtHeader) + foundQtHeader = true; + + // Get the last token for this directive. + TokenEngine::TokenSection tokenSection = directive->text(); + const int newLineToken = 1; + insertTokenIndex = tokenSection.containerIndex(tokenSection.count() - 1) + newLineToken; +} + +/* + Avoid inserting inside IfSections, except in the first one + we see, which probably is the header multiple inclusion guard. +*/ +void IncludeDirectiveAnalyzer::evaluateIfSection(const IfSection *ifSection) +{ + ++ifSectionCount; + RppTreeWalker::evaluateIfSection(ifSection); + --ifSectionCount; +} + +/* + Read all IdTokens and look for Qt class names. Also, on + the first IdToken set foundInsertPos to true + +*/ +void IncludeDirectiveAnalyzer::evaluateText(const Text *textLine) +{ + const int numTokens = textLine->count(); + for (int t = 0; t < numTokens; ++t) { + Rpp::Token *token = textLine->token(t); + if (token->toIdToken()) { + foundInsertPos = true; + const int containerIndex = token->index(); + const QByteArray tokenText = fileContents.text(containerIndex); + m_usedClasses.insert(tokenText); + } + } +} + +QT_END_NAMESPACE diff --git a/tools/porting/src/fileporter.h b/tools/porting/src/fileporter.h new file mode 100644 index 0000000..b3c80c1 --- /dev/null +++ b/tools/porting/src/fileporter.h @@ -0,0 +1,116 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef FILEPORTER_H +#define FILEPORTER_H + +#include "portingrules.h" +#include "replacetoken.h" +#include "filewriter.h" +#include "preprocessorcontrol.h" +#include <QString> +#include <QSet> +#include <QMap> + +QT_BEGIN_NAMESPACE + +class FilePorter +{ +public: + FilePorter(PreprocessorCache &preprocessorCache); + void port(QString fileName); + QSet<QByteArray> usedQtModules(); +private: + QByteArray loadFile(const QString &fileName); + QByteArray includeAnalyse(QByteArray fileContents); + TextReplacements includeDirectiveReplacements(); + + PreprocessorCache &preprocessorCache; + const QList<TokenReplacement*> tokenReplacementRules; + const QHash<QByteArray, QByteArray> headerReplacements; + + ReplaceToken replaceToken; + Tokenizer tokenizer; //used by includeAnalyse + + QSet<QByteArray> qt4HeaderNames; + QSet<QByteArray> m_usedQtModules; +}; + +class PreprocessReplace : public Rpp::RppTreeWalker +{ +public: + PreprocessReplace(const Rpp::Source *source, const QHash<QByteArray, QByteArray> &headerReplacements); + TextReplacements getReplacements(); +private: + void evaluateIncludeDirective(const Rpp::IncludeDirective *directive); + void evaluateText(const Rpp::Text *textLine); + const QHash<QByteArray, QByteArray> headerReplacements; + TextReplacements replacements; + +}; + +class IncludeDirectiveAnalyzer : public Rpp::RppTreeWalker +{ +public: + IncludeDirectiveAnalyzer(const TokenEngine::TokenContainer &fileContents); + int insertPos(); + QSet<QByteArray> includedHeaders(); + QSet<QByteArray> usedClasses(); +private: + void evaluateIncludeDirective(const Rpp::IncludeDirective *directive); + void evaluateIfSection(const Rpp::IfSection *ifSection); + void evaluateText(const Rpp::Text *textLine); + + int insertTokenIndex; + bool foundInsertPos; + bool foundQtHeader; + int ifSectionCount; + + const TokenEngine::TokenContainer &fileContents; + Rpp::Source *source; + TypedPool<Rpp::Item> mempool; + QSet<QByteArray> m_includedHeaders; + QSet<QByteArray> m_usedClasses; +}; + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/filewriter.cpp b/tools/porting/src/filewriter.cpp new file mode 100644 index 0000000..d8914ce --- /dev/null +++ b/tools/porting/src/filewriter.cpp @@ -0,0 +1,159 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "filewriter.h" +#include <QFile> +#include <QFileInfo> +#include <QDir> +#include <ctype.h> +#include <errno.h> + +QT_BEGIN_NAMESPACE + +FileWriter *FileWriter::theInstance = 0; + +FileWriter *FileWriter::instance() +{ + if(!theInstance) + theInstance = new FileWriter(); + + return theInstance; +} + +void FileWriter::deleteInstance() +{ + if(theInstance) { + delete theInstance; + theInstance=0; + } +} + +FileWriter::FileWriter(OverWriteFiles overWrite, QString overwriteMsg) +:overWriteFiles(overWrite) +,overwriteMessage(overwriteMsg) +{ + if(overwriteMessage.isEmpty()) + overwriteMessage = QLatin1String("Convert file "); +} + +FileWriter::WriteResult FileWriter::writeFileVerbously(QString filePath, QByteArray contents) +{ + const WriteResult result = writeFile(filePath, contents); + if (result == WriteSucceeded) { + QString cleanPath = QDir::cleanPath(filePath); + printf("Wrote to file: %s \n", QDir::toNativeSeparators(cleanPath).toLocal8Bit().constData()); + } + return result; +} + +FileWriter::WriteResult FileWriter::writeFile(QString filePath, QByteArray contents) +{ + if(filePath.isEmpty()) + return WriteFailed; + QString path = QFileInfo(filePath).path(); + if (!QDir().mkpath(path)){ + printf("Error creating path %s \n", QDir::toNativeSeparators(path).toLocal8Bit().constData()); + } + + QString cleanPath = QDir::cleanPath(filePath); + QFile f(cleanPath); + if (f.exists()) { + if (overWriteFiles == DontOverWrite) { + printf("Error writing file %s: It already exists \n", + QDir::toNativeSeparators(cleanPath).toLatin1().constData()); + return WriteFailed; + } else if(overWriteFiles == AskOnOverWrite) { + printf("%s%s? (Y)es, (N)o, (A)ll ", overwriteMessage.toLatin1().constData(), + QDir::toNativeSeparators(cleanPath).toLatin1().constData()); + + char answer = 0; + while (answer != 'y' && answer != 'n' && answer != 'a') { +#if defined(Q_OS_WIN) && defined(_MSC_VER) && _MSC_VER >= 1400 + int result = scanf_s("%c", &answer); +#else + int result = scanf("%c", &answer); +#endif + if (1 == result) + answer = tolower(answer); + else if (EOF == result) { + if (EINTR == errno || EILSEQ == errno) + continue; + + answer = 'n'; + } + } + + if(answer == 'n') + return WriteSkipped; + else if(answer == 'a') + overWriteFiles=AlwaysOverWrite; + } + } + + f.open(QFile::WriteOnly); + if (f.isOpen() && f.write(contents) == contents.size()) + return WriteSucceeded; + + printf("Could not write to to file: %s. Is it write protected?\n", + QDir::toNativeSeparators(filePath).toLatin1().constData()); + + return WriteFailed; +} + +/* + Sets the write mode for the file writer. writeMode is one of + DontOverWrite, AlwaysOverWrite, AskOnOverWrite. +*/ +void FileWriter::setOverwriteFiles(OverWriteFiles writeMode) +{ + overWriteFiles = writeMode; +} + +QByteArray detectLineEndings(const QByteArray &array) +{ + if (array.contains("\r\n")) { + return "\r\n"; + } else { + return "\n"; + } +} + +QT_END_NAMESPACE diff --git a/tools/porting/src/filewriter.h b/tools/porting/src/filewriter.h new file mode 100644 index 0000000..b22cd21 --- /dev/null +++ b/tools/porting/src/filewriter.h @@ -0,0 +1,75 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef FILEWRITER_H +#define FILEWRITER_H + +#include <QMap> +#include <QString> +#include <QByteArray> + +QT_BEGIN_NAMESPACE + +class FileWriter +{ +public: + enum OverWriteFiles{DontOverWrite, AlwaysOverWrite, AskOnOverWrite}; + enum WriteResult { WriteFailed = 0, WriteSucceeded = 1, WriteSkipped }; + static FileWriter *instance(); + static void deleteInstance(); + + FileWriter(OverWriteFiles overWRite = AskOnOverWrite, + QString overwriteMessage = QString()); + WriteResult writeFile(QString filePath, QByteArray contents); + WriteResult writeFileVerbously(QString filePath, QByteArray contents); + void setOverwriteFiles(OverWriteFiles writeMode); +private: + QMap<QString, int> processedFilesSet; + OverWriteFiles overWriteFiles; + QString overwriteMessage; + static FileWriter *theInstance; +}; + +QByteArray detectLineEndings(const QByteArray &array); + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/list.h b/tools/porting/src/list.h new file mode 100644 index 0000000..fdba81f --- /dev/null +++ b/tools/porting/src/list.h @@ -0,0 +1,374 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef LIST_H +#define LIST_H + +#include "smallobject.h" +#include <QtGlobal> + +QT_BEGIN_NAMESPACE + +template <typename T> +class List +{ + struct Data + { + int alloc, size; + T array[1]; + }; + pool *p; + Data *d; + +public: + inline List(pool *_pool) : p(_pool), d(0) { d = malloc(16); d->size = 0; d->alloc = 16; } + + inline List(const List &v) : d(0) { operator=(v); } + inline ~List() { d = 0; } + List &operator=(const List &v); + + bool operator==(const List &v) const; + inline bool operator!=(const List &v) const { return !(*this == v); } + + inline int size() const { return d->size; } + inline bool isEmpty() const { return d->size == 0; } + + inline int capacity() const { return d->alloc; } + void reserve(int alloc); + + inline T* data() { return d->array; } + inline const T* data() const { return d->array; } + void clear(); + + const T &at(int i) const; + T &operator[](int i); + const T &operator[](int i) const; + void append(const T &t); + void prepend(const T &t); + void insert(int i, const T &t); + void insert(int i, int n, const T &t); + void replace(int i, const T &t); + void remove(int i); + void remove(int i, int n); + + List &fill(const T &t, int size = -1); + + int indexOf(const T &t, int from = 0) const; + int lastIndexOf(const T &t, int from = -1) const; + bool contains(const T &t) const; + int count(const T &t) const; + + // STL-style + typedef T* iterator; + typedef const T* const_iterator; + inline iterator begin() { return d->array; } + inline const_iterator begin() const { return d->array; } + inline iterator end() { return d->array + d->size; } + inline const_iterator end() const { return d->array + d->size; } + iterator insert(iterator before, int n, const T &x); + inline iterator insert(iterator before, const T &x) { return insert(before, 1, x); } + iterator erase(iterator begin, iterator end); + inline iterator erase(iterator pos) { return erase(pos, pos+1); } + + // more Qt + inline int count() const { return d->size; } + inline T& first() { Q_ASSERT(!isEmpty()); return *begin(); } + inline const T& first() const { Q_ASSERT(!isEmpty()); return *begin(); } + inline T& last() { Q_ASSERT(!isEmpty()); return *(end()-1); } + inline const T& last() const { Q_ASSERT(!isEmpty()); return *(end()-1); } + + T value(int i) const; + T value(int i, const T &defaultValue) const; + + // STL compatibility + typedef T value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; +#ifndef QT_NO_STL + typedef ptrdiff_t difference_type; +#else + typedef int difference_type; +#endif + typedef iterator Iterator; + typedef const_iterator ConstIterator; + typedef int size_type; + inline void push_back(const T &t) { append(t); } + inline void push_front(const T &t) { prepend(t); } + void pop_back() { Q_ASSERT(!isEmpty()); erase(end()-1); } + void pop_front() { Q_ASSERT(!isEmpty()); erase(begin()); } + inline bool empty() const + { return d->size == 0; } + inline T& front() { return first(); } + inline const_reference front() const { return first(); } + inline reference back() { return last(); } + inline const_reference back() const { return last(); } + + //comfort + List &operator+=(const List &l); + inline List operator+(const List &l) const + { List n = *this; n += l; return n; } + inline void operator+=(const T &t) + { append(t); } + inline List &operator<< (const T &t) + { append(t); return *this; } + +private: + Data *malloc(int alloc); +}; + +template <typename T> +inline void List<T>::clear() +{ d->size = 0; } + +template <typename T> +inline const T &List<T>::at(int i) const +{ Q_ASSERT_X(i >= 0 && i < d->size, "List<T>::at", "index out of range"); + return d->array[i]; } +template <typename T> +inline const T &List<T>::operator[](int i) const +{ Q_ASSERT_X(i >= 0 && i < d->size, "List<T>::operator[]", "index out of range"); + return d->array[i]; } +template <typename T> +inline T &List<T>::operator[](int i) +{ Q_ASSERT_X(i >= 0 && i < d->size, "List<T>::operator[]", "index out of range"); + return d->array[i]; } +template <typename T> +inline void List<T>::insert(int i, const T &t) +{ Q_ASSERT_X(i >= 0 && i <= d->size, "List<T>::insert", "index out of range"); + insert(begin()+i, 1, t); } +template <typename T> +inline void List<T>::insert(int i, int n, const T &t) +{ Q_ASSERT_X(i >= 0 && i <= d->size, "List<T>::insert", "index out of range"); + insert(begin() + i, n, t); } +template <typename T> +inline void List<T>::remove(int i, int n) +{ Q_ASSERT_X(i >= 0 && i + n <= d->size, "List<T>::remove", "index out of range"); + erase(begin() + i, begin() + i + n); } +template <typename T> +inline void List<T>::remove(int i) +{ Q_ASSERT_X(i >= 0 && i < d->size, "List<T>::remove", "index out of range"); + erase(begin() + i, begin() + i + 1); } +template <typename T> +inline void List<T>::prepend(const T &t) +{ insert(begin(), 1, t); } +template <typename T> +inline void List<T>::replace(int i, const T &t) +{ Q_ASSERT_X(i >= 0 && i < d->size, "List<T>::replace", "index out of range"); + data()[i] = t; } + +template <typename T> +List<T> &List<T>::operator=(const List<T> &v) +{ + p = v.p; + d = malloc(v.d->alloc); + memcpy(d, v.d, sizeof(Data) + (v.d->size - 1) * sizeof(T)); + return *this; +} + +template <typename T> +inline typename List<T>::Data *List<T>::malloc(int alloc) +{ + return static_cast<Data *>(p->allocate(sizeof(Data) + (alloc - 1) * sizeof(T))); +} + +template <typename T> +void List<T>::reserve(int alloc) +{ + if (alloc <= d->alloc) + return; + alloc <<= 2; + d = static_cast<Data *>(p->reallocate(d, sizeof(Data) + d->alloc * sizeof(T), + sizeof(Data) + (alloc - 1) * sizeof(T))); + d->alloc = alloc; +} + +template<typename T> +T List<T>::value(int i) const +{ + if(i < 0 || i >= d->size) { + return T(); + } + return d->array[i]; +} +template<typename T> +T List<T>::value(int i, const T& defaultValue) const +{ + return ((i < 0 || i >= d->size) ? defaultValue : d->array[i]); +} + +template <typename T> +void List<T>::append(const T &t) +{ + reserve(d->size + 1); + d->array[d->size++] = t; +} + + +template <typename T> +typename List<T>::iterator List<T>::insert(iterator before, size_type n, const T& t) +{ + int p = before - d->array; + if (n != 0) { + reserve(d->size + n); + T *b = d->array+p; + T *i = b+n; + memmove(i, b, (d->size-p)*sizeof(T)); + while (i != b) + *(--i) = t; + } + d->size += n; + return d->array+p; +} + +template <typename T> +typename List<T>::iterator List<T>::erase(iterator begin, iterator end) +{ + int f = begin - d->array; + int l = end - d->array; + int n = l - f; + memmove(d->array + f, d->array + l, (d->size-l)*sizeof(T)); + d->size -= n; + return d->array + f; +} + +template <typename T> +bool List<T>::operator==(const List<T> &v) const +{ + if (d->size != v.d->size) + return false; + T* b = d->array; + T* i = b + d->size; + T* j = v.d->array + d->size; + while (i != b) + if (!(*--i == *--j)) + return false; + return true; +} + +template <typename T> +List<T> &List<T>::fill(const T &t, int size) +{ + resize(size < 0 ? d->size : size); + if (d->size) { + T* i = d->array + d->size; + T* b = d->array; + while (i != b) + *--i = t; + } + return *this; +} + +template <typename T> +List<T> &List<T>::operator+=(const List &l) +{ + int newSize = d->size + l.d->size; + reserve(newSize); + + T *w = d->array + newSize; + T *i = l.d->array + l.d->size; + T *b = l.d->array; + while (i != b) + *--w = *--i; + d->size = newSize; + return *this; +} + +template <typename T> +int List<T>::indexOf(const T &t, int from) const +{ + if (from < 0) + from = qMax(from + d->size, 0); + if (from < d->size) { + T* n = d->array + from - 1; + T* e = d->array + d->size; + while (++n != e) + if (*n == t) + return n - d->array; + } + return -1; +} + +template <typename T> +int List<T>::lastIndexOf(const T &t, int from) const +{ + if (from < 0) + from += d->size; + else if (from >= d->size) + from = d->size-1; + if (from >= 0) { + T* b = d->array; + T* n = d->array + from + 1; + while (n != b) { + if (*--n == t) + return n - b; + } + } + return -1; +} + +template <typename T> +bool List<T>::contains(const T &t) const +{ + T* b = d->array; + T* i = d->array + d->size; + while (i != b) + if (*--i == t) + return true; + return false; +} + +template <typename T> +int List<T>::count(const T &t) const +{ + int c = 0; + T* b = d->array; + T* i = d->array + d->size; + while (i != b) + if (*--i == t) + ++c; + return c; +} + +QT_END_NAMESPACE + +#endif // LIST_H diff --git a/tools/porting/src/logger.cpp b/tools/porting/src/logger.cpp new file mode 100644 index 0000000..e5903cb --- /dev/null +++ b/tools/porting/src/logger.cpp @@ -0,0 +1,148 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "logger.h" +#include <QFile> +#include <QDateTime> + +QT_BEGIN_NAMESPACE + +LogEntry::LogEntry(QString type, QString location) +:type(type), location(location) +{} + +PlainLogEntry::PlainLogEntry(QString type, QString location, QString text) +:LogEntry(type, location), text(text) +{} + +SourcePointLogEntry::SourcePointLogEntry(QString type, QString location, QString file, int line, int column, QString text) +:LogEntry(type, location), file(file), line(line), column(column), text(text) +{} + +QString SourcePointLogEntry::description() const +{ + return QLatin1String("In file ") + file + + QLatin1String(" at line ") + QString::number(line + 1) + //line count is zero based, adjust here. + QLatin1String(" column ") + QString::number(column) + + QLatin1String(": ") + text ; +} + +void SourcePointLogEntry::updateLinePos(int threshold, int delta) +{ + if (line >= threshold) + line += delta; +} + +///////////////////////////////////////////////////// + + +Logger::~Logger() +{ + qDeleteAll(logEntries); +} + +Logger *Logger::theInstance = 0; +Logger *Logger::instance() +{ + if(!theInstance) + theInstance = new Logger(); + return theInstance; +} + +void Logger::deleteInstance() +{ + if(theInstance) + delete theInstance; +} + +void Logger::addEntry(LogEntry *entry) +{ + Q_ASSERT(entry); + pendingLogEntries.append(entry); +} + +void Logger::beginSection() +{ + commitSection(); +} + +void Logger::commitSection() +{ + logEntries += pendingLogEntries; + pendingLogEntries.clear(); +} + +void Logger::revertSection() +{ + qDeleteAll(pendingLogEntries); + pendingLogEntries.clear(); +} + +int Logger::numEntries() +{ + commitSection(); + return logEntries.size(); +} + +QStringList Logger::fullReport() +{ + commitSection(); + QStringList report; + report << QLatin1String("Log for qt3to4 on ") + QDateTime::currentDateTime().toString() + + QLatin1String(". Number of log entries: ") + QString::number(logEntries.size()); + foreach(LogEntry *logEntry, logEntries) { + report << logEntry->description(); + } + return report; +} + +/* + Update the line for all SourcePointLogEntrys in the list of pending log + entries located on or after insertLine. +*/ +void Logger::updateLineNumbers(int insertLine, int numLines) +{ + foreach(LogEntry *logEntry, pendingLogEntries) { + logEntry->updateLinePos(insertLine, numLines); + } +} + +QT_END_NAMESPACE diff --git a/tools/porting/src/logger.h b/tools/porting/src/logger.h new file mode 100644 index 0000000..3e684c4 --- /dev/null +++ b/tools/porting/src/logger.h @@ -0,0 +1,124 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef LOGGER_H +#define LOGGER_H + +#include <QString> +#include <QStringList> +#include <QList> +#include <QMap> + +QT_BEGIN_NAMESPACE +/* + Base class for logger entries; + description() should return a text for this entry, +*/ +class LogEntry +{ +public: + LogEntry(QString type, QString location); + virtual ~LogEntry(){}; + virtual QString description() const =0; + virtual void updateLinePos(int threshold, int delta) {Q_UNUSED(threshold); Q_UNUSED(delta)}; +protected: + QString type; // Error, Warning, Info, etc + QString location;// preprocessor, c++parser, porting, etc +}; + +class PlainLogEntry: public LogEntry +{ +public: + PlainLogEntry(QString type, QString lcation, QString text); + QString description() const {return text;}; +protected: + QString text; +}; + +/* + A log entry that stores a source point: file, line and column. +*/ +class SourcePointLogEntry : public LogEntry +{ +public: + SourcePointLogEntry(QString type, QString location, QString file, int line, int column, QString text); + QString description() const; + void updateLinePos(int threshold, int delta); +protected: + QString file; + int line; + int column; + QString text; +}; + + +class Logger +{ +public: + Logger(){}; + ~Logger(); + static Logger *instance(); + static void deleteInstance(); + + void beginSection(); + void commitSection(); + void revertSection(); + void addEntry(LogEntry *entry); + + QStringList fullReport(); + int numEntries(); + void updateLineNumbers(int insertLine, int numLines); + /* + glabalState can be used for storage of application state + together with the logger. This can be useful in some cases, + for example the current filename is stored here when processing + files. + */ + QMap<QString, QString> globalState; +private: + static Logger *theInstance; + QList<LogEntry*> logEntries; + QList<LogEntry*> pendingLogEntries; +}; + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/parser.cpp b/tools/porting/src/parser.cpp new file mode 100644 index 0000000..d1163bb --- /dev/null +++ b/tools/porting/src/parser.cpp @@ -0,0 +1,4526 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "parser.h" +#include "tokens.h" +#include "errors.h" + +#include <QString> +#include <QStringList> +#include <QDateTime> + +QT_BEGIN_NAMESPACE + +#define TT (tokenStream->currentTokenText().data()) + +#define ADVANCE(tk, descr) \ +{ \ + if (tokenStream->lookAhead() != tk) { \ + reportError(QString::fromLatin1("'%1' expected found '%2'").arg(QLatin1String(descr)).arg(QString::fromLatin1((tokenStream->currentTokenText().constData())))); \ + return false; \ + } \ + advance(); \ +} + +#define ADVANCE_NR(tk, descr) \ + do { \ + if (tokenStream->lookAhead() != tk) { \ + reportError(i18n("'%1' expected found '%2'").arg(QLatin1String(descr)).arg(QString::fromLatin1(tokenStream->currentTokenText().constData()))); \ + } \ + else \ + advance(); \ + } while (0) + +#define CHECK(tk, descr) \ + do { \ + if (tokenStream->lookAhead() != tk) { \ + return false; \ + } \ + advance(); \ + } while (0) + +#define MATCH(tk, descr) \ + do { \ + if (tokenStream->lookAhead() != tk) { \ + reportError(Errors::SyntaxError); \ + return false; \ + } \ + } while (0) + +#define UPDATE_POS(_node, start, end) \ + do { \ + (_node)->setPosition(start, end); \ + } while (0) + +#define AST_FROM_TOKEN(node, tk) \ + AST *node = CreateNode<AST>(m_pool); \ + UPDATE_POS(node, (tk), (tk)+1); + +#define DUMP_AST(node) \ + do { \ + fprintf(stderr, "\n=================================================\n"); \ + for (int i=node->startToken(); i<node->endToken(); ++i) \ + fprintf(stderr, "%s", tokenStream->tokenText(i).constData()); \ + fprintf(stderr, "\n=================================================\n"); \ + } while (0) + +#define RXX_NO_ERROR + +QString i18n(const char *arg) +{ + return QLatin1String(arg); +} + + +//@todo remove me +enum +{ + OBJC_CLASS, + OBJC_PROTOCOL, + OBJC_ALIAS +}; + +Parser::Parser() +{ + m_maxProblems = 5; + objcp = false; +} + +Parser::~Parser() +{ +} + +TranslationUnitAST *Parser::parse(TokenStreamAdapter::TokenStream *p_tokenStream, pool *p) +{ + //tokenStream->rewind(0); + m_pool = p; + tokenStream = p_tokenStream; + TranslationUnitAST *ast = 0; + parseTranslationUnit(ast); + return ast; +} + +/* + Parses a part of the translation unit given by tokenStream. When the number + of nodes in the AST exeeds targetMaxASTnodes, this function will return as + soon as possible. The progress is stored by updating the cursor inside + tokenStream. done is set to true if the parser finished parsing the + tokenStream, and to false otherwise. +*/ +TranslationUnitAST *Parser::parse(TokenStreamAdapter::TokenStream *p_tokenStream, pool *p, int targetMaxASTNodes, bool &done) +{ + m_pool = p; + tokenStream = p_tokenStream; + TranslationUnitAST *ast = 0; + // we always create one node, so target max nodes cannot be < 2. + if (targetMaxASTNodes < 2) + targetMaxASTNodes = 2; + + // Advance past whitespace and comment tokens at the start. + while (tokenStream->isHidden(tokenStream->cursor())) { + tokenStream->nextToken(); + } + int start = tokenStream->cursor(); + + AST::N = 0; + m_problems = 0; + ast = CreateNode<TranslationUnitAST>(m_pool); + while (tokenStream->lookAhead() && AST::N < targetMaxASTNodes) { + DeclarationAST *def = 0; + int startDecl = tokenStream->cursor(); + if (!parseDeclaration(def)) { + // error recovery + if (startDecl == tokenStream->cursor()) + advance(); // skip at least one token + skipUntilDeclaration(); + } + ast->addDeclaration(def); + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + + done = tokenStream->tokenAtEnd(); + return ast; +} + + +bool Parser::reportError(const Error& err) +{ +Q_UNUSED(err); +#ifndef RXX_NO_ERROR + if (m_problems < m_maxProblems) { + ++m_problems; + int line=0, col=0; + QByteArray fileName; + tokenStream->getTokenStartPosition(tokenStream->cursor(), &line, &col, &fileName); + + QString s = tokenStream->currentTokenText(); + s = s.left(30).trimmed(); + if (s.isEmpty()) + s = i18n("<eof>"); + + if (fileName.isEmpty()) + //fileName = m_file->fileName; + fileName = "implement me"; + + // m_driver->addProblem(m_driver->currentFileName(), Problem(err.text.arg(s), line, col)); + fprintf(stderr, "%s: error %s at line %d column %d\n", + fileName.constData(), + err.text.arg(s).toLatin1().constData(), line, col); + } +#endif // RXX_NO_ERROR + return true; +} + +bool Parser::reportError(const QString& msg) +{ +Q_UNUSED(msg); +#ifndef RXX_NO_ERROR + if (m_problems < m_maxProblems) { + ++m_problems; + int line=0, col=0; + QByteArray fileName; + tokenStream->getTokenStartPosition(tokenStream->cursor(), &line, &col, &fileName); + + if (fileName.isEmpty()) + //fileName = m_file->fileName; + fileName = "implement me"; + + // m_driver->addProblem(m_driver->currentFileName(), Problem(msg, line, col)); + fprintf(stderr, "%s: error %s at line %d column %d\n", + fileName.constData(), + msg.toLatin1().constData(), line, col); + } +#endif // RXX_NO_ERROR + return true; +} + +void Parser::syntaxError() +{ + (void) reportError(Errors::SyntaxError); +} + +bool Parser::skipUntil(int token) +{ + while (tokenStream->lookAhead()) { + if (tokenStream->lookAhead() == token) + return true; + + advance(); + } + + return false; +} + +bool Parser::skipUntilDeclaration() +{ + while (tokenStream->lookAhead()) { + + switch(tokenStream->lookAhead()) { + case ';': + case '~': + case Token_scope: + case Token_identifier: + case Token_operator: + case Token_char: + case Token_wchar_t: + case Token_bool: + case Token_short: + case Token_int: + case Token_long: + case Token_signed: + case Token_unsigned: + case Token_float: + case Token_double: + case Token_void: + case Token_extern: + case Token_namespace: + case Token_using: + case Token_typedef: + case Token_asm: + case Token_template: + case Token_export: + + case Token_const: // cv + case Token_volatile: // cv + + case Token_public: + case Token_protected: + case Token_private: + case Token_signals: // Qt + case Token_slots: // Qt + return true; + + default: + advance(); + } + } + + return false; +} + +bool Parser::skipUntilStatement() +{ + while (tokenStream->lookAhead()) { + switch(tokenStream->lookAhead()) { + case ';': + case '{': + case '}': + case Token_const: + case Token_volatile: + case Token_identifier: + case Token_case: + case Token_default: + case Token_if: + case Token_switch: + case Token_while: + case Token_do: + case Token_for: + case Token_break: + case Token_continue: + case Token_return: + case Token_goto: + case Token_try: + case Token_catch: + case Token_throw: + case Token_char: + case Token_wchar_t: + case Token_bool: + case Token_short: + case Token_int: + case Token_long: + case Token_signed: + case Token_unsigned: + case Token_float: + case Token_double: + case Token_void: + case Token_class: + case Token_struct: + case Token_union: + case Token_enum: + case Token_scope: + case Token_template: + case Token_using: + return true; + + default: + advance(); + } + } + + return false; +} + +bool Parser::skip(int l, int r) +{ + int count = 0; + while (tokenStream->lookAhead()) { + int tk = tokenStream->lookAhead(); + + if (tk == l) + ++count; + else if (tk == r) + --count; + else if (l != '{' && (tk == '{' || tk == '}' || tk == ';')) + return false; + + if (count == 0) + return true; + + advance(); + } + + return false; +} + +bool Parser::skipCommaExpression(AbstractExpressionAST *&node) +{ +#ifndef RXX_NO_PARSE_EXPRESSION + return parseCommaExpression(node); +#else + int start = tokenStream->cursor(); + + AbstractExpressionAST *expr = 0; + if (!skipExpression(expr)) + return false; + + while (tokenStream->lookAhead() == ',') { + advance(); + + if (!skipExpression(expr)) { + reportError(i18n("expression expected")); + return false; + } + } + + AbstractExpressionAST *ast = CreateNode<AbstractExpressionAST>(m_pool); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +#endif // RXX_NO_PARSE_EXPRESSION +} + +bool Parser::skipExpression(AbstractExpressionAST *&node) +{ +#ifndef RXX_NO_PARSE_EXPRESSION + return parseExpression(node); +#else + int start = tokenStream->cursor(); + int count = 0; + + while (tokenStream->lookAhead()) { + int tk = tokenStream->lookAhead(); + + switch(tk) { + case '(': + case '[': + case '{': + ++count; + advance(); + break; + + case ']': + case ')': + case '}': + if (count == 0) { + AbstractExpressionAST *ast = CreateNode<AbstractExpressionAST>(m_pool); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; + } + --count; + advance(); + break; + + case Token_struct: + case Token_union: + case Token_class: { + int c = tokenStream->cursor(); + TypeSpecifierAST *spec = 0; + if (!parseClassSpecifier(spec)) + tokenStream->rewind(c + 1); + } + break; + + case ',': + case ';': + case Token_case: + case Token_default: + case Token_if: + case Token_while: + case Token_do: + case Token_for: + case Token_break: + case Token_continue: + case Token_return: + case Token_goto: + { + if ((tk == ',' || tk == ';') && count > 0) { + advance(); + break; + } + + AbstractExpressionAST *ast = CreateNode<AbstractExpressionAST>(m_pool); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + } + return true; + + default: + advance(); + } + } + + return false; +#endif // RXX_NO_PARSE_EXPRESSION +} + +bool Parser::parseName(NameAST *&node, bool parseTemplateId) +{ + AST *winDeclSpec = 0; + parseWinDeclSpec(winDeclSpec); + + int start = tokenStream->cursor(); + + NameAST *ast = CreateNode<NameAST>(m_pool); + + if (tokenStream->lookAhead() == Token_scope) { + ast->setGlobal(true); + advance(); + } + + int idx = tokenStream->cursor(); + + while (true) { + ClassOrNamespaceNameAST *n = 0; + if (!parseUnqualifiedName(n)) + return false; + + if (tokenStream->lookAhead() == Token_scope) { + advance(); + ast->addClassOrNamespaceName(n); + if (tokenStream->lookAhead() == Token_template) + advance(); /// skip optional template #### @todo CHECK + } else if (!parseTemplateId && n) { + tokenStream->rewind(n->startToken()); + parseUnqualifiedName(n, parseTemplateId); + ast->setUnqualifiedName(n); + break; + } else { + ast->setUnqualifiedName(n); + break; + } + } + + if (idx == tokenStream->cursor()) + return false; + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseTranslationUnit(TranslationUnitAST *&node) +{ + QTime t; + t.start(); + + advance(); + int start = tokenStream->cursor(); + + m_problems = 0; + TranslationUnitAST *tun = CreateNode<TranslationUnitAST>(m_pool); + node = tun; + while (tokenStream->lookAhead()) { + DeclarationAST *def = 0; + int startDecl = tokenStream->cursor(); + if (!parseDeclaration(def)) { + // error recovery + if (startDecl == tokenStream->cursor()) + advance(); // skip at least one token + skipUntilDeclaration(); + } + node->addDeclaration(def); + } + + UPDATE_POS(node, start, tokenStream->cursor()); + + return m_problems == 0; +} + +bool Parser::parseDeclaration(DeclarationAST *&node) +{ + int start = tokenStream->cursor(); + + switch(tokenStream->lookAhead()) { + + case ';': + advance(); + return true; + + case Token_extern: + return parseLinkageSpecification(node); + + case Token_namespace: + return parseNamespace(node); + + case Token_using: + return parseUsing(node); + + case Token_typedef: + return parseTypedef(node); + + case Token_asm: + return parseAsmDefinition(node); + + case Token_template: + case Token_export: + return parseTemplateDeclaration(node); + + default: + { + // tokenStream->rewind(start); + + if (objcp && parseObjcDef(node)) + return true; + + tokenStream->rewind(start); + + AST *storageSpec = 0; + parseStorageClassSpecifier(storageSpec); + + AST *cv = 0; + parseCvQualify(cv); + + TypeSpecifierAST *spec = 0; + if (parseEnumSpecifier(spec) || parseClassSpecifier(spec)) { + spec->setCvQualify(cv); + + AST *cv2 = 0; + parseCvQualify(cv2); + spec->setCv2Qualify(cv2); + + InitDeclaratorListAST *declarators = 0; + parseInitDeclaratorList(declarators); + ADVANCE(';', ";"); + + SimpleDeclarationAST *ast = CreateNode<SimpleDeclarationAST>(m_pool); + ast->setStorageSpecifier(storageSpec); + ast->setTypeSpec(spec); + ast->setInitDeclaratorList(declarators); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; + } + + tokenStream->rewind(start); + return parseDeclarationInternal(node); + } + + } // end switch +} + +bool Parser::parseLinkageSpecification(DeclarationAST *&node) +{ + int start = tokenStream->cursor(); + + if (tokenStream->lookAhead() != Token_extern) { + return false; + } + advance(); + + LinkageSpecificationAST *ast = CreateNode<LinkageSpecificationAST>(m_pool); + + int startExternType = tokenStream->cursor(); + if (tokenStream->lookAhead() == Token_string_literal) { + advance(); + AST *externType = CreateNode<AST>(m_pool); + UPDATE_POS(externType, startExternType, tokenStream->cursor()); + + ast->setExternType(externType); + } + + if (tokenStream->lookAhead() == '{') { + LinkageBodyAST *linkageBody = 0; + parseLinkageBody(linkageBody); + ast->setLinkageBody(linkageBody); + } else { + DeclarationAST *decl = 0; + if (!parseDeclaration(decl)) { + reportError(i18n("Declaration syntax error")); + } + ast->setDeclaration(decl); + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + + node = ast; + + return true; +} + +bool Parser::parseLinkageBody(LinkageBodyAST *&node) +{ + + int start = tokenStream->cursor(); + + if (tokenStream->lookAhead() != '{') { + return false; + } + advance(); + + LinkageBodyAST *lba = CreateNode<LinkageBodyAST>(m_pool); + node = lba; + + while (tokenStream->lookAhead()) { + int tk = tokenStream->lookAhead(); + + if (tk == '}') + break; + + DeclarationAST *def = 0; + int startDecl = tokenStream->cursor(); + if (parseDeclaration(def)) { + node->addDeclaration(def); + } else { + // error recovery + if (startDecl == tokenStream->cursor()) + advance(); // skip at least one token + skipUntilDeclaration(); + } + } + + if (tokenStream->lookAhead() != '}') { + reportError(i18n("} expected")); + } else + advance(); + + UPDATE_POS(node, start, tokenStream->cursor()); + return true; +} + +bool Parser::parseNamespace(DeclarationAST *&node) +{ + int start = tokenStream->cursor(); + + if (tokenStream->lookAhead() != Token_namespace) { + return false; + } + advance(); + + int startNamespaceName = tokenStream->cursor(); + if (tokenStream->lookAhead() == Token_identifier) { + advance(); + } + AST *namespaceName = CreateNode<AST>(m_pool); + UPDATE_POS(namespaceName, startNamespaceName, tokenStream->cursor()); + + if (tokenStream->lookAhead() == '=') { + // namespace alias + advance(); + + NameAST *name = 0; + if (parseName(name)) { + ADVANCE(';', ";"); + + NamespaceAliasAST *ast = CreateNode<NamespaceAliasAST>(m_pool); + ast->setNamespaceName(namespaceName); + ast->setAliasName(name); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; + } else { + reportError(i18n("namespace expected")); + return false; + } + } else if (tokenStream->lookAhead() != '{') { + reportError(i18n("{ expected")); + return false; + } + + NamespaceAST *ast = CreateNode<NamespaceAST>(m_pool); + ast->setNamespaceName(namespaceName); + + LinkageBodyAST *linkageBody = 0; + parseLinkageBody(linkageBody); + + ast->setLinkageBody(linkageBody); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseUsing(DeclarationAST *&node) +{ + int start = tokenStream->cursor(); + + if (tokenStream->lookAhead() != Token_using) { + return false; + } + advance(); + + if (tokenStream->lookAhead() == Token_namespace) { + if (!parseUsingDirective(node)) { + return false; + } + UPDATE_POS(node, start, tokenStream->cursor()); + return true; + } + + UsingAST *ast = CreateNode<UsingAST>(m_pool); + + int startTypeName = tokenStream->cursor(); + if (tokenStream->lookAhead() == Token_typename) { + advance(); + AST *tn = CreateNode<AST>(m_pool); + UPDATE_POS(tn, startTypeName, tokenStream->cursor()); + ast->setTypeName(tn); + } + + NameAST *name = 0; + if (!parseName(name)) + return false; + + ast->setName(name); + + ADVANCE(';', ";"); + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseUsingDirective(DeclarationAST *&node) +{ + int start = tokenStream->cursor(); + + if (tokenStream->lookAhead() != Token_namespace) { + return false; + } + advance(); + + NameAST *name = 0; + if (!parseName(name)) { + reportError(i18n("Namespace name expected")); + return false; + } + + ADVANCE(';', ";"); + + UsingDirectiveAST *ast = CreateNode<UsingDirectiveAST>(m_pool); + ast->setName(name); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + + +bool Parser::parseOperatorFunctionId(AST *&node) +{ + int start = tokenStream->cursor(); + + if (tokenStream->lookAhead() != Token_operator) { + return false; + } + advance(); + + AST *op = 0; + if (parseOperator(op)) { + AST *asn = CreateNode<AST>(m_pool); + node = asn; + UPDATE_POS(node, start, tokenStream->cursor()); + return true; + } else { + // parse cast operator + AST *cv = 0; + parseCvQualify(cv); + + TypeSpecifierAST *spec = 0; + if (!parseSimpleTypeSpecifier(spec)) { + syntaxError(); + return false; + } + spec->setCvQualify(cv); + + AST *cv2 = 0; + parseCvQualify(cv2); + spec->setCv2Qualify(cv2); + + AST *ptrOp = 0; + while (parsePtrOperator(ptrOp)) + ; + + AST *asn = CreateNode<AST>(m_pool); + node = asn; + UPDATE_POS(node, start, tokenStream->cursor()); + return true; + } +} + +bool Parser::parseTemplateArgumentList(TemplateArgumentListAST *&node, bool reportError) +{ + int start = tokenStream->cursor(); + + TemplateArgumentListAST *ast = CreateNode<TemplateArgumentListAST>(m_pool); + + AST *templArg = 0; + if (!parseTemplateArgument(templArg)) + return false; + ast->addArgument(templArg); + + while (tokenStream->lookAhead() == ',') { + advance(); + + if (!parseTemplateArgument(templArg)) { + if (reportError) { + syntaxError(); + break; + } else + return false; + } + ast->addArgument(templArg); + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseTypedef(DeclarationAST *&node) +{ + int start = tokenStream->cursor(); + + if (tokenStream->lookAhead() != Token_typedef) { + return false; + } + advance(); + + TypeSpecifierAST *spec = 0; + if (!parseTypeSpecifierOrClassSpec(spec)) { + reportError(i18n("Need a type specifier to declare")); + return false; + } + + InitDeclaratorListAST *declarators = 0; + if (!parseInitDeclaratorList(declarators)) { + //reportError(i18n("Need an identifier to declare")); + //return false; + } + + ADVANCE(';', ";"); + + TypedefAST *ast = CreateNode<TypedefAST>(m_pool); + ast->setTypeSpec(spec); + ast->setInitDeclaratorList(declarators); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseAsmDefinition(DeclarationAST *&node) +{ + int start = tokenStream->cursor(); + + ADVANCE(Token_asm, "asm"); + + AST *cv = 0; + parseCvQualify(cv); + + skip('(', ')'); + advance(); + ADVANCE(';', ";"); + + DeclarationAST *ast = CreateNode<DeclarationAST>(m_pool); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseTemplateDeclaration(DeclarationAST *&node) +{ + int start = tokenStream->cursor(); + + AST *exp = 0; + + int startExport = tokenStream->cursor(); + if (tokenStream->lookAhead() == Token_export) { + advance(); + AST *n = CreateNode<AST>(m_pool); + UPDATE_POS(n, startExport, tokenStream->cursor()); + exp = n; + } + + if (tokenStream->lookAhead() != Token_template) { + return false; + } + advance(); + + TemplateParameterListAST *params = 0; + if (tokenStream->lookAhead() == '<') { + advance(); + parseTemplateParameterList(params); + + ADVANCE('>', ">"); + } + + DeclarationAST *def = 0; + if (!parseDeclaration(def)) { + reportError(i18n("expected a declaration")); + } + + TemplateDeclarationAST *ast = CreateNode<TemplateDeclarationAST>(m_pool); + ast->setExported(exp); + ast->setTemplateParameterList(params); + ast->setDeclaration(def); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseOperator(AST *&/*node*/) +{ + QString text(QString::fromLatin1(tokenStream->currentTokenText().constData())); + + switch(tokenStream->lookAhead()) { + case Token_new: + case Token_delete: + advance(); + if (tokenStream->lookAhead() == '[' && tokenStream->lookAhead(1) == ']') { + advance(); + advance(); + text += QLatin1String("[]"); + } + return true; + + case '+': + case '-': + case '*': + case '/': + case '%': + case '^': + case '&': + case '|': + case '~': + case '!': + case '=': + case '<': + case '>': + case ',': + case Token_assign: + case Token_shift: + case Token_eq: + case Token_not_eq: + case Token_leq: + case Token_geq: + case Token_and: + case Token_or: + case Token_incr: + case Token_decr: + case Token_ptrmem: + case Token_arrow: + advance(); + return true; + + default: + if (tokenStream->lookAhead() == '(' && tokenStream->lookAhead(1) == ')') { + advance(); + advance(); + return true; + } else if (tokenStream->lookAhead() == '[' && tokenStream->lookAhead(1) == ']') { + advance(); + advance(); + return true; + } + } + + return false; +} + +bool Parser::parseCvQualify(AST *&node) +{ + int start = tokenStream->cursor(); + + AST *ast = CreateNode<AST>(m_pool); + + int n = 0; + while (tokenStream->lookAhead()) { + int tk = tokenStream->lookAhead(); + if (tk == Token_const || tk == Token_volatile) { + ++n; + int startWord = tokenStream->cursor(); + advance(); + AST *word = CreateNode<AST>(m_pool); + UPDATE_POS(word, startWord, tokenStream->cursor()); + word->setParent(ast); + } else + break; + } + + if (n == 0) + return false; + + + UPDATE_POS(ast, start, tokenStream->cursor()); + + node = ast; + return true; +} + +bool Parser::parseSimpleTypeSpecifier(TypeSpecifierAST *&node, bool onlyIntegral) +{ + int start = tokenStream->cursor(); + bool isIntegral = false; + bool done = false; + + while (!done) { + switch(tokenStream->lookAhead()) { + case Token_char: + case Token_wchar_t: + case Token_bool: + case Token_short: + case Token_int: + case Token_long: + case Token_signed: + case Token_unsigned: + case Token_float: + case Token_double: + case Token_void: + isIntegral = true; + advance(); + break; + + default: + done = true; + } + } + + TypeSpecifierAST *ast = CreateNode<TypeSpecifierAST>(m_pool); + if (isIntegral) { + ClassOrNamespaceNameAST *cl = CreateNode<ClassOrNamespaceNameAST>(m_pool); + + AST *n = CreateNode<AST>(m_pool); + UPDATE_POS(n, start, tokenStream->cursor()); + cl->setName(n); + UPDATE_POS(cl, start, tokenStream->cursor()); + + NameAST *name = CreateNode<NameAST>(m_pool); + name->setUnqualifiedName(cl); + UPDATE_POS(name, start, tokenStream->cursor()); + ast->setName(name); + } else if (tokenStream->lookAhead() == Token___typeof) { + advance(); + if (tokenStream->lookAhead() == '(') { + advance(); + TypeIdAST *typeId = 0; + parseTypeId(typeId); + ADVANCE(')', ")"); + } else { + AbstractExpressionAST *e = 0; + parseUnaryExpression(e); + } + } else if (onlyIntegral) { + tokenStream->rewind(start); + return false; + } else { + NameAST *name = 0; + if (!parseName(name)) { + tokenStream->rewind(start); + return false; + } + ast->setName(name); + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parsePtrOperator(AST *&node) +{ + int start = tokenStream->cursor(); + int tok = tokenStream->lookAhead(); + AST *memPtr = 0; + + switch (tok) { + case '&': + case '*': + advance(); + break; + + case Token_scope: + case Token_identifier: + if (!parsePtrToMember(memPtr)) { + tokenStream->rewind(start); + return false; + } + break; + + default: + return false; + } + + AST *cv = 0; + parseCvQualify(cv); + + AST *ast = CreateNode<AST>(m_pool); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + + +bool Parser::parseTemplateArgument(AST *&node) +{ + int start = tokenStream->cursor(); + + TypeIdAST *typeId = 0; + if (parseTypeId(typeId)) { + if (tokenStream->lookAhead() == ',' || tokenStream->lookAhead() == '>') { + node = typeId; + return true; + } + } + + tokenStream->rewind(start); + AbstractExpressionAST *expr = 0; + if (!parseLogicalOrExpression(expr, true)) { + return false; + } + node = expr; + + return true; +} + +bool Parser::parseTypeSpecifier(TypeSpecifierAST *&spec) +{ + AST *cv = 0; + parseCvQualify(cv); + + if (parseElaboratedTypeSpecifier(spec) || parseSimpleTypeSpecifier(spec)) { + spec->setCvQualify(cv); + + AST *cv2 = 0; + parseCvQualify(cv2); + spec->setCv2Qualify(cv2); + + return true; + } + + return false; +} + +bool Parser::parseDeclarator(DeclaratorAST *&node) +{ + int start = tokenStream->cursor(); + + DeclaratorAST *ast = CreateNode<DeclaratorAST>(m_pool); + + DeclaratorAST *decl = 0; + NameAST *declId = 0; + + AST *ptrOp = 0; + while (parsePtrOperator(ptrOp)) { + ast->addPtrOp(ptrOp); + } + + if (tokenStream->lookAhead() == '(') { + advance(); + + if (!parseDeclarator(decl)) { + return false; + } + ast->setSubDeclarator(decl); + + if (tokenStream->lookAhead() != ')') { + return false; + } + advance(); + } else { + if (tokenStream->lookAhead() == ':') { + // unnamed bitfield + } else if (parseDeclaratorId(declId)) { + ast->setDeclaratorId(declId); + } else { + tokenStream->rewind(start); + return false; + } + + if (tokenStream->lookAhead() == ':') { + advance(); + AbstractExpressionAST *expr = 0; + if (!parseConstantExpression(expr)) { + reportError(i18n("Constant expression expected")); + } + goto update_pos; + } + } + + { + bool isVector = false; + + while (tokenStream->lookAhead() == '[') { + int startArray = tokenStream->cursor(); + advance(); + AbstractExpressionAST *expr = 0; + parseCommaExpression(expr); + + ADVANCE(']', "]"); + AST *array = CreateNode<AST>(m_pool); + UPDATE_POS(array, startArray, tokenStream->cursor()); + ast->addArrayDimension(array); + isVector = true; + } + + bool skipParen = false; + if (tokenStream->lookAhead() == Token_identifier + && tokenStream->lookAhead(1) == '(' + && tokenStream->lookAhead(2) == '(') { + advance(); + advance(); + skipParen = true; + } + + int tok = tokenStream->lookAhead(); + if (ast->subDeclarator() && !(isVector || tok == '(' || tok == ',' || tok == ';' || tok == '=')) { + tokenStream->rewind(start); + return false; + } + + int index = tokenStream->cursor(); + if (tokenStream->lookAhead() == '(') { + advance(); + + ParameterDeclarationClauseAST *params = 0; + if (!parseParameterDeclarationClause(params)) { + tokenStream->rewind(index); + goto update_pos; + } + ast->setParameterDeclarationClause(params); + + if (tokenStream->lookAhead() != ')') { + tokenStream->rewind(index); + goto update_pos; + } + + advance(); // skip ')' + + AST *constant = 0; + parseCvQualify(constant); + ast->setConstant(constant); + + AST *except = 0; + if (parseExceptionSpecification(except)) { + ast->setExceptionSpecification(except); + } + } + + if (skipParen) { + if (tokenStream->lookAhead() != ')') { + reportError(i18n("')' expected")); + } else + advance(); + } + } + +update_pos: + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseAbstractDeclarator(DeclaratorAST *&node) +{ + int start = tokenStream->cursor(); + + DeclaratorAST *ast = CreateNode<DeclaratorAST>(m_pool); + DeclaratorAST *decl = 0; + + AST *ptrOp = 0; + while (parsePtrOperator(ptrOp)) { + ast->addPtrOp(ptrOp); + } + + int index = tokenStream->cursor(); + if (tokenStream->lookAhead() == '(') { + advance(); + + if (!parseAbstractDeclarator(decl)) { + tokenStream->rewind(index); + goto label1; + } + + ast->setSubDeclarator(decl); + + if (tokenStream->lookAhead() != ')'){ + tokenStream->rewind(start); + return false; + } + advance(); + } else if (tokenStream->lookAhead() == ':') { + advance(); + AbstractExpressionAST *expr = 0; + if (!parseConstantExpression(expr)) { + reportError(i18n("Constant expression expected")); + } + goto update_pos; + } + +label1: + { + bool isVector = false; + + while (tokenStream->lookAhead() == '[') { + int startArray = tokenStream->cursor(); + advance(); + AbstractExpressionAST *expr = 0; + parseCommaExpression(expr); + + ADVANCE(']', "]"); + AST *array = CreateNode<AST>(m_pool); + UPDATE_POS(array, startArray, tokenStream->cursor()); + ast->addArrayDimension(array); + isVector = true; + } + + int tok = tokenStream->lookAhead(); + if (ast->subDeclarator() && !(isVector || tok == '(' || tok == ',' || tok == ';' || tok == '=')) { + tokenStream->rewind(start); + return false; + } + + int index = tokenStream->cursor(); + if (tokenStream->lookAhead() == '(') { + advance(); + + ParameterDeclarationClauseAST *params = 0; + if (!parseParameterDeclarationClause(params)) { + tokenStream->rewind(index); + goto update_pos; + } + ast->setParameterDeclarationClause(params); + + if (tokenStream->lookAhead() != ')') { + tokenStream->rewind(index); + goto update_pos; + } + + advance(); // skip ')' + + AST *constant = 0; + parseCvQualify(constant); + ast->setConstant(constant); + + AST *except = 0; + if (parseExceptionSpecification(except)) { + ast->setExceptionSpecification(except); + } + } + } + +update_pos: + if (tokenStream->cursor() == start) + return false; + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseEnumSpecifier(TypeSpecifierAST *&node) +{ + int start = tokenStream->cursor(); + + if (tokenStream->lookAhead() != Token_enum) { + return false; + } + + advance(); + + NameAST *name = 0; + parseName(name); + + if (tokenStream->lookAhead() != '{') { + tokenStream->rewind(start); + return false; + } + advance(); + + EnumSpecifierAST *ast = CreateNode<EnumSpecifierAST>(m_pool); + ast->setName(name); + + EnumeratorAST *enumerator = 0; + if (parseEnumerator(enumerator)) { + ast->addEnumerator(enumerator); + + while (tokenStream->lookAhead() == ',') { + advance(); + + if (!parseEnumerator(enumerator)) { + //reportError(i18n("Enumerator expected")); + break; + } + + ast->addEnumerator(enumerator); + } + } + + if (tokenStream->lookAhead() != '}') + reportError(i18n("} missing")); + else + advance(); + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseTemplateParameterList(TemplateParameterListAST *&node) +{ + int start = tokenStream->cursor(); + + TemplateParameterListAST *ast = CreateNode<TemplateParameterListAST>(m_pool); + + TemplateParameterAST *param = 0; + if (!parseTemplateParameter(param)) { + return false; + } + ast->addTemplateParameter(param); + + while (tokenStream->lookAhead() == ',') { + advance(); + + if (!parseTemplateParameter(param)) { + syntaxError(); + break; + } else { + ast->addTemplateParameter(param); + } + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseTemplateParameter(TemplateParameterAST *&node) +{ + int start = tokenStream->cursor(); + TemplateParameterAST *ast = CreateNode<TemplateParameterAST>(m_pool); + + TypeParameterAST *typeParameter = 0; + ParameterDeclarationAST *param = 0; + + int tk = tokenStream->lookAhead(); + + if ((tk == Token_class || tk == Token_typename || tk == Token_template) && parseTypeParameter(typeParameter)) { + ast->setTypeParameter(typeParameter); + goto ok; + } + + if (!parseParameterDeclaration(param)) + return false; + ast->setTypeValueParameter(param); + +ok: + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseTypeParameter(TypeParameterAST *&node) +{ + int start = tokenStream->cursor(); + TypeParameterAST *ast = CreateNode<TypeParameterAST>(m_pool); + + AST_FROM_TOKEN(kind, tokenStream->cursor()); + ast->setKind(kind); + + switch(tokenStream->lookAhead()) { + + case Token_class: + case Token_typename: + { + advance(); // skip class + + // parse optional name + NameAST *name = 0; + if(parseName(name)){ + ast->setName(name); + + if (tokenStream->lookAhead() == '='){ + advance(); + + TypeIdAST *typeId = 0; + if(!parseTypeId(typeId)){ + //syntaxError(); + tokenStream->rewind(start); + return false; + } + ast->setTypeId(typeId); + } else if (!(tokenStream->lookAhead() == ',' || tokenStream->lookAhead() == '>')) { + tokenStream->rewind(start); + return false; + } + } + } + break; + + case Token_template: + { + advance(); // skip template + ADVANCE('<', "<"); + + TemplateParameterListAST *params = 0; + if (!parseTemplateParameterList(params)) { + return false; + } + ast->setTemplateParameterList(params); + + ADVANCE('>', ">"); + + if (tokenStream->lookAhead() == Token_class) + advance(); + + // parse optional name + NameAST *name = 0; + if (parseName(name)) { + ast->setName(name); + if (tokenStream->lookAhead() == '=') { + advance(); + + TypeIdAST *typeId = 0; + if (!parseTypeId(typeId)) { + syntaxError(); + return false; + } + ast->setTypeId(typeId); + } + } + + if (tokenStream->lookAhead() == '=') { + advance(); + + NameAST *templ_name = 0; + parseName(templ_name); + } + } + break; + + default: + return false; + + } // end switch + + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseStorageClassSpecifier(AST *&node) +{ + int start = tokenStream->cursor(); + AST *ast = CreateNode<AST>(m_pool); + + while (tokenStream->lookAhead()) { + int tk = tokenStream->lookAhead(); + if (tk == Token_friend || tk == Token_auto || tk == Token_register || tk == Token_static || + tk == Token_extern || tk == Token_mutable) { + int startNode = tokenStream->cursor(); + advance(); + + AST *n = CreateNode<AST>(m_pool); + UPDATE_POS(n, startNode, tokenStream->cursor()); + n->setParent(ast); + } else + break; + } + + if (length(ast->children()) == 0) + return false; + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseFunctionSpecifier(AST *&node) +{ + int start = tokenStream->cursor(); + AST *ast = CreateNode<AST>(m_pool); + + while (tokenStream->lookAhead()) { + int tk = tokenStream->lookAhead(); + if (tk == Token_inline || tk == Token_virtual || tk == Token_explicit) { + int startNode = tokenStream->cursor(); + advance(); + + AST *n = CreateNode<AST>(m_pool); + UPDATE_POS(n, startNode, tokenStream->cursor()); + n->setParent(ast); + } else { + break; + } + } + + if (length(ast->children()) == 0) + return false; + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseTypeId(TypeIdAST *&node) +{ + /// @todo implement the AST for typeId + int start = tokenStream->cursor(); + + TypeSpecifierAST *spec = 0; + if (!parseTypeSpecifier(spec)) { + tokenStream->rewind(start); + return false; + } + + DeclaratorAST *decl = 0; + parseAbstractDeclarator(decl); + + TypeIdAST *ast = CreateNode<TypeIdAST>(m_pool); + ast->setTypeSpecifier(spec); + ast->setDeclarator(decl); + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseInitDeclaratorList(InitDeclaratorListAST *&node) +{ + int start = tokenStream->cursor(); + + InitDeclaratorListAST *ast = CreateNode<InitDeclaratorListAST>(m_pool); + InitDeclaratorAST *decl = 0; + + if (!parseInitDeclarator(decl)) { + return false; + } + ast->addInitDeclarator(decl); + + while (tokenStream->lookAhead() == ',') { + advance(); + + if (!parseInitDeclarator(decl)) { + syntaxError(); + break; + } + ast->addInitDeclarator(decl); + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseParameterDeclarationClause(ParameterDeclarationClauseAST *&node) +{ + int start = tokenStream->cursor(); + + ParameterDeclarationClauseAST *ast = CreateNode<ParameterDeclarationClauseAST>(m_pool); + + ParameterDeclarationListAST *params = 0; + if (!parseParameterDeclarationList(params)) { + + if (tokenStream->lookAhead() == ')') + goto good; + + if (tokenStream->lookAhead() == Token_ellipsis && tokenStream->lookAhead(1) == ')') { + AST_FROM_TOKEN(ellipsis, tokenStream->cursor()); + ast->setEllipsis(ellipsis); + advance(); + goto good; + } + return false; + } + + if (tokenStream->lookAhead() == Token_ellipsis) { + AST_FROM_TOKEN(ellipsis, tokenStream->cursor()); + ast->setEllipsis(ellipsis); + advance(); + } + +good: + ast->setParameterDeclarationList(params); + + /// @todo add ellipsis + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseParameterDeclarationList(ParameterDeclarationListAST *&node) +{ + int start = tokenStream->cursor(); + + ParameterDeclarationListAST *ast = CreateNode<ParameterDeclarationListAST>(m_pool); + + ParameterDeclarationAST *param = 0; + if (!parseParameterDeclaration(param)) { + tokenStream->rewind(start); + return false; + } + ast->addParameter(param); + + while (tokenStream->lookAhead() == ',') { + advance(); + + if (tokenStream->lookAhead() == Token_ellipsis) + break; + + if (!parseParameterDeclaration(param)) { + tokenStream->rewind(start); + return false; + } + ast->addParameter(param); + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseParameterDeclaration(ParameterDeclarationAST *&node) +{ + int start = tokenStream->cursor(); + + AST *storage = 0; + parseStorageClassSpecifier(storage); + + // parse decl spec + TypeSpecifierAST *spec = 0; + if (!parseTypeSpecifier(spec)) { + tokenStream->rewind(start); + return false; + } + + int index = tokenStream->cursor(); + + DeclaratorAST *decl = 0; + if (!parseDeclarator(decl)) { + tokenStream->rewind(index); + + // try with abstract declarator + parseAbstractDeclarator(decl); + } + + AbstractExpressionAST *expr = 0; + if (tokenStream->lookAhead() == '=') { + advance(); + if (!parseLogicalOrExpression(expr,true)) { + //reportError(i18n("Expression expected")); + } + } + + ParameterDeclarationAST *ast = CreateNode<ParameterDeclarationAST>(m_pool); + ast->setTypeSpec(spec); + ast->setDeclarator(decl); + ast->setExpression(expr); + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseClassSpecifier(TypeSpecifierAST *&node) +{ + int start = tokenStream->cursor(); + + AST *classKey = 0; + int classKeyStart = tokenStream->cursor(); + + int kind = tokenStream->lookAhead(); + if (kind == Token_class || kind == Token_struct || kind == Token_union) { + AST *asn = CreateNode<AST>(m_pool); + classKey = asn; + advance(); + UPDATE_POS(classKey, classKeyStart, tokenStream->cursor()); + } else { + return false; + } + + AST *winDeclSpec = 0; + parseWinDeclSpec(winDeclSpec); + + while (tokenStream->lookAhead() == Token_identifier && tokenStream->lookAhead(1) == Token_identifier) + advance(); + + NameAST *name = 0; + parseName(name); + + BaseClauseAST *bases = 0; + if (tokenStream->lookAhead() == ':') { + if (!parseBaseClause(bases)) { + skipUntil('{'); + } + } + + if (tokenStream->lookAhead() != '{') { + tokenStream->rewind(start); + return false; + } + + ADVANCE('{', "{"); + + ClassSpecifierAST *ast = CreateNode<ClassSpecifierAST>(m_pool); + ast->setWinDeclSpec(winDeclSpec); + ast->setClassKey(classKey); + ast->setName(name); + ast->setBaseClause(bases); + + while (tokenStream->lookAhead()) { + if (tokenStream->lookAhead() == '}') + break; + + DeclarationAST *memSpec = 0; + int startDecl = tokenStream->cursor(); + if (!parseMemberSpecification(memSpec)) { + if (startDecl == tokenStream->cursor()) + advance(); // skip at least one token + skipUntilDeclaration(); + } else + ast->addDeclaration(memSpec); + } + + if (tokenStream->lookAhead() != '}') { + reportError(i18n("} missing")); + } else + advance(); + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseAccessSpecifier(AST *&node) +{ + int start = tokenStream->cursor(); + + switch(tokenStream->lookAhead()) { + case Token_public: + case Token_protected: + case Token_private: { + AST *asn = CreateNode<AST>(m_pool); + node = asn; + advance(); + UPDATE_POS(node, start, tokenStream->cursor()); + return true; + } + } + + return false; +} + +bool Parser::parseMemberSpecification(DeclarationAST *&node) +{ + int start = tokenStream->cursor(); + + AST *access = 0; + + if (tokenStream->lookAhead() == ';') { + advance(); + return true; + } else if (tokenStream->lookAhead() == Token_Q_OBJECT || tokenStream->lookAhead() == Token_K_DCOP) { + advance(); + return true; + } else if (tokenStream->lookAhead() == Token_signals + || tokenStream->lookAhead() == Token_k_dcop + || tokenStream->lookAhead() == Token_k_dcop_signals) { + AccessDeclarationAST *ast = CreateNode<AccessDeclarationAST>(m_pool); + advance(); + AST *n = CreateNode<AST>(m_pool); + UPDATE_POS(n, start, tokenStream->cursor()); + ast->addAccess(n); + ADVANCE(':', ":"); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; + } else if (parseTypedef(node)) { + return true; + } else if (parseUsing(node)) { + return true; + } else if (parseTemplateDeclaration(node)) { + return true; + } else if (parseAccessSpecifier(access)) { + AccessDeclarationAST *ast = CreateNode<AccessDeclarationAST>(m_pool); + ast->addAccess(access); + + int startSlot = tokenStream->cursor(); + if (tokenStream->lookAhead() == Token_slots) { + advance(); + AST *sl = CreateNode<AST>(m_pool); + UPDATE_POS(sl, startSlot, tokenStream->cursor()); + ast->addAccess(sl); + } + ADVANCE(':', ":"); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; + } + + tokenStream->rewind(start); + + AST *storageSpec = 0; + parseStorageClassSpecifier(storageSpec); + + AST *cv = 0; + parseCvQualify(cv); + + TypeSpecifierAST *spec = 0; + if (parseEnumSpecifier(spec) || parseClassSpecifier(spec)) { + spec->setCvQualify(cv); + + AST *cv2 = 0; + parseCvQualify(cv2); + spec->setCv2Qualify(cv2); + + InitDeclaratorListAST *declarators = 0; + parseInitDeclaratorList(declarators); + ADVANCE(';', ";"); + + SimpleDeclarationAST *ast = CreateNode<SimpleDeclarationAST>(m_pool); + ast->setTypeSpec(spec); + ast->setInitDeclaratorList(declarators); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; + } + + tokenStream->rewind(start); + return parseDeclarationInternal(node); +} + +bool Parser::parseCtorInitializer(AST *&/*node*/) +{ + if (tokenStream->lookAhead() != ':') { + return false; + } + advance(); + + AST *inits = 0; + if (!parseMemInitializerList(inits)) { + reportError(i18n("Member initializers expected")); + } + + return true; +} + +bool Parser::parseElaboratedTypeSpecifier(TypeSpecifierAST *&node) +{ + int start = tokenStream->cursor(); + + int tk = tokenStream->lookAhead(); + if (tk == Token_class || + tk == Token_struct || + tk == Token_union || + tk == Token_enum || + tk == Token_typename) + { + AST *kind = CreateNode<AST>(m_pool); + advance(); + UPDATE_POS(kind, start, tokenStream->cursor()); + + NameAST *name = 0; + + if (parseName(name)) { + ElaboratedTypeSpecifierAST *ast = CreateNode<ElaboratedTypeSpecifierAST>(m_pool); + ast->setKind(kind); + ast->setName(name); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; + } + } + + tokenStream->rewind(start); + return false; +} + +bool Parser::parseDeclaratorId(NameAST *&node) +{ + return parseName(node); +} + +bool Parser::parseExceptionSpecification(AST *&node) +{ + if (tokenStream->lookAhead() != Token_throw) { + return false; + } + advance(); + + ADVANCE('(', "("); + if (tokenStream->lookAhead() == Token_ellipsis) { + // extension found in MSVC++ 7.x headers + int start = tokenStream->cursor(); + AST *ast = CreateNode<AST>(m_pool); + AST_FROM_TOKEN(ellipsis, tokenStream->cursor()); + ellipsis->setParent(ast); + advance(); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + } else { + parseTypeIdList(node); + } + ADVANCE(')', ")"); + + return true; +} + +bool Parser::parseEnumerator(EnumeratorAST *&node) +{ + int start = tokenStream->cursor(); + + if (tokenStream->lookAhead() != Token_identifier) { + return false; + } + advance(); + + EnumeratorAST *ena = CreateNode<EnumeratorAST>(m_pool); + node = ena; + + AST *id = CreateNode<AST>(m_pool); + UPDATE_POS(id, start, tokenStream->cursor()); + node->setId(id); + + if (tokenStream->lookAhead() == '=') { + advance(); + + AbstractExpressionAST *expr = 0; + if (!parseConstantExpression(expr)) { + reportError(i18n("Constant expression expected")); + } + node->setExpression(expr); + } + + UPDATE_POS(node, start, tokenStream->cursor()); + + return true; +} + +bool Parser::parseInitDeclarator(InitDeclaratorAST *&node) +{ + int start = tokenStream->cursor(); + + DeclaratorAST *decl = 0; + AST *init = 0; + if (!parseDeclarator(decl)) { + return false; + } + + parseInitializer(init); + + InitDeclaratorAST *ast = CreateNode<InitDeclaratorAST>(m_pool); + ast->setDeclarator(decl); + ast->setInitializer(init); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + + + +bool Parser::parseBaseClause(BaseClauseAST *&node) +{ + int start = tokenStream->cursor(); + if (tokenStream->lookAhead() != ':') { + return false; + } + advance(); + + BaseClauseAST *bca = CreateNode<BaseClauseAST>(m_pool); + + BaseSpecifierAST *baseSpec = 0; + if (parseBaseSpecifier(baseSpec)) { + bca->addBaseSpecifier(baseSpec); + + while (tokenStream->lookAhead() == ',') { + advance(); + + if (!parseBaseSpecifier(baseSpec)) { + reportError(i18n("Base class specifier expected")); + return false; + } + bca->addBaseSpecifier(baseSpec); + } + } else + return false; + + UPDATE_POS(bca, start, tokenStream->cursor()); + node = bca; + + return true; +} + +bool Parser::parseInitializer(AST *&node) +{ + if (tokenStream->lookAhead() == '=') { + advance(); + + if (!parseInitializerClause(node)) { + reportError(i18n("Initializer clause expected")); + return false; + } + return true; + } else if (tokenStream->lookAhead() == '(') { + advance(); + AbstractExpressionAST *expr = 0; + skipCommaExpression(expr); + CHECK(')', ")"); + node = expr; + return true; + } + + return false; +} + +bool Parser::parseMemInitializerList(AST *&/*node*/) +{ + AST *init = 0; + if (!parseMemInitializer(init)) { + return false; + } + + while (tokenStream->lookAhead() == ',') { + advance(); + + if (!parseMemInitializer(init)) { + break; + } + } + + return true; +} + +bool Parser::parseMemInitializer(AST *&/*node*/) +{ + NameAST *initId = 0; + if (!parseMemInitializerId(initId)) { + reportError(i18n("Identifier expected")); + return false; + } + ADVANCE('(', "("); + AbstractExpressionAST *expr = 0; + skipCommaExpression(expr); + ADVANCE(')', ")"); + + return true; +} + +bool Parser::parseTypeIdList(AST *&node) +{ + + int start = tokenStream->cursor(); + + TypeIdAST *typeId = 0; + if (!parseTypeId(typeId)) { + return false; + } + + AST *ast = CreateNode<AST>(m_pool); + typeId->setParent(ast); + + while (tokenStream->lookAhead() == ',') { + advance(); + if (parseTypeId(typeId)) { + typeId->setParent(ast); + } else { + reportError(i18n("Type id expected")); + break; + } + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseBaseSpecifier(BaseSpecifierAST *&node) +{ + int start = tokenStream->cursor(); + BaseSpecifierAST *ast = CreateNode<BaseSpecifierAST>(m_pool); + + AST *access = 0; + if (tokenStream->lookAhead() == Token_virtual) { + AST_FROM_TOKEN(virt, tokenStream->cursor()); + ast->setIsVirtual(virt); + + advance(); + + parseAccessSpecifier(access); + } else { + parseAccessSpecifier(access); + + if (tokenStream->lookAhead() == Token_virtual) { + AST_FROM_TOKEN(virt, tokenStream->cursor()); + ast->setIsVirtual(virt); + advance(); + } + } + + NameAST *name = 0; + if (!parseName(name)) { + reportError(i18n("Class name expected")); + } + + ast->setAccess(access); + ast->setName(name); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + + +bool Parser::parseInitializerClause(AST *&node) +{ + if (tokenStream->lookAhead() == '{') { + if (!skip('{','}')) { + reportError(i18n("} missing")); + } else + advance(); + } else { + AbstractExpressionAST *expr = 0; + if (!parseAssignmentExpression(expr)) { + //reportError(i18n("Expression expected")); + } + node = expr; + } + + return true; +} + +bool Parser::parseMemInitializerId(NameAST *&node) +{ + + return parseName(node); +} + +bool Parser::parsePtrToMember(AST *&/*node*/) /// ### create the AST node +{ + int start = tokenStream->cursor(); + + if (tokenStream->lookAhead() == Token_scope) + advance(); + + ClassOrNamespaceNameAST *name = 0; + while (tokenStream->lookAhead() == Token_identifier) { + + if (!parseUnqualifiedName(name)) + break; + + if (tokenStream->lookAhead() == Token_scope + && tokenStream->lookAhead(1) == '*') { + advance(); + advance(); + return true; + } + + if (tokenStream->lookAhead() == Token_scope) + advance(); + } + + tokenStream->rewind(start); + return false; +} + +bool Parser::parseUnqualifiedName(ClassOrNamespaceNameAST *&node, bool parseTemplateId) +{ + int start = tokenStream->cursor(); + bool isDestructor = false; + + ClassOrNamespaceNameAST *ast = CreateNode<ClassOrNamespaceNameAST>(m_pool); + + if (tokenStream->lookAhead() == Token_identifier) { + int startName = tokenStream->cursor(); + AST *n = CreateNode<AST>(m_pool); + advance(); + UPDATE_POS(n, startName, tokenStream->cursor()); + ast->setName(n); + } else if (tokenStream->lookAhead() == '~' && tokenStream->lookAhead(1) == Token_identifier) { + int startName = tokenStream->cursor(); + AST *n = CreateNode<AST>(m_pool); + advance(); // skip ~ + advance(); // skip classname + UPDATE_POS(n, startName, tokenStream->cursor()); + ast->setName(n); + isDestructor = true; + } else if (tokenStream->lookAhead() == Token_operator) { + AST *n = 0; + if (!parseOperatorFunctionId(n)) + return false; + ast->setName(n); + } else { + return false; + } + + if (parseTemplateId && !isDestructor) { + + int index = tokenStream->cursor(); + + if (tokenStream->lookAhead() == '<') { + advance(); + + // optional template arguments + TemplateArgumentListAST *args = 0; + parseTemplateArgumentList(args); + + if (tokenStream->lookAhead() != '>') { + tokenStream->rewind(index); + } else { + advance(); + ast->setTemplateArgumentList(args); + } + } + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseStringLiteral(AST *&node) +{ + int start = tokenStream->cursor(); + + while (tokenStream->lookAhead()) { + if (tokenStream->lookAhead() == Token_identifier && + tokenStream->currentTokenText() == "L" && tokenStream->lookAhead(1) == Token_string_literal) { + + advance(); + advance(); + } else if (tokenStream->lookAhead() == Token_string_literal) { + advance(); + } else + return false; + } + + AST *ast = CreateNode<AST>(m_pool); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::skipExpressionStatement(StatementAST *&node) +{ + int start = tokenStream->cursor(); + + AbstractExpressionAST *expr = 0; + skipCommaExpression(expr); + + ADVANCE(';', ";"); + + ExpressionStatementAST *ast = CreateNode<ExpressionStatementAST>(m_pool); + ast->setExpression(expr); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseStatement(StatementAST *&node) +{ + int start = tokenStream->cursor(); + + switch(tokenStream->lookAhead()) { + + case Token_while: + return parseWhileStatement(node); + + case Token_do: + return parseDoStatement(node); + + case Token_for: + return parseForStatement(node); + + case Token_if: + return parseIfStatement(node); + + case Token_switch: + return parseSwitchStatement(node); + + case Token_try: + return parseTryBlockStatement(node); + + case Token_case: + case Token_default: + return parseLabeledStatement(node); + + case Token_break: + case Token_continue: + advance(); + ADVANCE(';', ";"); + return true; + + case Token_goto: + advance(); + ADVANCE(Token_identifier, "identifier"); + ADVANCE(';', ";"); + return true; + + case Token_return: + { + advance(); + AbstractExpressionAST *expr = 0; + skipCommaExpression(expr); + + ADVANCE(';', ";"); + + ReturnStatementAST *ast = CreateNode<ReturnStatementAST>(m_pool); + ast->setExpression(expr); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + } + return true; + + case '{': + return parseCompoundStatement(node); + + case Token_identifier: + if (parseLabeledStatement(node)) + return true; + break; + } + + if (parseDeclarationStatement(node)) + return true; + + return skipExpressionStatement(node); +} + +bool Parser::parseCondition(ConditionAST *&node) +{ + int start = tokenStream->cursor(); + + ConditionAST *ast = CreateNode<ConditionAST>(m_pool); + TypeSpecifierAST *spec = 0; + + if (parseTypeSpecifier(spec)) { + DeclaratorAST *decl = 0; + if (parseDeclarator(decl) && tokenStream->lookAhead() == '=') { + advance(); + + AbstractExpressionAST *expr = 0; + if (parseExpression(expr)) { + ast->setTypeSpec(spec); + ast->setDeclarator(decl); + ast->setExpression(expr); + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; + } + } + } + + tokenStream->rewind(start); + + AbstractExpressionAST *expr = 0; + if (!skipCommaExpression(expr)) { + return false; + } + + ast->setExpression(expr); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + + +bool Parser::parseWhileStatement(StatementAST *&node) +{ + int start = tokenStream->cursor(); + + ADVANCE(Token_while, "while"); + ADVANCE('(' , "("); + + ConditionAST *cond = 0; + if (!parseCondition(cond)) { + reportError(i18n("condition expected")); + return false; + } + ADVANCE(')', ")"); + + StatementAST *body = 0; + if (!parseStatement(body)) { + reportError(i18n("statement expected")); + return false; + } + + WhileStatementAST *ast = CreateNode<WhileStatementAST>(m_pool); + ast->setCondition(cond); + ast->setStatement(body); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseDoStatement(StatementAST *&node) +{ + int start = tokenStream->cursor(); + + ADVANCE(Token_do, "do"); + + StatementAST *body = 0; + if (!parseStatement(body)) { + reportError(i18n("statement expected")); + //return false; + } + + ADVANCE_NR(Token_while, "while"); + ADVANCE_NR('(' , "("); + + AbstractExpressionAST *expr = 0; + if (!skipCommaExpression(expr)) { + reportError(i18n("expression expected")); + //return false; + } + + ADVANCE_NR(')', ")"); + ADVANCE_NR(';', ";"); + + DoStatementAST *ast = CreateNode<DoStatementAST>(m_pool); + ast->setStatement(body); + //ast->setCondition(condition); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseForStatement(StatementAST *&node) +{ + int start = tokenStream->cursor(); + + ADVANCE(Token_for, "for"); + ADVANCE('(', "("); + + StatementAST *init = 0; + if (!parseForInitStatement(init)) { + reportError(i18n("for initialization expected")); + return false; + } + + ConditionAST *cond = 0; + parseCondition(cond); + ADVANCE(';', ";"); + + AbstractExpressionAST *expr = 0; + skipCommaExpression(expr); + ADVANCE(')', ")"); + + StatementAST *body = 0; + if (!parseStatement(body)) + return false; + + ForStatementAST *ast = CreateNode<ForStatementAST>(m_pool); + ast->setInitStatement(init); + ast->setCondition(cond); + // ast->setExpression(expression); + ast->setStatement(body); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseForInitStatement(StatementAST *&node) +{ + if (parseDeclarationStatement(node)) + return true; + + return skipExpressionStatement(node); +} + +bool Parser::parseCompoundStatement(StatementAST *&node) +{ + int start = tokenStream->cursor(); + + if (tokenStream->lookAhead() != '{') { + return false; + } + advance(); + + StatementListAST *ast = CreateNode<StatementListAST>(m_pool); + + while (tokenStream->lookAhead()) { + if (tokenStream->lookAhead() == '}') + break; + + StatementAST *stmt = 0; + int startStmt = tokenStream->cursor(); + if (!parseStatement(stmt)) { + if (startStmt == tokenStream->cursor()) + advance(); + skipUntilStatement(); + } else { + ast->addStatement(stmt); + } + } + + if (tokenStream->lookAhead() != '}') { + reportError(i18n("} expected")); + } else { + advance(); + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseIfStatement(StatementAST *&node) +{ + int start = tokenStream->cursor(); + + ADVANCE(Token_if, "if"); + + ADVANCE('(' , "("); + + IfStatementAST *ast = CreateNode<IfStatementAST>(m_pool); + + ConditionAST *cond = 0; + if (!parseCondition(cond)) { + reportError(i18n("condition expected")); + return false; + } + ADVANCE(')', ")"); + + StatementAST *stmt = 0; + if (!parseStatement(stmt)) { + reportError(i18n("statement expected")); + return false; + } + + ast->setCondition(cond); + ast->setStatement(stmt); + + if (tokenStream->lookAhead() == Token_else) { + advance(); + StatementAST *elseStmt = 0; + if (!parseStatement(elseStmt)) { + reportError(i18n("statement expected")); + return false; + } + ast->setElseStatement(elseStmt); + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseSwitchStatement(StatementAST *&node) +{ + int start = tokenStream->cursor(); + ADVANCE(Token_switch, "switch"); + + ADVANCE('(' , "("); + + ConditionAST *cond = 0; + if (!parseCondition(cond)) { + reportError(i18n("condition expected")); + return false; + } + ADVANCE(')', ")"); + + StatementAST *stmt = 0; + if (!parseStatement(stmt)) { + syntaxError(); + return false; + } + + SwitchStatementAST *ast = CreateNode<SwitchStatementAST>(m_pool); + ast->setCondition(cond); + ast->setStatement(stmt); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseLabeledStatement(StatementAST *&node) +{ + switch(tokenStream->lookAhead()) { + case Token_identifier: + case Token_default: + if (tokenStream->lookAhead(1) == ':') { + advance(); + advance(); + + StatementAST *stmt = 0; + LabeledStatementAST *ast = CreateNode<LabeledStatementAST>(m_pool); + node = ast; + if (parseStatement(stmt)) { + ast->setStatement(stmt); + return true; + } + } + break; + + case Token_case: + { + advance(); + AbstractExpressionAST *expr = 0; + if (!parseConstantExpression(expr)) { + reportError(i18n("expression expected")); + } else if (tokenStream->lookAhead() == Token_ellipsis) { + advance(); + + AbstractExpressionAST *expr2 = 0; + if (!parseConstantExpression(expr2)) { + reportError(i18n("expression expected")); + } + } + ADVANCE(':', ":"); + + StatementAST *stmt = 0; + LabeledStatementAST *ast = CreateNode<LabeledStatementAST>(m_pool); + node = ast; + ast->setExpression(expr); + + if (parseStatement(stmt)) { + ast->setStatement(stmt); + return true; + } + } + break; + + } + return false; +} + +bool Parser::parseBlockDeclaration(DeclarationAST *&node) +{ + switch(tokenStream->lookAhead()) { + case Token_typedef: + return parseTypedef(node); + case Token_using: + return parseUsing(node); + case Token_asm: + return parseAsmDefinition(node); + case Token_namespace: + return parseNamespaceAliasDefinition(node); + } + + int start = tokenStream->cursor(); + + AST *storageSpec = 0; + parseStorageClassSpecifier(storageSpec); + + AST *cv = 0; + parseCvQualify(cv); + + TypeSpecifierAST *spec = 0; + if (!parseTypeSpecifierOrClassSpec(spec)) { // replace with simpleTypeSpecifier?!?! + tokenStream->rewind(start); + return false; + } + spec->setCvQualify(cv); + + AST *cv2 = 0; + parseCvQualify(cv2); + spec->setCv2Qualify(cv2); + + InitDeclaratorListAST *declarators = 0; + parseInitDeclaratorList(declarators); + + if (tokenStream->lookAhead() != ';') { + tokenStream->rewind(start); + return false; + } + advance(); + + SimpleDeclarationAST *ast = CreateNode<SimpleDeclarationAST>(m_pool); + ast->setTypeSpec(spec); + ast->setInitDeclaratorList(declarators); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseNamespaceAliasDefinition(DeclarationAST *&/*node*/) +{ + if (tokenStream->lookAhead() != Token_namespace) { + return false; + } + advance(); + + ADVANCE(Token_identifier, "identifier"); + ADVANCE('=', "="); + + NameAST *name = 0; + if (!parseName(name)) { + reportError(i18n("Namespace name expected")); + } + + ADVANCE(';', ";"); + + return true; + +} + +bool Parser::parseDeclarationStatement(StatementAST *&node) +{ + int start = tokenStream->cursor(); + + DeclarationAST *decl = 0; + if (!parseBlockDeclaration(decl)) + return false; + + DeclarationStatementAST *ast = CreateNode<DeclarationStatementAST>(m_pool); + ast->setDeclaration(decl); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseDeclarationInternal(DeclarationAST *&node) +{ + int start = tokenStream->cursor(); + + // that is for the case '__declspec(dllexport) int ...' or + // '__declspec(dllexport) inline int ...', etc. + AST *winDeclSpec = 0; + parseWinDeclSpec(winDeclSpec); + + AST *funSpec = 0; + bool hasFunSpec = parseFunctionSpecifier(funSpec); + + AST *storageSpec = 0; + bool hasStorageSpec = parseStorageClassSpecifier(storageSpec); + + if (hasStorageSpec && !hasFunSpec) + hasFunSpec = parseFunctionSpecifier(funSpec); + + // that is for the case 'friend __declspec(dllexport) ....' + AST *winDeclSpec2 = 0; + parseWinDeclSpec(winDeclSpec2); + + AST *cv = 0; + parseCvQualify(cv); + + int index = tokenStream->cursor(); + NameAST *name = 0; + if (parseName(name) && tokenStream->lookAhead() == '(') { + // no type specifier, maybe a constructor or a cast operator?? + + tokenStream->rewind(index); + + InitDeclaratorAST *declarator = 0; + if (parseInitDeclarator(declarator)) { + switch(tokenStream->lookAhead()) { + case ';': + { + advance(); + + InitDeclaratorListAST *declarators = CreateNode<InitDeclaratorListAST>(m_pool); + + // update declarators position + if (declarator) + declarators->setPosition(declarator->startToken(), declarator->endToken()); + declarators->addInitDeclarator(declarator); + + SimpleDeclarationAST *ast = CreateNode<SimpleDeclarationAST>(m_pool); + ast->setInitDeclaratorList(declarators); + node = ast; + UPDATE_POS(node, start, tokenStream->cursor()); + return true; + + } + break; + + case ':': + { + AST *ctorInit = 0; + StatementListAST *funBody = 0; + if (parseCtorInitializer(ctorInit) && parseFunctionBody(funBody)) { + FunctionDefinitionAST *ast = CreateNode<FunctionDefinitionAST>(m_pool); + ast->setStorageSpecifier(storageSpec); + ast->setFunctionSpecifier(funSpec); + ast->setInitDeclarator(declarator); + ast->setFunctionBody(funBody); + node = ast; + UPDATE_POS(node, start, tokenStream->cursor()); + return true; + } + } + break; + + case '{': + { + StatementListAST *funBody = 0; + if (parseFunctionBody(funBody)) { + FunctionDefinitionAST *ast = CreateNode<FunctionDefinitionAST>(m_pool); + ast->setStorageSpecifier(storageSpec); + ast->setFunctionSpecifier(funSpec); + ast->setInitDeclarator(declarator); + ast->setFunctionBody(funBody); + node = ast; + UPDATE_POS(node, start, tokenStream->cursor()); + return true; + } + } + break; + + case '(': + case '[': + // ops!! it seems a declarator + goto start_decl; + break; + } + + } + } + +start_decl: + tokenStream->rewind(index); + + if (tokenStream->lookAhead() == Token_const && tokenStream->lookAhead(1) == Token_identifier && tokenStream->lookAhead(2) == '=') { + // constant definition + advance(); + InitDeclaratorListAST *declarators = 0; + if (parseInitDeclaratorList(declarators)) { + ADVANCE(';', ";"); + DeclarationAST *ast = CreateNode<DeclarationAST>(m_pool); + node = ast; + UPDATE_POS(node, start, tokenStream->cursor()); + return true; + } + syntaxError(); + return false; + } + + TypeSpecifierAST *spec = 0; + if (parseTypeSpecifier(spec)) { + if (!hasFunSpec) + parseFunctionSpecifier(funSpec); // e.g. "void inline" + spec->setCvQualify(cv); + + InitDeclaratorListAST *declarators = 0; + + InitDeclaratorAST *decl = 0; + int startDeclarator = tokenStream->cursor(); + bool maybeFunctionDefinition = false; + + if (tokenStream->lookAhead() != ';') { + if (parseInitDeclarator(decl) && tokenStream->lookAhead() == '{') { + // function definition + maybeFunctionDefinition = true; + } else { + tokenStream->rewind(startDeclarator); + if (!parseInitDeclaratorList(declarators)) { + syntaxError(); + return false; + } + } + } + + switch(tokenStream->lookAhead()) { + case ';': + { + advance(); + SimpleDeclarationAST *ast = CreateNode<SimpleDeclarationAST>(m_pool); + ast->setStorageSpecifier(storageSpec); + ast->setFunctionSpecifier(funSpec); + ast->setTypeSpec(spec); + ast->setWinDeclSpec(winDeclSpec); + ast->setInitDeclaratorList(declarators); + node = ast; + UPDATE_POS(node, start, tokenStream->cursor()); + } + return true; + + case '{': + { + if (!maybeFunctionDefinition) { + syntaxError(); + return false; + } + StatementListAST *funBody = 0; + if (parseFunctionBody(funBody)) { + FunctionDefinitionAST *ast = CreateNode<FunctionDefinitionAST>(m_pool); + ast->setWinDeclSpec(winDeclSpec); + ast->setStorageSpecifier(storageSpec); + ast->setFunctionSpecifier(funSpec); + ast->setTypeSpec(spec); + ast->setInitDeclarator(decl); + ast->setFunctionBody(funBody); + node = ast; + UPDATE_POS(node, start, tokenStream->cursor()); + return true; + } + } + break; + + } + } + + syntaxError(); + return false; +} + +bool Parser::parseFunctionBody(StatementListAST *&node) +{ + int start = tokenStream->cursor(); + if (tokenStream->lookAhead() != '{') { + return false; + } + advance(); + + StatementListAST *ast = CreateNode<StatementListAST>(m_pool); + + while (tokenStream->lookAhead()) { + if (tokenStream->lookAhead() == '}') + break; + + StatementAST *stmt = 0; + int startStmt = tokenStream->cursor(); + if (!parseStatement(stmt)) { + syntaxError(); + if (startStmt == tokenStream->cursor()) + advance(); + skipUntilStatement(); + } else + ast->addStatement(stmt); + } + + if (tokenStream->lookAhead() != '}') { + reportError(i18n("} expected")); + } else + advance(); + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + +bool Parser::parseTypeSpecifierOrClassSpec(TypeSpecifierAST *&node) +{ + if (parseClassSpecifier(node)) + return true; + else if (parseEnumSpecifier(node)) + return true; + else if (parseTypeSpecifier(node)) + return true; + + return false; +} + +bool Parser::parseTryBlockStatement(StatementAST *&node) +{ + if (tokenStream->lookAhead() != Token_try) { + return false; + } + advance(); + + StatementAST *stmt = 0; + if (!parseCompoundStatement(stmt)) { + syntaxError(); + return false; + } + + if (tokenStream->lookAhead() != Token_catch) { + reportError(i18n("catch expected")); + return false; + } + + while (tokenStream->lookAhead() == Token_catch) { + advance(); + ADVANCE('(', "("); + ConditionAST *cond = 0; + if (tokenStream->lookAhead() == Token_ellipsis) { + advance(); + } else if (!parseCondition(cond)) { + reportError(i18n("condition expected")); + return false; + } + ADVANCE(')', ")"); + + StatementAST *body = 0; + if (!parseCompoundStatement(body)) { + syntaxError(); + return false; + } + } + + node = stmt; + return true; +} + +bool Parser::parsePrimaryExpression(AbstractExpressionAST *&node) +{ + int start = tokenStream->cursor(); + + AbstractExpressionAST *ast = CreateExpression<NodeType_PrimaryExpression>(m_pool); + + switch(tokenStream->lookAhead()) { + case Token_string_literal: + { + AST *lit = 0; + parseStringLiteral(lit); + if (lit) + lit->setParent(ast); + } + break; + + case Token_number_literal: + case Token_char_literal: + case Token_true: + case Token_false: + case Token_this: + { + AST_FROM_TOKEN(opNode, tokenStream->cursor()); + opNode->setParent(ast); + advance(); + } + break; + + case '(': + { + advance(); + + if (tokenStream->lookAhead() == '{') { + StatementAST *stmt = 0; + if (!parseCompoundStatement(stmt)) + return false; + if (stmt) + stmt->setParent(ast); + } else { + AbstractExpressionAST *expr = 0; + if (!parseExpression(expr)) { + return false; + } + if (expr) + expr->setParent(ast); + } + CHECK(')', ")"); + } + break; + + default: + { +/* ### reenable me + TypeSpecifierAST *typeSpec = 0; + if (parseSimpleTypeSpecifier(typeSpec) && tokenStream->lookAhead() == '(') { + Q_ASSERT (0); + advance(); + AbstractExpressionAST *expr = 0; + parseCommaExpression(expr); + CHECK(')', ")"); + break; + + if (typeSpec) + typeSpec->setParent(ast); + + if (expr) + expr->setParent(ast); + } + + tokenStream->rewind(start); +*/ + + NameAST *name = 0; + if (!parseName(name, false)) + return false; + + if (name) + name->setParent(ast); + + break; + } + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + + +/* + postfix-expression-internal: + [ expression ] + ( expression-list [opt] ) + (.|->) template [opt] id-expression + (.|->) pseudo-destructor-name + ++ + -- +*/ +bool Parser::parsePostfixExpressionInternal(AbstractExpressionAST *postfixExpr, AbstractExpressionAST *&node) +{ + Q_ASSERT (postfixExpr); + + int start = tokenStream->cursor(); + + switch (tokenStream->lookAhead()) { + case '[': + { + advance(); + AbstractExpressionAST *expr = 0; + parseExpression(expr); + CHECK(']', "]"); + + SubscriptingAST *ast = CreateNode<SubscriptingAST>(m_pool); + ast->setExpression(postfixExpr); + ast->setSubscript(expr); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + } + return true; + + case '(': + { + advance(); + AbstractExpressionAST *expr = 0; + parseExpression(expr); + CHECK(')', ")"); + + FunctionCallAST *ast = CreateNode<FunctionCallAST>(m_pool); + ast->setExpression(postfixExpr); + ast->setArguments(expr); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + } + return true; + + case '.': + case Token_arrow: + { + AST_FROM_TOKEN(op, tokenStream->cursor()); + + advance(); + if (tokenStream->lookAhead() == Token_template) + advance(); + + NameAST *name = 0; + if (!parseName(name)) + return false; + + ClassMemberAccessAST *ast = CreateNode<ClassMemberAccessAST>(m_pool); + ast->setOp(op); + ast->setExpression(postfixExpr); + ast->setName(name); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + } + return true; + + case Token_incr: + case Token_decr: + { + AST_FROM_TOKEN(op, tokenStream->cursor()); + advance(); + + IncrDecrAST *ast = CreateNode<IncrDecrAST>(m_pool); + ast->setExpression(postfixExpr); + ast->setOp(op); + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + } + return true; + + default: + return false; + } +} + +/* + postfix-expression: + simple-type-specifier ( expression-list [opt] ) + primary-expression postfix-expression-internal* +*/ +bool Parser::parsePostfixExpression(AbstractExpressionAST *&node) +{ + int start = tokenStream->cursor(); + + switch (tokenStream->lookAhead()) { + case Token_dynamic_cast: + case Token_static_cast: + case Token_reinterpret_cast: + case Token_const_cast: + { + AST_FROM_TOKEN(castOp, tokenStream->cursor()); + + advance(); + CHECK('<', "<"); + TypeIdAST *typeId = 0; + parseTypeId(typeId); + CHECK('>', ">"); + + CHECK('(', ")"); + AbstractExpressionAST *expr = 0; + parseCommaExpression(expr); + CHECK(')', ")"); + + CppCastExpressionAST *tmp = CreateNode<CppCastExpressionAST>(m_pool); + tmp->setCastOp(castOp); + tmp->setTypeId(typeId); + tmp->setExpression(expr); + + AbstractExpressionAST *ast = tmp; + AbstractExpressionAST *e = 0; + while (parsePostfixExpressionInternal(ast, e)) { + ast = e; + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + } + return true; + + case Token_typename: + { + advance(); + + NameAST* name = 0; + if (!parseName(name)) + return false; + + CHECK('(', "("); + AbstractExpressionAST *expr = 0; + parseCommaExpression(expr); + CHECK(')', ")"); + + // ### AST + } + return true; + + case Token_typeid: + { + advance(); + + CHECK('(', "("); + AbstractExpressionAST *expr = 0; + parseCommaExpression(expr); + CHECK(')', ")"); + + // ### AST + } + return true; + + default: + break; + } + + TypeSpecifierAST *typeSpec = 0; + AbstractExpressionAST *expr = 0; + + if (parseSimpleTypeSpecifier(typeSpec/*, true*/) && tokenStream->lookAhead() == '(') { + advance(); // skip '(' + parseCommaExpression(expr); + CHECK(')', ")"); + } else { + tokenStream->rewind(start); + + if (!parsePrimaryExpression(expr)) + return false; + } + + AbstractExpressionAST *ast = CreateExpression<NodeType_PostfixExpression>(m_pool); + if (typeSpec) + typeSpec->setParent(ast); + + if (expr) + expr->setParent(ast); + + AbstractExpressionAST *e = 0; + while (parsePostfixExpressionInternal(ast, e)) { + ast = e; + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseUnaryExpression(AbstractExpressionAST *&node) +{ + int start = tokenStream->cursor(); + + switch(tokenStream->lookAhead()) { + case Token_incr: + case Token_decr: + case '*': + case '&': + case '+': + case '-': + case '!': + case '~': + { + AST_FROM_TOKEN(opNode, tokenStream->cursor()); + + advance(); + AbstractExpressionAST *expr = 0; + if (!parseCastExpression(expr)) + return false; + + AbstractExpressionAST *ast = CreateExpression<NodeType_UnaryExpression>(m_pool); + + opNode->setParent(ast); + if (expr) + expr->setParent(ast); + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; + } + + case Token_sizeof: + { + AbstractExpressionAST *ast = CreateExpression<NodeType_UnaryExpression>(m_pool); + + AST_FROM_TOKEN(opNode, tokenStream->cursor()); + opNode->setParent(ast); + + advance(); + int index = tokenStream->cursor(); + if (tokenStream->lookAhead() == '(') { + advance(); + TypeIdAST *typeId = 0; + if (parseTypeId(typeId) && tokenStream->lookAhead() == ')') { + if (typeId) + typeId->setParent(ast); + + advance(); + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; + } + tokenStream->rewind(index); + } + AbstractExpressionAST *expr = 0; + if (!parseUnaryExpression(expr)) + return false; + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; + } + + case Token_new: + return parseNewExpression(node); + + case Token_delete: + return parseDeleteExpression(node); + } + + return parsePostfixExpression(node); +} + +bool Parser::parseNewExpression(AbstractExpressionAST *&node) +{ + int start = tokenStream->cursor(); + + AbstractExpressionAST *ast = CreateExpression<NodeType_NewExpression>(m_pool); + + if (tokenStream->lookAhead() == Token_scope && tokenStream->lookAhead(1) == Token_new) { + AST_FROM_TOKEN(scopeNode, tokenStream->cursor()); + scopeNode->setParent(ast); + advance(); + } + + AST_FROM_TOKEN(newNode, tokenStream->cursor()); + newNode->setParent(ast); + + CHECK(Token_new, "new"); + + if (tokenStream->lookAhead() == '(') { + advance(); + AbstractExpressionAST *expr = 0; + parseCommaExpression(expr); + if (expr) + expr->setParent(ast); + CHECK(')', ")"); + } + + if (tokenStream->lookAhead() == '(') { + advance(); + TypeIdAST *typeId = 0; + parseTypeId(typeId); + if (typeId) + typeId->setParent(ast); + CHECK(')', ")"); + } else { + AbstractExpressionAST *typeId = 0; + parseNewTypeId(typeId); + if (typeId) + typeId->setParent(ast); + } + + AbstractExpressionAST *init = 0; + parseNewInitializer(init); + if (init) + init->setParent(ast); + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseNewTypeId(AbstractExpressionAST *&node) +{ + int start = tokenStream->cursor(); + + TypeSpecifierAST *typeSpec = 0; + if (!parseTypeSpecifier(typeSpec)) + return false; + + AbstractExpressionAST *ast = CreateExpression<NodeType_NewTypeId>(m_pool); + + if (typeSpec) + typeSpec->setParent(ast); + + AbstractExpressionAST *declarator = 0; + parseNewDeclarator(declarator); + if (declarator) + declarator->setParent(ast); + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseNewDeclarator(AbstractExpressionAST *&node) +{ + int start = tokenStream->cursor(); + + AbstractExpressionAST *ast = CreateExpression<NodeType_NewInitializer>(m_pool); + + AST *ptrOp = 0; + if (parsePtrOperator(ptrOp)) { + if (ptrOp) + ptrOp->setParent(ast); + + AbstractExpressionAST *declarator = 0; + parseNewDeclarator(declarator); + + if (declarator) + declarator->setParent(ast); + } + + while (tokenStream->lookAhead() == '[') { + advance(); + AbstractExpressionAST *expr = 0; + parseExpression(expr); + ADVANCE(']', "]"); + + if (expr) + expr->setParent(ast); + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseNewInitializer(AbstractExpressionAST *&node) +{ + int start = tokenStream->cursor(); + + if (tokenStream->lookAhead() != '(') + return false; + + AbstractExpressionAST *ast = CreateExpression<NodeType_NewInitializer>(m_pool); + + advance(); + AbstractExpressionAST *expr = 0; + parseCommaExpression(expr); + + if (expr) + expr->setParent(ast); + + CHECK(')', ")"); + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseDeleteExpression(AbstractExpressionAST *&node) +{ + int start = tokenStream->cursor(); + + AbstractExpressionAST *ast = CreateExpression<NodeType_DeleteExpression>(m_pool); + + if (tokenStream->lookAhead() == Token_scope && tokenStream->lookAhead(1) == Token_delete) { + AST_FROM_TOKEN(scopeNode, tokenStream->cursor()); + scopeNode->setParent(ast); + advance(); + } + + AST_FROM_TOKEN(deleteNode, tokenStream->cursor()); + deleteNode->setParent(ast); + + CHECK(Token_delete, "delete"); + + if (tokenStream->lookAhead() == '[') { + int beg = tokenStream->cursor(); + advance(); + CHECK(']', "]"); + + AST *n = CreateNode<AST>(m_pool); + UPDATE_POS(n, beg, tokenStream->cursor()); + n->setParent(ast); + } + + AbstractExpressionAST *expr = 0; + if (!parseCastExpression(expr)) + return false; + + if (expr) + expr->setParent(ast); + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseCastExpression(AbstractExpressionAST *&node) +{ + int start = tokenStream->cursor(); + + if (tokenStream->lookAhead() == '(') { + AbstractExpressionAST *ast = CreateExpression<NodeType_CastExpression>(m_pool); + + advance(); + TypeIdAST *typeId = 0; + if (parseTypeId(typeId)) { + + if (typeId) + typeId->setParent(ast); + + if (tokenStream->lookAhead() == ')') { + advance(); + + AbstractExpressionAST *expr = 0; + if (parseCastExpression(expr)) { + if (expr) + expr->setParent(ast); + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; + } + } + } + } + + tokenStream->rewind(start); + return parseUnaryExpression(node); +} + +bool Parser::parsePmExpression(AbstractExpressionAST *&node) +{ + int start = tokenStream->cursor(); + + AbstractExpressionAST *ast = 0; + if (!parseCastExpression(ast) || !ast) // ### fixme + return false; + + while (tokenStream->lookAhead() == Token_ptrmem) { + int startOp = tokenStream->cursor(); + AST_FROM_TOKEN(op, startOp); + advance(); + + AbstractExpressionAST *rightExpr = 0; + if (!parseCastExpression(rightExpr)) + return false; + + BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool); + tmp->setOp(op); + tmp->setLeftExpression(ast); + tmp->setRightExpression(rightExpr); + UPDATE_POS(tmp, startOp, tokenStream->cursor()); + ast = tmp; + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseMultiplicativeExpression(AbstractExpressionAST *&node) +{ + int start = tokenStream->cursor(); + + AbstractExpressionAST *ast = 0; + if (!parsePmExpression(ast)) + return false; + + while (tokenStream->lookAhead() == '*' || tokenStream->lookAhead() == '/' || tokenStream->lookAhead() == '%') { + int startOp = tokenStream->cursor(); + AST_FROM_TOKEN(op, startOp); + advance(); + + AbstractExpressionAST *rightExpr = 0; + if (!parsePmExpression(rightExpr)) + return false; + + BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool); + tmp->setOp(op); + tmp->setLeftExpression(ast); + tmp->setRightExpression(rightExpr); + UPDATE_POS(tmp, startOp, tokenStream->cursor()); + ast = tmp; + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + + +bool Parser::parseAdditiveExpression(AbstractExpressionAST *&node) +{ + int start = tokenStream->cursor(); + + AbstractExpressionAST *ast = 0; + if (!parseMultiplicativeExpression(ast)) + return false; + + while (tokenStream->lookAhead() == '+' || tokenStream->lookAhead() == '-') { + int startOp = tokenStream->cursor(); + AST_FROM_TOKEN(op, startOp); + advance(); + + AbstractExpressionAST *rightExpr = 0; + if (!parseMultiplicativeExpression(rightExpr)) + return false; + + BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool); + tmp->setOp(op); + tmp->setLeftExpression(ast); + tmp->setRightExpression(rightExpr); + UPDATE_POS(tmp, startOp, tokenStream->cursor()); + ast = tmp; + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseShiftExpression(AbstractExpressionAST *&node) +{ + int start = tokenStream->cursor(); + + AbstractExpressionAST *ast = 0; + if (!parseAdditiveExpression(ast)) + return false; + + while (tokenStream->lookAhead() == Token_shift) { + int startOp = tokenStream->cursor(); + AST_FROM_TOKEN(op, startOp); + advance(); + + AbstractExpressionAST *rightExpr = 0; + if (!parseAdditiveExpression(rightExpr)) + return false; + + BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool); + tmp->setOp(op); + tmp->setLeftExpression(ast); + tmp->setRightExpression(rightExpr); + UPDATE_POS(tmp, startOp, tokenStream->cursor()); + ast = tmp; + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseRelationalExpression(AbstractExpressionAST *&node, bool templArgs) +{ + int start = tokenStream->cursor(); + + AbstractExpressionAST *ast = 0; + if (!parseShiftExpression(ast)) + return false; + + while (tokenStream->lookAhead() == '<' || (tokenStream->lookAhead() == '>' && !templArgs) || + tokenStream->lookAhead() == Token_leq || tokenStream->lookAhead() == Token_geq) { + int startOp = tokenStream->cursor(); + AST_FROM_TOKEN(op, startOp); + advance(); + + AbstractExpressionAST *rightExpr = 0; + if (!parseShiftExpression(rightExpr)) + return false; + + BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool); + tmp->setOp(op); + tmp->setLeftExpression(ast); + tmp->setRightExpression(rightExpr); + UPDATE_POS(tmp, startOp, tokenStream->cursor()); + ast = tmp; + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseEqualityExpression(AbstractExpressionAST *&node, bool templArgs) +{ + int start = tokenStream->cursor(); + + AbstractExpressionAST *ast = 0; + if (!parseRelationalExpression(ast, templArgs)) + return false; + + while (tokenStream->lookAhead() == Token_eq || tokenStream->lookAhead() == Token_not_eq) { + int startOp = tokenStream->cursor(); + AST_FROM_TOKEN(op, startOp); + advance(); + + AbstractExpressionAST *rightExpr = 0; + if (!parseRelationalExpression(rightExpr, templArgs)) + return false; + + BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool); + tmp->setOp(op); + tmp->setLeftExpression(ast); + tmp->setRightExpression(rightExpr); + UPDATE_POS(tmp, startOp, tokenStream->cursor()); + ast = tmp; + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseAndExpression(AbstractExpressionAST *&node, bool templArgs) +{ + int start = tokenStream->cursor(); + + AbstractExpressionAST *ast = 0; + if (!parseEqualityExpression(ast, templArgs)) + return false; + + while (tokenStream->lookAhead() == '&') { + int startOp = tokenStream->cursor(); + AST_FROM_TOKEN(op, startOp); + advance(); + + AbstractExpressionAST *rightExpr = 0; + if (!parseEqualityExpression(rightExpr, templArgs)) + return false; + + BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool); + tmp->setOp(op); + tmp->setLeftExpression(ast); + tmp->setRightExpression(rightExpr); + UPDATE_POS(tmp, startOp, tokenStream->cursor()); + ast = tmp; + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseExclusiveOrExpression(AbstractExpressionAST *&node, bool templArgs) +{ + int start = tokenStream->cursor(); + + AbstractExpressionAST *ast = 0; + if (!parseAndExpression(ast, templArgs)) + return false; + + while (tokenStream->lookAhead() == '^') { + int startOp = tokenStream->cursor(); + AST_FROM_TOKEN(op, startOp); + advance(); + + AbstractExpressionAST *rightExpr = 0; + if (!parseAndExpression(rightExpr, templArgs)) + return false; + + BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool); + tmp->setOp(op); + tmp->setLeftExpression(ast); + tmp->setRightExpression(rightExpr); + UPDATE_POS(tmp, startOp, tokenStream->cursor()); + ast = tmp; + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseInclusiveOrExpression(AbstractExpressionAST *&node, bool templArgs) +{ + int start = tokenStream->cursor(); + + AbstractExpressionAST *ast = 0; + if (!parseExclusiveOrExpression(ast, templArgs)) + return false; + + while (tokenStream->lookAhead() == '|') { + int startOp = tokenStream->cursor(); + AST_FROM_TOKEN(op, startOp); + advance(); + + AbstractExpressionAST *rightExpr = 0; + if (!parseExclusiveOrExpression(rightExpr, templArgs)) + return false; + + BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool); + tmp->setOp(op); + tmp->setLeftExpression(ast); + tmp->setRightExpression(rightExpr); + UPDATE_POS(tmp, startOp, tokenStream->cursor()); + ast = tmp; + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseLogicalAndExpression(AbstractExpressionAST *&node, bool templArgs) +{ + int start = tokenStream->cursor(); + + AbstractExpressionAST *ast = 0; + if (!parseInclusiveOrExpression(ast, templArgs)) + return false; + + while (tokenStream->lookAhead() == Token_and) { + int startOp = tokenStream->cursor(); + AST_FROM_TOKEN(op, startOp); + advance(); + + AbstractExpressionAST *rightExpr = 0; + if (!parseInclusiveOrExpression(rightExpr, templArgs)) + return false; + + BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool); + tmp->setOp(op); + tmp->setLeftExpression(ast); + tmp->setRightExpression(rightExpr); + UPDATE_POS(tmp, startOp, tokenStream->cursor()); + ast = tmp; + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseLogicalOrExpression(AbstractExpressionAST *&node, bool templArgs) +{ + int start = tokenStream->cursor(); + + AbstractExpressionAST *ast = 0; + if (!parseLogicalAndExpression(ast, templArgs)) + return false; + + while (tokenStream->lookAhead() == Token_or) { + int startOp = tokenStream->cursor(); + AST_FROM_TOKEN(op, startOp); + advance(); + + AbstractExpressionAST *rightExpr = 0; + if (!parseLogicalAndExpression(rightExpr, templArgs)) + return false; + + BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool); + tmp->setOp(op); + tmp->setLeftExpression(ast); + tmp->setRightExpression(rightExpr); + UPDATE_POS(tmp, startOp, tokenStream->cursor()); + ast = tmp; + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseConditionalExpression(AbstractExpressionAST *&node) +{ + int start = tokenStream->cursor(); + AbstractExpressionAST *ast = 0; + if (!parseLogicalOrExpression(ast)) + return false; + + if (tokenStream->lookAhead() == '?') { + advance(); + + AbstractExpressionAST *leftExpr = 0; + if (!parseExpression(leftExpr)) + return false; + + CHECK(':', ":"); + + AbstractExpressionAST *rightExpr = 0; + if (!parseAssignmentExpression(rightExpr)) + return false; + + ConditionalExpressionAST *tmp = CreateNode<ConditionalExpressionAST>(m_pool); + tmp->setCondition(ast); + tmp->setLeftExpression(leftExpr); + tmp->setRightExpression(rightExpr); + ast = tmp; + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseAssignmentExpression(AbstractExpressionAST *&node) +{ + int start = tokenStream->cursor(); + + AbstractExpressionAST *ast = 0; + if (tokenStream->lookAhead() == Token_throw && !parseThrowExpression(ast)) + return false; + else if (!parseConditionalExpression(ast)) + return false; + + while (tokenStream->lookAhead() == Token_assign || tokenStream->lookAhead() == '=') { + int startOp = tokenStream->cursor(); + AST_FROM_TOKEN(op, startOp); + advance(); + + AbstractExpressionAST *rightExpr = 0; + if (!parseConditionalExpression(rightExpr)) + return false; + + BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool); + tmp->setOp(op); + tmp->setLeftExpression(ast); + tmp->setRightExpression(rightExpr); + UPDATE_POS(tmp, startOp, tokenStream->cursor()); + ast = tmp; + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseConstantExpression(AbstractExpressionAST *&node) +{ + return parseConditionalExpression(node); +} + +bool Parser::parseExpression(AbstractExpressionAST *&node) +{ + return parseCommaExpression(node); +} + +bool Parser::parseCommaExpression(AbstractExpressionAST *&node) +{ + int start = tokenStream->cursor(); + + AbstractExpressionAST *ast = 0; + if (!parseAssignmentExpression(ast)) + return false; + + while (tokenStream->lookAhead() == ',') { + int startOp = tokenStream->cursor(); + AST_FROM_TOKEN(op, startOp); + advance(); + + AbstractExpressionAST *rightExpr = 0; + if (!parseAssignmentExpression(rightExpr)) + return false; + + BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool); + tmp->setOp(op); + tmp->setLeftExpression(ast); + tmp->setRightExpression(rightExpr); + UPDATE_POS(tmp, startOp, tokenStream->cursor()); + ast = tmp; + } + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + return true; +} + +bool Parser::parseThrowExpression(AbstractExpressionAST *&node) +{ + if (tokenStream->lookAhead() != Token_throw) + return false; + + int start = tokenStream->cursor(); + + AST_FROM_TOKEN(throwNode, tokenStream->cursor()); + CHECK(Token_throw, "throw"); + AbstractExpressionAST *expr = 0; + if (!parseAssignmentExpression(expr)) + return false; + + AbstractExpressionAST *ast = CreateExpression<NodeType_ThrowExpression>(m_pool); + throwNode->setParent(ast); + if (expr) + expr->setParent(ast); + + UPDATE_POS(ast, start, tokenStream->cursor()); + node = ast; + + return true; +} + + +// ### Objective C++ +bool Parser::parseIvarDeclList(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseIvarDecls(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseIvarDecl(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseIvars(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseIvarDeclarator(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseMethodDecl(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseUnarySelector(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseKeywordSelector(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseSelector(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseKeywordDecl(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseReceiver(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseObjcMessageExpr(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseMessageArgs(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseKeywordExpr(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseKeywordArgList(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseKeywordArg(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseReservedWord(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseMyParms(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseMyParm(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseOptParmList(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseObjcSelectorExpr(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseSelectorArg(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseKeywordNameList(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseKeywordName(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseObjcEncodeExpr(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseObjcString(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseProtocolRefs(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseIdentifierList(AST *& node) +{ + int start = tokenStream->cursor(); + + if (tokenStream->lookAhead() != Token_identifier) + return false; + + AST *ast = CreateNode<AST>(m_pool); + + AST_FROM_TOKEN(tk, tokenStream->cursor()); + tk->setParent(ast); + advance(); + + while (tokenStream->lookAhead() == ',') { + advance(); + if (tokenStream->lookAhead() == Token_identifier) { + AST_FROM_TOKEN(tk, tokenStream->cursor()); + tk->setParent(ast); + advance(); + } + ADVANCE(Token_identifier, "identifier"); + } + + node = ast; + UPDATE_POS(node, start, tokenStream->cursor()); + return true; +} + +bool Parser::parseIdentifierColon(AST *& node) +{ + Q_UNUSED(node); + + if (tokenStream->lookAhead() == Token_identifier && tokenStream->lookAhead(1) == ':') { + advance(); + advance(); + return true; + } // ### else if PTYPENAME -> return true ; + + return false; +} + +bool Parser::parseObjcProtocolExpr(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseObjcOpenBracketExpr(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseObjcCloseBracket(AST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseObjcDef(DeclarationAST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseObjcClassDef(DeclarationAST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseObjcClassDecl(DeclarationAST *& node) +{ + Q_UNUSED(node); + + ADVANCE(OBJC_CLASS, "@class"); + + AST *idList = 0; + parseIdentifierList(idList); + ADVANCE(';', ";"); + + return true; +} + +bool Parser::parseObjcProtocolDecl(DeclarationAST *& node) +{ + Q_UNUSED(node); + + ADVANCE(OBJC_PROTOCOL, "@protocol"); + + AST *idList = 0; + parseIdentifierList(idList); + ADVANCE(';', ";"); + + return true; +} + +bool Parser::parseObjcAliasDecl(DeclarationAST *& node) +{ + Q_UNUSED(node); + + ADVANCE(OBJC_ALIAS, "@alias"); + + AST *idList = 0; + parseIdentifierList(idList); + ADVANCE(';', ";"); + + return true; +} + +bool Parser::parseObjcProtocolDef(DeclarationAST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseObjcMethodDef(DeclarationAST *& node) +{ + Q_UNUSED(node); + return false; +} + +bool Parser::parseWinDeclSpec(AST *& node) +{ + if (tokenStream->lookAhead() == Token_identifier + && tokenStream->lookAhead(1) == '(' + && tokenStream->currentTokenText() == "__declspec") { + int start = tokenStream->cursor(); + advance(); + advance(); // skip '(' + + parseIdentifierList(node); + ADVANCE(')', ")"); + + UPDATE_POS(node, start, tokenStream->cursor()); + return true; + } + + return false; +} + +void Parser::advance() +{ + for (;;) { + tokenStream->nextToken(); + if (!tokenStream->isHidden(tokenStream->cursor())) + break; + } +} + +QT_END_NAMESPACE diff --git a/tools/porting/src/parser.h b/tools/porting/src/parser.h new file mode 100644 index 0000000..75cf9c0 --- /dev/null +++ b/tools/porting/src/parser.h @@ -0,0 +1,247 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef PARSER_H +#define PARSER_H + +#include "ast.h" +#include "tokenstreamadapter.h" + +#include <QString> +#include <QStringList> +#include <QList> + +QT_BEGIN_NAMESPACE + +class FileSymbol; +class TokenStream; +class Error; + +class Parser +{ +public: + Parser(); + ~Parser(); + +// TranslationUnitAST *parse(FileSymbol *file, pool *p); + TranslationUnitAST *parse(TokenStreamAdapter::TokenStream *tokenStream, pool *p); + TranslationUnitAST *parse(TokenStreamAdapter::TokenStream *tokenStream, pool *p, int targetMaxASTnodes, bool &done); +private: + bool reportError(const Error& err); + /** @todo remove*/ bool reportError(const QString& msg); + /** @todo remove*/ void syntaxError(); + +public /*rules*/ : + + bool parseTranslationUnit(TranslationUnitAST *&node); + + bool parseDeclaration(DeclarationAST *&node); + bool parseBlockDeclaration(DeclarationAST *&node); + bool parseLinkageSpecification(DeclarationAST *&node); + bool parseLinkageBody(LinkageBodyAST *&node); + bool parseNamespace(DeclarationAST *&node); + bool parseNamespaceAliasDefinition(DeclarationAST *&node); + bool parseUsing(DeclarationAST *&node); + bool parseUsingDirective(DeclarationAST *&node); + bool parseTypedef(DeclarationAST *&node); + bool parseAsmDefinition(DeclarationAST *&node); + bool parseTemplateDeclaration(DeclarationAST *&node); + bool parseDeclarationInternal(DeclarationAST *&node); + + bool parseStringLiteral(AST *&node); + bool parseUnqualifiedName(ClassOrNamespaceNameAST *&node, bool parseTemplateId = true); + bool parseName(NameAST *&node, bool parseTemplateId = true); + bool parseOperatorFunctionId(AST *&node); + bool parseTemplateArgumentList(TemplateArgumentListAST *&node, bool reportError = true); + bool parseOperator(AST *&node); + bool parseCvQualify(AST *&node); + bool parseSimpleTypeSpecifier(TypeSpecifierAST *&node, bool onlyIntegral = false); + bool parsePtrOperator(AST *&node); + bool parseTemplateArgument(AST *&node); + bool parseTypeSpecifier(TypeSpecifierAST *&node); + bool parseTypeSpecifierOrClassSpec(TypeSpecifierAST *&node); + bool parseDeclarator(DeclaratorAST *&node); + bool parseTemplateParameterList(TemplateParameterListAST *&node); + bool parseTemplateParameter(TemplateParameterAST *&node); + bool parseStorageClassSpecifier(AST *&node); + bool parseFunctionSpecifier(AST *&node); + bool parseInitDeclaratorList(InitDeclaratorListAST *&node); + bool parseInitDeclarator(InitDeclaratorAST *&node); + bool parseParameterDeclarationClause(ParameterDeclarationClauseAST *&node); + bool parseCtorInitializer(AST *&node); + bool parsePtrToMember(AST *&node); + bool parseEnumSpecifier(TypeSpecifierAST *&node); + bool parseClassSpecifier(TypeSpecifierAST *&node); + bool parseWinDeclSpec(AST *&node); + bool parseElaboratedTypeSpecifier(TypeSpecifierAST *&node); + bool parseDeclaratorId(NameAST *&node); + bool parseExceptionSpecification(AST *&node); + bool parseEnumerator(EnumeratorAST *&node); + bool parseTypeParameter(TypeParameterAST *&node); + bool parseParameterDeclaration(ParameterDeclarationAST *&node); + bool parseTypeId(TypeIdAST *&node); + bool parseAbstractDeclarator(DeclaratorAST *&node); + bool parseParameterDeclarationList(ParameterDeclarationListAST *&node); + bool parseMemberSpecification(DeclarationAST *&node); + bool parseAccessSpecifier(AST *&node); + bool parseTypeIdList(AST *&node); + bool parseMemInitializerList(AST *&node); + bool parseMemInitializer(AST *&node); + bool parseInitializer(AST *&node); + bool parseBaseClause(BaseClauseAST *&node); + bool parseBaseSpecifier(BaseSpecifierAST *&node); + bool parseInitializerClause(AST *&node); + bool parseMemInitializerId(NameAST *&node); + bool parseFunctionBody(StatementListAST *&node); + + // expression + bool skipExpression(AbstractExpressionAST *&node); + bool skipCommaExpression(AbstractExpressionAST *&node); + bool skipExpressionStatement(StatementAST *&node); + + bool parseExpression(AbstractExpressionAST *&node); + bool parsePrimaryExpression(AbstractExpressionAST *&node); + bool parsePostfixExpression(AbstractExpressionAST *&node); + bool parsePostfixExpressionInternal(AbstractExpressionAST *expr, AbstractExpressionAST *&node); + bool parseUnaryExpression(AbstractExpressionAST *&node); + bool parseNewExpression(AbstractExpressionAST *&node); + bool parseNewTypeId(AbstractExpressionAST *&node); + bool parseNewDeclarator(AbstractExpressionAST *&node); + bool parseNewInitializer(AbstractExpressionAST *&node); + bool parseDeleteExpression(AbstractExpressionAST *&node); + bool parseCastExpression(AbstractExpressionAST *&node); + bool parsePmExpression(AbstractExpressionAST *&node); + bool parseMultiplicativeExpression(AbstractExpressionAST *&node); + bool parseAdditiveExpression(AbstractExpressionAST *&node); + bool parseShiftExpression(AbstractExpressionAST *&node); + bool parseRelationalExpression(AbstractExpressionAST *&node, bool templArgs = false); + bool parseEqualityExpression(AbstractExpressionAST *&node, bool templArgs = false); + bool parseAndExpression(AbstractExpressionAST *&node, bool templArgs = false); + bool parseExclusiveOrExpression(AbstractExpressionAST *&node, bool templArgs = false); + bool parseInclusiveOrExpression(AbstractExpressionAST *&node, bool templArgs = false); + bool parseLogicalAndExpression(AbstractExpressionAST *&node, bool templArgs = false); + bool parseLogicalOrExpression(AbstractExpressionAST *&node, bool templArgs = false); + bool parseConditionalExpression(AbstractExpressionAST *&node); + bool parseAssignmentExpression(AbstractExpressionAST *&node); + bool parseConstantExpression(AbstractExpressionAST *&node); + bool parseCommaExpression(AbstractExpressionAST *&node); + bool parseThrowExpression(AbstractExpressionAST *&node); + + // statement + bool parseCondition(ConditionAST *&node); + bool parseStatement(StatementAST *&node); + bool parseWhileStatement(StatementAST *&node); + bool parseDoStatement(StatementAST *&node); + bool parseForStatement(StatementAST *&node); + bool parseCompoundStatement(StatementAST *&node); + bool parseForInitStatement(StatementAST *&node); + bool parseIfStatement(StatementAST *&node); + bool parseSwitchStatement(StatementAST *&node); + bool parseLabeledStatement(StatementAST *&node); + bool parseDeclarationStatement(StatementAST *&node); + bool parseTryBlockStatement(StatementAST *&node); + + // objective c + bool parseObjcDef(DeclarationAST *&node); + bool parseObjcClassDef(DeclarationAST *&node); + bool parseObjcClassDecl(DeclarationAST *&node); + bool parseObjcProtocolDecl(DeclarationAST *&node); + bool parseObjcAliasDecl(DeclarationAST *&node); + bool parseObjcProtocolDef(DeclarationAST *&node); + bool parseObjcMethodDef(DeclarationAST *&node); + + bool parseIvarDeclList(AST *&node); + bool parseIvarDecls(AST *&node); + bool parseIvarDecl(AST *&node); + bool parseIvars(AST *&node); + bool parseIvarDeclarator(AST *&node); + bool parseMethodDecl(AST *&node); + bool parseUnarySelector(AST *&node); + bool parseKeywordSelector(AST *&node); + bool parseSelector(AST *&node); + bool parseKeywordDecl(AST *&node); + bool parseReceiver(AST *&node); + bool parseObjcMessageExpr(AST *&node); + bool parseMessageArgs(AST *&node); + bool parseKeywordExpr(AST *&node); + bool parseKeywordArgList(AST *&node); + bool parseKeywordArg(AST *&node); + bool parseReservedWord(AST *&node); + bool parseMyParms(AST *&node); + bool parseMyParm(AST *&node); + bool parseOptParmList(AST *&node); + bool parseObjcSelectorExpr(AST *&node); + bool parseSelectorArg(AST *&node); + bool parseKeywordNameList(AST *&node); + bool parseKeywordName(AST *&node); + bool parseObjcEncodeExpr(AST *&node); + bool parseObjcString(AST *&node); + bool parseProtocolRefs(AST *&node); + bool parseIdentifierList(AST *&node); + bool parseIdentifierColon(AST *&node); + bool parseObjcProtocolExpr(AST *&node); + bool parseObjcOpenBracketExpr(AST *&node); + bool parseObjcCloseBracket(AST *&node); + + bool skipUntil(int token); + bool skipUntilDeclaration(); + bool skipUntilStatement(); + bool skip(int l, int r); + + void advance(); + +private: + int m_problems; + int m_maxProblems; + bool objcp; + TokenStreamAdapter::TokenStream *tokenStream; + pool *m_pool; + FileSymbol *m_file; + +private: + Parser(const Parser& source); + void operator = (const Parser& source); +}; + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/port.cpp b/tools/porting/src/port.cpp new file mode 100644 index 0000000..2ceb788 --- /dev/null +++ b/tools/porting/src/port.cpp @@ -0,0 +1,297 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "projectporter.h" +#include "fileporter.h" +#include "logger.h" +#include "preprocessorcontrol.h" + +#include <QString> +#include <QFile> +#include <QFileInfo> +#include <QDir> +#include <QByteArray> +#include <QBuffer> +#include <QTextStream> +#include <QCoreApplication> +#include <QLibraryInfo> +#include <QtDebug> + +QT_BEGIN_NAMESPACE + +QString rulesFilePath; +QString applicationDirPath; + +QString findRulesFile(const QString &fileName) +{ + // Check QLibraryInfo::DataPath/filename + QString filePath; + filePath = QDir::cleanPath(QLibraryInfo::location(QLibraryInfo::DataPath) + QLatin1String("/") + fileName) ; + if (QFile::exists(filePath)) + return QFileInfo(filePath).canonicalFilePath(); + + // Check QLibraryInfo::PrefixPath/tools/porting/src/filename + filePath = QDir::cleanPath(QLibraryInfo::location(QLibraryInfo::PrefixPath) + QLatin1String("/tools/porting/src/") + fileName); + if (QFile::exists(filePath)) + return QFileInfo(filePath).canonicalFilePath(); + + //no luck + return QString(); +} + +/* + A option contains an argument and its help text. +*/ +class Option +{ +public: + Option(const QString &argument, const QString &description) + :argument(argument), description(description) {} + + /* + Checks if candidateArgument matches the options argument. + */ + bool checkArgument(const QString &candidateArgument) const + { + return (candidateArgument == argument) || + (candidateArgument.toLower() == argument.toLower()); + } + + QString argument; + QString description; +}; + +typedef QList<Option> OptionList; + +void usage(const OptionList &optionList) +{ + printf("Tool for porting Qt 3 applications to Qt 4, using the compatibility library\n"); + printf("and compatibility functions in the core library.\n"); + printf("Usage: qt3to4 [options] <Infile>, [Infile], ...\n"); + printf("\n"); + printf("Infile can be a source file or a project file.\n"); + printf("If you specify a project file, ending with .pro or .pri,\n"); + printf("qt3to4 will port all files specified in that project.\n"); + printf("\n"); + printf("Options:\n"); + + // Find the length of the longest argument. + int argumentMaxLenght = 0; + foreach (const Option option, optionList) { + if (option.argument.count() > argumentMaxLenght) + argumentMaxLenght = option.argument.count(); + } + + // Print the options, pad with spaces between the argument and description where needed. + const int extraSpaces = 5; + foreach (const Option option, optionList) { + printf("%s", option.argument.toLocal8Bit().constData()); + for (int i = 0; i < argumentMaxLenght - option.argument.count() + extraSpaces; ++i) + printf(" "); + puts(option.description.toLocal8Bit().constData()); + } + + printf("\n"); + printf("The porting documentation contains more information on how\n"); + printf("to use qt3to4 as well as general porting information.\n"); +} + +int runPort(int argc, char**argv) +{ + QCoreApplication app(argc, argv); + applicationDirPath = app.applicationDirPath(); + QString defaultRulesFileName = QLatin1String("q3porting.xml"); + QStringList inFileNames; + QStringList includeSearchDirectories; + bool enableCppParsing = true; + bool useBuildtinQt3Headers = true; + bool showMissingFilesWarnings = false; + bool alwaysOverwrite = false; + int currentArg = 1; + + const Option helpOption(QLatin1String("-h"), QLatin1String("Display this help.")); + const Option rulesFileOption(QLatin1String("-rulesFile"), QLatin1String("Specify the location for the rules file.")); + const Option includeDirectoryOption(QLatin1String("-I"), QLatin1String("Add directory to the list of directories to be searched for header files.")); + const Option disableCppParsingOption(QLatin1String("-disableCppParsing"), QLatin1String("Disable the C++ parsing component.")); + const Option disableBuiltinQt3HeadersOption(QLatin1String("-disableBuiltinQt3Headers"), QLatin1String("Do not use the built-in Qt 3 headers.")); + const Option missingFileWarningsOption(QLatin1String("-missingFileWarnings"), QLatin1String("Warn about files not found while searching for header files.")); + const Option alwaysOverwriteOption(QLatin1String("-alwaysOverwrite"), QLatin1String("Port all files without prompting.")); + const Option strictOption(QLatin1String("-strict"), QLatin1String("Be stricter when selecting which tokens to replace.")); + + const OptionList optionList = OptionList() << helpOption << alwaysOverwriteOption << rulesFileOption + << includeDirectoryOption << disableCppParsingOption + << disableBuiltinQt3HeadersOption << missingFileWarningsOption + << strictOption; + + if (argc == 1) { + usage(optionList); + return 0; + } + + // Read arguments. + while (currentArg < argc) { + QString argText = QLatin1String(argv[currentArg]); + if(argText.isEmpty()) { + continue; + } else if (argText == QLatin1String("--help") || argText == QLatin1String("/h") || argText == QLatin1String("-help") + || argText == QLatin1String("-h") || argText == QLatin1String("-?") || argText == QLatin1String("/?")) { + usage(optionList); + return 0; + } else if (rulesFileOption.checkArgument(argText)) { + ++currentArg; + if (currentArg >= argc) { + printf("You must specify a file name along with %s \n", argText.toLocal8Bit().constData()); + return 0; + } + rulesFilePath = QLatin1String(argv[currentArg]); + + if (!QFile::exists(rulesFilePath)) { + printf("File not found: %s\n", rulesFilePath.toLocal8Bit().constData()); + return 0; + } + } else if (includeDirectoryOption.checkArgument(argText)) { + ++currentArg; + if (currentArg >= argc) { + printf("You must specify a directory name along with %s\n", + argText.toLocal8Bit().constData()); + return 0; + } + includeSearchDirectories += QLatin1String(argv[currentArg]); + } else if (disableCppParsingOption.checkArgument(argText)) { + enableCppParsing = false; + } else if (strictOption.checkArgument(argText)) { + // Enable strict mode, this is used by the ScopedTokenReplacement constructor. + Logger::instance()->globalState.insert(QLatin1String("strictMode"), QLatin1String("")); + } else if (disableBuiltinQt3HeadersOption.checkArgument(argText)) { + useBuildtinQt3Headers = false; + } else if (missingFileWarningsOption.checkArgument(argText)) { + showMissingFilesWarnings = true; + } else if (alwaysOverwriteOption.checkArgument(argText)) { + alwaysOverwrite = true; + FileWriter::instance()->setOverwriteFiles(FileWriter::AlwaysOverWrite); + } else if (argText[0] == QLatin1Char('-')) { + printf("Unknown option %s\n", argText.toLocal8Bit().constData()); + return 0; + } else { + inFileNames.append(argText); + } + ++currentArg; + } + + if (rulesFilePath.isEmpty()) + rulesFilePath = findRulesFile(defaultRulesFileName); + + // Check if we have a rule file. + if (!QFile::exists(rulesFilePath)) { + printf("Error: Could not find the %s rule file: ", defaultRulesFileName.toLocal8Bit().constData()); + printf("Please try specifying the location of the file with the %s option \n", + rulesFileOption.argument.toLocal8Bit().constData()); + return 0; + } + + // Check if we have any infiles + if (inFileNames.isEmpty()) { + printf("You must specify a file name. \n"); + return 0; + } + + // Read rule file and create PortingRules instance. + printf("Using rules file: "); + puts(QDir::toNativeSeparators(rulesFilePath).toLocal8Bit().constData()); + PortingRules::createInstance(rulesFilePath); + + + // Construct a ProjectPorter object add pass it the options. + QStringList builtinQtheaders; + if (useBuildtinQt3Headers) { + builtinQtheaders += QLatin1String(":qt3headers0.resource"); + builtinQtheaders += QLatin1String(":qt3headers1.resource"); + builtinQtheaders += QLatin1String(":qt3headers2.resource"); + builtinQtheaders += QLatin1String(":qt3headers3.resource"); + } + + ProjectPorter porter(QDir::currentPath(), includeSearchDirectories, builtinQtheaders); + porter.enableCppParsing(enableCppParsing); + porter.enableMissingFilesWarnings(showMissingFilesWarnings); + + // Determine mode based on file exstesions and port. + // (The ProjectPorter class is also used for porting single files :) + foreach (QString inFileName, inFileNames) { + const QString canonicalFileName = QFileInfo(inFileName).canonicalFilePath(); + if (QFile::exists(canonicalFileName)) { + if (canonicalFileName.endsWith(QLatin1String(".pro")) || canonicalFileName.endsWith(QLatin1String(".pri"))) + porter.portProject(canonicalFileName); + else + porter.portFile(canonicalFileName); + } else { + printf("File not found: %s \n", QDir::toNativeSeparators(inFileName).toLocal8Bit().constData()); + } + } + + // Write log + if (Logger::instance()->numEntries() > 0) { + QStringList report = Logger::instance()->fullReport(); + QString logFileName = QLatin1String("portinglog.txt"); + printf("Writing log to %s \n", logFileName.toLocal8Bit().constData()); + QByteArray logContents; + QBuffer logBuffer(&logContents); + logBuffer.open(QIODevice::Text | QIODevice::WriteOnly); + QTextStream logStream(&logBuffer); + foreach (QString logLine, report) { + logStream << logLine << endl; + } + logStream << endl; + + QFile logFile(logFileName); + logFile.open(QIODevice::WriteOnly | QIODevice::Append); + logFile.write(logContents); + } + Logger::deleteInstance(); + PortingRules::deleteInstance(); + return 0; +} + +QT_END_NAMESPACE + +int main(int argc, char**argv) +{ + return QT_PREPEND_NAMESPACE(runPort)(argc, argv); +} diff --git a/tools/porting/src/portingrules.cpp b/tools/porting/src/portingrules.cpp new file mode 100644 index 0000000..8e9bcd4 --- /dev/null +++ b/tools/porting/src/portingrules.cpp @@ -0,0 +1,296 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "portingrules.h" +#include "logger.h" +#include "qtsimplexml.h" +#include <QFile> +#include <QFileInfo> +#include <QDir> + +QT_BEGIN_NAMESPACE + +PortingRules *PortingRules::theInstance = 0; + +void PortingRules::createInstance(QString xmlFilePath) +{ + deleteInstance(); + theInstance = new PortingRules(xmlFilePath); +} + +PortingRules *PortingRules::instance() +{ + if(theInstance) { + return theInstance; + } else { + qWarning("Error: must create a PortingRules instance with createInstance() before calling instance()\n"); + return 0; + } +} + +void PortingRules::deleteInstance() +{ + if(theInstance) { + delete theInstance; + theInstance = 0; + } +} + +PortingRules::PortingRules(QString xmlFilePath) +{ + parseXml(xmlFilePath); +} + +QList<TokenReplacement*> PortingRules::getTokenReplacementRules() +{ + if(tokenRules.isEmpty()) + addLogWarning(QLatin1String("Warning: token rules list is empty")); + return tokenRules; +} + +QStringList PortingRules::getHeaderList(QtVersion qtVersion) +{ + if(qt3Headers.isEmpty() || qt4Headers.isEmpty()) + addLogWarning(QLatin1String("Warning: headers list is empty")); + + if (qtVersion==Qt3) + return qt3Headers; + else //Qt4 + return qt4Headers; +} + +QHash<QByteArray, QByteArray> PortingRules::getNeededHeaders() +{ + if(neededHeaders.isEmpty()) + addLogWarning(QLatin1String("Warning: needed headers list is empty")); + return neededHeaders; +} + +QStringList PortingRules::getInheritsQt() +{ + if(tokenRules.isEmpty()) + addLogWarning(QLatin1String("Warning: inheritsQtClass list is empty")); + return inheritsQtClass; +} + +QHash<QByteArray, QByteArray> PortingRules::getClassLibraryList() +{ + if(classLibraryList.isEmpty()) + addLogWarning(QLatin1String("Warning: classLibraryList list is empty")); + return classLibraryList; +} + +QHash<QByteArray, QByteArray> PortingRules::getHeaderReplacements() +{ + return headerReplacements; +} + +/* + Loads rule xml file given by fileName, and sets up data structures. + The rules can generally be divided into to types, replacement rules and + info rules. + + Replacement rules has the form Qt3Symobl -> Qt4Symbol + Info rules includes the NeedHeader, Qt3Header, Qt4Header, InhertitsQt + rule types. +*/ +void PortingRules::parseXml(QString fileName) +{ + QtSimpleXml *xmlPointer = loadXml(fileName); + QtSimpleXml &xml = *xmlPointer; + + int ruleCount = xml[QLatin1String("Rules")].numChildren(); + ++ruleCount; + + for(int rule=0; rule<ruleCount; ++rule) { + QtSimpleXml ¤tRule = xml[QLatin1String("Rules")][rule]; + QString ruleType = currentRule.attribute(QLatin1String("Type")); + + if(isReplacementRule(ruleType)) { + QString qt3Symbol = currentRule[QLatin1String("Qt3")].text(); + QString qt4Symbol = currentRule[QLatin1String("Qt4")].text(); + + QString disable = currentRule.attribute(QLatin1String("Disable")); + if(disable == QLatin1String("True") || disable == QLatin1String("true")) { + disableRule(currentRule); + continue; + } + + if (isRuleDisabled(currentRule)) + continue; + + if(ruleType == QLatin1String("RenamedHeader")) { + headerReplacements.insert(qt3Symbol.toLatin1(), qt4Symbol.toLatin1()); + } else if(ruleType == QLatin1String("RenamedClass") || ruleType == QLatin1String("RenamedToken") ) { + tokenRules.append(new ClassNameReplacement( + qt3Symbol.toLatin1(), qt4Symbol.toLatin1())); + } else if(ruleType == QLatin1String("RenamedEnumvalue") || ruleType == QLatin1String("RenamedType") || + ruleType == QLatin1String("RenamedQtSymbol") ) { + checkScopeAddRule(currentRule); + } + } else if(ruleType == QLatin1String("NeedHeader")) { + const QByteArray className = currentRule[QLatin1String("Class")].text().toLatin1(); + const QByteArray headerName = currentRule[QLatin1String("Header")].text().toLatin1(); + neededHeaders.insert(className, headerName); + } + else if(ruleType == QLatin1String("qt3Header")) { + qt3Headers += currentRule.text(); + } + else if(ruleType == QLatin1String("qt4Header")) { + qt4Headers += currentRule.text(); + } + else if(ruleType == QLatin1String("InheritsQt")) { + inheritsQtClass += currentRule.text(); + } + else if(ruleType == QLatin1String("Qt4Class")) { + // Get library name, make it lowercase and chop of the "Qt" prefix. + const QByteArray libraryName = currentRule[QLatin1String("Library")].text().toLatin1().toLower().mid(2); + classLibraryList.insert(currentRule[QLatin1String("Name")].text().toLatin1(), libraryName); + } + } + + QString includeFile = xml[QLatin1String("Rules")][QLatin1String("Include")].text(); + + if(!includeFile.isNull()) { + QString resolvedIncludeFile = resolveFileName(fileName, includeFile); + if (!resolvedIncludeFile.isEmpty()) + parseXml(resolvedIncludeFile); + } + + delete xmlPointer; +} + +/* + Check if the rule in currentRule describes a qualified name + (like QButton::ToggleState). If so, create a scoped ScopedTokenReplacement, + else create a GenericTokenReplacement +*/ +void PortingRules::checkScopeAddRule(/*const */QtSimpleXml ¤tRule) +{ + QByteArray oldToken = currentRule[QLatin1String("Qt3")].text().toLatin1(); + QByteArray newToken = currentRule[QLatin1String("Qt4")].text().toLatin1(); + + if (oldToken.contains(QByteArray("::"))) + tokenRules.append(new ScopedTokenReplacement(oldToken, newToken)); + else + tokenRules.append(new GenericTokenReplacement(oldToken, newToken)); +} + +/* + Loads the xml-file given by fileName into a new'ed QtSimpleXml, which is + returned by pointer. +*/ +QtSimpleXml *PortingRules::loadXml(const QString fileName) const +{ + QFile f(fileName); + if(!f.open(QIODevice::ReadOnly)) { + qFatal("Could not find rule file %s", fileName.toLatin1().constData()); + } + QtSimpleXml *xml = new QtSimpleXml(); + if(!xml->setContent(&f)) + addLogError(QLatin1String("Xml parsing failed: ") + xml->errorString()); + + return xml; +} + +/* + Resolves includeFilePath against currentFilePath. If currentFilePath + contains foo/bar.xml, and includeFilePath contains bar2.xml, the returned + result will be foo/bar2.xml. If includeFilePath is absolute, it is returned + unmodified. +*/ +QString PortingRules::resolveFileName(const QString currentFilePath, + const QString includeFilePath) const +{ + if(QFileInfo(includeFilePath).isAbsolute()) + return includeFilePath; + QString relativeDirectory = QFileInfo(currentFilePath).dir().dirName(); + QString testFileName = relativeDirectory + QLatin1String("/") + includeFilePath; + if (QFile::exists(testFileName)) + return testFileName; + + return QString(); +} +/* + Checks if a rule is a replacement rule. +*/ +bool PortingRules::isReplacementRule(const QString ruleType) const +{ + return (ruleType == QLatin1String("RenamedHeader") || ruleType == QLatin1String("RenamedClass") || + ruleType == QLatin1String("RenamedToken") || ruleType == QLatin1String("RenamedEnumvalue") || + ruleType == QLatin1String("RenamedType") || ruleType == QLatin1String("RenamedQtSymbol") ); +} + +/* + Disables a replacement rule given by the replacementRule parameter +*/ +void PortingRules::disableRule(QtSimpleXml &replacementRule) +{ + RuleDescription ruleDescription(replacementRule); + disabledRules.append(ruleDescription); +} + +/* + Checks if a replacement rule is disabled or not +*/ +bool PortingRules::isRuleDisabled(QtSimpleXml &replacementRule) const +{ + RuleDescription ruleDescription(replacementRule); + return disabledRules.contains(ruleDescription); +} + +/* + Adds a warning to the global logger. +*/ +void PortingRules::addLogWarning(const QString text) const +{ + Logger::instance()->addEntry(new PlainLogEntry(QLatin1String("Warning"), QLatin1String("Porting"), text)); +} + +/* + Adds an error to the global logger. +*/ +void PortingRules::addLogError(const QString text) const +{ + Logger::instance()->addEntry(new PlainLogEntry(QLatin1String("Error"), QLatin1String("Porting"), text)); +} + +QT_END_NAMESPACE diff --git a/tools/porting/src/portingrules.h b/tools/porting/src/portingrules.h new file mode 100644 index 0000000..2f8c83e --- /dev/null +++ b/tools/porting/src/portingrules.h @@ -0,0 +1,114 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef PORTINGRULES_H +#define PORTINGRULES_H + +#include "qtsimplexml.h" +#include "tokenreplacements.h" +#include <QList> +#include <QPair> +#include <QHash> +#include <QSet> +#include <QStringList> + +QT_BEGIN_NAMESPACE + +class RuleDescription +{ +public: + explicit RuleDescription(QtSimpleXml &replacementRule) { + qt3 = replacementRule[QLatin1String("Qt3")].text(); + qt4 = replacementRule[QLatin1String("Qt4")].text(); + ruleType = replacementRule.attribute(QLatin1String("Type")); + } + QString qt3; + QString qt4; + QString ruleType; + bool operator==(const RuleDescription &other) const + { + return (qt3 == other.qt3 && qt4 == other.qt4 && ruleType == other.ruleType); + } +}; + +class PortingRules +{ +public: + static void createInstance(QString xmlFilePath); + static PortingRules *instance(); + static void deleteInstance(); + + enum QtVersion{Qt3, Qt4}; + PortingRules(QString xmlFilePath); + QList<TokenReplacement*> getTokenReplacementRules(); + QStringList getHeaderList(QtVersion qtVersion); + QHash<QByteArray, QByteArray> getNeededHeaders(); + QStringList getInheritsQt(); + QHash<QByteArray, QByteArray> getClassLibraryList(); + QHash<QByteArray, QByteArray> getHeaderReplacements(); +private: + static PortingRules *theInstance; + + QList<TokenReplacement*> tokenRules; + QStringList qt3Headers; + QStringList qt4Headers; + QHash<QByteArray, QByteArray> neededHeaders; + QStringList inheritsQtClass; + QList<RuleDescription> disabledRules; + QHash<QByteArray, QByteArray> classLibraryList; + QHash<QByteArray, QByteArray> headerReplacements; + + + void parseXml(const QString fileName); + void checkScopeAddRule(/*const */QtSimpleXml ¤tRule); + QtSimpleXml *loadXml(const QString fileName) const ; + QString resolveFileName(const QString currentFileName, + const QString includeFileName) const; + bool isReplacementRule(const QString ruleType) const; + void disableRule(QtSimpleXml &replacementRule); + bool isRuleDisabled(QtSimpleXml &replacementRule) const; + void addLogWarning(const QString text) const; + void addLogError(const QString text) const; +}; + +QT_END_NAMESPACE + +#endif // PORTINGRULES_H diff --git a/tools/porting/src/preprocessorcontrol.cpp b/tools/porting/src/preprocessorcontrol.cpp new file mode 100644 index 0000000..0691de4 --- /dev/null +++ b/tools/porting/src/preprocessorcontrol.cpp @@ -0,0 +1,430 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "preprocessorcontrol.h" +#include <QDir> +#include <QFile> +#include <QFileInfo> +#include <QTemporaryFile> + +QT_BEGIN_NAMESPACE +using namespace TokenEngine; +using namespace Rpp; + +IncludeFiles::IncludeFiles(const QString &basePath, const QStringList &searchPaths) +:m_basePath(basePath) +{ + //prepend basePath to all relative paths in searchPaths + foreach (QString path, searchPaths) { + QString finalPath; + if (QDir::isAbsolutePath(path)) + finalPath = QDir::cleanPath(path); + else + finalPath = QDir::cleanPath(m_basePath + QLatin1String("/") + path); + + if(QFile::exists(finalPath)) + m_searchPaths.append(finalPath); + } +} + +/* + Performs an #include "..." style file lookup. + Aboslute filenames are checked directly. Relative filenames are first + looked for relative to the current file path, then the includepaths + are searched if not found. +*/ +QString IncludeFiles::quoteLookup(const QString ¤tFile, + const QString &includeFile) const +{ + //if includeFile is absolute, check if it exists + if (QDir::isAbsolutePath(includeFile)) { + if(QFile::exists(includeFile)) + return includeFile; + else + return QString(); + } + + //If currentFile is not an absolute file path, make it one by + //prepending m_baspath + QString currentFilePath; + if(QDir::isAbsolutePath(currentFile)) + currentFilePath = currentFile; + else + currentFilePath = QDir::cleanPath(m_basePath + QLatin1String("/") + currentFile); + + //Check if it includeFile exists in the same dir as currentFilePath + const QString currentPath = QFileInfo(currentFilePath).path(); + QString localFile = QDir::cleanPath(currentPath + QLatin1String("/") + includeFile); + if(QFile::exists(localFile)) + return localFile; + + return searchIncludePaths(includeFile); +} + +/* + Performs an #include <...> style file lookup. + Aboslute filenames are checked directly. + Relative paths are searched for in the includepaths. +*/ +QString IncludeFiles::angleBracketLookup(const QString &includeFile) const +{ + //if includeFile is absolute, check if it exists + if (QDir::isAbsolutePath(includeFile)) { + if(QFile::exists(includeFile)) + return includeFile; + else + return QString(); + } + + return searchIncludePaths(includeFile); +} + +QString IncludeFiles::resolve(const QString &filename) const +{ + if(QDir::isAbsolutePath(filename)) + return filename; + + QString prepended = QDir::cleanPath(m_basePath + QLatin1String("/") + filename); + if(QFile::exists(prepended)) + return prepended; + else + return QString(); +} + + +/* + Searches for includeFile paths by appending it to all includePaths + and checking if the file exists. Returns QString() if the file is not + found. +*/ +QString IncludeFiles::searchIncludePaths(const QString &includeFile) const +{ + QString foundFile; + foreach(QString includePath, m_searchPaths) { + QString testFile = includePath + QLatin1String("/") + includeFile; + if(QFile::exists(testFile)){ + foundFile = testFile; + break; + } + } + return foundFile; +} + +QByteArray PreprocessorCache::readFile(const QString &filename) const +{ + // If anybody is connected to the readFile signal we tell them to + // read the file for us. + if (receivers(SIGNAL(readFile(QByteArray&,QString))) > 0) { + QByteArray array; + // Workaround for "not being able to emit from const function" + PreprocessorCache *cache = const_cast<PreprocessorCache *>(this); + emit cache->readFile(array, filename); + return array; + } + + QFile f(filename); + if (!f.exists()) + return QByteArray(); + f.open(QIODevice::ReadOnly); + if (!f.isOpen()) + return QByteArray(); + return f.readAll(); +} + +PreprocessorCache::PreprocessorCache() +{ + connect(&m_preprocessor, SIGNAL(error(QString,QString)), + this, SIGNAL(error(QString,QString))); +} + + +/* + Return a TokenSequence with the contents of filname. + Assumens filename exists and is readable, returns a empty + TokenSequence if not. + + The result is cached. +*/ +TokenContainer PreprocessorCache::sourceTokens(const QString &filename) +{ + // Check if the source tokens are already in the cache. + if(m_sourceTokens.contains(filename)) + return m_sourceTokens.value(filename); + + // Read and tokenize file. + QByteArray fileContents = readFile(filename); + if(fileContents == QByteArray()) + return TokenContainer(); + + QVector<TokenEngine::Token> tokenList = m_tokenizer.tokenize(fileContents); + + // Create a FileInfo object that holds the filename for this container. + FileInfo *containterFileInfo = new FileInfo; + containterFileInfo->filename = filename; + + // Create container. + TokenContainer tokenContainer(fileContents, tokenList, containterFileInfo); + + // Insert into cache. + m_sourceTokens.insert(filename, tokenContainer); + return tokenContainer; +} + +/* + Return a Source* tree representing the contents of filename. + Assumens filename exists and is readable, returns a empty + Source object if not. + + The result is cached. +*/ +Source *PreprocessorCache::sourceTree(const QString &filename) +{ + // Check if the Rpp tree for this file is already in the cache. + if(m_sourceTrees.contains(filename)) + return m_sourceTrees.value(filename); + + // Get the tokens for the contents of this file. + TokenContainer tokenContainer = sourceTokens(filename); + + // Run lexer and the preprocessor-parser. + QVector<Type> tokenTypes = m_lexer.lex(tokenContainer); + Source *source = m_preprocessor.parse(tokenContainer, tokenTypes, &m_memoryPool); + source->setFileName(filename); + + // Insert into cache. + if(tokenContainer.count() > 0) //don't cache empty files. + m_sourceTrees.insert(filename, source); + + return source; +} + + +/* + Returns whether the cache contains a TokenContainer for the given filename. +*/ +bool PreprocessorCache::containsSourceTokens(const QString &filename) +{ + return m_sourceTokens.contains(filename); +} + +/* + Returns whether the cache contains a Preprocessor tree for the given filename. +*/ +bool PreprocessorCache::containsSourceTree(const QString &filename) +{ + return m_sourceTrees.contains(filename); +} + +PreprocessorController::PreprocessorController(IncludeFiles includeFiles, + PreprocessorCache &preprocessorCache, + QStringList preLoadFilesFilenames) +:m_includeFiles(includeFiles), + m_preprocessorCache(preprocessorCache) + { + // Load qt3 headers from resources. The headers are stored as + // QHash<QString, QByteArray>, serialized using QDataStream. The hash + // maps filename -> contents. + if (preLoadFilesFilenames != QStringList()) { + foreach (QString filename, preLoadFilesFilenames) { + QFile f(filename); + if (f.open(QIODevice::ReadOnly)) { + QByteArray buffer = f.readAll(); + f.close(); + QDataStream stream(buffer); + QHash<QString, QByteArray> files; + stream >> files; + m_preLoadFiles.unite(files); + } + } + } + + //connect include callback + connect(&m_rppTreeEvaluator, + SIGNAL(includeCallback(Rpp::Source *&, const Rpp::Source *, + const QString &, Rpp::RppTreeEvaluator::IncludeType)), + SLOT(includeSlot(Rpp::Source *&, const Rpp::Source *, + const QString &, Rpp::RppTreeEvaluator::IncludeType))); + + // connect readFile callback + connect(&m_preprocessorCache, SIGNAL(readFile(QByteArray&,QString)), + SLOT(readFile(QByteArray&,QString))); + + //connect error handlers + connect(&m_preprocessorCache , SIGNAL(error(QString,QString)), + this, SIGNAL(error(QString,QString))); +} + +/* + Callback from RppTreeEvaluator, called when we evaluate an #include + directive. We do a filename lookup based on the type of include, and then ask + the cache to give us the source tree for that file. +*/ +void PreprocessorController::includeSlot(Source *&includee, + const Source *includer, + const QString &filename, + RppTreeEvaluator::IncludeType includeType) +{ + QString newFilename; + if(includeType == RppTreeEvaluator::QuoteInclude) + newFilename = m_includeFiles.quoteLookup(includer->fileName(), filename); + else //AngleBracketInclude + newFilename = m_includeFiles.angleBracketLookup(filename); + + if (QFile::exists(newFilename)) { + includee = m_preprocessorCache.sourceTree(newFilename); + return; + } + + if (m_preLoadFiles.contains(filename)) { + includee = m_preprocessorCache.sourceTree(filename); + return; + } + + includee = m_preprocessorCache.sourceTree(newFilename); + emit error(QLatin1String("Error"), QLatin1String("Could not find file ") + filename); +} + +/* + Callback connected to preprocessorCache. Tries to load a file from + m_preLoadFiles before going to disk. +*/ +void PreprocessorController::readFile(QByteArray &contents, QString filename) +{ + if (m_preLoadFiles.contains(filename)) { + contents = m_preLoadFiles.value(filename); + return; + } + + QFile f(filename); + if (!f.exists()) + return; + f.open(QIODevice::ReadOnly); + if (!f.isOpen()) + return; + contents = f.readAll(); +} + +/* + Preprocess file give by filename. Filename is resloved agains the basepath + set in IncludeFiles. +*/ +TokenSectionSequence PreprocessorController::evaluate(const QString &filename, Rpp::DefineMap *activedefinitions) +{ + QString resolvedFilename = m_includeFiles.resolve(filename); + if(!QFile::exists(resolvedFilename)) + emit error(QLatin1String("Error"), QLatin1String("Could not find file: ") + filename); + Source *source = m_preprocessorCache.sourceTree(resolvedFilename); + + return m_rppTreeEvaluator.evaluate(source, activedefinitions); +} + +QByteArray defaultDefines = + "#define __attribute__(a...) \n \ + #define __attribute__ \n \ + #define __extension \n \ + #define __extension__ \n \ + #define __restrict \n \ + #define __restrict__ \n \ + #define __volatile volatile\n \ + #define __volatile__ volatile\n \ + #define __inline inline\n \ + #define __inline__ inline\n \ + #define __const const\n \ + #define __const__ const\n \ + #define __asm asm\n \ + #define __asm__ asm\n \ + #define __GNUC__ 2\n \ + #define __GNUC_MINOR__ 95\n \ + #define __cplusplus \n \ + #define __linux__ \n"; + + +/* + Returns a DefineMap containing the above macro definitions. The DefineMap + will contain pointers to data stored in the provided cache object. +*/ +Rpp::DefineMap *defaultMacros(PreprocessorCache &cache) +{ + DefineMap *defineMap = new DefineMap(); + //write out default macros to a temp file + QTemporaryFile tempfile; + tempfile.open(); + tempfile.write(defaultDefines); + tempfile.flush(); + + IncludeFiles *includeFiles = new IncludeFiles(QString(), QStringList()); + PreprocessorController preprocessorController(*includeFiles, cache); + //evaluate default macro file. + preprocessorController.evaluate(tempfile.fileName(), defineMap); + delete includeFiles; + return defineMap; +} + +void StandardOutErrorHandler::error(QString type, QString text) +{ + Q_UNUSED(type); + puts(qPrintable(text)); +} + +/* + RppPreprocessor is a convenience class that contains all the components + needed to preprocess files. Error messages are printed to standard out. +*/ +RppPreprocessor::RppPreprocessor(QString basePath, QStringList includePaths, QStringList preLoadFilesFilenames) +:m_includeFiles(basePath, includePaths) +,m_activeDefinitions(defaultMacros(m_cache)) +,m_controller(m_includeFiles, m_cache, preLoadFilesFilenames) +{ + QObject::connect(&m_controller, SIGNAL(error(QString,QString)), &m_errorHandler, SLOT(error(QString,QString))); +} + +RppPreprocessor::~RppPreprocessor() +{ + delete m_activeDefinitions; +} + +TokenEngine::TokenSectionSequence RppPreprocessor::evaluate(const QString &filename) +{ + DefineMap defMap = *m_activeDefinitions; + return m_controller.evaluate(filename, &defMap); +} + +QT_END_NAMESPACE diff --git a/tools/porting/src/preprocessorcontrol.h b/tools/porting/src/preprocessorcontrol.h new file mode 100644 index 0000000..bceed19 --- /dev/null +++ b/tools/porting/src/preprocessorcontrol.h @@ -0,0 +1,139 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef PREPROCESSORCONTROL_H +#define PREPROCESSORCONTROL_H + +#include "tokenengine.h" +#include "tokenizer.h" +#include "rpplexer.h" +#include "rpptreeevaluator.h" +#include "rpp.h" +#include <QString> +#include <QStringList> +#include <QHash> + +QT_BEGIN_NAMESPACE + +class IncludeFiles +{ +public: + IncludeFiles(const QString &basePath, const QStringList &searchPaths); + QString quoteLookup(const QString ¤tFile, + const QString &includeFile)const; + QString angleBracketLookup(const QString &includeFile) const; + QString resolve(const QString &filename) const; +private: + QString searchIncludePaths(const QString &includeFile)const; + QStringList m_searchPaths; + QString m_basePath; +}; + +class PreprocessorCache: public QObject +{ +Q_OBJECT +public: + PreprocessorCache(); + TokenEngine::TokenContainer sourceTokens(const QString &filename); + Rpp::Source *sourceTree(const QString &filename); + bool containsSourceTokens(const QString &filename); + bool containsSourceTree(const QString &filename); +signals: + void error(QString type, QString text); + void readFile(QByteArray &contents, QString filename); +private: + QByteArray readFile(const QString & filename) const; + Tokenizer m_tokenizer; + Rpp::RppLexer m_lexer; + Rpp::Preprocessor m_preprocessor; + TypedPool<Rpp::Item> m_memoryPool; + QHash<QString, Rpp::Source *> m_sourceTrees; + QHash<QString, TokenEngine::TokenContainer> m_sourceTokens; +}; + +class PreprocessorController: public QObject +{ +Q_OBJECT +public: + PreprocessorController(IncludeFiles includefiles, + PreprocessorCache &preprocessorCache, + QStringList preLoadFilesFilenames = QStringList()); + + TokenEngine::TokenSectionSequence evaluate(const QString &filename, Rpp::DefineMap *activedefinitions); +public slots: + void includeSlot(Rpp::Source *&includee, const Rpp::Source *includer, + const QString &filename, Rpp::RppTreeEvaluator::IncludeType includeType); + void readFile(QByteArray &contents, QString filename); +signals: + void error(QString type, QString text); +private: + IncludeFiles m_includeFiles; + Rpp::RppTreeEvaluator m_rppTreeEvaluator; + PreprocessorCache &m_preprocessorCache; + QHash<QString, QByteArray> m_preLoadFiles; +}; + +Rpp::DefineMap *defaultMacros(PreprocessorCache &preprocessorCache); + +class StandardOutErrorHandler : public QObject +{ +Q_OBJECT +public slots: + void error(QString type, QString text); +}; + +class RppPreprocessor +{ +public: + RppPreprocessor(QString basePath, QStringList includePaths, QStringList preLoadFilesFilename = QStringList()); + ~RppPreprocessor(); + TokenEngine::TokenSectionSequence evaluate(const QString &filename); +private: + IncludeFiles m_includeFiles; + PreprocessorCache m_cache; + Rpp::DefineMap *m_activeDefinitions; + PreprocessorController m_controller; + StandardOutErrorHandler m_errorHandler; +}; + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/projectporter.cpp b/tools/porting/src/projectporter.cpp new file mode 100644 index 0000000..5b980b9 --- /dev/null +++ b/tools/porting/src/projectporter.cpp @@ -0,0 +1,414 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "projectporter.h" +#include "proparser.h" +#include "textreplacement.h" +#include "fileporter.h" +#include "logger.h" +#include "translationunit.h" +#include "codemodelattributes.h" +#include <QtDebug> +#include <QFile> +#include <QDir> +#include <QStringList> +#include <QFileInfo> +#include <QBuffer> + +QT_BEGIN_NAMESPACE + +using namespace TokenEngine; + +ProjectPorter::ProjectPorter(QString basePath, QStringList includeDirectories, QStringList qt3HeadersFilenames) +:basePath(basePath) +,includeDirectories(includeDirectories) +,defaultDefinitions(defaultMacros(preprocessorCache)) +,filePorter(preprocessorCache) +,qt3HeadersFilenames(qt3HeadersFilenames) +,analyze(true) +,warnings(false) +{} + +void ProjectPorter::enableCppParsing(bool enable) +{ + analyze = enable; +} + +void ProjectPorter::enableMissingFilesWarnings(bool enable) +{ + warnings = enable; +} + +void ProjectPorter::portProject(QString fileName) +{ + QFileInfo fileInfo(fileName); + portProject(fileInfo.path(), fileInfo.fileName()); +} + +/* + Port a single file +*/ +void ProjectPorter::portFile(QString fileName) +{ + if (analyze) { + IncludeFiles includeFiles(basePath, includeDirectories); + + PreprocessorController preprocessor(includeFiles, preprocessorCache, qt3HeadersFilenames); + connect(&preprocessor, SIGNAL(error(QString,QString)), SLOT(error(QString,QString))); + + Rpp::DefineMap definitionsCopy = *defaultDefinitions; + // Preprocess + TokenSectionSequence translationUnit = preprocessor.evaluate(fileName, &definitionsCopy); + // Parse + TranslationUnit translationUnitData = TranslationUnitAnalyzer().analyze(translationUnit); + + // Enable attribute generation for this file. + enableAttributes(includeFiles, fileName); + // Generate attributes. + CodeModelAttributes().createAttributes(translationUnitData); + } + + portFiles(QString(), QStringList() << fileName); +} + +void ProjectPorter::error(QString type, QString text) +{ + if (warnings && type == QLatin1String("Error")) + printf("Warning: %s\n", text.toLocal8Bit().constData()); +} + +void ProjectPorter::portProject(QString basePath, QString proFileName) +{ + QString fullInFileName = basePath + QLatin1String("/") + proFileName; + QFileInfo infileInfo(fullInFileName); + if (!infileInfo.exists()) { + printf("Could not open file: %s\n", QDir::toNativeSeparators(fullInFileName).toLocal8Bit().constData()); + return; + } + + QString proFileContents = loadFile(fullInFileName); + QMap<QString, QString> proFileMap = proFileTagMap(proFileContents, QDir(basePath).absolutePath()); + + + // Check if this is a TEMPLATE = subdirs .pro file, in that case we + // process each subdir (recursively). + + QString templateTag = proFileMap[QLatin1String("TEMPLATE")]; + if (templateTag == QLatin1String("subdirs")) { + QStringList subdirs = proFileMap[QLatin1String("SUBDIRS")].split(QLatin1String(" "), QString::SkipEmptyParts); + foreach(QString subdir, subdirs) { + QString newBasePath = basePath + QLatin1String("/") + subdir; + QStringList dirsInSubdir = subdir.split(QRegExp(QLatin1String("/|\\\\")), QString::SkipEmptyParts); + QString newProFileName = dirsInSubdir.last() + QLatin1String(".pro"); + portProject(newBasePath, newProFileName); + } + return; + } + + // Get headers and sources file names from .pro file. + QStringList sources = proFileMap[QLatin1String("SOURCES")].split(QLatin1String(" "), QString::SkipEmptyParts); + QStringList headers = proFileMap[QLatin1String("HEADERS")].split(QLatin1String(" "), QString::SkipEmptyParts); + QStringList forms = proFileMap[QLatin1String("FORMS")].split(QLatin1String(" "), QString::SkipEmptyParts); + QStringList uidoth; + for (int i = 0; i < forms.size(); ++i) { + QString ui_h = forms.at(i) + QLatin1String(".h"); + if (QFile::exists(basePath + QLatin1String("/") + ui_h)) + uidoth += ui_h; + } + + if (analyze) { + printf("Parsing"); + // Get include paths from the pro file. + QStringList includeProPaths = proFileMap[QLatin1String("INCLUDEPATH")].split(QLatin1String(" "), QString::SkipEmptyParts); + QStringList dependProPaths = proFileMap[QLatin1String("DEPENDPATH")].split(QLatin1String(" "), QString::SkipEmptyParts); + IncludeFiles includeFiles(basePath, includeDirectories + includeProPaths + dependProPaths); + + PreprocessorController preprocessorController(includeFiles, preprocessorCache, qt3HeadersFilenames); + connect(&preprocessorController, SIGNAL(error(QString,QString)), SLOT(error(QString,QString))); + + TranslationUnitAnalyzer translationUnitAnalyzer; + CodeModelAttributes codeModelAttributes; + + // Enable attribute generation for header files. + foreach(QString headerFile, headers) + enableAttributes(includeFiles, headerFile); + + // Enable attribute generation for ui.h files. + foreach(QString headerFile, uidoth) + enableAttributes(includeFiles, headerFile); + + // Analyze each translation unit. (one per cpp file) + foreach(QString sourceFile, sources) { + printf("."); + fflush(stdout); + Rpp::DefineMap definitionsCopy = *defaultDefinitions; + TokenSectionSequence translationUnit = + preprocessorController.evaluate(sourceFile, &definitionsCopy); + TranslationUnit translationUnitData = + translationUnitAnalyzer.analyze(translationUnit); + + // Enable attribute generation for this file. + enableAttributes(includeFiles, sourceFile); + + codeModelAttributes.createAttributes(translationUnitData); + } + puts(""); + } + + + // Port files. + portFiles(basePath, sources); + portFiles(basePath, headers); + if (!uidoth.isEmpty()) + portFiles(basePath, uidoth); + + Logger::instance()->globalState[QLatin1String("currentFileName")] = proFileName; + Logger::instance()->beginSection(); + portProFile(fullInFileName, proFileMap); +} + +/* + Port each file given in the fileNames list. If a file name is relative + it is assumed to be relative to basePath. +*/ +void ProjectPorter::portFiles(QString basePath, QStringList fileNames) +{ + foreach(QString fileName, fileNames) { + QString fullFilePath; + QFileInfo fileInfo(fileName); + if (fileInfo.isAbsolute()) { + fullFilePath = QDir::cleanPath(fileName); + } else { + fullFilePath = QDir::cleanPath(basePath + QLatin1String("/") + fileName); + } + + QFileInfo fullFilePathInfo(fullFilePath); + if (!fullFilePathInfo.exists()) { + printf("Could not find file: %s\n", QDir::toNativeSeparators(fullFilePath).toLocal8Bit().constData()); + continue; + } + + if (!processedFilesSet.contains(fullFilePath)){ + Logger::instance()->globalState[QLatin1String("currentFileName")] = fullFilePath; + filePorter.port(fullFilePath); + processedFilesSet.insert(fullFilePath); + } + } +} + +void ProjectPorter::portProFile(QString fileName, QMap<QString, QString> tagMap) +{ + // Read pro file. + QFile proFile(fileName); + if (!proFile.open(QIODevice::ReadOnly)) + return; + + const QByteArray contents = proFile.readAll(); + const QByteArray lineEnding = detectLineEndings(contents); + proFile.seek(0); + + QTextStream proTextStream(&proFile); + QStringList lines; + while (!proTextStream.atEnd()) + lines += proTextStream.readLine(); + + proFile.close(); + + // Find out what modules we should add to the QT variable. + QSet<QByteArray> qtModules; + + // Add qt3support to the Qt tag + qtModules.insert(QByteArray("qt3support")); + + // Read CONFIG and add other modules. + QStringList config = tagMap[QLatin1String("CONFIG")].split(QLatin1String(" "), QString::SkipEmptyParts); + if (config.contains(QLatin1String("opengl"))) + qtModules.insert(QByteArray("opengl")); + if (config.contains(QLatin1String("xml"))) + qtModules.insert(QByteArray("xml")); + if (config.contains(QLatin1String("sql"))) + qtModules.insert(QByteArray("sql")); + if (config.contains(QLatin1String("network"))) + qtModules.insert(QByteArray("network")); + + // Get set of used modules from the file porter. + qtModules += filePorter.usedQtModules(); + + // Remove gui and core. + qtModules.remove(QByteArray("gui")); + qtModules.remove(QByteArray("core")); + + // Qt3Support is already added. + qtModules.remove(QByteArray("3support")); + + // Remove modules already present in the QT variable. + QStringList qt = tagMap[QLatin1String("QT")].split(QLatin1String(" "), QString::SkipEmptyParts); + foreach(QString name, qt) { + qtModules.remove(name.toLatin1()); + } + + Logger *logger = Logger::instance(); + bool changesMade = false; + + if (!qtModules.isEmpty()) { + changesMade = true; + QString insertText = QLatin1String("QT += "); + foreach(QByteArray module, qtModules) { + insertText += QString::fromLatin1(module) + QLatin1Char(' '); + } + lines += QString(QLatin1String("#The following line was inserted by qt3to4")); + lines += insertText; + QString logText = QLatin1String("In file ") + + logger->globalState.value(QLatin1String("currentFileName")) + + QLatin1String(": Added entry ") + + insertText; + logger->addEntry(new PlainLogEntry(QLatin1String("Info"), QLatin1String("Porting"), logText)); + } + + // Add uic3 if we have forms, and change FORMS and INTERFACES to FORMS3 + if (!tagMap[QLatin1String("FORMS")].isEmpty() || !tagMap[QLatin1String("INTERFACES")].isEmpty()) { + changesMade = true; + lines += QString(QLatin1String("#The following line was inserted by qt3to4")); + QString insertText = QLatin1String("CONFIG += uic3") + QString::fromLatin1(lineEnding.constData()); + lines += insertText; + QString logText = QLatin1String("In file ") + + logger->globalState.value(QLatin1String("currentFileName")) + + QLatin1String(": Added entry ") + + insertText; + logger->addEntry(new PlainLogEntry(QLatin1String("Info"), QLatin1String("Porting"), logText)); + + const QString formsToForms3(QLatin1String("#The following line was changed from FORMS to FORMS3 by qt3to4")); + const QString interfacesToForms3(QLatin1String("#The following line was changed from INTERFACES to FORMS3 by qt3to4")); + for (int i = 0; i < lines.count(); ++i) { + QString cLine = lines.at(i); + cLine = cLine.trimmed(); + if (cLine.startsWith(QLatin1String("FORMS"))) { + lines[i].replace(QLatin1String("FORMS"), QLatin1String("FORMS3")); + lines.insert(i, formsToForms3); + ++i; + QString logText = QLatin1String("In file ") + + logger->globalState.value(QLatin1String("currentFileName")) + + QLatin1String(": Renamed FORMS to FORMS3"); + logger->addEntry(new PlainLogEntry(QLatin1String("Info"), QLatin1String("Porting"), logText)); + } else if (cLine.startsWith(QLatin1String("INTERFACES"))) { + lines[i].replace(QLatin1String("INTERFACES"), QLatin1String("FORMS3")); + lines.insert(i, interfacesToForms3); + ++i; + QString logText = QLatin1String("In file ") + + logger->globalState.value(QLatin1String("currentFileName")) + + QLatin1String(": Renamed INTERFACES to FORMS3"); + logger->addEntry(new PlainLogEntry(QLatin1String("Info"), QLatin1String("Porting"), logText)); + } + } + } + + // Comment out any REQUIRES tag. + if (!tagMap[QLatin1String("REQUIRES")].isEmpty()) { + changesMade = true; + QString insertText(QLatin1String("#The following line was commented out by qt3to4")); + for (int i = 0; i < lines.count(); ++i) { + if (lines.at(i).startsWith(QLatin1String("REQUIRES"))) { + QString lineCopy = lines.at(i); + lineCopy.prepend(QLatin1Char('#')); + lines[i] = lineCopy; + lines.insert(i, insertText); + ++i; //skip ahead, we just insertet a line at i. + QString logText = QLatin1String("In file ") + + logger->globalState.value(QLatin1String("currentFileName")) + + QLatin1String(": Commented out REQUIRES section"); + logger->addEntry(new PlainLogEntry(QLatin1String("Info"), QLatin1String("Porting"), logText)); + } + } + } + + // Check if any changes has been made. + if (!changesMade) { + Logger::instance()->addEntry( + new PlainLogEntry(QLatin1String("Info"), QLatin1String("Porting"), QLatin1String("No changes made to file ") + fileName)); + Logger::instance()->commitSection(); + return; + } + + // Write lines to array. + QByteArray bob; + QTextStream outProFileStream(&bob); + foreach(QString line, lines) + outProFileStream << line << lineEnding; + outProFileStream.flush(); + + // Write array to file, commit log if write was successful. + FileWriter::WriteResult result = FileWriter::instance()->writeFileVerbously(fileName, bob); + if (result == FileWriter::WriteSucceeded) { + logger->commitSection(); + } else if (result == FileWriter::WriteFailed) { + logger->revertSection(); + logger->addEntry( + new PlainLogEntry(QLatin1String("Error"), QLatin1String("Porting"), QLatin1String("Error writing to file ") + fileName)); + } else if (result == FileWriter::WriteSkipped) { + logger->revertSection(); + logger->addEntry( + new PlainLogEntry(QLatin1String("Error"), QLatin1String("Porting"), QLatin1String("User skipped file ") + fileName)); + } else { + // Internal error. + logger->revertSection(); + const QString errorString = QLatin1String("Internal error in qt3to4 - FileWriter returned invalid result code while writing to ") + fileName; + logger->addEntry(new PlainLogEntry(QLatin1String("Error"), QLatin1String("Porting"), errorString)); + } +} + +/* + Enables attribute generation for fileName. The file is looked up using the + provied includeFiles object. +*/ +void ProjectPorter::enableAttributes(const IncludeFiles &includeFiles, const QString &fileName) +{ + QString resolvedFilePath = includeFiles.resolve(fileName); + if (!QFile::exists(resolvedFilePath)) + resolvedFilePath = includeFiles.angleBracketLookup(fileName); + if (!QFile::exists(resolvedFilePath)) + return; + + TokenContainer tokenContainer = preprocessorCache.sourceTokens(resolvedFilePath); + TokenAttributes *attributes = tokenContainer.tokenAttributes(); + attributes->addAttribute("CreateAttributes", "True"); +} + +QT_END_NAMESPACE diff --git a/tools/porting/src/projectporter.h b/tools/porting/src/projectporter.h new file mode 100644 index 0000000..7cc69d9 --- /dev/null +++ b/tools/porting/src/projectporter.h @@ -0,0 +1,82 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef PROJECTPORTER_H +#define PROJECTPORTER_H + +#include "fileporter.h" +#include "preprocessorcontrol.h" +#include <QString> +#include <QSet> + +QT_BEGIN_NAMESPACE + +class ProjectPorter : public QObject +{ +Q_OBJECT +public: + ProjectPorter(QString basePath, QStringList includeDirectories, QStringList qt3HeadersFilenames = QStringList()); + void enableCppParsing(bool enable); + void enableMissingFilesWarnings(bool enable); + void portProject(QString filePath); + void portFile(QString filePath); +private slots: + void error(QString type, QString text); +private: + void portProject(QString inPath, QString proFileName); + void portProFile(QString fileName, QMap<QString, QString> tagMap); + void portFiles(QString basePath, QStringList fileNames); + void enableAttributes(const IncludeFiles &includeFiles, const QString &fileName); + + QSet<QString> processedFilesSet; + QString basePath; + QStringList includeDirectories; + PreprocessorCache preprocessorCache; + Rpp::DefineMap *defaultDefinitions; + FilePorter filePorter; + QStringList qt3HeadersFilenames; + bool analyze; + bool warnings; +}; + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/proparser.cpp b/tools/porting/src/proparser.cpp new file mode 100644 index 0000000..e4ab4b5 --- /dev/null +++ b/tools/porting/src/proparser.cpp @@ -0,0 +1,193 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "proparser.h" + +#include <QDir> +#include <QFile> +#include <QFileInfo> +#include <QRegExp> +#include <QStringList> +#include <QTextStream> + +#ifdef Q_OS_UNIX +#include <unistd.h> +#endif + +#ifdef Q_OS_WIN32 +#define QT_POPEN _popen +#else +#define QT_POPEN popen +#endif + +QT_BEGIN_NAMESPACE + +QString loadFile( const QString &fileName ) +{ + QFile file( fileName ); + if ( !file.open(QIODevice::ReadOnly) ) { + fprintf( stderr, "error: Cannot load '%s': %s\n", + file.fileName().toLocal8Bit().constData(), + file.errorString().toLatin1().constData() ); + return QString(); + } + + QTextStream in( &file ); + return in.readAll(); +} + +QMap<QString, QString> proFileTagMap( const QString& text, QString currentPath ) +{ + QString t = text; + if (currentPath.isEmpty()) + currentPath = QDir::currentPath(); + + + QMap<QString, QString> tagMap; + /* + Strip any commments before we try to include. We + still need to do it after we include to make sure the + included file does not have comments + */ + t.replace( QRegExp(QLatin1String("#[^\n]*\n")), QLatin1String(" ") ); + /* + Strip comments, merge lines ending with backslash, add + spaces around '=' and '+=', replace '\n' with ';', and + simplify white spaces. + */ + t.replace( QRegExp(QLatin1String("#[^\n]*\n")), QLatin1String(" ") ); + t.replace( QRegExp(QLatin1String("\\\\[^\n\\S]*\n")), QLatin1String(" ") ); + t.replace( QLatin1String("="), QLatin1String(" = ") ); + t.replace( QLatin1String("+ ="), QLatin1String(" += ") ); + t.replace( QLatin1String("\n"), QLatin1String(";") ); + t = t.simplified(); + + /* + Populate tagMap with 'key = value' entries. + */ + QStringList lines = t.split(QLatin1Char(';')); + QStringList::Iterator line; + for ( line = lines.begin(); line != lines.end(); ++line ) { + QStringList toks = (*line).split(QLatin1Char(' '), QString::SkipEmptyParts); + + if ( toks.count() >= 3 && + (toks[1] == QLatin1String("=") || toks[1] == QLatin1String("+=") || + toks[1] == QLatin1String("*=")) ) { + QString tag = toks.first(); + int k = tag.lastIndexOf( QLatin1Char(':') ); // as in 'unix:' + if ( k != -1 ) + tag = tag.mid( k + 1 ); + toks.erase( toks.begin() ); + + QString action = toks.first(); + toks.erase( toks.begin() ); + + if ( tagMap.contains(tag) ) { + if ( action == QLatin1String("=") ) + tagMap.insert( tag, toks.join(QLatin1String(" ")) ); + else + tagMap[tag] += QLatin1Char( ' ' ) + toks.join( QLatin1String(" ") ); + } else { + tagMap[tag] = toks.join( QLatin1String(" ") ); + } + } + } + /* + Expand $$variables within the 'value' part of a 'key = value' + pair. + */ + QRegExp var( QLatin1String("\\$\\$[({]?([a-zA-Z0-9_]+)[)}]?") ); + QMap<QString, QString>::Iterator it; + for ( it = tagMap.begin(); it != tagMap.end(); ++it ) { + int i = 0; + while ( (i = var.indexIn((*it), i)) != -1 ) { + int len = var.matchedLength(); + QString invocation = var.cap(1); + QString after; + + if ( invocation == QLatin1String("system") ) { + // skip system(); it will be handled in the next pass + ++i; + } else { + if ( tagMap.contains(invocation) ) + after = tagMap[invocation]; + else if (invocation.toLower() == QLatin1String("pwd")) + after = currentPath; + (*it).replace( i, len, after ); + i += after.length(); + } + } + } + + /* + Execute system() calls. + */ + QRegExp callToSystem( QLatin1String("\\$\\$system\\s*\\(([^()]*)\\)") ); + for ( it = tagMap.begin(); it != tagMap.end(); ++it ) { + int i = 0; + while ( (i = callToSystem.indexIn((*it), i)) != -1 ) { + /* + This code is stolen from qmake's project.cpp file. + Ideally we would use the same parser, so we wouldn't + have this code duplication. + */ + QString after; + char buff[256]; + FILE *proc = QT_POPEN( callToSystem.cap(1).toLatin1().constData(), "r" ); + while ( proc && !feof(proc) ) { + int read_in = int(fread( buff, 1, 255, proc )); + if ( !read_in ) + break; + for ( int i = 0; i < read_in; i++ ) { + if ( buff[i] == '\n' || buff[i] == '\t' ) + buff[i] = ' '; + } + buff[read_in] = '\0'; + after += QLatin1String(buff); + } + (*it).replace( i, callToSystem.matchedLength(), after ); + i += after.length(); + } + } + return tagMap; +} + +QT_END_NAMESPACE diff --git a/tools/porting/src/proparser.h b/tools/porting/src/proparser.h new file mode 100644 index 0000000..970e4c5 --- /dev/null +++ b/tools/porting/src/proparser.h @@ -0,0 +1,55 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef PROPARSER_H +#define PROPARSER_H + +#include <QMap> +#include <QString> + +QT_BEGIN_NAMESPACE + +QMap<QString, QString> proFileTagMap( const QString& text, QString currentPath = QString() ); +QString loadFile( const QString &fileName ); + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/q3porting.xml b/tools/porting/src/q3porting.xml new file mode 100644 index 0000000..3436633 --- /dev/null +++ b/tools/porting/src/q3porting.xml @@ -0,0 +1,10563 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!--************************************************************************ +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +**************************************************************************--> +<Rules> + <Count>3796</Count> + <item Type="RenamedHeader" > + <Qt4>q3buttongroup.h</Qt4> + <Qt3>qvbuttongroup.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>qcombobox.h</Qt4> + <Qt3>qcombo.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>qtextstream.h</Qt4> + <Qt3>qtstream.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3objectdict.h</Qt4> + <Qt3>qobjcoll.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3accel.h</Qt4> + <Qt3>qaccel.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3asciicache.h</Qt4> + <Qt3>qasciicache.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3asciidict.h</Qt4> + <Qt3>qasciidict.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3buttongroup.h</Qt4> + <Qt3>qbuttongroup.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3cache.h</Qt4> + <Qt3>qcache.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3canvas.h</Qt4> + <Qt3>qcanvas.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3cleanuphandler.h</Qt4> + <Qt3>qcleanuphandler.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3cstring.h</Qt4> + <Qt3>qcstring.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3databrowser.h</Qt4> + <Qt3>qdatabrowser.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3datatable.h</Qt4> + <Qt3>qdatatable.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3dataview.h</Qt4> + <Qt3>qdataview.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3datetimeedit.h</Qt4> + <Qt3>qdatetimeedit.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3deepcopy.h</Qt4> + <Qt3>qdeepcopy.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3dict.h</Qt4> + <Qt3>qdict.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3dns.h</Qt4> + <Qt3>qdns.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3dockarea.h</Qt4> + <Qt3>qdockarea.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3dockwindow.h</Qt4> + <Qt3>qdockwindow.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3dragobject.h</Qt4> + <Qt3>qdragobject.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3dropsite.h</Qt4> + <Qt3>qdropsite.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3editorfactory.h</Qt4> + <Qt3>qeditorfactory.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3filedialog.h</Qt4> + <Qt3>qfiledialog.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3frame.h</Qt4> + <Qt3>qframe.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3ftp.h</Qt4> + <Qt3>qftp.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3garray.h</Qt4> + <Qt3>qgarray.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3gcache.h</Qt4> + <Qt3>qgcache.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3gdict.h</Qt4> + <Qt3>qgdict.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3glist.h</Qt4> + <Qt3>qglist.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3grid.h</Qt4> + <Qt3>qgrid.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3gridview.h</Qt4> + <Qt3>qgridview.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3groupbox.h</Qt4> + <Qt3>qgroupbox.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3gvector.h</Qt4> + <Qt3>qgvector.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3hbox.h</Qt4> + <Qt3>qhbox.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3header.h</Qt4> + <Qt3>qheader.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3hgroupbox.h</Qt4> + <Qt3>qhgroupbox.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3http.h</Qt4> + <Qt3>qhttp.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3iconview.h</Qt4> + <Qt3>qiconview.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3intcache.h</Qt4> + <Qt3>qintcache.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3intdict.h</Qt4> + <Qt3>qintdict.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3listbox.h</Qt4> + <Qt3>qlistbox.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3listview.h</Qt4> + <Qt3>qlistview.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3localfs.h</Qt4> + <Qt3>qlocalfs.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3mainwindow.h</Qt4> + <Qt3>qmainwindow.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3memarray.h</Qt4> + <Qt3>qmemarray.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3multilineedit.h</Qt4> + <Qt3>qmultilineedit.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3network.h</Qt4> + <Qt3>qnetwork.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3networkprotocol.h</Qt4> + <Qt3>qnetworkprotocol.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3objectdict.h</Qt4> + <Qt3>qobjectdict.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3paintdevicemetrics.h</Qt4> + <Qt3>qpaintdevicemetrics.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3picture.h</Qt4> + <Qt3>qpicture.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3pointarray.h</Qt4> + <Qt3>qpointarray.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3polygonscanner.h</Qt4> + <Qt3>qpolygonscanner.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3popupmenu.h</Qt4> + <Qt3>qpopupmenu.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3process.h</Qt4> + <Qt3>qprocess.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3progressbar.h</Qt4> + <Qt3>qprogressbar.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3progressdialog.h</Qt4> + <Qt3>qprogressdialog.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3ptrcollection.h</Qt4> + <Qt3>qptrcollection.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3ptrdict.h</Qt4> + <Qt3>qptrdict.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3ptrlist.h</Qt4> + <Qt3>qptrlist.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3ptrqueue.h</Qt4> + <Qt3>qptrqueue.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3ptrstack.h</Qt4> + <Qt3>qptrstack.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3ptrvector.h</Qt4> + <Qt3>qptrvector.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3rangecontrol.h</Qt4> + <Qt3>qrangecontrol.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3scrollview.h</Qt4> + <Qt3>qscrollview.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3semaphore.h</Qt4> + <Qt3>qsemaphore.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3serversocket.h</Qt4> + <Qt3>qserversocket.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3shared.h</Qt4> + <Qt3>qshared.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3signal.h</Qt4> + <Qt3>qsignal.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3simplerichtext.h</Qt4> + <Qt3>qsimplerichtext.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3socket.h</Qt4> + <Qt3>qsocket.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3socketdevice.h</Qt4> + <Qt3>qsocketdevice.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3sortedlist.h</Qt4> + <Qt3>qsortedlist.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3sqlcursor.h</Qt4> + <Qt3>qsqlcursor.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3sqleditorfactory.h</Qt4> + <Qt3>qsqleditorfactory.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3sqlform.h</Qt4> + <Qt3>qsqlform.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3sqlpropertymap.h</Qt4> + <Qt3>qsqlpropertymap.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3sqlselectcursor.h</Qt4> + <Qt3>qsqlselectcursor.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3strlist.h</Qt4> + <Qt3>qstrlist.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3strvec.h</Qt4> + <Qt3>qstrvec.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3stylesheet.h</Qt4> + <Qt3>qstylesheet.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3syntaxhighlighter.h</Qt4> + <Qt3>qsyntaxhighlighter.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3tabdialog.h</Qt4> + <Qt3>qtabdialog.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3table.h</Qt4> + <Qt3>qtable.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3textbrowser.h</Qt4> + <Qt3>qtextbrowser.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3textedit.h</Qt4> + <Qt3>qtextedit.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3textstream.h</Qt4> + <Qt3>qtextstream.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3textview.h</Qt4> + <Qt3>qtextview.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3tl.h</Qt4> + <Qt3>qtl.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3toolbar.h</Qt4> + <Qt3>qtoolbar.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3url.h</Qt4> + <Qt3>qurl.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3urloperator.h</Qt4> + <Qt3>qurloperator.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3valuelist.h</Qt4> + <Qt3>qvaluelist.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3valuestack.h</Qt4> + <Qt3>qvaluestack.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3valuevector.h</Qt4> + <Qt3>qvaluevector.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3vbox.h</Qt4> + <Qt3>qvbox.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3vgroupbox.h</Qt4> + <Qt3>qvgroupbox.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3whatsthis.h</Qt4> + <Qt3>qwhatsthis.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3widgetstack.h</Qt4> + <Qt3>qwidgetstack.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3wizard.h</Qt4> + <Qt3>qwizard.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3accel.h</Qt4> + <Qt3>qaccel.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3asciicache.h</Qt4> + <Qt3>qasciicache.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3asciidict.h</Qt4> + <Qt3>qasciidict.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3buttongroup.h</Qt4> + <Qt3>qbuttongroup.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3cache.h</Qt4> + <Qt3>qcache.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3canvas.h</Qt4> + <Qt3>qcanvas.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3cleanuphandler.h</Qt4> + <Qt3>qcleanuphandler.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3cstring.h</Qt4> + <Qt3>qcstring.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3databrowser.h</Qt4> + <Qt3>qdatabrowser.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3datatable.h</Qt4> + <Qt3>qdatatable.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3dataview.h</Qt4> + <Qt3>qdataview.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3datetimeedit.h</Qt4> + <Qt3>qdatetimeedit.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3deepcopy.h</Qt4> + <Qt3>qdeepcopy.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3dict.h</Qt4> + <Qt3>qdict.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3dns.h</Qt4> + <Qt3>qdns.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3dockarea.h</Qt4> + <Qt3>qdockarea.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3dockwindow.h</Qt4> + <Qt3>qdockwindow.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3dragobject.h</Qt4> + <Qt3>qdragobject.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3dropsite.h</Qt4> + <Qt3>qdropsite.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3editorfactory.h</Qt4> + <Qt3>qeditorfactory.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3filedialog.h</Qt4> + <Qt3>qfiledialog.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3frame.h</Qt4> + <Qt3>qframe.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3ftp.h</Qt4> + <Qt3>qftp.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3garray.h</Qt4> + <Qt3>qgarray.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3gcache.h</Qt4> + <Qt3>qgcache.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3gdict.h</Qt4> + <Qt3>qgdict.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3glist.h</Qt4> + <Qt3>qglist.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3grid.h</Qt4> + <Qt3>qgrid.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3gridview.h</Qt4> + <Qt3>qgridview.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3groupbox.h</Qt4> + <Qt3>qgroupbox.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3gvector.h</Qt4> + <Qt3>qgvector.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3hbox.h</Qt4> + <Qt3>qhbox.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3header.h</Qt4> + <Qt3>qheader.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3hgroupbox.h</Qt4> + <Qt3>qhgroupbox.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3http.h</Qt4> + <Qt3>qhttp.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3iconview.h</Qt4> + <Qt3>qiconview.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3intcache.h</Qt4> + <Qt3>qintcache.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3intdict.h</Qt4> + <Qt3>qintdict.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3listbox.h</Qt4> + <Qt3>qlistbox.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3listview.h</Qt4> + <Qt3>qlistview.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3localfs.h</Qt4> + <Qt3>qlocalfs.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3mainwindow.h</Qt4> + <Qt3>qmainwindow.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3memarray.h</Qt4> + <Qt3>qmemarray.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3multilineedit.h</Qt4> + <Qt3>qmultilineedit.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3network.h</Qt4> + <Qt3>qnetwork.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3networkprotocol.h</Qt4> + <Qt3>qnetworkprotocol.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3objectdict.h</Qt4> + <Qt3>qobjectdict.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3paintdevicemetrics.h</Qt4> + <Qt3>qpaintdevicemetrics.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3picture.h</Qt4> + <Qt3>qpicture.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3pointarray.h</Qt4> + <Qt3>qpointarray.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3polygonscanner.h</Qt4> + <Qt3>qpolygonscanner.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3popupmenu.h</Qt4> + <Qt3>qpopupmenu.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3process.h</Qt4> + <Qt3>qprocess.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3progressbar.h</Qt4> + <Qt3>qprogressbar.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3progressdialog.h</Qt4> + <Qt3>qprogressdialog.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3ptrcollection.h</Qt4> + <Qt3>qptrcollection.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3ptrdict.h</Qt4> + <Qt3>qptrdict.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3ptrlist.h</Qt4> + <Qt3>qptrlist.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3ptrqueue.h</Qt4> + <Qt3>qptrqueue.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3ptrstack.h</Qt4> + <Qt3>qptrstack.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3ptrvector.h</Qt4> + <Qt3>qptrvector.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3rangecontrol.h</Qt4> + <Qt3>qrangecontrol.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3scrollview.h</Qt4> + <Qt3>qscrollview.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3semaphore.h</Qt4> + <Qt3>qsemaphore.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3serversocket.h</Qt4> + <Qt3>qserversocket.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3shared.h</Qt4> + <Qt3>qshared.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3signal.h</Qt4> + <Qt3>qsignal.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3simplerichtext.h</Qt4> + <Qt3>qsimplerichtext.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3socket.h</Qt4> + <Qt3>qsocket.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3socketdevice.h</Qt4> + <Qt3>qsocketdevice.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3sortedlist.h</Qt4> + <Qt3>qsortedlist.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3sqlcursor.h</Qt4> + <Qt3>qsqlcursor.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3sqleditorfactory.h</Qt4> + <Qt3>qsqleditorfactory.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3sqlform.h</Qt4> + <Qt3>qsqlform.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3sqlpropertymap.h</Qt4> + <Qt3>qsqlpropertymap.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3sqlselectcursor.h</Qt4> + <Qt3>qsqlselectcursor.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3strlist.h</Qt4> + <Qt3>qstrlist.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3strvec.h</Qt4> + <Qt3>qstrvec.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3stylesheet.h</Qt4> + <Qt3>qstylesheet.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3syntaxhighlighter.h</Qt4> + <Qt3>qsyntaxhighlighter.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3tabdialog.h</Qt4> + <Qt3>qtabdialog.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3table.h</Qt4> + <Qt3>qtable.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3textbrowser.h</Qt4> + <Qt3>qtextbrowser.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3textedit.h</Qt4> + <Qt3>qtextedit.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3textstream.h</Qt4> + <Qt3>qtextstream.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3textview.h</Qt4> + <Qt3>qtextview.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3tl.h</Qt4> + <Qt3>qtl.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3toolbar.h</Qt4> + <Qt3>qtoolbar.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3url.h</Qt4> + <Qt3>qurl.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3urloperator.h</Qt4> + <Qt3>qurloperator.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3valuelist.h</Qt4> + <Qt3>qvaluelist.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3valuestack.h</Qt4> + <Qt3>qvaluestack.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3valuevector.h</Qt4> + <Qt3>qvaluevector.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3vbox.h</Qt4> + <Qt3>qvbox.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3vgroupbox.h</Qt4> + <Qt3>qvgroupbox.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3whatsthis.h</Qt4> + <Qt3>qwhatsthis.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3widgetstack.h</Qt4> + <Qt3>qwidgetstack.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>q3wizard.h</Qt4> + <Qt3>qwizard.h</Qt3> + </item> + <item Type="Qt4Class" > + <Library>ActiveQt</Library> + <Name>QAxAggregated</Name> + </item> + <item Type="Qt4Class" > + <Library>ActiveQt</Library> + <Name>QAxBase</Name> + </item> + <item Type="Qt4Class" > + <Library>ActiveQt</Library> + <Name>QAxBindable</Name> + </item> + <item Type="Qt4Class" > + <Library>ActiveQt</Library> + <Name>QAxClass</Name> + </item> + <item Type="Qt4Class" > + <Library>ActiveQt</Library> + <Name>QAxFactory</Name> + </item> + <item Type="Qt4Class" > + <Library>ActiveQt</Library> + <Name>QAxObject</Name> + </item> + <item Type="Qt4Class" > + <Library>ActiveQt</Library> + <Name>QAxScript</Name> + </item> + <item Type="Qt4Class" > + <Library>ActiveQt</Library> + <Name>QAxScriptEngine</Name> + </item> + <item Type="Qt4Class" > + <Library>ActiveQt</Library> + <Name>QAxScriptManager</Name> + </item> + <item Type="Qt4Class" > + <Library>ActiveQt</Library> + <Name>QAxSelect</Name> + </item> + <item Type="Qt4Class" > + <Library>ActiveQt</Library> + <Name>QAxWidget</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3Accel</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3Action</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ActionGroup</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3AsciiBucket</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3AsciiCache</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3AsciiCacheIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3AsciiDict</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3AsciiDictIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3BaseBucket</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3BoxLayout</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3Button</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ButtonGroup</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3Cache</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3CacheIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3Canvas</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3CanvasEllipse</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3CanvasItem</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3CanvasItemList</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3CanvasLine</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3CanvasPixmap</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3CanvasPixmapArray</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3CanvasPolygon</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3CanvasPolygonalItem</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3CanvasRectangle</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3CanvasSpline</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3CanvasSprite</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3CanvasText</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3CanvasView</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3CheckListItem</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3CheckTableItem</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3CleanupHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ColorDrag</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ComboBox</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ComboTableItem</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3CString</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3DataBrowser</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3DataTable</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3DataView</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3DateEdit</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3DateTimeEdit</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3DateTimeEditBase</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3DeepCopy</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3Dict</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3DictIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3Dns</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3DnsSocket</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3DockArea</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3DockAreaLayout</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3DockWindow</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3DragObject</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3DropSite</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3EditorFactory</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3FileDialog</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3FileIconProvider</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3FilePreview</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3Frame</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3Ftp</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3GArray</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3GCache</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3GCacheIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3GDict</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3GDictIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3GList</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3GListIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3GListStdIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3Grid</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3GridLayout</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3GridView</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3GroupBox</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3GVector</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3HBox</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3HBoxLayout</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3HButtonGroup</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3Header</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3HGroupBox</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3Http</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3HttpHeader</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3HttpRequestHeader</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3HttpResponseHeader</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3IconDrag</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3IconDragItem</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3IconView</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3IconViewItem</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ImageDrag</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3IntBucket</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3IntCache</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3IntCacheIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3IntDict</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3IntDictIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ListBox</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ListBoxItem</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ListBoxPixmap</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ListBoxText</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ListView</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ListViewItem</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ListViewItemIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3LNode</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3LocalFs</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3MainWindow</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3MemArray</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3MimeSourceFactory</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3MultiLineEdit</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3NetworkOperation</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3NetworkProtocol</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3NetworkProtocolDict</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3NetworkProtocolFactory</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3NetworkProtocolFactoryBase</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ObjectDictionary</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3PaintDeviceMetrics</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3Painter</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3Picture</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3PointArray</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3PolygonScanner</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3PopupMenu</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3Process</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ProgressBar</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ProgressDialog</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3PtrBucket</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3PtrCollection</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3PtrDict</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3PtrDictIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3PtrList</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3PtrListIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3PtrListStdIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3PtrQueue</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3PtrStack</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3PtrVector</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3RangeControl</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ScrollView</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3Semaphore</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ServerSocket</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3Shared</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3Signal</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3SimpleRichText</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3SingleCleanupHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3Socket</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3SocketDevice</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3SortedList</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3SpinWidget</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3SqlCursor</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3SqlEditorFactory</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3SqlFieldInfo</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3SqlFieldInfoList</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3SqlForm</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3SqlPropertyMap</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3SqlRecordInfo</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3SqlSelectCursor</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3StoredDrag</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3StrIList</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3StringBucket</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3StrIVec</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3StrList</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3StrListIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3StrVec</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3StyleSheet</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3StyleSheetItem</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3SyntaxHighlighter</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3TabDialog</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3Table</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3TableItem</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3TableSelection</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3TextBrowser</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3TextDrag</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3TextEdit</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3TextEditOptimPrivate</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3TextStream</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3TextView</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3TimeEdit</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ToolBar</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3TSFUNC</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3UriDrag</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3Url</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3UrlOperator</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ValueList</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ValueListConstIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ValueListIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ValueStack</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3ValueVector</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3VBox</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3VBoxLayout</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3VButtonGroup</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3VGroupBox</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3WhatsThis</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3WidgetStack</Name> + </item> + <item Type="Qt4Class" > + <Library>Qt3Support</Library> + <Name>Q3Wizard</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QAbstractEventDispatcher</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QAbstractFileEngine</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QAbstractFileEngineHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QAbstractItemModel</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QAbstractListModel</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QAbstractTableModel</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QArgument</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QAtomic</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QAtomicPointer</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QBasicAtomic</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QBasicAtomicPointer</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QBasicTimer</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QBitArray</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QBitRef</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QBool</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QBuffer</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QByteArray</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QByteArrayMatcher</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QByteRef</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QCache</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QChar</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QCharRef</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QChildEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QConstString</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QCOORD</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QCoreApplication</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QCustomEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QDataStream</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QDate</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QDateTime</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QDebug</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QDir</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QDynamicPropertyChangeEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QEventLoop</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QFactoryInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QFile</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QFileInfo</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QFileInfoList</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QFileInfoListIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QFileSystemWatcher</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QFlag</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QFlags</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QForeachContainer</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QForeachContainerBase</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QFSFileEngine</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QGenericArgument</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QGenericReturnArgument</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QGlobalStatic</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QHash</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QHashData</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QHashDummyNode</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QHashDummyValue</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QHashIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QHashNode</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QInternal</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QIntForSize</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QIntForType</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QIODevice</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QLatin1Char</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QLatin1String</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QLibrary</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QLibraryInfo</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QLine</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QLineF</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QLinkedList</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QLinkedListData</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QLinkedListIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QLinkedListNode</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QList</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QListData</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QListIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QLocale</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMap</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMapData</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMapIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMetaClassInfo</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMetaEnum</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMetaMethod</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMetaObject</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMetaProperty</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMetaType</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMetaTypeId</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMetaTypeId2</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMimeData</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QModelIndex</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QModelIndexList</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMultiHash</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMultiMap</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMutableHashIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMutableLinkedListIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMutableListIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMutableMapIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMutableSetIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMutableStringListIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMutableVectorIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMutex</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QMutexLocker</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QNoDebug</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QNoImplicitBoolCast</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QObject</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QObjectCleanupHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QObjectData</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QObjectList</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QObjectUserData</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QPair</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QPersistentModelIndex</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QPluginLoader</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QPoint</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QPointer</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QPointF</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QProcess</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QQueue</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QReadLocker</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QReadWriteLock</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QRect</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QRectF</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QRegExp</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QResource</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QReturnArgument</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QSemaphore</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QSet</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QSetIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QSettings</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QSharedData</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QSharedDataPointer</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QSignalMapper</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QSize</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QSizeF</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QSocketNotifier</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QStack</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QStdWString</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QString</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QStringList</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QStringListIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QStringMatcher</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QSysInfo</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QSystemLocale</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QTemporaryFile</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QTextCodec</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QTextCodecFactoryInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QTextCodecPlugin</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QTextDecoder</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QTextEncoder</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QTextIStream</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QTextOStream</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QTextStream</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QTextStreamFunction</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QTextStreamManipulator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QThread</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QThreadStorage</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QThreadStorageData</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QTime</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QTimeLine</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QTimer</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QTimerEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QTranslator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QTS</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QTypeInfo</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QUintForSize</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QUintForType</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QUrl</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QUuid</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QVariant</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QVariantComparisonHelper</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QVariantList</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QVariantMap</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QVarLengthArray</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QVector</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QVectorData</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QVectorIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QVectorTypedData</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QWaitCondition</Name> + </item> + <item Type="Qt4Class" > + <Library>QtCore</Library> + <Name>QWriteLocker</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDBus</Library> + <Name>QDBusAbstractAdaptor</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDBus</Library> + <Name>QDBusAbstractInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDBus</Library> + <Name>QDBusArgument</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDBus</Library> + <Name>QDBusConnection</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDBus</Library> + <Name>QDBusConnectionInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDBus</Library> + <Name>QDBusError</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDBus</Library> + <Name>QDBusInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDBus</Library> + <Name>QDBusInterfacePtr</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDBus</Library> + <Name>QDBusMessage</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDBus</Library> + <Name>QDBusMetaType</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDBus</Library> + <Name>QDBusObjectPath</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDBus</Library> + <Name>QDBusReply</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDBus</Library> + <Name>QDBusServer</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDBus</Library> + <Name>QDBusSignature</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDBus</Library> + <Name>QDBusVariant</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QAbstractExtensionFactory</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QAbstractExtensionManager</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QAbstractFormBuilder</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerActionEditorInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerBrushManagerInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerComponents</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerContainerExtension</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerCustomWidgetCollectionInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerCustomWidgetInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerDnDItemInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerExportWidget</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerExtraInfoExtension</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerFormEditorInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerFormEditorPluginInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerFormWindowCursorInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerFormWindowInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerFormWindowManagerInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerFormWindowToolInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerIconCacheInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerLayoutDecorationExtension</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerMemberSheetExtension</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerMetaDataBaseInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerMetaDataBaseItemInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerObjectInspectorInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerPropertyEditorInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerPropertySheetExtension</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerTaskMenuExtension</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerWidgetBoxInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerWidgetDataBaseInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerWidgetDataBaseItemInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QDesignerWidgetFactoryInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QExtensionFactory</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QExtensionManager</Name> + </item> + <item Type="Qt4Class" > + <Library>QtDesigner</Library> + <Name>QFormBuilder</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAbstractButton</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAbstractGraphicsPathItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAbstractGraphicsShapeItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAbstractItemDelegate</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAbstractItemView</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAbstractPageSetupDialog</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAbstractPrintDialog</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAbstractProxyModel</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAbstractScrollArea</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAbstractSlider</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAbstractSpinBox</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAbstractTextDocumentLayout</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAbstractUndoItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAccessible</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAccessibleApplication</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAccessibleBridge</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAccessibleBridgeFactoryInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAccessibleBridgePlugin</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAccessibleEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAccessibleFactoryInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAccessibleInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAccessibleInterfaceEx</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAccessibleObject</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAccessibleObjectEx</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAccessiblePlugin</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAccessibleWidget</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAccessibleWidgetEx</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QAction</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QActionEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QActionGroup</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QApplication</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QBitmap</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QBoxLayout</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QBrush</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QBrushData</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QButtonGroup</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QCalendarWidget</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QCDEStyle</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QCheckBox</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QCleanLooksStyle</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QCleanlooksStyle</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QClipboard</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QClipboardEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QCloseEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QColor</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QColorDialog</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QColorGroup</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QColormap</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QComboBox</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QCommonStyle</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QCompleter</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QConicalGradient</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QContextMenuEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QCopChannel</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QCursor</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QCursorShape</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDataWidgetMapper</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDateEdit</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDateTimeEdit</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDecoration</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDecorationAction</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDecorationDefault</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDecorationFactory</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDecorationFactoryInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDecorationPlugin</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDecorationStyled</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDecorationWindows</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDesktopServices</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDesktopWidget</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDial</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDialog</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDialogButtonBox</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDirectPainter</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDirModel</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDockWidget</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDoubleSpinBox</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDoubleValidator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDrag</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDragEnterEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDragLeaveEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDragMoveEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDragResponseEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QDropEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QErrorMessage</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QFileDialog</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QFileIconProvider</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QFileOpenEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QFocusEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QFocusFrame</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QFont</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QFontComboBox</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QFontDatabase</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QFontDialog</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QFontInfo</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QFontMetrics</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QFontMetricsF</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QFrame</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGradient</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGradientStop</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGradientStops</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGraphicsEllipseItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGraphicsItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGraphicsItemAnimation</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGraphicsItemGroup</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGraphicsLineItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGraphicsPathItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGraphicsPixmapItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGraphicsPolygonItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGraphicsRectItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGraphicsScene</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGraphicsSceneContextMenuEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGraphicsSceneDragDropEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGraphicsSceneEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGraphicsSceneHelpEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGraphicsSceneHoverEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGraphicsSceneMouseEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGraphicsSceneWheelEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGraphicsSimpleTextItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGraphicsTextItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGraphicsView</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGridLayout</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QGroupBox</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QHBoxLayout</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QHeaderView</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QHelpEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QHideEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QHoverEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QIcon</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QIconDragEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QIconEngine</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QIconEngineFactoryInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QIconEnginePlugin</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QIconSet</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QImage</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QImageIOHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QImageIOHandlerFactoryInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QImageIOPlugin</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QImageReader</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QImageTextKeyLang</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QImageWriter</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QInputContext</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QInputContextFactory</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QInputContextFactoryInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QInputContextPlugin</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QInputDialog</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QInputEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QInputMethodEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QIntValidator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QItemDelegate</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QItemEditorCreator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QItemEditorCreatorBase</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QItemEditorFactory</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QItemSelection</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QItemSelectionModel</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QItemSelectionRange</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QKbdDriverFactory</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QKbdDriverPlugin</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QKeyEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QKeySequence</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QLabel</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QLayout</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QLayoutItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QLayoutIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QLCDNumber</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QLinearGradient</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QLineEdit</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QLinuxFb_Shared</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QLinuxFbScreen</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QListView</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QListWidget</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QListWidgetItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QMacMime</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QMacPasteBoardMime</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QMacStyle</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QMainWindow</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QMatrix</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QMenu</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QMenuBar</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QMenubarUpdatedEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QMenuItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QMessageBox</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QMimeSource</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QMotifStyle</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QMouseDriverFactory</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QMouseDriverPlugin</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QMouseEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QMoveEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QMovie</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPageSetupDialog</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPaintDevice</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPaintEngine</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPaintEngineState</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPainter</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPainterPath</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPainterPathPrivate</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPainterPathStroker</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPaintEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPalette</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPen</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPicture</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPictureFormatInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPictureFormatPlugin</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPictureIO</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPixmap</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPixmapCache</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPlastiqueStyle</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPolygon</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPolygonF</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPoolEntry</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPrintDialog</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPrintEngine</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPrinter</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QProgressBar</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QProgressDialog</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QProxyModel</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QPushButton</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QRadialGradient</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QRadioButton</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QRegExpValidator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QRegion</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QResizeEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QRgb</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QRubberBand</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QScreen</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QScreenCursor</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QScreenDriverFactory</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QScreenDriverFactoryInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QScreenDriverPlugin</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QScrollArea</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QScrollBar</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QSessionManager</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QShortcut</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QShortcutEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QShowEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QSizeGrip</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QSizePolicy</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QSlider</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QSortFilterProxyModel</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QSound</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QSpacerItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QSpinBox</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QSplashScreen</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QSplitter</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QSplitterHandle</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStackedLayout</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStackedWidget</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStandardItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStandardItemEditorCreator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStandardItemModel</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStatusBar</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStatusTipEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStringListModel</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyle</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleFactory</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleFactoryInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleHintReturn</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleHintReturnMask</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOption</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionButton</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionComboBox</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionComplex</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionDockWidget</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionFocusRect</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionFrame</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionFrameV2</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionGraphicsItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionGroupBox</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionHeader</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionMenuItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionProgressBar</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionProgressBarV2</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionQ3DockWindow</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionQ3ListView</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionQ3ListViewItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionRubberBand</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionSizeGrip</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionSlider</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionSpinBox</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionTab</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionTabBarBase</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionTabV2</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionTabWidgetFrame</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionTitleBar</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionToolBar</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionToolBox</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionToolButton</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionViewItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStyleOptionViewItemV2</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStylePainter</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QStylePlugin</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QSyntaxHighlighter</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QSystemTrayIcon</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTabBar</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTabletEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTableView</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTableWidget</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTableWidgetItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTableWidgetSelectionRange</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTabWidget</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextBlock</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextBlockFormat</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextBlockGroup</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextBlockUserData</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextBrowser</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextCharFormat</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextCursor</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextDocument</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextDocumentFragment</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextEdit</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextFormat</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextFragment</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextFrame</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextFrameFormat</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextFrameLayoutData</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextImageFormat</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextInlineObject</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextLayout</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextLength</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextLine</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextList</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextListFormat</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextObject</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextObjectInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextOption</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextTable</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextTableCell</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTextTableFormat</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTimeEdit</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QToolBar</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QToolBarChangeEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QToolBox</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QToolButton</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QToolTip</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTransformedScreen</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTransportAuth</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTreeView</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTreeWidget</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTreeWidgetItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QTreeWidgetItemIterator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QUndoCommand</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QUndoGroup</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QUndoStack</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QUndoView</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QUpdateLaterEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QValidator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QVBoxLayout</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QVFbHeader</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QVFbKeyboardHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QVFbKeyData</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QVFbMouseHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QVFbScreen</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QVNCScreen</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWhatsThis</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWhatsThisClickedEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWheelEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWidget</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWidgetAction</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWidgetData</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWidgetItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWidgetList</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWidgetMapper</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWidgetSet</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWindowsMime</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWindowsStyle</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWindowStateChangeEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWindowsXPStyle</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWMatrix</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWorkspace</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSBusMouseHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSCalibratedMouseHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSClient</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSCursor</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSCursorMap</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSDisplay</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSEmbedWidget</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSInputMethod</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSInternalWindowInfo</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSKeyboardHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSKeyboardHandlerFactoryInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSLinuxTPMouseHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSManager</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSMouseHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSMouseHandlerFactoryInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSPC101KeyboardHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSPcMouseHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSPointerCalibrationData</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSPropertyManager</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSProtocolItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSScreenSaver</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSServer</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSServerSocket</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSSL5000KeyboardHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSSocket</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSSoundClient</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSSoundServer</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSSoundServerSocket</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSTslibMouseHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSTtyKeyboardHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSUmKeyboardHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSUsbKeyboardHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSVr41xxKeyboardHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSVr41xxMouseHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSWindow</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSWindowInfo</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSYopyKeyboardHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QWSYopyMouseHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QX11EmbedContainer</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QX11EmbedWidget</Name> + </item> + <item Type="Qt4Class" > + <Library>QtGui</Library> + <Name>QX11Info</Name> + </item> + <item Type="Qt4Class" > + <Library>QtNetwork</Library> + <Name>QAbstractSocket</Name> + </item> + <item Type="Qt4Class" > + <Library>QtNetwork</Library> + <Name>QFtp</Name> + </item> + <item Type="Qt4Class" > + <Library>QtNetwork</Library> + <Name>QHostAddress</Name> + </item> + <item Type="Qt4Class" > + <Library>QtNetwork</Library> + <Name>QHostInfo</Name> + </item> + <item Type="Qt4Class" > + <Library>QtNetwork</Library> + <Name>QHttp</Name> + </item> + <item Type="Qt4Class" > + <Library>QtNetwork</Library> + <Name>QHttpHeader</Name> + </item> + <item Type="Qt4Class" > + <Library>QtNetwork</Library> + <Name>QHttpRequestHeader</Name> + </item> + <item Type="Qt4Class" > + <Library>QtNetwork</Library> + <Name>QHttpResponseHeader</Name> + </item> + <item Type="Qt4Class" > + <Library>QtNetwork</Library> + <Name>QIPv6Address</Name> + </item> + <item Type="Qt4Class" > + <Library>QtNetwork</Library> + <Name>QNetworkAddressEntry</Name> + </item> + <item Type="Qt4Class" > + <Library>QtNetwork</Library> + <Name>QNetworkInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtNetwork</Library> + <Name>QNetworkProxy</Name> + </item> + <item Type="Qt4Class" > + <Library>QtNetwork</Library> + <Name>QTcpServer</Name> + </item> + <item Type="Qt4Class" > + <Library>QtNetwork</Library> + <Name>QTcpSocket</Name> + </item> + <item Type="Qt4Class" > + <Library>QtNetwork</Library> + <Name>QUdpSocket</Name> + </item> + <item Type="Qt4Class" > + <Library>QtNetwork</Library> + <Name>QUrlInfo</Name> + </item> + <item Type="Qt4Class" > + <Library>QtOpenGL</Library> + <Name>QGLColormap</Name> + </item> + <item Type="Qt4Class" > + <Library>QtOpenGL</Library> + <Name>QGLContext</Name> + </item> + <item Type="Qt4Class" > + <Library>QtOpenGL</Library> + <Name>QGLFormat</Name> + </item> + <item Type="Qt4Class" > + <Library>QtOpenGL</Library> + <Name>QGLFramebufferObject</Name> + </item> + <item Type="Qt4Class" > + <Library>QtOpenGL</Library> + <Name>QGLPixelBuffer</Name> + </item> + <item Type="Qt4Class" > + <Library>QtOpenGL</Library> + <Name>QGLWidget</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QDB2Driver</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QDB2Result</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QIBaseDriver</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QIBaseResult</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QMYSQLDriver</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QMYSQLResult</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QOCIDriver</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QOCIResult</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QODBCDriver</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QODBCResult</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QPSQLDriver</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QPSQLResult</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QSqlDatabase</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QSqlDriver</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QSqlDriverCreator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QSqlDriverCreatorBase</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QSqlDriverFactoryInterface</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QSqlDriverPlugin</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QSqlError</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QSqlField</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QSqlIndex</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QSQLite2Driver</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QSQLite2Result</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QSQLiteDriver</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QSQLiteResult</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QSqlQuery</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QSqlQueryModel</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QSqlRecord</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QSqlRelation</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QSqlRelationalDelegate</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QSqlRelationalTableModel</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QSqlResult</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QSqlTableModel</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QTDSDriver</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSql</Library> + <Name>QTDSResult</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSvg</Library> + <Name>QGraphicsSvgItem</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSvg</Library> + <Name>QSvgRenderer</Name> + </item> + <item Type="Qt4Class" > + <Library>QtSvg</Library> + <Name>QSvgWidget</Name> + </item> + <item Type="Qt4Class" > + <Library>QtTest</Library> + <Name>QEventSizeOfChecker</Name> + </item> + <item Type="Qt4Class" > + <Library>QtTest</Library> + <Name>QSignalSpy</Name> + </item> + <item Type="Qt4Class" > + <Library>QtTest</Library> + <Name>QSpontaneKeyEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtTest</Library> + <Name>QTest</Name> + </item> + <item Type="Qt4Class" > + <Library>QtTest</Library> + <Name>QTestAccessibility</Name> + </item> + <item Type="Qt4Class" > + <Library>QtTest</Library> + <Name>QTestAccessibilityEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtTest</Library> + <Name>QTestData</Name> + </item> + <item Type="Qt4Class" > + <Library>QtTest</Library> + <Name>QTestDelayEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtTest</Library> + <Name>QTestEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtTest</Library> + <Name>QTestEventList</Name> + </item> + <item Type="Qt4Class" > + <Library>QtTest</Library> + <Name>QTestEventLoop</Name> + </item> + <item Type="Qt4Class" > + <Library>QtTest</Library> + <Name>QTestKeyClicksEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtTest</Library> + <Name>QTestKeyEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtTest</Library> + <Name>QTestMouseEvent</Name> + </item> + <item Type="Qt4Class" > + <Library>QtUiTools</Library> + <Name>QUiLoader</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QDomAttr</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QDomCDATASection</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QDomCharacterData</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QDomComment</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QDomDocument</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QDomDocumentFragment</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QDomDocumentType</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QDomElement</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QDomEntity</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QDomEntityReference</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QDomImplementation</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QDomNamedNodeMap</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QDomNode</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QDomNodeList</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QDomNotation</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QDomProcessingInstruction</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QDomText</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QXmlAttributes</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QXmlContentHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QXmlDeclHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QXmlDefaultHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QXmlDTDHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QXmlEntityResolver</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QXmlErrorHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QXmlInputSource</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QXmlLexicalHandler</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QXmlLocator</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QXmlNamespaceSupport</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QXmlParseException</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QXmlReader</Name> + </item> + <item Type="Qt4Class" > + <Library>QtXml</Library> + <Name>QXmlSimpleReader</Name> + </item> + <item Type="qt3Header" >jri.h</item> + <item Type="qt3Header" >jri_md.h</item> + <item Type="qt3Header" >jritypes.h</item> + <item Type="qt3Header" >moc_yacc.h</item> + <item Type="qt3Header" >mwerks_mac.h</item> + <item Type="qt3Header" >npapi.h</item> + <item Type="qt3Header" >npupp.h</item> + <item Type="qt3Header" >q1xcompatibility.h</item> + <item Type="qt3Header" >qabstractlayout.h</item> + <item Type="qt3Header" >qaccel.h</item> + <item Type="qt3Header" >qaccessible.h</item> + <item Type="qt3Header" >qaction.h</item> + <item Type="qt3Header" >qapp.h</item> + <item Type="qt3Header" >qapplication.h</item> + <item Type="qt3Header" >qaquastyle.h</item> + <item Type="qt3Header" >qarray.h</item> + <item Type="qt3Header" >qasciicache.h</item> + <item Type="qt3Header" >qasciidict.h</item> + <item Type="qt3Header" >qassistantclient.h</item> + <item Type="qt3Header" >qasyncimageio.h</item> + <item Type="qt3Header" >qasyncio.h</item> + <item Type="qt3Header" >qaxbase.h</item> + <item Type="qt3Header" >qaxbindable.h</item> + <item Type="qt3Header" >qaxfactory.h</item> + <item Type="qt3Header" >qaxobject.h</item> + <item Type="qt3Header" >qaxscript.h</item> + <item Type="qt3Header" >qaxwidget.h</item> + <item Type="qt3Header" >qbig5codec.h</item> + <item Type="qt3Header" >qbitarray.h</item> + <item Type="qt3Header" >qbitarry.h</item> + <item Type="qt3Header" >qbitmap.h</item> + <item Type="qt3Header" >qbrush.h</item> + <item Type="qt3Header" >qbttngrp.h</item> + <item Type="qt3Header" >qbuffer.h</item> + <item Type="qt3Header" >qbutton.h</item> + <item Type="qt3Header" >qbuttongroup.h</item> + <item Type="qt3Header" >qcache.h</item> + <item Type="qt3Header" >qcanvas.h</item> + <item Type="qt3Header" >qcdestyle.h</item> + <item Type="qt3Header" >qcheckbox.h</item> + <item Type="qt3Header" >qchkbox.h</item> + <item Type="qt3Header" >qcleanuphandler.h</item> + <item Type="qt3Header" >qclipboard.h</item> + <item Type="qt3Header" >qclipbrd.h</item> + <item Type="qt3Header" >qcollect.h</item> + <item Type="qt3Header" >qcollection.h</item> + <item Type="qt3Header" >qcolor.h</item> + <item Type="qt3Header" >qcolordialog.h</item> + <item Type="qt3Header" >qcombo.h</item> + <item Type="qt3Header" >qcombobox.h</item> + <item Type="qt3Header" >qcommonstyle.h</item> + <item Type="qt3Header" >qcompactstyle.h</item> + <item Type="qt3Header" >qconfig-dist.h</item> + <item Type="qt3Header" >qconfig-large.h</item> + <item Type="qt3Header" >qconfig-medium.h</item> + <item Type="qt3Header" >qconfig-minimal.h</item> + <item Type="qt3Header" >qconfig-small.h</item> + <item Type="qt3Header" >qconfig.h</item> + <item Type="qt3Header" >qconnect.h</item> + <item Type="qt3Header" >qconnection.h</item> + <item Type="qt3Header" >qcopchannel_qws.h</item> + <item Type="qt3Header" >qcstring.h</item> + <item Type="qt3Header" >qcursor.h</item> + <item Type="qt3Header" >qdatabrowser.h</item> + <item Type="qt3Header" >qdatastream.h</item> + <item Type="qt3Header" >qdatatable.h</item> + <item Type="qt3Header" >qdataview.h</item> + <item Type="qt3Header" >qdatetime.h</item> + <item Type="qt3Header" >qdatetimeedit.h</item> + <item Type="qt3Header" >qdatetm.h</item> + <item Type="qt3Header" >qdeepcopy.h</item> + <item Type="qt3Header" >qdesktopwidget.h</item> + <item Type="qt3Header" >qdial.h</item> + <item Type="qt3Header" >qdialog.h</item> + <item Type="qt3Header" >qdict.h</item> + <item Type="qt3Header" >qdir.h</item> + <item Type="qt3Header" >qdirectpainter_qws.h</item> + <item Type="qt3Header" >qdns.h</item> + <item Type="qt3Header" >qdockarea.h</item> + <item Type="qt3Header" >qdockwindow.h</item> + <item Type="qt3Header" >qdom.h</item> + <item Type="qt3Header" >qdragobject.h</item> + <item Type="qt3Header" >qdrawutil.h</item> + <item Type="qt3Header" >qdrawutl.h</item> + <item Type="qt3Header" >qdropsite.h</item> + <item Type="qt3Header" >qdstream.h</item> + <item Type="qt3Header" >qeditorfactory.h</item> + <item Type="qt3Header" >qerrormessage.h</item> + <item Type="qt3Header" >qeucjpcodec.h</item> + <item Type="qt3Header" >qeuckrcodec.h</item> + <item Type="qt3Header" >qevent.h</item> + <item Type="qt3Header" >qeventloop.h</item> + <item Type="qt3Header" >qfeatures.h</item> + <item Type="qt3Header" >qfile.h</item> + <item Type="qt3Header" >qfiledef.h</item> + <item Type="qt3Header" >qfiledialog.h</item> + <item Type="qt3Header" >qfiledlg.h</item> + <item Type="qt3Header" >qfileinf.h</item> + <item Type="qt3Header" >qfileinfo.h</item> + <item Type="qt3Header" >qfocusdata.h</item> + <item Type="qt3Header" >qfont.h</item> + <item Type="qt3Header" >qfontdatabase.h</item> + <item Type="qt3Header" >qfontdialog.h</item> + <item Type="qt3Header" >qfontfactorybdf_qws.h</item> + <item Type="qt3Header" >qfontfactoryttf_qws.h</item> + <item Type="qt3Header" >qfontinf.h</item> + <item Type="qt3Header" >qfontinfo.h</item> + <item Type="qt3Header" >qfontmanager_qws.h</item> + <item Type="qt3Header" >qfontmet.h</item> + <item Type="qt3Header" >qfontmetrics.h</item> + <item Type="qt3Header" >qframe.h</item> + <item Type="qt3Header" >qftp.h</item> + <item Type="qt3Header" >qfunctions_wce.h</item> + <item Type="qt3Header" >qgarray.h</item> + <item Type="qt3Header" >qgb18030codec.h</item> + <item Type="qt3Header" >qgbkcodec.h</item> + <item Type="qt3Header" >qgcache.h</item> + <item Type="qt3Header" >qgdict.h</item> + <item Type="qt3Header" >qgeneric.h</item> + <item Type="qt3Header" >qgfx_qws.h</item> + <item Type="qt3Header" >qgfxdriverfactory_qws.h</item> + <item Type="qt3Header" >qgfxdriverplugin_qws.h</item> + <item Type="qt3Header" >qgfxlinuxfb_qws.h</item> + <item Type="qt3Header" >qgfxmach64_qws.h</item> + <item Type="qt3Header" >qgfxmach64defs_qws.h</item> + <item Type="qt3Header" >qgfxmatrox_qws.h</item> + <item Type="qt3Header" >qgfxmatroxdefs_qws.h</item> + <item Type="qt3Header" >qgfxraster_qws.h</item> + <item Type="qt3Header" >qgfxrepeater_qws.h</item> + <item Type="qt3Header" >qgfxshadowfb_qws.h</item> + <item Type="qt3Header" >qgfxsnap_qws.h</item> + <item Type="qt3Header" >qgfxtransformed_qws.h</item> + <item Type="qt3Header" >qgfxvfb_qws.h</item> + <item Type="qt3Header" >qgfxvga16_qws.h</item> + <item Type="qt3Header" >qgfxvnc_qws.h</item> + <item Type="qt3Header" >qgfxvoodoo_qws.h</item> + <item Type="qt3Header" >qgfxvoodoodefs_qws.h</item> + <item Type="qt3Header" >qgif.h</item> + <item Type="qt3Header" >qgl.h</item> + <item Type="qt3Header" >qglcolormap.h</item> + <item Type="qt3Header" >qglist.h</item> + <item Type="qt3Header" >qglobal.h</item> + <item Type="qt3Header" >qgplugin.h</item> + <item Type="qt3Header" >qgrid.h</item> + <item Type="qt3Header" >qgridview.h</item> + <item Type="qt3Header" >qgroupbox.h</item> + <item Type="qt3Header" >qgrpbox.h</item> + <item Type="qt3Header" >qguardedptr.h</item> + <item Type="qt3Header" >qgvector.h</item> + <item Type="qt3Header" >qhbox.h</item> + <item Type="qt3Header" >qhbuttongroup.h</item> + <item Type="qt3Header" >qheader.h</item> + <item Type="qt3Header" >qhgroupbox.h</item> + <item Type="qt3Header" >qhostaddress.h</item> + <item Type="qt3Header" >qhttp.h</item> + <item Type="qt3Header" >qiconset.h</item> + <item Type="qt3Header" >qiconview.h</item> + <item Type="qt3Header" >qimage.h</item> + <item Type="qt3Header" >qimageformatplugin.h</item> + <item Type="qt3Header" >qinputdialog.h</item> + <item Type="qt3Header" >qintcach.h</item> + <item Type="qt3Header" >qintcache.h</item> + <item Type="qt3Header" >qintdict.h</item> + <item Type="qt3Header" >qinterlacestyle.h</item> + <item Type="qt3Header" >qiodev.h</item> + <item Type="qt3Header" >qiodevice.h</item> + <item Type="qt3Header" >qjiscodec.h</item> + <item Type="qt3Header" >qjpegio.h</item> + <item Type="qt3Header" >qjpunicode.h</item> + <item Type="qt3Header" >qkbd_qws.h</item> + <item Type="qt3Header" >qkbddriverfactory_qws.h</item> + <item Type="qt3Header" >qkbddriverplugin_qws.h</item> + <item Type="qt3Header" >qkbdpc101_qws.h</item> + <item Type="qt3Header" >qkbdsl5000_qws.h</item> + <item Type="qt3Header" >qkbdtty_qws.h</item> + <item Type="qt3Header" >qkbdusb_qws.h</item> + <item Type="qt3Header" >qkbdvr41xx_qws.h</item> + <item Type="qt3Header" >qkbdyopy_qws.h</item> + <item Type="qt3Header" >qkeyboard_qws.h</item> + <item Type="qt3Header" >qkeycode.h</item> + <item Type="qt3Header" >qkeysequence.h</item> + <item Type="qt3Header" >qlabel.h</item> + <item Type="qt3Header" >qlayout.h</item> + <item Type="qt3Header" >qlcdnum.h</item> + <item Type="qt3Header" >qlcdnumber.h</item> + <item Type="qt3Header" >qlibrary.h</item> + <item Type="qt3Header" >qlined.h</item> + <item Type="qt3Header" >qlineedit.h</item> + <item Type="qt3Header" >qlist.h</item> + <item Type="qt3Header" >qlistbox.h</item> + <item Type="qt3Header" >qlistview.h</item> + <item Type="qt3Header" >qlocale.h</item> + <item Type="qt3Header" >qlocalfs.h</item> + <item Type="qt3Header" >qmacstyle_mac.h</item> + <item Type="qt3Header" >qmainwindow.h</item> + <item Type="qt3Header" >qmap.h</item> + <item Type="qt3Header" >qmemarray.h</item> + <item Type="qt3Header" >qmemorymanager_qws.h</item> + <item Type="qt3Header" >qmenubar.h</item> + <item Type="qt3Header" >qmenudata.h</item> + <item Type="qt3Header" >qmenudta.h</item> + <item Type="qt3Header" >qmessagebox.h</item> + <item Type="qt3Header" >qmetaobj.h</item> + <item Type="qt3Header" >qmetaobject.h</item> + <item Type="qt3Header" >qmime.h</item> + <item Type="qt3Header" >qmlined.h</item> + <item Type="qt3Header" >qmngio.h</item> + <item Type="qt3Header" >qmodules.h</item> + <item Type="qt3Header" >qmotif.h</item> + <item Type="qt3Header" >qmotifdialog.h</item> + <item Type="qt3Header" >qmotifplusstyle.h</item> + <item Type="qt3Header" >qmotifstyle.h</item> + <item Type="qt3Header" >qmotifwidget.h</item> + <item Type="qt3Header" >qmouse_qws.h</item> + <item Type="qt3Header" >qmousebus_qws.h</item> + <item Type="qt3Header" >qmousedriverfactory_qws.h</item> + <item Type="qt3Header" >qmousedriverplugin_qws.h</item> + <item Type="qt3Header" >qmouselinuxtp_qws.h</item> + <item Type="qt3Header" >qmousepc_qws.h</item> + <item Type="qt3Header" >qmousevr41xx_qws.h</item> + <item Type="qt3Header" >qmouseyopy_qws.h</item> + <item Type="qt3Header" >qmovie.h</item> + <item Type="qt3Header" >qmsgbox.h</item> + <item Type="qt3Header" >qmultilinedit.h</item> + <item Type="qt3Header" >qmultilineedit.h</item> + <item Type="qt3Header" >qmutex.h</item> + <item Type="qt3Header" >qnamespace.h</item> + <item Type="qt3Header" >qnetwork.h</item> + <item Type="qt3Header" >qnetworkprotocol.h</item> + <item Type="qt3Header" >qnp.h</item> + <item Type="qt3Header" >qobjcoll.h</item> + <item Type="qt3Header" >qobjdefs.h</item> + <item Type="qt3Header" >qobject.h</item> + <item Type="qt3Header" >qobjectcleanuphandler.h</item> + <item Type="qt3Header" >qobjectdefs.h</item> + <item Type="qt3Header" >qobjectdict.h</item> + <item Type="qt3Header" >qobjectlist.h</item> + <item Type="qt3Header" >qpaintd.h</item> + <item Type="qt3Header" >qpaintdc.h</item> + <item Type="qt3Header" >qpaintdevice.h</item> + <item Type="qt3Header" >qpaintdevicedefs.h</item> + <item Type="qt3Header" >qpaintdevicemetrics.h</item> + <item Type="qt3Header" >qpainter.h</item> + <item Type="qt3Header" >qpair.h</item> + <item Type="qt3Header" >qpalette.h</item> + <item Type="qt3Header" >qpdevmet.h</item> + <item Type="qt3Header" >qpen.h</item> + <item Type="qt3Header" >qpicture.h</item> + <item Type="qt3Header" >qpixmap.h</item> + <item Type="qt3Header" >qpixmapcache.h</item> + <item Type="qt3Header" >qplatinumstyle.h</item> + <item Type="qt3Header" >qpmcache.h</item> + <item Type="qt3Header" >qpngio.h</item> + <item Type="qt3Header" >qpntarry.h</item> + <item Type="qt3Header" >qpocketpcstyle_wce.h</item> + <item Type="qt3Header" >qpoint.h</item> + <item Type="qt3Header" >qpointarray.h</item> + <item Type="qt3Header" >qpolygonscanner.h</item> + <item Type="qt3Header" >qpopmenu.h</item> + <item Type="qt3Header" >qpopupmenu.h</item> + <item Type="qt3Header" >qprintdialog.h</item> + <item Type="qt3Header" >qprinter.h</item> + <item Type="qt3Header" >qprndlg.h</item> + <item Type="qt3Header" >qprocess.h</item> + <item Type="qt3Header" >qprogbar.h</item> + <item Type="qt3Header" >qprogdlg.h</item> + <item Type="qt3Header" >qprogressbar.h</item> + <item Type="qt3Header" >qprogressdialog.h</item> + <item Type="qt3Header" >qpsprn.h</item> + <item Type="qt3Header" >qptrcollection.h</item> + <item Type="qt3Header" >qptrdict.h</item> + <item Type="qt3Header" >qptrlist.h</item> + <item Type="qt3Header" >qptrqueue.h</item> + <item Type="qt3Header" >qptrstack.h</item> + <item Type="qt3Header" >qptrvector.h</item> + <item Type="qt3Header" >qpushbt.h</item> + <item Type="qt3Header" >qpushbutton.h</item> + <item Type="qt3Header" >qqueue.h</item> + <item Type="qt3Header" >qradiobt.h</item> + <item Type="qt3Header" >qradiobutton.h</item> + <item Type="qt3Header" >qrangecontrol.h</item> + <item Type="qt3Header" >qrangect.h</item> + <item Type="qt3Header" >qrect.h</item> + <item Type="qt3Header" >qregexp.h</item> + <item Type="qt3Header" >qregion.h</item> + <item Type="qt3Header" >qrtlcodec.h</item> + <item Type="qt3Header" >qscrbar.h</item> + <item Type="qt3Header" >qscrollbar.h</item> + <item Type="qt3Header" >qscrollview.h</item> + <item Type="qt3Header" >qsemaphore.h</item> + <item Type="qt3Header" >qsemimodal.h</item> + <item Type="qt3Header" >qserversocket.h</item> + <item Type="qt3Header" >qsession.h</item> + <item Type="qt3Header" >qsessionmanager.h</item> + <item Type="qt3Header" >qsettings.h</item> + <item Type="qt3Header" >qsgistyle.h</item> + <item Type="qt3Header" >qshared.h</item> + <item Type="qt3Header" >qsignal.h</item> + <item Type="qt3Header" >qsignalmapper.h</item> + <item Type="qt3Header" >qsignalslotimp.h</item> + <item Type="qt3Header" >qsimplerichtext.h</item> + <item Type="qt3Header" >qsize.h</item> + <item Type="qt3Header" >qsizegrip.h</item> + <item Type="qt3Header" >qsizepolicy.h</item> + <item Type="qt3Header" >qsjiscodec.h</item> + <item Type="qt3Header" >qslider.h</item> + <item Type="qt3Header" >qsocket.h</item> + <item Type="qt3Header" >qsocketdevice.h</item> + <item Type="qt3Header" >qsocketnotifier.h</item> + <item Type="qt3Header" >qsocknot.h</item> + <item Type="qt3Header" >qsortedlist.h</item> + <item Type="qt3Header" >qsound.h</item> + <item Type="qt3Header" >qsoundqss_qws.h</item> + <item Type="qt3Header" >qspinbox.h</item> + <item Type="qt3Header" >qsplashscreen.h</item> + <item Type="qt3Header" >qsplitter.h</item> + <item Type="qt3Header" >qsql.h</item> + <item Type="qt3Header" >qsqlcursor.h</item> + <item Type="qt3Header" >qsqldatabase.h</item> + <item Type="qt3Header" >qsqldriver.h</item> + <item Type="qt3Header" >qsqldriverplugin.h</item> + <item Type="qt3Header" >qsqleditorfactory.h</item> + <item Type="qt3Header" >qsqlerror.h</item> + <item Type="qt3Header" >qsqlfield.h</item> + <item Type="qt3Header" >qsqlform.h</item> + <item Type="qt3Header" >qsqlindex.h</item> + <item Type="qt3Header" >qsqlpropertymap.h</item> + <item Type="qt3Header" >qsqlquery.h</item> + <item Type="qt3Header" >qsqlrecord.h</item> + <item Type="qt3Header" >qsqlresult.h</item> + <item Type="qt3Header" >qsqlselectcursor.h</item> + <item Type="qt3Header" >qstack.h</item> + <item Type="qt3Header" >qstatusbar.h</item> + <item Type="qt3Header" >qstring.h</item> + <item Type="qt3Header" >qstringlist.h</item> + <item Type="qt3Header" >qstrlist.h</item> + <item Type="qt3Header" >qstrvec.h</item> + <item Type="qt3Header" >qstyle.h</item> + <item Type="qt3Header" >qstylefactory.h</item> + <item Type="qt3Header" >qstyleplugin.h</item> + <item Type="qt3Header" >qstylesheet.h</item> + <item Type="qt3Header" >qsyntaxhighlighter.h</item> + <item Type="qt3Header" >qt.h</item> + <item Type="qt3Header" >qt_mac.h</item> + <item Type="qt3Header" >qt_mac9.h</item> + <item Type="qt3Header" >qt_windows.h</item> + <item Type="qt3Header" >qtabbar.h</item> + <item Type="qt3Header" >qtabdialog.h</item> + <item Type="qt3Header" >qtabdlg.h</item> + <item Type="qt3Header" >qtable.h</item> + <item Type="qt3Header" >qtabwidget.h</item> + <item Type="qt3Header" >qtextbrowser.h</item> + <item Type="qt3Header" >qtextcodec.h</item> + <item Type="qt3Header" >qtextcodecfactory.h</item> + <item Type="qt3Header" >qtextcodecplugin.h</item> + <item Type="qt3Header" >qtextedit.h</item> + <item Type="qt3Header" >qtextstream.h</item> + <item Type="qt3Header" >qtextview.h</item> + <item Type="qt3Header" >qthread.h</item> + <item Type="qt3Header" >qthreadstorage.h</item> + <item Type="qt3Header" >qtimer.h</item> + <item Type="qt3Header" >qtl.h</item> + <item Type="qt3Header" >qtoolbar.h</item> + <item Type="qt3Header" >qtoolbox.h</item> + <item Type="qt3Header" >qtoolbutton.h</item> + <item Type="qt3Header" >qtooltip.h</item> + <item Type="qt3Header" >qtranslator.h</item> + <item Type="qt3Header" >qtsciicodec.h</item> + <item Type="qt3Header" >qtstream.h</item> + <item Type="qt3Header" >qurl.h</item> + <item Type="qt3Header" >qurlinfo.h</item> + <item Type="qt3Header" >qurloperator.h</item> + <item Type="qt3Header" >qutfcodec.h</item> + <item Type="qt3Header" >quuid.h</item> + <item Type="qt3Header" >qvalidator.h</item> + <item Type="qt3Header" >qvaluelist.h</item> + <item Type="qt3Header" >qvaluestack.h</item> + <item Type="qt3Header" >qvaluevector.h</item> + <item Type="qt3Header" >qvariant.h</item> + <item Type="qt3Header" >qvbox.h</item> + <item Type="qt3Header" >qvbuttongroup.h</item> + <item Type="qt3Header" >qvector.h</item> + <item Type="qt3Header" >qvfbhdr.h</item> + <item Type="qt3Header" >qvgroupbox.h</item> + <item Type="qt3Header" >qwaitcondition.h</item> + <item Type="qt3Header" >qwhatsthis.h</item> + <item Type="qt3Header" >qwidcoll.h</item> + <item Type="qt3Header" >qwidget.h</item> + <item Type="qt3Header" >qwidgetfactory.h</item> + <item Type="qt3Header" >qwidgetintdict.h</item> + <item Type="qt3Header" >qwidgetlist.h</item> + <item Type="qt3Header" >qwidgetplugin.h</item> + <item Type="qt3Header" >qwidgetstack.h</item> + <item Type="qt3Header" >qwindefs.h</item> + <item Type="qt3Header" >qwindow.h</item> + <item Type="qt3Header" >qwindowdefs.h</item> + <item Type="qt3Header" >qwindowdefs_win.h</item> + <item Type="qt3Header" >qwindowsstyle.h</item> + <item Type="qt3Header" >qwindowsxpstyle.h</item> + <item Type="qt3Header" >qwindowsystem_qws.h</item> + <item Type="qt3Header" >qwinexport.h</item> + <item Type="qt3Header" >qwinfunctions_wce.h</item> + <item Type="qt3Header" >qwizard.h</item> + <item Type="qt3Header" >qwmatrix.h</item> + <item Type="qt3Header" >qworkspace.h</item> + <item Type="qt3Header" >qwsbeosdecoration_qws.h</item> + <item Type="qt3Header" >qwscommand_qws.h</item> + <item Type="qt3Header" >qwscursor_qws.h</item> + <item Type="qt3Header" >qwsdecoration_qws.h</item> + <item Type="qt3Header" >qwsdefaultdecoration_qws.h</item> + <item Type="qt3Header" >qwsdisplay_qws.h</item> + <item Type="qt3Header" >qwsevent_qws.h</item> + <item Type="qt3Header" >qwsgfx_qnx6.h</item> + <item Type="qt3Header" >qwshydrodecoration_qws.h</item> + <item Type="qt3Header" >qwskde2decoration_qws.h</item> + <item Type="qt3Header" >qwskdedecoration_qws.h</item> + <item Type="qt3Header" >qwskeyboard_qnx4.h</item> + <item Type="qt3Header" >qwsmanager_qws.h</item> + <item Type="qt3Header" >qwsmouse_qnx4.h</item> + <item Type="qt3Header" >qwsproperty_qws.h</item> + <item Type="qt3Header" >qwsregionmanager_qws.h</item> + <item Type="qt3Header" >qwssocket_qws.h</item> + <item Type="qt3Header" >qwsutils_qws.h</item> + <item Type="qt3Header" >qwswindowsdecoration_qws.h</item> + <item Type="qt3Header" >qxml.h</item> + <item Type="qt3Header" >qxt.h</item> + <item Type="qt3Header" >qxtwidget.h</item> + <item Type="qt4Header" >Q3Accel</item> + <item Type="qt4Header" >Q3Action</item> + <item Type="qt4Header" >Q3ActionGroup</item> + <item Type="qt4Header" >Q3AsciiBucket</item> + <item Type="qt4Header" >Q3AsciiCache</item> + <item Type="qt4Header" >Q3AsciiCacheIterator</item> + <item Type="qt4Header" >Q3AsciiDict</item> + <item Type="qt4Header" >Q3AsciiDictIterator</item> + <item Type="qt4Header" >Q3BaseBucket</item> + <item Type="qt4Header" >Q3BoxLayout</item> + <item Type="qt4Header" >Q3Button</item> + <item Type="qt4Header" >Q3ButtonGroup</item> + <item Type="qt4Header" >Q3CString</item> + <item Type="qt4Header" >Q3Cache</item> + <item Type="qt4Header" >Q3CacheIterator</item> + <item Type="qt4Header" >Q3Canvas</item> + <item Type="qt4Header" >Q3CanvasEllipse</item> + <item Type="qt4Header" >Q3CanvasItem</item> + <item Type="qt4Header" >Q3CanvasItemList</item> + <item Type="qt4Header" >Q3CanvasLine</item> + <item Type="qt4Header" >Q3CanvasPixmap</item> + <item Type="qt4Header" >Q3CanvasPixmapArray</item> + <item Type="qt4Header" >Q3CanvasPolygon</item> + <item Type="qt4Header" >Q3CanvasPolygonalItem</item> + <item Type="qt4Header" >Q3CanvasRectangle</item> + <item Type="qt4Header" >Q3CanvasSpline</item> + <item Type="qt4Header" >Q3CanvasSprite</item> + <item Type="qt4Header" >Q3CanvasText</item> + <item Type="qt4Header" >Q3CanvasView</item> + <item Type="qt4Header" >Q3CheckListItem</item> + <item Type="qt4Header" >Q3CheckTableItem</item> + <item Type="qt4Header" >Q3CleanupHandler</item> + <item Type="qt4Header" >Q3ColorDrag</item> + <item Type="qt4Header" >Q3ComboBox</item> + <item Type="qt4Header" >Q3ComboTableItem</item> + <item Type="qt4Header" >Q3DataBrowser</item> + <item Type="qt4Header" >Q3DataTable</item> + <item Type="qt4Header" >Q3DataView</item> + <item Type="qt4Header" >Q3DateEdit</item> + <item Type="qt4Header" >Q3DateTimeEdit</item> + <item Type="qt4Header" >Q3DateTimeEditBase</item> + <item Type="qt4Header" >Q3DeepCopy</item> + <item Type="qt4Header" >Q3Dict</item> + <item Type="qt4Header" >Q3DictIterator</item> + <item Type="qt4Header" >Q3Dns</item> + <item Type="qt4Header" >Q3DnsSocket</item> + <item Type="qt4Header" >Q3DockArea</item> + <item Type="qt4Header" >Q3DockAreaLayout</item> + <item Type="qt4Header" >Q3DockWindow</item> + <item Type="qt4Header" >Q3DragObject</item> + <item Type="qt4Header" >Q3DropSite</item> + <item Type="qt4Header" >Q3EditorFactory</item> + <item Type="qt4Header" >Q3FileDialog</item> + <item Type="qt4Header" >Q3FileIconProvider</item> + <item Type="qt4Header" >Q3FilePreview</item> + <item Type="qt4Header" >Q3Frame</item> + <item Type="qt4Header" >Q3Ftp</item> + <item Type="qt4Header" >Q3GArray</item> + <item Type="qt4Header" >Q3GCache</item> + <item Type="qt4Header" >Q3GCacheIterator</item> + <item Type="qt4Header" >Q3GDict</item> + <item Type="qt4Header" >Q3GDictIterator</item> + <item Type="qt4Header" >Q3GList</item> + <item Type="qt4Header" >Q3GListIterator</item> + <item Type="qt4Header" >Q3GListStdIterator</item> + <item Type="qt4Header" >Q3GVector</item> + <item Type="qt4Header" >Q3Grid</item> + <item Type="qt4Header" >Q3GridLayout</item> + <item Type="qt4Header" >Q3GridView</item> + <item Type="qt4Header" >Q3GroupBox</item> + <item Type="qt4Header" >Q3HBox</item> + <item Type="qt4Header" >Q3HBoxLayout</item> + <item Type="qt4Header" >Q3HButtonGroup</item> + <item Type="qt4Header" >Q3HGroupBox</item> + <item Type="qt4Header" >Q3Header</item> + <item Type="qt4Header" >Q3Http</item> + <item Type="qt4Header" >Q3HttpHeader</item> + <item Type="qt4Header" >Q3HttpRequestHeader</item> + <item Type="qt4Header" >Q3HttpResponseHeader</item> + <item Type="qt4Header" >Q3IconDrag</item> + <item Type="qt4Header" >Q3IconDragItem</item> + <item Type="qt4Header" >Q3IconView</item> + <item Type="qt4Header" >Q3IconViewItem</item> + <item Type="qt4Header" >Q3ImageDrag</item> + <item Type="qt4Header" >Q3IntBucket</item> + <item Type="qt4Header" >Q3IntCache</item> + <item Type="qt4Header" >Q3IntCacheIterator</item> + <item Type="qt4Header" >Q3IntDict</item> + <item Type="qt4Header" >Q3IntDictIterator</item> + <item Type="qt4Header" >Q3LNode</item> + <item Type="qt4Header" >Q3ListBox</item> + <item Type="qt4Header" >Q3ListBoxItem</item> + <item Type="qt4Header" >Q3ListBoxPixmap</item> + <item Type="qt4Header" >Q3ListBoxText</item> + <item Type="qt4Header" >Q3ListView</item> + <item Type="qt4Header" >Q3ListViewItem</item> + <item Type="qt4Header" >Q3ListViewItemIterator</item> + <item Type="qt4Header" >Q3LocalFs</item> + <item Type="qt4Header" >Q3MainWindow</item> + <item Type="qt4Header" >Q3MemArray</item> + <item Type="qt4Header" >Q3MimeSourceFactory</item> + <item Type="qt4Header" >Q3MultiLineEdit</item> + <item Type="qt4Header" >Q3NetworkOperation</item> + <item Type="qt4Header" >Q3NetworkProtocol</item> + <item Type="qt4Header" >Q3NetworkProtocolDict</item> + <item Type="qt4Header" >Q3NetworkProtocolFactory</item> + <item Type="qt4Header" >Q3NetworkProtocolFactoryBase</item> + <item Type="qt4Header" >Q3ObjectDictionary</item> + <item Type="qt4Header" >Q3PaintDeviceMetrics</item> + <item Type="qt4Header" >Q3Painter</item> + <item Type="qt4Header" >Q3Picture</item> + <item Type="qt4Header" >Q3PointArray</item> + <item Type="qt4Header" >Q3PolygonScanner</item> + <item Type="qt4Header" >Q3PopupMenu</item> + <item Type="qt4Header" >Q3Process</item> + <item Type="qt4Header" >Q3ProgressBar</item> + <item Type="qt4Header" >Q3ProgressDialog</item> + <item Type="qt4Header" >Q3PtrBucket</item> + <item Type="qt4Header" >Q3PtrCollection</item> + <item Type="qt4Header" >Q3PtrDict</item> + <item Type="qt4Header" >Q3PtrDictIterator</item> + <item Type="qt4Header" >Q3PtrList</item> + <item Type="qt4Header" >Q3PtrListIterator</item> + <item Type="qt4Header" >Q3PtrListStdIterator</item> + <item Type="qt4Header" >Q3PtrQueue</item> + <item Type="qt4Header" >Q3PtrStack</item> + <item Type="qt4Header" >Q3PtrVector</item> + <item Type="qt4Header" >Q3RangeControl</item> + <item Type="qt4Header" >Q3ScrollView</item> + <item Type="qt4Header" >Q3Semaphore</item> + <item Type="qt4Header" >Q3ServerSocket</item> + <item Type="qt4Header" >Q3Shared</item> + <item Type="qt4Header" >Q3Signal</item> + <item Type="qt4Header" >Q3SimpleRichText</item> + <item Type="qt4Header" >Q3SingleCleanupHandler</item> + <item Type="qt4Header" >Q3Socket</item> + <item Type="qt4Header" >Q3SocketDevice</item> + <item Type="qt4Header" >Q3SortedList</item> + <item Type="qt4Header" >Q3SpinWidget</item> + <item Type="qt4Header" >Q3SqlCursor</item> + <item Type="qt4Header" >Q3SqlEditorFactory</item> + <item Type="qt4Header" >Q3SqlFieldInfo</item> + <item Type="qt4Header" >Q3SqlFieldInfoList</item> + <item Type="qt4Header" >Q3SqlForm</item> + <item Type="qt4Header" >Q3SqlPropertyMap</item> + <item Type="qt4Header" >Q3SqlRecordInfo</item> + <item Type="qt4Header" >Q3SqlSelectCursor</item> + <item Type="qt4Header" >Q3StoredDrag</item> + <item Type="qt4Header" >Q3StrIList</item> + <item Type="qt4Header" >Q3StrIVec</item> + <item Type="qt4Header" >Q3StrList</item> + <item Type="qt4Header" >Q3StrListIterator</item> + <item Type="qt4Header" >Q3StrVec</item> + <item Type="qt4Header" >Q3StringBucket</item> + <item Type="qt4Header" >Q3StyleSheet</item> + <item Type="qt4Header" >Q3StyleSheetItem</item> + <item Type="qt4Header" >Q3SyntaxHighlighter</item> + <item Type="qt4Header" >Q3TSFUNC</item> + <item Type="qt4Header" >Q3TabDialog</item> + <item Type="qt4Header" >Q3Table</item> + <item Type="qt4Header" >Q3TableItem</item> + <item Type="qt4Header" >Q3TableSelection</item> + <item Type="qt4Header" >Q3TextBrowser</item> + <item Type="qt4Header" >Q3TextDrag</item> + <item Type="qt4Header" >Q3TextEdit</item> + <item Type="qt4Header" >Q3TextEditOptimPrivate</item> + <item Type="qt4Header" >Q3TextStream</item> + <item Type="qt4Header" >Q3TextView</item> + <item Type="qt4Header" >Q3TimeEdit</item> + <item Type="qt4Header" >Q3ToolBar</item> + <item Type="qt4Header" >Q3UriDrag</item> + <item Type="qt4Header" >Q3Url</item> + <item Type="qt4Header" >Q3UrlOperator</item> + <item Type="qt4Header" >Q3VBox</item> + <item Type="qt4Header" >Q3VBoxLayout</item> + <item Type="qt4Header" >Q3VButtonGroup</item> + <item Type="qt4Header" >Q3VGroupBox</item> + <item Type="qt4Header" >Q3ValueList</item> + <item Type="qt4Header" >Q3ValueListConstIterator</item> + <item Type="qt4Header" >Q3ValueListIterator</item> + <item Type="qt4Header" >Q3ValueStack</item> + <item Type="qt4Header" >Q3ValueVector</item> + <item Type="qt4Header" >Q3WhatsThis</item> + <item Type="qt4Header" >Q3WidgetStack</item> + <item Type="qt4Header" >Q3Wizard</item> + <item Type="qt4Header" >QAbstractButton</item> + <item Type="qt4Header" >QAbstractEventDispatcher</item> + <item Type="qt4Header" >QAbstractExtensionFactory</item> + <item Type="qt4Header" >QAbstractExtensionManager</item> + <item Type="qt4Header" >QAbstractFileEngine</item> + <item Type="qt4Header" >QAbstractFileEngineHandler</item> + <item Type="qt4Header" >QAbstractFormBuilder</item> + <item Type="qt4Header" >QAbstractGraphicsPathItem</item> + <item Type="qt4Header" >QAbstractGraphicsShapeItem</item> + <item Type="qt4Header" >QAbstractItemDelegate</item> + <item Type="qt4Header" >QAbstractItemModel</item> + <item Type="qt4Header" >QAbstractItemView</item> + <item Type="qt4Header" >QAbstractListModel</item> + <item Type="qt4Header" >QAbstractPageSetupDialog</item> + <item Type="qt4Header" >QAbstractPrintDialog</item> + <item Type="qt4Header" >QAbstractProxyModel</item> + <item Type="qt4Header" >QAbstractScrollArea</item> + <item Type="qt4Header" >QAbstractSlider</item> + <item Type="qt4Header" >QAbstractSocket</item> + <item Type="qt4Header" >QAbstractSpinBox</item> + <item Type="qt4Header" >QAbstractTableModel</item> + <item Type="qt4Header" >QAbstractTextDocumentLayout</item> + <item Type="qt4Header" >QAbstractUndoItem</item> + <item Type="qt4Header" >QAccessible</item> + <item Type="qt4Header" >QAccessibleApplication</item> + <item Type="qt4Header" >QAccessibleBridge</item> + <item Type="qt4Header" >QAccessibleBridgeFactoryInterface</item> + <item Type="qt4Header" >QAccessibleBridgePlugin</item> + <item Type="qt4Header" >QAccessibleEvent</item> + <item Type="qt4Header" >QAccessibleFactoryInterface</item> + <item Type="qt4Header" >QAccessibleInterface</item> + <item Type="qt4Header" >QAccessibleInterfaceEx</item> + <item Type="qt4Header" >QAccessibleObject</item> + <item Type="qt4Header" >QAccessibleObjectEx</item> + <item Type="qt4Header" >QAccessiblePlugin</item> + <item Type="qt4Header" >QAccessibleWidget</item> + <item Type="qt4Header" >QAccessibleWidgetEx</item> + <item Type="qt4Header" >QAction</item> + <item Type="qt4Header" >QActionEvent</item> + <item Type="qt4Header" >QActionGroup</item> + <item Type="qt4Header" >QApplication</item> + <item Type="qt4Header" >QArgument</item> + <item Type="qt4Header" >QAssistantClient</item> + <item Type="qt4Header" >QAtomic</item> + <item Type="qt4Header" >QAtomicPointer</item> + <item Type="qt4Header" >QAxAggregated</item> + <item Type="qt4Header" >QAxBase</item> + <item Type="qt4Header" >QAxBindable</item> + <item Type="qt4Header" >QAxClass</item> + <item Type="qt4Header" >QAxFactory</item> + <item Type="qt4Header" >QAxObject</item> + <item Type="qt4Header" >QAxScript</item> + <item Type="qt4Header" >QAxScriptEngine</item> + <item Type="qt4Header" >QAxScriptManager</item> + <item Type="qt4Header" >QAxSelect</item> + <item Type="qt4Header" >QAxWidget</item> + <item Type="qt4Header" >QBasicAtomic</item> + <item Type="qt4Header" >QBasicAtomicPointer</item> + <item Type="qt4Header" >QBasicTimer</item> + <item Type="qt4Header" >QBitArray</item> + <item Type="qt4Header" >QBitRef</item> + <item Type="qt4Header" >QBitmap</item> + <item Type="qt4Header" >QBool</item> + <item Type="qt4Header" >QBoxLayout</item> + <item Type="qt4Header" >QBrush</item> + <item Type="qt4Header" >QBrushData</item> + <item Type="qt4Header" >QBuffer</item> + <item Type="qt4Header" >QButtonGroup</item> + <item Type="qt4Header" >QByteArray</item> + <item Type="qt4Header" >QByteArrayMatcher</item> + <item Type="qt4Header" >QByteRef</item> + <item Type="qt4Header" >QCDEStyle</item> + <item Type="qt4Header" >QCOORD</item> + <item Type="qt4Header" >QCache</item> + <item Type="qt4Header" >QCalendarWidget</item> + <item Type="qt4Header" >QChar</item> + <item Type="qt4Header" >QCharRef</item> + <item Type="qt4Header" >QCheckBox</item> + <item Type="qt4Header" >QChildEvent</item> + <item Type="qt4Header" >QCleanLooksStyle</item> + <item Type="qt4Header" >QCleanlooksStyle</item> + <item Type="qt4Header" >QClipboard</item> + <item Type="qt4Header" >QClipboardEvent</item> + <item Type="qt4Header" >QCloseEvent</item> + <item Type="qt4Header" >QColor</item> + <item Type="qt4Header" >QColorDialog</item> + <item Type="qt4Header" >QColorGroup</item> + <item Type="qt4Header" >QColormap</item> + <item Type="qt4Header" >QComboBox</item> + <item Type="qt4Header" >QCommonStyle</item> + <item Type="qt4Header" >QCompleter</item> + <item Type="qt4Header" >QConicalGradient</item> + <item Type="qt4Header" >QConstString</item> + <item Type="qt4Header" >QContextMenuEvent</item> + <item Type="qt4Header" >QCopChannel</item> + <item Type="qt4Header" >QCoreApplication</item> + <item Type="qt4Header" >QCursor</item> + <item Type="qt4Header" >QCursorShape</item> + <item Type="qt4Header" >QCustomEvent</item> + <item Type="qt4Header" >QDB2Driver</item> + <item Type="qt4Header" >QDB2Result</item> + <item Type="qt4Header" >QDBusAbstractAdaptor</item> + <item Type="qt4Header" >QDBusAbstractInterface</item> + <item Type="qt4Header" >QDBusArgument</item> + <item Type="qt4Header" >QDBusConnection</item> + <item Type="qt4Header" >QDBusConnectionInterface</item> + <item Type="qt4Header" >QDBusError</item> + <item Type="qt4Header" >QDBusInterface</item> + <item Type="qt4Header" >QDBusInterfacePtr</item> + <item Type="qt4Header" >QDBusMessage</item> + <item Type="qt4Header" >QDBusMetaType</item> + <item Type="qt4Header" >QDBusObjectPath</item> + <item Type="qt4Header" >QDBusReply</item> + <item Type="qt4Header" >QDBusServer</item> + <item Type="qt4Header" >QDBusSignature</item> + <item Type="qt4Header" >QDBusVariant</item> + <item Type="qt4Header" >QDataStream</item> + <item Type="qt4Header" >QDataWidgetMapper</item> + <item Type="qt4Header" >QDate</item> + <item Type="qt4Header" >QDateEdit</item> + <item Type="qt4Header" >QDateTime</item> + <item Type="qt4Header" >QDateTimeEdit</item> + <item Type="qt4Header" >QDebug</item> + <item Type="qt4Header" >QDecoration</item> + <item Type="qt4Header" >QDecorationAction</item> + <item Type="qt4Header" >QDecorationDefault</item> + <item Type="qt4Header" >QDecorationFactory</item> + <item Type="qt4Header" >QDecorationFactoryInterface</item> + <item Type="qt4Header" >QDecorationPlugin</item> + <item Type="qt4Header" >QDecorationStyled</item> + <item Type="qt4Header" >QDecorationWindows</item> + <item Type="qt4Header" >QDesignerActionEditorInterface</item> + <item Type="qt4Header" >QDesignerBrushManagerInterface</item> + <item Type="qt4Header" >QDesignerComponents</item> + <item Type="qt4Header" >QDesignerContainerExtension</item> + <item Type="qt4Header" >QDesignerCustomWidgetCollectionInterface</item> + <item Type="qt4Header" >QDesignerCustomWidgetInterface</item> + <item Type="qt4Header" >QDesignerDnDItemInterface</item> + <item Type="qt4Header" >QDesignerExportWidget</item> + <item Type="qt4Header" >QDesignerExtraInfoExtension</item> + <item Type="qt4Header" >QDesignerFormEditorInterface</item> + <item Type="qt4Header" >QDesignerFormEditorPluginInterface</item> + <item Type="qt4Header" >QDesignerFormWindowCursorInterface</item> + <item Type="qt4Header" >QDesignerFormWindowInterface</item> + <item Type="qt4Header" >QDesignerFormWindowManagerInterface</item> + <item Type="qt4Header" >QDesignerFormWindowToolInterface</item> + <item Type="qt4Header" >QDesignerIconCacheInterface</item> + <item Type="qt4Header" >QDesignerLayoutDecorationExtension</item> + <item Type="qt4Header" >QDesignerMemberSheetExtension</item> + <item Type="qt4Header" >QDesignerMetaDataBaseInterface</item> + <item Type="qt4Header" >QDesignerMetaDataBaseItemInterface</item> + <item Type="qt4Header" >QDesignerObjectInspectorInterface</item> + <item Type="qt4Header" >QDesignerPropertyEditorInterface</item> + <item Type="qt4Header" >QDesignerPropertySheetExtension</item> + <item Type="qt4Header" >QDesignerTaskMenuExtension</item> + <item Type="qt4Header" >QDesignerWidgetBoxInterface</item> + <item Type="qt4Header" >QDesignerWidgetDataBaseInterface</item> + <item Type="qt4Header" >QDesignerWidgetDataBaseItemInterface</item> + <item Type="qt4Header" >QDesignerWidgetFactoryInterface</item> + <item Type="qt4Header" >QDesktopServices</item> + <item Type="qt4Header" >QDesktopWidget</item> + <item Type="qt4Header" >QDial</item> + <item Type="qt4Header" >QDialog</item> + <item Type="qt4Header" >QDialogButtonBox</item> + <item Type="qt4Header" >QDir</item> + <item Type="qt4Header" >QDirModel</item> + <item Type="qt4Header" >QDirectPainter</item> + <item Type="qt4Header" >QDockWidget</item> + <item Type="qt4Header" >QDomAttr</item> + <item Type="qt4Header" >QDomCDATASection</item> + <item Type="qt4Header" >QDomCharacterData</item> + <item Type="qt4Header" >QDomComment</item> + <item Type="qt4Header" >QDomDocument</item> + <item Type="qt4Header" >QDomDocumentFragment</item> + <item Type="qt4Header" >QDomDocumentType</item> + <item Type="qt4Header" >QDomElement</item> + <item Type="qt4Header" >QDomEntity</item> + <item Type="qt4Header" >QDomEntityReference</item> + <item Type="qt4Header" >QDomImplementation</item> + <item Type="qt4Header" >QDomNamedNodeMap</item> + <item Type="qt4Header" >QDomNode</item> + <item Type="qt4Header" >QDomNodeList</item> + <item Type="qt4Header" >QDomNotation</item> + <item Type="qt4Header" >QDomProcessingInstruction</item> + <item Type="qt4Header" >QDomText</item> + <item Type="qt4Header" >QDoubleSpinBox</item> + <item Type="qt4Header" >QDoubleValidator</item> + <item Type="qt4Header" >QDrag</item> + <item Type="qt4Header" >QDragEnterEvent</item> + <item Type="qt4Header" >QDragLeaveEvent</item> + <item Type="qt4Header" >QDragMoveEvent</item> + <item Type="qt4Header" >QDragResponseEvent</item> + <item Type="qt4Header" >QDropEvent</item> + <item Type="qt4Header" >QDynamicPropertyChangeEvent</item> + <item Type="qt4Header" >QErrorMessage</item> + <item Type="qt4Header" >QEvent</item> + <item Type="qt4Header" >QEventLoop</item> + <item Type="qt4Header" >QEventSizeOfChecker</item> + <item Type="qt4Header" >QExtensionFactory</item> + <item Type="qt4Header" >QExtensionManager</item> + <item Type="qt4Header" >QFSFileEngine</item> + <item Type="qt4Header" >QFactoryInterface</item> + <item Type="qt4Header" >QFile</item> + <item Type="qt4Header" >QFileDialog</item> + <item Type="qt4Header" >QFileIconProvider</item> + <item Type="qt4Header" >QFileInfo</item> + <item Type="qt4Header" >QFileInfoList</item> + <item Type="qt4Header" >QFileInfoListIterator</item> + <item Type="qt4Header" >QFileOpenEvent</item> + <item Type="qt4Header" >QFileSystemWatcher</item> + <item Type="qt4Header" >QFlag</item> + <item Type="qt4Header" >QFlags</item> + <item Type="qt4Header" >QFocusEvent</item> + <item Type="qt4Header" >QFocusFrame</item> + <item Type="qt4Header" >QFont</item> + <item Type="qt4Header" >QFontComboBox</item> + <item Type="qt4Header" >QFontDatabase</item> + <item Type="qt4Header" >QFontDialog</item> + <item Type="qt4Header" >QFontInfo</item> + <item Type="qt4Header" >QFontMetrics</item> + <item Type="qt4Header" >QFontMetricsF</item> + <item Type="qt4Header" >QForeachContainer</item> + <item Type="qt4Header" >QForeachContainerBase</item> + <item Type="qt4Header" >QFormBuilder</item> + <item Type="qt4Header" >QFrame</item> + <item Type="qt4Header" >QFtp</item> + <item Type="qt4Header" >QGLColormap</item> + <item Type="qt4Header" >QGLContext</item> + <item Type="qt4Header" >QGLFormat</item> + <item Type="qt4Header" >QGLFramebufferObject</item> + <item Type="qt4Header" >QGLPixelBuffer</item> + <item Type="qt4Header" >QGLWidget</item> + <item Type="qt4Header" >QGenericArgument</item> + <item Type="qt4Header" >QGenericReturnArgument</item> + <item Type="qt4Header" >QGlobalStatic</item> + <item Type="qt4Header" >QGradient</item> + <item Type="qt4Header" >QGradientStop</item> + <item Type="qt4Header" >QGradientStops</item> + <item Type="qt4Header" >QGraphicsEllipseItem</item> + <item Type="qt4Header" >QGraphicsItem</item> + <item Type="qt4Header" >QGraphicsItemAnimation</item> + <item Type="qt4Header" >QGraphicsItemGroup</item> + <item Type="qt4Header" >QGraphicsLineItem</item> + <item Type="qt4Header" >QGraphicsPathItem</item> + <item Type="qt4Header" >QGraphicsPixmapItem</item> + <item Type="qt4Header" >QGraphicsPolygonItem</item> + <item Type="qt4Header" >QGraphicsRectItem</item> + <item Type="qt4Header" >QGraphicsScene</item> + <item Type="qt4Header" >QGraphicsSceneContextMenuEvent</item> + <item Type="qt4Header" >QGraphicsSceneDragDropEvent</item> + <item Type="qt4Header" >QGraphicsSceneEvent</item> + <item Type="qt4Header" >QGraphicsSceneHelpEvent</item> + <item Type="qt4Header" >QGraphicsSceneHoverEvent</item> + <item Type="qt4Header" >QGraphicsSceneMouseEvent</item> + <item Type="qt4Header" >QGraphicsSceneWheelEvent</item> + <item Type="qt4Header" >QGraphicsSimpleTextItem</item> + <item Type="qt4Header" >QGraphicsSvgItem</item> + <item Type="qt4Header" >QGraphicsTextItem</item> + <item Type="qt4Header" >QGraphicsView</item> + <item Type="qt4Header" >QGridLayout</item> + <item Type="qt4Header" >QGroupBox</item> + <item Type="qt4Header" >QHBoxLayout</item> + <item Type="qt4Header" >QHash</item> + <item Type="qt4Header" >QHashData</item> + <item Type="qt4Header" >QHashDummyNode</item> + <item Type="qt4Header" >QHashDummyValue</item> + <item Type="qt4Header" >QHashIterator</item> + <item Type="qt4Header" >QHashNode</item> + <item Type="qt4Header" >QHeaderView</item> + <item Type="qt4Header" >QHelpEvent</item> + <item Type="qt4Header" >QHideEvent</item> + <item Type="qt4Header" >QHostAddress</item> + <item Type="qt4Header" >QHostInfo</item> + <item Type="qt4Header" >QHoverEvent</item> + <item Type="qt4Header" >QHttp</item> + <item Type="qt4Header" >QHttpHeader</item> + <item Type="qt4Header" >QHttpRequestHeader</item> + <item Type="qt4Header" >QHttpResponseHeader</item> + <item Type="qt4Header" >QIBaseDriver</item> + <item Type="qt4Header" >QIBaseResult</item> + <item Type="qt4Header" >QIODevice</item> + <item Type="qt4Header" >QIPv6Address</item> + <item Type="qt4Header" >QIcon</item> + <item Type="qt4Header" >QIconDragEvent</item> + <item Type="qt4Header" >QIconEngine</item> + <item Type="qt4Header" >QIconEngineFactoryInterface</item> + <item Type="qt4Header" >QIconEnginePlugin</item> + <item Type="qt4Header" >QIconSet</item> + <item Type="qt4Header" >QImage</item> + <item Type="qt4Header" >QImageIOHandler</item> + <item Type="qt4Header" >QImageIOHandlerFactoryInterface</item> + <item Type="qt4Header" >QImageIOPlugin</item> + <item Type="qt4Header" >QImageReader</item> + <item Type="qt4Header" >QImageTextKeyLang</item> + <item Type="qt4Header" >QImageWriter</item> + <item Type="qt4Header" >QInputContext</item> + <item Type="qt4Header" >QInputContextFactory</item> + <item Type="qt4Header" >QInputContextFactoryInterface</item> + <item Type="qt4Header" >QInputContextPlugin</item> + <item Type="qt4Header" >QInputDialog</item> + <item Type="qt4Header" >QInputEvent</item> + <item Type="qt4Header" >QInputMethodEvent</item> + <item Type="qt4Header" >QIntForSize</item> + <item Type="qt4Header" >QIntForType</item> + <item Type="qt4Header" >QIntValidator</item> + <item Type="qt4Header" >QInternal</item> + <item Type="qt4Header" >QItemDelegate</item> + <item Type="qt4Header" >QItemEditorCreator</item> + <item Type="qt4Header" >QItemEditorCreatorBase</item> + <item Type="qt4Header" >QItemEditorFactory</item> + <item Type="qt4Header" >QItemSelection</item> + <item Type="qt4Header" >QItemSelectionModel</item> + <item Type="qt4Header" >QItemSelectionRange</item> + <item Type="qt4Header" >QKbdDriverFactory</item> + <item Type="qt4Header" >QKbdDriverPlugin</item> + <item Type="qt4Header" >QKeyEvent</item> + <item Type="qt4Header" >QKeySequence</item> + <item Type="qt4Header" >QLCDNumber</item> + <item Type="qt4Header" >QLabel</item> + <item Type="qt4Header" >QLatin1Char</item> + <item Type="qt4Header" >QLatin1String</item> + <item Type="qt4Header" >QLayout</item> + <item Type="qt4Header" >QLayoutItem</item> + <item Type="qt4Header" >QLayoutIterator</item> + <item Type="qt4Header" >QLibrary</item> + <item Type="qt4Header" >QLibraryInfo</item> + <item Type="qt4Header" >QLine</item> + <item Type="qt4Header" >QLineEdit</item> + <item Type="qt4Header" >QLineF</item> + <item Type="qt4Header" >QLinearGradient</item> + <item Type="qt4Header" >QLinkedList</item> + <item Type="qt4Header" >QLinkedListData</item> + <item Type="qt4Header" >QLinkedListIterator</item> + <item Type="qt4Header" >QLinkedListNode</item> + <item Type="qt4Header" >QLinuxFbScreen</item> + <item Type="qt4Header" >QLinuxFb_Shared</item> + <item Type="qt4Header" >QList</item> + <item Type="qt4Header" >QListData</item> + <item Type="qt4Header" >QListIterator</item> + <item Type="qt4Header" >QListView</item> + <item Type="qt4Header" >QListWidget</item> + <item Type="qt4Header" >QListWidgetItem</item> + <item Type="qt4Header" >QLocale</item> + <item Type="qt4Header" >QMYSQLDriver</item> + <item Type="qt4Header" >QMYSQLResult</item> + <item Type="qt4Header" >QMacMime</item> + <item Type="qt4Header" >QMacPasteBoardMime</item> + <item Type="qt4Header" >QMacStyle</item> + <item Type="qt4Header" >QMainWindow</item> + <item Type="qt4Header" >QMap</item> + <item Type="qt4Header" >QMapData</item> + <item Type="qt4Header" >QMapIterator</item> + <item Type="qt4Header" >QMatrix</item> + <item Type="qt4Header" >QMenu</item> + <item Type="qt4Header" >QMenuBar</item> + <item Type="qt4Header" >QMenuItem</item> + <item Type="qt4Header" >QMenubarUpdatedEvent</item> + <item Type="qt4Header" >QMessageBox</item> + <item Type="qt4Header" >QMetaClassInfo</item> + <item Type="qt4Header" >QMetaEnum</item> + <item Type="qt4Header" >QMetaMethod</item> + <item Type="qt4Header" >QMetaObject</item> + <item Type="qt4Header" >QMetaProperty</item> + <item Type="qt4Header" >QMetaType</item> + <item Type="qt4Header" >QMetaTypeId</item> + <item Type="qt4Header" >QMetaTypeId2</item> + <item Type="qt4Header" >QMimeData</item> + <item Type="qt4Header" >QMimeSource</item> + <item Type="qt4Header" >QModelIndex</item> + <item Type="qt4Header" >QModelIndexList</item> + <item Type="qt4Header" >QMotifStyle</item> + <item Type="qt4Header" >QMouseDriverFactory</item> + <item Type="qt4Header" >QMouseDriverPlugin</item> + <item Type="qt4Header" >QMouseEvent</item> + <item Type="qt4Header" >QMoveEvent</item> + <item Type="qt4Header" >QMovie</item> + <item Type="qt4Header" >QMultiHash</item> + <item Type="qt4Header" >QMultiMap</item> + <item Type="qt4Header" >QMutableHashIterator</item> + <item Type="qt4Header" >QMutableLinkedListIterator</item> + <item Type="qt4Header" >QMutableListIterator</item> + <item Type="qt4Header" >QMutableMapIterator</item> + <item Type="qt4Header" >QMutableSetIterator</item> + <item Type="qt4Header" >QMutableStringListIterator</item> + <item Type="qt4Header" >QMutableVectorIterator</item> + <item Type="qt4Header" >QMutex</item> + <item Type="qt4Header" >QMutexLocker</item> + <item Type="qt4Header" >QNetworkAddressEntry</item> + <item Type="qt4Header" >QNetworkInterface</item> + <item Type="qt4Header" >QNetworkProxy</item> + <item Type="qt4Header" >QNoDebug</item> + <item Type="qt4Header" >QNoImplicitBoolCast</item> + <item Type="qt4Header" >QOCIDriver</item> + <item Type="qt4Header" >QOCIResult</item> + <item Type="qt4Header" >QODBCDriver</item> + <item Type="qt4Header" >QODBCResult</item> + <item Type="qt4Header" >QObject</item> + <item Type="qt4Header" >QObjectCleanupHandler</item> + <item Type="qt4Header" >QObjectData</item> + <item Type="qt4Header" >QObjectList</item> + <item Type="qt4Header" >QObjectUserData</item> + <item Type="qt4Header" >QPSQLDriver</item> + <item Type="qt4Header" >QPSQLResult</item> + <item Type="qt4Header" >QPageSetupDialog</item> + <item Type="qt4Header" >QPaintDevice</item> + <item Type="qt4Header" >QPaintEngine</item> + <item Type="qt4Header" >QPaintEngineState</item> + <item Type="qt4Header" >QPaintEvent</item> + <item Type="qt4Header" >QPainter</item> + <item Type="qt4Header" >QPainterPath</item> + <item Type="qt4Header" >QPainterPathPrivate</item> + <item Type="qt4Header" >QPainterPathStroker</item> + <item Type="qt4Header" >QPair</item> + <item Type="qt4Header" >QPalette</item> + <item Type="qt4Header" >QPen</item> + <item Type="qt4Header" >QPersistentModelIndex</item> + <item Type="qt4Header" >QPicture</item> + <item Type="qt4Header" >QPictureFormatInterface</item> + <item Type="qt4Header" >QPictureFormatPlugin</item> + <item Type="qt4Header" >QPictureIO</item> + <item Type="qt4Header" >QPixmap</item> + <item Type="qt4Header" >QPixmapCache</item> + <item Type="qt4Header" >QPlastiqueStyle</item> + <item Type="qt4Header" >QPluginLoader</item> + <item Type="qt4Header" >QPoint</item> + <item Type="qt4Header" >QPointF</item> + <item Type="qt4Header" >QPointer</item> + <item Type="qt4Header" >QPolygon</item> + <item Type="qt4Header" >QPolygonF</item> + <item Type="qt4Header" >QPoolEntry</item> + <item Type="qt4Header" >QPrintDialog</item> + <item Type="qt4Header" >QPrintEngine</item> + <item Type="qt4Header" >QPrinter</item> + <item Type="qt4Header" >QProcess</item> + <item Type="qt4Header" >QProgressBar</item> + <item Type="qt4Header" >QProgressDialog</item> + <item Type="qt4Header" >QProxyModel</item> + <item Type="qt4Header" >QPushButton</item> + <item Type="qt4Header" >QQueue</item> + <item Type="qt4Header" >QRadialGradient</item> + <item Type="qt4Header" >QRadioButton</item> + <item Type="qt4Header" >QReadLocker</item> + <item Type="qt4Header" >QReadWriteLock</item> + <item Type="qt4Header" >QRect</item> + <item Type="qt4Header" >QRectF</item> + <item Type="qt4Header" >QRegExp</item> + <item Type="qt4Header" >QRegExpValidator</item> + <item Type="qt4Header" >QRegion</item> + <item Type="qt4Header" >QResizeEvent</item> + <item Type="qt4Header" >QResource</item> + <item Type="qt4Header" >QReturnArgument</item> + <item Type="qt4Header" >QRgb</item> + <item Type="qt4Header" >QRubberBand</item> + <item Type="qt4Header" >QSQLite2Driver</item> + <item Type="qt4Header" >QSQLite2Result</item> + <item Type="qt4Header" >QSQLiteDriver</item> + <item Type="qt4Header" >QSQLiteResult</item> + <item Type="qt4Header" >QScreen</item> + <item Type="qt4Header" >QScreenCursor</item> + <item Type="qt4Header" >QScreenDriverFactory</item> + <item Type="qt4Header" >QScreenDriverFactoryInterface</item> + <item Type="qt4Header" >QScreenDriverPlugin</item> + <item Type="qt4Header" >QScrollArea</item> + <item Type="qt4Header" >QScrollBar</item> + <item Type="qt4Header" >QSemaphore</item> + <item Type="qt4Header" >QSessionManager</item> + <item Type="qt4Header" >QSet</item> + <item Type="qt4Header" >QSetIterator</item> + <item Type="qt4Header" >QSettings</item> + <item Type="qt4Header" >QSharedData</item> + <item Type="qt4Header" >QSharedDataPointer</item> + <item Type="qt4Header" >QShortcut</item> + <item Type="qt4Header" >QShortcutEvent</item> + <item Type="qt4Header" >QShowEvent</item> + <item Type="qt4Header" >QSignalMapper</item> + <item Type="qt4Header" >QSignalSpy</item> + <item Type="qt4Header" >QSize</item> + <item Type="qt4Header" >QSizeF</item> + <item Type="qt4Header" >QSizeGrip</item> + <item Type="qt4Header" >QSizePolicy</item> + <item Type="qt4Header" >QSlider</item> + <item Type="qt4Header" >QSocketNotifier</item> + <item Type="qt4Header" >QSortFilterProxyModel</item> + <item Type="qt4Header" >QSound</item> + <item Type="qt4Header" >QSpacerItem</item> + <item Type="qt4Header" >QSpinBox</item> + <item Type="qt4Header" >QSplashScreen</item> + <item Type="qt4Header" >QSplitter</item> + <item Type="qt4Header" >QSplitterHandle</item> + <item Type="qt4Header" >QSpontaneKeyEvent</item> + <item Type="qt4Header" >QSqlDatabase</item> + <item Type="qt4Header" >QSqlDriver</item> + <item Type="qt4Header" >QSqlDriverCreator</item> + <item Type="qt4Header" >QSqlDriverCreatorBase</item> + <item Type="qt4Header" >QSqlDriverFactoryInterface</item> + <item Type="qt4Header" >QSqlDriverPlugin</item> + <item Type="qt4Header" >QSqlError</item> + <item Type="qt4Header" >QSqlField</item> + <item Type="qt4Header" >QSqlIndex</item> + <item Type="qt4Header" >QSqlQuery</item> + <item Type="qt4Header" >QSqlQueryModel</item> + <item Type="qt4Header" >QSqlRecord</item> + <item Type="qt4Header" >QSqlRelation</item> + <item Type="qt4Header" >QSqlRelationalDelegate</item> + <item Type="qt4Header" >QSqlRelationalTableModel</item> + <item Type="qt4Header" >QSqlResult</item> + <item Type="qt4Header" >QSqlTableModel</item> + <item Type="qt4Header" >QStack</item> + <item Type="qt4Header" >QStackedLayout</item> + <item Type="qt4Header" >QStackedWidget</item> + <item Type="qt4Header" >QStandardItem</item> + <item Type="qt4Header" >QStandardItemEditorCreator</item> + <item Type="qt4Header" >QStandardItemModel</item> + <item Type="qt4Header" >QStatusBar</item> + <item Type="qt4Header" >QStatusTipEvent</item> + <item Type="qt4Header" >QStdWString</item> + <item Type="qt4Header" >QString</item> + <item Type="qt4Header" >QStringList</item> + <item Type="qt4Header" >QStringListIterator</item> + <item Type="qt4Header" >QStringListModel</item> + <item Type="qt4Header" >QStringMatcher</item> + <item Type="qt4Header" >QStyle</item> + <item Type="qt4Header" >QStyleFactory</item> + <item Type="qt4Header" >QStyleFactoryInterface</item> + <item Type="qt4Header" >QStyleHintReturn</item> + <item Type="qt4Header" >QStyleHintReturnMask</item> + <item Type="qt4Header" >QStyleOption</item> + <item Type="qt4Header" >QStyleOptionButton</item> + <item Type="qt4Header" >QStyleOptionComboBox</item> + <item Type="qt4Header" >QStyleOptionComplex</item> + <item Type="qt4Header" >QStyleOptionDockWidget</item> + <item Type="qt4Header" >QStyleOptionFocusRect</item> + <item Type="qt4Header" >QStyleOptionFrame</item> + <item Type="qt4Header" >QStyleOptionFrameV2</item> + <item Type="qt4Header" >QStyleOptionGraphicsItem</item> + <item Type="qt4Header" >QStyleOptionGroupBox</item> + <item Type="qt4Header" >QStyleOptionHeader</item> + <item Type="qt4Header" >QStyleOptionMenuItem</item> + <item Type="qt4Header" >QStyleOptionProgressBar</item> + <item Type="qt4Header" >QStyleOptionProgressBarV2</item> + <item Type="qt4Header" >QStyleOptionQ3DockWindow</item> + <item Type="qt4Header" >QStyleOptionQ3ListView</item> + <item Type="qt4Header" >QStyleOptionQ3ListViewItem</item> + <item Type="qt4Header" >QStyleOptionRubberBand</item> + <item Type="qt4Header" >QStyleOptionSizeGrip</item> + <item Type="qt4Header" >QStyleOptionSlider</item> + <item Type="qt4Header" >QStyleOptionSpinBox</item> + <item Type="qt4Header" >QStyleOptionTab</item> + <item Type="qt4Header" >QStyleOptionTabBarBase</item> + <item Type="qt4Header" >QStyleOptionTabV2</item> + <item Type="qt4Header" >QStyleOptionTabWidgetFrame</item> + <item Type="qt4Header" >QStyleOptionTitleBar</item> + <item Type="qt4Header" >QStyleOptionToolBar</item> + <item Type="qt4Header" >QStyleOptionToolBox</item> + <item Type="qt4Header" >QStyleOptionToolButton</item> + <item Type="qt4Header" >QStyleOptionViewItem</item> + <item Type="qt4Header" >QStyleOptionViewItemV2</item> + <item Type="qt4Header" >QStylePainter</item> + <item Type="qt4Header" >QStylePlugin</item> + <item Type="qt4Header" >QSvgRenderer</item> + <item Type="qt4Header" >QSvgWidget</item> + <item Type="qt4Header" >QSyntaxHighlighter</item> + <item Type="qt4Header" >QSysInfo</item> + <item Type="qt4Header" >QSystemLocale</item> + <item Type="qt4Header" >QSystemTrayIcon</item> + <item Type="qt4Header" >QTDSDriver</item> + <item Type="qt4Header" >QTDSResult</item> + <item Type="qt4Header" >QTS</item> + <item Type="qt4Header" >QTabBar</item> + <item Type="qt4Header" >QTabWidget</item> + <item Type="qt4Header" >QTableView</item> + <item Type="qt4Header" >QTableWidget</item> + <item Type="qt4Header" >QTableWidgetItem</item> + <item Type="qt4Header" >QTableWidgetSelectionRange</item> + <item Type="qt4Header" >QTabletEvent</item> + <item Type="qt4Header" >QTcpServer</item> + <item Type="qt4Header" >QTcpSocket</item> + <item Type="qt4Header" >QTemporaryFile</item> + <item Type="qt4Header" >QTest</item> + <item Type="qt4Header" >QTestAccessibility</item> + <item Type="qt4Header" >QTestAccessibilityEvent</item> + <item Type="qt4Header" >QTestData</item> + <item Type="qt4Header" >QTestDelayEvent</item> + <item Type="qt4Header" >QTestEvent</item> + <item Type="qt4Header" >QTestEventList</item> + <item Type="qt4Header" >QTestEventLoop</item> + <item Type="qt4Header" >QTestKeyClicksEvent</item> + <item Type="qt4Header" >QTestKeyEvent</item> + <item Type="qt4Header" >QTestMouseEvent</item> + <item Type="qt4Header" >QTextBlock</item> + <item Type="qt4Header" >QTextBlockFormat</item> + <item Type="qt4Header" >QTextBlockGroup</item> + <item Type="qt4Header" >QTextBlockUserData</item> + <item Type="qt4Header" >QTextBrowser</item> + <item Type="qt4Header" >QTextCharFormat</item> + <item Type="qt4Header" >QTextCodec</item> + <item Type="qt4Header" >QTextCodecFactoryInterface</item> + <item Type="qt4Header" >QTextCodecPlugin</item> + <item Type="qt4Header" >QTextCursor</item> + <item Type="qt4Header" >QTextDecoder</item> + <item Type="qt4Header" >QTextDocument</item> + <item Type="qt4Header" >QTextDocumentFragment</item> + <item Type="qt4Header" >QTextEdit</item> + <item Type="qt4Header" >QTextEncoder</item> + <item Type="qt4Header" >QTextFormat</item> + <item Type="qt4Header" >QTextFragment</item> + <item Type="qt4Header" >QTextFrame</item> + <item Type="qt4Header" >QTextFrameFormat</item> + <item Type="qt4Header" >QTextFrameLayoutData</item> + <item Type="qt4Header" >QTextIStream</item> + <item Type="qt4Header" >QTextImageFormat</item> + <item Type="qt4Header" >QTextInlineObject</item> + <item Type="qt4Header" >QTextItem</item> + <item Type="qt4Header" >QTextLayout</item> + <item Type="qt4Header" >QTextLength</item> + <item Type="qt4Header" >QTextLine</item> + <item Type="qt4Header" >QTextList</item> + <item Type="qt4Header" >QTextListFormat</item> + <item Type="qt4Header" >QTextOStream</item> + <item Type="qt4Header" >QTextObject</item> + <item Type="qt4Header" >QTextObjectInterface</item> + <item Type="qt4Header" >QTextOption</item> + <item Type="qt4Header" >QTextStream</item> + <item Type="qt4Header" >QTextStreamFunction</item> + <item Type="qt4Header" >QTextStreamManipulator</item> + <item Type="qt4Header" >QTextTable</item> + <item Type="qt4Header" >QTextTableCell</item> + <item Type="qt4Header" >QTextTableFormat</item> + <item Type="qt4Header" >QThread</item> + <item Type="qt4Header" >QThreadStorage</item> + <item Type="qt4Header" >QThreadStorageData</item> + <item Type="qt4Header" >QTime</item> + <item Type="qt4Header" >QTimeEdit</item> + <item Type="qt4Header" >QTimeLine</item> + <item Type="qt4Header" >QTimer</item> + <item Type="qt4Header" >QTimerEvent</item> + <item Type="qt4Header" >QToolBar</item> + <item Type="qt4Header" >QToolBarChangeEvent</item> + <item Type="qt4Header" >QToolBox</item> + <item Type="qt4Header" >QToolButton</item> + <item Type="qt4Header" >QToolTip</item> + <item Type="qt4Header" >QTransformedScreen</item> + <item Type="qt4Header" >QTranslator</item> + <item Type="qt4Header" >QTransportAuth</item> + <item Type="qt4Header" >QTreeView</item> + <item Type="qt4Header" >QTreeWidget</item> + <item Type="qt4Header" >QTreeWidgetItem</item> + <item Type="qt4Header" >QTreeWidgetItemIterator</item> + <item Type="qt4Header" >QTypeInfo</item> + <item Type="qt4Header" >QUdpSocket</item> + <item Type="qt4Header" >QUiLoader</item> + <item Type="qt4Header" >QUintForSize</item> + <item Type="qt4Header" >QUintForType</item> + <item Type="qt4Header" >QUndoCommand</item> + <item Type="qt4Header" >QUndoGroup</item> + <item Type="qt4Header" >QUndoStack</item> + <item Type="qt4Header" >QUndoView</item> + <item Type="qt4Header" >QUpdateLaterEvent</item> + <item Type="qt4Header" >QUrl</item> + <item Type="qt4Header" >QUrlInfo</item> + <item Type="qt4Header" >QUuid</item> + <item Type="qt4Header" >QVBoxLayout</item> + <item Type="qt4Header" >QVFbHeader</item> + <item Type="qt4Header" >QVFbKeyData</item> + <item Type="qt4Header" >QVFbKeyboardHandler</item> + <item Type="qt4Header" >QVFbMouseHandler</item> + <item Type="qt4Header" >QVFbScreen</item> + <item Type="qt4Header" >QVNCScreen</item> + <item Type="qt4Header" >QValidator</item> + <item Type="qt4Header" >QVarLengthArray</item> + <item Type="qt4Header" >QVariant</item> + <item Type="qt4Header" >QVariantComparisonHelper</item> + <item Type="qt4Header" >QVariantList</item> + <item Type="qt4Header" >QVariantMap</item> + <item Type="qt4Header" >QVector</item> + <item Type="qt4Header" >QVectorData</item> + <item Type="qt4Header" >QVectorIterator</item> + <item Type="qt4Header" >QVectorTypedData</item> + <item Type="qt4Header" >QWMatrix</item> + <item Type="qt4Header" >QWSBusMouseHandler</item> + <item Type="qt4Header" >QWSCalibratedMouseHandler</item> + <item Type="qt4Header" >QWSClient</item> + <item Type="qt4Header" >QWSCursor</item> + <item Type="qt4Header" >QWSCursorMap</item> + <item Type="qt4Header" >QWSDisplay</item> + <item Type="qt4Header" >QWSEmbedWidget</item> + <item Type="qt4Header" >QWSEvent</item> + <item Type="qt4Header" >QWSInputMethod</item> + <item Type="qt4Header" >QWSInternalWindowInfo</item> + <item Type="qt4Header" >QWSKeyboardHandler</item> + <item Type="qt4Header" >QWSKeyboardHandlerFactoryInterface</item> + <item Type="qt4Header" >QWSLinuxTPMouseHandler</item> + <item Type="qt4Header" >QWSManager</item> + <item Type="qt4Header" >QWSMouseHandler</item> + <item Type="qt4Header" >QWSMouseHandlerFactoryInterface</item> + <item Type="qt4Header" >QWSPC101KeyboardHandler</item> + <item Type="qt4Header" >QWSPcMouseHandler</item> + <item Type="qt4Header" >QWSPointerCalibrationData</item> + <item Type="qt4Header" >QWSPropertyManager</item> + <item Type="qt4Header" >QWSProtocolItem</item> + <item Type="qt4Header" >QWSSL5000KeyboardHandler</item> + <item Type="qt4Header" >QWSScreenSaver</item> + <item Type="qt4Header" >QWSServer</item> + <item Type="qt4Header" >QWSServerSocket</item> + <item Type="qt4Header" >QWSSocket</item> + <item Type="qt4Header" >QWSSoundClient</item> + <item Type="qt4Header" >QWSSoundServer</item> + <item Type="qt4Header" >QWSSoundServerSocket</item> + <item Type="qt4Header" >QWSTslibMouseHandler</item> + <item Type="qt4Header" >QWSTtyKeyboardHandler</item> + <item Type="qt4Header" >QWSUmKeyboardHandler</item> + <item Type="qt4Header" >QWSUsbKeyboardHandler</item> + <item Type="qt4Header" >QWSVr41xxKeyboardHandler</item> + <item Type="qt4Header" >QWSVr41xxMouseHandler</item> + <item Type="qt4Header" >QWSWindow</item> + <item Type="qt4Header" >QWSWindowInfo</item> + <item Type="qt4Header" >QWSYopyKeyboardHandler</item> + <item Type="qt4Header" >QWSYopyMouseHandler</item> + <item Type="qt4Header" >QWaitCondition</item> + <item Type="qt4Header" >QWhatsThis</item> + <item Type="qt4Header" >QWhatsThisClickedEvent</item> + <item Type="qt4Header" >QWheelEvent</item> + <item Type="qt4Header" >QWidget</item> + <item Type="qt4Header" >QWidgetAction</item> + <item Type="qt4Header" >QWidgetData</item> + <item Type="qt4Header" >QWidgetItem</item> + <item Type="qt4Header" >QWidgetList</item> + <item Type="qt4Header" >QWidgetMapper</item> + <item Type="qt4Header" >QWidgetSet</item> + <item Type="qt4Header" >QWindowStateChangeEvent</item> + <item Type="qt4Header" >QWindowsMime</item> + <item Type="qt4Header" >QWindowsStyle</item> + <item Type="qt4Header" >QWindowsXPStyle</item> + <item Type="qt4Header" >QWorkspace</item> + <item Type="qt4Header" >QWriteLocker</item> + <item Type="qt4Header" >QX11EmbedContainer</item> + <item Type="qt4Header" >QX11EmbedWidget</item> + <item Type="qt4Header" >QX11Info</item> + <item Type="qt4Header" >QXmlAttributes</item> + <item Type="qt4Header" >QXmlContentHandler</item> + <item Type="qt4Header" >QXmlDTDHandler</item> + <item Type="qt4Header" >QXmlDeclHandler</item> + <item Type="qt4Header" >QXmlDefaultHandler</item> + <item Type="qt4Header" >QXmlEntityResolver</item> + <item Type="qt4Header" >QXmlErrorHandler</item> + <item Type="qt4Header" >QXmlInputSource</item> + <item Type="qt4Header" >QXmlLexicalHandler</item> + <item Type="qt4Header" >QXmlLocator</item> + <item Type="qt4Header" >QXmlNamespaceSupport</item> + <item Type="qt4Header" >QXmlParseException</item> + <item Type="qt4Header" >QXmlReader</item> + <item Type="qt4Header" >QXmlSimpleReader</item> + <item Type="RenamedClass" > + <Qt4>QIcon</Qt4> + <Qt3>QIconSet</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>QMatrix</Qt4> + <Qt3>QWMatrix</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>QPointer</Qt4> + <Qt3>QGuardedPtr</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3Accel</Qt4> + <Qt3>QAccel</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ActionGroup</Qt4> + <Qt3>QActionGroup</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3AsciiBucket</Qt4> + <Qt3>QAsciiBucket</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3AsciiCache</Qt4> + <Qt3>QAsciiCache</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3AsciiCacheIterator</Qt4> + <Qt3>QAsciiCacheIterator</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3AsciiDict</Qt4> + <Qt3>QAsciiDict</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3AsciiDictIterator</Qt4> + <Qt3>QAsciiDictIterator</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3BaseBucket</Qt4> + <Qt3>QBaseBucket</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3BoxLayout</Qt4> + <Qt3>QBoxLayout</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ButtonGroup</Qt4> + <Qt3>QButtonGroup</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3CString</Qt4> + <Qt3>QCString</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3Cache</Qt4> + <Qt3>QCache</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3CacheIterator</Qt4> + <Qt3>QCacheIterator</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3Canvas</Qt4> + <Qt3>QCanvas</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3CanvasEllipse</Qt4> + <Qt3>QCanvasEllipse</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3CanvasItem</Qt4> + <Qt3>QCanvasItem</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3CanvasItemList</Qt4> + <Qt3>QCanvasItemList</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3CanvasLine</Qt4> + <Qt3>QCanvasLine</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3CanvasPixmap</Qt4> + <Qt3>QCanvasPixmap</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3CanvasPixmapArray</Qt4> + <Qt3>QCanvasPixmapArray</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3CanvasPolygon</Qt4> + <Qt3>QCanvasPolygon</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3CanvasPolygonalItem</Qt4> + <Qt3>QCanvasPolygonalItem</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3CanvasRectangle</Qt4> + <Qt3>QCanvasRectangle</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3CanvasSpline</Qt4> + <Qt3>QCanvasSpline</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3CanvasSprite</Qt4> + <Qt3>QCanvasSprite</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3CanvasText</Qt4> + <Qt3>QCanvasText</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3CanvasView</Qt4> + <Qt3>QCanvasView</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3CheckListItem</Qt4> + <Qt3>QCheckListItem</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3CheckTableItem</Qt4> + <Qt3>QCheckTableItem</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3CleanupHandler</Qt4> + <Qt3>QCleanupHandler</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ColorDrag</Qt4> + <Qt3>QColorDrag</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ComboTableItem</Qt4> + <Qt3>QComboTableItem</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3DataBrowser</Qt4> + <Qt3>QDataBrowser</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3DataTable</Qt4> + <Qt3>QDataTable</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3DataView</Qt4> + <Qt3>QDataView</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3DateEdit</Qt4> + <Qt3>QDateEdit</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3DateTimeEdit</Qt4> + <Qt3>QDateTimeEdit</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3DateTimeEditBase</Qt4> + <Qt3>QDateTimeEditBase</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3Dict</Qt4> + <Qt3>QDict</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3DictIterator</Qt4> + <Qt3>QDictIterator</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3Dns</Qt4> + <Qt3>QDns</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3DnsSocket</Qt4> + <Qt3>QDnsSocket</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3DockArea</Qt4> + <Qt3>QDockArea</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3DockAreaLayout</Qt4> + <Qt3>QDockAreaLayout</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3DockWindow</Qt4> + <Qt3>QDockWindow</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3DragObject</Qt4> + <Qt3>QDragObject</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3DropSite</Qt4> + <Qt3>QDropSite</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3EditorFactory</Qt4> + <Qt3>QEditorFactory</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3FileDialog</Qt4> + <Qt3>QFileDialog</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3FileIconProvider</Qt4> + <Qt3>QFileIconProvider</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3FilePreview</Qt4> + <Qt3>QFilePreview</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3Frame</Qt4> + <Qt3>QFrame</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3Ftp</Qt4> + <Qt3>QFtp</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3GArray</Qt4> + <Qt3>QGArray</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3GCache</Qt4> + <Qt3>QGCache</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3GCacheIterator</Qt4> + <Qt3>QGCacheIterator</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3GDict</Qt4> + <Qt3>QGDict</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3GDictIterator</Qt4> + <Qt3>QGDictIterator</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3GList</Qt4> + <Qt3>QGList</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3GListIterator</Qt4> + <Qt3>QGListIterator</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3GListStdIterator</Qt4> + <Qt3>QGListStdIterator</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3GVector</Qt4> + <Qt3>QGVector</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3Grid</Qt4> + <Qt3>QGrid</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3GridLayout</Qt4> + <Qt3>QGridLayout</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3GridView</Qt4> + <Qt3>QGridView</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3GroupBox</Qt4> + <Qt3>QGroupBox</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3HBox</Qt4> + <Qt3>QHBox</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3HBoxLayout</Qt4> + <Qt3>QHBoxLayout</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3HButtonGroup</Qt4> + <Qt3>QHButtonGroup</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3HGroupBox</Qt4> + <Qt3>QHGroupBox</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3Header</Qt4> + <Qt3>QHeader</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3Http</Qt4> + <Qt3>QHttp</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3HttpHeader</Qt4> + <Qt3>QHttpHeader</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3HttpRequestHeader</Qt4> + <Qt3>QHttpRequestHeader</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3HttpResponseHeader</Qt4> + <Qt3>QHttpResponseHeader</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3IconDrag</Qt4> + <Qt3>QIconDrag</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3IconDragItem</Qt4> + <Qt3>QIconDragItem</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3IconView</Qt4> + <Qt3>QIconView</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3IconViewItem</Qt4> + <Qt3>QIconViewItem</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ImageDrag</Qt4> + <Qt3>QImageDrag</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3IntBucket</Qt4> + <Qt3>QIntBucket</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3IntCache</Qt4> + <Qt3>QIntCache</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3IntCacheIterator</Qt4> + <Qt3>QIntCacheIterator</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3IntDict</Qt4> + <Qt3>QIntDict</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3IntDictIterator</Qt4> + <Qt3>QIntDictIterator</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3LNode</Qt4> + <Qt3>QLNode</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ListBox</Qt4> + <Qt3>QListBox</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ListBoxItem</Qt4> + <Qt3>QListBoxItem</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ListBoxPixmap</Qt4> + <Qt3>QListBoxPixmap</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ListBoxText</Qt4> + <Qt3>QListBoxText</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ListView</Qt4> + <Qt3>QListView</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ListViewItem</Qt4> + <Qt3>QListViewItem</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ListViewItemIterator</Qt4> + <Qt3>QListViewItemIterator</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3LocalFs</Qt4> + <Qt3>QLocalFs</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3MainWindow</Qt4> + <Qt3>QMainWindow</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3MemArray</Qt4> + <Qt3>QMemArray</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3MimeSourceFactory</Qt4> + <Qt3>QMimeSourceFactory</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3MultiLineEdit</Qt4> + <Qt3>QMultiLineEdit</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3NetworkOperation</Qt4> + <Qt3>QNetworkOperation</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3NetworkProtocol</Qt4> + <Qt3>QNetworkProtocol</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3NetworkProtocolFactory</Qt4> + <Qt3>QNetworkProtocolFactory</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3NetworkProtocolFactoryBase</Qt4> + <Qt3>QNetworkProtocolFactoryBase</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ObjectDictionary</Qt4> + <Qt3>QObjectDictionary</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3PaintDeviceMetrics</Qt4> + <Qt3>QPaintDeviceMetrics</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3Picture</Qt4> + <Qt3>QPicture</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3PointArray</Qt4> + <Qt3>QPointArray</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3PolygonScanner</Qt4> + <Qt3>QPolygonScanner</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3PopupMenu</Qt4> + <Qt3>QPopupMenu</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3Process</Qt4> + <Qt3>QProcess</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ProgressBar</Qt4> + <Qt3>QProgressBar</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ProgressDialog</Qt4> + <Qt3>QProgressDialog</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3PtrBucket</Qt4> + <Qt3>QPtrBucket</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3PtrCollection</Qt4> + <Qt3>QPtrCollection</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3PtrDict</Qt4> + <Qt3>QPtrDict</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3PtrDictIterator</Qt4> + <Qt3>QPtrDictIterator</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3PtrList</Qt4> + <Qt3>QPtrList</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3PtrListIterator</Qt4> + <Qt3>QPtrListIterator</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3PtrListStdIterator</Qt4> + <Qt3>QPtrListStdIterator</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3PtrQueue</Qt4> + <Qt3>QPtrQueue</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3PtrStack</Qt4> + <Qt3>QPtrStack</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3PtrVector</Qt4> + <Qt3>QPtrVector</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3RangeControl</Qt4> + <Qt3>QRangeControl</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ScrollView</Qt4> + <Qt3>QScrollView</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ServerSocket</Qt4> + <Qt3>QServerSocket</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3Shared</Qt4> + <Qt3>QShared</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3Signal</Qt4> + <Qt3>QSignal</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3SimpleRichText</Qt4> + <Qt3>QSimpleRichText</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3SingleCleanupHandler</Qt4> + <Qt3>QSingleCleanupHandler</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3Socket</Qt4> + <Qt3>QSocket</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3SocketDevice</Qt4> + <Qt3>QSocketDevice</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3SortedList</Qt4> + <Qt3>QSortedList</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3SpinWidget</Qt4> + <Qt3>QSpinWidget</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3SqlCursor</Qt4> + <Qt3>QSqlCursor</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3SqlEditorFactory</Qt4> + <Qt3>QSqlEditorFactory</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3SqlFieldInfo</Qt4> + <Qt3>QSqlFieldInfo</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3SqlForm</Qt4> + <Qt3>QSqlForm</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3SqlPropertyMap</Qt4> + <Qt3>QSqlPropertyMap</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3SqlRecordInfo</Qt4> + <Qt3>QSqlRecordInfo</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3SqlSelectCursor</Qt4> + <Qt3>QSqlSelectCursor</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3StoredDrag</Qt4> + <Qt3>QStoredDrag</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3StrIList</Qt4> + <Qt3>QStrIList</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3StrIVec</Qt4> + <Qt3>QStrIVec</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3StrList</Qt4> + <Qt3>QStrList</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3StrListIterator</Qt4> + <Qt3>QStrListIterator</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3StrVec</Qt4> + <Qt3>QStrVec</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3StringBucket</Qt4> + <Qt3>QStringBucket</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3StyleSheet</Qt4> + <Qt3>QStyleSheet</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3StyleSheetItem</Qt4> + <Qt3>QStyleSheetItem</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3SyntaxHighlighter</Qt4> + <Qt3>QSyntaxHighlighter</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3TSManip</Qt4> + <Qt3>QTSManip</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3TabDialog</Qt4> + <Qt3>QTabDialog</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3Table</Qt4> + <Qt3>QTable</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3TableItem</Qt4> + <Qt3>QTableItem</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3TableSelection</Qt4> + <Qt3>QTableSelection</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3TextBrowser</Qt4> + <Qt3>QTextBrowser</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3TextDrag</Qt4> + <Qt3>QTextDrag</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3TextEdit</Qt4> + <Qt3>QTextEdit</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3TextEditOptimPrivate</Qt4> + <Qt3>QTextEditOptimPrivate</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3TextStream</Qt4> + <Qt3>QTextStream</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3TextView</Qt4> + <Qt3>QTextView</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3TimeEdit</Qt4> + <Qt3>QTimeEdit</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ToolBar</Qt4> + <Qt3>QToolBar</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3UriDrag</Qt4> + <Qt3>QUriDrag</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3Url</Qt4> + <Qt3>QUrl</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3UrlOperator</Qt4> + <Qt3>QUrlOperator</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3VBox</Qt4> + <Qt3>QVBox</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3VBoxLayout</Qt4> + <Qt3>QVBoxLayout</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3VButtonGroup</Qt4> + <Qt3>QVButtonGroup</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3VGroupBox</Qt4> + <Qt3>QVGroupBox</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ValueList</Qt4> + <Qt3>QValueList</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ValueListConstIterator</Qt4> + <Qt3>QValueListConstIterator</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ValueListIterator</Qt4> + <Qt3>QValueListIterator</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ValueStack</Qt4> + <Qt3>QValueStack</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3ValueVector</Qt4> + <Qt3>QValueVector</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3WhatsThis</Qt4> + <Qt3>QWhatsThis</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3WidgetStack</Qt4> + <Qt3>QWidgetStack</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3Wizard</Qt4> + <Qt3>QWizard</Qt3> + </item> + <item Type="InheritsQt" >Qt</item> + <item Type="InheritsQt" >QKeySequence</item> + <item Type="InheritsQt" >QEvent</item> + <item Type="InheritsQt" >QTimerEvent</item> + <item Type="InheritsQt" >QMouseEvent</item> + <item Type="InheritsQt" >QWheelEvent</item> + <item Type="InheritsQt" >QTabletEvent</item> + <item Type="InheritsQt" >QKeyEvent</item> + <item Type="InheritsQt" >QFocusEvent</item> + <item Type="InheritsQt" >QPaintEvent</item> + <item Type="InheritsQt" >QMoveEvent</item> + <item Type="InheritsQt" >QResizeEvent</item> + <item Type="InheritsQt" >QCloseEvent</item> + <item Type="InheritsQt" >QIconDragEvent</item> + <item Type="InheritsQt" >QShowEvent</item> + <item Type="InheritsQt" >QHideEvent</item> + <item Type="InheritsQt" >QContextMenuEvent</item> + <item Type="InheritsQt" >QIMEvent</item> + <item Type="InheritsQt" >QIMComposeEvent</item> + <item Type="InheritsQt" >QDropEvent</item> + <item Type="InheritsQt" >QDragMoveEvent</item> + <item Type="InheritsQt" >QDragEnterEvent</item> + <item Type="InheritsQt" >QDragResponseEvent</item> + <item Type="InheritsQt" >QDragLeaveEvent</item> + <item Type="InheritsQt" >QChildEvent</item> + <item Type="InheritsQt" >QCustomEvent</item> + <item Type="InheritsQt" >QObject</item> + <item Type="InheritsQt" >QBrush</item> + <item Type="InheritsQt" >QWidget</item> + <item Type="InheritsQt" >QStyle</item> + <item Type="InheritsQt" >QFrame</item> + <item Type="InheritsQt" >QComboBox</item> + <item Type="InheritsQt" >QGroupBox</item> + <item Type="InheritsQt" >QDialog</item> + <item Type="InheritsQt" >QDataView</item> + <item Type="InheritsQt" >QDockWindow</item> + <item Type="InheritsQt" >QCommonStyle</item> + <item Type="InheritsQt" >QNetworkProtocol</item> + <item Type="InheritsQt" >QNetworkOperation</item> + <item Type="InheritsQt" >QPixmap</item> + <item Type="InheritsQt" >QGPlugin</item> + <item Type="InheritsQt" >QGrid</item> + <item Type="InheritsQt" >QSpinWidget</item> + <item Type="InheritsQt" >QButtonGroup</item> + <item Type="InheritsQt" >QDateTimeEditBase</item> + <item Type="InheritsQt" >QDateEdit</item> + <item Type="InheritsQt" >QTimeEdit</item> + <item Type="InheritsQt" >QDateTimeEdit</item> + <item Type="InheritsQt" >QHBox</item> + <item Type="InheritsQt" >QHButtonGroup</item> + <item Type="InheritsQt" >QHGroupBox</item> + <item Type="InheritsQt" >QSocketNotifier</item> + <item Type="InheritsQt" >QEventLoop</item> + <item Type="InheritsQt" >QHttp</item> + <item Type="InheritsQt" >QAction</item> + <item Type="InheritsQt" >QActionGroup</item> + <item Type="InheritsQt" >QImageFormatPlugin</item> + <item Type="InheritsQt" >QLineEdit</item> + <item Type="InheritsQt" >QMotifStyle</item> + <item Type="InheritsQt" >QAccel</item> + <item Type="InheritsQt" >QLabel</item> + <item Type="InheritsQt" >QLayout</item> + <item Type="InheritsQt" >QGridLayout</item> + <item Type="InheritsQt" >QBoxLayout</item> + <item Type="InheritsQt" >QHBoxLayout</item> + <item Type="InheritsQt" >QVBoxLayout</item> + <item Type="InheritsQt" >QLCDNumber</item> + <item Type="InheritsQt" >QInputDialog</item> + <item Type="InheritsQt" >QScrollBar</item> + <item Type="InheritsQt" >QScrollView</item> + <item Type="InheritsQt" >QWindowsStyle</item> + <item Type="InheritsQt" >QBitmap</item> + <item Type="InheritsQt" >QSignal</item> + <item Type="InheritsQt" >QMessageBox</item> + <item Type="InheritsQt" >QHeader</item> + <item Type="InheritsQt" >QMotifPlusStyle</item> + <item Type="InheritsQt" >QCDEStyle</item> + <item Type="InheritsQt" >QButton</item> + <item Type="InheritsQt" >QFtp</item> + <item Type="InheritsQt" >QGuardedPtrPrivate</item> + <item Type="InheritsQt" >QObjectCleanupHandler</item> + <item Type="InheritsQt" >QColorDialog</item> + <item Type="InheritsQt" >QCustomMenuItem</item> + <item Type="InheritsQt" >QListViewItem</item> + <item Type="InheritsQt" >QListView</item> + <item Type="InheritsQt" >QCheckListItem</item> + <item Type="InheritsQt" >QPen</item> + <item Type="InheritsQt" >QDragObject</item> + <item Type="InheritsQt" >QStoredDrag</item> + <item Type="InheritsQt" >QTextDrag</item> + <item Type="InheritsQt" >QImageDrag</item> + <item Type="InheritsQt" >QUriDrag</item> + <item Type="InheritsQt" >QColorDrag</item> + <item Type="InheritsQt" >QDragManager</item> + <item Type="InheritsQt" >QIconDrag</item> + <item Type="InheritsQt" >QIconViewItem</item> + <item Type="InheritsQt" >QIconView</item> + <item Type="InheritsQt" >QPlatinumStyle</item> + <item Type="InheritsQt" >QCursor</item> + <item Type="InheritsQt" >QErrorMessage</item> + <item Type="InheritsQt" >QPopupMenu</item> + <item Type="InheritsQt" >QPrintDialog</item> + <item Type="InheritsQt" >QProcess</item> + <item Type="InheritsQt" >QProgressBar</item> + <item Type="InheritsQt" >QSemiModal</item> + <item Type="InheritsQt" >QStyleSheetItem</item> + <item Type="InheritsQt" >QStyleSheet</item> + <item Type="InheritsQt" >QPushButton</item> + <item Type="InheritsQt" >QRadioButton</item> + <item Type="InheritsQt" >QDial</item> + <item Type="InheritsQt" >QDockAreaLayout</item> + <item Type="InheritsQt" >QDockArea</item> + <item Type="InheritsQt" >QClipboard</item> + <item Type="InheritsQt" >QListBox</item> + <item Type="InheritsQt" >QGridView</item> + <item Type="InheritsQt" >QProgressDialog</item> + <item Type="InheritsQt" >QSessionManager</item> + <item Type="InheritsQt" >QSGIStyle</item> + <item Type="InheritsQt" >QFontDialog</item> + <item Type="InheritsQt" >QTimer</item> + <item Type="InheritsQt" >QSignalMapper</item> + <item Type="InheritsQt" >QSizeGrip</item> + <item Type="InheritsQt" >QSlider</item> + <item Type="InheritsQt" >QSocket</item> + <item Type="InheritsQt" >QServerSocket</item> + <item Type="InheritsQt" >QDns</item> + <item Type="InheritsQt" >QDnsSocket</item> + <item Type="InheritsQt" >QSound</item> + <item Type="InheritsQt" >QAuServer</item> + <item Type="InheritsQt" >QSpinBox</item> + <item Type="InheritsQt" >QSplashScreen</item> + <item Type="InheritsQt" >QSplitter</item> + <item Type="InheritsQt" >QEditorFactory</item> + <item Type="InheritsQt" >QSqlResultShared</item> + <item Type="InheritsQt" >QSqlDriverPlugin</item> + <item Type="InheritsQt" >QSqlDriver</item> + <item Type="InheritsQt" >QSqlForm</item> + <item Type="InheritsQt" >QTableItem</item> + <item Type="InheritsQt" >QComboTableItem</item> + <item Type="InheritsQt" >QCheckTableItem</item> + <item Type="InheritsQt" >QTable</item> + <item Type="InheritsQt" >QSqlDatabase</item> + <item Type="InheritsQt" >QDataBrowser</item> + <item Type="InheritsQt" >QStatusBar</item> + <item Type="InheritsQt" >QMenuBar</item> + <item Type="InheritsQt" >QCanvasItem</item> + <item Type="InheritsQt" >QCanvas</item> + <item Type="InheritsQt" >QCanvasView</item> + <item Type="InheritsQt" >QCanvasPixmap</item> + <item Type="InheritsQt" >QCanvasSprite</item> + <item Type="InheritsQt" >QCanvasPolygonalItem</item> + <item Type="InheritsQt" >QCanvasRectangle</item> + <item Type="InheritsQt" >QCanvasPolygon</item> + <item Type="InheritsQt" >QCanvasSpline</item> + <item Type="InheritsQt" >QCanvasLine</item> + <item Type="InheritsQt" >QCanvasEllipse</item> + <item Type="InheritsQt" >QCanvasText</item> + <item Type="InheritsQt" >QTranslator</item> + <item Type="InheritsQt" >QStylePlugin</item> + <item Type="InheritsQt" >QTextEdit</item> + <item Type="InheritsQt" >QSyntaxHighlighter</item> + <item Type="InheritsQt" >QTab</item> + <item Type="InheritsQt" >QTabBar</item> + <item Type="InheritsQt" >QTabDialog</item> + <item Type="InheritsQt" >QSqlEditorFactory</item> + <item Type="InheritsQt" >QTabWidget</item> + <item Type="InheritsQt" >QTextBrowser</item> + <item Type="InheritsQt" >QTextCodecPlugin</item> + <item Type="InheritsQt" >QMultiLineEdit</item> + <item Type="InheritsQt" >QToolBar</item> + <item Type="InheritsQt" >QTextView</item> + <item Type="InheritsQt" >QDataPump</item> + <item Type="InheritsQt" >QMainWindow</item> + <item Type="InheritsQt" >QToolBox</item> + <item Type="InheritsQt" >QToolButton</item> + <item Type="InheritsQt" >QToolTipGroup</item> + <item Type="InheritsQt" >QToolTip</item> + <item Type="InheritsQt" >QDesktopWidget</item> + <item Type="InheritsQt" >QUrlOperator</item> + <item Type="InheritsQt" >QFileIconProvider</item> + <item Type="InheritsQt" >QFileDialog</item> + <item Type="InheritsQt" >QValidator</item> + <item Type="InheritsQt" >QIntValidator</item> + <item Type="InheritsQt" >QDoubleValidator</item> + <item Type="InheritsQt" >QRegExpValidator</item> + <item Type="InheritsQt" >QDataTable</item> + <item Type="InheritsQt" >QVBox</item> + <item Type="InheritsQt" >QVButtonGroup</item> + <item Type="InheritsQt" >QVGroupBox</item> + <item Type="InheritsQt" >QWhatsThis</item> + <item Type="InheritsQt" >QApplication</item> + <item Type="InheritsQt" >QWidgetPlugin</item> + <item Type="InheritsQt" >QWidgetStack</item> + <item Type="InheritsQt" >QCheckBox</item> + <item Type="InheritsQt" >QCompactStyle</item> + <item Type="InheritsQt" >QWizard</item> + <item Type="InheritsQt" >QPainter</item> + <item Type="InheritsQt" >QWorkspace</item> + <item Type="InheritsQt" >QLocalFs</item> + <item Type="RenamedEnumvalue" > + <Qt4>QIODevice::Append</Qt4> + <Qt3>IO_Append</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QIODevice::ReadOnly</Qt4> + <Qt3>IO_ReadOnly</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QIODevice::ReadWrite</Qt4> + <Qt3>IO_ReadWrite</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QIODevice::Text</Qt4> + <Qt3>IO_Translate</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QIODevice::Truncate</Qt4> + <Qt3>IO_Truncate</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QIODevice::WriteOnly</Qt4> + <Qt3>IO_WriteOnly</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QIODevice::Unbuffered</Qt4> + <Qt3>IO_Raw</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QAccessible::Movable</Qt4> + <Qt3>QAccessible::Moveable</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QApplication::CustomColor</Qt4> + <Qt3>QApplication::CustomColors</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QApplication::NormalColor</Qt4> + <Qt3>QApplication::NormalColors</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QCheckBox::NoChange</Qt4> + <Qt3>QButton::NoChange</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QCheckBox::Off</Qt4> + <Qt3>QButton::Off</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QCheckBox::On</Qt4> + <Qt3>QButton::On</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QChar::NoDecomposition</Qt4> + <Qt3>QChar::Single</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QChar::ByteOrderMark</Qt4> + <Qt3>QChar::byteOrderMark</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QChar::ByteOrderSwapped</Qt4> + <Qt3>QChar::byteOrderSwapped</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QChar::Nbsp</Qt4> + <Qt3>QChar::nbsp</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QChar::Null</Qt4> + <Qt3>QChar::null</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QChar::ReplacementCharacter</Qt4> + <Qt3>QChar::replacement</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QComboBox::InsertAfterCurrent</Qt4> + <Qt3>QComboBox::AfterCurrent</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QComboBox::InsertAtBottom</Qt4> + <Qt3>QComboBox::AtBottom</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QComboBox::InsertAtCurrent</Qt4> + <Qt3>QComboBox::AtCurrent</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QComboBox::InsertAtTop</Qt4> + <Qt3>QComboBox::AtTop</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QComboBox::InsertBeforeCurrent</Qt4> + <Qt3>QComboBox::BeforeCurrent</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QComboBox::NoInsert</Qt4> + <Qt3>QComboBox::NoInsertion</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QDir::NoFilter</Qt4> + <Qt3>QDir::DefaultFilter</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QDir::NoSort</Qt4> + <Qt3>QDir::DefaultSort</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFrame::Box</Qt4> + <Qt3>Q3Frame::GroupBoxPanel</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFrame::StyledPanel</Qt4> + <Qt3>Q3Frame::LineEditPanel</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFrame::StyledPanel</Qt4> + <Qt3>Q3Frame::PopupPanel</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFrame::StyledPanel</Qt4> + <Qt3>Q3Frame::MenuBarPanel</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFrame::StyledPanel</Qt4> + <Qt3>Q3Frame::ToolBarPanel</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFrame::StyledPanel</Qt4> + <Qt3>Q3Frame::TabWidgetPanel</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QEvent::Shortcut</Qt4> + <Qt3>QEvent::Accel</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QEvent::ShortcutOverride</Qt4> + <Qt3>QEvent::AccelOverride</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QEvent::WindowTitleChange</Qt4> + <Qt3>QEvent::CaptionChange</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QEvent::ChildAdded</Qt4> + <Qt3>QEvent::ChildInserted</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QEvent::InputMethodCompose</Qt4> + <Qt3>QEvent::IMCompose</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QEvent::InputMethodEnd</Qt4> + <Qt3>QEvent::IMEnd</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QEvent::InputMethodStart</Qt4> + <Qt3>QEvent::IMStart</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QEvent::WindowIconChange</Qt4> + <Qt3>QEvent::IconChange</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QEvent::LayoutRequest</Qt4> + <Qt3>QEvent::LayoutHint</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QEvent::ParentChange</Qt4> + <Qt3>QEvent::Reparent</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFile::ExeGroup</Qt4> + <Qt3>QFileInfo::ExeGroup</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFile::ExeOther</Qt4> + <Qt3>QFileInfo::ExeOther</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFile::ExeOwner</Qt4> + <Qt3>QFileInfo::ExeOwner</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFile::ExeUser</Qt4> + <Qt3>QFileInfo::ExeUser</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFile::ReadGroup</Qt4> + <Qt3>QFileInfo::ReadGroup</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFile::ReadOther</Qt4> + <Qt3>QFileInfo::ReadOther</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFile::ReadOwner</Qt4> + <Qt3>QFileInfo::ReadOwner</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFile::ReadUser</Qt4> + <Qt3>QFileInfo::ReadUser</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFile::WriteGroup</Qt4> + <Qt3>QFileInfo::WriteGroup</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFile::WriteOther</Qt4> + <Qt3>QFileInfo::WriteOther</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFile::WriteOwner</Qt4> + <Qt3>QFileInfo::WriteOwner</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFile::WriteUser</Qt4> + <Qt3>QFileInfo::WriteUser</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFrame::StyledPanel</Qt4> + <Qt3>QFrame::GroupBoxPanel</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFrame::StyledPanel</Qt4> + <Qt3>QFrame::LineEditPanel</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFrame::StyledPanel</Qt4> + <Qt3>QFrame::MenuBarPanel</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFrame::StyledPanel</Qt4> + <Qt3>QFrame::PopupPanel</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFrame::StyledPanel</Qt4> + <Qt3>QFrame::TabWidgetPanel</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QFrame::StyledPanel</Qt4> + <Qt3>QFrame::ToolBarPanel</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::IgnoreAspectRatio</Qt4> + <Qt3>QImage::ScaleFree</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::KeepAspectRatioByExpanding</Qt4> + <Qt3>QImage::ScaleMax</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::KeepAspectRatio</Qt4> + <Qt3>QImage::ScaleMin</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QKeySequence::ExactMatch</Qt4> + <Qt3>Qt::Identical</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QKeySequence::NoMatch</Qt4> + <Qt3>Qt::NoMatch</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QKeySequence::PartialMatch</Qt4> + <Qt3>Qt::PartialMatch</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QLayout::SetDefaultConstraint</Qt4> + <Qt3>QLayout::Auto</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QLayout::SetFixedSize</Qt4> + <Qt3>QLayout::Fixed</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QLayout::SetNoConstraint</Qt4> + <Qt3>QLayout::FreeResize</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QLayout::SetMinimumSize</Qt4> + <Qt3>QLayout::Minimum</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QMacStyle::SizeDefault</Qt4> + <Qt3>QMacStyle::SizeNone</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSettings::SystemScope</Qt4> + <Qt3>QSettings::Global</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSettings::UserScope</Qt4> + <Qt3>QSettings::User</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::IgnoreAspectRatio</Qt4> + <Qt3>QSize::ScaleFree</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::KeepAspectRatioByExpanding</Qt4> + <Qt3>QSize::ScaleMax</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::KeepAspectRatio</Qt4> + <Qt3>QSize::ScaleMin</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSizePolicy::Horizontally</Qt4> + <Qt3>QSizePolicy::Horizontal</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSizePolicy::Vertically</Qt4> + <Qt3>QSizePolicy::Vertical</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSlider::TicksAbove</Qt4> + <Qt3>QSlider::Above</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSlider::TicksBelow</Qt4> + <Qt3>QSlider::Below</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSlider::TicksBothSides</Qt4> + <Qt3>QSlider::Both</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSlider::TicksLeft</Qt4> + <Qt3>QSlider::Left</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSlider::NoTicks</Qt4> + <Qt3>QSlider::NoMarks</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSlider::TicksRight</Qt4> + <Qt3>QSlider::Right</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Q3Socket::Closing</Qt4> + <Qt3>QSocket::Closing</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Q3Socket::Connected</Qt4> + <Qt3>QSocket::Connected</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Q3Socket::Connecting</Qt4> + <Qt3>QSocket::Connecting</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Q3Socket::Connection</Qt4> + <Qt3>QSocket::Connection</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Q3Socket::ErrConnectionRefused</Qt4> + <Qt3>QSocket::ErrConnectionRefused</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Q3Socket::ErrHostNotFound</Qt4> + <Qt3>QSocket::ErrHostNotFound</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Q3Socket::ErrSocketRead</Qt4> + <Qt3>QSocket::ErrSocketRead</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QAbstractSocket::HostLookupState</Qt4> + <Qt3>QSocket::HostLookup</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QAbstractSocket::UnconnectedState</Qt4> + <Qt3>QSocket::Idle</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSqlError::ConnectionError</Qt4> + <Qt3>QSqlError::Connection</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSqlError::NoError</Qt4> + <Qt3>QSqlError::None</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSqlError::StatementError</Qt4> + <Qt3>QSqlError::Statement</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSqlError::TransactionError</Qt4> + <Qt3>QSqlError::Transaction</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSqlError::UnknownError</Qt4> + <Qt3>QSqlError::Unknown</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::CC_Q3ListView</Qt4> + <Qt3>QStyle::CC_ListView</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::SH_UnderlineShortcut</Qt4> + <Qt3>QStyle::SH_UnderlineAccelerator</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_Active</Qt4> + <Qt3>QStyle::Style_Active</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_AutoRaise</Qt4> + <Qt3>QStyle::Style_AutoRaise</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_Bottom</Qt4> + <Qt3>QStyle::Style_Bottom</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_Children</Qt4> + <Qt3>QStyle::Style_Children</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_None</Qt4> + <Qt3>QStyle::Style_Default</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_DownArrow</Qt4> + <Qt3>QStyle::Style_Down</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_Editing</Qt4> + <Qt3>QStyle::Style_Editing</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_Enabled</Qt4> + <Qt3>QStyle::Style_Enabled</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_FocusAtBorder</Qt4> + <Qt3>QStyle::Style_FocusAtBorder</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_HasFocus</Qt4> + <Qt3>QStyle::Style_HasFocus</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_Horizontal</Qt4> + <Qt3>QStyle::Style_Horizontal</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_Item</Qt4> + <Qt3>QStyle::Style_Item</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_MouseOver</Qt4> + <Qt3>QStyle::Style_MouseOver</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_NoChange</Qt4> + <Qt3>QStyle::Style_NoChange</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_None</Qt4> + <Qt3>QStyle::Style_None</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_Off</Qt4> + <Qt3>QStyle::Style_Off</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_On</Qt4> + <Qt3>QStyle::Style_On</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_Open</Qt4> + <Qt3>QStyle::Style_Open</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_Raised</Qt4> + <Qt3>QStyle::Style_Raised</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_Rectangle</Qt4> + <Qt3>QStyle::Style_Rectangle</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_Selected</Qt4> + <Qt3>QStyle::Style_Selected</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_Sibling</Qt4> + <Qt3>QStyle::Style_Sibling</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_Sunken</Qt4> + <Qt3>QStyle::Style_Sunken</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_Top</Qt4> + <Qt3>QStyle::Style_Top</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QStyle::State_Up</Qt4> + <Qt3>QStyle::Style_Up</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QTabBar::RoundedNorth</Qt4> + <Qt3>QTabBar::RoundedAbove</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QTabBar:: RoundedSouth</Qt4> + <Qt3>QTabBar::RoundedBelow</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QTabBar:: TriangularNorth</Qt4> + <Qt3>QTabBar::TriangularAbove</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QTabBar:: TriangularSouth</Qt4> + <Qt3>QTabBar::TriangularBelow</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QTextEdit::MovePageDown</Qt4> + <Qt3>QTextEdit::MovePgDown</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QTextEdit::MovePageUp</Qt4> + <Qt3>QTextEdit::MovePgUp</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QToolButton::BesideIcon</Qt4> + <Qt3>QToolButton::Right</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QToolButton::BelowIcon</Qt4> + <Qt3>QToolButton::Under</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QValidator::Intermediate</Qt4> + <Qt3>QValidator::Valid</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QCoreVariant::Icon</Qt4> + <Qt3>QVariant::IconSet</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::ClickFocus</Qt4> + <Qt3>QWidget::ClickFocus</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::NoFocus</Qt4> + <Qt3>QWidget::NoFocus</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::StrongFocus</Qt4> + <Qt3>QWidget::StrongFocus</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::TabFocus</Qt4> + <Qt3>QWidget::TabFocus</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WheelFocus</Qt4> + <Qt3>QWidget::WheelFocus</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::AlignLeft</Qt4> + <Qt3>Qt::AlignAuto</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::AltModifier</Qt4> + <Qt3>Qt::AltButton</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::AscendingOrder</Qt4> + <Qt3>Qt::Ascending</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DockBottom</Qt4> + <Qt3>Qt::Bottom</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::BottomLeftCorner</Qt4> + <Qt3>Qt::BottomLeft</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::BottomRightCorner</Qt4> + <Qt3>Qt::BottomRight</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::TextWrapAnywhere</Qt4> + <Qt3>Qt::BreakAnywhere</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::ControlModifier</Qt4> + <Qt3>Qt::ControlButton</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::TexturePattern</Qt4> + <Qt3>Qt::CustomPattern</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DescendingOrder</Qt4> + <Qt3>Qt::Descending</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::TextDontClip</Qt4> + <Qt3>Qt::DontClip</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::TextDontPrint</Qt4> + <Qt3>Qt::DontPrint</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::TextExpandTabs</Qt4> + <Qt3>Qt::ExpandTabs</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::TextIncludeTrailingSpaces</Qt4> + <Qt3>Qt::IncludeTrailingSpaces</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::KeyboardModifierMask</Qt4> + <Qt3>Qt::KeyButtonMask</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Backspace</Qt4> + <Qt3>Qt::Key_BackSpace</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Backtab</Qt4> + <Qt3>Qt::Key_BackTab</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_MediaPrevious</Qt4> + <Qt3>Qt::Key_MediaPrev</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_PageDown</Qt4> + <Qt3>Qt::Key_Next</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_PageUp</Qt4> + <Qt3>Qt::Key_Prior</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Aacute</Qt4> + <Qt3>Qt::Key_aacute</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Acircumflex</Qt4> + <Qt3>Qt::Key_acircumflex</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Adiaeresis</Qt4> + <Qt3>Qt::Key_adiaeresis</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_AE</Qt4> + <Qt3>Qt::Key_ae</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Agrave</Qt4> + <Qt3>Qt::Key_agrave</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Aring</Qt4> + <Qt3>Qt::Key_aring</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Atilde</Qt4> + <Qt3>Qt::Key_atilde</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Ccedilla</Qt4> + <Qt3>Qt::Key_ccedilla</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Eacute</Qt4> + <Qt3>Qt::Key_eacute</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Ecircumflex</Qt4> + <Qt3>Qt::Key_ecircumflex</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Ediaeresis</Qt4> + <Qt3>Qt::Key_ediaeresis</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Egrave</Qt4> + <Qt3>Qt::Key_egrave</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_ETH</Qt4> + <Qt3>Qt::Key_eth</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Iacute</Qt4> + <Qt3>Qt::Key_iacute</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Icircumflex</Qt4> + <Qt3>Qt::Key_icircumflex</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Idiaeresis</Qt4> + <Qt3>Qt::Key_idiaeresis</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Igrave</Qt4> + <Qt3>Qt::Key_igrave</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Ntilde</Qt4> + <Qt3>Qt::Key_ntilde</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Oacute</Qt4> + <Qt3>Qt::Key_oacute</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Ocircumflex</Qt4> + <Qt3>Qt::Key_ocircumflex</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Odiaeresis</Qt4> + <Qt3>Qt::Key_odiaeresis</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Ograve</Qt4> + <Qt3>Qt::Key_ograve</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Ooblique</Qt4> + <Qt3>Qt::Key_oslash</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Otilde</Qt4> + <Qt3>Qt::Key_otilde</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_THORN</Qt4> + <Qt3>Qt::Key_thorn</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Uacute</Qt4> + <Qt3>Qt::Key_uacute</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Ucircumflex</Qt4> + <Qt3>Qt::Key_ucircumflex</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Udiaeresis</Qt4> + <Qt3>Qt::Key_udiaeresis</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Ugrave</Qt4> + <Qt3>Qt::Key_ugrave</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Yacute</Qt4> + <Qt3>Qt::Key_yacute</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::KeypadModifier</Qt4> + <Qt3>Qt::Keypad</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DockLeft</Qt4> + <Qt3>Qt::Left</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::MV_10_0</Qt4> + <Qt3>Qt::MV_10_DOT_0</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::MV_10_1</Qt4> + <Qt3>Qt::MV_10_DOT_1</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::MV_10_2</Qt4> + <Qt3>Qt::MV_10_DOT_2</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::MV_10_3</Qt4> + <Qt3>Qt::MV_10_DOT_3</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::MV_10_4</Qt4> + <Qt3>Qt::MV_10_DOT_4</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::MV_9</Qt4> + <Qt3>Qt::MV_9</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::MV_10_0</Qt4> + <Qt3>Qt::MV_CHEETAH</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::MV_10_2</Qt4> + <Qt3>Qt::MV_JAGUAR</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::MV_10_3</Qt4> + <Qt3>Qt::MV_PANTHER</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::MV_10_1</Qt4> + <Qt3>Qt::MV_PUMA</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::MV_10_4</Qt4> + <Qt3>Qt::MV_TIGER</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::MV_Unknown</Qt4> + <Qt3>Qt::MV_Unknown</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::MetaModifier</Qt4> + <Qt3>Qt::MetaButton</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DockMinimized</Qt4> + <Qt3>Qt::Minimized</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::TextHideMnemonic</Qt4> + <Qt3>Qt::NoAccel</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::TextOverline</Qt4> + <Qt3>Qt::Overline</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DockRight</Qt4> + <Qt3>Qt::Right</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::ShiftModifier</Qt4> + <Qt3>Qt::ShiftButton</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::TextShowMnemonic</Qt4> + <Qt3>Qt::ShowPrefix</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::TextSingleLine</Qt4> + <Qt3>Qt::SingleLine</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::TextStrikeOut</Qt4> + <Qt3>Qt::StrikeOut</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DockTop</Qt4> + <Qt3>Qt::Top</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::TopLeftCorner</Qt4> + <Qt3>Qt::TopLeft</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::TopRightCorner</Qt4> + <Qt3>Qt::TopRight</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DockTornOff</Qt4> + <Qt3>Qt::TornOff</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::TextUnderline</Qt4> + <Qt3>Qt::Underline</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DockUnmanaged</Qt4> + <Qt3>Qt::Unmanaged</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WStaticContents</Qt4> + <Qt3>Qt::WNorthWestGravity</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WNoAutoErase</Qt4> + <Qt3>Qt::WRepaintNoErase</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WType_Dialog</Qt4> + <Qt3>Qt::WStyle_Dialog</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WStyle_NoBorder</Qt4> + <Qt3>Qt::WStyle_NoBorderEx</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>(Qt::WType_Dialog | Qt::WShowModal)</Qt4> + <Qt3>Qt::WType_Modal</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::WV_2000</Qt4> + <Qt3>Qt::WV_2000</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::WV_2003</Qt4> + <Qt3>Qt::WV_2003</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::WV_32s</Qt4> + <Qt3>Qt::WV_32s</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::WV_95</Qt4> + <Qt3>Qt::WV_95</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::WV_98</Qt4> + <Qt3>Qt::WV_98</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::WV_CE</Qt4> + <Qt3>Qt::WV_CE</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::WV_CENET</Qt4> + <Qt3>Qt::WV_CENET</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::WV_CE_based</Qt4> + <Qt3>Qt::WV_CE_based</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::WV_DOS_based</Qt4> + <Qt3>Qt::WV_DOS_based</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::WV_Me</Qt4> + <Qt3>Qt::WV_Me</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::WV_NT</Qt4> + <Qt3>Qt::WV_NT</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::WV_NT_based</Qt4> + <Qt3>Qt::WV_NT_based</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>QSysInfo::WV_XP</Qt4> + <Qt3>Qt::WV_XP</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::TextWordWrap</Qt4> + <Qt3>Qt::WordBreak</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::IBeamCursor</Qt4> + <Qt3>Qt::IbeamCursor</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::NoButton</Qt4> + <Qt3>Qt::NoButton</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::LeftButton</Qt4> + <Qt3>Qt::LeftButton</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::RightButton</Qt4> + <Qt3>Qt::RightButton</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::MidButton</Qt4> + <Qt3>Qt::MidButton</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::MouseButtonMask</Qt4> + <Qt3>Qt::MouseButtonMask</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::ShiftButton</Qt4> + <Qt3>Qt::ShiftButton</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::ControlButton</Qt4> + <Qt3>Qt::ControlButton</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::AltButton</Qt4> + <Qt3>Qt::AltButton</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::MetaButton</Qt4> + <Qt3>Qt::MetaButton</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::KeyButtonMask</Qt4> + <Qt3>Qt::KeyButtonMask</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Keypad</Qt4> + <Qt3>Qt::Keypad</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Horizontal</Qt4> + <Qt3>Qt::Horizontal</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Vertical</Qt4> + <Qt3>Qt::Vertical</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::AlignAuto</Qt4> + <Qt3>Qt::AlignAuto</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::AlignLeft</Qt4> + <Qt3>Qt::AlignLeft</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::AlignRight</Qt4> + <Qt3>Qt::AlignRight</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::AlignHCenter</Qt4> + <Qt3>Qt::AlignHCenter</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::AlignJustify</Qt4> + <Qt3>Qt::AlignJustify</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::AlignHorizontal_Mask</Qt4> + <Qt3>Qt::AlignHorizontal_Mask</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::AlignTop</Qt4> + <Qt3>Qt::AlignTop</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::AlignBottom</Qt4> + <Qt3>Qt::AlignBottom</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::AlignVCenter</Qt4> + <Qt3>Qt::AlignVCenter</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::AlignVertical_Mask</Qt4> + <Qt3>Qt::AlignVertical_Mask</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::AlignCenter</Qt4> + <Qt3>Qt::AlignCenter</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::SingleLine</Qt4> + <Qt3>Qt::SingleLine</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DontClip</Qt4> + <Qt3>Qt::DontClip</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::ExpandTabs</Qt4> + <Qt3>Qt::ExpandTabs</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::ShowPrefix</Qt4> + <Qt3>Qt::ShowPrefix</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WordBreak</Qt4> + <Qt3>Qt::WordBreak</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::BreakAnywhere</Qt4> + <Qt3>Qt::BreakAnywhere</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DontPrint</Qt4> + <Qt3>Qt::DontPrint</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::IncludeTrailingSpaces</Qt4> + <Qt3>Qt::IncludeTrailingSpaces</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::NoAccel</Qt4> + <Qt3>Qt::NoAccel</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WType_TopLevel</Qt4> + <Qt3>Qt::WType_TopLevel</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WType_Dialog</Qt4> + <Qt3>Qt::WType_Dialog</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WType_Popup</Qt4> + <Qt3>Qt::WType_Popup</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WType_Desktop</Qt4> + <Qt3>Qt::WType_Desktop</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WType_Mask</Qt4> + <Qt3>Qt::WType_Mask</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WStyle_Customize</Qt4> + <Qt3>Qt::WStyle_Customize</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WStyle_NormalBorder</Qt4> + <Qt3>Qt::WStyle_NormalBorder</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WStyle_DialogBorder</Qt4> + <Qt3>Qt::WStyle_DialogBorder</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WStyle_NoBorder</Qt4> + <Qt3>Qt::WStyle_NoBorder</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WStyle_Title</Qt4> + <Qt3>Qt::WStyle_Title</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WStyle_SysMenu</Qt4> + <Qt3>Qt::WStyle_SysMenu</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WStyle_Minimize</Qt4> + <Qt3>Qt::WStyle_Minimize</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WStyle_Maximize</Qt4> + <Qt3>Qt::WStyle_Maximize</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WStyle_MinMax</Qt4> + <Qt3>Qt::WStyle_MinMax</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WStyle_Tool</Qt4> + <Qt3>Qt::WStyle_Tool</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WStyle_StaysOnTop</Qt4> + <Qt3>Qt::WStyle_StaysOnTop</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WStyle_ContextHelp</Qt4> + <Qt3>Qt::WStyle_ContextHelp</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WDestructiveClose</Qt4> + <Qt3>Qt::WDestructiveClose</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WPaintDesktop</Qt4> + <Qt3>Qt::WPaintDesktop</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WPaintClever</Qt4> + <Qt3>Qt::WPaintClever</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WResizeNoErase</Qt4> + <Qt3>Qt::WResizeNoErase</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WMouseNoMask</Qt4> + <Qt3>Qt::WMouseNoMask</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WStaticContents</Qt4> + <Qt3>Qt::WStaticContents</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WRepaintNoErase</Qt4> + <Qt3>Qt::WRepaintNoErase</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WX11BypassWM</Qt4> + <Qt3>Qt::WX11BypassWM</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WWinOwnDC</Qt4> + <Qt3>Qt::WWinOwnDC</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WMacNoSheet</Qt4> + <Qt3>Qt::WMacNoSheet</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WMacDrawer</Qt4> + <Qt3>Qt::WMacDrawer</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WGroupLeader</Qt4> + <Qt3>Qt::WGroupLeader</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WShowModal</Qt4> + <Qt3>Qt::WShowModal</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WNoMousePropagation</Qt4> + <Qt3>Qt::WNoMousePropagation</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WStyle_Splash</Qt4> + <Qt3>Qt::WStyle_Splash</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WNoAutoErase</Qt4> + <Qt3>Qt::WNoAutoErase</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WNorthWestGravity</Qt4> + <Qt3>Qt::WNorthWestGravity</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WType_Modal</Qt4> + <Qt3>Qt::WType_Modal</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WStyle_Dialog</Qt4> + <Qt3>Qt::WStyle_Dialog</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WStyle_NoBorderEx</Qt4> + <Qt3>Qt::WStyle_NoBorderEx</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WindowNoState</Qt4> + <Qt3>Qt::WindowNoState</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WindowMinimized</Qt4> + <Qt3>Qt::WindowMinimized</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WindowMaximized</Qt4> + <Qt3>Qt::WindowMaximized</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WindowFullScreen</Qt4> + <Qt3>Qt::WindowFullScreen</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WindowActive</Qt4> + <Qt3>Qt::WindowActive</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::ColorMode_Mask</Qt4> + <Qt3>Qt::ColorMode_Mask</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::AutoColor</Qt4> + <Qt3>Qt::AutoColor</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::ColorOnly</Qt4> + <Qt3>Qt::ColorOnly</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::MonoOnly</Qt4> + <Qt3>Qt::MonoOnly</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::AlphaDither_Mask</Qt4> + <Qt3>Qt::AlphaDither_Mask</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::ThresholdAlphaDither</Qt4> + <Qt3>Qt::ThresholdAlphaDither</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::OrderedAlphaDither</Qt4> + <Qt3>Qt::OrderedAlphaDither</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DiffuseAlphaDither</Qt4> + <Qt3>Qt::DiffuseAlphaDither</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::NoAlpha</Qt4> + <Qt3>Qt::NoAlpha</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Dither_Mask</Qt4> + <Qt3>Qt::Dither_Mask</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DiffuseDither</Qt4> + <Qt3>Qt::DiffuseDither</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::OrderedDither</Qt4> + <Qt3>Qt::OrderedDither</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::ThresholdDither</Qt4> + <Qt3>Qt::ThresholdDither</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DitherMode_Mask</Qt4> + <Qt3>Qt::DitherMode_Mask</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::AutoDither</Qt4> + <Qt3>Qt::AutoDither</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::PreferDither</Qt4> + <Qt3>Qt::PreferDither</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::AvoidDither</Qt4> + <Qt3>Qt::AvoidDither</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::TransparentMode</Qt4> + <Qt3>Qt::TransparentMode</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::OpaqueMode</Qt4> + <Qt3>Qt::OpaqueMode</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::PixelUnit</Qt4> + <Qt3>Qt::PixelUnit</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::LoMetricUnit</Qt4> + <Qt3>Qt::LoMetricUnit</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::HiMetricUnit</Qt4> + <Qt3>Qt::HiMetricUnit</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::LoEnglishUnit</Qt4> + <Qt3>Qt::LoEnglishUnit</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::HiEnglishUnit</Qt4> + <Qt3>Qt::HiEnglishUnit</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::TwipsUnit</Qt4> + <Qt3>Qt::TwipsUnit</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::MacStyle</Qt4> + <Qt3>Qt::MacStyle</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WindowsStyle</Qt4> + <Qt3>Qt::WindowsStyle</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Win3Style</Qt4> + <Qt3>Qt::Win3Style</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::PMStyle</Qt4> + <Qt3>Qt::PMStyle</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::MotifStyle</Qt4> + <Qt3>Qt::MotifStyle</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::META</Qt4> + <Qt3>Qt::META</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::SHIFT</Qt4> + <Qt3>Qt::SHIFT</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::CTRL</Qt4> + <Qt3>Qt::CTRL</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::ALT</Qt4> + <Qt3>Qt::ALT</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::MODIFIER_MASK</Qt4> + <Qt3>Qt::MODIFIER_MASK</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::UNICODE_ACCEL</Qt4> + <Qt3>Qt::UNICODE_ACCEL</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Escape</Qt4> + <Qt3>Qt::Key_Escape</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Tab</Qt4> + <Qt3>Qt::Key_Tab</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Backtab</Qt4> + <Qt3>Qt::Key_Backtab</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_BackTab</Qt4> + <Qt3>Qt::Key_BackTab</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Backspace</Qt4> + <Qt3>Qt::Key_Backspace</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_BackSpace</Qt4> + <Qt3>Qt::Key_BackSpace</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Return</Qt4> + <Qt3>Qt::Key_Return</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Enter</Qt4> + <Qt3>Qt::Key_Enter</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Insert</Qt4> + <Qt3>Qt::Key_Insert</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Delete</Qt4> + <Qt3>Qt::Key_Delete</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Pause</Qt4> + <Qt3>Qt::Key_Pause</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Print</Qt4> + <Qt3>Qt::Key_Print</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_SysReq</Qt4> + <Qt3>Qt::Key_SysReq</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Clear</Qt4> + <Qt3>Qt::Key_Clear</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Home</Qt4> + <Qt3>Qt::Key_Home</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_End</Qt4> + <Qt3>Qt::Key_End</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Left</Qt4> + <Qt3>Qt::Key_Left</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Up</Qt4> + <Qt3>Qt::Key_Up</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Right</Qt4> + <Qt3>Qt::Key_Right</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Down</Qt4> + <Qt3>Qt::Key_Down</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Prior</Qt4> + <Qt3>Qt::Key_Prior</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_PageUp</Qt4> + <Qt3>Qt::Key_PageUp</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Next</Qt4> + <Qt3>Qt::Key_Next</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_PageDown</Qt4> + <Qt3>Qt::Key_PageDown</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Shift</Qt4> + <Qt3>Qt::Key_Shift</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Control</Qt4> + <Qt3>Qt::Key_Control</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Meta</Qt4> + <Qt3>Qt::Key_Meta</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Alt</Qt4> + <Qt3>Qt::Key_Alt</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_CapsLock</Qt4> + <Qt3>Qt::Key_CapsLock</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_NumLock</Qt4> + <Qt3>Qt::Key_NumLock</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_ScrollLock</Qt4> + <Qt3>Qt::Key_ScrollLock</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F1</Qt4> + <Qt3>Qt::Key_F1</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F2</Qt4> + <Qt3>Qt::Key_F2</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F3</Qt4> + <Qt3>Qt::Key_F3</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F4</Qt4> + <Qt3>Qt::Key_F4</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F5</Qt4> + <Qt3>Qt::Key_F5</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F6</Qt4> + <Qt3>Qt::Key_F6</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F7</Qt4> + <Qt3>Qt::Key_F7</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F8</Qt4> + <Qt3>Qt::Key_F8</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F9</Qt4> + <Qt3>Qt::Key_F9</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F10</Qt4> + <Qt3>Qt::Key_F10</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F11</Qt4> + <Qt3>Qt::Key_F11</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F12</Qt4> + <Qt3>Qt::Key_F12</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F13</Qt4> + <Qt3>Qt::Key_F13</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F14</Qt4> + <Qt3>Qt::Key_F14</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F15</Qt4> + <Qt3>Qt::Key_F15</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F16</Qt4> + <Qt3>Qt::Key_F16</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F17</Qt4> + <Qt3>Qt::Key_F17</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F18</Qt4> + <Qt3>Qt::Key_F18</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F19</Qt4> + <Qt3>Qt::Key_F19</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F20</Qt4> + <Qt3>Qt::Key_F20</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F21</Qt4> + <Qt3>Qt::Key_F21</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F22</Qt4> + <Qt3>Qt::Key_F22</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F23</Qt4> + <Qt3>Qt::Key_F23</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F24</Qt4> + <Qt3>Qt::Key_F24</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F25</Qt4> + <Qt3>Qt::Key_F25</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F26</Qt4> + <Qt3>Qt::Key_F26</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F27</Qt4> + <Qt3>Qt::Key_F27</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F28</Qt4> + <Qt3>Qt::Key_F28</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F29</Qt4> + <Qt3>Qt::Key_F29</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F30</Qt4> + <Qt3>Qt::Key_F30</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F31</Qt4> + <Qt3>Qt::Key_F31</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F32</Qt4> + <Qt3>Qt::Key_F32</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F33</Qt4> + <Qt3>Qt::Key_F33</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F34</Qt4> + <Qt3>Qt::Key_F34</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F35</Qt4> + <Qt3>Qt::Key_F35</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Super_L</Qt4> + <Qt3>Qt::Key_Super_L</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Super_R</Qt4> + <Qt3>Qt::Key_Super_R</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Menu</Qt4> + <Qt3>Qt::Key_Menu</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Hyper_L</Qt4> + <Qt3>Qt::Key_Hyper_L</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Hyper_R</Qt4> + <Qt3>Qt::Key_Hyper_R</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Help</Qt4> + <Qt3>Qt::Key_Help</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Direction_L</Qt4> + <Qt3>Qt::Key_Direction_L</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Direction_R</Qt4> + <Qt3>Qt::Key_Direction_R</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Space</Qt4> + <Qt3>Qt::Key_Space</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Any</Qt4> + <Qt3>Qt::Key_Any</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Exclam</Qt4> + <Qt3>Qt::Key_Exclam</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_QuoteDbl</Qt4> + <Qt3>Qt::Key_QuoteDbl</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_NumberSign</Qt4> + <Qt3>Qt::Key_NumberSign</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Dollar</Qt4> + <Qt3>Qt::Key_Dollar</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Percent</Qt4> + <Qt3>Qt::Key_Percent</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Ampersand</Qt4> + <Qt3>Qt::Key_Ampersand</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Apostrophe</Qt4> + <Qt3>Qt::Key_Apostrophe</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_ParenLeft</Qt4> + <Qt3>Qt::Key_ParenLeft</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_ParenRight</Qt4> + <Qt3>Qt::Key_ParenRight</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Asterisk</Qt4> + <Qt3>Qt::Key_Asterisk</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Plus</Qt4> + <Qt3>Qt::Key_Plus</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Comma</Qt4> + <Qt3>Qt::Key_Comma</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Minus</Qt4> + <Qt3>Qt::Key_Minus</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Period</Qt4> + <Qt3>Qt::Key_Period</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Slash</Qt4> + <Qt3>Qt::Key_Slash</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_0</Qt4> + <Qt3>Qt::Key_0</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_1</Qt4> + <Qt3>Qt::Key_1</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_2</Qt4> + <Qt3>Qt::Key_2</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_3</Qt4> + <Qt3>Qt::Key_3</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_4</Qt4> + <Qt3>Qt::Key_4</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_5</Qt4> + <Qt3>Qt::Key_5</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_6</Qt4> + <Qt3>Qt::Key_6</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_7</Qt4> + <Qt3>Qt::Key_7</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_8</Qt4> + <Qt3>Qt::Key_8</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_9</Qt4> + <Qt3>Qt::Key_9</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Colon</Qt4> + <Qt3>Qt::Key_Colon</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Semicolon</Qt4> + <Qt3>Qt::Key_Semicolon</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Less</Qt4> + <Qt3>Qt::Key_Less</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Equal</Qt4> + <Qt3>Qt::Key_Equal</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Greater</Qt4> + <Qt3>Qt::Key_Greater</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Question</Qt4> + <Qt3>Qt::Key_Question</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_At</Qt4> + <Qt3>Qt::Key_At</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_A</Qt4> + <Qt3>Qt::Key_A</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_B</Qt4> + <Qt3>Qt::Key_B</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_C</Qt4> + <Qt3>Qt::Key_C</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_D</Qt4> + <Qt3>Qt::Key_D</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_E</Qt4> + <Qt3>Qt::Key_E</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_F</Qt4> + <Qt3>Qt::Key_F</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_G</Qt4> + <Qt3>Qt::Key_G</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_H</Qt4> + <Qt3>Qt::Key_H</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_I</Qt4> + <Qt3>Qt::Key_I</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_J</Qt4> + <Qt3>Qt::Key_J</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_K</Qt4> + <Qt3>Qt::Key_K</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_L</Qt4> + <Qt3>Qt::Key_L</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_M</Qt4> + <Qt3>Qt::Key_M</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_N</Qt4> + <Qt3>Qt::Key_N</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_O</Qt4> + <Qt3>Qt::Key_O</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_P</Qt4> + <Qt3>Qt::Key_P</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Q</Qt4> + <Qt3>Qt::Key_Q</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_R</Qt4> + <Qt3>Qt::Key_R</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_S</Qt4> + <Qt3>Qt::Key_S</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_T</Qt4> + <Qt3>Qt::Key_T</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_U</Qt4> + <Qt3>Qt::Key_U</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_V</Qt4> + <Qt3>Qt::Key_V</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_W</Qt4> + <Qt3>Qt::Key_W</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_X</Qt4> + <Qt3>Qt::Key_X</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Y</Qt4> + <Qt3>Qt::Key_Y</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Z</Qt4> + <Qt3>Qt::Key_Z</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_BracketLeft</Qt4> + <Qt3>Qt::Key_BracketLeft</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Backslash</Qt4> + <Qt3>Qt::Key_Backslash</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_BracketRight</Qt4> + <Qt3>Qt::Key_BracketRight</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_AsciiCircum</Qt4> + <Qt3>Qt::Key_AsciiCircum</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Underscore</Qt4> + <Qt3>Qt::Key_Underscore</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_QuoteLeft</Qt4> + <Qt3>Qt::Key_QuoteLeft</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_BraceLeft</Qt4> + <Qt3>Qt::Key_BraceLeft</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Bar</Qt4> + <Qt3>Qt::Key_Bar</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_BraceRight</Qt4> + <Qt3>Qt::Key_BraceRight</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_AsciiTilde</Qt4> + <Qt3>Qt::Key_AsciiTilde</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_nobreakspace</Qt4> + <Qt3>Qt::Key_nobreakspace</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_exclamdown</Qt4> + <Qt3>Qt::Key_exclamdown</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_cent</Qt4> + <Qt3>Qt::Key_cent</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_sterling</Qt4> + <Qt3>Qt::Key_sterling</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_currency</Qt4> + <Qt3>Qt::Key_currency</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_yen</Qt4> + <Qt3>Qt::Key_yen</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_brokenbar</Qt4> + <Qt3>Qt::Key_brokenbar</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_section</Qt4> + <Qt3>Qt::Key_section</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_diaeresis</Qt4> + <Qt3>Qt::Key_diaeresis</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_copyright</Qt4> + <Qt3>Qt::Key_copyright</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_ordfeminine</Qt4> + <Qt3>Qt::Key_ordfeminine</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_guillemotleft</Qt4> + <Qt3>Qt::Key_guillemotleft</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_notsign</Qt4> + <Qt3>Qt::Key_notsign</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_hyphen</Qt4> + <Qt3>Qt::Key_hyphen</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_registered</Qt4> + <Qt3>Qt::Key_registered</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_macron</Qt4> + <Qt3>Qt::Key_macron</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_degree</Qt4> + <Qt3>Qt::Key_degree</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_plusminus</Qt4> + <Qt3>Qt::Key_plusminus</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_twosuperior</Qt4> + <Qt3>Qt::Key_twosuperior</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_threesuperior</Qt4> + <Qt3>Qt::Key_threesuperior</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_acute</Qt4> + <Qt3>Qt::Key_acute</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_mu</Qt4> + <Qt3>Qt::Key_mu</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_paragraph</Qt4> + <Qt3>Qt::Key_paragraph</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_periodcentered</Qt4> + <Qt3>Qt::Key_periodcentered</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_cedilla</Qt4> + <Qt3>Qt::Key_cedilla</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_onesuperior</Qt4> + <Qt3>Qt::Key_onesuperior</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_masculine</Qt4> + <Qt3>Qt::Key_masculine</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_guillemotright</Qt4> + <Qt3>Qt::Key_guillemotright</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_onequarter</Qt4> + <Qt3>Qt::Key_onequarter</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_onehalf</Qt4> + <Qt3>Qt::Key_onehalf</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_threequarters</Qt4> + <Qt3>Qt::Key_threequarters</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_questiondown</Qt4> + <Qt3>Qt::Key_questiondown</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Agrave</Qt4> + <Qt3>Qt::Key_Agrave</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Aacute</Qt4> + <Qt3>Qt::Key_Aacute</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Acircumflex</Qt4> + <Qt3>Qt::Key_Acircumflex</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Atilde</Qt4> + <Qt3>Qt::Key_Atilde</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Adiaeresis</Qt4> + <Qt3>Qt::Key_Adiaeresis</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Aring</Qt4> + <Qt3>Qt::Key_Aring</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_AE</Qt4> + <Qt3>Qt::Key_AE</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Ccedilla</Qt4> + <Qt3>Qt::Key_Ccedilla</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Egrave</Qt4> + <Qt3>Qt::Key_Egrave</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Eacute</Qt4> + <Qt3>Qt::Key_Eacute</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Ecircumflex</Qt4> + <Qt3>Qt::Key_Ecircumflex</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Ediaeresis</Qt4> + <Qt3>Qt::Key_Ediaeresis</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Igrave</Qt4> + <Qt3>Qt::Key_Igrave</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Iacute</Qt4> + <Qt3>Qt::Key_Iacute</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Icircumflex</Qt4> + <Qt3>Qt::Key_Icircumflex</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Idiaeresis</Qt4> + <Qt3>Qt::Key_Idiaeresis</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_ETH</Qt4> + <Qt3>Qt::Key_ETH</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Ntilde</Qt4> + <Qt3>Qt::Key_Ntilde</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Ograve</Qt4> + <Qt3>Qt::Key_Ograve</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Oacute</Qt4> + <Qt3>Qt::Key_Oacute</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Ocircumflex</Qt4> + <Qt3>Qt::Key_Ocircumflex</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Otilde</Qt4> + <Qt3>Qt::Key_Otilde</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Odiaeresis</Qt4> + <Qt3>Qt::Key_Odiaeresis</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_multiply</Qt4> + <Qt3>Qt::Key_multiply</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Ooblique</Qt4> + <Qt3>Qt::Key_Ooblique</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Ugrave</Qt4> + <Qt3>Qt::Key_Ugrave</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Uacute</Qt4> + <Qt3>Qt::Key_Uacute</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Ucircumflex</Qt4> + <Qt3>Qt::Key_Ucircumflex</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Udiaeresis</Qt4> + <Qt3>Qt::Key_Udiaeresis</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Yacute</Qt4> + <Qt3>Qt::Key_Yacute</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_THORN</Qt4> + <Qt3>Qt::Key_THORN</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_ssharp</Qt4> + <Qt3>Qt::Key_ssharp</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_agrave</Qt4> + <Qt3>Qt::Key_agrave</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_aacute</Qt4> + <Qt3>Qt::Key_aacute</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_acircumflex</Qt4> + <Qt3>Qt::Key_acircumflex</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_atilde</Qt4> + <Qt3>Qt::Key_atilde</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_adiaeresis</Qt4> + <Qt3>Qt::Key_adiaeresis</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_aring</Qt4> + <Qt3>Qt::Key_aring</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_ae</Qt4> + <Qt3>Qt::Key_ae</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_ccedilla</Qt4> + <Qt3>Qt::Key_ccedilla</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_egrave</Qt4> + <Qt3>Qt::Key_egrave</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_eacute</Qt4> + <Qt3>Qt::Key_eacute</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_ecircumflex</Qt4> + <Qt3>Qt::Key_ecircumflex</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_ediaeresis</Qt4> + <Qt3>Qt::Key_ediaeresis</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_igrave</Qt4> + <Qt3>Qt::Key_igrave</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_iacute</Qt4> + <Qt3>Qt::Key_iacute</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_icircumflex</Qt4> + <Qt3>Qt::Key_icircumflex</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_idiaeresis</Qt4> + <Qt3>Qt::Key_idiaeresis</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_eth</Qt4> + <Qt3>Qt::Key_eth</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_ntilde</Qt4> + <Qt3>Qt::Key_ntilde</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_ograve</Qt4> + <Qt3>Qt::Key_ograve</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_oacute</Qt4> + <Qt3>Qt::Key_oacute</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_ocircumflex</Qt4> + <Qt3>Qt::Key_ocircumflex</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_otilde</Qt4> + <Qt3>Qt::Key_otilde</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_odiaeresis</Qt4> + <Qt3>Qt::Key_odiaeresis</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_division</Qt4> + <Qt3>Qt::Key_division</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_oslash</Qt4> + <Qt3>Qt::Key_oslash</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_ugrave</Qt4> + <Qt3>Qt::Key_ugrave</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_uacute</Qt4> + <Qt3>Qt::Key_uacute</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_ucircumflex</Qt4> + <Qt3>Qt::Key_ucircumflex</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_udiaeresis</Qt4> + <Qt3>Qt::Key_udiaeresis</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_yacute</Qt4> + <Qt3>Qt::Key_yacute</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_thorn</Qt4> + <Qt3>Qt::Key_thorn</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_ydiaeresis</Qt4> + <Qt3>Qt::Key_ydiaeresis</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Back</Qt4> + <Qt3>Qt::Key_Back</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Forward</Qt4> + <Qt3>Qt::Key_Forward</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Stop</Qt4> + <Qt3>Qt::Key_Stop</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Refresh</Qt4> + <Qt3>Qt::Key_Refresh</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_VolumeDown</Qt4> + <Qt3>Qt::Key_VolumeDown</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_VolumeMute</Qt4> + <Qt3>Qt::Key_VolumeMute</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_VolumeUp</Qt4> + <Qt3>Qt::Key_VolumeUp</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_BassBoost</Qt4> + <Qt3>Qt::Key_BassBoost</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_BassUp</Qt4> + <Qt3>Qt::Key_BassUp</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_BassDown</Qt4> + <Qt3>Qt::Key_BassDown</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_TrebleUp</Qt4> + <Qt3>Qt::Key_TrebleUp</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_TrebleDown</Qt4> + <Qt3>Qt::Key_TrebleDown</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_MediaPlay</Qt4> + <Qt3>Qt::Key_MediaPlay</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_MediaStop</Qt4> + <Qt3>Qt::Key_MediaStop</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_MediaPrev</Qt4> + <Qt3>Qt::Key_MediaPrev</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_MediaNext</Qt4> + <Qt3>Qt::Key_MediaNext</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_MediaRecord</Qt4> + <Qt3>Qt::Key_MediaRecord</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_HomePage</Qt4> + <Qt3>Qt::Key_HomePage</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Favorites</Qt4> + <Qt3>Qt::Key_Favorites</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Search</Qt4> + <Qt3>Qt::Key_Search</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Standby</Qt4> + <Qt3>Qt::Key_Standby</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_OpenUrl</Qt4> + <Qt3>Qt::Key_OpenUrl</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_LaunchMail</Qt4> + <Qt3>Qt::Key_LaunchMail</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_LaunchMedia</Qt4> + <Qt3>Qt::Key_LaunchMedia</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Launch0</Qt4> + <Qt3>Qt::Key_Launch0</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Launch1</Qt4> + <Qt3>Qt::Key_Launch1</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Launch2</Qt4> + <Qt3>Qt::Key_Launch2</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Launch3</Qt4> + <Qt3>Qt::Key_Launch3</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Launch4</Qt4> + <Qt3>Qt::Key_Launch4</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Launch5</Qt4> + <Qt3>Qt::Key_Launch5</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Launch6</Qt4> + <Qt3>Qt::Key_Launch6</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Launch7</Qt4> + <Qt3>Qt::Key_Launch7</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Launch8</Qt4> + <Qt3>Qt::Key_Launch8</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_Launch9</Qt4> + <Qt3>Qt::Key_Launch9</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_LaunchA</Qt4> + <Qt3>Qt::Key_LaunchA</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_LaunchB</Qt4> + <Qt3>Qt::Key_LaunchB</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_LaunchC</Qt4> + <Qt3>Qt::Key_LaunchC</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_LaunchD</Qt4> + <Qt3>Qt::Key_LaunchD</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_LaunchE</Qt4> + <Qt3>Qt::Key_LaunchE</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_LaunchF</Qt4> + <Qt3>Qt::Key_LaunchF</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_MediaLast</Qt4> + <Qt3>Qt::Key_MediaLast</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Key_unknown</Qt4> + <Qt3>Qt::Key_unknown</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::UpArrow</Qt4> + <Qt3>Qt::UpArrow</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DownArrow</Qt4> + <Qt3>Qt::DownArrow</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::LeftArrow</Qt4> + <Qt3>Qt::LeftArrow</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::RightArrow</Qt4> + <Qt3>Qt::RightArrow</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::NoPen</Qt4> + <Qt3>Qt::NoPen</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::SolidLine</Qt4> + <Qt3>Qt::SolidLine</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DashLine</Qt4> + <Qt3>Qt::DashLine</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DotLine</Qt4> + <Qt3>Qt::DotLine</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DashDotLine</Qt4> + <Qt3>Qt::DashDotLine</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DashDotDotLine</Qt4> + <Qt3>Qt::DashDotDotLine</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::MPenStyle</Qt4> + <Qt3>Qt::MPenStyle</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::FlatCap</Qt4> + <Qt3>Qt::FlatCap</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::SquareCap</Qt4> + <Qt3>Qt::SquareCap</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::RoundCap</Qt4> + <Qt3>Qt::RoundCap</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::MPenCapStyle</Qt4> + <Qt3>Qt::MPenCapStyle</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::MiterJoin</Qt4> + <Qt3>Qt::MiterJoin</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::BevelJoin</Qt4> + <Qt3>Qt::BevelJoin</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::RoundJoin</Qt4> + <Qt3>Qt::RoundJoin</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::MPenJoinStyle</Qt4> + <Qt3>Qt::MPenJoinStyle</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::NoBrush</Qt4> + <Qt3>Qt::NoBrush</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::SolidPattern</Qt4> + <Qt3>Qt::SolidPattern</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Dense1Pattern</Qt4> + <Qt3>Qt::Dense1Pattern</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Dense2Pattern</Qt4> + <Qt3>Qt::Dense2Pattern</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Dense3Pattern</Qt4> + <Qt3>Qt::Dense3Pattern</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Dense4Pattern</Qt4> + <Qt3>Qt::Dense4Pattern</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Dense5Pattern</Qt4> + <Qt3>Qt::Dense5Pattern</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Dense6Pattern</Qt4> + <Qt3>Qt::Dense6Pattern</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Dense7Pattern</Qt4> + <Qt3>Qt::Dense7Pattern</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::HorPattern</Qt4> + <Qt3>Qt::HorPattern</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::VerPattern</Qt4> + <Qt3>Qt::VerPattern</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::CrossPattern</Qt4> + <Qt3>Qt::CrossPattern</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::BDiagPattern</Qt4> + <Qt3>Qt::BDiagPattern</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::FDiagPattern</Qt4> + <Qt3>Qt::FDiagPattern</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DiagCrossPattern</Qt4> + <Qt3>Qt::DiagCrossPattern</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::CustomPattern</Qt4> + <Qt3>Qt::CustomPattern</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::UI_General</Qt4> + <Qt3>Qt::UI_General</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::UI_AnimateMenu</Qt4> + <Qt3>Qt::UI_AnimateMenu</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::UI_FadeMenu</Qt4> + <Qt3>Qt::UI_FadeMenu</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::UI_AnimateCombo</Qt4> + <Qt3>Qt::UI_AnimateCombo</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::UI_AnimateTooltip</Qt4> + <Qt3>Qt::UI_AnimateTooltip</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::UI_FadeTooltip</Qt4> + <Qt3>Qt::UI_FadeTooltip</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::UI_AnimateToolBox</Qt4> + <Qt3>Qt::UI_AnimateToolBox</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::ArrowCursor</Qt4> + <Qt3>Qt::ArrowCursor</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::UpArrowCursor</Qt4> + <Qt3>Qt::UpArrowCursor</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::CrossCursor</Qt4> + <Qt3>Qt::CrossCursor</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WaitCursor</Qt4> + <Qt3>Qt::WaitCursor</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::SizeVerCursor</Qt4> + <Qt3>Qt::SizeVerCursor</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::SizeHorCursor</Qt4> + <Qt3>Qt::SizeHorCursor</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::SizeBDiagCursor</Qt4> + <Qt3>Qt::SizeBDiagCursor</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::SizeFDiagCursor</Qt4> + <Qt3>Qt::SizeFDiagCursor</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::SizeAllCursor</Qt4> + <Qt3>Qt::SizeAllCursor</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::BlankCursor</Qt4> + <Qt3>Qt::BlankCursor</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::SplitVCursor</Qt4> + <Qt3>Qt::SplitVCursor</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::SplitHCursor</Qt4> + <Qt3>Qt::SplitHCursor</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::PointingHandCursor</Qt4> + <Qt3>Qt::PointingHandCursor</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::ForbiddenCursor</Qt4> + <Qt3>Qt::ForbiddenCursor</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::WhatsThisCursor</Qt4> + <Qt3>Qt::WhatsThisCursor</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::BusyCursor</Qt4> + <Qt3>Qt::BusyCursor</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::LastCursor</Qt4> + <Qt3>Qt::LastCursor</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::BitmapCursor</Qt4> + <Qt3>Qt::BitmapCursor</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::PlainText</Qt4> + <Qt3>Qt::PlainText</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::RichText</Qt4> + <Qt3>Qt::RichText</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::AutoText</Qt4> + <Qt3>Qt::AutoText</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::LogText</Qt4> + <Qt3>Qt::LogText</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::AnchorName</Qt4> + <Qt3>Qt::AnchorName</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::AnchorHref</Qt4> + <Qt3>Qt::AnchorHref</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DockUnmanaged</Qt4> + <Qt3>Qt::DockUnmanaged</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DockTornOff</Qt4> + <Qt3>Qt::DockTornOff</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DockTop</Qt4> + <Qt3>Qt::DockTop</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DockBottom</Qt4> + <Qt3>Qt::DockBottom</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DockRight</Qt4> + <Qt3>Qt::DockRight</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DockLeft</Qt4> + <Qt3>Qt::DockLeft</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::DockMinimized</Qt4> + <Qt3>Qt::DockMinimized</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Unmanaged</Qt4> + <Qt3>Qt::Unmanaged</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::TornOff</Qt4> + <Qt3>Qt::TornOff</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Top</Qt4> + <Qt3>Qt::Top</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Bottom</Qt4> + <Qt3>Qt::Bottom</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Right</Qt4> + <Qt3>Qt::Right</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Left</Qt4> + <Qt3>Qt::Left</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::Minimized</Qt4> + <Qt3>Qt::Minimized</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::TextDate</Qt4> + <Qt3>Qt::TextDate</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::ISODate</Qt4> + <Qt3>Qt::ISODate</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::LocalDate</Qt4> + <Qt3>Qt::LocalDate</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::LocalTime</Qt4> + <Qt3>Qt::LocalTime</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::UTC</Qt4> + <Qt3>Qt::UTC</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::FixedColor</Qt4> + <Qt3>Qt::FixedColor</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::FixedPixmap</Qt4> + <Qt3>Qt::FixedPixmap</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::NoBackground</Qt4> + <Qt3>Qt::NoBackground</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::PaletteForeground</Qt4> + <Qt3>Qt::PaletteForeground</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::PaletteButton</Qt4> + <Qt3>Qt::PaletteButton</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::PaletteLight</Qt4> + <Qt3>Qt::PaletteLight</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::PaletteMidlight</Qt4> + <Qt3>Qt::PaletteMidlight</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::PaletteDark</Qt4> + <Qt3>Qt::PaletteDark</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::PaletteMid</Qt4> + <Qt3>Qt::PaletteMid</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::PaletteText</Qt4> + <Qt3>Qt::PaletteText</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::PaletteBrightText</Qt4> + <Qt3>Qt::PaletteBrightText</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::PaletteBase</Qt4> + <Qt3>Qt::PaletteBase</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::PaletteBackground</Qt4> + <Qt3>Qt::PaletteBackground</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::PaletteShadow</Qt4> + <Qt3>Qt::PaletteShadow</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::PaletteHighlight</Qt4> + <Qt3>Qt::PaletteHighlight</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::PaletteHighlightedText</Qt4> + <Qt3>Qt::PaletteHighlightedText</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::PaletteButtonText</Qt4> + <Qt3>Qt::PaletteButtonText</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::PaletteLink</Qt4> + <Qt3>Qt::PaletteLink</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::PaletteLinkVisited</Qt4> + <Qt3>Qt::PaletteLinkVisited</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::X11ParentRelative</Qt4> + <Qt3>Qt::X11ParentRelative</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::CaseSensitive</Qt4> + <Qt3>Qt::CaseSensitive</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::TopLeft</Qt4> + <Qt3>Qt::TopLeft</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::TopRight</Qt4> + <Qt3>Qt::TopRight</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::BottomLeft</Qt4> + <Qt3>Qt::BottomLeft</Qt3> + </item> + <item Type="RenamedEnumvalue" > + <Qt4>Qt::BottomRight</Qt4> + <Qt3>Qt::BottomRight</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>QApplication::ColorSpec</Qt4> + <Qt3>QApplication::ColorMode</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>QCheckBox::ToggleState</Qt4> + <Qt3>QButton::ToggleState</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::CursorShape</Qt4> + <Qt3>QCursorShape</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>QFile::Filters</Qt4> + <Qt3>QFile::FilterSpec</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>QFile::Permission</Qt4> + <Qt3>QFile::PermissionSpec</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>QFile::SortFlags</Qt4> + <Qt3>QFile::SortSpec</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>QFile::Error</Qt4> + <Qt3>QFile::Status</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>QFile::Permission</Qt4> + <Qt3>QFileInfo::PermissionSpec</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::Orientation</Qt4> + <Qt3>QGrid::Direction</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::Orientation</Qt4> + <Qt3>QGridWidget::Direction</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>qlonglong</Qt4> + <Qt3>QIODevice::Offset</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::AspectRatioMode</Qt4> + <Qt3>QImage::ScaleMode</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::AspectRatioMode</Qt4> + <Qt3>QSize::ScaleMode</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Q3Socket::Error</Qt4> + <Qt3>QSocket::Error</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Q3Socket::State</Qt4> + <Qt3>QSocket::State</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>QStyle::SubControls</Qt4> + <Qt3>QStyle::SCFlags</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>QStyle::State</Qt4> + <Qt3>QStyle::SFlags</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>QTextStream</Qt4> + <Qt3>QTS</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>QUriDrag</Qt4> + <Qt3>QUrlDrag</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::FocusPolicy</Qt4> + <Qt3>QWidget::FocusPolicy</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>qlonglong</Qt4> + <Qt3>Q_LLONG</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>qulonglong</Qt4> + <Qt3>Q_ULLONG</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::ToolBarDock</Qt4> + <Qt3>Qt::Dock</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>QSysInfo::MacVersion</Qt4> + <Qt3>Qt::MacintoshVersion</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::TextFlag</Qt4> + <Qt3>Qt::TextFlags</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>QSysInfo::WinVersion</Qt4> + <Qt3>Qt::WindowsVersion</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::Orientation</Qt4> + <Qt3>Qt::Orientation</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::SortOrder</Qt4> + <Qt3>Qt::SortOrder</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::WindowState</Qt4> + <Qt3>Qt::WindowState</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::BGMode</Qt4> + <Qt3>Qt::BGMode</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::PaintUnit</Qt4> + <Qt3>Qt::PaintUnit</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::GUIStyle</Qt4> + <Qt3>Qt::GUIStyle</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::Modifier</Qt4> + <Qt3>Qt::Modifier</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::Key</Qt4> + <Qt3>Qt::Key</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::ArrowType</Qt4> + <Qt3>Qt::ArrowType</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::PenStyle</Qt4> + <Qt3>Qt::PenStyle</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::PenCapStyle</Qt4> + <Qt3>Qt::PenCapStyle</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::PenJoinStyle</Qt4> + <Qt3>Qt::PenJoinStyle</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::BrushStyle</Qt4> + <Qt3>Qt::BrushStyle</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::UIEffect</Qt4> + <Qt3>Qt::UIEffect</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::CursorShape</Qt4> + <Qt3>Qt::CursorShape</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::TextFormat</Qt4> + <Qt3>Qt::TextFormat</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::AnchorAttribute</Qt4> + <Qt3>Qt::AnchorAttribute</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::Dock</Qt4> + <Qt3>Qt::Dock</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::DateFormat</Qt4> + <Qt3>Qt::DateFormat</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::TimeSpec</Qt4> + <Qt3>Qt::TimeSpec</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::BackgroundMode</Qt4> + <Qt3>Qt::BackgroundMode</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::Corner</Qt4> + <Qt3>Qt::Corner</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::WFlags</Qt4> + <Qt3>Qt::WFlags</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::ToolBarDock</Qt4> + <Qt3>Qt::ToolBarDock</Qt3> + </item> + <item Type="RenamedType" > + <Qt4>Qt::HANDLE</Qt4> + <Qt3>Qt::HANDLE</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::color0</Qt4> + <Qt3>Qt::color0</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::color1</Qt4> + <Qt3>Qt::color1</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::black</Qt4> + <Qt3>Qt::black</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::white</Qt4> + <Qt3>Qt::white</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::darkGray</Qt4> + <Qt3>Qt::darkGray</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::gray</Qt4> + <Qt3>Qt::gray</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::lightGray</Qt4> + <Qt3>Qt::lightGray</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::red</Qt4> + <Qt3>Qt::red</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::green</Qt4> + <Qt3>Qt::green</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::blue</Qt4> + <Qt3>Qt::blue</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::cyan</Qt4> + <Qt3>Qt::cyan</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::magenta</Qt4> + <Qt3>Qt::magenta</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::yellow</Qt4> + <Qt3>Qt::yellow</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::darkRed</Qt4> + <Qt3>Qt::darkRed</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::darkGreen</Qt4> + <Qt3>Qt::darkGreen</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::darkBlue</Qt4> + <Qt3>Qt::darkBlue</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::darkCyan</Qt4> + <Qt3>Qt::darkCyan</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::darkMagenta</Qt4> + <Qt3>Qt::darkMagenta</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::darkYellow</Qt4> + <Qt3>Qt::darkYellow</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::ButtonState</Qt4> + <Qt3>Qt::ButtonState</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::TextFlags</Qt4> + <Qt3>Qt::TextFlags</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::ImageConversionFlags</Qt4> + <Qt3>Qt::ImageConversionFlags</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::arrowCursor</Qt4> + <Qt3>Qt::arrowCursor</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::upArrowCursor</Qt4> + <Qt3>Qt::upArrowCursor</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::crossCursor</Qt4> + <Qt3>Qt::crossCursor</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::waitCursor</Qt4> + <Qt3>Qt::waitCursor</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::ibeamCursor</Qt4> + <Qt3>Qt::ibeamCursor</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::sizeVerCursor</Qt4> + <Qt3>Qt::sizeVerCursor</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::sizeHorCursor</Qt4> + <Qt3>Qt::sizeHorCursor</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::sizeBDiagCursor</Qt4> + <Qt3>Qt::sizeBDiagCursor</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::sizeFDiagCursor</Qt4> + <Qt3>Qt::sizeFDiagCursor</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::sizeAllCursor</Qt4> + <Qt3>Qt::sizeAllCursor</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::blankCursor</Qt4> + <Qt3>Qt::blankCursor</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::splitVCursor</Qt4> + <Qt3>Qt::splitVCursor</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::splitHCursor</Qt4> + <Qt3>Qt::splitHCursor</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::pointingHandCursor</Qt4> + <Qt3>Qt::pointingHandCursor</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::forbiddenCursor</Qt4> + <Qt3>Qt::forbiddenCursor</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>Qt::whatsThisCursor</Qt4> + <Qt3>Qt::whatsThisCursor</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>qPixmapFromMimeSource</Qt4> + <Qt3>QPixmap::fromMimeSource</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>QImageReader::supportedImageFormats</Qt4> + <Qt3>QImage::inputFormats</Qt3> + </item> + <item Type="RenamedQtSymbol" > + <Qt4>QImageWriter::supportedImageFormats</Qt4> + <Qt3>QImage::outputFormats</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>QPointer</Qt4> + <Qt3>QGuardedPtr</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3DeepCopy</Qt4> + <Qt3>QDeepCopy</Qt3> + </item> + <item Type="RenamedClass" > + <Qt4>Q3PtrCollection</Qt4> + <Qt3>QCollection</Qt3> + </item> + <item Type="NeedHeader" > + <Class>Q3SqlFieldInfo</Class> + <Header>Q3SqlFieldInfo</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3TextStream</Class> + <Header>Q3TextStream</Header> + </item> + <item Type="NeedHeader" > + <Class>QCloseEvent</Class> + <Header>QCloseEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QHelpEvent</Class> + <Header>QHelpEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QDragMoveEvent</Class> + <Header>QDragMoveEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QDropEvent</Class> + <Header>QDropEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QKeyEvent</Class> + <Header>QKeyEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QClipboardEvent</Class> + <Header>QClipboardEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QHideEvent</Class> + <Header>QHideEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QDragLeaveEvent</Class> + <Header>QDragLeaveEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QWhatsThisClickedEvent</Class> + <Header>QWhatsThisClickedEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QMoveEvent</Class> + <Header>QMoveEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QFileOpenEvent</Class> + <Header>QFileOpenEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QResizeEvent</Class> + <Header>QResizeEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QContextMenuEvent</Class> + <Header>QContextMenuEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QActionEvent</Class> + <Header>QActionEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QWSUpdateEvent</Class> + <Header>QWSUpdateEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QInputMethodEvent</Class> + <Header>QInputMethodEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QShortcutEvent</Class> + <Header>QShortcutEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QDragEnterEvent</Class> + <Header>QDragEnterEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QDragResponseEvent</Class> + <Header>QDragResponseEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QToolBarChangeEvent</Class> + <Header>QToolBarChangeEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QShowEvent</Class> + <Header>QShowEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QWSEvent</Class> + <Header>QWSEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QFocusEvent</Class> + <Header>QFocusEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QInputEvent</Class> + <Header>QInputEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QStatusTipEvent</Class> + <Header>QStatusTipEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QWheelEvent</Class> + <Header>QWheelEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QMouseEvent</Class> + <Header>QMouseEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QTabletEvent</Class> + <Header>QTabletEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QPaintEvent</Class> + <Header>QPaintEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QIconDragEvent</Class> + <Header>QIconDragEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QChildEvent</Class> + <Header>QChildEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QEvent</Class> + <Header>QEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QWinEventNotifier</Class> + <Header>QWinEventNotifier</Header> + </item> + <item Type="NeedHeader" > + <Class>QTimerEvent</Class> + <Header>QTimerEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>QEventLoop</Class> + <Header>QEventLoop</Header> + </item> + <item Type="NeedHeader" > + <Class>QCustomEvent</Class> + <Header>QCustomEvent</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3PtrList</Class> + <Header>Q3PtrList</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3ValueList</Class> + <Header>Q3ValueList</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3MemArray</Class> + <Header>Q3MemArray</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3StrList</Class> + <Header>Q3StrList</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3Painter</Class> + <Header>Q3Painter</Header> + </item> + <item Type="NeedHeader" > + <Class>QTextStream</Class> + <Header>QTextStream</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3Frame</Class> + <Header>Q3Frame</Header> + </item> + <item Type="NeedHeader" > + <Class>QBoxLayout</Class> + <Header>QBoxLayout</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3VBoxLayout</Class> + <Header>Q3VBoxLayout</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3HBoxLayout</Class> + <Header>Q3HBoxLayout</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3GridLayout</Class> + <Header>Q3GridLayout</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3CString</Class> + <Header>Q3CString</Header> + </item> + <item Type="NeedHeader" > + <Class>QPixmap</Class> + <Header>QPixmap</Header> + </item> + <item Type="NeedHeader" > + <Class>QTranslator</Class> + <Header>QTranslator</Header> + </item> + <item Type="NeedHeader" > + <Class>QLabel</Class> + <Header>QLabel</Header> + </item> + <item Type="NeedHeader" > + <Class>QListBoxItem</Class> + <Header>QListBoxItem</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3Action</Class> + <Header>Q3Action</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3ActionGroup</Class> + <Header>Q3ActionGroup</Header> + </item> + <item Type="NeedHeader" > + <Class>qPixmapFromMimeSource</Class> + <Header>q3mimefactory.h</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3SqlFieldInfo</Class> + <Header>Q3SqlFieldInfo</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3SqlFieldInfoList</Class> + <Header>Q3SqlFieldInfoList</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3SqlCursor</Class> + <Header>Q3SqlCursor</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3SqlEditorFactory</Class> + <Header>Q3SqlEditorFactory</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3SqlForm</Class> + <Header>Q3SqlForm</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3SqlPropertyMap</Class> + <Header>Q3SqlPropertyMap</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3SqlRecordInfo</Class> + <Header>Q3SqlRecordInfo</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3SqlSelectCursor</Class> + <Header>Q3SqlSelectCursor</Header> + </item> + <item Type="NeedHeader" > + <Class>QSqlError</Class> + <Header>QSqlError</Header> + </item> + <item Type="NeedHeader" > + <Class>QSqlQuery</Class> + <Header>QSqlQuery</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3PointArray</Class> + <Header>Q3PointArray</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3PopupMenu</Class> + <Header>Q3PopupMenu</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3Button</Class> + <Header>Q3Button</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3BoxLayout</Class> + <Header>Q3BoxLayout</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3Signal</Class> + <Header>Q3Signal</Header> + </item> + <item Type="NeedHeader" > + <Class>QTextIStream</Class> + <Header>QTextIStream</Header> + </item> + <item Type="NeedHeader" > + <Class>QTextOStream</Class> + <Header>QTextOStream</Header> + </item> + <item Type="NeedHeader" > + <Class>Q3PtrCollection</Class> + <Header>Q3PtrCollection</Header> + </item> + <item Type="RenamedHeader" > + <Qt4>qnamespace.h</Qt4> + <Qt3>qkeycode.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>qobject.h</Qt4> + <Qt3>qobjectlist.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>qwidget.h</Qt4> + <Qt3>qwidgetlist.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>qapplication.h</Qt4> + <Qt3>qapp.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>qmessagebox.h</Qt4> + <Qt3>qmsgbox.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>qicon.h</Qt4> + <Qt3>qiconset.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>qmatrix.h</Qt4> + <Qt3>qwmatrix.h</Qt3> + </item> + <item Type="RenamedHeader" > + <Qt4>qpointer.h</Qt4> + <Qt3>qguardedptr.h</Qt3> + </item> + <item Type="RenamedToken" > + <Qt4>q3InitNetworkProtocols</Qt4> + <Qt3>qInitNetworkProtocols</Qt3> + </item> + <item Type="RenamedToken" > + <Qt4>qSort</Qt4> + <Qt3>qHeapSort</Qt3> + </item> +</Rules> diff --git a/tools/porting/src/qt3headers0.qrc b/tools/porting/src/qt3headers0.qrc new file mode 100644 index 0000000..3fa52d8 --- /dev/null +++ b/tools/porting/src/qt3headers0.qrc @@ -0,0 +1,6 @@ +<!DOCTYPE RCC> +<RCC version="1.0"> + <qresource> + <file compress="9">qt3headers0.resource</file> + </qresource> +</RCC>
\ No newline at end of file diff --git a/tools/porting/src/qt3headers0.resource b/tools/porting/src/qt3headers0.resource Binary files differnew file mode 100644 index 0000000..8e24385 --- /dev/null +++ b/tools/porting/src/qt3headers0.resource diff --git a/tools/porting/src/qt3headers1.qrc b/tools/porting/src/qt3headers1.qrc new file mode 100644 index 0000000..3178598 --- /dev/null +++ b/tools/porting/src/qt3headers1.qrc @@ -0,0 +1,6 @@ +<!DOCTYPE RCC> +<RCC version="1.0"> + <qresource> + <file compress="9">qt3headers1.resource</file> + </qresource> +</RCC>
\ No newline at end of file diff --git a/tools/porting/src/qt3headers1.resource b/tools/porting/src/qt3headers1.resource Binary files differnew file mode 100644 index 0000000..8da4b9a --- /dev/null +++ b/tools/porting/src/qt3headers1.resource diff --git a/tools/porting/src/qt3headers2.qrc b/tools/porting/src/qt3headers2.qrc new file mode 100644 index 0000000..dad47b6 --- /dev/null +++ b/tools/porting/src/qt3headers2.qrc @@ -0,0 +1,6 @@ +<!DOCTYPE RCC> +<RCC version="1.0"> + <qresource> + <file compress="9">qt3headers2.resource</file> + </qresource> +</RCC>
\ No newline at end of file diff --git a/tools/porting/src/qt3headers2.resource b/tools/porting/src/qt3headers2.resource Binary files differnew file mode 100644 index 0000000..62bdb8e --- /dev/null +++ b/tools/porting/src/qt3headers2.resource diff --git a/tools/porting/src/qt3headers3.qrc b/tools/porting/src/qt3headers3.qrc new file mode 100644 index 0000000..77a6661 --- /dev/null +++ b/tools/porting/src/qt3headers3.qrc @@ -0,0 +1,6 @@ +<!DOCTYPE RCC> +<RCC version="1.0"> + <qresource> + <file compress="9">qt3headers3.resource</file> + </qresource> +</RCC>
\ No newline at end of file diff --git a/tools/porting/src/qt3headers3.resource b/tools/porting/src/qt3headers3.resource Binary files differnew file mode 100644 index 0000000..6a096e8 --- /dev/null +++ b/tools/porting/src/qt3headers3.resource diff --git a/tools/porting/src/qt3to4.pri b/tools/porting/src/qt3to4.pri new file mode 100644 index 0000000..c10c2f8 --- /dev/null +++ b/tools/porting/src/qt3to4.pri @@ -0,0 +1,68 @@ +DEPENDPATH += $$PWD +INCLUDEPATH += $$PWD + +QT += XML +HEADERS += $$PWD/smallobject.h \ + $$PWD/tokenengine.h \ + $$PWD/tokenizer.h \ + $$PWD/rpplexer.h \ + $$PWD/rpp.h \ + $$PWD/rpptreewalker.h \ + $$PWD/rpptreeevaluator.h \ + $$PWD/rppexpressionbuilder.h \ + $$PWD/preprocessorcontrol.h \ + $$PWD/replacetoken.h \ + $$PWD/tokenreplacements.h \ + $$PWD/textreplacement.h \ + $$PWD/portingrules.h \ + $$PWD/qtsimplexml.h \ + $$PWD/projectporter.h \ + $$PWD/proparser.h \ + $$PWD/fileporter.h \ + $$PWD/logger.h \ + $$PWD/tokens.h \ + $$PWD/filewriter.h \ + $$PWD/cpplexer.h \ + $$PWD/smallobject.h \ + $$PWD/ast.h \ + $$PWD/errors.h \ + $$PWD/parser.h \ + $$PWD/translationunit.h \ + $$PWD/treewalker.h \ + $$PWD/semantic.h \ + $$PWD/codemodel.h \ + $$PWD/codemodelwalker.h \ + $$PWD/codemodelattributes.h + +SOURCES += \ + $$PWD/smallobject.cpp \ + $$PWD/tokenengine.cpp \ + $$PWD/tokenizer.cpp \ + $$PWD/rpplexer.cpp \ + $$PWD/rpp.cpp \ + $$PWD/rpptreewalker.cpp \ + $$PWD/rpptreeevaluator.cpp \ + $$PWD/rppexpressionbuilder.cpp \ + $$PWD/preprocessorcontrol.cpp \ + $$PWD/replacetoken.cpp \ + $$PWD/tokenreplacements.cpp \ + $$PWD/textreplacement.cpp \ + $$PWD/portingrules.cpp \ + $$PWD/qtsimplexml.cpp \ + $$PWD/projectporter.cpp \ + $$PWD/proparser.cpp \ + $$PWD/fileporter.cpp \ + $$PWD/logger.cpp \ + $$PWD/filewriter.cpp \ + $$PWD/cpplexer.cpp \ + $$PWD/ast.cpp \ + $$PWD/errors.cpp \ + $$PWD/parser.cpp \ + $$PWD/translationunit.cpp \ + $$PWD/treewalker.cpp \ + $$PWD/semantic.cpp \ + $$PWD/codemodel.cpp \ + $$PWD/codemodelwalker.cpp \ + $$PWD/codemodelattributes.cpp + + diff --git a/tools/porting/src/qtsimplexml.cpp b/tools/porting/src/qtsimplexml.cpp new file mode 100644 index 0000000..cf7b580 --- /dev/null +++ b/tools/porting/src/qtsimplexml.cpp @@ -0,0 +1,278 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qtsimplexml.h" +#include <QDomDocument> + +QT_BEGIN_NAMESPACE + +QtSimpleXml::QtSimpleXml(const QString &name) +{ + valid = false; + n = name; + parent = 0; +} + +QtSimpleXml &QtSimpleXml::operator [](int index) +{ + if (index < 0) + return *this; + + if (index > children.size()) { + static QtSimpleXml NIL; + qWarning("QtSimpleXml::operator[], Out of range access: size is %i, index is %i", + children.size(), index); + return NIL; + } + + if (index == children.size()) { + QtSimpleXml *item = new QtSimpleXml(QLatin1String("item")); + item->parent = this; + children.insert(item->name(), item); + return *item; + } + + QMultiMap<QString, QtSimpleXml *>::Iterator it = children.begin(); + while (index--) ++it; + return *it.value(); +} + +QtSimpleXml &QtSimpleXml::operator [](const QString &key) +{ + if (!children.contains(key)) { + QtSimpleXml *item = new QtSimpleXml(key); + item->parent = this; + children.insert(item->name(), item); + return *item; + } + + return *children.find(key).value(); +} + +QtSimpleXml &QtSimpleXml::operator =(const QString &text) +{ + valid = true; + QtSimpleXml *p = parent; + while (p && !p->valid) { + p->valid = true; + p = p->parent; + } + + s = text; + return *this; +} + +QDomDocument QtSimpleXml::toDomDocument() const +{ + QDomDocument doc; + QString data = QLatin1String("version=\"1.0\" encoding=\"UTF-8\""); + doc.appendChild(doc.createProcessingInstruction(QLatin1String("xml"), data)); + + if (!valid) + return doc; + + if(!s.isEmpty()) + doc.appendChild(doc.createTextNode(s)); + + { + QMultiMap<QString, QtSimpleXml *>::ConstIterator it = children.constBegin(); + for (; it != children.end(); ++it) { + QtSimpleXml *item = it.value(); + if (item->valid) { + QDomNode node = item->toDomElement(&doc); + doc.appendChild(node); + } + } + } + + return doc; +} + +QDomElement QtSimpleXml::toDomElement(QDomDocument *doc) const +{ + QDomElement elem = doc->createElement(n); + QMap<QString, QString>::ConstIterator ita = attr.constBegin(); + for (; ita != attr.constEnd(); ++ita) + elem.setAttribute(ita.key(), ita.value()); + + if(!s.isEmpty()) + elem.appendChild(doc->createTextNode(s)); + + { + QMultiMap<QString, QtSimpleXml *>::ConstIterator it = children.constBegin(); + for (; it != children.constEnd(); ++it) { + QtSimpleXml *item = it.value(); + if (item->valid) { + QDomNode node = item->toDomElement(doc); + elem.appendChild(node); + } + } + } + + return elem; +} + +QString QtSimpleXml::name() const +{ + return n; +} + +QString QtSimpleXml::text() const +{ + return s; +} + +int QtSimpleXml::numChildren() const +{ + return children.count(); +} + +bool QtSimpleXml::isValid() const +{ + return valid; +} + +void QtSimpleXml::setAttribute(const QString &key, const QString &value) +{ + attr.insert(key, QString(value)); +} + +QString QtSimpleXml::attribute(const QString &key) +{ + return attr[key]; +} + +bool QtSimpleXml::setContent(const QString &content) +{ + QDomDocument doc; + QString errorMsg; + int errorLine; + int errorColumn; + + if (!doc.setContent(content, false, &errorMsg, &errorLine, &errorColumn)) { + errorStr = errorMsg; + errorStr += QLatin1String(" at ") + QString::number(errorLine) + QLatin1String(":") + QString::number(errorColumn); + return false; + } + + parse(doc); + return true; +} + +bool QtSimpleXml::setContent(QIODevice *device) +{ + QDomDocument doc; + QString errorMsg; + int errorLine; + int errorColumn; + if (!doc.setContent(device, false, &errorMsg, &errorLine, &errorColumn)) { + errorStr = errorMsg; + errorStr += QLatin1String(" at ") + QString::number(errorLine) + QLatin1String(":") + QString::number(errorColumn); + return false; + } + + QDomNode child = doc.firstChild(); + while (!child.isNull() && !child.isElement()) + child = child.nextSibling(); + + while (!child.isNull()) { + QtSimpleXml *xmlNode = new QtSimpleXml; + xmlNode->parse(child); + xmlNode->parent=this; + children.insert(xmlNode->name(), xmlNode); + do { + child = child.nextSibling(); + } while (!child.isNull() && !child.isElement()); + } + + return true; +} + + +void QtSimpleXml::parse(QDomNode node) +{ + // puts("parse"); + if (node.isNull()) + return; + + valid = true; + n = node.nodeName(); + QDomElement element = node.toElement(); + + QDomNamedNodeMap attrs = element.attributes(); + for (int i = 0; i < (int) attrs.count(); ++i) { + QDomAttr attribute = attrs.item(i).toAttr(); + attr.insert(attribute.name(), attribute.value()); + } + + if (element.firstChild().isText()) { + // printf("Got text %s\n", element.text().stripWhiteSpace().latin1()); + s = element.text().trimmed(); + return; + } + + if (node.hasChildNodes()) { + + // Skip to first element child + QDomNode child = node.firstChild(); + while (!child.isNull() && !child.isElement()) + child = child.nextSibling(); + + while (!child.isNull()) { + QtSimpleXml *xmlNode = new QtSimpleXml; + xmlNode->parse(child); + children.insert(xmlNode->name(), xmlNode); + + node = node.nextSibling(); + + do { + child = child.nextSibling(); + } while (!child.isNull() && !child.isElement()); + } + } +} + +QString QtSimpleXml::errorString() const +{ + return errorStr; +} + +QT_END_NAMESPACE diff --git a/tools/porting/src/qtsimplexml.h b/tools/porting/src/qtsimplexml.h new file mode 100644 index 0000000..66d4c16 --- /dev/null +++ b/tools/porting/src/qtsimplexml.h @@ -0,0 +1,97 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QTSIMPLEXML_H +#define QTSIMPLEXML_H + +#include <QString> +#include <QMultiMap> +#include <QMap> + +QT_BEGIN_NAMESPACE + +class QDomDocument; +class QDomElement; +class QDomNode; +class QIODevice; + +class QtSimpleXml +{ +public: + QtSimpleXml(const QString &name = QString()); + + QString name() const; + QString text() const; + int numChildren() const; + bool isValid() const; + + const QtSimpleXml &operator [](int index) const; + QtSimpleXml &operator [](int index); + QtSimpleXml &operator [](const QString &key); + QtSimpleXml &operator =(const QString &text); + + void setAttribute(const QString &key, const QString &value); + QString attribute(const QString &key); + + bool setContent(const QString &content); + bool setContent(QIODevice *device); + QString errorString() const; + + QDomDocument toDomDocument() const; + QDomElement toDomElement(QDomDocument *doc) const; +private: + void parse(QDomNode node); + + QtSimpleXml *parent; + + QMultiMap<QString, QtSimpleXml *> children; + QMap<QString, QString> attr; + + QString s; + QString n; + bool valid; + + QString errorStr; +}; + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/replacetoken.cpp b/tools/porting/src/replacetoken.cpp new file mode 100644 index 0000000..67a847f --- /dev/null +++ b/tools/porting/src/replacetoken.cpp @@ -0,0 +1,105 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "replacetoken.h" +#include "tokenreplacements.h" +#include <QByteArray> + +QT_BEGIN_NAMESPACE + +/* + Add an entry to the tokenRuleLookup map for each token replacement rule. +*/ +ReplaceToken::ReplaceToken(const QList<TokenReplacement*> &tokenReplacementRules) +:tokenReplacementRules(tokenReplacementRules) +{ + foreach (TokenReplacement* rep, tokenReplacementRules) { + QByteArray key = rep->getReplaceKey(); + if(!key.isEmpty()) { + tokenRuleLookup.insert(key, rep); + } + } +} + +TextReplacements ReplaceToken::getTokenTextReplacements(const TokenEngine::TokenContainer &container) +{ + TextReplacements textReplacements; + + int t=0; + const int numTokens = container.count(); + while(t < numTokens) { + QByteArray tokenText = container.text(t); + bool changed = false; + + if(isPreprocessorDirective(tokenText)) { + foreach(TokenReplacement *tokenReplacementRule, tokenReplacementRules) { + if(!changed) + changed = tokenReplacementRule->doReplace(container, t, textReplacements); + if(changed) + break; + } + } else if (isInterestingToken(tokenText.trimmed())) { + foreach (TokenReplacement* value, tokenRuleLookup.values(tokenText)) { + changed = value->doReplace(container, t, textReplacements); + if(changed) { + goto end; + } + } + } + end: + ++t; + } + return textReplacements; +} + +bool ReplaceToken::isInterestingToken(const QByteArray &text) +{ + return !(text.isEmpty() || text==";" || text=="(" || text==")" || text=="{" || text=="}" || text=="=" + || text=="+=" || text=="-=" || text=="if" || text=="then" || text=="else" + ); +} + +bool ReplaceToken::isPreprocessorDirective(const QByteArray &token) +{ + return (token[0]=='#'); +} + +QT_END_NAMESPACE diff --git a/tools/porting/src/replacetoken.h b/tools/porting/src/replacetoken.h new file mode 100644 index 0000000..196d458 --- /dev/null +++ b/tools/porting/src/replacetoken.h @@ -0,0 +1,67 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef REPLACETOKEN_H +#define REPLACETOKEN_H + +#include "tokenengine.h" +#include "tokenreplacements.h" +#include "textreplacement.h" +#include <QList> +#include <QMultiMap> + +QT_BEGIN_NAMESPACE + +class ReplaceToken +{ +public: + ReplaceToken(const QList<TokenReplacement*> &tokenReplacementRules); + TextReplacements getTokenTextReplacements(const TokenEngine::TokenContainer &tokenContainer); +private: + bool isInterestingToken(const QByteArray &token); + bool isPreprocessorDirective(const QByteArray &token); + QMultiMap<QByteArray, TokenReplacement*> tokenRuleLookup; + const QList<TokenReplacement*> tokenReplacementRules; +}; + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/rpp.cpp b/tools/porting/src/rpp.cpp new file mode 100644 index 0000000..bec05fe --- /dev/null +++ b/tools/porting/src/rpp.cpp @@ -0,0 +1,728 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "rpp.h" +#include "rppexpressionbuilder.h" + +QT_BEGIN_NAMESPACE + +using namespace TokenEngine; + +namespace Rpp +{ + +Preprocessor::Preprocessor() + : lexerTokenIndex(0), numTokens(0) +{ + +} + +Source *Preprocessor::parse(const TokenEngine::TokenContainer &tokenContainer, + const QVector<Type> &tokenTypeList, TypedPool<Item> *memoryPool) +{ + m_memoryPool = memoryPool; + Source *m_source = createNode<Source>(m_memoryPool); //node with no parent + m_tokenContainer = tokenContainer; + m_tokenTypeList = tokenTypeList; + lexerTokenIndex = 0; + numTokens = m_tokenContainer.count(); + + if(m_tokenContainer.count() != tokenTypeList.count()) { + emit error(QLatin1String("Error"), QLatin1String("Internal error in preprocessor: Number of tokens is not equal to number of types in type list")); + return m_source; + } + + if(tokenTypeList.isEmpty()) { + // emit error("Warning:", "Trying to parse empty source file"); + return m_source; + } + Q_ASSERT(m_source->toItemComposite()); + parseGroup(m_source); + + return m_source; +} + +// group-part +// group group-part +bool Preprocessor::parseGroup(Item *group) +{ + Q_ASSERT(group->toItemComposite()); + bool gotGroup = false; + while(lexerTokenIndex < numTokens) { + if (!parseGroupPart(group)) + break; + gotGroup = true; + } + return gotGroup; +} + +//if-section (# if / # ifdef / #ifndef ) +//control-line ( #include / etc ) +//# non-directive ( # text newline +//text-line (text newline ) +bool Preprocessor::parseGroupPart(Item *group) +{ + //cout << "parse group part" << endl; + Q_ASSERT(group->toItemComposite()); + + //look up first significant token + Type token = lookAhead(); + if(token == Token_eof) + return false; + + //look for '#' + if(token != Token_preproc) + return parseTextLine(group); + + //look up first significant token after the '#' + token = lookAheadSkipHash(); + if(token == Token_eof) + return false; + + // Check if we are at the end of a group. This is not an neccesarely an + // error, it happens when we reach an #endif for example. + if (token == Token_directive_elif || token == Token_directive_else || + token == Token_directive_endif) + return false; + + // if-section? + if(token == Token_directive_if || token == Token_directive_ifdef || + token == Token_directive_ifndef) + return parseIfSection(group); + + // control-line? + if (token == Token_directive_define) + return parseDefineDirective(group); + if (token == Token_directive_undef) + return parseUndefDirective(group); + if (token == Token_directive_include) + return parseIncludeDirective(group); + if (token == Token_directive_error) + return parseErrorDirective(group); + if (token == Token_directive_pragma) + return parsePragmaDirective(group); + + return parseNonDirective(group); +} + +// if-section -> if-group elif-groups[opt] else-group[opt] endif-line +bool Preprocessor::parseIfSection(Item *group) +{ + // cout << "parse if section" << endl ; + Q_ASSERT(group->toItemComposite()); + IfSection *ifSection = createNode<IfSection>(m_memoryPool, group); + group->toItemComposite()->add(ifSection); + + if (!parseIfGroup(ifSection)) + return false; + + Type type = lookAheadSkipHash(); + if(type == Token_directive_elif) + if(!parseElifGroups(ifSection)) + return false; + + type = lookAheadSkipHash(); + if(type == Token_directive_else) + if(!parseElseGroup(ifSection)) + return false; + + return parseEndifLine(ifSection); +} + +bool Preprocessor::parseNonDirective(Item *group) +{ + // cout << "parsenondirective" << endl; + Q_ASSERT(group->toItemComposite()); + TokenSection tokenSection = readLine(); + if(tokenSection.count() == 0) + return false; + + NonDirective *nonDirective = createNode<NonDirective>(m_memoryPool, group); + group->toItemComposite()->add(nonDirective); + nonDirective->setTokenSection(tokenSection); + return true; +} + + +bool Preprocessor::parseTextLine(Item *group) +{ + //cout << "parsetextline" << endl; + Q_ASSERT(group->toItemComposite()); + const TokenSection tokenSection = readLine(); + // cout << tokenSection.fullText().constData() << endl; + + if(tokenSection.count() == 0) + return false; + + Text *text = createNode<Text>(m_memoryPool, group); + group->toItemComposite()->add(text); + text->setTokenSection(tokenSection); + + // Create Token-derived nodes and atach to text + QVector<Token *> tokens; + tokens.reserve(tokenSection.count()); + for (int t = 0; t < tokenSection.count(); ++t) { + Token *node = 0; + const int containerIndex = tokenSection.containerIndex(t); + switch(m_tokenTypeList.at(containerIndex)) { + case Token_identifier: + case Token_defined: + case Token_directive_if: + case Token_directive_elif: + case Token_directive_else: + case Token_directive_undef: + case Token_directive_endif: + case Token_directive_ifdef: + case Token_directive_ifndef: + case Token_directive_define: + case Token_directive_include: + node = createNode<IdToken>(m_memoryPool, text); + break; + case Token_line_comment: + node = createNode<LineComment>(m_memoryPool, text); + break; + case Token_multiline_comment: + node = createNode<MultiLineComment>(m_memoryPool, text); + break; + case Token_whitespaces: + case Token_char_literal: + case Token_string_literal: + default: + node = createNode<NonIdToken>(m_memoryPool, text); + break; + } + Q_ASSERT(node); + node->setToken(containerIndex); + tokens.append(node); + } + + text->setTokens(tokens); + + return true; +} + +// if-group -> ifDirective +// if-group -> ifdefDirevtive +// if-group -> ifndefDirevtive +bool Preprocessor::parseIfGroup(IfSection *ifSection) +{ + // cout << "parse if group" << endl; + Q_ASSERT(ifSection->toItemComposite()); + bool result; + const Type type = lookAheadSkipHash(); + if (type == Token_directive_ifdef) { + IfdefDirective *d = createNode<IfdefDirective>(m_memoryPool, ifSection); + result = parseIfdefLikeDirective(d); + ifSection->setIfGroup(d); + } else if (type == Token_directive_ifndef) { + IfndefDirective *d = createNode<IfndefDirective>(m_memoryPool, ifSection); + result = parseIfdefLikeDirective(d); + ifSection->setIfGroup(d); + } else if (type == Token_directive_if) { + IfDirective *d = createNode<IfDirective>(m_memoryPool, ifSection); + result = parseIfLikeDirective(d); + ifSection->setIfGroup(d); + } else { + result = false; + } + return result; +} + +bool Preprocessor::parseElifGroups(IfSection *ifSection) +{ + //cout << "parse ElifGroups" << endl; + bool gotElif = false; + while(lookAheadSkipHash() == Token_directive_elif ) { + if (!parseElifGroup(ifSection)) + break; + gotElif = true; + } + return gotElif; +} + +bool Preprocessor::parseElifGroup(IfSection *ifSection) +{ + //cout << "parse ElifGroup" << endl; + ElifDirective *elifDirective = createNode<ElifDirective>(m_memoryPool, ifSection); + ifSection->addElifGroup(elifDirective); + return parseIfLikeDirective(elifDirective); +} + +bool Preprocessor::parseElseGroup(IfSection *ifSection) +{ + //cout << "parse else group" << endl; + TokenSection tokenSection = readLine(); + if(tokenSection.count() == 0) + return false; + + ElseDirective *elseDirective = createNode<ElseDirective>(m_memoryPool, ifSection); + ifSection->setElseGroup(elseDirective); + elseDirective->setTokenSection(tokenSection); + parseGroup(elseDirective); + return true; +} + +//# endif newline +bool Preprocessor::parseEndifLine(IfSection *ifSection) +{ + //cout << "parse endifline" << endl; + TokenSection tokenSection = readLine(); + if(tokenSection.count() == 0) + return false; + + EndifDirective *endifDirective = createNode<EndifDirective>(m_memoryPool, ifSection); + ifSection->setEndifLine(endifDirective); + endifDirective->setTokenSection(tokenSection); + + return true; +} + +//parses an "ifdef-like" directive, like #ifdef and #ifndef :) +//# ifdef identifier newline group[opt] +bool Preprocessor::parseIfdefLikeDirective(IfdefLikeDirective *node) +{ + Q_ASSERT(node->toItemComposite()); + const TokenSection tokenSection = readLine(); + const QVector<int> cleanedLine = cleanTokenRange(tokenSection); + + if(cleanedLine.count() < 3) + return false; + + node->setTokenSection(tokenSection); + node->setIdentifier(TokenList(m_tokenContainer, QVector<int>() << cleanedLine.at(2))); + parseGroup(node); + + return true; +} + +//# if constant-expression newline group[opt] +bool Preprocessor::parseIfLikeDirective(IfLikeDirective *node) +{ + //cout << "parse if-like directive" << endl; + Q_ASSERT(node->toItemComposite()); + TokenSection tokenSection = readLine(); + QVector<int> cleanedSection = cleanTokenRange(tokenSection); + if(cleanedSection.count() < 3) + return false; + + cleanedSection.erase(cleanedSection.begin(), cleanedSection.begin() + 2); //remove # and if + cleanedSection.pop_back(); //remove endl; + + const TokenList sectionList(m_tokenContainer, cleanedSection); + ExpressionBuilder expressionBuilder(sectionList, m_tokenTypeList, m_memoryPool); + Expression *expr = expressionBuilder.parse(); + node->setTokenSection(tokenSection); + node->setExpression(expr); + + parseGroup(node); + return true; +} + +/* + # define identifier replacement-list new-line + # define identifier lparen identifier-list[opt] ) replacement-list new-line + # define identifier lparen ... ) replacement-list new-line + # define identifier lparen identifier-list, ... ) replacement-list new-line +*/ +bool Preprocessor::parseDefineDirective(Item *group) +{ + Q_ASSERT(group->toItemComposite()); + const TokenSection line = readLine(); + const QVector<int> cleanedLine = cleanTokenRange(line); + if(cleanedLine.count() < 3) + return false; + + // get identifier + const int identifier = cleanedLine.at(2); //skip "#" and "define" + DefineDirective *defineDirective = 0; + int replacementListStart; + + // check if this is a macro function + if (cleanedLine.count() >= 4 + && m_tokenContainer.text(cleanedLine.at(3)) == "(" + && !isWhiteSpace(cleanedLine.at(3) - 1)) { + MacroFunctionDefinition *macro; + macro = createNode<MacroFunctionDefinition>(m_memoryPool, group); + + int tokenIndex = 4; //point to first argument or ')' + QVector<int> macroParameterList; + while(tokenIndex < cleanedLine.count()) { + QByteArray currentText = m_tokenContainer.text(cleanedLine.at(tokenIndex)); + ++tokenIndex; + if(currentText == ")") + break; + if(currentText == ",") + continue; + macroParameterList.append(cleanedLine.at(tokenIndex - 1)); + } + macro->setParameters(TokenList(m_tokenContainer, macroParameterList)); + defineDirective = macro; + replacementListStart = tokenIndex; + } else { + MacroDefinition *macro; + macro = createNode<MacroDefinition>(m_memoryPool, group); + defineDirective = macro; + replacementListStart = 3; + } + Q_ASSERT(defineDirective); + + // This is a bit hackish.. we want the replacement list with whitepspace + // tokens, but cleanedLine() has already removed those. And we can't use + // the original line, because that may contain escaped newline tokens. + // So we remove the esacped newlines and search for the token number + // given by cleanedLine.at(replacementListStart) + QVector<int> replacementList; + const QVector<int> noEscNewline = cleanEscapedNewLines(line); + if (replacementListStart < cleanedLine.count()) { + const int cleanedLineReplacementListStart = cleanedLine.at(replacementListStart); + const int rListStart = noEscNewline.indexOf(cleanedLineReplacementListStart); + if (rListStart != -1) { + const int skipNewLineToken = 1; + for (int i = rListStart; i < noEscNewline.count() - skipNewLineToken; ++i) { + const int tokenContainerIndex = noEscNewline.at(i); + const Type type = m_tokenTypeList.at(tokenContainerIndex); + // Don't append comment tokens. + if (type != Token_line_comment && type != Token_multiline_comment) { + replacementList.append(tokenContainerIndex); + + } + } + } + } + + defineDirective->setTokenSection(line); + defineDirective->setIdentifier(TokenList(m_tokenContainer, QVector<int>() << identifier)); + defineDirective->setReplacementList(TokenList(m_tokenContainer, replacementList)); + group->toItemComposite()->add(defineDirective); + return true; +} + + +// # undef identifier newline +bool Preprocessor::parseUndefDirective(Item *group) +{ + Q_ASSERT(group->toItemComposite()); + const TokenSection tokenSection = readLine(); + const QVector<int> cleanedLine = cleanTokenRange(tokenSection); + + if(cleanedLine.count() < 3) + return false; + + UndefDirective *undefDirective = createNode<UndefDirective>(m_memoryPool, group); + group->toItemComposite()->add(undefDirective); + undefDirective->setIdentifier(TokenList(m_tokenContainer, QVector<int>() << cleanedLine.at(2))); + undefDirective->setTokenSection(tokenSection); + return true; +} + +//include pp-tokens new-line +bool Preprocessor::parseIncludeDirective(Item *group) +{ + // cout << "parseIncludeDirective" << endl; + Q_ASSERT(group->toItemComposite()); + TokenSection tokenSection = readLine(); + if(tokenSection.count() == 0) + return false; + + const TokenEngine::TokenContainer tokenContainer = tokenSection.tokenContainer(0); + IncludeDirective *includeDirective = createNode<IncludeDirective>(m_memoryPool, group); + group->toItemComposite()->add(includeDirective); + includeDirective->setTokenSection(tokenSection); + + //remove whitepspace and comment tokens + TokenList tokenList(m_tokenContainer, cleanTokenRange(tokenSection)); + + //iterate through the tokens, look for a string literal or a '<'. + int tokenIndex = 0; + const int endIndex = tokenList.count(); + while (tokenIndex < endIndex) { + const int containerTokenIndex = tokenList.containerIndex(tokenIndex); + if(m_tokenTypeList.at(containerTokenIndex) == Token_string_literal) { + QByteArray tokenText = tokenList.text(tokenIndex); + includeDirective->setFilename(tokenText.mid(1, tokenText.size() -2)); //remove quotes + includeDirective->setFilenameTokens(TokenEngine::TokenList(tokenContainer, QVector<int>() << containerTokenIndex)); + includeDirective->setIncludeType(IncludeDirective::QuoteInclude); + break; + } else if(tokenList.text(tokenIndex) == "<") { + // We found a <, all following tokens until we read a + // > is a part of the file anme + QByteArray filename; + ++tokenIndex; //skip '<' + QVector<int> filenameTokens; + while(tokenIndex < endIndex) { + const QByteArray tokenText = tokenList.text(tokenIndex); + if(tokenText == ">") + break; + filenameTokens.append(tokenList.containerIndex(tokenIndex)); + filename += tokenText; + ++tokenIndex; + } + if(tokenIndex < endIndex) { + includeDirective->setFilename(filename); + includeDirective->setFilenameTokens(TokenEngine::TokenList(tokenContainer, filenameTokens)); + includeDirective->setIncludeType(IncludeDirective::AngleBracketInclude); + } + break; + } + ++tokenIndex; + } + + return true; +} + +//# error pp-tokens[opt] new-line +bool Preprocessor::parseErrorDirective(Item *group) +{ + Q_ASSERT(group->toItemComposite()); + TokenSection tokenSection = readLine(); + if(tokenSection.count() == 0) + return false; + + ErrorDirective *errorDirective = createNode<ErrorDirective>(m_memoryPool, group); + group->toItemComposite()->add(errorDirective); + errorDirective->setTokenSection(tokenSection); + return true; +} + +//# pragma pp-tokens[opt] new-line +bool Preprocessor::parsePragmaDirective(Item *group) +{ + Q_ASSERT(group->toItemComposite()); + TokenSection tokenSection = readLine(); + if(tokenSection.count() == 0) + return false; + + PragmaDirective *pragmaDirective = createNode<PragmaDirective>(m_memoryPool, group); + group->toItemComposite()->add(pragmaDirective); + pragmaDirective->setTokenSection(tokenSection); + return true; +} +/* + Reads a preprocessor line from the source by advancing lexerTokenIndex and + returning a TokenSection containing the read line. Text lines separated by + an escaped newline are joined. +*/ +TokenSection Preprocessor::readLine() +{ + const int startIndex = lexerTokenIndex; + bool gotNewline = false; + + while(isValidIndex(lexerTokenIndex) && !gotNewline) { + if(m_tokenTypeList.at(lexerTokenIndex) == Token_newline) { + if (lexerTokenIndex == 0 || m_tokenTypeList.at(lexerTokenIndex-1) != '\\') { + gotNewline = true; + break; + } + } + ++lexerTokenIndex; + } + + if(gotNewline) + ++lexerTokenIndex; //include newline + else + emit error(QLatin1String("Error"), QLatin1String("Unexpected end of source")); + + return TokenSection(m_tokenContainer, startIndex, lexerTokenIndex - startIndex); +} + +/* + Returns false if index is past the end of m_tokenContainer. +*/ +inline bool Preprocessor::isValidIndex(const int index) const +{ + return (index < m_tokenContainer.count()); +} + +/* + Returns true if the token at index is a whitepsace token. +*/ +inline bool Preprocessor::isWhiteSpace(const int index) const +{ + return (m_tokenTypeList.at(index) == Token_whitespaces); +} + +/* + Looks ahead from lexerTokenIndex, returns the token type found at the first + token that is not a comment or whitespace token. +*/ +Type Preprocessor::lookAhead() const +{ + const int index = skipWhiteSpaceAndComments(); + if (index == -1) + return Token_eof; + return m_tokenTypeList.at(index); +} +/* + Looks ahead from lexerTokenIndex, returns the token type found at the first + token that is not a comment, whitespace or '#' token. +*/ +Type Preprocessor::lookAheadSkipHash() const +{ + const int index = skipWhiteSpaceCommentsHash(); + if (index == -1) + return Token_eof; + return m_tokenTypeList.at(index); +} + +/* + Returns the index for the first token after lexerTokenIndex that is not a + whitespace or comment token. +*/ +inline int Preprocessor::skipWhiteSpaceAndComments() const +{ + int index = lexerTokenIndex; + if(!isValidIndex(index)) + return -1; + while(m_tokenTypeList.at(index) == Token_whitespaces + || m_tokenTypeList.at(index) == Token_comment + || m_tokenTypeList.at(index) == Token_line_comment + || m_tokenTypeList.at(index) == Token_multiline_comment ) { + ++index; + if(!isValidIndex(index)) + return -1; + } + return index; +} + +/* + Returns the index for the first token after lexerTokenIndex that is not a + whitespace, comment or '#' token. +*/ +inline int Preprocessor::skipWhiteSpaceCommentsHash() const +{ + int index = lexerTokenIndex; + if(!isValidIndex(index)) + return -1; + while(m_tokenTypeList.at(index) == Token_whitespaces + || m_tokenTypeList.at(index) == Token_comment + || m_tokenTypeList.at(index) == Token_line_comment + || m_tokenTypeList.at(index) == Token_multiline_comment + || m_tokenTypeList.at(index) == Token_preproc ) { + ++index; + if(!isValidIndex(index)) + return -1; + } + return index; +} + +/* + Removes escaped newlines from tokenSection. Both the escape token ('\') + and the newline token ('\n') are removed. +*/ +QVector<int> Preprocessor::cleanEscapedNewLines(const TokenSection &tokenSection) const +{ + QVector<int> indexList; + + int t = 0; + const int numTokens = tokenSection.count(); + while (t < numTokens) { + const int containerIndex = tokenSection.containerIndex(t); + const int currentToken = t; + ++t; + + //handle escaped newlines + if (tokenSection.text(currentToken) == "\\" + && currentToken + 1 < numTokens + && m_tokenTypeList.at(containerIndex + 1) == Token_newline) + continue; + + indexList.append(containerIndex); + } + return indexList; +} + +/* + Removes escaped newlines, whitespace and comment tokens from tokenSection +*/ +QVector<int> Preprocessor::cleanTokenRange(const TokenSection &tokenSection) const +{ + QVector<int> indexList; + + int t = 0; + const int numTokens = tokenSection.count(); + while (t < numTokens) { + const int containerIndex = tokenSection.containerIndex(t); + const Type tokenType = m_tokenTypeList.at(containerIndex); + const int currentToken = t; + ++t; + + if(tokenType == Token_whitespaces || + tokenType == Token_line_comment || + tokenType == Token_multiline_comment ) + continue; + + //handle escaped newlines + if(tokenSection.text(currentToken) == "\\" && + currentToken + 1 < numTokens && + m_tokenTypeList.at(containerIndex + 1) == Token_newline) + continue; + + indexList.append(containerIndex); + } + return indexList; +} +/* + Returns the text for an Item node and all its children. +*/ +QByteArray visitGetText(Item *item) +{ + QByteArray text; + + text += item->text().fullText(); + + if(item->toItemComposite()) { + ItemComposite *composite = item->toItemComposite(); + for (int i=0; i <composite->count(); ++i) + text += visitGetText(composite->item(i)); + } + + return text; +} + +void Source::setFileName(const QString &fileName) +{ + m_fileName = fileName; +} + +} // namespace Rpp + +QT_END_NAMESPACE diff --git a/tools/porting/src/rpp.h b/tools/porting/src/rpp.h new file mode 100644 index 0000000..bb53eb8 --- /dev/null +++ b/tools/porting/src/rpp.h @@ -0,0 +1,1072 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef RPP_H +#define RPP_H + +#include "tokenengine.h" +#include "rpplexer.h" +#include "tokens.h" +#include "smallobject.h" +#include <QHash> +#include <QStringList> +#include <QFile> +#include <QByteArray> +#include <QDir> +#include <QMultiMap> +#include <ctype.h> + +QT_BEGIN_NAMESPACE + +namespace Rpp +{ + +struct Item; +struct ItemComposite; + +struct Source; + +struct Directive; +struct EmptyDirective; +struct ErrorDirective; +struct PragmaDirective; +struct IncludeDirective; +struct ConditionalDirective; +struct DefineDirective; +struct UndefDirective; +struct LineDirective; +struct NonDirective; + +struct IfSection; +struct IfLikeDirective; +struct IfDirective; +struct ElifDirective; +struct IfdefLikeDirective; +struct IfdefDirective; +struct IfndefDirective; +struct ElseDirective; +struct EndifDirective; + +struct Text; +struct Token; +struct TokenComposite; +struct IdToken; +struct NonIdToken; +struct PastingToken; +struct LineComment; +struct MultiLineComment; +struct WhiteSpace; + +struct MacroDefinition; +struct MacroFunctionDefinition; +struct MacroParameters; +struct MacroParameter; + +struct Expression; +struct UnaryExpression; +struct BinaryExpression; +struct ConditionalExpression; + +struct StringLiteral; +struct IntLiteral; +struct MacroReference; +struct MacroFunctionReference; +struct MacroArguments; +struct MacroArgument; + +struct Item +{ + virtual ~Item() {} + + virtual Item *parent() const = 0; + + virtual ItemComposite *toItemComposite() const + { return 0; } + + virtual Item *toItem() const + { return const_cast<Item *>(this); } + + virtual Directive *toDirective() const + { return 0; } + + virtual Text *toText() const + { return 0; } + + virtual Token *toToken() const + { return 0; } + + virtual Source *toSource() const + { return 0; } + + virtual Expression *toExpression() const + { return 0; } + + virtual IfSection *toIfSection() const + { return 0; } + + // Text returns the original text for an item, e.g. + // the way it is found in the source + virtual TokenEngine::TokenSection text() const + { return TokenEngine::TokenSection(); } + +protected: + //using the default constructor for an item is + //only allowded for subclasses. + Item() {}; +}; + +struct ItemComposite +{ + virtual ~ItemComposite() {} + virtual int count() const = 0; + virtual Item *item(int index) const = 0; + virtual void add(Item *item) = 0; +/* + Classes that inherit ItemComposite must implement this + function themselves + virtual ItemComposite *toItemComposite() const + { return const_cast<ItemComposite *>(this); } +*/ +}; + +struct Directive: public Item +{ + inline Directive(Item *parent = 0) + : m_parent(parent), m_numLines(0) {} + + virtual Item *parent() const + { return m_parent; } + + inline void setParent(Item *parent) + { m_parent = parent;} + + void setNumLines(const int numLines) + {m_numLines = numLines;} + + virtual Directive *toDirective() const + { return const_cast<Directive *>(this); } + + virtual EmptyDirective *toEmptyDirective() const + { return 0; } + + virtual ErrorDirective *toErrorDirective() const + { return 0; } + + virtual PragmaDirective *toPragmaDirective() const + { return 0; } + + virtual IncludeDirective *toIncludeDirective() const + { return 0; } + + virtual ConditionalDirective *toConditionalDirective() const + { return 0; } + + virtual DefineDirective *toDefineDirective() const + { return 0; } + + virtual UndefDirective *toUndefDirective() const + { return 0; } + + virtual LineDirective *toLineDirective() const + { return 0; } + + virtual NonDirective *toNonDirective() const + { return 0; } + + void setTokenSection(TokenEngine::TokenSection section) + { m_tokenSection = section; } + + TokenEngine::TokenSection text() const + { return m_tokenSection; } + +protected: + Item *m_parent; + int m_numLines; + TokenEngine::TokenSection m_tokenSection; +}; + + +struct Token: public Item +{ + inline Token(Item *parent = 0) + : m_tokenIndex(0), m_parent(parent) {} + + virtual Item *parent() const + { return m_parent; } + + virtual MacroArguments *toMacroArguments() const + { return 0; } + + virtual IdToken *toIdToken() const + { return 0; } + + virtual NonIdToken *toNonIdToken() const + { return 0; } + + virtual LineComment *toLineComment() const + { return 0; } + + virtual MultiLineComment *toMultiLineComment() const + { return 0; } + + virtual WhiteSpace *toWhiteSpace() const + { return 0; } + + virtual Token *toToken() const + { return const_cast<Token *>(this); } + + void setToken(int tokenIndex) + { m_tokenIndex = tokenIndex;} + + int index() const + { return m_tokenIndex; } + +protected: + int m_tokenIndex; + Item *m_parent; +}; + +struct Text: public Item +{ + inline Text(Item *parent = 0) + : m_parent(parent) {} + + virtual Text *toText() const + { return const_cast<Text *>(this); } + + virtual Item *parent() const + { return m_parent; } + + void setTokenSection(TokenEngine::TokenSection tokenSection) + {m_tokenSection = tokenSection; } + + TokenEngine::TokenSection text() const + { return m_tokenSection; } + + QVector<TokenEngine::TokenSection> cleanedText() const + { return m_cleanedSection; } + + void setTokens( const QVector<Token *> &tokens ) + { m_tokens = tokens; } + + void addToken(Token *token) + {m_tokens.append(token);} + + Token *token(int index) const + {return m_tokens.at(index);} + + inline int count() const + {return m_tokens.count();} + + QVector<Token *> tokenList() const + { return m_tokens; } + +protected: + Item *m_parent; + TokenEngine::TokenSection m_tokenSection; // all tokens + QVector<TokenEngine::TokenSection> m_cleanedSection; //comments removed + QVector<Token *> m_tokens; +}; + +struct IdToken: public Token +{ + inline IdToken(Item *parent = 0) + : Token(parent) {} + + virtual IdToken *toIdToken() const + { return const_cast<IdToken *>(this); } +}; + +struct NonIdToken: public Token +{ + inline NonIdToken(Item *parent = 0) + : Token(parent) {} + + virtual NonIdToken *toNonIdToken() const + { return const_cast< NonIdToken *>(this); } +}; + +struct LineComment : public NonIdToken +{ + inline LineComment(Item *parent = 0) + : NonIdToken(parent) {} + + virtual LineComment *toLineComment() const + { return const_cast< LineComment *>(this); } +}; + +struct MultiLineComment: public NonIdToken +{ + inline MultiLineComment(Item *parent = 0) + : NonIdToken(parent) {} + + virtual MultiLineComment *toMultiLineComment() const + { return const_cast< MultiLineComment *>(this); } +protected: +}; + +struct WhiteSpace: public NonIdToken +{ + inline WhiteSpace(Item *parent = 0) + : NonIdToken(parent) {} + + virtual WhiteSpace *toWhiteSpace() const + { return const_cast<WhiteSpace *>(this); } +}; + +struct Source: public Item, public ItemComposite +{ + Source(Item *parent = 0) + :m_parent(parent) {} + + virtual Source *toSource() const + { return const_cast<Source *>(this); } + + ItemComposite *toItemComposite() const + { return const_cast<Source *>(this); } + + virtual int count() const + { return m_items.count(); } + + virtual Item *item(int index) const + { return m_items.at(index); } + + inline QString fileName() const + { return m_fileName; } + + void setFileName(const QString &fileName); + + virtual Item *parent() const + { return m_parent; } + + inline void add(Item *item) + { m_items.append(item); } + +private: + Item *m_parent; + QVector<Item *> m_items; + QString m_fileName; +}; + +struct EmptyDirective: public Directive +{ + EmptyDirective(Item *item) + : Directive(item) {} + + virtual EmptyDirective *toEmptyDirective() const + { return const_cast<EmptyDirective *>(this); } +}; + +struct ErrorDirective: public Directive +{ + ErrorDirective(Item *item) + : Directive(item) {} + + virtual ErrorDirective *toErrorDirective() const + { return const_cast<ErrorDirective *>(this); } +}; + +struct PragmaDirective: public Directive +{ + PragmaDirective(Item *item) + : Directive(item) {} + + virtual PragmaDirective *toPragmaDirective() const + { return const_cast<PragmaDirective *>(this); } +}; + +struct IncludeDirective: public Directive +{ + enum IncludeType {QuoteInclude, AngleBracketInclude}; + + IncludeDirective(Item *item) + : Directive(item), m_includeType(QuoteInclude) {} + + IncludeDirective() : Directive() {} + + virtual IncludeDirective *toIncludeDirective() const + { return const_cast<IncludeDirective *>(this); } + + void setFilenameTokens(const TokenEngine::TokenList &filenameTokens) + { m_filenameTokens = filenameTokens; } + + TokenEngine::TokenList filenameTokens() const + { return m_filenameTokens; } + + void setFilename(const QByteArray &filename) + { m_filename = filename; } + + QByteArray filename() const + { return m_filename;} + + void setIncludeType(IncludeType includeType) + { m_includeType = includeType; } + + IncludeType includeType() const + { return m_includeType; } +private: + TokenEngine::TokenList m_filenameTokens; + QByteArray m_filename; + IncludeType m_includeType; +}; + +struct ConditionalDirective: public Directive, public ItemComposite +{ + inline ConditionalDirective(Item *parent = 0) + :Directive(parent) {} + + virtual ConditionalDirective *toConditionalDirective() const + { return const_cast<ConditionalDirective *>(this); } + + ItemComposite *toItemComposite() const + { return const_cast<ConditionalDirective *>(this); } + + virtual IfDirective *toIfDirective() const + { return 0; } + + virtual IfdefDirective *toIfdefDirective() const + { return 0; } + + virtual IfndefDirective *toIfndefDirective() const + { return 0; } + + virtual ElifDirective *toElifDirective() const + { return 0; } + + virtual ElseDirective *toElseDirective() const + { return 0; } + + int count() const + { return m_items.count(); } + + Item *item(int index) const + { return m_items.at(index); } + + void add(Item *item) + { m_items.append(item); } +protected: + QVector<Item *> m_items; +}; + +struct IfSection: public Item, public ItemComposite +{ + IfSection(Item *parent) + :m_parent(parent), m_ifGroup(0), m_elseGroup(0), m_endifLine(0) {} + + IfSection *toIfSection() const + { return const_cast<IfSection *>(this); } + + ItemComposite *toItemComposite() const + { return const_cast<IfSection *>(this); } + + void setParent(Item *parent) + { m_parent = parent; } + + Item *parent() const + { return m_parent; } + + void setIfGroup(ConditionalDirective *ifGroup) + { m_ifGroup = ifGroup; m_items.append(ifGroup); } + + ConditionalDirective *ifGroup() const + { return m_ifGroup; } + + void addElifGroup(ConditionalDirective *elifGroup) + { m_elifGroups.append(elifGroup); m_items.append(elifGroup); } + + QVector<ConditionalDirective *> elifGroups() const + { return m_elifGroups; } + + void setElseGroup(ConditionalDirective *elseGroup) + { m_elseGroup = elseGroup; m_items.append(elseGroup); } + + ConditionalDirective *elseGroup() const + { return m_elseGroup; } + + void setEndifLine(Directive *endifLine) + { m_endifLine = endifLine; m_items.append(endifLine); } + + Directive *endifLine() const + { return m_endifLine; } + + int count() const + { return m_items.count(); } + + Item *item(int index) const + { return m_items.at(index);} + + private: + void add(Item *item) + { Q_UNUSED(item); } + + Item *m_parent; + QVector<Item *> m_items; + ConditionalDirective *m_ifGroup; + QVector<ConditionalDirective *> m_elifGroups; + ConditionalDirective *m_elseGroup; + Directive *m_endifLine; +}; + +struct Expression: public Item +{ + enum Operator + { + LtEqOp = 300, + GtEqOp, + LtOp, + GtOp, + EqOp, + NotEqOp, + OrOp, + AndOp, + LShiftOp, + RShiftOp + }; + + inline Expression(Item *parent = 0) + : m_parent(parent) {} + + inline Expression *parentExpression() const + { return m_parent ? m_parent->toExpression() : 0; } + + virtual Item *parent() const + { return m_parent; } + + virtual Expression *toExpression() const + { return const_cast<Expression *>(this); } + + virtual UnaryExpression *toUnaryExpression() const + { return 0; } + + virtual BinaryExpression *toBinaryExpression() const + { return 0; } + + virtual StringLiteral *toStringLiteral() const + { return 0; } + + virtual IntLiteral *toIntLiteral() const + { return 0; } + + virtual MacroReference *toMacroReference() const + { return 0; } + + virtual MacroFunctionReference *toMacroFunctionReference() const + { return 0; } + + virtual ConditionalExpression *toConditionalExpression() const + { return 0; } + + int evaluate(bool *ok = 0); + +private: + Item *m_parent; +}; + +struct StringLiteral: public Expression +{ + inline StringLiteral(const QByteArray &value, Item *parent) + : Expression(parent), m_value(value) {} + + QByteArray value() const + { return m_value; } + + virtual StringLiteral *toStringLiteral() const + { return const_cast<StringLiteral *>(this); } + +private: + QByteArray m_value; +}; + +struct IntLiteral: public Expression +{ + inline IntLiteral(int value, Item *parent = 0) + : Expression(parent), m_value(value) {} + + inline int value() const + { return m_value; } + + virtual IntLiteral *toIntLiteral() const + { return const_cast<IntLiteral *>(this); } + +private: + int m_value; +}; + +struct MacroReference: public Expression +{ + enum Type { + DefinedRef, //#if defined(foo) + ValueRef + }; + + inline MacroReference(const TokenEngine::TokenList &name, Type type, Item *parent = 0) + : Expression(parent), m_type(type), m_name(name) {} + + virtual MacroReference *toMacroReference() const + { return const_cast<MacroReference *>(this); } + + inline TokenEngine::TokenList name() const + { return m_name; } + + inline void setName(const TokenEngine::TokenList &name) + { m_name = name; } + + inline int type() const + { return m_type; } + +private: + int m_type; + TokenEngine::TokenList m_name; +}; + +struct MacroFunctionReference: public Expression +{ + MacroFunctionReference(const QByteArray &name, Item *parent); + + inline QByteArray name() const + { return m_name; } + + inline void setName(const QByteArray &name) + { m_name = name; } + + inline MacroArguments *arguments() const + { return m_arguments; } + + virtual MacroFunctionReference *toMacroFunctionReference() const + { return const_cast<MacroFunctionReference *>(this); } + +private: + QByteArray m_name; + MacroArguments *m_arguments; +}; + +struct UnaryExpression: public Expression +{ + inline UnaryExpression(int op, Expression *e, Expression *parent = 0) + : Expression(parent), m_op(op), m_expression(e) {} + + inline int op() const + { return m_op; } + + inline Expression *expression() const + { return m_expression; } + + virtual UnaryExpression *toUnaryExpression() const + { return const_cast<UnaryExpression *>(this); } + +private: + int m_op; + Expression *m_expression; +}; + +struct BinaryExpression: public Expression +{ + inline BinaryExpression(int op, Expression *left, Expression *right, Expression *parent = 0) + : Expression(parent), + m_op(op), + m_leftExpression(left), + m_rightExpression(right) {} + + inline int op() const + { return m_op; } + + inline Expression *leftExpression() const + { return m_leftExpression; } + + inline Expression *rightExpression() const + { return m_rightExpression; } + + virtual BinaryExpression *toBinaryExpression() const + { return const_cast<BinaryExpression *>(this); } + +private: + int m_op; + Expression *m_leftExpression; + Expression *m_rightExpression; +}; + +struct ConditionalExpression: public Expression +{ + inline ConditionalExpression(Expression *condition, Expression *left, Expression *right, Expression *parent = 0) + : Expression(parent), + m_condition(condition), + m_leftExpression(left), + m_rightExpression(right) {} + + inline Expression *condition() const + { return m_condition; } + + inline Expression *leftExpression() const + { return m_leftExpression; } + + inline Expression *rightExpression() const + { return m_rightExpression; } + + virtual ConditionalExpression *toConditionalExpression() const + { return const_cast<ConditionalExpression *>(this); } + +private: + Expression *m_condition; + Expression *m_leftExpression; + Expression *m_rightExpression; +}; + + +struct IfLikeDirective: public ConditionalDirective +{ + inline IfLikeDirective(Item *parent = 0) + :ConditionalDirective(parent), m_expression(0) {} + + void setExpression(Expression *expression) + { m_expression = expression; } + + Expression *expression() const + { return m_expression; } + +protected: + Expression *m_expression; +}; + +struct IfDirective: public IfLikeDirective +{ + inline IfDirective(Item *parent = 0) + :IfLikeDirective(parent) {} + + virtual IfDirective *toIfDirective() const + { return const_cast<IfDirective *>(this); } +}; + + +struct ElifDirective: public IfLikeDirective +{ + inline ElifDirective(Item *parent = 0) + :IfLikeDirective(parent) {} + + virtual ElifDirective *toElifDirective() const + { return const_cast<ElifDirective *>(this); } +}; + +struct IfdefLikeDirective: public ConditionalDirective +{ + inline IfdefLikeDirective(Item *parent = 0) + :ConditionalDirective(parent) {} + + inline TokenEngine::TokenList identifier() const + { return m_identifier; } + + inline void setIdentifier(const TokenEngine::TokenList &identifier) + { m_identifier = identifier; } +protected: + TokenEngine::TokenList m_identifier; +}; + +struct IfdefDirective: public IfdefLikeDirective +{ + IfdefDirective(Item *parent) + :IfdefLikeDirective(parent) {} + + virtual IfdefDirective *toIfdefDirective() const + { return const_cast<IfdefDirective *>(this); } +}; + +struct IfndefDirective: public IfdefLikeDirective +{ + inline IfndefDirective(Item *parent) + :IfdefLikeDirective(parent) {} + + virtual IfndefDirective *toIfndefDirective() const + { return const_cast<IfndefDirective *>(this); } +}; + +struct ElseDirective: public ConditionalDirective +{ + ElseDirective(Item *parent) + :ConditionalDirective(parent) {} + + virtual ElseDirective *toElseDirective() const + { return const_cast<ElseDirective *>(this); } +}; + +struct EndifDirective : public Directive +{ + EndifDirective(Item *parent) + :Directive(parent) {} + + EndifDirective *toEndifDirective() const + { return const_cast<EndifDirective *>(this); } +}; + +struct DefineDirective: public Directive +{ + DefineDirective(Item *parent) + : Directive(parent) {}; + + inline TokenEngine::TokenList identifier() const + { return m_identifier; } + + inline void setIdentifier(TokenEngine::TokenList identifier) + { m_identifier = identifier; } + + inline void setReplacementList(TokenEngine::TokenList replacementList) + { m_replacementList = replacementList; } + + inline TokenEngine::TokenList replacementList() const + { return m_replacementList; } + + virtual DefineDirective *toDefineDirective() const + { return const_cast<DefineDirective *>(this); } + + virtual MacroDefinition *toMacroDefinition() const + { return 0; } + + virtual MacroFunctionDefinition *toMacroFunctionDefinition() const + { return 0; } +private: + TokenEngine::TokenList m_identifier; + TokenEngine::TokenList m_replacementList; +}; + +struct MacroDefinition: public DefineDirective +{ + MacroDefinition(Item *parent) + : DefineDirective(parent) {}; + + virtual MacroDefinition *toMacroDefinition() const + { return const_cast<MacroDefinition *>(this); } +}; + +struct MacroFunctionDefinition: public DefineDirective +{ + MacroFunctionDefinition(Item *parent) + : DefineDirective(parent) {} + + virtual MacroFunctionDefinition *toMacroFunctionDefinition() const + { return const_cast<MacroFunctionDefinition *>(this); } + + void setParameters(TokenEngine::TokenList macroParameters) + { m_parameters = macroParameters;} + + inline TokenEngine::TokenList parameters() const + { return m_parameters; } + +private: + TokenEngine::TokenList m_parameters; +}; + +struct MacroParameter: public Item +{ + inline MacroParameter(Item *parent) + : m_parent(parent) {} + + inline QByteArray name() const + { return m_name; } + + inline void setName(const QByteArray &name) + { m_name = name; } + + virtual Item *parent() const + { return m_parent; } + +private: + Item *m_parent; + QByteArray m_name; +}; + +struct MacroParameters: public Item, public ItemComposite +{ + MacroParameters(MacroFunctionDefinition *parent) + : m_parent(parent) {} + + ItemComposite *toItemComposite() const + { return const_cast<MacroParameters *>(this); } + + virtual Item *parent() const + { return m_parent; } + + virtual int count() const + { return m_items.count(); } + + virtual Item *item(int index) const + { return m_items.at(index); } + + void addParameter(MacroParameter *param) + { Q_ASSERT(param->parent() == this); m_items.append(param); } + + int indexOf(const QByteArray ¶m) const + { + for (int i=0; i<m_items.count(); ++i) { + // cout <<"checking |" << param.constData() << "| against |" << m_items.at(i)->name().constData() <<"|" << endl; + if (m_items.at(i)->name() == param) + return i; + } + return -1; + } + + inline bool contains(const QByteArray ¶m) const + { return indexOf(param) != -1; } +/* + void add(const QByteArray ¶m) + { + MacroParameter *p = createNode<MacroParameter>(this); + p->setName(param); + addParameter(p); + } +*/ +private: + MacroFunctionDefinition *m_parent; + QVector<MacroParameter*> m_items; +}; + +struct UndefDirective: public Directive +{ + UndefDirective(Item *parent) + :Directive(parent) {} + + inline TokenEngine::TokenList identifier() const + { return m_identifier; } + + inline void setIdentifier(const TokenEngine::TokenList &identifier) + { m_identifier = identifier; } + + virtual UndefDirective *toUndefDirective() const + { return const_cast<UndefDirective *>(this); } +private: + TokenEngine::TokenList m_identifier; +}; + +struct LineDirective: public Directive +{ + LineDirective(Item *parent) + :Directive(parent) {} + + virtual LineDirective *toLineDirective() const + { return const_cast<LineDirective *>(this); } +}; + +struct NonDirective: public Directive +{ + NonDirective(Item *parent) + :Directive(parent) {} + + virtual NonDirective *toNonDirective() const + { return const_cast<NonDirective *>(this); } +}; + +class Preprocessor : public QObject +{ +Q_OBJECT +public: + Preprocessor(); + Source *parse(const TokenEngine::TokenContainer &tokenContainer, + const QVector<Type> &tokenTypeList, TypedPool<Item> *memoryPool); +signals: + void error(const QString type, const QString message); +private: + bool parseGroup(Item *node); + bool parseGroupPart(Item *node); + + bool parseIfSection(Item *node); + bool parseNonDirective(Item *node); + bool parseTextLine(Item *node); + + bool parseIfGroup(IfSection *node); + bool parseElifGroups(IfSection *node); + bool parseElifGroup(IfSection *node); + bool parseElseGroup(IfSection *node); + bool parseEndifLine(IfSection *node); + + bool parseIfdefLikeDirective(IfdefLikeDirective *node); + bool parseIfLikeDirective(IfLikeDirective *node); + + bool parseDefineDirective(Item *node); + bool parseUndefDirective(Item *node); + bool parseIncludeDirective(Item *node); + bool parseErrorDirective(Item *node); + bool parsePragmaDirective(Item*node); + + TokenEngine::TokenSection readLine(); + inline bool isValidIndex(const int index) const; + inline bool isWhiteSpace(const int index) const; + Type lookAhead() const; + Type lookAheadSkipHash() const; + inline int skipWhiteSpaceAndComments() const; + inline int skipWhiteSpaceCommentsHash() const; + QVector<int> cleanEscapedNewLines(const TokenEngine::TokenSection &tokenSection) const; + QVector<int> cleanTokenRange(const TokenEngine::TokenSection &tokenSection) const; + + Source *m_source; + TokenEngine::TokenContainer m_tokenContainer; + QVector<Type> m_tokenTypeList; + TypedPool<Item> *m_memoryPool; + int lexerTokenIndex; + int numTokens; +}; + +/* + T must be a subclass of Item, parent must implment + the ItemComposite interface +*/ +template <typename T> +T *createNode(TypedPool<Item> *memPool, Item *parent) +{ + Q_ASSERT(parent); + T* node = new (memPool->allocate(sizeof(T))) T(parent); + Q_ASSERT(node); + return node; +} + +template <typename T> +T *createNode(TypedPool<Item> *memPool) +{ + T* node = new (memPool->allocate(sizeof(T))) T(0); + Q_ASSERT(node); + return node; +} + + +QByteArray visitGetText(Item *item); + +} // namespace Rpp + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/rppexpressionbuilder.cpp b/tools/porting/src/rppexpressionbuilder.cpp new file mode 100644 index 0000000..93b6e8b --- /dev/null +++ b/tools/porting/src/rppexpressionbuilder.cpp @@ -0,0 +1,330 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "rppexpressionbuilder.h" +#include "tokens.h" +#include "rpp.h" + +QT_BEGIN_NAMESPACE + +using namespace TokenEngine; +namespace Rpp { + +ExpressionBuilder::ExpressionBuilder(const TokenList &tokenList, const QVector<Type> &typeList, TypedPool<Item> *memoryPool) +:i(0) +,m_tokenList(tokenList) +,m_typeList(typeList) +,m_memoryPool(memoryPool) +{} + +Rpp::Expression *ExpressionBuilder::parse() +{ + if(unary_expression_lookup()) + return conditional_expression(); + else + return createIntLiteral(0); +} +Type ExpressionBuilder::next() +{ + if(!hasNext()) + return Token_eof; + return typeAt(i++); +} + +inline bool ExpressionBuilder::test(int token) +{ + if (i < m_tokenList.count() && typeAt(i) == token) { + ++i; + return true; + } + return false; +} + +inline bool ExpressionBuilder::moreTokens(int delta) +{ + return (i + delta < m_tokenList.count()); +} + +inline Type ExpressionBuilder::lookup(int k) +{ + const int l = i - 1 + k; + return l < m_tokenList.count() ? typeAt(l) : Token_eof; +} + +Expression *ExpressionBuilder::conditional_expression() +{ + Expression *value = logical_OR_expression(); + if (test('?')) { + Expression *leftExpression = conditional_expression(); + Expression *rightExpression; + if(test(':')) + rightExpression = conditional_expression(); + else + rightExpression = createIntLiteral(0); + return createConditionalExpression(value, leftExpression, rightExpression); + } + return value; +} + +Expression *ExpressionBuilder::logical_OR_expression() +{ + Expression *value = logical_AND_expression(); + if (test(Token_or)) + return createBinaryExpression(Expression::OrOp, value, logical_OR_expression()); + return value; +} + +Expression *ExpressionBuilder::logical_AND_expression() +{ + Expression *value = inclusive_OR_expression(); + if (test(Token_and)) + return createBinaryExpression(Expression::AndOp, value, logical_AND_expression()); + return value; +} + +Expression *ExpressionBuilder::inclusive_OR_expression() +{ + Expression *value = exclusive_OR_expression(); + if (test('|')) + return createBinaryExpression('|', value, inclusive_OR_expression()); + return value; +} + +Expression *ExpressionBuilder::exclusive_OR_expression() +{ + Expression *value = AND_expression(); + if (test('^')) + return createBinaryExpression('^', value, exclusive_OR_expression()); + return value; +} + +Expression *ExpressionBuilder::AND_expression() +{ + Expression *value = equality_expression(); + if (test('&')) + return createBinaryExpression('&', value, AND_expression()); + return value; +} + +Expression *ExpressionBuilder::equality_expression() +{ + Expression *value = relational_expression(); + switch (next()) { + case Token_eq: + return createBinaryExpression(Expression::EqOp, value, equality_expression()); + case Token_not_eq: + return createBinaryExpression(Expression::NotEqOp, value, equality_expression()); + default: + prev(); + return value; + } +} + +Expression *ExpressionBuilder::relational_expression() +{ + Expression *value = shift_expression(); + switch (next()) { + case '<': + return createBinaryExpression('<', value, relational_expression()); + case '>': + return createBinaryExpression('>', value, relational_expression()); + case Token_leq: + return createBinaryExpression(Expression::LtEqOp, value, relational_expression()); + case Token_geq: + return createBinaryExpression(Expression::GtEqOp, value, relational_expression()); + default: + prev(); + return value; + } +} + +Expression *ExpressionBuilder::shift_expression() +{ + Expression *value = additive_expression(); + switch (next()) { + case Token_left_shift: + return createBinaryExpression(Expression::LShiftOp, value, shift_expression()); + case Token_right_shift: + return createBinaryExpression(Expression::RShiftOp, value, shift_expression()); + default: + prev(); + return value; + } +} + +Expression *ExpressionBuilder::additive_expression() +{ + Expression *value = multiplicative_expression(); + switch (next()) { + case '+': + return createBinaryExpression('+', value, additive_expression()); + case '-': + return createBinaryExpression('-', value, additive_expression()); + default: + prev(); + return value; + } +} + +Expression *ExpressionBuilder::multiplicative_expression() +{ + Expression *value = unary_expression(); + switch (next()) { + case '*': + return createBinaryExpression('*', value, multiplicative_expression()); + case '%': + return createBinaryExpression('%', value, multiplicative_expression()); + case '/': + return createBinaryExpression('/', value, multiplicative_expression()); + default: + prev(); + return value; + }; +} + +Expression *ExpressionBuilder::unary_expression() +{ + switch (next()) { + case '+': + return createUnaryExpression('+', unary_expression()); + case '-': + return createUnaryExpression('-', unary_expression()); + case '!': + return createUnaryExpression('!', unary_expression()); + case '~': + return createUnaryExpression('~', unary_expression()); + case Token_defined: + { + int identifierIndex = 0; + if (test(Token_identifier)) { + identifierIndex = i - 1; + } else if (test('(')) { + if (test(Token_identifier)) + identifierIndex = i -1; + test(')'); + } + return createMacroReference(MacroReference::DefinedRef, createTokenList(identifierIndex)); + } + default: + prev(); + return primary_expression(); + } +} + +bool ExpressionBuilder::unary_expression_lookup() +{ + Type t = lookup(); + return (primary_expression_lookup() + || t == '+' + || t == '-' + || t == '!' + || t == '~' + || t == Token_defined); +} + +Expression *ExpressionBuilder::primary_expression() +{ + Expression *value; + if (test('(')) { + if (moreTokens(1)) + value = conditional_expression(); + else + value = createIntLiteral(0); // Syntax error. + test(')'); + } else { + next(); + bool ok; + int val = QString::fromLatin1(lexem()).toInt(&ok, 0); + if(ok) + value = createIntLiteral(val); + else + value = createMacroReference(MacroReference::ValueRef, createTokenList(i -1)); + } + return value; +} + +bool ExpressionBuilder::primary_expression_lookup() +{ + Type t = lookup(); + return (t == Token_identifier + || t == Token_number_literal +/* || t == PP_FLOATING_LITERAL*/ + || t == '('); +} +/* + Creates a tokenList containing one token +*/ +TokenList ExpressionBuilder::createTokenList(int tokenIndex) const +{ + return TokenList(m_tokenList.tokenContainer(tokenIndex), + QVector<int>() << m_tokenList.containerIndex(tokenIndex)); +} +/* + Node cration helper functions +*/ +UnaryExpression *ExpressionBuilder::createUnaryExpression(int op, Expression *expression) +{ + return new (m_memoryPool->allocate(sizeof(UnaryExpression))) UnaryExpression(op, expression); +} + +BinaryExpression *ExpressionBuilder::createBinaryExpression(int op, Expression *leftExpresson, Expression *rightExpression) +{ + return new (m_memoryPool->allocate(sizeof(BinaryExpression))) BinaryExpression(op, leftExpresson, rightExpression); +} + +ConditionalExpression *ExpressionBuilder::createConditionalExpression(Expression *condition, Expression *leftExpression, Expression *rightExpression) +{ + return new (m_memoryPool->allocate(sizeof(ConditionalExpression))) ConditionalExpression(condition, leftExpression, rightExpression); +} + +MacroReference *ExpressionBuilder::createMacroReference(MacroReference::Type type, TokenEngine::TokenList token) +{ + return new (m_memoryPool->allocate(sizeof(MacroReference))) MacroReference(token, type); +} + +IntLiteral *ExpressionBuilder::createIntLiteral(const int arg) +{ + return new (m_memoryPool->allocate(sizeof(IntLiteral))) IntLiteral(arg); +} + +} + +QT_END_NAMESPACE diff --git a/tools/porting/src/rppexpressionbuilder.h b/tools/porting/src/rppexpressionbuilder.h new file mode 100644 index 0000000..5e11ca7 --- /dev/null +++ b/tools/porting/src/rppexpressionbuilder.h @@ -0,0 +1,107 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef RPPEXPRESSIONBUILDER_H +#define RPPEXPRESSIONBUILDER_H + +#include "tokens.h" +#include "tokenengine.h" +#include "smallobject.h" +#include "rpp.h" +#include <QByteArray> + +QT_BEGIN_NAMESPACE + +namespace Rpp { + +class ExpressionBuilder +{ +public: + ExpressionBuilder(const TokenEngine::TokenList &tokenList, const QVector<Type> &typeList, TypedPool<Item> *memoryPool); + Rpp::Expression *parse(); +private: + + inline bool hasNext() const { return (i < m_tokenList.count()); } + Type next(); + bool test(int); + bool moreTokens(int delta); + inline void prev() {--i;} + Type lookup(int k = 1); + inline Type token() { return typeAt(i-1);} + inline QByteArray lexem() { return m_tokenList.text(i-1);} + inline Type typeAt(int t) { return m_typeList.at(m_tokenList.containerIndex(t));} + + Expression *conditional_expression(); + Expression *logical_OR_expression(); + Expression *logical_AND_expression(); + Expression *inclusive_OR_expression(); + Expression *exclusive_OR_expression(); + Expression *AND_expression(); + Expression *equality_expression(); + Expression *relational_expression(); + Expression *shift_expression(); + Expression *additive_expression(); + Expression *multiplicative_expression(); + Expression *unary_expression(); + Expression *primary_expression(); + + bool unary_expression_lookup(); + bool primary_expression_lookup(); + + UnaryExpression *createUnaryExpression(int op, Expression *expression); + BinaryExpression *createBinaryExpression(int op, Expression *leftExpresson, Expression *rightExpression); + ConditionalExpression *createConditionalExpression(Expression *condition, Expression *leftExpression, Expression *rightExpression); + MacroReference *createMacroReference(MacroReference::Type type, TokenEngine::TokenList token); + IntLiteral *createIntLiteral(const int arg); + + TokenEngine::TokenList createTokenList(int tokenIndex) const; + + int i; + TokenEngine::TokenList m_tokenList; + QVector<Type> m_typeList; + TypedPool<Item> *m_memoryPool; +}; + +} + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/rpplexer.cpp b/tools/porting/src/rpplexer.cpp new file mode 100644 index 0000000..d3b836a --- /dev/null +++ b/tools/porting/src/rpplexer.cpp @@ -0,0 +1,381 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "rpplexer.h" +#include <QChar> +#include <ctype.h> + +QT_BEGIN_NAMESPACE + +using namespace TokenEngine; + +namespace Rpp { +RppLexer::RppLexer() + : m_buffer(0), m_ptr(0), m_len(0) +{ + setupScanTable(); +} + +void RppLexer::setupScanTable() +{ + memset(s_attr_table, 0, 256); + + for (int i=0; i<128; ++i) { + switch (i) { + case ':': + case '*': + case '%': + case '^': + case '=': + case '!': + case '&': + case '|': + case '+': + case '<': + case '>': + case '-': + case '.': + s_scan_table[i] = &RppLexer::scanOperator; + break; + + case '\r': + case '\n': + s_scan_table[i] = &RppLexer::scanNewline; + break; + + case '\'': + s_scan_table[i] = &RppLexer::scanCharLiteral; + break; + + case '"': + s_scan_table[i] = &RppLexer::scanStringLiteral; + break; + case '#': + s_scan_table[i] = &RppLexer::scanPreprocessor; + break; + + case '/': + s_scan_table[i] = &RppLexer::scanComment; + break; + + default: + if (isspace(i)) { + s_scan_table[i] = &RppLexer::scanWhiteSpaces; + s_attr_table[i] |= A_Whitespace; + } else if (isalpha(i) || i == '_') { + s_scan_table[i] = &RppLexer::scanKeyword; + s_attr_table[i] |= A_Alpha; + } else if (isdigit(i)) { + s_scan_table[i] = &RppLexer::scanNumberLiteral; + s_attr_table[i] |= A_Digit; + } else + s_scan_table[i] = &RppLexer::scanChar; + } + } + + s_scan_table[128] = &RppLexer::scanUnicodeChar; +} + +QVector<Type> RppLexer::lex(const TokenContainer &tokenContainer) +{ + QVector<Type> tokenTypes; + const int numTokens = tokenContainer.count(); + tokenTypes.reserve(numTokens); + QByteArray text = tokenContainer.fullText(); + m_buffer = text.constData(); + for(int t=0; t<numTokens; ++t) { + TokenEngine::Token token = tokenContainer.token(t); + tokenTypes.append(indentify(token.start, token.length)); + } + return tokenTypes; +} + +Type RppLexer::indentify(int pos, int length) +{ + Q_ASSERT(length > 0); + m_ptr = pos; + m_len = length; + int kind = 0; + const unsigned char ch = m_buffer[pos]; + (this->*s_scan_table[ch < 128 ? ch : 128])(&kind); + return (Type)kind; +} + +void RppLexer::scanChar(int *kind) +{ + *kind = m_buffer[m_ptr]; +} + +void RppLexer::scanWhiteSpaces(int *kind) +{ + *kind = Token_whitespaces; + + while (unsigned char ch = m_buffer[m_ptr]) { + if (s_attr_table[ch] & A_Whitespace) + ++m_ptr; + else + break; + } +} + +void RppLexer::scanNewline(int *kind) +{ + *kind = '\n'; +} + +void RppLexer::scanUnicodeChar(int *kind) +{ + *kind = m_buffer[m_ptr]; +} + +void RppLexer::scanCharLiteral(int *kind) +{ + *kind = Token_char_literal; +} + +void RppLexer::scanStringLiteral(int *kind) +{ + *kind = Token_string_literal; +} + +void RppLexer::scanIdentifier(int *kind) +{ + *kind = Token_identifier; +} + +void RppLexer::scanNumberLiteral(int *kind) +{ + *kind = Token_number_literal; +} + +void RppLexer::scanPreprocessor(int *kind) +{ + *kind = Token_preproc; +} + +void RppLexer::scanComment(int *kind) +{ + switch(m_buffer[m_ptr + 1]) { + case '/': + *kind = Token_line_comment; + break; + case '*': + *kind = Token_multiline_comment; + break; + default: + scanOperator(kind); + } +} + +void RppLexer::scanOperator(int *kind) +{ + switch (m_buffer[m_ptr]) { + case ':': + if (m_buffer[m_ptr+1] == ':') { + *kind = Token_scope; + return; + } + break; + + case '*': + case '/': + case '%': + case '^': + if (m_buffer[m_ptr+1] == '=') { + *kind = Token_assign; + return; + } + break; + + case '=': + if (m_buffer[m_ptr+1] == '=') { + *kind = Token_eq; + return; + } + break; + case '!': + if (m_buffer[m_ptr+1] == '=') { + *kind = Token_not_eq; + return; + } + break; + + case '&': + if (m_buffer[m_ptr+1] == '&') { + *kind = Token_and; + return; + } else if (m_buffer[m_ptr+1] == '=') { + *kind = Token_assign; + return; + } + break; + + case '|': + if (m_buffer[m_ptr+1] == '|' ) { + *kind = Token_or; + return; + } else if (m_buffer[m_ptr+1] == '=') { + *kind = Token_assign; + return; + } + break; + + case '+': + if (m_buffer[m_ptr+1] == '+' ) { + *kind = Token_incr; + return; + } else if (m_buffer[m_ptr+1] == '=') { + *kind = Token_assign; + return; + } + break; + + case '<': + if (m_buffer[m_ptr+1] == '<') { + if (m_buffer[m_ptr+2] == '=') { + *kind = Token_assign; + return; + } + *kind = Token_left_shift; + return; + } else if (m_buffer[m_ptr+1] == '=') { + *kind = Token_leq; + return; + } + break; + + case '>': + if (m_buffer[m_ptr+1] == '>') { + if (m_buffer[m_ptr+2] == '=') { + *kind = Token_assign; + return; + } + *kind = Token_right_shift; + return; + } else if (m_buffer[m_ptr+1] == '=') { + *kind = Token_geq; + return; + } + break; + + case '-': + if (m_buffer[m_ptr+1] == '>') { + if (m_buffer[m_ptr+2] == '*') { + *kind = Token_ptrmem; + return; + } + *kind = Token_arrow; + return; + } else if (m_buffer[m_ptr+1] == '-') { + *kind = Token_decr; + return; + } else if (m_buffer[m_ptr+1] == '=') { + *kind = Token_assign; + return; + } + break; + + case '.': + if (m_buffer[m_ptr+1] == '.' && m_buffer[m_ptr+2] == '.') { + *kind = Token_ellipsis; + return; + } else if (m_buffer[m_ptr+1] == '*') { + *kind = Token_ptrmem; + return; + } + break; + + } + + *kind = m_buffer[m_ptr++]; +} + +bool RppLexer::match(const char *buf, int len) +{ + if (m_len != len) + return false; + for (int i = 0; i < len; ++i) { + if(m_buffer[m_ptr + i] != buf[i]) + return false; + } + return true; +} + +void RppLexer::scanKeyword(int *kind) +{ + if(match("if", 2)) + *kind = Token_directive_if; + else if(match("elif", 4)) + *kind = Token_directive_elif; + else if(match("else", 4)) + *kind = Token_directive_else; + else if(match("line", 4)) + *kind = Token_directive_line; + else if(match("else", 4)) + *kind = Token_directive_else; + else if(match("line", 4)) + *kind = Token_directive_line; + else if(match("endif", 5)) + *kind = Token_directive_endif; + else if(match("ifdef", 5)) + *kind = Token_directive_ifdef; + else if(match("error", 5)) + *kind = Token_directive_error; + else if(match("undef", 5)) + *kind = Token_directive_undef; + else if(match("pragma", 6)) + *kind = Token_directive_pragma; + else if(match("ifndef", 6)) + *kind = Token_directive_ifndef; + else if(match("define", 6)) + *kind = Token_directive_define; + else if(match("include", 7)) + *kind = Token_directive_include; + else if(match("defined", 7)) + *kind = Token_defined; + else + *kind = Token_identifier; +} + +} //namespace Rpp + +QT_END_NAMESPACE diff --git a/tools/porting/src/rpplexer.h b/tools/porting/src/rpplexer.h new file mode 100644 index 0000000..1a2c0aa --- /dev/null +++ b/tools/porting/src/rpplexer.h @@ -0,0 +1,100 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef RPPLEXER_H +#define RPPLEXER_H + +#include "tokens.h" +#include "tokenengine.h" +#include <QByteArray> +#include <QVector> + +QT_BEGIN_NAMESPACE + +namespace Rpp { + +class RppLexer +{ +public: + + RppLexer(); + QVector<Type> lex(const TokenEngine::TokenContainer &tokenContainer); +private: + Type indentify(int pos, int length); + void setupScanTable(); + + void scanChar(int *kind); + void scanUnicodeChar(int *kind); + void scanNewline(int *kind); + void scanWhiteSpaces(int *kind); + void scanCharLiteral(int *kind); + void scanStringLiteral(int *kind); + void scanNumberLiteral(int *kind); + void scanIdentifier(int *kind); + void scanPreprocessor(int *kind); + void scanComment(int *kind); + void scanOperator(int *kind); + void scanKeyword(int *kind); + + bool match(const char *buf, int len); + typedef void (RppLexer::*scan_fun_ptr)(int *kind); + RppLexer::scan_fun_ptr s_scan_table[128+1]; + int s_attr_table[256]; + + enum + { + A_Alpha = 0x01, + A_Digit = 0x02, + A_Alphanum = A_Alpha | A_Digit, + A_Whitespace = 0x04 + }; + + const char *m_buffer; + int m_ptr; + int m_len; +}; + +} //namespace Rpp + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/rpptreeevaluator.cpp b/tools/porting/src/rpptreeevaluator.cpp new file mode 100644 index 0000000..fa6bde9 --- /dev/null +++ b/tools/porting/src/rpptreeevaluator.cpp @@ -0,0 +1,554 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "rpptreeevaluator.h" +#include <QChar> +#include <QtDebug> + +QT_BEGIN_NAMESPACE + +using namespace TokenEngine; +namespace Rpp { + +RppTreeEvaluator::RppTreeEvaluator() +{ + QByteArray text(" "); + TokenEngine::Token token; + token.start = 0; + token.length = 1; + QVector<TokenEngine::Token> tokenList; + tokenList.append(token); + TokenContainer newLineContainer(text, tokenList, new TokenEngine::GeneratedInfo()); + newlineSection= new TokenSection(newLineContainer, 0, 1); +} + +RppTreeEvaluator::~RppTreeEvaluator() +{ + delete newlineSection; +} + +TokenSectionSequence RppTreeEvaluator::evaluate(const Source *source, + DefineMap *activeDefinitions) +{ + m_tokenSections.clear(); + m_activeDefinitions = activeDefinitions; + evaluateSource(source); + return TokenSectionSequence(m_tokenSections); +} + +void RppTreeEvaluator::evaluateText(const Text *textLine) +{ + const int numTokens = textLine->count(); + const TokenContainer tokenContainer = textLine->text().tokenContainer(0); + + int t = 0; + int startTokenRun = 0; + while(t < numTokens) { + const Token *currentToken = textLine->token(t); + int currentContainerIndex = currentToken->index(); + //handle macro replacements + if(currentToken->toIdToken()) { + const int tokenIndex = currentToken->index(); + const QByteArray tokenText = tokenContainer.tempText(tokenIndex); + if(m_activeDefinitions->contains(tokenText)) { + //crate section + TokenSection section(tokenContainer, textLine->token(startTokenRun)->index(), t - startTokenRun); + m_tokenSections.append(section); + //evaluate macro + const int oldContainerIndex = currentContainerIndex; + TokenContainer evaluatedText = evaluateMacro(tokenContainer, currentContainerIndex); + TokenSection evalSection(evaluatedText, 0, evaluatedText.count()); + m_tokenSections.append(evalSection); + t += currentContainerIndex - oldContainerIndex; + startTokenRun = t; + } + ++t; + continue; + } + + //handle comments + if(currentToken->toLineComment() || currentToken->toMultiLineComment()) { + //create section + TokenSection section(tokenContainer, textLine->token(startTokenRun)->index(), t - startTokenRun ); + m_tokenSections.append(section); + t++; //skip comment + startTokenRun = t; + t++; + continue; + } + + // handle escaped newlines + if (currentContainerIndex + 1 < numTokens) { + const TokenTempRef tokenRef1 = tokenContainer.tokenTempRef(currentContainerIndex); + const TokenTempRef tokenRef2 = tokenContainer.tokenTempRef(currentContainerIndex + 1); + // This is i slight hack. We want to check if the next token is a newline token, + // but since we don't have any lexical info at this point we just check if it starts + // with \r or \n + if (tokenRef1.at(0) == '\\' && (tokenRef2.at(0) == '\n' || tokenRef2.at(0) == '\r')) { + //create section + TokenSection section(tokenContainer, textLine->token(startTokenRun)->index(), t - startTokenRun ); + m_tokenSections.append(section); + t += 2; + startTokenRun = t; + t++; + continue; + } + } + + t++; + } + //round up any tokens at the end and put them in a section + if(t - startTokenRun > 1) { + TokenSection section(tokenContainer, textLine->token(startTokenRun)->index(), t - startTokenRun ); + m_tokenSections.append(section); + } + + m_tokenSections.append(*newlineSection); +} + +/* + Evaluates and ifsection by selecting which one of the if-elif-else + groups and then evaling that. +*/ +void RppTreeEvaluator::evaluateIfSection(const IfSection *ifSection) +{ + ConditionalDirective *ifGroup = ifSection->ifGroup(); + if(evaluateCondition(ifGroup)) { + evaluateConditionalDirective(ifGroup); + return; + } + + QVector<ConditionalDirective *> elifGroups = ifSection->elifGroups(); + foreach(ConditionalDirective *elifGroup, elifGroups) { + if(evaluateCondition(elifGroup)) { + evaluateConditionalDirective(elifGroup); + return; + } + } + + ConditionalDirective *elseGroup = ifSection->elseGroup(); + if(elseGroup) + evaluateConditionalDirective(elseGroup); +} + +/* + Evaluate an IncludeDirective by evaluating the Source for the included + file. The source is found by emitting the includeCallback signal, which + must be handled outside RppTreeEvaluator. +*/ +void RppTreeEvaluator::evaluateIncludeDirective(const IncludeDirective *directive) +{ + Source *currentSource = getParentSource(directive); + IncludeType includeType = includeTypeFromDirective(directive); + Source *newSource = 0; + emit includeCallback(newSource, currentSource, QString::fromLatin1(directive->filename().constData()), includeType); + Q_ASSERT(newSource); // If you get an assert here you probably + // forgot to connect to the includeCallback signal + evaluateSource(newSource); +} + +void RppTreeEvaluator::evaluateDefineDirective(const DefineDirective *directive) +{ + m_tokenSections.append(*newlineSection); + m_activeDefinitions->insert(directive->identifier().fullText(), directive); +} + +void RppTreeEvaluator::evaluateUndefDirective(const UndefDirective *directive) +{ + m_tokenSections.append(*newlineSection); + const QByteArray text = directive->identifier().fullText(); + m_activeDefinitions->remove(text); +} + +/* + Evaluate the truth-value of an conditionalDirective +*/ +bool RppTreeEvaluator::evaluateCondition(const ConditionalDirective *conditionalDirective) +{ + if (IfDirective *ifDirective = conditionalDirective->toIfDirective()) + return (evaluateExpression(ifDirective->expression()) != 0); + if (ElifDirective *elifDirective = conditionalDirective->toElifDirective()) + return (evaluateExpression(elifDirective->expression()) != 0); + if (IfdefDirective *ifdefDirective = conditionalDirective->toIfdefDirective()) + return m_activeDefinitions->contains(ifdefDirective->identifier().fullText()); + if (IfndefDirective *ifndefDirective = conditionalDirective->toIfndefDirective()) + return !m_activeDefinitions->contains(ifndefDirective->identifier().fullText()); + else + return false; //error! +} + +/* + Recursively evaluates an Expression +*/ +int RppTreeEvaluator::evaluateExpression(Expression *expression) +{ + if (IntLiteral *e = expression->toIntLiteral()) { + return e->value(); + } else if (StringLiteral *e = expression->toStringLiteral()) { + return e->value().size(); + } else if (MacroReference *e = expression->toMacroReference()) { + switch(e->type()) { + case MacroReference::DefinedRef: { + return m_activeDefinitions->contains(e->name().fullText()) ? 1 : 0; + } case MacroReference::ValueRef: { + const QByteArray identifier = e->name().fullText(); + if (m_activeDefinitions->contains(identifier)) { + int token = e->name().containerIndex(0); + TokenContainer value = evaluateMacro(e->name().tokenContainer(token), token); + return QString(QLatin1String(value.fullText())).toInt(0, 0); + } else { + return 0; // error + } + } + default: Q_ASSERT(0); + } + } else if (MacroFunctionReference *e = expression->toMacroFunctionReference()) { + Q_UNUSED(e); + //TODO handle MacroFunctionReference +// DefineDirective *def = e->findDefinition(e->name()); +// Q_ASSERT(def->toMacroFunctionDefinition()); +// qWarning("not implemented yet"); + return 0; + } else if (UnaryExpression *e = expression->toUnaryExpression()) { + int result = evaluateExpression(e->expression()); + switch (e->op()) { + case '+': return + result; + case '-': return - result; + case '!': return ! result; + case '~': return ~ result; + default: Q_ASSERT(0); + } + } else if (BinaryExpression *e = expression->toBinaryExpression()) { + int v1 = evaluateExpression(e->leftExpression()); + int v2 = evaluateExpression(e->rightExpression()); + + switch (e->op()) { + case '/': { return v2 ? v1 / v2 : 0; } //avoid division by zero + case '*': return v1 * v2; + case '%': { return v2 ? v1 % v2 : 0; } //avoid modulus by zero + case '+': return v1 + v2; + case '-': return v1 - v2; + case '<': return v1 < v2; + case '>': return v1 > v2; + case '&': return v1 & v2; + case '^': return v1 ^ v2; + case '|': return v1 | v2; + case Expression::LtEqOp: return v1 <= v2; + case Expression::GtEqOp: return v1 >= v2; + case Expression::EqOp: return v1 == v2; + case Expression::NotEqOp: return v1 != v2; + case Expression::AndOp: return v1 && v2; + case Expression::OrOp: return v1 || v2; + case Expression::LShiftOp: return v1 << v2; + case Expression::RShiftOp: return v1 >> v2; + default: Q_ASSERT(0); + } + + } else if ( ConditionalExpression *e = expression->toConditionalExpression()){ + return e->condition() ? evaluateExpression(e->leftExpression()) : evaluateExpression(e->rightExpression()); + } + return 0; +} +/* + Expands a macro at index identiferTokenIndex in tokenContainer. Returns + the expanded macro text, and updates identiferTokenIndex to point after + the last token consumed. + + Given the construct 'FN(a)', the '(a)' part will be consumed if FN is + defined to be a macro function, but not if it is an ordenary macro. +*/ +TokenContainer RppTreeEvaluator::evaluateMacro(TokenContainer tokenContainer, int &identiferTokenIndex) +{ + QByteArray identifierText = tokenContainer.text(identiferTokenIndex); + if(!m_activeDefinitions->contains(identifierText)) + return TokenContainer(); + + const Rpp::DefineDirective *directive = m_activeDefinitions->value(identifierText); + Q_ASSERT(directive); + + // To prevent infinite recursive macro expansions, the skip set contains + // a set of identifers already seen. + QSet<QByteArray> skip; + + if(directive->toMacroDefinition()) { + ++identiferTokenIndex; + QVector<TokenEngine::Token> tokenList; + tokenList.append(TokenEngine::Token(0, identifierText.count())); + return evaluateMacroInternal(skip, TokenContainer(identifierText, tokenList)); + } else if (Rpp::MacroFunctionDefinition *macro = directive->toMacroFunctionDefinition()) { + MacroFunctionParser macroFunctionParser(tokenContainer, identiferTokenIndex); + if (macroFunctionParser.isValid() && macro->parameters().count() == macroFunctionParser.argumentCount()) { + TokenContainer macroFunctionContainer = + TokenEngine::copy(tokenContainer, identiferTokenIndex, macroFunctionParser.tokenCount()); + identiferTokenIndex += macroFunctionParser.tokenCount(); + return evaluateMacroInternal(skip, macroFunctionContainer); + } else { + // Error case, such as calling a macro function with the wrong number of parameters, + // or calling a macro function witout a parameter list. + return TokenEngine::copy(tokenContainer, identiferTokenIndex++, 1); + } + } + return TokenContainer(); +} + +/* + Recursively expands all macroes in macroInvokeTokens, returns a + TokenContainer with the new tokens. +*/ +TokenEngine::TokenContainer RppTreeEvaluator::evaluateMacroInternal(QSet<QByteArray> skip, TokenEngine::TokenContainer macroInvokeTokens) +{ + bool changed = false; + QByteArray tokenText; + QVector<TokenEngine::Token> tokenList; + const int numTokens = macroInvokeTokens.count(); + + for (int t = 0; t < numTokens; ++t) { + const QByteArray identifierText = macroInvokeTokens.text(t); + + // if the current token text is not a part of a macro definition we just copy it. + if (!m_activeDefinitions->contains(identifierText)) { + tokenList.append(TokenEngine::Token(tokenText.count(), identifierText.count())); + tokenText.append(identifierText); + continue; + } + + // If the token text is in the skip list we copy it. + if (skip.contains(identifierText)) { + tokenList.append(TokenEngine::Token(tokenText.count(), identifierText.count())); + tokenText.append(identifierText); + continue; + } + + skip.insert(identifierText); + changed = true; + const Rpp::DefineDirective *directive = m_activeDefinitions->value(identifierText); + Q_ASSERT(directive); + // if it is a macro, we copy in the replacement list. + if (Rpp::MacroDefinition *macro = directive->toMacroDefinition()) { + TokenList replacementList = macro->replacementList(); + TokenEngine::copy(tokenText, tokenList, replacementList, 0, replacementList.count()); + + // To avoid infinite loops, set changed to false if the replacement + // text is identical to the identifier text. + if (replacementList.fullText().simplified() == identifierText.simplified()) + changed = false; + } else if (Rpp::MacroFunctionDefinition *macro = directive->toMacroFunctionDefinition()) { + TokenList replacementList = macro->replacementList(); + TokenList paramenterList = macro->parameters(); + + MacroFunctionParser macroFunctionParser(macroInvokeTokens, t); + if (macroFunctionParser.isValid() && macro->parameters().count() == macroFunctionParser.argumentCount()) { + t += macroFunctionParser.tokenCount(); + // For each token in the replacement list: If the token matches a + // token in the parameter list, replace it with the + // corresponding argument tokens from the argument list. + for (int replacementToken = 0; replacementToken < replacementList.count(); ++replacementToken) { + const QByteArray replacementTokenText = replacementList.text(replacementToken); + bool replaced = false; + for (int parameterToken = 0; parameterToken < paramenterList.count(); ++parameterToken) { + const QByteArray parameterTokenText = paramenterList.text(parameterToken); + if (parameterTokenText == replacementTokenText) { + TokenSection argumentTokenSection = macroFunctionParser.argument(parameterToken); + TokenEngine::copy(tokenText, tokenList, argumentTokenSection, 0, argumentTokenSection.count()); + replaced = true; + break; + } + } + if (! replaced) { + TokenEngine::copy(tokenText, tokenList, replacementList, replacementToken, 1); + } + } + } + } + } + if (!changed) + return macroInvokeTokens; + return evaluateMacroInternal(skip, TokenContainer(tokenText, tokenList)); +} + +TokenContainer RppTreeEvaluator::cloneTokenList(const TokenList &list) +{ + QByteArray text; + QVector<TokenEngine::Token> tokens; + int index = 0; + for (int t = 0; t<list.count(); ++t) { + const QByteArray tokenText = list.text(t); + const int textLength = tokenText.count(); + text += tokenText; + TokenEngine::Token token; + token.start = index; + token.length = textLength; + tokens.append(token); + index += textLength; + } + TokenContainer container(text, tokens, new GeneratedInfo()); + return container; +} + +/* + Returns the parent Source for a given item. +*/ +Source *RppTreeEvaluator::getParentSource(const Item *item) const +{ + Q_ASSERT(item); + while(item->toSource() == 0) { + item = item->parent(); + Q_ASSERT(item); + } + + return item->toSource(); +} +/* + We have two IncludeType enums, one in IncludeDirective and one in + RppTreeEvaluator. This function translates between them. +*/ +RppTreeEvaluator::IncludeType RppTreeEvaluator::includeTypeFromDirective( + const IncludeDirective *includeDirective) const +{ + if(includeDirective->includeType() == IncludeDirective::QuoteInclude) + return QuoteInclude; + else + return AngleBracketInclude; +} + +/* + The MacrofunctionParser class is used to parse a macro function call (not + a macro function definition.) + + startToken should give the token index for the identifier token for the macro function. +*/ +MacroFunctionParser::MacroFunctionParser(const TokenEngine::TokenContainer &tokenContainer, int startToken) +:m_tokenContainer(tokenContainer) +,m_startToken(startToken) +,m_numTokens(0) +,m_valid(false) +{ + int tokenIndex = startToken; + ++tokenIndex; //skip identifier token + int parenthesisCount = 0; + int currentArgumentStartToken = tokenIndex; + + // Parse argument tokens, add arguments to the m_arguments list. + // Arguments may consist of multiple tokens. Parenthesis in arguments + // are allowed, as long as they match. Inside a pair of argument + // parenthesis, ',' no longer signals a new argument. For example, + // FN((a,b)) is legal and contains one argument. + while(tokenIndex < tokenContainer.count()) { + QByteArray currentText = tokenContainer.text(tokenIndex); + ++tokenIndex; + if (currentText == "(") { + ++parenthesisCount; + if (parenthesisCount == 1) { + // first parenthesis + currentArgumentStartToken = tokenIndex; + continue; + } + } + if (currentText == ")") { + --parenthesisCount; + if (parenthesisCount == 0) { + //end of argument + m_arguments.append(TokenSection(tokenContainer, currentArgumentStartToken, tokenIndex - currentArgumentStartToken - 1)); + currentArgumentStartToken = tokenIndex; + //end of argument list + break; + } + } + if (currentText == "," && parenthesisCount == 1) { + //end of argument + m_arguments.append(TokenSection(tokenContainer, currentArgumentStartToken, tokenIndex - currentArgumentStartToken - 1)); + currentArgumentStartToken = tokenIndex; + continue; + } + + if (QChar::fromLatin1(currentText.at(0)).isSpace()) { + continue; + } + + // If we get here without having seen a paranthesis we have a syntax + // error in the macro function call. + if (parenthesisCount == 0) { + parenthesisCount = -1; + break; + } + } + m_numTokens = tokenIndex - startToken; + m_valid = (parenthesisCount == 0); +} + +/* + Returns true if the MacroFunctionParser contains a valid macro function +*/ +bool MacroFunctionParser::isValid() +{ + return m_valid; +} + +/* + Returns the number of tokens in the tokenContainer that is covered by + the macro function. +*/ +int MacroFunctionParser::tokenCount() +{ + return m_numTokens; +} + +/* + Returns the number of arguments for the macro function. +*/ +int MacroFunctionParser::argumentCount() +{ + return m_arguments.count(); +} + +/* + Returns the tokens for the argument given by argumentIndex. +*/ +TokenSection MacroFunctionParser::argument(int argumentIndex) +{ + Q_ASSERT(argumentIndex < m_arguments.count()); + return m_arguments.at(argumentIndex); +} + +} //namespace Rpp + +QT_END_NAMESPACE diff --git a/tools/porting/src/rpptreeevaluator.h b/tools/porting/src/rpptreeevaluator.h new file mode 100644 index 0000000..0dec745 --- /dev/null +++ b/tools/porting/src/rpptreeevaluator.h @@ -0,0 +1,117 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef RPPTREEEVALUATOR_H +#define RPPTREEEVALUATOR_H + +#include "tokenengine.h" +#include "rpp.h" +#include "rpptreewalker.h" +#include <QObject> +#include <QList> +#include <QHash> +#include <QSet> + +QT_BEGIN_NAMESPACE + +namespace Rpp { + +class DefineMap : public QHash<QByteArray, const DefineDirective *> +{ + +}; + +class RppTreeEvaluator: public QObject, public RppTreeWalker +{ +Q_OBJECT +public: + RppTreeEvaluator(); + ~RppTreeEvaluator(); + TokenEngine::TokenSectionSequence evaluate(const Source *source, + DefineMap *activedefinitions); + enum IncludeType {QuoteInclude, AngleBracketInclude}; +signals: + void includeCallback(Rpp::Source *&includee, + const Rpp::Source *includer, + const QString &filename, + Rpp::RppTreeEvaluator::IncludeType includeType); +protected: + void evaluateIncludeDirective(const IncludeDirective *directive); + void evaluateDefineDirective(const DefineDirective *directive); + void evaluateUndefDirective(const UndefDirective *directive); + void evaluateIfSection(const IfSection *ifSection); + void evaluateText(const Text *text); + bool evaluateCondition(const ConditionalDirective *conditionalDirective); + int evaluateExpression(Expression *expression); + + TokenEngine::TokenContainer evaluateMacro(TokenEngine::TokenContainer tokenContainer, int &identiferTokenIndex); + TokenEngine::TokenContainer evaluateMacroInternal(QSet<QByteArray> skip, TokenEngine::TokenContainer tokenContainer); + TokenEngine::TokenContainer cloneTokenList(const TokenEngine::TokenList &list); + Source *getParentSource(const Item *item) const; + IncludeType includeTypeFromDirective( + const IncludeDirective *includeDirective) const; +private: + QVector<TokenEngine::TokenSection> m_tokenSections; + DefineMap *m_activeDefinitions; + TokenEngine::TokenSection *newlineSection; +}; + +class MacroFunctionParser +{ +public: + MacroFunctionParser(const TokenEngine::TokenContainer &tokenContainer, int startToken); + bool isValid(); + int tokenCount(); + int argumentCount(); + TokenEngine::TokenSection argument(int argumentIndex); +private: + const TokenEngine::TokenContainer &m_tokenContainer; + const int m_startToken; + int m_numTokens; + bool m_valid; + QVector<TokenEngine::TokenSection> m_arguments; +}; + +}//namespace Rpp + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/rpptreewalker.cpp b/tools/porting/src/rpptreewalker.cpp new file mode 100644 index 0000000..256b10a --- /dev/null +++ b/tools/porting/src/rpptreewalker.cpp @@ -0,0 +1,166 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "rpptreewalker.h" + +QT_BEGIN_NAMESPACE + +namespace Rpp { + +void RppTreeWalker::evaluateItem(const Item *item) +{ + if(!item) + return; + if (Source *source = item->toSource()) + evaluateSource(source); + else if (Directive *directive = item->toDirective()) + evaluateDirective(directive); + else if (IfSection *ifSection = item->toIfSection()) + evaluateIfSection(ifSection); + else if (Text *text = item->toText()) + evaluateText(text); +} + +void RppTreeWalker::evaluateItemComposite(const ItemComposite *itemComposite) +{ + if (!itemComposite) + return; + for (int i = 0; i < itemComposite->count(); ++i) { + evaluateItem(itemComposite->item(i)); + } +} + +void RppTreeWalker::evaluateSource(const Source *source) +{ + evaluateItemComposite(source->toItemComposite()); +} + +void RppTreeWalker::evaluateDirective(const Directive *directive) +{ + if (!directive) + return; + if (EmptyDirective *dir = directive->toEmptyDirective()) + evaluateEmptyDirective(dir); + else if (ErrorDirective *dir = directive->toErrorDirective()) + evaluateErrorDirective(dir); + else if (PragmaDirective *dir = directive->toPragmaDirective()) + evaluatePragmaDirective(dir); + else if (IncludeDirective *dir = directive->toIncludeDirective()) + evaluateIncludeDirective(dir); + else if (DefineDirective *dir = directive->toDefineDirective()) + evaluateDefineDirective(dir); + else if (UndefDirective *dir = directive->toUndefDirective()) + evaluateUndefDirective(dir); + else if (LineDirective *dir = directive->toLineDirective()) + evaluateLineDirective(dir); + else if (NonDirective *dir = directive->toNonDirective()) + evaluateNonDirective(dir); + else if (NonDirective *dir = directive->toNonDirective()) + evaluateNonDirective(dir); + else if (ConditionalDirective *dir = directive->toConditionalDirective()) + evaluateConditionalDirective(dir); +} + +/* + This function evaluates all the branches of an IfSection. You should + override it if you want to only evaluate the "correct" branch. +*/ +void RppTreeWalker::evaluateIfSection(const IfSection *ifSection) +{ + if (!ifSection) + return; + evaluateItemComposite(ifSection->toItemComposite()); +} + +void RppTreeWalker::evaluateConditionalDirective(const ConditionalDirective *conditionalDirective) +{ + if (!conditionalDirective) + return; + if (IfdefDirective *dir = conditionalDirective->toIfdefDirective()) + evaluateIfdefDirective(dir); + else if (IfndefDirective *dir = conditionalDirective->toIfndefDirective()) + evaluateIfndefDirective(dir); + else if (IfDirective *dir = conditionalDirective->toIfDirective()) + evaluateIfDirective(dir); + else if (ElifDirective *dir = conditionalDirective->toElifDirective()) + evaluateElifDirective(dir); + else if (ElseDirective *dir = conditionalDirective->toElseDirective()) + evaluateElseDirective(dir); +} + +void RppTreeWalker::evaluateIfdefDirective(const IfdefDirective *directive) +{ + if (!directive) + return; + evaluateItemComposite(directive->toItemComposite()); +} + +void RppTreeWalker::evaluateIfndefDirective(const IfndefDirective *directive) +{ + if (!directive) + return; + evaluateItemComposite(directive->toItemComposite()); +} + +void RppTreeWalker::evaluateIfDirective(const IfDirective *directive) +{ + if (!directive) + return; + evaluateItemComposite(directive->toItemComposite()); +} + +void RppTreeWalker::evaluateElifDirective(const ElifDirective *directive) +{ + if (!directive) + return; + evaluateItemComposite(directive->toItemComposite()); +} + +void RppTreeWalker::evaluateElseDirective(const ElseDirective *directive) +{ + if (!directive) + return; + evaluateItemComposite(directive->toItemComposite()); +} + +} + +QT_END_NAMESPACE diff --git a/tools/porting/src/rpptreewalker.h b/tools/porting/src/rpptreewalker.h new file mode 100644 index 0000000..2f89ec3 --- /dev/null +++ b/tools/porting/src/rpptreewalker.h @@ -0,0 +1,85 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef RPPTREEWALKER_H +#define RPPTREEWALKER_H + +#include "rpp.h" + +QT_BEGIN_NAMESPACE + +namespace Rpp { + +class RppTreeWalker +{ +public: + virtual ~RppTreeWalker(){}; + virtual void evaluateItem(const Item *item); + virtual void evaluateItemComposite(const ItemComposite *itemComposite); + virtual void evaluateSource(const Source *source); + virtual void evaluateDirective(const Directive *directive); + virtual void evaluateIfSection(const IfSection *ifSection); + virtual void evaluateConditionalDirective(const ConditionalDirective *conditionalDirective); + + virtual void evaluateText(const Text *textLine) {Q_UNUSED(textLine);} + virtual void evaluateEmptyDirective(const EmptyDirective *directive) {Q_UNUSED(directive);} + virtual void evaluateErrorDirective(const ErrorDirective *directive) {Q_UNUSED(directive);} + virtual void evaluatePragmaDirective(const PragmaDirective *directive) {Q_UNUSED(directive);} + virtual void evaluateIncludeDirective(const IncludeDirective *directive) {Q_UNUSED(directive);} + virtual void evaluateDefineDirective(const DefineDirective *directive) {Q_UNUSED(directive);} + virtual void evaluateUndefDirective(const UndefDirective *directive) {Q_UNUSED(directive);} + virtual void evaluateLineDirective(const LineDirective *directive) {Q_UNUSED(directive);} + virtual void evaluateNonDirective(const NonDirective *directive) {Q_UNUSED(directive);} + + virtual void evaluateIfdefDirective(const IfdefDirective *directive); + virtual void evaluateIfndefDirective(const IfndefDirective *directive); + virtual void evaluateIfDirective(const IfDirective *directive); + virtual void evaluateElifDirective(const ElifDirective *directive); + virtual void evaluateElseDirective(const ElseDirective *directive); + + virtual void evaluateEndifDirective(const EndifDirective *directive) {Q_UNUSED(directive);} +}; + +} + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/semantic.cpp b/tools/porting/src/semantic.cpp new file mode 100644 index 0000000..886ffb9 --- /dev/null +++ b/tools/porting/src/semantic.cpp @@ -0,0 +1,1227 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "smallobject.h" +#include "tokenengine.h" +#include "semantic.h" +#include <QtDebug> +#include <QString> +#include <QRegExp> + +QT_BEGIN_NAMESPACE + +using namespace TokenStreamAdapter; +using namespace TokenEngine; +using namespace CodeModel; + +Semantic::Semantic(CodeModel::NamespaceScope *globalScope, + TokenStreamAdapter::TokenStream *tokenStream, + TypedPool<CodeModel::Item> *storage) +{ + m_storage = storage; + m_tokenStream = tokenStream; + + m_currentAccess = CodeModel::Member::Public; + m_inSlots = false; + m_inSignals = false; + m_inStorageSpec = false; + m_inTypedef = false; + + globalScope->setName("::"); + currentScope.push(globalScope); + + //create global UnknownType and UnknownTypeMember + UnknownType *type = Create<UnknownType>(m_storage); + type->setName("__UnknownType"); + globalScope->addType(type); + type->setParent(globalScope); + + m_sharedUnknownMember = Create<TypeMember>(m_storage); + m_sharedUnknownMember->setNameToken(TokenRef()); + m_sharedUnknownMember->setName("Unknown"); + m_sharedUnknownMember->setType(type); + globalScope->addMember(m_sharedUnknownMember); + m_sharedUnknownMember->setParent(globalScope); + +} + +void Semantic::parseAST(TranslationUnitAST *node) +{ + TreeWalker::parseTranslationUnit(node); +} + + +void Semantic::parseLinkageSpecification(LinkageSpecificationAST *ast) +{ + if(!ast) + return; + int inStorageSpec = m_inStorageSpec; + m_inStorageSpec = true; + TreeWalker::parseLinkageSpecification(ast); + m_inStorageSpec = inStorageSpec; +} + +void Semantic::parseNamespace(NamespaceAST *ast) +{ + CodeModel::NamespaceScope *parent = currentScope.top()->toNamespaceScope(); + if(!parent->toNamespaceScope()) { + emit error("Error in Semantic::parseNamespace: parent scope was not a namespace"); + return; + } + + QByteArray nsName; + if (!ast->namespaceName() || textOf(ast->namespaceName()).isEmpty()){ + nsName = "(__QT_ANON_NAMESPACE)"; + } else { + nsName = textOf(ast->namespaceName()); + } + + CodeModel::NamespaceScope *namespaceScope = 0; + + // Look up namespace scope in case it is already defined. + // (Unlike classes, C++ namespaces are "open" and can be added to.) + CodeModel::Scope *scope = parent->scopes().value(nsName); + if (scope) + namespaceScope = scope->toNamespaceScope(); + + // Create new namespace if not found. + if (!namespaceScope) { + namespaceScope = CodeModel::Create<CodeModel::NamespaceScope>(m_storage); + namespaceScope->setName(nsName); + parent->addScope(namespaceScope); + + NamespaceMember *namespaceMember = Create<NamespaceMember>(m_storage); + namespaceMember->setNameToken(tokenRefFromAST(ast->namespaceName())); + namespaceMember->setName(nsName); + namespaceMember->setNamespaceScope(namespaceScope); + currentScope.top()->addMember(namespaceMember); + namespaceMember->setParent(currentScope.top()); + } + + currentScope.push(namespaceScope); + TreeWalker::parseNamespace(ast); + currentScope.pop(); +} + +void Semantic::parseClassSpecifier(ClassSpecifierAST *ast) +{ + if (!ast->name()){ + return; + } + + QByteArray kind = textOf(ast->classKey()); + if (kind == "class") + m_currentAccess = CodeModel::Member::Private; + else // kind =="struct" + m_currentAccess = CodeModel::Member::Public; + + QByteArray className = textOf(ast->name()->unqualifiedName()); + + //create ClassScope + CodeModel::ClassScope *klass = CodeModel::Create<CodeModel::ClassScope>(m_storage); + klass->setName(className); + currentScope.top()->addScope(klass); + + //create ClassType + CodeModel::ClassType *type = CodeModel::Create<CodeModel::ClassType>(m_storage); + type->setScope(klass); + currentScope.top()->addType(type); + type->setParent(currentScope.top()); + + //create TypeMember + CodeModel::TypeMember *typeMember = CodeModel::Create<CodeModel::TypeMember>(m_storage); + typeMember->setNameToken(tokenRefFromAST(ast->name()->unqualifiedName())); + typeMember->setName(className); + typeMember->setType(type); + currentScope.top()->addMember(typeMember); + typeMember->setParent(currentScope.top()); + + currentScope.push(klass); + if (ast->baseClause()) + parseBaseClause(ast->baseClause(), klass); + + //TreeWalker::parseClassSpecifier(ast); + parseNode(ast->winDeclSpec()); + parseNode(ast->classKey()); + parseNode(ast->baseClause()); + + // Here's the trick for parsing c++ classes: + // All inline function definitions must be interpreted as if they were + // written after any other declarations in the class. + QList<DeclarationAST *> functionDefinitions; + if (ast->declarationList()) + foreach(DeclarationAST *decl, *ast->declarationList()) { + if(decl->nodeType() == NodeType_FunctionDefinition) + functionDefinitions.append(decl); + else + parseNode(decl); + } + foreach(DeclarationAST *decl, functionDefinitions) + parseNode(decl); + + currentScope.pop(); +} +/* + Parse a class, struct or enum forward decalration. +*/ +void Semantic::parseElaboratedTypeSpecifier(ElaboratedTypeSpecifierAST *node) +{ + if (!node) + return; + AST *kind = node->kind(); + if (!kind) + return; + + const QByteArray kindText = textOf(kind); + const QByteArray nameText = textOf(node->name()); + + // Don't do anything if the class, struct or enum has already been declared or defined. + if (lookupNameInScope(currentScope.top(), node->name()).count() > 0) + return; + + if (kindText == "class" || kindText == "struct") { + // Create ClassType. + CodeModel::ClassType *type = CodeModel::Create<CodeModel::ClassType>(m_storage); + type->setScope(0); + currentScope.top()->addType(type); + type->setParent(currentScope.top()); + + // Create TypeMember. + CodeModel::TypeMember *typeMember = CodeModel::Create<CodeModel::TypeMember>(m_storage); + typeMember->setNameToken(tokenRefFromAST(node->name()->unqualifiedName())); + typeMember->setName(nameText); + typeMember->setType(type); + currentScope.top()->addMember(typeMember); + typeMember->setParent(currentScope.top()); + } else if (kindText == "enum") { + //create a Type + CodeModel::EnumType *enumType = CodeModel::Create<CodeModel::EnumType>(m_storage); + enumType->setName(nameText); + currentScope.top()->addType(enumType); + enumType->setParent(currentScope.top()); + + //create a TypeMember + CodeModel::TypeMember *typeMember = CodeModel::Create<CodeModel::TypeMember>(m_storage); + if(node->name()) + typeMember->setNameToken(tokenRefFromAST(node->name()->unqualifiedName())); + typeMember->setName(nameText); + typeMember->setType(enumType); + currentScope.top()->addMember(typeMember); + typeMember->setParent(currentScope.top()); + } +} + +void Semantic::parseSimpleDeclaration(SimpleDeclarationAST *ast) +{ + TypeSpecifierAST *typeSpec = ast->typeSpec(); + InitDeclaratorListAST *declarators = ast->initDeclaratorList(); + + if (typeSpec) + parseTypeSpecifier(typeSpec); + + if (declarators){ + List<InitDeclaratorAST*> l = *declarators->initDeclaratorList(); + + foreach (InitDeclaratorAST *current, l) { + parseDeclaration(ast->functionSpecifier(), ast->storageSpecifier(), typeSpec, current); + } + } +} + +void Semantic::parseDeclaration(AST *funSpec, AST *storageSpec, TypeSpecifierAST *typeSpec, InitDeclaratorAST *decl) +{ + if (m_inStorageSpec) + return; + + if(!decl) + return; + + DeclaratorAST *d = decl->declarator(); + if (!d) + return; + + if (!d->subDeclarator() && d->parameterDeclarationClause()) { + parseFunctionDeclaration(funSpec, storageSpec, typeSpec, decl); + return; + } + if(!typeSpec || !typeSpec->name()) + return; + + DeclaratorAST *t = d; + while (t && t->subDeclarator()) + t = t->subDeclarator(); + + QByteArray id; + if (t && t->declaratorId() && t->declaratorId()->unqualifiedName()) + id = textOf(t->declaratorId()->unqualifiedName()); + + if (!t || !t->declaratorId() || !t->declaratorId()->unqualifiedName()) + return; + AST *nameAST = t->declaratorId()->unqualifiedName(); + QByteArray name = textOf(nameAST); + + + if (!scopeOfDeclarator(d, QList<QByteArray>()).isEmpty()){ + return; + } + + //Check if this is possibly a function call by searching for '(' and ')' + const QByteArray declText = textOf(decl); + if (declText.contains("(") && declText.contains(")")) { + if (decl->declarator() && decl->declarator()->subDeclarator()) { + + NameAST * name = decl->declarator()->subDeclarator()->declaratorId(); + if (name) + parseNameUse(name); + return; + } + } + + //create VariableMember + CodeModel::VariableMember *variableMember = CodeModel::Create<CodeModel::VariableMember>(m_storage); + variableMember->setNameToken(tokenRefFromAST(nameAST)); + variableMember->setName(name); + variableMember->setAccess(m_currentAccess); + variableMember->setParent(currentScope.top()); + currentScope.top()->addMember(variableMember); + + //look up type of variableMember, + + TypeMember *typeMember = typeLookup(currentScope.top(), typeSpec->name()); + if(typeMember) { + variableMember->setType(typeMember->type()); + } else { + QByteArray text = typeOfDeclaration(typeSpec, d); + CodeModel::UnknownType *type = CodeModel::Create<CodeModel::UnknownType>(m_storage); + type->setName(text); + variableMember->setType(type); + } + + if (decl) + parseNode(decl->initializer()); + +} + +void Semantic::parseFunctionDeclaration(AST *funSpec, AST *storageSpec, + TypeSpecifierAST * typeSpec, InitDeclaratorAST * initDeclarator) +{ + bool isFriend = false; + bool isVirtual = false; + bool isStatic = false; + bool isInline = false; + bool isPure = initDeclarator->initializer() != 0; + + if (funSpec){ + List<AST*> l = *funSpec->children(); + foreach (AST *current, l) { + QByteArray text = textOf(current); + if (text == "virtual") isVirtual = true; + else if (text == "inline") isInline = true; + } + } + + if (storageSpec){ + List<AST*> l = *storageSpec->children(); + foreach (AST *current, l) { + QByteArray text = textOf(current); + if (text == "friend") isFriend = true; + else if (text == "static") isStatic = true; + } + } + DeclaratorAST *declarator = initDeclarator->declarator(); + if(!declarator || !declarator->declaratorId()) + return; + AST *nameAST = declarator->declaratorId()->unqualifiedName(); + QByteArray name = textOf(nameAST); + + CodeModel::FunctionMember *method = CodeModel::Create<CodeModel::FunctionMember>(m_storage); + method->setNameToken(tokenRefFromAST(nameAST)); + method->setName(name); + method->setAccess(m_currentAccess); + method->setStatic(isStatic); + method->setVirtual(isVirtual); + method->setAbstract(isPure); + + parseFunctionArguments(declarator, method); + + if (m_inSignals) + method->setSignal(true); + + if (m_inSlots) + method->setSlot(true); + + method->setConstant(declarator->constant() != 0); + + QByteArray text = typeOfDeclaration(typeSpec, declarator); + if (!text.isEmpty()) { + CodeModel::UnknownType *type = CodeModel::Create<CodeModel::UnknownType>(m_storage); + type->setName(text); + method->setReturnType(type); + } + + method->setParent(currentScope.top()); + currentScope.top()->addMember(method); +} + + +void Semantic::parseBaseClause(BaseClauseAST * baseClause, CodeModel::ClassScope *klass) +{ + if(!baseClause) + return; + if(!klass) + return; + List<BaseSpecifierAST*> *l = baseClause->baseSpecifierList(); + if (!l) + return; + foreach (BaseSpecifierAST *baseSpecifier, *l) { + QByteArray baseName; + if (!baseSpecifier->name()) + continue; + + // Look up a class with the correct name. + QList<Member *> candidates = nameLookup(klass, baseSpecifier->name()); + if (candidates.count() == 1 ) { + Member *member = candidates.at(0); + Q_ASSERT(member); + TypeMember *typeMember = member->toTypeMember(); + if (typeMember) { + Q_ASSERT(typeMember->type()); + ClassType *classType = typeMember->type()->toClassType(); + if (classType) { + klass->addBaseClass(classType); + } + } + } + } +} +void Semantic::parseFunctionArguments(const DeclaratorAST *declarator, CodeModel::FunctionMember *method) +{ + if(!declarator || !method) + return; + + ParameterDeclarationClauseAST *clause = declarator->parameterDeclarationClause(); + + if (clause && clause->parameterDeclarationList()){ + ParameterDeclarationListAST *params = clause->parameterDeclarationList(); + List<ParameterDeclarationAST*> *l = params->parameterList(); + if (!l) + return; + foreach (ParameterDeclarationAST *param, *l) { + CodeModel::Argument *arg = CodeModel::Create<CodeModel::Argument>(m_storage); + arg->setParent(method); + + if (param->declarator()){ + QByteArray text = declaratorToString(param->declarator(), QByteArray(), true); + if(param->declarator()->declaratorId()) + arg->setNameToken(tokenRefFromAST(param->declarator()->declaratorId()->unqualifiedName())); + if (!text.isEmpty()) + arg->setName(text); + } + + QByteArray tp = typeOfDeclaration(param->typeSpec(), param->declarator()); + if (!tp.isEmpty()) { + CodeModel::UnknownType *type = CodeModel::Create<CodeModel::UnknownType>(m_storage); + type->setName(tp); + arg->setType(type); + } + + method->addArgument(arg); + } + } +} + +// using directive (using namespace A) +void Semantic::parseUsingDirective(UsingDirectiveAST *ast) +{ + QByteArray qualifiedname = textOf(ast->name()); + QByteArray name = textOf(ast->name()->unqualifiedName()); + + //look up target namespace name + QList<Member *> memberList = nameLookup(currentScope.top(), ast->name()); + + NamespaceScope *targetNamespace = 0; + + // search for namespace in member list. + QList<Member *>::ConstIterator it = memberList.constBegin(); + while(it != memberList.constEnd()) { + if (NamespaceMember *namespaceMember = (*it)->toNamespaceMember()) { + targetNamespace = namespaceMember->namespaceScope(); + break; + } + ++it; + } + + if (targetNamespace == 0) + return; + + // Find the insertion namespace, which is the first common + // ancesotor namespace for the current scope and the target namespace + + // currentScope might be a block scope, find its first namespace parent + CodeModel::Scope *currentParent = currentScope.top(); + while (currentParent->toNamespaceScope() == 0) { + currentParent = currentParent->parent(); + } + + CodeModel::Scope *namespaceA = currentParent; + while (namespaceA != 0) { + CodeModel::Scope *namespaceB = targetNamespace; + while (namespaceB != 0) { + if (namespaceB == namespaceA) + break; + namespaceB = namespaceB->parent(); + } + if (namespaceB == namespaceA) + break; + namespaceA = namespaceA->parent(); + } + + if (namespaceA == 0 || namespaceA->toNamespaceScope() == 0) + return; + + NamespaceScope *insertionNamespace = namespaceA->toNamespaceScope(); + + // Create using directive link + UsingDirectiveLink *usingDirectiveLink = Create<UsingDirectiveLink>(m_storage); + usingDirectiveLink->setParent(currentScope.top()); + usingDirectiveLink->setTargetNamespace(targetNamespace); + usingDirectiveLink->setInsertionNamespace(insertionNamespace); + + // add it to current namespace + if (NamespaceScope *namespaceScope = currentScope.top()->toNamespaceScope()) + namespaceScope->addUsingDirectiveLink(usingDirectiveLink); + else if (BlockScope *blockScope = currentScope.top()->toBlockScope()) + blockScope->addUsingDirectiveLink(usingDirectiveLink); +} + +void Semantic::parseFunctionDefinition(FunctionDefinitionAST *ast) +{ + AST *funSpec = ast->functionSpecifier(); + AST *storageSpec = ast->storageSpecifier(); + TypeSpecifierAST *typeSpec = ast->typeSpec(); + InitDeclaratorAST *initDeclarator = ast->initDeclarator(); + if (!ast->initDeclarator()) + return; + + DeclaratorAST *d = initDeclarator->declarator(); + + if (!d->declaratorId()) + return; + + parseFunctionDeclaration(funSpec, storageSpec, typeSpec, initDeclarator); + CodeModel::FunctionMember *method = functionLookup(currentScope.top(), d); + + if(!method) { + emit error("Error in Semantic::parseFunctionDefinition: Could not find declaration for function definition"); + return; + } + + CodeModel::Scope *parent = method->parent(); + + if(!ast->functionBody()) { + emit error("Error in Semantic::parseFunctionDefinition: no function body in function definition"); + return; + } + + //create child function scope + QByteArray id = textOf(d->declaratorId()->unqualifiedName()); + CodeModel::BlockScope *functionScope = CodeModel::Create<CodeModel::BlockScope>(m_storage); + functionScope->setName(QByteArray("__QT_ANON_BLOCK_SCOPE(Function: ") + id + QByteArray(")")); + functionScope->setParent(parent); + method->setFunctionBodyScope(functionScope); + + //add arguments to child scope + ArgumentCollection arguments = method->arguments(); + ArgumentCollection::ConstIterator it = arguments.constBegin(); + while(it != arguments.constEnd()) { + CodeModel::Argument *argument = *it; + CodeModel::VariableMember *variableMember = CodeModel::Create<CodeModel::VariableMember>(m_storage); + variableMember->setNameToken(argument->nameToken()); + variableMember->setType(argument->type()); + variableMember->setName(argument->name()); + variableMember->setParent(functionScope); + functionScope->addMember(variableMember); + ++it; + } + + //push function scope and parse function body + currentScope.push(functionScope); + parseStatementList(ast->functionBody()); + currentScope.pop(); +} + +void Semantic::parseStatementList(StatementListAST *statemenList) +{ + if(!statemenList) + return; + CodeModel::BlockScope *blockScope = CodeModel::Create<CodeModel::BlockScope>(m_storage); + blockScope->setName("__QT_ANON_BLOCK_SCOPE"); + blockScope->setParent(currentScope.top()); + currentScope.top()->addScope(blockScope); + + currentScope.push(blockScope); + TreeWalker::parseStatementList(statemenList); + currentScope.pop(); +} + +void Semantic::parseExpression(AbstractExpressionAST* node) +{ + if(!node) + return; + if(node->nodeType() == NodeType_ClassMemberAccess) + parseClassMemberAccess(static_cast<ClassMemberAccessAST *>(node)); + else + TreeWalker::parseExpression(node); +} + +/* + Pretty hardwired code for handling class member access of the types: + object.member and objectPtr->member. + + This function creates a name use for object to its declaration, and a + name use from member to its declaration in the class. +*/ +void Semantic::parseClassMemberAccess(ClassMemberAccessAST *node) +{ + if(!node) + return; + parseExpression(node->expression()); + // Get a name use for the 'object' name. + NameUse *nameUse = findNameUse(node->expression()); + // Since the NameUse refers to an object, its decalaration must be + // a ClassType. Get the scope of this class type. + if( nameUse + && nameUse->declaration() + && nameUse->declaration()->toVariableMember() + && nameUse->declaration()->toVariableMember()->type() + && nameUse->declaration()->toVariableMember()->type()->toClassType() + && nameUse->declaration()->toVariableMember()->type()->toClassType()->scope()) { + + CodeModel::Scope *scope = nameUse->declaration()->toVariableMember()->type()->toClassType()->scope(); + QList<CodeModel::Member *> members = lookupNameInScope(scope, node->name()); + if(members.count() != 0) { + createNameUse(members.at(0), node->name()); + return; + } + } + // Create a NameUse that refers to the global shared unknown type. + createNameUse(m_sharedUnknownMember, node->name()); +} + +void Semantic::parseExpressionStatement(ExpressionStatementAST *node) +{ + TreeWalker::parseExpressionStatement(node); +} + +// using declaration (using A::b) +void Semantic::parseUsing(UsingAST *ast) +{ + //CodeModel::Scope *s = lookUpScope(currentScope.top(), ast->name()); + QList<CodeModel::Member *> members = nameLookup(currentScope.top(), ast->name()); + if(members.isEmpty()) { + emit error("Error in Semantic::parseUsing: could not look up using target"); + return; + } + //TODO: handle multiple members (when nameLookup returns a set of overloded functions) + CodeModel::Member *member = members[0]; + CodeModel::Scope *targetScope = member->parent(); + if(!targetScope) { + emit error("Error in Semantic::parseUsing: target has no parent scope"); + return; + } + + if(!ast->name()) + return; + AST *nameAST = ast->name()->unqualifiedName(); + if(!nameAST) + return; + QByteArray name = textOf(nameAST); +} + +void Semantic::parseEnumSpecifier(EnumSpecifierAST *ast) +{ + if (!ast->name()) + return; + + QByteArray name = textOf(ast->name()); + + //create a Type + CodeModel::EnumType *enumType = CodeModel::Create<CodeModel::EnumType>(m_storage); + enumType->setName(name); + currentScope.top()->addType(enumType); + enumType->setParent(currentScope.top()); + + //create a TypeMember + CodeModel::TypeMember *typeMember = CodeModel::Create<CodeModel::TypeMember>(m_storage); + if(ast->name()) + typeMember->setNameToken(tokenRefFromAST(ast->name()->unqualifiedName())); + typeMember->setName(name); + typeMember->setType(enumType); + currentScope.top()->addMember(typeMember); + typeMember->setParent(currentScope.top()); + + //parse the eneumerators + List<EnumeratorAST*> *list = ast->enumeratorList(); + if (!list) + return; + foreach (EnumeratorAST *current, *list) { + CodeModel::VariableMember *enumerator = CodeModel::Create<CodeModel::VariableMember>(m_storage); + enumerator->setNameToken(tokenRefFromAST(current->id())); + enumerator->setName(textOf(current->id())); + enumerator->setAccess(m_currentAccess); + enumerator->setStatic(true); + enumerator->setType(enumType); + currentScope.top()->addMember(enumerator); + enumerator->setParent(currentScope.top()); + } + +} + +void Semantic::parseTypedef(TypedefAST *ast) +{ + TypeSpecifierAST *typeSpec = ast->typeSpec(); + InitDeclaratorListAST *declarators = ast->initDeclaratorList(); + + if (typeSpec && declarators){ + QByteArray typeId; + + if (typeSpec->name()) + typeId = textOf(typeSpec->name()); + + List<InitDeclaratorAST*> *l = declarators->initDeclaratorList(); + if (!l) + return; + foreach (InitDeclaratorAST *initDecl, *l) { + QByteArray type, id; + if (initDecl->declarator()){ + type = typeOfDeclaration(typeSpec, initDecl->declarator()); + + DeclaratorAST *d = initDecl->declarator(); + while (d->subDeclarator()){ + d = d->subDeclarator(); + } + + if (d->declaratorId()) + id = textOf(d->declaratorId()); + } + + //create a type + CodeModel::Scope *scope = currentScope.top(); + CodeModel::AliasType *typeAlias = CodeModel::Create<CodeModel::AliasType>(m_storage); + //typeAlias->setName(id); + //typeAlias->setParent(scope); + scope->addType(typeAlias); + + //create a TypeMember + CodeModel::TypeMember *typeMember = CodeModel::Create<CodeModel::TypeMember>(m_storage); + if(typeSpec->name()) + typeMember->setNameToken(tokenRefFromAST(typeSpec->name()->unqualifiedName())); + typeMember->setName(id); + typeMember->setType(typeAlias); + currentScope.top()->addMember(typeMember); + typeMember->setParent(currentScope.top()); + + } + + } +} + +void Semantic::parseTypeSpecifier(TypeSpecifierAST *ast) +{ + // If this is a classSpecifier or a EnumSpecifier we skip the name lookup, + // because looking up the name "E" in a class definition like + // "class E { ..." makes no sense. (There might be a variable named E + // already declared, but that variable is now shadowed by the class type.) + if( ast->nodeType() != NodeType_EnumSpecifier + && ast->nodeType() != NodeType_ClassSpecifier + && ast->nodeType() != NodeType_ElaboratedTypeSpecifier ) + parseNameUse(ast->name()); + TreeWalker::parseTypeSpecifier(ast); +} + +/* + Parses a name: looks up name, creates name use. +*/ +void Semantic::parseNameUse(NameAST* name) +{ + if(!name) + return; + + // Look up name + QList<CodeModel::Member *> members = nameLookup(currentScope.top(), name); + if(members.isEmpty()) { + //cout << "no declaration found for " << textOf(name).constData() << endl; + // Create NameUse that refer to a shared UnknownMember + createNameUse(m_sharedUnknownMember, name); + return; + } + + //TODO: handle multiple members (when nameLookup returns a set of overloaded functions) + CodeModel::Member *member = members[0]; + if(!member->parent()) { + emit error("Error in Semantic::parseUsing: target has no parent scope"); + return; + } + + createNameUse(member, name); +} + +/* + Looks up name used in basescope. If name->isGlobal() is true or if classOrNamespaceList() + returns a non-empty list, the C++ qualified name lookup rules are used. Otherwise the + unquialified name lookup rules are used. Returns the a list of members that was found, + In most cases this list will contain zero or one element, except in the case of overloaded functions. + TODO: Argument-dependent name lookup +*/ +QList<CodeModel::Member *> Semantic::nameLookup(CodeModel::Scope *baseScope, const NameAST* name) +{ + if (name->isGlobal() || (name->classOrNamespaceNameList() + && name->classOrNamespaceNameList()->size()>0 )) { + return qualifiedNameLookup(baseScope, name); + } else { + return unqualifiedNameLookup(baseScope, name); + } +} + +//look up an unqualified name +QList<CodeModel::Member *> Semantic::unqualifiedNameLookup(CodeModel::Scope *baseScope, const NameAST* name) +{ + QList<UsingDirectiveLink *> usingDirectiveLinks; + CodeModel::Scope *currentScope = baseScope; + QList<CodeModel::Member *> entities; + + while (currentScope != 0) { + // Add any "using namespace" directive links for the current scope to + // usingDirectiveLinks + if (NamespaceScope *namespaceScope = currentScope->toNamespaceScope()) + usingDirectiveLinks += namespaceScope->usingDirectiveLinks(); + if (BlockScope *blockScope = currentScope->toBlockScope()) + usingDirectiveLinks += blockScope->usingDirectiveLinks(); + + // Search usingDirectiveLinks for a link where currentScope is the + // insertion namespace. If found look up name in the target namespace + // for that link. + if (NamespaceScope *namespaceScope = currentScope->toNamespaceScope()) { + QList<UsingDirectiveLink *>::ConstIterator it = usingDirectiveLinks.constBegin(); + while (it != usingDirectiveLinks.constEnd()) { + if ((*it)->insertionNamespace() == namespaceScope) + entities = lookupNameInScope((*it)->targetNamespace(), name); + ++it; + } + } + + // Look up names in this scope. + entities += lookupNameInScope(currentScope, name); + if (!entities.isEmpty()) + break; + currentScope = currentScope->parent(); + } + return entities; +} + +//look up a qualified name +QList<CodeModel::Member *> Semantic::qualifiedNameLookup(CodeModel::Scope *baseScope, const NameAST* name) +{ + QList<CodeModel::Member *> entities; + CodeModel::Scope *currentScope = baseScope; + + // Check if the global ("::") scope has been specified. + if(name->isGlobal()) { + while (currentScope->parent()) + currentScope = currentScope->parent(); + } + + while (entities.isEmpty() && currentScope != 0) { + CodeModel::Scope *targetScope = scopeLookup(currentScope, name); + entities = lookupNameInScope(targetScope, name); + currentScope = currentScope->parent(); + } + + return entities; +} + +//looks up a name in a scope, includes base classes if scope is a class scope +QList<CodeModel::Member *> Semantic::lookupNameInScope(CodeModel::Scope *scope, const NameAST* name) +{ + QList<CodeModel::Member *> entities; + + if(!scope || !name) + return entities; + + QByteArray nameText = textOf(name->unqualifiedName()->name()); + //look up name in members of current scope + const CodeModel::MemberCollection members = scope->members(); + if (members.contains(nameText)) + entities.append(members.value(nameText)); + + // if not found, look up name in base classes (if any) + CodeModel::ClassScope *classScope = scope->toClassScope(); + if (entities.isEmpty() && classScope) { + const TypeCollection baseClasses = classScope->baseClasses(); + TypeCollection::ConstIterator it = baseClasses.constBegin(); + while (it != baseClasses.constEnd()) { + CodeModel::Scope *baseClass = it.value()->toClassType()->scope(); + if (scope != baseClass) + entities += lookupNameInScope(baseClass, name); + ++it; + } + + if (entities.count() > 1) + emit error("Error in Semantic::lookupNameInScope: name " + + nameText + " is ambigous"); + } + return entities; +} + +/* + Resolves the classOrNamespaceNameList part of a NameAST against a base scope. +*/ +CodeModel::Scope *Semantic::scopeLookup(CodeModel::Scope *baseScope, const NameAST* name) +{ + CodeModel::Scope *currentScope = baseScope; + const List<ClassOrNamespaceNameAST *> *scopeList = name->classOrNamespaceNameList(); + // if there is no scope list, then the scope we are looking for is baseScope + if (!scopeList) + return baseScope; + + // Check if the global ("::") scope has been specified. + if(name->isGlobal()) { + while (currentScope->parent()) + currentScope = currentScope->parent(); + } + + while(currentScope != 0) { + int nestingCounter = 0; + CodeModel::Scope *nestedScope = currentScope; + while (nestingCounter < scopeList->count()) { + const QByteArray nameText = textOf((*scopeList)[nestingCounter]->name()); + nestedScope = nestedScope->scopes().value(nameText); + if (!nestedScope) + break; + ++nestingCounter; + } + if(nestedScope) // found target scope? + return nestedScope; + + currentScope = currentScope->parent(); //look in parent scope + } + + return 0; +} + +TypeMember *Semantic::typeLookup(CodeModel::Scope *baseScope, const NameAST* name) +{ + QList<CodeModel::Member *> memberList = nameLookup(baseScope, name); + + foreach(Member *member, memberList) { + if(TypeMember *typeMember = member->toTypeMember()) + return typeMember; + } + return 0; +} + +FunctionMember *Semantic::functionLookup(CodeModel::Scope *baseScope, + const DeclaratorAST *functionDeclarator) +{ + + QList<CodeModel::Member*> candidateList = + nameLookup(baseScope, functionDeclarator->declaratorId()); + return selectFunction(candidateList, functionDeclarator); +} + +/* + This is a simplified function lookup routine, for matching member function + definitions with member function declarations. It does not implement + the general C++ function overload resolution rules. +*/ +FunctionMember *Semantic::selectFunction(QList<CodeModel::Member*> candidatateList, const DeclaratorAST *functionDeclarator) +{ + // get arguments for function we are looking for + FunctionMember testFunction; + parseFunctionArguments(functionDeclarator, &testFunction); + const ArgumentCollection testArgumentCollection = testFunction.arguments(); + + //test againts functions in overload list. + foreach(Member* member, candidatateList) { + FunctionMember *function = member->toFunctionMember(); + if (!function) + continue; + const ArgumentCollection argumentCollection = function->arguments(); + + //test argument types and number of arguments + ArgumentCollection::ConstIterator arg1 = argumentCollection.constBegin(); + ArgumentCollection::ConstIterator arg2 = testArgumentCollection.constBegin(); + bool match = true; + while(arg1 != argumentCollection.constEnd() && arg2 != testArgumentCollection.constEnd()) { + if( arg1.value()->type()->name() != arg2.value()->type()->name() ) { + match = false; + break; + } + ++arg1; + ++arg2; + } + if(match) + return function; + } + return 0; +} + +QByteArray Semantic::typeOfDeclaration(TypeSpecifierAST *typeSpec, DeclaratorAST *declarator) +{ + if (!typeSpec) + return QByteArray(); + + QByteArray text; + + if (typeSpec->cvQualify()) { + List<AST*> cv = *typeSpec->cvQualify()->children(); + foreach (AST *current, cv) { + text += " " + textOf(current); + } + text += " "; + } + + + text += textOf(typeSpec); + + if (typeSpec->cv2Qualify()) { + List<AST*> cv = *typeSpec->cv2Qualify()->children(); + foreach (AST *current, cv) { + text += textOf(current) + " "; + } + } + + if (declarator && declarator->ptrOpList()) { + List<AST*> ptrOpList = *declarator->ptrOpList(); + foreach (AST *current, ptrOpList) { + text += " " + textOf(current); + } + text += " "; + } + + return text.trimmed().simplified(); +} + + + +QList<QByteArray> Semantic::scopeOfName(NameAST *id, const QList<QByteArray>& startScope) +{ + QList<QByteArray> scope = startScope; + if (id && id->classOrNamespaceNameList()){ + if (id->isGlobal()) + scope.clear(); + + List<ClassOrNamespaceNameAST*> l = *id->classOrNamespaceNameList(); + foreach (ClassOrNamespaceNameAST *current, l) { + if (current->name()) + scope << textOf(current->name()); + } + } + + return scope; +} + +QList<QByteArray> Semantic::scopeOfDeclarator(DeclaratorAST *d, const QList<QByteArray>& startScope) +{ + if(!d) + return QList<QByteArray>(); + return scopeOfName(d->declaratorId(), startScope); +} + +QByteArray Semantic::typeSpecToString(TypeSpecifierAST* typeSpec) +{ + if (!typeSpec) + return QByteArray(); + + QByteArray tp; + if (typeSpec->cvQualify()) { + tp += "const "; + } + + tp += (QString::fromLatin1(textOf(typeSpec)).replace(QRegExp(QLatin1String(" :: ")), QString::fromUtf8("::"))).toLatin1(); + return tp; +} + +QByteArray Semantic::declaratorToString(DeclaratorAST* declarator, const QByteArray& scope, bool skipPtrOp) +{ + if (!declarator) + return QByteArray(); + + QByteArray text; + + if (!skipPtrOp && declarator->ptrOpList()){ + List<AST*> ptrOpList = *declarator->ptrOpList(); + foreach (AST *current, ptrOpList) { + text += textOf(current); + } + text += QByteArray(" "); + } + + text += scope; + + if (declarator->subDeclarator()) + text += QByteArray("(") + declaratorToString(declarator->subDeclarator()) + QByteArray(")"); + + if (declarator->declaratorId()) + text += textOf(declarator->declaratorId()); + + if (declarator->arrayDimensionList()) { + List<AST*> arrays = *declarator->arrayDimensionList(); + foreach (AST *current, arrays) { + current=current; //silence unused symbol warning + text += QByteArray("[]"); + } + } + + if (declarator->parameterDeclarationClause()){ + text += QByteArray("("); + + ParameterDeclarationListAST* l = declarator->parameterDeclarationClause()->parameterDeclarationList(); + if (l != 0){ + List<ParameterDeclarationAST*> params = *l->parameterList(); + foreach (ParameterDeclarationAST *current, params) { + QByteArray type = typeSpecToString(current->typeSpec()); + text += type; + if (!type.isEmpty()) + text += QByteArray(" "); + text += declaratorToString(current->declarator()); + + // ### FIXME if (it.current()) + text += QByteArray(", "); + } + } + + text += QByteArray(")"); + + if (declarator->constant() != 0) + text += QByteArray(" const"); + } + + return QString::fromLatin1(text).replace(QRegExp(QLatin1String(" :: ")), QLatin1String("::")).simplified().toLatin1(); +} + +QByteArray Semantic::textOf(const AST *node) const +{ + if (!node) + return QByteArray(); + QByteArray text; + for (int i = node->startToken(); i < node->endToken(); ++i) { + if (!m_tokenStream->isHidden(i)) { + if (i != node->startToken()) + text += QByteArray(" "); + text += m_tokenStream->tokenText(i); + } + } + return text; +} + +void Semantic::createNameUse(Member *member, NameAST *name) +{ + if (!name) + return; + + AST *unqualifedName = name->unqualifiedName()->name(); + + if(!unqualifedName || !member) + return; + + CodeModel::NameUse *nameUse = CodeModel::Create<CodeModel::NameUse>(m_storage); + nameUse->setParent(currentScope.top()); + nameUse->setNameToken(tokenRefFromAST(unqualifedName)); + nameUse->setName(textOf(unqualifedName)); + nameUse->setDeclaration(member); + + currentScope.top()->addNameUse(nameUse); + addNameUse(unqualifedName, nameUse); +} + +void Semantic::addNameUse(AST *node, NameUse *nameUse) +{ + const int tokenIndex = node->startToken(); + m_nameUses.insert(tokenIndex, nameUse); +} + +/* + Searches a AST node and all its children for a nameUse. The name use is + found by looking up each node's tokens in the m_nameUses map. A depth-first + search is used. +*/ +NameUse *Semantic::findNameUse(AST *node) +{ + if(!node) + return 0; + + List<AST*> *children = node->children(); + if(children) { + NameUse *nameUse = 0; + foreach(AST* child , *children) { + nameUse = findNameUse(child); + if(nameUse) + break; + } + if (nameUse) + return nameUse; + } + + for (int t = node->startToken(); t < node->endToken(); ++t) { + // cout << t <<" |" <<m_tokenStream->tokenText(t).constData() << "|" << endl; + if (m_nameUses.contains(t)) + return m_nameUses.value(t); + } + return 0; +} + +/* + Gets a TokenRef from an AST node. + Assumes that the node only covers one token, which means that + node->statToken() == node->endToken(). If this is not the case + then the TokenRef will reference the token at startToken. +*/ +TokenEngine::TokenRef Semantic::tokenRefFromAST(AST *node) +{ + const int startTokenIndex = node->startToken(); + const TokenEngine::TokenContainer tokenContainer = m_tokenStream->tokenContainer(startTokenIndex); + const int containerIndex = m_tokenStream->containerIndex(startTokenIndex); + return TokenEngine::TokenRef(tokenContainer, containerIndex); +} + +QT_END_NAMESPACE diff --git a/tools/porting/src/semantic.h b/tools/porting/src/semantic.h new file mode 100644 index 0000000..f432198 --- /dev/null +++ b/tools/porting/src/semantic.h @@ -0,0 +1,131 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef SEMANTIC_H +#define SEMANTIC_H + +#include "treewalker.h" +#include "codemodel.h" +#include "tokenstreamadapter.h" + +#include <QObject> +#include <QStack> +#include <QList> +#include <QByteArray> + +QT_BEGIN_NAMESPACE + +class Semantic: public QObject, public TreeWalker +{ +Q_OBJECT +public: + Semantic(CodeModel::NamespaceScope *globalScope, + TokenStreamAdapter::TokenStream *tokenStream, + TypedPool<CodeModel::Item> *storage); + + void parseAST(TranslationUnitAST *node); +signals: + void error(const QByteArray &message); + void warning(const QByteArray &message); +protected: + virtual void parseNamespace(NamespaceAST *); + virtual void parseClassSpecifier(ClassSpecifierAST *); + virtual void parseElaboratedTypeSpecifier(ElaboratedTypeSpecifierAST *node); + virtual void parseSimpleDeclaration(SimpleDeclarationAST *); + virtual void parseDeclaration(AST *funSpec, AST *storageSpec, TypeSpecifierAST *typeSpec, InitDeclaratorAST *decl); + virtual void parseFunctionDeclaration(AST *funSpec, AST *storageSpec, TypeSpecifierAST *typeSpec, InitDeclaratorAST *decl); + virtual void parseFunctionArguments(const DeclaratorAST *declarator, CodeModel::FunctionMember *method); + virtual void parseFunctionDefinition(FunctionDefinitionAST *); + virtual void parseStatementList(StatementListAST *); + virtual void parseBaseClause(BaseClauseAST *baseClause, CodeModel::ClassScope * klass); + virtual void parseLinkageSpecification(LinkageSpecificationAST *); + virtual void parseUsing(UsingAST *); + virtual void parseUsingDirective(UsingDirectiveAST *); + virtual void parseExpression(AbstractExpressionAST*); + virtual void parseExpressionStatement(ExpressionStatementAST *node); + virtual void parseClassMemberAccess(ClassMemberAccessAST *node); + virtual void parseNameUse(NameAST*); + virtual void parseEnumSpecifier(EnumSpecifierAST *); + virtual void parseTypedef(TypedefAST *); + virtual void parseTypeSpecifier(TypeSpecifierAST *); + + QList<CodeModel::Member *> nameLookup(CodeModel::Scope *baseScope, const NameAST* name); + QList<CodeModel::Member *> unqualifiedNameLookup(CodeModel::Scope *baseScope, const NameAST* name); + QList<CodeModel::Member *> qualifiedNameLookup(CodeModel::Scope *baseScope, const NameAST* name); + QList<CodeModel::Member *> lookupNameInScope(CodeModel::Scope *scope, const NameAST* name); + + CodeModel::TypeMember *typeLookup(CodeModel::Scope *baseScope, const NameAST* name); + CodeModel::FunctionMember *functionLookup(CodeModel::Scope *baseScope, const DeclaratorAST *functionDeclarator); + CodeModel::Scope *scopeLookup(CodeModel::Scope *baseScope, const NameAST* name); + CodeModel::FunctionMember *selectFunction(QList<CodeModel::Member*> candidatateList, const DeclaratorAST *functionDeclarator); + + QByteArray typeOfDeclaration(TypeSpecifierAST *typeSpec, DeclaratorAST *declarator); + QList<QByteArray> scopeOfName(NameAST *id, const QList<QByteArray> &scope); + QList<QByteArray> scopeOfDeclarator(DeclaratorAST *d, const QList<QByteArray> &scope); + QByteArray declaratorToString(DeclaratorAST* declarator, const QByteArray& scope = QByteArray(), bool skipPtrOp = false); + QByteArray typeSpecToString(TypeSpecifierAST* typeSpec); + + QByteArray textOf(const AST *node) const; + void createNameUse(CodeModel::Member *member, NameAST *name); + void addNameUse(AST *node, CodeModel::NameUse *nameUse); + CodeModel::NameUse *findNameUse(AST *node); + TokenEngine::TokenRef tokenRefFromAST(AST *node); +private: + TokenStreamAdapter::TokenStream *m_tokenStream; + TypedPool<CodeModel::Item> *m_storage; + CodeModel::Member::Access m_currentAccess; + bool m_inSlots; + bool m_inSignals; + bool m_inStorageSpec; + bool m_inTypedef; + + QMap<int, CodeModel::NameUse *> m_nameUses; + QStack<CodeModel::Scope *> currentScope; + CodeModel::TypeMember *m_sharedUnknownMember; +private: + Semantic(const Semantic &source); + void operator = (const Semantic &source); +}; + +QT_END_NAMESPACE + +#endif // SEMANTIC_H diff --git a/tools/porting/src/smallobject.cpp b/tools/porting/src/smallobject.cpp new file mode 100644 index 0000000..37871c1 --- /dev/null +++ b/tools/porting/src/smallobject.cpp @@ -0,0 +1,59 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "smallobject.h" + +QT_BEGIN_NAMESPACE + +int block_t::N = 0; +static pool mem_pool; + +void *SmallObject::operator new(size_t size) +{ + return mem_pool.allocate(size); +} + +void SmallObject::operator delete(void * /*p*/ ) +{ +} + +QT_END_NAMESPACE diff --git a/tools/porting/src/smallobject.h b/tools/porting/src/smallobject.h new file mode 100644 index 0000000..bc5816d --- /dev/null +++ b/tools/porting/src/smallobject.h @@ -0,0 +1,182 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef SMALLOBJECT_H +#define SMALLOBJECT_H + +#include <QList> + +#include <assert.h> +#include <stdlib.h> +#include <string.h> + +QT_BEGIN_NAMESPACE + +struct block_t +{ + static int N; + + block_t *chain; + char *data; + char *ptr; + char *end; + + inline void init(int block_size = 256) + { + ++N; + chain = 0; + data = (char*) malloc(block_size); + ptr = data; + end = data + block_size; + } + + inline void init0(int block_size) + { + init(); + memset(data, '0', block_size); + } + + inline void destroy() + { + --N; + if (chain) { + chain->destroy(); + free(chain); + } + + free(data); + } + + inline void *allocate(size_t size, block_t **right_most) + { + const unsigned int block_size = 1 << 16; + if (end < ptr + size) { + assert( size < block_size ); + + if (!chain) { + chain = (block_t*) malloc(sizeof(block_t)); + Q_ASSERT(chain); + chain->init(block_size); + } + + return chain->allocate(size, right_most); + } + + char *r = ptr; + ptr += size; + + if (right_most) + *right_most = this; + + return r; + } + +}; + +// a stupid memory pool +struct pool +{ + block_t blk; + block_t *right_most; + + inline pool() { blk.init(); right_most = &blk; } + inline ~pool() { blk.destroy(); } + + inline void *allocate(size_t size) + { + void *ptr = right_most->allocate(size, &right_most); + Q_ASSERT(ptr); + return ptr; + + } + inline void *reallocate(void *old, size_t old_size, size_t size) + { + void *alloc = right_most->allocate(size, &right_most); + memcpy(alloc, old, old_size); + return alloc; + } +private: + Q_DISABLE_COPY(pool) +}; + +/* + A memory pool that calls the destructor for each stored item when memory is + freed, at the expence storing one BaseType* per item. + + Note that allocations for types that does not inherit BaseType + is not allowed and will result in a crash when the memory is freed. +*/ +template <typename BaseType> +class TypedPool +{ +public: + inline TypedPool() { blk.init(); right_most = &blk; } + inline ~TypedPool() + { + foreach(BaseType *item, allocated) + item->~BaseType(); + blk.destroy(); + } + + inline void *allocate(size_t size) + { + void *memory = right_most->allocate(size, &right_most); + allocated.append(reinterpret_cast<BaseType *>(memory)); + Q_ASSERT(memory); + return memory; + } +private: + Q_DISABLE_COPY(TypedPool) + block_t blk; + block_t *right_most; + QList<BaseType *> allocated; +}; + +struct SmallObject +{ + static void *operator new(size_t size); + static void operator delete(void *p); +}; + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/src.pro b/tools/porting/src/src.pro new file mode 100644 index 0000000..d626b19 --- /dev/null +++ b/tools/porting/src/src.pro @@ -0,0 +1,93 @@ +TEMPLATE = app +CONFIG -= moc +CONFIG += console +CONFIG -= app_bundle +build_all:!build_pass { + CONFIG -= build_all + CONFIG += release +} +QT = xml core +DEPENDPATH += . +TARGET =qt3to4 +DESTDIR = ../../../bin +DEFINES += QT_NO_CAST_TO_ASCII + +HEADERS += smallobject.h \ + tokenengine.h \ + tokenizer.h \ + rpplexer.h \ + rpp.h \ + rpptreewalker.h \ + rpptreeevaluator.h \ + rppexpressionbuilder.h \ + preprocessorcontrol.h \ + replacetoken.h \ + tokenreplacements.h \ + textreplacement.h \ + portingrules.h \ + qtsimplexml.h \ + projectporter.h \ + proparser.h \ + fileporter.h \ + logger.h \ + tokens.h \ + filewriter.h \ + cpplexer.h \ + smallobject.h \ + ast.h \ + errors.h \ + parser.h \ + translationunit.h \ + treewalker.h \ + semantic.h \ + codemodel.h \ + codemodelwalker.h \ + codemodelattributes.h + +SOURCES += port.cpp \ + smallobject.cpp \ + tokenengine.cpp \ + tokenizer.cpp \ + rpplexer.cpp \ + rpp.cpp \ + rpptreewalker.cpp \ + rpptreeevaluator.cpp \ + rppexpressionbuilder.cpp \ + preprocessorcontrol.cpp \ + replacetoken.cpp \ + tokenreplacements.cpp \ + textreplacement.cpp \ + portingrules.cpp \ + qtsimplexml.cpp \ + projectporter.cpp \ + proparser.cpp \ + fileporter.cpp \ + logger.cpp \ + filewriter.cpp \ + cpplexer.cpp \ + ast.cpp \ + errors.cpp \ + parser.cpp \ + translationunit.cpp \ + treewalker.cpp \ + semantic.cpp \ + codemodel.cpp \ + codemodelwalker.cpp \ + codemodelattributes.cpp + +RESOURCES += qt3headers0.qrc qt3headers1.qrc qt3headers2.qrc qt3headers3.qrc + +target.path=$$[QT_INSTALL_BINS] +INSTALLS += target + +RULESXML = q3porting.xml +RULESXML.files = q3porting.xml +RULESXML.path = $$[QT_INSTALL_DATA] +INSTALLS += RULESXML + +win32-msvc.net|win32-msvc2* { + QMAKE_CXXFLAGS -= -Zm200 -Zm300 + QMAKE_CXXFLAGS += -Zm1000 + QMAKE_CFLAGS -= -Zm200 -Zm300 + QMAKE_CFLAGS += -Zm1000 +} diff --git a/tools/porting/src/textreplacement.cpp b/tools/porting/src/textreplacement.cpp new file mode 100644 index 0000000..6555f52 --- /dev/null +++ b/tools/porting/src/textreplacement.cpp @@ -0,0 +1,100 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "textreplacement.h" + +QT_BEGIN_NAMESPACE + +bool TextReplacements::insert(QByteArray newText, int insertPosition, int currentLenght) +{ + //bubble sort the new replacement into the list + int i; + for(i=0; i<textReplacementList.size(); ++i) { + if (insertPosition == textReplacementList.at(i).insertPosition) + return false; // multiple replacements on the same insertPosition is not allowed. + if(insertPosition < textReplacementList.at(i).insertPosition) + break; //we found the right position + } + //++i; + // cout << "inserting new text " << newText.constData() << endl; + // %s at %d overwriting %d bytes at list pos %d\n", newText.constData(), insertPosition, currentLenght, i); + TextReplacement rep; + rep.newText=newText; + rep.insertPosition=insertPosition; + rep.currentLenght=currentLenght; + + textReplacementList.insert(i, rep); + return true; +} + +void TextReplacements::clear() +{ + textReplacementList.clear(); +} + +QByteArray TextReplacements::apply(QByteArray current) +{ + QByteArray newData=current; + int i; + int replacementOffset=0; + + for(i=0; i<textReplacementList.size(); ++i) { + TextReplacement rep=textReplacementList.at(i); + //printf("applying new text %s insert at %d overwriting %d bytes \n", rep.newText.constData(), rep.insertPosition, rep.currentLenght); + newData.remove(rep.insertPosition+replacementOffset, rep.currentLenght); + newData.insert(rep.insertPosition+replacementOffset, rep.newText); + + //modify all remaining replacements if we change the document length + replacementOffset+=(rep.newText.size() - rep.currentLenght); + } + + return newData; +} + +TextReplacements &TextReplacements::operator+=(const TextReplacements &other) +{ + foreach(TextReplacement rep, other.replacements()) { + insert(rep.newText, rep.insertPosition, rep.currentLenght); + } + return *this; +} + +QT_END_NAMESPACE diff --git a/tools/porting/src/textreplacement.h b/tools/porting/src/textreplacement.h new file mode 100644 index 0000000..27601c6 --- /dev/null +++ b/tools/porting/src/textreplacement.h @@ -0,0 +1,91 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef TEXTREPLACEMENT_H +#define TEXTREPLACEMENT_H + +#include <QByteArray> +#include <QList> +#include <QtAlgorithms> + +QT_BEGIN_NAMESPACE + +class TextReplacement +{ +public: + QByteArray newText; + int insertPosition; + int currentLenght; //length of the text that is going to be replaced. + bool operator<(const TextReplacement &other) const + { + return (insertPosition < other.insertPosition); + } +}; + +class TextReplacements +{ +public: + /* + creates a TextReplacement that inserts newText at insertPosition. currentLength bytes + are overwritten in the original text. If there already is an insert at insertPosition, + the insert will not be performed. + + insert maintains the TextReplacement list in sorted order. + + Returns true if the insert was successful, false otherwise; + */ + bool insert(QByteArray newText, int insertPosition, int currentLenght); + void clear(); + QList<TextReplacement> replacements() const + { + return textReplacementList; + } + QByteArray apply(QByteArray current); + + TextReplacements &operator+=(const TextReplacements &other); + +private: + QList<TextReplacement> textReplacementList; +}; + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/tokenengine.cpp b/tools/porting/src/tokenengine.cpp new file mode 100644 index 0000000..fd9a5b3 --- /dev/null +++ b/tools/porting/src/tokenengine.cpp @@ -0,0 +1,402 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "tokenengine.h" + +QT_BEGIN_NAMESPACE + +namespace TokenEngine { + +/* + Add a container-global attribute. +*/ +void TokenAttributes::addAttribute(const QByteArray &name, const QByteArray &value) +{ + const QByteArray keyText = makeKeyText(-1, name); + attributes.insert(keyText, value); +} + +/* + Retrieve container-global attribute. +*/ +QByteArray TokenAttributes::attribute(const QByteArray &name) const +{ + const QByteArray keyText = makeKeyText(-1, name); + return attributes.value(keyText); +} + +/* + Add an attribute. Note: Don't use names starting with a number, that will + break the indexing. +*/ +void TokenAttributes::addAttribute(const int index, const QByteArray &name, const QByteArray &value) +{ + const QByteArray keyText = makeKeyText(index, name); + attributes.insert(keyText, value); +} + +QByteArray TokenAttributes::attribute(const int index, const QByteArray &name) const +{ + const QByteArray keyText = makeKeyText(index, name); + return attributes.value(keyText); +} + +QByteArray TokenAttributes::makeKeyText(const int index, const QByteArray &name) const +{ + QByteArray indexText; + return indexText.setNum(index) + name; +} + + +/* + Construnct an empty TokenContainer. +*/ +TokenContainer::TokenContainer() +{ + d = new TokenContainerData(); + d->typeInfo = 0; +} + +/* + Construnct a TokenContainer from data +*/ +TokenContainer::TokenContainer(QByteArray text, QVector<Token> tokens, TypeInfo *typeInfo) +{ + d = new TokenContainerData(); + d->text = text; + d->tokens = tokens; + if(typeInfo == 0) + d->typeInfo = new TypeInfo(); + else + d->typeInfo = typeInfo; +} + +int TokenContainer::count() const +{ + return d->tokens.count(); +} + +QByteArray TokenContainer::text(const int index) const +{ + Token token = d->tokens.at(index); + return d->text.mid(token.start, token.length); +} + +QByteArray TokenContainer::tempText(const int index) const +{ + Token token = d->tokens.at(index); + return QByteArray::fromRawData(d->text.constData() + token.start, token.length); +} + +QByteArray TokenContainer::fullText() const +{ + return d->text; +} + +TokenContainer TokenContainer::tokenContainer(const int index) const +{ + Q_UNUSED(index); + return *this; +} + +Token TokenContainer::token(const int index) const +{ + return d->tokens.at(index); +} + +TypeInfo *TokenContainer::typeInfo() +{ + return d->typeInfo; +} + +TokenAttributes *TokenContainer::tokenAttributes() +{ + return d->tokenAttributes; +} + +const TokenAttributes *TokenContainer::tokenAttributes() const +{ + return d->tokenAttributes; +} + +/* + Returns the line number for the given index. +*/ +int TokenContainer::line(int index) const +{ + //This algorithm is a bit more complicated than it should be, + //since we have to search for newlines inside comments. + //(Comments are tokenized as one token) + QByteArray contents = fullText(); + int pos=0; + int lines=0; + for(int t=0; t < index; ++t) { + int tokenLength = d->tokens.at(t).length; + if((tokenLength == 1) && (text(t) == "\n")) { + ++lines; + } else if(tokenLength > 2) {// 3 is the minimum size for a comment (// + newline) + int newpos = d->tokens.at(t).length; + for(int p = pos; p < newpos; ++p) { + if(contents[p] == '\n') + ++lines; + } + } + pos += d->tokens.at(t).length; + } + return lines; +} + +/* + Returns the column number for the given index. +*/ +int TokenContainer::column(int index) const +{ + //Scan backwards, find \n. + int chars = 0; + int t = index; + while (t>0) { + if((d->tokens.at(t).length == 1) && (text(t) == "\n")) + break; + chars += d->tokens.at(t).length; + --t; + } + return chars; +} + +TokenTempRef TokenContainer::tokenTempRef(const int index) const +{ + Q_ASSERT(index < d->tokens.count()); + const Token token = d->tokens.at(index); + return TokenTempRef(d->text.constData() + token.start, token.length); +} + +QByteArray TokenSection::fullText() const +{ + QByteArray text; + for (int t = m_start; t < m_start + m_count; ++t) { + text += m_tokenContainer.text(t); + } + return text; +} + +QByteArray TokenList::fullText() const +{ + QByteArray text; + for (int t = 0; t < m_tokenList.count(); ++t) { + text += m_tokenContainer.text(m_tokenList.at(t)); + } + return text; +} + +TokenSectionSequence::TokenSectionSequence(QVector<TokenSection> tokenSections) +:m_tokenSections(tokenSections), m_count(0) +{ + for(int s = 0; s < m_tokenSections.count(); ++s) { + m_startIndexes.append(m_count); + m_count += m_tokenSections.at(s).count(); + } +} + +QByteArray TokenSectionSequence::fullText() const +{ + QByteArray text; + foreach(TokenSection section, m_tokenSections) { + text += section.fullText(); + } + return text; +} + +int TokenSectionSequence::count() const +{ + return m_count; +} + +QVector<TokenSection> TokenSectionSequence::tokenSections() const +{ + return m_tokenSections; +} + +QByteArray TokenSectionSequence::text(const int index) const +{ + const int sectionIndex = findSection(index); + const int sectionInternalIndex = calculateInternalIndex(index, sectionIndex); + return m_tokenSections.at(sectionIndex).text(sectionInternalIndex); +} + +QByteArray TokenSectionSequence::tempText(const int index) const +{ + const int sectionIndex = findSection(index); + const int sectionInternalIndex = calculateInternalIndex(index, sectionIndex); + return m_tokenSections.at(sectionIndex).tempText(sectionInternalIndex); +} + + +TokenContainer TokenSectionSequence::tokenContainer(const int index) const +{ + const int sectionIndex = findSection(index); + const int sectionInternalIndex = calculateInternalIndex(index, sectionIndex); + return m_tokenSections.at(sectionIndex).tokenContainer(sectionInternalIndex); +} + +int TokenSectionSequence::containerIndex(const int index) const +{ + const int sectionIndex = findSection(index); + const int sectionInternalIndex = calculateInternalIndex(index, sectionIndex); + return m_tokenSections.at(sectionIndex).containerIndex(sectionInternalIndex); +} + +int TokenSectionSequence::findSection(const int index) const +{ + int c = 0; + bool found = false; + //Here we do a linear search through all collections in the list, + //which could turn out to be to slow. + while(!found && c < m_tokenSections.count()) { + const int sectionEnd = m_startIndexes.at(c) + + m_tokenSections.at(c).count(); + if (index < sectionEnd) + found = true; + else + ++c; + } + if(!found) { + //error + Q_ASSERT(0); + return -1; + } + Q_ASSERT(c < m_tokenSections.count()); + return c; +} + +int TokenSectionSequence::calculateInternalIndex(const int index, const int sectionIndex) const +{ + const int sectionInternalIndex = + index - m_startIndexes.at(sectionIndex); + Q_ASSERT(sectionInternalIndex < m_tokenSections.at(sectionIndex).count()); + return sectionInternalIndex; +} + + +TokenSectionSequenceIterator::TokenSectionSequenceIterator(const TokenSectionSequence &tokenSectionSequence) +:m_currentSection(0) +,m_currentToken(-1) +,m_numSections(tokenSectionSequence.m_tokenSections.count()) +,m_tokenSectionSequence(tokenSectionSequence) + +{ } + +/* + Resets the token iterator. +*/ +void TokenSectionSequenceIterator::reset() +{ + m_currentSection = 0; + m_currentToken = -1; +} + +/* + Advances the token iterator. +*/ +bool TokenSectionSequenceIterator::nextToken() +{ + if(m_tokenSectionSequence.m_tokenSections.isEmpty()) + return false; + ++m_currentToken; + //check of we are past the end of the current section + if(m_currentToken < m_tokenSectionSequence.m_tokenSections.at(m_currentSection).count()) + return true; + //Advance to the next non-empty section. + m_currentToken = 0; + do { + ++m_currentSection; + //return false if no more sections + if(m_currentSection >= m_numSections) + return false; + //skip empty sections + } while(m_tokenSectionSequence.m_tokenSections.at(m_currentSection).count() == 0); + + return true; +} + +/* + Returns the text for the current token; +*/ +QByteArray TokenSectionSequenceIterator::text() const +{ + return m_tokenSectionSequence.m_tokenSections.at(m_currentSection).text(m_currentToken); +} + +/* + Returns the text for the current token as a temporary QByteArray; +*/ +QByteArray TokenSectionSequenceIterator::tempText() const +{ + return m_tokenSectionSequence.m_tokenSections.at(m_currentSection).tempText(m_currentToken); +} + +/* + Returns the container for the current token; +*/ +TokenContainer TokenSectionSequenceIterator::tokenContainer() const +{ + return m_tokenSectionSequence.m_tokenSections.at(m_currentSection).tokenContainer(m_currentToken); +} + +/* + Returns the containerIndex for the current token; +*/ +int TokenSectionSequenceIterator::containerIndex() const +{ + return m_tokenSectionSequence.m_tokenSections.at(m_currentSection).containerIndex(m_currentToken); +} + +/* + Returns a temporary token reference for the current token for the current token; +*/ +TokenTempRef TokenSectionSequenceIterator::tokenTempRef() const +{ + return m_tokenSectionSequence.m_tokenSections.at(m_currentSection).tokenTempRef(m_currentToken); +} + + +} //namespace TokenEngine + +QT_END_NAMESPACE diff --git a/tools/porting/src/tokenengine.h b/tools/porting/src/tokenengine.h new file mode 100644 index 0000000..5d7d88d --- /dev/null +++ b/tools/porting/src/tokenengine.h @@ -0,0 +1,391 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef TOKENENGINE_H +#define TOKENENGINE_H + +#include <QByteArray> +#include <QVector> +#include <QString> +#include <QSharedData> +#include <QSharedDataPointer> +#include <QMap> + +QT_BEGIN_NAMESPACE + +namespace TokenEngine { + +class TokenContainer; +/* + A token is defined as a start-position and a length. Since the actual text + storage is not reffered to here, Token needs to be used together with + a TokenContainer in order to be useful. +*/ +class Token +{ +public: + Token() + :start(0), length(0) {} + Token(int p_start, int p_lenght) + :start(p_start), length(p_lenght) {} + int start; + int length; +}; + +/* + Each TokenContainer has a TypeInfo object with meta-information. +*/ +class FileInfo; +class GeneratedInfo; +class TypeInfo +{ +public: + virtual ~TypeInfo() {}; + virtual FileInfo *toFileInfo() const {return 0;} + virtual GeneratedInfo *toGeneratedInfo() const {return 0;} +}; + +/* + MetaInfo for containers that contains tokens from a file +*/ +class FileInfo: public TypeInfo +{ +public: + FileInfo *toFileInfo() const + {return const_cast<FileInfo *>(this);} + + QString filename; +}; + +/* + MetaInfo for containers that contains generated tokens. +*/ +class GeneratedInfo: public TypeInfo +{ +public: + GeneratedInfo *toGeneratedInfo() const + {return const_cast<GeneratedInfo *>(this);} + + //preprocessor tree pointer? +}; + +class TokenAttributes +{ +public: + void addAttribute(const QByteArray &name, const QByteArray &value); + QByteArray attribute(const QByteArray &name) const; + void addAttribute(const int index, const QByteArray &name, const QByteArray &value); + QByteArray attribute(const int index, const QByteArray &name) const; + +private: + inline QByteArray makeKeyText(const int index, const QByteArray &name) const; + QMap<QByteArray, QByteArray> attributes; +}; + + +/* + A TokenSequence that stores text and tokens referencing + that text. +*/ +class TokenContainerData : public QSharedData +{ +public: + TokenContainerData() + : typeInfo(0) + {tokenAttributes = new TokenAttributes();} + ~TokenContainerData() + {delete tokenAttributes; delete typeInfo; } + QByteArray text; + QVector<Token> tokens; + TypeInfo *typeInfo; + TokenAttributes *tokenAttributes; +}; +class TokenTempRef; +class TokenContainer +{ +public: + TokenContainer(); + TokenContainer(QByteArray text, QVector<Token> tokens, TypeInfo *typeInfo = 0); + int count() const; + QByteArray text(const int index) const; + QByteArray tempText(const int index) const; + QByteArray fullText() const; + TokenContainer tokenContainer(const int index) const; + inline int containerIndex(const int index) const + { return index; } + Token token(const int index) const; + TypeInfo *typeInfo(); + TokenAttributes *tokenAttributes(); + const TokenAttributes *tokenAttributes() const; + int line(int index) const; + int column(int index) const; + TokenTempRef tokenTempRef(const int index) const; +private: + const QByteArray &textRef() + { return d->text; } + QExplicitlySharedDataPointer<TokenContainerData> d; +}; + +/* + A reference to a single token in a container +*/ +class TokenRef +{ +public: + TokenRef(): m_index(-1) {} + TokenRef(TokenContainer tokenContainer, int containerIndex) + : m_tokenContainer(tokenContainer), m_index(containerIndex) {} + inline int count() const + { return m_index == -1 ? 0 : 1; } + inline QByteArray text(const int index = 0) const + { Q_UNUSED(index); return m_tokenContainer.text(m_index); } + inline QByteArray tempText(const int index) const + { Q_UNUSED(index); return m_tokenContainer.tempText(m_index); } + inline QByteArray fullText() const + { return text(); } + inline TokenContainer tokenContainer(const int index = 0) const + { Q_UNUSED(index); return m_tokenContainer; } + inline int containerIndex(const int index = 0) const + { Q_UNUSED(index); return m_index; } +private: + TokenContainer m_tokenContainer; + int m_index; +}; + +/* + A temporary reference to a single token in a container. This reference does + not increase the refcount on the TokenContainer. +*/ +class TokenTempRef +{ +public: + TokenTempRef(const char *text, int length) + : m_text(text), m_length(length) {} + inline const char *constData() const + { return m_text; } + inline int length() const + { return m_length; } + char at(int index) const + { Q_ASSERT(index < m_length); return m_text[index]; } +private: + const char *m_text; + int m_length; +}; + +/* + Contains a selected range from a TokenSequence. +*/ +class TokenSection +{ +public: + TokenSection() : m_start(0), m_count(0) {} + TokenSection(TokenContainer tokenContainer, + const int start, const int count) + :m_tokenContainer(tokenContainer), m_start(start), m_count(count) {} + + inline int count() const + { return m_count; } + inline QByteArray text(const int index) const + { + const int cIndex = containerIndex(index); + Q_ASSERT(cIndex < m_tokenContainer.count()); + return m_tokenContainer.text(cIndex); + } + inline QByteArray tempText(const int index) const + { + const int cIndex = containerIndex(index); + Q_ASSERT(cIndex < m_tokenContainer.count()); + return m_tokenContainer.tempText(cIndex); + } + QByteArray fullText() const; + inline TokenContainer tokenContainer(const int index = 0) const + { Q_UNUSED(index); return m_tokenContainer; } + inline int containerIndex(const int index) const + { return m_start + index; } + TokenTempRef tokenTempRef(const int index) const + { + const int cIndex = containerIndex(index); + Q_ASSERT(cIndex < m_tokenContainer.count()); + return m_tokenContainer.tokenTempRef(cIndex); + } +private: + TokenContainer m_tokenContainer; + int m_start; + int m_count; +}; + +/* + A list of tokens from a tokenContainer +*/ +class TokenList +{ +public: + TokenList() {}; + TokenList(TokenContainer tokenContainer, QVector<int> tokenList) + :m_tokenContainer(tokenContainer), m_tokenList(tokenList) {} + inline int count() const + { return m_tokenList.count(); } + inline QByteArray text(const int index) const + { + const int cIndex = containerIndex(index); + Q_ASSERT(cIndex < m_tokenContainer.count()); + return m_tokenContainer.text(cIndex); + } + inline QByteArray tempText(const int index) const + { + const int cIndex = containerIndex(index); + Q_ASSERT(cIndex < m_tokenContainer.count()); + return m_tokenContainer.tempText(cIndex); + } + QByteArray fullText() const; + inline TokenContainer tokenContainer(const int index) const + { Q_UNUSED(index); return m_tokenContainer; } + inline int containerIndex(const int index) const + { return m_tokenList.at(index); } + Token token(const int index) const + { + const int cIndex = containerIndex(index); + Q_ASSERT(cIndex < m_tokenContainer.count()); + return m_tokenContainer.token(cIndex); + } + +private: + TokenContainer m_tokenContainer; + QVector<int> m_tokenList; +}; + +/* + Combines a list of TokenSequences into one TokenSectionSequence +*/ +class TokenSectionSequenceIterator; +class TokenSectionSequence +{ +public: + TokenSectionSequence() :m_count(0) {}; + TokenSectionSequence(QVector<TokenSection> tokenSections); + + QByteArray fullText() const; + int count() const; + QVector<TokenSection> tokenSections() const; + + //random access interface, access time is linear on the number of sections + QByteArray text(const int index) const; + QByteArray tempText(const int index) const; + TokenContainer tokenContainer(const int index) const; + int containerIndex(const int index) const; + +protected: + int findSection(const int index) const; + int calculateInternalIndex(const int index, const int sectionIndex) const; +private: + QVector<TokenSection> m_tokenSections; + QVector<int> m_startIndexes; + int m_count; + friend class TokenSectionSequenceIterator; +}; + +//sequental access interface, constant access time. +class TokenSectionSequenceIterator +{ +public: + TokenSectionSequenceIterator(const TokenSectionSequence &tokenSectionSequence); + void reset(); + bool nextToken(); + QByteArray text() const; + QByteArray tempText() const; + TokenContainer tokenContainer() const; + int containerIndex() const; + TokenTempRef tokenTempRef() const; +private: + int m_currentSection; + int m_currentToken; // token index in currentTokenSequence; + const int m_numSections; + const TokenSectionSequence &m_tokenSectionSequence; +}; + +template <typename TokenSequence> +QByteArray getText(TokenSequence tokenSequence) +{ + QByteArray text; + for (int t = 0; t<tokenSequence.count(); ++t) { + text += tokenSequence.text(t); + } + return text; +} + +/* + Append the text and the tokens from the range [startToken, startToken + numTokens> + to text and tokenList. +*/ +template <typename TokenSequenceType> +void copy(QByteArray &text, QVector<TokenEngine::Token> &tokenList, const TokenSequenceType &tokenSequence, int startToken, int numTokens) +{ + const int endToken = startToken + numTokens; + int textIndex = text.count(); + for(int t = startToken; t < endToken; ++t) { + const QByteArray tokenText = tokenSequence.text(t); + const int tokenLength = tokenText.count(); + TokenEngine::Token token(textIndex, tokenLength); + tokenList.append(token); + text += tokenSequence.text(t); + textIndex += tokenText.count(); + } +} + +/* + Copy a the range [startToken, startToken + numTokens> from a tokenSequence to a new + TokenConrtainer. +*/ +template <typename TokenSequenceType> +TokenContainer copy(const TokenSequenceType &tokenSequence, int startToken, int numTokens) +{ + QByteArray containerText; + QVector<Token> tokens; + tokens.reserve(numTokens); + TokenEngine::copy(containerText, tokens, tokenSequence, startToken, numTokens); + return TokenContainer(containerText, tokens); +} + +} //namespace TokenEngine + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/tokenizer.cpp b/tools/porting/src/tokenizer.cpp new file mode 100644 index 0000000..1eacd88 --- /dev/null +++ b/tools/porting/src/tokenizer.cpp @@ -0,0 +1,491 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "tokenizer.h" +#include "tokens.h" +#include <QDateTime> +#include <QHash> +#include <ctype.h> + +QT_BEGIN_NAMESPACE + +using TokenEngine::Token; + +static QHash<QByteArray, bool> preprocessed; +bool Tokenizer::s_initialized = false; +Tokenizer::scan_fun_ptr Tokenizer::s_scan_table[128 + 1]; +int Tokenizer::s_attr_table[256]; + +Tokenizer::Tokenizer() + : m_buffer(0), m_ptr(0) +{ + if (!s_initialized) + setupScanTable(); +} + +Tokenizer::~Tokenizer() +{ +} + +enum +{ + A_Alpha = 0x01, + A_Digit = 0x02, + A_Alphanum = A_Alpha | A_Digit, + A_Whitespace = 0x04 +}; + +void Tokenizer::setupScanTable() +{ + s_initialized = true; + + memset(s_attr_table, 0, 256); + + for (int i=0; i<128; ++i) { + switch (i) { + case ':': + case '*': + case '%': + case '^': + case '=': + case '!': + case '&': + case '|': + case '+': + case '<': + case '>': + case '-': + case '.': + s_scan_table[i] = &Tokenizer::scanOperator; + break; + + case '\r': + case '\n': + s_scan_table[i] = &Tokenizer::scanNewline; + break; + + case '#': + s_scan_table[i] = &Tokenizer::scanPreprocessor; + break; + + case '/': + s_scan_table[i] = &Tokenizer::scanComment; + break; + + case '\'': + s_scan_table[i] = &Tokenizer::scanCharLiteral; + break; + + case '"': + s_scan_table[i] = &Tokenizer::scanStringLiteral; + break; + + default: + if (isspace(i)) { + s_scan_table[i] = &Tokenizer::scanWhiteSpaces; + s_attr_table[i] |= A_Whitespace; + } else if (isalpha(i) || i == '_') { + s_scan_table[i] = &Tokenizer::scanIdentifier; + s_attr_table[i] |= A_Alpha; + } else if (isdigit(i)) { + s_scan_table[i] = &Tokenizer::scanNumberLiteral; + s_attr_table[i] |= A_Digit; + } else + s_scan_table[i] = &Tokenizer::scanChar; + } + } + + s_scan_table[128] = &Tokenizer::scanUnicodeChar; +} + +QVector<TokenEngine::Token> Tokenizer::tokenize(QByteArray text) +{ + m_tokens.clear(); + + m_buffer = text; + m_ptr = 0; + + // tokenize + for (;;) { + Token tk; + bool endOfFile = nextToken(tk); + if (endOfFile) { + break; + } + m_tokens.append(tk); + } + + return m_tokens; +} + +bool Tokenizer::nextToken(Token &tok) +{ + int start = m_ptr; + unsigned char ch = (unsigned char)m_buffer[m_ptr]; + + int kind = 0; + (this->*s_scan_table[ch < 128 ? ch : 128])(&kind); + + tok.start = start; + tok.length = m_ptr - start; + + return (kind == 0); +} + +void Tokenizer::scanChar(int *kind) +{ + *kind = m_buffer[m_ptr++]; +} + +void Tokenizer::scanWhiteSpaces(int *kind) +{ + *kind = Token_whitespaces; + while (unsigned char ch = m_buffer[m_ptr]) { + if (s_attr_table[ch] & A_Whitespace) + ++m_ptr; + else + break; + } +} + +void Tokenizer::scanNewline(int *kind) +{ + Q_UNUSED(kind); + const unsigned char ch = m_buffer[m_ptr++]; + // Check for \n. + if (ch == '\n') { + *kind = '\n'; + return; + } + + // Check for \r\n. + if (ch == '\r' && m_buffer[m_ptr] == '\n') { + *kind = '\n'; + ++ m_ptr; + return; + } + + *kind = ch; +} + +void Tokenizer::scanUnicodeChar(int *kind) +{ + *kind = m_buffer[m_ptr++]; +} + +void Tokenizer::scanCharLiteral(int *kind) +{ + ++m_ptr; + for (;;) { + unsigned char ch = m_buffer[m_ptr]; + switch (ch) { + case '\0': + case '\n': + // ### error + *kind = Token_char_literal; + return; + case '\\': + if (m_buffer[m_ptr+1] == '\'' || m_buffer[m_ptr+1] == '\\') + m_ptr += 2; + else + ++m_ptr; + break; + case '\'': + ++m_ptr; + *kind = Token_char_literal; + return; + default: + ++m_ptr; + break; + } + } + + // ### error + *kind = Token_char_literal; +} + +void Tokenizer::scanStringLiteral(int *kind) +{ + ++m_ptr; + while (m_buffer[m_ptr]) { + switch (m_buffer[m_ptr]) { + case '\n': + // ### error + *kind = Token_string_literal; + return; + case '\\': + if (m_buffer[m_ptr+1] == '"' || m_buffer[m_ptr+1] == '\\') + m_ptr += 2; + else + ++m_ptr; + break; + case '"': + ++m_ptr; + *kind = Token_string_literal; + return; + default: + ++m_ptr; + break; + } + } + + // ### error + *kind = Token_string_literal; +} + +void Tokenizer::scanIdentifier(int *kind) +{ + unsigned char ch; + for (;;) { + ch = m_buffer[m_ptr]; + if (s_attr_table[ch] & A_Alphanum) + ++m_ptr; + else + break; + } + *kind = Token_identifier; +} + +void Tokenizer::scanNumberLiteral(int *kind) +{ + unsigned char ch; + for (;;) { + ch = m_buffer[m_ptr]; + if (s_attr_table[ch] & A_Alphanum || ch == '.') + ++m_ptr; + else + break; + } + + // ### finish to implement me!! + *kind = Token_number_literal; +} + +void Tokenizer::scanComment(int *kind) +{ + if (!(m_buffer[m_ptr+1] == '/' || m_buffer[m_ptr+1] == '*')) { + scanOperator(kind); + return; + } + + ++m_ptr; // skip '/' + + bool multiLineComment = m_buffer[m_ptr++] == '*'; + + while (m_buffer[m_ptr]) { + switch (m_buffer[m_ptr]) { + case '\r': + case '\n': + if (!multiLineComment) { + *kind = Token_comment; + return; + } + + (void) scanNewline(kind); + break; + + case '*': + if (multiLineComment && m_buffer[m_ptr+1] == '/') { + m_ptr += 2; + *kind = Token_comment; + return; + } + ++m_ptr; + break; + + default: + ++m_ptr; + } + } + + // ### error + *kind = Token_comment; +} + + +void Tokenizer::scanPreprocessor(int *kind) +{ + ++m_ptr; + *kind = Token_preproc; +} + + +void Tokenizer::scanOperator(int *kind) +{ + switch (m_buffer[m_ptr]) { + case ':': + if (m_buffer[m_ptr+1] == ':') { + m_ptr += 2; + *kind = Token_scope; + return; + } + break; + + case '*': + case '/': + case '%': + case '^': + if (m_buffer[m_ptr+1] == '=') { + m_ptr += 2; + *kind = Token_assign; + return; + } + break; + + case '=': + case '!': + if (m_buffer[m_ptr+1] == '=') { + m_ptr += 2; + *kind = Token_eq; + return; + } + break; + + case '&': + if (m_buffer[m_ptr+1] == '&') { + m_ptr += 2; + *kind = Token_and; + return; + } else if (m_buffer[m_ptr+1] == '=') { + m_ptr += 2; + *kind = Token_assign; + return; + } + break; + + case '|': + if (m_buffer[m_ptr+1] == '|' ) { + m_ptr += 2; + *kind = Token_or; + return; + } else if (m_buffer[m_ptr+1] == '=') { + m_ptr += 2; + *kind = Token_assign; + return; + } + break; + + case '+': + if (m_buffer[m_ptr+1] == '+' ) { + m_ptr += 2; + *kind = Token_incr; + return; + } else if (m_buffer[m_ptr+1] == '=') { + m_ptr += 2; + *kind = Token_assign; + return; + } + break; + + case '<': + if (m_buffer[m_ptr+1] == '<') { + if (m_buffer[m_ptr+2] == '=') { + m_ptr += 3; + *kind = Token_assign; + return; + } + m_ptr += 2; + *kind = Token_shift; + return; + } else if (m_buffer[m_ptr+1] == '=') { + m_ptr += 2; + *kind = Token_leq; + return; + } + break; + + case '>': + if (m_buffer[m_ptr+1] == '>') { + if (m_buffer[m_ptr+2] == '=') { + m_ptr += 3; + *kind = Token_assign; + return; + } + m_ptr += 2; + *kind = Token_shift; + return; + } else if (m_buffer[m_ptr+1] == '=') { + m_ptr += 2; + *kind = Token_geq; + return; + } + break; + + case '-': + if (m_buffer[m_ptr+1] == '>') { + if (m_buffer[m_ptr+2] == '*') { + m_ptr += 3; + *kind = Token_ptrmem; + return; + } + m_ptr += 2; + *kind = Token_arrow; + return; + } else if (m_buffer[m_ptr+1] == '-') { + m_ptr += 2; + *kind = Token_decr; + return; + } else if (m_buffer[m_ptr+1] == '=') { + m_ptr += 2; + *kind = Token_assign; + return; + } + break; + + case '.': + if (m_buffer[m_ptr+1] == '.' && m_buffer[m_ptr+2] == '.') { + m_ptr += 3; + *kind = Token_ellipsis; + return; + } else if (m_buffer[m_ptr+1] == '*') { + m_ptr += 2; + *kind = Token_ptrmem; + return; + } + break; + + } + + *kind = m_buffer[m_ptr++]; +} + +QT_END_NAMESPACE diff --git a/tools/porting/src/tokenizer.h b/tools/porting/src/tokenizer.h new file mode 100644 index 0000000..7850fc0 --- /dev/null +++ b/tools/porting/src/tokenizer.h @@ -0,0 +1,88 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef TOKENIZER_H +#define TOKENIZER_H + +#include "tokenengine.h" +#include <QVector> +#include <QByteArray> + +QT_BEGIN_NAMESPACE + +class Tokenizer +{ +public: + Tokenizer(); + ~Tokenizer(); + typedef void (Tokenizer::*scan_fun_ptr)(int *kind); + QVector<TokenEngine::Token> tokenize(QByteArray text); +private: + bool nextToken(TokenEngine::Token &tok); + + void scanChar(int *kind); + void scanUnicodeChar(int *kind); + void scanNewline(int *kind); + void scanWhiteSpaces(int *kind); + void scanCharLiteral(int *kind); + void scanStringLiteral(int *kind); + void scanNumberLiteral(int *kind); + void scanIdentifier(int *kind); + void scanComment(int *kind); + void scanPreprocessor(int *kind); + void scanOperator(int *kind); + + void setupScanTable(); +private: + static bool s_initialized; + static scan_fun_ptr s_scan_table[]; + static int s_attr_table[]; + + const char *m_buffer; + int m_ptr; + + QVector<TokenEngine::Token> m_tokens; +}; + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/tokenreplacements.cpp b/tools/porting/src/tokenreplacements.cpp new file mode 100644 index 0000000..d859ab6 --- /dev/null +++ b/tools/porting/src/tokenreplacements.cpp @@ -0,0 +1,371 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "tokenreplacements.h" +#include "logger.h" +#include "portingrules.h" + +QT_BEGIN_NAMESPACE +using namespace TokenEngine; + +void addLogSourceEntry(const QString &text, const TokenContainer &tokenContainer, const int index) +{ + Logger *logger = Logger::instance(); + int line = tokenContainer.line(index); + int col = tokenContainer.column(index); + SourcePointLogEntry *logEntry = + new SourcePointLogEntry(QLatin1String("Info"), QLatin1String("Porting"), + logger->globalState.value(QLatin1String("currentFileName")), + line, col, text); + logger->addEntry(logEntry); +} + +void addLogWarning(const QString &text) +{ + Logger::instance()->addEntry(new PlainLogEntry(QLatin1String("Warning"), QLatin1String("Porting"), text)); +} + +QualifiedNameParser::QualifiedNameParser(const TokenContainer &tokenContainer, const int tokenIndex) +:tokenContainer(tokenContainer) +,currentIndex(tokenIndex) +{ + Q_ASSERT(isValidIndex(currentIndex)); +} + +bool QualifiedNameParser::isPartOfQualifiedName() +{ + return ((nextScopeToken(Left) != -1) || (nextScopeToken(Right) != -1)); +} + + +bool QualifiedNameParser::isValidIndex(int index) +{ + return (index < tokenContainer.count() && index >= 0); +} + +/* + A qualifier is a the leftmost or middle part of a qualified name +*/ +bool QualifiedNameParser::isQualifier() +{ + return (nextScopeToken(Right) != -1); +} + +/* + A name is a the rightmost part of a qualified name. +*/ +bool QualifiedNameParser::isName() +{ + return (nextScopeToken(Left) != -1); +} + +/* + Peek for a qualifier or name in the given direction +*/ +int QualifiedNameParser::peek(Direction direction) +{ + return nextScopeToken(direction); +} + +/* + Look for a qualifier or name in the given direction,update + current position if found. +*/ +int QualifiedNameParser::move(Direction direction) +{ + int tokenIndex = nextScopeToken(direction); + if(tokenIndex != -1) + currentIndex = tokenIndex; + return tokenIndex; +} + +/* + Looks for "::" starting at currentIndex, returns the token index + for it if found. If the first non-whitespace token found is something else, + -1 is returned. +*/ +int QualifiedNameParser::findScopeOperator(Direction direction) +{ + int tokenIndex = currentIndex; + QByteArray tokenText; + //loop until we get a token containing text or we pass the beginning/end of the source + tokenIndex += direction; + while(tokenText.isEmpty() && isValidIndex(tokenIndex)) { + tokenText = tokenContainer.text(tokenIndex).trimmed(); + if(tokenText==QByteArray("::")) + return tokenIndex; + tokenIndex += direction; + } + return -1; +} +/* + Walks a qualified name. Returns the token index + for the next identifer in the qualified name, or -1 if its not found. +*/ +int QualifiedNameParser::nextScopeToken(Direction direction) +{ + int tokenIndex = findScopeOperator(direction); + if (tokenIndex == -1) + return -1; + QByteArray tokenText; + //loop until we get a token containing text or we pass the start of the source + tokenIndex += direction; + while(tokenText.isEmpty() && isValidIndex(tokenIndex)) { + tokenText = tokenContainer.text(tokenIndex).trimmed(); + tokenIndex += direction; + } + return tokenIndex - direction; +} + +///////////////////// +GenericTokenReplacement::GenericTokenReplacement(QByteArray oldToken, QByteArray newToken) +:oldToken(oldToken) +,newToken(newToken) +{} + +QByteArray GenericTokenReplacement::getReplaceKey() +{ + return QByteArray(oldToken); +} + +bool GenericTokenReplacement::doReplace(const TokenContainer &tokenContainer, + int index, TextReplacements &textReplacements) +{ + QByteArray tokenText = tokenContainer.text(index); + if(tokenText == oldToken){ + addLogSourceEntry(QString::fromLatin1(tokenText + QByteArray(" -> ") + newToken), tokenContainer, index); + TokenEngine::Token token = tokenContainer.token(index); + textReplacements.insert(newToken, token.start, token.length); + return true; + } + return false; + +} + +/////////////////// +ClassNameReplacement::ClassNameReplacement(QByteArray oldToken, QByteArray newToken) +:oldToken(oldToken) +,newToken(newToken) +{} + +QByteArray ClassNameReplacement::getReplaceKey() +{ + return QByteArray(oldToken); +} + +/* + Replace a class name token. If the class name is a scope specifier (a "qualifier") + in a qualified name, we check if qualified name will be replaced by a porting rule. + If so, we don't do the class name replacement. +*/ +bool ClassNameReplacement::doReplace(const TokenContainer &tokenContainer, int index, TextReplacements &textReplacements) +{ + QByteArray tokenText = tokenContainer.text(index); + if(tokenText != oldToken) + return false; + + QualifiedNameParser nameParser(tokenContainer, index); + if(nameParser.isPartOfQualifiedName() && + nameParser.peek(QualifiedNameParser::Right) != -1) { + int nameTokenIndex = nameParser.peek(QualifiedNameParser::Right); + QByteArray name = tokenContainer.text(nameTokenIndex); + TextReplacements textReplacements; + QList<TokenReplacement*> tokenReplacements + = PortingRules::instance()->getTokenReplacementRules(); + bool changed = false; + foreach(TokenReplacement *tokenReplacement, tokenReplacements) { + changed = tokenReplacement->doReplace(tokenContainer, nameTokenIndex, textReplacements); + if(changed) + break; + } + if(changed) + return false; + } + addLogSourceEntry(QString::fromLatin1(tokenText + QByteArray(" -> ") + newToken), tokenContainer, index); + TokenEngine::Token token = tokenContainer.token(index); + textReplacements.insert(newToken, token.start, token.length); + return true; +} + +/////////////////// + +ScopedTokenReplacement::ScopedTokenReplacement(const QByteArray &oldToken, + const QByteArray &newToken) +:newScopedName(newToken) +{ + Q_ASSERT(oldToken.contains(QByteArray("::"))); + + // Split oldToken into scope and name parts. + oldName = oldToken.mid(oldToken.lastIndexOf(':')+1); + oldScope = oldToken.mid(0, oldToken.indexOf(':')); + + // Split newToken into scope and name parts, execept if we have a spcial + // case like Qt::WType_Modal -> (Qt::WType_Dialog | Qt::WShowModal) + if (newToken.count(QByteArray("::")) != 1 || newToken.contains(QByteArray("("))) { + newName = newToken; + } else { + newName = newToken.mid(newToken.lastIndexOf(':')+1); + newScope = newToken.mid(0, newToken.indexOf(':')); + } + + strictMode = Logger::instance()->globalState.contains(QString::fromLatin1("strictMode")); +} + +bool ScopedTokenReplacement::doReplace(const TokenContainer &tokenContainer, int sourceIndex, TextReplacements &textReplacements) +{ + const QByteArray sourceName = tokenContainer.text(sourceIndex); + + // Check if the token texts matches. + if (sourceName != oldName) + return false; + + // Get token attributes. The attributes are created by the the C++ parser/analyzer. + const TokenAttributes *attributes = tokenContainer.tokenAttributes(); + // If the declaration attribute is set we don't replace. + if (!attributes->attribute(sourceIndex, "declaration").isEmpty()) + return false; + // If the unknown (undeclared) attribute is set we don't replace. + if (!attributes->attribute(sourceIndex, "unknown").isEmpty()) + return false; + // If nameUse is set we test if the nameUse refers to the correct declaration. + // This is done by checking the parentScope attribute, which returns the scope + // for the declaration associated with this name use. + const bool haveNameUseInfo = !attributes->attribute(sourceIndex, "nameUse").isEmpty(); + if (haveNameUseInfo) { + if (attributes->attribute(sourceIndex, "parentScope") != oldScope) + return false; + // If the user has specified -strict, we don't replace tokens when we don't have name use info. + } else if (strictMode) { + return false; + } + + // The token might have a qualifier, and in that case we need to check if + // we should replace the qualifier as well. + QualifiedNameParser nameParser(tokenContainer, sourceIndex); + + // This is a pretty special case, it means that in a qualified + // name like aaa::bbb the replacement rule has been triggered for + // the aaa part. Since this is not what we'd normally use a + // ScopedReplacement for, we just return here. + if (nameParser.isQualifier()) + return false; + + // If the token is unqualified, just replace it. + if (!nameParser.isPartOfQualifiedName()) { + // If we have no name use info we try to avoid replacements of + // e.g. Vertical with QSizePolicy::Vertically. Unqualified tokens + // can't happen for classes one does not usually inherit from, so + // we only let them pass for stuff that people usually inherited from. + if (!haveNameUseInfo && newScope != "Qt" && newScope != "QFrame" && newScope != "QValidator") + return false; + + const Token sourceToken = tokenContainer.token(sourceIndex); + addLogSourceEntry(QString::fromLatin1(sourceName + QByteArray(" -> ") + newScopedName), tokenContainer, sourceIndex); + textReplacements.insert(newScopedName, sourceToken.start, sourceName.size()); + return true; + } + + // Peek left for the qualifer token. + const int sourceScopeIndex = nameParser.peek(QualifiedNameParser::Left); + if (sourceScopeIndex == -1) { + return false; + } + + const Token sourceNameToken = tokenContainer.token(sourceIndex); + const Token sourceScopeToken = tokenContainer.token(sourceScopeIndex); + const QByteArray sourceScope = tokenContainer.text(sourceScopeIndex); + + // If we have no name use info and the source and old scopes don't match, + // we generally don't do a replace, unless the old scope is Qt and + // the source scope inherits Qt. For example, QWidget::ButtonState should + // be renamed to Qt::ButtonState. + if (!haveNameUseInfo && sourceScope != oldScope) { + if (oldScope != "Qt") + return false; + // Check if sourceScope inherits the Qt class. + if (!PortingRules::instance()->getInheritsQt().contains(QString::fromLatin1(sourceScope.constData()))) //TODO optimize: linear search + return false; + } + + // Spcecial cases, such as QIODevice::Offset -> Q_LONGLONG + // or Qt::WType_Modal -> (Qt::WType_Dialog | Qt::WShowModal). + if (newScope.isEmpty()) { + addLogSourceEntry(QString::fromLatin1((sourceScope + QByteArray("::") + sourceName + + QByteArray(" -> ") + newScopedName).constData()), tokenContainer, sourceIndex); + const int qualiferLength = sourceNameToken.start - sourceScopeToken.start; + const int length = qualiferLength + sourceNameToken.length; + textReplacements.insert(newName, sourceScopeToken.start, length); + return true; + } + + // If the old and new scopes are equal, we replace the name part only. + if (newScope == sourceScope) { + // If the names are equal, there is no need to do anything. + if (newName == sourceName) + return true; + addLogSourceEntry(QString::fromLatin1((sourceName + QByteArray(" -> ") + newName).constData()), tokenContainer, sourceIndex); + textReplacements.insert(newName, sourceNameToken.start, sourceNameToken.length); + return true; + } + + // If the names are equal, replace scope only. + if (newName == sourceName) { + addLogSourceEntry(QString::fromLatin1((sourceScope + QByteArray(" -> ") + newScope).constData()), tokenContainer, sourceScopeIndex); + textReplacements.insert(newScope, sourceScopeToken.start, sourceScopeToken.length); + return true; + } + + // Replace scope and name. + addLogSourceEntry(QString::fromLatin1((sourceScope + QByteArray("::") + sourceName + + QByteArray(" -> ") + newScopedName).constData()), + tokenContainer, sourceScopeIndex); + textReplacements.insert(newScope, sourceScopeToken.start, sourceScopeToken.length); + textReplacements.insert(newName, sourceNameToken.start, sourceNameToken.length); + return true; +} + +QByteArray ScopedTokenReplacement::getReplaceKey() +{ + return oldName; +} + + +QT_END_NAMESPACE diff --git a/tools/porting/src/tokenreplacements.h b/tools/porting/src/tokenreplacements.h new file mode 100644 index 0000000..0f5035c --- /dev/null +++ b/tools/porting/src/tokenreplacements.h @@ -0,0 +1,154 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef TOKENREPLACEMENTS_H +#define TOKENREPLACEMENTS_H + +#include "tokenengine.h" +#include "textreplacement.h" +#include <QStringList> +#include <QByteArray> + +QT_BEGIN_NAMESPACE + +void addLogSourceEntry(const QString &text, const TokenEngine::TokenContainer&, const int index); +void addLogWarning(const QString &text); + +class TokenReplacement +{ +public: + + virtual bool doReplace(const TokenEngine::TokenContainer& , + int /*tokenIndex*/, + TextReplacements&){return false;}; + /* + returns the replace key for this replacement. Every time a token matches the replace key, + doReplace() will be called for this TokenReplacement. + */ + virtual QByteArray getReplaceKey(){return QByteArray();}; + virtual ~TokenReplacement(){}; +}; + +/* + A TokenReplacement that change any token +*/ +class GenericTokenReplacement : public TokenReplacement +{ +public: + GenericTokenReplacement(QByteArray oldToken, QByteArray newToken); + bool doReplace(const TokenEngine::TokenContainer &tokenContainer, + int tokenIndex, TextReplacements &textReplacements); + QByteArray getReplaceKey(); +private: + QByteArray oldToken; + QByteArray newToken; +}; + +/* + A TokenReplacement that changes tokens that specify class names. + In some cases where the class name token is a part of a qualified name + it is not correct to rename it. ex: + + QButton::toggleState + + Here it is wrong to rename QButton -> Q3Button, since there is + a rule that says QButton::ToggleState -> QCheckBox::ToggleState, + but no rule for Q3Button::ToggleState. +*/ +class ClassNameReplacement : public TokenReplacement +{ +public: + ClassNameReplacement(QByteArray oldToken, QByteArray newToken); + bool doReplace(const TokenEngine::TokenContainer &tokenContainer, + int tokenIndex, TextReplacements &textReplacements); + QByteArray getReplaceKey(); +private: + QByteArray oldToken; + QByteArray newToken; +}; + +/* + Changes scoped tokens: + AA::BB -> CC::DD + oldToken corresponds to the AA::BB part, newToken corresponds CC::DD. + Since this is a token replacement, the AA part of oldToken is typically + unknown. This means that we might change tokens named BB that does not belong + to the AA scope. Ast replacemnts will fix this. + +*/ +class ScopedTokenReplacement : public TokenReplacement +{ +public: + ScopedTokenReplacement(const QByteArray &oldToken, const QByteArray &newToken); + bool doReplace(const TokenEngine::TokenContainer &tokenContainer, + int tokenIndex, TextReplacements &textReplacements); + QByteArray getReplaceKey(); +private: + QByteArray oldName; + QByteArray oldScope; + QByteArray newName; + QByteArray newScope; + QByteArray newScopedName; + bool strictMode; +}; + +class QualifiedNameParser +{ +public: + QualifiedNameParser(const TokenEngine::TokenContainer &tokenContainer, + const int tokenIndex); + enum Direction { Left=-1, Right=1 }; + bool isPartOfQualifiedName(); + bool isValidIndex(int index); + bool isQualifier(); + bool isName(); + int peek(Direction direction); + int move(Direction direction); +private: + int nextScopeToken(Direction direction); + int findScopeOperator(Direction direction); + const TokenEngine::TokenContainer tokenContainer; + int currentIndex; +}; + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/tokens.h b/tools/porting/src/tokens.h new file mode 100644 index 0000000..4a4d366 --- /dev/null +++ b/tools/porting/src/tokens.h @@ -0,0 +1,186 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef TOKENS_H +#define TOKENS_H + +#include <qglobal.h> + +QT_BEGIN_NAMESPACE + +enum Type +{ + Token_eof = 0, + Token_newline = 10, + Token_identifier = 1000, + Token_number_literal, + Token_char_literal, + Token_string_literal, + Token_whitespaces, + Token_comment, + Token_preproc, + Token_line_comment, + Token_multiline_comment, + + Token_assign = 2000, + Token_ptrmem, + Token_ellipsis, + Token_scope, + Token_shift, + Token_eq, + Token_leq, + Token_geq, + Token_incr, + Token_decr, + Token_arrow, + + Token_concat, + + Token___typeof, + + Token_K_DCOP, + Token_k_dcop, + Token_k_dcop_signals, + + Token_Q_OBJECT, + Token_signals, + Token_slots, + Token_emit, + + Token_and, + Token_and_eq, + Token_asm, + Token_auto, + Token_bitand, + Token_bitor, + Token_bool, + Token_break, + Token_case, + Token_catch, + Token_char, + Token_class, + Token_compl, + Token_const, + Token_const_cast, + Token_continue, + Token_default, + Token_delete, + Token_do, + Token_double, + Token_dynamic_cast, + Token_else, + Token_enum, + Token_explicit, + Token_export, + Token_extern, + Token_false, + Token_float, + Token_for, + Token_friend, + Token_goto, + Token_if, + Token_inline, + Token_int, + Token_long, + Token_mutable, + Token_namespace, + Token_new, + Token_not, + Token_not_eq, + Token_operator, + Token_or, + Token_or_eq, + Token_private, + Token_protected, + Token_public, + Token_register, + Token_reinterpret_cast, + Token_return, + Token_short, + Token_signed, + Token_sizeof, + Token_static, + Token_static_cast, + Token_struct, + Token_switch, + Token_template, + Token_this, + Token_throw, + Token_true, + Token_try, + Token_typedef, + Token_typeid, + Token_typename, + Token_union, + Token_unsigned, + Token_using, + Token_virtual, + Token_void, + Token_volatile, + Token_wchar_t, + Token_while, + Token_xor, + Token_xor_eq, + + Token_left_shift, + Token_right_shift, + + // preprecessor + Token_directive_identifier, + Token_directive_if, + Token_directive_elif, + Token_directive_else, + Token_directive_undef, + Token_directive_endif, + Token_directive_ifdef, + Token_directive_ifndef, + Token_directive_define, + Token_directive_include, + Token_directive_line, + Token_directive_error, + Token_directive_pragma, + Token_defined +}; + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/tokenstreamadapter.h b/tools/porting/src/tokenstreamadapter.h new file mode 100644 index 0000000..28774b4 --- /dev/null +++ b/tools/porting/src/tokenstreamadapter.h @@ -0,0 +1,152 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef TOKENSTREAMADAPTER_H +#define TOKENSTREAMADAPTER_H + +#include "tokenengine.h" +#include "tokens.h" + +#include <QVector> + +QT_BEGIN_NAMESPACE + +namespace TokenStreamAdapter { +struct TokenStream +{ + TokenStream(TokenEngine::TokenSectionSequence translationUnit, QVector<Type> tokenKindList) + :m_translationUnit(translationUnit), + m_tokenKindList(tokenKindList), + m_cursor(0), + m_numTokens(tokenKindList.count()) + { + Q_ASSERT(translationUnit.count() == m_numTokens); + + // Copy out the container and containerIndex for each token so we can have + // constant time random access to it. + TokenEngine::TokenSectionSequenceIterator it(translationUnit); + while(it.nextToken()) { + m_tokenContainers.append(it.tokenContainer()); + m_containerIndices.append(it.containerIndex()); + } + } + + bool isHidden(int index) const + { + if(index >= m_numTokens) + return false; + QT_PREPEND_NAMESPACE(Type) type = m_tokenKindList.at(index); + return (type == Token_whitespaces || type == 10 /*newline*/ || + type == Token_comment || type == Token_preproc ); + } + + inline int lookAhead(int n = 0) const + { + if(m_cursor + n >= m_numTokens) + return 0; + return m_tokenKindList.at(m_cursor + n); + } + + inline int currentToken() const + { return lookAhead(); } + + inline QByteArray currentTokenText() const + { + return tokenText(m_cursor); + } + + inline TokenEngine::TokenContainer tokenContainer(int index = 0) const + { + if (index < m_numTokens) + return m_tokenContainers.at(index); + else + return TokenEngine::TokenContainer(); + } + + inline int containerIndex(int index = 0) const + { + if (index < m_numTokens) + return m_containerIndices.at(index); + else + return -1; + } + + inline QByteArray tokenText(int index = 0) const + { + if (index < m_numTokens) { + const TokenEngine::TokenContainer container = tokenContainer(index); + const int cIndex = containerIndex(index); + return container.text(cIndex); + } else { + return QByteArray(); + } + } + + inline void rewind(int index) + { m_cursor = index; } + + inline int cursor() const + { return m_cursor; } + + inline void nextToken() + { ++m_cursor; } + + inline bool tokenAtEnd() + { return m_cursor >= m_numTokens; } + + TokenEngine::TokenSectionSequence tokenSections() const + { return m_translationUnit; } + +private: + TokenEngine::TokenSectionSequence m_translationUnit; + QVector<Type> m_tokenKindList; + QList<TokenEngine::TokenContainer> m_tokenContainers; + QList<int> m_containerIndices; + int m_cursor; + int m_numTokens; +}; + +} //namespace TokenStreamAdapter + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/translationunit.cpp b/tools/porting/src/translationunit.cpp new file mode 100644 index 0000000..8a9b133 --- /dev/null +++ b/tools/porting/src/translationunit.cpp @@ -0,0 +1,102 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "translationunit.h" + +QT_BEGIN_NAMESPACE + +using namespace TokenEngine; +using namespace CodeModel; +using namespace TokenStreamAdapter; + +TranslationUnit::TranslationUnit() +{ + TokenSectionSequence empty; + d = new TranslationUnitData(empty); +} + +TranslationUnit::TranslationUnit(const TokenEngine::TokenSectionSequence &tokens) +{ d = new TranslationUnitData(tokens); } + +TokenSectionSequence TranslationUnit::tokens() const +{ return d->tokens; } + +void TranslationUnit::setCodeModel(NamespaceScope *globalScope) +{ d->globalScope = globalScope; } + +NamespaceScope *TranslationUnit::codeModel() +{ return d->globalScope; } + +TypedPool<CodeModel::Item> *TranslationUnit::codeModelMemoryPool() +{ return &d->codeModelMemoryPool; } + + + +/* + Performs C++ parsing and semantic analysis on a translation unit. + Returns a TranslationUnit, which contains all the data. +*/ +TranslationUnit TranslationUnitAnalyzer::analyze + (const TokenSectionSequence &translationUnitTokens, int targetMaxASTNodes) +{ + TranslationUnit translationUnit(translationUnitTokens); + CodeModel::NamespaceScope *codeModel = + CodeModel::Create<CodeModel::NamespaceScope>(translationUnit.codeModelMemoryPool()); + translationUnit.setCodeModel(codeModel); + + // run lexical analysis + QVector<QT_PREPEND_NAMESPACE(Type)> typeList = lexer.lex(translationUnitTokens); + TokenStreamAdapter::TokenStream tokenStream(translationUnitTokens, typeList); + + Semantic semantic(codeModel, &tokenStream, translationUnit.codeModelMemoryPool()); + + // parse and run semantic on the translation unit + bool done = false; + while(!done) { + pool p; + TranslationUnitAST *node = parser.parse(&tokenStream, &p, targetMaxASTNodes, done); + semantic.parseTranslationUnit(node); + } + + return translationUnit; +} + +QT_END_NAMESPACE diff --git a/tools/porting/src/translationunit.h b/tools/porting/src/translationunit.h new file mode 100644 index 0000000..3b10463 --- /dev/null +++ b/tools/porting/src/translationunit.h @@ -0,0 +1,93 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef TRANSLATIONUNIT_H +#define TRANSLATIONUNIT_H + +#include "tokenengine.h" +#include "tokenstreamadapter.h" +#include "ast.h" +#include "codemodel.h" +#include "smallobject.h" +#include "cpplexer.h" +#include "parser.h" +#include "semantic.h" +#include <QSharedData> + +QT_BEGIN_NAMESPACE + +class TranslationUnitData : public QSharedData +{ +public: + TranslationUnitData(const TokenEngine::TokenSectionSequence &t) + :tokens(t), globalScope(0) {}; + TokenEngine::TokenSectionSequence tokens; + CodeModel::NamespaceScope *globalScope; + TypedPool<CodeModel::Item> codeModelMemoryPool; +}; + +class TranslationUnit +{ +public: + TranslationUnit(); + TranslationUnit(const TokenEngine::TokenSectionSequence &tokens); + TokenEngine::TokenSectionSequence tokens() const; + CodeModel::NamespaceScope *codeModel(); + TypedPool<CodeModel::Item> *codeModelMemoryPool(); +private: + friend class TranslationUnitAnalyzer; + void setCodeModel(CodeModel::NamespaceScope *globalScope); + QExplicitlySharedDataPointer<TranslationUnitData> d; +}; + +class TranslationUnitAnalyzer +{ +public: + TranslationUnit analyze + (const TokenEngine::TokenSectionSequence &translationUnitTokens, int targetMaxASTNodes = 10000); +private: + CppLexer lexer; + Parser parser; +}; + +QT_END_NAMESPACE + +#endif diff --git a/tools/porting/src/treewalker.cpp b/tools/porting/src/treewalker.cpp new file mode 100644 index 0000000..fbd5fc7 --- /dev/null +++ b/tools/porting/src/treewalker.cpp @@ -0,0 +1,457 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "treewalker.h" + +QT_BEGIN_NAMESPACE + +/* +template <class T> +inline void parseAll(TreeWalker *w, const List<T *> *l) +{ + if (!l) + return; + + foreach(T *e, *l) + w->parseNode(e); +} +*/ + +//Workaround for ICE on MSVC, use macro instead of template. +#define PARSE_ALL(ListType, ListValueType) \ +inline void parseAll(TreeWalker *w, const ListType *l) \ +{ \ + if (!l) \ + return; \ + foreach(ListValueType *e, *l) \ + w->parseNode(e); \ +} \ + +PARSE_ALL(List<AST *>, AST) +PARSE_ALL(List<ClassOrNamespaceNameAST *>, ClassOrNamespaceNameAST) +PARSE_ALL(List<BaseSpecifierAST *>, BaseSpecifierAST) +PARSE_ALL(List<DeclarationAST *>, DeclarationAST) +PARSE_ALL(List<EnumeratorAST *>, EnumeratorAST) +PARSE_ALL(List<ParameterDeclarationAST *>, ParameterDeclarationAST) +PARSE_ALL(List<InitDeclaratorAST *>, InitDeclaratorAST) +PARSE_ALL(List<TemplateParameterAST *>, TemplateParameterAST) +PARSE_ALL(List<StatementAST *>, StatementAST) + + +void TreeWalker::parseTemplateArgumentList(TemplateArgumentListAST *node) +{ + List<AST *> *arglist = node->argumentList(); + parseAll(this, arglist); +} + +void TreeWalker::parseClassOrNamespaceName(ClassOrNamespaceNameAST *node) +{ + parseNode(node->name()); + parseNode(node->templateArgumentList()); +} + +void TreeWalker::parseName(NameAST *node) +{ + parseAll(this, node->classOrNamespaceNameList()); + parseNode(node->unqualifiedName()); +} + +void TreeWalker::parseTypeParameter(TypeParameterAST *node) +{ + parseNode(node->templateParameterList()); + parseNode(node->name()); + parseNode(node->typeId()); +} + +void TreeWalker::parseDeclaration(DeclarationAST *node) +{ + switch (node->nodeType()) { + case NodeType_AccessDeclaration: + parseAccessDeclaration(static_cast<AccessDeclarationAST*>(node)); + break; + case NodeType_LinkageSpecification: + parseLinkageSpecification(static_cast<LinkageSpecificationAST*>(node)); + break; + case NodeType_Namespace: + parseNamespace(static_cast<NamespaceAST*>(node)); + break; + case NodeType_NamespaceAlias: + parseNamespaceAlias(static_cast<NamespaceAliasAST*>(node)); + break; + case NodeType_Using: + parseUsing(static_cast<UsingAST*>(node)); + break; + case NodeType_UsingDirective: + parseUsingDirective(static_cast<UsingDirectiveAST*>(node)); + break; + case NodeType_Typedef: + parseTypedef(static_cast<TypedefAST*>(node)); + break; + case NodeType_TemplateDeclaration: + parseTemplateDeclaration(static_cast<TemplateDeclarationAST*>(node)); + break; + case NodeType_SimpleDeclaration: + parseSimpleDeclaration(static_cast<SimpleDeclarationAST*>(node)); + break; + case NodeType_FunctionDefinition: + parseFunctionDefinition(static_cast<FunctionDefinitionAST*>(node)); + break; + default: + break; + } +} + +void TreeWalker::parseAccessDeclaration(AccessDeclarationAST *node) +{ + parseAll(this, node->accessList()); +} + +void TreeWalker::parseTypeSpecifier(TypeSpecifierAST *node) +{ + parseNode(node->name()); + parseNode(node->cvQualify()); + parseNode(node->cv2Qualify()); + + switch (node->nodeType()) { + case NodeType_ClassSpecifier: + parseClassSpecifier(static_cast<ClassSpecifierAST*>(node)); + break; + case NodeType_EnumSpecifier: + parseEnumSpecifier(static_cast<EnumSpecifierAST*>(node)); + break; + case NodeType_ElaboratedTypeSpecifier: + parseElaboratedTypeSpecifier(static_cast<ElaboratedTypeSpecifierAST*>(node)); + break; + default: + break; + } +} + +void TreeWalker::parseBaseSpecifier(BaseSpecifierAST *node) +{ + parseNode(node->isVirtual()); + parseNode(node->access()); + parseNode(node->name()); +} + +void TreeWalker::parseBaseClause(BaseClauseAST *node) +{ + parseAll(this, node->baseSpecifierList()); +} + +void TreeWalker::parseClassSpecifier(ClassSpecifierAST *node) +{ + parseNode(node->winDeclSpec()); + parseNode(node->classKey()); + parseNode(node->baseClause()); + parseAll(this, node->declarationList()); +} + +void TreeWalker::parseEnumerator(EnumeratorAST *node) +{ + parseNode(node->id()); + parseNode(node->expression()); +} + +void TreeWalker::parseEnumSpecifier(EnumSpecifierAST *node) +{ + parseAll(this, node->enumeratorList()); +} + +void TreeWalker::parseElaboratedTypeSpecifier(ElaboratedTypeSpecifierAST *node) +{ + parseNode(node->kind()); +} + +void TreeWalker::parseLinkageBody(LinkageBodyAST *node) +{ + parseAll(this, node->declarationList()); +} + +void TreeWalker::parseLinkageSpecification(LinkageSpecificationAST *node) +{ + parseNode(node->externType()); + parseNode(node->linkageBody()); + parseNode(node->declaration()); +} + +void TreeWalker::parseNamespace(NamespaceAST *node) +{ + parseNode(node->namespaceName()); + parseNode(node->linkageBody()); +} + +void TreeWalker::parseNamespaceAlias(NamespaceAliasAST *node) +{ + parseNode(node->namespaceName()); + parseNode(node->aliasName()); +} + +void TreeWalker::parseUsing(UsingAST *node) +{ + parseNode(node->typeName()); + parseNode(node->name()); +} + +void TreeWalker::parseUsingDirective(UsingDirectiveAST *node) +{ + parseNode(node->name()); +} + +void TreeWalker::parseDeclarator(DeclaratorAST *node) +{ + parseAll(this, node->ptrOpList()); + parseNode(node->subDeclarator()); + parseNode(node->declaratorId()); + parseNode(node->bitfieldInitialization()); + parseAll(this, node->arrayDimensionList()); + parseNode(node->parameterDeclarationClause()); + parseNode(node->constant()); + parseNode(node->exceptionSpecification()); +} + +void TreeWalker::parseParameterDeclaration(ParameterDeclarationAST *node) +{ + parseNode(node->typeSpec()); + parseNode(node->declarator()); + parseNode(node->expression()); +} + +void TreeWalker::parseParameterDeclarationList(ParameterDeclarationListAST *node) +{ + parseAll(this, node->parameterList()); +} + +void TreeWalker::parseParameterDeclarationClause(ParameterDeclarationClauseAST *node) +{ + parseNode(node->parameterDeclarationList()); + parseNode(node->ellipsis()); +} + +void TreeWalker::parseInitDeclarator(InitDeclaratorAST *node) +{ + parseNode(node->declarator()); + parseNode(node->initializer()); +} + +void TreeWalker::parseInitDeclaratorList(InitDeclaratorListAST *node) +{ + parseAll(this, node->initDeclaratorList()); +} + +void TreeWalker::parseTypedef(TypedefAST *node) +{ + parseNode(node->typeSpec()); + parseNode(node->initDeclaratorList()); +} + +void TreeWalker::parseTemplateParameter(TemplateParameterAST *node) +{ + parseNode(node->typeParameter()); + parseNode(node->typeValueParameter()); +} + +void TreeWalker::parseTemplateParameterList(TemplateParameterListAST *node) +{ + parseAll(this, node->templateParameterList()); +} + +void TreeWalker::parseTemplateDeclaration(TemplateDeclarationAST *node) +{ + parseNode(node->exported()); + parseNode(node->templateParameterList()); + parseNode(node->declaration()); +} + +void TreeWalker::parseSimpleDeclaration(SimpleDeclarationAST *node) +{ + parseNode(node->functionSpecifier()); + parseNode(node->storageSpecifier()); + parseNode(node->typeSpec()); + parseNode(node->initDeclaratorList()); + parseNode(node->winDeclSpec()); +} + +void TreeWalker::parseStatement(StatementAST *node) +{ + switch (node->nodeType()) { + case NodeType_ExpressionStatement: + parseExpressionStatement(static_cast<ExpressionStatementAST*>(node)); + break; + + case NodeType_IfStatement: + parseIfStatement(static_cast<IfStatementAST*>(node)); + break; + + case NodeType_WhileStatement: + parseWhileStatement(static_cast<WhileStatementAST*>(node)); + return; + + case NodeType_DoStatement: + parseDoStatement(static_cast<DoStatementAST*>(node)); + break; + + case NodeType_ForStatement: + parseForStatement(static_cast<ForStatementAST*>(node)); + break; + + case NodeType_SwitchStatement: + parseSwitchStatement(static_cast<SwitchStatementAST*>(node)); + break; + + case NodeType_LabeledStatement: + parseLabeledStatement(static_cast<LabeledStatementAST*>(node)); + break; + + case NodeType_StatementList: + parseStatementList(static_cast<StatementListAST*>(node)); + break; + + case NodeType_DeclarationStatement: + parseDeclarationStatement(static_cast<DeclarationStatementAST*>(node)); + break; + + case NodeType_ReturnStatement: + parseReturnStatement(static_cast<ReturnStatementAST*>(node)); + break; + + default: + break; + } +} + +void TreeWalker::parseExpressionStatement(ExpressionStatementAST *node) +{ + parseNode(node->expression()); +} + +void TreeWalker::parseCondition(ConditionAST *node) +{ + parseNode(node->typeSpec()); + parseNode(node->declarator()); + parseNode(node->expression()); +} + +void TreeWalker::parseIfStatement(IfStatementAST *node) +{ + parseNode(node->condition()); + parseNode(node->statement()); + parseNode(node->elseStatement()); +} + +void TreeWalker::parseWhileStatement(WhileStatementAST *node) +{ + parseNode(node->condition()); + parseNode(node->statement()); +} + +void TreeWalker::parseDoStatement(DoStatementAST *node) +{ + parseNode(node->condition()); + parseNode(node->statement()); +} + +void TreeWalker::parseForStatement(ForStatementAST *node) +{ + parseNode(node->initStatement()); + parseNode(node->condition()); + parseNode(node->expression()); + parseNode(node->statement()); +} + +void TreeWalker::parseSwitchStatement(SwitchStatementAST *node) +{ + parseNode(node->condition()); + parseNode(node->statement()); +} + +void TreeWalker::parseLabeledStatement(LabeledStatementAST *node) +{ + parseNode(node->expression()); + parseNode(node->statement()); +} + +void TreeWalker::parseStatementList(StatementListAST *node) +{ + parseAll(this, node->statementList()); +} + +void TreeWalker::parseDeclarationStatement(DeclarationStatementAST *node) +{ + parseNode(node->declaration()); +} + +void TreeWalker::parseFunctionDefinition(FunctionDefinitionAST *node) +{ + parseNode(node->functionSpecifier()); + parseNode(node->storageSpecifier()); + parseNode(node->typeSpec()); + parseNode(node->initDeclarator()); + parseNode(node->functionBody()); + parseNode(node->winDeclSpec()); +} + +void TreeWalker::parseTranslationUnit(TranslationUnitAST *node) +{ + parseAll(this, node->declarationList()); +} + + +void TreeWalker::parseExpression(AbstractExpressionAST *node) +{ + parseAll(this, node->children()); +} + + +void TreeWalker::parseBinaryExpression(BinaryExpressionAST *node) +{ + parseNode(node->op()); + parseNode(node->leftExpression()); + parseNode(node->rightExpression()); +} + +void TreeWalker::parseReturnStatement(ReturnStatementAST *node) +{ + parseNode(node->expression()); +} + +QT_END_NAMESPACE diff --git a/tools/porting/src/treewalker.h b/tools/porting/src/treewalker.h new file mode 100644 index 0000000..d0dadb4 --- /dev/null +++ b/tools/porting/src/treewalker.h @@ -0,0 +1,235 @@ +/**************************************************************************** +** +** Copyright (C) 2001-2004 Roberto Raggi +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the qt3to4 porting application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef TREEWALKER_H +#define TREEWALKER_H + +#include "ast.h" + +QT_BEGIN_NAMESPACE + +class TreeWalker +{ +public: + TreeWalker() {} + virtual ~TreeWalker() {} + + virtual void parseNode(AST *node); + virtual void parseTemplateArgumentList(TemplateArgumentListAST *node); + virtual void parseClassOrNamespaceName(ClassOrNamespaceNameAST *node); + virtual void parseName(NameAST *node); + virtual void parseTypeParameter(TypeParameterAST *node); + virtual void parseDeclaration(DeclarationAST *node); + virtual void parseAccessDeclaration(AccessDeclarationAST *node); + virtual void parseTypeSpecifier(TypeSpecifierAST *node); + virtual void parseBaseSpecifier(BaseSpecifierAST *node); + virtual void parseBaseClause(BaseClauseAST *node); + virtual void parseClassSpecifier(ClassSpecifierAST *node); + virtual void parseEnumerator(EnumeratorAST *node); + virtual void parseEnumSpecifier(EnumSpecifierAST *node); + virtual void parseElaboratedTypeSpecifier(ElaboratedTypeSpecifierAST *node); + virtual void parseLinkageBody(LinkageBodyAST *node); + virtual void parseLinkageSpecification(LinkageSpecificationAST *node); + virtual void parseNamespace(NamespaceAST *node); + virtual void parseNamespaceAlias(NamespaceAliasAST *node); + virtual void parseUsing(UsingAST *node); + virtual void parseUsingDirective(UsingDirectiveAST *node); + virtual void parseDeclarator(DeclaratorAST *node); + virtual void parseParameterDeclaration(ParameterDeclarationAST *node); + virtual void parseParameterDeclarationList(ParameterDeclarationListAST *node); + virtual void parseParameterDeclarationClause(ParameterDeclarationClauseAST *node); + virtual void parseInitDeclarator(InitDeclaratorAST *node); + virtual void parseInitDeclaratorList(InitDeclaratorListAST *node); + virtual void parseTypedef(TypedefAST *node); + virtual void parseTemplateParameter(TemplateParameterAST *node); + virtual void parseTemplateParameterList(TemplateParameterListAST *node); + virtual void parseTemplateDeclaration(TemplateDeclarationAST *node); + virtual void parseSimpleDeclaration(SimpleDeclarationAST *node); + virtual void parseStatement(StatementAST *node); + virtual void parseExpressionStatement(ExpressionStatementAST *node); + virtual void parseCondition(ConditionAST *node); + virtual void parseIfStatement(IfStatementAST *node); + virtual void parseWhileStatement(WhileStatementAST *node); + virtual void parseDoStatement(DoStatementAST *node); + virtual void parseForStatement(ForStatementAST *node); + virtual void parseSwitchStatement(SwitchStatementAST *node); + virtual void parseLabeledStatement(LabeledStatementAST *node); + virtual void parseReturnStatement(ReturnStatementAST *node); + virtual void parseStatementList(StatementListAST *node); + virtual void parseDeclarationStatement(DeclarationStatementAST *node); + virtual void parseFunctionDefinition(FunctionDefinitionAST *node); + virtual void parseTranslationUnit(TranslationUnitAST *node); + virtual void parseExpression(AbstractExpressionAST *node); + virtual void parseBinaryExpression(BinaryExpressionAST *node); +}; + +inline void TreeWalker::parseNode(AST *node) +{ + if (!node) + return; + + switch(node->nodeType()) { + + case NodeType_Declaration: + case NodeType_AccessDeclaration: + case NodeType_LinkageSpecification: + case NodeType_Namespace: + case NodeType_NamespaceAlias: + case NodeType_Using: + case NodeType_UsingDirective: + case NodeType_Typedef: + case NodeType_TemplateDeclaration: + case NodeType_SimpleDeclaration: + case NodeType_FunctionDefinition: + parseDeclaration(static_cast<DeclarationAST*>(node)); + break; + + case NodeType_Statement: + case NodeType_ExpressionStatement: + case NodeType_IfStatement: + case NodeType_WhileStatement: + case NodeType_DoStatement: + case NodeType_ForStatement: + case NodeType_SwitchStatement: + case NodeType_LabeledStatement: + case NodeType_StatementList: + case NodeType_DeclarationStatement: + case NodeType_ReturnStatement: + parseStatement(static_cast<StatementAST*>(node)); + break; + + case NodeType_TypeSpecifier: + case NodeType_ClassSpecifier: + case NodeType_EnumSpecifier: + case NodeType_ElaboratedTypeSpecifier: + parseTypeSpecifier(static_cast<TypeSpecifierAST*>(node)); + break; + + case NodeType_TemplateArgumentList: + parseTemplateArgumentList(static_cast<TemplateArgumentListAST*>(node)); + break; + case NodeType_ClassOrNamespaceName: + parseClassOrNamespaceName(static_cast<ClassOrNamespaceNameAST*>(node)); + break; + case NodeType_Name: + parseName(static_cast<NameAST*>(node)); + break; + case NodeType_TypeParameter: + parseTypeParameter(static_cast<TypeParameterAST*>(node)); + break; + case NodeType_BaseSpecifier: + parseBaseSpecifier(static_cast<BaseSpecifierAST*>(node)); + break; + case NodeType_BaseClause: + parseBaseClause(static_cast<BaseClauseAST*>(node)); + break; + case NodeType_Enumerator: + parseEnumerator(static_cast<EnumeratorAST*>(node)); + break; + case NodeType_LinkageBody: + parseLinkageBody(static_cast<LinkageBodyAST*>(node)); + break; + case NodeType_Declarator: + parseDeclarator(static_cast<DeclaratorAST*>(node)); + break; + case NodeType_ParameterDeclaration: + parseParameterDeclaration(static_cast<ParameterDeclarationAST*>(node)); + break; + case NodeType_ParameterDeclarationList: + parseParameterDeclarationList(static_cast<ParameterDeclarationListAST*>(node)); + break; + case NodeType_ParameterDeclarationClause: + parseParameterDeclarationClause(static_cast<ParameterDeclarationClauseAST*>(node)); + break; + case NodeType_InitDeclarator: + parseInitDeclarator(static_cast<InitDeclaratorAST*>(node)); + break; + case NodeType_InitDeclaratorList: + parseInitDeclaratorList(static_cast<InitDeclaratorListAST*>(node)); + break; + case NodeType_TemplateParameter: + parseTemplateParameter(static_cast<TemplateParameterAST*>(node)); + break; + case NodeType_TemplateParameterList: + parseTemplateParameterList(static_cast<TemplateParameterListAST*>(node)); + break; + case NodeType_Condition: + parseCondition(static_cast<ConditionAST*>(node)); + break; + case NodeType_TranslationUnit: + parseTranslationUnit(static_cast<TranslationUnitAST*>(node)); + break; + + case NodeType_BinaryExpression: + parseBinaryExpression(static_cast<BinaryExpressionAST*>(node)); + break; + + case NodeType_Expression: + case NodeType_PrimaryExpression: + + case NodeType_PostfixExpression: + case NodeType_Subscripting: + case NodeType_FunctionCall: + case NodeType_ExplicitTypeConversion: + case NodeType_PseudoConstructorCall: + case NodeType_ClassMemberAccess: + case NodeType_IncrDecr: + case NodeType_CppCastExpression: + case NodeType_TypeIdentification: + + case NodeType_UnaryExpression: + case NodeType_NewExpression: + case NodeType_NewTypeId: + case NodeType_NewDeclarator: + case NodeType_NewInitializer: + case NodeType_DeleteExpression: + case NodeType_CastExpression: + case NodeType_ConditionalExpression: + case NodeType_ThrowExpression: + parseExpression(static_cast<AbstractExpressionAST*>(node)); + break; + } +} + +QT_END_NAMESPACE + +#endif // TREEWALKER_H |