Translate index of command line item into in index of parsed argument

[sepavloff]

Summary

Support of configuration files needs means to distinguish arguments that come
from such file and those actually specified in command line. In particular, the
warnings about unused argument need to be suppressed for the arguments defined
in config files. Number of strings that come from configuration file can be
determined by the code that expands this file. Driver then converts these strings
into collection of objects of type 'llvm::opt::Arg', this is not a one-to-one
transformation. Options with separated arguments, such as '-triple' are
represented by two strings in command line but are transformed into one argument
object.

These change adds additional argument to 'OptTable::ParseArgs', which allows to
calculate number of arguments corresponding to config file content.

[sepavloff]

Current implementation in D24933 does not require this change anymore.

include/llvm/Option/OptTable.h

public:
   ///
   /// \param MissingArgIndex - On error, the index of the option which could
   /// not be parsed.
   /// \param MissingArgCount - On error, the number of missing options.
   /// \param FlagsToInclude - Only parse options with any of these flags.
   /// Zero is the default which includes all flags.
   /// \param FlagsToExclude - Don't parse options with this flag.  Zero
   /// is the default and means exclude nothing.
+  /// \param IndexToTranslate - If not null, points to the index of option in
+  /// \c Args, on exit provides index of corresponding element in the returned
+  /// array.
   /// \return An InputArgList; on error this will contain all the options
   /// which could be parsed.
+  ///
+  /// Argument \c IndexToTranslate is added to assist using configuration file.
+  /// It allows to determine correspondence between elements of \c Args that
+  /// came from configuration file and elements in the result list that
+  /// correspond to them. Due to options that require separate arguments these
+  /// numbers can be different. For instance, the two elements in \c Argc:
+  /// \verbatim
+  ///   -triple x86_64-apple-darwin
+  /// \endverbatim
+  /// result in one argument.
+  ///
+  /// If \c IndexToTranslate is not null, the function expects it points to a
+  /// variable that contains index of the first element past the content of
+  /// config file. Upon exit this variable is assigned the index of
+  /// corresponding element in the result. If the last option in config file
+  /// requires separate argument and that argument is not provided in the file
+  /// (for instance, config file contains only \c -triple), the index is written
+  /// with negative sign.
   InputArgList ParseArgs(ArrayRef<const char *> Args, unsigned &MissingArgIndex,
                          unsigned &MissingArgCount, unsigned FlagsToInclude = 0,
-                         unsigned FlagsToExclude = 0) const;
+                         unsigned FlagsToExclude = 0,
+                         int *IndexToTranslate = nullptr) const;
 
   /// \brief Render the help text for an option table.
   ///
   /// \param OS - The stream to write the help text to.
   /// \param Name - The name to use in the usage line.
   /// \param Title - The title to use in the usage line.
   /// \param FlagsToInclude - If non-zero, only include options with any
   ///                         of these flags set.

lib/Option/OptTable.cpp

Arg *OptTable::ParseOneArg(const ArgList &Args, unsigned &Index,
 
   return new Arg(getOption(TheUnknownOptionID), Str, Index++, Str);
 }
 
 InputArgList OptTable::ParseArgs(ArrayRef<const char *> ArgArr,
                                  unsigned &MissingArgIndex,
                                  unsigned &MissingArgCount,
                                  unsigned FlagsToInclude,
-                                 unsigned FlagsToExclude) const {
+                                 unsigned FlagsToExclude,
+                                 int *IndexToTranslate) const {
   InputArgList Args(ArgArr.begin(), ArgArr.end());
 
   // FIXME: Handle '@' args (or at least error on them).
 
   MissingArgIndex = MissingArgCount = 0;
+  unsigned ToTranslate = 0;
+  if (IndexToTranslate)
+    ToTranslate = static_cast<int>(*IndexToTranslate);
   unsigned Index = 0, End = ArgArr.size();
   while (Index < End) {
     // Ingore nullptrs, they are response file's EOL markers
     if (Args.getArgString(Index) == nullptr) {
       ++Index;
       continue;
     }
     // Ignore empty arguments (other things may still take them as arguments).
if (!A) {
       assert(Index >= End && "Unexpected parser error.");
       assert(Index - Prev - 1 && "No missing arguments!");
       MissingArgIndex = Prev;
       MissingArgCount = Index - Prev - 1;
       break;
     }
 
     Args.append(A);
+
+    // Check if the index to translate is reached.
+    if (ToTranslate && Prev < ToTranslate) {
+      if (Index == ToTranslate) {
+        *IndexToTranslate = static_cast<int>(Args.size());
+        ToTranslate = 0;
+      } else if (Index > ToTranslate) {
+        *IndexToTranslate = -static_cast<int>(Args.size());
+        ToTranslate = 0;
+      }
+    }
   }
 
   return Args;
 }
 
 static std::string getOptionHelpName(const OptTable &Opts, OptSpecifier Id) {
   const Option O = Opts.getOption(Id);
   std::string Name = O.getPrefixedName();

unittests/Option/OptionParsingTest.cpp

TEST(Option, FlagAliasToJoined) {
   // Check that a flag alias provides an empty argument to a joined option.
   const char *MyArgs[] = { "-K" };
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_EQ(AL.size(), 1U);
   EXPECT_TRUE(AL.hasArg(OPT_B));
   EXPECT_EQ(1U, AL.getAllArgValues(OPT_B).size());
   EXPECT_EQ("", AL.getAllArgValues(OPT_B)[0]);
 }
+
+TEST(Option, IndexTranslation) {
+  TestOptTable T;
+  unsigned MAI, MAC;
+
+  // Check that the number of config options successfully converted into the
+  // number of arguments.
+  const char *MyArgs[] = { "-A", "-C", "000", "-C", "foo", "-Bbar" };
+  int Ndx = 5;
+  InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC, 0, 0, &Ndx);
+  EXPECT_EQ(AL.size(), 4U);
+  EXPECT_TRUE(AL.hasArg(OPT_A));
+  EXPECT_TRUE(AL.hasArg(OPT_B));
+  EXPECT_EQ("bar", AL.getLastArgValue(OPT_B));
+  EXPECT_TRUE(AL.hasArg(OPT_C));
+  EXPECT_EQ("foo", AL.getLastArgValue(OPT_C));
+  EXPECT_EQ(Ndx, 3);
+}
+
+TEST(Option, IndexTranslationWrong) {
+  TestOptTable T;
+  unsigned MAI, MAC;
+
+  // Check that the the case when an option is split in the middle is detected.
+  const char *MyArgs[] = { "-A", "-C", "000", "-C", "foo", "-Bbar" };
+  int Ndx = 4;
+  InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC, 0, 0, &Ndx);
+  EXPECT_EQ(AL.size(), 4U);
+  EXPECT_TRUE(AL.hasArg(OPT_A));
+  EXPECT_TRUE(AL.hasArg(OPT_B));
+  EXPECT_EQ("bar", AL.getLastArgValue(OPT_B));
+  EXPECT_TRUE(AL.hasArg(OPT_C));
+  EXPECT_EQ("foo", AL.getLastArgValue(OPT_C));
+  EXPECT_EQ(Ndx, -3);
+}