1 files changed, 0 insertions, 196 deletions
diff --git a/Source/cmCommandArgumentsHelper.h b/Source/cmCommandArgumentsHelper.h
deleted file mode 100644
index 44db374d6..000000000
--- a/Source/cmCommandArgumentsHelper.h
+++ /dev/null
@@ -1,196 +0,0 @@
-/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-   file Copyright.txt or https://cmake.org/licensing for details.  */
-#ifndef cmCommandArgumentsHelper_h
-#define cmCommandArgumentsHelper_h
-
-#include "cmConfigure.h"
-
-#include <set>
-#include <string>
-#include <vector>
-
-class cmCommandArgumentGroup;
-class cmCommandArgumentsHelper;
-
-/* cmCommandArgumentsHelper, cmCommandArgumentGroup and cmCommandArgument (i.e.
-its derived classes cmCAXXX can be used to simplify the processing of
-arguments to cmake commands. Maybe they can also be used to generate
-documentation.
-
-For every argument supported by a command one cmCommandArgument is created
-and added to cmCommandArgumentsHelper. cmCommand has a cmCommandArgumentsHelper
-as member variable so this should be used.
-
-The order of the arguments is defined using the Follows(arg) method. It says
-that this argument follows immediateley the given argument. It can be used
-with multiple arguments if the argument can follow after different arguments.
-
-Arguments can be arranged in groups using cmCommandArgumentGroup. Every
-member of a group can follow any other member of the group. These groups
-can also be used to define the order.
-
-Once all arguments and groups are set up, cmCommandArgumentsHelper::Parse()
-is called and afterwards the values of the arguments can be evaluated.
-
-For an example see cmExportCommand.cxx.
-*/
-class cmCommandArgument
-{
-public:
-  cmCommandArgument(cmCommandArgumentsHelper* args, const char* key,
-                    cmCommandArgumentGroup* group = CM_NULLPTR);
-  virtual ~cmCommandArgument() {}
-
-  /// this argument may follow after arg. 0 means it comes first.
-  void Follows(const cmCommandArgument* arg);
-
-  /// this argument may follow after any of the arguments in the given group
-  void FollowsGroup(const cmCommandArgumentGroup* group);
-
-  /// Returns true if the argument was found in the argument list
-  bool WasFound() const { return this->WasActive; }
-
-  // The following methods are only called from
-  // cmCommandArgumentsHelper::Parse(), but making this a friend would
-  // give it access to everything
-
-  /// Make the current argument the currently active argument
-  void Activate();
-  /// Consume the current string
-  bool Consume(const std::string& arg);
-
-  /// Return true if this argument may follow after the given argument.
-  bool MayFollow(const cmCommandArgument* current) const;
-
-  /** Returns true if the given key matches the key for this argument.
-  If this argument has an empty key everything matches. */
-  bool KeyMatches(const std::string& key) const;
-
-  /// Make this argument follow all members of the own group
-  void ApplyOwnGroup();
-
-  /// Reset argument, so it's back to its initial state
-  void Reset();
-
-private:
-  const char* Key;
-  std::set<const cmCommandArgument*> ArgumentsBefore;
-  cmCommandArgumentGroup* Group;
-  bool WasActive;
-  bool ArgumentsBeforeEmpty;
-  unsigned int CurrentIndex;
-
-  virtual bool DoConsume(const std::string& arg, unsigned int index) = 0;
-  virtual void DoReset() = 0;
-};
-
-/** cmCAStringVector is to be used for arguments which can consist of more
-than one string, e.g. the FILES argument in INSTALL(FILES f1 f2 f3 ...). */
-class cmCAStringVector : public cmCommandArgument
-{
-public:
-  cmCAStringVector(cmCommandArgumentsHelper* args, const char* key,
-                   cmCommandArgumentGroup* group = CM_NULLPTR);
-
-  /// Return the vector of strings
-  const std::vector<std::string>& GetVector() const { return this->Vector; }
-
-  /** Is there a keyword which should be skipped in
-  the arguments (e.g. ARGS for ADD_CUSTOM_COMMAND) ? */
-  void SetIgnore(const char* ignore) { this->Ignore = ignore; }
-private:
-  std::vector<std::string> Vector;
-  unsigned int DataStart;
-  const char* Ignore;
-  cmCAStringVector();
-  bool DoConsume(const std::string& arg, unsigned int index) CM_OVERRIDE;
-  void DoReset() CM_OVERRIDE;
-};
-
-/** cmCAString is to be used for arguments which consist of one value,
-e.g. the executable name in ADD_EXECUTABLE(). */
-class cmCAString : public cmCommandArgument
-{
-public:
-  cmCAString(cmCommandArgumentsHelper* args, const char* key,
-             cmCommandArgumentGroup* group = CM_NULLPTR);
-
-  /// Return the string
-  const std::string& GetString() const { return this->String; }
-  const char* GetCString() const { return this->String.c_str(); }
-private:
-  std::string String;
-  unsigned int DataStart;
-  bool DoConsume(const std::string& arg, unsigned int index) CM_OVERRIDE;
-  void DoReset() CM_OVERRIDE;
-  cmCAString();
-};
-
-/** cmCAEnabler is to be used for options which are off by default and can be
-enabled using a special argument, e.g. EXCLUDE_FROM_ALL in ADD_EXECUTABLE(). */
-class cmCAEnabler : public cmCommandArgument
-{
-public:
-  cmCAEnabler(cmCommandArgumentsHelper* args, const char* key,
-              cmCommandArgumentGroup* group = CM_NULLPTR);
-
-  /// Has it been enabled ?
-  bool IsEnabled() const { return this->Enabled; }
-private:
-  bool Enabled;
-  bool DoConsume(const std::string& arg, unsigned int index) CM_OVERRIDE;
-  void DoReset() CM_OVERRIDE;
-  cmCAEnabler();
-};
-
-/** cmCADisable is to be used for options which are on by default and can be
-disabled using a special argument.*/
-class cmCADisabler : public cmCommandArgument
-{
-public:
-  cmCADisabler(cmCommandArgumentsHelper* args, const char* key,
-               cmCommandArgumentGroup* group = CM_NULLPTR);
-
-  /// Is it still enabled ?
-  bool IsEnabled() const { return this->Enabled; }
-private:
-  bool Enabled;
-  bool DoConsume(const std::string& arg, unsigned int index) CM_OVERRIDE;
-  void DoReset() CM_OVERRIDE;
-  cmCADisabler();
-};
-
-/** Group of arguments, needed for ordering. E.g. WIN32, EXCLUDE_FROM_ALL and
-MACSOX_BUNDLE from ADD_EXECUTABLE() are a group.
-*/
-class cmCommandArgumentGroup
-{
-  friend class cmCommandArgument;
-
-public:
-  cmCommandArgumentGroup() {}
-
-  /// All members of this group may follow the given argument
-  void Follows(const cmCommandArgument* arg);
-
-  /// All members of this group may follow all members of the given group
-  void FollowsGroup(const cmCommandArgumentGroup* group);
-
-private:
-  std::vector<cmCommandArgument*> ContainedArguments;
-};
-
-class cmCommandArgumentsHelper
-{
-public:
-  /// Parse the argument list
-  void Parse(const std::vector<std::string>* args,
-             std::vector<std::string>* unconsumedArgs);
-  /// Add an argument.
-  void AddArgument(cmCommandArgument* arg);
-
-private:
-  std::vector<cmCommandArgument*> Arguments;
-};
-
-#endif