Change void* name_token to const void* to address warnings.

[clayborg]

Looks good.

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, void* name_token = NULL)
+    GenerateTypeScriptFunction (const char* oneliner, std::string& output, const void* name_token = NULL)
     {
         return false;
     }
     
     virtual bool
-    GenerateTypeScriptFunction (StringList &input, std::string& output, void* name_token = NULL)
+    GenerateTypeScriptFunction (StringList &input, std::string& output, const void* name_token = NULL)
     {
         return false;
     }
     
     virtual bool
     GenerateScriptAliasFunction (StringList &input, std::string& output)
     {
         return false;
     }
     
     virtual bool
-    GenerateTypeSynthClass (StringList &input, std::string& output, void* name_token = NULL)
+    GenerateTypeSynthClass (StringList &input, std::string& output, const void* name_token = NULL)
     {
         return false;
     }
     
     virtual bool
-    GenerateTypeSynthClass (const char* oneliner, std::string& output, void* name_token = NULL)
+    GenerateTypeSynthClass (const char* oneliner, std::string& output, const void* name_token = NULL)
     {
         return false;
     }
     
     virtual lldb::ScriptInterpreterObjectSP
     CreateSyntheticScriptedProvider (const char *class_name,
                                      lldb::ValueObjectSP valobj)
     {

include/lldb/Interpreter/ScriptInterpreterPython.h

public:
     lldb_private::Error
     ExecuteMultipleLines (const char *in_string,
                           const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
 
     Error
     ExportFunctionDefinitionToInterpreter (StringList &function_def) override;
 
     bool
-    GenerateTypeScriptFunction (StringList &input, std::string& output, void* name_token = NULL) override;
+    GenerateTypeScriptFunction (StringList &input, std::string& output, const void* name_token = NULL) override;
     
     bool
-    GenerateTypeSynthClass (StringList &input, std::string& output, void* name_token = NULL) override;
+    GenerateTypeSynthClass (StringList &input, std::string& output, const void* name_token = NULL) override;
     
     bool
-    GenerateTypeSynthClass (const char* oneliner, std::string& output, void* name_token = NULL) override;
+    GenerateTypeSynthClass (const char* oneliner, std::string& output, const void* name_token = NULL) override;
     
     // use this if the function code is just a one-liner script
     bool
-    GenerateTypeScriptFunction (const char* oneliner, std::string& output, void* name_token = NULL) override;
+    GenerateTypeScriptFunction (const char* oneliner, std::string& output, const void* name_token = NULL) override;
     
     bool
     GenerateScriptAliasFunction (StringList &input, std::string& output) override;
     
     lldb::ScriptInterpreterObjectSP
     CreateSyntheticScriptedProvider (const char *class_name,
                                      lldb::ValueObjectSP valobj) override;
 

source/API/SBTypeCategory.cpp

SBTypeCategory::AddTypeSummary (SBTypeNameSpecifier type_name,
     if (!summary.IsValid())
         return false;
     
     // FIXME: we need to iterate over all the Debugger objects and have each of them contain a copy of the function
     // since we currently have formatters live in a global space, while Python code lives in a specific Debugger-related environment
     // this should eventually be fixed by deciding a final location in the LLDB object space for formatters
     if (summary.IsFunctionCode())
     {
-        void *name_token = (void*)ConstString(type_name.GetName()).GetCString();
+        const void *name_token = (const void*)ConstString(type_name.GetName()).GetCString();
         const char* script = summary.GetData();
         StringList input; input.SplitIntoLines(script, strlen(script));
         uint32_t num_debuggers = lldb_private::Debugger::GetNumDebuggers();
         bool need_set = true;
         for (uint32_t j = 0;
              j < num_debuggers;
              j++)
         {
SBTypeCategory::AddTypeSynthetic (SBTypeNameSpecifier type_name,
     if (!synth.IsValid())
         return false;
 
     // FIXME: we need to iterate over all the Debugger objects and have each of them contain a copy of the function
     // since we currently have formatters live in a global space, while Python code lives in a specific Debugger-related environment
     // this should eventually be fixed by deciding a final location in the LLDB object space for formatters
     if (synth.IsClassCode())
     {
-        void *name_token = (void*)ConstString(type_name.GetName()).GetCString();
+        const void *name_token = (const void*)ConstString(type_name.GetName()).GetCString();
         const char* script = synth.GetData();
         StringList input; input.SplitIntoLines(script, strlen(script));
         uint32_t num_debuggers = lldb_private::Debugger::GetNumDebuggers();
         bool need_set = true;
         for (uint32_t j = 0;
              j < num_debuggers;
              j++)
         {

source/Interpreter/ScriptInterpreterPython.cpp

if (!m_sys_module_dict)
             m_sys_module_dict.Reset(PyModule_GetDict (sys_module));
     }
     return m_sys_module_dict;
 }
 
 static std::string
 GenerateUniqueName (const char* base_name_wanted,
                     uint32_t& functions_counter,
-                    void* name_token = nullptr)
+                    const void* name_token = nullptr)
 {
     StreamString sstr;
     
     if (!base_name_wanted)
         return std::string();
     
     if (!name_token)
         sstr.Printf ("%s_%d", base_name_wanted, functions_counter++);
ScriptInterpreterPython::GenerateFunction(const char *signature, const StringList &input)
     // Verify that the results are valid Python.
     
     error = ExportFunctionDefinitionToInterpreter (auto_generated_function);
     
     return error;
 }
 
 bool
-ScriptInterpreterPython::GenerateTypeScriptFunction (StringList &user_input, std::string& output, void* name_token)
+ScriptInterpreterPython::GenerateTypeScriptFunction (StringList &user_input, std::string& output, const void* name_token)
 {
     static uint32_t num_created_functions = 0;
     user_input.RemoveBlankLines ();
     StreamString sstr;
     
     // Check to see if we have any data; if not, just return.
     if (user_input.GetSize() == 0)
         return false;
ScriptInterpreterPython::GenerateScriptAliasFunction (StringList &user_input, std::string &output)
     
     // Store the name of the auto-generated function to be called.
     output.assign(auto_generated_function_name);
     return true;
 }
 
 
 bool
-ScriptInterpreterPython::GenerateTypeSynthClass (StringList &user_input, std::string &output, void* name_token)
+ScriptInterpreterPython::GenerateTypeSynthClass (StringList &user_input, std::string &output, const void* name_token)
 {
     static uint32_t num_created_classes = 0;
     user_input.RemoveBlankLines ();
     int num_lines = user_input.GetSize ();
     StreamString sstr;
     
     // Check to see if we have any data; if not, just return.
     if (user_input.GetSize() == 0)
void* ret_val;
                                            python_interpreter->m_dictionary_name.c_str(),
                                            valobj);
     }
     
     return MakeScriptObject(ret_val);
 }
 
 bool
-ScriptInterpreterPython::GenerateTypeScriptFunction (const char* oneliner, std::string& output, void* name_token)
+ScriptInterpreterPython::GenerateTypeScriptFunction (const char* oneliner, std::string& output, const void* name_token)
 {
     StringList input;
     input.SplitIntoLines(oneliner, strlen(oneliner));
     return GenerateTypeScriptFunction(input, output, name_token);
 }
 
 bool
-ScriptInterpreterPython::GenerateTypeSynthClass (const char* oneliner, std::string& output, void* name_token)
+ScriptInterpreterPython::GenerateTypeSynthClass (const char* oneliner, std::string& output, const void* name_token)
 {
     StringList input;
     input.SplitIntoLines(oneliner, strlen(oneliner));
     return GenerateTypeSynthClass(input, output, name_token);
 }
 
 
 Error