1 //===--- Stmt.cpp - Statement AST Node Implementation ---------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the Stmt class and statement subclasses.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/AST/Stmt.h"
15 #include "clang/AST/ExprCXX.h"
16 #include "clang/AST/ExprObjC.h"
17 #include "clang/AST/StmtCXX.h"
18 #include "clang/AST/StmtObjC.h"
19 #include "clang/AST/Type.h"
20 #include "clang/AST/ASTContext.h"
21 #include "clang/AST/ASTDiagnostic.h"
22 #include "clang/Basic/TargetInfo.h"
23 #include "llvm/ADT/StringExtras.h"
24 #include "llvm/Support/raw_ostream.h"
25 using namespace clang;
26
27 static struct StmtClassNameTable {
28 const char *Name;
29 unsigned Counter;
30 unsigned Size;
31 } StmtClassInfo[Stmt::lastStmtConstant+1];
32
getStmtInfoTableEntry(Stmt::StmtClass E)33 static StmtClassNameTable &getStmtInfoTableEntry(Stmt::StmtClass E) {
34 static bool Initialized = false;
35 if (Initialized)
36 return StmtClassInfo[E];
37
38 // Intialize the table on the first use.
39 Initialized = true;
40 #define ABSTRACT_STMT(STMT)
41 #define STMT(CLASS, PARENT) \
42 StmtClassInfo[(unsigned)Stmt::CLASS##Class].Name = #CLASS; \
43 StmtClassInfo[(unsigned)Stmt::CLASS##Class].Size = sizeof(CLASS);
44 #include "clang/AST/StmtNodes.inc"
45
46 return StmtClassInfo[E];
47 }
48
getStmtClassName() const49 const char *Stmt::getStmtClassName() const {
50 return getStmtInfoTableEntry((StmtClass) StmtBits.sClass).Name;
51 }
52
PrintStats()53 void Stmt::PrintStats() {
54 // Ensure the table is primed.
55 getStmtInfoTableEntry(Stmt::NullStmtClass);
56
57 unsigned sum = 0;
58 llvm::errs() << "\n*** Stmt/Expr Stats:\n";
59 for (int i = 0; i != Stmt::lastStmtConstant+1; i++) {
60 if (StmtClassInfo[i].Name == 0) continue;
61 sum += StmtClassInfo[i].Counter;
62 }
63 llvm::errs() << " " << sum << " stmts/exprs total.\n";
64 sum = 0;
65 for (int i = 0; i != Stmt::lastStmtConstant+1; i++) {
66 if (StmtClassInfo[i].Name == 0) continue;
67 if (StmtClassInfo[i].Counter == 0) continue;
68 llvm::errs() << " " << StmtClassInfo[i].Counter << " "
69 << StmtClassInfo[i].Name << ", " << StmtClassInfo[i].Size
70 << " each (" << StmtClassInfo[i].Counter*StmtClassInfo[i].Size
71 << " bytes)\n";
72 sum += StmtClassInfo[i].Counter*StmtClassInfo[i].Size;
73 }
74
75 llvm::errs() << "Total bytes = " << sum << "\n";
76 }
77
addStmtClass(StmtClass s)78 void Stmt::addStmtClass(StmtClass s) {
79 ++getStmtInfoTableEntry(s).Counter;
80 }
81
82 bool Stmt::StatisticsEnabled = false;
EnableStatistics()83 void Stmt::EnableStatistics() {
84 StatisticsEnabled = true;
85 }
86
IgnoreImplicit()87 Stmt *Stmt::IgnoreImplicit() {
88 Stmt *s = this;
89
90 if (ExprWithCleanups *ewc = dyn_cast<ExprWithCleanups>(s))
91 s = ewc->getSubExpr();
92
93 while (ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(s))
94 s = ice->getSubExpr();
95
96 return s;
97 }
98
99 /// \brief Strip off all label-like statements.
100 ///
101 /// This will strip off label statements, case statements, attributed
102 /// statements and default statements recursively.
stripLabelLikeStatements() const103 const Stmt *Stmt::stripLabelLikeStatements() const {
104 const Stmt *S = this;
105 while (true) {
106 if (const LabelStmt *LS = dyn_cast<LabelStmt>(S))
107 S = LS->getSubStmt();
108 else if (const SwitchCase *SC = dyn_cast<SwitchCase>(S))
109 S = SC->getSubStmt();
110 else if (const AttributedStmt *AS = dyn_cast<AttributedStmt>(S))
111 S = AS->getSubStmt();
112 else
113 return S;
114 }
115 }
116
117 namespace {
118 struct good {};
119 struct bad {};
120
121 // These silly little functions have to be static inline to suppress
122 // unused warnings, and they have to be defined to suppress other
123 // warnings.
is_good(good)124 static inline good is_good(good) { return good(); }
125
126 typedef Stmt::child_range children_t();
implements_children(children_t T::*)127 template <class T> good implements_children(children_t T::*) {
128 return good();
129 }
implements_children(children_t Stmt::*)130 static inline bad implements_children(children_t Stmt::*) {
131 return bad();
132 }
133
134 typedef SourceRange getSourceRange_t() const;
implements_getSourceRange(getSourceRange_t T::*)135 template <class T> good implements_getSourceRange(getSourceRange_t T::*) {
136 return good();
137 }
implements_getSourceRange(getSourceRange_t Stmt::*)138 static inline bad implements_getSourceRange(getSourceRange_t Stmt::*) {
139 return bad();
140 }
141
142 #define ASSERT_IMPLEMENTS_children(type) \
143 (void) sizeof(is_good(implements_children(&type::children)))
144 #define ASSERT_IMPLEMENTS_getSourceRange(type) \
145 (void) sizeof(is_good(implements_getSourceRange(&type::getSourceRange)))
146 }
147
148 /// Check whether the various Stmt classes implement their member
149 /// functions.
check_implementations()150 static inline void check_implementations() {
151 #define ABSTRACT_STMT(type)
152 #define STMT(type, base) \
153 ASSERT_IMPLEMENTS_children(type); \
154 ASSERT_IMPLEMENTS_getSourceRange(type);
155 #include "clang/AST/StmtNodes.inc"
156 }
157
children()158 Stmt::child_range Stmt::children() {
159 switch (getStmtClass()) {
160 case Stmt::NoStmtClass: llvm_unreachable("statement without class");
161 #define ABSTRACT_STMT(type)
162 #define STMT(type, base) \
163 case Stmt::type##Class: \
164 return static_cast<type*>(this)->children();
165 #include "clang/AST/StmtNodes.inc"
166 }
167 llvm_unreachable("unknown statement kind!");
168 }
169
getSourceRange() const170 SourceRange Stmt::getSourceRange() const {
171 switch (getStmtClass()) {
172 case Stmt::NoStmtClass: llvm_unreachable("statement without class");
173 #define ABSTRACT_STMT(type)
174 #define STMT(type, base) \
175 case Stmt::type##Class: \
176 return static_cast<const type*>(this)->getSourceRange();
177 #include "clang/AST/StmtNodes.inc"
178 }
179 llvm_unreachable("unknown statement kind!");
180 }
181
182 // Amusing macro metaprogramming hack: check whether a class provides
183 // a more specific implementation of getLocStart() and getLocEnd().
184 //
185 // See also Expr.cpp:getExprLoc().
186 namespace {
187 /// This implementation is used when a class provides a custom
188 /// implementation of getLocStart.
189 template <class S, class T>
getLocStartImpl(const Stmt * stmt,SourceLocation (T::* v)()const)190 SourceLocation getLocStartImpl(const Stmt *stmt,
191 SourceLocation (T::*v)() const) {
192 return static_cast<const S*>(stmt)->getLocStart();
193 }
194
195 /// This implementation is used when a class doesn't provide a custom
196 /// implementation of getLocStart. Overload resolution should pick it over
197 /// the implementation above because it's more specialized according to
198 /// function template partial ordering.
199 template <class S>
getLocStartImpl(const Stmt * stmt,SourceLocation (Stmt::* v)()const)200 SourceLocation getLocStartImpl(const Stmt *stmt,
201 SourceLocation (Stmt::*v)() const) {
202 return static_cast<const S*>(stmt)->getSourceRange().getBegin();
203 }
204
205 /// This implementation is used when a class provides a custom
206 /// implementation of getLocEnd.
207 template <class S, class T>
getLocEndImpl(const Stmt * stmt,SourceLocation (T::* v)()const)208 SourceLocation getLocEndImpl(const Stmt *stmt,
209 SourceLocation (T::*v)() const) {
210 return static_cast<const S*>(stmt)->getLocEnd();
211 }
212
213 /// This implementation is used when a class doesn't provide a custom
214 /// implementation of getLocEnd. Overload resolution should pick it over
215 /// the implementation above because it's more specialized according to
216 /// function template partial ordering.
217 template <class S>
getLocEndImpl(const Stmt * stmt,SourceLocation (Stmt::* v)()const)218 SourceLocation getLocEndImpl(const Stmt *stmt,
219 SourceLocation (Stmt::*v)() const) {
220 return static_cast<const S*>(stmt)->getSourceRange().getEnd();
221 }
222 }
223
getLocStart() const224 SourceLocation Stmt::getLocStart() const {
225 switch (getStmtClass()) {
226 case Stmt::NoStmtClass: llvm_unreachable("statement without class");
227 #define ABSTRACT_STMT(type)
228 #define STMT(type, base) \
229 case Stmt::type##Class: \
230 return getLocStartImpl<type>(this, &type::getLocStart);
231 #include "clang/AST/StmtNodes.inc"
232 }
233 llvm_unreachable("unknown statement kind");
234 }
235
getLocEnd() const236 SourceLocation Stmt::getLocEnd() const {
237 switch (getStmtClass()) {
238 case Stmt::NoStmtClass: llvm_unreachable("statement without class");
239 #define ABSTRACT_STMT(type)
240 #define STMT(type, base) \
241 case Stmt::type##Class: \
242 return getLocEndImpl<type>(this, &type::getLocEnd);
243 #include "clang/AST/StmtNodes.inc"
244 }
245 llvm_unreachable("unknown statement kind");
246 }
247
CompoundStmt(ASTContext & C,Stmt ** StmtStart,unsigned NumStmts,SourceLocation LB,SourceLocation RB)248 CompoundStmt::CompoundStmt(ASTContext &C, Stmt **StmtStart, unsigned NumStmts,
249 SourceLocation LB, SourceLocation RB)
250 : Stmt(CompoundStmtClass), LBracLoc(LB), RBracLoc(RB) {
251 CompoundStmtBits.NumStmts = NumStmts;
252 assert(CompoundStmtBits.NumStmts == NumStmts &&
253 "NumStmts doesn't fit in bits of CompoundStmtBits.NumStmts!");
254
255 if (NumStmts == 0) {
256 Body = 0;
257 return;
258 }
259
260 Body = new (C) Stmt*[NumStmts];
261 memcpy(Body, StmtStart, NumStmts * sizeof(*Body));
262 }
263
setStmts(ASTContext & C,Stmt ** Stmts,unsigned NumStmts)264 void CompoundStmt::setStmts(ASTContext &C, Stmt **Stmts, unsigned NumStmts) {
265 if (this->Body)
266 C.Deallocate(Body);
267 this->CompoundStmtBits.NumStmts = NumStmts;
268
269 Body = new (C) Stmt*[NumStmts];
270 memcpy(Body, Stmts, sizeof(Stmt *) * NumStmts);
271 }
272
getName() const273 const char *LabelStmt::getName() const {
274 return getDecl()->getIdentifier()->getNameStart();
275 }
276
Create(ASTContext & C,SourceLocation Loc,ArrayRef<const Attr * > Attrs,Stmt * SubStmt)277 AttributedStmt *AttributedStmt::Create(ASTContext &C, SourceLocation Loc,
278 ArrayRef<const Attr*> Attrs,
279 Stmt *SubStmt) {
280 void *Mem = C.Allocate(sizeof(AttributedStmt) +
281 sizeof(Attr*) * (Attrs.size() - 1),
282 llvm::alignOf<AttributedStmt>());
283 return new (Mem) AttributedStmt(Loc, Attrs, SubStmt);
284 }
285
CreateEmpty(ASTContext & C,unsigned NumAttrs)286 AttributedStmt *AttributedStmt::CreateEmpty(ASTContext &C, unsigned NumAttrs) {
287 assert(NumAttrs > 0 && "NumAttrs should be greater than zero");
288 void *Mem = C.Allocate(sizeof(AttributedStmt) +
289 sizeof(Attr*) * (NumAttrs - 1),
290 llvm::alignOf<AttributedStmt>());
291 return new (Mem) AttributedStmt(EmptyShell(), NumAttrs);
292 }
293
294 // This is defined here to avoid polluting Stmt.h with importing Expr.h
getSourceRange() const295 SourceRange ReturnStmt::getSourceRange() const {
296 if (RetExpr)
297 return SourceRange(RetLoc, RetExpr->getLocEnd());
298 else
299 return SourceRange(RetLoc);
300 }
301
hasImplicitControlFlow() const302 bool Stmt::hasImplicitControlFlow() const {
303 switch (StmtBits.sClass) {
304 default:
305 return false;
306
307 case CallExprClass:
308 case ConditionalOperatorClass:
309 case ChooseExprClass:
310 case StmtExprClass:
311 case DeclStmtClass:
312 return true;
313
314 case Stmt::BinaryOperatorClass: {
315 const BinaryOperator* B = cast<BinaryOperator>(this);
316 if (B->isLogicalOp() || B->getOpcode() == BO_Comma)
317 return true;
318 else
319 return false;
320 }
321 }
322 }
323
generateAsmString(ASTContext & C) const324 std::string AsmStmt::generateAsmString(ASTContext &C) const {
325 if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
326 return gccAsmStmt->generateAsmString(C);
327 if (const MSAsmStmt *msAsmStmt = dyn_cast<MSAsmStmt>(this))
328 return msAsmStmt->generateAsmString(C);
329 llvm_unreachable("unknown asm statement kind!");
330 }
331
getOutputConstraint(unsigned i) const332 StringRef AsmStmt::getOutputConstraint(unsigned i) const {
333 if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
334 return gccAsmStmt->getOutputConstraint(i);
335 if (const MSAsmStmt *msAsmStmt = dyn_cast<MSAsmStmt>(this))
336 return msAsmStmt->getOutputConstraint(i);
337 llvm_unreachable("unknown asm statement kind!");
338 }
339
getOutputExpr(unsigned i) const340 const Expr *AsmStmt::getOutputExpr(unsigned i) const {
341 if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
342 return gccAsmStmt->getOutputExpr(i);
343 if (const MSAsmStmt *msAsmStmt = dyn_cast<MSAsmStmt>(this))
344 return msAsmStmt->getOutputExpr(i);
345 llvm_unreachable("unknown asm statement kind!");
346 }
347
getInputConstraint(unsigned i) const348 StringRef AsmStmt::getInputConstraint(unsigned i) const {
349 if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
350 return gccAsmStmt->getInputConstraint(i);
351 if (const MSAsmStmt *msAsmStmt = dyn_cast<MSAsmStmt>(this))
352 return msAsmStmt->getInputConstraint(i);
353 llvm_unreachable("unknown asm statement kind!");
354 }
355
getInputExpr(unsigned i) const356 const Expr *AsmStmt::getInputExpr(unsigned i) const {
357 if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
358 return gccAsmStmt->getInputExpr(i);
359 if (const MSAsmStmt *msAsmStmt = dyn_cast<MSAsmStmt>(this))
360 return msAsmStmt->getInputExpr(i);
361 llvm_unreachable("unknown asm statement kind!");
362 }
363
getClobber(unsigned i) const364 StringRef AsmStmt::getClobber(unsigned i) const {
365 if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
366 return gccAsmStmt->getClobber(i);
367 if (const MSAsmStmt *msAsmStmt = dyn_cast<MSAsmStmt>(this))
368 return msAsmStmt->getClobber(i);
369 llvm_unreachable("unknown asm statement kind!");
370 }
371
372 /// getNumPlusOperands - Return the number of output operands that have a "+"
373 /// constraint.
getNumPlusOperands() const374 unsigned AsmStmt::getNumPlusOperands() const {
375 unsigned Res = 0;
376 for (unsigned i = 0, e = getNumOutputs(); i != e; ++i)
377 if (isOutputPlusConstraint(i))
378 ++Res;
379 return Res;
380 }
381
getClobber(unsigned i) const382 StringRef GCCAsmStmt::getClobber(unsigned i) const {
383 return getClobberStringLiteral(i)->getString();
384 }
385
getOutputExpr(unsigned i)386 Expr *GCCAsmStmt::getOutputExpr(unsigned i) {
387 return cast<Expr>(Exprs[i]);
388 }
389
390 /// getOutputConstraint - Return the constraint string for the specified
391 /// output operand. All output constraints are known to be non-empty (either
392 /// '=' or '+').
getOutputConstraint(unsigned i) const393 StringRef GCCAsmStmt::getOutputConstraint(unsigned i) const {
394 return getOutputConstraintLiteral(i)->getString();
395 }
396
getInputExpr(unsigned i)397 Expr *GCCAsmStmt::getInputExpr(unsigned i) {
398 return cast<Expr>(Exprs[i + NumOutputs]);
399 }
setInputExpr(unsigned i,Expr * E)400 void GCCAsmStmt::setInputExpr(unsigned i, Expr *E) {
401 Exprs[i + NumOutputs] = E;
402 }
403
404 /// getInputConstraint - Return the specified input constraint. Unlike output
405 /// constraints, these can be empty.
getInputConstraint(unsigned i) const406 StringRef GCCAsmStmt::getInputConstraint(unsigned i) const {
407 return getInputConstraintLiteral(i)->getString();
408 }
409
setOutputsAndInputsAndClobbers(ASTContext & C,IdentifierInfo ** Names,StringLiteral ** Constraints,Stmt ** Exprs,unsigned NumOutputs,unsigned NumInputs,StringLiteral ** Clobbers,unsigned NumClobbers)410 void GCCAsmStmt::setOutputsAndInputsAndClobbers(ASTContext &C,
411 IdentifierInfo **Names,
412 StringLiteral **Constraints,
413 Stmt **Exprs,
414 unsigned NumOutputs,
415 unsigned NumInputs,
416 StringLiteral **Clobbers,
417 unsigned NumClobbers) {
418 this->NumOutputs = NumOutputs;
419 this->NumInputs = NumInputs;
420 this->NumClobbers = NumClobbers;
421
422 unsigned NumExprs = NumOutputs + NumInputs;
423
424 C.Deallocate(this->Names);
425 this->Names = new (C) IdentifierInfo*[NumExprs];
426 std::copy(Names, Names + NumExprs, this->Names);
427
428 C.Deallocate(this->Exprs);
429 this->Exprs = new (C) Stmt*[NumExprs];
430 std::copy(Exprs, Exprs + NumExprs, this->Exprs);
431
432 C.Deallocate(this->Constraints);
433 this->Constraints = new (C) StringLiteral*[NumExprs];
434 std::copy(Constraints, Constraints + NumExprs, this->Constraints);
435
436 C.Deallocate(this->Clobbers);
437 this->Clobbers = new (C) StringLiteral*[NumClobbers];
438 std::copy(Clobbers, Clobbers + NumClobbers, this->Clobbers);
439 }
440
441 /// getNamedOperand - Given a symbolic operand reference like %[foo],
442 /// translate this into a numeric value needed to reference the same operand.
443 /// This returns -1 if the operand name is invalid.
getNamedOperand(StringRef SymbolicName) const444 int GCCAsmStmt::getNamedOperand(StringRef SymbolicName) const {
445 unsigned NumPlusOperands = 0;
446
447 // Check if this is an output operand.
448 for (unsigned i = 0, e = getNumOutputs(); i != e; ++i) {
449 if (getOutputName(i) == SymbolicName)
450 return i;
451 }
452
453 for (unsigned i = 0, e = getNumInputs(); i != e; ++i)
454 if (getInputName(i) == SymbolicName)
455 return getNumOutputs() + NumPlusOperands + i;
456
457 // Not found.
458 return -1;
459 }
460
461 /// AnalyzeAsmString - Analyze the asm string of the current asm, decomposing
462 /// it into pieces. If the asm string is erroneous, emit errors and return
463 /// true, otherwise return false.
AnalyzeAsmString(SmallVectorImpl<AsmStringPiece> & Pieces,ASTContext & C,unsigned & DiagOffs) const464 unsigned GCCAsmStmt::AnalyzeAsmString(SmallVectorImpl<AsmStringPiece>&Pieces,
465 ASTContext &C, unsigned &DiagOffs) const {
466 StringRef Str = getAsmString()->getString();
467 const char *StrStart = Str.begin();
468 const char *StrEnd = Str.end();
469 const char *CurPtr = StrStart;
470
471 // "Simple" inline asms have no constraints or operands, just convert the asm
472 // string to escape $'s.
473 if (isSimple()) {
474 std::string Result;
475 for (; CurPtr != StrEnd; ++CurPtr) {
476 switch (*CurPtr) {
477 case '$':
478 Result += "$$";
479 break;
480 default:
481 Result += *CurPtr;
482 break;
483 }
484 }
485 Pieces.push_back(AsmStringPiece(Result));
486 return 0;
487 }
488
489 // CurStringPiece - The current string that we are building up as we scan the
490 // asm string.
491 std::string CurStringPiece;
492
493 bool HasVariants = !C.getTargetInfo().hasNoAsmVariants();
494
495 while (1) {
496 // Done with the string?
497 if (CurPtr == StrEnd) {
498 if (!CurStringPiece.empty())
499 Pieces.push_back(AsmStringPiece(CurStringPiece));
500 return 0;
501 }
502
503 char CurChar = *CurPtr++;
504 switch (CurChar) {
505 case '$': CurStringPiece += "$$"; continue;
506 case '{': CurStringPiece += (HasVariants ? "$(" : "{"); continue;
507 case '|': CurStringPiece += (HasVariants ? "$|" : "|"); continue;
508 case '}': CurStringPiece += (HasVariants ? "$)" : "}"); continue;
509 case '%':
510 break;
511 default:
512 CurStringPiece += CurChar;
513 continue;
514 }
515
516 // Escaped "%" character in asm string.
517 if (CurPtr == StrEnd) {
518 // % at end of string is invalid (no escape).
519 DiagOffs = CurPtr-StrStart-1;
520 return diag::err_asm_invalid_escape;
521 }
522
523 char EscapedChar = *CurPtr++;
524 if (EscapedChar == '%') { // %% -> %
525 // Escaped percentage sign.
526 CurStringPiece += '%';
527 continue;
528 }
529
530 if (EscapedChar == '=') { // %= -> Generate an unique ID.
531 CurStringPiece += "${:uid}";
532 continue;
533 }
534
535 // Otherwise, we have an operand. If we have accumulated a string so far,
536 // add it to the Pieces list.
537 if (!CurStringPiece.empty()) {
538 Pieces.push_back(AsmStringPiece(CurStringPiece));
539 CurStringPiece.clear();
540 }
541
542 // Handle %x4 and %x[foo] by capturing x as the modifier character.
543 char Modifier = '\0';
544 if (isalpha(EscapedChar)) {
545 if (CurPtr == StrEnd) { // Premature end.
546 DiagOffs = CurPtr-StrStart-1;
547 return diag::err_asm_invalid_escape;
548 }
549 Modifier = EscapedChar;
550 EscapedChar = *CurPtr++;
551 }
552
553 if (isdigit(EscapedChar)) {
554 // %n - Assembler operand n
555 unsigned N = 0;
556
557 --CurPtr;
558 while (CurPtr != StrEnd && isdigit(*CurPtr))
559 N = N*10 + ((*CurPtr++)-'0');
560
561 unsigned NumOperands =
562 getNumOutputs() + getNumPlusOperands() + getNumInputs();
563 if (N >= NumOperands) {
564 DiagOffs = CurPtr-StrStart-1;
565 return diag::err_asm_invalid_operand_number;
566 }
567
568 Pieces.push_back(AsmStringPiece(N, Modifier));
569 continue;
570 }
571
572 // Handle %[foo], a symbolic operand reference.
573 if (EscapedChar == '[') {
574 DiagOffs = CurPtr-StrStart-1;
575
576 // Find the ']'.
577 const char *NameEnd = (const char*)memchr(CurPtr, ']', StrEnd-CurPtr);
578 if (NameEnd == 0)
579 return diag::err_asm_unterminated_symbolic_operand_name;
580 if (NameEnd == CurPtr)
581 return diag::err_asm_empty_symbolic_operand_name;
582
583 StringRef SymbolicName(CurPtr, NameEnd - CurPtr);
584
585 int N = getNamedOperand(SymbolicName);
586 if (N == -1) {
587 // Verify that an operand with that name exists.
588 DiagOffs = CurPtr-StrStart;
589 return diag::err_asm_unknown_symbolic_operand_name;
590 }
591 Pieces.push_back(AsmStringPiece(N, Modifier));
592
593 CurPtr = NameEnd+1;
594 continue;
595 }
596
597 DiagOffs = CurPtr-StrStart-1;
598 return diag::err_asm_invalid_escape;
599 }
600 }
601
602 /// Assemble final IR asm string (GCC-style).
generateAsmString(ASTContext & C) const603 std::string GCCAsmStmt::generateAsmString(ASTContext &C) const {
604 // Analyze the asm string to decompose it into its pieces. We know that Sema
605 // has already done this, so it is guaranteed to be successful.
606 SmallVector<GCCAsmStmt::AsmStringPiece, 4> Pieces;
607 unsigned DiagOffs;
608 AnalyzeAsmString(Pieces, C, DiagOffs);
609
610 std::string AsmString;
611 for (unsigned i = 0, e = Pieces.size(); i != e; ++i) {
612 if (Pieces[i].isString())
613 AsmString += Pieces[i].getString();
614 else if (Pieces[i].getModifier() == '\0')
615 AsmString += '$' + llvm::utostr(Pieces[i].getOperandNo());
616 else
617 AsmString += "${" + llvm::utostr(Pieces[i].getOperandNo()) + ':' +
618 Pieces[i].getModifier() + '}';
619 }
620 return AsmString;
621 }
622
623 /// Assemble final IR asm string (MS-style).
generateAsmString(ASTContext & C) const624 std::string MSAsmStmt::generateAsmString(ASTContext &C) const {
625 // FIXME: This needs to be translated into the IR string representation.
626 return AsmStr;
627 }
628
getOutputExpr(unsigned i)629 Expr *MSAsmStmt::getOutputExpr(unsigned i) {
630 return cast<Expr>(Exprs[i]);
631 }
632
getInputExpr(unsigned i)633 Expr *MSAsmStmt::getInputExpr(unsigned i) {
634 return cast<Expr>(Exprs[i + NumOutputs]);
635 }
setInputExpr(unsigned i,Expr * E)636 void MSAsmStmt::setInputExpr(unsigned i, Expr *E) {
637 Exprs[i + NumOutputs] = E;
638 }
639
getCaughtType() const640 QualType CXXCatchStmt::getCaughtType() const {
641 if (ExceptionDecl)
642 return ExceptionDecl->getType();
643 return QualType();
644 }
645
646 //===----------------------------------------------------------------------===//
647 // Constructors
648 //===----------------------------------------------------------------------===//
649
GCCAsmStmt(ASTContext & C,SourceLocation asmloc,bool issimple,bool isvolatile,unsigned numoutputs,unsigned numinputs,IdentifierInfo ** names,StringLiteral ** constraints,Expr ** exprs,StringLiteral * asmstr,unsigned numclobbers,StringLiteral ** clobbers,SourceLocation rparenloc)650 GCCAsmStmt::GCCAsmStmt(ASTContext &C, SourceLocation asmloc, bool issimple,
651 bool isvolatile, unsigned numoutputs, unsigned numinputs,
652 IdentifierInfo **names, StringLiteral **constraints,
653 Expr **exprs, StringLiteral *asmstr,
654 unsigned numclobbers, StringLiteral **clobbers,
655 SourceLocation rparenloc)
656 : AsmStmt(GCCAsmStmtClass, asmloc, issimple, isvolatile, numoutputs,
657 numinputs, numclobbers), RParenLoc(rparenloc), AsmStr(asmstr) {
658
659 unsigned NumExprs = NumOutputs + NumInputs;
660
661 Names = new (C) IdentifierInfo*[NumExprs];
662 std::copy(names, names + NumExprs, Names);
663
664 Exprs = new (C) Stmt*[NumExprs];
665 std::copy(exprs, exprs + NumExprs, Exprs);
666
667 Constraints = new (C) StringLiteral*[NumExprs];
668 std::copy(constraints, constraints + NumExprs, Constraints);
669
670 Clobbers = new (C) StringLiteral*[NumClobbers];
671 std::copy(clobbers, clobbers + NumClobbers, Clobbers);
672 }
673
MSAsmStmt(ASTContext & C,SourceLocation asmloc,SourceLocation lbraceloc,bool issimple,bool isvolatile,ArrayRef<Token> asmtoks,ArrayRef<IdentifierInfo * > inputs,ArrayRef<IdentifierInfo * > outputs,ArrayRef<Expr * > inputexprs,ArrayRef<Expr * > outputexprs,StringRef asmstr,ArrayRef<StringRef> constraints,ArrayRef<StringRef> clobbers,SourceLocation endloc)674 MSAsmStmt::MSAsmStmt(ASTContext &C, SourceLocation asmloc,
675 SourceLocation lbraceloc, bool issimple, bool isvolatile,
676 ArrayRef<Token> asmtoks, ArrayRef<IdentifierInfo*> inputs,
677 ArrayRef<IdentifierInfo*> outputs,
678 ArrayRef<Expr*> inputexprs, ArrayRef<Expr*> outputexprs,
679 StringRef asmstr, ArrayRef<StringRef> constraints,
680 ArrayRef<StringRef> clobbers, SourceLocation endloc)
681 : AsmStmt(MSAsmStmtClass, asmloc, issimple, isvolatile, outputs.size(),
682 inputs.size(), clobbers.size()), LBraceLoc(lbraceloc),
683 EndLoc(endloc), AsmStr(asmstr.str()), NumAsmToks(asmtoks.size()) {
684 assert (inputs.size() == inputexprs.size() && "Input expr size mismatch!");
685 assert (outputs.size() == outputexprs.size() && "Input expr size mismatch!");
686
687 unsigned NumExprs = NumOutputs + NumInputs;
688
689 Names = new (C) IdentifierInfo*[NumExprs];
690 for (unsigned i = 0, e = NumOutputs; i != e; ++i)
691 Names[i] = outputs[i];
692 for (unsigned i = NumOutputs, j = 0, e = NumExprs; i != e; ++i, ++j)
693 Names[i] = inputs[j];
694
695 Exprs = new (C) Stmt*[NumExprs];
696 for (unsigned i = 0, e = NumOutputs; i != e; ++i)
697 Exprs[i] = outputexprs[i];
698 for (unsigned i = NumOutputs, j = 0, e = NumExprs; i != e; ++i, ++j)
699 Exprs[i] = inputexprs[j];
700
701 AsmToks = new (C) Token[NumAsmToks];
702 for (unsigned i = 0, e = NumAsmToks; i != e; ++i)
703 AsmToks[i] = asmtoks[i];
704
705 Constraints = new (C) StringRef[NumExprs];
706 for (unsigned i = 0, e = NumExprs; i != e; ++i) {
707 size_t size = constraints[i].size();
708 char *dest = new (C) char[size];
709 std::strncpy(dest, constraints[i].data(), size);
710 Constraints[i] = StringRef(dest, size);
711 }
712
713 Clobbers = new (C) StringRef[NumClobbers];
714 for (unsigned i = 0, e = NumClobbers; i != e; ++i) {
715 // FIXME: Avoid the allocation/copy if at all possible.
716 size_t size = clobbers[i].size();
717 char *dest = new (C) char[size];
718 std::strncpy(dest, clobbers[i].data(), size);
719 Clobbers[i] = StringRef(dest, size);
720 }
721 }
722
ObjCForCollectionStmt(Stmt * Elem,Expr * Collect,Stmt * Body,SourceLocation FCL,SourceLocation RPL)723 ObjCForCollectionStmt::ObjCForCollectionStmt(Stmt *Elem, Expr *Collect,
724 Stmt *Body, SourceLocation FCL,
725 SourceLocation RPL)
726 : Stmt(ObjCForCollectionStmtClass) {
727 SubExprs[ELEM] = Elem;
728 SubExprs[COLLECTION] = reinterpret_cast<Stmt*>(Collect);
729 SubExprs[BODY] = Body;
730 ForLoc = FCL;
731 RParenLoc = RPL;
732 }
733
ObjCAtTryStmt(SourceLocation atTryLoc,Stmt * atTryStmt,Stmt ** CatchStmts,unsigned NumCatchStmts,Stmt * atFinallyStmt)734 ObjCAtTryStmt::ObjCAtTryStmt(SourceLocation atTryLoc, Stmt *atTryStmt,
735 Stmt **CatchStmts, unsigned NumCatchStmts,
736 Stmt *atFinallyStmt)
737 : Stmt(ObjCAtTryStmtClass), AtTryLoc(atTryLoc),
738 NumCatchStmts(NumCatchStmts), HasFinally(atFinallyStmt != 0)
739 {
740 Stmt **Stmts = getStmts();
741 Stmts[0] = atTryStmt;
742 for (unsigned I = 0; I != NumCatchStmts; ++I)
743 Stmts[I + 1] = CatchStmts[I];
744
745 if (HasFinally)
746 Stmts[NumCatchStmts + 1] = atFinallyStmt;
747 }
748
Create(ASTContext & Context,SourceLocation atTryLoc,Stmt * atTryStmt,Stmt ** CatchStmts,unsigned NumCatchStmts,Stmt * atFinallyStmt)749 ObjCAtTryStmt *ObjCAtTryStmt::Create(ASTContext &Context,
750 SourceLocation atTryLoc,
751 Stmt *atTryStmt,
752 Stmt **CatchStmts,
753 unsigned NumCatchStmts,
754 Stmt *atFinallyStmt) {
755 unsigned Size = sizeof(ObjCAtTryStmt) +
756 (1 + NumCatchStmts + (atFinallyStmt != 0)) * sizeof(Stmt *);
757 void *Mem = Context.Allocate(Size, llvm::alignOf<ObjCAtTryStmt>());
758 return new (Mem) ObjCAtTryStmt(atTryLoc, atTryStmt, CatchStmts, NumCatchStmts,
759 atFinallyStmt);
760 }
761
CreateEmpty(ASTContext & Context,unsigned NumCatchStmts,bool HasFinally)762 ObjCAtTryStmt *ObjCAtTryStmt::CreateEmpty(ASTContext &Context,
763 unsigned NumCatchStmts,
764 bool HasFinally) {
765 unsigned Size = sizeof(ObjCAtTryStmt) +
766 (1 + NumCatchStmts + HasFinally) * sizeof(Stmt *);
767 void *Mem = Context.Allocate(Size, llvm::alignOf<ObjCAtTryStmt>());
768 return new (Mem) ObjCAtTryStmt(EmptyShell(), NumCatchStmts, HasFinally);
769 }
770
getSourceRange() const771 SourceRange ObjCAtTryStmt::getSourceRange() const {
772 SourceLocation EndLoc;
773 if (HasFinally)
774 EndLoc = getFinallyStmt()->getLocEnd();
775 else if (NumCatchStmts)
776 EndLoc = getCatchStmt(NumCatchStmts - 1)->getLocEnd();
777 else
778 EndLoc = getTryBody()->getLocEnd();
779
780 return SourceRange(AtTryLoc, EndLoc);
781 }
782
Create(ASTContext & C,SourceLocation tryLoc,Stmt * tryBlock,Stmt ** handlers,unsigned numHandlers)783 CXXTryStmt *CXXTryStmt::Create(ASTContext &C, SourceLocation tryLoc,
784 Stmt *tryBlock, Stmt **handlers,
785 unsigned numHandlers) {
786 std::size_t Size = sizeof(CXXTryStmt);
787 Size += ((numHandlers + 1) * sizeof(Stmt));
788
789 void *Mem = C.Allocate(Size, llvm::alignOf<CXXTryStmt>());
790 return new (Mem) CXXTryStmt(tryLoc, tryBlock, handlers, numHandlers);
791 }
792
Create(ASTContext & C,EmptyShell Empty,unsigned numHandlers)793 CXXTryStmt *CXXTryStmt::Create(ASTContext &C, EmptyShell Empty,
794 unsigned numHandlers) {
795 std::size_t Size = sizeof(CXXTryStmt);
796 Size += ((numHandlers + 1) * sizeof(Stmt));
797
798 void *Mem = C.Allocate(Size, llvm::alignOf<CXXTryStmt>());
799 return new (Mem) CXXTryStmt(Empty, numHandlers);
800 }
801
CXXTryStmt(SourceLocation tryLoc,Stmt * tryBlock,Stmt ** handlers,unsigned numHandlers)802 CXXTryStmt::CXXTryStmt(SourceLocation tryLoc, Stmt *tryBlock,
803 Stmt **handlers, unsigned numHandlers)
804 : Stmt(CXXTryStmtClass), TryLoc(tryLoc), NumHandlers(numHandlers) {
805 Stmt **Stmts = reinterpret_cast<Stmt **>(this + 1);
806 Stmts[0] = tryBlock;
807 std::copy(handlers, handlers + NumHandlers, Stmts + 1);
808 }
809
CXXForRangeStmt(DeclStmt * Range,DeclStmt * BeginEndStmt,Expr * Cond,Expr * Inc,DeclStmt * LoopVar,Stmt * Body,SourceLocation FL,SourceLocation CL,SourceLocation RPL)810 CXXForRangeStmt::CXXForRangeStmt(DeclStmt *Range, DeclStmt *BeginEndStmt,
811 Expr *Cond, Expr *Inc, DeclStmt *LoopVar,
812 Stmt *Body, SourceLocation FL,
813 SourceLocation CL, SourceLocation RPL)
814 : Stmt(CXXForRangeStmtClass), ForLoc(FL), ColonLoc(CL), RParenLoc(RPL) {
815 SubExprs[RANGE] = Range;
816 SubExprs[BEGINEND] = BeginEndStmt;
817 SubExprs[COND] = reinterpret_cast<Stmt*>(Cond);
818 SubExprs[INC] = reinterpret_cast<Stmt*>(Inc);
819 SubExprs[LOOPVAR] = LoopVar;
820 SubExprs[BODY] = Body;
821 }
822
getRangeInit()823 Expr *CXXForRangeStmt::getRangeInit() {
824 DeclStmt *RangeStmt = getRangeStmt();
825 VarDecl *RangeDecl = dyn_cast_or_null<VarDecl>(RangeStmt->getSingleDecl());
826 assert(RangeDecl &&& "for-range should have a single var decl");
827 return RangeDecl->getInit();
828 }
829
getRangeInit() const830 const Expr *CXXForRangeStmt::getRangeInit() const {
831 return const_cast<CXXForRangeStmt*>(this)->getRangeInit();
832 }
833
getLoopVariable()834 VarDecl *CXXForRangeStmt::getLoopVariable() {
835 Decl *LV = cast<DeclStmt>(getLoopVarStmt())->getSingleDecl();
836 assert(LV && "No loop variable in CXXForRangeStmt");
837 return cast<VarDecl>(LV);
838 }
839
getLoopVariable() const840 const VarDecl *CXXForRangeStmt::getLoopVariable() const {
841 return const_cast<CXXForRangeStmt*>(this)->getLoopVariable();
842 }
843
IfStmt(ASTContext & C,SourceLocation IL,VarDecl * var,Expr * cond,Stmt * then,SourceLocation EL,Stmt * elsev)844 IfStmt::IfStmt(ASTContext &C, SourceLocation IL, VarDecl *var, Expr *cond,
845 Stmt *then, SourceLocation EL, Stmt *elsev)
846 : Stmt(IfStmtClass), IfLoc(IL), ElseLoc(EL)
847 {
848 setConditionVariable(C, var);
849 SubExprs[COND] = reinterpret_cast<Stmt*>(cond);
850 SubExprs[THEN] = then;
851 SubExprs[ELSE] = elsev;
852 }
853
getConditionVariable() const854 VarDecl *IfStmt::getConditionVariable() const {
855 if (!SubExprs[VAR])
856 return 0;
857
858 DeclStmt *DS = cast<DeclStmt>(SubExprs[VAR]);
859 return cast<VarDecl>(DS->getSingleDecl());
860 }
861
setConditionVariable(ASTContext & C,VarDecl * V)862 void IfStmt::setConditionVariable(ASTContext &C, VarDecl *V) {
863 if (!V) {
864 SubExprs[VAR] = 0;
865 return;
866 }
867
868 SourceRange VarRange = V->getSourceRange();
869 SubExprs[VAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(),
870 VarRange.getEnd());
871 }
872
ForStmt(ASTContext & C,Stmt * Init,Expr * Cond,VarDecl * condVar,Expr * Inc,Stmt * Body,SourceLocation FL,SourceLocation LP,SourceLocation RP)873 ForStmt::ForStmt(ASTContext &C, Stmt *Init, Expr *Cond, VarDecl *condVar,
874 Expr *Inc, Stmt *Body, SourceLocation FL, SourceLocation LP,
875 SourceLocation RP)
876 : Stmt(ForStmtClass), ForLoc(FL), LParenLoc(LP), RParenLoc(RP)
877 {
878 SubExprs[INIT] = Init;
879 setConditionVariable(C, condVar);
880 SubExprs[COND] = reinterpret_cast<Stmt*>(Cond);
881 SubExprs[INC] = reinterpret_cast<Stmt*>(Inc);
882 SubExprs[BODY] = Body;
883 }
884
getConditionVariable() const885 VarDecl *ForStmt::getConditionVariable() const {
886 if (!SubExprs[CONDVAR])
887 return 0;
888
889 DeclStmt *DS = cast<DeclStmt>(SubExprs[CONDVAR]);
890 return cast<VarDecl>(DS->getSingleDecl());
891 }
892
setConditionVariable(ASTContext & C,VarDecl * V)893 void ForStmt::setConditionVariable(ASTContext &C, VarDecl *V) {
894 if (!V) {
895 SubExprs[CONDVAR] = 0;
896 return;
897 }
898
899 SourceRange VarRange = V->getSourceRange();
900 SubExprs[CONDVAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(),
901 VarRange.getEnd());
902 }
903
SwitchStmt(ASTContext & C,VarDecl * Var,Expr * cond)904 SwitchStmt::SwitchStmt(ASTContext &C, VarDecl *Var, Expr *cond)
905 : Stmt(SwitchStmtClass), FirstCase(0), AllEnumCasesCovered(0)
906 {
907 setConditionVariable(C, Var);
908 SubExprs[COND] = reinterpret_cast<Stmt*>(cond);
909 SubExprs[BODY] = NULL;
910 }
911
getConditionVariable() const912 VarDecl *SwitchStmt::getConditionVariable() const {
913 if (!SubExprs[VAR])
914 return 0;
915
916 DeclStmt *DS = cast<DeclStmt>(SubExprs[VAR]);
917 return cast<VarDecl>(DS->getSingleDecl());
918 }
919
setConditionVariable(ASTContext & C,VarDecl * V)920 void SwitchStmt::setConditionVariable(ASTContext &C, VarDecl *V) {
921 if (!V) {
922 SubExprs[VAR] = 0;
923 return;
924 }
925
926 SourceRange VarRange = V->getSourceRange();
927 SubExprs[VAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(),
928 VarRange.getEnd());
929 }
930
getSubStmt()931 Stmt *SwitchCase::getSubStmt() {
932 if (isa<CaseStmt>(this))
933 return cast<CaseStmt>(this)->getSubStmt();
934 return cast<DefaultStmt>(this)->getSubStmt();
935 }
936
WhileStmt(ASTContext & C,VarDecl * Var,Expr * cond,Stmt * body,SourceLocation WL)937 WhileStmt::WhileStmt(ASTContext &C, VarDecl *Var, Expr *cond, Stmt *body,
938 SourceLocation WL)
939 : Stmt(WhileStmtClass) {
940 setConditionVariable(C, Var);
941 SubExprs[COND] = reinterpret_cast<Stmt*>(cond);
942 SubExprs[BODY] = body;
943 WhileLoc = WL;
944 }
945
getConditionVariable() const946 VarDecl *WhileStmt::getConditionVariable() const {
947 if (!SubExprs[VAR])
948 return 0;
949
950 DeclStmt *DS = cast<DeclStmt>(SubExprs[VAR]);
951 return cast<VarDecl>(DS->getSingleDecl());
952 }
953
setConditionVariable(ASTContext & C,VarDecl * V)954 void WhileStmt::setConditionVariable(ASTContext &C, VarDecl *V) {
955 if (!V) {
956 SubExprs[VAR] = 0;
957 return;
958 }
959
960 SourceRange VarRange = V->getSourceRange();
961 SubExprs[VAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(),
962 VarRange.getEnd());
963 }
964
965 // IndirectGotoStmt
getConstantTarget()966 LabelDecl *IndirectGotoStmt::getConstantTarget() {
967 if (AddrLabelExpr *E =
968 dyn_cast<AddrLabelExpr>(getTarget()->IgnoreParenImpCasts()))
969 return E->getLabel();
970 return 0;
971 }
972
973 // ReturnStmt
getRetValue() const974 const Expr* ReturnStmt::getRetValue() const {
975 return cast_or_null<Expr>(RetExpr);
976 }
getRetValue()977 Expr* ReturnStmt::getRetValue() {
978 return cast_or_null<Expr>(RetExpr);
979 }
980
SEHTryStmt(bool IsCXXTry,SourceLocation TryLoc,Stmt * TryBlock,Stmt * Handler)981 SEHTryStmt::SEHTryStmt(bool IsCXXTry,
982 SourceLocation TryLoc,
983 Stmt *TryBlock,
984 Stmt *Handler)
985 : Stmt(SEHTryStmtClass),
986 IsCXXTry(IsCXXTry),
987 TryLoc(TryLoc)
988 {
989 Children[TRY] = TryBlock;
990 Children[HANDLER] = Handler;
991 }
992
Create(ASTContext & C,bool IsCXXTry,SourceLocation TryLoc,Stmt * TryBlock,Stmt * Handler)993 SEHTryStmt* SEHTryStmt::Create(ASTContext &C,
994 bool IsCXXTry,
995 SourceLocation TryLoc,
996 Stmt *TryBlock,
997 Stmt *Handler) {
998 return new(C) SEHTryStmt(IsCXXTry,TryLoc,TryBlock,Handler);
999 }
1000
getExceptHandler() const1001 SEHExceptStmt* SEHTryStmt::getExceptHandler() const {
1002 return dyn_cast<SEHExceptStmt>(getHandler());
1003 }
1004
getFinallyHandler() const1005 SEHFinallyStmt* SEHTryStmt::getFinallyHandler() const {
1006 return dyn_cast<SEHFinallyStmt>(getHandler());
1007 }
1008
SEHExceptStmt(SourceLocation Loc,Expr * FilterExpr,Stmt * Block)1009 SEHExceptStmt::SEHExceptStmt(SourceLocation Loc,
1010 Expr *FilterExpr,
1011 Stmt *Block)
1012 : Stmt(SEHExceptStmtClass),
1013 Loc(Loc)
1014 {
1015 Children[FILTER_EXPR] = reinterpret_cast<Stmt*>(FilterExpr);
1016 Children[BLOCK] = Block;
1017 }
1018
Create(ASTContext & C,SourceLocation Loc,Expr * FilterExpr,Stmt * Block)1019 SEHExceptStmt* SEHExceptStmt::Create(ASTContext &C,
1020 SourceLocation Loc,
1021 Expr *FilterExpr,
1022 Stmt *Block) {
1023 return new(C) SEHExceptStmt(Loc,FilterExpr,Block);
1024 }
1025
SEHFinallyStmt(SourceLocation Loc,Stmt * Block)1026 SEHFinallyStmt::SEHFinallyStmt(SourceLocation Loc,
1027 Stmt *Block)
1028 : Stmt(SEHFinallyStmtClass),
1029 Loc(Loc),
1030 Block(Block)
1031 {}
1032
Create(ASTContext & C,SourceLocation Loc,Stmt * Block)1033 SEHFinallyStmt* SEHFinallyStmt::Create(ASTContext &C,
1034 SourceLocation Loc,
1035 Stmt *Block) {
1036 return new(C)SEHFinallyStmt(Loc,Block);
1037 }
1038