blob: b2b2f31dd6ea40b739552497bca8adf6feeca8ff [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- ParseDecl.cpp - Declaration Parsing ------------------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the Declaration portions of the Parser interfaces.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Parse/Parser.h"
Chris Lattner500d3292009-01-29 05:15:15 +000015#include "clang/Parse/ParseDiagnostic.h"
Chris Lattner31e05722007-08-26 06:24:45 +000016#include "clang/Parse/Scope.h"
Chris Lattnerc46d1a12008-10-20 06:45:43 +000017#include "ExtensionRAIIObject.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000018#include "llvm/ADT/SmallSet.h"
19using namespace clang;
20
21//===----------------------------------------------------------------------===//
22// C99 6.7: Declarations.
23//===----------------------------------------------------------------------===//
24
25/// ParseTypeName
26/// type-name: [C99 6.7.6]
27/// specifier-qualifier-list abstract-declarator[opt]
Sebastian Redl4c5d3202008-11-21 19:14:01 +000028///
29/// Called type-id in C++.
Sebastian Redlef65f062009-05-29 18:02:33 +000030Action::TypeResult Parser::ParseTypeName(SourceRange *Range) {
Reid Spencer5f016e22007-07-11 17:01:13 +000031 // Parse the common declaration-specifiers piece.
32 DeclSpec DS;
33 ParseSpecifierQualifierList(DS);
Sebastian Redlef65f062009-05-29 18:02:33 +000034
Reid Spencer5f016e22007-07-11 17:01:13 +000035 // Parse the abstract-declarator, if present.
36 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
37 ParseDeclarator(DeclaratorInfo);
Sebastian Redlef65f062009-05-29 18:02:33 +000038 if (Range)
39 *Range = DeclaratorInfo.getSourceRange();
40
Chris Lattnereaaebc72009-04-25 08:06:05 +000041 if (DeclaratorInfo.isInvalidType())
Douglas Gregor809070a2009-02-18 17:45:20 +000042 return true;
43
44 return Actions.ActOnTypeName(CurScope, DeclaratorInfo);
Reid Spencer5f016e22007-07-11 17:01:13 +000045}
46
47/// ParseAttributes - Parse a non-empty attributes list.
48///
49/// [GNU] attributes:
50/// attribute
51/// attributes attribute
52///
53/// [GNU] attribute:
54/// '__attribute__' '(' '(' attribute-list ')' ')'
55///
56/// [GNU] attribute-list:
57/// attrib
58/// attribute_list ',' attrib
59///
60/// [GNU] attrib:
61/// empty
62/// attrib-name
63/// attrib-name '(' identifier ')'
64/// attrib-name '(' identifier ',' nonempty-expr-list ')'
65/// attrib-name '(' argument-expression-list [C99 6.5.2] ')'
66///
67/// [GNU] attrib-name:
68/// identifier
69/// typespec
70/// typequal
71/// storageclass
72///
73/// FIXME: The GCC grammar/code for this construct implies we need two
74/// token lookahead. Comment from gcc: "If they start with an identifier
75/// which is followed by a comma or close parenthesis, then the arguments
76/// start with that identifier; otherwise they are an expression list."
77///
78/// At the moment, I am not doing 2 token lookahead. I am also unaware of
79/// any attributes that don't work (based on my limited testing). Most
80/// attributes are very simple in practice. Until we find a bug, I don't see
81/// a pressing need to implement the 2 token lookahead.
82
Sebastian Redlab197ba2009-02-09 18:23:29 +000083AttributeList *Parser::ParseAttributes(SourceLocation *EndLoc) {
Chris Lattner04d66662007-10-09 17:33:22 +000084 assert(Tok.is(tok::kw___attribute) && "Not an attribute list!");
Reid Spencer5f016e22007-07-11 17:01:13 +000085
86 AttributeList *CurrAttr = 0;
87
Chris Lattner04d66662007-10-09 17:33:22 +000088 while (Tok.is(tok::kw___attribute)) {
Reid Spencer5f016e22007-07-11 17:01:13 +000089 ConsumeToken();
90 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
91 "attribute")) {
92 SkipUntil(tok::r_paren, true); // skip until ) or ;
93 return CurrAttr;
94 }
95 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "(")) {
96 SkipUntil(tok::r_paren, true); // skip until ) or ;
97 return CurrAttr;
98 }
99 // Parse the attribute-list. e.g. __attribute__(( weak, alias("__f") ))
Chris Lattner04d66662007-10-09 17:33:22 +0000100 while (Tok.is(tok::identifier) || isDeclarationSpecifier() ||
101 Tok.is(tok::comma)) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000102
Chris Lattner04d66662007-10-09 17:33:22 +0000103 if (Tok.is(tok::comma)) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000104 // allows for empty/non-empty attributes. ((__vector_size__(16),,,,))
105 ConsumeToken();
106 continue;
107 }
108 // we have an identifier or declaration specifier (const, int, etc.)
109 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
110 SourceLocation AttrNameLoc = ConsumeToken();
111
112 // check if we have a "paramterized" attribute
Chris Lattner04d66662007-10-09 17:33:22 +0000113 if (Tok.is(tok::l_paren)) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000114 ConsumeParen(); // ignore the left paren loc for now
115
Chris Lattner04d66662007-10-09 17:33:22 +0000116 if (Tok.is(tok::identifier)) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000117 IdentifierInfo *ParmName = Tok.getIdentifierInfo();
118 SourceLocation ParmLoc = ConsumeToken();
119
Chris Lattner04d66662007-10-09 17:33:22 +0000120 if (Tok.is(tok::r_paren)) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000121 // __attribute__(( mode(byte) ))
122 ConsumeParen(); // ignore the right paren loc for now
123 CurrAttr = new AttributeList(AttrName, AttrNameLoc,
124 ParmName, ParmLoc, 0, 0, CurrAttr);
Chris Lattner04d66662007-10-09 17:33:22 +0000125 } else if (Tok.is(tok::comma)) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000126 ConsumeToken();
127 // __attribute__(( format(printf, 1, 2) ))
Sebastian Redla55e52c2008-11-25 22:21:31 +0000128 ExprVector ArgExprs(Actions);
Reid Spencer5f016e22007-07-11 17:01:13 +0000129 bool ArgExprsOk = true;
130
131 // now parse the non-empty comma separated list of expressions
132 while (1) {
Sebastian Redl2f7ece72008-12-11 21:36:32 +0000133 OwningExprResult ArgExpr(ParseAssignmentExpression());
Sebastian Redl0e9eabc2008-12-09 13:15:23 +0000134 if (ArgExpr.isInvalid()) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000135 ArgExprsOk = false;
136 SkipUntil(tok::r_paren);
137 break;
138 } else {
Sebastian Redleffa8d12008-12-10 00:02:53 +0000139 ArgExprs.push_back(ArgExpr.release());
Reid Spencer5f016e22007-07-11 17:01:13 +0000140 }
Chris Lattner04d66662007-10-09 17:33:22 +0000141 if (Tok.isNot(tok::comma))
Reid Spencer5f016e22007-07-11 17:01:13 +0000142 break;
143 ConsumeToken(); // Eat the comma, move to the next argument
144 }
Chris Lattner04d66662007-10-09 17:33:22 +0000145 if (ArgExprsOk && Tok.is(tok::r_paren)) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000146 ConsumeParen(); // ignore the right paren loc for now
147 CurrAttr = new AttributeList(AttrName, AttrNameLoc, ParmName,
Sebastian Redla55e52c2008-11-25 22:21:31 +0000148 ParmLoc, ArgExprs.take(), ArgExprs.size(), CurrAttr);
Reid Spencer5f016e22007-07-11 17:01:13 +0000149 }
150 }
151 } else { // not an identifier
Nate Begeman6f3d8382009-06-26 06:32:41 +0000152 switch (Tok.getKind()) {
153 case tok::r_paren:
Reid Spencer5f016e22007-07-11 17:01:13 +0000154 // parse a possibly empty comma separated list of expressions
Reid Spencer5f016e22007-07-11 17:01:13 +0000155 // __attribute__(( nonnull() ))
156 ConsumeParen(); // ignore the right paren loc for now
157 CurrAttr = new AttributeList(AttrName, AttrNameLoc,
158 0, SourceLocation(), 0, 0, CurrAttr);
Nate Begeman6f3d8382009-06-26 06:32:41 +0000159 break;
160 case tok::kw_char:
161 case tok::kw_wchar_t:
162 case tok::kw_bool:
163 case tok::kw_short:
164 case tok::kw_int:
165 case tok::kw_long:
166 case tok::kw_signed:
167 case tok::kw_unsigned:
168 case tok::kw_float:
169 case tok::kw_double:
170 case tok::kw_void:
171 case tok::kw_typeof:
172 // If it's a builtin type name, eat it and expect a rparen
173 // __attribute__(( vec_type_hint(char) ))
174 ConsumeToken();
175 CurrAttr = new AttributeList(AttrName, AttrNameLoc,
176 0, SourceLocation(), 0, 0, CurrAttr);
177 if (Tok.is(tok::r_paren))
178 ConsumeParen();
179 break;
180 default:
Reid Spencer5f016e22007-07-11 17:01:13 +0000181 // __attribute__(( aligned(16) ))
Sebastian Redla55e52c2008-11-25 22:21:31 +0000182 ExprVector ArgExprs(Actions);
Reid Spencer5f016e22007-07-11 17:01:13 +0000183 bool ArgExprsOk = true;
184
185 // now parse the list of expressions
186 while (1) {
Sebastian Redl2f7ece72008-12-11 21:36:32 +0000187 OwningExprResult ArgExpr(ParseAssignmentExpression());
Sebastian Redl0e9eabc2008-12-09 13:15:23 +0000188 if (ArgExpr.isInvalid()) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000189 ArgExprsOk = false;
190 SkipUntil(tok::r_paren);
191 break;
192 } else {
Sebastian Redleffa8d12008-12-10 00:02:53 +0000193 ArgExprs.push_back(ArgExpr.release());
Reid Spencer5f016e22007-07-11 17:01:13 +0000194 }
Chris Lattner04d66662007-10-09 17:33:22 +0000195 if (Tok.isNot(tok::comma))
Reid Spencer5f016e22007-07-11 17:01:13 +0000196 break;
197 ConsumeToken(); // Eat the comma, move to the next argument
198 }
199 // Match the ')'.
Chris Lattner04d66662007-10-09 17:33:22 +0000200 if (ArgExprsOk && Tok.is(tok::r_paren)) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000201 ConsumeParen(); // ignore the right paren loc for now
Sebastian Redla55e52c2008-11-25 22:21:31 +0000202 CurrAttr = new AttributeList(AttrName, AttrNameLoc, 0,
203 SourceLocation(), ArgExprs.take(), ArgExprs.size(),
Reid Spencer5f016e22007-07-11 17:01:13 +0000204 CurrAttr);
205 }
Nate Begeman6f3d8382009-06-26 06:32:41 +0000206 break;
Reid Spencer5f016e22007-07-11 17:01:13 +0000207 }
208 }
209 } else {
210 CurrAttr = new AttributeList(AttrName, AttrNameLoc,
211 0, SourceLocation(), 0, 0, CurrAttr);
212 }
213 }
214 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen))
Reid Spencer5f016e22007-07-11 17:01:13 +0000215 SkipUntil(tok::r_paren, false);
Sebastian Redlab197ba2009-02-09 18:23:29 +0000216 SourceLocation Loc = Tok.getLocation();;
217 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) {
218 SkipUntil(tok::r_paren, false);
219 }
220 if (EndLoc)
221 *EndLoc = Loc;
Reid Spencer5f016e22007-07-11 17:01:13 +0000222 }
223 return CurrAttr;
224}
225
Eli Friedmana23b4852009-06-08 07:21:15 +0000226/// ParseMicrosoftDeclSpec - Parse an __declspec construct
227///
228/// [MS] decl-specifier:
229/// __declspec ( extended-decl-modifier-seq )
230///
231/// [MS] extended-decl-modifier-seq:
232/// extended-decl-modifier[opt]
233/// extended-decl-modifier extended-decl-modifier-seq
234
Eli Friedman290eeb02009-06-08 23:27:34 +0000235AttributeList* Parser::ParseMicrosoftDeclSpec(AttributeList *CurrAttr) {
Steve Narofff59e17e2008-12-24 20:59:21 +0000236 assert(Tok.is(tok::kw___declspec) && "Not a declspec!");
Eli Friedmana23b4852009-06-08 07:21:15 +0000237
Steve Narofff59e17e2008-12-24 20:59:21 +0000238 ConsumeToken();
Eli Friedmana23b4852009-06-08 07:21:15 +0000239 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
240 "declspec")) {
241 SkipUntil(tok::r_paren, true); // skip until ) or ;
242 return CurrAttr;
243 }
Eli Friedman290eeb02009-06-08 23:27:34 +0000244 while (Tok.getIdentifierInfo()) {
Eli Friedmana23b4852009-06-08 07:21:15 +0000245 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
246 SourceLocation AttrNameLoc = ConsumeToken();
247 if (Tok.is(tok::l_paren)) {
248 ConsumeParen();
249 // FIXME: This doesn't parse __declspec(property(get=get_func_name))
250 // correctly.
251 OwningExprResult ArgExpr(ParseAssignmentExpression());
252 if (!ArgExpr.isInvalid()) {
253 ExprTy* ExprList = ArgExpr.take();
254 CurrAttr = new AttributeList(AttrName, AttrNameLoc, 0,
255 SourceLocation(), &ExprList, 1,
256 CurrAttr, true);
257 }
258 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen))
259 SkipUntil(tok::r_paren, false);
260 } else {
261 CurrAttr = new AttributeList(AttrName, AttrNameLoc, 0, SourceLocation(),
262 0, 0, CurrAttr, true);
263 }
264 }
265 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen))
266 SkipUntil(tok::r_paren, false);
Eli Friedman290eeb02009-06-08 23:27:34 +0000267 return CurrAttr;
268}
269
270AttributeList* Parser::ParseMicrosoftTypeAttributes(AttributeList *CurrAttr) {
271 // Treat these like attributes
272 // FIXME: Allow Sema to distinguish between these and real attributes!
273 while (Tok.is(tok::kw___fastcall) || Tok.is(tok::kw___stdcall) ||
274 Tok.is(tok::kw___cdecl) || Tok.is(tok::kw___ptr64) ||
275 Tok.is(tok::kw___w64)) {
276 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
277 SourceLocation AttrNameLoc = ConsumeToken();
278 if (Tok.is(tok::kw___ptr64) || Tok.is(tok::kw___w64))
279 // FIXME: Support these properly!
280 continue;
281 CurrAttr = new AttributeList(AttrName, AttrNameLoc, 0,
282 SourceLocation(), 0, 0, CurrAttr, true);
283 }
284 return CurrAttr;
Steve Narofff59e17e2008-12-24 20:59:21 +0000285}
286
Reid Spencer5f016e22007-07-11 17:01:13 +0000287/// ParseDeclaration - Parse a full 'declaration', which consists of
288/// declaration-specifiers, some number of declarators, and a semicolon.
Chris Lattner97144fc2009-04-02 04:16:50 +0000289/// 'Context' should be a Declarator::TheContext value. This returns the
290/// location of the semicolon in DeclEnd.
Chris Lattner8f08cb72007-08-25 06:57:03 +0000291///
292/// declaration: [C99 6.7]
293/// block-declaration ->
294/// simple-declaration
295/// others [FIXME]
Douglas Gregoradcac882008-12-01 23:54:00 +0000296/// [C++] template-declaration
Chris Lattner8f08cb72007-08-25 06:57:03 +0000297/// [C++] namespace-definition
Douglas Gregorf780abc2008-12-30 03:27:21 +0000298/// [C++] using-directive
Douglas Gregord7f37bf2009-06-22 23:06:13 +0000299/// [C++] using-declaration
Sebastian Redl50de12f2009-03-24 22:27:57 +0000300/// [C++0x] static_assert-declaration
Chris Lattner8f08cb72007-08-25 06:57:03 +0000301/// others... [FIXME]
302///
Chris Lattner97144fc2009-04-02 04:16:50 +0000303Parser::DeclGroupPtrTy Parser::ParseDeclaration(unsigned Context,
304 SourceLocation &DeclEnd) {
Chris Lattner682bf922009-03-29 16:50:03 +0000305 DeclPtrTy SingleDecl;
Chris Lattner8f08cb72007-08-25 06:57:03 +0000306 switch (Tok.getKind()) {
Douglas Gregoradcac882008-12-01 23:54:00 +0000307 case tok::kw_template:
Douglas Gregor1426e532009-05-12 21:31:51 +0000308 case tok::kw_export:
Douglas Gregor4d9a16f2009-05-12 23:25:50 +0000309 SingleDecl = ParseDeclarationStartingWithTemplate(Context, DeclEnd);
Chris Lattner682bf922009-03-29 16:50:03 +0000310 break;
Chris Lattner8f08cb72007-08-25 06:57:03 +0000311 case tok::kw_namespace:
Chris Lattner97144fc2009-04-02 04:16:50 +0000312 SingleDecl = ParseNamespace(Context, DeclEnd);
Chris Lattner682bf922009-03-29 16:50:03 +0000313 break;
Douglas Gregorf780abc2008-12-30 03:27:21 +0000314 case tok::kw_using:
Chris Lattner97144fc2009-04-02 04:16:50 +0000315 SingleDecl = ParseUsingDirectiveOrDeclaration(Context, DeclEnd);
Chris Lattner682bf922009-03-29 16:50:03 +0000316 break;
Anders Carlsson511d7ab2009-03-11 16:27:10 +0000317 case tok::kw_static_assert:
Chris Lattner97144fc2009-04-02 04:16:50 +0000318 SingleDecl = ParseStaticAssertDeclaration(DeclEnd);
Chris Lattner682bf922009-03-29 16:50:03 +0000319 break;
Chris Lattner8f08cb72007-08-25 06:57:03 +0000320 default:
Chris Lattner97144fc2009-04-02 04:16:50 +0000321 return ParseSimpleDeclaration(Context, DeclEnd);
Chris Lattner8f08cb72007-08-25 06:57:03 +0000322 }
Chris Lattner682bf922009-03-29 16:50:03 +0000323
324 // This routine returns a DeclGroup, if the thing we parsed only contains a
325 // single decl, convert it now.
326 return Actions.ConvertDeclToDeclGroup(SingleDecl);
Chris Lattner8f08cb72007-08-25 06:57:03 +0000327}
328
329/// simple-declaration: [C99 6.7: declaration] [C++ 7p1: dcl.dcl]
330/// declaration-specifiers init-declarator-list[opt] ';'
331///[C90/C++]init-declarator-list ';' [TODO]
332/// [OMP] threadprivate-directive [TODO]
Chris Lattnercd147752009-03-29 17:27:48 +0000333///
334/// If RequireSemi is false, this does not check for a ';' at the end of the
335/// declaration.
336Parser::DeclGroupPtrTy Parser::ParseSimpleDeclaration(unsigned Context,
Chris Lattner97144fc2009-04-02 04:16:50 +0000337 SourceLocation &DeclEnd,
Chris Lattnercd147752009-03-29 17:27:48 +0000338 bool RequireSemi) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000339 // Parse the common declaration-specifiers piece.
340 DeclSpec DS;
341 ParseDeclarationSpecifiers(DS);
342
343 // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };"
344 // declaration-specifiers init-declarator-list[opt] ';'
Chris Lattner04d66662007-10-09 17:33:22 +0000345 if (Tok.is(tok::semi)) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000346 ConsumeToken();
Chris Lattner682bf922009-03-29 16:50:03 +0000347 DeclPtrTy TheDecl = Actions.ParsedFreeStandingDeclSpec(CurScope, DS);
348 return Actions.ConvertDeclToDeclGroup(TheDecl);
Reid Spencer5f016e22007-07-11 17:01:13 +0000349 }
350
351 Declarator DeclaratorInfo(DS, (Declarator::TheContext)Context);
352 ParseDeclarator(DeclaratorInfo);
353
Chris Lattner23c4b182009-03-29 17:18:04 +0000354 DeclGroupPtrTy DG =
355 ParseInitDeclaratorListAfterFirstDeclarator(DeclaratorInfo);
Chris Lattnercd147752009-03-29 17:27:48 +0000356
Chris Lattner97144fc2009-04-02 04:16:50 +0000357 DeclEnd = Tok.getLocation();
358
Chris Lattnercd147752009-03-29 17:27:48 +0000359 // If the client wants to check what comes after the declaration, just return
360 // immediately without checking anything!
361 if (!RequireSemi) return DG;
Chris Lattner23c4b182009-03-29 17:18:04 +0000362
363 if (Tok.is(tok::semi)) {
364 ConsumeToken();
Chris Lattner23c4b182009-03-29 17:18:04 +0000365 return DG;
366 }
367
Chris Lattner23c4b182009-03-29 17:18:04 +0000368 Diag(Tok, diag::err_expected_semi_declation);
369 // Skip to end of block or statement
370 SkipUntil(tok::r_brace, true, true);
371 if (Tok.is(tok::semi))
372 ConsumeToken();
373 return DG;
Reid Spencer5f016e22007-07-11 17:01:13 +0000374}
375
Douglas Gregor1426e532009-05-12 21:31:51 +0000376/// \brief Parse 'declaration' after parsing 'declaration-specifiers
377/// declarator'. This method parses the remainder of the declaration
378/// (including any attributes or initializer, among other things) and
379/// finalizes the declaration.
Reid Spencer5f016e22007-07-11 17:01:13 +0000380///
Reid Spencer5f016e22007-07-11 17:01:13 +0000381/// init-declarator: [C99 6.7]
382/// declarator
383/// declarator '=' initializer
384/// [GNU] declarator simple-asm-expr[opt] attributes[opt]
385/// [GNU] declarator simple-asm-expr[opt] attributes[opt] '=' initializer
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +0000386/// [C++] declarator initializer[opt]
387///
388/// [C++] initializer:
389/// [C++] '=' initializer-clause
390/// [C++] '(' expression-list ')'
Sebastian Redl50de12f2009-03-24 22:27:57 +0000391/// [C++0x] '=' 'default' [TODO]
392/// [C++0x] '=' 'delete'
393///
394/// According to the standard grammar, =default and =delete are function
395/// definitions, but that definitely doesn't fit with the parser here.
Reid Spencer5f016e22007-07-11 17:01:13 +0000396///
Douglas Gregore542c862009-06-23 23:11:28 +0000397Parser::DeclPtrTy Parser::ParseDeclarationAfterDeclarator(Declarator &D,
398 const ParsedTemplateInfo &TemplateInfo) {
Douglas Gregor1426e532009-05-12 21:31:51 +0000399 // If a simple-asm-expr is present, parse it.
400 if (Tok.is(tok::kw_asm)) {
401 SourceLocation Loc;
402 OwningExprResult AsmLabel(ParseSimpleAsm(&Loc));
403 if (AsmLabel.isInvalid()) {
404 SkipUntil(tok::semi, true, true);
405 return DeclPtrTy();
406 }
407
408 D.setAsmLabel(AsmLabel.release());
409 D.SetRangeEnd(Loc);
410 }
411
412 // If attributes are present, parse them.
413 if (Tok.is(tok::kw___attribute)) {
414 SourceLocation Loc;
415 AttributeList *AttrList = ParseAttributes(&Loc);
416 D.AddAttributes(AttrList, Loc);
417 }
418
419 // Inform the current actions module that we just parsed this declarator.
Douglas Gregore542c862009-06-23 23:11:28 +0000420 DeclPtrTy ThisDecl = TemplateInfo.TemplateParams?
421 Actions.ActOnTemplateDeclarator(CurScope,
422 Action::MultiTemplateParamsArg(Actions,
423 TemplateInfo.TemplateParams->data(),
424 TemplateInfo.TemplateParams->size()),
425 D)
426 : Actions.ActOnDeclarator(CurScope, D);
Douglas Gregor1426e532009-05-12 21:31:51 +0000427
428 // Parse declarator '=' initializer.
429 if (Tok.is(tok::equal)) {
430 ConsumeToken();
431 if (getLang().CPlusPlus0x && Tok.is(tok::kw_delete)) {
432 SourceLocation DelLoc = ConsumeToken();
433 Actions.SetDeclDeleted(ThisDecl, DelLoc);
434 } else {
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +0000435 if (getLang().CPlusPlus)
436 Actions.ActOnCXXEnterDeclInitializer(CurScope, ThisDecl);
437
Douglas Gregor1426e532009-05-12 21:31:51 +0000438 OwningExprResult Init(ParseInitializer());
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +0000439
440 if (getLang().CPlusPlus)
441 Actions.ActOnCXXExitDeclInitializer(CurScope, ThisDecl);
442
Douglas Gregor1426e532009-05-12 21:31:51 +0000443 if (Init.isInvalid()) {
444 SkipUntil(tok::semi, true, true);
445 return DeclPtrTy();
446 }
Anders Carlssonf5dcd382009-05-30 21:37:25 +0000447 Actions.AddInitializerToDecl(ThisDecl, Actions.FullExpr(Init));
Douglas Gregor1426e532009-05-12 21:31:51 +0000448 }
449 } else if (Tok.is(tok::l_paren)) {
450 // Parse C++ direct initializer: '(' expression-list ')'
451 SourceLocation LParenLoc = ConsumeParen();
452 ExprVector Exprs(Actions);
453 CommaLocsTy CommaLocs;
454
455 if (ParseExpressionList(Exprs, CommaLocs)) {
456 SkipUntil(tok::r_paren);
457 } else {
458 // Match the ')'.
459 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
460
461 assert(!Exprs.empty() && Exprs.size()-1 == CommaLocs.size() &&
462 "Unexpected number of commas!");
463 Actions.AddCXXDirectInitializerToDecl(ThisDecl, LParenLoc,
464 move_arg(Exprs),
Jay Foadbeaaccd2009-05-21 09:52:38 +0000465 CommaLocs.data(), RParenLoc);
Douglas Gregor1426e532009-05-12 21:31:51 +0000466 }
467 } else {
468 Actions.ActOnUninitializedDecl(ThisDecl);
469 }
470
471 return ThisDecl;
472}
473
474/// ParseInitDeclaratorListAfterFirstDeclarator - Parse 'declaration' after
475/// parsing 'declaration-specifiers declarator'. This method is split out this
476/// way to handle the ambiguity between top-level function-definitions and
477/// declarations.
478///
479/// init-declarator-list: [C99 6.7]
480/// init-declarator
481/// init-declarator-list ',' init-declarator
482///
483/// According to the standard grammar, =default and =delete are function
484/// definitions, but that definitely doesn't fit with the parser here.
485///
Chris Lattner682bf922009-03-29 16:50:03 +0000486Parser::DeclGroupPtrTy Parser::
Reid Spencer5f016e22007-07-11 17:01:13 +0000487ParseInitDeclaratorListAfterFirstDeclarator(Declarator &D) {
Chris Lattner682bf922009-03-29 16:50:03 +0000488 // Declarators may be grouped together ("int X, *Y, Z();"). Remember the decls
489 // that we parse together here.
490 llvm::SmallVector<DeclPtrTy, 8> DeclsInGroup;
Reid Spencer5f016e22007-07-11 17:01:13 +0000491
492 // At this point, we know that it is not a function definition. Parse the
493 // rest of the init-declarator-list.
494 while (1) {
Douglas Gregor1426e532009-05-12 21:31:51 +0000495 DeclPtrTy ThisDecl = ParseDeclarationAfterDeclarator(D);
496 if (ThisDecl.get())
497 DeclsInGroup.push_back(ThisDecl);
Reid Spencer5f016e22007-07-11 17:01:13 +0000498
Reid Spencer5f016e22007-07-11 17:01:13 +0000499 // If we don't have a comma, it is either the end of the list (a ';') or an
500 // error, bail out.
Chris Lattner04d66662007-10-09 17:33:22 +0000501 if (Tok.isNot(tok::comma))
Reid Spencer5f016e22007-07-11 17:01:13 +0000502 break;
503
504 // Consume the comma.
505 ConsumeToken();
506
507 // Parse the next declarator.
508 D.clear();
Chris Lattneraab740a2008-10-20 04:57:38 +0000509
510 // Accept attributes in an init-declarator. In the first declarator in a
511 // declaration, these would be part of the declspec. In subsequent
512 // declarators, they become part of the declarator itself, so that they
513 // don't apply to declarators after *this* one. Examples:
514 // short __attribute__((common)) var; -> declspec
515 // short var __attribute__((common)); -> declarator
516 // short x, __attribute__((common)) var; -> declarator
Sebastian Redlab197ba2009-02-09 18:23:29 +0000517 if (Tok.is(tok::kw___attribute)) {
518 SourceLocation Loc;
519 AttributeList *AttrList = ParseAttributes(&Loc);
520 D.AddAttributes(AttrList, Loc);
521 }
Chris Lattneraab740a2008-10-20 04:57:38 +0000522
Reid Spencer5f016e22007-07-11 17:01:13 +0000523 ParseDeclarator(D);
524 }
525
Eli Friedmanc1dc6532009-05-29 01:49:24 +0000526 return Actions.FinalizeDeclaratorGroup(CurScope, D.getDeclSpec(),
527 DeclsInGroup.data(),
Chris Lattner23c4b182009-03-29 17:18:04 +0000528 DeclsInGroup.size());
Reid Spencer5f016e22007-07-11 17:01:13 +0000529}
530
531/// ParseSpecifierQualifierList
532/// specifier-qualifier-list:
533/// type-specifier specifier-qualifier-list[opt]
534/// type-qualifier specifier-qualifier-list[opt]
535/// [GNU] attributes specifier-qualifier-list[opt]
536///
537void Parser::ParseSpecifierQualifierList(DeclSpec &DS) {
538 /// specifier-qualifier-list is a subset of declaration-specifiers. Just
539 /// parse declaration-specifiers and complain about extra stuff.
Reid Spencer5f016e22007-07-11 17:01:13 +0000540 ParseDeclarationSpecifiers(DS);
541
542 // Validate declspec for type-name.
543 unsigned Specs = DS.getParsedSpecifiers();
Chris Lattnerb6645dd2009-04-14 21:16:09 +0000544 if (Specs == DeclSpec::PQ_None && !DS.getNumProtocolQualifiers() &&
545 !DS.getAttributes())
Reid Spencer5f016e22007-07-11 17:01:13 +0000546 Diag(Tok, diag::err_typename_requires_specqual);
547
548 // Issue diagnostic and remove storage class if present.
549 if (Specs & DeclSpec::PQ_StorageClassSpecifier) {
550 if (DS.getStorageClassSpecLoc().isValid())
551 Diag(DS.getStorageClassSpecLoc(),diag::err_typename_invalid_storageclass);
552 else
553 Diag(DS.getThreadSpecLoc(), diag::err_typename_invalid_storageclass);
554 DS.ClearStorageClassSpecs();
555 }
556
557 // Issue diagnostic and remove function specfier if present.
558 if (Specs & DeclSpec::PQ_FunctionSpecifier) {
Douglas Gregorb48fe382008-10-31 09:07:45 +0000559 if (DS.isInlineSpecified())
560 Diag(DS.getInlineSpecLoc(), diag::err_typename_invalid_functionspec);
561 if (DS.isVirtualSpecified())
562 Diag(DS.getVirtualSpecLoc(), diag::err_typename_invalid_functionspec);
563 if (DS.isExplicitSpecified())
564 Diag(DS.getExplicitSpecLoc(), diag::err_typename_invalid_functionspec);
Reid Spencer5f016e22007-07-11 17:01:13 +0000565 DS.ClearFunctionSpecs();
566 }
567}
568
Chris Lattnerc199ab32009-04-12 20:42:31 +0000569/// isValidAfterIdentifierInDeclaratorAfterDeclSpec - Return true if the
570/// specified token is valid after the identifier in a declarator which
571/// immediately follows the declspec. For example, these things are valid:
572///
573/// int x [ 4]; // direct-declarator
574/// int x ( int y); // direct-declarator
575/// int(int x ) // direct-declarator
576/// int x ; // simple-declaration
577/// int x = 17; // init-declarator-list
578/// int x , y; // init-declarator-list
579/// int x __asm__ ("foo"); // init-declarator-list
Chris Lattnerb6645dd2009-04-14 21:16:09 +0000580/// int x : 4; // struct-declarator
Chris Lattnerc83c27a2009-04-12 22:29:43 +0000581/// int x { 5}; // C++'0x unified initializers
Chris Lattnerc199ab32009-04-12 20:42:31 +0000582///
583/// This is not, because 'x' does not immediately follow the declspec (though
584/// ')' happens to be valid anyway).
585/// int (x)
586///
587static bool isValidAfterIdentifierInDeclarator(const Token &T) {
588 return T.is(tok::l_square) || T.is(tok::l_paren) || T.is(tok::r_paren) ||
589 T.is(tok::semi) || T.is(tok::comma) || T.is(tok::equal) ||
Chris Lattnerb6645dd2009-04-14 21:16:09 +0000590 T.is(tok::kw_asm) || T.is(tok::l_brace) || T.is(tok::colon);
Chris Lattnerc199ab32009-04-12 20:42:31 +0000591}
592
Chris Lattnere40c2952009-04-14 21:34:55 +0000593
594/// ParseImplicitInt - This method is called when we have an non-typename
595/// identifier in a declspec (which normally terminates the decl spec) when
596/// the declspec has no type specifier. In this case, the declspec is either
597/// malformed or is "implicit int" (in K&R and C89).
598///
599/// This method handles diagnosing this prettily and returns false if the
600/// declspec is done being processed. If it recovers and thinks there may be
601/// other pieces of declspec after it, it returns true.
602///
Chris Lattnerf4382f52009-04-14 22:17:06 +0000603bool Parser::ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS,
Douglas Gregor4d9a16f2009-05-12 23:25:50 +0000604 const ParsedTemplateInfo &TemplateInfo,
Chris Lattnere40c2952009-04-14 21:34:55 +0000605 AccessSpecifier AS) {
Chris Lattnerf4382f52009-04-14 22:17:06 +0000606 assert(Tok.is(tok::identifier) && "should have identifier");
607
Chris Lattnere40c2952009-04-14 21:34:55 +0000608 SourceLocation Loc = Tok.getLocation();
609 // If we see an identifier that is not a type name, we normally would
610 // parse it as the identifer being declared. However, when a typename
611 // is typo'd or the definition is not included, this will incorrectly
612 // parse the typename as the identifier name and fall over misparsing
613 // later parts of the diagnostic.
614 //
615 // As such, we try to do some look-ahead in cases where this would
616 // otherwise be an "implicit-int" case to see if this is invalid. For
617 // example: "static foo_t x = 4;" In this case, if we parsed foo_t as
618 // an identifier with implicit int, we'd get a parse error because the
619 // next token is obviously invalid for a type. Parse these as a case
620 // with an invalid type specifier.
621 assert(!DS.hasTypeSpecifier() && "Type specifier checked above");
622
623 // Since we know that this either implicit int (which is rare) or an
624 // error, we'd do lookahead to try to do better recovery.
625 if (isValidAfterIdentifierInDeclarator(NextToken())) {
626 // If this token is valid for implicit int, e.g. "static x = 4", then
627 // we just avoid eating the identifier, so it will be parsed as the
628 // identifier in the declarator.
629 return false;
630 }
631
632 // Otherwise, if we don't consume this token, we are going to emit an
633 // error anyway. Try to recover from various common problems. Check
634 // to see if this was a reference to a tag name without a tag specified.
635 // This is a common problem in C (saying 'foo' instead of 'struct foo').
Chris Lattnerf4382f52009-04-14 22:17:06 +0000636 //
637 // C++ doesn't need this, and isTagName doesn't take SS.
638 if (SS == 0) {
639 const char *TagName = 0;
640 tok::TokenKind TagKind = tok::unknown;
Chris Lattnere40c2952009-04-14 21:34:55 +0000641
Chris Lattnere40c2952009-04-14 21:34:55 +0000642 switch (Actions.isTagName(*Tok.getIdentifierInfo(), CurScope)) {
643 default: break;
644 case DeclSpec::TST_enum: TagName="enum" ;TagKind=tok::kw_enum ;break;
645 case DeclSpec::TST_union: TagName="union" ;TagKind=tok::kw_union ;break;
646 case DeclSpec::TST_struct:TagName="struct";TagKind=tok::kw_struct;break;
647 case DeclSpec::TST_class: TagName="class" ;TagKind=tok::kw_class ;break;
648 }
Chris Lattnere40c2952009-04-14 21:34:55 +0000649
Chris Lattnerf4382f52009-04-14 22:17:06 +0000650 if (TagName) {
651 Diag(Loc, diag::err_use_of_tag_name_without_tag)
652 << Tok.getIdentifierInfo() << TagName
653 << CodeModificationHint::CreateInsertion(Tok.getLocation(),TagName);
654
655 // Parse this as a tag as if the missing tag were present.
656 if (TagKind == tok::kw_enum)
657 ParseEnumSpecifier(Loc, DS, AS);
658 else
Douglas Gregor4d9a16f2009-05-12 23:25:50 +0000659 ParseClassSpecifier(TagKind, Loc, DS, TemplateInfo, AS);
Chris Lattnerf4382f52009-04-14 22:17:06 +0000660 return true;
661 }
Chris Lattnere40c2952009-04-14 21:34:55 +0000662 }
663
664 // Since this is almost certainly an invalid type name, emit a
665 // diagnostic that says it, eat the token, and mark the declspec as
666 // invalid.
Chris Lattnerf4382f52009-04-14 22:17:06 +0000667 SourceRange R;
668 if (SS) R = SS->getRange();
669
670 Diag(Loc, diag::err_unknown_typename) << Tok.getIdentifierInfo() << R;
Chris Lattnere40c2952009-04-14 21:34:55 +0000671 const char *PrevSpec;
672 DS.SetTypeSpecType(DeclSpec::TST_error, Loc, PrevSpec);
673 DS.SetRangeEnd(Tok.getLocation());
674 ConsumeToken();
675
676 // TODO: Could inject an invalid typedef decl in an enclosing scope to
677 // avoid rippling error messages on subsequent uses of the same type,
678 // could be useful if #include was forgotten.
679 return false;
680}
681
Reid Spencer5f016e22007-07-11 17:01:13 +0000682/// ParseDeclarationSpecifiers
683/// declaration-specifiers: [C99 6.7]
684/// storage-class-specifier declaration-specifiers[opt]
685/// type-specifier declaration-specifiers[opt]
Reid Spencer5f016e22007-07-11 17:01:13 +0000686/// [C99] function-specifier declaration-specifiers[opt]
687/// [GNU] attributes declaration-specifiers[opt]
688///
689/// storage-class-specifier: [C99 6.7.1]
690/// 'typedef'
691/// 'extern'
692/// 'static'
693/// 'auto'
694/// 'register'
Sebastian Redl669d5d72008-11-14 23:42:31 +0000695/// [C++] 'mutable'
Reid Spencer5f016e22007-07-11 17:01:13 +0000696/// [GNU] '__thread'
Reid Spencer5f016e22007-07-11 17:01:13 +0000697/// function-specifier: [C99 6.7.4]
698/// [C99] 'inline'
Douglas Gregorb48fe382008-10-31 09:07:45 +0000699/// [C++] 'virtual'
700/// [C++] 'explicit'
Anders Carlssonf47f7a12009-05-06 04:46:28 +0000701/// 'friend': [C++ dcl.friend]
702
Reid Spencer5f016e22007-07-11 17:01:13 +0000703///
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +0000704void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
Douglas Gregor4d9a16f2009-05-12 23:25:50 +0000705 const ParsedTemplateInfo &TemplateInfo,
Chris Lattnerc199ab32009-04-12 20:42:31 +0000706 AccessSpecifier AS) {
Chris Lattner81c018d2008-03-13 06:29:04 +0000707 DS.SetRangeStart(Tok.getLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +0000708 while (1) {
709 int isInvalid = false;
710 const char *PrevSpec = 0;
711 SourceLocation Loc = Tok.getLocation();
Douglas Gregor12e083c2008-11-07 15:42:26 +0000712
Reid Spencer5f016e22007-07-11 17:01:13 +0000713 switch (Tok.getKind()) {
Douglas Gregor12e083c2008-11-07 15:42:26 +0000714 default:
Chris Lattnerbce61352008-07-26 00:20:22 +0000715 DoneWithDeclSpec:
Reid Spencer5f016e22007-07-11 17:01:13 +0000716 // If this is not a declaration specifier token, we're done reading decl
717 // specifiers. First verify that DeclSpec's are consistent.
Douglas Gregor9b3064b2009-04-01 22:41:11 +0000718 DS.Finish(Diags, PP);
Reid Spencer5f016e22007-07-11 17:01:13 +0000719 return;
Chris Lattner5e02c472009-01-05 00:07:25 +0000720
721 case tok::coloncolon: // ::foo::bar
722 // Annotate C++ scope specifiers. If we get one, loop.
723 if (TryAnnotateCXXScopeToken())
724 continue;
725 goto DoneWithDeclSpec;
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000726
727 case tok::annot_cxxscope: {
728 if (DS.hasTypeSpecifier())
729 goto DoneWithDeclSpec;
730
731 // We are looking for a qualified typename.
Douglas Gregor9135c722009-03-25 15:40:00 +0000732 Token Next = NextToken();
733 if (Next.is(tok::annot_template_id) &&
734 static_cast<TemplateIdAnnotation *>(Next.getAnnotationValue())
Douglas Gregorc45c2322009-03-31 00:43:58 +0000735 ->Kind == TNK_Type_template) {
Douglas Gregor9135c722009-03-25 15:40:00 +0000736 // We have a qualified template-id, e.g., N::A<int>
737 CXXScopeSpec SS;
738 ParseOptionalCXXScopeSpecifier(SS);
739 assert(Tok.is(tok::annot_template_id) &&
740 "ParseOptionalCXXScopeSpecifier not working");
741 AnnotateTemplateIdTokenAsType(&SS);
742 continue;
743 }
744
745 if (Next.isNot(tok::identifier))
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000746 goto DoneWithDeclSpec;
747
748 CXXScopeSpec SS;
Douglas Gregor35073692009-03-26 23:56:24 +0000749 SS.setScopeRep(Tok.getAnnotationValue());
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000750 SS.setRange(Tok.getAnnotationRange());
751
752 // If the next token is the name of the class type that the C++ scope
753 // denotes, followed by a '(', then this is a constructor declaration.
754 // We're done with the decl-specifiers.
Chris Lattnerf4382f52009-04-14 22:17:06 +0000755 if (Actions.isCurrentClassName(*Next.getIdentifierInfo(),
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000756 CurScope, &SS) &&
757 GetLookAheadToken(2).is(tok::l_paren))
758 goto DoneWithDeclSpec;
759
Douglas Gregorb696ea32009-02-04 17:00:24 +0000760 TypeTy *TypeRep = Actions.getTypeName(*Next.getIdentifierInfo(),
761 Next.getLocation(), CurScope, &SS);
Douglas Gregor55f6b142009-02-09 18:46:07 +0000762
Chris Lattnerf4382f52009-04-14 22:17:06 +0000763 // If the referenced identifier is not a type, then this declspec is
764 // erroneous: We already checked about that it has no type specifier, and
765 // C++ doesn't have implicit int. Diagnose it as a typo w.r.t. to the
766 // typename.
767 if (TypeRep == 0) {
768 ConsumeToken(); // Eat the scope spec so the identifier is current.
Douglas Gregor4d9a16f2009-05-12 23:25:50 +0000769 if (ParseImplicitInt(DS, &SS, TemplateInfo, AS)) continue;
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000770 goto DoneWithDeclSpec;
Chris Lattnerf4382f52009-04-14 22:17:06 +0000771 }
Douglas Gregore4e5b052009-03-19 00:18:19 +0000772
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000773 ConsumeToken(); // The C++ scope.
774
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000775 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000776 TypeRep);
777 if (isInvalid)
778 break;
779
780 DS.SetRangeEnd(Tok.getLocation());
781 ConsumeToken(); // The typename.
782
783 continue;
784 }
Chris Lattner80d0c892009-01-21 19:48:37 +0000785
786 case tok::annot_typename: {
Douglas Gregor31a19b62009-04-01 21:51:26 +0000787 if (Tok.getAnnotationValue())
788 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
789 Tok.getAnnotationValue());
790 else
791 DS.SetTypeSpecError();
Chris Lattner80d0c892009-01-21 19:48:37 +0000792 DS.SetRangeEnd(Tok.getAnnotationEndLoc());
793 ConsumeToken(); // The typename
794
795 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
796 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
797 // Objective-C interface. If we don't have Objective-C or a '<', this is
798 // just a normal reference to a typedef name.
799 if (!Tok.is(tok::less) || !getLang().ObjC1)
800 continue;
801
802 SourceLocation EndProtoLoc;
Chris Lattnerb28317a2009-03-28 19:18:32 +0000803 llvm::SmallVector<DeclPtrTy, 8> ProtocolDecl;
Chris Lattner80d0c892009-01-21 19:48:37 +0000804 ParseObjCProtocolReferences(ProtocolDecl, false, EndProtoLoc);
805 DS.setProtocolQualifiers(&ProtocolDecl[0], ProtocolDecl.size());
806
807 DS.SetRangeEnd(EndProtoLoc);
808 continue;
809 }
810
Chris Lattner3bd934a2008-07-26 01:18:38 +0000811 // typedef-name
812 case tok::identifier: {
Chris Lattner5e02c472009-01-05 00:07:25 +0000813 // In C++, check to see if this is a scope specifier like foo::bar::, if
814 // so handle it as such. This is important for ctor parsing.
Chris Lattner837acd02009-01-21 19:19:26 +0000815 if (getLang().CPlusPlus && TryAnnotateCXXScopeToken())
816 continue;
Chris Lattner5e02c472009-01-05 00:07:25 +0000817
Chris Lattner3bd934a2008-07-26 01:18:38 +0000818 // This identifier can only be a typedef name if we haven't already seen
819 // a type-specifier. Without this check we misparse:
820 // typedef int X; struct Y { short X; }; as 'short int'.
821 if (DS.hasTypeSpecifier())
822 goto DoneWithDeclSpec;
823
824 // It has to be available as a typedef too!
Douglas Gregorb696ea32009-02-04 17:00:24 +0000825 TypeTy *TypeRep = Actions.getTypeName(*Tok.getIdentifierInfo(),
826 Tok.getLocation(), CurScope);
Douglas Gregor55f6b142009-02-09 18:46:07 +0000827
Chris Lattnerc199ab32009-04-12 20:42:31 +0000828 // If this is not a typedef name, don't parse it as part of the declspec,
829 // it must be an implicit int or an error.
830 if (TypeRep == 0) {
Douglas Gregor4d9a16f2009-05-12 23:25:50 +0000831 if (ParseImplicitInt(DS, 0, TemplateInfo, AS)) continue;
Chris Lattner3bd934a2008-07-26 01:18:38 +0000832 goto DoneWithDeclSpec;
Chris Lattnerc199ab32009-04-12 20:42:31 +0000833 }
Douglas Gregor55f6b142009-02-09 18:46:07 +0000834
Douglas Gregorb48fe382008-10-31 09:07:45 +0000835 // C++: If the identifier is actually the name of the class type
836 // being defined and the next token is a '(', then this is a
837 // constructor declaration. We're done with the decl-specifiers
838 // and will treat this token as an identifier.
Chris Lattnerc199ab32009-04-12 20:42:31 +0000839 if (getLang().CPlusPlus && CurScope->isClassScope() &&
Douglas Gregorb48fe382008-10-31 09:07:45 +0000840 Actions.isCurrentClassName(*Tok.getIdentifierInfo(), CurScope) &&
841 NextToken().getKind() == tok::l_paren)
842 goto DoneWithDeclSpec;
843
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000844 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
Chris Lattner3bd934a2008-07-26 01:18:38 +0000845 TypeRep);
846 if (isInvalid)
847 break;
848
849 DS.SetRangeEnd(Tok.getLocation());
850 ConsumeToken(); // The identifier
851
852 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
853 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
854 // Objective-C interface. If we don't have Objective-C or a '<', this is
855 // just a normal reference to a typedef name.
856 if (!Tok.is(tok::less) || !getLang().ObjC1)
857 continue;
858
859 SourceLocation EndProtoLoc;
Chris Lattnerb28317a2009-03-28 19:18:32 +0000860 llvm::SmallVector<DeclPtrTy, 8> ProtocolDecl;
Chris Lattnere13b9592008-07-26 04:03:38 +0000861 ParseObjCProtocolReferences(ProtocolDecl, false, EndProtoLoc);
Chris Lattnerae4da612008-07-26 01:53:50 +0000862 DS.setProtocolQualifiers(&ProtocolDecl[0], ProtocolDecl.size());
Chris Lattner3bd934a2008-07-26 01:18:38 +0000863
864 DS.SetRangeEnd(EndProtoLoc);
865
Steve Naroff4f9b9f12008-09-22 10:28:57 +0000866 // Need to support trailing type qualifiers (e.g. "id<p> const").
867 // If a type specifier follows, it will be diagnosed elsewhere.
868 continue;
Chris Lattner3bd934a2008-07-26 01:18:38 +0000869 }
Douglas Gregor39a8de12009-02-25 19:37:18 +0000870
871 // type-name
872 case tok::annot_template_id: {
873 TemplateIdAnnotation *TemplateId
874 = static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue());
Douglas Gregorc45c2322009-03-31 00:43:58 +0000875 if (TemplateId->Kind != TNK_Type_template) {
Douglas Gregor39a8de12009-02-25 19:37:18 +0000876 // This template-id does not refer to a type name, so we're
877 // done with the type-specifiers.
878 goto DoneWithDeclSpec;
879 }
880
881 // Turn the template-id annotation token into a type annotation
882 // token, then try again to parse it as a type-specifier.
Douglas Gregor31a19b62009-04-01 21:51:26 +0000883 AnnotateTemplateIdTokenAsType();
Douglas Gregor39a8de12009-02-25 19:37:18 +0000884 continue;
885 }
886
Reid Spencer5f016e22007-07-11 17:01:13 +0000887 // GNU attributes support.
888 case tok::kw___attribute:
889 DS.AddAttributes(ParseAttributes());
890 continue;
Steve Narofff59e17e2008-12-24 20:59:21 +0000891
892 // Microsoft declspec support.
893 case tok::kw___declspec:
Eli Friedmana23b4852009-06-08 07:21:15 +0000894 DS.AddAttributes(ParseMicrosoftDeclSpec());
Steve Narofff59e17e2008-12-24 20:59:21 +0000895 continue;
Reid Spencer5f016e22007-07-11 17:01:13 +0000896
Steve Naroff239f0732008-12-25 14:16:32 +0000897 // Microsoft single token adornments.
Steve Naroff86bc6cf2008-12-25 14:41:26 +0000898 case tok::kw___forceinline:
Eli Friedman290eeb02009-06-08 23:27:34 +0000899 // FIXME: Add handling here!
900 break;
901
902 case tok::kw___ptr64:
Steve Naroff86bc6cf2008-12-25 14:41:26 +0000903 case tok::kw___w64:
Steve Naroff239f0732008-12-25 14:16:32 +0000904 case tok::kw___cdecl:
905 case tok::kw___stdcall:
906 case tok::kw___fastcall:
Eli Friedman290eeb02009-06-08 23:27:34 +0000907 DS.AddAttributes(ParseMicrosoftTypeAttributes());
908 continue;
909
Reid Spencer5f016e22007-07-11 17:01:13 +0000910 // storage-class-specifier
911 case tok::kw_typedef:
912 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_typedef, Loc, PrevSpec);
913 break;
914 case tok::kw_extern:
915 if (DS.isThreadSpecified())
Chris Lattner1ab3b962008-11-18 07:48:38 +0000916 Diag(Tok, diag::ext_thread_before) << "extern";
Reid Spencer5f016e22007-07-11 17:01:13 +0000917 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_extern, Loc, PrevSpec);
918 break;
Steve Naroff8d54bf22007-12-18 00:16:02 +0000919 case tok::kw___private_extern__:
Chris Lattnerf97409f2008-04-06 06:57:35 +0000920 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_private_extern, Loc,
921 PrevSpec);
Steve Naroff8d54bf22007-12-18 00:16:02 +0000922 break;
Reid Spencer5f016e22007-07-11 17:01:13 +0000923 case tok::kw_static:
924 if (DS.isThreadSpecified())
Chris Lattner1ab3b962008-11-18 07:48:38 +0000925 Diag(Tok, diag::ext_thread_before) << "static";
Reid Spencer5f016e22007-07-11 17:01:13 +0000926 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_static, Loc, PrevSpec);
927 break;
928 case tok::kw_auto:
Anders Carlssone89d1592009-06-26 18:41:36 +0000929 if (getLang().CPlusPlus0x)
930 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto, Loc, PrevSpec);
931 else
932 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_auto, Loc, PrevSpec);
Reid Spencer5f016e22007-07-11 17:01:13 +0000933 break;
934 case tok::kw_register:
935 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_register, Loc, PrevSpec);
936 break;
Sebastian Redl669d5d72008-11-14 23:42:31 +0000937 case tok::kw_mutable:
938 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_mutable, Loc, PrevSpec);
939 break;
Reid Spencer5f016e22007-07-11 17:01:13 +0000940 case tok::kw___thread:
941 isInvalid = DS.SetStorageClassSpecThread(Loc, PrevSpec)*2;
942 break;
Douglas Gregor12e083c2008-11-07 15:42:26 +0000943
Reid Spencer5f016e22007-07-11 17:01:13 +0000944 // function-specifier
945 case tok::kw_inline:
946 isInvalid = DS.SetFunctionSpecInline(Loc, PrevSpec);
947 break;
Douglas Gregorb48fe382008-10-31 09:07:45 +0000948 case tok::kw_virtual:
949 isInvalid = DS.SetFunctionSpecVirtual(Loc, PrevSpec);
950 break;
Douglas Gregorb48fe382008-10-31 09:07:45 +0000951 case tok::kw_explicit:
952 isInvalid = DS.SetFunctionSpecExplicit(Loc, PrevSpec);
953 break;
Chris Lattner80d0c892009-01-21 19:48:37 +0000954
Anders Carlssonf47f7a12009-05-06 04:46:28 +0000955 // friend
956 case tok::kw_friend:
957 isInvalid = DS.SetFriendSpec(Loc, PrevSpec);
958 break;
959
Chris Lattner80d0c892009-01-21 19:48:37 +0000960 // type-specifier
961 case tok::kw_short:
962 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec);
963 break;
964 case tok::kw_long:
965 if (DS.getTypeSpecWidth() != DeclSpec::TSW_long)
966 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec);
967 else
968 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec);
969 break;
970 case tok::kw_signed:
971 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec);
972 break;
973 case tok::kw_unsigned:
974 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec);
975 break;
976 case tok::kw__Complex:
977 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec);
978 break;
979 case tok::kw__Imaginary:
980 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec);
981 break;
982 case tok::kw_void:
983 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec);
984 break;
985 case tok::kw_char:
986 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec);
987 break;
988 case tok::kw_int:
989 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec);
990 break;
991 case tok::kw_float:
992 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec);
993 break;
994 case tok::kw_double:
995 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec);
996 break;
997 case tok::kw_wchar_t:
998 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec);
999 break;
1000 case tok::kw_bool:
1001 case tok::kw__Bool:
1002 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec);
1003 break;
1004 case tok::kw__Decimal32:
1005 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec);
1006 break;
1007 case tok::kw__Decimal64:
1008 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec);
1009 break;
1010 case tok::kw__Decimal128:
1011 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec);
1012 break;
1013
1014 // class-specifier:
1015 case tok::kw_class:
1016 case tok::kw_struct:
Chris Lattner4c97d762009-04-12 21:49:30 +00001017 case tok::kw_union: {
1018 tok::TokenKind Kind = Tok.getKind();
1019 ConsumeToken();
Douglas Gregor4d9a16f2009-05-12 23:25:50 +00001020 ParseClassSpecifier(Kind, Loc, DS, TemplateInfo, AS);
Chris Lattner80d0c892009-01-21 19:48:37 +00001021 continue;
Chris Lattner4c97d762009-04-12 21:49:30 +00001022 }
Chris Lattner80d0c892009-01-21 19:48:37 +00001023
1024 // enum-specifier:
1025 case tok::kw_enum:
Chris Lattner4c97d762009-04-12 21:49:30 +00001026 ConsumeToken();
1027 ParseEnumSpecifier(Loc, DS, AS);
Chris Lattner80d0c892009-01-21 19:48:37 +00001028 continue;
1029
1030 // cv-qualifier:
1031 case tok::kw_const:
1032 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const, Loc, PrevSpec,getLang())*2;
1033 break;
1034 case tok::kw_volatile:
1035 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec,
1036 getLang())*2;
1037 break;
1038 case tok::kw_restrict:
1039 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec,
1040 getLang())*2;
1041 break;
1042
Douglas Gregord57959a2009-03-27 23:10:48 +00001043 // C++ typename-specifier:
1044 case tok::kw_typename:
1045 if (TryAnnotateTypeOrScopeToken())
1046 continue;
1047 break;
1048
Chris Lattner80d0c892009-01-21 19:48:37 +00001049 // GNU typeof support.
1050 case tok::kw_typeof:
1051 ParseTypeofSpecifier(DS);
1052 continue;
1053
Anders Carlsson6fd634f2009-06-24 17:47:40 +00001054 case tok::kw_decltype:
1055 ParseDecltypeSpecifier(DS);
1056 continue;
1057
Steve Naroffd3ded1f2008-06-05 00:02:44 +00001058 case tok::less:
Chris Lattner3bd934a2008-07-26 01:18:38 +00001059 // GCC ObjC supports types like "<SomeProtocol>" as a synonym for
Chris Lattnerbce61352008-07-26 00:20:22 +00001060 // "id<SomeProtocol>". This is hopelessly old fashioned and dangerous,
1061 // but we support it.
Chris Lattner3bd934a2008-07-26 01:18:38 +00001062 if (DS.hasTypeSpecifier() || !getLang().ObjC1)
Chris Lattnerbce61352008-07-26 00:20:22 +00001063 goto DoneWithDeclSpec;
1064
1065 {
1066 SourceLocation EndProtoLoc;
Chris Lattnerb28317a2009-03-28 19:18:32 +00001067 llvm::SmallVector<DeclPtrTy, 8> ProtocolDecl;
Chris Lattnere13b9592008-07-26 04:03:38 +00001068 ParseObjCProtocolReferences(ProtocolDecl, false, EndProtoLoc);
Chris Lattnerae4da612008-07-26 01:53:50 +00001069 DS.setProtocolQualifiers(&ProtocolDecl[0], ProtocolDecl.size());
Chris Lattner3bd934a2008-07-26 01:18:38 +00001070 DS.SetRangeEnd(EndProtoLoc);
1071
Chris Lattner1ab3b962008-11-18 07:48:38 +00001072 Diag(Loc, diag::warn_objc_protocol_qualifier_missing_id)
Chris Lattner75e36062009-04-03 18:38:42 +00001073 << CodeModificationHint::CreateInsertion(Loc, "id")
Chris Lattner1ab3b962008-11-18 07:48:38 +00001074 << SourceRange(Loc, EndProtoLoc);
Steve Naroff4f9b9f12008-09-22 10:28:57 +00001075 // Need to support trailing type qualifiers (e.g. "id<p> const").
1076 // If a type specifier follows, it will be diagnosed elsewhere.
1077 continue;
Steve Naroffd3ded1f2008-06-05 00:02:44 +00001078 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001079 }
1080 // If the specifier combination wasn't legal, issue a diagnostic.
1081 if (isInvalid) {
1082 assert(PrevSpec && "Method did not return previous specifier!");
Chris Lattner1ab3b962008-11-18 07:48:38 +00001083 // Pick between error or extwarn.
1084 unsigned DiagID = isInvalid == 1 ? diag::err_invalid_decl_spec_combination
1085 : diag::ext_duplicate_declspec;
1086 Diag(Tok, DiagID) << PrevSpec;
Reid Spencer5f016e22007-07-11 17:01:13 +00001087 }
Chris Lattner81c018d2008-03-13 06:29:04 +00001088 DS.SetRangeEnd(Tok.getLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +00001089 ConsumeToken();
1090 }
1091}
Douglas Gregoradcac882008-12-01 23:54:00 +00001092
Chris Lattner7a0ab5f2009-01-06 06:59:53 +00001093/// ParseOptionalTypeSpecifier - Try to parse a single type-specifier. We
Douglas Gregor12e083c2008-11-07 15:42:26 +00001094/// primarily follow the C++ grammar with additions for C99 and GNU,
1095/// which together subsume the C grammar. Note that the C++
1096/// type-specifier also includes the C type-qualifier (for const,
1097/// volatile, and C99 restrict). Returns true if a type-specifier was
1098/// found (and parsed), false otherwise.
1099///
1100/// type-specifier: [C++ 7.1.5]
1101/// simple-type-specifier
1102/// class-specifier
1103/// enum-specifier
1104/// elaborated-type-specifier [TODO]
1105/// cv-qualifier
1106///
1107/// cv-qualifier: [C++ 7.1.5.1]
1108/// 'const'
1109/// 'volatile'
1110/// [C99] 'restrict'
1111///
1112/// simple-type-specifier: [ C++ 7.1.5.2]
1113/// '::'[opt] nested-name-specifier[opt] type-name [TODO]
1114/// '::'[opt] nested-name-specifier 'template' template-id [TODO]
1115/// 'char'
1116/// 'wchar_t'
1117/// 'bool'
1118/// 'short'
1119/// 'int'
1120/// 'long'
1121/// 'signed'
1122/// 'unsigned'
1123/// 'float'
1124/// 'double'
1125/// 'void'
1126/// [C99] '_Bool'
1127/// [C99] '_Complex'
1128/// [C99] '_Imaginary' // Removed in TC2?
1129/// [GNU] '_Decimal32'
1130/// [GNU] '_Decimal64'
1131/// [GNU] '_Decimal128'
1132/// [GNU] typeof-specifier
1133/// [OBJC] class-name objc-protocol-refs[opt] [TODO]
1134/// [OBJC] typedef-name objc-protocol-refs[opt] [TODO]
Anders Carlsson6fd634f2009-06-24 17:47:40 +00001135/// [C++0x] 'decltype' ( expression )
Chris Lattner7a0ab5f2009-01-06 06:59:53 +00001136bool Parser::ParseOptionalTypeSpecifier(DeclSpec &DS, int& isInvalid,
1137 const char *&PrevSpec,
Douglas Gregor4d9a16f2009-05-12 23:25:50 +00001138 const ParsedTemplateInfo &TemplateInfo) {
Douglas Gregor12e083c2008-11-07 15:42:26 +00001139 SourceLocation Loc = Tok.getLocation();
1140
1141 switch (Tok.getKind()) {
Chris Lattner166a8fc2009-01-04 23:41:41 +00001142 case tok::identifier: // foo::bar
Douglas Gregord57959a2009-03-27 23:10:48 +00001143 case tok::kw_typename: // typename foo::bar
Chris Lattner166a8fc2009-01-04 23:41:41 +00001144 // Annotate typenames and C++ scope specifiers. If we get one, just
1145 // recurse to handle whatever we get.
1146 if (TryAnnotateTypeOrScopeToken())
Douglas Gregor4d9a16f2009-05-12 23:25:50 +00001147 return ParseOptionalTypeSpecifier(DS, isInvalid, PrevSpec, TemplateInfo);
Chris Lattner166a8fc2009-01-04 23:41:41 +00001148 // Otherwise, not a type specifier.
1149 return false;
1150 case tok::coloncolon: // ::foo::bar
1151 if (NextToken().is(tok::kw_new) || // ::new
1152 NextToken().is(tok::kw_delete)) // ::delete
1153 return false;
1154
1155 // Annotate typenames and C++ scope specifiers. If we get one, just
1156 // recurse to handle whatever we get.
1157 if (TryAnnotateTypeOrScopeToken())
Douglas Gregor4d9a16f2009-05-12 23:25:50 +00001158 return ParseOptionalTypeSpecifier(DS, isInvalid, PrevSpec, TemplateInfo);
Chris Lattner166a8fc2009-01-04 23:41:41 +00001159 // Otherwise, not a type specifier.
1160 return false;
1161
Douglas Gregor12e083c2008-11-07 15:42:26 +00001162 // simple-type-specifier:
Chris Lattnerb31757b2009-01-06 05:06:21 +00001163 case tok::annot_typename: {
Douglas Gregor31a19b62009-04-01 21:51:26 +00001164 if (Tok.getAnnotationValue())
1165 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
1166 Tok.getAnnotationValue());
1167 else
1168 DS.SetTypeSpecError();
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001169 DS.SetRangeEnd(Tok.getAnnotationEndLoc());
1170 ConsumeToken(); // The typename
Douglas Gregor12e083c2008-11-07 15:42:26 +00001171
1172 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
1173 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
1174 // Objective-C interface. If we don't have Objective-C or a '<', this is
1175 // just a normal reference to a typedef name.
1176 if (!Tok.is(tok::less) || !getLang().ObjC1)
1177 return true;
1178
1179 SourceLocation EndProtoLoc;
Chris Lattnerb28317a2009-03-28 19:18:32 +00001180 llvm::SmallVector<DeclPtrTy, 8> ProtocolDecl;
Douglas Gregor12e083c2008-11-07 15:42:26 +00001181 ParseObjCProtocolReferences(ProtocolDecl, false, EndProtoLoc);
1182 DS.setProtocolQualifiers(&ProtocolDecl[0], ProtocolDecl.size());
1183
1184 DS.SetRangeEnd(EndProtoLoc);
1185 return true;
1186 }
1187
1188 case tok::kw_short:
1189 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec);
1190 break;
1191 case tok::kw_long:
1192 if (DS.getTypeSpecWidth() != DeclSpec::TSW_long)
1193 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec);
1194 else
1195 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec);
1196 break;
1197 case tok::kw_signed:
1198 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec);
1199 break;
1200 case tok::kw_unsigned:
1201 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec);
1202 break;
1203 case tok::kw__Complex:
1204 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec);
1205 break;
1206 case tok::kw__Imaginary:
1207 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec);
1208 break;
1209 case tok::kw_void:
1210 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec);
1211 break;
1212 case tok::kw_char:
1213 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec);
1214 break;
1215 case tok::kw_int:
1216 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec);
1217 break;
1218 case tok::kw_float:
1219 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec);
1220 break;
1221 case tok::kw_double:
1222 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec);
1223 break;
1224 case tok::kw_wchar_t:
1225 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec);
1226 break;
1227 case tok::kw_bool:
1228 case tok::kw__Bool:
1229 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec);
1230 break;
1231 case tok::kw__Decimal32:
1232 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec);
1233 break;
1234 case tok::kw__Decimal64:
1235 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec);
1236 break;
1237 case tok::kw__Decimal128:
1238 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec);
1239 break;
1240
1241 // class-specifier:
1242 case tok::kw_class:
1243 case tok::kw_struct:
Chris Lattner4c97d762009-04-12 21:49:30 +00001244 case tok::kw_union: {
1245 tok::TokenKind Kind = Tok.getKind();
1246 ConsumeToken();
Douglas Gregor4d9a16f2009-05-12 23:25:50 +00001247 ParseClassSpecifier(Kind, Loc, DS, TemplateInfo);
Douglas Gregor12e083c2008-11-07 15:42:26 +00001248 return true;
Chris Lattner4c97d762009-04-12 21:49:30 +00001249 }
Douglas Gregor12e083c2008-11-07 15:42:26 +00001250
1251 // enum-specifier:
1252 case tok::kw_enum:
Chris Lattner4c97d762009-04-12 21:49:30 +00001253 ConsumeToken();
1254 ParseEnumSpecifier(Loc, DS);
Douglas Gregor12e083c2008-11-07 15:42:26 +00001255 return true;
1256
1257 // cv-qualifier:
1258 case tok::kw_const:
1259 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const , Loc, PrevSpec,
1260 getLang())*2;
1261 break;
1262 case tok::kw_volatile:
1263 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec,
1264 getLang())*2;
1265 break;
1266 case tok::kw_restrict:
1267 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec,
1268 getLang())*2;
1269 break;
1270
1271 // GNU typeof support.
1272 case tok::kw_typeof:
1273 ParseTypeofSpecifier(DS);
1274 return true;
1275
Anders Carlsson6fd634f2009-06-24 17:47:40 +00001276 // C++0x decltype support.
1277 case tok::kw_decltype:
1278 ParseDecltypeSpecifier(DS);
1279 return true;
1280
Eli Friedman290eeb02009-06-08 23:27:34 +00001281 case tok::kw___ptr64:
1282 case tok::kw___w64:
Steve Naroff239f0732008-12-25 14:16:32 +00001283 case tok::kw___cdecl:
1284 case tok::kw___stdcall:
1285 case tok::kw___fastcall:
Eli Friedman290eeb02009-06-08 23:27:34 +00001286 DS.AddAttributes(ParseMicrosoftTypeAttributes());
Chris Lattner837acd02009-01-21 19:19:26 +00001287 return true;
Steve Naroff239f0732008-12-25 14:16:32 +00001288
Douglas Gregor12e083c2008-11-07 15:42:26 +00001289 default:
1290 // Not a type-specifier; do nothing.
1291 return false;
1292 }
1293
1294 // If the specifier combination wasn't legal, issue a diagnostic.
1295 if (isInvalid) {
1296 assert(PrevSpec && "Method did not return previous specifier!");
Chris Lattner1ab3b962008-11-18 07:48:38 +00001297 // Pick between error or extwarn.
1298 unsigned DiagID = isInvalid == 1 ? diag::err_invalid_decl_spec_combination
1299 : diag::ext_duplicate_declspec;
1300 Diag(Tok, DiagID) << PrevSpec;
Douglas Gregor12e083c2008-11-07 15:42:26 +00001301 }
1302 DS.SetRangeEnd(Tok.getLocation());
1303 ConsumeToken(); // whatever we parsed above.
1304 return true;
1305}
Reid Spencer5f016e22007-07-11 17:01:13 +00001306
Chris Lattnercd4b83c2007-10-29 04:42:53 +00001307/// ParseStructDeclaration - Parse a struct declaration without the terminating
1308/// semicolon.
1309///
Reid Spencer5f016e22007-07-11 17:01:13 +00001310/// struct-declaration:
Chris Lattnercd4b83c2007-10-29 04:42:53 +00001311/// specifier-qualifier-list struct-declarator-list
Reid Spencer5f016e22007-07-11 17:01:13 +00001312/// [GNU] __extension__ struct-declaration
Chris Lattnercd4b83c2007-10-29 04:42:53 +00001313/// [GNU] specifier-qualifier-list
Reid Spencer5f016e22007-07-11 17:01:13 +00001314/// struct-declarator-list:
1315/// struct-declarator
1316/// struct-declarator-list ',' struct-declarator
1317/// [GNU] struct-declarator-list ',' attributes[opt] struct-declarator
1318/// struct-declarator:
1319/// declarator
1320/// [GNU] declarator attributes[opt]
1321/// declarator[opt] ':' constant-expression
1322/// [GNU] declarator[opt] ':' constant-expression attributes[opt]
1323///
Chris Lattnere1359422008-04-10 06:46:29 +00001324void Parser::
1325ParseStructDeclaration(DeclSpec &DS,
1326 llvm::SmallVectorImpl<FieldDeclarator> &Fields) {
Chris Lattnerc46d1a12008-10-20 06:45:43 +00001327 if (Tok.is(tok::kw___extension__)) {
1328 // __extension__ silences extension warnings in the subexpression.
1329 ExtensionRAIIObject O(Diags); // Use RAII to do this.
Steve Naroff28a7ca82007-08-20 22:28:22 +00001330 ConsumeToken();
Chris Lattnerc46d1a12008-10-20 06:45:43 +00001331 return ParseStructDeclaration(DS, Fields);
1332 }
Steve Naroff28a7ca82007-08-20 22:28:22 +00001333
1334 // Parse the common specifier-qualifiers-list piece.
Chris Lattner60b1e3e2008-04-10 06:15:14 +00001335 SourceLocation DSStart = Tok.getLocation();
Steve Naroff28a7ca82007-08-20 22:28:22 +00001336 ParseSpecifierQualifierList(DS);
Steve Naroff28a7ca82007-08-20 22:28:22 +00001337
Douglas Gregor4920f1f2009-01-12 22:49:06 +00001338 // If there are no declarators, this is a free-standing declaration
1339 // specifier. Let the actions module cope with it.
Chris Lattner04d66662007-10-09 17:33:22 +00001340 if (Tok.is(tok::semi)) {
Douglas Gregor4920f1f2009-01-12 22:49:06 +00001341 Actions.ParsedFreeStandingDeclSpec(CurScope, DS);
Steve Naroff28a7ca82007-08-20 22:28:22 +00001342 return;
1343 }
1344
1345 // Read struct-declarators until we find the semicolon.
Chris Lattnerebe457c2008-04-10 16:37:40 +00001346 Fields.push_back(FieldDeclarator(DS));
Steve Naroff28a7ca82007-08-20 22:28:22 +00001347 while (1) {
Chris Lattnere1359422008-04-10 06:46:29 +00001348 FieldDeclarator &DeclaratorInfo = Fields.back();
1349
Steve Naroff28a7ca82007-08-20 22:28:22 +00001350 /// struct-declarator: declarator
1351 /// struct-declarator: declarator[opt] ':' constant-expression
Chris Lattner04d66662007-10-09 17:33:22 +00001352 if (Tok.isNot(tok::colon))
Chris Lattnere1359422008-04-10 06:46:29 +00001353 ParseDeclarator(DeclaratorInfo.D);
Steve Naroff28a7ca82007-08-20 22:28:22 +00001354
Chris Lattner04d66662007-10-09 17:33:22 +00001355 if (Tok.is(tok::colon)) {
Steve Naroff28a7ca82007-08-20 22:28:22 +00001356 ConsumeToken();
Sebastian Redl2f7ece72008-12-11 21:36:32 +00001357 OwningExprResult Res(ParseConstantExpression());
Sebastian Redl0e9eabc2008-12-09 13:15:23 +00001358 if (Res.isInvalid())
Steve Naroff28a7ca82007-08-20 22:28:22 +00001359 SkipUntil(tok::semi, true, true);
Chris Lattner60b1e3e2008-04-10 06:15:14 +00001360 else
Sebastian Redleffa8d12008-12-10 00:02:53 +00001361 DeclaratorInfo.BitfieldSize = Res.release();
Steve Naroff28a7ca82007-08-20 22:28:22 +00001362 }
Sebastian Redlab197ba2009-02-09 18:23:29 +00001363
Steve Naroff28a7ca82007-08-20 22:28:22 +00001364 // If attributes exist after the declarator, parse them.
Sebastian Redlab197ba2009-02-09 18:23:29 +00001365 if (Tok.is(tok::kw___attribute)) {
1366 SourceLocation Loc;
1367 AttributeList *AttrList = ParseAttributes(&Loc);
1368 DeclaratorInfo.D.AddAttributes(AttrList, Loc);
1369 }
1370
Steve Naroff28a7ca82007-08-20 22:28:22 +00001371 // If we don't have a comma, it is either the end of the list (a ';')
1372 // or an error, bail out.
Chris Lattner04d66662007-10-09 17:33:22 +00001373 if (Tok.isNot(tok::comma))
Chris Lattnercd4b83c2007-10-29 04:42:53 +00001374 return;
Sebastian Redlab197ba2009-02-09 18:23:29 +00001375
Steve Naroff28a7ca82007-08-20 22:28:22 +00001376 // Consume the comma.
1377 ConsumeToken();
Sebastian Redlab197ba2009-02-09 18:23:29 +00001378
Steve Naroff28a7ca82007-08-20 22:28:22 +00001379 // Parse the next declarator.
Chris Lattnerebe457c2008-04-10 16:37:40 +00001380 Fields.push_back(FieldDeclarator(DS));
Sebastian Redlab197ba2009-02-09 18:23:29 +00001381
Steve Naroff28a7ca82007-08-20 22:28:22 +00001382 // Attributes are only allowed on the second declarator.
Sebastian Redlab197ba2009-02-09 18:23:29 +00001383 if (Tok.is(tok::kw___attribute)) {
1384 SourceLocation Loc;
1385 AttributeList *AttrList = ParseAttributes(&Loc);
1386 Fields.back().D.AddAttributes(AttrList, Loc);
1387 }
Steve Naroff28a7ca82007-08-20 22:28:22 +00001388 }
Steve Naroff28a7ca82007-08-20 22:28:22 +00001389}
1390
1391/// ParseStructUnionBody
1392/// struct-contents:
1393/// struct-declaration-list
1394/// [EXT] empty
1395/// [GNU] "struct-declaration-list" without terminatoring ';'
1396/// struct-declaration-list:
1397/// struct-declaration
1398/// struct-declaration-list struct-declaration
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00001399/// [OBC] '@' 'defs' '(' class-name ')'
Steve Naroff28a7ca82007-08-20 22:28:22 +00001400///
Reid Spencer5f016e22007-07-11 17:01:13 +00001401void Parser::ParseStructUnionBody(SourceLocation RecordLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001402 unsigned TagType, DeclPtrTy TagDecl) {
Chris Lattner49f28ca2009-03-05 08:00:35 +00001403 PrettyStackTraceActionsDecl CrashInfo(TagDecl, RecordLoc, Actions,
1404 PP.getSourceManager(),
1405 "parsing struct/union body");
Chris Lattner27b7f102009-03-05 02:25:03 +00001406
Reid Spencer5f016e22007-07-11 17:01:13 +00001407 SourceLocation LBraceLoc = ConsumeBrace();
1408
Douglas Gregor3218c4b2009-01-09 22:42:13 +00001409 ParseScope StructScope(this, Scope::ClassScope|Scope::DeclScope);
Douglas Gregor72de6672009-01-08 20:45:30 +00001410 Actions.ActOnTagStartDefinition(CurScope, TagDecl);
1411
Reid Spencer5f016e22007-07-11 17:01:13 +00001412 // Empty structs are an extension in C (C99 6.7.2.1p7), but are allowed in
1413 // C++.
Douglas Gregore37ac4f2008-04-13 21:30:24 +00001414 if (Tok.is(tok::r_brace) && !getLang().CPlusPlus)
Chris Lattner1ab3b962008-11-18 07:48:38 +00001415 Diag(Tok, diag::ext_empty_struct_union_enum)
1416 << DeclSpec::getSpecifierName((DeclSpec::TST)TagType);
Reid Spencer5f016e22007-07-11 17:01:13 +00001417
Chris Lattnerb28317a2009-03-28 19:18:32 +00001418 llvm::SmallVector<DeclPtrTy, 32> FieldDecls;
Chris Lattnere1359422008-04-10 06:46:29 +00001419 llvm::SmallVector<FieldDeclarator, 8> FieldDeclarators;
1420
Reid Spencer5f016e22007-07-11 17:01:13 +00001421 // While we still have something to read, read the declarations in the struct.
Chris Lattner04d66662007-10-09 17:33:22 +00001422 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001423 // Each iteration of this loop reads one struct-declaration.
1424
1425 // Check for extraneous top-level semicolon.
Chris Lattner04d66662007-10-09 17:33:22 +00001426 if (Tok.is(tok::semi)) {
Douglas Gregor9b3064b2009-04-01 22:41:11 +00001427 Diag(Tok, diag::ext_extra_struct_semi)
1428 << CodeModificationHint::CreateRemoval(SourceRange(Tok.getLocation()));
Reid Spencer5f016e22007-07-11 17:01:13 +00001429 ConsumeToken();
1430 continue;
1431 }
Chris Lattnere1359422008-04-10 06:46:29 +00001432
1433 // Parse all the comma separated declarators.
1434 DeclSpec DS;
1435 FieldDeclarators.clear();
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00001436 if (!Tok.is(tok::at)) {
1437 ParseStructDeclaration(DS, FieldDeclarators);
1438
1439 // Convert them all to fields.
1440 for (unsigned i = 0, e = FieldDeclarators.size(); i != e; ++i) {
1441 FieldDeclarator &FD = FieldDeclarators[i];
1442 // Install the declarator into the current TagDecl.
Chris Lattnerb28317a2009-03-28 19:18:32 +00001443 DeclPtrTy Field = Actions.ActOnField(CurScope, TagDecl,
1444 DS.getSourceRange().getBegin(),
1445 FD.D, FD.BitfieldSize);
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00001446 FieldDecls.push_back(Field);
1447 }
1448 } else { // Handle @defs
1449 ConsumeToken();
1450 if (!Tok.isObjCAtKeyword(tok::objc_defs)) {
1451 Diag(Tok, diag::err_unexpected_at);
1452 SkipUntil(tok::semi, true, true);
1453 continue;
1454 }
1455 ConsumeToken();
1456 ExpectAndConsume(tok::l_paren, diag::err_expected_lparen);
1457 if (!Tok.is(tok::identifier)) {
1458 Diag(Tok, diag::err_expected_ident);
1459 SkipUntil(tok::semi, true, true);
1460 continue;
1461 }
Chris Lattnerb28317a2009-03-28 19:18:32 +00001462 llvm::SmallVector<DeclPtrTy, 16> Fields;
Douglas Gregor44b43212008-12-11 16:49:14 +00001463 Actions.ActOnDefs(CurScope, TagDecl, Tok.getLocation(),
1464 Tok.getIdentifierInfo(), Fields);
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00001465 FieldDecls.insert(FieldDecls.end(), Fields.begin(), Fields.end());
1466 ConsumeToken();
1467 ExpectAndConsume(tok::r_paren, diag::err_expected_rparen);
1468 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001469
Chris Lattner04d66662007-10-09 17:33:22 +00001470 if (Tok.is(tok::semi)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001471 ConsumeToken();
Chris Lattner04d66662007-10-09 17:33:22 +00001472 } else if (Tok.is(tok::r_brace)) {
Chris Lattner1ab3b962008-11-18 07:48:38 +00001473 Diag(Tok, diag::ext_expected_semi_decl_list);
Reid Spencer5f016e22007-07-11 17:01:13 +00001474 break;
1475 } else {
1476 Diag(Tok, diag::err_expected_semi_decl_list);
1477 // Skip to end of block or statement
1478 SkipUntil(tok::r_brace, true, true);
1479 }
1480 }
1481
Steve Naroff60fccee2007-10-29 21:38:07 +00001482 SourceLocation RBraceLoc = MatchRHSPunctuation(tok::r_brace, LBraceLoc);
Reid Spencer5f016e22007-07-11 17:01:13 +00001483
Reid Spencer5f016e22007-07-11 17:01:13 +00001484 AttributeList *AttrList = 0;
1485 // If attributes exist after struct contents, parse them.
Chris Lattner04d66662007-10-09 17:33:22 +00001486 if (Tok.is(tok::kw___attribute))
Daniel Dunbar5e592d82008-10-03 16:42:10 +00001487 AttrList = ParseAttributes();
Daniel Dunbar1bfe1c22008-10-03 02:03:53 +00001488
1489 Actions.ActOnFields(CurScope,
Jay Foadbeaaccd2009-05-21 09:52:38 +00001490 RecordLoc, TagDecl, FieldDecls.data(), FieldDecls.size(),
Daniel Dunbar1bfe1c22008-10-03 02:03:53 +00001491 LBraceLoc, RBraceLoc,
Douglas Gregor72de6672009-01-08 20:45:30 +00001492 AttrList);
1493 StructScope.Exit();
1494 Actions.ActOnTagFinishDefinition(CurScope, TagDecl);
Reid Spencer5f016e22007-07-11 17:01:13 +00001495}
1496
1497
1498/// ParseEnumSpecifier
1499/// enum-specifier: [C99 6.7.2.2]
1500/// 'enum' identifier[opt] '{' enumerator-list '}'
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001501///[C99/C++]'enum' identifier[opt] '{' enumerator-list ',' '}'
Reid Spencer5f016e22007-07-11 17:01:13 +00001502/// [GNU] 'enum' attributes[opt] identifier[opt] '{' enumerator-list ',' [opt]
1503/// '}' attributes[opt]
1504/// 'enum' identifier
1505/// [GNU] 'enum' attributes[opt] identifier
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001506///
1507/// [C++] elaborated-type-specifier:
1508/// [C++] 'enum' '::'[opt] nested-name-specifier[opt] identifier
1509///
Chris Lattner4c97d762009-04-12 21:49:30 +00001510void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS,
1511 AccessSpecifier AS) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001512 // Parse the tag portion of this.
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00001513
1514 AttributeList *Attr = 0;
1515 // If attributes exist after tag, parse them.
1516 if (Tok.is(tok::kw___attribute))
1517 Attr = ParseAttributes();
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001518
1519 CXXScopeSpec SS;
Chris Lattner7a0ab5f2009-01-06 06:59:53 +00001520 if (getLang().CPlusPlus && ParseOptionalCXXScopeSpecifier(SS)) {
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001521 if (Tok.isNot(tok::identifier)) {
1522 Diag(Tok, diag::err_expected_ident);
1523 if (Tok.isNot(tok::l_brace)) {
1524 // Has no name and is not a definition.
1525 // Skip the rest of this declarator, up until the comma or semicolon.
1526 SkipUntil(tok::comma, true);
1527 return;
1528 }
1529 }
1530 }
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00001531
1532 // Must have either 'enum name' or 'enum {...}'.
1533 if (Tok.isNot(tok::identifier) && Tok.isNot(tok::l_brace)) {
1534 Diag(Tok, diag::err_expected_ident_lbrace);
1535
1536 // Skip the rest of this declarator, up until the comma or semicolon.
1537 SkipUntil(tok::comma, true);
Reid Spencer5f016e22007-07-11 17:01:13 +00001538 return;
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00001539 }
1540
1541 // If an identifier is present, consume and remember it.
1542 IdentifierInfo *Name = 0;
1543 SourceLocation NameLoc;
1544 if (Tok.is(tok::identifier)) {
1545 Name = Tok.getIdentifierInfo();
1546 NameLoc = ConsumeToken();
1547 }
1548
1549 // There are three options here. If we have 'enum foo;', then this is a
1550 // forward declaration. If we have 'enum foo {...' then this is a
1551 // definition. Otherwise we have something like 'enum foo xyz', a reference.
1552 //
1553 // This is needed to handle stuff like this right (C99 6.7.2.3p11):
1554 // enum foo {..}; void bar() { enum foo; } <- new foo in bar.
1555 // enum foo {..}; void bar() { enum foo x; } <- use of old foo.
1556 //
1557 Action::TagKind TK;
1558 if (Tok.is(tok::l_brace))
1559 TK = Action::TK_Definition;
1560 else if (Tok.is(tok::semi))
1561 TK = Action::TK_Declaration;
1562 else
1563 TK = Action::TK_Reference;
Douglas Gregor402abb52009-05-28 23:31:59 +00001564 bool Owned = false;
Chris Lattnerb28317a2009-03-28 19:18:32 +00001565 DeclPtrTy TagDecl = Actions.ActOnTag(CurScope, DeclSpec::TST_enum, TK,
Douglas Gregor402abb52009-05-28 23:31:59 +00001566 StartLoc, SS, Name, NameLoc, Attr, AS,
1567 Owned);
Reid Spencer5f016e22007-07-11 17:01:13 +00001568
Chris Lattner04d66662007-10-09 17:33:22 +00001569 if (Tok.is(tok::l_brace))
Reid Spencer5f016e22007-07-11 17:01:13 +00001570 ParseEnumBody(StartLoc, TagDecl);
1571
1572 // TODO: semantic analysis on the declspec for enums.
1573 const char *PrevSpec = 0;
Chris Lattnerb28317a2009-03-28 19:18:32 +00001574 if (DS.SetTypeSpecType(DeclSpec::TST_enum, StartLoc, PrevSpec,
Douglas Gregor402abb52009-05-28 23:31:59 +00001575 TagDecl.getAs<void>(), Owned))
Chris Lattner1ab3b962008-11-18 07:48:38 +00001576 Diag(StartLoc, diag::err_invalid_decl_spec_combination) << PrevSpec;
Reid Spencer5f016e22007-07-11 17:01:13 +00001577}
1578
1579/// ParseEnumBody - Parse a {} enclosed enumerator-list.
1580/// enumerator-list:
1581/// enumerator
1582/// enumerator-list ',' enumerator
1583/// enumerator:
1584/// enumeration-constant
1585/// enumeration-constant '=' constant-expression
1586/// enumeration-constant:
1587/// identifier
1588///
Chris Lattnerb28317a2009-03-28 19:18:32 +00001589void Parser::ParseEnumBody(SourceLocation StartLoc, DeclPtrTy EnumDecl) {
Douglas Gregor074149e2009-01-05 19:45:36 +00001590 // Enter the scope of the enum body and start the definition.
1591 ParseScope EnumScope(this, Scope::DeclScope);
Douglas Gregor72de6672009-01-08 20:45:30 +00001592 Actions.ActOnTagStartDefinition(CurScope, EnumDecl);
Douglas Gregor074149e2009-01-05 19:45:36 +00001593
Reid Spencer5f016e22007-07-11 17:01:13 +00001594 SourceLocation LBraceLoc = ConsumeBrace();
1595
Chris Lattner7946dd32007-08-27 17:24:30 +00001596 // C does not allow an empty enumerator-list, C++ does [dcl.enum].
Chris Lattner04d66662007-10-09 17:33:22 +00001597 if (Tok.is(tok::r_brace) && !getLang().CPlusPlus)
Chris Lattner1ab3b962008-11-18 07:48:38 +00001598 Diag(Tok, diag::ext_empty_struct_union_enum) << "enum";
Reid Spencer5f016e22007-07-11 17:01:13 +00001599
Chris Lattnerb28317a2009-03-28 19:18:32 +00001600 llvm::SmallVector<DeclPtrTy, 32> EnumConstantDecls;
Reid Spencer5f016e22007-07-11 17:01:13 +00001601
Chris Lattnerb28317a2009-03-28 19:18:32 +00001602 DeclPtrTy LastEnumConstDecl;
Reid Spencer5f016e22007-07-11 17:01:13 +00001603
1604 // Parse the enumerator-list.
Chris Lattner04d66662007-10-09 17:33:22 +00001605 while (Tok.is(tok::identifier)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001606 IdentifierInfo *Ident = Tok.getIdentifierInfo();
1607 SourceLocation IdentLoc = ConsumeToken();
1608
1609 SourceLocation EqualLoc;
Sebastian Redl15faa7f2008-12-09 20:22:58 +00001610 OwningExprResult AssignedVal(Actions);
Chris Lattner04d66662007-10-09 17:33:22 +00001611 if (Tok.is(tok::equal)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001612 EqualLoc = ConsumeToken();
Sebastian Redl0e9eabc2008-12-09 13:15:23 +00001613 AssignedVal = ParseConstantExpression();
1614 if (AssignedVal.isInvalid())
Reid Spencer5f016e22007-07-11 17:01:13 +00001615 SkipUntil(tok::comma, tok::r_brace, true, true);
Reid Spencer5f016e22007-07-11 17:01:13 +00001616 }
1617
1618 // Install the enumerator constant into EnumDecl.
Chris Lattnerb28317a2009-03-28 19:18:32 +00001619 DeclPtrTy EnumConstDecl = Actions.ActOnEnumConstant(CurScope, EnumDecl,
1620 LastEnumConstDecl,
1621 IdentLoc, Ident,
1622 EqualLoc,
1623 AssignedVal.release());
Reid Spencer5f016e22007-07-11 17:01:13 +00001624 EnumConstantDecls.push_back(EnumConstDecl);
1625 LastEnumConstDecl = EnumConstDecl;
1626
Chris Lattner04d66662007-10-09 17:33:22 +00001627 if (Tok.isNot(tok::comma))
Reid Spencer5f016e22007-07-11 17:01:13 +00001628 break;
1629 SourceLocation CommaLoc = ConsumeToken();
1630
Douglas Gregor9b3064b2009-04-01 22:41:11 +00001631 if (Tok.isNot(tok::identifier) &&
1632 !(getLang().C99 || getLang().CPlusPlus0x))
1633 Diag(CommaLoc, diag::ext_enumerator_list_comma)
1634 << getLang().CPlusPlus
1635 << CodeModificationHint::CreateRemoval((SourceRange(CommaLoc)));
Reid Spencer5f016e22007-07-11 17:01:13 +00001636 }
1637
1638 // Eat the }.
Mike Stumpc6e35aa2009-05-16 07:06:02 +00001639 SourceLocation RBraceLoc = MatchRHSPunctuation(tok::r_brace, LBraceLoc);
Reid Spencer5f016e22007-07-11 17:01:13 +00001640
Mike Stumpc6e35aa2009-05-16 07:06:02 +00001641 Actions.ActOnEnumBody(StartLoc, LBraceLoc, RBraceLoc, EnumDecl,
Jay Foadbeaaccd2009-05-21 09:52:38 +00001642 EnumConstantDecls.data(), EnumConstantDecls.size());
Reid Spencer5f016e22007-07-11 17:01:13 +00001643
Chris Lattnerb28317a2009-03-28 19:18:32 +00001644 Action::AttrTy *AttrList = 0;
Reid Spencer5f016e22007-07-11 17:01:13 +00001645 // If attributes exist after the identifier list, parse them.
Chris Lattner04d66662007-10-09 17:33:22 +00001646 if (Tok.is(tok::kw___attribute))
Reid Spencer5f016e22007-07-11 17:01:13 +00001647 AttrList = ParseAttributes(); // FIXME: where do they do?
Douglas Gregor72de6672009-01-08 20:45:30 +00001648
1649 EnumScope.Exit();
1650 Actions.ActOnTagFinishDefinition(CurScope, EnumDecl);
Reid Spencer5f016e22007-07-11 17:01:13 +00001651}
1652
1653/// isTypeSpecifierQualifier - Return true if the current token could be the
Steve Naroff5f8aa692008-02-11 23:15:56 +00001654/// start of a type-qualifier-list.
1655bool Parser::isTypeQualifier() const {
1656 switch (Tok.getKind()) {
1657 default: return false;
1658 // type-qualifier
1659 case tok::kw_const:
1660 case tok::kw_volatile:
1661 case tok::kw_restrict:
1662 return true;
1663 }
1664}
1665
1666/// isTypeSpecifierQualifier - Return true if the current token could be the
Reid Spencer5f016e22007-07-11 17:01:13 +00001667/// start of a specifier-qualifier-list.
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001668bool Parser::isTypeSpecifierQualifier() {
Reid Spencer5f016e22007-07-11 17:01:13 +00001669 switch (Tok.getKind()) {
1670 default: return false;
Chris Lattner166a8fc2009-01-04 23:41:41 +00001671
1672 case tok::identifier: // foo::bar
Douglas Gregord57959a2009-03-27 23:10:48 +00001673 case tok::kw_typename: // typename T::type
Chris Lattner166a8fc2009-01-04 23:41:41 +00001674 // Annotate typenames and C++ scope specifiers. If we get one, just
1675 // recurse to handle whatever we get.
1676 if (TryAnnotateTypeOrScopeToken())
1677 return isTypeSpecifierQualifier();
1678 // Otherwise, not a type specifier.
1679 return false;
Douglas Gregord57959a2009-03-27 23:10:48 +00001680
Chris Lattner166a8fc2009-01-04 23:41:41 +00001681 case tok::coloncolon: // ::foo::bar
1682 if (NextToken().is(tok::kw_new) || // ::new
1683 NextToken().is(tok::kw_delete)) // ::delete
1684 return false;
1685
1686 // Annotate typenames and C++ scope specifiers. If we get one, just
1687 // recurse to handle whatever we get.
1688 if (TryAnnotateTypeOrScopeToken())
1689 return isTypeSpecifierQualifier();
1690 // Otherwise, not a type specifier.
1691 return false;
1692
Reid Spencer5f016e22007-07-11 17:01:13 +00001693 // GNU attributes support.
1694 case tok::kw___attribute:
Steve Naroffd1861fd2007-07-31 12:34:36 +00001695 // GNU typeof support.
1696 case tok::kw_typeof:
1697
Reid Spencer5f016e22007-07-11 17:01:13 +00001698 // type-specifiers
1699 case tok::kw_short:
1700 case tok::kw_long:
1701 case tok::kw_signed:
1702 case tok::kw_unsigned:
1703 case tok::kw__Complex:
1704 case tok::kw__Imaginary:
1705 case tok::kw_void:
1706 case tok::kw_char:
Argyrios Kyrtzidis64c438a2008-08-09 16:51:54 +00001707 case tok::kw_wchar_t:
Reid Spencer5f016e22007-07-11 17:01:13 +00001708 case tok::kw_int:
1709 case tok::kw_float:
1710 case tok::kw_double:
Chris Lattner9298d962007-11-15 05:25:19 +00001711 case tok::kw_bool:
Reid Spencer5f016e22007-07-11 17:01:13 +00001712 case tok::kw__Bool:
1713 case tok::kw__Decimal32:
1714 case tok::kw__Decimal64:
1715 case tok::kw__Decimal128:
1716
Chris Lattner99dc9142008-04-13 18:59:07 +00001717 // struct-or-union-specifier (C99) or class-specifier (C++)
1718 case tok::kw_class:
Reid Spencer5f016e22007-07-11 17:01:13 +00001719 case tok::kw_struct:
1720 case tok::kw_union:
1721 // enum-specifier
1722 case tok::kw_enum:
1723
1724 // type-qualifier
1725 case tok::kw_const:
1726 case tok::kw_volatile:
1727 case tok::kw_restrict:
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001728
1729 // typedef-name
Chris Lattnerb31757b2009-01-06 05:06:21 +00001730 case tok::annot_typename:
Reid Spencer5f016e22007-07-11 17:01:13 +00001731 return true;
Chris Lattner7c186be2008-10-20 00:25:30 +00001732
1733 // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
1734 case tok::less:
1735 return getLang().ObjC1;
Steve Naroff239f0732008-12-25 14:16:32 +00001736
1737 case tok::kw___cdecl:
1738 case tok::kw___stdcall:
1739 case tok::kw___fastcall:
Eli Friedman290eeb02009-06-08 23:27:34 +00001740 case tok::kw___w64:
1741 case tok::kw___ptr64:
1742 return true;
Reid Spencer5f016e22007-07-11 17:01:13 +00001743 }
1744}
1745
1746/// isDeclarationSpecifier() - Return true if the current token is part of a
1747/// declaration specifier.
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001748bool Parser::isDeclarationSpecifier() {
Reid Spencer5f016e22007-07-11 17:01:13 +00001749 switch (Tok.getKind()) {
1750 default: return false;
Chris Lattner166a8fc2009-01-04 23:41:41 +00001751
1752 case tok::identifier: // foo::bar
Steve Naroff61f72cb2009-03-09 21:12:44 +00001753 // Unfortunate hack to support "Class.factoryMethod" notation.
1754 if (getLang().ObjC1 && NextToken().is(tok::period))
1755 return false;
Douglas Gregord57959a2009-03-27 23:10:48 +00001756 // Fall through
Steve Naroff61f72cb2009-03-09 21:12:44 +00001757
Douglas Gregord57959a2009-03-27 23:10:48 +00001758 case tok::kw_typename: // typename T::type
Chris Lattner166a8fc2009-01-04 23:41:41 +00001759 // Annotate typenames and C++ scope specifiers. If we get one, just
1760 // recurse to handle whatever we get.
1761 if (TryAnnotateTypeOrScopeToken())
1762 return isDeclarationSpecifier();
1763 // Otherwise, not a declaration specifier.
1764 return false;
1765 case tok::coloncolon: // ::foo::bar
1766 if (NextToken().is(tok::kw_new) || // ::new
1767 NextToken().is(tok::kw_delete)) // ::delete
1768 return false;
1769
1770 // Annotate typenames and C++ scope specifiers. If we get one, just
1771 // recurse to handle whatever we get.
1772 if (TryAnnotateTypeOrScopeToken())
1773 return isDeclarationSpecifier();
1774 // Otherwise, not a declaration specifier.
1775 return false;
1776
Reid Spencer5f016e22007-07-11 17:01:13 +00001777 // storage-class-specifier
1778 case tok::kw_typedef:
1779 case tok::kw_extern:
Steve Naroff8d54bf22007-12-18 00:16:02 +00001780 case tok::kw___private_extern__:
Reid Spencer5f016e22007-07-11 17:01:13 +00001781 case tok::kw_static:
1782 case tok::kw_auto:
1783 case tok::kw_register:
1784 case tok::kw___thread:
1785
1786 // type-specifiers
1787 case tok::kw_short:
1788 case tok::kw_long:
1789 case tok::kw_signed:
1790 case tok::kw_unsigned:
1791 case tok::kw__Complex:
1792 case tok::kw__Imaginary:
1793 case tok::kw_void:
1794 case tok::kw_char:
Argyrios Kyrtzidis64c438a2008-08-09 16:51:54 +00001795 case tok::kw_wchar_t:
Reid Spencer5f016e22007-07-11 17:01:13 +00001796 case tok::kw_int:
1797 case tok::kw_float:
1798 case tok::kw_double:
Chris Lattner9298d962007-11-15 05:25:19 +00001799 case tok::kw_bool:
Reid Spencer5f016e22007-07-11 17:01:13 +00001800 case tok::kw__Bool:
1801 case tok::kw__Decimal32:
1802 case tok::kw__Decimal64:
1803 case tok::kw__Decimal128:
1804
Chris Lattner99dc9142008-04-13 18:59:07 +00001805 // struct-or-union-specifier (C99) or class-specifier (C++)
1806 case tok::kw_class:
Reid Spencer5f016e22007-07-11 17:01:13 +00001807 case tok::kw_struct:
1808 case tok::kw_union:
1809 // enum-specifier
1810 case tok::kw_enum:
1811
1812 // type-qualifier
1813 case tok::kw_const:
1814 case tok::kw_volatile:
1815 case tok::kw_restrict:
Steve Naroffd1861fd2007-07-31 12:34:36 +00001816
Reid Spencer5f016e22007-07-11 17:01:13 +00001817 // function-specifier
1818 case tok::kw_inline:
Douglas Gregorb48fe382008-10-31 09:07:45 +00001819 case tok::kw_virtual:
1820 case tok::kw_explicit:
Chris Lattnerd6c7c182007-08-09 16:40:21 +00001821
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001822 // typedef-name
Chris Lattnerb31757b2009-01-06 05:06:21 +00001823 case tok::annot_typename:
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001824
Chris Lattner1ef08762007-08-09 17:01:07 +00001825 // GNU typeof support.
1826 case tok::kw_typeof:
1827
1828 // GNU attributes.
Chris Lattnerd6c7c182007-08-09 16:40:21 +00001829 case tok::kw___attribute:
Reid Spencer5f016e22007-07-11 17:01:13 +00001830 return true;
Chris Lattnerf3948c42008-07-26 03:38:44 +00001831
1832 // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
1833 case tok::less:
1834 return getLang().ObjC1;
Steve Naroff239f0732008-12-25 14:16:32 +00001835
Steve Naroff47f52092009-01-06 19:34:12 +00001836 case tok::kw___declspec:
Steve Naroff239f0732008-12-25 14:16:32 +00001837 case tok::kw___cdecl:
1838 case tok::kw___stdcall:
1839 case tok::kw___fastcall:
Eli Friedman290eeb02009-06-08 23:27:34 +00001840 case tok::kw___w64:
1841 case tok::kw___ptr64:
1842 case tok::kw___forceinline:
1843 return true;
Reid Spencer5f016e22007-07-11 17:01:13 +00001844 }
1845}
1846
1847
1848/// ParseTypeQualifierListOpt
1849/// type-qualifier-list: [C99 6.7.5]
1850/// type-qualifier
Chris Lattner5a69d1c2008-12-18 07:02:59 +00001851/// [GNU] attributes [ only if AttributesAllowed=true ]
Reid Spencer5f016e22007-07-11 17:01:13 +00001852/// type-qualifier-list type-qualifier
Chris Lattner5a69d1c2008-12-18 07:02:59 +00001853/// [GNU] type-qualifier-list attributes [ only if AttributesAllowed=true ]
Reid Spencer5f016e22007-07-11 17:01:13 +00001854///
Chris Lattner5a69d1c2008-12-18 07:02:59 +00001855void Parser::ParseTypeQualifierListOpt(DeclSpec &DS, bool AttributesAllowed) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001856 while (1) {
1857 int isInvalid = false;
1858 const char *PrevSpec = 0;
1859 SourceLocation Loc = Tok.getLocation();
1860
1861 switch (Tok.getKind()) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001862 case tok::kw_const:
1863 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const , Loc, PrevSpec,
1864 getLang())*2;
1865 break;
1866 case tok::kw_volatile:
1867 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec,
1868 getLang())*2;
1869 break;
1870 case tok::kw_restrict:
1871 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec,
1872 getLang())*2;
1873 break;
Eli Friedman290eeb02009-06-08 23:27:34 +00001874 case tok::kw___w64:
Steve Naroff86bc6cf2008-12-25 14:41:26 +00001875 case tok::kw___ptr64:
Steve Naroff239f0732008-12-25 14:16:32 +00001876 case tok::kw___cdecl:
1877 case tok::kw___stdcall:
1878 case tok::kw___fastcall:
Eli Friedman290eeb02009-06-08 23:27:34 +00001879 if (AttributesAllowed) {
1880 DS.AddAttributes(ParseMicrosoftTypeAttributes());
1881 continue;
1882 }
1883 goto DoneWithTypeQuals;
Reid Spencer5f016e22007-07-11 17:01:13 +00001884 case tok::kw___attribute:
Chris Lattner5a69d1c2008-12-18 07:02:59 +00001885 if (AttributesAllowed) {
1886 DS.AddAttributes(ParseAttributes());
1887 continue; // do *not* consume the next token!
1888 }
1889 // otherwise, FALL THROUGH!
1890 default:
Steve Naroff239f0732008-12-25 14:16:32 +00001891 DoneWithTypeQuals:
Chris Lattner5a69d1c2008-12-18 07:02:59 +00001892 // If this is not a type-qualifier token, we're done reading type
1893 // qualifiers. First verify that DeclSpec's are consistent.
Douglas Gregor9b3064b2009-04-01 22:41:11 +00001894 DS.Finish(Diags, PP);
Chris Lattner5a69d1c2008-12-18 07:02:59 +00001895 return;
Reid Spencer5f016e22007-07-11 17:01:13 +00001896 }
Chris Lattnera1fcbad2008-12-18 06:50:14 +00001897
Reid Spencer5f016e22007-07-11 17:01:13 +00001898 // If the specifier combination wasn't legal, issue a diagnostic.
1899 if (isInvalid) {
1900 assert(PrevSpec && "Method did not return previous specifier!");
Chris Lattner1ab3b962008-11-18 07:48:38 +00001901 // Pick between error or extwarn.
1902 unsigned DiagID = isInvalid == 1 ? diag::err_invalid_decl_spec_combination
1903 : diag::ext_duplicate_declspec;
1904 Diag(Tok, DiagID) << PrevSpec;
Reid Spencer5f016e22007-07-11 17:01:13 +00001905 }
1906 ConsumeToken();
1907 }
1908}
1909
1910
1911/// ParseDeclarator - Parse and verify a newly-initialized declarator.
1912///
1913void Parser::ParseDeclarator(Declarator &D) {
1914 /// This implements the 'declarator' production in the C grammar, then checks
1915 /// for well-formedness and issues diagnostics.
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001916 ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
Reid Spencer5f016e22007-07-11 17:01:13 +00001917}
1918
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001919/// ParseDeclaratorInternal - Parse a C or C++ declarator. The direct-declarator
1920/// is parsed by the function passed to it. Pass null, and the direct-declarator
1921/// isn't parsed at all, making this function effectively parse the C++
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001922/// ptr-operator production.
1923///
Sebastian Redlf30208a2009-01-24 21:16:55 +00001924/// declarator: [C99 6.7.5] [C++ 8p4, dcl.decl]
1925/// [C] pointer[opt] direct-declarator
1926/// [C++] direct-declarator
1927/// [C++] ptr-operator declarator
Reid Spencer5f016e22007-07-11 17:01:13 +00001928///
1929/// pointer: [C99 6.7.5]
1930/// '*' type-qualifier-list[opt]
1931/// '*' type-qualifier-list[opt] pointer
1932///
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001933/// ptr-operator:
1934/// '*' cv-qualifier-seq[opt]
1935/// '&'
Sebastian Redl05532f22009-03-15 22:02:01 +00001936/// [C++0x] '&&'
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001937/// [GNU] '&' restrict[opt] attributes[opt]
Sebastian Redl05532f22009-03-15 22:02:01 +00001938/// [GNU?] '&&' restrict[opt] attributes[opt]
Sebastian Redlf30208a2009-01-24 21:16:55 +00001939/// '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt]
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001940void Parser::ParseDeclaratorInternal(Declarator &D,
1941 DirectDeclParseFunction DirectDeclParser) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001942
Sebastian Redlf30208a2009-01-24 21:16:55 +00001943 // C++ member pointers start with a '::' or a nested-name.
1944 // Member pointers get special handling, since there's no place for the
1945 // scope spec in the generic path below.
Chris Lattnerf919bfe2009-03-24 17:04:48 +00001946 if (getLang().CPlusPlus &&
1947 (Tok.is(tok::coloncolon) || Tok.is(tok::identifier) ||
1948 Tok.is(tok::annot_cxxscope))) {
Sebastian Redlf30208a2009-01-24 21:16:55 +00001949 CXXScopeSpec SS;
1950 if (ParseOptionalCXXScopeSpecifier(SS)) {
1951 if(Tok.isNot(tok::star)) {
1952 // The scope spec really belongs to the direct-declarator.
1953 D.getCXXScopeSpec() = SS;
1954 if (DirectDeclParser)
1955 (this->*DirectDeclParser)(D);
1956 return;
1957 }
1958
1959 SourceLocation Loc = ConsumeToken();
Sebastian Redlab197ba2009-02-09 18:23:29 +00001960 D.SetRangeEnd(Loc);
Sebastian Redlf30208a2009-01-24 21:16:55 +00001961 DeclSpec DS;
1962 ParseTypeQualifierListOpt(DS);
Sebastian Redlab197ba2009-02-09 18:23:29 +00001963 D.ExtendWithDeclSpec(DS);
Sebastian Redlf30208a2009-01-24 21:16:55 +00001964
1965 // Recurse to parse whatever is left.
1966 ParseDeclaratorInternal(D, DirectDeclParser);
1967
1968 // Sema will have to catch (syntactically invalid) pointers into global
1969 // scope. It has to catch pointers into namespace scope anyway.
1970 D.AddTypeInfo(DeclaratorChunk::getMemberPointer(SS,DS.getTypeQualifiers(),
Sebastian Redlab197ba2009-02-09 18:23:29 +00001971 Loc, DS.TakeAttributes()),
1972 /* Don't replace range end. */SourceLocation());
Sebastian Redlf30208a2009-01-24 21:16:55 +00001973 return;
1974 }
1975 }
1976
1977 tok::TokenKind Kind = Tok.getKind();
Steve Naroff5618bd42008-08-27 16:04:49 +00001978 // Not a pointer, C++ reference, or block.
Chris Lattner9af55002009-03-27 04:18:06 +00001979 if (Kind != tok::star && Kind != tok::caret &&
Chris Lattnerf919bfe2009-03-24 17:04:48 +00001980 (Kind != tok::amp || !getLang().CPlusPlus) &&
Sebastian Redl743de1f2009-03-23 00:00:23 +00001981 // We parse rvalue refs in C++03, because otherwise the errors are scary.
Chris Lattner9af55002009-03-27 04:18:06 +00001982 (Kind != tok::ampamp || !getLang().CPlusPlus)) {
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001983 if (DirectDeclParser)
1984 (this->*DirectDeclParser)(D);
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001985 return;
1986 }
Sebastian Redlf30208a2009-01-24 21:16:55 +00001987
Sebastian Redl05532f22009-03-15 22:02:01 +00001988 // Otherwise, '*' -> pointer, '^' -> block, '&' -> lvalue reference,
1989 // '&&' -> rvalue reference
Sebastian Redl743de1f2009-03-23 00:00:23 +00001990 SourceLocation Loc = ConsumeToken(); // Eat the *, ^, & or &&.
Sebastian Redlab197ba2009-02-09 18:23:29 +00001991 D.SetRangeEnd(Loc);
Reid Spencer5f016e22007-07-11 17:01:13 +00001992
Chris Lattner9af55002009-03-27 04:18:06 +00001993 if (Kind == tok::star || Kind == tok::caret) {
Chris Lattner76549142008-02-21 01:32:26 +00001994 // Is a pointer.
Reid Spencer5f016e22007-07-11 17:01:13 +00001995 DeclSpec DS;
Sebastian Redlf30208a2009-01-24 21:16:55 +00001996
Reid Spencer5f016e22007-07-11 17:01:13 +00001997 ParseTypeQualifierListOpt(DS);
Sebastian Redlab197ba2009-02-09 18:23:29 +00001998 D.ExtendWithDeclSpec(DS);
Sebastian Redlf30208a2009-01-24 21:16:55 +00001999
Reid Spencer5f016e22007-07-11 17:01:13 +00002000 // Recursively parse the declarator.
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002001 ParseDeclaratorInternal(D, DirectDeclParser);
Steve Naroff5618bd42008-08-27 16:04:49 +00002002 if (Kind == tok::star)
2003 // Remember that we parsed a pointer type, and remember the type-quals.
2004 D.AddTypeInfo(DeclaratorChunk::getPointer(DS.getTypeQualifiers(), Loc,
Sebastian Redlab197ba2009-02-09 18:23:29 +00002005 DS.TakeAttributes()),
2006 SourceLocation());
Steve Naroff5618bd42008-08-27 16:04:49 +00002007 else
2008 // Remember that we parsed a Block type, and remember the type-quals.
2009 D.AddTypeInfo(DeclaratorChunk::getBlockPointer(DS.getTypeQualifiers(),
Mike Stump75b163f2009-04-21 00:51:43 +00002010 Loc, DS.TakeAttributes()),
Sebastian Redlab197ba2009-02-09 18:23:29 +00002011 SourceLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +00002012 } else {
2013 // Is a reference
2014 DeclSpec DS;
2015
Sebastian Redl743de1f2009-03-23 00:00:23 +00002016 // Complain about rvalue references in C++03, but then go on and build
2017 // the declarator.
2018 if (Kind == tok::ampamp && !getLang().CPlusPlus0x)
2019 Diag(Loc, diag::err_rvalue_reference);
2020
Reid Spencer5f016e22007-07-11 17:01:13 +00002021 // C++ 8.3.2p1: cv-qualified references are ill-formed except when the
2022 // cv-qualifiers are introduced through the use of a typedef or of a
2023 // template type argument, in which case the cv-qualifiers are ignored.
2024 //
2025 // [GNU] Retricted references are allowed.
2026 // [GNU] Attributes on references are allowed.
2027 ParseTypeQualifierListOpt(DS);
Sebastian Redlab197ba2009-02-09 18:23:29 +00002028 D.ExtendWithDeclSpec(DS);
Reid Spencer5f016e22007-07-11 17:01:13 +00002029
2030 if (DS.getTypeQualifiers() != DeclSpec::TQ_unspecified) {
2031 if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
2032 Diag(DS.getConstSpecLoc(),
Chris Lattner1ab3b962008-11-18 07:48:38 +00002033 diag::err_invalid_reference_qualifier_application) << "const";
Reid Spencer5f016e22007-07-11 17:01:13 +00002034 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
2035 Diag(DS.getVolatileSpecLoc(),
Chris Lattner1ab3b962008-11-18 07:48:38 +00002036 diag::err_invalid_reference_qualifier_application) << "volatile";
Reid Spencer5f016e22007-07-11 17:01:13 +00002037 }
2038
2039 // Recursively parse the declarator.
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002040 ParseDeclaratorInternal(D, DirectDeclParser);
Reid Spencer5f016e22007-07-11 17:01:13 +00002041
Douglas Gregorf1f9b4e2008-11-03 15:51:28 +00002042 if (D.getNumTypeObjects() > 0) {
2043 // C++ [dcl.ref]p4: There shall be no references to references.
2044 DeclaratorChunk& InnerChunk = D.getTypeObject(D.getNumTypeObjects() - 1);
2045 if (InnerChunk.Kind == DeclaratorChunk::Reference) {
Chris Lattnerda83bac2008-11-19 07:37:42 +00002046 if (const IdentifierInfo *II = D.getIdentifier())
2047 Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference)
2048 << II;
2049 else
2050 Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference)
2051 << "type name";
Douglas Gregorf1f9b4e2008-11-03 15:51:28 +00002052
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002053 // Once we've complained about the reference-to-reference, we
Douglas Gregorf1f9b4e2008-11-03 15:51:28 +00002054 // can go ahead and build the (technically ill-formed)
2055 // declarator: reference collapsing will take care of it.
2056 }
2057 }
2058
Reid Spencer5f016e22007-07-11 17:01:13 +00002059 // Remember that we parsed a reference type. It doesn't have type-quals.
Chris Lattner76549142008-02-21 01:32:26 +00002060 D.AddTypeInfo(DeclaratorChunk::getReference(DS.getTypeQualifiers(), Loc,
Sebastian Redl05532f22009-03-15 22:02:01 +00002061 DS.TakeAttributes(),
2062 Kind == tok::amp),
Sebastian Redlab197ba2009-02-09 18:23:29 +00002063 SourceLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +00002064 }
2065}
2066
2067/// ParseDirectDeclarator
2068/// direct-declarator: [C99 6.7.5]
Douglas Gregor42a552f2008-11-05 20:51:48 +00002069/// [C99] identifier
Reid Spencer5f016e22007-07-11 17:01:13 +00002070/// '(' declarator ')'
2071/// [GNU] '(' attributes declarator ')'
2072/// [C90] direct-declarator '[' constant-expression[opt] ']'
2073/// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
2074/// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
2075/// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']'
2076/// [C99] direct-declarator '[' type-qual-list[opt] '*' ']'
2077/// direct-declarator '(' parameter-type-list ')'
2078/// direct-declarator '(' identifier-list[opt] ')'
2079/// [GNU] direct-declarator '(' parameter-forward-declarations
2080/// parameter-type-list[opt] ')'
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +00002081/// [C++] direct-declarator '(' parameter-declaration-clause ')'
2082/// cv-qualifier-seq[opt] exception-specification[opt]
Douglas Gregorb48fe382008-10-31 09:07:45 +00002083/// [C++] declarator-id
Douglas Gregor42a552f2008-11-05 20:51:48 +00002084///
2085/// declarator-id: [C++ 8]
2086/// id-expression
2087/// '::'[opt] nested-name-specifier[opt] type-name
2088///
2089/// id-expression: [C++ 5.1]
2090/// unqualified-id
2091/// qualified-id [TODO]
2092///
2093/// unqualified-id: [C++ 5.1]
2094/// identifier
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002095/// operator-function-id
Douglas Gregor42a552f2008-11-05 20:51:48 +00002096/// conversion-function-id [TODO]
2097/// '~' class-name
Douglas Gregor39a8de12009-02-25 19:37:18 +00002098/// template-id
Argyrios Kyrtzidisc7ed9c62008-11-07 22:02:30 +00002099///
Reid Spencer5f016e22007-07-11 17:01:13 +00002100void Parser::ParseDirectDeclarator(Declarator &D) {
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00002101 DeclaratorScopeObj DeclScopeObj(*this, D.getCXXScopeSpec());
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002102
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00002103 if (getLang().CPlusPlus) {
2104 if (D.mayHaveIdentifier()) {
Sebastian Redlf30208a2009-01-24 21:16:55 +00002105 // ParseDeclaratorInternal might already have parsed the scope.
2106 bool afterCXXScope = D.getCXXScopeSpec().isSet() ||
2107 ParseOptionalCXXScopeSpecifier(D.getCXXScopeSpec());
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00002108 if (afterCXXScope) {
2109 // Change the declaration context for name lookup, until this function
2110 // is exited (and the declarator has been parsed).
2111 DeclScopeObj.EnterDeclaratorScope();
2112 }
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002113
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00002114 if (Tok.is(tok::identifier)) {
2115 assert(Tok.getIdentifierInfo() && "Not an identifier?");
Anders Carlsson4649cac2009-04-30 22:41:11 +00002116
2117 // If this identifier is the name of the current class, it's a
2118 // constructor name.
2119 if (!D.getDeclSpec().hasTypeSpecifier() &&
2120 Actions.isCurrentClassName(*Tok.getIdentifierInfo(),CurScope)) {
2121 D.setConstructor(Actions.getTypeName(*Tok.getIdentifierInfo(),
2122 Tok.getLocation(), CurScope),
2123 Tok.getLocation());
2124 // This is a normal identifier.
2125 } else
2126 D.SetIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00002127 ConsumeToken();
2128 goto PastIdentifier;
Douglas Gregor39a8de12009-02-25 19:37:18 +00002129 } else if (Tok.is(tok::annot_template_id)) {
2130 TemplateIdAnnotation *TemplateId
2131 = static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue());
2132
2133 // FIXME: Could this template-id name a constructor?
2134
2135 // FIXME: This is an egregious hack, where we silently ignore
2136 // the specialization (which should be a function template
2137 // specialization name) and use the name instead. This hack
2138 // will go away when we have support for function
2139 // specializations.
2140 D.SetIdentifier(TemplateId->Name, Tok.getLocation());
2141 TemplateId->Destroy();
2142 ConsumeToken();
2143 goto PastIdentifier;
Douglas Gregor70316a02008-12-26 15:00:45 +00002144 } else if (Tok.is(tok::kw_operator)) {
2145 SourceLocation OperatorLoc = Tok.getLocation();
Sebastian Redlab197ba2009-02-09 18:23:29 +00002146 SourceLocation EndLoc;
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002147
Douglas Gregor70316a02008-12-26 15:00:45 +00002148 // First try the name of an overloaded operator
Sebastian Redlab197ba2009-02-09 18:23:29 +00002149 if (OverloadedOperatorKind Op = TryParseOperatorFunctionId(&EndLoc)) {
2150 D.setOverloadedOperator(Op, OperatorLoc, EndLoc);
Douglas Gregor70316a02008-12-26 15:00:45 +00002151 } else {
2152 // This must be a conversion function (C++ [class.conv.fct]).
Sebastian Redlab197ba2009-02-09 18:23:29 +00002153 if (TypeTy *ConvType = ParseConversionFunctionId(&EndLoc))
2154 D.setConversionFunction(ConvType, OperatorLoc, EndLoc);
2155 else {
Douglas Gregor70316a02008-12-26 15:00:45 +00002156 D.SetIdentifier(0, Tok.getLocation());
Sebastian Redlab197ba2009-02-09 18:23:29 +00002157 }
Douglas Gregor70316a02008-12-26 15:00:45 +00002158 }
2159 goto PastIdentifier;
2160 } else if (Tok.is(tok::tilde)) {
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00002161 // This should be a C++ destructor.
2162 SourceLocation TildeLoc = ConsumeToken();
2163 if (Tok.is(tok::identifier)) {
Sebastian Redlab197ba2009-02-09 18:23:29 +00002164 // FIXME: Inaccurate.
2165 SourceLocation NameLoc = Tok.getLocation();
Douglas Gregor7f43d672009-02-25 23:52:28 +00002166 SourceLocation EndLoc;
Douglas Gregor31a19b62009-04-01 21:51:26 +00002167 TypeResult Type = ParseClassName(EndLoc);
2168 if (Type.isInvalid())
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00002169 D.SetIdentifier(0, TildeLoc);
Douglas Gregor31a19b62009-04-01 21:51:26 +00002170 else
2171 D.setDestructor(Type.get(), TildeLoc, NameLoc);
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00002172 } else {
2173 Diag(Tok, diag::err_expected_class_name);
2174 D.SetIdentifier(0, TildeLoc);
2175 }
2176 goto PastIdentifier;
2177 }
2178
2179 // If we reached this point, token is not identifier and not '~'.
2180
2181 if (afterCXXScope) {
2182 Diag(Tok, diag::err_expected_unqualified_id);
2183 D.SetIdentifier(0, Tok.getLocation());
2184 D.setInvalidType(true);
2185 goto PastIdentifier;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002186 }
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002187 }
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00002188 }
2189
2190 // If we reached this point, we are either in C/ObjC or the token didn't
2191 // satisfy any of the C++-specific checks.
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00002192 if (Tok.is(tok::identifier) && D.mayHaveIdentifier()) {
2193 assert(!getLang().CPlusPlus &&
2194 "There's a C++-specific check for tok::identifier above");
2195 assert(Tok.getIdentifierInfo() && "Not an identifier?");
2196 D.SetIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
2197 ConsumeToken();
2198 } else if (Tok.is(tok::l_paren)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00002199 // direct-declarator: '(' declarator ')'
2200 // direct-declarator: '(' attributes declarator ')'
2201 // Example: 'char (*X)' or 'int (*XX)(void)'
2202 ParseParenDeclarator(D);
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00002203 } else if (D.mayOmitIdentifier()) {
Reid Spencer5f016e22007-07-11 17:01:13 +00002204 // This could be something simple like "int" (in which case the declarator
2205 // portion is empty), if an abstract-declarator is allowed.
2206 D.SetIdentifier(0, Tok.getLocation());
2207 } else {
Douglas Gregore950d4b2009-03-06 23:28:18 +00002208 if (D.getContext() == Declarator::MemberContext)
2209 Diag(Tok, diag::err_expected_member_name_or_semi)
2210 << D.getDeclSpec().getSourceRange();
2211 else if (getLang().CPlusPlus)
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002212 Diag(Tok, diag::err_expected_unqualified_id);
2213 else
Chris Lattner1ab3b962008-11-18 07:48:38 +00002214 Diag(Tok, diag::err_expected_ident_lparen);
Reid Spencer5f016e22007-07-11 17:01:13 +00002215 D.SetIdentifier(0, Tok.getLocation());
Chris Lattner1f6f54b2008-11-11 06:13:16 +00002216 D.setInvalidType(true);
Reid Spencer5f016e22007-07-11 17:01:13 +00002217 }
2218
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00002219 PastIdentifier:
Reid Spencer5f016e22007-07-11 17:01:13 +00002220 assert(D.isPastIdentifier() &&
2221 "Haven't past the location of the identifier yet?");
2222
2223 while (1) {
Chris Lattner04d66662007-10-09 17:33:22 +00002224 if (Tok.is(tok::l_paren)) {
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00002225 // The paren may be part of a C++ direct initializer, eg. "int x(1);".
2226 // In such a case, check if we actually have a function declarator; if it
2227 // is not, the declarator has been fully parsed.
Chris Lattner7399ee02008-10-20 02:05:46 +00002228 if (getLang().CPlusPlus && D.mayBeFollowedByCXXDirectInit()) {
2229 // When not in file scope, warn for ambiguous function declarators, just
2230 // in case the author intended it as a variable definition.
2231 bool warnIfAmbiguous = D.getContext() != Declarator::FileContext;
2232 if (!isCXXFunctionDeclarator(warnIfAmbiguous))
2233 break;
2234 }
Chris Lattneref4715c2008-04-06 05:45:57 +00002235 ParseFunctionDeclarator(ConsumeParen(), D);
Chris Lattner04d66662007-10-09 17:33:22 +00002236 } else if (Tok.is(tok::l_square)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00002237 ParseBracketDeclarator(D);
2238 } else {
2239 break;
2240 }
2241 }
2242}
2243
Chris Lattneref4715c2008-04-06 05:45:57 +00002244/// ParseParenDeclarator - We parsed the declarator D up to a paren. This is
2245/// only called before the identifier, so these are most likely just grouping
2246/// parens for precedence. If we find that these are actually function
2247/// parameter parens in an abstract-declarator, we call ParseFunctionDeclarator.
2248///
2249/// direct-declarator:
2250/// '(' declarator ')'
2251/// [GNU] '(' attributes declarator ')'
Chris Lattner7399ee02008-10-20 02:05:46 +00002252/// direct-declarator '(' parameter-type-list ')'
2253/// direct-declarator '(' identifier-list[opt] ')'
2254/// [GNU] direct-declarator '(' parameter-forward-declarations
2255/// parameter-type-list[opt] ')'
Chris Lattneref4715c2008-04-06 05:45:57 +00002256///
2257void Parser::ParseParenDeclarator(Declarator &D) {
2258 SourceLocation StartLoc = ConsumeParen();
2259 assert(!D.isPastIdentifier() && "Should be called before passing identifier");
2260
Chris Lattner7399ee02008-10-20 02:05:46 +00002261 // Eat any attributes before we look at whether this is a grouping or function
2262 // declarator paren. If this is a grouping paren, the attribute applies to
2263 // the type being built up, for example:
2264 // int (__attribute__(()) *x)(long y)
2265 // If this ends up not being a grouping paren, the attribute applies to the
2266 // first argument, for example:
2267 // int (__attribute__(()) int x)
2268 // In either case, we need to eat any attributes to be able to determine what
2269 // sort of paren this is.
2270 //
2271 AttributeList *AttrList = 0;
2272 bool RequiresArg = false;
2273 if (Tok.is(tok::kw___attribute)) {
2274 AttrList = ParseAttributes();
2275
2276 // We require that the argument list (if this is a non-grouping paren) be
2277 // present even if the attribute list was empty.
2278 RequiresArg = true;
2279 }
Steve Naroff239f0732008-12-25 14:16:32 +00002280 // Eat any Microsoft extensions.
Eli Friedman290eeb02009-06-08 23:27:34 +00002281 if (Tok.is(tok::kw___cdecl) || Tok.is(tok::kw___stdcall) ||
2282 Tok.is(tok::kw___fastcall) || Tok.is(tok::kw___w64) ||
2283 Tok.is(tok::kw___ptr64)) {
2284 AttrList = ParseMicrosoftTypeAttributes(AttrList);
2285 }
Chris Lattner7399ee02008-10-20 02:05:46 +00002286
Chris Lattneref4715c2008-04-06 05:45:57 +00002287 // If we haven't past the identifier yet (or where the identifier would be
2288 // stored, if this is an abstract declarator), then this is probably just
2289 // grouping parens. However, if this could be an abstract-declarator, then
2290 // this could also be the start of function arguments (consider 'void()').
2291 bool isGrouping;
2292
2293 if (!D.mayOmitIdentifier()) {
2294 // If this can't be an abstract-declarator, this *must* be a grouping
2295 // paren, because we haven't seen the identifier yet.
2296 isGrouping = true;
2297 } else if (Tok.is(tok::r_paren) || // 'int()' is a function.
Argyrios Kyrtzidise25d2702008-10-06 00:07:55 +00002298 (getLang().CPlusPlus && Tok.is(tok::ellipsis)) || // C++ int(...)
Chris Lattneref4715c2008-04-06 05:45:57 +00002299 isDeclarationSpecifier()) { // 'int(int)' is a function.
2300 // This handles C99 6.7.5.3p11: in "typedef int X; void foo(X)", X is
2301 // considered to be a type, not a K&R identifier-list.
2302 isGrouping = false;
2303 } else {
2304 // Otherwise, this is a grouping paren, e.g. 'int (*X)' or 'int(X)'.
2305 isGrouping = true;
2306 }
2307
2308 // If this is a grouping paren, handle:
2309 // direct-declarator: '(' declarator ')'
2310 // direct-declarator: '(' attributes declarator ')'
2311 if (isGrouping) {
Argyrios Kyrtzidis3f2a8a02008-10-07 10:21:57 +00002312 bool hadGroupingParens = D.hasGroupingParens();
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00002313 D.setGroupingParens(true);
Chris Lattner7399ee02008-10-20 02:05:46 +00002314 if (AttrList)
Sebastian Redlab197ba2009-02-09 18:23:29 +00002315 D.AddAttributes(AttrList, SourceLocation());
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00002316
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002317 ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
Chris Lattneref4715c2008-04-06 05:45:57 +00002318 // Match the ')'.
Sebastian Redlab197ba2009-02-09 18:23:29 +00002319 SourceLocation Loc = MatchRHSPunctuation(tok::r_paren, StartLoc);
Argyrios Kyrtzidis3f2a8a02008-10-07 10:21:57 +00002320
2321 D.setGroupingParens(hadGroupingParens);
Sebastian Redlab197ba2009-02-09 18:23:29 +00002322 D.SetRangeEnd(Loc);
Chris Lattneref4715c2008-04-06 05:45:57 +00002323 return;
2324 }
2325
2326 // Okay, if this wasn't a grouping paren, it must be the start of a function
2327 // argument list. Recognize that this declarator will never have an
Chris Lattner7399ee02008-10-20 02:05:46 +00002328 // identifier (and remember where it would have been), then call into
2329 // ParseFunctionDeclarator to handle of argument list.
Chris Lattneref4715c2008-04-06 05:45:57 +00002330 D.SetIdentifier(0, Tok.getLocation());
2331
Chris Lattner7399ee02008-10-20 02:05:46 +00002332 ParseFunctionDeclarator(StartLoc, D, AttrList, RequiresArg);
Chris Lattneref4715c2008-04-06 05:45:57 +00002333}
2334
2335/// ParseFunctionDeclarator - We are after the identifier and have parsed the
2336/// declarator D up to a paren, which indicates that we are parsing function
2337/// arguments.
Reid Spencer5f016e22007-07-11 17:01:13 +00002338///
Chris Lattner7399ee02008-10-20 02:05:46 +00002339/// If AttrList is non-null, then the caller parsed those arguments immediately
2340/// after the open paren - they should be considered to be the first argument of
2341/// a parameter. If RequiresArg is true, then the first argument of the
2342/// function is required to be present and required to not be an identifier
2343/// list.
2344///
Reid Spencer5f016e22007-07-11 17:01:13 +00002345/// This method also handles this portion of the grammar:
2346/// parameter-type-list: [C99 6.7.5]
2347/// parameter-list
2348/// parameter-list ',' '...'
2349///
2350/// parameter-list: [C99 6.7.5]
2351/// parameter-declaration
2352/// parameter-list ',' parameter-declaration
2353///
2354/// parameter-declaration: [C99 6.7.5]
2355/// declaration-specifiers declarator
Chris Lattner04421082008-04-08 04:40:51 +00002356/// [C++] declaration-specifiers declarator '=' assignment-expression
Reid Spencer5f016e22007-07-11 17:01:13 +00002357/// [GNU] declaration-specifiers declarator attributes
Sebastian Redl50de12f2009-03-24 22:27:57 +00002358/// declaration-specifiers abstract-declarator[opt]
2359/// [C++] declaration-specifiers abstract-declarator[opt]
Chris Lattner8123a952008-04-10 02:22:51 +00002360/// '=' assignment-expression
Reid Spencer5f016e22007-07-11 17:01:13 +00002361/// [GNU] declaration-specifiers abstract-declarator[opt] attributes
2362///
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +00002363/// For C++, after the parameter-list, it also parses "cv-qualifier-seq[opt]"
Sebastian Redl50de12f2009-03-24 22:27:57 +00002364/// and "exception-specification[opt]".
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +00002365///
Chris Lattner7399ee02008-10-20 02:05:46 +00002366void Parser::ParseFunctionDeclarator(SourceLocation LParenLoc, Declarator &D,
2367 AttributeList *AttrList,
2368 bool RequiresArg) {
Chris Lattneref4715c2008-04-06 05:45:57 +00002369 // lparen is already consumed!
2370 assert(D.isPastIdentifier() && "Should not call before identifier!");
Reid Spencer5f016e22007-07-11 17:01:13 +00002371
Chris Lattner7399ee02008-10-20 02:05:46 +00002372 // This parameter list may be empty.
Chris Lattner04d66662007-10-09 17:33:22 +00002373 if (Tok.is(tok::r_paren)) {
Chris Lattner7399ee02008-10-20 02:05:46 +00002374 if (RequiresArg) {
Chris Lattner1ab3b962008-11-18 07:48:38 +00002375 Diag(Tok, diag::err_argument_required_after_attribute);
Chris Lattner7399ee02008-10-20 02:05:46 +00002376 delete AttrList;
2377 }
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +00002378
Sebastian Redlab197ba2009-02-09 18:23:29 +00002379 SourceLocation Loc = ConsumeParen(); // Eat the closing ')'.
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +00002380
2381 // cv-qualifier-seq[opt].
2382 DeclSpec DS;
Sebastian Redl7dc81342009-04-29 17:30:04 +00002383 bool hasExceptionSpec = false;
Sebastian Redl3cc97262009-05-31 11:47:27 +00002384 SourceLocation ThrowLoc;
Sebastian Redl7dc81342009-04-29 17:30:04 +00002385 bool hasAnyExceptionSpec = false;
Sebastian Redlef65f062009-05-29 18:02:33 +00002386 llvm::SmallVector<TypeTy*, 2> Exceptions;
2387 llvm::SmallVector<SourceRange, 2> ExceptionRanges;
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +00002388 if (getLang().CPlusPlus) {
Chris Lattner5a69d1c2008-12-18 07:02:59 +00002389 ParseTypeQualifierListOpt(DS, false /*no attributes*/);
Sebastian Redlab197ba2009-02-09 18:23:29 +00002390 if (!DS.getSourceRange().getEnd().isInvalid())
2391 Loc = DS.getSourceRange().getEnd();
Douglas Gregor0fe7bea2008-11-25 03:22:00 +00002392
2393 // Parse exception-specification[opt].
Sebastian Redl7dc81342009-04-29 17:30:04 +00002394 if (Tok.is(tok::kw_throw)) {
2395 hasExceptionSpec = true;
Sebastian Redl3cc97262009-05-31 11:47:27 +00002396 ThrowLoc = Tok.getLocation();
Sebastian Redlef65f062009-05-29 18:02:33 +00002397 ParseExceptionSpecification(Loc, Exceptions, ExceptionRanges,
2398 hasAnyExceptionSpec);
2399 assert(Exceptions.size() == ExceptionRanges.size() &&
2400 "Produced different number of exception types and ranges.");
Sebastian Redl7dc81342009-04-29 17:30:04 +00002401 }
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +00002402 }
2403
Chris Lattnerf97409f2008-04-06 06:57:35 +00002404 // Remember that we parsed a function type, and remember the attributes.
Reid Spencer5f016e22007-07-11 17:01:13 +00002405 // int() -> no prototype, no '...'.
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +00002406 D.AddTypeInfo(DeclaratorChunk::getFunction(/*prototype*/getLang().CPlusPlus,
Chris Lattnerf97409f2008-04-06 06:57:35 +00002407 /*variadic*/ false,
Douglas Gregor965acbb2009-02-18 07:07:28 +00002408 SourceLocation(),
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +00002409 /*arglist*/ 0, 0,
2410 DS.getTypeQualifiers(),
Sebastian Redl3cc97262009-05-31 11:47:27 +00002411 hasExceptionSpec, ThrowLoc,
Sebastian Redl7dc81342009-04-29 17:30:04 +00002412 hasAnyExceptionSpec,
Sebastian Redlef65f062009-05-29 18:02:33 +00002413 Exceptions.data(),
2414 ExceptionRanges.data(),
Sebastian Redl7dc81342009-04-29 17:30:04 +00002415 Exceptions.size(),
Sebastian Redlab197ba2009-02-09 18:23:29 +00002416 LParenLoc, D),
2417 Loc);
Chris Lattnerf97409f2008-04-06 06:57:35 +00002418 return;
Sebastian Redlef65f062009-05-29 18:02:33 +00002419 }
2420
Chris Lattner7399ee02008-10-20 02:05:46 +00002421 // Alternatively, this parameter list may be an identifier list form for a
2422 // K&R-style function: void foo(a,b,c)
Steve Naroff2d081c42009-01-28 19:16:40 +00002423 if (!getLang().CPlusPlus && Tok.is(tok::identifier)) {
Steve Narofff64ef622009-01-30 14:23:32 +00002424 if (!TryAnnotateTypeOrScopeToken()) {
Chris Lattner7399ee02008-10-20 02:05:46 +00002425 // K&R identifier lists can't have typedefs as identifiers, per
2426 // C99 6.7.5.3p11.
Steve Naroff2d081c42009-01-28 19:16:40 +00002427 if (RequiresArg) {
2428 Diag(Tok, diag::err_argument_required_after_attribute);
2429 delete AttrList;
2430 }
Steve Naroff2d081c42009-01-28 19:16:40 +00002431 // Identifier list. Note that '(' identifier-list ')' is only allowed for
2432 // normal declarators, not for abstract-declarators.
2433 return ParseFunctionDeclaratorIdentifierList(LParenLoc, D);
Chris Lattner7399ee02008-10-20 02:05:46 +00002434 }
Chris Lattnerf97409f2008-04-06 06:57:35 +00002435 }
2436
2437 // Finally, a normal, non-empty parameter type list.
2438
2439 // Build up an array of information about the parsed arguments.
2440 llvm::SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
Chris Lattner04421082008-04-08 04:40:51 +00002441
2442 // Enter function-declaration scope, limiting any declarators to the
2443 // function prototype scope, including parameter declarators.
Chris Lattnerae50fa02009-03-05 00:00:31 +00002444 ParseScope PrototypeScope(this,
2445 Scope::FunctionPrototypeScope|Scope::DeclScope);
Chris Lattnerf97409f2008-04-06 06:57:35 +00002446
2447 bool IsVariadic = false;
Douglas Gregor965acbb2009-02-18 07:07:28 +00002448 SourceLocation EllipsisLoc;
Chris Lattnerf97409f2008-04-06 06:57:35 +00002449 while (1) {
2450 if (Tok.is(tok::ellipsis)) {
2451 IsVariadic = true;
Douglas Gregor965acbb2009-02-18 07:07:28 +00002452 EllipsisLoc = ConsumeToken(); // Consume the ellipsis.
Chris Lattnerf97409f2008-04-06 06:57:35 +00002453 break;
Reid Spencer5f016e22007-07-11 17:01:13 +00002454 }
2455
Chris Lattnerf97409f2008-04-06 06:57:35 +00002456 SourceLocation DSStart = Tok.getLocation();
Reid Spencer5f016e22007-07-11 17:01:13 +00002457
Chris Lattnerf97409f2008-04-06 06:57:35 +00002458 // Parse the declaration-specifiers.
2459 DeclSpec DS;
Chris Lattner7399ee02008-10-20 02:05:46 +00002460
2461 // If the caller parsed attributes for the first argument, add them now.
2462 if (AttrList) {
2463 DS.AddAttributes(AttrList);
2464 AttrList = 0; // Only apply the attributes to the first parameter.
2465 }
Chris Lattnere64c5492009-02-27 18:38:20 +00002466 ParseDeclarationSpecifiers(DS);
2467
Chris Lattnerf97409f2008-04-06 06:57:35 +00002468 // Parse the declarator. This is "PrototypeContext", because we must
2469 // accept either 'declarator' or 'abstract-declarator' here.
2470 Declarator ParmDecl(DS, Declarator::PrototypeContext);
2471 ParseDeclarator(ParmDecl);
2472
2473 // Parse GNU attributes, if present.
Sebastian Redlab197ba2009-02-09 18:23:29 +00002474 if (Tok.is(tok::kw___attribute)) {
2475 SourceLocation Loc;
2476 AttributeList *AttrList = ParseAttributes(&Loc);
2477 ParmDecl.AddAttributes(AttrList, Loc);
2478 }
Chris Lattnerf97409f2008-04-06 06:57:35 +00002479
Chris Lattnerf97409f2008-04-06 06:57:35 +00002480 // Remember this parsed parameter in ParamInfo.
2481 IdentifierInfo *ParmII = ParmDecl.getIdentifier();
2482
Douglas Gregor72b505b2008-12-16 21:30:33 +00002483 // DefArgToks is used when the parsing of default arguments needs
2484 // to be delayed.
2485 CachedTokens *DefArgToks = 0;
2486
Chris Lattnerf97409f2008-04-06 06:57:35 +00002487 // If no parameter was specified, verify that *something* was specified,
2488 // otherwise we have a missing type and identifier.
Chris Lattnere64c5492009-02-27 18:38:20 +00002489 if (DS.isEmpty() && ParmDecl.getIdentifier() == 0 &&
2490 ParmDecl.getNumTypeObjects() == 0) {
Chris Lattnerf97409f2008-04-06 06:57:35 +00002491 // Completely missing, emit error.
2492 Diag(DSStart, diag::err_missing_param);
2493 } else {
2494 // Otherwise, we have something. Add it and let semantic analysis try
2495 // to grok it and add the result to the ParamInfo we are building.
2496
2497 // Inform the actions module about the parameter declarator, so it gets
2498 // added to the current scope.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002499 DeclPtrTy Param = Actions.ActOnParamDeclarator(CurScope, ParmDecl);
Chris Lattner04421082008-04-08 04:40:51 +00002500
2501 // Parse the default argument, if any. We parse the default
2502 // arguments in all dialects; the semantic analysis in
2503 // ActOnParamDefaultArgument will reject the default argument in
2504 // C.
2505 if (Tok.is(tok::equal)) {
Douglas Gregor61366e92008-12-24 00:01:03 +00002506 SourceLocation EqualLoc = Tok.getLocation();
2507
Chris Lattner04421082008-04-08 04:40:51 +00002508 // Parse the default argument
Douglas Gregor72b505b2008-12-16 21:30:33 +00002509 if (D.getContext() == Declarator::MemberContext) {
2510 // If we're inside a class definition, cache the tokens
2511 // corresponding to the default argument. We'll actually parse
2512 // them when we see the end of the class definition.
2513 // FIXME: Templates will require something similar.
2514 // FIXME: Can we use a smart pointer for Toks?
2515 DefArgToks = new CachedTokens;
2516
2517 if (!ConsumeAndStoreUntil(tok::comma, tok::r_paren, *DefArgToks,
2518 tok::semi, false)) {
2519 delete DefArgToks;
2520 DefArgToks = 0;
Douglas Gregor61366e92008-12-24 00:01:03 +00002521 Actions.ActOnParamDefaultArgumentError(Param);
2522 } else
Anders Carlsson5e300d12009-06-12 16:51:40 +00002523 Actions.ActOnParamUnparsedDefaultArgument(Param, EqualLoc,
2524 (*DefArgToks)[1].getLocation());
Chris Lattner04421082008-04-08 04:40:51 +00002525 } else {
Douglas Gregor72b505b2008-12-16 21:30:33 +00002526 // Consume the '='.
Douglas Gregor61366e92008-12-24 00:01:03 +00002527 ConsumeToken();
Douglas Gregor72b505b2008-12-16 21:30:33 +00002528
2529 OwningExprResult DefArgResult(ParseAssignmentExpression());
2530 if (DefArgResult.isInvalid()) {
2531 Actions.ActOnParamDefaultArgumentError(Param);
2532 SkipUntil(tok::comma, tok::r_paren, true, true);
2533 } else {
2534 // Inform the actions module about the default argument
2535 Actions.ActOnParamDefaultArgument(Param, EqualLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +00002536 move(DefArgResult));
Douglas Gregor72b505b2008-12-16 21:30:33 +00002537 }
Chris Lattner04421082008-04-08 04:40:51 +00002538 }
2539 }
Chris Lattnerf97409f2008-04-06 06:57:35 +00002540
2541 ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
Douglas Gregor72b505b2008-12-16 21:30:33 +00002542 ParmDecl.getIdentifierLoc(), Param,
2543 DefArgToks));
Chris Lattnerf97409f2008-04-06 06:57:35 +00002544 }
2545
2546 // If the next token is a comma, consume it and keep reading arguments.
2547 if (Tok.isNot(tok::comma)) break;
2548
2549 // Consume the comma.
2550 ConsumeToken();
Reid Spencer5f016e22007-07-11 17:01:13 +00002551 }
2552
Chris Lattnerf97409f2008-04-06 06:57:35 +00002553 // Leave prototype scope.
Douglas Gregor8935b8b2008-12-10 06:34:36 +00002554 PrototypeScope.Exit();
Chris Lattnerf97409f2008-04-06 06:57:35 +00002555
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +00002556 // If we have the closing ')', eat it.
Sebastian Redlab197ba2009-02-09 18:23:29 +00002557 SourceLocation Loc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +00002558
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +00002559 DeclSpec DS;
Sebastian Redl7dc81342009-04-29 17:30:04 +00002560 bool hasExceptionSpec = false;
Sebastian Redl3cc97262009-05-31 11:47:27 +00002561 SourceLocation ThrowLoc;
Sebastian Redl7dc81342009-04-29 17:30:04 +00002562 bool hasAnyExceptionSpec = false;
Sebastian Redlef65f062009-05-29 18:02:33 +00002563 llvm::SmallVector<TypeTy*, 2> Exceptions;
2564 llvm::SmallVector<SourceRange, 2> ExceptionRanges;
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +00002565 if (getLang().CPlusPlus) {
Douglas Gregor0fe7bea2008-11-25 03:22:00 +00002566 // Parse cv-qualifier-seq[opt].
Chris Lattner5a69d1c2008-12-18 07:02:59 +00002567 ParseTypeQualifierListOpt(DS, false /*no attributes*/);
Sebastian Redlab197ba2009-02-09 18:23:29 +00002568 if (!DS.getSourceRange().getEnd().isInvalid())
2569 Loc = DS.getSourceRange().getEnd();
Douglas Gregor0fe7bea2008-11-25 03:22:00 +00002570
2571 // Parse exception-specification[opt].
Sebastian Redl7dc81342009-04-29 17:30:04 +00002572 if (Tok.is(tok::kw_throw)) {
2573 hasExceptionSpec = true;
Sebastian Redl3cc97262009-05-31 11:47:27 +00002574 ThrowLoc = Tok.getLocation();
Sebastian Redlef65f062009-05-29 18:02:33 +00002575 ParseExceptionSpecification(Loc, Exceptions, ExceptionRanges,
2576 hasAnyExceptionSpec);
2577 assert(Exceptions.size() == ExceptionRanges.size() &&
2578 "Produced different number of exception types and ranges.");
Sebastian Redl7dc81342009-04-29 17:30:04 +00002579 }
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +00002580 }
2581
Reid Spencer5f016e22007-07-11 17:01:13 +00002582 // Remember that we parsed a function type, and remember the attributes.
Chris Lattnerf97409f2008-04-06 06:57:35 +00002583 D.AddTypeInfo(DeclaratorChunk::getFunction(/*proto*/true, IsVariadic,
Douglas Gregor965acbb2009-02-18 07:07:28 +00002584 EllipsisLoc,
Jay Foadbeaaccd2009-05-21 09:52:38 +00002585 ParamInfo.data(), ParamInfo.size(),
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +00002586 DS.getTypeQualifiers(),
Sebastian Redl3cc97262009-05-31 11:47:27 +00002587 hasExceptionSpec, ThrowLoc,
Sebastian Redl7dc81342009-04-29 17:30:04 +00002588 hasAnyExceptionSpec,
Sebastian Redlef65f062009-05-29 18:02:33 +00002589 Exceptions.data(),
2590 ExceptionRanges.data(),
Sebastian Redl7dc81342009-04-29 17:30:04 +00002591 Exceptions.size(), LParenLoc, D),
Sebastian Redlab197ba2009-02-09 18:23:29 +00002592 Loc);
Reid Spencer5f016e22007-07-11 17:01:13 +00002593}
2594
Chris Lattner66d28652008-04-06 06:34:08 +00002595/// ParseFunctionDeclaratorIdentifierList - While parsing a function declarator
2596/// we found a K&R-style identifier list instead of a type argument list. The
2597/// current token is known to be the first identifier in the list.
2598///
2599/// identifier-list: [C99 6.7.5]
2600/// identifier
2601/// identifier-list ',' identifier
2602///
2603void Parser::ParseFunctionDeclaratorIdentifierList(SourceLocation LParenLoc,
2604 Declarator &D) {
2605 // Build up an array of information about the parsed arguments.
2606 llvm::SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
2607 llvm::SmallSet<const IdentifierInfo*, 16> ParamsSoFar;
2608
2609 // If there was no identifier specified for the declarator, either we are in
2610 // an abstract-declarator, or we are in a parameter declarator which was found
2611 // to be abstract. In abstract-declarators, identifier lists are not valid:
2612 // diagnose this.
2613 if (!D.getIdentifier())
2614 Diag(Tok, diag::ext_ident_list_in_param);
2615
2616 // Tok is known to be the first identifier in the list. Remember this
2617 // identifier in ParamInfo.
Chris Lattner3825c2e2008-04-06 06:50:56 +00002618 ParamsSoFar.insert(Tok.getIdentifierInfo());
Chris Lattner66d28652008-04-06 06:34:08 +00002619 ParamInfo.push_back(DeclaratorChunk::ParamInfo(Tok.getIdentifierInfo(),
Chris Lattnerb28317a2009-03-28 19:18:32 +00002620 Tok.getLocation(),
2621 DeclPtrTy()));
Chris Lattner66d28652008-04-06 06:34:08 +00002622
Chris Lattner50c64772008-04-06 06:39:19 +00002623 ConsumeToken(); // eat the first identifier.
Chris Lattner66d28652008-04-06 06:34:08 +00002624
2625 while (Tok.is(tok::comma)) {
2626 // Eat the comma.
2627 ConsumeToken();
2628
Chris Lattner50c64772008-04-06 06:39:19 +00002629 // If this isn't an identifier, report the error and skip until ')'.
Chris Lattner66d28652008-04-06 06:34:08 +00002630 if (Tok.isNot(tok::identifier)) {
2631 Diag(Tok, diag::err_expected_ident);
Chris Lattner50c64772008-04-06 06:39:19 +00002632 SkipUntil(tok::r_paren);
2633 return;
Chris Lattner66d28652008-04-06 06:34:08 +00002634 }
Chris Lattneraaf9ddb2008-04-06 06:47:48 +00002635
Chris Lattner66d28652008-04-06 06:34:08 +00002636 IdentifierInfo *ParmII = Tok.getIdentifierInfo();
Chris Lattneraaf9ddb2008-04-06 06:47:48 +00002637
2638 // Reject 'typedef int y; int test(x, y)', but continue parsing.
Douglas Gregorb696ea32009-02-04 17:00:24 +00002639 if (Actions.getTypeName(*ParmII, Tok.getLocation(), CurScope))
Chris Lattnerda83bac2008-11-19 07:37:42 +00002640 Diag(Tok, diag::err_unexpected_typedef_ident) << ParmII;
Chris Lattner66d28652008-04-06 06:34:08 +00002641
2642 // Verify that the argument identifier has not already been mentioned.
2643 if (!ParamsSoFar.insert(ParmII)) {
Chris Lattnerda83bac2008-11-19 07:37:42 +00002644 Diag(Tok, diag::err_param_redefinition) << ParmII;
Chris Lattner50c64772008-04-06 06:39:19 +00002645 } else {
2646 // Remember this identifier in ParamInfo.
Chris Lattner66d28652008-04-06 06:34:08 +00002647 ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002648 Tok.getLocation(),
2649 DeclPtrTy()));
Chris Lattner50c64772008-04-06 06:39:19 +00002650 }
Chris Lattner66d28652008-04-06 06:34:08 +00002651
2652 // Eat the identifier.
2653 ConsumeToken();
2654 }
Sebastian Redlab197ba2009-02-09 18:23:29 +00002655
2656 // If we have the closing ')', eat it and we're done.
2657 SourceLocation RLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
2658
Chris Lattner50c64772008-04-06 06:39:19 +00002659 // Remember that we parsed a function type, and remember the attributes. This
2660 // function type is always a K&R style function type, which is not varargs and
2661 // has no prototype.
2662 D.AddTypeInfo(DeclaratorChunk::getFunction(/*proto*/false, /*varargs*/false,
Douglas Gregor965acbb2009-02-18 07:07:28 +00002663 SourceLocation(),
Chris Lattner50c64772008-04-06 06:39:19 +00002664 &ParamInfo[0], ParamInfo.size(),
Sebastian Redl7dc81342009-04-29 17:30:04 +00002665 /*TypeQuals*/0,
Sebastian Redl3cc97262009-05-31 11:47:27 +00002666 /*exception*/false,
2667 SourceLocation(), false, 0, 0, 0,
Sebastian Redl7dc81342009-04-29 17:30:04 +00002668 LParenLoc, D),
Sebastian Redlab197ba2009-02-09 18:23:29 +00002669 RLoc);
Chris Lattner66d28652008-04-06 06:34:08 +00002670}
Chris Lattneref4715c2008-04-06 05:45:57 +00002671
Reid Spencer5f016e22007-07-11 17:01:13 +00002672/// [C90] direct-declarator '[' constant-expression[opt] ']'
2673/// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
2674/// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
2675/// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']'
2676/// [C99] direct-declarator '[' type-qual-list[opt] '*' ']'
2677void Parser::ParseBracketDeclarator(Declarator &D) {
2678 SourceLocation StartLoc = ConsumeBracket();
2679
Chris Lattner378c7e42008-12-18 07:27:21 +00002680 // C array syntax has many features, but by-far the most common is [] and [4].
2681 // This code does a fast path to handle some of the most obvious cases.
2682 if (Tok.getKind() == tok::r_square) {
Sebastian Redlab197ba2009-02-09 18:23:29 +00002683 SourceLocation EndLoc = MatchRHSPunctuation(tok::r_square, StartLoc);
Chris Lattner378c7e42008-12-18 07:27:21 +00002684 // Remember that we parsed the empty array type.
2685 OwningExprResult NumElements(Actions);
Sebastian Redlab197ba2009-02-09 18:23:29 +00002686 D.AddTypeInfo(DeclaratorChunk::getArray(0, false, false, 0, StartLoc),
2687 EndLoc);
Chris Lattner378c7e42008-12-18 07:27:21 +00002688 return;
2689 } else if (Tok.getKind() == tok::numeric_constant &&
2690 GetLookAheadToken(1).is(tok::r_square)) {
2691 // [4] is very common. Parse the numeric constant expression.
Sebastian Redlcd965b92009-01-18 18:53:16 +00002692 OwningExprResult ExprRes(Actions.ActOnNumericConstant(Tok));
Chris Lattner378c7e42008-12-18 07:27:21 +00002693 ConsumeToken();
2694
Sebastian Redlab197ba2009-02-09 18:23:29 +00002695 SourceLocation EndLoc = MatchRHSPunctuation(tok::r_square, StartLoc);
Chris Lattner378c7e42008-12-18 07:27:21 +00002696
2697 // If there was an error parsing the assignment-expression, recover.
2698 if (ExprRes.isInvalid())
2699 ExprRes.release(); // Deallocate expr, just use [].
2700
2701 // Remember that we parsed a array type, and remember its features.
2702 D.AddTypeInfo(DeclaratorChunk::getArray(0, false, 0,
Sebastian Redlab197ba2009-02-09 18:23:29 +00002703 ExprRes.release(), StartLoc),
2704 EndLoc);
Chris Lattner378c7e42008-12-18 07:27:21 +00002705 return;
2706 }
2707
Reid Spencer5f016e22007-07-11 17:01:13 +00002708 // If valid, this location is the position where we read the 'static' keyword.
2709 SourceLocation StaticLoc;
Chris Lattner04d66662007-10-09 17:33:22 +00002710 if (Tok.is(tok::kw_static))
Reid Spencer5f016e22007-07-11 17:01:13 +00002711 StaticLoc = ConsumeToken();
2712
2713 // If there is a type-qualifier-list, read it now.
Chris Lattnera1fcbad2008-12-18 06:50:14 +00002714 // Type qualifiers in an array subscript are a C99 feature.
Reid Spencer5f016e22007-07-11 17:01:13 +00002715 DeclSpec DS;
Chris Lattner5a69d1c2008-12-18 07:02:59 +00002716 ParseTypeQualifierListOpt(DS, false /*no attributes*/);
Reid Spencer5f016e22007-07-11 17:01:13 +00002717
2718 // If we haven't already read 'static', check to see if there is one after the
2719 // type-qualifier-list.
Chris Lattner04d66662007-10-09 17:33:22 +00002720 if (!StaticLoc.isValid() && Tok.is(tok::kw_static))
Reid Spencer5f016e22007-07-11 17:01:13 +00002721 StaticLoc = ConsumeToken();
2722
2723 // Handle "direct-declarator [ type-qual-list[opt] * ]".
2724 bool isStar = false;
Sebastian Redl15faa7f2008-12-09 20:22:58 +00002725 OwningExprResult NumElements(Actions);
Chris Lattner5dcc6ce2008-04-06 05:26:30 +00002726
2727 // Handle the case where we have '[*]' as the array size. However, a leading
2728 // star could be the start of an expression, for example 'X[*p + 4]'. Verify
2729 // the the token after the star is a ']'. Since stars in arrays are
2730 // infrequent, use of lookahead is not costly here.
2731 if (Tok.is(tok::star) && GetLookAheadToken(1).is(tok::r_square)) {
Chris Lattnera711dd02008-04-06 05:27:21 +00002732 ConsumeToken(); // Eat the '*'.
Reid Spencer5f016e22007-07-11 17:01:13 +00002733
Chris Lattnera1fcbad2008-12-18 06:50:14 +00002734 if (StaticLoc.isValid()) {
Chris Lattner5dcc6ce2008-04-06 05:26:30 +00002735 Diag(StaticLoc, diag::err_unspecified_vla_size_with_static);
Chris Lattnera1fcbad2008-12-18 06:50:14 +00002736 StaticLoc = SourceLocation(); // Drop the static.
2737 }
Chris Lattner5dcc6ce2008-04-06 05:26:30 +00002738 isStar = true;
Chris Lattner04d66662007-10-09 17:33:22 +00002739 } else if (Tok.isNot(tok::r_square)) {
Chris Lattner378c7e42008-12-18 07:27:21 +00002740 // Note, in C89, this production uses the constant-expr production instead
2741 // of assignment-expr. The only difference is that assignment-expr allows
2742 // things like '=' and '*='. Sema rejects these in C89 mode because they
2743 // are not i-c-e's, so we don't need to distinguish between the two here.
2744
Douglas Gregore0762c92009-06-19 23:52:42 +00002745 // Parse the constant-expression or assignment-expression now (depending
2746 // on dialect).
2747 if (getLang().CPlusPlus)
2748 NumElements = ParseConstantExpression();
2749 else
2750 NumElements = ParseAssignmentExpression();
Reid Spencer5f016e22007-07-11 17:01:13 +00002751 }
2752
2753 // If there was an error parsing the assignment-expression, recover.
Sebastian Redl0e9eabc2008-12-09 13:15:23 +00002754 if (NumElements.isInvalid()) {
Chris Lattner5cb10d32009-04-24 22:30:50 +00002755 D.setInvalidType(true);
Reid Spencer5f016e22007-07-11 17:01:13 +00002756 // If the expression was invalid, skip it.
2757 SkipUntil(tok::r_square);
2758 return;
2759 }
Sebastian Redlab197ba2009-02-09 18:23:29 +00002760
2761 SourceLocation EndLoc = MatchRHSPunctuation(tok::r_square, StartLoc);
2762
Chris Lattner378c7e42008-12-18 07:27:21 +00002763 // Remember that we parsed a array type, and remember its features.
Reid Spencer5f016e22007-07-11 17:01:13 +00002764 D.AddTypeInfo(DeclaratorChunk::getArray(DS.getTypeQualifiers(),
2765 StaticLoc.isValid(), isStar,
Sebastian Redlab197ba2009-02-09 18:23:29 +00002766 NumElements.release(), StartLoc),
2767 EndLoc);
Reid Spencer5f016e22007-07-11 17:01:13 +00002768}
2769
Argyrios Kyrtzidis0f072032008-09-05 11:26:19 +00002770/// [GNU] typeof-specifier:
2771/// typeof ( expressions )
2772/// typeof ( type-name )
2773/// [GNU/C++] typeof unary-expression
Steve Naroffd1861fd2007-07-31 12:34:36 +00002774///
2775void Parser::ParseTypeofSpecifier(DeclSpec &DS) {
Chris Lattner04d66662007-10-09 17:33:22 +00002776 assert(Tok.is(tok::kw_typeof) && "Not a typeof specifier");
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00002777 Token OpTok = Tok;
Steve Naroffd1861fd2007-07-31 12:34:36 +00002778 SourceLocation StartLoc = ConsumeToken();
2779
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00002780 bool isCastExpr;
2781 TypeTy *CastTy;
2782 SourceRange CastRange;
2783 OwningExprResult Operand = ParseExprAfterTypeofSizeofAlignof(OpTok,
2784 isCastExpr,
2785 CastTy,
2786 CastRange);
2787
2788 if (CastRange.getEnd().isInvalid())
Argyrios Kyrtzidis64096252009-05-22 10:22:18 +00002789 // FIXME: Not accurate, the range gets one token more than it should.
2790 DS.SetRangeEnd(Tok.getLocation());
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00002791 else
2792 DS.SetRangeEnd(CastRange.getEnd());
2793
2794 if (isCastExpr) {
2795 if (!CastTy) {
2796 DS.SetTypeSpecError();
Argyrios Kyrtzidis0f072032008-09-05 11:26:19 +00002797 return;
Douglas Gregor809070a2009-02-18 17:45:20 +00002798 }
Argyrios Kyrtzidis0f072032008-09-05 11:26:19 +00002799
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00002800 const char *PrevSpec = 0;
2801 // Check for duplicate type specifiers (e.g. "int typeof(int)").
2802 if (DS.SetTypeSpecType(DeclSpec::TST_typeofType, StartLoc, PrevSpec,
2803 CastTy))
2804 Diag(StartLoc, diag::err_invalid_decl_spec_combination) << PrevSpec;
2805 return;
Argyrios Kyrtzidis64096252009-05-22 10:22:18 +00002806 }
Argyrios Kyrtzidis0f072032008-09-05 11:26:19 +00002807
Argyrios Kyrtzidis64096252009-05-22 10:22:18 +00002808 // If we get here, the operand to the typeof was an expresion.
2809 if (Operand.isInvalid()) {
2810 DS.SetTypeSpecError();
Steve Naroff9dfa7b42007-08-02 02:53:48 +00002811 return;
Steve Naroffd1861fd2007-07-31 12:34:36 +00002812 }
Argyrios Kyrtzidis0f072032008-09-05 11:26:19 +00002813
Argyrios Kyrtzidis64096252009-05-22 10:22:18 +00002814 const char *PrevSpec = 0;
2815 // Check for duplicate type specifiers (e.g. "int typeof(int)").
2816 if (DS.SetTypeSpecType(DeclSpec::TST_typeofExpr, StartLoc, PrevSpec,
2817 Operand.release()))
2818 Diag(StartLoc, diag::err_invalid_decl_spec_combination) << PrevSpec;
Steve Naroffd1861fd2007-07-31 12:34:36 +00002819}