1 //===-- ResourceScriptParser.cpp --------------------------------*- C++-*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===---------------------------------------------------------------------===// 9 // 10 // This implements the parser defined in ResourceScriptParser.h. 11 // 12 //===---------------------------------------------------------------------===// 13 14 #include "ResourceScriptParser.h" 15 #include "llvm/Option/ArgList.h" 16 #include "llvm/Support/FileSystem.h" 17 #include "llvm/Support/Path.h" 18 #include "llvm/Support/Process.h" 19 20 // Take an expression returning llvm::Error and forward the error if it exists. 21 #define RETURN_IF_ERROR(Expr) \ 22 if (auto Err = (Expr)) \ 23 return std::move(Err); 24 25 // Take an expression returning llvm::Expected<T> and assign it to Var or 26 // forward the error out of the function. 27 #define ASSIGN_OR_RETURN(Var, Expr) \ 28 auto Var = (Expr); \ 29 if (!Var) \ 30 return Var.takeError(); 31 32 namespace llvm { 33 namespace rc { 34 35 RCParser::ParserError::ParserError(const Twine &Expected, const LocIter CurLoc, 36 const LocIter End) 37 : ErrorLoc(CurLoc), FileEnd(End) { 38 CurMessage = "Error parsing file: expected " + Expected.str() + ", got " + 39 (CurLoc == End ? "<EOF>" : CurLoc->value()).str(); 40 } 41 42 char RCParser::ParserError::ID = 0; 43 44 RCParser::RCParser(std::vector<RCToken> TokenList) 45 : Tokens(std::move(TokenList)), CurLoc(Tokens.begin()), End(Tokens.end()) {} 46 47 bool RCParser::isEof() const { return CurLoc == End; } 48 49 RCParser::ParseType RCParser::parseSingleResource() { 50 // The first thing we read is usually a resource's name. However, in some 51 // cases (LANGUAGE and STRINGTABLE) the resources don't have their names 52 // and the first token to be read is the type. 53 ASSIGN_OR_RETURN(NameToken, readTypeOrName()); 54 55 if (NameToken->equalsLower("LANGUAGE")) 56 return parseLanguageResource(); 57 else if (NameToken->equalsLower("STRINGTABLE")) 58 return parseStringTableResource(); 59 60 // If it's not an unnamed resource, what we've just read is a name. Now, 61 // read resource type; 62 ASSIGN_OR_RETURN(TypeToken, readTypeOrName()); 63 64 ParseType Result = std::unique_ptr<RCResource>(); 65 (void)!Result; 66 67 if (TypeToken->equalsLower("ACCELERATORS")) 68 Result = parseAcceleratorsResource(); 69 else if (TypeToken->equalsLower("BITMAP")) 70 Result = parseBitmapResource(); 71 else if (TypeToken->equalsLower("CURSOR")) 72 Result = parseCursorResource(); 73 else if (TypeToken->equalsLower("DIALOG")) 74 Result = parseDialogResource(false); 75 else if (TypeToken->equalsLower("DIALOGEX")) 76 Result = parseDialogResource(true); 77 else if (TypeToken->equalsLower("HTML")) 78 Result = parseHTMLResource(); 79 else if (TypeToken->equalsLower("ICON")) 80 Result = parseIconResource(); 81 else if (TypeToken->equalsLower("MENU")) 82 Result = parseMenuResource(); 83 else if (TypeToken->equalsLower("RCDATA")) 84 Result = parseUserDefinedResource(RkRcData); 85 else if (TypeToken->equalsLower("VERSIONINFO")) 86 Result = parseVersionInfoResource(); 87 else 88 Result = parseUserDefinedResource(*TypeToken); 89 90 if (Result) 91 (*Result)->setName(*NameToken); 92 93 return Result; 94 } 95 96 bool RCParser::isNextTokenKind(Kind TokenKind) const { 97 return !isEof() && look().kind() == TokenKind; 98 } 99 100 const RCToken &RCParser::look() const { 101 assert(!isEof()); 102 return *CurLoc; 103 } 104 105 const RCToken &RCParser::read() { 106 assert(!isEof()); 107 return *CurLoc++; 108 } 109 110 void RCParser::consume() { 111 assert(!isEof()); 112 CurLoc++; 113 } 114 115 // An integer description might consist of a single integer or 116 // an arithmetic expression evaluating to the integer. The expressions 117 // can contain the following tokens: <int> ( ) + - | & ~. Their meaning 118 // is the same as in C++. 119 // The operators in the original RC implementation have the following 120 // precedence: 121 // 1) Unary operators (- ~), 122 // 2) Binary operators (+ - & |), with no precedence. 123 // 124 // The following grammar is used to parse the expressions Exp1: 125 // Exp1 ::= Exp2 || Exp1 + Exp2 || Exp1 - Exp2 || Exp1 | Exp2 || Exp1 & Exp2 126 // Exp2 ::= -Exp2 || ~Exp2 || Int || (Exp1). 127 // (More conveniently, Exp1 is a non-empty sequence of Exp2 expressions, 128 // separated by binary operators.) 129 // 130 // Expressions of type Exp1 are read by parseIntExpr1(Inner) method, while Exp2 131 // is read by parseIntExpr2(). 132 // 133 // The original Microsoft tool handles multiple unary operators incorrectly. 134 // For example, in 16-bit little-endian integers: 135 // 1 => 01 00, -1 => ff ff, --1 => ff ff, ---1 => 01 00; 136 // 1 => 01 00, ~1 => fe ff, ~~1 => fd ff, ~~~1 => fc ff. 137 // Our implementation differs from the original one and handles these 138 // operators correctly: 139 // 1 => 01 00, -1 => ff ff, --1 => 01 00, ---1 => ff ff; 140 // 1 => 01 00, ~1 => fe ff, ~~1 => 01 00, ~~~1 => fe ff. 141 142 Expected<RCInt> RCParser::readInt() { return parseIntExpr1(); } 143 144 Expected<RCInt> RCParser::parseIntExpr1() { 145 // Exp1 ::= Exp2 || Exp1 + Exp2 || Exp1 - Exp2 || Exp1 | Exp2 || Exp1 & Exp2. 146 ASSIGN_OR_RETURN(FirstResult, parseIntExpr2()); 147 RCInt Result = *FirstResult; 148 149 while (!isEof() && look().isBinaryOp()) { 150 auto OpToken = read(); 151 ASSIGN_OR_RETURN(NextResult, parseIntExpr2()); 152 153 switch (OpToken.kind()) { 154 case Kind::Plus: 155 Result += *NextResult; 156 break; 157 158 case Kind::Minus: 159 Result -= *NextResult; 160 break; 161 162 case Kind::Pipe: 163 Result |= *NextResult; 164 break; 165 166 case Kind::Amp: 167 Result &= *NextResult; 168 break; 169 170 default: 171 llvm_unreachable("Already processed all binary ops."); 172 } 173 } 174 175 return Result; 176 } 177 178 Expected<RCInt> RCParser::parseIntExpr2() { 179 // Exp2 ::= -Exp2 || ~Exp2 || Int || (Exp1). 180 static const char ErrorMsg[] = "'-', '~', integer or '('"; 181 182 if (isEof()) 183 return getExpectedError(ErrorMsg); 184 185 switch (look().kind()) { 186 case Kind::Minus: { 187 consume(); 188 ASSIGN_OR_RETURN(Result, parseIntExpr2()); 189 return -(*Result); 190 } 191 192 case Kind::Tilde: { 193 consume(); 194 ASSIGN_OR_RETURN(Result, parseIntExpr2()); 195 return ~(*Result); 196 } 197 198 case Kind::Int: 199 return RCInt(read()); 200 201 case Kind::LeftParen: { 202 consume(); 203 ASSIGN_OR_RETURN(Result, parseIntExpr1()); 204 RETURN_IF_ERROR(consumeType(Kind::RightParen)); 205 return *Result; 206 } 207 208 default: 209 return getExpectedError(ErrorMsg); 210 } 211 } 212 213 Expected<StringRef> RCParser::readString() { 214 if (!isNextTokenKind(Kind::String)) 215 return getExpectedError("string"); 216 return read().value(); 217 } 218 219 Expected<StringRef> RCParser::readFilename() { 220 if (!isNextTokenKind(Kind::String) && !isNextTokenKind(Kind::Identifier)) 221 return getExpectedError("string"); 222 return read().value(); 223 } 224 225 Expected<StringRef> RCParser::readIdentifier() { 226 if (!isNextTokenKind(Kind::Identifier)) 227 return getExpectedError("identifier"); 228 return read().value(); 229 } 230 231 Expected<IntOrString> RCParser::readIntOrString() { 232 if (!isNextTokenKind(Kind::Int) && !isNextTokenKind(Kind::String)) 233 return getExpectedError("int or string"); 234 return IntOrString(read()); 235 } 236 237 Expected<IntOrString> RCParser::readTypeOrName() { 238 // We suggest that the correct resource name or type should be either an 239 // identifier or an integer. The original RC tool is much more liberal. 240 if (!isNextTokenKind(Kind::Identifier) && !isNextTokenKind(Kind::Int)) 241 return getExpectedError("int or identifier"); 242 return IntOrString(read()); 243 } 244 245 Error RCParser::consumeType(Kind TokenKind) { 246 if (isNextTokenKind(TokenKind)) { 247 consume(); 248 return Error::success(); 249 } 250 251 switch (TokenKind) { 252 #define TOKEN(TokenName) \ 253 case Kind::TokenName: \ 254 return getExpectedError(#TokenName); 255 #define SHORT_TOKEN(TokenName, TokenCh) \ 256 case Kind::TokenName: \ 257 return getExpectedError(#TokenCh); 258 #include "ResourceScriptTokenList.def" 259 } 260 261 llvm_unreachable("All case options exhausted."); 262 } 263 264 bool RCParser::consumeOptionalType(Kind TokenKind) { 265 if (isNextTokenKind(TokenKind)) { 266 consume(); 267 return true; 268 } 269 270 return false; 271 } 272 273 Expected<SmallVector<RCInt, 8>> RCParser::readIntsWithCommas(size_t MinCount, 274 size_t MaxCount) { 275 assert(MinCount <= MaxCount); 276 277 SmallVector<RCInt, 8> Result; 278 279 auto FailureHandler = 280 [&](llvm::Error Err) -> Expected<SmallVector<RCInt, 8>> { 281 if (Result.size() < MinCount) 282 return std::move(Err); 283 consumeError(std::move(Err)); 284 return Result; 285 }; 286 287 for (size_t i = 0; i < MaxCount; ++i) { 288 // Try to read a comma unless we read the first token. 289 // Sometimes RC tool requires them and sometimes not. We decide to 290 // always require them. 291 if (i >= 1) { 292 if (auto CommaError = consumeType(Kind::Comma)) 293 return FailureHandler(std::move(CommaError)); 294 } 295 296 if (auto IntResult = readInt()) 297 Result.push_back(*IntResult); 298 else 299 return FailureHandler(IntResult.takeError()); 300 } 301 302 return std::move(Result); 303 } 304 305 Expected<uint32_t> RCParser::parseFlags(ArrayRef<StringRef> FlagDesc, 306 ArrayRef<uint32_t> FlagValues) { 307 assert(!FlagDesc.empty()); 308 assert(FlagDesc.size() == FlagValues.size()); 309 310 uint32_t Result = 0; 311 while (isNextTokenKind(Kind::Comma)) { 312 consume(); 313 ASSIGN_OR_RETURN(FlagResult, readIdentifier()); 314 bool FoundFlag = false; 315 316 for (size_t FlagId = 0; FlagId < FlagDesc.size(); ++FlagId) { 317 if (!FlagResult->equals_lower(FlagDesc[FlagId])) 318 continue; 319 320 Result |= FlagValues[FlagId]; 321 FoundFlag = true; 322 break; 323 } 324 325 if (!FoundFlag) 326 return getExpectedError(join(FlagDesc, "/"), true); 327 } 328 329 return Result; 330 } 331 332 uint16_t RCParser::parseMemoryFlags(uint16_t Flags) { 333 while (!isEof()) { 334 const RCToken &Token = look(); 335 if (Token.kind() != Kind::Identifier) 336 return Flags; 337 const StringRef Ident = Token.value(); 338 if (Ident.equals_lower("PRELOAD")) 339 Flags |= MfPreload; 340 else if (Ident.equals_lower("LOADONCALL")) 341 Flags &= ~MfPreload; 342 else if (Ident.equals_lower("FIXED")) 343 Flags &= ~(MfMoveable | MfDiscardable); 344 else if (Ident.equals_lower("MOVEABLE")) 345 Flags |= MfMoveable; 346 else if (Ident.equals_lower("DISCARDABLE")) 347 Flags |= MfDiscardable | MfMoveable | MfPure; 348 else if (Ident.equals_lower("PURE")) 349 Flags |= MfPure; 350 else if (Ident.equals_lower("IMPURE")) 351 Flags &= ~(MfPure | MfDiscardable); 352 else if (Ident.equals_lower("SHARED")) 353 Flags |= MfPure; 354 else if (Ident.equals_lower("NONSHARED")) 355 Flags &= ~(MfPure | MfDiscardable); 356 else 357 return Flags; 358 consume(); 359 } 360 return Flags; 361 } 362 363 Expected<OptionalStmtList> 364 RCParser::parseOptionalStatements(OptStmtType StmtsType) { 365 OptionalStmtList Result; 366 367 // The last statement is always followed by the start of the block. 368 while (!isNextTokenKind(Kind::BlockBegin)) { 369 ASSIGN_OR_RETURN(SingleParse, parseSingleOptionalStatement(StmtsType)); 370 Result.addStmt(std::move(*SingleParse)); 371 } 372 373 return std::move(Result); 374 } 375 376 Expected<std::unique_ptr<OptionalStmt>> 377 RCParser::parseSingleOptionalStatement(OptStmtType StmtsType) { 378 ASSIGN_OR_RETURN(TypeToken, readIdentifier()); 379 if (TypeToken->equals_lower("CHARACTERISTICS")) 380 return parseCharacteristicsStmt(); 381 if (TypeToken->equals_lower("LANGUAGE")) 382 return parseLanguageStmt(); 383 if (TypeToken->equals_lower("VERSION")) 384 return parseVersionStmt(); 385 386 if (StmtsType != OptStmtType::BasicStmt) { 387 if (TypeToken->equals_lower("CAPTION")) 388 return parseCaptionStmt(); 389 if (TypeToken->equals_lower("CLASS")) 390 return parseClassStmt(); 391 if (TypeToken->equals_lower("FONT")) 392 return parseFontStmt(StmtsType); 393 if (TypeToken->equals_lower("STYLE")) 394 return parseStyleStmt(); 395 } 396 397 return getExpectedError("optional statement type, BEGIN or '{'", 398 /* IsAlreadyRead = */ true); 399 } 400 401 RCParser::ParseType RCParser::parseLanguageResource() { 402 // Read LANGUAGE as an optional statement. If it's read correctly, we can 403 // upcast it to RCResource. 404 return parseLanguageStmt(); 405 } 406 407 RCParser::ParseType RCParser::parseAcceleratorsResource() { 408 uint16_t MemoryFlags = 409 parseMemoryFlags(AcceleratorsResource::getDefaultMemoryFlags()); 410 ASSIGN_OR_RETURN(OptStatements, parseOptionalStatements()); 411 RETURN_IF_ERROR(consumeType(Kind::BlockBegin)); 412 413 auto Accels = llvm::make_unique<AcceleratorsResource>( 414 std::move(*OptStatements), MemoryFlags); 415 416 while (!consumeOptionalType(Kind::BlockEnd)) { 417 ASSIGN_OR_RETURN(EventResult, readIntOrString()); 418 RETURN_IF_ERROR(consumeType(Kind::Comma)); 419 ASSIGN_OR_RETURN(IDResult, readInt()); 420 ASSIGN_OR_RETURN( 421 FlagsResult, 422 parseFlags(AcceleratorsResource::Accelerator::OptionsStr, 423 AcceleratorsResource::Accelerator::OptionsFlags)); 424 Accels->addAccelerator(*EventResult, *IDResult, *FlagsResult); 425 } 426 427 return std::move(Accels); 428 } 429 430 RCParser::ParseType RCParser::parseCursorResource() { 431 uint16_t MemoryFlags = 432 parseMemoryFlags(CursorResource::getDefaultMemoryFlags()); 433 ASSIGN_OR_RETURN(Arg, readFilename()); 434 return llvm::make_unique<CursorResource>(*Arg, MemoryFlags); 435 } 436 437 RCParser::ParseType RCParser::parseDialogResource(bool IsExtended) { 438 uint16_t MemoryFlags = 439 parseMemoryFlags(DialogResource::getDefaultMemoryFlags()); 440 // Dialog resources have the following format of the arguments: 441 // DIALOG: x, y, width, height [opt stmts...] {controls...} 442 // DIALOGEX: x, y, width, height [, helpID] [opt stmts...] {controls...} 443 // These are very similar, so we parse them together. 444 ASSIGN_OR_RETURN(LocResult, readIntsWithCommas(4, 4)); 445 446 uint32_t HelpID = 0; // When HelpID is unset, it's assumed to be 0. 447 if (IsExtended && consumeOptionalType(Kind::Comma)) { 448 ASSIGN_OR_RETURN(HelpIDResult, readInt()); 449 HelpID = *HelpIDResult; 450 } 451 452 ASSIGN_OR_RETURN(OptStatements, parseOptionalStatements( 453 IsExtended ? OptStmtType::DialogExStmt 454 : OptStmtType::DialogStmt)); 455 456 assert(isNextTokenKind(Kind::BlockBegin) && 457 "parseOptionalStatements, when successful, halts on BlockBegin."); 458 consume(); 459 460 auto Dialog = llvm::make_unique<DialogResource>( 461 (*LocResult)[0], (*LocResult)[1], (*LocResult)[2], (*LocResult)[3], 462 HelpID, std::move(*OptStatements), IsExtended, MemoryFlags); 463 464 while (!consumeOptionalType(Kind::BlockEnd)) { 465 ASSIGN_OR_RETURN(ControlDefResult, parseControl()); 466 Dialog->addControl(std::move(*ControlDefResult)); 467 } 468 469 return std::move(Dialog); 470 } 471 472 RCParser::ParseType RCParser::parseUserDefinedResource(IntOrString Type) { 473 uint16_t MemoryFlags = 474 parseMemoryFlags(UserDefinedResource::getDefaultMemoryFlags()); 475 if (isEof()) 476 return getExpectedError("filename, '{' or BEGIN"); 477 478 // Check if this is a file resource. 479 switch (look().kind()) { 480 case Kind::String: 481 case Kind::Identifier: 482 return llvm::make_unique<UserDefinedResource>(Type, read().value(), 483 MemoryFlags); 484 default: 485 break; 486 } 487 488 RETURN_IF_ERROR(consumeType(Kind::BlockBegin)); 489 std::vector<IntOrString> Data; 490 491 // Consume comma before each consecutive token except the first one. 492 bool ConsumeComma = false; 493 while (!consumeOptionalType(Kind::BlockEnd)) { 494 if (ConsumeComma) 495 RETURN_IF_ERROR(consumeType(Kind::Comma)); 496 ConsumeComma = true; 497 498 ASSIGN_OR_RETURN(Item, readIntOrString()); 499 Data.push_back(*Item); 500 } 501 502 return llvm::make_unique<UserDefinedResource>(Type, std::move(Data), 503 MemoryFlags); 504 } 505 506 RCParser::ParseType RCParser::parseVersionInfoResource() { 507 uint16_t MemoryFlags = 508 parseMemoryFlags(VersionInfoResource::getDefaultMemoryFlags()); 509 ASSIGN_OR_RETURN(FixedResult, parseVersionInfoFixed()); 510 ASSIGN_OR_RETURN(BlockResult, parseVersionInfoBlockContents(StringRef())); 511 return llvm::make_unique<VersionInfoResource>( 512 std::move(**BlockResult), std::move(*FixedResult), MemoryFlags); 513 } 514 515 Expected<Control> RCParser::parseControl() { 516 // Each control definition (except CONTROL) follows one of the schemes below 517 // depending on the control class: 518 // [class] text, id, x, y, width, height [, style] [, exstyle] [, helpID] 519 // [class] id, x, y, width, height [, style] [, exstyle] [, helpID] 520 // Note that control ids must be integers. 521 // Text might be either a string or an integer pointing to resource ID. 522 ASSIGN_OR_RETURN(ClassResult, readIdentifier()); 523 std::string ClassUpper = ClassResult->upper(); 524 auto CtlInfo = Control::SupportedCtls.find(ClassUpper); 525 if (CtlInfo == Control::SupportedCtls.end()) 526 return getExpectedError("control type, END or '}'", true); 527 528 // Read caption if necessary. 529 IntOrString Caption{StringRef()}; 530 if (CtlInfo->getValue().HasTitle) { 531 ASSIGN_OR_RETURN(CaptionResult, readIntOrString()); 532 RETURN_IF_ERROR(consumeType(Kind::Comma)); 533 Caption = *CaptionResult; 534 } 535 536 ASSIGN_OR_RETURN(ID, readInt()); 537 RETURN_IF_ERROR(consumeType(Kind::Comma)); 538 539 IntOrString Class; 540 Optional<uint32_t> Style; 541 if (ClassUpper == "CONTROL") { 542 // CONTROL text, id, class, style, x, y, width, height [, exstyle] [, helpID] 543 ASSIGN_OR_RETURN(ClassStr, readString()); 544 RETURN_IF_ERROR(consumeType(Kind::Comma)); 545 Class = *ClassStr; 546 ASSIGN_OR_RETURN(StyleVal, readInt()); 547 RETURN_IF_ERROR(consumeType(Kind::Comma)); 548 Style = *StyleVal; 549 } else { 550 Class = CtlInfo->getValue().CtlClass; 551 } 552 553 // x, y, width, height 554 ASSIGN_OR_RETURN(Args, readIntsWithCommas(4, 4)); 555 556 if (ClassUpper != "CONTROL") { 557 if (consumeOptionalType(Kind::Comma)) { 558 ASSIGN_OR_RETURN(Val, readInt()); 559 Style = *Val; 560 } 561 } 562 563 Optional<uint32_t> ExStyle; 564 if (consumeOptionalType(Kind::Comma)) { 565 ASSIGN_OR_RETURN(Val, readInt()); 566 ExStyle = *Val; 567 } 568 Optional<uint32_t> HelpID; 569 if (consumeOptionalType(Kind::Comma)) { 570 ASSIGN_OR_RETURN(Val, readInt()); 571 HelpID = *Val; 572 } 573 574 return Control(*ClassResult, Caption, *ID, (*Args)[0], (*Args)[1], 575 (*Args)[2], (*Args)[3], Style, ExStyle, HelpID, Class); 576 } 577 578 RCParser::ParseType RCParser::parseBitmapResource() { 579 uint16_t MemoryFlags = 580 parseMemoryFlags(BitmapResource::getDefaultMemoryFlags()); 581 ASSIGN_OR_RETURN(Arg, readFilename()); 582 return llvm::make_unique<BitmapResource>(*Arg, MemoryFlags); 583 } 584 585 RCParser::ParseType RCParser::parseIconResource() { 586 uint16_t MemoryFlags = 587 parseMemoryFlags(IconResource::getDefaultMemoryFlags()); 588 ASSIGN_OR_RETURN(Arg, readFilename()); 589 return llvm::make_unique<IconResource>(*Arg, MemoryFlags); 590 } 591 592 RCParser::ParseType RCParser::parseHTMLResource() { 593 uint16_t MemoryFlags = 594 parseMemoryFlags(HTMLResource::getDefaultMemoryFlags()); 595 ASSIGN_OR_RETURN(Arg, readFilename()); 596 return llvm::make_unique<HTMLResource>(*Arg, MemoryFlags); 597 } 598 599 RCParser::ParseType RCParser::parseMenuResource() { 600 uint16_t MemoryFlags = 601 parseMemoryFlags(MenuResource::getDefaultMemoryFlags()); 602 ASSIGN_OR_RETURN(OptStatements, parseOptionalStatements()); 603 ASSIGN_OR_RETURN(Items, parseMenuItemsList()); 604 return llvm::make_unique<MenuResource>(std::move(*OptStatements), 605 std::move(*Items), MemoryFlags); 606 } 607 608 Expected<MenuDefinitionList> RCParser::parseMenuItemsList() { 609 RETURN_IF_ERROR(consumeType(Kind::BlockBegin)); 610 611 MenuDefinitionList List; 612 613 // Read a set of items. Each item is of one of three kinds: 614 // MENUITEM SEPARATOR 615 // MENUITEM caption:String, result:Int [, menu flags]... 616 // POPUP caption:String [, menu flags]... { items... } 617 while (!consumeOptionalType(Kind::BlockEnd)) { 618 ASSIGN_OR_RETURN(ItemTypeResult, readIdentifier()); 619 620 bool IsMenuItem = ItemTypeResult->equals_lower("MENUITEM"); 621 bool IsPopup = ItemTypeResult->equals_lower("POPUP"); 622 if (!IsMenuItem && !IsPopup) 623 return getExpectedError("MENUITEM, POPUP, END or '}'", true); 624 625 if (IsMenuItem && isNextTokenKind(Kind::Identifier)) { 626 // Now, expecting SEPARATOR. 627 ASSIGN_OR_RETURN(SeparatorResult, readIdentifier()); 628 if (SeparatorResult->equals_lower("SEPARATOR")) { 629 List.addDefinition(llvm::make_unique<MenuSeparator>()); 630 continue; 631 } 632 633 return getExpectedError("SEPARATOR or string", true); 634 } 635 636 // Not a separator. Read the caption. 637 ASSIGN_OR_RETURN(CaptionResult, readString()); 638 639 // If MENUITEM, expect also a comma and an integer. 640 uint32_t MenuResult = -1; 641 642 if (IsMenuItem) { 643 RETURN_IF_ERROR(consumeType(Kind::Comma)); 644 ASSIGN_OR_RETURN(IntResult, readInt()); 645 MenuResult = *IntResult; 646 } 647 648 ASSIGN_OR_RETURN(FlagsResult, parseFlags(MenuDefinition::OptionsStr, 649 MenuDefinition::OptionsFlags)); 650 651 if (IsPopup) { 652 // If POPUP, read submenu items recursively. 653 ASSIGN_OR_RETURN(SubMenuResult, parseMenuItemsList()); 654 List.addDefinition(llvm::make_unique<PopupItem>( 655 *CaptionResult, *FlagsResult, std::move(*SubMenuResult))); 656 continue; 657 } 658 659 assert(IsMenuItem); 660 List.addDefinition( 661 llvm::make_unique<MenuItem>(*CaptionResult, MenuResult, *FlagsResult)); 662 } 663 664 return std::move(List); 665 } 666 667 RCParser::ParseType RCParser::parseStringTableResource() { 668 uint16_t MemoryFlags = 669 parseMemoryFlags(StringTableResource::getDefaultMemoryFlags()); 670 ASSIGN_OR_RETURN(OptStatements, parseOptionalStatements()); 671 RETURN_IF_ERROR(consumeType(Kind::BlockBegin)); 672 673 auto Table = llvm::make_unique<StringTableResource>(std::move(*OptStatements), 674 MemoryFlags); 675 676 // Read strings until we reach the end of the block. 677 while (!consumeOptionalType(Kind::BlockEnd)) { 678 // Each definition consists of string's ID (an integer) and a string. 679 // Some examples in documentation suggest that there might be a comma in 680 // between, however we strictly adhere to the single statement definition. 681 ASSIGN_OR_RETURN(IDResult, readInt()); 682 consumeOptionalType(Kind::Comma); 683 ASSIGN_OR_RETURN(StrResult, readString()); 684 Table->addString(*IDResult, *StrResult); 685 } 686 687 return std::move(Table); 688 } 689 690 Expected<std::unique_ptr<VersionInfoBlock>> 691 RCParser::parseVersionInfoBlockContents(StringRef BlockName) { 692 RETURN_IF_ERROR(consumeType(Kind::BlockBegin)); 693 694 auto Contents = llvm::make_unique<VersionInfoBlock>(BlockName); 695 696 while (!isNextTokenKind(Kind::BlockEnd)) { 697 ASSIGN_OR_RETURN(Stmt, parseVersionInfoStmt()); 698 Contents->addStmt(std::move(*Stmt)); 699 } 700 701 consume(); // Consume BlockEnd. 702 703 return std::move(Contents); 704 } 705 706 Expected<std::unique_ptr<VersionInfoStmt>> RCParser::parseVersionInfoStmt() { 707 // Expect either BLOCK or VALUE, then a name or a key (a string). 708 ASSIGN_OR_RETURN(TypeResult, readIdentifier()); 709 710 if (TypeResult->equals_lower("BLOCK")) { 711 ASSIGN_OR_RETURN(NameResult, readString()); 712 return parseVersionInfoBlockContents(*NameResult); 713 } 714 715 if (TypeResult->equals_lower("VALUE")) { 716 ASSIGN_OR_RETURN(KeyResult, readString()); 717 // Read a non-empty list of strings and/or ints, each 718 // possibly preceded by a comma. Unfortunately, the tool behavior depends 719 // on them existing or not, so we need to memorize where we found them. 720 std::vector<IntOrString> Values; 721 std::vector<bool> PrecedingCommas; 722 RETURN_IF_ERROR(consumeType(Kind::Comma)); 723 while (!isNextTokenKind(Kind::Identifier) && 724 !isNextTokenKind(Kind::BlockEnd)) { 725 // Try to eat a comma if it's not the first statement. 726 bool HadComma = Values.size() > 0 && consumeOptionalType(Kind::Comma); 727 ASSIGN_OR_RETURN(ValueResult, readIntOrString()); 728 Values.push_back(*ValueResult); 729 PrecedingCommas.push_back(HadComma); 730 } 731 return llvm::make_unique<VersionInfoValue>(*KeyResult, std::move(Values), 732 std::move(PrecedingCommas)); 733 } 734 735 return getExpectedError("BLOCK or VALUE", true); 736 } 737 738 Expected<VersionInfoResource::VersionInfoFixed> 739 RCParser::parseVersionInfoFixed() { 740 using RetType = VersionInfoResource::VersionInfoFixed; 741 RetType Result; 742 743 // Read until the beginning of the block. 744 while (!isNextTokenKind(Kind::BlockBegin)) { 745 ASSIGN_OR_RETURN(TypeResult, readIdentifier()); 746 auto FixedType = RetType::getFixedType(*TypeResult); 747 748 if (!RetType::isTypeSupported(FixedType)) 749 return getExpectedError("fixed VERSIONINFO statement type", true); 750 if (Result.IsTypePresent[FixedType]) 751 return getExpectedError("yet unread fixed VERSIONINFO statement type", 752 true); 753 754 // VERSION variations take multiple integers. 755 size_t NumInts = RetType::isVersionType(FixedType) ? 4 : 1; 756 ASSIGN_OR_RETURN(ArgsResult, readIntsWithCommas(NumInts, NumInts)); 757 SmallVector<uint32_t, 4> ArgInts(ArgsResult->begin(), ArgsResult->end()); 758 Result.setValue(FixedType, ArgInts); 759 } 760 761 return Result; 762 } 763 764 RCParser::ParseOptionType RCParser::parseLanguageStmt() { 765 ASSIGN_OR_RETURN(Args, readIntsWithCommas(/* min = */ 2, /* max = */ 2)); 766 return llvm::make_unique<LanguageResource>((*Args)[0], (*Args)[1]); 767 } 768 769 RCParser::ParseOptionType RCParser::parseCharacteristicsStmt() { 770 ASSIGN_OR_RETURN(Arg, readInt()); 771 return llvm::make_unique<CharacteristicsStmt>(*Arg); 772 } 773 774 RCParser::ParseOptionType RCParser::parseVersionStmt() { 775 ASSIGN_OR_RETURN(Arg, readInt()); 776 return llvm::make_unique<VersionStmt>(*Arg); 777 } 778 779 RCParser::ParseOptionType RCParser::parseCaptionStmt() { 780 ASSIGN_OR_RETURN(Arg, readString()); 781 return llvm::make_unique<CaptionStmt>(*Arg); 782 } 783 784 RCParser::ParseOptionType RCParser::parseClassStmt() { 785 ASSIGN_OR_RETURN(Arg, readIntOrString()); 786 return llvm::make_unique<ClassStmt>(*Arg); 787 } 788 789 RCParser::ParseOptionType RCParser::parseFontStmt(OptStmtType DialogType) { 790 assert(DialogType != OptStmtType::BasicStmt); 791 792 ASSIGN_OR_RETURN(SizeResult, readInt()); 793 RETURN_IF_ERROR(consumeType(Kind::Comma)); 794 ASSIGN_OR_RETURN(NameResult, readString()); 795 796 // Default values for the optional arguments. 797 uint32_t FontWeight = 0; 798 bool FontItalic = false; 799 uint32_t FontCharset = 1; 800 if (DialogType == OptStmtType::DialogExStmt) { 801 if (consumeOptionalType(Kind::Comma)) { 802 ASSIGN_OR_RETURN(Args, readIntsWithCommas(/* min = */ 0, /* max = */ 3)); 803 if (Args->size() >= 1) 804 FontWeight = (*Args)[0]; 805 if (Args->size() >= 2) 806 FontItalic = (*Args)[1] != 0; 807 if (Args->size() >= 3) 808 FontCharset = (*Args)[2]; 809 } 810 } 811 return llvm::make_unique<FontStmt>(*SizeResult, *NameResult, FontWeight, 812 FontItalic, FontCharset); 813 } 814 815 RCParser::ParseOptionType RCParser::parseStyleStmt() { 816 ASSIGN_OR_RETURN(Arg, readInt()); 817 return llvm::make_unique<StyleStmt>(*Arg); 818 } 819 820 Error RCParser::getExpectedError(const Twine &Message, bool IsAlreadyRead) { 821 return make_error<ParserError>( 822 Message, IsAlreadyRead ? std::prev(CurLoc) : CurLoc, End); 823 } 824 825 } // namespace rc 826 } // namespace llvm 827