|
|
/***************************************************************************
|
|
|
begin : Sat Jul 21 2001
|
|
|
copyright : (C) 2001 by Victor R<>er
|
|
|
email : victor_roeder@gmx.de
|
|
|
copyright : (C) 2002,2003 by Roberto Raggi
|
|
|
email : roberto@kdevelop.org
|
|
|
copyright : (C) 2005 by Adam Treat
|
|
|
email : manyoso@yahoo.com
|
|
|
copyright : (C) 2006 by David Nolden
|
|
|
email : david.nolden.kdevelop@art-master.de
|
|
|
***************************************************************************/
|
|
|
|
|
|
/***************************************************************************
|
|
|
* *
|
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
|
* it under the terms of the GNU General Public License as published by *
|
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
|
* (at your option) any later version. *
|
|
|
* *
|
|
|
***************************************************************************/
|
|
|
|
|
|
#ifndef CPPEVALUATION_H
|
|
|
#define CPPEVALUATION_H
|
|
|
|
|
|
#include <qvaluelist.h>
|
|
|
|
|
|
#include "expressioninfo.h"
|
|
|
#include "simpletype.h"
|
|
|
#include "declarationinfo.h"
|
|
|
#include <hashedstring.h>
|
|
|
|
|
|
class SimpleContext;
|
|
|
|
|
|
void statusBarText( const QString& str, int time = 1000 );
|
|
|
|
|
|
namespace CppEvaluation {
|
|
|
|
|
|
template <class To, class From>
|
|
|
extern QValueList<To> convertList( const QValueList<From>& from );
|
|
|
|
|
|
extern QString nameFromType( SimpleType t );
|
|
|
|
|
|
class Operator;
|
|
|
|
|
|
struct OperatorIdentification {
|
|
|
QValueList<QString> innerParams; /** Inner parameters of the operator( for the vec["hello"] the "hello" ) */
|
|
|
int start, end; /** Range the operator occupies */
|
|
|
bool found;
|
|
|
Operator* op; ///Can be 0 !
|
|
|
|
|
|
OperatorIdentification() : start( 0 ), end( 0 ), found( false ), op( 0 ) {}
|
|
|
|
|
|
operator bool() {
|
|
|
return found;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
|
|
|
class EvaluationResult {
|
|
|
public:
|
|
|
EvaluationResult& operator = ( const EvaluationResult& rhs ) {
|
|
|
resultType = rhs.resultType;
|
|
|
sourceVariable = rhs.sourceVariable;
|
|
|
expr = rhs.expr;
|
|
|
isMacro = rhs.isMacro;
|
|
|
macro = rhs.macro;
|
|
|
return *this;
|
|
|
}
|
|
|
|
|
|
EvaluationResult( const EvaluationResult& rhs ) : resultType( rhs.resultType ), expr( rhs.expr ), sourceVariable( rhs.sourceVariable ), isMacro( rhs.isMacro ), macro( rhs.macro ) {}
|
|
|
|
|
|
LocateResult resultType; ///The resulting type
|
|
|
|
|
|
ExpressionInfo expr; ///Information about the expression that was processed
|
|
|
|
|
|
DeclarationInfo sourceVariable; ///If the type comes from a variable, this stores Information about it
|
|
|
|
|
|
bool isMacro;
|
|
|
Macro macro;
|
|
|
|
|
|
///should be removed
|
|
|
EvaluationResult( SimpleType rhs ) : isMacro( false ) {
|
|
|
if ( rhs.get() != 0 )
|
|
|
resultType = rhs->desc();
|
|
|
}
|
|
|
|
|
|
EvaluationResult( LocateResult tp = TypeDesc(), DeclarationInfo var = DeclarationInfo() ) : resultType( tp ), sourceVariable( var ), isMacro( false ) {}
|
|
|
|
|
|
/*operator TypeDesc () const {
|
|
|
return (TypeDesc)resultType;
|
|
|
}*/
|
|
|
|
|
|
///This must be removed
|
|
|
operator SimpleType() const {
|
|
|
if ( resultType->resolved() ) {
|
|
|
return SimpleType( resultType->resolved() );
|
|
|
} else {
|
|
|
return SimpleType( new SimpleTypeImpl( ( TypeDesc ) resultType ) );
|
|
|
}
|
|
|
}
|
|
|
|
|
|
TypeDesc* operator -> () {
|
|
|
return & resultType.desc();
|
|
|
}
|
|
|
|
|
|
operator LocateResult () const {
|
|
|
return resultType;
|
|
|
}
|
|
|
|
|
|
operator bool() const {
|
|
|
return ( bool ) resultType;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class Operator {
|
|
|
public:
|
|
|
enum BindingSide {
|
|
|
Neutral = 0,
|
|
|
Left = 1,
|
|
|
Right = 2
|
|
|
};
|
|
|
enum Type {
|
|
|
Unary = 1,
|
|
|
Binary = 2,
|
|
|
Ternary = 3
|
|
|
};
|
|
|
|
|
|
virtual ~Operator() {}
|
|
|
|
|
|
virtual int priority() = 0;
|
|
|
|
|
|
virtual Type type() = 0;
|
|
|
virtual int paramCount() = 0;
|
|
|
|
|
|
///"binding" means that the operator needs the evaluated type of the expression on that side
|
|
|
///The types of all bound sides will later be sent in the "params"-list of the apply-function
|
|
|
virtual BindingSide binding() = 0; ///The side to which the operator binds
|
|
|
|
|
|
///When this returns true, the ident-structure must be filled correctly
|
|
|
virtual OperatorIdentification identify( QString& str ) = 0;
|
|
|
|
|
|
///params
|
|
|
virtual EvaluationResult apply( QValueList<EvaluationResult> params, QValueList<EvaluationResult> innerParams ) = 0;
|
|
|
|
|
|
virtual QString name() = 0;
|
|
|
|
|
|
///Should return whether the item it the given side can be a type(Neutral stands for the inner paremeters)
|
|
|
virtual bool canBeType( BindingSide side ) {
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
protected:
|
|
|
void log( const QString& msg );
|
|
|
QString printTypeList( QValueList<EvaluationResult>& lst );
|
|
|
};
|
|
|
|
|
|
|
|
|
class OperatorSet {
|
|
|
private:
|
|
|
typedef QValueList< Operator* > OperatorList;
|
|
|
OperatorList m_operators;
|
|
|
public:
|
|
|
OperatorSet() {}
|
|
|
|
|
|
~OperatorSet();
|
|
|
|
|
|
void registerOperator( Operator* op ) {
|
|
|
m_operators << op;
|
|
|
}
|
|
|
|
|
|
OperatorIdentification identifyOperator( const QString& str_ , Operator::BindingSide allowedBindings = ( Operator::BindingSide ) ( Operator::Left | Operator::Right | Operator::Neutral ) );
|
|
|
|
|
|
};
|
|
|
extern OperatorSet AllOperators;
|
|
|
|
|
|
|
|
|
template <class OperatorType>
|
|
|
class RegisterOperator {
|
|
|
public:
|
|
|
RegisterOperator( OperatorSet& set
|
|
|
) {
|
|
|
set.registerOperator( new OperatorType() );
|
|
|
}
|
|
|
~RegisterOperator() {}
|
|
|
}
|
|
|
;
|
|
|
|
|
|
|
|
|
class UnaryOperator : public Operator {
|
|
|
public:
|
|
|
UnaryOperator( int priority , QString identString, QString description, Operator::BindingSide binding ) : Operator(), m_priority( priority ), m_identString( identString ), m_name( description ), m_binding( binding ) {}
|
|
|
|
|
|
virtual int priority() {
|
|
|
return m_priority;
|
|
|
}
|
|
|
|
|
|
virtual Operator::Type type() {
|
|
|
return Operator::Unary;
|
|
|
}
|
|
|
|
|
|
virtual Operator::BindingSide binding() {
|
|
|
return m_binding;
|
|
|
}
|
|
|
|
|
|
virtual int paramCount() {
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
virtual OperatorIdentification identify( QString& str );
|
|
|
|
|
|
virtual EvaluationResult unaryApply( EvaluationResult param, const QValueList<EvaluationResult>& innerParams ) = 0;
|
|
|
|
|
|
virtual bool checkParams( const QValueList<EvaluationResult>& params ) {
|
|
|
return !params.isEmpty() && params[ 0 ];
|
|
|
}
|
|
|
|
|
|
virtual EvaluationResult apply( QValueList<EvaluationResult> params, QValueList<EvaluationResult> innerParams );
|
|
|
|
|
|
virtual QString name() {
|
|
|
return m_name;
|
|
|
}
|
|
|
|
|
|
private:
|
|
|
int m_priority;
|
|
|
QString m_identString;
|
|
|
QString m_name;
|
|
|
Operator::BindingSide m_binding;
|
|
|
protected:
|
|
|
|
|
|
QString identString() const {
|
|
|
return m_identString;
|
|
|
}
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
class NestedTypeOperator : public UnaryOperator {
|
|
|
public:
|
|
|
NestedTypeOperator() : UnaryOperator( 18, "::", "nested-type-operator", Operator::Left ) {}
|
|
|
|
|
|
virtual EvaluationResult unaryApply( EvaluationResult param, const QValueList<EvaluationResult>& /*innerParams*/ );
|
|
|
};
|
|
|
|
|
|
//RegisterOperator< NestedTypeOperator > NestedTypeReg( AllOperators ); ///This registers the operator to the list of all operators
|
|
|
|
|
|
class DotOperator : public UnaryOperator {
|
|
|
public:
|
|
|
DotOperator() : UnaryOperator( 17, ".", "dot-operator", Operator::Left ) {}
|
|
|
|
|
|
virtual EvaluationResult unaryApply( EvaluationResult param, const QValueList<EvaluationResult>& /*innerParams*/ );
|
|
|
|
|
|
virtual bool canBeType( BindingSide side ) {
|
|
|
return false;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
class ArrowOperator : public UnaryOperator {
|
|
|
public:
|
|
|
ArrowOperator() : UnaryOperator( 17, "->", "arrow-operator", Operator::Left ) {}
|
|
|
|
|
|
virtual EvaluationResult unaryApply( EvaluationResult param, const QValueList<EvaluationResult>& innerParams );
|
|
|
|
|
|
virtual bool canBeType( BindingSide side ) {
|
|
|
return false;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
|
|
|
class StarOperator : public UnaryOperator {
|
|
|
public:
|
|
|
StarOperator() : UnaryOperator( 15, "*", "star-operator", Operator::Right ) { ///Normally this should have a priority of 16, but that would need changes to the expression-parsin g-loop
|
|
|
}
|
|
|
|
|
|
virtual EvaluationResult unaryApply( EvaluationResult param, const QValueList<EvaluationResult>& /*innerParams*/ );
|
|
|
|
|
|
virtual bool canBeType( BindingSide side ) {
|
|
|
return false;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
|
|
|
class AddressOperator : public UnaryOperator {
|
|
|
public:
|
|
|
AddressOperator() : UnaryOperator( 16, "&", "address-operator", Operator::Right ) {}
|
|
|
|
|
|
virtual EvaluationResult unaryApply( EvaluationResult param, const QValueList<EvaluationResult>& /*innerParams*/ );
|
|
|
|
|
|
virtual bool canBeType( BindingSide side ) {
|
|
|
return false;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
|
|
|
class UnaryParenOperator : public UnaryOperator {
|
|
|
public:
|
|
|
///Identstring should be both parens, for Example "[]" or "()"
|
|
|
UnaryParenOperator( int priority , QString identString, QString description, Operator::BindingSide binding ) : UnaryOperator( priority, identString, description, binding ) {}
|
|
|
|
|
|
virtual OperatorIdentification identify( QString& str );
|
|
|
|
|
|
virtual bool canBeType( BindingSide side ) {
|
|
|
return false;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
class IndexOperator : public UnaryParenOperator {
|
|
|
public:
|
|
|
IndexOperator() : UnaryParenOperator( 17, "[]", "index-operator", Operator::Left ) {}
|
|
|
|
|
|
virtual EvaluationResult unaryApply( EvaluationResult param, const QValueList<EvaluationResult>& innerParams );
|
|
|
|
|
|
virtual bool canBeType( BindingSide side ) {
|
|
|
return false;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
|
|
|
class ParenOperator : public UnaryParenOperator {
|
|
|
public:
|
|
|
ParenOperator() : UnaryParenOperator( 16, "()", "paren-operator", Operator::Left ) {}
|
|
|
|
|
|
virtual bool checkParams( const QValueList<EvaluationResult>& params ) {
|
|
|
return !params.isEmpty();
|
|
|
}
|
|
|
|
|
|
virtual EvaluationResult unaryApply( EvaluationResult param, const QValueList<EvaluationResult>& innerParams );
|
|
|
|
|
|
virtual bool canBeType( BindingSide side ) {
|
|
|
return false;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
//This is used in CppCodeCompletion::evaluateExpression(..)
|
|
|
class ExpressionEvaluation {
|
|
|
private:
|
|
|
CppCodeCompletion* m_data;
|
|
|
SimpleContext* m_ctx;
|
|
|
ExpressionInfo m_expr;
|
|
|
bool m_global;
|
|
|
OperatorSet& m_operators;
|
|
|
HashedStringSet m_includeFiles;
|
|
|
|
|
|
public:
|
|
|
ExpressionEvaluation( CppCodeCompletion* data, ExpressionInfo expr, OperatorSet& operators, const HashedStringSet& includeFiles, SimpleContext* ctx = 0 );
|
|
|
|
|
|
EvaluationResult evaluate();
|
|
|
|
|
|
private:
|
|
|
/**
|
|
|
recursion-method:
|
|
|
1. Find the rightmost operator with the lowest priority, split the expression
|
|
|
|
|
|
vector[ (*it)->position ]().
|
|
|
*/
|
|
|
virtual EvaluationResult evaluateExpressionInternal( QString expr, EvaluationResult scope, SimpleContext * ctx, SimpleContext* innerCtx , bool canBeTypeExpression = true );
|
|
|
|
|
|
///Locates types or members
|
|
|
EvaluationResult evaluateAtomicExpression( TypeDesc expr, EvaluationResult scope, SimpleContext * ctx = 0, bool canBeTypeExpression = true );
|
|
|
};
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
#endif
|
|
|
// kate: indent-mode csands; tab-width 4;
|
