ParseInit.cpp revision 221345
1222429Snwhitehorn//===--- ParseInit.cpp - Initializer Parsing ------------------------------===// 2222429Snwhitehorn// 3222429Snwhitehorn// The LLVM Compiler Infrastructure 4222429Snwhitehorn// 5222429Snwhitehorn// This file is distributed under the University of Illinois Open Source 6222429Snwhitehorn// License. See LICENSE.TXT for details. 7222429Snwhitehorn// 8222429Snwhitehorn//===----------------------------------------------------------------------===// 9222429Snwhitehorn// 10222429Snwhitehorn// This file implements initializer parsing as specified by C99 6.7.8. 11222429Snwhitehorn// 12222429Snwhitehorn//===----------------------------------------------------------------------===// 13222429Snwhitehorn 14222429Snwhitehorn#include "clang/Parse/Parser.h" 15222429Snwhitehorn#include "clang/Parse/ParseDiagnostic.h" 16222429Snwhitehorn#include "RAIIObjectsForParser.h" 17222429Snwhitehorn#include "clang/Sema/Designator.h" 18222429Snwhitehorn#include "clang/Sema/Scope.h" 19222429Snwhitehorn#include "llvm/ADT/SmallString.h" 20222429Snwhitehorn#include "llvm/Support/raw_ostream.h" 21222429Snwhitehornusing namespace clang; 22222429Snwhitehorn 23222429Snwhitehorn 24222429Snwhitehorn/// MayBeDesignationStart - Return true if this token might be the start of a 25222429Snwhitehorn/// designator. If we can tell it is impossible that it is a designator, return 26222429Snwhitehorn/// false. 27222429Snwhitehornstatic bool MayBeDesignationStart(tok::TokenKind K, Preprocessor &PP) { 28222429Snwhitehorn switch (K) { 29222429Snwhitehorn default: return false; 30222429Snwhitehorn case tok::period: // designator: '.' identifier 31222429Snwhitehorn case tok::l_square: // designator: array-designator 32222429Snwhitehorn return true; 33222429Snwhitehorn case tok::identifier: // designation: identifier ':' 34222429Snwhitehorn return PP.LookAhead(0).is(tok::colon); 35222429Snwhitehorn } 36222429Snwhitehorn} 37222429Snwhitehorn 38222429Snwhitehornstatic void CheckArrayDesignatorSyntax(Parser &P, SourceLocation Loc, 39222429Snwhitehorn Designation &Desig) { 40222429Snwhitehorn // If we have exactly one array designator, this used the GNU 41222429Snwhitehorn // 'designation: array-designator' extension, otherwise there should be no 42222429Snwhitehorn // designators at all! 43222429Snwhitehorn if (Desig.getNumDesignators() == 1 && 44222429Snwhitehorn (Desig.getDesignator(0).isArrayDesignator() || 45222429Snwhitehorn Desig.getDesignator(0).isArrayRangeDesignator())) 46222429Snwhitehorn P.Diag(Loc, diag::ext_gnu_missing_equal_designator); 47222429Snwhitehorn else if (Desig.getNumDesignators() > 0) 48222429Snwhitehorn P.Diag(Loc, diag::err_expected_equal_designator); 49222429Snwhitehorn} 50222429Snwhitehorn 51222429Snwhitehorn/// ParseInitializerWithPotentialDesignator - Parse the 'initializer' production 52222429Snwhitehorn/// checking to see if the token stream starts with a designator. 53222429Snwhitehorn/// 54222429Snwhitehorn/// designation: 55222429Snwhitehorn/// designator-list '=' 56222429Snwhitehorn/// [GNU] array-designator 57222429Snwhitehorn/// [GNU] identifier ':' 58222429Snwhitehorn/// 59222429Snwhitehorn/// designator-list: 60222429Snwhitehorn/// designator 61227293Sed/// designator-list designator 62222429Snwhitehorn/// 63222429Snwhitehorn/// designator: 64222429Snwhitehorn/// array-designator 65222429Snwhitehorn/// '.' identifier 66222429Snwhitehorn/// 67222429Snwhitehorn/// array-designator: 68222429Snwhitehorn/// '[' constant-expression ']' 69222429Snwhitehorn/// [GNU] '[' constant-expression '...' constant-expression ']' 70222429Snwhitehorn/// 71265970Sian/// NOTE: [OBC] allows '[ objc-receiver objc-message-args ]' as an 72265970Sian/// initializer (because it is an expression). We need to consider this case 73222429Snwhitehorn/// when parsing array designators. 74222429Snwhitehorn/// 75222429SnwhitehornExprResult Parser::ParseInitializerWithPotentialDesignator() { 76222429Snwhitehorn 77222429Snwhitehorn // If this is the old-style GNU extension: 78222429Snwhitehorn // designation ::= identifier ':' 79222429Snwhitehorn // Handle it as a field designator. Otherwise, this must be the start of a 80222429Snwhitehorn // normal expression. 81222429Snwhitehorn if (Tok.is(tok::identifier)) { 82222429Snwhitehorn const IdentifierInfo *FieldName = Tok.getIdentifierInfo(); 83222429Snwhitehorn 84222469Snwhitehorn llvm::SmallString<256> NewSyntax; 85222429Snwhitehorn llvm::raw_svector_ostream(NewSyntax) << '.' << FieldName->getName() 86222429Snwhitehorn << " = "; 87222429Snwhitehorn 88222429Snwhitehorn SourceLocation NameLoc = ConsumeToken(); // Eat the identifier. 89222429Snwhitehorn 90222429Snwhitehorn assert(Tok.is(tok::colon) && "MayBeDesignationStart not working properly!"); 91222429Snwhitehorn SourceLocation ColonLoc = ConsumeToken(); 92222429Snwhitehorn 93222429Snwhitehorn Diag(Tok, diag::ext_gnu_old_style_field_designator) 94222429Snwhitehorn << FixItHint::CreateReplacement(SourceRange(NameLoc, ColonLoc), 95222429Snwhitehorn NewSyntax.str()); 96222429Snwhitehorn 97222429Snwhitehorn Designation D; 98222429Snwhitehorn D.AddDesignator(Designator::getField(FieldName, SourceLocation(), NameLoc)); 99222463Snwhitehorn return Actions.ActOnDesignatedInitializer(D, ColonLoc, true, 100222429Snwhitehorn ParseInitializer()); 101222429Snwhitehorn } 102222429Snwhitehorn 103222429Snwhitehorn // Desig - This is initialized when we see our first designator. We may have 104222429Snwhitehorn // an objc message send with no designator, so we don't want to create this 105222429Snwhitehorn // eagerly. 106222463Snwhitehorn Designation Desig; 107222463Snwhitehorn 108222463Snwhitehorn // Parse each designator in the designator list until we find an initializer. 109222463Snwhitehorn while (Tok.is(tok::period) || Tok.is(tok::l_square)) { 110222429Snwhitehorn if (Tok.is(tok::period)) { 111265970Sian // designator: '.' identifier 112222429Snwhitehorn SourceLocation DotLoc = ConsumeToken(); 113265970Sian 114265970Sian if (Tok.isNot(tok::identifier)) { 115265970Sian Diag(Tok.getLocation(), diag::err_expected_field_designator); 116265970Sian return ExprError(); 117265970Sian } 118265970Sian 119265970Sian Desig.AddDesignator(Designator::getField(Tok.getIdentifierInfo(), DotLoc, 120265970Sian Tok.getLocation())); 121265970Sian ConsumeToken(); // Eat the identifier. 122265970Sian continue; 123265970Sian } 124265970Sian 125265970Sian // We must have either an array designator now or an objc message send. 126265970Sian assert(Tok.is(tok::l_square) && "Unexpected token!"); 127265970Sian 128265970Sian // Handle the two forms of array designator: 129265970Sian // array-designator: '[' constant-expression ']' 130265970Sian // array-designator: '[' constant-expression '...' constant-expression ']' 131265970Sian // 132222429Snwhitehorn // Also, we have to handle the case where the expression after the 133222429Snwhitehorn // designator an an objc message send: '[' objc-message-expr ']'. 134222429Snwhitehorn // Interesting cases are: 135222429Snwhitehorn // [foo bar] -> objc message send 136222429Snwhitehorn // [foo] -> array designator 137222429Snwhitehorn // [foo ... bar] -> array designator 138222429Snwhitehorn // [4][foo bar] -> obsolete GNU designation with objc message send. 139222429Snwhitehorn // 140222429Snwhitehorn InMessageExpressionRAIIObject InMessage(*this, true); 141222429Snwhitehorn 142222429Snwhitehorn SourceLocation StartLoc = ConsumeBracket(); 143222429Snwhitehorn ExprResult Idx; 144222460Snwhitehorn 145222460Snwhitehorn // If Objective-C is enabled and this is a typename (class message 146222429Snwhitehorn // send) or send to 'super', parse this as a message send 147222429Snwhitehorn // expression. We handle C++ and C separately, since C++ requires 148222429Snwhitehorn // much more complicated parsing. 149222429Snwhitehorn if (getLang().ObjC1 && getLang().CPlusPlus) { 150222429Snwhitehorn // Send to 'super'. 151222429Snwhitehorn if (Tok.is(tok::identifier) && Tok.getIdentifierInfo() == Ident_super && 152222429Snwhitehorn NextToken().isNot(tok::period) && 153222429Snwhitehorn getCurScope()->isInObjcMethodScope()) { 154222429Snwhitehorn CheckArrayDesignatorSyntax(*this, StartLoc, Desig); 155222429Snwhitehorn return ParseAssignmentExprWithObjCMessageExprStart(StartLoc, 156222429Snwhitehorn ConsumeToken(), 157222429Snwhitehorn ParsedType(), 158222429Snwhitehorn 0); 159222429Snwhitehorn } 160222429Snwhitehorn 161222429Snwhitehorn // Parse the receiver, which is either a type or an expression. 162222429Snwhitehorn bool IsExpr; 163222429Snwhitehorn void *TypeOrExpr; 164222429Snwhitehorn if (ParseObjCXXMessageReceiver(IsExpr, TypeOrExpr)) { 165222429Snwhitehorn SkipUntil(tok::r_square); 166222429Snwhitehorn return ExprError(); 167222429Snwhitehorn } 168222429Snwhitehorn 169222429Snwhitehorn // If the receiver was a type, we have a class message; parse 170222429Snwhitehorn // the rest of it. 171222429Snwhitehorn if (!IsExpr) { 172222429Snwhitehorn CheckArrayDesignatorSyntax(*this, StartLoc, Desig); 173222429Snwhitehorn return ParseAssignmentExprWithObjCMessageExprStart(StartLoc, 174222429Snwhitehorn SourceLocation(), 175222429Snwhitehorn ParsedType::getFromOpaquePtr(TypeOrExpr), 176222429Snwhitehorn 0); 177222429Snwhitehorn } 178222429Snwhitehorn 179222429Snwhitehorn // If the receiver was an expression, we still don't know 180222429Snwhitehorn // whether we have a message send or an array designator; just 181222429Snwhitehorn // adopt the expression for further analysis below. 182222429Snwhitehorn // FIXME: potentially-potentially evaluated expression above? 183222429Snwhitehorn Idx = ExprResult(static_cast<Expr*>(TypeOrExpr)); 184222429Snwhitehorn } else if (getLang().ObjC1 && Tok.is(tok::identifier)) { 185222429Snwhitehorn IdentifierInfo *II = Tok.getIdentifierInfo(); 186222429Snwhitehorn SourceLocation IILoc = Tok.getLocation(); 187222429Snwhitehorn ParsedType ReceiverType; 188222429Snwhitehorn // Three cases. This is a message send to a type: [type foo] 189222429Snwhitehorn // This is a message send to super: [super foo] 190222429Snwhitehorn // This is a message sent to an expr: [super.bar foo] 191222429Snwhitehorn switch (Sema::ObjCMessageKind Kind 192222429Snwhitehorn = Actions.getObjCMessageKind(getCurScope(), II, IILoc, 193222429Snwhitehorn II == Ident_super, 194222429Snwhitehorn NextToken().is(tok::period), 195265970Sian ReceiverType)) { 196265970Sian case Sema::ObjCSuperMessage: 197222429Snwhitehorn case Sema::ObjCClassMessage: 198222429Snwhitehorn CheckArrayDesignatorSyntax(*this, StartLoc, Desig); 199222429Snwhitehorn if (Kind == Sema::ObjCSuperMessage) 200222429Snwhitehorn return ParseAssignmentExprWithObjCMessageExprStart(StartLoc, 201 ConsumeToken(), 202 ParsedType(), 203 0); 204 ConsumeToken(); // the identifier 205 if (!ReceiverType) { 206 SkipUntil(tok::r_square); 207 return ExprError(); 208 } 209 210 return ParseAssignmentExprWithObjCMessageExprStart(StartLoc, 211 SourceLocation(), 212 ReceiverType, 213 0); 214 215 case Sema::ObjCInstanceMessage: 216 // Fall through; we'll just parse the expression and 217 // (possibly) treat this like an Objective-C message send 218 // later. 219 break; 220 } 221 } 222 223 // Parse the index expression, if we haven't already gotten one 224 // above (which can only happen in Objective-C++). 225 // Note that we parse this as an assignment expression, not a constant 226 // expression (allowing *=, =, etc) to handle the objc case. Sema needs 227 // to validate that the expression is a constant. 228 // FIXME: We also need to tell Sema that we're in a 229 // potentially-potentially evaluated context. 230 if (!Idx.get()) { 231 Idx = ParseAssignmentExpression(); 232 if (Idx.isInvalid()) { 233 SkipUntil(tok::r_square); 234 return move(Idx); 235 } 236 } 237 238 // Given an expression, we could either have a designator (if the next 239 // tokens are '...' or ']' or an objc message send. If this is an objc 240 // message send, handle it now. An objc-message send is the start of 241 // an assignment-expression production. 242 if (getLang().ObjC1 && Tok.isNot(tok::ellipsis) && 243 Tok.isNot(tok::r_square)) { 244 CheckArrayDesignatorSyntax(*this, Tok.getLocation(), Desig); 245 return ParseAssignmentExprWithObjCMessageExprStart(StartLoc, 246 SourceLocation(), 247 ParsedType(), 248 Idx.take()); 249 } 250 251 // If this is a normal array designator, remember it. 252 if (Tok.isNot(tok::ellipsis)) { 253 Desig.AddDesignator(Designator::getArray(Idx.release(), StartLoc)); 254 } else { 255 // Handle the gnu array range extension. 256 Diag(Tok, diag::ext_gnu_array_range); 257 SourceLocation EllipsisLoc = ConsumeToken(); 258 259 ExprResult RHS(ParseConstantExpression()); 260 if (RHS.isInvalid()) { 261 SkipUntil(tok::r_square); 262 return move(RHS); 263 } 264 Desig.AddDesignator(Designator::getArrayRange(Idx.release(), 265 RHS.release(), 266 StartLoc, EllipsisLoc)); 267 } 268 269 SourceLocation EndLoc = MatchRHSPunctuation(tok::r_square, StartLoc); 270 Desig.getDesignator(Desig.getNumDesignators() - 1).setRBracketLoc(EndLoc); 271 } 272 273 // Okay, we're done with the designator sequence. We know that there must be 274 // at least one designator, because the only case we can get into this method 275 // without a designator is when we have an objc message send. That case is 276 // handled and returned from above. 277 assert(!Desig.empty() && "Designator is empty?"); 278 279 // Handle a normal designator sequence end, which is an equal. 280 if (Tok.is(tok::equal)) { 281 SourceLocation EqualLoc = ConsumeToken(); 282 return Actions.ActOnDesignatedInitializer(Desig, EqualLoc, false, 283 ParseInitializer()); 284 } 285 286 // We read some number of designators and found something that isn't an = or 287 // an initializer. If we have exactly one array designator, this 288 // is the GNU 'designation: array-designator' extension. Otherwise, it is a 289 // parse error. 290 if (Desig.getNumDesignators() == 1 && 291 (Desig.getDesignator(0).isArrayDesignator() || 292 Desig.getDesignator(0).isArrayRangeDesignator())) { 293 Diag(Tok, diag::ext_gnu_missing_equal_designator) 294 << FixItHint::CreateInsertion(Tok.getLocation(), "= "); 295 return Actions.ActOnDesignatedInitializer(Desig, Tok.getLocation(), 296 true, ParseInitializer()); 297 } 298 299 Diag(Tok, diag::err_expected_equal_designator); 300 return ExprError(); 301} 302 303 304/// ParseBraceInitializer - Called when parsing an initializer that has a 305/// leading open brace. 306/// 307/// initializer: [C99 6.7.8] 308/// '{' initializer-list '}' 309/// '{' initializer-list ',' '}' 310/// [GNU] '{' '}' 311/// 312/// initializer-list: 313/// designation[opt] initializer ...[opt] 314/// initializer-list ',' designation[opt] initializer ...[opt] 315/// 316ExprResult Parser::ParseBraceInitializer() { 317 InMessageExpressionRAIIObject InMessage(*this, false); 318 319 SourceLocation LBraceLoc = ConsumeBrace(); 320 321 /// InitExprs - This is the actual list of expressions contained in the 322 /// initializer. 323 ExprVector InitExprs(Actions); 324 325 if (Tok.is(tok::r_brace)) { 326 // Empty initializers are a C++ feature and a GNU extension to C. 327 if (!getLang().CPlusPlus) 328 Diag(LBraceLoc, diag::ext_gnu_empty_initializer); 329 // Match the '}'. 330 return Actions.ActOnInitList(LBraceLoc, MultiExprArg(Actions), 331 ConsumeBrace()); 332 } 333 334 bool InitExprsOk = true; 335 336 while (1) { 337 // Parse: designation[opt] initializer 338 339 // If we know that this cannot be a designation, just parse the nested 340 // initializer directly. 341 ExprResult SubElt; 342 if (MayBeDesignationStart(Tok.getKind(), PP)) 343 SubElt = ParseInitializerWithPotentialDesignator(); 344 else 345 SubElt = ParseInitializer(); 346 347 if (Tok.is(tok::ellipsis)) 348 SubElt = Actions.ActOnPackExpansion(SubElt.get(), ConsumeToken()); 349 350 // If we couldn't parse the subelement, bail out. 351 if (!SubElt.isInvalid()) { 352 InitExprs.push_back(SubElt.release()); 353 } else { 354 InitExprsOk = false; 355 356 // We have two ways to try to recover from this error: if the code looks 357 // grammatically ok (i.e. we have a comma coming up) try to continue 358 // parsing the rest of the initializer. This allows us to emit 359 // diagnostics for later elements that we find. If we don't see a comma, 360 // assume there is a parse error, and just skip to recover. 361 // FIXME: This comment doesn't sound right. If there is a r_brace 362 // immediately, it can't be an error, since there is no other way of 363 // leaving this loop except through this if. 364 if (Tok.isNot(tok::comma)) { 365 SkipUntil(tok::r_brace, false, true); 366 break; 367 } 368 } 369 370 // If we don't have a comma continued list, we're done. 371 if (Tok.isNot(tok::comma)) break; 372 373 // TODO: save comma locations if some client cares. 374 ConsumeToken(); 375 376 // Handle trailing comma. 377 if (Tok.is(tok::r_brace)) break; 378 } 379 if (InitExprsOk && Tok.is(tok::r_brace)) 380 return Actions.ActOnInitList(LBraceLoc, move_arg(InitExprs), 381 ConsumeBrace()); 382 383 // Match the '}'. 384 MatchRHSPunctuation(tok::r_brace, LBraceLoc); 385 return ExprError(); // an error occurred. 386} 387 388