← Back to branch summary

~ubuntu-branches/ubuntu/karmic/kdevelop/karmic

« back to all changes in this revision

Viewing changes to languages/cpp/parser/codegenerator.h

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Thomas
  • Date: 2009-05-25 19:34:26 UTC
  • mfrom: (1.1.11 upstream) (2.3.1 experimental)
  • Revision ID: james.westby@ubuntu.com-20090525193426-hdntv90rvflyew8g
Tags: 4:3.9.93-1ubuntu1
* Merge from Debian experimental, remaining changes:
  - Conflict/replace -kde4 packages

Show diffs side-by-side

added added

removed removed

Lines of Context:
languages/cpp/parser/codegenerator.h
 
1
/*
 
2
   Copyright 2008 Hamish Rodda <rodda@kde.org>
 
3
 
 
4
   This library is free software; you can redistribute it and/or
 
5
   modify it under the terms of the GNU Library General Public
 
6
   License version 2 as published by the Free Software Foundation.
 
7
 
 
8
   This library is distributed in the hope that it will be useful,
 
9
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
11
   Library General Public License for more details.
 
12
 
 
13
   You should have received a copy of the GNU Library General Public License
 
14
   along with this library; see the file COPYING.LIB.  If not, write to
 
15
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 
16
   Boston, MA 02110-1301, USA.
 
17
*/
 
18
 
 
19
#ifndef CODEGENERATOR_H
 
20
#define CODEGENERATOR_H
 
21
 
 
22
#include <QTextStream>
 
23
#include <QString>
 
24
 
 
25
#include "default_visitor.h"
 
26
 
 
27
class Token;
 
28
 
 
29
class KDEVCPPPARSER_EXPORT CodeGenerator : public DefaultVisitor
 
30
{
 
31
public:
 
32
  CodeGenerator(ParseSession* session);
 
33
  virtual ~CodeGenerator();
 
34
 
 
35
  QString output();
 
36
 
 
37
protected:
 
38
  virtual void visitAccessSpecifier (AccessSpecifierAST*);
 
39
  virtual void visitAsmDefinition (AsmDefinitionAST*);
 
40
  virtual void visitBaseClause (BaseClauseAST*);
 
41
  virtual void visitBaseSpecifier (BaseSpecifierAST*);
 
42
  virtual void visitBinaryExpression (BinaryExpressionAST*);
 
43
  virtual void visitCastExpression (CastExpressionAST*);
 
44
  virtual void visitClassMemberAccess (ClassMemberAccessAST*);
 
45
  virtual void visitClassSpecifier (ClassSpecifierAST*);
 
46
  virtual void visitCompoundStatement (CompoundStatementAST*);
 
47
  virtual void visitCondition (ConditionAST*);
 
48
  virtual void visitConditionalExpression (ConditionalExpressionAST*);
 
49
  virtual void visitCppCastExpression (CppCastExpressionAST*);
 
50
  virtual void visitCtorInitializer (CtorInitializerAST*);
 
51
  virtual void visitDeclarationStatement (DeclarationStatementAST*);
 
52
  virtual void visitDeclarator (DeclaratorAST*);
 
53
  virtual void visitDeleteExpression (DeleteExpressionAST*);
 
54
  virtual void visitDoStatement (DoStatementAST*);
 
55
  virtual void visitElaboratedTypeSpecifier (ElaboratedTypeSpecifierAST*);
 
56
  virtual void visitEnumSpecifier (EnumSpecifierAST*);
 
57
  virtual void visitEnumerator (EnumeratorAST*);
 
58
  virtual void visitExceptionSpecification (ExceptionSpecificationAST*);
 
59
  virtual void visitExpressionOrDeclarationStatement (ExpressionOrDeclarationStatementAST*);
 
60
  virtual void visitExpressionStatement (ExpressionStatementAST*);
 
61
  virtual void visitForStatement (ForStatementAST*);
 
62
  virtual void visitFunctionCall (FunctionCallAST*);
 
63
  virtual void visitFunctionDefinition (FunctionDefinitionAST*);
 
64
  virtual void visitIfStatement (IfStatementAST*);
 
65
  virtual void visitIncrDecrExpression (IncrDecrExpressionAST*);
 
66
  virtual void visitInitDeclarator (InitDeclaratorAST*);
 
67
  virtual void visitInitializer (InitializerAST*);
 
68
  virtual void visitInitializerClause (InitializerClauseAST*);
 
69
  virtual void visitJumpStatement (JumpStatementAST*);
 
70
  virtual void visitLabeledStatement (LabeledStatementAST*);
 
71
  virtual void visitLinkageBody (LinkageBodyAST*);
 
72
  virtual void visitLinkageSpecification (LinkageSpecificationAST*);
 
73
  virtual void visitMemInitializer (MemInitializerAST*);
 
74
  virtual void visitName (NameAST*);
 
75
  virtual void visitNamespace (NamespaceAST*);
 
76
  virtual void visitNamespaceAliasDefinition (NamespaceAliasDefinitionAST*);
 
77
  virtual void visitNewDeclarator (NewDeclaratorAST*);
 
78
  virtual void visitNewExpression (NewExpressionAST*);
 
79
  virtual void visitNewInitializer (NewInitializerAST*);
 
80
  virtual void visitNewTypeId (NewTypeIdAST*);
 
81
  virtual void visitOperator (OperatorAST*);
 
82
  virtual void visitOperatorFunctionId (OperatorFunctionIdAST*);
 
83
  virtual void visitParameterDeclaration (ParameterDeclarationAST*);
 
84
  virtual void visitParameterDeclarationClause (ParameterDeclarationClauseAST*);
 
85
  virtual void visitPostfixExpression (PostfixExpressionAST*);
 
86
  virtual void visitPrimaryExpression (PrimaryExpressionAST*);
 
87
  virtual void visitPtrOperator (PtrOperatorAST*);
 
88
  virtual void visitPtrToMember (PtrToMemberAST*);
 
89
  virtual void visitReturnStatement (ReturnStatementAST*);
 
90
  virtual void visitSimpleDeclaration (SimpleDeclarationAST*);
 
91
  virtual void visitSimpleTypeSpecifier (SimpleTypeSpecifierAST*);
 
92
  virtual void visitSizeofExpression (SizeofExpressionAST*);
 
93
  virtual void visitStringLiteral (StringLiteralAST*);
 
94
  virtual void visitSubscriptExpression (SubscriptExpressionAST*);
 
95
  virtual void visitSwitchStatement (SwitchStatementAST*);
 
96
  virtual void visitTemplateArgument (TemplateArgumentAST*);
 
97
  virtual void visitTemplateDeclaration (TemplateDeclarationAST*);
 
98
  virtual void visitTemplateParameter (TemplateParameterAST*);
 
99
  virtual void visitThrowExpression (ThrowExpressionAST*);
 
100
  virtual void visitTranslationUnit (TranslationUnitAST*);
 
101
  virtual void visitTryBlockStatement (TryBlockStatementAST*);
 
102
  virtual void visitCatchStatement (CatchStatementAST*);
 
103
  virtual void visitTypeId (TypeIdAST*);
 
104
  virtual void visitTypeIdentification (TypeIdentificationAST*);
 
105
  virtual void visitTypeParameter (TypeParameterAST*);
 
106
  virtual void visitTypedef (TypedefAST*);
 
107
  virtual void visitUnaryExpression (UnaryExpressionAST*);
 
108
  virtual void visitUnqualifiedName (UnqualifiedNameAST*);
 
109
  virtual void visitUsing (UsingAST*);
 
110
  virtual void visitUsingDirective (UsingDirectiveAST*);
 
111
  virtual void visitWhileStatement (WhileStatementAST*);
 
112
  virtual void visitWinDeclSpec (WinDeclSpecAST*);
 
113
 
 
114
private:
 
115
  void outputToken(std::size_t tokenPosition);
 
116
 
 
117
  void print(const ListNode<std::size_t>* tokenList, bool followingSpace = false);
 
118
  void print(std::size_t token, bool followingSpace = false);
 
119
  void printToken(int token, bool followingSpace = false);
 
120
 
 
121
  template <class AstNode>
 
122
  void visitCommaPrint(const ListNode<AstNode>* list)
 
123
  {
 
124
    const ListNode<AstNode>* it = list->toFront(), *end = it;
 
125
    bool first = true;
 
126
    do {
 
127
      if (first) first = false; else m_output << ",";
 
128
      visit(it->element);
 
129
      it = it->next;
 
130
    } while (it != end);
 
131
  }
 
132
 
 
133
  template <class _Tp>
 
134
  void commaPrintNodes(Visitor *v, const ListNode<_Tp> *nodes, const QString& separator = QString(","))
 
135
  {
 
136
    if (!nodes)
 
137
      return;
 
138
 
 
139
    const ListNode<_Tp>
 
140
      *it = nodes->toFront(),
 
141
      *end = it;
 
142
 
 
143
    bool first = true;
 
144
 
 
145
    do
 
146
      {
 
147
        if (first) first = false; else m_output << separator;
 
148
        v->visit(it->element);
 
149
        it = it->next;
 
150
      }
 
151
    while (it != end);
 
152
  }
 
153
 
 
154
  template <class _Tp>
 
155
  void surroundPrintNodes(Visitor *v, const ListNode<_Tp> *nodes, const QString& separatorLeft, const QString& separatorRight)
 
156
  {
 
157
    if (!nodes)
 
158
      return;
 
159
 
 
160
    const ListNode<_Tp>
 
161
      *it = nodes->toFront(),
 
162
      *end = it;
 
163
 
 
164
    do
 
165
      {
 
166
        m_output << separatorLeft;
 
167
        v->visit(it->element);
 
168
        m_output << separatorRight;
 
169
        it = it->next;
 
170
      }
 
171
    while (it != end);
 
172
  }
 
173
 
 
174
  QString m_outputString;
 
175
  QTextStream m_output;
 
176
  ParseSession* m_session;
 
177
};
 
178
 
 
179
#endif // CODEGENERATOR_H