UserSettingsController.h revision 75b11a343a035ab426473a785a045f0614af9984 
1//====-- UserSettingsController.h --------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef liblldb_UserSettingsController_h_
11#define liblldb_UserSettingsController_h_
12
13// C Includes
14// C++ Includes
15
16#include <string>
17#include <vector>
18
19// Other libraries and framework includes
20// Project includes
21
22#include "lldb/lldb-private.h"
23#include "lldb/Core/ConstString.h"
24#include "lldb/Core/StringList.h"
25#include "lldb/Core/Stream.h"
26#include "lldb/Core/StreamString.h"
27#include "lldb/Host/Mutex.h"
28
29namespace lldb_private {
30
31typedef struct
32{
33    const char *var_name;
34    lldb::SettableVariableType var_type;
35    const char *default_value;
36    lldb::OptionEnumValueElement *enum_values;
37    bool initialized;
38    bool hidden;
39    const char *description;   //help text
40} SettingEntry;
41
42
43typedef struct
44{
45    lldb::UserSettingsControllerSP parent;
46    ConstString level_name;
47    std::vector<SettingEntry> global_settings;
48    std::vector<SettingEntry> instance_settings;
49} UserSettingDefinition;
50
51class UserSettingsController
52{
53public:
54
55    UserSettingsController (const char *level_name,
56                            const lldb::UserSettingsControllerSP &parent);
57
58    virtual
59    ~UserSettingsController ();
60
61    // Pure virtual functions, which all sub-classes must implement.
62
63    virtual lldb::InstanceSettingsSP
64    CreateNewInstanceSettings (const char *instance_name) = 0;
65
66    virtual void
67    UpdateGlobalVariable (const ConstString &var_name,
68                          const char *index_value,
69                          const char *value,
70                          const SettingEntry &entry,
71                          const lldb::VarSetOperationType op,
72                          Error &err) = 0;
73
74    virtual void
75    GetGlobalSettingsValue (const ConstString &var_name,
76                            StringList &value) = 0;
77
78    // End of pure virtual functions.
79
80    Error
81    SetVariable (const char *full_dot_name,
82                 const char *value,
83                 const lldb::VarSetOperationType op,
84                 const bool override,
85                 const char *debugger_instance_name,
86                 const char *index_value = NULL);
87
88    StringList
89    GetVariable (const char *full_dot_name,
90                 lldb::SettableVariableType &var_type,
91                 const char *debugger_instance_name);
92
93    const lldb::UserSettingsControllerSP &
94    GetParent ();
95
96    const ConstString &
97    GetLevelName ();
98
99    void
100    RegisterChild (const lldb::UserSettingsControllerSP &child);
101
102    void
103    RemoveChild (const lldb::UserSettingsControllerSP &child);
104
105    void
106    CreateSettingsVector (const SettingEntry *table,
107                          const bool global);
108
109    void
110    CreateDefaultInstanceSettings ();
111
112    void
113    InitializeGlobalVariables ();
114
115    const lldb::InstanceSettingsSP &
116    FindPendingSettings (const ConstString &instance_name);
117
118    void
119    RemovePendingSettings (const ConstString &instance_name);
120
121    void
122    RegisterInstanceSettings (InstanceSettings *instance_settings);
123
124    void
125    UnregisterInstanceSettings (InstanceSettings *instance_settings);
126
127    void
128    RenameInstanceSettings (const char *old_name, const char *new_name);
129
130    // -------------------------------------------------------------------------
131    // Public static methods
132    // -------------------------------------------------------------------------
133
134    static void
135    FindAllSettingsDescriptions (CommandInterpreter &interpreter,
136                                 lldb::UserSettingsControllerSP root,
137                                 std::string &current_prefix,
138                                 StreamString &result_stream,
139                                 Error &err);
140
141    static void
142    FindSettingsDescriptions (CommandInterpreter &interpreter,
143                              lldb::UserSettingsControllerSP root,
144                              std::string &current_prefix,
145                              const char *search_name,
146                              StreamString &result_stream,
147                              Error &err);
148
149    static void
150    GetAllVariableValues (CommandInterpreter &interpreter,
151                          lldb::UserSettingsControllerSP root,
152                          std::string &current_prefix,
153                          StreamString &result_stream,
154                          Error &err);
155
156    static int
157    CompleteSettingsNames (lldb::UserSettingsControllerSP root_settings,
158                           Args &partial_setting_name_pieces,
159                           bool &word_complete,
160                           StringList &matches);
161
162    static int
163    CompleteSettingsValue (lldb::UserSettingsControllerSP root_settings,
164                           const char *full_dot_name,
165                           const char *partial_value,
166                           bool &word_complete,
167                           StringList &matches);
168
169    static Args
170    BreakNameIntoPieces (const char *full_dot_name);
171
172    static const char *
173    GetTypeString (lldb::SettableVariableType var_type);
174
175
176    static const char *
177    EnumToString (const lldb::OptionEnumValueElement *enum_values, int value);
178
179    static void
180    UpdateStringVariable (lldb::VarSetOperationType op,
181                          std::string &string_var,
182                          const char *new_value,
183                          Error &err);
184
185
186    static void
187    UpdateBooleanVariable (lldb::VarSetOperationType op,
188                           bool &bool_var,
189                           const char *new_value,
190                           Error &err);
191
192    static void
193    UpdateStringArrayVariable (lldb::VarSetOperationType op,
194                               const char *index_value,
195                               Args &array_var,
196                               const char *new_value,
197                               Error &err);
198
199    static void
200    UpdateDictionaryVariable (lldb::VarSetOperationType op,
201                              const char *index_value,
202                              std::map<std::string, std::string> &dictionary,
203                              const char *new_value,
204                              Error &err);
205
206    static void
207    UpdateEnumVariable (lldb::OptionEnumValueElement *enum_values,
208                        int *enum_var,
209                        const char *new_value,
210                        Error &err);
211
212    static bool
213    InitializeSettingsController (lldb::UserSettingsControllerSP &controller_sp,
214                                  SettingEntry *global_settings,
215                                  SettingEntry *instance_settings);
216
217    static void
218    FinalizeSettingsController (lldb::UserSettingsControllerSP &controller_sp);
219
220
221protected:
222
223    // -------------------------------------------------------------------------
224    // Protected methods are declared below here.
225    // -------------------------------------------------------------------------
226
227    bool
228    IsLiveInstance (const std::string &instance_name);
229
230    int
231    GlobalVariableMatches (const char *partial_name,
232                           const std::string &complete_prefix,
233                           StringList &matches);
234
235    int
236    InstanceVariableMatches (const char *partial_name,
237                             const std::string &complete_prefix,
238                             const char *instance_name,
239                             StringList &matches);
240
241    int
242    LiveInstanceMatches (const char *partial_name,
243                         const std::string &complete_prefix,
244                         bool &word_complete,
245                         StringList &matches);
246
247    int
248    ChildMatches (const char *partial_name,
249                  const std::string &complete_prefix,
250                  bool &word_complete,
251                  StringList &matches);
252
253
254    size_t
255    GetNumChildren ();
256
257    const lldb::UserSettingsControllerSP
258    GetChildAtIndex (size_t index);
259
260
261    const SettingEntry *
262    GetGlobalEntry (const ConstString &var_name);
263
264    const SettingEntry *
265    GetInstanceEntry (const ConstString &var_name);
266
267    void
268    BuildParentPrefix (std::string &parent_prefix);
269
270
271    void
272    CopyDefaultSettings (const lldb::InstanceSettingsSP &new_settings,
273                         const ConstString &instance_name,
274                         bool pending);
275
276    lldb::InstanceSettingsSP
277    PendingSettingsForInstance (const ConstString &instance_name);
278
279    InstanceSettings *
280    FindSettingsForInstance (const ConstString &instance_name);
281
282    void
283    GetAllPendingSettingValues (StreamString &result_stream);
284
285    void
286    GetAllDefaultSettingValues (StreamString &result_stream);
287
288    void
289    GetAllInstanceVariableValues (CommandInterpreter &interpreter,
290                                  StreamString &result_stream);
291
292    void
293    OverrideAllInstances (const ConstString &var_name,
294                          const char *value,
295                          lldb::VarSetOperationType op,
296                          const char *index_value,
297                          Error &err);
298
299    UserSettingDefinition &
300    GetControllerSettings () { return m_settings; }
301
302    // -------------------------------------------------------------------------
303    // Static protected methods are declared below here.
304    // -------------------------------------------------------------------------
305
306    static void
307    PrintEnumValues (const lldb::OptionEnumValueElement *enum_values, Stream &str);
308
309
310     static int
311     BooleanMatches (const char *partial_value,
312                     bool &word_complete,
313                     StringList &matches);
314
315     static int
316     EnumMatches (const char *partial_value,
317                  lldb::OptionEnumValueElement *enum_values,
318                  bool &word_complete,
319                  StringList &matches);
320
321    static void
322    VerifyOperationForType (lldb::SettableVariableType var_type,
323                            lldb::VarSetOperationType op,
324                            const ConstString &var_name,
325                            Error &err);
326
327    // This is protected rather than private so that classes that inherit from UserSettingsController can access it.
328
329    lldb::InstanceSettingsSP m_default_settings;
330
331private:
332
333    UserSettingDefinition m_settings;
334
335    std::vector<lldb::UserSettingsControllerSP> m_children;
336    std::map <std::string, lldb::InstanceSettingsSP> m_pending_settings;
337    std::map <std::string, InstanceSettings *> m_live_settings;    // live settings should never be NULL (hence 'live')
338    mutable Mutex m_children_mutex;
339    mutable Mutex m_pending_settings_mutex;
340    mutable Mutex m_live_settings_mutex;
341
342    DISALLOW_COPY_AND_ASSIGN (UserSettingsController);
343};
344
345class InstanceSettings
346{
347public:
348
349    InstanceSettings (UserSettingsController &owner, const char *instance_name, bool live_instance = true);
350
351    InstanceSettings (const InstanceSettings &rhs);
352
353    virtual
354    ~InstanceSettings ();
355
356    InstanceSettings&
357    operator= (const InstanceSettings &rhs);
358
359    // Begin Pure Virtual Functions
360
361    virtual void
362    UpdateInstanceSettingsVariable (const ConstString &var_name,
363                                    const char *index_value,
364                                    const char *value,
365                                    const ConstString &instance_name,
366                                    const SettingEntry &entry,
367                                    lldb::VarSetOperationType op,
368                                    Error &err,
369                                    bool pending) = 0;
370
371    virtual void
372    GetInstanceSettingsValue (const SettingEntry &entry,
373                              const ConstString &var_name,
374                              StringList &value) = 0;
375
376    virtual void
377    CopyInstanceSettings (const lldb::InstanceSettingsSP &new_settings,
378                          bool pending) = 0;
379
380    virtual const ConstString
381    CreateInstanceName () = 0;
382
383    // End Pure Virtual Functions
384
385    const ConstString &
386    GetInstanceName () { return m_instance_name; }
387
388
389    void
390    ChangeInstanceName (const std::string &new_instance_name);
391
392    static const ConstString &
393    GetDefaultName ();
394
395    static const ConstString &
396    InvalidName ();
397
398protected:
399
400    UserSettingsController &m_owner;
401    ConstString m_instance_name;
402};
403
404
405
406} // namespace lldb_private
407
408#endif // liblldb_UserSettingsController_h_
409