Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
Marco Bubke
flatpak-qt-creator
Commits
b7512a2d
Commit
b7512a2d
authored
Feb 12, 2010
by
Roberto Raggi
Browse files
Removed obsolete files.
parent
04462a4e
Changes
2
Hide whitespace changes
Inline
Side-by-side
src/libs/cplusplus/NameOfExpression.cpp
deleted
100644 → 0
View file @
04462a4e
/**************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** Commercial Usage
**
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** 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.
**
** If you are unsure which license is appropriate for your use, please
** contact the sales department at http://qt.nokia.com/contact.
**
**************************************************************************/
#include
"NameOfExpression.h"
#include
"LookupContext.h"
#include
<cplusplus/Overview.h>
#include
<Control.h>
#include
<AST.h>
#include
<Scope.h>
#include
<Names.h>
#include
<Symbols.h>
#include
<Literals.h>
#include
<CoreTypes.h>
#include
<TypeVisitor.h>
#include
<NameVisitor.h>
#include
<QList>
#include
<QtDebug>
using
namespace
CPlusPlus
;
NameOfExpression
::
NameOfExpression
(
const
LookupContext
&
context
)
:
ASTVisitor
(
context
.
expressionDocument
()
->
control
()),
_context
(
context
),
sem
(
_context
.
control
())
{
}
NameOfExpression
::~
NameOfExpression
()
{
}
QList
<
FullySpecifiedType
>
ResolveExpression
::
operator
()(
ExpressionAST
*
ast
)
{
QList
<
FullySpecifiedType
>
previousResolvedSymbols
=
switchResolvedSymbols
(
QList
<
FullySpecifiedType
>
());
accept
(
ast
);
return
switchResolvedSymbols
(
previousResolvedSymbols
);
}
QList
<
FullySpecifiedType
>
ResolveExpression
::
switchResolvedSymbols
(
const
QList
<
FullySpecifiedType
>
&
symbols
)
{
QList
<
FullySpecifiedType
>
previousResolvedSymbols
=
_resolvedSymbols
;
_resolvedSymbols
=
symbols
;
return
previousResolvedSymbols
;
}
bool
ResolveExpression
::
visit
(
ExpressionListAST
*
)
{
// nothing to do.
return
false
;
}
bool
ResolveExpression
::
visit
(
BinaryExpressionAST
*
)
{
// nothing to do.
return
false
;
}
bool
ResolveExpression
::
visit
(
CastExpressionAST
*
)
{
// nothing to do.
return
false
;
}
bool
ResolveExpression
::
visit
(
ConditionAST
*
)
{
// nothing to do.
return
false
;
}
bool
ResolveExpression
::
visit
(
ConditionalExpressionAST
*
)
{
// nothing to do.
return
false
;
}
bool
ResolveExpression
::
visit
(
CppCastExpressionAST
*
)
{
// ### resolve ast->type_id
return
false
;
}
bool
ResolveExpression
::
visit
(
DeleteExpressionAST
*
)
{
// nothing to do.
return
false
;
}
bool
ResolveExpression
::
visit
(
ArrayInitializerAST
*
)
{
// nothing to do.
return
false
;
}
bool
ResolveExpression
::
visit
(
NewExpressionAST
*
)
{
// nothing to do.
return
false
;
}
bool
ResolveExpression
::
visit
(
TypeidExpressionAST
*
)
{
// nothing to do.
return
false
;
}
bool
ResolveExpression
::
visit
(
TypenameCallExpressionAST
*
)
{
// nothing to do
return
false
;
}
bool
ResolveExpression
::
visit
(
TypeConstructorCallAST
*
)
{
// nothing to do.
return
false
;
}
bool
ResolveExpression
::
visit
(
PostfixExpressionAST
*
ast
)
{
accept
(
ast
->
base_expression
);
for
(
PostfixAST
*
fx
=
ast
->
postfix_expressions
;
fx
;
fx
=
fx
->
next
)
{
accept
(
fx
);
}
return
false
;
}
bool
ResolveExpression
::
visit
(
SizeofExpressionAST
*
)
{
FullySpecifiedType
ty
(
control
()
->
integerType
(
IntegerType
::
Int
));
ty
.
setUnsigned
(
true
);
_resolvedSymbols
.
append
(
ty
);
return
false
;
}
bool
ResolveExpression
::
visit
(
NumericLiteralAST
*
)
{
_resolvedSymbols
.
append
(
control
()
->
integerType
(
IntegerType
::
Int
));
// ### handle short, long, floats, ...
return
false
;
}
bool
ResolveExpression
::
visit
(
BoolLiteralAST
*
)
{
_resolvedSymbols
.
append
(
control
()
->
integerType
(
IntegerType
::
Bool
));
return
false
;
}
bool
ResolveExpression
::
visit
(
ThisExpressionAST
*
)
{
if
(
!
_context
.
symbol
())
return
false
;
Scope
*
scope
=
_context
.
symbol
()
->
scope
();
for
(;
scope
;
scope
=
scope
->
enclosingScope
())
{
if
(
scope
->
isFunctionScope
())
{
Function
*
fun
=
scope
->
owner
()
->
asFunction
();
if
(
Scope
*
cscope
=
scope
->
enclosingClassScope
())
{
Class
*
klass
=
cscope
->
owner
()
->
asClass
();
FullySpecifiedType
classTy
(
control
()
->
namedType
(
klass
->
name
()));
FullySpecifiedType
ptrTy
(
control
()
->
pointerType
(
classTy
));
_resolvedSymbols
.
append
(
ptrTy
);
break
;
}
else
if
(
QualifiedNameId
*
q
=
fun
->
name
()
->
asQualifiedNameId
())
{
Name
*
nestedNameSpecifier
=
0
;
if
(
q
->
nameCount
()
==
2
)
nestedNameSpecifier
=
q
->
nameAt
(
0
);
else
nestedNameSpecifier
=
control
()
->
qualifiedNameId
(
&
q
->
names
()[
0
],
q
->
nameCount
()
-
1
);
FullySpecifiedType
classTy
(
control
()
->
namedType
(
nestedNameSpecifier
));
FullySpecifiedType
ptrTy
(
control
()
->
pointerType
(
classTy
));
_resolvedSymbols
.
append
(
ptrTy
);
break
;
}
}
}
return
false
;
}
bool
ResolveExpression
::
visit
(
NestedExpressionAST
*
ast
)
{
accept
(
ast
->
expression
);
return
false
;
}
bool
ResolveExpression
::
visit
(
StringLiteralAST
*
)
{
FullySpecifiedType
charTy
=
control
()
->
integerType
(
IntegerType
::
Char
);
charTy
.
setConst
(
true
);
FullySpecifiedType
ty
(
control
()
->
pointerType
(
charTy
));
_resolvedSymbols
.
append
(
ty
);
return
false
;
}
bool
ResolveExpression
::
visit
(
ThrowExpressionAST
*
)
{
return
false
;
}
bool
ResolveExpression
::
visit
(
TypeIdAST
*
)
{
return
false
;
}
bool
ResolveExpression
::
visit
(
UnaryExpressionAST
*
ast
)
{
accept
(
ast
->
expression
);
unsigned
unaryOp
=
tokenKind
(
ast
->
unary_op_token
);
if
(
unaryOp
==
T_AMPER
)
{
QMutableListIterator
<
FullySpecifiedType
>
it
(
_resolvedSymbols
);
while
(
it
.
hasNext
())
{
FullySpecifiedType
ty
=
it
.
next
();
ty
.
setType
(
control
()
->
pointerType
(
ty
));
it
.
setValue
(
ty
);
}
}
else
if
(
unaryOp
==
T_STAR
)
{
QMutableListIterator
<
FullySpecifiedType
>
it
(
_resolvedSymbols
);
while
(
it
.
hasNext
())
{
FullySpecifiedType
ty
=
it
.
next
();
if
(
PointerType
*
ptrTy
=
ty
->
asPointerType
())
{
it
.
setValue
(
ptrTy
->
elementType
());
}
else
{
it
.
remove
();
}
}
}
return
false
;
}
bool
ResolveExpression
::
visit
(
QualifiedNameAST
*
ast
)
{
Scope
dummy
;
Name
*
name
=
sem
.
check
(
ast
,
&
dummy
);
QList
<
Symbol
*>
symbols
=
_context
.
resolve
(
name
);
foreach
(
Symbol
*
symbol
,
symbols
)
{
if
(
symbol
->
isTypedef
())
{
if
(
NamedType
*
namedTy
=
symbol
->
type
()
->
asNamedType
())
{
LookupContext
symbolContext
(
symbol
,
_context
);
QList
<
Symbol
*>
resolvedClasses
=
symbolContext
.
resolveClass
(
namedTy
->
name
());
if
(
resolvedClasses
.
count
())
{
foreach
(
Symbol
*
s
,
resolvedClasses
)
{
_resolvedSymbols
.
append
(
s
->
type
());
}
continue
;
}
}
}
_resolvedSymbols
.
append
(
symbol
->
type
());
}
return
false
;
}
bool
ResolveExpression
::
visit
(
OperatorFunctionIdAST
*
)
{
return
false
;
}
bool
ResolveExpression
::
visit
(
ConversionFunctionIdAST
*
)
{
return
false
;
}
bool
ResolveExpression
::
visit
(
SimpleNameAST
*
ast
)
{
Scope
dummy
;
Name
*
name
=
sem
.
check
(
ast
,
&
dummy
);
QList
<
Symbol
*>
symbols
=
_context
.
resolve
(
name
);
foreach
(
Symbol
*
symbol
,
symbols
)
_resolvedSymbols
.
append
(
symbol
->
type
());
return
false
;
}
bool
ResolveExpression
::
visit
(
DestructorNameAST
*
)
{
FullySpecifiedType
ty
(
control
()
->
voidType
());
_resolvedSymbols
.
append
(
ty
);
return
false
;
}
bool
ResolveExpression
::
visit
(
TemplateIdAST
*
ast
)
{
Scope
dummy
;
Name
*
name
=
sem
.
check
(
ast
,
&
dummy
);
QList
<
Symbol
*>
symbols
=
_context
.
resolve
(
name
);
foreach
(
Symbol
*
symbol
,
symbols
)
_resolvedSymbols
.
append
(
symbol
->
type
());
return
false
;
}
bool
ResolveExpression
::
visit
(
CallAST
*
)
{
QMutableListIterator
<
FullySpecifiedType
>
it
(
_resolvedSymbols
);
while
(
it
.
hasNext
())
{
FullySpecifiedType
ty
=
it
.
next
();
if
(
Function
*
funTy
=
ty
->
asFunction
())
{
it
.
setValue
(
funTy
->
returnType
());
}
else
{
it
.
remove
();
}
}
return
false
;
}
bool
ResolveExpression
::
visit
(
ArrayAccessAST
*
/* ast */
)
{
QMutableListIterator
<
FullySpecifiedType
>
it
(
_resolvedSymbols
);
while
(
it
.
hasNext
())
{
FullySpecifiedType
ty
=
it
.
next
();
if
(
PointerType
*
ptrTy
=
ty
->
asPointerType
())
{
it
.
setValue
(
ptrTy
->
elementType
());
}
else
{
it
.
remove
();
}
}
return
false
;
}
bool
ResolveExpression
::
visit
(
MemberAccessAST
*
ast
)
{
Scope
dummy
;
Name
*
memberName
=
sem
.
check
(
ast
->
member_name
,
&
dummy
);
unsigned
accessOp
=
tokenKind
(
ast
->
access_token
);
Overview
overview
;
QList
<
FullySpecifiedType
>
candidates
=
_resolvedSymbols
;
_resolvedSymbols
.
clear
();
foreach
(
FullySpecifiedType
ty
,
candidates
)
{
NamedType
*
namedTy
=
0
;
if
(
accessOp
==
T_ARROW
)
{
if
(
PointerType
*
ptrTy
=
ty
->
asPointerType
())
namedTy
=
ptrTy
->
elementType
()
->
asNamedType
();
}
else
if
(
accessOp
==
T_DOT
)
{
if
(
ReferenceType
*
refTy
=
ty
->
asReferenceType
())
ty
=
refTy
->
elementType
();
namedTy
=
ty
->
asNamedType
();
if
(
!
namedTy
)
{
Function
*
fun
=
ty
->
asFunction
();
if
(
fun
&&
(
fun
->
scope
()
->
isBlockScope
()
||
fun
->
scope
()
->
isNamespaceScope
()))
namedTy
=
fun
->
returnType
()
->
asNamedType
();
}
}
if
(
namedTy
)
{
QList
<
Symbol
*>
symbols
=
_context
.
resolveClass
(
namedTy
->
name
());
if
(
symbols
.
isEmpty
())
return
false
;
Class
*
klass
=
symbols
.
first
()
->
asClass
();
QList
<
Scope
*>
allScopes
;
QSet
<
Class
*>
processed
;
QList
<
Class
*>
todo
;
todo
.
append
(
klass
);
while
(
!
todo
.
isEmpty
())
{
Class
*
klass
=
todo
.
last
();
todo
.
removeLast
();
if
(
processed
.
contains
(
klass
))
continue
;
processed
.
insert
(
klass
);
allScopes
.
append
(
klass
->
members
());
for
(
unsigned
i
=
0
;
i
<
klass
->
baseClassCount
();
++
i
)
{
BaseClass
*
baseClass
=
klass
->
baseClassAt
(
i
);
Name
*
baseClassName
=
baseClass
->
name
();
QList
<
Symbol
*>
baseClasses
=
_context
.
resolveClass
(
baseClassName
/*, allScopes*/
);
if
(
baseClasses
.
isEmpty
())
qWarning
()
<<
"unresolved base class:"
<<
overview
.
prettyName
(
baseClassName
);
foreach
(
Symbol
*
symbol
,
baseClasses
)
{
todo
.
append
(
symbol
->
asClass
());
}
}
}
QList
<
Symbol
*>
candidates
=
_context
.
resolve
(
memberName
,
allScopes
);
foreach
(
Symbol
*
candidate
,
candidates
)
{
FullySpecifiedType
ty
=
candidate
->
type
();
if
(
TemplateNameId
*
templId
=
namedTy
->
name
()
->
asTemplateNameId
())
{
Substitution
subst
;
for
(
unsigned
i
=
0
;
i
<
templId
->
templateArgumentCount
();
++
i
)
{
FullySpecifiedType
templArgTy
=
templId
->
templateArgumentAt
(
i
);
if
(
i
<
klass
->
templateParameterCount
())
{
subst
.
append
(
qMakePair
(
klass
->
templateParameterAt
(
i
)
->
name
(),
templArgTy
));
}
}
Instantiation
inst
(
control
(),
subst
);
ty
=
inst
(
ty
);
}
_resolvedSymbols
.
append
(
ty
);
}
}
}
return
false
;
}
bool
ResolveExpression
::
visit
(
PostIncrDecrAST
*
)
{
return
false
;
}
src/libs/cplusplus/NameOfExpression.h
deleted
100644 → 0
View file @
04462a4e
/**************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** Commercial Usage
**
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** 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.
**
** If you are unsure which license is appropriate for your use, please
** contact the sales department at http://qt.nokia.com/contact.
**
**************************************************************************/
#ifndef CPLUSPLUS_NAMEOFEXPRESSION_H
#define CPLUSPLUS_NAMEOFEXPRESSION_H
#include
"LookupContext.h"
#include
<ASTVisitor.h>
#include
<Semantic.h>
#include
<FullySpecifiedType.h>
namespace
CPlusPlus
{
class
CPLUSPLUS_EXPORT
NameOfExpression
:
protected
ASTVisitor
{
public:
NameOfExpression
(
const
LookupContext
&
context
);
virtual
~
NameOfExpression
();
Name
*
operator
()(
ExpressionAST
*
ast
);
protected:
QList
<
FullySpecifiedType
>
switchResolvedSymbols
(
const
QList
<
FullySpecifiedType
>
&
symbols
);
virtual
bool
visit
(
ExpressionListAST
*
ast
);
virtual
bool
visit
(
BinaryExpressionAST
*
ast
);
virtual
bool
visit
(
CastExpressionAST
*
ast
);
virtual
bool
visit
(
ConditionAST
*
ast
);
virtual
bool
visit
(
ConditionalExpressionAST
*
ast
);
virtual
bool
visit
(
CppCastExpressionAST
*
ast
);
virtual
bool
visit
(
DeleteExpressionAST
*
ast
);
virtual
bool
visit
(
ArrayInitializerAST
*
ast
);
virtual
bool
visit
(
NewExpressionAST
*
ast
);
virtual
bool
visit
(
TypeidExpressionAST
*
ast
);
virtual
bool
visit
(
TypenameCallExpressionAST
*
ast
);
virtual
bool
visit
(
TypeConstructorCallAST
*
ast
);
virtual
bool
visit
(
PostfixExpressionAST
*
ast
);
virtual
bool
visit
(
SizeofExpressionAST
*
ast
);
virtual
bool
visit
(
NumericLiteralAST
*
ast
);
virtual
bool
visit
(
BoolLiteralAST
*
ast
);
virtual
bool
visit
(
ThisExpressionAST
*
ast
);
virtual
bool
visit
(
NestedExpressionAST
*
ast
);
virtual
bool
visit
(
StringLiteralAST
*
ast
);
virtual
bool
visit
(
ThrowExpressionAST
*
ast
);
virtual
bool
visit
(
TypeIdAST
*
ast
);
virtual
bool
visit
(
UnaryExpressionAST
*
ast
);
//names
virtual
bool
visit
(
QualifiedNameAST
*
ast
);
virtual
bool
visit
(
OperatorFunctionIdAST
*
ast
);
virtual
bool
visit
(
ConversionFunctionIdAST
*
ast
);
virtual
bool
visit
(
SimpleNameAST
*
ast
);
virtual
bool
visit
(
DestructorNameAST
*
ast
);
virtual
bool
visit
(
TemplateIdAST
*
ast
);
// postfix expressions
virtual
bool
visit
(
CallAST
*
ast
);
virtual
bool
visit
(
ArrayAccessAST
*
ast
);
virtual
bool
visit
(
PostIncrDecrAST
*
ast
);
virtual
bool
visit
(
MemberAccessAST
*
ast
);
private:
LookupContext
_context
;
Semantic
sem
;
QList
<
FullySpecifiedType
>
_resolvedSymbols
;
};
}
// end of namespace CPlusPlus
#endif // CPLUSPLUS_NAMEOFEXPRESSION_H
Write
Preview
Supports
Markdown
0%
Try again
or
attach a new file
.
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment