blob: ea468b04586894b8fc02f697e39b7a82b97f5e32 [file] [log] [blame]
Chris Lattner7ad0fbe2006-11-05 07:46:30 +00001//===--- ParseDecl.cpp - Declaration Parsing ------------------------------===//
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00002//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the Declaration portions of the Parser interfaces.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Parse/Parser.h"
Chris Lattner60f36222009-01-29 05:15:15 +000015#include "clang/Parse/ParseDiagnostic.h"
John McCall8b0666c2010-08-20 18:27:03 +000016#include "clang/Sema/Scope.h"
17#include "clang/Sema/ParsedTemplate.h"
Chris Lattner8a9a97a2009-12-10 00:21:05 +000018#include "RAIIObjectsForParser.h"
Chris Lattnerad9ac942007-01-23 01:14:52 +000019#include "llvm/ADT/SmallSet.h"
Chris Lattnerc0acd3d2006-07-31 05:13:43 +000020using namespace clang;
21
22//===----------------------------------------------------------------------===//
23// C99 6.7: Declarations.
24//===----------------------------------------------------------------------===//
25
Chris Lattnerf5fbd792006-08-10 23:56:11 +000026/// ParseTypeName
27/// type-name: [C99 6.7.6]
28/// specifier-qualifier-list abstract-declarator[opt]
Sebastian Redlbd150f42008-11-21 19:14:01 +000029///
30/// Called type-id in C++.
Sebastian Redld6434562009-05-29 18:02:33 +000031Action::TypeResult Parser::ParseTypeName(SourceRange *Range) {
Chris Lattnerf5fbd792006-08-10 23:56:11 +000032 // Parse the common declaration-specifiers piece.
33 DeclSpec DS;
Chris Lattner1890ac82006-08-13 01:16:23 +000034 ParseSpecifierQualifierList(DS);
Sebastian Redld6434562009-05-29 18:02:33 +000035
Chris Lattnerf5fbd792006-08-10 23:56:11 +000036 // Parse the abstract-declarator, if present.
37 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
38 ParseDeclarator(DeclaratorInfo);
Sebastian Redld6434562009-05-29 18:02:33 +000039 if (Range)
40 *Range = DeclaratorInfo.getSourceRange();
41
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +000042 if (DeclaratorInfo.isInvalidType())
Douglas Gregor220cac52009-02-18 17:45:20 +000043 return true;
44
Douglas Gregor0be31a22010-07-02 17:43:08 +000045 return Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
Chris Lattnerf5fbd792006-08-10 23:56:11 +000046}
47
Alexis Hunt96d5c762009-11-21 08:43:09 +000048/// ParseGNUAttributes - Parse a non-empty attributes list.
Chris Lattnerb8cd5c22006-08-15 04:10:46 +000049///
50/// [GNU] attributes:
51/// attribute
52/// attributes attribute
53///
54/// [GNU] attribute:
55/// '__attribute__' '(' '(' attribute-list ')' ')'
56///
57/// [GNU] attribute-list:
58/// attrib
59/// attribute_list ',' attrib
60///
61/// [GNU] attrib:
62/// empty
Steve Naroff0f2fe172007-06-01 17:11:19 +000063/// attrib-name
64/// attrib-name '(' identifier ')'
65/// attrib-name '(' identifier ',' nonempty-expr-list ')'
66/// attrib-name '(' argument-expression-list [C99 6.5.2] ')'
Chris Lattnerb8cd5c22006-08-15 04:10:46 +000067///
Steve Naroff0f2fe172007-06-01 17:11:19 +000068/// [GNU] attrib-name:
69/// identifier
70/// typespec
71/// typequal
72/// storageclass
Mike Stump11289f42009-09-09 15:08:12 +000073///
Steve Naroff0f2fe172007-06-01 17:11:19 +000074/// FIXME: The GCC grammar/code for this construct implies we need two
Mike Stump11289f42009-09-09 15:08:12 +000075/// token lookahead. Comment from gcc: "If they start with an identifier
76/// which is followed by a comma or close parenthesis, then the arguments
Steve Naroff0f2fe172007-06-01 17:11:19 +000077/// start with that identifier; otherwise they are an expression list."
78///
79/// At the moment, I am not doing 2 token lookahead. I am also unaware of
80/// any attributes that don't work (based on my limited testing). Most
81/// attributes are very simple in practice. Until we find a bug, I don't see
82/// a pressing need to implement the 2 token lookahead.
Chris Lattnerb8cd5c22006-08-15 04:10:46 +000083
Alexis Hunt96d5c762009-11-21 08:43:09 +000084AttributeList *Parser::ParseGNUAttributes(SourceLocation *EndLoc) {
85 assert(Tok.is(tok::kw___attribute) && "Not a GNU attribute list!");
Mike Stump11289f42009-09-09 15:08:12 +000086
Steve Naroffb8371e12007-06-09 03:39:29 +000087 AttributeList *CurrAttr = 0;
Mike Stump11289f42009-09-09 15:08:12 +000088
Chris Lattner76c72282007-10-09 17:33:22 +000089 while (Tok.is(tok::kw___attribute)) {
Steve Naroff0f2fe172007-06-01 17:11:19 +000090 ConsumeToken();
91 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
92 "attribute")) {
93 SkipUntil(tok::r_paren, true); // skip until ) or ;
94 return CurrAttr;
95 }
96 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "(")) {
97 SkipUntil(tok::r_paren, true); // skip until ) or ;
98 return CurrAttr;
99 }
100 // Parse the attribute-list. e.g. __attribute__(( weak, alias("__f") ))
Chris Lattner76c72282007-10-09 17:33:22 +0000101 while (Tok.is(tok::identifier) || isDeclarationSpecifier() ||
102 Tok.is(tok::comma)) {
Mike Stump11289f42009-09-09 15:08:12 +0000103
104 if (Tok.is(tok::comma)) {
Steve Naroff0f2fe172007-06-01 17:11:19 +0000105 // allows for empty/non-empty attributes. ((__vector_size__(16),,,,))
106 ConsumeToken();
107 continue;
108 }
109 // we have an identifier or declaration specifier (const, int, etc.)
110 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
111 SourceLocation AttrNameLoc = ConsumeToken();
Mike Stump11289f42009-09-09 15:08:12 +0000112
Douglas Gregora2f49452010-03-16 19:09:18 +0000113 // check if we have a "parameterized" attribute
Chris Lattner76c72282007-10-09 17:33:22 +0000114 if (Tok.is(tok::l_paren)) {
Steve Naroffb8371e12007-06-09 03:39:29 +0000115 ConsumeParen(); // ignore the left paren loc for now
Mike Stump11289f42009-09-09 15:08:12 +0000116
Chris Lattner76c72282007-10-09 17:33:22 +0000117 if (Tok.is(tok::identifier)) {
Steve Naroff0f2fe172007-06-01 17:11:19 +0000118 IdentifierInfo *ParmName = Tok.getIdentifierInfo();
119 SourceLocation ParmLoc = ConsumeToken();
Mike Stump11289f42009-09-09 15:08:12 +0000120
121 if (Tok.is(tok::r_paren)) {
Steve Naroff0f2fe172007-06-01 17:11:19 +0000122 // __attribute__(( mode(byte) ))
Steve Naroffb8371e12007-06-09 03:39:29 +0000123 ConsumeParen(); // ignore the right paren loc for now
Alexis Hunt96d5c762009-11-21 08:43:09 +0000124 CurrAttr = new AttributeList(AttrName, AttrNameLoc, 0, AttrNameLoc,
Steve Naroffb8371e12007-06-09 03:39:29 +0000125 ParmName, ParmLoc, 0, 0, CurrAttr);
Chris Lattner76c72282007-10-09 17:33:22 +0000126 } else if (Tok.is(tok::comma)) {
Steve Naroff0f2fe172007-06-01 17:11:19 +0000127 ConsumeToken();
128 // __attribute__(( format(printf, 1, 2) ))
Sebastian Redl511ed552008-11-25 22:21:31 +0000129 ExprVector ArgExprs(Actions);
Steve Naroff0f2fe172007-06-01 17:11:19 +0000130 bool ArgExprsOk = true;
Mike Stump11289f42009-09-09 15:08:12 +0000131
Steve Naroff0f2fe172007-06-01 17:11:19 +0000132 // now parse the non-empty comma separated list of expressions
133 while (1) {
Sebastian Redl59b5e512008-12-11 21:36:32 +0000134 OwningExprResult ArgExpr(ParseAssignmentExpression());
Sebastian Redl17f2c7d2008-12-09 13:15:23 +0000135 if (ArgExpr.isInvalid()) {
Steve Naroff0f2fe172007-06-01 17:11:19 +0000136 ArgExprsOk = false;
137 SkipUntil(tok::r_paren);
138 break;
139 } else {
Sebastian Redld9f7b1c2008-12-10 00:02:53 +0000140 ArgExprs.push_back(ArgExpr.release());
Steve Naroff0f2fe172007-06-01 17:11:19 +0000141 }
Chris Lattner76c72282007-10-09 17:33:22 +0000142 if (Tok.isNot(tok::comma))
Steve Naroff0f2fe172007-06-01 17:11:19 +0000143 break;
144 ConsumeToken(); // Eat the comma, move to the next argument
145 }
Chris Lattner76c72282007-10-09 17:33:22 +0000146 if (ArgExprsOk && Tok.is(tok::r_paren)) {
Steve Naroffb8371e12007-06-09 03:39:29 +0000147 ConsumeParen(); // ignore the right paren loc for now
Alexis Hunt96d5c762009-11-21 08:43:09 +0000148 CurrAttr = new AttributeList(AttrName, AttrNameLoc, 0,
149 AttrNameLoc, ParmName, ParmLoc,
150 ArgExprs.take(), ArgExprs.size(),
151 CurrAttr);
Steve Naroff0f2fe172007-06-01 17:11:19 +0000152 }
153 }
154 } else { // not an identifier
Nate Begemanf2758702009-06-26 06:32:41 +0000155 switch (Tok.getKind()) {
156 case tok::r_paren:
Steve Naroff0f2fe172007-06-01 17:11:19 +0000157 // parse a possibly empty comma separated list of expressions
Steve Naroff0f2fe172007-06-01 17:11:19 +0000158 // __attribute__(( nonnull() ))
Steve Naroffb8371e12007-06-09 03:39:29 +0000159 ConsumeParen(); // ignore the right paren loc for now
Alexis Hunt96d5c762009-11-21 08:43:09 +0000160 CurrAttr = new AttributeList(AttrName, AttrNameLoc, 0, AttrNameLoc,
Steve Naroffb8371e12007-06-09 03:39:29 +0000161 0, SourceLocation(), 0, 0, CurrAttr);
Nate Begemanf2758702009-06-26 06:32:41 +0000162 break;
163 case tok::kw_char:
164 case tok::kw_wchar_t:
Alisdair Mereditha9ad47d2009-07-14 06:30:34 +0000165 case tok::kw_char16_t:
166 case tok::kw_char32_t:
Nate Begemanf2758702009-06-26 06:32:41 +0000167 case tok::kw_bool:
168 case tok::kw_short:
169 case tok::kw_int:
170 case tok::kw_long:
171 case tok::kw_signed:
172 case tok::kw_unsigned:
173 case tok::kw_float:
174 case tok::kw_double:
175 case tok::kw_void:
176 case tok::kw_typeof:
Fariborz Jahanian9d7d3d82010-08-17 23:19:16 +0000177 CurrAttr = new AttributeList(AttrName, AttrNameLoc, 0, AttrNameLoc,
178 0, SourceLocation(), 0, 0, CurrAttr);
179 if (CurrAttr->getKind() == AttributeList::AT_IBOutletCollection)
180 Diag(Tok, diag::err_iboutletcollection_builtintype);
Nate Begemanf2758702009-06-26 06:32:41 +0000181 // If it's a builtin type name, eat it and expect a rparen
182 // __attribute__(( vec_type_hint(char) ))
183 ConsumeToken();
Nate Begemanf2758702009-06-26 06:32:41 +0000184 if (Tok.is(tok::r_paren))
185 ConsumeParen();
186 break;
187 default:
Steve Naroff0f2fe172007-06-01 17:11:19 +0000188 // __attribute__(( aligned(16) ))
Sebastian Redl511ed552008-11-25 22:21:31 +0000189 ExprVector ArgExprs(Actions);
Steve Naroff0f2fe172007-06-01 17:11:19 +0000190 bool ArgExprsOk = true;
Mike Stump11289f42009-09-09 15:08:12 +0000191
Steve Naroff0f2fe172007-06-01 17:11:19 +0000192 // now parse the list of expressions
193 while (1) {
Sebastian Redl59b5e512008-12-11 21:36:32 +0000194 OwningExprResult ArgExpr(ParseAssignmentExpression());
Sebastian Redl17f2c7d2008-12-09 13:15:23 +0000195 if (ArgExpr.isInvalid()) {
Steve Naroff0f2fe172007-06-01 17:11:19 +0000196 ArgExprsOk = false;
197 SkipUntil(tok::r_paren);
198 break;
199 } else {
Sebastian Redld9f7b1c2008-12-10 00:02:53 +0000200 ArgExprs.push_back(ArgExpr.release());
Steve Naroff0f2fe172007-06-01 17:11:19 +0000201 }
Chris Lattner76c72282007-10-09 17:33:22 +0000202 if (Tok.isNot(tok::comma))
Steve Naroff0f2fe172007-06-01 17:11:19 +0000203 break;
204 ConsumeToken(); // Eat the comma, move to the next argument
205 }
206 // Match the ')'.
Chris Lattner76c72282007-10-09 17:33:22 +0000207 if (ArgExprsOk && Tok.is(tok::r_paren)) {
Steve Naroffb8371e12007-06-09 03:39:29 +0000208 ConsumeParen(); // ignore the right paren loc for now
Sebastian Redl511ed552008-11-25 22:21:31 +0000209 CurrAttr = new AttributeList(AttrName, AttrNameLoc, 0,
Alexis Hunt96d5c762009-11-21 08:43:09 +0000210 AttrNameLoc, 0, SourceLocation(), ArgExprs.take(),
211 ArgExprs.size(),
Steve Naroffb8371e12007-06-09 03:39:29 +0000212 CurrAttr);
Steve Naroff0f2fe172007-06-01 17:11:19 +0000213 }
Nate Begemanf2758702009-06-26 06:32:41 +0000214 break;
Steve Naroff0f2fe172007-06-01 17:11:19 +0000215 }
216 }
217 } else {
Alexis Hunt96d5c762009-11-21 08:43:09 +0000218 CurrAttr = new AttributeList(AttrName, AttrNameLoc, 0, AttrNameLoc,
Steve Naroffb8371e12007-06-09 03:39:29 +0000219 0, SourceLocation(), 0, 0, CurrAttr);
Steve Naroff0f2fe172007-06-01 17:11:19 +0000220 }
221 }
Steve Naroff98d153c2007-06-06 23:19:11 +0000222 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen))
Steve Naroff98d153c2007-06-06 23:19:11 +0000223 SkipUntil(tok::r_paren, false);
Alexis Hunt96d5c762009-11-21 08:43:09 +0000224 SourceLocation Loc = Tok.getLocation();
Sebastian Redlf6591ca2009-02-09 18:23:29 +0000225 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) {
226 SkipUntil(tok::r_paren, false);
227 }
228 if (EndLoc)
229 *EndLoc = Loc;
Steve Naroff0f2fe172007-06-01 17:11:19 +0000230 }
231 return CurrAttr;
232}
Chris Lattnerf5fbd792006-08-10 23:56:11 +0000233
Eli Friedman06de2b52009-06-08 07:21:15 +0000234/// ParseMicrosoftDeclSpec - Parse an __declspec construct
235///
236/// [MS] decl-specifier:
237/// __declspec ( extended-decl-modifier-seq )
238///
239/// [MS] extended-decl-modifier-seq:
240/// extended-decl-modifier[opt]
241/// extended-decl-modifier extended-decl-modifier-seq
242
Eli Friedman53339e02009-06-08 23:27:34 +0000243AttributeList* Parser::ParseMicrosoftDeclSpec(AttributeList *CurrAttr) {
Steve Naroff3a9b7e02008-12-24 20:59:21 +0000244 assert(Tok.is(tok::kw___declspec) && "Not a declspec!");
Eli Friedman06de2b52009-06-08 07:21:15 +0000245
Steve Naroff3a9b7e02008-12-24 20:59:21 +0000246 ConsumeToken();
Eli Friedman06de2b52009-06-08 07:21:15 +0000247 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
248 "declspec")) {
249 SkipUntil(tok::r_paren, true); // skip until ) or ;
250 return CurrAttr;
251 }
Eli Friedman53339e02009-06-08 23:27:34 +0000252 while (Tok.getIdentifierInfo()) {
Eli Friedman06de2b52009-06-08 07:21:15 +0000253 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
254 SourceLocation AttrNameLoc = ConsumeToken();
255 if (Tok.is(tok::l_paren)) {
256 ConsumeParen();
257 // FIXME: This doesn't parse __declspec(property(get=get_func_name))
258 // correctly.
259 OwningExprResult ArgExpr(ParseAssignmentExpression());
260 if (!ArgExpr.isInvalid()) {
John McCall37ad5512010-08-23 06:44:23 +0000261 Expr *ExprList = ArgExpr.take();
Alexis Hunt96d5c762009-11-21 08:43:09 +0000262 CurrAttr = new AttributeList(AttrName, AttrNameLoc, 0, AttrNameLoc, 0,
Eli Friedman06de2b52009-06-08 07:21:15 +0000263 SourceLocation(), &ExprList, 1,
264 CurrAttr, true);
265 }
266 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen))
267 SkipUntil(tok::r_paren, false);
268 } else {
Alexis Hunt96d5c762009-11-21 08:43:09 +0000269 CurrAttr = new AttributeList(AttrName, AttrNameLoc, 0, AttrNameLoc,
270 0, SourceLocation(), 0, 0, CurrAttr, true);
Eli Friedman06de2b52009-06-08 07:21:15 +0000271 }
272 }
273 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen))
274 SkipUntil(tok::r_paren, false);
Eli Friedman53339e02009-06-08 23:27:34 +0000275 return CurrAttr;
276}
277
278AttributeList* Parser::ParseMicrosoftTypeAttributes(AttributeList *CurrAttr) {
279 // Treat these like attributes
280 // FIXME: Allow Sema to distinguish between these and real attributes!
281 while (Tok.is(tok::kw___fastcall) || Tok.is(tok::kw___stdcall) ||
Douglas Gregora941dca2010-05-18 16:57:00 +0000282 Tok.is(tok::kw___thiscall) || Tok.is(tok::kw___cdecl) ||
283 Tok.is(tok::kw___ptr64) || Tok.is(tok::kw___w64)) {
Eli Friedman53339e02009-06-08 23:27:34 +0000284 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
285 SourceLocation AttrNameLoc = ConsumeToken();
286 if (Tok.is(tok::kw___ptr64) || Tok.is(tok::kw___w64))
287 // FIXME: Support these properly!
288 continue;
Alexis Hunt96d5c762009-11-21 08:43:09 +0000289 CurrAttr = new AttributeList(AttrName, AttrNameLoc, 0, AttrNameLoc, 0,
Eli Friedman53339e02009-06-08 23:27:34 +0000290 SourceLocation(), 0, 0, CurrAttr, true);
291 }
292 return CurrAttr;
Steve Naroff3a9b7e02008-12-24 20:59:21 +0000293}
294
Chris Lattner53361ac2006-08-10 05:19:57 +0000295/// ParseDeclaration - Parse a full 'declaration', which consists of
296/// declaration-specifiers, some number of declarators, and a semicolon.
Chris Lattner49836b42009-04-02 04:16:50 +0000297/// 'Context' should be a Declarator::TheContext value. This returns the
298/// location of the semicolon in DeclEnd.
Chris Lattnera5235172007-08-25 06:57:03 +0000299///
300/// declaration: [C99 6.7]
301/// block-declaration ->
302/// simple-declaration
303/// others [FIXME]
Douglas Gregoreb31f392008-12-01 23:54:00 +0000304/// [C++] template-declaration
Chris Lattnera5235172007-08-25 06:57:03 +0000305/// [C++] namespace-definition
Douglas Gregord7c4d982008-12-30 03:27:21 +0000306/// [C++] using-directive
Douglas Gregor77b50e12009-06-22 23:06:13 +0000307/// [C++] using-declaration
Sebastian Redlf769df52009-03-24 22:27:57 +0000308/// [C++0x] static_assert-declaration
Chris Lattnera5235172007-08-25 06:57:03 +0000309/// others... [FIXME]
310///
Chris Lattner49836b42009-04-02 04:16:50 +0000311Parser::DeclGroupPtrTy Parser::ParseDeclaration(unsigned Context,
Alexis Hunt96d5c762009-11-21 08:43:09 +0000312 SourceLocation &DeclEnd,
313 CXX0XAttributeList Attr) {
Argyrios Kyrtzidis355094e2010-06-17 10:52:18 +0000314 ParenBraceBracketBalancer BalancerRAIIObj(*this);
315
John McCall48871652010-08-21 09:40:31 +0000316 Decl *SingleDecl = 0;
Chris Lattnera5235172007-08-25 06:57:03 +0000317 switch (Tok.getKind()) {
Douglas Gregoreb31f392008-12-01 23:54:00 +0000318 case tok::kw_template:
Douglas Gregor23996282009-05-12 21:31:51 +0000319 case tok::kw_export:
Alexis Hunt96d5c762009-11-21 08:43:09 +0000320 if (Attr.HasAttr)
321 Diag(Attr.Range.getBegin(), diag::err_attributes_not_allowed)
322 << Attr.Range;
Douglas Gregor1b57ff32009-05-12 23:25:50 +0000323 SingleDecl = ParseDeclarationStartingWithTemplate(Context, DeclEnd);
Chris Lattner5bbb3c82009-03-29 16:50:03 +0000324 break;
Chris Lattnera5235172007-08-25 06:57:03 +0000325 case tok::kw_namespace:
Alexis Hunt96d5c762009-11-21 08:43:09 +0000326 if (Attr.HasAttr)
327 Diag(Attr.Range.getBegin(), diag::err_attributes_not_allowed)
328 << Attr.Range;
Chris Lattner49836b42009-04-02 04:16:50 +0000329 SingleDecl = ParseNamespace(Context, DeclEnd);
Chris Lattner5bbb3c82009-03-29 16:50:03 +0000330 break;
Douglas Gregord7c4d982008-12-30 03:27:21 +0000331 case tok::kw_using:
Alexis Hunt96d5c762009-11-21 08:43:09 +0000332 SingleDecl = ParseUsingDirectiveOrDeclaration(Context, DeclEnd, Attr);
Chris Lattner5bbb3c82009-03-29 16:50:03 +0000333 break;
Anders Carlssonf24fcff62009-03-11 16:27:10 +0000334 case tok::kw_static_assert:
Alexis Hunt96d5c762009-11-21 08:43:09 +0000335 if (Attr.HasAttr)
336 Diag(Attr.Range.getBegin(), diag::err_attributes_not_allowed)
337 << Attr.Range;
Chris Lattner49836b42009-04-02 04:16:50 +0000338 SingleDecl = ParseStaticAssertDeclaration(DeclEnd);
Chris Lattner5bbb3c82009-03-29 16:50:03 +0000339 break;
Chris Lattnera5235172007-08-25 06:57:03 +0000340 default:
Chris Lattner005fc1b2010-04-05 18:18:31 +0000341 return ParseSimpleDeclaration(Context, DeclEnd, Attr.AttrList, true);
Chris Lattnera5235172007-08-25 06:57:03 +0000342 }
Alexis Hunt96d5c762009-11-21 08:43:09 +0000343
Chris Lattner5bbb3c82009-03-29 16:50:03 +0000344 // This routine returns a DeclGroup, if the thing we parsed only contains a
345 // single decl, convert it now.
346 return Actions.ConvertDeclToDeclGroup(SingleDecl);
Chris Lattnera5235172007-08-25 06:57:03 +0000347}
348
349/// simple-declaration: [C99 6.7: declaration] [C++ 7p1: dcl.dcl]
350/// declaration-specifiers init-declarator-list[opt] ';'
351///[C90/C++]init-declarator-list ';' [TODO]
352/// [OMP] threadprivate-directive [TODO]
Chris Lattner32dc41c2009-03-29 17:27:48 +0000353///
354/// If RequireSemi is false, this does not check for a ';' at the end of the
Chris Lattner005fc1b2010-04-05 18:18:31 +0000355/// declaration. If it is true, it checks for and eats it.
Chris Lattner32dc41c2009-03-29 17:27:48 +0000356Parser::DeclGroupPtrTy Parser::ParseSimpleDeclaration(unsigned Context,
Alexis Hunt96d5c762009-11-21 08:43:09 +0000357 SourceLocation &DeclEnd,
Chris Lattner005fc1b2010-04-05 18:18:31 +0000358 AttributeList *Attr,
359 bool RequireSemi) {
Chris Lattner53361ac2006-08-10 05:19:57 +0000360 // Parse the common declaration-specifiers piece.
John McCall28a6aea2009-11-04 02:18:39 +0000361 ParsingDeclSpec DS(*this);
Alexis Hunt96d5c762009-11-21 08:43:09 +0000362 if (Attr)
363 DS.AddAttributes(Attr);
Douglas Gregor9de54ea2010-01-13 17:31:36 +0000364 ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS_none,
365 getDeclSpecContextFromDeclaratorContext(Context));
Mike Stump11289f42009-09-09 15:08:12 +0000366
Chris Lattner0e894622006-08-13 19:58:17 +0000367 // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };"
368 // declaration-specifiers init-declarator-list[opt] ';'
Chris Lattner76c72282007-10-09 17:33:22 +0000369 if (Tok.is(tok::semi)) {
Chris Lattner005fc1b2010-04-05 18:18:31 +0000370 if (RequireSemi) ConsumeToken();
John McCall48871652010-08-21 09:40:31 +0000371 Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none,
John McCallb54367d2010-05-21 20:45:30 +0000372 DS);
John McCall28a6aea2009-11-04 02:18:39 +0000373 DS.complete(TheDecl);
Chris Lattner5bbb3c82009-03-29 16:50:03 +0000374 return Actions.ConvertDeclToDeclGroup(TheDecl);
Chris Lattner0e894622006-08-13 19:58:17 +0000375 }
Mike Stump11289f42009-09-09 15:08:12 +0000376
Chris Lattner005fc1b2010-04-05 18:18:31 +0000377 return ParseDeclGroup(DS, Context, /*FunctionDefs=*/ false, &DeclEnd);
John McCalld5a36322009-11-03 19:26:08 +0000378}
Mike Stump11289f42009-09-09 15:08:12 +0000379
John McCalld5a36322009-11-03 19:26:08 +0000380/// ParseDeclGroup - Having concluded that this is either a function
381/// definition or a group of object declarations, actually parse the
382/// result.
John McCall28a6aea2009-11-04 02:18:39 +0000383Parser::DeclGroupPtrTy Parser::ParseDeclGroup(ParsingDeclSpec &DS,
384 unsigned Context,
John McCalld5a36322009-11-03 19:26:08 +0000385 bool AllowFunctionDefinitions,
386 SourceLocation *DeclEnd) {
387 // Parse the first declarator.
John McCall28a6aea2009-11-04 02:18:39 +0000388 ParsingDeclarator D(*this, DS, static_cast<Declarator::TheContext>(Context));
John McCalld5a36322009-11-03 19:26:08 +0000389 ParseDeclarator(D);
Chris Lattner32dc41c2009-03-29 17:27:48 +0000390
John McCalld5a36322009-11-03 19:26:08 +0000391 // Bail out if the first declarator didn't seem well-formed.
392 if (!D.hasName() && !D.mayOmitIdentifier()) {
393 // Skip until ; or }.
394 SkipUntil(tok::r_brace, true, true);
395 if (Tok.is(tok::semi))
396 ConsumeToken();
397 return DeclGroupPtrTy();
Chris Lattnerefb0f112009-03-29 17:18:04 +0000398 }
Mike Stump11289f42009-09-09 15:08:12 +0000399
Chris Lattnerdbb1e932010-07-11 22:24:20 +0000400 // Check to see if we have a function *definition* which must have a body.
401 if (AllowFunctionDefinitions && D.isFunctionDeclarator() &&
402 // Look at the next token to make sure that this isn't a function
403 // declaration. We have to check this because __attribute__ might be the
404 // start of a function definition in GCC-extended K&R C.
405 !isDeclarationAfterDeclarator()) {
406
Chris Lattner13901342010-07-11 22:42:07 +0000407 if (isStartOfFunctionDefinition(D)) {
John McCalld5a36322009-11-03 19:26:08 +0000408 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {
409 Diag(Tok, diag::err_function_declared_typedef);
410
411 // Recover by treating the 'typedef' as spurious.
412 DS.ClearStorageClassSpecs();
413 }
414
John McCall48871652010-08-21 09:40:31 +0000415 Decl *TheDecl = ParseFunctionDefinition(D);
John McCalld5a36322009-11-03 19:26:08 +0000416 return Actions.ConvertDeclToDeclGroup(TheDecl);
Chris Lattner13901342010-07-11 22:42:07 +0000417 }
418
419 if (isDeclarationSpecifier()) {
420 // If there is an invalid declaration specifier right after the function
421 // prototype, then we must be in a missing semicolon case where this isn't
422 // actually a body. Just fall through into the code that handles it as a
423 // prototype, and let the top-level code handle the erroneous declspec
424 // where it would otherwise expect a comma or semicolon.
John McCalld5a36322009-11-03 19:26:08 +0000425 } else {
426 Diag(Tok, diag::err_expected_fn_body);
427 SkipUntil(tok::semi);
428 return DeclGroupPtrTy();
429 }
430 }
431
John McCall48871652010-08-21 09:40:31 +0000432 llvm::SmallVector<Decl *, 8> DeclsInGroup;
433 Decl *FirstDecl = ParseDeclarationAfterDeclarator(D);
John McCall28a6aea2009-11-04 02:18:39 +0000434 D.complete(FirstDecl);
John McCall48871652010-08-21 09:40:31 +0000435 if (FirstDecl)
John McCalld5a36322009-11-03 19:26:08 +0000436 DeclsInGroup.push_back(FirstDecl);
437
438 // If we don't have a comma, it is either the end of the list (a ';') or an
439 // error, bail out.
440 while (Tok.is(tok::comma)) {
441 // Consume the comma.
Chris Lattnerefb0f112009-03-29 17:18:04 +0000442 ConsumeToken();
John McCalld5a36322009-11-03 19:26:08 +0000443
444 // Parse the next declarator.
445 D.clear();
446
447 // Accept attributes in an init-declarator. In the first declarator in a
448 // declaration, these would be part of the declspec. In subsequent
449 // declarators, they become part of the declarator itself, so that they
450 // don't apply to declarators after *this* one. Examples:
451 // short __attribute__((common)) var; -> declspec
452 // short var __attribute__((common)); -> declarator
453 // short x, __attribute__((common)) var; -> declarator
454 if (Tok.is(tok::kw___attribute)) {
455 SourceLocation Loc;
Alexis Hunt96d5c762009-11-21 08:43:09 +0000456 AttributeList *AttrList = ParseGNUAttributes(&Loc);
John McCalld5a36322009-11-03 19:26:08 +0000457 D.AddAttributes(AttrList, Loc);
458 }
459
460 ParseDeclarator(D);
461
John McCall48871652010-08-21 09:40:31 +0000462 Decl *ThisDecl = ParseDeclarationAfterDeclarator(D);
John McCall28a6aea2009-11-04 02:18:39 +0000463 D.complete(ThisDecl);
John McCall48871652010-08-21 09:40:31 +0000464 if (ThisDecl)
John McCalld5a36322009-11-03 19:26:08 +0000465 DeclsInGroup.push_back(ThisDecl);
466 }
467
468 if (DeclEnd)
469 *DeclEnd = Tok.getLocation();
470
471 if (Context != Declarator::ForContext &&
472 ExpectAndConsume(tok::semi,
473 Context == Declarator::FileContext
474 ? diag::err_invalid_token_after_toplevel_declarator
475 : diag::err_expected_semi_declaration)) {
Chris Lattner13901342010-07-11 22:42:07 +0000476 // Okay, there was no semicolon and one was expected. If we see a
477 // declaration specifier, just assume it was missing and continue parsing.
478 // Otherwise things are very confused and we skip to recover.
479 if (!isDeclarationSpecifier()) {
480 SkipUntil(tok::r_brace, true, true);
481 if (Tok.is(tok::semi))
482 ConsumeToken();
483 }
John McCalld5a36322009-11-03 19:26:08 +0000484 }
485
Douglas Gregor0be31a22010-07-02 17:43:08 +0000486 return Actions.FinalizeDeclaratorGroup(getCurScope(), DS,
John McCalld5a36322009-11-03 19:26:08 +0000487 DeclsInGroup.data(),
488 DeclsInGroup.size());
Chris Lattner53361ac2006-08-10 05:19:57 +0000489}
490
Douglas Gregor23996282009-05-12 21:31:51 +0000491/// \brief Parse 'declaration' after parsing 'declaration-specifiers
492/// declarator'. This method parses the remainder of the declaration
493/// (including any attributes or initializer, among other things) and
494/// finalizes the declaration.
Chris Lattnerf0f3baa2006-08-14 00:15:20 +0000495///
Chris Lattnerf0f3baa2006-08-14 00:15:20 +0000496/// init-declarator: [C99 6.7]
497/// declarator
498/// declarator '=' initializer
Chris Lattner6d7e6342006-08-15 03:41:14 +0000499/// [GNU] declarator simple-asm-expr[opt] attributes[opt]
500/// [GNU] declarator simple-asm-expr[opt] attributes[opt] '=' initializer
Argyrios Kyrtzidis9a1191c2008-10-06 17:10:33 +0000501/// [C++] declarator initializer[opt]
502///
503/// [C++] initializer:
504/// [C++] '=' initializer-clause
505/// [C++] '(' expression-list ')'
Sebastian Redlf769df52009-03-24 22:27:57 +0000506/// [C++0x] '=' 'default' [TODO]
507/// [C++0x] '=' 'delete'
508///
509/// According to the standard grammar, =default and =delete are function
510/// definitions, but that definitely doesn't fit with the parser here.
Chris Lattnerf0f3baa2006-08-14 00:15:20 +0000511///
John McCall48871652010-08-21 09:40:31 +0000512Decl *Parser::ParseDeclarationAfterDeclarator(Declarator &D,
Douglas Gregorb52fabb2009-06-23 23:11:28 +0000513 const ParsedTemplateInfo &TemplateInfo) {
Douglas Gregor23996282009-05-12 21:31:51 +0000514 // If a simple-asm-expr is present, parse it.
515 if (Tok.is(tok::kw_asm)) {
516 SourceLocation Loc;
517 OwningExprResult AsmLabel(ParseSimpleAsm(&Loc));
518 if (AsmLabel.isInvalid()) {
519 SkipUntil(tok::semi, true, true);
John McCall48871652010-08-21 09:40:31 +0000520 return 0;
Douglas Gregor23996282009-05-12 21:31:51 +0000521 }
Mike Stump11289f42009-09-09 15:08:12 +0000522
Douglas Gregor23996282009-05-12 21:31:51 +0000523 D.setAsmLabel(AsmLabel.release());
524 D.SetRangeEnd(Loc);
525 }
Mike Stump11289f42009-09-09 15:08:12 +0000526
Douglas Gregor23996282009-05-12 21:31:51 +0000527 // If attributes are present, parse them.
528 if (Tok.is(tok::kw___attribute)) {
529 SourceLocation Loc;
Alexis Hunt96d5c762009-11-21 08:43:09 +0000530 AttributeList *AttrList = ParseGNUAttributes(&Loc);
Douglas Gregor23996282009-05-12 21:31:51 +0000531 D.AddAttributes(AttrList, Loc);
532 }
Mike Stump11289f42009-09-09 15:08:12 +0000533
Douglas Gregor23996282009-05-12 21:31:51 +0000534 // Inform the current actions module that we just parsed this declarator.
John McCall48871652010-08-21 09:40:31 +0000535 Decl *ThisDecl = 0;
Douglas Gregor450f00842009-09-25 18:43:00 +0000536 switch (TemplateInfo.Kind) {
537 case ParsedTemplateInfo::NonTemplate:
Douglas Gregor0be31a22010-07-02 17:43:08 +0000538 ThisDecl = Actions.ActOnDeclarator(getCurScope(), D);
Douglas Gregor450f00842009-09-25 18:43:00 +0000539 break;
540
541 case ParsedTemplateInfo::Template:
542 case ParsedTemplateInfo::ExplicitSpecialization:
Douglas Gregor0be31a22010-07-02 17:43:08 +0000543 ThisDecl = Actions.ActOnTemplateDeclarator(getCurScope(),
Douglas Gregorb52fabb2009-06-23 23:11:28 +0000544 Action::MultiTemplateParamsArg(Actions,
545 TemplateInfo.TemplateParams->data(),
546 TemplateInfo.TemplateParams->size()),
Douglas Gregor450f00842009-09-25 18:43:00 +0000547 D);
548 break;
549
550 case ParsedTemplateInfo::ExplicitInstantiation: {
John McCall48871652010-08-21 09:40:31 +0000551 DeclResult ThisRes
Douglas Gregor0be31a22010-07-02 17:43:08 +0000552 = Actions.ActOnExplicitInstantiation(getCurScope(),
Douglas Gregor450f00842009-09-25 18:43:00 +0000553 TemplateInfo.ExternLoc,
554 TemplateInfo.TemplateLoc,
555 D);
556 if (ThisRes.isInvalid()) {
557 SkipUntil(tok::semi, true, true);
John McCall48871652010-08-21 09:40:31 +0000558 return 0;
Douglas Gregor450f00842009-09-25 18:43:00 +0000559 }
560
561 ThisDecl = ThisRes.get();
562 break;
563 }
564 }
Mike Stump11289f42009-09-09 15:08:12 +0000565
Douglas Gregor23996282009-05-12 21:31:51 +0000566 // Parse declarator '=' initializer.
567 if (Tok.is(tok::equal)) {
568 ConsumeToken();
569 if (getLang().CPlusPlus0x && Tok.is(tok::kw_delete)) {
570 SourceLocation DelLoc = ConsumeToken();
571 Actions.SetDeclDeleted(ThisDecl, DelLoc);
572 } else {
John McCall1f4ee7b2009-12-19 09:28:58 +0000573 if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) {
574 EnterScope(0);
Douglas Gregor0be31a22010-07-02 17:43:08 +0000575 Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl);
John McCall1f4ee7b2009-12-19 09:28:58 +0000576 }
Argyrios Kyrtzidis3df19782009-06-17 22:50:06 +0000577
Douglas Gregor7aa6b222010-05-30 01:49:25 +0000578 if (Tok.is(tok::code_completion)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +0000579 Actions.CodeCompleteInitializer(getCurScope(), ThisDecl);
Douglas Gregor7aa6b222010-05-30 01:49:25 +0000580 ConsumeCodeCompletionToken();
581 SkipUntil(tok::comma, true, true);
582 return ThisDecl;
583 }
584
Douglas Gregor23996282009-05-12 21:31:51 +0000585 OwningExprResult Init(ParseInitializer());
Argyrios Kyrtzidis3df19782009-06-17 22:50:06 +0000586
John McCall1f4ee7b2009-12-19 09:28:58 +0000587 if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) {
Douglas Gregor0be31a22010-07-02 17:43:08 +0000588 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
John McCall1f4ee7b2009-12-19 09:28:58 +0000589 ExitScope();
590 }
Argyrios Kyrtzidis3df19782009-06-17 22:50:06 +0000591
Douglas Gregor23996282009-05-12 21:31:51 +0000592 if (Init.isInvalid()) {
Douglas Gregor604c3022010-03-01 18:27:54 +0000593 SkipUntil(tok::comma, true, true);
594 Actions.ActOnInitializerError(ThisDecl);
595 } else
John McCallb268a282010-08-23 23:25:46 +0000596 Actions.AddInitializerToDecl(ThisDecl, Init.take());
Douglas Gregor23996282009-05-12 21:31:51 +0000597 }
598 } else if (Tok.is(tok::l_paren)) {
599 // Parse C++ direct initializer: '(' expression-list ')'
600 SourceLocation LParenLoc = ConsumeParen();
601 ExprVector Exprs(Actions);
602 CommaLocsTy CommaLocs;
603
Douglas Gregor613bf102009-12-22 17:47:17 +0000604 if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) {
605 EnterScope(0);
Douglas Gregor0be31a22010-07-02 17:43:08 +0000606 Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl);
Douglas Gregor613bf102009-12-22 17:47:17 +0000607 }
608
Douglas Gregor23996282009-05-12 21:31:51 +0000609 if (ParseExpressionList(Exprs, CommaLocs)) {
610 SkipUntil(tok::r_paren);
Douglas Gregor613bf102009-12-22 17:47:17 +0000611
612 if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) {
Douglas Gregor0be31a22010-07-02 17:43:08 +0000613 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
Douglas Gregor613bf102009-12-22 17:47:17 +0000614 ExitScope();
615 }
Douglas Gregor23996282009-05-12 21:31:51 +0000616 } else {
617 // Match the ')'.
618 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
619
620 assert(!Exprs.empty() && Exprs.size()-1 == CommaLocs.size() &&
621 "Unexpected number of commas!");
Douglas Gregor613bf102009-12-22 17:47:17 +0000622
623 if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) {
Douglas Gregor0be31a22010-07-02 17:43:08 +0000624 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
Douglas Gregor613bf102009-12-22 17:47:17 +0000625 ExitScope();
626 }
627
Douglas Gregor23996282009-05-12 21:31:51 +0000628 Actions.AddCXXDirectInitializerToDecl(ThisDecl, LParenLoc,
629 move_arg(Exprs),
Jay Foad7d0479f2009-05-21 09:52:38 +0000630 CommaLocs.data(), RParenLoc);
Douglas Gregor23996282009-05-12 21:31:51 +0000631 }
632 } else {
Mike Stump11289f42009-09-09 15:08:12 +0000633 bool TypeContainsUndeducedAuto =
Anders Carlssonae019932009-07-11 00:34:39 +0000634 D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto;
635 Actions.ActOnUninitializedDecl(ThisDecl, TypeContainsUndeducedAuto);
Douglas Gregor23996282009-05-12 21:31:51 +0000636 }
637
638 return ThisDecl;
639}
640
Chris Lattner1890ac82006-08-13 01:16:23 +0000641/// ParseSpecifierQualifierList
642/// specifier-qualifier-list:
643/// type-specifier specifier-qualifier-list[opt]
644/// type-qualifier specifier-qualifier-list[opt]
Chris Lattnere37e2332006-08-15 04:50:22 +0000645/// [GNU] attributes specifier-qualifier-list[opt]
Chris Lattner1890ac82006-08-13 01:16:23 +0000646///
647void Parser::ParseSpecifierQualifierList(DeclSpec &DS) {
648 /// specifier-qualifier-list is a subset of declaration-specifiers. Just
649 /// parse declaration-specifiers and complain about extra stuff.
Chris Lattner1890ac82006-08-13 01:16:23 +0000650 ParseDeclarationSpecifiers(DS);
Mike Stump11289f42009-09-09 15:08:12 +0000651
Chris Lattner1890ac82006-08-13 01:16:23 +0000652 // Validate declspec for type-name.
653 unsigned Specs = DS.getParsedSpecifiers();
Chris Lattnera723ba92009-04-14 21:16:09 +0000654 if (Specs == DeclSpec::PQ_None && !DS.getNumProtocolQualifiers() &&
655 !DS.getAttributes())
Chris Lattner1890ac82006-08-13 01:16:23 +0000656 Diag(Tok, diag::err_typename_requires_specqual);
Mike Stump11289f42009-09-09 15:08:12 +0000657
Chris Lattner1b22eed2006-11-28 05:12:07 +0000658 // Issue diagnostic and remove storage class if present.
Chris Lattner1890ac82006-08-13 01:16:23 +0000659 if (Specs & DeclSpec::PQ_StorageClassSpecifier) {
Chris Lattner1b22eed2006-11-28 05:12:07 +0000660 if (DS.getStorageClassSpecLoc().isValid())
661 Diag(DS.getStorageClassSpecLoc(),diag::err_typename_invalid_storageclass);
662 else
663 Diag(DS.getThreadSpecLoc(), diag::err_typename_invalid_storageclass);
Chris Lattnera925dc62006-11-28 04:33:46 +0000664 DS.ClearStorageClassSpecs();
Chris Lattner1890ac82006-08-13 01:16:23 +0000665 }
Mike Stump11289f42009-09-09 15:08:12 +0000666
Chris Lattner1b22eed2006-11-28 05:12:07 +0000667 // Issue diagnostic and remove function specfier if present.
Chris Lattner1890ac82006-08-13 01:16:23 +0000668 if (Specs & DeclSpec::PQ_FunctionSpecifier) {
Douglas Gregor61956c42008-10-31 09:07:45 +0000669 if (DS.isInlineSpecified())
670 Diag(DS.getInlineSpecLoc(), diag::err_typename_invalid_functionspec);
671 if (DS.isVirtualSpecified())
672 Diag(DS.getVirtualSpecLoc(), diag::err_typename_invalid_functionspec);
673 if (DS.isExplicitSpecified())
674 Diag(DS.getExplicitSpecLoc(), diag::err_typename_invalid_functionspec);
Chris Lattnera925dc62006-11-28 04:33:46 +0000675 DS.ClearFunctionSpecs();
Chris Lattner1890ac82006-08-13 01:16:23 +0000676 }
677}
Chris Lattner53361ac2006-08-10 05:19:57 +0000678
Chris Lattner6cc055a2009-04-12 20:42:31 +0000679/// isValidAfterIdentifierInDeclaratorAfterDeclSpec - Return true if the
680/// specified token is valid after the identifier in a declarator which
681/// immediately follows the declspec. For example, these things are valid:
682///
683/// int x [ 4]; // direct-declarator
684/// int x ( int y); // direct-declarator
685/// int(int x ) // direct-declarator
686/// int x ; // simple-declaration
687/// int x = 17; // init-declarator-list
688/// int x , y; // init-declarator-list
689/// int x __asm__ ("foo"); // init-declarator-list
Chris Lattnera723ba92009-04-14 21:16:09 +0000690/// int x : 4; // struct-declarator
Chris Lattner2b988c12009-04-12 22:29:43 +0000691/// int x { 5}; // C++'0x unified initializers
Chris Lattner6cc055a2009-04-12 20:42:31 +0000692///
693/// This is not, because 'x' does not immediately follow the declspec (though
694/// ')' happens to be valid anyway).
695/// int (x)
696///
697static bool isValidAfterIdentifierInDeclarator(const Token &T) {
698 return T.is(tok::l_square) || T.is(tok::l_paren) || T.is(tok::r_paren) ||
699 T.is(tok::semi) || T.is(tok::comma) || T.is(tok::equal) ||
Chris Lattnera723ba92009-04-14 21:16:09 +0000700 T.is(tok::kw_asm) || T.is(tok::l_brace) || T.is(tok::colon);
Chris Lattner6cc055a2009-04-12 20:42:31 +0000701}
702
Chris Lattner20a0c612009-04-14 21:34:55 +0000703
704/// ParseImplicitInt - This method is called when we have an non-typename
705/// identifier in a declspec (which normally terminates the decl spec) when
706/// the declspec has no type specifier. In this case, the declspec is either
707/// malformed or is "implicit int" (in K&R and C89).
708///
709/// This method handles diagnosing this prettily and returns false if the
710/// declspec is done being processed. If it recovers and thinks there may be
711/// other pieces of declspec after it, it returns true.
712///
Chris Lattnerb4a8fe82009-04-14 22:17:06 +0000713bool Parser::ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS,
Douglas Gregor1b57ff32009-05-12 23:25:50 +0000714 const ParsedTemplateInfo &TemplateInfo,
Chris Lattner20a0c612009-04-14 21:34:55 +0000715 AccessSpecifier AS) {
Chris Lattnerb4a8fe82009-04-14 22:17:06 +0000716 assert(Tok.is(tok::identifier) && "should have identifier");
Mike Stump11289f42009-09-09 15:08:12 +0000717
Chris Lattner20a0c612009-04-14 21:34:55 +0000718 SourceLocation Loc = Tok.getLocation();
719 // If we see an identifier that is not a type name, we normally would
720 // parse it as the identifer being declared. However, when a typename
721 // is typo'd or the definition is not included, this will incorrectly
722 // parse the typename as the identifier name and fall over misparsing
723 // later parts of the diagnostic.
724 //
725 // As such, we try to do some look-ahead in cases where this would
726 // otherwise be an "implicit-int" case to see if this is invalid. For
727 // example: "static foo_t x = 4;" In this case, if we parsed foo_t as
728 // an identifier with implicit int, we'd get a parse error because the
729 // next token is obviously invalid for a type. Parse these as a case
730 // with an invalid type specifier.
731 assert(!DS.hasTypeSpecifier() && "Type specifier checked above");
Mike Stump11289f42009-09-09 15:08:12 +0000732
Chris Lattner20a0c612009-04-14 21:34:55 +0000733 // Since we know that this either implicit int (which is rare) or an
734 // error, we'd do lookahead to try to do better recovery.
735 if (isValidAfterIdentifierInDeclarator(NextToken())) {
736 // If this token is valid for implicit int, e.g. "static x = 4", then
737 // we just avoid eating the identifier, so it will be parsed as the
738 // identifier in the declarator.
739 return false;
740 }
Mike Stump11289f42009-09-09 15:08:12 +0000741
Chris Lattner20a0c612009-04-14 21:34:55 +0000742 // Otherwise, if we don't consume this token, we are going to emit an
743 // error anyway. Try to recover from various common problems. Check
744 // to see if this was a reference to a tag name without a tag specified.
745 // This is a common problem in C (saying 'foo' instead of 'struct foo').
Chris Lattnerb4a8fe82009-04-14 22:17:06 +0000746 //
747 // C++ doesn't need this, and isTagName doesn't take SS.
748 if (SS == 0) {
749 const char *TagName = 0;
750 tok::TokenKind TagKind = tok::unknown;
Mike Stump11289f42009-09-09 15:08:12 +0000751
Douglas Gregor0be31a22010-07-02 17:43:08 +0000752 switch (Actions.isTagName(*Tok.getIdentifierInfo(), getCurScope())) {
Chris Lattner20a0c612009-04-14 21:34:55 +0000753 default: break;
754 case DeclSpec::TST_enum: TagName="enum" ;TagKind=tok::kw_enum ;break;
755 case DeclSpec::TST_union: TagName="union" ;TagKind=tok::kw_union ;break;
756 case DeclSpec::TST_struct:TagName="struct";TagKind=tok::kw_struct;break;
757 case DeclSpec::TST_class: TagName="class" ;TagKind=tok::kw_class ;break;
758 }
Mike Stump11289f42009-09-09 15:08:12 +0000759
Chris Lattnerb4a8fe82009-04-14 22:17:06 +0000760 if (TagName) {
761 Diag(Loc, diag::err_use_of_tag_name_without_tag)
John McCall38200b02010-02-14 01:03:10 +0000762 << Tok.getIdentifierInfo() << TagName << getLang().CPlusPlus
Douglas Gregora771f462010-03-31 17:46:05 +0000763 << FixItHint::CreateInsertion(Tok.getLocation(),TagName);
Mike Stump11289f42009-09-09 15:08:12 +0000764
Chris Lattnerb4a8fe82009-04-14 22:17:06 +0000765 // Parse this as a tag as if the missing tag were present.
766 if (TagKind == tok::kw_enum)
Douglas Gregordc70c3a2010-03-02 17:53:14 +0000767 ParseEnumSpecifier(Loc, DS, TemplateInfo, AS);
Chris Lattnerb4a8fe82009-04-14 22:17:06 +0000768 else
Douglas Gregor1b57ff32009-05-12 23:25:50 +0000769 ParseClassSpecifier(TagKind, Loc, DS, TemplateInfo, AS);
Chris Lattnerb4a8fe82009-04-14 22:17:06 +0000770 return true;
771 }
Chris Lattner20a0c612009-04-14 21:34:55 +0000772 }
Mike Stump11289f42009-09-09 15:08:12 +0000773
Douglas Gregor15e56022009-10-13 23:27:22 +0000774 // This is almost certainly an invalid type name. Let the action emit a
775 // diagnostic and attempt to recover.
John McCallba7bf592010-08-24 05:47:05 +0000776 ParsedType T;
Douglas Gregor15e56022009-10-13 23:27:22 +0000777 if (Actions.DiagnoseUnknownTypeName(*Tok.getIdentifierInfo(), Loc,
Douglas Gregor0be31a22010-07-02 17:43:08 +0000778 getCurScope(), SS, T)) {
Douglas Gregor15e56022009-10-13 23:27:22 +0000779 // The action emitted a diagnostic, so we don't have to.
780 if (T) {
781 // The action has suggested that the type T could be used. Set that as
782 // the type in the declaration specifiers, consume the would-be type
783 // name token, and we're done.
784 const char *PrevSpec;
785 unsigned DiagID;
John McCallba7bf592010-08-24 05:47:05 +0000786 DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID, T);
Douglas Gregor15e56022009-10-13 23:27:22 +0000787 DS.SetRangeEnd(Tok.getLocation());
788 ConsumeToken();
789
790 // There may be other declaration specifiers after this.
791 return true;
792 }
793
794 // Fall through; the action had no suggestion for us.
795 } else {
796 // The action did not emit a diagnostic, so emit one now.
797 SourceRange R;
798 if (SS) R = SS->getRange();
799 Diag(Loc, diag::err_unknown_typename) << Tok.getIdentifierInfo() << R;
800 }
Mike Stump11289f42009-09-09 15:08:12 +0000801
Douglas Gregor15e56022009-10-13 23:27:22 +0000802 // Mark this as an error.
Chris Lattner20a0c612009-04-14 21:34:55 +0000803 const char *PrevSpec;
John McCall49bfce42009-08-03 20:12:06 +0000804 unsigned DiagID;
805 DS.SetTypeSpecType(DeclSpec::TST_error, Loc, PrevSpec, DiagID);
Chris Lattner20a0c612009-04-14 21:34:55 +0000806 DS.SetRangeEnd(Tok.getLocation());
807 ConsumeToken();
Mike Stump11289f42009-09-09 15:08:12 +0000808
Chris Lattner20a0c612009-04-14 21:34:55 +0000809 // TODO: Could inject an invalid typedef decl in an enclosing scope to
810 // avoid rippling error messages on subsequent uses of the same type,
811 // could be useful if #include was forgotten.
812 return false;
813}
814
Douglas Gregor9de54ea2010-01-13 17:31:36 +0000815/// \brief Determine the declaration specifier context from the declarator
816/// context.
817///
818/// \param Context the declarator context, which is one of the
819/// Declarator::TheContext enumerator values.
820Parser::DeclSpecContext
821Parser::getDeclSpecContextFromDeclaratorContext(unsigned Context) {
822 if (Context == Declarator::MemberContext)
823 return DSC_class;
824 if (Context == Declarator::FileContext)
825 return DSC_top_level;
826 return DSC_normal;
827}
828
Chris Lattnerc0acd3d2006-07-31 05:13:43 +0000829/// ParseDeclarationSpecifiers
830/// declaration-specifiers: [C99 6.7]
Chris Lattner3b561a32006-08-13 00:12:11 +0000831/// storage-class-specifier declaration-specifiers[opt]
832/// type-specifier declaration-specifiers[opt]
Chris Lattner3b561a32006-08-13 00:12:11 +0000833/// [C99] function-specifier declaration-specifiers[opt]
Chris Lattnere37e2332006-08-15 04:50:22 +0000834/// [GNU] attributes declaration-specifiers[opt]
Chris Lattnerc0acd3d2006-07-31 05:13:43 +0000835///
Chris Lattnerf63f89a2006-08-05 03:28:50 +0000836/// storage-class-specifier: [C99 6.7.1]
Chris Lattnerda48a8e2006-08-04 05:25:55 +0000837/// 'typedef'
838/// 'extern'
839/// 'static'
840/// 'auto'
841/// 'register'
Sebastian Redlccdfaba2008-11-14 23:42:31 +0000842/// [C++] 'mutable'
Chris Lattnerda48a8e2006-08-04 05:25:55 +0000843/// [GNU] '__thread'
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000844/// function-specifier: [C99 6.7.4]
Chris Lattner3b561a32006-08-13 00:12:11 +0000845/// [C99] 'inline'
Douglas Gregor61956c42008-10-31 09:07:45 +0000846/// [C++] 'virtual'
847/// [C++] 'explicit'
Anders Carlssoncd8db412009-05-06 04:46:28 +0000848/// 'friend': [C++ dcl.friend]
Sebastian Redl39c2a8b2009-11-05 15:47:02 +0000849/// 'constexpr': [C++0x dcl.constexpr]
Anders Carlssoncd8db412009-05-06 04:46:28 +0000850
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000851///
Douglas Gregorb9bd8a92008-12-24 02:52:09 +0000852void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
Douglas Gregor1b57ff32009-05-12 23:25:50 +0000853 const ParsedTemplateInfo &TemplateInfo,
John McCall07e91c02009-08-06 02:15:43 +0000854 AccessSpecifier AS,
Douglas Gregorc49f5b22010-08-23 18:23:48 +0000855 DeclSpecContext DSContext) {
Chris Lattner2e232092008-03-13 06:29:04 +0000856 DS.SetRangeStart(Tok.getLocation());
Chris Lattnerc0acd3d2006-07-31 05:13:43 +0000857 while (1) {
John McCall49bfce42009-08-03 20:12:06 +0000858 bool isInvalid = false;
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000859 const char *PrevSpec = 0;
John McCall49bfce42009-08-03 20:12:06 +0000860 unsigned DiagID = 0;
861
Chris Lattner4d8f8732006-11-28 05:05:08 +0000862 SourceLocation Loc = Tok.getLocation();
Douglas Gregor450c75a2008-11-07 15:42:26 +0000863
Chris Lattnerc0acd3d2006-07-31 05:13:43 +0000864 switch (Tok.getKind()) {
Mike Stump11289f42009-09-09 15:08:12 +0000865 default:
Chris Lattner0974b232008-07-26 00:20:22 +0000866 DoneWithDeclSpec:
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000867 // If this is not a declaration specifier token, we're done reading decl
868 // specifiers. First verify that DeclSpec's are consistent.
Douglas Gregore3e01a22009-04-01 22:41:11 +0000869 DS.Finish(Diags, PP);
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000870 return;
Mike Stump11289f42009-09-09 15:08:12 +0000871
Douglas Gregorc49f5b22010-08-23 18:23:48 +0000872 case tok::code_completion: {
873 Action::ParserCompletionContext CCC = Action::PCC_Namespace;
874 if (DS.hasTypeSpecifier()) {
875 bool AllowNonIdentifiers
876 = (getCurScope()->getFlags() & (Scope::ControlScope |
877 Scope::BlockScope |
878 Scope::TemplateParamScope |
879 Scope::FunctionPrototypeScope |
880 Scope::AtCatchScope)) == 0;
881 bool AllowNestedNameSpecifiers
882 = DSContext == DSC_top_level ||
883 (DSContext == DSC_class && DS.isFriendSpecified());
884
885 Actions.CodeCompleteDeclarator(getCurScope(), AllowNonIdentifiers,
886 AllowNestedNameSpecifiers);
887 ConsumeCodeCompletionToken();
888 return;
889 }
890
891 if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate)
892 CCC = DSContext == DSC_class? Action::PCC_MemberTemplate
893 : Action::PCC_Template;
894 else if (DSContext == DSC_class)
895 CCC = Action::PCC_Class;
896 else if (ObjCImpDecl)
897 CCC = Action::PCC_ObjCImplementation;
898
899 Actions.CodeCompleteOrdinaryName(getCurScope(), CCC);
900 ConsumeCodeCompletionToken();
901 return;
902 }
903
Chris Lattnerbd31aa32009-01-05 00:07:25 +0000904 case tok::coloncolon: // ::foo::bar
John McCall1f476a12010-02-26 08:45:28 +0000905 // C++ scope specifier. Annotate and loop, or bail out on error.
906 if (TryAnnotateCXXScopeToken(true)) {
907 if (!DS.hasTypeSpecifier())
908 DS.SetTypeSpecError();
909 goto DoneWithDeclSpec;
910 }
John McCall8bc2a702010-03-01 18:20:46 +0000911 if (Tok.is(tok::coloncolon)) // ::new or ::delete
912 goto DoneWithDeclSpec;
John McCall1f476a12010-02-26 08:45:28 +0000913 continue;
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +0000914
915 case tok::annot_cxxscope: {
916 if (DS.hasTypeSpecifier())
917 goto DoneWithDeclSpec;
918
John McCall9dab4e62009-12-12 11:40:51 +0000919 CXXScopeSpec SS;
John McCall37ad5512010-08-23 06:44:23 +0000920 SS.setScopeRep((NestedNameSpecifier*) Tok.getAnnotationValue());
John McCall9dab4e62009-12-12 11:40:51 +0000921 SS.setRange(Tok.getAnnotationRange());
922
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +0000923 // We are looking for a qualified typename.
Douglas Gregor167fa622009-03-25 15:40:00 +0000924 Token Next = NextToken();
Mike Stump11289f42009-09-09 15:08:12 +0000925 if (Next.is(tok::annot_template_id) &&
Douglas Gregor167fa622009-03-25 15:40:00 +0000926 static_cast<TemplateIdAnnotation *>(Next.getAnnotationValue())
Douglas Gregorb67535d2009-03-31 00:43:58 +0000927 ->Kind == TNK_Type_template) {
Douglas Gregor167fa622009-03-25 15:40:00 +0000928 // We have a qualified template-id, e.g., N::A<int>
Douglas Gregor9de54ea2010-01-13 17:31:36 +0000929
930 // C++ [class.qual]p2:
931 // In a lookup in which the constructor is an acceptable lookup
932 // result and the nested-name-specifier nominates a class C:
933 //
934 // - if the name specified after the
935 // nested-name-specifier, when looked up in C, is the
936 // injected-class-name of C (Clause 9), or
937 //
938 // - if the name specified after the nested-name-specifier
939 // is the same as the identifier or the
940 // simple-template-id's template-name in the last
941 // component of the nested-name-specifier,
942 //
943 // the name is instead considered to name the constructor of
944 // class C.
945 //
946 // Thus, if the template-name is actually the constructor
947 // name, then the code is ill-formed; this interpretation is
948 // reinforced by the NAD status of core issue 635.
949 TemplateIdAnnotation *TemplateId
950 = static_cast<TemplateIdAnnotation *>(Next.getAnnotationValue());
John McCall84821e72010-04-13 06:39:49 +0000951 if ((DSContext == DSC_top_level ||
952 (DSContext == DSC_class && DS.isFriendSpecified())) &&
953 TemplateId->Name &&
Douglas Gregor0be31a22010-07-02 17:43:08 +0000954 Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)) {
Douglas Gregor9de54ea2010-01-13 17:31:36 +0000955 if (isConstructorDeclarator()) {
956 // The user meant this to be an out-of-line constructor
957 // definition, but template arguments are not allowed
958 // there. Just allow this as a constructor; we'll
959 // complain about it later.
960 goto DoneWithDeclSpec;
961 }
962
963 // The user meant this to name a type, but it actually names
964 // a constructor with some extraneous template
965 // arguments. Complain, then parse it as a type as the user
966 // intended.
967 Diag(TemplateId->TemplateNameLoc,
968 diag::err_out_of_line_template_id_names_constructor)
969 << TemplateId->Name;
970 }
971
John McCall9dab4e62009-12-12 11:40:51 +0000972 DS.getTypeSpecScope() = SS;
973 ConsumeToken(); // The C++ scope.
Mike Stump11289f42009-09-09 15:08:12 +0000974 assert(Tok.is(tok::annot_template_id) &&
Douglas Gregor167fa622009-03-25 15:40:00 +0000975 "ParseOptionalCXXScopeSpecifier not working");
976 AnnotateTemplateIdTokenAsType(&SS);
977 continue;
978 }
979
Douglas Gregorc5790df2009-09-28 07:26:33 +0000980 if (Next.is(tok::annot_typename)) {
John McCall9dab4e62009-12-12 11:40:51 +0000981 DS.getTypeSpecScope() = SS;
982 ConsumeToken(); // The C++ scope.
John McCallba7bf592010-08-24 05:47:05 +0000983 if (Tok.getAnnotationValue()) {
984 ParsedType T = getTypeAnnotation(Tok);
Douglas Gregorc5790df2009-09-28 07:26:33 +0000985 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc,
John McCallba7bf592010-08-24 05:47:05 +0000986 PrevSpec, DiagID, T);
987 }
Douglas Gregorc5790df2009-09-28 07:26:33 +0000988 else
989 DS.SetTypeSpecError();
990 DS.SetRangeEnd(Tok.getAnnotationEndLoc());
991 ConsumeToken(); // The typename
992 }
993
Douglas Gregor167fa622009-03-25 15:40:00 +0000994 if (Next.isNot(tok::identifier))
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +0000995 goto DoneWithDeclSpec;
996
Douglas Gregor9de54ea2010-01-13 17:31:36 +0000997 // If we're in a context where the identifier could be a class name,
998 // check whether this is a constructor declaration.
John McCall84821e72010-04-13 06:39:49 +0000999 if ((DSContext == DSC_top_level ||
1000 (DSContext == DSC_class && DS.isFriendSpecified())) &&
Douglas Gregor0be31a22010-07-02 17:43:08 +00001001 Actions.isCurrentClassName(*Next.getIdentifierInfo(), getCurScope(),
Douglas Gregor9de54ea2010-01-13 17:31:36 +00001002 &SS)) {
1003 if (isConstructorDeclarator())
1004 goto DoneWithDeclSpec;
1005
1006 // As noted in C++ [class.qual]p2 (cited above), when the name
1007 // of the class is qualified in a context where it could name
1008 // a constructor, its a constructor name. However, we've
1009 // looked at the declarator, and the user probably meant this
1010 // to be a type. Complain that it isn't supposed to be treated
1011 // as a type, then proceed to parse it as a type.
1012 Diag(Next.getLocation(), diag::err_out_of_line_type_names_constructor)
1013 << Next.getIdentifierInfo();
1014 }
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +00001015
John McCallba7bf592010-08-24 05:47:05 +00001016 ParsedType TypeRep = Actions.getTypeName(*Next.getIdentifierInfo(),
1017 Next.getLocation(),
1018 getCurScope(), &SS);
Douglas Gregor8bf42052009-02-09 18:46:07 +00001019
Chris Lattnerb4a8fe82009-04-14 22:17:06 +00001020 // If the referenced identifier is not a type, then this declspec is
1021 // erroneous: We already checked about that it has no type specifier, and
1022 // C++ doesn't have implicit int. Diagnose it as a typo w.r.t. to the
Mike Stump11289f42009-09-09 15:08:12 +00001023 // typename.
Chris Lattnerb4a8fe82009-04-14 22:17:06 +00001024 if (TypeRep == 0) {
1025 ConsumeToken(); // Eat the scope spec so the identifier is current.
Douglas Gregor1b57ff32009-05-12 23:25:50 +00001026 if (ParseImplicitInt(DS, &SS, TemplateInfo, AS)) continue;
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +00001027 goto DoneWithDeclSpec;
Chris Lattnerb4a8fe82009-04-14 22:17:06 +00001028 }
Mike Stump11289f42009-09-09 15:08:12 +00001029
John McCall9dab4e62009-12-12 11:40:51 +00001030 DS.getTypeSpecScope() = SS;
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +00001031 ConsumeToken(); // The C++ scope.
1032
Douglas Gregor9817f4a2009-02-09 15:09:02 +00001033 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
John McCall49bfce42009-08-03 20:12:06 +00001034 DiagID, TypeRep);
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +00001035 if (isInvalid)
1036 break;
Mike Stump11289f42009-09-09 15:08:12 +00001037
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +00001038 DS.SetRangeEnd(Tok.getLocation());
1039 ConsumeToken(); // The typename.
1040
1041 continue;
1042 }
Mike Stump11289f42009-09-09 15:08:12 +00001043
Chris Lattnere387d9e2009-01-21 19:48:37 +00001044 case tok::annot_typename: {
John McCallba7bf592010-08-24 05:47:05 +00001045 if (Tok.getAnnotationValue()) {
1046 ParsedType T = getTypeAnnotation(Tok);
Douglas Gregorfe3d7d02009-04-01 21:51:26 +00001047 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
John McCallba7bf592010-08-24 05:47:05 +00001048 DiagID, T);
1049 } else
Douglas Gregorfe3d7d02009-04-01 21:51:26 +00001050 DS.SetTypeSpecError();
Chris Lattner005fc1b2010-04-05 18:18:31 +00001051
1052 if (isInvalid)
1053 break;
1054
Chris Lattnere387d9e2009-01-21 19:48:37 +00001055 DS.SetRangeEnd(Tok.getAnnotationEndLoc());
1056 ConsumeToken(); // The typename
Mike Stump11289f42009-09-09 15:08:12 +00001057
Chris Lattnere387d9e2009-01-21 19:48:37 +00001058 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
1059 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
1060 // Objective-C interface. If we don't have Objective-C or a '<', this is
1061 // just a normal reference to a typedef name.
1062 if (!Tok.is(tok::less) || !getLang().ObjC1)
1063 continue;
Mike Stump11289f42009-09-09 15:08:12 +00001064
Argyrios Kyrtzidisfc1f9e42009-09-29 19:41:44 +00001065 SourceLocation LAngleLoc, EndProtoLoc;
John McCall48871652010-08-21 09:40:31 +00001066 llvm::SmallVector<Decl *, 8> ProtocolDecl;
Argyrios Kyrtzidisfc1f9e42009-09-29 19:41:44 +00001067 llvm::SmallVector<SourceLocation, 8> ProtocolLocs;
1068 ParseObjCProtocolReferences(ProtocolDecl, ProtocolLocs, false,
1069 LAngleLoc, EndProtoLoc);
1070 DS.setProtocolQualifiers(ProtocolDecl.data(), ProtocolDecl.size(),
1071 ProtocolLocs.data(), LAngleLoc);
Mike Stump11289f42009-09-09 15:08:12 +00001072
Chris Lattnere387d9e2009-01-21 19:48:37 +00001073 DS.SetRangeEnd(EndProtoLoc);
1074 continue;
1075 }
Mike Stump11289f42009-09-09 15:08:12 +00001076
Chris Lattner16fac4f2008-07-26 01:18:38 +00001077 // typedef-name
1078 case tok::identifier: {
Chris Lattnerbd31aa32009-01-05 00:07:25 +00001079 // In C++, check to see if this is a scope specifier like foo::bar::, if
1080 // so handle it as such. This is important for ctor parsing.
John McCall1f476a12010-02-26 08:45:28 +00001081 if (getLang().CPlusPlus) {
1082 if (TryAnnotateCXXScopeToken(true)) {
1083 if (!DS.hasTypeSpecifier())
1084 DS.SetTypeSpecError();
1085 goto DoneWithDeclSpec;
1086 }
1087 if (!Tok.is(tok::identifier))
1088 continue;
1089 }
Mike Stump11289f42009-09-09 15:08:12 +00001090
Chris Lattner16fac4f2008-07-26 01:18:38 +00001091 // This identifier can only be a typedef name if we haven't already seen
1092 // a type-specifier. Without this check we misparse:
1093 // typedef int X; struct Y { short X; }; as 'short int'.
1094 if (DS.hasTypeSpecifier())
1095 goto DoneWithDeclSpec;
Mike Stump11289f42009-09-09 15:08:12 +00001096
John Thompson22334602010-02-05 00:12:22 +00001097 // Check for need to substitute AltiVec keyword tokens.
1098 if (TryAltiVecToken(DS, Loc, PrevSpec, DiagID, isInvalid))
1099 break;
1100
Chris Lattner16fac4f2008-07-26 01:18:38 +00001101 // It has to be available as a typedef too!
John McCallba7bf592010-08-24 05:47:05 +00001102 ParsedType TypeRep =
1103 Actions.getTypeName(*Tok.getIdentifierInfo(),
1104 Tok.getLocation(), getCurScope());
Douglas Gregor8bf42052009-02-09 18:46:07 +00001105
Chris Lattner6cc055a2009-04-12 20:42:31 +00001106 // If this is not a typedef name, don't parse it as part of the declspec,
1107 // it must be an implicit int or an error.
John McCallba7bf592010-08-24 05:47:05 +00001108 if (!TypeRep) {
Douglas Gregor1b57ff32009-05-12 23:25:50 +00001109 if (ParseImplicitInt(DS, 0, TemplateInfo, AS)) continue;
Chris Lattner16fac4f2008-07-26 01:18:38 +00001110 goto DoneWithDeclSpec;
Chris Lattner6cc055a2009-04-12 20:42:31 +00001111 }
Douglas Gregor8bf42052009-02-09 18:46:07 +00001112
Douglas Gregor9de54ea2010-01-13 17:31:36 +00001113 // If we're in a context where the identifier could be a class name,
1114 // check whether this is a constructor declaration.
1115 if (getLang().CPlusPlus && DSContext == DSC_class &&
Douglas Gregor0be31a22010-07-02 17:43:08 +00001116 Actions.isCurrentClassName(*Tok.getIdentifierInfo(), getCurScope()) &&
Douglas Gregor9de54ea2010-01-13 17:31:36 +00001117 isConstructorDeclarator())
Douglas Gregor61956c42008-10-31 09:07:45 +00001118 goto DoneWithDeclSpec;
1119
Douglas Gregor9817f4a2009-02-09 15:09:02 +00001120 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
John McCall49bfce42009-08-03 20:12:06 +00001121 DiagID, TypeRep);
Chris Lattner16fac4f2008-07-26 01:18:38 +00001122 if (isInvalid)
1123 break;
Mike Stump11289f42009-09-09 15:08:12 +00001124
Chris Lattner16fac4f2008-07-26 01:18:38 +00001125 DS.SetRangeEnd(Tok.getLocation());
1126 ConsumeToken(); // The identifier
1127
1128 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
1129 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
1130 // Objective-C interface. If we don't have Objective-C or a '<', this is
1131 // just a normal reference to a typedef name.
1132 if (!Tok.is(tok::less) || !getLang().ObjC1)
1133 continue;
Mike Stump11289f42009-09-09 15:08:12 +00001134
Argyrios Kyrtzidisfc1f9e42009-09-29 19:41:44 +00001135 SourceLocation LAngleLoc, EndProtoLoc;
John McCall48871652010-08-21 09:40:31 +00001136 llvm::SmallVector<Decl *, 8> ProtocolDecl;
Argyrios Kyrtzidisfc1f9e42009-09-29 19:41:44 +00001137 llvm::SmallVector<SourceLocation, 8> ProtocolLocs;
1138 ParseObjCProtocolReferences(ProtocolDecl, ProtocolLocs, false,
1139 LAngleLoc, EndProtoLoc);
1140 DS.setProtocolQualifiers(ProtocolDecl.data(), ProtocolDecl.size(),
1141 ProtocolLocs.data(), LAngleLoc);
Mike Stump11289f42009-09-09 15:08:12 +00001142
Chris Lattner16fac4f2008-07-26 01:18:38 +00001143 DS.SetRangeEnd(EndProtoLoc);
1144
Steve Naroffcd5e7822008-09-22 10:28:57 +00001145 // Need to support trailing type qualifiers (e.g. "id<p> const").
1146 // If a type specifier follows, it will be diagnosed elsewhere.
1147 continue;
Chris Lattner16fac4f2008-07-26 01:18:38 +00001148 }
Douglas Gregor7f741122009-02-25 19:37:18 +00001149
1150 // type-name
1151 case tok::annot_template_id: {
Mike Stump11289f42009-09-09 15:08:12 +00001152 TemplateIdAnnotation *TemplateId
Douglas Gregor7f741122009-02-25 19:37:18 +00001153 = static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue());
Douglas Gregorb67535d2009-03-31 00:43:58 +00001154 if (TemplateId->Kind != TNK_Type_template) {
Douglas Gregor7f741122009-02-25 19:37:18 +00001155 // This template-id does not refer to a type name, so we're
1156 // done with the type-specifiers.
1157 goto DoneWithDeclSpec;
1158 }
1159
Douglas Gregor9de54ea2010-01-13 17:31:36 +00001160 // If we're in a context where the template-id could be a
1161 // constructor name or specialization, check whether this is a
1162 // constructor declaration.
1163 if (getLang().CPlusPlus && DSContext == DSC_class &&
Douglas Gregor0be31a22010-07-02 17:43:08 +00001164 Actions.isCurrentClassName(*TemplateId->Name, getCurScope()) &&
Douglas Gregor9de54ea2010-01-13 17:31:36 +00001165 isConstructorDeclarator())
1166 goto DoneWithDeclSpec;
1167
Douglas Gregor7f741122009-02-25 19:37:18 +00001168 // Turn the template-id annotation token into a type annotation
1169 // token, then try again to parse it as a type-specifier.
Douglas Gregorfe3d7d02009-04-01 21:51:26 +00001170 AnnotateTemplateIdTokenAsType();
Douglas Gregor7f741122009-02-25 19:37:18 +00001171 continue;
1172 }
1173
Chris Lattnere37e2332006-08-15 04:50:22 +00001174 // GNU attributes support.
1175 case tok::kw___attribute:
Alexis Hunt96d5c762009-11-21 08:43:09 +00001176 DS.AddAttributes(ParseGNUAttributes());
Chris Lattnerb95cca02006-10-17 03:01:08 +00001177 continue;
Steve Naroff3a9b7e02008-12-24 20:59:21 +00001178
1179 // Microsoft declspec support.
1180 case tok::kw___declspec:
Eli Friedman06de2b52009-06-08 07:21:15 +00001181 DS.AddAttributes(ParseMicrosoftDeclSpec());
Steve Naroff3a9b7e02008-12-24 20:59:21 +00001182 continue;
Mike Stump11289f42009-09-09 15:08:12 +00001183
Steve Naroff44ac7772008-12-25 14:16:32 +00001184 // Microsoft single token adornments.
Steve Narofff9c29d42008-12-25 14:41:26 +00001185 case tok::kw___forceinline:
Eli Friedman53339e02009-06-08 23:27:34 +00001186 // FIXME: Add handling here!
1187 break;
1188
1189 case tok::kw___ptr64:
Steve Narofff9c29d42008-12-25 14:41:26 +00001190 case tok::kw___w64:
Steve Naroff44ac7772008-12-25 14:16:32 +00001191 case tok::kw___cdecl:
1192 case tok::kw___stdcall:
1193 case tok::kw___fastcall:
Douglas Gregora941dca2010-05-18 16:57:00 +00001194 case tok::kw___thiscall:
Eli Friedman53339e02009-06-08 23:27:34 +00001195 DS.AddAttributes(ParseMicrosoftTypeAttributes());
1196 continue;
1197
Chris Lattnerf63f89a2006-08-05 03:28:50 +00001198 // storage-class-specifier
1199 case tok::kw_typedef:
John McCall49bfce42009-08-03 20:12:06 +00001200 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_typedef, Loc, PrevSpec,
1201 DiagID);
Chris Lattnerf63f89a2006-08-05 03:28:50 +00001202 break;
1203 case tok::kw_extern:
Chris Lattner353f5742006-11-28 04:50:12 +00001204 if (DS.isThreadSpecified())
Chris Lattner6d29c102008-11-18 07:48:38 +00001205 Diag(Tok, diag::ext_thread_before) << "extern";
John McCall49bfce42009-08-03 20:12:06 +00001206 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_extern, Loc, PrevSpec,
1207 DiagID);
Chris Lattnerf63f89a2006-08-05 03:28:50 +00001208 break;
Steve Naroff2050b0d2007-12-18 00:16:02 +00001209 case tok::kw___private_extern__:
Chris Lattner371ed4e2008-04-06 06:57:35 +00001210 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_private_extern, Loc,
John McCall49bfce42009-08-03 20:12:06 +00001211 PrevSpec, DiagID);
Steve Naroff2050b0d2007-12-18 00:16:02 +00001212 break;
Chris Lattnerf63f89a2006-08-05 03:28:50 +00001213 case tok::kw_static:
Chris Lattner353f5742006-11-28 04:50:12 +00001214 if (DS.isThreadSpecified())
Chris Lattner6d29c102008-11-18 07:48:38 +00001215 Diag(Tok, diag::ext_thread_before) << "static";
John McCall49bfce42009-08-03 20:12:06 +00001216 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_static, Loc, PrevSpec,
1217 DiagID);
Chris Lattnerf63f89a2006-08-05 03:28:50 +00001218 break;
1219 case tok::kw_auto:
Anders Carlsson082acde2009-06-26 18:41:36 +00001220 if (getLang().CPlusPlus0x)
John McCall49bfce42009-08-03 20:12:06 +00001221 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto, Loc, PrevSpec,
1222 DiagID);
Anders Carlsson082acde2009-06-26 18:41:36 +00001223 else
John McCall49bfce42009-08-03 20:12:06 +00001224 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_auto, Loc, PrevSpec,
1225 DiagID);
Chris Lattnerf63f89a2006-08-05 03:28:50 +00001226 break;
1227 case tok::kw_register:
John McCall49bfce42009-08-03 20:12:06 +00001228 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_register, Loc, PrevSpec,
1229 DiagID);
Chris Lattnerf63f89a2006-08-05 03:28:50 +00001230 break;
Sebastian Redlccdfaba2008-11-14 23:42:31 +00001231 case tok::kw_mutable:
John McCall49bfce42009-08-03 20:12:06 +00001232 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_mutable, Loc, PrevSpec,
1233 DiagID);
Sebastian Redlccdfaba2008-11-14 23:42:31 +00001234 break;
Chris Lattnerf63f89a2006-08-05 03:28:50 +00001235 case tok::kw___thread:
John McCall49bfce42009-08-03 20:12:06 +00001236 isInvalid = DS.SetStorageClassSpecThread(Loc, PrevSpec, DiagID);
Chris Lattnerf63f89a2006-08-05 03:28:50 +00001237 break;
Mike Stump11289f42009-09-09 15:08:12 +00001238
Chris Lattnerb9093cd2006-08-04 04:39:53 +00001239 // function-specifier
1240 case tok::kw_inline:
John McCall49bfce42009-08-03 20:12:06 +00001241 isInvalid = DS.SetFunctionSpecInline(Loc, PrevSpec, DiagID);
Chris Lattnerb9093cd2006-08-04 04:39:53 +00001242 break;
Douglas Gregor61956c42008-10-31 09:07:45 +00001243 case tok::kw_virtual:
John McCall49bfce42009-08-03 20:12:06 +00001244 isInvalid = DS.SetFunctionSpecVirtual(Loc, PrevSpec, DiagID);
Douglas Gregor61956c42008-10-31 09:07:45 +00001245 break;
Douglas Gregor61956c42008-10-31 09:07:45 +00001246 case tok::kw_explicit:
John McCall49bfce42009-08-03 20:12:06 +00001247 isInvalid = DS.SetFunctionSpecExplicit(Loc, PrevSpec, DiagID);
Douglas Gregor61956c42008-10-31 09:07:45 +00001248 break;
Chris Lattnere387d9e2009-01-21 19:48:37 +00001249
Anders Carlssoncd8db412009-05-06 04:46:28 +00001250 // friend
1251 case tok::kw_friend:
John McCall07e91c02009-08-06 02:15:43 +00001252 if (DSContext == DSC_class)
1253 isInvalid = DS.SetFriendSpec(Loc, PrevSpec, DiagID);
1254 else {
1255 PrevSpec = ""; // not actually used by the diagnostic
1256 DiagID = diag::err_friend_invalid_in_context;
1257 isInvalid = true;
1258 }
Anders Carlssoncd8db412009-05-06 04:46:28 +00001259 break;
Mike Stump11289f42009-09-09 15:08:12 +00001260
Sebastian Redl39c2a8b2009-11-05 15:47:02 +00001261 // constexpr
1262 case tok::kw_constexpr:
1263 isInvalid = DS.SetConstexprSpec(Loc, PrevSpec, DiagID);
1264 break;
1265
Chris Lattnere387d9e2009-01-21 19:48:37 +00001266 // type-specifier
1267 case tok::kw_short:
John McCall49bfce42009-08-03 20:12:06 +00001268 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec,
1269 DiagID);
Chris Lattnere387d9e2009-01-21 19:48:37 +00001270 break;
1271 case tok::kw_long:
1272 if (DS.getTypeSpecWidth() != DeclSpec::TSW_long)
John McCall49bfce42009-08-03 20:12:06 +00001273 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec,
1274 DiagID);
Chris Lattnere387d9e2009-01-21 19:48:37 +00001275 else
John McCall49bfce42009-08-03 20:12:06 +00001276 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec,
1277 DiagID);
Chris Lattnere387d9e2009-01-21 19:48:37 +00001278 break;
1279 case tok::kw_signed:
John McCall49bfce42009-08-03 20:12:06 +00001280 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec,
1281 DiagID);
Chris Lattnere387d9e2009-01-21 19:48:37 +00001282 break;
1283 case tok::kw_unsigned:
John McCall49bfce42009-08-03 20:12:06 +00001284 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec,
1285 DiagID);
Chris Lattnere387d9e2009-01-21 19:48:37 +00001286 break;
1287 case tok::kw__Complex:
John McCall49bfce42009-08-03 20:12:06 +00001288 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec,
1289 DiagID);
Chris Lattnere387d9e2009-01-21 19:48:37 +00001290 break;
1291 case tok::kw__Imaginary:
John McCall49bfce42009-08-03 20:12:06 +00001292 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec,
1293 DiagID);
Chris Lattnere387d9e2009-01-21 19:48:37 +00001294 break;
1295 case tok::kw_void:
John McCall49bfce42009-08-03 20:12:06 +00001296 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec,
1297 DiagID);
Chris Lattnere387d9e2009-01-21 19:48:37 +00001298 break;
1299 case tok::kw_char:
John McCall49bfce42009-08-03 20:12:06 +00001300 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec,
1301 DiagID);
Chris Lattnere387d9e2009-01-21 19:48:37 +00001302 break;
1303 case tok::kw_int:
John McCall49bfce42009-08-03 20:12:06 +00001304 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec,
1305 DiagID);
Chris Lattnere387d9e2009-01-21 19:48:37 +00001306 break;
1307 case tok::kw_float:
John McCall49bfce42009-08-03 20:12:06 +00001308 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec,
1309 DiagID);
Chris Lattnere387d9e2009-01-21 19:48:37 +00001310 break;
1311 case tok::kw_double:
John McCall49bfce42009-08-03 20:12:06 +00001312 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec,
1313 DiagID);
Chris Lattnere387d9e2009-01-21 19:48:37 +00001314 break;
1315 case tok::kw_wchar_t:
John McCall49bfce42009-08-03 20:12:06 +00001316 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec,
1317 DiagID);
Chris Lattnere387d9e2009-01-21 19:48:37 +00001318 break;
Alisdair Mereditha9ad47d2009-07-14 06:30:34 +00001319 case tok::kw_char16_t:
John McCall49bfce42009-08-03 20:12:06 +00001320 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec,
1321 DiagID);
Alisdair Mereditha9ad47d2009-07-14 06:30:34 +00001322 break;
1323 case tok::kw_char32_t:
John McCall49bfce42009-08-03 20:12:06 +00001324 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec,
1325 DiagID);
Alisdair Mereditha9ad47d2009-07-14 06:30:34 +00001326 break;
Chris Lattnere387d9e2009-01-21 19:48:37 +00001327 case tok::kw_bool:
1328 case tok::kw__Bool:
John McCall49bfce42009-08-03 20:12:06 +00001329 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec,
1330 DiagID);
Chris Lattnere387d9e2009-01-21 19:48:37 +00001331 break;
1332 case tok::kw__Decimal32:
John McCall49bfce42009-08-03 20:12:06 +00001333 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec,
1334 DiagID);
Chris Lattnere387d9e2009-01-21 19:48:37 +00001335 break;
1336 case tok::kw__Decimal64:
John McCall49bfce42009-08-03 20:12:06 +00001337 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec,
1338 DiagID);
Chris Lattnere387d9e2009-01-21 19:48:37 +00001339 break;
1340 case tok::kw__Decimal128:
John McCall49bfce42009-08-03 20:12:06 +00001341 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec,
1342 DiagID);
Chris Lattnere387d9e2009-01-21 19:48:37 +00001343 break;
John Thompson22334602010-02-05 00:12:22 +00001344 case tok::kw___vector:
1345 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID);
1346 break;
1347 case tok::kw___pixel:
1348 isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID);
1349 break;
Chris Lattnere387d9e2009-01-21 19:48:37 +00001350
1351 // class-specifier:
1352 case tok::kw_class:
1353 case tok::kw_struct:
Chris Lattnerffaa0e62009-04-12 21:49:30 +00001354 case tok::kw_union: {
1355 tok::TokenKind Kind = Tok.getKind();
1356 ConsumeToken();
Douglas Gregor1b57ff32009-05-12 23:25:50 +00001357 ParseClassSpecifier(Kind, Loc, DS, TemplateInfo, AS);
Chris Lattnere387d9e2009-01-21 19:48:37 +00001358 continue;
Chris Lattnerffaa0e62009-04-12 21:49:30 +00001359 }
Chris Lattnere387d9e2009-01-21 19:48:37 +00001360
1361 // enum-specifier:
1362 case tok::kw_enum:
Chris Lattnerffaa0e62009-04-12 21:49:30 +00001363 ConsumeToken();
Douglas Gregordc70c3a2010-03-02 17:53:14 +00001364 ParseEnumSpecifier(Loc, DS, TemplateInfo, AS);
Chris Lattnere387d9e2009-01-21 19:48:37 +00001365 continue;
1366
1367 // cv-qualifier:
1368 case tok::kw_const:
John McCall49bfce42009-08-03 20:12:06 +00001369 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const, Loc, PrevSpec, DiagID,
1370 getLang());
Chris Lattnere387d9e2009-01-21 19:48:37 +00001371 break;
1372 case tok::kw_volatile:
John McCall49bfce42009-08-03 20:12:06 +00001373 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID,
1374 getLang());
Chris Lattnere387d9e2009-01-21 19:48:37 +00001375 break;
1376 case tok::kw_restrict:
John McCall49bfce42009-08-03 20:12:06 +00001377 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID,
1378 getLang());
Chris Lattnere387d9e2009-01-21 19:48:37 +00001379 break;
1380
Douglas Gregor333489b2009-03-27 23:10:48 +00001381 // C++ typename-specifier:
1382 case tok::kw_typename:
John McCall1f476a12010-02-26 08:45:28 +00001383 if (TryAnnotateTypeOrScopeToken()) {
1384 DS.SetTypeSpecError();
1385 goto DoneWithDeclSpec;
1386 }
1387 if (!Tok.is(tok::kw_typename))
Douglas Gregor333489b2009-03-27 23:10:48 +00001388 continue;
1389 break;
1390
Chris Lattnere387d9e2009-01-21 19:48:37 +00001391 // GNU typeof support.
1392 case tok::kw_typeof:
1393 ParseTypeofSpecifier(DS);
1394 continue;
1395
Anders Carlsson74948d02009-06-24 17:47:40 +00001396 case tok::kw_decltype:
1397 ParseDecltypeSpecifier(DS);
1398 continue;
1399
Steve Naroffcfdf6162008-06-05 00:02:44 +00001400 case tok::less:
Chris Lattner16fac4f2008-07-26 01:18:38 +00001401 // GCC ObjC supports types like "<SomeProtocol>" as a synonym for
Chris Lattner0974b232008-07-26 00:20:22 +00001402 // "id<SomeProtocol>". This is hopelessly old fashioned and dangerous,
1403 // but we support it.
Chris Lattner16fac4f2008-07-26 01:18:38 +00001404 if (DS.hasTypeSpecifier() || !getLang().ObjC1)
Chris Lattner0974b232008-07-26 00:20:22 +00001405 goto DoneWithDeclSpec;
Mike Stump11289f42009-09-09 15:08:12 +00001406
Chris Lattner0974b232008-07-26 00:20:22 +00001407 {
Argyrios Kyrtzidisfc1f9e42009-09-29 19:41:44 +00001408 SourceLocation LAngleLoc, EndProtoLoc;
John McCall48871652010-08-21 09:40:31 +00001409 llvm::SmallVector<Decl *, 8> ProtocolDecl;
Argyrios Kyrtzidisfc1f9e42009-09-29 19:41:44 +00001410 llvm::SmallVector<SourceLocation, 8> ProtocolLocs;
1411 ParseObjCProtocolReferences(ProtocolDecl, ProtocolLocs, false,
1412 LAngleLoc, EndProtoLoc);
1413 DS.setProtocolQualifiers(ProtocolDecl.data(), ProtocolDecl.size(),
1414 ProtocolLocs.data(), LAngleLoc);
Chris Lattner16fac4f2008-07-26 01:18:38 +00001415 DS.SetRangeEnd(EndProtoLoc);
1416
Chris Lattner6d29c102008-11-18 07:48:38 +00001417 Diag(Loc, diag::warn_objc_protocol_qualifier_missing_id)
Douglas Gregora771f462010-03-31 17:46:05 +00001418 << FixItHint::CreateInsertion(Loc, "id")
Chris Lattner6d29c102008-11-18 07:48:38 +00001419 << SourceRange(Loc, EndProtoLoc);
Steve Naroffcd5e7822008-09-22 10:28:57 +00001420 // Need to support trailing type qualifiers (e.g. "id<p> const").
1421 // If a type specifier follows, it will be diagnosed elsewhere.
1422 continue;
Steve Naroffcfdf6162008-06-05 00:02:44 +00001423 }
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00001424 }
John McCall49bfce42009-08-03 20:12:06 +00001425 // If the specifier wasn't legal, issue a diagnostic.
Chris Lattnerb9093cd2006-08-04 04:39:53 +00001426 if (isInvalid) {
1427 assert(PrevSpec && "Method did not return previous specifier!");
John McCall49bfce42009-08-03 20:12:06 +00001428 assert(DiagID);
Douglas Gregora05f5ab2010-08-23 14:34:43 +00001429
1430 if (DiagID == diag::ext_duplicate_declspec)
1431 Diag(Tok, DiagID)
1432 << PrevSpec << FixItHint::CreateRemoval(Tok.getLocation());
1433 else
1434 Diag(Tok, DiagID) << PrevSpec;
Chris Lattnerb9093cd2006-08-04 04:39:53 +00001435 }
Chris Lattner2e232092008-03-13 06:29:04 +00001436 DS.SetRangeEnd(Tok.getLocation());
Chris Lattnerb9093cd2006-08-04 04:39:53 +00001437 ConsumeToken();
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00001438 }
1439}
Douglas Gregoreb31f392008-12-01 23:54:00 +00001440
Chris Lattnera448d752009-01-06 06:59:53 +00001441/// ParseOptionalTypeSpecifier - Try to parse a single type-specifier. We
Douglas Gregor450c75a2008-11-07 15:42:26 +00001442/// primarily follow the C++ grammar with additions for C99 and GNU,
1443/// which together subsume the C grammar. Note that the C++
1444/// type-specifier also includes the C type-qualifier (for const,
1445/// volatile, and C99 restrict). Returns true if a type-specifier was
1446/// found (and parsed), false otherwise.
1447///
1448/// type-specifier: [C++ 7.1.5]
1449/// simple-type-specifier
1450/// class-specifier
1451/// enum-specifier
1452/// elaborated-type-specifier [TODO]
1453/// cv-qualifier
1454///
1455/// cv-qualifier: [C++ 7.1.5.1]
1456/// 'const'
1457/// 'volatile'
1458/// [C99] 'restrict'
1459///
1460/// simple-type-specifier: [ C++ 7.1.5.2]
1461/// '::'[opt] nested-name-specifier[opt] type-name [TODO]
1462/// '::'[opt] nested-name-specifier 'template' template-id [TODO]
1463/// 'char'
1464/// 'wchar_t'
1465/// 'bool'
1466/// 'short'
1467/// 'int'
1468/// 'long'
1469/// 'signed'
1470/// 'unsigned'
1471/// 'float'
1472/// 'double'
1473/// 'void'
1474/// [C99] '_Bool'
1475/// [C99] '_Complex'
1476/// [C99] '_Imaginary' // Removed in TC2?
1477/// [GNU] '_Decimal32'
1478/// [GNU] '_Decimal64'
1479/// [GNU] '_Decimal128'
1480/// [GNU] typeof-specifier
1481/// [OBJC] class-name objc-protocol-refs[opt] [TODO]
1482/// [OBJC] typedef-name objc-protocol-refs[opt] [TODO]
Anders Carlsson74948d02009-06-24 17:47:40 +00001483/// [C++0x] 'decltype' ( expression )
John Thompson22334602010-02-05 00:12:22 +00001484/// [AltiVec] '__vector'
John McCall49bfce42009-08-03 20:12:06 +00001485bool Parser::ParseOptionalTypeSpecifier(DeclSpec &DS, bool& isInvalid,
Chris Lattnera448d752009-01-06 06:59:53 +00001486 const char *&PrevSpec,
John McCall49bfce42009-08-03 20:12:06 +00001487 unsigned &DiagID,
Sebastian Redl2b372722010-02-03 21:21:43 +00001488 const ParsedTemplateInfo &TemplateInfo,
1489 bool SuppressDeclarations) {
Douglas Gregor450c75a2008-11-07 15:42:26 +00001490 SourceLocation Loc = Tok.getLocation();
1491
1492 switch (Tok.getKind()) {
Chris Lattner020bab92009-01-04 23:41:41 +00001493 case tok::identifier: // foo::bar
Douglas Gregorb8eaf292010-04-15 23:40:53 +00001494 // If we already have a type specifier, this identifier is not a type.
1495 if (DS.getTypeSpecType() != DeclSpec::TST_unspecified ||
1496 DS.getTypeSpecWidth() != DeclSpec::TSW_unspecified ||
1497 DS.getTypeSpecSign() != DeclSpec::TSS_unspecified)
1498 return false;
John Thompson22334602010-02-05 00:12:22 +00001499 // Check for need to substitute AltiVec keyword tokens.
1500 if (TryAltiVecToken(DS, Loc, PrevSpec, DiagID, isInvalid))
1501 break;
1502 // Fall through.
Douglas Gregor333489b2009-03-27 23:10:48 +00001503 case tok::kw_typename: // typename foo::bar
Chris Lattner020bab92009-01-04 23:41:41 +00001504 // Annotate typenames and C++ scope specifiers. If we get one, just
1505 // recurse to handle whatever we get.
1506 if (TryAnnotateTypeOrScopeToken())
John McCall1f476a12010-02-26 08:45:28 +00001507 return true;
1508 if (Tok.is(tok::identifier))
1509 return false;
1510 return ParseOptionalTypeSpecifier(DS, isInvalid, PrevSpec, DiagID,
1511 TemplateInfo, SuppressDeclarations);
Chris Lattner020bab92009-01-04 23:41:41 +00001512 case tok::coloncolon: // ::foo::bar
1513 if (NextToken().is(tok::kw_new) || // ::new
1514 NextToken().is(tok::kw_delete)) // ::delete
1515 return false;
Mike Stump11289f42009-09-09 15:08:12 +00001516
Chris Lattner020bab92009-01-04 23:41:41 +00001517 // Annotate typenames and C++ scope specifiers. If we get one, just
1518 // recurse to handle whatever we get.
1519 if (TryAnnotateTypeOrScopeToken())
John McCall1f476a12010-02-26 08:45:28 +00001520 return true;
1521 return ParseOptionalTypeSpecifier(DS, isInvalid, PrevSpec, DiagID,
1522 TemplateInfo, SuppressDeclarations);
Mike Stump11289f42009-09-09 15:08:12 +00001523
Douglas Gregor450c75a2008-11-07 15:42:26 +00001524 // simple-type-specifier:
Chris Lattnera8a3f732009-01-06 05:06:21 +00001525 case tok::annot_typename: {
John McCallba7bf592010-08-24 05:47:05 +00001526 if (ParsedType T = getTypeAnnotation(Tok)) {
Douglas Gregorfe3d7d02009-04-01 21:51:26 +00001527 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
John McCallba7bf592010-08-24 05:47:05 +00001528 DiagID, T);
1529 } else
Douglas Gregorfe3d7d02009-04-01 21:51:26 +00001530 DS.SetTypeSpecError();
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +00001531 DS.SetRangeEnd(Tok.getAnnotationEndLoc());
1532 ConsumeToken(); // The typename
Mike Stump11289f42009-09-09 15:08:12 +00001533
Douglas Gregor450c75a2008-11-07 15:42:26 +00001534 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
1535 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
1536 // Objective-C interface. If we don't have Objective-C or a '<', this is
1537 // just a normal reference to a typedef name.
1538 if (!Tok.is(tok::less) || !getLang().ObjC1)
1539 return true;
Mike Stump11289f42009-09-09 15:08:12 +00001540
Argyrios Kyrtzidisfc1f9e42009-09-29 19:41:44 +00001541 SourceLocation LAngleLoc, EndProtoLoc;
John McCall48871652010-08-21 09:40:31 +00001542 llvm::SmallVector<Decl *, 8> ProtocolDecl;
Argyrios Kyrtzidisfc1f9e42009-09-29 19:41:44 +00001543 llvm::SmallVector<SourceLocation, 8> ProtocolLocs;
1544 ParseObjCProtocolReferences(ProtocolDecl, ProtocolLocs, false,
1545 LAngleLoc, EndProtoLoc);
1546 DS.setProtocolQualifiers(ProtocolDecl.data(), ProtocolDecl.size(),
1547 ProtocolLocs.data(), LAngleLoc);
Mike Stump11289f42009-09-09 15:08:12 +00001548
Douglas Gregor450c75a2008-11-07 15:42:26 +00001549 DS.SetRangeEnd(EndProtoLoc);
1550 return true;
1551 }
1552
1553 case tok::kw_short:
John McCall49bfce42009-08-03 20:12:06 +00001554 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, DiagID);
Douglas Gregor450c75a2008-11-07 15:42:26 +00001555 break;
1556 case tok::kw_long:
1557 if (DS.getTypeSpecWidth() != DeclSpec::TSW_long)
John McCall49bfce42009-08-03 20:12:06 +00001558 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec,
1559 DiagID);
Douglas Gregor450c75a2008-11-07 15:42:26 +00001560 else
John McCall49bfce42009-08-03 20:12:06 +00001561 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec,
1562 DiagID);
Douglas Gregor450c75a2008-11-07 15:42:26 +00001563 break;
1564 case tok::kw_signed:
John McCall49bfce42009-08-03 20:12:06 +00001565 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec, DiagID);
Douglas Gregor450c75a2008-11-07 15:42:26 +00001566 break;
1567 case tok::kw_unsigned:
John McCall49bfce42009-08-03 20:12:06 +00001568 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec,
1569 DiagID);
Douglas Gregor450c75a2008-11-07 15:42:26 +00001570 break;
1571 case tok::kw__Complex:
John McCall49bfce42009-08-03 20:12:06 +00001572 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec,
1573 DiagID);
Douglas Gregor450c75a2008-11-07 15:42:26 +00001574 break;
1575 case tok::kw__Imaginary:
John McCall49bfce42009-08-03 20:12:06 +00001576 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec,
1577 DiagID);
Douglas Gregor450c75a2008-11-07 15:42:26 +00001578 break;
1579 case tok::kw_void:
John McCall49bfce42009-08-03 20:12:06 +00001580 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID);
Douglas Gregor450c75a2008-11-07 15:42:26 +00001581 break;
1582 case tok::kw_char:
John McCall49bfce42009-08-03 20:12:06 +00001583 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID);
Douglas Gregor450c75a2008-11-07 15:42:26 +00001584 break;
1585 case tok::kw_int:
John McCall49bfce42009-08-03 20:12:06 +00001586 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID);
Douglas Gregor450c75a2008-11-07 15:42:26 +00001587 break;
1588 case tok::kw_float:
John McCall49bfce42009-08-03 20:12:06 +00001589 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID);
Douglas Gregor450c75a2008-11-07 15:42:26 +00001590 break;
1591 case tok::kw_double:
John McCall49bfce42009-08-03 20:12:06 +00001592 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID);
Douglas Gregor450c75a2008-11-07 15:42:26 +00001593 break;
1594 case tok::kw_wchar_t:
John McCall49bfce42009-08-03 20:12:06 +00001595 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID);
Douglas Gregor450c75a2008-11-07 15:42:26 +00001596 break;
Alisdair Mereditha9ad47d2009-07-14 06:30:34 +00001597 case tok::kw_char16_t:
John McCall49bfce42009-08-03 20:12:06 +00001598 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID);
Alisdair Mereditha9ad47d2009-07-14 06:30:34 +00001599 break;
1600 case tok::kw_char32_t:
John McCall49bfce42009-08-03 20:12:06 +00001601 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID);
Alisdair Mereditha9ad47d2009-07-14 06:30:34 +00001602 break;
Douglas Gregor450c75a2008-11-07 15:42:26 +00001603 case tok::kw_bool:
1604 case tok::kw__Bool:
John McCall49bfce42009-08-03 20:12:06 +00001605 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID);
Douglas Gregor450c75a2008-11-07 15:42:26 +00001606 break;
1607 case tok::kw__Decimal32:
John McCall49bfce42009-08-03 20:12:06 +00001608 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec,
1609 DiagID);
Douglas Gregor450c75a2008-11-07 15:42:26 +00001610 break;
1611 case tok::kw__Decimal64:
John McCall49bfce42009-08-03 20:12:06 +00001612 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec,
1613 DiagID);
Douglas Gregor450c75a2008-11-07 15:42:26 +00001614 break;
1615 case tok::kw__Decimal128:
John McCall49bfce42009-08-03 20:12:06 +00001616 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec,
1617 DiagID);
Douglas Gregor450c75a2008-11-07 15:42:26 +00001618 break;
John Thompson22334602010-02-05 00:12:22 +00001619 case tok::kw___vector:
1620 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID);
1621 break;
1622 case tok::kw___pixel:
1623 isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID);
1624 break;
1625
Douglas Gregor450c75a2008-11-07 15:42:26 +00001626 // class-specifier:
1627 case tok::kw_class:
1628 case tok::kw_struct:
Chris Lattnerffaa0e62009-04-12 21:49:30 +00001629 case tok::kw_union: {
1630 tok::TokenKind Kind = Tok.getKind();
1631 ConsumeToken();
Sebastian Redl2b372722010-02-03 21:21:43 +00001632 ParseClassSpecifier(Kind, Loc, DS, TemplateInfo, AS_none,
1633 SuppressDeclarations);
Douglas Gregor450c75a2008-11-07 15:42:26 +00001634 return true;
Chris Lattnerffaa0e62009-04-12 21:49:30 +00001635 }
Douglas Gregor450c75a2008-11-07 15:42:26 +00001636
1637 // enum-specifier:
1638 case tok::kw_enum:
Chris Lattnerffaa0e62009-04-12 21:49:30 +00001639 ConsumeToken();
Douglas Gregordc70c3a2010-03-02 17:53:14 +00001640 ParseEnumSpecifier(Loc, DS, TemplateInfo, AS_none);
Douglas Gregor450c75a2008-11-07 15:42:26 +00001641 return true;
1642
1643 // cv-qualifier:
1644 case tok::kw_const:
1645 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const , Loc, PrevSpec,
John McCall49bfce42009-08-03 20:12:06 +00001646 DiagID, getLang());
Douglas Gregor450c75a2008-11-07 15:42:26 +00001647 break;
1648 case tok::kw_volatile:
1649 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec,
John McCall49bfce42009-08-03 20:12:06 +00001650 DiagID, getLang());
Douglas Gregor450c75a2008-11-07 15:42:26 +00001651 break;
1652 case tok::kw_restrict:
1653 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec,
John McCall49bfce42009-08-03 20:12:06 +00001654 DiagID, getLang());
Douglas Gregor450c75a2008-11-07 15:42:26 +00001655 break;
1656
1657 // GNU typeof support.
1658 case tok::kw_typeof:
1659 ParseTypeofSpecifier(DS);
1660 return true;
1661
Anders Carlsson74948d02009-06-24 17:47:40 +00001662 // C++0x decltype support.
1663 case tok::kw_decltype:
1664 ParseDecltypeSpecifier(DS);
1665 return true;
Mike Stump11289f42009-09-09 15:08:12 +00001666
Anders Carlssonbae27372009-06-26 23:44:14 +00001667 // C++0x auto support.
1668 case tok::kw_auto:
1669 if (!getLang().CPlusPlus0x)
1670 return false;
1671
John McCall49bfce42009-08-03 20:12:06 +00001672 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto, Loc, PrevSpec, DiagID);
Anders Carlssonbae27372009-06-26 23:44:14 +00001673 break;
Eli Friedman53339e02009-06-08 23:27:34 +00001674 case tok::kw___ptr64:
1675 case tok::kw___w64:
Steve Naroff44ac7772008-12-25 14:16:32 +00001676 case tok::kw___cdecl:
1677 case tok::kw___stdcall:
1678 case tok::kw___fastcall:
Douglas Gregora941dca2010-05-18 16:57:00 +00001679 case tok::kw___thiscall:
Eli Friedman53339e02009-06-08 23:27:34 +00001680 DS.AddAttributes(ParseMicrosoftTypeAttributes());
Chris Lattner78ecd4f2009-01-21 19:19:26 +00001681 return true;
Steve Naroff44ac7772008-12-25 14:16:32 +00001682
Douglas Gregor450c75a2008-11-07 15:42:26 +00001683 default:
1684 // Not a type-specifier; do nothing.
1685 return false;
1686 }
1687
1688 // If the specifier combination wasn't legal, issue a diagnostic.
1689 if (isInvalid) {
1690 assert(PrevSpec && "Method did not return previous specifier!");
Chris Lattner6d29c102008-11-18 07:48:38 +00001691 // Pick between error or extwarn.
Chris Lattner6d29c102008-11-18 07:48:38 +00001692 Diag(Tok, DiagID) << PrevSpec;
Douglas Gregor450c75a2008-11-07 15:42:26 +00001693 }
1694 DS.SetRangeEnd(Tok.getLocation());
1695 ConsumeToken(); // whatever we parsed above.
1696 return true;
1697}
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00001698
Chris Lattner70ae4912007-10-29 04:42:53 +00001699/// ParseStructDeclaration - Parse a struct declaration without the terminating
1700/// semicolon.
1701///
Chris Lattner90a26b02007-01-23 04:38:16 +00001702/// struct-declaration:
Chris Lattner70ae4912007-10-29 04:42:53 +00001703/// specifier-qualifier-list struct-declarator-list
Chris Lattner736ed5d2007-06-09 05:59:07 +00001704/// [GNU] __extension__ struct-declaration
Chris Lattner70ae4912007-10-29 04:42:53 +00001705/// [GNU] specifier-qualifier-list
Chris Lattner90a26b02007-01-23 04:38:16 +00001706/// struct-declarator-list:
1707/// struct-declarator
1708/// struct-declarator-list ',' struct-declarator
1709/// [GNU] struct-declarator-list ',' attributes[opt] struct-declarator
1710/// struct-declarator:
1711/// declarator
1712/// [GNU] declarator attributes[opt]
1713/// declarator[opt] ':' constant-expression
1714/// [GNU] declarator[opt] ':' constant-expression attributes[opt]
1715///
Chris Lattnera12405b2008-04-10 06:46:29 +00001716void Parser::
John McCallcfefb6d2009-11-03 02:38:08 +00001717ParseStructDeclaration(DeclSpec &DS, FieldCallback &Fields) {
Chris Lattnerf02ef3e2008-10-20 06:45:43 +00001718 if (Tok.is(tok::kw___extension__)) {
1719 // __extension__ silences extension warnings in the subexpression.
1720 ExtensionRAIIObject O(Diags); // Use RAII to do this.
Steve Naroff97170802007-08-20 22:28:22 +00001721 ConsumeToken();
Chris Lattnerf02ef3e2008-10-20 06:45:43 +00001722 return ParseStructDeclaration(DS, Fields);
1723 }
Mike Stump11289f42009-09-09 15:08:12 +00001724
Steve Naroff97170802007-08-20 22:28:22 +00001725 // Parse the common specifier-qualifiers-list piece.
Chris Lattner32295d32008-04-10 06:15:14 +00001726 SourceLocation DSStart = Tok.getLocation();
Steve Naroff97170802007-08-20 22:28:22 +00001727 ParseSpecifierQualifierList(DS);
Mike Stump11289f42009-09-09 15:08:12 +00001728
Douglas Gregorc6f58fe2009-01-12 22:49:06 +00001729 // If there are no declarators, this is a free-standing declaration
1730 // specifier. Let the actions module cope with it.
Chris Lattner76c72282007-10-09 17:33:22 +00001731 if (Tok.is(tok::semi)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +00001732 Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none, DS);
Steve Naroff97170802007-08-20 22:28:22 +00001733 return;
1734 }
1735
1736 // Read struct-declarators until we find the semicolon.
John McCallcfefb6d2009-11-03 02:38:08 +00001737 bool FirstDeclarator = true;
Steve Naroff97170802007-08-20 22:28:22 +00001738 while (1) {
John McCall28a6aea2009-11-04 02:18:39 +00001739 ParsingDeclRAIIObject PD(*this);
John McCallcfefb6d2009-11-03 02:38:08 +00001740 FieldDeclarator DeclaratorInfo(DS);
1741
1742 // Attributes are only allowed here on successive declarators.
1743 if (!FirstDeclarator && Tok.is(tok::kw___attribute)) {
1744 SourceLocation Loc;
Alexis Hunt96d5c762009-11-21 08:43:09 +00001745 AttributeList *AttrList = ParseGNUAttributes(&Loc);
John McCallcfefb6d2009-11-03 02:38:08 +00001746 DeclaratorInfo.D.AddAttributes(AttrList, Loc);
1747 }
Mike Stump11289f42009-09-09 15:08:12 +00001748
Steve Naroff97170802007-08-20 22:28:22 +00001749 /// struct-declarator: declarator
1750 /// struct-declarator: declarator[opt] ':' constant-expression
Chris Lattner17c3b1f2009-12-10 01:59:24 +00001751 if (Tok.isNot(tok::colon)) {
1752 // Don't parse FOO:BAR as if it were a typo for FOO::BAR.
1753 ColonProtectionRAIIObject X(*this);
Chris Lattnera12405b2008-04-10 06:46:29 +00001754 ParseDeclarator(DeclaratorInfo.D);
Chris Lattner17c3b1f2009-12-10 01:59:24 +00001755 }
Mike Stump11289f42009-09-09 15:08:12 +00001756
Chris Lattner76c72282007-10-09 17:33:22 +00001757 if (Tok.is(tok::colon)) {
Steve Naroff97170802007-08-20 22:28:22 +00001758 ConsumeToken();
Sebastian Redl59b5e512008-12-11 21:36:32 +00001759 OwningExprResult Res(ParseConstantExpression());
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001760 if (Res.isInvalid())
Steve Naroff97170802007-08-20 22:28:22 +00001761 SkipUntil(tok::semi, true, true);
Chris Lattner32295d32008-04-10 06:15:14 +00001762 else
Sebastian Redld9f7b1c2008-12-10 00:02:53 +00001763 DeclaratorInfo.BitfieldSize = Res.release();
Steve Naroff97170802007-08-20 22:28:22 +00001764 }
Sebastian Redlf6591ca2009-02-09 18:23:29 +00001765
Steve Naroff97170802007-08-20 22:28:22 +00001766 // If attributes exist after the declarator, parse them.
Sebastian Redlf6591ca2009-02-09 18:23:29 +00001767 if (Tok.is(tok::kw___attribute)) {
1768 SourceLocation Loc;
Alexis Hunt96d5c762009-11-21 08:43:09 +00001769 AttributeList *AttrList = ParseGNUAttributes(&Loc);
Sebastian Redlf6591ca2009-02-09 18:23:29 +00001770 DeclaratorInfo.D.AddAttributes(AttrList, Loc);
1771 }
1772
John McCallcfefb6d2009-11-03 02:38:08 +00001773 // We're done with this declarator; invoke the callback.
John McCall48871652010-08-21 09:40:31 +00001774 Decl *D = Fields.invoke(DeclaratorInfo);
John McCall28a6aea2009-11-04 02:18:39 +00001775 PD.complete(D);
John McCallcfefb6d2009-11-03 02:38:08 +00001776
Steve Naroff97170802007-08-20 22:28:22 +00001777 // If we don't have a comma, it is either the end of the list (a ';')
1778 // or an error, bail out.
Chris Lattner76c72282007-10-09 17:33:22 +00001779 if (Tok.isNot(tok::comma))
Chris Lattner70ae4912007-10-29 04:42:53 +00001780 return;
Sebastian Redlf6591ca2009-02-09 18:23:29 +00001781
Steve Naroff97170802007-08-20 22:28:22 +00001782 // Consume the comma.
1783 ConsumeToken();
Sebastian Redlf6591ca2009-02-09 18:23:29 +00001784
John McCallcfefb6d2009-11-03 02:38:08 +00001785 FirstDeclarator = false;
Steve Naroff97170802007-08-20 22:28:22 +00001786 }
Steve Naroff97170802007-08-20 22:28:22 +00001787}
1788
1789/// ParseStructUnionBody
1790/// struct-contents:
1791/// struct-declaration-list
1792/// [EXT] empty
1793/// [GNU] "struct-declaration-list" without terminatoring ';'
1794/// struct-declaration-list:
1795/// struct-declaration
1796/// struct-declaration-list struct-declaration
Chris Lattner535b8302008-06-21 19:39:06 +00001797/// [OBC] '@' 'defs' '(' class-name ')'
Steve Naroff97170802007-08-20 22:28:22 +00001798///
Chris Lattner1300fb92007-01-23 23:42:53 +00001799void Parser::ParseStructUnionBody(SourceLocation RecordLoc,
John McCall48871652010-08-21 09:40:31 +00001800 unsigned TagType, Decl *TagDecl) {
Chris Lattnereae6cb62009-03-05 08:00:35 +00001801 PrettyStackTraceActionsDecl CrashInfo(TagDecl, RecordLoc, Actions,
1802 PP.getSourceManager(),
1803 "parsing struct/union body");
Mike Stump11289f42009-09-09 15:08:12 +00001804
Chris Lattner90a26b02007-01-23 04:38:16 +00001805 SourceLocation LBraceLoc = ConsumeBrace();
Mike Stump11289f42009-09-09 15:08:12 +00001806
Douglas Gregor658b9552009-01-09 22:42:13 +00001807 ParseScope StructScope(this, Scope::ClassScope|Scope::DeclScope);
Douglas Gregor0be31a22010-07-02 17:43:08 +00001808 Actions.ActOnTagStartDefinition(getCurScope(), TagDecl);
Douglas Gregor82ac25e2009-01-08 20:45:30 +00001809
Chris Lattner7b9ace62007-01-23 20:11:08 +00001810 // Empty structs are an extension in C (C99 6.7.2.1p7), but are allowed in
1811 // C++.
Douglas Gregor556877c2008-04-13 21:30:24 +00001812 if (Tok.is(tok::r_brace) && !getLang().CPlusPlus)
Douglas Gregorda2955e2010-07-29 14:29:34 +00001813 Diag(Tok, diag::ext_empty_struct_union)
1814 << (TagType == TST_union);
Chris Lattner7b9ace62007-01-23 20:11:08 +00001815
John McCall48871652010-08-21 09:40:31 +00001816 llvm::SmallVector<Decl *, 32> FieldDecls;
Chris Lattnera12405b2008-04-10 06:46:29 +00001817
Chris Lattner7b9ace62007-01-23 20:11:08 +00001818 // While we still have something to read, read the declarations in the struct.
Chris Lattner76c72282007-10-09 17:33:22 +00001819 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) {
Chris Lattner90a26b02007-01-23 04:38:16 +00001820 // Each iteration of this loop reads one struct-declaration.
Mike Stump11289f42009-09-09 15:08:12 +00001821
Chris Lattner736ed5d2007-06-09 05:59:07 +00001822 // Check for extraneous top-level semicolon.
Chris Lattner76c72282007-10-09 17:33:22 +00001823 if (Tok.is(tok::semi)) {
Douglas Gregore3e01a22009-04-01 22:41:11 +00001824 Diag(Tok, diag::ext_extra_struct_semi)
Douglas Gregor13d05682010-06-16 23:08:59 +00001825 << DeclSpec::getSpecifierName((DeclSpec::TST)TagType)
Douglas Gregora771f462010-03-31 17:46:05 +00001826 << FixItHint::CreateRemoval(Tok.getLocation());
Chris Lattner36e46a22007-06-09 05:49:55 +00001827 ConsumeToken();
1828 continue;
1829 }
Chris Lattnera12405b2008-04-10 06:46:29 +00001830
1831 // Parse all the comma separated declarators.
1832 DeclSpec DS;
Mike Stump11289f42009-09-09 15:08:12 +00001833
John McCallcfefb6d2009-11-03 02:38:08 +00001834 if (!Tok.is(tok::at)) {
1835 struct CFieldCallback : FieldCallback {
1836 Parser &P;
John McCall48871652010-08-21 09:40:31 +00001837 Decl *TagDecl;
1838 llvm::SmallVectorImpl<Decl *> &FieldDecls;
John McCallcfefb6d2009-11-03 02:38:08 +00001839
John McCall48871652010-08-21 09:40:31 +00001840 CFieldCallback(Parser &P, Decl *TagDecl,
1841 llvm::SmallVectorImpl<Decl *> &FieldDecls) :
John McCallcfefb6d2009-11-03 02:38:08 +00001842 P(P), TagDecl(TagDecl), FieldDecls(FieldDecls) {}
1843
John McCall48871652010-08-21 09:40:31 +00001844 virtual Decl *invoke(FieldDeclarator &FD) {
John McCallcfefb6d2009-11-03 02:38:08 +00001845 // Install the declarator into the current TagDecl.
John McCall48871652010-08-21 09:40:31 +00001846 Decl *Field = P.Actions.ActOnField(P.getCurScope(), TagDecl,
John McCall5e6253b2009-11-03 21:13:47 +00001847 FD.D.getDeclSpec().getSourceRange().getBegin(),
1848 FD.D, FD.BitfieldSize);
John McCallcfefb6d2009-11-03 02:38:08 +00001849 FieldDecls.push_back(Field);
1850 return Field;
Douglas Gregor66a985d2009-08-26 14:27:30 +00001851 }
John McCallcfefb6d2009-11-03 02:38:08 +00001852 } Callback(*this, TagDecl, FieldDecls);
1853
1854 ParseStructDeclaration(DS, Callback);
Chris Lattner535b8302008-06-21 19:39:06 +00001855 } else { // Handle @defs
1856 ConsumeToken();
1857 if (!Tok.isObjCAtKeyword(tok::objc_defs)) {
1858 Diag(Tok, diag::err_unexpected_at);
Chris Lattner245c5332010-02-02 00:37:27 +00001859 SkipUntil(tok::semi, true);
Chris Lattner535b8302008-06-21 19:39:06 +00001860 continue;
1861 }
1862 ConsumeToken();
1863 ExpectAndConsume(tok::l_paren, diag::err_expected_lparen);
1864 if (!Tok.is(tok::identifier)) {
1865 Diag(Tok, diag::err_expected_ident);
Chris Lattner245c5332010-02-02 00:37:27 +00001866 SkipUntil(tok::semi, true);
Chris Lattner535b8302008-06-21 19:39:06 +00001867 continue;
1868 }
John McCall48871652010-08-21 09:40:31 +00001869 llvm::SmallVector<Decl *, 16> Fields;
Douglas Gregor0be31a22010-07-02 17:43:08 +00001870 Actions.ActOnDefs(getCurScope(), TagDecl, Tok.getLocation(),
Douglas Gregor91f84212008-12-11 16:49:14 +00001871 Tok.getIdentifierInfo(), Fields);
Chris Lattner535b8302008-06-21 19:39:06 +00001872 FieldDecls.insert(FieldDecls.end(), Fields.begin(), Fields.end());
1873 ConsumeToken();
1874 ExpectAndConsume(tok::r_paren, diag::err_expected_rparen);
Mike Stump11289f42009-09-09 15:08:12 +00001875 }
Chris Lattner736ed5d2007-06-09 05:59:07 +00001876
Chris Lattner76c72282007-10-09 17:33:22 +00001877 if (Tok.is(tok::semi)) {
Chris Lattner90a26b02007-01-23 04:38:16 +00001878 ConsumeToken();
Chris Lattner76c72282007-10-09 17:33:22 +00001879 } else if (Tok.is(tok::r_brace)) {
Chris Lattner245c5332010-02-02 00:37:27 +00001880 ExpectAndConsume(tok::semi, diag::ext_expected_semi_decl_list);
Chris Lattner0c7e82d2007-06-09 05:54:40 +00001881 break;
Chris Lattner90a26b02007-01-23 04:38:16 +00001882 } else {
Chris Lattner245c5332010-02-02 00:37:27 +00001883 ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list);
1884 // Skip to end of block or statement to avoid ext-warning on extra ';'.
Chris Lattner90a26b02007-01-23 04:38:16 +00001885 SkipUntil(tok::r_brace, true, true);
Chris Lattner245c5332010-02-02 00:37:27 +00001886 // If we stopped at a ';', eat it.
1887 if (Tok.is(tok::semi)) ConsumeToken();
Chris Lattner90a26b02007-01-23 04:38:16 +00001888 }
1889 }
Mike Stump11289f42009-09-09 15:08:12 +00001890
Steve Naroff33a1e802007-10-29 21:38:07 +00001891 SourceLocation RBraceLoc = MatchRHSPunctuation(tok::r_brace, LBraceLoc);
Mike Stump11289f42009-09-09 15:08:12 +00001892
Ted Kremenekc162e8e2010-02-11 02:19:13 +00001893 llvm::OwningPtr<AttributeList> AttrList;
Chris Lattner90a26b02007-01-23 04:38:16 +00001894 // If attributes exist after struct contents, parse them.
Chris Lattner76c72282007-10-09 17:33:22 +00001895 if (Tok.is(tok::kw___attribute))
Ted Kremenekc162e8e2010-02-11 02:19:13 +00001896 AttrList.reset(ParseGNUAttributes());
Daniel Dunbar15619c72008-10-03 02:03:53 +00001897
Douglas Gregor0be31a22010-07-02 17:43:08 +00001898 Actions.ActOnFields(getCurScope(),
Jay Foad7d0479f2009-05-21 09:52:38 +00001899 RecordLoc, TagDecl, FieldDecls.data(), FieldDecls.size(),
Daniel Dunbar15619c72008-10-03 02:03:53 +00001900 LBraceLoc, RBraceLoc,
Ted Kremenekc162e8e2010-02-11 02:19:13 +00001901 AttrList.get());
Douglas Gregor82ac25e2009-01-08 20:45:30 +00001902 StructScope.Exit();
Douglas Gregor0be31a22010-07-02 17:43:08 +00001903 Actions.ActOnTagFinishDefinition(getCurScope(), TagDecl, RBraceLoc);
Chris Lattner90a26b02007-01-23 04:38:16 +00001904}
1905
1906
Chris Lattner3b561a32006-08-13 00:12:11 +00001907/// ParseEnumSpecifier
Chris Lattner1890ac82006-08-13 01:16:23 +00001908/// enum-specifier: [C99 6.7.2.2]
Chris Lattner3b561a32006-08-13 00:12:11 +00001909/// 'enum' identifier[opt] '{' enumerator-list '}'
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +00001910///[C99/C++]'enum' identifier[opt] '{' enumerator-list ',' '}'
Chris Lattnere37e2332006-08-15 04:50:22 +00001911/// [GNU] 'enum' attributes[opt] identifier[opt] '{' enumerator-list ',' [opt]
1912/// '}' attributes[opt]
Chris Lattner3b561a32006-08-13 00:12:11 +00001913/// 'enum' identifier
Chris Lattnere37e2332006-08-15 04:50:22 +00001914/// [GNU] 'enum' attributes[opt] identifier
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +00001915///
1916/// [C++] elaborated-type-specifier:
1917/// [C++] 'enum' '::'[opt] nested-name-specifier[opt] identifier
1918///
Chris Lattnerffaa0e62009-04-12 21:49:30 +00001919void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS,
Douglas Gregordc70c3a2010-03-02 17:53:14 +00001920 const ParsedTemplateInfo &TemplateInfo,
Chris Lattnerffaa0e62009-04-12 21:49:30 +00001921 AccessSpecifier AS) {
Chris Lattnerffbc2712007-01-25 06:05:38 +00001922 // Parse the tag portion of this.
Douglas Gregorf45b0cf2009-09-18 15:37:17 +00001923 if (Tok.is(tok::code_completion)) {
1924 // Code completion for an enum name.
Douglas Gregor0be31a22010-07-02 17:43:08 +00001925 Actions.CodeCompleteTag(getCurScope(), DeclSpec::TST_enum);
Douglas Gregor6da3db42010-05-25 05:58:43 +00001926 ConsumeCodeCompletionToken();
Douglas Gregorf45b0cf2009-09-18 15:37:17 +00001927 }
1928
Ted Kremenekc162e8e2010-02-11 02:19:13 +00001929 llvm::OwningPtr<AttributeList> Attr;
Argyrios Kyrtzidisf01fa822008-09-11 00:21:41 +00001930 // If attributes exist after tag, parse them.
1931 if (Tok.is(tok::kw___attribute))
Ted Kremenekc162e8e2010-02-11 02:19:13 +00001932 Attr.reset(ParseGNUAttributes());
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +00001933
Abramo Bagnarad7548482010-05-19 21:37:53 +00001934 CXXScopeSpec &SS = DS.getTypeSpecScope();
John McCall1f476a12010-02-26 08:45:28 +00001935 if (getLang().CPlusPlus) {
John McCallba7bf592010-08-24 05:47:05 +00001936 if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(), false))
John McCall1f476a12010-02-26 08:45:28 +00001937 return;
1938
1939 if (SS.isSet() && Tok.isNot(tok::identifier)) {
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +00001940 Diag(Tok, diag::err_expected_ident);
1941 if (Tok.isNot(tok::l_brace)) {
1942 // Has no name and is not a definition.
1943 // Skip the rest of this declarator, up until the comma or semicolon.
1944 SkipUntil(tok::comma, true);
1945 return;
1946 }
1947 }
1948 }
Mike Stump11289f42009-09-09 15:08:12 +00001949
Argyrios Kyrtzidisf01fa822008-09-11 00:21:41 +00001950 // Must have either 'enum name' or 'enum {...}'.
1951 if (Tok.isNot(tok::identifier) && Tok.isNot(tok::l_brace)) {
1952 Diag(Tok, diag::err_expected_ident_lbrace);
Mike Stump11289f42009-09-09 15:08:12 +00001953
Argyrios Kyrtzidisf01fa822008-09-11 00:21:41 +00001954 // Skip the rest of this declarator, up until the comma or semicolon.
1955 SkipUntil(tok::comma, true);
Chris Lattner3b561a32006-08-13 00:12:11 +00001956 return;
Argyrios Kyrtzidisf01fa822008-09-11 00:21:41 +00001957 }
Mike Stump11289f42009-09-09 15:08:12 +00001958
Argyrios Kyrtzidisf01fa822008-09-11 00:21:41 +00001959 // If an identifier is present, consume and remember it.
1960 IdentifierInfo *Name = 0;
1961 SourceLocation NameLoc;
1962 if (Tok.is(tok::identifier)) {
1963 Name = Tok.getIdentifierInfo();
1964 NameLoc = ConsumeToken();
1965 }
Mike Stump11289f42009-09-09 15:08:12 +00001966
Argyrios Kyrtzidisf01fa822008-09-11 00:21:41 +00001967 // There are three options here. If we have 'enum foo;', then this is a
1968 // forward declaration. If we have 'enum foo {...' then this is a
1969 // definition. Otherwise we have something like 'enum foo xyz', a reference.
1970 //
1971 // This is needed to handle stuff like this right (C99 6.7.2.3p11):
1972 // enum foo {..}; void bar() { enum foo; } <- new foo in bar.
1973 // enum foo {..}; void bar() { enum foo x; } <- use of old foo.
1974 //
John McCall9bb74a52009-07-31 02:45:11 +00001975 Action::TagUseKind TUK;
Argyrios Kyrtzidisf01fa822008-09-11 00:21:41 +00001976 if (Tok.is(tok::l_brace))
John McCall9bb74a52009-07-31 02:45:11 +00001977 TUK = Action::TUK_Definition;
Argyrios Kyrtzidisf01fa822008-09-11 00:21:41 +00001978 else if (Tok.is(tok::semi))
John McCall9bb74a52009-07-31 02:45:11 +00001979 TUK = Action::TUK_Declaration;
Argyrios Kyrtzidisf01fa822008-09-11 00:21:41 +00001980 else
John McCall9bb74a52009-07-31 02:45:11 +00001981 TUK = Action::TUK_Reference;
Douglas Gregorcbbf3e32010-05-03 17:48:54 +00001982
1983 // enums cannot be templates, although they can be referenced from a
1984 // template.
1985 if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate &&
1986 TUK != Action::TUK_Reference) {
1987 Diag(Tok, diag::err_enum_template);
1988
1989 // Skip the rest of this declarator, up until the comma or semicolon.
1990 SkipUntil(tok::comma, true);
1991 return;
1992 }
1993
Douglas Gregord6ab8742009-05-28 23:31:59 +00001994 bool Owned = false;
John McCall7f41d982009-09-11 04:59:25 +00001995 bool IsDependent = false;
Douglas Gregorba41d012010-04-24 16:38:41 +00001996 SourceLocation TSTLoc = NameLoc.isValid()? NameLoc : StartLoc;
1997 const char *PrevSpec = 0;
1998 unsigned DiagID;
John McCall48871652010-08-21 09:40:31 +00001999 Decl *TagDecl = Actions.ActOnTag(getCurScope(), DeclSpec::TST_enum, TUK,
2000 StartLoc, SS, Name, NameLoc, Attr.get(),
2001 AS,
2002 Action::MultiTemplateParamsArg(Actions),
2003 Owned, IsDependent);
Douglas Gregorba41d012010-04-24 16:38:41 +00002004 if (IsDependent) {
2005 // This enum has a dependent nested-name-specifier. Handle it as a
2006 // dependent tag.
2007 if (!Name) {
2008 DS.SetTypeSpecError();
2009 Diag(Tok, diag::err_expected_type_name_after_typename);
2010 return;
2011 }
2012
Douglas Gregor0be31a22010-07-02 17:43:08 +00002013 TypeResult Type = Actions.ActOnDependentTag(getCurScope(), DeclSpec::TST_enum,
Douglas Gregorba41d012010-04-24 16:38:41 +00002014 TUK, SS, Name, StartLoc,
2015 NameLoc);
2016 if (Type.isInvalid()) {
2017 DS.SetTypeSpecError();
2018 return;
2019 }
2020
2021 if (DS.SetTypeSpecType(DeclSpec::TST_typename, TSTLoc, PrevSpec, DiagID,
John McCallba7bf592010-08-24 05:47:05 +00002022 Type.get()))
Douglas Gregorba41d012010-04-24 16:38:41 +00002023 Diag(StartLoc, DiagID) << PrevSpec;
2024
2025 return;
2026 }
Mike Stump11289f42009-09-09 15:08:12 +00002027
John McCall48871652010-08-21 09:40:31 +00002028 if (!TagDecl) {
Douglas Gregorba41d012010-04-24 16:38:41 +00002029 // The action failed to produce an enumeration tag. If this is a
2030 // definition, consume the entire definition.
2031 if (Tok.is(tok::l_brace)) {
2032 ConsumeBrace();
2033 SkipUntil(tok::r_brace);
2034 }
2035
2036 DS.SetTypeSpecError();
2037 return;
2038 }
2039
Chris Lattner76c72282007-10-09 17:33:22 +00002040 if (Tok.is(tok::l_brace))
Chris Lattnerc1915e22007-01-25 07:29:02 +00002041 ParseEnumBody(StartLoc, TagDecl);
Mike Stump11289f42009-09-09 15:08:12 +00002042
John McCallba7bf592010-08-24 05:47:05 +00002043 // FIXME: The DeclSpec should keep the locations of both the keyword
2044 // and the name (if there is one).
Douglas Gregor72100632010-01-25 16:33:23 +00002045 if (DS.SetTypeSpecType(DeclSpec::TST_enum, TSTLoc, PrevSpec, DiagID,
John McCall48871652010-08-21 09:40:31 +00002046 TagDecl, Owned))
John McCall49bfce42009-08-03 20:12:06 +00002047 Diag(StartLoc, DiagID) << PrevSpec;
Chris Lattner3b561a32006-08-13 00:12:11 +00002048}
2049
Chris Lattnerc1915e22007-01-25 07:29:02 +00002050/// ParseEnumBody - Parse a {} enclosed enumerator-list.
2051/// enumerator-list:
2052/// enumerator
2053/// enumerator-list ',' enumerator
2054/// enumerator:
2055/// enumeration-constant
2056/// enumeration-constant '=' constant-expression
2057/// enumeration-constant:
2058/// identifier
2059///
John McCall48871652010-08-21 09:40:31 +00002060void Parser::ParseEnumBody(SourceLocation StartLoc, Decl *EnumDecl) {
Douglas Gregor07665a62009-01-05 19:45:36 +00002061 // Enter the scope of the enum body and start the definition.
2062 ParseScope EnumScope(this, Scope::DeclScope);
Douglas Gregor0be31a22010-07-02 17:43:08 +00002063 Actions.ActOnTagStartDefinition(getCurScope(), EnumDecl);
Douglas Gregor07665a62009-01-05 19:45:36 +00002064
Chris Lattnerc1915e22007-01-25 07:29:02 +00002065 SourceLocation LBraceLoc = ConsumeBrace();
Mike Stump11289f42009-09-09 15:08:12 +00002066
Chris Lattner37256fb2007-08-27 17:24:30 +00002067 // C does not allow an empty enumerator-list, C++ does [dcl.enum].
Chris Lattner76c72282007-10-09 17:33:22 +00002068 if (Tok.is(tok::r_brace) && !getLang().CPlusPlus)
Fariborz Jahanian6e814922010-05-28 22:23:22 +00002069 Diag(Tok, diag::error_empty_enum);
Mike Stump11289f42009-09-09 15:08:12 +00002070
John McCall48871652010-08-21 09:40:31 +00002071 llvm::SmallVector<Decl *, 32> EnumConstantDecls;
Chris Lattnerc1915e22007-01-25 07:29:02 +00002072
John McCall48871652010-08-21 09:40:31 +00002073 Decl *LastEnumConstDecl = 0;
Mike Stump11289f42009-09-09 15:08:12 +00002074
Chris Lattnerc1915e22007-01-25 07:29:02 +00002075 // Parse the enumerator-list.
Chris Lattner76c72282007-10-09 17:33:22 +00002076 while (Tok.is(tok::identifier)) {
Chris Lattnerc1915e22007-01-25 07:29:02 +00002077 IdentifierInfo *Ident = Tok.getIdentifierInfo();
2078 SourceLocation IdentLoc = ConsumeToken();
Mike Stump11289f42009-09-09 15:08:12 +00002079
Chris Lattnerc1915e22007-01-25 07:29:02 +00002080 SourceLocation EqualLoc;
John McCall37ad5512010-08-23 06:44:23 +00002081 OwningExprResult AssignedVal;
Chris Lattner76c72282007-10-09 17:33:22 +00002082 if (Tok.is(tok::equal)) {
Chris Lattnerc1915e22007-01-25 07:29:02 +00002083 EqualLoc = ConsumeToken();
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00002084 AssignedVal = ParseConstantExpression();
2085 if (AssignedVal.isInvalid())
Chris Lattnerda6c2ce2007-04-27 19:13:15 +00002086 SkipUntil(tok::comma, tok::r_brace, true, true);
Chris Lattnerc1915e22007-01-25 07:29:02 +00002087 }
Mike Stump11289f42009-09-09 15:08:12 +00002088
Chris Lattnerc1915e22007-01-25 07:29:02 +00002089 // Install the enumerator constant into EnumDecl.
John McCall48871652010-08-21 09:40:31 +00002090 Decl *EnumConstDecl = Actions.ActOnEnumConstant(getCurScope(), EnumDecl,
2091 LastEnumConstDecl,
2092 IdentLoc, Ident,
2093 EqualLoc,
2094 AssignedVal.release());
Chris Lattner4ef40012007-06-11 01:28:17 +00002095 EnumConstantDecls.push_back(EnumConstDecl);
2096 LastEnumConstDecl = EnumConstDecl;
Mike Stump11289f42009-09-09 15:08:12 +00002097
Chris Lattner76c72282007-10-09 17:33:22 +00002098 if (Tok.isNot(tok::comma))
Chris Lattnerc1915e22007-01-25 07:29:02 +00002099 break;
2100 SourceLocation CommaLoc = ConsumeToken();
Mike Stump11289f42009-09-09 15:08:12 +00002101
2102 if (Tok.isNot(tok::identifier) &&
Douglas Gregore3e01a22009-04-01 22:41:11 +00002103 !(getLang().C99 || getLang().CPlusPlus0x))
2104 Diag(CommaLoc, diag::ext_enumerator_list_comma)
2105 << getLang().CPlusPlus
Douglas Gregora771f462010-03-31 17:46:05 +00002106 << FixItHint::CreateRemoval(CommaLoc);
Chris Lattnerc1915e22007-01-25 07:29:02 +00002107 }
Mike Stump11289f42009-09-09 15:08:12 +00002108
Chris Lattnerc1915e22007-01-25 07:29:02 +00002109 // Eat the }.
Mike Stump6814d1c2009-05-16 07:06:02 +00002110 SourceLocation RBraceLoc = MatchRHSPunctuation(tok::r_brace, LBraceLoc);
Chris Lattnerc1915e22007-01-25 07:29:02 +00002111
Ted Kremenekc162e8e2010-02-11 02:19:13 +00002112 llvm::OwningPtr<AttributeList> Attr;
Chris Lattnerc1915e22007-01-25 07:29:02 +00002113 // If attributes exist after the identifier list, parse them.
Chris Lattner76c72282007-10-09 17:33:22 +00002114 if (Tok.is(tok::kw___attribute))
Ted Kremenekc162e8e2010-02-11 02:19:13 +00002115 Attr.reset(ParseGNUAttributes()); // FIXME: where do they do?
Douglas Gregor82ac25e2009-01-08 20:45:30 +00002116
Edward O'Callaghanc69169d2009-08-08 14:36:57 +00002117 Actions.ActOnEnumBody(StartLoc, LBraceLoc, RBraceLoc, EnumDecl,
2118 EnumConstantDecls.data(), EnumConstantDecls.size(),
Douglas Gregor0be31a22010-07-02 17:43:08 +00002119 getCurScope(), Attr.get());
Mike Stump11289f42009-09-09 15:08:12 +00002120
Douglas Gregor82ac25e2009-01-08 20:45:30 +00002121 EnumScope.Exit();
Douglas Gregor0be31a22010-07-02 17:43:08 +00002122 Actions.ActOnTagFinishDefinition(getCurScope(), EnumDecl, RBraceLoc);
Chris Lattnerc1915e22007-01-25 07:29:02 +00002123}
Chris Lattner3b561a32006-08-13 00:12:11 +00002124
Chris Lattnerf5fbd792006-08-10 23:56:11 +00002125/// isTypeSpecifierQualifier - Return true if the current token could be the
Steve Naroff69e8f9e2008-02-11 23:15:56 +00002126/// start of a type-qualifier-list.
2127bool Parser::isTypeQualifier() const {
2128 switch (Tok.getKind()) {
2129 default: return false;
2130 // type-qualifier
2131 case tok::kw_const:
2132 case tok::kw_volatile:
2133 case tok::kw_restrict:
2134 return true;
2135 }
2136}
2137
Chris Lattnerfd48afe2010-02-28 18:18:36 +00002138/// isKnownToBeTypeSpecifier - Return true if we know that the specified token
2139/// is definitely a type-specifier. Return false if it isn't part of a type
2140/// specifier or if we're not sure.
2141bool Parser::isKnownToBeTypeSpecifier(const Token &Tok) const {
2142 switch (Tok.getKind()) {
2143 default: return false;
2144 // type-specifiers
2145 case tok::kw_short:
2146 case tok::kw_long:
2147 case tok::kw_signed:
2148 case tok::kw_unsigned:
2149 case tok::kw__Complex:
2150 case tok::kw__Imaginary:
2151 case tok::kw_void:
2152 case tok::kw_char:
2153 case tok::kw_wchar_t:
2154 case tok::kw_char16_t:
2155 case tok::kw_char32_t:
2156 case tok::kw_int:
2157 case tok::kw_float:
2158 case tok::kw_double:
2159 case tok::kw_bool:
2160 case tok::kw__Bool:
2161 case tok::kw__Decimal32:
2162 case tok::kw__Decimal64:
2163 case tok::kw__Decimal128:
2164 case tok::kw___vector:
2165
2166 // struct-or-union-specifier (C99) or class-specifier (C++)
2167 case tok::kw_class:
2168 case tok::kw_struct:
2169 case tok::kw_union:
2170 // enum-specifier
2171 case tok::kw_enum:
2172
2173 // typedef-name
2174 case tok::annot_typename:
2175 return true;
2176 }
2177}
2178
Steve Naroff69e8f9e2008-02-11 23:15:56 +00002179/// isTypeSpecifierQualifier - Return true if the current token could be the
Chris Lattnerf5fbd792006-08-10 23:56:11 +00002180/// start of a specifier-qualifier-list.
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +00002181bool Parser::isTypeSpecifierQualifier() {
Chris Lattnerf5fbd792006-08-10 23:56:11 +00002182 switch (Tok.getKind()) {
2183 default: return false;
Mike Stump11289f42009-09-09 15:08:12 +00002184
Chris Lattner020bab92009-01-04 23:41:41 +00002185 case tok::identifier: // foo::bar
John Thompson22334602010-02-05 00:12:22 +00002186 if (TryAltiVecVectorToken())
2187 return true;
2188 // Fall through.
Douglas Gregor333489b2009-03-27 23:10:48 +00002189 case tok::kw_typename: // typename T::type
Chris Lattner020bab92009-01-04 23:41:41 +00002190 // Annotate typenames and C++ scope specifiers. If we get one, just
2191 // recurse to handle whatever we get.
2192 if (TryAnnotateTypeOrScopeToken())
John McCall1f476a12010-02-26 08:45:28 +00002193 return true;
2194 if (Tok.is(tok::identifier))
2195 return false;
2196 return isTypeSpecifierQualifier();
Douglas Gregor333489b2009-03-27 23:10:48 +00002197
Chris Lattner020bab92009-01-04 23:41:41 +00002198 case tok::coloncolon: // ::foo::bar
2199 if (NextToken().is(tok::kw_new) || // ::new
2200 NextToken().is(tok::kw_delete)) // ::delete
2201 return false;
2202
Chris Lattner020bab92009-01-04 23:41:41 +00002203 if (TryAnnotateTypeOrScopeToken())
John McCall1f476a12010-02-26 08:45:28 +00002204 return true;
2205 return isTypeSpecifierQualifier();
Mike Stump11289f42009-09-09 15:08:12 +00002206
Chris Lattnere37e2332006-08-15 04:50:22 +00002207 // GNU attributes support.
2208 case tok::kw___attribute:
Steve Naroffad373bd2007-07-31 12:34:36 +00002209 // GNU typeof support.
2210 case tok::kw_typeof:
Mike Stump11289f42009-09-09 15:08:12 +00002211
Chris Lattnerf5fbd792006-08-10 23:56:11 +00002212 // type-specifiers
2213 case tok::kw_short:
2214 case tok::kw_long:
2215 case tok::kw_signed:
2216 case tok::kw_unsigned:
2217 case tok::kw__Complex:
2218 case tok::kw__Imaginary:
2219 case tok::kw_void:
2220 case tok::kw_char:
Argyrios Kyrtzidis40e9e482008-08-09 16:51:54 +00002221 case tok::kw_wchar_t:
Alisdair Mereditha9ad47d2009-07-14 06:30:34 +00002222 case tok::kw_char16_t:
2223 case tok::kw_char32_t:
Chris Lattnerf5fbd792006-08-10 23:56:11 +00002224 case tok::kw_int:
2225 case tok::kw_float:
2226 case tok::kw_double:
Chris Lattnerbb31a422007-11-15 05:25:19 +00002227 case tok::kw_bool:
Chris Lattnerf5fbd792006-08-10 23:56:11 +00002228 case tok::kw__Bool:
2229 case tok::kw__Decimal32:
2230 case tok::kw__Decimal64:
2231 case tok::kw__Decimal128:
John Thompson22334602010-02-05 00:12:22 +00002232 case tok::kw___vector:
Mike Stump11289f42009-09-09 15:08:12 +00002233
Chris Lattner861a2262008-04-13 18:59:07 +00002234 // struct-or-union-specifier (C99) or class-specifier (C++)
2235 case tok::kw_class:
Chris Lattnerf5fbd792006-08-10 23:56:11 +00002236 case tok::kw_struct:
2237 case tok::kw_union:
2238 // enum-specifier
2239 case tok::kw_enum:
Mike Stump11289f42009-09-09 15:08:12 +00002240
Chris Lattnerf5fbd792006-08-10 23:56:11 +00002241 // type-qualifier
2242 case tok::kw_const:
2243 case tok::kw_volatile:
2244 case tok::kw_restrict:
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +00002245
2246 // typedef-name
Chris Lattnera8a3f732009-01-06 05:06:21 +00002247 case tok::annot_typename:
Chris Lattnerf5fbd792006-08-10 23:56:11 +00002248 return true;
Mike Stump11289f42009-09-09 15:08:12 +00002249
Chris Lattner409bf7d2008-10-20 00:25:30 +00002250 // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
2251 case tok::less:
2252 return getLang().ObjC1;
Mike Stump11289f42009-09-09 15:08:12 +00002253
Steve Naroff44ac7772008-12-25 14:16:32 +00002254 case tok::kw___cdecl:
2255 case tok::kw___stdcall:
2256 case tok::kw___fastcall:
Douglas Gregora941dca2010-05-18 16:57:00 +00002257 case tok::kw___thiscall:
Eli Friedman53339e02009-06-08 23:27:34 +00002258 case tok::kw___w64:
2259 case tok::kw___ptr64:
2260 return true;
Chris Lattnerf5fbd792006-08-10 23:56:11 +00002261 }
2262}
2263
Chris Lattneracd58a32006-08-06 17:24:14 +00002264/// isDeclarationSpecifier() - Return true if the current token is part of a
2265/// declaration specifier.
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +00002266bool Parser::isDeclarationSpecifier() {
Chris Lattneracd58a32006-08-06 17:24:14 +00002267 switch (Tok.getKind()) {
2268 default: return false;
Mike Stump11289f42009-09-09 15:08:12 +00002269
Chris Lattner020bab92009-01-04 23:41:41 +00002270 case tok::identifier: // foo::bar
Steve Naroff9527bbf2009-03-09 21:12:44 +00002271 // Unfortunate hack to support "Class.factoryMethod" notation.
2272 if (getLang().ObjC1 && NextToken().is(tok::period))
2273 return false;
John Thompson22334602010-02-05 00:12:22 +00002274 if (TryAltiVecVectorToken())
2275 return true;
2276 // Fall through.
Douglas Gregor333489b2009-03-27 23:10:48 +00002277 case tok::kw_typename: // typename T::type
Chris Lattner020bab92009-01-04 23:41:41 +00002278 // Annotate typenames and C++ scope specifiers. If we get one, just
2279 // recurse to handle whatever we get.
2280 if (TryAnnotateTypeOrScopeToken())
John McCall1f476a12010-02-26 08:45:28 +00002281 return true;
2282 if (Tok.is(tok::identifier))
2283 return false;
2284 return isDeclarationSpecifier();
2285
Chris Lattner020bab92009-01-04 23:41:41 +00002286 case tok::coloncolon: // ::foo::bar
2287 if (NextToken().is(tok::kw_new) || // ::new
2288 NextToken().is(tok::kw_delete)) // ::delete
2289 return false;
Mike Stump11289f42009-09-09 15:08:12 +00002290
Chris Lattner020bab92009-01-04 23:41:41 +00002291 // Annotate typenames and C++ scope specifiers. If we get one, just
2292 // recurse to handle whatever we get.
2293 if (TryAnnotateTypeOrScopeToken())
John McCall1f476a12010-02-26 08:45:28 +00002294 return true;
2295 return isDeclarationSpecifier();
Mike Stump11289f42009-09-09 15:08:12 +00002296
Chris Lattneracd58a32006-08-06 17:24:14 +00002297 // storage-class-specifier
2298 case tok::kw_typedef:
2299 case tok::kw_extern:
Steve Naroff2050b0d2007-12-18 00:16:02 +00002300 case tok::kw___private_extern__:
Chris Lattneracd58a32006-08-06 17:24:14 +00002301 case tok::kw_static:
2302 case tok::kw_auto:
2303 case tok::kw_register:
2304 case tok::kw___thread:
Mike Stump11289f42009-09-09 15:08:12 +00002305
Chris Lattneracd58a32006-08-06 17:24:14 +00002306 // type-specifiers
2307 case tok::kw_short:
2308 case tok::kw_long:
2309 case tok::kw_signed:
2310 case tok::kw_unsigned:
2311 case tok::kw__Complex:
2312 case tok::kw__Imaginary:
2313 case tok::kw_void:
2314 case tok::kw_char:
Argyrios Kyrtzidis40e9e482008-08-09 16:51:54 +00002315 case tok::kw_wchar_t:
Alisdair Mereditha9ad47d2009-07-14 06:30:34 +00002316 case tok::kw_char16_t:
2317 case tok::kw_char32_t:
2318
Chris Lattneracd58a32006-08-06 17:24:14 +00002319 case tok::kw_int:
2320 case tok::kw_float:
2321 case tok::kw_double:
Chris Lattnerbb31a422007-11-15 05:25:19 +00002322 case tok::kw_bool:
Chris Lattneracd58a32006-08-06 17:24:14 +00002323 case tok::kw__Bool:
2324 case tok::kw__Decimal32:
2325 case tok::kw__Decimal64:
2326 case tok::kw__Decimal128:
John Thompson22334602010-02-05 00:12:22 +00002327 case tok::kw___vector:
Mike Stump11289f42009-09-09 15:08:12 +00002328
Chris Lattner861a2262008-04-13 18:59:07 +00002329 // struct-or-union-specifier (C99) or class-specifier (C++)
2330 case tok::kw_class:
Chris Lattneracd58a32006-08-06 17:24:14 +00002331 case tok::kw_struct:
2332 case tok::kw_union:
2333 // enum-specifier
2334 case tok::kw_enum:
Mike Stump11289f42009-09-09 15:08:12 +00002335
Chris Lattneracd58a32006-08-06 17:24:14 +00002336 // type-qualifier
2337 case tok::kw_const:
2338 case tok::kw_volatile:
2339 case tok::kw_restrict:
Steve Naroffad373bd2007-07-31 12:34:36 +00002340
Chris Lattneracd58a32006-08-06 17:24:14 +00002341 // function-specifier
2342 case tok::kw_inline:
Douglas Gregor61956c42008-10-31 09:07:45 +00002343 case tok::kw_virtual:
2344 case tok::kw_explicit:
Chris Lattner7b20dc72007-08-09 16:40:21 +00002345
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +00002346 // typedef-name
Chris Lattnera8a3f732009-01-06 05:06:21 +00002347 case tok::annot_typename:
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +00002348
Chris Lattner599e47e2007-08-09 17:01:07 +00002349 // GNU typeof support.
2350 case tok::kw_typeof:
Mike Stump11289f42009-09-09 15:08:12 +00002351
Chris Lattner599e47e2007-08-09 17:01:07 +00002352 // GNU attributes.
Chris Lattner7b20dc72007-08-09 16:40:21 +00002353 case tok::kw___attribute:
Chris Lattneracd58a32006-08-06 17:24:14 +00002354 return true;
Mike Stump11289f42009-09-09 15:08:12 +00002355
Chris Lattner8b2ec162008-07-26 03:38:44 +00002356 // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
2357 case tok::less:
2358 return getLang().ObjC1;
Mike Stump11289f42009-09-09 15:08:12 +00002359
Steve Narofff192fab2009-01-06 19:34:12 +00002360 case tok::kw___declspec:
Steve Naroff44ac7772008-12-25 14:16:32 +00002361 case tok::kw___cdecl:
2362 case tok::kw___stdcall:
2363 case tok::kw___fastcall:
Douglas Gregora941dca2010-05-18 16:57:00 +00002364 case tok::kw___thiscall:
Eli Friedman53339e02009-06-08 23:27:34 +00002365 case tok::kw___w64:
2366 case tok::kw___ptr64:
2367 case tok::kw___forceinline:
2368 return true;
Chris Lattneracd58a32006-08-06 17:24:14 +00002369 }
2370}
2371
Douglas Gregor9de54ea2010-01-13 17:31:36 +00002372bool Parser::isConstructorDeclarator() {
2373 TentativeParsingAction TPA(*this);
2374
2375 // Parse the C++ scope specifier.
2376 CXXScopeSpec SS;
John McCallba7bf592010-08-24 05:47:05 +00002377 if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(), true)) {
John McCall1f476a12010-02-26 08:45:28 +00002378 TPA.Revert();
2379 return false;
2380 }
Douglas Gregor9de54ea2010-01-13 17:31:36 +00002381
2382 // Parse the constructor name.
2383 if (Tok.is(tok::identifier) || Tok.is(tok::annot_template_id)) {
2384 // We already know that we have a constructor name; just consume
2385 // the token.
2386 ConsumeToken();
2387 } else {
2388 TPA.Revert();
2389 return false;
2390 }
2391
2392 // Current class name must be followed by a left parentheses.
2393 if (Tok.isNot(tok::l_paren)) {
2394 TPA.Revert();
2395 return false;
2396 }
2397 ConsumeParen();
2398
2399 // A right parentheses or ellipsis signals that we have a constructor.
2400 if (Tok.is(tok::r_paren) || Tok.is(tok::ellipsis)) {
2401 TPA.Revert();
2402 return true;
2403 }
2404
2405 // If we need to, enter the specified scope.
2406 DeclaratorScopeObj DeclScopeObj(*this, SS);
Douglas Gregor0be31a22010-07-02 17:43:08 +00002407 if (SS.isSet() && Actions.ShouldEnterDeclaratorScope(getCurScope(), SS))
Douglas Gregor9de54ea2010-01-13 17:31:36 +00002408 DeclScopeObj.EnterDeclaratorScope();
2409
2410 // Check whether the next token(s) are part of a declaration
2411 // specifier, in which case we have the start of a parameter and,
2412 // therefore, we know that this is a constructor.
2413 bool IsConstructor = isDeclarationSpecifier();
2414 TPA.Revert();
2415 return IsConstructor;
2416}
Chris Lattnerb9093cd2006-08-04 04:39:53 +00002417
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00002418/// ParseTypeQualifierListOpt
2419/// type-qualifier-list: [C99 6.7.5]
2420/// type-qualifier
Chris Lattnercf0bab22008-12-18 07:02:59 +00002421/// [GNU] attributes [ only if AttributesAllowed=true ]
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00002422/// type-qualifier-list type-qualifier
Chris Lattnercf0bab22008-12-18 07:02:59 +00002423/// [GNU] type-qualifier-list attributes [ only if AttributesAllowed=true ]
Alexis Hunt96d5c762009-11-21 08:43:09 +00002424/// [C++0x] attribute-specifier[opt] is allowed before cv-qualifier-seq
2425/// if CXX0XAttributesAllowed = true
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00002426///
Alexis Hunt96d5c762009-11-21 08:43:09 +00002427void Parser::ParseTypeQualifierListOpt(DeclSpec &DS, bool GNUAttributesAllowed,
2428 bool CXX0XAttributesAllowed) {
2429 if (getLang().CPlusPlus0x && isCXX0XAttributeSpecifier()) {
2430 SourceLocation Loc = Tok.getLocation();
2431 CXX0XAttributeList Attr = ParseCXX0XAttributes();
2432 if (CXX0XAttributesAllowed)
2433 DS.AddAttributes(Attr.AttrList);
2434 else
2435 Diag(Loc, diag::err_attributes_not_allowed);
2436 }
2437
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00002438 while (1) {
John McCall49bfce42009-08-03 20:12:06 +00002439 bool isInvalid = false;
Chris Lattnerd9c3c592006-08-05 06:26:47 +00002440 const char *PrevSpec = 0;
John McCall49bfce42009-08-03 20:12:06 +00002441 unsigned DiagID = 0;
Chris Lattner60809f52006-11-28 05:18:46 +00002442 SourceLocation Loc = Tok.getLocation();
Chris Lattnerd9c3c592006-08-05 06:26:47 +00002443
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00002444 switch (Tok.getKind()) {
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00002445 case tok::kw_const:
John McCall49bfce42009-08-03 20:12:06 +00002446 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const , Loc, PrevSpec, DiagID,
2447 getLang());
Chris Lattnerd9c3c592006-08-05 06:26:47 +00002448 break;
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00002449 case tok::kw_volatile:
John McCall49bfce42009-08-03 20:12:06 +00002450 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID,
2451 getLang());
Chris Lattnerd9c3c592006-08-05 06:26:47 +00002452 break;
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00002453 case tok::kw_restrict:
John McCall49bfce42009-08-03 20:12:06 +00002454 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID,
2455 getLang());
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00002456 break;
Eli Friedman53339e02009-06-08 23:27:34 +00002457 case tok::kw___w64:
Steve Narofff9c29d42008-12-25 14:41:26 +00002458 case tok::kw___ptr64:
Steve Naroff44ac7772008-12-25 14:16:32 +00002459 case tok::kw___cdecl:
2460 case tok::kw___stdcall:
2461 case tok::kw___fastcall:
Douglas Gregora941dca2010-05-18 16:57:00 +00002462 case tok::kw___thiscall:
Alexis Hunt96d5c762009-11-21 08:43:09 +00002463 if (GNUAttributesAllowed) {
Eli Friedman53339e02009-06-08 23:27:34 +00002464 DS.AddAttributes(ParseMicrosoftTypeAttributes());
2465 continue;
2466 }
2467 goto DoneWithTypeQuals;
Chris Lattnere37e2332006-08-15 04:50:22 +00002468 case tok::kw___attribute:
Alexis Hunt96d5c762009-11-21 08:43:09 +00002469 if (GNUAttributesAllowed) {
2470 DS.AddAttributes(ParseGNUAttributes());
Chris Lattnercf0bab22008-12-18 07:02:59 +00002471 continue; // do *not* consume the next token!
2472 }
2473 // otherwise, FALL THROUGH!
2474 default:
Steve Naroff44ac7772008-12-25 14:16:32 +00002475 DoneWithTypeQuals:
Chris Lattnercf0bab22008-12-18 07:02:59 +00002476 // If this is not a type-qualifier token, we're done reading type
2477 // qualifiers. First verify that DeclSpec's are consistent.
Douglas Gregore3e01a22009-04-01 22:41:11 +00002478 DS.Finish(Diags, PP);
Chris Lattnercf0bab22008-12-18 07:02:59 +00002479 return;
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00002480 }
Chris Lattnerb6ec4e72008-12-18 06:50:14 +00002481
Chris Lattnerd9c3c592006-08-05 06:26:47 +00002482 // If the specifier combination wasn't legal, issue a diagnostic.
2483 if (isInvalid) {
2484 assert(PrevSpec && "Method did not return previous specifier!");
Chris Lattner6d29c102008-11-18 07:48:38 +00002485 Diag(Tok, DiagID) << PrevSpec;
Chris Lattnerd9c3c592006-08-05 06:26:47 +00002486 }
2487 ConsumeToken();
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00002488 }
2489}
2490
Chris Lattnerd5d0a6c2006-08-07 00:58:14 +00002491
2492/// ParseDeclarator - Parse and verify a newly-initialized declarator.
2493///
2494void Parser::ParseDeclarator(Declarator &D) {
2495 /// This implements the 'declarator' production in the C grammar, then checks
2496 /// for well-formedness and issues diagnostics.
Sebastian Redlbd150f42008-11-21 19:14:01 +00002497 ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
Chris Lattnerd5d0a6c2006-08-07 00:58:14 +00002498}
2499
Sebastian Redlbd150f42008-11-21 19:14:01 +00002500/// ParseDeclaratorInternal - Parse a C or C++ declarator. The direct-declarator
2501/// is parsed by the function passed to it. Pass null, and the direct-declarator
2502/// isn't parsed at all, making this function effectively parse the C++
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002503/// ptr-operator production.
2504///
Sebastian Redl9ed6efd2009-01-24 21:16:55 +00002505/// declarator: [C99 6.7.5] [C++ 8p4, dcl.decl]
2506/// [C] pointer[opt] direct-declarator
2507/// [C++] direct-declarator
2508/// [C++] ptr-operator declarator
Chris Lattner6c7416c2006-08-07 00:19:33 +00002509///
2510/// pointer: [C99 6.7.5]
2511/// '*' type-qualifier-list[opt]
2512/// '*' type-qualifier-list[opt] pointer
2513///
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002514/// ptr-operator:
2515/// '*' cv-qualifier-seq[opt]
2516/// '&'
Sebastian Redled0f3b02009-03-15 22:02:01 +00002517/// [C++0x] '&&'
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002518/// [GNU] '&' restrict[opt] attributes[opt]
Sebastian Redled0f3b02009-03-15 22:02:01 +00002519/// [GNU?] '&&' restrict[opt] attributes[opt]
Sebastian Redl9ed6efd2009-01-24 21:16:55 +00002520/// '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt]
Sebastian Redlbd150f42008-11-21 19:14:01 +00002521void Parser::ParseDeclaratorInternal(Declarator &D,
2522 DirectDeclParseFunction DirectDeclParser) {
Douglas Gregor66a985d2009-08-26 14:27:30 +00002523 if (Diags.hasAllExtensionsSilenced())
2524 D.setExtension();
Douglas Gregorc49f5b22010-08-23 18:23:48 +00002525
Sebastian Redl9ed6efd2009-01-24 21:16:55 +00002526 // C++ member pointers start with a '::' or a nested-name.
2527 // Member pointers get special handling, since there's no place for the
2528 // scope spec in the generic path below.
Chris Lattner803802d2009-03-24 17:04:48 +00002529 if (getLang().CPlusPlus &&
2530 (Tok.is(tok::coloncolon) || Tok.is(tok::identifier) ||
2531 Tok.is(tok::annot_cxxscope))) {
Sebastian Redl9ed6efd2009-01-24 21:16:55 +00002532 CXXScopeSpec SS;
John McCallba7bf592010-08-24 05:47:05 +00002533 ParseOptionalCXXScopeSpecifier(SS, ParsedType(), true); // ignore fail
John McCall1f476a12010-02-26 08:45:28 +00002534
Jeffrey Yasskin4e150f82010-04-07 23:29:58 +00002535 if (SS.isNotEmpty()) {
Mike Stump11289f42009-09-09 15:08:12 +00002536 if (Tok.isNot(tok::star)) {
Sebastian Redl9ed6efd2009-01-24 21:16:55 +00002537 // The scope spec really belongs to the direct-declarator.
2538 D.getCXXScopeSpec() = SS;
2539 if (DirectDeclParser)
2540 (this->*DirectDeclParser)(D);
2541 return;
2542 }
2543
2544 SourceLocation Loc = ConsumeToken();
Sebastian Redlf6591ca2009-02-09 18:23:29 +00002545 D.SetRangeEnd(Loc);
Sebastian Redl9ed6efd2009-01-24 21:16:55 +00002546 DeclSpec DS;
2547 ParseTypeQualifierListOpt(DS);
Sebastian Redlf6591ca2009-02-09 18:23:29 +00002548 D.ExtendWithDeclSpec(DS);
Sebastian Redl9ed6efd2009-01-24 21:16:55 +00002549
2550 // Recurse to parse whatever is left.
2551 ParseDeclaratorInternal(D, DirectDeclParser);
2552
2553 // Sema will have to catch (syntactically invalid) pointers into global
2554 // scope. It has to catch pointers into namespace scope anyway.
2555 D.AddTypeInfo(DeclaratorChunk::getMemberPointer(SS,DS.getTypeQualifiers(),
Sebastian Redlf6591ca2009-02-09 18:23:29 +00002556 Loc, DS.TakeAttributes()),
2557 /* Don't replace range end. */SourceLocation());
Sebastian Redl9ed6efd2009-01-24 21:16:55 +00002558 return;
2559 }
2560 }
2561
2562 tok::TokenKind Kind = Tok.getKind();
Steve Naroffec33ed92008-08-27 16:04:49 +00002563 // Not a pointer, C++ reference, or block.
Chris Lattner9eac9312009-03-27 04:18:06 +00002564 if (Kind != tok::star && Kind != tok::caret &&
Chris Lattner803802d2009-03-24 17:04:48 +00002565 (Kind != tok::amp || !getLang().CPlusPlus) &&
Sebastian Redl3b27be62009-03-23 00:00:23 +00002566 // We parse rvalue refs in C++03, because otherwise the errors are scary.
Chris Lattner9eac9312009-03-27 04:18:06 +00002567 (Kind != tok::ampamp || !getLang().CPlusPlus)) {
Sebastian Redlbd150f42008-11-21 19:14:01 +00002568 if (DirectDeclParser)
2569 (this->*DirectDeclParser)(D);
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002570 return;
2571 }
Sebastian Redl9ed6efd2009-01-24 21:16:55 +00002572
Sebastian Redled0f3b02009-03-15 22:02:01 +00002573 // Otherwise, '*' -> pointer, '^' -> block, '&' -> lvalue reference,
2574 // '&&' -> rvalue reference
Sebastian Redl3b27be62009-03-23 00:00:23 +00002575 SourceLocation Loc = ConsumeToken(); // Eat the *, ^, & or &&.
Sebastian Redlf6591ca2009-02-09 18:23:29 +00002576 D.SetRangeEnd(Loc);
Bill Wendling3708c182007-05-27 10:15:43 +00002577
Chris Lattner9eac9312009-03-27 04:18:06 +00002578 if (Kind == tok::star || Kind == tok::caret) {
Chris Lattner788404f2008-02-21 01:32:26 +00002579 // Is a pointer.
Bill Wendling3708c182007-05-27 10:15:43 +00002580 DeclSpec DS;
Sebastian Redl9ed6efd2009-01-24 21:16:55 +00002581
Bill Wendling3708c182007-05-27 10:15:43 +00002582 ParseTypeQualifierListOpt(DS);
Sebastian Redlf6591ca2009-02-09 18:23:29 +00002583 D.ExtendWithDeclSpec(DS);
Sebastian Redl9ed6efd2009-01-24 21:16:55 +00002584
Bill Wendling3708c182007-05-27 10:15:43 +00002585 // Recursively parse the declarator.
Sebastian Redlbd150f42008-11-21 19:14:01 +00002586 ParseDeclaratorInternal(D, DirectDeclParser);
Steve Naroffec33ed92008-08-27 16:04:49 +00002587 if (Kind == tok::star)
2588 // Remember that we parsed a pointer type, and remember the type-quals.
2589 D.AddTypeInfo(DeclaratorChunk::getPointer(DS.getTypeQualifiers(), Loc,
Sebastian Redlf6591ca2009-02-09 18:23:29 +00002590 DS.TakeAttributes()),
2591 SourceLocation());
Steve Naroffec33ed92008-08-27 16:04:49 +00002592 else
2593 // Remember that we parsed a Block type, and remember the type-quals.
Mike Stump11289f42009-09-09 15:08:12 +00002594 D.AddTypeInfo(DeclaratorChunk::getBlockPointer(DS.getTypeQualifiers(),
Mike Stump3214d122009-04-21 00:51:43 +00002595 Loc, DS.TakeAttributes()),
Sebastian Redlf6591ca2009-02-09 18:23:29 +00002596 SourceLocation());
Bill Wendling3708c182007-05-27 10:15:43 +00002597 } else {
2598 // Is a reference
Bill Wendling93efb222007-06-02 23:28:54 +00002599 DeclSpec DS;
2600
Sebastian Redl3b27be62009-03-23 00:00:23 +00002601 // Complain about rvalue references in C++03, but then go on and build
2602 // the declarator.
2603 if (Kind == tok::ampamp && !getLang().CPlusPlus0x)
2604 Diag(Loc, diag::err_rvalue_reference);
2605
Bill Wendling93efb222007-06-02 23:28:54 +00002606 // C++ 8.3.2p1: cv-qualified references are ill-formed except when the
2607 // cv-qualifiers are introduced through the use of a typedef or of a
2608 // template type argument, in which case the cv-qualifiers are ignored.
2609 //
2610 // [GNU] Retricted references are allowed.
2611 // [GNU] Attributes on references are allowed.
Alexis Hunt96d5c762009-11-21 08:43:09 +00002612 // [C++0x] Attributes on references are not allowed.
2613 ParseTypeQualifierListOpt(DS, true, false);
Sebastian Redlf6591ca2009-02-09 18:23:29 +00002614 D.ExtendWithDeclSpec(DS);
Bill Wendling93efb222007-06-02 23:28:54 +00002615
2616 if (DS.getTypeQualifiers() != DeclSpec::TQ_unspecified) {
2617 if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
2618 Diag(DS.getConstSpecLoc(),
Chris Lattner6d29c102008-11-18 07:48:38 +00002619 diag::err_invalid_reference_qualifier_application) << "const";
Bill Wendling93efb222007-06-02 23:28:54 +00002620 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
2621 Diag(DS.getVolatileSpecLoc(),
Chris Lattner6d29c102008-11-18 07:48:38 +00002622 diag::err_invalid_reference_qualifier_application) << "volatile";
Bill Wendling93efb222007-06-02 23:28:54 +00002623 }
Bill Wendling3708c182007-05-27 10:15:43 +00002624
2625 // Recursively parse the declarator.
Sebastian Redlbd150f42008-11-21 19:14:01 +00002626 ParseDeclaratorInternal(D, DirectDeclParser);
Bill Wendling3708c182007-05-27 10:15:43 +00002627
Douglas Gregor66583c52008-11-03 15:51:28 +00002628 if (D.getNumTypeObjects() > 0) {
2629 // C++ [dcl.ref]p4: There shall be no references to references.
2630 DeclaratorChunk& InnerChunk = D.getTypeObject(D.getNumTypeObjects() - 1);
2631 if (InnerChunk.Kind == DeclaratorChunk::Reference) {
Chris Lattnerebad6a22008-11-19 07:37:42 +00002632 if (const IdentifierInfo *II = D.getIdentifier())
2633 Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference)
2634 << II;
2635 else
2636 Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference)
2637 << "type name";
Douglas Gregor66583c52008-11-03 15:51:28 +00002638
Sebastian Redlbd150f42008-11-21 19:14:01 +00002639 // Once we've complained about the reference-to-reference, we
Douglas Gregor66583c52008-11-03 15:51:28 +00002640 // can go ahead and build the (technically ill-formed)
2641 // declarator: reference collapsing will take care of it.
2642 }
2643 }
2644
Bill Wendling3708c182007-05-27 10:15:43 +00002645 // Remember that we parsed a reference type. It doesn't have type-quals.
Chris Lattner788404f2008-02-21 01:32:26 +00002646 D.AddTypeInfo(DeclaratorChunk::getReference(DS.getTypeQualifiers(), Loc,
Sebastian Redled0f3b02009-03-15 22:02:01 +00002647 DS.TakeAttributes(),
2648 Kind == tok::amp),
Sebastian Redlf6591ca2009-02-09 18:23:29 +00002649 SourceLocation());
Bill Wendling3708c182007-05-27 10:15:43 +00002650 }
Chris Lattner6c7416c2006-08-07 00:19:33 +00002651}
2652
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00002653/// ParseDirectDeclarator
2654/// direct-declarator: [C99 6.7.5]
Douglas Gregor831c93f2008-11-05 20:51:48 +00002655/// [C99] identifier
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00002656/// '(' declarator ')'
2657/// [GNU] '(' attributes declarator ')'
Chris Lattnere8074e62006-08-06 18:30:15 +00002658/// [C90] direct-declarator '[' constant-expression[opt] ']'
2659/// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
2660/// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
2661/// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']'
2662/// [C99] direct-declarator '[' type-qual-list[opt] '*' ']'
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00002663/// direct-declarator '(' parameter-type-list ')'
2664/// direct-declarator '(' identifier-list[opt] ')'
2665/// [GNU] direct-declarator '(' parameter-forward-declarations
2666/// parameter-type-list[opt] ')'
Argyrios Kyrtzidis22c40fa2008-10-24 21:46:40 +00002667/// [C++] direct-declarator '(' parameter-declaration-clause ')'
2668/// cv-qualifier-seq[opt] exception-specification[opt]
Douglas Gregor61956c42008-10-31 09:07:45 +00002669/// [C++] declarator-id
Douglas Gregor831c93f2008-11-05 20:51:48 +00002670///
2671/// declarator-id: [C++ 8]
2672/// id-expression
2673/// '::'[opt] nested-name-specifier[opt] type-name
2674///
2675/// id-expression: [C++ 5.1]
2676/// unqualified-id
Douglas Gregord90fd522009-09-25 21:45:23 +00002677/// qualified-id
Douglas Gregor831c93f2008-11-05 20:51:48 +00002678///
2679/// unqualified-id: [C++ 5.1]
Mike Stump11289f42009-09-09 15:08:12 +00002680/// identifier
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +00002681/// operator-function-id
Douglas Gregord90fd522009-09-25 21:45:23 +00002682/// conversion-function-id
Mike Stump11289f42009-09-09 15:08:12 +00002683/// '~' class-name
Douglas Gregor7f741122009-02-25 19:37:18 +00002684/// template-id
Argyrios Kyrtzidise4426352008-11-07 22:02:30 +00002685///
Chris Lattneracd58a32006-08-06 17:24:14 +00002686void Parser::ParseDirectDeclarator(Declarator &D) {
Argyrios Kyrtzidis9323b042008-11-26 22:40:03 +00002687 DeclaratorScopeObj DeclScopeObj(*this, D.getCXXScopeSpec());
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +00002688
Douglas Gregor7861a802009-11-03 01:35:08 +00002689 if (getLang().CPlusPlus && D.mayHaveIdentifier()) {
2690 // ParseDeclaratorInternal might already have parsed the scope.
Jeffrey Yasskinc76498d2010-04-08 16:38:48 +00002691 if (D.getCXXScopeSpec().isEmpty()) {
John McCallba7bf592010-08-24 05:47:05 +00002692 ParseOptionalCXXScopeSpecifier(D.getCXXScopeSpec(), ParsedType(), true);
John McCall1f476a12010-02-26 08:45:28 +00002693 }
2694
Jeffrey Yasskinc76498d2010-04-08 16:38:48 +00002695 if (D.getCXXScopeSpec().isValid()) {
Douglas Gregor0be31a22010-07-02 17:43:08 +00002696 if (Actions.ShouldEnterDeclaratorScope(getCurScope(), D.getCXXScopeSpec()))
John McCall2b058ef2009-12-11 20:04:54 +00002697 // Change the declaration context for name lookup, until this function
2698 // is exited (and the declarator has been parsed).
2699 DeclScopeObj.EnterDeclaratorScope();
Jeffrey Yasskinc76498d2010-04-08 16:38:48 +00002700 }
2701
Douglas Gregor7861a802009-11-03 01:35:08 +00002702 if (Tok.is(tok::identifier) || Tok.is(tok::kw_operator) ||
2703 Tok.is(tok::annot_template_id) || Tok.is(tok::tilde)) {
2704 // We found something that indicates the start of an unqualified-id.
2705 // Parse that unqualified-id.
John McCall84821e72010-04-13 06:39:49 +00002706 bool AllowConstructorName;
2707 if (D.getDeclSpec().hasTypeSpecifier())
2708 AllowConstructorName = false;
2709 else if (D.getCXXScopeSpec().isSet())
2710 AllowConstructorName =
2711 (D.getContext() == Declarator::FileContext ||
2712 (D.getContext() == Declarator::MemberContext &&
2713 D.getDeclSpec().isFriendSpecified()));
2714 else
2715 AllowConstructorName = (D.getContext() == Declarator::MemberContext);
2716
Douglas Gregor7861a802009-11-03 01:35:08 +00002717 if (ParseUnqualifiedId(D.getCXXScopeSpec(),
2718 /*EnteringContext=*/true,
2719 /*AllowDestructorName=*/true,
Douglas Gregor9de54ea2010-01-13 17:31:36 +00002720 AllowConstructorName,
John McCallba7bf592010-08-24 05:47:05 +00002721 ParsedType(),
Jeffrey Yasskinc76498d2010-04-08 16:38:48 +00002722 D.getName()) ||
2723 // Once we're past the identifier, if the scope was bad, mark the
2724 // whole declarator bad.
2725 D.getCXXScopeSpec().isInvalid()) {
Argyrios Kyrtzidis9323b042008-11-26 22:40:03 +00002726 D.SetIdentifier(0, Tok.getLocation());
2727 D.setInvalidType(true);
Douglas Gregor7861a802009-11-03 01:35:08 +00002728 } else {
2729 // Parsed the unqualified-id; update range information and move along.
2730 if (D.getSourceRange().getBegin().isInvalid())
2731 D.SetRangeBegin(D.getName().getSourceRange().getBegin());
2732 D.SetRangeEnd(D.getName().getSourceRange().getEnd());
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002733 }
Douglas Gregor7861a802009-11-03 01:35:08 +00002734 goto PastIdentifier;
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00002735 }
Douglas Gregor7861a802009-11-03 01:35:08 +00002736 } else if (Tok.is(tok::identifier) && D.mayHaveIdentifier()) {
Argyrios Kyrtzidis9323b042008-11-26 22:40:03 +00002737 assert(!getLang().CPlusPlus &&
2738 "There's a C++-specific check for tok::identifier above");
2739 assert(Tok.getIdentifierInfo() && "Not an identifier?");
2740 D.SetIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
2741 ConsumeToken();
Douglas Gregor7861a802009-11-03 01:35:08 +00002742 goto PastIdentifier;
2743 }
2744
2745 if (Tok.is(tok::l_paren)) {
Chris Lattneracd58a32006-08-06 17:24:14 +00002746 // direct-declarator: '(' declarator ')'
Chris Lattnere37e2332006-08-15 04:50:22 +00002747 // direct-declarator: '(' attributes declarator ')'
Chris Lattneracd58a32006-08-06 17:24:14 +00002748 // Example: 'char (*X)' or 'int (*XX)(void)'
2749 ParseParenDeclarator(D);
Douglas Gregor9de54ea2010-01-13 17:31:36 +00002750
2751 // If the declarator was parenthesized, we entered the declarator
2752 // scope when parsing the parenthesized declarator, then exited
2753 // the scope already. Re-enter the scope, if we need to.
2754 if (D.getCXXScopeSpec().isSet()) {
Fariborz Jahanian358acd52010-08-17 23:50:37 +00002755 // If there was an error parsing parenthesized declarator, declarator
2756 // scope may have been enterred before. Don't do it again.
2757 if (!D.isInvalidType() &&
2758 Actions.ShouldEnterDeclaratorScope(getCurScope(), D.getCXXScopeSpec()))
Douglas Gregor9de54ea2010-01-13 17:31:36 +00002759 // Change the declaration context for name lookup, until this function
2760 // is exited (and the declarator has been parsed).
Fariborz Jahanian358acd52010-08-17 23:50:37 +00002761 DeclScopeObj.EnterDeclaratorScope();
Douglas Gregor9de54ea2010-01-13 17:31:36 +00002762 }
Argyrios Kyrtzidis9323b042008-11-26 22:40:03 +00002763 } else if (D.mayOmitIdentifier()) {
Chris Lattneracd58a32006-08-06 17:24:14 +00002764 // This could be something simple like "int" (in which case the declarator
2765 // portion is empty), if an abstract-declarator is allowed.
2766 D.SetIdentifier(0, Tok.getLocation());
2767 } else {
Douglas Gregord9f92e22009-03-06 23:28:18 +00002768 if (D.getContext() == Declarator::MemberContext)
2769 Diag(Tok, diag::err_expected_member_name_or_semi)
2770 << D.getDeclSpec().getSourceRange();
2771 else if (getLang().CPlusPlus)
Douglas Gregor30d60cb2009-11-03 19:44:04 +00002772 Diag(Tok, diag::err_expected_unqualified_id) << getLang().CPlusPlus;
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +00002773 else
Chris Lattner6d29c102008-11-18 07:48:38 +00002774 Diag(Tok, diag::err_expected_ident_lparen);
Chris Lattnereec40f92006-08-06 21:55:29 +00002775 D.SetIdentifier(0, Tok.getLocation());
Chris Lattner8c5dd732008-11-11 06:13:16 +00002776 D.setInvalidType(true);
Chris Lattneracd58a32006-08-06 17:24:14 +00002777 }
Mike Stump11289f42009-09-09 15:08:12 +00002778
Argyrios Kyrtzidis9323b042008-11-26 22:40:03 +00002779 PastIdentifier:
Chris Lattneracd58a32006-08-06 17:24:14 +00002780 assert(D.isPastIdentifier() &&
2781 "Haven't past the location of the identifier yet?");
Mike Stump11289f42009-09-09 15:08:12 +00002782
Alexis Hunt96d5c762009-11-21 08:43:09 +00002783 // Don't parse attributes unless we have an identifier.
Douglas Gregor0286b462010-02-19 16:47:56 +00002784 if (D.getIdentifier() && getLang().CPlusPlus0x
Alexis Hunt96d5c762009-11-21 08:43:09 +00002785 && isCXX0XAttributeSpecifier(true)) {
2786 SourceLocation AttrEndLoc;
2787 CXX0XAttributeList Attr = ParseCXX0XAttributes();
2788 D.AddAttributes(Attr.AttrList, AttrEndLoc);
2789 }
2790
Chris Lattneracd58a32006-08-06 17:24:14 +00002791 while (1) {
Chris Lattner76c72282007-10-09 17:33:22 +00002792 if (Tok.is(tok::l_paren)) {
Argyrios Kyrtzidis9a1191c2008-10-06 17:10:33 +00002793 // The paren may be part of a C++ direct initializer, eg. "int x(1);".
2794 // In such a case, check if we actually have a function declarator; if it
2795 // is not, the declarator has been fully parsed.
Chris Lattner8ff2c6c2008-10-20 02:05:46 +00002796 if (getLang().CPlusPlus && D.mayBeFollowedByCXXDirectInit()) {
2797 // When not in file scope, warn for ambiguous function declarators, just
2798 // in case the author intended it as a variable definition.
2799 bool warnIfAmbiguous = D.getContext() != Declarator::FileContext;
2800 if (!isCXXFunctionDeclarator(warnIfAmbiguous))
2801 break;
2802 }
Chris Lattnerc0a1c7d2008-04-06 05:45:57 +00002803 ParseFunctionDeclarator(ConsumeParen(), D);
Chris Lattner76c72282007-10-09 17:33:22 +00002804 } else if (Tok.is(tok::l_square)) {
Chris Lattnere8074e62006-08-06 18:30:15 +00002805 ParseBracketDeclarator(D);
Chris Lattneracd58a32006-08-06 17:24:14 +00002806 } else {
2807 break;
2808 }
2809 }
2810}
2811
Chris Lattnerc0a1c7d2008-04-06 05:45:57 +00002812/// ParseParenDeclarator - We parsed the declarator D up to a paren. This is
2813/// only called before the identifier, so these are most likely just grouping
Mike Stump11289f42009-09-09 15:08:12 +00002814/// parens for precedence. If we find that these are actually function
Chris Lattnerc0a1c7d2008-04-06 05:45:57 +00002815/// parameter parens in an abstract-declarator, we call ParseFunctionDeclarator.
2816///
2817/// direct-declarator:
2818/// '(' declarator ')'
2819/// [GNU] '(' attributes declarator ')'
Chris Lattner8ff2c6c2008-10-20 02:05:46 +00002820/// direct-declarator '(' parameter-type-list ')'
2821/// direct-declarator '(' identifier-list[opt] ')'
2822/// [GNU] direct-declarator '(' parameter-forward-declarations
2823/// parameter-type-list[opt] ')'
Chris Lattnerc0a1c7d2008-04-06 05:45:57 +00002824///
2825void Parser::ParseParenDeclarator(Declarator &D) {
2826 SourceLocation StartLoc = ConsumeParen();
2827 assert(!D.isPastIdentifier() && "Should be called before passing identifier");
Mike Stump11289f42009-09-09 15:08:12 +00002828
Chris Lattner8ff2c6c2008-10-20 02:05:46 +00002829 // Eat any attributes before we look at whether this is a grouping or function
2830 // declarator paren. If this is a grouping paren, the attribute applies to
2831 // the type being built up, for example:
2832 // int (__attribute__(()) *x)(long y)
2833 // If this ends up not being a grouping paren, the attribute applies to the
2834 // first argument, for example:
2835 // int (__attribute__(()) int x)
2836 // In either case, we need to eat any attributes to be able to determine what
2837 // sort of paren this is.
2838 //
Ted Kremenekc162e8e2010-02-11 02:19:13 +00002839 llvm::OwningPtr<AttributeList> AttrList;
Chris Lattner8ff2c6c2008-10-20 02:05:46 +00002840 bool RequiresArg = false;
2841 if (Tok.is(tok::kw___attribute)) {
Ted Kremenekc162e8e2010-02-11 02:19:13 +00002842 AttrList.reset(ParseGNUAttributes());
Mike Stump11289f42009-09-09 15:08:12 +00002843
Chris Lattner8ff2c6c2008-10-20 02:05:46 +00002844 // We require that the argument list (if this is a non-grouping paren) be
2845 // present even if the attribute list was empty.
2846 RequiresArg = true;
2847 }
Steve Naroff44ac7772008-12-25 14:16:32 +00002848 // Eat any Microsoft extensions.
Eli Friedman53339e02009-06-08 23:27:34 +00002849 if (Tok.is(tok::kw___cdecl) || Tok.is(tok::kw___stdcall) ||
Douglas Gregora941dca2010-05-18 16:57:00 +00002850 Tok.is(tok::kw___thiscall) || Tok.is(tok::kw___fastcall) ||
2851 Tok.is(tok::kw___w64) || Tok.is(tok::kw___ptr64)) {
Ted Kremenekc162e8e2010-02-11 02:19:13 +00002852 AttrList.reset(ParseMicrosoftTypeAttributes(AttrList.take()));
Eli Friedman53339e02009-06-08 23:27:34 +00002853 }
Mike Stump11289f42009-09-09 15:08:12 +00002854
Chris Lattnerc0a1c7d2008-04-06 05:45:57 +00002855 // If we haven't past the identifier yet (or where the identifier would be
2856 // stored, if this is an abstract declarator), then this is probably just
2857 // grouping parens. However, if this could be an abstract-declarator, then
2858 // this could also be the start of function arguments (consider 'void()').
2859 bool isGrouping;
Mike Stump11289f42009-09-09 15:08:12 +00002860
Chris Lattnerc0a1c7d2008-04-06 05:45:57 +00002861 if (!D.mayOmitIdentifier()) {
2862 // If this can't be an abstract-declarator, this *must* be a grouping
2863 // paren, because we haven't seen the identifier yet.
2864 isGrouping = true;
2865 } else if (Tok.is(tok::r_paren) || // 'int()' is a function.
Argyrios Kyrtzidise8addf52008-10-06 00:07:55 +00002866 (getLang().CPlusPlus && Tok.is(tok::ellipsis)) || // C++ int(...)
Chris Lattnerc0a1c7d2008-04-06 05:45:57 +00002867 isDeclarationSpecifier()) { // 'int(int)' is a function.
2868 // This handles C99 6.7.5.3p11: in "typedef int X; void foo(X)", X is
2869 // considered to be a type, not a K&R identifier-list.
2870 isGrouping = false;
2871 } else {
2872 // Otherwise, this is a grouping paren, e.g. 'int (*X)' or 'int(X)'.
2873 isGrouping = true;
2874 }
Mike Stump11289f42009-09-09 15:08:12 +00002875
Chris Lattnerc0a1c7d2008-04-06 05:45:57 +00002876 // If this is a grouping paren, handle:
2877 // direct-declarator: '(' declarator ')'
2878 // direct-declarator: '(' attributes declarator ')'
2879 if (isGrouping) {
Argyrios Kyrtzidis8ae36842008-10-07 10:21:57 +00002880 bool hadGroupingParens = D.hasGroupingParens();
Argyrios Kyrtzidis9a1191c2008-10-06 17:10:33 +00002881 D.setGroupingParens(true);
Chris Lattner8ff2c6c2008-10-20 02:05:46 +00002882 if (AttrList)
Ted Kremenekc162e8e2010-02-11 02:19:13 +00002883 D.AddAttributes(AttrList.take(), SourceLocation());
Argyrios Kyrtzidis9a1191c2008-10-06 17:10:33 +00002884
Sebastian Redlbd150f42008-11-21 19:14:01 +00002885 ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
Chris Lattnerc0a1c7d2008-04-06 05:45:57 +00002886 // Match the ')'.
Sebastian Redlf6591ca2009-02-09 18:23:29 +00002887 SourceLocation Loc = MatchRHSPunctuation(tok::r_paren, StartLoc);
Argyrios Kyrtzidis8ae36842008-10-07 10:21:57 +00002888
2889 D.setGroupingParens(hadGroupingParens);
Sebastian Redlf6591ca2009-02-09 18:23:29 +00002890 D.SetRangeEnd(Loc);
Chris Lattnerc0a1c7d2008-04-06 05:45:57 +00002891 return;
2892 }
Mike Stump11289f42009-09-09 15:08:12 +00002893
Chris Lattnerc0a1c7d2008-04-06 05:45:57 +00002894 // Okay, if this wasn't a grouping paren, it must be the start of a function
2895 // argument list. Recognize that this declarator will never have an
Chris Lattner8ff2c6c2008-10-20 02:05:46 +00002896 // identifier (and remember where it would have been), then call into
2897 // ParseFunctionDeclarator to handle of argument list.
Chris Lattnerc0a1c7d2008-04-06 05:45:57 +00002898 D.SetIdentifier(0, Tok.getLocation());
2899
Ted Kremenekc162e8e2010-02-11 02:19:13 +00002900 ParseFunctionDeclarator(StartLoc, D, AttrList.take(), RequiresArg);
Chris Lattnerc0a1c7d2008-04-06 05:45:57 +00002901}
2902
2903/// ParseFunctionDeclarator - We are after the identifier and have parsed the
2904/// declarator D up to a paren, which indicates that we are parsing function
2905/// arguments.
Chris Lattneracd58a32006-08-06 17:24:14 +00002906///
Chris Lattner8ff2c6c2008-10-20 02:05:46 +00002907/// If AttrList is non-null, then the caller parsed those arguments immediately
2908/// after the open paren - they should be considered to be the first argument of
2909/// a parameter. If RequiresArg is true, then the first argument of the
2910/// function is required to be present and required to not be an identifier
2911/// list.
2912///
Chris Lattneracd58a32006-08-06 17:24:14 +00002913/// This method also handles this portion of the grammar:
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00002914/// parameter-type-list: [C99 6.7.5]
2915/// parameter-list
2916/// parameter-list ',' '...'
Douglas Gregor9bfc2e52009-09-22 21:41:40 +00002917/// [C++] parameter-list '...'
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00002918///
2919/// parameter-list: [C99 6.7.5]
2920/// parameter-declaration
2921/// parameter-list ',' parameter-declaration
2922///
2923/// parameter-declaration: [C99 6.7.5]
2924/// declaration-specifiers declarator
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00002925/// [C++] declaration-specifiers declarator '=' assignment-expression
Chris Lattnere37e2332006-08-15 04:50:22 +00002926/// [GNU] declaration-specifiers declarator attributes
Sebastian Redlf769df52009-03-24 22:27:57 +00002927/// declaration-specifiers abstract-declarator[opt]
2928/// [C++] declaration-specifiers abstract-declarator[opt]
Chris Lattner58258242008-04-10 02:22:51 +00002929/// '=' assignment-expression
Chris Lattnere37e2332006-08-15 04:50:22 +00002930/// [GNU] declaration-specifiers abstract-declarator[opt] attributes
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00002931///
Argyrios Kyrtzidis22c40fa2008-10-24 21:46:40 +00002932/// For C++, after the parameter-list, it also parses "cv-qualifier-seq[opt]"
Sebastian Redlf769df52009-03-24 22:27:57 +00002933/// and "exception-specification[opt]".
Argyrios Kyrtzidis22c40fa2008-10-24 21:46:40 +00002934///
Chris Lattner8ff2c6c2008-10-20 02:05:46 +00002935void Parser::ParseFunctionDeclarator(SourceLocation LParenLoc, Declarator &D,
2936 AttributeList *AttrList,
2937 bool RequiresArg) {
Chris Lattnerc0a1c7d2008-04-06 05:45:57 +00002938 // lparen is already consumed!
2939 assert(D.isPastIdentifier() && "Should not call before identifier!");
Mike Stump11289f42009-09-09 15:08:12 +00002940
Chris Lattner8ff2c6c2008-10-20 02:05:46 +00002941 // This parameter list may be empty.
Chris Lattner76c72282007-10-09 17:33:22 +00002942 if (Tok.is(tok::r_paren)) {
Chris Lattner8ff2c6c2008-10-20 02:05:46 +00002943 if (RequiresArg) {
Chris Lattner6d29c102008-11-18 07:48:38 +00002944 Diag(Tok, diag::err_argument_required_after_attribute);
Chris Lattner8ff2c6c2008-10-20 02:05:46 +00002945 delete AttrList;
2946 }
Argyrios Kyrtzidis22c40fa2008-10-24 21:46:40 +00002947
Argyrios Kyrtzidis20cf1912009-08-19 23:14:54 +00002948 SourceLocation RParenLoc = ConsumeParen(); // Eat the closing ')'.
2949 SourceLocation EndLoc = RParenLoc;
Argyrios Kyrtzidis22c40fa2008-10-24 21:46:40 +00002950
2951 // cv-qualifier-seq[opt].
2952 DeclSpec DS;
Sebastian Redl2b9cacb2009-04-29 17:30:04 +00002953 bool hasExceptionSpec = false;
Sebastian Redlfb3f1792009-05-31 11:47:27 +00002954 SourceLocation ThrowLoc;
Sebastian Redl2b9cacb2009-04-29 17:30:04 +00002955 bool hasAnyExceptionSpec = false;
John McCallba7bf592010-08-24 05:47:05 +00002956 llvm::SmallVector<ParsedType, 2> Exceptions;
Sebastian Redld6434562009-05-29 18:02:33 +00002957 llvm::SmallVector<SourceRange, 2> ExceptionRanges;
Argyrios Kyrtzidis22c40fa2008-10-24 21:46:40 +00002958 if (getLang().CPlusPlus) {
Chris Lattnercf0bab22008-12-18 07:02:59 +00002959 ParseTypeQualifierListOpt(DS, false /*no attributes*/);
Sebastian Redlf6591ca2009-02-09 18:23:29 +00002960 if (!DS.getSourceRange().getEnd().isInvalid())
Argyrios Kyrtzidis20cf1912009-08-19 23:14:54 +00002961 EndLoc = DS.getSourceRange().getEnd();
Douglas Gregor2afd0be2008-11-25 03:22:00 +00002962
2963 // Parse exception-specification[opt].
Sebastian Redl2b9cacb2009-04-29 17:30:04 +00002964 if (Tok.is(tok::kw_throw)) {
2965 hasExceptionSpec = true;
Sebastian Redlfb3f1792009-05-31 11:47:27 +00002966 ThrowLoc = Tok.getLocation();
Argyrios Kyrtzidis20cf1912009-08-19 23:14:54 +00002967 ParseExceptionSpecification(EndLoc, Exceptions, ExceptionRanges,
Sebastian Redld6434562009-05-29 18:02:33 +00002968 hasAnyExceptionSpec);
2969 assert(Exceptions.size() == ExceptionRanges.size() &&
2970 "Produced different number of exception types and ranges.");
Sebastian Redl2b9cacb2009-04-29 17:30:04 +00002971 }
Argyrios Kyrtzidis22c40fa2008-10-24 21:46:40 +00002972 }
2973
Chris Lattner371ed4e2008-04-06 06:57:35 +00002974 // Remember that we parsed a function type, and remember the attributes.
Chris Lattneracd58a32006-08-06 17:24:14 +00002975 // int() -> no prototype, no '...'.
Argyrios Kyrtzidis22c40fa2008-10-24 21:46:40 +00002976 D.AddTypeInfo(DeclaratorChunk::getFunction(/*prototype*/getLang().CPlusPlus,
Chris Lattner371ed4e2008-04-06 06:57:35 +00002977 /*variadic*/ false,
Douglas Gregor94349fd2009-02-18 07:07:28 +00002978 SourceLocation(),
Argyrios Kyrtzidis22c40fa2008-10-24 21:46:40 +00002979 /*arglist*/ 0, 0,
2980 DS.getTypeQualifiers(),
Sebastian Redlfb3f1792009-05-31 11:47:27 +00002981 hasExceptionSpec, ThrowLoc,
Sebastian Redl2b9cacb2009-04-29 17:30:04 +00002982 hasAnyExceptionSpec,
Sebastian Redld6434562009-05-29 18:02:33 +00002983 Exceptions.data(),
2984 ExceptionRanges.data(),
Sebastian Redl2b9cacb2009-04-29 17:30:04 +00002985 Exceptions.size(),
Argyrios Kyrtzidis20cf1912009-08-19 23:14:54 +00002986 LParenLoc, RParenLoc, D),
2987 EndLoc);
Chris Lattner371ed4e2008-04-06 06:57:35 +00002988 return;
Sebastian Redld6434562009-05-29 18:02:33 +00002989 }
2990
Chris Lattner8ff2c6c2008-10-20 02:05:46 +00002991 // Alternatively, this parameter list may be an identifier list form for a
2992 // K&R-style function: void foo(a,b,c)
John Thompson22334602010-02-05 00:12:22 +00002993 if (!getLang().CPlusPlus && Tok.is(tok::identifier)
2994 && !TryAltiVecVectorToken()) {
John McCall1f476a12010-02-26 08:45:28 +00002995 if (TryAnnotateTypeOrScopeToken() || !Tok.is(tok::annot_typename)) {
Chris Lattner8ff2c6c2008-10-20 02:05:46 +00002996 // K&R identifier lists can't have typedefs as identifiers, per
2997 // C99 6.7.5.3p11.
Steve Naroffb0486722009-01-28 19:16:40 +00002998 if (RequiresArg) {
2999 Diag(Tok, diag::err_argument_required_after_attribute);
3000 delete AttrList;
3001 }
Chris Lattner9453ab82010-05-14 17:23:36 +00003002
Steve Naroffb0486722009-01-28 19:16:40 +00003003 // Identifier list. Note that '(' identifier-list ')' is only allowed for
Chris Lattner9453ab82010-05-14 17:23:36 +00003004 // normal declarators, not for abstract-declarators. Get the first
3005 // identifier.
Chris Lattnerff895c12010-05-14 17:44:56 +00003006 Token FirstTok = Tok;
Chris Lattner9453ab82010-05-14 17:23:36 +00003007 ConsumeToken(); // eat the first identifier.
Chris Lattnerff895c12010-05-14 17:44:56 +00003008
3009 // Identifier lists follow a really simple grammar: the identifiers can
3010 // be followed *only* by a ", moreidentifiers" or ")". However, K&R
3011 // identifier lists are really rare in the brave new modern world, and it
3012 // is very common for someone to typo a type in a non-k&r style list. If
3013 // we are presented with something like: "void foo(intptr x, float y)",
3014 // we don't want to start parsing the function declarator as though it is
3015 // a K&R style declarator just because intptr is an invalid type.
3016 //
3017 // To handle this, we check to see if the token after the first identifier
3018 // is a "," or ")". Only if so, do we parse it as an identifier list.
3019 if (Tok.is(tok::comma) || Tok.is(tok::r_paren))
3020 return ParseFunctionDeclaratorIdentifierList(LParenLoc,
3021 FirstTok.getIdentifierInfo(),
3022 FirstTok.getLocation(), D);
3023
3024 // If we get here, the code is invalid. Push the first identifier back
3025 // into the token stream and parse the first argument as an (invalid)
3026 // normal argument declarator.
3027 PP.EnterToken(Tok);
3028 Tok = FirstTok;
Chris Lattner8ff2c6c2008-10-20 02:05:46 +00003029 }
Chris Lattner371ed4e2008-04-06 06:57:35 +00003030 }
Mike Stump11289f42009-09-09 15:08:12 +00003031
Chris Lattner371ed4e2008-04-06 06:57:35 +00003032 // Finally, a normal, non-empty parameter type list.
Mike Stump11289f42009-09-09 15:08:12 +00003033
Chris Lattner371ed4e2008-04-06 06:57:35 +00003034 // Build up an array of information about the parsed arguments.
3035 llvm::SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00003036
3037 // Enter function-declaration scope, limiting any declarators to the
3038 // function prototype scope, including parameter declarators.
Chris Lattnerbd61a952009-03-05 00:00:31 +00003039 ParseScope PrototypeScope(this,
3040 Scope::FunctionPrototypeScope|Scope::DeclScope);
Mike Stump11289f42009-09-09 15:08:12 +00003041
Chris Lattner371ed4e2008-04-06 06:57:35 +00003042 bool IsVariadic = false;
Douglas Gregor94349fd2009-02-18 07:07:28 +00003043 SourceLocation EllipsisLoc;
Chris Lattner371ed4e2008-04-06 06:57:35 +00003044 while (1) {
3045 if (Tok.is(tok::ellipsis)) {
3046 IsVariadic = true;
Douglas Gregor94349fd2009-02-18 07:07:28 +00003047 EllipsisLoc = ConsumeToken(); // Consume the ellipsis.
Chris Lattner371ed4e2008-04-06 06:57:35 +00003048 break;
Chris Lattneracd58a32006-08-06 17:24:14 +00003049 }
Mike Stump11289f42009-09-09 15:08:12 +00003050
Chris Lattner371ed4e2008-04-06 06:57:35 +00003051 SourceLocation DSStart = Tok.getLocation();
Mike Stump11289f42009-09-09 15:08:12 +00003052
Chris Lattner371ed4e2008-04-06 06:57:35 +00003053 // Parse the declaration-specifiers.
John McCall28a6aea2009-11-04 02:18:39 +00003054 // Just use the ParsingDeclaration "scope" of the declarator.
Chris Lattner371ed4e2008-04-06 06:57:35 +00003055 DeclSpec DS;
Chris Lattner8ff2c6c2008-10-20 02:05:46 +00003056
3057 // If the caller parsed attributes for the first argument, add them now.
3058 if (AttrList) {
3059 DS.AddAttributes(AttrList);
3060 AttrList = 0; // Only apply the attributes to the first parameter.
3061 }
Chris Lattnerde39c3e2009-02-27 18:38:20 +00003062 ParseDeclarationSpecifiers(DS);
Mike Stump11289f42009-09-09 15:08:12 +00003063
Chris Lattner371ed4e2008-04-06 06:57:35 +00003064 // Parse the declarator. This is "PrototypeContext", because we must
3065 // accept either 'declarator' or 'abstract-declarator' here.
3066 Declarator ParmDecl(DS, Declarator::PrototypeContext);
3067 ParseDeclarator(ParmDecl);
3068
3069 // Parse GNU attributes, if present.
Sebastian Redlf6591ca2009-02-09 18:23:29 +00003070 if (Tok.is(tok::kw___attribute)) {
3071 SourceLocation Loc;
Alexis Hunt96d5c762009-11-21 08:43:09 +00003072 AttributeList *AttrList = ParseGNUAttributes(&Loc);
Sebastian Redlf6591ca2009-02-09 18:23:29 +00003073 ParmDecl.AddAttributes(AttrList, Loc);
3074 }
Mike Stump11289f42009-09-09 15:08:12 +00003075
Chris Lattner371ed4e2008-04-06 06:57:35 +00003076 // Remember this parsed parameter in ParamInfo.
3077 IdentifierInfo *ParmII = ParmDecl.getIdentifier();
Mike Stump11289f42009-09-09 15:08:12 +00003078
Douglas Gregor4d87df52008-12-16 21:30:33 +00003079 // DefArgToks is used when the parsing of default arguments needs
3080 // to be delayed.
3081 CachedTokens *DefArgToks = 0;
3082
Chris Lattner371ed4e2008-04-06 06:57:35 +00003083 // If no parameter was specified, verify that *something* was specified,
3084 // otherwise we have a missing type and identifier.
Chris Lattnerde39c3e2009-02-27 18:38:20 +00003085 if (DS.isEmpty() && ParmDecl.getIdentifier() == 0 &&
3086 ParmDecl.getNumTypeObjects() == 0) {
Chris Lattner371ed4e2008-04-06 06:57:35 +00003087 // Completely missing, emit error.
3088 Diag(DSStart, diag::err_missing_param);
3089 } else {
3090 // Otherwise, we have something. Add it and let semantic analysis try
3091 // to grok it and add the result to the ParamInfo we are building.
Mike Stump11289f42009-09-09 15:08:12 +00003092
Chris Lattner371ed4e2008-04-06 06:57:35 +00003093 // Inform the actions module about the parameter declarator, so it gets
3094 // added to the current scope.
John McCall48871652010-08-21 09:40:31 +00003095 Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDecl);
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00003096
3097 // Parse the default argument, if any. We parse the default
3098 // arguments in all dialects; the semantic analysis in
3099 // ActOnParamDefaultArgument will reject the default argument in
3100 // C.
3101 if (Tok.is(tok::equal)) {
Douglas Gregor58354032008-12-24 00:01:03 +00003102 SourceLocation EqualLoc = Tok.getLocation();
3103
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00003104 // Parse the default argument
Douglas Gregor4d87df52008-12-16 21:30:33 +00003105 if (D.getContext() == Declarator::MemberContext) {
3106 // If we're inside a class definition, cache the tokens
3107 // corresponding to the default argument. We'll actually parse
3108 // them when we see the end of the class definition.
3109 // FIXME: Templates will require something similar.
3110 // FIXME: Can we use a smart pointer for Toks?
3111 DefArgToks = new CachedTokens;
3112
Mike Stump11289f42009-09-09 15:08:12 +00003113 if (!ConsumeAndStoreUntil(tok::comma, tok::r_paren, *DefArgToks,
Argyrios Kyrtzidis8d7bdba2010-04-23 21:20:12 +00003114 /*StopAtSemi=*/true,
3115 /*ConsumeFinalToken=*/false)) {
Douglas Gregor4d87df52008-12-16 21:30:33 +00003116 delete DefArgToks;
3117 DefArgToks = 0;
Douglas Gregor58354032008-12-24 00:01:03 +00003118 Actions.ActOnParamDefaultArgumentError(Param);
Argyrios Kyrtzidis249179c2010-08-06 09:47:24 +00003119 } else {
3120 // Mark the end of the default argument so that we know when to
3121 // stop when we parse it later on.
3122 Token DefArgEnd;
3123 DefArgEnd.startToken();
3124 DefArgEnd.setKind(tok::cxx_defaultarg_end);
3125 DefArgEnd.setLocation(Tok.getLocation());
3126 DefArgToks->push_back(DefArgEnd);
Mike Stump11289f42009-09-09 15:08:12 +00003127 Actions.ActOnParamUnparsedDefaultArgument(Param, EqualLoc,
Anders Carlsson84613c42009-06-12 16:51:40 +00003128 (*DefArgToks)[1].getLocation());
Argyrios Kyrtzidis249179c2010-08-06 09:47:24 +00003129 }
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00003130 } else {
Douglas Gregor4d87df52008-12-16 21:30:33 +00003131 // Consume the '='.
Douglas Gregor58354032008-12-24 00:01:03 +00003132 ConsumeToken();
Mike Stump11289f42009-09-09 15:08:12 +00003133
Douglas Gregor4d87df52008-12-16 21:30:33 +00003134 OwningExprResult DefArgResult(ParseAssignmentExpression());
3135 if (DefArgResult.isInvalid()) {
3136 Actions.ActOnParamDefaultArgumentError(Param);
3137 SkipUntil(tok::comma, tok::r_paren, true, true);
3138 } else {
3139 // Inform the actions module about the default argument
3140 Actions.ActOnParamDefaultArgument(Param, EqualLoc,
John McCallb268a282010-08-23 23:25:46 +00003141 DefArgResult.take());
Douglas Gregor4d87df52008-12-16 21:30:33 +00003142 }
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00003143 }
3144 }
Mike Stump11289f42009-09-09 15:08:12 +00003145
3146 ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
3147 ParmDecl.getIdentifierLoc(), Param,
Douglas Gregor4d87df52008-12-16 21:30:33 +00003148 DefArgToks));
Chris Lattner371ed4e2008-04-06 06:57:35 +00003149 }
3150
3151 // If the next token is a comma, consume it and keep reading arguments.
Douglas Gregor9bfc2e52009-09-22 21:41:40 +00003152 if (Tok.isNot(tok::comma)) {
3153 if (Tok.is(tok::ellipsis)) {
3154 IsVariadic = true;
3155 EllipsisLoc = ConsumeToken(); // Consume the ellipsis.
3156
3157 if (!getLang().CPlusPlus) {
3158 // We have ellipsis without a preceding ',', which is ill-formed
3159 // in C. Complain and provide the fix.
3160 Diag(EllipsisLoc, diag::err_missing_comma_before_ellipsis)
Douglas Gregora771f462010-03-31 17:46:05 +00003161 << FixItHint::CreateInsertion(EllipsisLoc, ", ");
Douglas Gregor9bfc2e52009-09-22 21:41:40 +00003162 }
3163 }
3164
3165 break;
3166 }
Mike Stump11289f42009-09-09 15:08:12 +00003167
Chris Lattner371ed4e2008-04-06 06:57:35 +00003168 // Consume the comma.
3169 ConsumeToken();
Chris Lattneracd58a32006-08-06 17:24:14 +00003170 }
Mike Stump11289f42009-09-09 15:08:12 +00003171
Chris Lattner371ed4e2008-04-06 06:57:35 +00003172 // Leave prototype scope.
Douglas Gregor7307d6c2008-12-10 06:34:36 +00003173 PrototypeScope.Exit();
Mike Stump11289f42009-09-09 15:08:12 +00003174
Argyrios Kyrtzidis22c40fa2008-10-24 21:46:40 +00003175 // If we have the closing ')', eat it.
Argyrios Kyrtzidis20cf1912009-08-19 23:14:54 +00003176 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
3177 SourceLocation EndLoc = RParenLoc;
Argyrios Kyrtzidis22c40fa2008-10-24 21:46:40 +00003178
Argyrios Kyrtzidis22c40fa2008-10-24 21:46:40 +00003179 DeclSpec DS;
Sebastian Redl2b9cacb2009-04-29 17:30:04 +00003180 bool hasExceptionSpec = false;
Sebastian Redlfb3f1792009-05-31 11:47:27 +00003181 SourceLocation ThrowLoc;
Sebastian Redl2b9cacb2009-04-29 17:30:04 +00003182 bool hasAnyExceptionSpec = false;
John McCallba7bf592010-08-24 05:47:05 +00003183 llvm::SmallVector<ParsedType, 2> Exceptions;
Sebastian Redld6434562009-05-29 18:02:33 +00003184 llvm::SmallVector<SourceRange, 2> ExceptionRanges;
Alexis Hunt96d5c762009-11-21 08:43:09 +00003185
Argyrios Kyrtzidis22c40fa2008-10-24 21:46:40 +00003186 if (getLang().CPlusPlus) {
Douglas Gregor2afd0be2008-11-25 03:22:00 +00003187 // Parse cv-qualifier-seq[opt].
Chris Lattnercf0bab22008-12-18 07:02:59 +00003188 ParseTypeQualifierListOpt(DS, false /*no attributes*/);
Sebastian Redlf6591ca2009-02-09 18:23:29 +00003189 if (!DS.getSourceRange().getEnd().isInvalid())
Argyrios Kyrtzidis20cf1912009-08-19 23:14:54 +00003190 EndLoc = DS.getSourceRange().getEnd();
Douglas Gregor2afd0be2008-11-25 03:22:00 +00003191
3192 // Parse exception-specification[opt].
Sebastian Redl2b9cacb2009-04-29 17:30:04 +00003193 if (Tok.is(tok::kw_throw)) {
3194 hasExceptionSpec = true;
Sebastian Redlfb3f1792009-05-31 11:47:27 +00003195 ThrowLoc = Tok.getLocation();
Argyrios Kyrtzidis20cf1912009-08-19 23:14:54 +00003196 ParseExceptionSpecification(EndLoc, Exceptions, ExceptionRanges,
Sebastian Redld6434562009-05-29 18:02:33 +00003197 hasAnyExceptionSpec);
3198 assert(Exceptions.size() == ExceptionRanges.size() &&
3199 "Produced different number of exception types and ranges.");
Sebastian Redl2b9cacb2009-04-29 17:30:04 +00003200 }
Argyrios Kyrtzidis22c40fa2008-10-24 21:46:40 +00003201 }
3202
Chris Lattnerd5d0a6c2006-08-07 00:58:14 +00003203 // Remember that we parsed a function type, and remember the attributes.
Chris Lattner371ed4e2008-04-06 06:57:35 +00003204 D.AddTypeInfo(DeclaratorChunk::getFunction(/*proto*/true, IsVariadic,
Douglas Gregor94349fd2009-02-18 07:07:28 +00003205 EllipsisLoc,
Jay Foad7d0479f2009-05-21 09:52:38 +00003206 ParamInfo.data(), ParamInfo.size(),
Argyrios Kyrtzidis22c40fa2008-10-24 21:46:40 +00003207 DS.getTypeQualifiers(),
Sebastian Redlfb3f1792009-05-31 11:47:27 +00003208 hasExceptionSpec, ThrowLoc,
Sebastian Redl2b9cacb2009-04-29 17:30:04 +00003209 hasAnyExceptionSpec,
Sebastian Redld6434562009-05-29 18:02:33 +00003210 Exceptions.data(),
3211 ExceptionRanges.data(),
Argyrios Kyrtzidis20cf1912009-08-19 23:14:54 +00003212 Exceptions.size(),
3213 LParenLoc, RParenLoc, D),
3214 EndLoc);
Chris Lattnerc0acd3d2006-07-31 05:13:43 +00003215}
Chris Lattneracd58a32006-08-06 17:24:14 +00003216
Chris Lattner6c940e62008-04-06 06:34:08 +00003217/// ParseFunctionDeclaratorIdentifierList - While parsing a function declarator
3218/// we found a K&R-style identifier list instead of a type argument list. The
Chris Lattner9453ab82010-05-14 17:23:36 +00003219/// first identifier has already been consumed, and the current token is the
3220/// token right after it.
Chris Lattner6c940e62008-04-06 06:34:08 +00003221///
3222/// identifier-list: [C99 6.7.5]
3223/// identifier
3224/// identifier-list ',' identifier
3225///
3226void Parser::ParseFunctionDeclaratorIdentifierList(SourceLocation LParenLoc,
Chris Lattner9453ab82010-05-14 17:23:36 +00003227 IdentifierInfo *FirstIdent,
3228 SourceLocation FirstIdentLoc,
Chris Lattner6c940e62008-04-06 06:34:08 +00003229 Declarator &D) {
3230 // Build up an array of information about the parsed arguments.
3231 llvm::SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
3232 llvm::SmallSet<const IdentifierInfo*, 16> ParamsSoFar;
Mike Stump11289f42009-09-09 15:08:12 +00003233
Chris Lattner6c940e62008-04-06 06:34:08 +00003234 // If there was no identifier specified for the declarator, either we are in
3235 // an abstract-declarator, or we are in a parameter declarator which was found
3236 // to be abstract. In abstract-declarators, identifier lists are not valid:
3237 // diagnose this.
3238 if (!D.getIdentifier())
Chris Lattner9453ab82010-05-14 17:23:36 +00003239 Diag(FirstIdentLoc, diag::ext_ident_list_in_param);
Chris Lattner6c940e62008-04-06 06:34:08 +00003240
Chris Lattner9453ab82010-05-14 17:23:36 +00003241 // The first identifier was already read, and is known to be the first
3242 // identifier in the list. Remember this identifier in ParamInfo.
3243 ParamsSoFar.insert(FirstIdent);
John McCall48871652010-08-21 09:40:31 +00003244 ParamInfo.push_back(DeclaratorChunk::ParamInfo(FirstIdent, FirstIdentLoc, 0));
Mike Stump11289f42009-09-09 15:08:12 +00003245
Chris Lattner6c940e62008-04-06 06:34:08 +00003246 while (Tok.is(tok::comma)) {
3247 // Eat the comma.
3248 ConsumeToken();
Mike Stump11289f42009-09-09 15:08:12 +00003249
Chris Lattner9186f552008-04-06 06:39:19 +00003250 // If this isn't an identifier, report the error and skip until ')'.
Chris Lattner6c940e62008-04-06 06:34:08 +00003251 if (Tok.isNot(tok::identifier)) {
3252 Diag(Tok, diag::err_expected_ident);
Chris Lattner9186f552008-04-06 06:39:19 +00003253 SkipUntil(tok::r_paren);
3254 return;
Chris Lattner6c940e62008-04-06 06:34:08 +00003255 }
Chris Lattner67b450c2008-04-06 06:47:48 +00003256
Chris Lattner6c940e62008-04-06 06:34:08 +00003257 IdentifierInfo *ParmII = Tok.getIdentifierInfo();
Chris Lattner67b450c2008-04-06 06:47:48 +00003258
3259 // Reject 'typedef int y; int test(x, y)', but continue parsing.
Douglas Gregor0be31a22010-07-02 17:43:08 +00003260 if (Actions.getTypeName(*ParmII, Tok.getLocation(), getCurScope()))
Chris Lattnerebad6a22008-11-19 07:37:42 +00003261 Diag(Tok, diag::err_unexpected_typedef_ident) << ParmII;
Mike Stump11289f42009-09-09 15:08:12 +00003262
Chris Lattner6c940e62008-04-06 06:34:08 +00003263 // Verify that the argument identifier has not already been mentioned.
3264 if (!ParamsSoFar.insert(ParmII)) {
Chris Lattnerebad6a22008-11-19 07:37:42 +00003265 Diag(Tok, diag::err_param_redefinition) << ParmII;
Chris Lattner9186f552008-04-06 06:39:19 +00003266 } else {
3267 // Remember this identifier in ParamInfo.
Chris Lattner6c940e62008-04-06 06:34:08 +00003268 ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
Chris Lattner83f095c2009-03-28 19:18:32 +00003269 Tok.getLocation(),
John McCall48871652010-08-21 09:40:31 +00003270 0));
Chris Lattner9186f552008-04-06 06:39:19 +00003271 }
Mike Stump11289f42009-09-09 15:08:12 +00003272
Chris Lattner6c940e62008-04-06 06:34:08 +00003273 // Eat the identifier.
3274 ConsumeToken();
3275 }
Sebastian Redlf6591ca2009-02-09 18:23:29 +00003276
3277 // If we have the closing ')', eat it and we're done.
3278 SourceLocation RLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
3279
Chris Lattner9186f552008-04-06 06:39:19 +00003280 // Remember that we parsed a function type, and remember the attributes. This
3281 // function type is always a K&R style function type, which is not varargs and
3282 // has no prototype.
3283 D.AddTypeInfo(DeclaratorChunk::getFunction(/*proto*/false, /*varargs*/false,
Douglas Gregor94349fd2009-02-18 07:07:28 +00003284 SourceLocation(),
Chris Lattner9186f552008-04-06 06:39:19 +00003285 &ParamInfo[0], ParamInfo.size(),
Sebastian Redl2b9cacb2009-04-29 17:30:04 +00003286 /*TypeQuals*/0,
Sebastian Redlfb3f1792009-05-31 11:47:27 +00003287 /*exception*/false,
3288 SourceLocation(), false, 0, 0, 0,
Argyrios Kyrtzidis20cf1912009-08-19 23:14:54 +00003289 LParenLoc, RLoc, D),
Sebastian Redlf6591ca2009-02-09 18:23:29 +00003290 RLoc);
Chris Lattner6c940e62008-04-06 06:34:08 +00003291}
Chris Lattnerc0a1c7d2008-04-06 05:45:57 +00003292
Chris Lattnere8074e62006-08-06 18:30:15 +00003293/// [C90] direct-declarator '[' constant-expression[opt] ']'
3294/// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
3295/// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
3296/// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']'
3297/// [C99] direct-declarator '[' type-qual-list[opt] '*' ']'
3298void Parser::ParseBracketDeclarator(Declarator &D) {
Chris Lattner04132372006-10-16 06:12:55 +00003299 SourceLocation StartLoc = ConsumeBracket();
Mike Stump11289f42009-09-09 15:08:12 +00003300
Chris Lattner84a11622008-12-18 07:27:21 +00003301 // C array syntax has many features, but by-far the most common is [] and [4].
3302 // This code does a fast path to handle some of the most obvious cases.
3303 if (Tok.getKind() == tok::r_square) {
Sebastian Redlf6591ca2009-02-09 18:23:29 +00003304 SourceLocation EndLoc = MatchRHSPunctuation(tok::r_square, StartLoc);
Alexis Hunt96d5c762009-11-21 08:43:09 +00003305 //FIXME: Use these
3306 CXX0XAttributeList Attr;
3307 if (getLang().CPlusPlus0x && isCXX0XAttributeSpecifier(true)) {
3308 Attr = ParseCXX0XAttributes();
3309 }
3310
Chris Lattner84a11622008-12-18 07:27:21 +00003311 // Remember that we parsed the empty array type.
John McCall37ad5512010-08-23 06:44:23 +00003312 OwningExprResult NumElements;
Douglas Gregor04318252009-07-06 15:59:29 +00003313 D.AddTypeInfo(DeclaratorChunk::getArray(0, false, false, 0,
3314 StartLoc, EndLoc),
Sebastian Redlf6591ca2009-02-09 18:23:29 +00003315 EndLoc);
Chris Lattner84a11622008-12-18 07:27:21 +00003316 return;
3317 } else if (Tok.getKind() == tok::numeric_constant &&
3318 GetLookAheadToken(1).is(tok::r_square)) {
3319 // [4] is very common. Parse the numeric constant expression.
Sebastian Redlffbcf962009-01-18 18:53:16 +00003320 OwningExprResult ExprRes(Actions.ActOnNumericConstant(Tok));
Chris Lattner84a11622008-12-18 07:27:21 +00003321 ConsumeToken();
3322
Sebastian Redlf6591ca2009-02-09 18:23:29 +00003323 SourceLocation EndLoc = MatchRHSPunctuation(tok::r_square, StartLoc);
Alexis Hunt96d5c762009-11-21 08:43:09 +00003324 //FIXME: Use these
3325 CXX0XAttributeList Attr;
3326 if (getLang().CPlusPlus0x && isCXX0XAttributeSpecifier()) {
3327 Attr = ParseCXX0XAttributes();
3328 }
Chris Lattner84a11622008-12-18 07:27:21 +00003329
3330 // If there was an error parsing the assignment-expression, recover.
3331 if (ExprRes.isInvalid())
3332 ExprRes.release(); // Deallocate expr, just use [].
Mike Stump11289f42009-09-09 15:08:12 +00003333
Chris Lattner84a11622008-12-18 07:27:21 +00003334 // Remember that we parsed a array type, and remember its features.
Douglas Gregor04318252009-07-06 15:59:29 +00003335 D.AddTypeInfo(DeclaratorChunk::getArray(0, false, 0, ExprRes.release(),
3336 StartLoc, EndLoc),
Sebastian Redlf6591ca2009-02-09 18:23:29 +00003337 EndLoc);
Chris Lattner84a11622008-12-18 07:27:21 +00003338 return;
3339 }
Mike Stump11289f42009-09-09 15:08:12 +00003340
Chris Lattnere8074e62006-08-06 18:30:15 +00003341 // If valid, this location is the position where we read the 'static' keyword.
3342 SourceLocation StaticLoc;
Chris Lattner76c72282007-10-09 17:33:22 +00003343 if (Tok.is(tok::kw_static))
Chris Lattneraf635312006-10-16 06:06:51 +00003344 StaticLoc = ConsumeToken();
Mike Stump11289f42009-09-09 15:08:12 +00003345
Chris Lattnere8074e62006-08-06 18:30:15 +00003346 // If there is a type-qualifier-list, read it now.
Chris Lattnerb6ec4e72008-12-18 06:50:14 +00003347 // Type qualifiers in an array subscript are a C99 feature.
Chris Lattnere8074e62006-08-06 18:30:15 +00003348 DeclSpec DS;
Chris Lattnercf0bab22008-12-18 07:02:59 +00003349 ParseTypeQualifierListOpt(DS, false /*no attributes*/);
Mike Stump11289f42009-09-09 15:08:12 +00003350
Chris Lattnere8074e62006-08-06 18:30:15 +00003351 // If we haven't already read 'static', check to see if there is one after the
3352 // type-qualifier-list.
Chris Lattner76c72282007-10-09 17:33:22 +00003353 if (!StaticLoc.isValid() && Tok.is(tok::kw_static))
Chris Lattneraf635312006-10-16 06:06:51 +00003354 StaticLoc = ConsumeToken();
Mike Stump11289f42009-09-09 15:08:12 +00003355
Chris Lattnere8074e62006-08-06 18:30:15 +00003356 // Handle "direct-declarator [ type-qual-list[opt] * ]".
Chris Lattnere8074e62006-08-06 18:30:15 +00003357 bool isStar = false;
John McCall37ad5512010-08-23 06:44:23 +00003358 OwningExprResult NumElements;
Mike Stump11289f42009-09-09 15:08:12 +00003359
Chris Lattner521ff2b2008-04-06 05:26:30 +00003360 // Handle the case where we have '[*]' as the array size. However, a leading
3361 // star could be the start of an expression, for example 'X[*p + 4]'. Verify
3362 // the the token after the star is a ']'. Since stars in arrays are
3363 // infrequent, use of lookahead is not costly here.
3364 if (Tok.is(tok::star) && GetLookAheadToken(1).is(tok::r_square)) {
Chris Lattnerc439f0d2008-04-06 05:27:21 +00003365 ConsumeToken(); // Eat the '*'.
Chris Lattner1906f802006-08-06 19:14:46 +00003366
Chris Lattnerb6ec4e72008-12-18 06:50:14 +00003367 if (StaticLoc.isValid()) {
Chris Lattner521ff2b2008-04-06 05:26:30 +00003368 Diag(StaticLoc, diag::err_unspecified_vla_size_with_static);
Chris Lattnerb6ec4e72008-12-18 06:50:14 +00003369 StaticLoc = SourceLocation(); // Drop the static.
3370 }
Chris Lattner521ff2b2008-04-06 05:26:30 +00003371 isStar = true;
Chris Lattner76c72282007-10-09 17:33:22 +00003372 } else if (Tok.isNot(tok::r_square)) {
Chris Lattner84a11622008-12-18 07:27:21 +00003373 // Note, in C89, this production uses the constant-expr production instead
3374 // of assignment-expr. The only difference is that assignment-expr allows
3375 // things like '=' and '*='. Sema rejects these in C89 mode because they
3376 // are not i-c-e's, so we don't need to distinguish between the two here.
Mike Stump11289f42009-09-09 15:08:12 +00003377
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00003378 // Parse the constant-expression or assignment-expression now (depending
3379 // on dialect).
3380 if (getLang().CPlusPlus)
3381 NumElements = ParseConstantExpression();
3382 else
3383 NumElements = ParseAssignmentExpression();
Chris Lattner62591722006-08-12 18:40:58 +00003384 }
Mike Stump11289f42009-09-09 15:08:12 +00003385
Chris Lattner62591722006-08-12 18:40:58 +00003386 // If there was an error parsing the assignment-expression, recover.
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00003387 if (NumElements.isInvalid()) {
Chris Lattnercd2a8c52009-04-24 22:30:50 +00003388 D.setInvalidType(true);
Chris Lattner62591722006-08-12 18:40:58 +00003389 // If the expression was invalid, skip it.
3390 SkipUntil(tok::r_square);
3391 return;
Chris Lattnere8074e62006-08-06 18:30:15 +00003392 }
Sebastian Redlf6591ca2009-02-09 18:23:29 +00003393
3394 SourceLocation EndLoc = MatchRHSPunctuation(tok::r_square, StartLoc);
3395
Alexis Hunt96d5c762009-11-21 08:43:09 +00003396 //FIXME: Use these
3397 CXX0XAttributeList Attr;
3398 if (getLang().CPlusPlus0x && isCXX0XAttributeSpecifier()) {
3399 Attr = ParseCXX0XAttributes();
3400 }
3401
Chris Lattner84a11622008-12-18 07:27:21 +00003402 // Remember that we parsed a array type, and remember its features.
Chris Lattnercbc426d2006-12-02 06:43:02 +00003403 D.AddTypeInfo(DeclaratorChunk::getArray(DS.getTypeQualifiers(),
3404 StaticLoc.isValid(), isStar,
Douglas Gregor04318252009-07-06 15:59:29 +00003405 NumElements.release(),
3406 StartLoc, EndLoc),
Sebastian Redlf6591ca2009-02-09 18:23:29 +00003407 EndLoc);
Chris Lattnere8074e62006-08-06 18:30:15 +00003408}
3409
Argyrios Kyrtzidis2545aeb2008-09-05 11:26:19 +00003410/// [GNU] typeof-specifier:
3411/// typeof ( expressions )
3412/// typeof ( type-name )
3413/// [GNU/C++] typeof unary-expression
Steve Naroffad373bd2007-07-31 12:34:36 +00003414///
3415void Parser::ParseTypeofSpecifier(DeclSpec &DS) {
Chris Lattner76c72282007-10-09 17:33:22 +00003416 assert(Tok.is(tok::kw_typeof) && "Not a typeof specifier");
Argyrios Kyrtzidis7bd98442009-05-22 10:22:50 +00003417 Token OpTok = Tok;
Steve Naroffad373bd2007-07-31 12:34:36 +00003418 SourceLocation StartLoc = ConsumeToken();
3419
John McCalle8595032010-01-13 20:03:27 +00003420 const bool hasParens = Tok.is(tok::l_paren);
3421
Argyrios Kyrtzidis7bd98442009-05-22 10:22:50 +00003422 bool isCastExpr;
John McCallba7bf592010-08-24 05:47:05 +00003423 ParsedType CastTy;
Argyrios Kyrtzidis7bd98442009-05-22 10:22:50 +00003424 SourceRange CastRange;
3425 OwningExprResult Operand = ParseExprAfterTypeofSizeofAlignof(OpTok,
3426 isCastExpr,
3427 CastTy,
3428 CastRange);
John McCalle8595032010-01-13 20:03:27 +00003429 if (hasParens)
3430 DS.setTypeofParensRange(CastRange);
Argyrios Kyrtzidis7bd98442009-05-22 10:22:50 +00003431
3432 if (CastRange.getEnd().isInvalid())
Argyrios Kyrtzidisf5cc7ac2009-05-22 10:22:18 +00003433 // FIXME: Not accurate, the range gets one token more than it should.
3434 DS.SetRangeEnd(Tok.getLocation());
Argyrios Kyrtzidis7bd98442009-05-22 10:22:50 +00003435 else
3436 DS.SetRangeEnd(CastRange.getEnd());
Mike Stump11289f42009-09-09 15:08:12 +00003437
Argyrios Kyrtzidis7bd98442009-05-22 10:22:50 +00003438 if (isCastExpr) {
3439 if (!CastTy) {
3440 DS.SetTypeSpecError();
Argyrios Kyrtzidis2545aeb2008-09-05 11:26:19 +00003441 return;
Douglas Gregor220cac52009-02-18 17:45:20 +00003442 }
Argyrios Kyrtzidis2545aeb2008-09-05 11:26:19 +00003443
Argyrios Kyrtzidis7bd98442009-05-22 10:22:50 +00003444 const char *PrevSpec = 0;
John McCall49bfce42009-08-03 20:12:06 +00003445 unsigned DiagID;
Argyrios Kyrtzidis7bd98442009-05-22 10:22:50 +00003446 // Check for duplicate type specifiers (e.g. "int typeof(int)").
3447 if (DS.SetTypeSpecType(DeclSpec::TST_typeofType, StartLoc, PrevSpec,
John McCall49bfce42009-08-03 20:12:06 +00003448 DiagID, CastTy))
3449 Diag(StartLoc, DiagID) << PrevSpec;
Argyrios Kyrtzidis7bd98442009-05-22 10:22:50 +00003450 return;
Argyrios Kyrtzidisf5cc7ac2009-05-22 10:22:18 +00003451 }
Argyrios Kyrtzidis2545aeb2008-09-05 11:26:19 +00003452
Argyrios Kyrtzidisf5cc7ac2009-05-22 10:22:18 +00003453 // If we get here, the operand to the typeof was an expresion.
3454 if (Operand.isInvalid()) {
3455 DS.SetTypeSpecError();
Steve Naroff4bd2f712007-08-02 02:53:48 +00003456 return;
Steve Naroffad373bd2007-07-31 12:34:36 +00003457 }
Argyrios Kyrtzidis2545aeb2008-09-05 11:26:19 +00003458
Argyrios Kyrtzidisf5cc7ac2009-05-22 10:22:18 +00003459 const char *PrevSpec = 0;
John McCall49bfce42009-08-03 20:12:06 +00003460 unsigned DiagID;
Argyrios Kyrtzidisf5cc7ac2009-05-22 10:22:18 +00003461 // Check for duplicate type specifiers (e.g. "int typeof(int)").
3462 if (DS.SetTypeSpecType(DeclSpec::TST_typeofExpr, StartLoc, PrevSpec,
John McCallba7bf592010-08-24 05:47:05 +00003463 DiagID, Operand.get()))
John McCall49bfce42009-08-03 20:12:06 +00003464 Diag(StartLoc, DiagID) << PrevSpec;
Steve Naroffad373bd2007-07-31 12:34:36 +00003465}
Chris Lattner73a9c7d2010-02-28 18:33:55 +00003466
3467
3468/// TryAltiVecVectorTokenOutOfLine - Out of line body that should only be called
3469/// from TryAltiVecVectorToken.
3470bool Parser::TryAltiVecVectorTokenOutOfLine() {
3471 Token Next = NextToken();
3472 switch (Next.getKind()) {
3473 default: return false;
3474 case tok::kw_short:
3475 case tok::kw_long:
3476 case tok::kw_signed:
3477 case tok::kw_unsigned:
3478 case tok::kw_void:
3479 case tok::kw_char:
3480 case tok::kw_int:
3481 case tok::kw_float:
3482 case tok::kw_double:
3483 case tok::kw_bool:
3484 case tok::kw___pixel:
3485 Tok.setKind(tok::kw___vector);
3486 return true;
3487 case tok::identifier:
3488 if (Next.getIdentifierInfo() == Ident_pixel) {
3489 Tok.setKind(tok::kw___vector);
3490 return true;
3491 }
3492 return false;
3493 }
3494}
3495
3496bool Parser::TryAltiVecTokenOutOfLine(DeclSpec &DS, SourceLocation Loc,
3497 const char *&PrevSpec, unsigned &DiagID,
3498 bool &isInvalid) {
3499 if (Tok.getIdentifierInfo() == Ident_vector) {
3500 Token Next = NextToken();
3501 switch (Next.getKind()) {
3502 case tok::kw_short:
3503 case tok::kw_long:
3504 case tok::kw_signed:
3505 case tok::kw_unsigned:
3506 case tok::kw_void:
3507 case tok::kw_char:
3508 case tok::kw_int:
3509 case tok::kw_float:
3510 case tok::kw_double:
3511 case tok::kw_bool:
3512 case tok::kw___pixel:
3513 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID);
3514 return true;
3515 case tok::identifier:
3516 if (Next.getIdentifierInfo() == Ident_pixel) {
3517 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID);
3518 return true;
3519 }
3520 break;
3521 default:
3522 break;
3523 }
Douglas Gregor9938e3b2010-06-16 15:28:57 +00003524 } else if ((Tok.getIdentifierInfo() == Ident_pixel) &&
Chris Lattner73a9c7d2010-02-28 18:33:55 +00003525 DS.isTypeAltiVecVector()) {
3526 isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID);
3527 return true;
3528 }
3529 return false;
3530}
3531