1 //===-- ResourceScriptParser.h ----------------------------------*- C++-*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===---------------------------------------------------------------------===//
10 // This defines the RC scripts parser. It takes a sequence of RC tokens
11 // and then provides the method to parse the resources one by one.
13 //===---------------------------------------------------------------------===//
15 #ifndef LLVM_TOOLS_LLVMRC_RESOURCESCRIPTPARSER_H
16 #define LLVM_TOOLS_LLVMRC_RESOURCESCRIPTPARSER_H
18 #include "ResourceScriptStmt.h"
19 #include "ResourceScriptToken.h"
21 #include "llvm/Support/Compiler.h"
22 #include "llvm/Support/raw_ostream.h"
24 #include <system_error>
35 using LocIter = std::vector<RCToken>::iterator;
36 using ParseType = Expected<std::unique_ptr<RCResource>>;
37 using ParseOptionType = Expected<std::unique_ptr<OptionalStmt>>;
39 // Class describing a single failure of parser.
40 class ParserError : public ErrorInfo<ParserError> {
42 ParserError(const Twine &Expected, const LocIter CurLoc, const LocIter End);
44 void log(raw_ostream &OS) const override { OS << CurMessage; }
45 std::error_code convertToErrorCode() const override {
46 return std::make_error_code(std::errc::invalid_argument);
48 const std::string &getMessage() const { return CurMessage; }
50 static char ID; // Keep llvm::Error happy.
53 std::string CurMessage;
54 LocIter ErrorLoc, FileEnd;
57 explicit RCParser(std::vector<RCToken> TokenList);
59 // Reads and returns a single resource definition, or error message if any
61 ParseType parseSingleResource();
66 using Kind = RCToken::Kind;
68 // Checks if the current parser state points to the token of type TokenKind.
69 bool isNextTokenKind(Kind TokenKind) const;
71 // These methods assume that the parser is not in EOF state.
73 // Take a look at the current token. Do not fetch it.
74 const RCToken &look() const;
75 // Read the current token and advance the state by one token.
76 const RCToken &read();
77 // Advance the state by one token, discarding the current token.
80 // The following methods try to read a single token, check if it has the
81 // correct type and then parse it.
82 // Each integer can be written as an arithmetic expression producing an
83 // unsigned 32-bit integer.
84 Expected<RCInt> readInt(); // Parse an integer.
85 Expected<StringRef> readString(); // Parse a string.
86 Expected<StringRef> readIdentifier(); // Parse an identifier.
87 Expected<StringRef> readFilename(); // Parse a filename.
88 Expected<IntOrString> readIntOrString(); // Parse an integer or a string.
89 Expected<IntOrString> readTypeOrName(); // Parse an integer or an identifier.
91 // Helper integer expression parsing methods.
92 Expected<RCInt> parseIntExpr1();
93 Expected<RCInt> parseIntExpr2();
95 // Advance the state by one, discarding the current token.
96 // If the discarded token had an incorrect type, fail.
97 Error consumeType(Kind TokenKind);
99 // Check the current token type. If it's TokenKind, discard it.
100 // Return true if the parser consumed this token successfully.
101 bool consumeOptionalType(Kind TokenKind);
103 // Read at least MinCount, and at most MaxCount integers separated by
104 // commas. The parser stops reading after fetching MaxCount integers
105 // or after an error occurs. Whenever the parser reads a comma, it
106 // expects an integer to follow.
107 Expected<SmallVector<RCInt, 8>> readIntsWithCommas(size_t MinCount,
110 // Read an unknown number of flags preceded by commas. Each correct flag
111 // has an entry in FlagDesc array of length NumFlags. In case i-th
112 // flag (0-based) has been read, the result is OR-ed with FlagValues[i].
113 // As long as parser has a comma to read, it expects to be fed with
114 // a correct flag afterwards.
115 Expected<uint32_t> parseFlags(ArrayRef<StringRef> FlagDesc,
116 ArrayRef<uint32_t> FlagValues);
118 // Reads a set of optional statements. These can change the behavior of
119 // a number of resource types (e.g. STRINGTABLE, MENU or DIALOG) if provided
120 // before the main block with the contents of the resource.
121 // Usually, resources use a basic set of optional statements:
122 // CHARACTERISTICS, LANGUAGE, VERSION
123 // However, DIALOG and DIALOGEX extend this list by the following items:
124 // CAPTION, CLASS, EXSTYLE, FONT, MENU, STYLE
125 // UseExtendedStatements flag (off by default) allows the parser to read
126 // the additional types of statements.
128 // Ref (to the list of all optional statements):
129 // msdn.microsoft.com/en-us/library/windows/desktop/aa381002(v=vs.85).aspx
130 enum class OptStmtType { BasicStmt, DialogStmt, DialogExStmt };
132 uint16_t parseMemoryFlags(uint16_t DefaultFlags);
134 Expected<OptionalStmtList>
135 parseOptionalStatements(OptStmtType StmtsType = OptStmtType::BasicStmt);
137 // Read a single optional statement.
138 Expected<std::unique_ptr<OptionalStmt>>
139 parseSingleOptionalStatement(OptStmtType StmtsType = OptStmtType::BasicStmt);
141 // Top-level resource parsers.
142 ParseType parseLanguageResource();
143 ParseType parseAcceleratorsResource();
144 ParseType parseBitmapResource();
145 ParseType parseCursorResource();
146 ParseType parseDialogResource(bool IsExtended);
147 ParseType parseIconResource();
148 ParseType parseHTMLResource();
149 ParseType parseMenuResource();
150 ParseType parseStringTableResource();
151 ParseType parseUserDefinedResource(IntOrString Type);
152 ParseType parseVersionInfoResource();
154 // Helper DIALOG parser - a single control.
155 Expected<Control> parseControl();
157 // Helper MENU parser.
158 Expected<MenuDefinitionList> parseMenuItemsList();
160 // Helper VERSIONINFO parser - read the contents of a single BLOCK statement,
161 // from BEGIN to END.
162 Expected<std::unique_ptr<VersionInfoBlock>>
163 parseVersionInfoBlockContents(StringRef BlockName);
164 // Helper VERSIONINFO parser - read either VALUE or BLOCK statement.
165 Expected<std::unique_ptr<VersionInfoStmt>> parseVersionInfoStmt();
166 // Helper VERSIONINFO parser - read fixed VERSIONINFO statements.
167 Expected<VersionInfoResource::VersionInfoFixed> parseVersionInfoFixed();
169 // Optional statement parsers.
170 ParseOptionType parseLanguageStmt();
171 ParseOptionType parseCharacteristicsStmt();
172 ParseOptionType parseVersionStmt();
173 ParseOptionType parseCaptionStmt();
174 ParseOptionType parseClassStmt();
175 ParseOptionType parseFontStmt(OptStmtType DialogType);
176 ParseOptionType parseStyleStmt();
178 // Raises an error. If IsAlreadyRead = false (default), this complains about
179 // the token that couldn't be parsed. If the flag is on, this complains about
180 // the correctly read token that makes no sense (that is, the current parser
181 // state is beyond the erroneous token.)
182 Error getExpectedError(const Twine &Message, bool IsAlreadyRead = false);
184 std::vector<RCToken> Tokens;