clang  10.0.0git
Nodes.cpp
Go to the documentation of this file.
1 //===- Nodes.cpp ----------------------------------------------*- C++ -*-=====//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
10 
11 using namespace clang;
12 
13 llvm::raw_ostream &syntax::operator<<(llvm::raw_ostream &OS, NodeKind K) {
14  switch (K) {
15  case NodeKind::Leaf:
16  return OS << "Leaf";
17  case NodeKind::TranslationUnit:
18  return OS << "TranslationUnit";
19  case NodeKind::UnknownExpression:
20  return OS << "UnknownExpression";
21  case NodeKind::UnknownStatement:
22  return OS << "UnknownStatement";
23  case NodeKind::DeclarationStatement:
24  return OS << "DeclarationStatement";
25  case NodeKind::EmptyStatement:
26  return OS << "EmptyStatement";
27  case NodeKind::SwitchStatement:
28  return OS << "SwitchStatement";
29  case NodeKind::CaseStatement:
30  return OS << "CaseStatement";
31  case NodeKind::DefaultStatement:
32  return OS << "DefaultStatement";
33  case NodeKind::IfStatement:
34  return OS << "IfStatement";
35  case NodeKind::ForStatement:
36  return OS << "ForStatement";
37  case NodeKind::WhileStatement:
38  return OS << "WhileStatement";
39  case NodeKind::ContinueStatement:
40  return OS << "ContinueStatement";
41  case NodeKind::BreakStatement:
42  return OS << "BreakStatement";
43  case NodeKind::ReturnStatement:
44  return OS << "ReturnStatement";
45  case NodeKind::RangeBasedForStatement:
46  return OS << "RangeBasedForStatement";
47  case NodeKind::ExpressionStatement:
48  return OS << "ExpressionStatement";
49  case NodeKind::CompoundStatement:
50  return OS << "CompoundStatement";
51  case NodeKind::UnknownDeclaration:
52  return OS << "UnknownDeclaration";
53  case NodeKind::EmptyDeclaration:
54  return OS << "EmptyDeclaration";
55  case NodeKind::StaticAssertDeclaration:
56  return OS << "StaticAssertDeclaration";
57  case NodeKind::LinkageSpecificationDeclaration:
58  return OS << "LinkageSpecificationDeclaration";
59  case NodeKind::SimpleDeclaration:
60  return OS << "SimpleDeclaration";
61  case NodeKind::NamespaceDefinition:
62  return OS << "NamespaceDefinition";
63  case NodeKind::NamespaceAliasDefinition:
64  return OS << "NamespaceAliasDefinition";
65  case NodeKind::UsingNamespaceDirective:
66  return OS << "UsingNamespaceDirective";
67  case NodeKind::UsingDeclaration:
68  return OS << "UsingDeclaration";
69  case NodeKind::TypeAliasDeclaration:
70  return OS << "TypeAliasDeclaration";
71  }
72  llvm_unreachable("unknown node kind");
73 }
74 
75 llvm::raw_ostream &syntax::operator<<(llvm::raw_ostream &OS, NodeRole R) {
76  switch (R) {
78  return OS << "Detached";
80  return OS << "Unknown";
82  return OS << "OpenParen";
84  return OS << "CloseParen";
86  return OS << "IntroducerKeyword";
88  return OS << "BodyStatement";
90  return OS << "CaseStatement_value";
92  return OS << "IfStatement_thenStatement";
94  return OS << "IfStatement_elseKeyword";
96  return OS << "IfStatement_elseStatement";
98  return OS << "ReturnStatement_value";
100  return OS << "ExpressionStatement_expression";
102  return OS << "CompoundStatement_statement";
104  return OS << "StaticAssertDeclaration_condition";
106  return OS << "StaticAssertDeclaration_message";
107  }
108  llvm_unreachable("invalid role");
109 }
110 
112  return llvm::cast_or_null<syntax::Leaf>(
114 }
115 
117  return llvm::cast_or_null<syntax::Statement>(
119 }
120 
122  return llvm::cast_or_null<syntax::Leaf>(
124 }
125 
127  return llvm::cast_or_null<syntax::Expression>(
129 }
130 
132  return llvm::cast_or_null<syntax::Statement>(
134 }
135 
137  return llvm::cast_or_null<syntax::Leaf>(
139 }
140 
142  return llvm::cast_or_null<syntax::Statement>(
144 }
145 
147  return llvm::cast_or_null<syntax::Leaf>(
149 }
150 
152  return llvm::cast_or_null<syntax::Statement>(
154 }
155 
157  return llvm::cast_or_null<syntax::Leaf>(
159 }
160 
162  return llvm::cast_or_null<syntax::Statement>(
164 }
165 
167  return llvm::cast_or_null<syntax::Leaf>(
169 }
170 
172  return llvm::cast_or_null<syntax::Statement>(
174 }
175 
177  return llvm::cast_or_null<syntax::Leaf>(
179 }
180 
182  return llvm::cast_or_null<syntax::Statement>(
184 }
185 
187  return llvm::cast_or_null<syntax::Leaf>(
189 }
190 
192  return llvm::cast_or_null<syntax::Leaf>(
194 }
195 
197  return llvm::cast_or_null<syntax::Leaf>(
199 }
200 
202  return llvm::cast_or_null<syntax::Expression>(
204 }
205 
207  return llvm::cast_or_null<syntax::Leaf>(
209 }
210 
212  return llvm::cast_or_null<syntax::Statement>(
214 }
215 
217  return llvm::cast_or_null<syntax::Expression>(
219 }
220 
222  return llvm::cast_or_null<syntax::Leaf>(
224 }
225 
226 std::vector<syntax::Statement *> syntax::CompoundStatement::statements() {
227  std::vector<syntax::Statement *> Children;
228  for (auto *C = firstChild(); C; C = C->nextSibling()) {
230  Children.push_back(llvm::cast<syntax::Statement>(C));
231  }
232  return Children;
233 }
234 
236  return llvm::cast_or_null<syntax::Leaf>(
238 }
239 
241  return llvm::cast_or_null<syntax::Expression>(
243 }
244 
246  return llvm::cast_or_null<syntax::Expression>(
248 }
An opening parenthesis in argument lists and blocks, e.g. &#39;{&#39;, &#39;(&#39;, etc.
Children of an unknown semantic nature, e.g. skipped tokens, comments.
syntax::Expression * value()
Definition: Nodes.cpp:126
llvm::raw_ostream & operator<<(llvm::raw_ostream &OS, NodeKind K)
For debugging purposes.
Definition: Nodes.cpp:13
syntax::Leaf * continueKeyword()
Definition: Nodes.cpp:186
syntax::Leaf * caseKeyword()
Definition: Nodes.cpp:121
syntax::Statement * thenStatement()
Definition: Nodes.cpp:151
An inner statement for those that have only a single child of kind statement, e.g.
syntax::Expression * expression()
Definition: Nodes.cpp:216
syntax::Statement * elseStatement()
Definition: Nodes.cpp:161
std::vector< syntax::Statement * > statements()
FIXME: use custom iterator instead of &#39;vector&#39;.
Definition: Nodes.cpp:226
An abstract node for C++ statements, e.g.
Definition: Nodes.h:141
Node * firstChild()
Definition: Tree.h:155
syntax::Statement * body()
Definition: Nodes.cpp:116
A keywords that introduces some grammar construct, e.g. &#39;if&#39;, &#39;try&#39;, etc.
syntax::Leaf * defaultKeyword()
Definition: Nodes.cpp:136
syntax::Expression * message()
Definition: Nodes.cpp:245
syntax::Leaf * elseKeyword()
Definition: Nodes.cpp:156
A closing parenthesis in argument lists and blocks, e.g. &#39;}&#39;, &#39;)&#39;, etc.
NodeKind
A kind of a syntax node, used for implementing casts.
Definition: Nodes.h:37
syntax::Statement * body()
Definition: Nodes.cpp:181
syntax::Statement * body()
Definition: Nodes.cpp:131
syntax::Expression * condition()
Definition: Nodes.cpp:240
A node without a parent.
syntax::Leaf * forKeyword()
Definition: Nodes.cpp:166
syntax::Statement * body()
Definition: Nodes.cpp:141
syntax::Leaf * returnKeyword()
Definition: Nodes.cpp:196
syntax::Leaf * switchKeyword()
Definition: Nodes.cpp:111
syntax::Statement * body()
Definition: Nodes.cpp:211
NodeRole
A relation between a parent and child node, e.g.
Definition: Nodes.h:78
Dataflow Directional Tag Classes.
syntax::Statement * body()
Definition: Nodes.cpp:171
A leaf node points to a single token inside the expanded token stream.
Definition: Tree.h:138
A base class for all expressions.
Definition: Nodes.h:120
Defines the clang::TokenKind enum and support functions.
syntax::Leaf * whileKeyword()
Definition: Nodes.cpp:176
syntax::Leaf * ifKeyword()
Definition: Nodes.cpp:146
syntax::Leaf * breakKeyword()
Definition: Nodes.cpp:191
syntax::Node * findChild(NodeRole R)
Find the first node with a corresponding role.
Definition: Tree.cpp:255
syntax::Expression * value()
Definition: Nodes.cpp:201