1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
|
/***************************************************************************
* Copyright (C) 2005 by Alexander Dymo *
* adymo@kdevelop.org *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Library General Public License as *
* published by the Free Software Foundation; either version 2 of the *
* License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU Library General Public *
* License along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#ifndef TQMAKETQMAKEAST_H
#define TQMAKETQMAKEAST_H
#include <tqstringlist.h>
/**
@file qmakeast.h
Abstract Syntax Tree (AST) class declarations.
*/
namespace TQMake {
/**
AST node.
This is the base class. Objects of this type are not created by the parser.
Each AST node holds the list of its tqchildren which are always deleted in the
destructor. This way, it's possible call delete for only root AST node and
others will be deleted automatically.
Each AST node also knows how to write the information back into .pro file.
*/
class AST {
public:
/**Type of AST node.*/
enum NodeType {
ProjectAST /**<Project, scope or function scope.*/,
AssignmentAST /**<Variable assignment.*/,
NewLineAST /**<Line feed.*/,
CommentAST /**<Comment.*/,
IncludeAST /**<.pri include.*/,
OrOperatorAST /* | */
};
/**Constructs AST with given node type.*/
AST(NodeType nodeType): m_nodeType(nodeType), m_depth(0) {}
virtual ~AST();
/**Adds child AST node to this node. Despite this function is virtual,
reimplementations should call it to make automatic destruction of
AST tree possible.*/
virtual void addChildAST(AST *node);
/**Removes child AST node from this node. Despite this function is virtual,
reimplementations should call it to make automatic destruction of
AST tree possible.*/
virtual void removeChildAST(AST *node);
/**Writes information stored in the AST into the @p buffer.
This is a default implementation which iterates over child nodes
and calls writeBack for each child node.*/
virtual void writeBack(TQString &buffer);
/**@return The type of the node.*/
virtual NodeType nodeType() const { return m_nodeType; }
/**Sets the depth of the node in AST.*/
void setDepth(int depth) { m_depth = depth; }
/**@return The depth of the node in AST.*/
int depth() const { return m_depth; }
/**@return The indentation string based on node depth.*/
virtual TQString indentation();
/**The list of child AST nodes.*/
TQValueList<AST*> m_tqchildren;
protected:
NodeType m_nodeType;
private:
int m_depth;
};
/**
Project AST node.
Represents complete projects, scopes and function scopes.
Examples:
@code
scopename{
var=value
}
function(args){
var=value
}
@endcode
*/
class ProjectAST: public AST {
public:
/**The kind of a project node.*/
enum Kind {
Project /**<Project*/,
Scope /**<Scope*/,
FunctionScope /**<FunctionScope*/,
Empty /**<Project does not exist, the AST is empty*/
};
enum LineEnding {
Unix,
MacOS,
Windows
};
/**Constructs a project node of given @p kind.*/
ProjectAST(Kind kind = Project): AST(AST::ProjectAST), m_kind(kind) {}
virtual void writeBack(TQString &buffer);
/**@return true if this node is a project.*/
bool isProject() const { return m_kind == Project; }
/**@return true if this node is a scope.*/
bool isScope() const { return m_kind == Scope; }
/**@return true if this node is a function scope.*/
bool isFunctionScope() const { return m_kind == FunctionScope; }
/**@return true if this node is empty.*/
bool isEmpty() const { return m_kind == Empty; }
void setFileName(const TQString& fileName) { m_fileName = fileName; }
TQString fileName() const { return m_fileName; }
void setLineEnding( LineEnding );
LineEnding lineEnding();
/**Scoped identifier (scope name or function name).*/
TQString scopedID;
/**Function arguments. Empty for other kinds of projects.*/
TQString args;
private:
Kind m_kind;
TQString m_fileName;
LineEnding m_lineEnding;
};
/**
Assignment AST node.
Represents assignments, for example:
<pre>
var=value
</pre>
Values can be specified on several lines and
each line is stored as a string in the list of values.@n
For example, if we have in .pro:
<pre>
SOURCES=a.cpp \
b.cpp c.cpp
</pre>
then values will be stored as a two elements list:
<pre>
a.cpp
b.cpp c.cpp
</pre>
*/
class AssignmentAST: public AST {
public:
AssignmentAST(): AST(AST::AssignmentAST){}
~AssignmentAST();
virtual void writeBack(TQString &buffer);
/**Scoped name of the variable.*/
TQString scopedID;
/**Operator.*/
TQString op;
/**List of values.*/
TQStringList values;
/**Indentation of multiline values*/
TQString indent;
};
/**
New line AST node.
Represents line feeds in files.
*/
class NewLineAST: public AST {
public:
NewLineAST(): AST(AST::NewLineAST) {}
virtual void writeBack(TQString &buffer);
};
/**
Comment AST node.
Represents comments.
*/
class CommentAST: public AST {
public:
CommentAST(): AST(AST::CommentAST) {}
virtual void writeBack(TQString &buffer);
/**Comment text.*/
TQString comment;
};
/**
Include AST node.
Represents pri include.
*/
class IncludeAST: public AST {
public:
IncludeAST(): AST(AST::IncludeAST) {}
virtual void writeBack(TQString &buffer);
TQString projectName;
};
}
#endif
|
