[LLDB] Fix Clang-tidy modernize-use-nullptr warnings in some files in include/lldb/Interpreter; other minor fixes.

[Eugene.Zelenko]

Summary

This is new Clang-tidy check which I run through LLDB code base, so I think will be good idea to review at least one set of changes before applying check to other places.

I checked this patch on my own build on RHEL 6.

lldb/trunk/include/lldb/Interpreter/CommandInterpreter.h

public:
     GetCommandSPExact (const char *cmd, 
                        bool include_aliases);
 
     CommandObject *
     GetCommandObjectExact (const char *cmd_cstr, 
                            bool include_aliases);
 
     CommandObject *
-    GetCommandObject (const char *cmd, 
-                      StringList *matches = NULL);
+    GetCommandObject(const char *cmd,
+                     StringList *matches = nullptr);
 
     bool
     CommandExists (const char *cmd);
 
     bool
     AliasExists (const char *cmd);
 
     bool
public:
 
     CommandObject *
     BuildAliasResult (const char *alias_name, 
                       std::string &raw_input_string, 
                       std::string &alias_result, 
                       CommandReturnObject &result);
 
     bool
-    HandleCommand (const char *command_line, 
-                   LazyBool add_to_history,
-                   CommandReturnObject &result, 
-                   ExecutionContext *override_context = NULL,
-                   bool repeat_on_empty_command = true,
-                   bool no_context_switching = false);
+    HandleCommand(const char *command_line,
+                  CommandReturnObject &result,
+                  ExecutionContext *override_context = nullptr,
     
     //------------------------------------------------------------------
     /// Execute a list of commands in sequence.
     ///
     /// @param[in] commands
     ///    The list of commands to execute.
     /// @param[in,out] context
-    ///    The execution context in which to run the commands.  Can be NULL in which case the default
+    ///    The execution context in which to run the commands. Can be nullptr in which case the default
     ///    context will be used.
     /// @param[in] options
     ///    This object holds the options used to control when to stop, whether to execute commands,
     ///    etc.
     /// @param[out] result
     ///    This is marked as succeeding with no output if all commands execute safely,
     ///    and failed with some explanation if we aborted executing the commands at some point.
     //------------------------------------------------------------------
     void
     HandleCommands (const StringList &commands, 
                     ExecutionContext *context,
                     CommandInterpreterRunOptions &options,
                     CommandReturnObject &result);
 
     //------------------------------------------------------------------
     /// Execute a list of commands from a file.
     ///
     /// @param[in] file
     ///    The file from which to read in commands.
     /// @param[in,out] context
-    ///    The execution context in which to run the commands.  Can be NULL in which case the default
+    ///    The execution context in which to run the commands. Can be nullptr in which case the default
     ///    context will be used.
     /// @param[in] options
     ///    This object holds the options used to control when to stop, whether to execute commands,
     ///    etc.
     /// @param[out] result
     ///    This is marked as succeeding with no output if all commands execute safely,
     ///    and failed with some explanation if we aborted executing the commands at some point.
     //------------------------------------------------------------------
public:
 
     bool
     GetQuitRequested () const
     {
         return m_quit_requested;
     }
 
     lldb::IOHandlerSP
-    GetIOHandler(bool force_create = false, CommandInterpreterRunOptions *options = NULL);
+    GetIOHandler(bool force_create = false, CommandInterpreterRunOptions *options = nullptr);
 
     bool
     GetStoppedForCrash () const
     {
         return m_stopped_for_crash;
     }
     
     bool
protected:
 
     size_t
     GetProcessOutput ();
 
     void
     SetSynchronous (bool value);
 
     lldb::CommandObjectSP
-    GetCommandSP (const char *cmd, bool include_aliases = true, bool exact = true, StringList *matches = NULL);
+    GetCommandSP(const char *cmd, bool include_aliases = true, bool exact = true, StringList *matches = nullptr);
     
 private:
     Error
     PreprocessCommand (std::string &command);
 
     // Completely resolves aliases and abbreviations, returning a pointer to the
     // final command object and updating command_line to the fully substituted
     // and translated command.

lldb/trunk/include/lldb/Interpreter/CommandObject.h

struct ArgumentHelpCallback
         const char*
         operator () () const
         {
             return (*help_callback)();
         }
         
         explicit operator bool() const
         {
-            return (help_callback != NULL);
+            return (help_callback != nullptr);
         }
     };
     
     struct ArgumentTableEntry  // Entries in the main argument information table
     {
         lldb::CommandArgumentType  arg_type;
         const char *arg_name;
         CommandCompletions::CommonCompletionTypes completion_type;
public:
     };
     
     typedef std::vector<CommandArgumentData> CommandArgumentEntry; // Used to build individual command argument lists
 
     static ArgumentTableEntry g_arguments_data[lldb::eArgTypeLastArg];   // Main argument information table
 
     typedef std::map<std::string, lldb::CommandObjectSP> CommandMap;
 
-    CommandObject (CommandInterpreter &interpreter,
-                   const char *name,
-                   const char *help = NULL,
-                   const char *syntax = NULL,
-                   uint32_t flags = 0);
+    CommandObject(CommandInterpreter &interpreter,
+                  const char *help = nullptr,
+                  const char *syntax = nullptr,
 
     virtual
     ~CommandObject ();
 
     static const char * 
     GetArgumentTypeAsCString (const lldb::CommandArgumentType arg_type);
     
     static const char * 
public:
     
     void
     SetIsAlias (bool value) { m_is_alias = value; }
 
     virtual bool
     IsMultiwordObject () { return false; }
 
     virtual lldb::CommandObjectSP
-    GetSubcommandSP (const char *sub_cmd, StringList *matches = NULL)
+    GetSubcommandSP(const char *sub_cmd, StringList *matches = nullptr)
     {
         return lldb::CommandObjectSP();
     }
     
     virtual CommandObject *
-    GetSubcommandObject (const char *sub_cmd, StringList *matches = NULL)
+    GetSubcommandObject(const char *sub_cmd, StringList *matches = nullptr)
     {
-        return NULL;
+        return nullptr;
     }
     
     virtual void
     AproposAllSubCommands (const char *prefix,
                            const char *search_word,
                            StringList &commands_found,
                            StringList &commands_help)
     {
public:
     
     //------------------------------------------------------------------
     /// Get the command that appropriate for a "repeat" of the current command.
     ///
     /// @param[in] current_command_line
     ///    The complete current command line.
     ///
     /// @return
-    ///     NULL if there is no special repeat command - it will use the current command line.
+    ///     nullptr if there is no special repeat command - it will use the current command line.
     ///     Otherwise a pointer to the command to be repeated.
     ///     If the returned string is the empty string, the command won't be repeated.    
     //------------------------------------------------------------------
     virtual const char *GetRepeatCommand (Args &current_command_args, uint32_t index)
     {
-        return NULL;
+        return nullptr;
     }
 
     bool
     HasOverrideCallback () const
     {
         return m_command_override_callback || m_deprecated_command_override_callback;
     }
     
protected:
     // to the specified command argument entry.
     static void
     AddIDsArgumentData(CommandArgumentEntry &arg, lldb::CommandArgumentType ID, lldb::CommandArgumentType IDRange);
 };
 
 class CommandObjectParsed : public CommandObject
 {
 public:
-    CommandObjectParsed (CommandInterpreter &interpreter,
-                         const char *name,
-                         const char *help = NULL,
-                         const char *syntax = NULL,
-                         uint32_t flags = 0) :
+    CommandObjectParsed(CommandInterpreter &interpreter,
+                        const char *help = nullptr,
+                        const char *syntax = nullptr,
         CommandObject (interpreter, name, help, syntax, flags) {}
 
     ~CommandObjectParsed() override = default;
     
     bool
     Execute(const char *args_string, CommandReturnObject &result) override;
     
 protected:
     virtual bool
     DoExecute (Args& command,
              CommandReturnObject &result) = 0;
     
     bool
     WantsRawCommandString() override
     {
         return false;
     }
 };
 
 class CommandObjectRaw : public CommandObject
 {
 public:
-    CommandObjectRaw (CommandInterpreter &interpreter,
-                         const char *name,
-                         const char *help = NULL,
-                         const char *syntax = NULL,
-                         uint32_t flags = 0) :
+    CommandObjectRaw(CommandInterpreter &interpreter,
+                     const char *help = nullptr,
+                     const char *syntax = nullptr,
         CommandObject (interpreter, name, help, syntax, flags) {}
 
     ~CommandObjectRaw() override = default;
     
     bool
     Execute(const char *args_string, CommandReturnObject &result) override;
 
 protected:    

lldb/trunk/include/lldb/Interpreter/CommandObjectMultiword.h

 //-------------------------------------------------------------------------
 
 class CommandObjectMultiword : public CommandObject
 {
 // These two want to iterate over the subcommand dictionary.
 friend class CommandInterpreter;
 friend class CommandObjectSyntax;
 public:
-    CommandObjectMultiword (CommandInterpreter &interpreter,
-                            const char *name,
-                            const char *help = NULL,
-                            const char *syntax = NULL,
-                            uint32_t flags = 0);
+    CommandObjectMultiword(CommandInterpreter &interpreter,
+                           const char *help = nullptr,
+                           const char *syntax = nullptr,
     
     ~CommandObjectMultiword() override;
 
     bool
     IsMultiwordObject() override
     {
         return true;
     }
 
     bool
     LoadSubCommand(const char *cmd_name,
                    const lldb::CommandObjectSP& command_obj) override;
 
     void
     GenerateHelpText(Stream &output_stream) override;
 
     lldb::CommandObjectSP
-    GetSubcommandSP(const char *sub_cmd, StringList *matches = NULL) override;
+    GetSubcommandSP(const char *sub_cmd, StringList *matches = nullptr) override;
 
     CommandObject *
-    GetSubcommandObject(const char *sub_cmd, StringList *matches = NULL) override;
+    GetSubcommandObject(const char *sub_cmd, StringList *matches = nullptr) override;
 
     void
     AproposAllSubCommands(const char *prefix,
                           const char *search_word,
                           StringList &commands_found,
                           StringList &commands_help) override;
 
     bool
protected:
 
     CommandObject::CommandMap m_subcommand_dict;
     bool m_can_be_removed;
 };
     
 class CommandObjectProxy : public CommandObject
 {
 public:
-    CommandObjectProxy (CommandInterpreter &interpreter,
-                        const char *name,
-                        const char *help = NULL,
-                        const char *syntax = NULL,
-                        uint32_t flags = 0);
+    CommandObjectProxy(CommandInterpreter &interpreter,
+                       const char *help = nullptr,
+                       const char *syntax = nullptr,
     
     ~CommandObjectProxy() override;
     
     // Subclasses must provide a command object that will be transparently
     // used for this object.
     virtual CommandObject *
     GetProxyCommandObject() = 0;
 
     const char *
     GetHelpLong() override;
     
     bool
     IsRemovable() const override;
 
     bool
     IsMultiwordObject() override;
     
     lldb::CommandObjectSP
-    GetSubcommandSP(const char *sub_cmd, StringList *matches = NULL) override;
+    GetSubcommandSP(const char *sub_cmd, StringList *matches = nullptr) override;
     
     CommandObject *
-    GetSubcommandObject(const char *sub_cmd, StringList *matches = NULL) override;
+    GetSubcommandObject(const char *sub_cmd, StringList *matches = nullptr) override;
     
     void
     AproposAllSubCommands(const char *prefix,
                           const char *search_word,
                           StringList &commands_found,
                           StringList &commands_help) override;
 
     bool

lldb/trunk/include/lldb/Interpreter/CommandReturnObject.h

 #include "lldb/lldb-private.h"
 #include "lldb/Core/STLUtils.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/StreamTee.h"
 
 namespace lldb_private {
 
-
 class CommandReturnObject
 {
 public:
-
     CommandReturnObject ();
     
     ~CommandReturnObject ();
 
     const char *
     GetOutputData ()
     {
         lldb::StreamSP stream_sp (m_out_stream.GetStreamAtIndex (eStreamStringIndex));
public:
 
     void
     AppendRawError (const char *in_string);
 
     void
     AppendErrorWithFormat (const char *format, ...)  __attribute__ ((format (printf, 2, 3)));
 
     void
-    SetError (const Error &error,
-              const char *fallback_error_cstr = NULL);
+    SetError(const Error &error,
+             const char *fallback_error_cstr = nullptr);
     
     void
     SetError (const char *error_cstr);
 
     lldb::ReturnStatus
     GetStatus();
 
     void
private:
     
     lldb::ReturnStatus m_status;
     bool m_did_change_process_state;
     bool m_interactive; // If true, then the input handle from the debugger will be hooked up
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandReturnObject_h_
+#endif // liblldb_CommandReturnObject_h_

lldb/trunk/include/lldb/Interpreter/OptionGroupArchitecture.h

 
 //-------------------------------------------------------------------------
 // OptionGroupArchitecture
 //-------------------------------------------------------------------------
 
 class OptionGroupArchitecture : public OptionGroup
 {
 public:
-    
     OptionGroupArchitecture ();
     
     ~OptionGroupArchitecture() override;
 
     uint32_t
     GetNumDefinitions() override;
     
     const OptionDefinition*
public:
 
     bool
     ArchitectureWasSpecified () const
     {
         return !m_arch_str.empty();
     }
 
     const char *
-    GetArchitectureName ()
+    GetArchitectureName()
     {
-        if (m_arch_str.empty())
-            return NULL;
-        return m_arch_str.c_str();
+        return (m_arch_str.empty() ? nullptr : m_arch_str.c_str());
     }
 
 protected:
-
     std::string m_arch_str; // Save the arch triple in case a platform is specified after the architecture
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_OptionGroupArchitecture_h_

lldb/trunk/include/lldb/Interpreter/OptionValue.h

-//===-- OptionValue.h --------------------------------------*- C++ -*-===//
+//===-- OptionValue.h -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
public:
             eDumpOptionType         = (1u << 1),
             eDumpOptionValue        = (1u << 2),
             eDumpOptionDescription  = (1u << 3),
             eDumpOptionRaw          = (1u << 4),
             eDumpGroupValue         = (eDumpOptionName | eDumpOptionType | eDumpOptionValue),
             eDumpGroupHelp          = (eDumpOptionName | eDumpOptionType | eDumpOptionDescription)
         };
 
-        
         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 ()
-        {
-        }
+        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 Error
         SetValueFromString (llvm::StringRef value, VarSetOperationType op = eVarSetOperationAssign);
public:
         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();
public:
 
         int64_t
         GetSInt64Value (int64_t fail_value = 0) const;
 
         bool
         SetSInt64Value (int64_t new_value);
 
         const char *
-        GetStringValue (const char *fail_value = NULL) const;
+        GetStringValue(const char *fail_value = nullptr) const;
 
         bool
         SetStringValue (const char *new_value);
 
         uint64_t
         GetUInt64Value (uint64_t fail_value = 0) const;
         
         bool
public:
         {
             m_parent_wp = parent_sp;
         }
 
         void
         SetValueChangedCallback (OptionValueChangedCallback callback,
                                  void *baton)
         {
-            assert (m_callback == NULL);
+            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_
+#endif // liblldb_OptionValue_h_

lldb/trunk/include/lldb/Interpreter/OptionValueProperties.h

-//===-- OptionValueProperties.h --------------------------------------*- C++ -*-===//
+//===-- OptionValueProperties.h ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_OptionValueProperties_h_
 #define liblldb_OptionValueProperties_h_
 
 // C Includes
 // C++ Includes
+#include <vector>
+
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/ConstString.h"
 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Interpreter/OptionValue.h"
 #include "lldb/Interpreter/Property.h"
 
 namespace lldb_private {
 
 class OptionValueProperties :
     public OptionValue,
     public std::enable_shared_from_this<OptionValueProperties>
 {
 public:
-
-    //---------------------------------------------------------------------
-    // OptionValueProperties
-    //---------------------------------------------------------------------
     OptionValueProperties () :
         OptionValue(),
         m_name (),
         m_properties (),
         m_name_to_index ()
     {
     }
 
     OptionValueProperties (const ConstString &name);
 
     OptionValueProperties (const OptionValueProperties &global_properties);
-    
-    ~OptionValueProperties() override
-    {
-    }
-    
+    ~OptionValueProperties() override = default;
     Type
     GetType() const override
     {
         return eTypeProperties;
     }
     
     bool
     Clear() override;
GetSubProperty (const ExecutionContext *exe_ctx,
                     const ConstString &name);
 
     void
     SetValueChangedCallback (uint32_t property_idx,
                              OptionValueChangedCallback callback,
                              void *baton);
 
 protected:
-
     Property *
-    ProtectedGetPropertyAtIndex (uint32_t idx)
+    ProtectedGetPropertyAtIndex(uint32_t idx)
     {
-        if (idx < m_properties.size())
-            return &m_properties[idx];
-        return NULL;
+        return ((idx < m_properties.size()) ? &m_properties[idx] : nullptr);
     }
 
     const Property *
-    ProtectedGetPropertyAtIndex (uint32_t idx) const
+    ProtectedGetPropertyAtIndex(uint32_t idx) const
     {
-        if (idx < m_properties.size())
-            return &m_properties[idx];
-        return NULL;
+        return ((idx < m_properties.size()) ? &m_properties[idx] : nullptr);
     }
 
     typedef UniqueCStringMap<size_t> NameToIndex;
 
     ConstString m_name;
     std::vector<Property> m_properties;
     NameToIndex m_name_to_index;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_OptionValueProperties_h_

lldb/trunk/include/lldb/Interpreter/OptionValueRegex.h

 //===-- OptionValueRegex.h --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_OptionValueRegex_h_
 #define liblldb_OptionValueRegex_h_
 
 // C Includes
 // C++ Includes
-#include <string>
-
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Interpreter/OptionValue.h"
 
 namespace lldb_private {
 
 class OptionValueRegex : public OptionValue
 {
 public:
-    OptionValueRegex (const char *value = NULL) :
+    OptionValueRegex(const char *value = nullptr) :
         OptionValue(),
         m_regex (value)
     {
     }
 
-    ~OptionValueRegex() override
-    {
-    }
-    
+    ~OptionValueRegex() override = default;
     //---------------------------------------------------------------------
     // Virtual subclass pure virtual overrides
     //---------------------------------------------------------------------
     
     OptionValue::Type
     GetType() const override
     {
         return eTypeRegex;
public:
     DeepCopy() const override;
 
     //---------------------------------------------------------------------
     // Subclass specific functions
     //---------------------------------------------------------------------
     const RegularExpression *
     GetCurrentValue() const
     {
-        if (m_regex.IsValid())
-            return &m_regex;
-        return NULL;
+        return (m_regex.IsValid() ? &m_regex : nullptr);
     }
     
     void
     SetCurrentValue (const char *value)
     {
         if (value && value[0])
             m_regex.Compile (value);
         else

lldb/trunk/include/lldb/Interpreter/OptionValueString.h

-//===-- OptionValueString.h --------------------------------------*- C++ -*-===//
+//===-- OptionValueString.h -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

 #include "lldb/Core/Flags.h"
 #include "lldb/Interpreter/OptionValue.h"
 
 namespace lldb_private {
 
 class OptionValueString : public OptionValue
 {
 public:
-    
     typedef Error (*ValidatorCallback) (const char* string,
                                         void* baton);
     
     enum Options
     {
         eOptionEncodeCharacterEscapeSequences = (1u << 0)
     };
 
     OptionValueString () :
         OptionValue(),
         m_current_value (),
         m_default_value (),
         m_options(),
         m_validator(),
         m_validator_baton()
     {
     }
     
-    OptionValueString (ValidatorCallback validator,
-                       void* baton = NULL) :
+    OptionValueString(ValidatorCallback validator,
+                      void* baton = nullptr) :
         OptionValue(),
         m_current_value (),
         m_default_value (),
         m_options(),
         m_validator(validator),
         m_validator_baton(baton)
     {
     }
OptionValueString (const char *current_value,
         m_validator_baton()
     {
         if  (current_value && current_value[0])
             m_current_value.assign (current_value);
         if  (default_value && default_value[0])
             m_default_value.assign (default_value);
     }
     
-    OptionValueString (const char *value,
-                       ValidatorCallback validator,
-                       void* baton = NULL) :
+    OptionValueString(const char *value,
+                      void* baton = nullptr) :
     OptionValue(),
     m_current_value (),
     m_default_value (),
     m_options(),
     m_validator(validator),
     m_validator_baton(baton)
     {
         if  (value && value[0])
         {
             m_current_value.assign (value);
             m_default_value.assign (value);
         }
     }
     
-    OptionValueString (const char *current_value,
-                       const char *default_value,
-                       ValidatorCallback validator,
-                       void* baton = NULL) :
+    OptionValueString(const char *current_value,
+                      void* baton = nullptr) :
     OptionValue(),
     m_current_value (),
     m_default_value (),
     m_options(),
     m_validator(validator),
     m_validator_baton(baton)
     {
         if  (current_value && current_value[0])
             m_current_value.assign (current_value);
         if  (default_value && default_value[0])
             m_default_value.assign (default_value);
     }
     
-    ~OptionValueString() override
-    {
-    }
-    
+    ~OptionValueString() override = default;
     //---------------------------------------------------------------------
     // Virtual subclass pure virtual overrides
     //---------------------------------------------------------------------
     
     OptionValue::Type
     GetType() const override
     {
         return eTypeString;

lldb/trunk/include/lldb/Interpreter/Options.h

 ///         SetOptionValue (uint32_t option_idx, int option_val, const char *option_arg)
 ///         {
 ///             Error error;
 ///             switch (option_val)
 ///             {
 ///             case 'g': debug = true; break;
 ///             case 'v': verbose = true; break;
 ///             case 'l': log_file = option_arg; break;
-///             case 'f': log_flags = strtoull(option_arg, NULL, 0); break;
+///             case 'f': log_flags = strtoull(option_arg, nullptr, 0); break;
 ///             default:
 ///                 error.SetErrorStringWithFormat("unrecognized short option %c", option_val);
 ///                 break;
 ///             }
 ///
 ///             return error;
 ///         }
 ///
 ///         CommandOptions (CommandInterpreter &interpreter) : debug (true), verbose (false), log_file (), log_flags (0)
 ///         {}
 ///
 ///         bool debug;
 ///         bool verbose;
 ///         std::string log_file;
 ///         uint32_t log_flags;
 ///
 ///         static struct option g_options[];
 ///
 ///     };
 ///
 ///     struct option CommandOptions::g_options[] =
 ///     {
-///         { "debug",              no_argument,        NULL,   'g' },
-///         { "log-file",           required_argument,  NULL,   'l' },
-///         { "log-flags",          required_argument,  NULL,   'f' },
-///         { "verbose",            no_argument,        NULL,   'v' },
-///         { NULL,                 0,                  NULL,   0   }
+///         { "debug",              no_argument,        nullptr,   'g' },
+///         { "log-file",           required_argument,  nullptr,   'l' },
+///         { "log-flags",          required_argument,  nullptr,   'f' },
+///         { "verbose",            no_argument,        nullptr,   'v' },
+///         { nullptr,              0,                  nullptr,   0   }
 ///     };
 ///
 ///     int main (int argc, const char **argv, const char **envp)
 ///     {
 ///         CommandOptions options;
 ///         Args main_command;
 ///         main_command.SetArguments(argc, argv, false);
 ///         main_command.ParseOptions(options);
public:
 
     bool
     SupportsLongOption (const char *long_option);
 
     // The following two pure virtual functions must be defined by every 
     // class that inherits from this class.
 
     virtual const OptionDefinition*
-    GetDefinitions () { return NULL; }
+    GetDefinitions()
+    {
+        return nullptr;
+    }
 
     // Call this prior to parsing any options. This call will call the
     // subclass OptionParsingStarting() and will avoid the need for all
     // OptionParsingStarting() function instances from having to call the
     // Option::OptionParsingStarting() like they did before. This was error
     // prone and subclasses shouldn't have to do it.
     void
     NotifyOptionParsingStarting ();
     
     Error
     NotifyOptionParsingFinished ();
 
     //------------------------------------------------------------------
     /// Set the value of an option.
     ///
     /// @param[in] option_idx
     ///     The index into the "struct option" array that was returned
     ///     by Options::GetLongOptions().
     ///
     /// @param[in] option_arg
     ///     The argument value for the option that the user entered, or
-    ///     NULL if there is no argument for the current option.
+    ///     nullptr if there is no argument for the current option.
     ///
     ///
     /// @see Args::ParseOptions (Options&)
     /// @see man getopt_long_only
     //------------------------------------------------------------------
     virtual Error
     SetOptionValue (uint32_t option_idx, const char *option_arg) = 0;
 

lldb/trunk/include/lldb/Interpreter/ScriptInterpreter.h

public:
     
     virtual bool
     GenerateWatchpointCommandCallbackData (StringList &input, std::string& output)
     {
         return false;
     }
     
     virtual bool
-    GenerateTypeScriptFunction (const char* oneliner, std::string& output, const void* name_token = NULL)
+    GenerateTypeScriptFunction(const char* oneliner, std::string& output, const void* name_token = nullptr)
     {
         return false;
     }
     
     virtual bool
-    GenerateTypeScriptFunction (StringList &input, std::string& output, const void* name_token = NULL)
+    GenerateTypeScriptFunction(StringList &input, std::string& output, const void* name_token = nullptr)
     {
         return false;
     }
     
     virtual bool
     GenerateScriptAliasFunction (StringList &input, std::string& output)
     {
         return false;
     }
     
     virtual bool
-    GenerateTypeSynthClass (StringList &input, std::string& output, const void* name_token = NULL)
+    GenerateTypeSynthClass(StringList &input, std::string& output, const void* name_token = nullptr)
     {
         return false;
     }
     
     virtual bool
-    GenerateTypeSynthClass (const char* oneliner, std::string& output, const void* name_token = NULL)
+    GenerateTypeSynthClass(const char* oneliner, std::string& output, const void* name_token = nullptr)
     {
         return false;
     }
 
     virtual StructuredData::ObjectSP
     CreateSyntheticScriptedProvider(const char *class_name, lldb::ValueObjectSP valobj)
     {
         return StructuredData::ObjectSP();