← Back to branch summary

~ubuntu-branches/debian/sid/kdevelop/sid

« back to all changes in this revision

Viewing changes to lib/cppparser/tree_parser.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jeremy Lainé
  • Date: 2010-05-05 07:21:55 UTC
  • mfrom: (1.2.3 upstream) (5.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20100505072155-h78lx19pu04sbhtn
Tags: 4:4.0.0-2
http://bugs.debian.org/579947
http://bugs.debian.org/481832
http://bugs.debian.org/562410
http://bugs.debian.org/546961
* Upload to unstable (Closes: #579947, #481832).
* Acknowledge obsolete NMU fixes (Closes: #562410, #546961).

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/cppparser/tree_parser.cpp
1
 
/* This file is part of KDevelop
2
 
    Copyright (C) 2002,2003 Roberto Raggi <roberto@kdevelop.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 as published by the Free Software Foundation; either
7
 
    version 2 of the License, or (at your option) any later version.
8
 
 
9
 
    This library is distributed in the hope that it will be useful,
10
 
    but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12
 
    Library General Public License for more details.
13
 
 
14
 
    You should have received a copy of the GNU Library General Public License
15
 
    along with this library; see the file COPYING.LIB.  If not, write to
16
 
    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17
 
    Boston, MA 02111-1307, USA.
18
 
*/
19
 
 
20
 
#include "tree_parser.h"
21
 
#include "driver.h"
22
 
#include <kdebug.h>
23
 
 
24
 
TreeParser::TreeParser()
25
 
{
26
 
}
27
 
 
28
 
TreeParser::~TreeParser()
29
 
{
30
 
}
31
 
 
32
 
void TreeParser::parseTranslationUnit( const ParsedFile& translationUnit )
33
 
{
34
 
    ////kdDebug(9007) << "TreeParser::parseTranslationUnit()" << endl;
35
 
 
36
 
    QPtrList<DeclarationAST> declarations = translationUnit->declarationList();
37
 
    QPtrListIterator<DeclarationAST> it( declarations );
38
 
    while( it.current() ){
39
 
                        if( (it.current() == 0 ) ) {
40
 
                                //kdDebug( 9007 ) << "declaration is zero" << endl;
41
 
                                continue;
42
 
                        }
43
 
        parseDeclaration( it.current() );
44
 
        ++it;
45
 
    }
46
 
}
47
 
 
48
 
void TreeParser::parseDeclaration( DeclarationAST* declaration )
49
 
{
50
 
    ////kdDebug(9007) << "TreeParser::parseDeclaration()" << endl;
51
 
 
52
 
    if( !declaration )
53
 
        return;
54
 
 
55
 
    switch( declaration->nodeType() )
56
 
    {
57
 
    case NodeType_LinkageSpecification:
58
 
        parseLinkageSpecification( static_cast<LinkageSpecificationAST*>(declaration) );
59
 
        break;
60
 
 
61
 
    case NodeType_Namespace:
62
 
        parseNamespace( static_cast<NamespaceAST*>(declaration) );
63
 
        break;
64
 
 
65
 
    case NodeType_NamespaceAlias:
66
 
        parseNamespaceAlias( static_cast<NamespaceAliasAST*>(declaration) );
67
 
        break;
68
 
 
69
 
    case NodeType_Using:
70
 
        parseUsing( static_cast<UsingAST*>(declaration) );
71
 
        break;
72
 
 
73
 
    case NodeType_UsingDirective:
74
 
        parseUsingDirective( static_cast<UsingDirectiveAST*>(declaration) );
75
 
        break;
76
 
 
77
 
    case NodeType_Typedef:
78
 
        parseTypedef( static_cast<TypedefAST*>(declaration) );
79
 
        break;
80
 
 
81
 
    case NodeType_TemplateDeclaration:
82
 
        parseTemplateDeclaration( static_cast<TemplateDeclarationAST*>(declaration) );
83
 
        break;
84
 
 
85
 
    case NodeType_SimpleDeclaration:
86
 
        parseSimpleDeclaration( static_cast<SimpleDeclarationAST*>(declaration) );
87
 
        break;
88
 
 
89
 
    case NodeType_FunctionDefinition:
90
 
        parseFunctionDefinition( static_cast<FunctionDefinitionAST*>(declaration) );
91
 
        break;
92
 
 
93
 
    case NodeType_AccessDeclaration:
94
 
        parseAccessDeclaration( static_cast<AccessDeclarationAST*>(declaration) );
95
 
        break;
96
 
   }
97
 
}
98
 
 
99
 
void TreeParser::parseLinkageSpecification( LinkageSpecificationAST* ast )
100
 
{
101
 
    ////kdDebug(9007) << "TreeParser::parseLinkageSpecification()" << endl;
102
 
    if( ast->linkageBody() )
103
 
        parseLinkageBody( ast->linkageBody() );
104
 
    else if( ast->declaration() )
105
 
        parseDeclaration( ast->declaration() );
106
 
}
107
 
 
108
 
void TreeParser::parseNamespace( NamespaceAST* decl )
109
 
{
110
 
    ////kdDebug(9007) << "TreeParser::parseNamespace()" << endl;
111
 
    if( decl->linkageBody() )
112
 
        parseLinkageBody( decl->linkageBody() );
113
 
}
114
 
 
115
 
void TreeParser::parseNamespaceAlias( NamespaceAliasAST* decl )
116
 
{
117
 
    ////kdDebug(9007) << "TreeParser::parseNamespaceAlias()" << endl;
118
 
    Q_UNUSED( decl );
119
 
}
120
 
 
121
 
void TreeParser::parseUsing( UsingAST* decl )
122
 
{
123
 
    ////kdDebug(9007) << "TreeParser::parseUsing()" << endl;
124
 
    Q_UNUSED( decl );
125
 
}
126
 
 
127
 
void TreeParser::parseUsingDirective( UsingDirectiveAST* decl )
128
 
{
129
 
    ////kdDebug(9007) << "TreeParser::parseUsingDirective()" << endl;
130
 
    Q_UNUSED( decl );
131
 
}
132
 
 
133
 
void TreeParser::parseTypedef( TypedefAST* decl )
134
 
{
135
 
    ////kdDebug(9007) << "TreeParser::parseTypedef()" << endl;
136
 
    if( decl->typeSpec() )
137
 
        parseTypeSpecifier( decl->typeSpec() );
138
 
}
139
 
 
140
 
void TreeParser::parseTemplateDeclaration( TemplateDeclarationAST* decl )
141
 
{
142
 
    ////kdDebug(9007) << "TreeParser::parseTemplateDeclaration()" << endl;
143
 
    Q_UNUSED( decl );
144
 
}
145
 
 
146
 
void TreeParser::parseSimpleDeclaration( SimpleDeclarationAST* decl )
147
 
{
148
 
    ////kdDebug(9007) << "TreeParser::parseSimpleDeclaration()" << endl;
149
 
    Q_UNUSED( decl );
150
 
}
151
 
 
152
 
void TreeParser::parseFunctionDefinition( FunctionDefinitionAST* def )
153
 
{
154
 
    ////kdDebug(9007) << "TreeParser::parseFunctionDefinition()" << endl;
155
 
    Q_UNUSED( def );
156
 
}
157
 
 
158
 
void TreeParser::parseLinkageBody( LinkageBodyAST* linkageBody )
159
 
{
160
 
    ////kdDebug(9007) << "TreeParser::parseLinkageBody()" << endl;
161
 
    QPtrList<DeclarationAST> declarations = linkageBody->declarationList();
162
 
    for( QPtrListIterator<DeclarationAST> it(declarations); it.current(); ++it ){
163
 
        parseDeclaration( it.current() );
164
 
    }
165
 
}
166
 
 
167
 
void TreeParser::parseTypeSpecifier( TypeSpecifierAST* typeSpec )
168
 
{
169
 
    ////kdDebug(9007) << "TreeParser::parseTypeSpecifier()" << endl;
170
 
    switch( typeSpec->nodeType() )
171
 
    {
172
 
    case NodeType_ClassSpecifier:
173
 
        parseClassSpecifier( static_cast<ClassSpecifierAST*>(typeSpec) );
174
 
        break;
175
 
 
176
 
    case NodeType_EnumSpecifier:
177
 
        parseEnumSpecifier( static_cast<EnumSpecifierAST*>(typeSpec) );
178
 
        break;
179
 
 
180
 
    case NodeType_ElaboratedTypeSpecifier:
181
 
        parseElaboratedTypeSpecifier( static_cast<ElaboratedTypeSpecifierAST*>(typeSpec) );
182
 
        break;
183
 
    }
184
 
}
185
 
 
186
 
void TreeParser::parseClassSpecifier( ClassSpecifierAST* classSpec )
187
 
{
188
 
    ////kdDebug(9007) << "TreeParser::parseClassSpecifier()" << endl;
189
 
    QPtrList<DeclarationAST> declarations = classSpec->declarationList();
190
 
    for( QPtrListIterator<DeclarationAST> it(declarations); it.current(); ++it ){
191
 
        parseDeclaration( it.current() );
192
 
    }
193
 
}
194
 
 
195
 
void TreeParser::parseEnumSpecifier( EnumSpecifierAST* enumSpec )
196
 
{
197
 
    ////kdDebug(9007) << "TreeParser::parseEnumSpecifier()" << endl;
198
 
    Q_UNUSED( enumSpec );
199
 
}
200
 
 
201
 
void TreeParser::parseElaboratedTypeSpecifier( ElaboratedTypeSpecifierAST* typeSpec )
202
 
{
203
 
    ////kdDebug(9007) << "TreeParser::parseElaboratedTypeSpecifier()" << endl;
204
 
    Q_UNUSED( typeSpec );
205
 
}
206
 
 
207
 
void TreeParser::parseAccessDeclaration ( AccessDeclarationAST * access )
208
 
{
209
 
    ////kdDebug(9007) << "TreeParser::parseAccessDeclaration()" << endl;
210
 
    Q_UNUSED( access );
211
 
}
212