blob: 445a72465c5df54b1ab0f510fbf1432e128b3c7e [file] [log] [blame]
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +00001//===--- ParsePragma.cpp - Language specific pragma parsing ---------------===//
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 language specific #pragma handlers.
11//
12//===----------------------------------------------------------------------===//
13
14#include "ParsePragma.h"
Chris Lattner500d3292009-01-29 05:15:15 +000015#include "clang/Parse/ParseDiagnostic.h"
Ted Kremenek4726d032009-03-23 22:28:25 +000016#include "clang/Parse/Parser.h"
John McCall19510852010-08-20 18:27:03 +000017#include "clang/Lex/Preprocessor.h"
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +000018using namespace clang;
19
Argyrios Kyrtzidisb918d0f2011-01-17 18:58:44 +000020/// \brief Handle the annotation token produced for #pragma unused(...)
21///
22/// Each annot_pragma_unused is followed by the argument token so e.g.
23/// "#pragma unused(x,y)" becomes:
24/// annot_pragma_unused 'x' annot_pragma_unused 'y'
25void Parser::HandlePragmaUnused() {
26 assert(Tok.is(tok::annot_pragma_unused));
27 SourceLocation UnusedLoc = ConsumeToken();
28 Actions.ActOnPragmaUnused(Tok, getCurScope(), UnusedLoc);
29 ConsumeToken(); // The argument token.
30}
Eli Friedmanaa8b0d12010-08-05 06:57:20 +000031
32// #pragma GCC visibility comes in two variants:
33// 'push' '(' [visibility] ')'
34// 'pop'
Douglas Gregor80c60f72010-09-09 22:45:38 +000035void PragmaGCCVisibilityHandler::HandlePragma(Preprocessor &PP,
36 PragmaIntroducerKind Introducer,
37 Token &VisTok) {
Eli Friedmanaa8b0d12010-08-05 06:57:20 +000038 SourceLocation VisLoc = VisTok.getLocation();
39
40 Token Tok;
Joerg Sonnenbergere23af2a2011-07-20 01:03:50 +000041 PP.LexUnexpandedToken(Tok);
Eli Friedmanaa8b0d12010-08-05 06:57:20 +000042
43 const IdentifierInfo *PushPop = Tok.getIdentifierInfo();
44
45 bool IsPush;
46 const IdentifierInfo *VisType;
47 if (PushPop && PushPop->isStr("pop")) {
48 IsPush = false;
49 VisType = 0;
50 } else if (PushPop && PushPop->isStr("push")) {
51 IsPush = true;
Joerg Sonnenbergere23af2a2011-07-20 01:03:50 +000052 PP.LexUnexpandedToken(Tok);
Eli Friedmanaa8b0d12010-08-05 06:57:20 +000053 if (Tok.isNot(tok::l_paren)) {
54 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen)
55 << "visibility";
56 return;
57 }
Joerg Sonnenbergere23af2a2011-07-20 01:03:50 +000058 PP.LexUnexpandedToken(Tok);
Eli Friedmanaa8b0d12010-08-05 06:57:20 +000059 VisType = Tok.getIdentifierInfo();
60 if (!VisType) {
61 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
62 << "visibility";
63 return;
64 }
Joerg Sonnenbergere23af2a2011-07-20 01:03:50 +000065 PP.LexUnexpandedToken(Tok);
Eli Friedmanaa8b0d12010-08-05 06:57:20 +000066 if (Tok.isNot(tok::r_paren)) {
67 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen)
68 << "visibility";
69 return;
70 }
71 } else {
72 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
73 << "visibility";
74 return;
75 }
Joerg Sonnenbergere23af2a2011-07-20 01:03:50 +000076 PP.LexUnexpandedToken(Tok);
Peter Collingbourne84021552011-02-28 02:37:51 +000077 if (Tok.isNot(tok::eod)) {
Eli Friedmanaa8b0d12010-08-05 06:57:20 +000078 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
79 << "visibility";
80 return;
81 }
82
83 Actions.ActOnPragmaVisibility(IsPush, VisType, VisLoc);
84}
85
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +000086// #pragma pack(...) comes in the following delicious flavors:
87// pack '(' [integer] ')'
88// pack '(' 'show' ')'
89// pack '(' ('push' | 'pop') [',' identifier] [, integer] ')'
Douglas Gregor80c60f72010-09-09 22:45:38 +000090void PragmaPackHandler::HandlePragma(Preprocessor &PP,
91 PragmaIntroducerKind Introducer,
92 Token &PackTok) {
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +000093 SourceLocation PackLoc = PackTok.getLocation();
94
95 Token Tok;
96 PP.Lex(Tok);
97 if (Tok.isNot(tok::l_paren)) {
Ted Kremenek4726d032009-03-23 22:28:25 +000098 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "pack";
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +000099 return;
100 }
101
John McCallf312b1e2010-08-26 23:41:50 +0000102 Sema::PragmaPackKind Kind = Sema::PPK_Default;
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +0000103 IdentifierInfo *Name = 0;
John McCall60d7b3a2010-08-24 06:29:42 +0000104 ExprResult Alignment;
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +0000105 SourceLocation LParenLoc = Tok.getLocation();
Mike Stump1eb44332009-09-09 15:08:12 +0000106 PP.Lex(Tok);
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +0000107 if (Tok.is(tok::numeric_constant)) {
108 Alignment = Actions.ActOnNumericConstant(Tok);
Sebastian Redl0e9eabc2008-12-09 13:15:23 +0000109 if (Alignment.isInvalid())
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +0000110 return;
111
112 PP.Lex(Tok);
113 } else if (Tok.is(tok::identifier)) {
114 const IdentifierInfo *II = Tok.getIdentifierInfo();
Chris Lattner08631c52008-11-23 21:45:46 +0000115 if (II->isStr("show")) {
John McCallf312b1e2010-08-26 23:41:50 +0000116 Kind = Sema::PPK_Show;
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +0000117 PP.Lex(Tok);
118 } else {
Chris Lattner08631c52008-11-23 21:45:46 +0000119 if (II->isStr("push")) {
John McCallf312b1e2010-08-26 23:41:50 +0000120 Kind = Sema::PPK_Push;
Chris Lattner08631c52008-11-23 21:45:46 +0000121 } else if (II->isStr("pop")) {
John McCallf312b1e2010-08-26 23:41:50 +0000122 Kind = Sema::PPK_Pop;
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +0000123 } else {
124 PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_invalid_action);
125 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000126 }
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +0000127 PP.Lex(Tok);
Mike Stump1eb44332009-09-09 15:08:12 +0000128
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +0000129 if (Tok.is(tok::comma)) {
130 PP.Lex(Tok);
Mike Stump1eb44332009-09-09 15:08:12 +0000131
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +0000132 if (Tok.is(tok::numeric_constant)) {
133 Alignment = Actions.ActOnNumericConstant(Tok);
Sebastian Redl0e9eabc2008-12-09 13:15:23 +0000134 if (Alignment.isInvalid())
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +0000135 return;
136
137 PP.Lex(Tok);
138 } else if (Tok.is(tok::identifier)) {
139 Name = Tok.getIdentifierInfo();
140 PP.Lex(Tok);
Mike Stump1eb44332009-09-09 15:08:12 +0000141
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +0000142 if (Tok.is(tok::comma)) {
143 PP.Lex(Tok);
Mike Stump1eb44332009-09-09 15:08:12 +0000144
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +0000145 if (Tok.isNot(tok::numeric_constant)) {
Chris Lattner08631c52008-11-23 21:45:46 +0000146 PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed);
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +0000147 return;
148 }
Mike Stump1eb44332009-09-09 15:08:12 +0000149
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +0000150 Alignment = Actions.ActOnNumericConstant(Tok);
Sebastian Redl0e9eabc2008-12-09 13:15:23 +0000151 if (Alignment.isInvalid())
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +0000152 return;
153
154 PP.Lex(Tok);
155 }
156 } else {
Chris Lattner08631c52008-11-23 21:45:46 +0000157 PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed);
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +0000158 return;
159 }
160 }
161 }
Sebastian Redl0e9eabc2008-12-09 13:15:23 +0000162 }
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +0000163
164 if (Tok.isNot(tok::r_paren)) {
Ted Kremenek4726d032009-03-23 22:28:25 +0000165 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "pack";
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +0000166 return;
167 }
168
Daniel Dunbar861800c2010-05-26 23:29:06 +0000169 SourceLocation RParenLoc = Tok.getLocation();
Eli Friedman99914792009-06-05 00:49:58 +0000170 PP.Lex(Tok);
Peter Collingbourne84021552011-02-28 02:37:51 +0000171 if (Tok.isNot(tok::eod)) {
Eli Friedman99914792009-06-05 00:49:58 +0000172 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "pack";
173 return;
174 }
175
Sebastian Redleffa8d12008-12-10 00:02:53 +0000176 Actions.ActOnPragmaPack(Kind, Name, Alignment.release(), PackLoc,
Daniel Dunbarfcdd8fe2008-10-04 19:21:03 +0000177 LParenLoc, RParenLoc);
178}
179
Fariborz Jahanian62c92582011-04-25 18:49:15 +0000180// #pragma ms_struct on
181// #pragma ms_struct off
182void PragmaMSStructHandler::HandlePragma(Preprocessor &PP,
183 PragmaIntroducerKind Introducer,
184 Token &MSStructTok) {
185 Sema::PragmaMSStructKind Kind = Sema::PMSST_OFF;
186
187 Token Tok;
188 PP.Lex(Tok);
189 if (Tok.isNot(tok::identifier)) {
190 PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct);
191 return;
192 }
193 const IdentifierInfo *II = Tok.getIdentifierInfo();
194 if (II->isStr("on")) {
195 Kind = Sema::PMSST_ON;
196 PP.Lex(Tok);
197 }
198 else if (II->isStr("off") || II->isStr("reset"))
199 PP.Lex(Tok);
200 else {
201 PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct);
202 return;
203 }
204
205 if (Tok.isNot(tok::eod)) {
206 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "ms_struct";
207 return;
208 }
209 Actions.ActOnPragmaMSStruct(Kind);
210}
211
Daniel Dunbarcbb98ed2010-07-31 19:17:07 +0000212// #pragma 'align' '=' {'native','natural','mac68k','power','reset'}
213// #pragma 'options 'align' '=' {'native','natural','mac68k','power','reset'}
John McCallf312b1e2010-08-26 23:41:50 +0000214static void ParseAlignPragma(Sema &Actions, Preprocessor &PP, Token &FirstTok,
Daniel Dunbarcbb98ed2010-07-31 19:17:07 +0000215 bool IsOptions) {
Daniel Dunbar861800c2010-05-26 23:29:06 +0000216 Token Tok;
Daniel Dunbarcbb98ed2010-07-31 19:17:07 +0000217
218 if (IsOptions) {
219 PP.Lex(Tok);
220 if (Tok.isNot(tok::identifier) ||
221 !Tok.getIdentifierInfo()->isStr("align")) {
222 PP.Diag(Tok.getLocation(), diag::warn_pragma_options_expected_align);
223 return;
224 }
Daniel Dunbar861800c2010-05-26 23:29:06 +0000225 }
Daniel Dunbar638e7cf2010-05-27 18:42:09 +0000226
Daniel Dunbar861800c2010-05-26 23:29:06 +0000227 PP.Lex(Tok);
228 if (Tok.isNot(tok::equal)) {
Daniel Dunbarcbb98ed2010-07-31 19:17:07 +0000229 PP.Diag(Tok.getLocation(), diag::warn_pragma_align_expected_equal)
230 << IsOptions;
Daniel Dunbar861800c2010-05-26 23:29:06 +0000231 return;
232 }
233
234 PP.Lex(Tok);
235 if (Tok.isNot(tok::identifier)) {
236 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
Daniel Dunbarcbb98ed2010-07-31 19:17:07 +0000237 << (IsOptions ? "options" : "align");
Daniel Dunbar861800c2010-05-26 23:29:06 +0000238 return;
239 }
240
John McCallf312b1e2010-08-26 23:41:50 +0000241 Sema::PragmaOptionsAlignKind Kind = Sema::POAK_Natural;
Daniel Dunbar861800c2010-05-26 23:29:06 +0000242 const IdentifierInfo *II = Tok.getIdentifierInfo();
Daniel Dunbar638e7cf2010-05-27 18:42:09 +0000243 if (II->isStr("native"))
John McCallf312b1e2010-08-26 23:41:50 +0000244 Kind = Sema::POAK_Native;
Daniel Dunbar638e7cf2010-05-27 18:42:09 +0000245 else if (II->isStr("natural"))
John McCallf312b1e2010-08-26 23:41:50 +0000246 Kind = Sema::POAK_Natural;
Daniel Dunbar6f739142010-05-27 18:42:17 +0000247 else if (II->isStr("packed"))
John McCallf312b1e2010-08-26 23:41:50 +0000248 Kind = Sema::POAK_Packed;
Daniel Dunbar861800c2010-05-26 23:29:06 +0000249 else if (II->isStr("power"))
John McCallf312b1e2010-08-26 23:41:50 +0000250 Kind = Sema::POAK_Power;
Daniel Dunbar861800c2010-05-26 23:29:06 +0000251 else if (II->isStr("mac68k"))
John McCallf312b1e2010-08-26 23:41:50 +0000252 Kind = Sema::POAK_Mac68k;
Daniel Dunbar861800c2010-05-26 23:29:06 +0000253 else if (II->isStr("reset"))
John McCallf312b1e2010-08-26 23:41:50 +0000254 Kind = Sema::POAK_Reset;
Daniel Dunbar861800c2010-05-26 23:29:06 +0000255 else {
Daniel Dunbarcbb98ed2010-07-31 19:17:07 +0000256 PP.Diag(Tok.getLocation(), diag::warn_pragma_align_invalid_option)
257 << IsOptions;
Daniel Dunbar861800c2010-05-26 23:29:06 +0000258 return;
259 }
260
261 SourceLocation KindLoc = Tok.getLocation();
262 PP.Lex(Tok);
Peter Collingbourne84021552011-02-28 02:37:51 +0000263 if (Tok.isNot(tok::eod)) {
Daniel Dunbar861800c2010-05-26 23:29:06 +0000264 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
Daniel Dunbarcbb98ed2010-07-31 19:17:07 +0000265 << (IsOptions ? "options" : "align");
Daniel Dunbar861800c2010-05-26 23:29:06 +0000266 return;
267 }
268
Daniel Dunbarcbb98ed2010-07-31 19:17:07 +0000269 Actions.ActOnPragmaOptionsAlign(Kind, FirstTok.getLocation(), KindLoc);
270}
271
Douglas Gregor80c60f72010-09-09 22:45:38 +0000272void PragmaAlignHandler::HandlePragma(Preprocessor &PP,
273 PragmaIntroducerKind Introducer,
274 Token &AlignTok) {
Daniel Dunbarcbb98ed2010-07-31 19:17:07 +0000275 ParseAlignPragma(Actions, PP, AlignTok, /*IsOptions=*/false);
276}
277
Douglas Gregor80c60f72010-09-09 22:45:38 +0000278void PragmaOptionsHandler::HandlePragma(Preprocessor &PP,
279 PragmaIntroducerKind Introducer,
280 Token &OptionsTok) {
Daniel Dunbarcbb98ed2010-07-31 19:17:07 +0000281 ParseAlignPragma(Actions, PP, OptionsTok, /*IsOptions=*/true);
Daniel Dunbar861800c2010-05-26 23:29:06 +0000282}
283
Ted Kremenek4726d032009-03-23 22:28:25 +0000284// #pragma unused(identifier)
Douglas Gregor80c60f72010-09-09 22:45:38 +0000285void PragmaUnusedHandler::HandlePragma(Preprocessor &PP,
286 PragmaIntroducerKind Introducer,
287 Token &UnusedTok) {
Ted Kremenek4726d032009-03-23 22:28:25 +0000288 // FIXME: Should we be expanding macros here? My guess is no.
289 SourceLocation UnusedLoc = UnusedTok.getLocation();
Mike Stump1eb44332009-09-09 15:08:12 +0000290
Ted Kremenek4726d032009-03-23 22:28:25 +0000291 // Lex the left '('.
292 Token Tok;
293 PP.Lex(Tok);
294 if (Tok.isNot(tok::l_paren)) {
295 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "unused";
296 return;
297 }
Mike Stump1eb44332009-09-09 15:08:12 +0000298
Ted Kremenek4726d032009-03-23 22:28:25 +0000299 // Lex the declaration reference(s).
Ted Kremenek7a02a372009-08-03 23:24:57 +0000300 llvm::SmallVector<Token, 5> Identifiers;
Ted Kremenek4726d032009-03-23 22:28:25 +0000301 SourceLocation RParenLoc;
302 bool LexID = true;
Mike Stump1eb44332009-09-09 15:08:12 +0000303
Ted Kremenek4726d032009-03-23 22:28:25 +0000304 while (true) {
305 PP.Lex(Tok);
Mike Stump1eb44332009-09-09 15:08:12 +0000306
Ted Kremenek4726d032009-03-23 22:28:25 +0000307 if (LexID) {
Mike Stump1eb44332009-09-09 15:08:12 +0000308 if (Tok.is(tok::identifier)) {
Ted Kremenek7a02a372009-08-03 23:24:57 +0000309 Identifiers.push_back(Tok);
Ted Kremenek4726d032009-03-23 22:28:25 +0000310 LexID = false;
311 continue;
312 }
313
Ted Kremenek7a02a372009-08-03 23:24:57 +0000314 // Illegal token!
Ted Kremenek4726d032009-03-23 22:28:25 +0000315 PP.Diag(Tok.getLocation(), diag::warn_pragma_unused_expected_var);
316 return;
317 }
Mike Stump1eb44332009-09-09 15:08:12 +0000318
Ted Kremenek4726d032009-03-23 22:28:25 +0000319 // We are execting a ')' or a ','.
320 if (Tok.is(tok::comma)) {
321 LexID = true;
322 continue;
323 }
Mike Stump1eb44332009-09-09 15:08:12 +0000324
Ted Kremenek4726d032009-03-23 22:28:25 +0000325 if (Tok.is(tok::r_paren)) {
326 RParenLoc = Tok.getLocation();
327 break;
328 }
Mike Stump1eb44332009-09-09 15:08:12 +0000329
Ted Kremenek7a02a372009-08-03 23:24:57 +0000330 // Illegal token!
Ted Kremenek4726d032009-03-23 22:28:25 +0000331 PP.Diag(Tok.getLocation(), diag::warn_pragma_unused_expected_punc);
332 return;
333 }
Eli Friedman99914792009-06-05 00:49:58 +0000334
335 PP.Lex(Tok);
Peter Collingbourne84021552011-02-28 02:37:51 +0000336 if (Tok.isNot(tok::eod)) {
Eli Friedman99914792009-06-05 00:49:58 +0000337 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
338 "unused";
339 return;
340 }
341
Ted Kremenek4726d032009-03-23 22:28:25 +0000342 // Verify that we have a location for the right parenthesis.
343 assert(RParenLoc.isValid() && "Valid '#pragma unused' must have ')'");
Ted Kremenek7a02a372009-08-03 23:24:57 +0000344 assert(!Identifiers.empty() && "Valid '#pragma unused' must have arguments");
Ted Kremenek4726d032009-03-23 22:28:25 +0000345
Argyrios Kyrtzidisb918d0f2011-01-17 18:58:44 +0000346 // For each identifier token, insert into the token stream a
347 // annot_pragma_unused token followed by the identifier token.
348 // This allows us to cache a "#pragma unused" that occurs inside an inline
349 // C++ member function.
350
351 Token *Toks = new Token[2*Identifiers.size()];
352 for (unsigned i=0; i != Identifiers.size(); i++) {
353 Token &pragmaUnusedTok = Toks[2*i], &idTok = Toks[2*i+1];
354 pragmaUnusedTok.startToken();
355 pragmaUnusedTok.setKind(tok::annot_pragma_unused);
356 pragmaUnusedTok.setLocation(UnusedLoc);
357 idTok = Identifiers[i];
358 }
359 PP.EnterTokenStream(Toks, 2*Identifiers.size(), /*DisableMacroExpansion=*/true, /*OwnsTokens=*/true);
Ted Kremenek4726d032009-03-23 22:28:25 +0000360}
Eli Friedman99914792009-06-05 00:49:58 +0000361
362// #pragma weak identifier
363// #pragma weak identifier '=' identifier
Douglas Gregor80c60f72010-09-09 22:45:38 +0000364void PragmaWeakHandler::HandlePragma(Preprocessor &PP,
365 PragmaIntroducerKind Introducer,
366 Token &WeakTok) {
Eli Friedman99914792009-06-05 00:49:58 +0000367 // FIXME: Should we be expanding macros here? My guess is no.
368 SourceLocation WeakLoc = WeakTok.getLocation();
369
370 Token Tok;
371 PP.Lex(Tok);
372 if (Tok.isNot(tok::identifier)) {
373 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "weak";
374 return;
375 }
376
377 IdentifierInfo *WeakName = Tok.getIdentifierInfo(), *AliasName = 0;
378 SourceLocation WeakNameLoc = Tok.getLocation(), AliasNameLoc;
379
380 PP.Lex(Tok);
381 if (Tok.is(tok::equal)) {
382 PP.Lex(Tok);
383 if (Tok.isNot(tok::identifier)) {
Mike Stump1eb44332009-09-09 15:08:12 +0000384 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
Eli Friedman99914792009-06-05 00:49:58 +0000385 << "weak";
386 return;
387 }
388 AliasName = Tok.getIdentifierInfo();
389 AliasNameLoc = Tok.getLocation();
390 PP.Lex(Tok);
391 }
392
Peter Collingbourne84021552011-02-28 02:37:51 +0000393 if (Tok.isNot(tok::eod)) {
Eli Friedman99914792009-06-05 00:49:58 +0000394 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "weak";
395 return;
396 }
397
398 if (AliasName) {
399 Actions.ActOnPragmaWeakAlias(WeakName, AliasName, WeakLoc, WeakNameLoc,
400 AliasNameLoc);
401 } else {
402 Actions.ActOnPragmaWeakID(WeakName, WeakLoc, WeakNameLoc);
403 }
404}
Peter Collingbourne321b8172011-02-14 01:42:35 +0000405
406void
407PragmaFPContractHandler::HandlePragma(Preprocessor &PP,
408 PragmaIntroducerKind Introducer,
409 Token &Tok) {
410 tok::OnOffSwitch OOS;
411 if (PP.LexOnOffSwitch(OOS))
412 return;
413
414 Actions.ActOnPragmaFPContract(OOS);
415}
Peter Collingbournef315fa82011-02-14 01:42:53 +0000416
417void
418PragmaOpenCLExtensionHandler::HandlePragma(Preprocessor &PP,
419 PragmaIntroducerKind Introducer,
420 Token &Tok) {
Tanya Lattnerb38b6a72011-04-14 23:35:31 +0000421 PP.LexUnexpandedToken(Tok);
Peter Collingbournef315fa82011-02-14 01:42:53 +0000422 if (Tok.isNot(tok::identifier)) {
423 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) <<
424 "OPENCL";
425 return;
426 }
427 IdentifierInfo *ename = Tok.getIdentifierInfo();
428 SourceLocation NameLoc = Tok.getLocation();
429
430 PP.Lex(Tok);
431 if (Tok.isNot(tok::colon)) {
432 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_colon) << ename;
433 return;
434 }
435
436 PP.Lex(Tok);
437 if (Tok.isNot(tok::identifier)) {
438 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_enable_disable);
439 return;
440 }
441 IdentifierInfo *op = Tok.getIdentifierInfo();
442
443 unsigned state;
444 if (op->isStr("enable")) {
445 state = 1;
446 } else if (op->isStr("disable")) {
447 state = 0;
448 } else {
449 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_enable_disable);
450 return;
451 }
452
453 OpenCLOptions &f = Actions.getOpenCLOptions();
454 if (ename->isStr("all")) {
455#define OPENCLEXT(nm) f.nm = state;
456#include "clang/Basic/OpenCLExtensions.def"
457 }
458#define OPENCLEXT(nm) else if (ename->isStr(#nm)) { f.nm = state; }
459#include "clang/Basic/OpenCLExtensions.def"
460 else {
461 PP.Diag(NameLoc, diag::warn_pragma_unknown_extension) << ename;
462 return;
463 }
464}
465