llvm/tools/llvm-rc/ResourceScriptParser.h

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