Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdevelop@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 367 insertions, 0 deletions

diff --git a/languages/cpp/cppevaluation.h b/languages/cpp/cppevaluation.h
new file mode 100644
index 00000000..e4adeb28
--- /dev/null
+++ b/languages/cpp/cppevaluation.h
@@ -0,0 +1,367 @@
+/***************************************************************************
+  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;