UserSettingsController.h revision 598df88bd6fc33c6fb330bc859bdc277795501f3 
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#include "lldb/Interpreter/NamedOptionValue.h"
29
30namespace lldb_private {
31
32typedef struct
33{
34    const char *var_name;
35    SettableVariableType var_type;
36    const char *default_value;
37    OptionEnumValueElement *enum_values;
38    bool initialized;
39    bool hidden;
40    const char *description;   //help text
41} SettingEntry;
42
43
44typedef struct
45{
46    lldb::UserSettingsControllerSP parent;
47    ConstString level_name;
48    std::vector<SettingEntry> global_settings;
49    std::vector<SettingEntry> instance_settings;
50} UserSettingDefinition;
51
52class UserSettingsController :
53    public STD_ENABLE_SHARED_FROM_THIS(UserSettingsController)
54{
55public:
56
57    UserSettingsController (const char *level_name,
58                            const lldb::UserSettingsControllerSP &parent);
59
60    virtual
61    ~UserSettingsController ();
62
63    // Pure virtual functions, which all sub-classes must implement.
64    virtual lldb::InstanceSettingsSP
65    CreateInstanceSettings (const char *instance_name) = 0;
66
67    // Virtual functions that you can override if you have global settings
68    // (not instance specific).
69    virtual bool
70    SetGlobalVariable (const ConstString &var_name,
71                       const char *index_value,
72                       const char *value,
73                       const SettingEntry &entry,
74                       const VarSetOperationType op,
75                       Error &err);
76
77    virtual bool
78    GetGlobalVariable (const ConstString &var_name,
79                       StringList &value,
80                       Error &err);
81
82    // End of pure virtual functions.
83    StringList
84    GetVariable (const char *full_dot_name,
85                 SettableVariableType &var_type,
86                 const char *debugger_instance_name,
87                 Error &err);
88
89    Error
90    SetVariable (const char *full_dot_name,
91                 const char *value,
92                 const VarSetOperationType op,
93                 const bool override,
94                 const char *debugger_instance_name,
95                 const char *index_value = NULL);
96
97    const lldb::UserSettingsControllerSP &
98    GetParent ();
99
100    const ConstString &
101    GetLevelName ();
102
103    void
104    RegisterChild (const lldb::UserSettingsControllerSP &child);
105
106    void
107    RemoveChild (const lldb::UserSettingsControllerSP &child);
108
109    void
110    CreateSettingsVector (const SettingEntry *table,
111                          const bool global);
112
113    void
114    CreateDefaultInstanceSettings ();
115
116    void
117    InitializeGlobalVariables ();
118
119    const lldb::InstanceSettingsSP &
120    FindPendingSettings (const ConstString &instance_name);
121
122    void
123    RemovePendingSettings (const ConstString &instance_name);
124
125    void
126    RegisterInstanceSettings (InstanceSettings *instance_settings);
127
128    void
129    UnregisterInstanceSettings (InstanceSettings *instance_settings);
130
131    void
132    RenameInstanceSettings (const char *old_name, const char *new_name);
133
134    void
135    SetDefaultInstanceSettings (const lldb::InstanceSettingsSP &instance_settings_sp)
136    {
137        m_default_settings = instance_settings_sp;
138    }
139    // -------------------------------------------------------------------------
140    // Public static methods
141    // -------------------------------------------------------------------------
142
143    static void
144    FindAllSettingsDescriptions (CommandInterpreter &interpreter,
145                                 const lldb::UserSettingsControllerSP& usc_sp,
146                                 const char *current_prefix,
147                                 Stream &result_stream,
148                                 Error &err);
149
150    static void
151    FindSettingsDescriptions (CommandInterpreter &interpreter,
152                              const lldb::UserSettingsControllerSP& usc_sp,
153                              const char *current_prefix,
154                              const char *search_name,
155                              Stream &result_stream,
156                              Error &err);
157
158    static void
159    SearchAllSettingsDescriptions (CommandInterpreter &interpreter,
160                                   const lldb::UserSettingsControllerSP& usc_sp,
161                                   const char *current_prefix,
162                                   const char *search_word,
163                                   Stream &result_stream);
164
165    static void
166    GetAllVariableValues (CommandInterpreter &interpreter,
167                          const lldb::UserSettingsControllerSP& usc_sp,
168                          const char *current_prefix,
169                          Stream &result_stream,
170                          Error &err);
171
172    static bool
173    DumpValue (CommandInterpreter &interpreter,
174               const lldb::UserSettingsControllerSP& usc_sp,
175               const char *variable_dot_name,
176               Stream &strm);
177
178    static bool
179    DumpValue (const char *variable_dot_name,
180               SettableVariableType var_type,
181               const StringList &variable_value,
182               Stream &strm);
183
184    static int
185    CompleteSettingsNames (const lldb::UserSettingsControllerSP& usc_sp,
186                           Args &partial_setting_name_pieces,
187                           bool &word_complete,
188                           StringList &matches);
189
190    static int
191    CompleteSettingsValue (const lldb::UserSettingsControllerSP& usc_sp,
192                           const char *full_dot_name,
193                           const char *partial_value,
194                           bool &word_complete,
195                           StringList &matches);
196
197    static Args
198    BreakNameIntoPieces (const char *full_dot_name);
199
200    static const char *
201    GetTypeString (SettableVariableType var_type);
202
203
204    static const char *
205    EnumToString (const OptionEnumValueElement *enum_values, int value);
206
207    static void
208    UpdateStringVariable (VarSetOperationType op,
209                          std::string &string_var,
210                          const char *new_value,
211                          Error &err);
212
213
214    static void
215    UpdateBooleanVariable (VarSetOperationType op,
216                           bool &bool_var,
217                           const char *new_value,
218                           bool clear_value, // Used for op == eVarSetOperationClear
219                           Error &err);
220
221    static void
222    UpdateStringArrayVariable (VarSetOperationType op,
223                               const char *index_value,
224                               Args &array_var,
225                               const char *new_value,
226                               Error &err);
227
228    static void
229    UpdateDictionaryVariable (VarSetOperationType op,
230                              const char *index_value,
231                              std::map<std::string, std::string> &dictionary,
232                              const char *new_value,
233                              Error &err);
234
235    static void
236    UpdateEnumVariable (OptionEnumValueElement *enum_values,
237                        int *enum_var,
238                        const char *new_value,
239                        Error &err);
240
241    static Error
242    UpdateStringOptionValue (const char *new_value_cstr,
243                             VarSetOperationType op,
244                             OptionValueString &option_value);
245
246    static Error
247    UpdateBooleanOptionValue (const char *new_value_cstr,
248                              VarSetOperationType op,
249                              OptionValueBoolean &option_value);
250
251    static Error
252    UpdateFileSpecOptionValue (const char *new_value_cstr,
253                               VarSetOperationType op,
254                               OptionValueFileSpec &option_value);
255
256    static bool
257    InitializeSettingsController (lldb::UserSettingsControllerSP &controller_sp,
258                                  SettingEntry *global_settings,
259                                  SettingEntry *instance_settings);
260
261    static void
262    FinalizeSettingsController (lldb::UserSettingsControllerSP &controller_sp);
263
264
265    lldb::InstanceSettingsSP
266    GetDefaultInstanceSettings ()
267    {
268        return m_default_settings;
269    }
270
271protected:
272
273    // -------------------------------------------------------------------------
274    // Protected methods are declared below here.
275    // -------------------------------------------------------------------------
276
277    bool
278    IsLiveInstance (const std::string &instance_name);
279
280    int
281    GlobalVariableMatches (const char *partial_name,
282                           const std::string &complete_prefix,
283                           StringList &matches);
284
285    int
286    InstanceVariableMatches (const char *partial_name,
287                             const std::string &complete_prefix,
288                             const char *instance_name,
289                             StringList &matches);
290
291    int
292    LiveInstanceMatches (const char *partial_name,
293                         const std::string &complete_prefix,
294                         bool &word_complete,
295                         StringList &matches);
296
297    int
298    ChildMatches (const char *partial_name,
299                  const std::string &complete_prefix,
300                  bool &word_complete,
301                  StringList &matches);
302
303
304    size_t
305    GetNumChildren ();
306
307    const lldb::UserSettingsControllerSP
308    GetChildAtIndex (size_t index);
309
310
311    const SettingEntry *
312    GetGlobalEntry (const ConstString &var_name);
313
314    const SettingEntry *
315    GetInstanceEntry (const ConstString &var_name);
316
317    void
318    BuildParentPrefix (std::string &parent_prefix);
319
320
321    void
322    CopyDefaultSettings (const lldb::InstanceSettingsSP &new_settings,
323                         const ConstString &instance_name,
324                         bool pending);
325
326    lldb::InstanceSettingsSP
327    PendingSettingsForInstance (const ConstString &instance_name);
328
329    InstanceSettings *
330    FindSettingsForInstance (const ConstString &instance_name);
331
332    void
333    GetAllPendingSettingValues (Stream &result_stream);
334
335    void
336    GetAllDefaultSettingValues (Stream &result_stream);
337
338    void
339    GetAllInstanceVariableValues (CommandInterpreter &interpreter,
340                                  Stream &result_stream);
341
342    void
343    OverrideAllInstances (const ConstString &var_name,
344                          const char *value,
345                          VarSetOperationType op,
346                          const char *index_value,
347                          Error &err);
348
349    UserSettingDefinition &
350    GetControllerSettings () { return m_settings; }
351
352    // -------------------------------------------------------------------------
353    // Static protected methods are declared below here.
354    // -------------------------------------------------------------------------
355
356    static void
357    PrintEnumValues (const OptionEnumValueElement *enum_values,
358                     Stream &str);
359
360
361    static int
362    BooleanMatches (const char *partial_value,
363                    bool &word_complete,
364                    StringList &matches);
365
366    static int
367    EnumMatches (const char *partial_value,
368                 OptionEnumValueElement *enum_values,
369                 bool &word_complete,
370                 StringList &matches);
371
372    static void
373    VerifyOperationForType (SettableVariableType var_type,
374                            VarSetOperationType op,
375                            const ConstString &var_name,
376                            Error &err);
377
378    // This is protected rather than private so that classes that inherit from UserSettingsController can access it.
379
380    lldb::InstanceSettingsSP m_default_settings;
381
382private:
383
384    UserSettingDefinition m_settings;
385
386    typedef std::map<std::string,InstanceSettings*> InstanceSettingsMap;
387
388    std::vector<lldb::UserSettingsControllerSP> m_children;
389    std::map <std::string, lldb::InstanceSettingsSP> m_pending_settings;
390    InstanceSettingsMap m_live_settings;    // live settings should never be NULL (hence 'live')
391    mutable Mutex m_children_mutex;
392    mutable Mutex m_pending_settings_mutex;
393    mutable Mutex m_live_settings_mutex;
394
395    DISALLOW_COPY_AND_ASSIGN (UserSettingsController);
396};
397
398class InstanceSettings
399{
400public:
401
402    InstanceSettings (const lldb::UserSettingsControllerSP &owner_sp, const char *instance_name, bool live_instance = true);
403
404    InstanceSettings (const InstanceSettings &rhs);
405
406    virtual
407    ~InstanceSettings ();
408
409    InstanceSettings&
410    operator= (const InstanceSettings &rhs);
411
412    // Begin Pure Virtual Functions
413
414    virtual void
415    UpdateInstanceSettingsVariable (const ConstString &var_name,
416                                    const char *index_value,
417                                    const char *value,
418                                    const ConstString &instance_name,
419                                    const SettingEntry &entry,
420                                    VarSetOperationType op,
421                                    Error &err,
422                                    bool pending) = 0;
423
424    virtual bool
425    GetInstanceSettingsValue (const SettingEntry &entry,
426                              const ConstString &var_name,
427                              StringList &value,
428                              Error *err) = 0;
429
430    virtual void
431    CopyInstanceSettings (const lldb::InstanceSettingsSP &new_settings,
432                          bool pending) = 0;
433
434    virtual const ConstString
435    CreateInstanceName () = 0;
436
437    // End Pure Virtual Functions
438
439    const ConstString &
440    GetInstanceName () { return m_instance_name; }
441
442
443    void
444    ChangeInstanceName (const std::string &new_instance_name);
445
446    static const ConstString &
447    GetDefaultName ();
448
449    static const ConstString &
450    InvalidName ();
451
452protected:
453
454    lldb::UserSettingsControllerWP m_owner_wp;
455    ConstString m_instance_name;
456};
457
458
459
460} // namespace lldb_private
461
462#endif // liblldb_UserSettingsController_h_
463