← 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: 2006-05-23 18:39:42 UTC
  • Revision ID: james.westby@ubuntu.com-20060523183942-hucifbvh68k2bwz7
Tags: upstream-3.3.2
Import upstream version 3.3.2

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 <kdebug.h>
 
22
 
 
23
TreeParser::TreeParser()
 
24
{
 
25
}
 
26
 
 
27
TreeParser::~TreeParser()
 
28
{
 
29
}
 
30
 
 
31
void TreeParser::parseTranslationUnit( TranslationUnitAST* translationUnit )
 
32
{
 
33
    //kdDebug(9007) << "TreeParser::parseTranslationUnit()" << endl;
 
34
 
 
35
    QPtrList<DeclarationAST> declarations = translationUnit->declarationList();
 
36
    QPtrListIterator<DeclarationAST> it( declarations );
 
37
    while( it.current() ){
 
38
        parseDeclaration( it.current() );
 
39
        ++it;
 
40
    }
 
41
}
 
42
 
 
43
void TreeParser::parseDeclaration( DeclarationAST* declaration )
 
44
{
 
45
    //kdDebug(9007) << "TreeParser::parseDeclaration()" << endl;
 
46
 
 
47
    if( !declaration )
 
48
        return;
 
49
 
 
50
    switch( declaration->nodeType() )
 
51
    {
 
52
    case NodeType_LinkageSpecification:
 
53
        parseLinkageSpecification( static_cast<LinkageSpecificationAST*>(declaration) );
 
54
        break;
 
55
 
 
56
    case NodeType_Namespace:
 
57
        parseNamespace( static_cast<NamespaceAST*>(declaration) );
 
58
        break;
 
59
 
 
60
    case NodeType_NamespaceAlias:
 
61
        parseNamespaceAlias( static_cast<NamespaceAliasAST*>(declaration) );
 
62
        break;
 
63
 
 
64
    case NodeType_Using:
 
65
        parseUsing( static_cast<UsingAST*>(declaration) );
 
66
        break;
 
67
 
 
68
    case NodeType_UsingDirective:
 
69
        parseUsingDirective( static_cast<UsingDirectiveAST*>(declaration) );
 
70
        break;
 
71
 
 
72
    case NodeType_Typedef:
 
73
        parseTypedef( static_cast<TypedefAST*>(declaration) );
 
74
        break;
 
75
 
 
76
    case NodeType_TemplateDeclaration:
 
77
        parseTemplateDeclaration( static_cast<TemplateDeclarationAST*>(declaration) );
 
78
        break;
 
79
 
 
80
    case NodeType_SimpleDeclaration:
 
81
        parseSimpleDeclaration( static_cast<SimpleDeclarationAST*>(declaration) );
 
82
        break;
 
83
 
 
84
    case NodeType_FunctionDefinition:
 
85
        parseFunctionDefinition( static_cast<FunctionDefinitionAST*>(declaration) );
 
86
        break;
 
87
 
 
88
    case NodeType_AccessDeclaration:
 
89
        parseAccessDeclaration( static_cast<AccessDeclarationAST*>(declaration) );
 
90
        break;
 
91
   }
 
92
}
 
93
 
 
94
void TreeParser::parseLinkageSpecification( LinkageSpecificationAST* ast )
 
95
{
 
96
    //kdDebug(9007) << "TreeParser::parseLinkageSpecification()" << endl;
 
97
    if( ast->linkageBody() )
 
98
        parseLinkageBody( ast->linkageBody() );
 
99
    else if( ast->declaration() )
 
100
        parseDeclaration( ast->declaration() );
 
101
}
 
102
 
 
103
void TreeParser::parseNamespace( NamespaceAST* decl )
 
104
{
 
105
    //kdDebug(9007) << "TreeParser::parseNamespace()" << endl;
 
106
    if( decl->linkageBody() )
 
107
        parseLinkageBody( decl->linkageBody() );
 
108
}
 
109
 
 
110
void TreeParser::parseNamespaceAlias( NamespaceAliasAST* decl )
 
111
{
 
112
    //kdDebug(9007) << "TreeParser::parseNamespaceAlias()" << endl;
 
113
    Q_UNUSED( decl );
 
114
}
 
115
 
 
116
void TreeParser::parseUsing( UsingAST* decl )
 
117
{
 
118
    //kdDebug(9007) << "TreeParser::parseUsing()" << endl;
 
119
    Q_UNUSED( decl );
 
120
}
 
121
 
 
122
void TreeParser::parseUsingDirective( UsingDirectiveAST* decl )
 
123
{
 
124
    //kdDebug(9007) << "TreeParser::parseUsingDirective()" << endl;
 
125
    Q_UNUSED( decl );
 
126
}
 
127
 
 
128
void TreeParser::parseTypedef( TypedefAST* decl )
 
129
{
 
130
    //kdDebug(9007) << "TreeParser::parseTypedef()" << endl;
 
131
    if( decl->typeSpec() )
 
132
        parseTypeSpecifier( decl->typeSpec() );
 
133
}
 
134
 
 
135
void TreeParser::parseTemplateDeclaration( TemplateDeclarationAST* decl )
 
136
{
 
137
    //kdDebug(9007) << "TreeParser::parseTemplateDeclaration()" << endl;
 
138
    Q_UNUSED( decl );
 
139
}
 
140
 
 
141
void TreeParser::parseSimpleDeclaration( SimpleDeclarationAST* decl )
 
142
{
 
143
    //kdDebug(9007) << "TreeParser::parseSimpleDeclaration()" << endl;
 
144
    Q_UNUSED( decl );
 
145
}
 
146
 
 
147
void TreeParser::parseFunctionDefinition( FunctionDefinitionAST* def )
 
148
{
 
149
    //kdDebug(9007) << "TreeParser::parseFunctionDefinition()" << endl;
 
150
    Q_UNUSED( def );
 
151
}
 
152
 
 
153
void TreeParser::parseLinkageBody( LinkageBodyAST* linkageBody )
 
154
{
 
155
    //kdDebug(9007) << "TreeParser::parseLinkageBody()" << endl;
 
156
    QPtrList<DeclarationAST> declarations = linkageBody->declarationList();
 
157
    for( QPtrListIterator<DeclarationAST> it(declarations); it.current(); ++it ){
 
158
        parseDeclaration( it.current() );
 
159
    }
 
160
}
 
161
 
 
162
void TreeParser::parseTypeSpecifier( TypeSpecifierAST* typeSpec )
 
163
{
 
164
    //kdDebug(9007) << "TreeParser::parseTypeSpecifier()" << endl;
 
165
    switch( typeSpec->nodeType() )
 
166
    {
 
167
    case NodeType_ClassSpecifier:
 
168
        parseClassSpecifier( static_cast<ClassSpecifierAST*>(typeSpec) );
 
169
        break;
 
170
 
 
171
    case NodeType_EnumSpecifier:
 
172
        parseEnumSpecifier( static_cast<EnumSpecifierAST*>(typeSpec) );
 
173
        break;
 
174
 
 
175
    case NodeType_ElaboratedTypeSpecifier:
 
176
        parseElaboratedTypeSpecifier( static_cast<ElaboratedTypeSpecifierAST*>(typeSpec) );
 
177
        break;
 
178
    }
 
179
}
 
180
 
 
181
void TreeParser::parseClassSpecifier( ClassSpecifierAST* classSpec )
 
182
{
 
183
    //kdDebug(9007) << "TreeParser::parseClassSpecifier()" << endl;
 
184
    QPtrList<DeclarationAST> declarations = classSpec->declarationList();
 
185
    for( QPtrListIterator<DeclarationAST> it(declarations); it.current(); ++it ){
 
186
        parseDeclaration( it.current() );
 
187
    }
 
188
}
 
189
 
 
190
void TreeParser::parseEnumSpecifier( EnumSpecifierAST* enumSpec )
 
191
{
 
192
    //kdDebug(9007) << "TreeParser::parseEnumSpecifier()" << endl;
 
193
    Q_UNUSED( enumSpec );
 
194
}
 
195
 
 
196
void TreeParser::parseElaboratedTypeSpecifier( ElaboratedTypeSpecifierAST* typeSpec )
 
197
{
 
198
    //kdDebug(9007) << "TreeParser::parseElaboratedTypeSpecifier()" << endl;
 
199
    Q_UNUSED( typeSpec );
 
200
}
 
201
 
 
202
void TreeParser::parseAccessDeclaration ( AccessDeclarationAST * access )
 
203
{
 
204
    //kdDebug(9007) << "TreeParser::parseAccessDeclaration()" << endl;
 
205
    Q_UNUSED( access );
 
206
}
 
207