OptionValue.h

Go to the documentation of this file.

//===-- OptionValue.h -------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef liblldb_OptionValue_h_
#define liblldb_OptionValue_h_

#include "lldb/Core/FormatEntity.h"
#include "lldb/Utility/CompletionRequest.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Status.h"
#include "lldb/lldb-defines.h"
#include "lldb/lldb-private-enumerations.h"
#include "lldb/lldb-private-interfaces.h"

namespace lldb_private {

// OptionValue
class OptionValue {
public:
  typedef enum {
    eTypeInvalid = 0,
    eTypeArch,
    eTypeArgs,
    eTypeArray,
    eTypeBoolean,
    eTypeChar,
    eTypeDictionary,
    eTypeEnum,
    eTypeFileSpec,
    eTypeFileSpecList,
    eTypeFormat,
    eTypeLanguage,
    eTypePathMap,
    eTypeProperties,
    eTypeRegex,
    eTypeSInt64,
    eTypeString,
    eTypeUInt64,
    eTypeUUID,
    eTypeFormatEntity
  } Type;

  enum {
    eDumpOptionName = (1u << 0),
    eDumpOptionType = (1u << 1),
    eDumpOptionValue = (1u << 2),
    eDumpOptionDescription = (1u << 3),
    eDumpOptionRaw = (1u << 4),
    eDumpOptionCommand = (1u << 5),
    eDumpGroupValue = (eDumpOptionName | eDumpOptionType | eDumpOptionValue),
    eDumpGroupHelp =
        (eDumpOptionName | eDumpOptionType | eDumpOptionDescription),
    eDumpGroupExport = (eDumpOptionCommand | eDumpOptionName | eDumpOptionValue)
  };

  OptionValue()
      : m_callback(nullptr), m_baton(nullptr), m_value_was_set(false) {}

  OptionValue(const OptionValue &rhs)
      : m_callback(rhs.m_callback), m_baton(rhs.m_baton),
        m_value_was_set(rhs.m_value_was_set) {}

  virtual ~OptionValue() = default;

  // Subclasses should override these functions
  virtual Type GetType() const = 0;

  // If this value is always hidden, the avoid showing any info on this value,
  // just show the info for the child values.
  virtual bool ValueIsTransparent() const {
    return GetType() == eTypeProperties;
  }

  virtual const char *GetTypeAsCString() const {
    return GetBuiltinTypeAsCString(GetType());
  }

  static const char *GetBuiltinTypeAsCString(Type t);

  virtual void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                         uint32_t dump_mask) = 0;

  virtual Status
  SetValueFromString(llvm::StringRef value,
                     VarSetOperationType op = eVarSetOperationAssign);

  virtual bool Clear() = 0;

  virtual lldb::OptionValueSP DeepCopy() const = 0;

  virtual size_t AutoComplete(CommandInterpreter &interpreter,
                              CompletionRequest &request);

  // Subclasses can override these functions
  virtual lldb::OptionValueSP GetSubValue(const ExecutionContext *exe_ctx,
                                          llvm::StringRef name,
                                          bool will_modify,
                                          Status &error) const {
    error.SetErrorStringWithFormat("'%s' is not a value subvalue", name.str().c_str());
    return lldb::OptionValueSP();
  }

  virtual Status SetSubValue(const ExecutionContext *exe_ctx,
                             VarSetOperationType op, llvm::StringRef name,
                             llvm::StringRef value);

  virtual bool IsAggregateValue() const { return false; }

  virtual ConstString GetName() const { return ConstString(); }

  virtual bool DumpQualifiedName(Stream &strm) const;

  // Subclasses should NOT override these functions as they use the above
  // functions to implement functionality
  uint32_t GetTypeAsMask() { return 1u << GetType(); }

  static uint32_t ConvertTypeToMask(OptionValue::Type type) {
    return 1u << type;
  }

  static OptionValue::Type ConvertTypeMaskToType(uint32_t type_mask) {
    // If only one bit is set, then return an appropriate enumeration
    switch (type_mask) {
    case 1u << eTypeArch:
      return eTypeArch;
    case 1u << eTypeArgs:
      return eTypeArgs;
    case 1u << eTypeArray:
      return eTypeArray;
    case 1u << eTypeBoolean:
      return eTypeBoolean;
    case 1u << eTypeChar:
      return eTypeChar;
    case 1u << eTypeDictionary:
      return eTypeDictionary;
    case 1u << eTypeEnum:
      return eTypeEnum;
    case 1u << eTypeFileSpec:
      return eTypeFileSpec;
    case 1u << eTypeFileSpecList:
      return eTypeFileSpecList;
    case 1u << eTypeFormat:
      return eTypeFormat;
    case 1u << eTypeLanguage:
      return eTypeLanguage;
    case 1u << eTypePathMap:
      return eTypePathMap;
    case 1u << eTypeProperties:
      return eTypeProperties;
    case 1u << eTypeRegex:
      return eTypeRegex;
    case 1u << eTypeSInt64:
      return eTypeSInt64;
    case 1u << eTypeString:
      return eTypeString;
    case 1u << eTypeUInt64:
      return eTypeUInt64;
    case 1u << eTypeUUID:
      return eTypeUUID;
    }
    // Else return invalid
    return eTypeInvalid;
  }

  static lldb::OptionValueSP
  CreateValueFromCStringForTypeMask(const char *value_cstr, uint32_t type_mask,
                                    Status &error);

  // Get this value as a uint64_t value if it is encoded as a boolean, uint64_t
  // or int64_t. Other types will cause "fail_value" to be returned
  uint64_t GetUInt64Value(uint64_t fail_value, bool *success_ptr);

  OptionValueArch *GetAsArch();

  const OptionValueArch *GetAsArch() const;

  OptionValueArray *GetAsArray();

  const OptionValueArray *GetAsArray() const;

  OptionValueArgs *GetAsArgs();

  const OptionValueArgs *GetAsArgs() const;

  OptionValueBoolean *GetAsBoolean();

  OptionValueChar *GetAsChar();

  const OptionValueBoolean *GetAsBoolean() const;

  const OptionValueChar *GetAsChar() const;

  OptionValueDictionary *GetAsDictionary();

  const OptionValueDictionary *GetAsDictionary() const;

  OptionValueEnumeration *GetAsEnumeration();

  const OptionValueEnumeration *GetAsEnumeration() const;

  OptionValueFileSpec *GetAsFileSpec();

  const OptionValueFileSpec *GetAsFileSpec() const;

  OptionValueFileSpecList *GetAsFileSpecList();

  const OptionValueFileSpecList *GetAsFileSpecList() const;

  OptionValueFormat *GetAsFormat();

  const OptionValueFormat *GetAsFormat() const;

  OptionValueLanguage *GetAsLanguage();

  const OptionValueLanguage *GetAsLanguage() const;

  OptionValuePathMappings *GetAsPathMappings();

  const OptionValuePathMappings *GetAsPathMappings() const;

  OptionValueProperties *GetAsProperties();

  const OptionValueProperties *GetAsProperties() const;

  OptionValueRegex *GetAsRegex();

  const OptionValueRegex *GetAsRegex() const;

  OptionValueSInt64 *GetAsSInt64();

  const OptionValueSInt64 *GetAsSInt64() const;

  OptionValueString *GetAsString();

  const OptionValueString *GetAsString() const;

  OptionValueUInt64 *GetAsUInt64();

  const OptionValueUInt64 *GetAsUInt64() const;

  OptionValueUUID *GetAsUUID();

  const OptionValueUUID *GetAsUUID() const;

  OptionValueFormatEntity *GetAsFormatEntity();

  const OptionValueFormatEntity *GetAsFormatEntity() const;

  bool GetBooleanValue(bool fail_value = false) const;

  bool SetBooleanValue(bool new_value);

  char GetCharValue(char fail_value) const;

  char SetCharValue(char new_value);

  int64_t GetEnumerationValue(int64_t fail_value = -1) const;

  bool SetEnumerationValue(int64_t value);

  FileSpec GetFileSpecValue() const;

  bool SetFileSpecValue(const FileSpec &file_spec);

  FileSpecList GetFileSpecListValue() const;

  lldb::Format
  GetFormatValue(lldb::Format fail_value = lldb::eFormatDefault) const;

  bool SetFormatValue(lldb::Format new_value);

  lldb::LanguageType GetLanguageValue(
      lldb::LanguageType fail_value = lldb::eLanguageTypeUnknown) const;

  bool SetLanguageValue(lldb::LanguageType new_language);

  const FormatEntity::Entry *GetFormatEntity() const;

  const RegularExpression *GetRegexValue() const;

  int64_t GetSInt64Value(int64_t fail_value = 0) const;

  bool SetSInt64Value(int64_t new_value);

  llvm::StringRef GetStringValue(llvm::StringRef fail_value) const;
  llvm::StringRef GetStringValue() const { return GetStringValue(llvm::StringRef()); }

  bool SetStringValue(llvm::StringRef new_value);

  uint64_t GetUInt64Value(uint64_t fail_value = 0) const;

  bool SetUInt64Value(uint64_t new_value);

  UUID GetUUIDValue() const;

  bool SetUUIDValue(const UUID &uuid);

  bool OptionWasSet() const { return m_value_was_set; }

  void SetOptionWasSet() { m_value_was_set = true; }

  void SetParent(const lldb::OptionValueSP &parent_sp) {
    m_parent_wp = parent_sp;
  }

  void SetValueChangedCallback(OptionValueChangedCallback callback,
                               void *baton) {
    assert(m_callback == nullptr);
    m_callback = callback;
    m_baton = baton;
  }

  void NotifyValueChanged() {
    if (m_callback)
      m_callback(m_baton, this);
  }

protected:
  lldb::OptionValueWP m_parent_wp;
  OptionValueChangedCallback m_callback;
  void *m_baton;
  bool m_value_was_set; // This can be used to see if a value has been set
                        // by a call to SetValueFromCString(). It is often
                        // handy to know if an option value was set from the
                        // command line or as a setting, versus if we just have
                        // the default value that was already populated in the
                        // option value.
};

} // namespace lldb_private

#endif // liblldb_OptionValue_h_