-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathdot_gdbinit
2314 lines (2100 loc) · 88.9 KB
/
dot_gdbinit
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
python
# GDB dashboard - Modular visual interface for GDB in Python.
#
# https://github.com/cyrus-and/gdb-dashboard
# License ----------------------------------------------------------------------
# Copyright (c) 2015-2021 Andrea Cardaci <[email protected]>
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
# Imports ----------------------------------------------------------------------
import ast
import io
import itertools
import math
import os
import re
import struct
import traceback
# Common attributes ------------------------------------------------------------
class R():
@staticmethod
def attributes():
return {
# miscellaneous
'ansi': {
'doc': 'Control the ANSI output of the dashboard.',
'default': True,
'type': bool
},
'syntax_highlighting': {
'doc': '''Pygments style to use for syntax highlighting.
Using an empty string (or a name not in the list) disables this feature. The
list of all the available styles can be obtained with (from GDB itself):
python from pygments.styles import *
python for style in get_all_styles(): print(style)''',
'default': 'monokai'
},
'discard_scrollback': {
'doc': '''Discard the scrollback buffer at each redraw.
This makes scrolling less confusing by discarding the previously printed
dashboards but only works with certain terminals.''',
'default': True,
'type': bool
},
# values formatting
'compact_values': {
'doc': 'Display complex objects in a single line.',
'default': True,
'type': bool
},
'max_value_length': {
'doc': 'Maximum length of displayed values before truncation.',
'default': 100,
'type': int
},
'value_truncation_string': {
'doc': 'String to use to mark value truncation.',
'default': '…',
},
'dereference': {
'doc': 'Annotate pointers with the pointed value.',
'default': True,
'type': bool
},
# prompt
'prompt': {
'doc': '''GDB prompt.
This value is used as a Python format string where `{status}` is expanded with
the substitution of either `prompt_running` or `prompt_not_running` attributes,
according to the target program status. The resulting string must be a valid GDB
prompt, see the command `python print(gdb.prompt.prompt_help())`''',
'default': '{status}'
},
'prompt_running': {
'doc': '''Define the value of `{status}` when the target program is running.
See the `prompt` attribute. This value is used as a Python format string where
`{pid}` is expanded with the process identifier of the target program.''',
'default': '\[\e[1;35m\]>>>\[\e[0m\]'
},
'prompt_not_running': {
'doc': '''Define the value of `{status}` when the target program is running.
See the `prompt` attribute. This value is used as a Python format string.''',
'default': '\[\e[90m\]>>>\[\e[0m\]'
},
# divider
'omit_divider': {
'doc': 'Omit the divider in external outputs when only one module is displayed.',
'default': False,
'type': bool
},
'divider_fill_char_primary': {
'doc': 'Filler around the label for primary dividers',
'default': '─'
},
'divider_fill_char_secondary': {
'doc': 'Filler around the label for secondary dividers',
'default': '─'
},
'divider_fill_style_primary': {
'doc': 'Style for `divider_fill_char_primary`',
'default': '36'
},
'divider_fill_style_secondary': {
'doc': 'Style for `divider_fill_char_secondary`',
'default': '90'
},
'divider_label_style_on_primary': {
'doc': 'Label style for non-empty primary dividers',
'default': '1;33'
},
'divider_label_style_on_secondary': {
'doc': 'Label style for non-empty secondary dividers',
'default': '1;37'
},
'divider_label_style_off_primary': {
'doc': 'Label style for empty primary dividers',
'default': '33'
},
'divider_label_style_off_secondary': {
'doc': 'Label style for empty secondary dividers',
'default': '90'
},
'divider_label_skip': {
'doc': 'Gap between the aligning border and the label.',
'default': 3,
'type': int,
'check': check_ge_zero
},
'divider_label_margin': {
'doc': 'Number of spaces around the label.',
'default': 1,
'type': int,
'check': check_ge_zero
},
'divider_label_align_right': {
'doc': 'Label alignment flag.',
'default': False,
'type': bool
},
# common styles
'style_selected_1': {
'default': '1;32'
},
'style_selected_2': {
'default': '32'
},
'style_low': {
'default': '90'
},
'style_high': {
'default': '1;37'
},
'style_error': {
'default': '31'
},
'style_critical': {
'default': '0;41'
}
}
# Common -----------------------------------------------------------------------
class Beautifier():
def __init__(self, hint, tab_size=4):
self.tab_spaces = ' ' * tab_size
self.active = False
if not R.ansi or not R.syntax_highlighting:
return
# attempt to set up Pygments
try:
import pygments
from pygments.lexers import GasLexer, NasmLexer
from pygments.formatters import Terminal256Formatter
if hint == 'att':
self.lexer = GasLexer()
elif hint == 'intel':
self.lexer = NasmLexer()
else:
from pygments.lexers import get_lexer_for_filename
self.lexer = get_lexer_for_filename(hint, stripnl=False)
self.formatter = Terminal256Formatter(style=R.syntax_highlighting)
self.active = True
except ImportError:
# Pygments not available
pass
except pygments.util.ClassNotFound:
# no lexer for this file or invalid style
pass
def process(self, source):
# convert tabs anyway
source = source.replace('\t', self.tab_spaces)
if self.active:
import pygments
source = pygments.highlight(source, self.lexer, self.formatter)
return source.rstrip('\n')
def run(command):
return gdb.execute(command, to_string=True)
def ansi(string, style):
if R.ansi:
return '\x1b[{}m{}\x1b[0m'.format(style, string)
else:
return string
def divider(width, label='', primary=False, active=True):
if primary:
divider_fill_style = R.divider_fill_style_primary
divider_fill_char = R.divider_fill_char_primary
divider_label_style_on = R.divider_label_style_on_primary
divider_label_style_off = R.divider_label_style_off_primary
else:
divider_fill_style = R.divider_fill_style_secondary
divider_fill_char = R.divider_fill_char_secondary
divider_label_style_on = R.divider_label_style_on_secondary
divider_label_style_off = R.divider_label_style_off_secondary
if label:
if active:
divider_label_style = divider_label_style_on
else:
divider_label_style = divider_label_style_off
skip = R.divider_label_skip
margin = R.divider_label_margin
before = ansi(divider_fill_char * skip, divider_fill_style)
middle = ansi(label, divider_label_style)
after_length = width - len(label) - skip - 2 * margin
after = ansi(divider_fill_char * after_length, divider_fill_style)
if R.divider_label_align_right:
before, after = after, before
return ''.join([before, ' ' * margin, middle, ' ' * margin, after])
else:
return ansi(divider_fill_char * width, divider_fill_style)
def check_gt_zero(x):
return x > 0
def check_ge_zero(x):
return x >= 0
def to_unsigned(value, size=8):
# values from GDB can be used transparently but are not suitable for
# being printed as unsigned integers, so a conversion is needed
mask = (2 ** (size * 8)) - 1
return int(value.cast(gdb.Value(mask).type)) & mask
def to_string(value):
# attempt to convert an inferior value to string; OK when (Python 3 ||
# simple ASCII); otherwise (Python 2.7 && not ASCII) encode the string as
# utf8
try:
value_string = str(value)
except UnicodeEncodeError:
value_string = unicode(value).encode('utf8')
except gdb.error as e:
value_string = ansi(e, R.style_error)
return value_string
def format_address(address):
pointer_size = gdb.parse_and_eval('$pc').type.sizeof
return ('0x{{:0{}x}}').format(pointer_size * 2).format(address)
def format_value(value, compact=None):
# format references as referenced values
# (TYPE_CODE_RVALUE_REF is not supported by old GDB)
if value.type.code in (getattr(gdb, 'TYPE_CODE_REF', None),
getattr(gdb, 'TYPE_CODE_RVALUE_REF', None)):
try:
value = value.referenced_value()
except gdb.error as e:
return ansi(e, R.style_error)
# format the value
out = to_string(value)
# dereference up to the actual value if requested
if R.dereference and value.type.code == gdb.TYPE_CODE_PTR:
while value.type.code == gdb.TYPE_CODE_PTR:
try:
value = value.dereference()
except gdb.error as e:
break
else:
formatted = to_string(value)
out += '{} {}'.format(ansi(':', R.style_low), formatted)
# compact the value
if compact is not None and compact or R.compact_values:
out = re.sub(r'$\s*', '', out, flags=re.MULTILINE)
# truncate the value
if R.max_value_length > 0 and len(out) > R.max_value_length:
out = out[0:R.max_value_length] + ansi(R.value_truncation_string, R.style_critical)
return out
# XXX parsing the output of `info breakpoints` is apparently the best option
# right now, see: https://sourceware.org/bugzilla/show_bug.cgi?id=18385
# XXX GDB version 7.11 (quire recent) does not have the pending field, so
# fall back to the parsed information
def fetch_breakpoints(watchpoints=False, pending=False):
# fetch breakpoints addresses
parsed_breakpoints = dict()
for line in run('info breakpoints').split('\n'):
# just keep numbered lines
if not line or not line[0].isdigit():
continue
# extract breakpoint number, address and pending status
fields = line.split()
number = int(fields[0].split('.')[0])
try:
if len(fields) >= 5 and fields[1] == 'breakpoint':
# multiple breakpoints have no address yet
is_pending = fields[4] == '<PENDING>'
is_multiple = fields[4] == '<MULTIPLE>'
address = None if is_multiple or is_pending else int(fields[4], 16)
is_enabled = fields[3] == 'y'
address_info = address, is_enabled
parsed_breakpoints[number] = [address_info], is_pending
elif len(fields) >= 3 and number in parsed_breakpoints:
# add this address to the list of multiple locations
address = int(fields[2], 16)
is_enabled = fields[1] == 'y'
address_info = address, is_enabled
parsed_breakpoints[number][0].append(address_info)
else:
# watchpoints
parsed_breakpoints[number] = [], False
except ValueError:
pass
# fetch breakpoints from the API and complement with address and source
# information
breakpoints = []
# XXX in older versions gdb.breakpoints() returns None
for gdb_breakpoint in gdb.breakpoints() or []:
# skip internal breakpoints
if gdb_breakpoint.number < 0:
continue
addresses, is_pending = parsed_breakpoints[gdb_breakpoint.number]
is_pending = getattr(gdb_breakpoint, 'pending', is_pending)
if not pending and is_pending:
continue
if not watchpoints and gdb_breakpoint.type != gdb.BP_BREAKPOINT:
continue
# add useful fields to the object
breakpoint = dict()
breakpoint['number'] = gdb_breakpoint.number
breakpoint['type'] = gdb_breakpoint.type
breakpoint['enabled'] = gdb_breakpoint.enabled
breakpoint['location'] = gdb_breakpoint.location
breakpoint['expression'] = gdb_breakpoint.expression
breakpoint['condition'] = gdb_breakpoint.condition
breakpoint['temporary'] = gdb_breakpoint.temporary
breakpoint['hit_count'] = gdb_breakpoint.hit_count
breakpoint['pending'] = is_pending
# add addresses and source information
breakpoint['addresses'] = []
for address, is_enabled in addresses:
if address:
sal = gdb.find_pc_line(address)
breakpoint['addresses'].append({
'address': address,
'enabled': is_enabled,
'file_name': sal.symtab.filename if address and sal.symtab else None,
'file_line': sal.line if address else None
})
breakpoints.append(breakpoint)
return breakpoints
# Dashboard --------------------------------------------------------------------
class Dashboard(gdb.Command):
'''Redisplay the dashboard.'''
def __init__(self):
gdb.Command.__init__(self, 'dashboard', gdb.COMMAND_USER, gdb.COMPLETE_NONE, True)
# setup subcommands
Dashboard.ConfigurationCommand(self)
Dashboard.OutputCommand(self)
Dashboard.EnabledCommand(self)
Dashboard.LayoutCommand(self)
# setup style commands
Dashboard.StyleCommand(self, 'dashboard', R, R.attributes())
# main terminal
self.output = None
# used to inhibit redisplays during init parsing
self.inhibited = None
# enabled by default
self.enabled = None
self.enable()
def on_continue(self, _):
# try to contain the GDB messages in a specified area unless the
# dashboard is printed to a separate file (dashboard -output ...)
# or there are no modules to display in the main terminal
enabled_modules = list(filter(lambda m: not m.output and m.enabled, self.modules))
if self.is_running() and not self.output and len(enabled_modules) > 0:
width, _ = Dashboard.get_term_size()
gdb.write(Dashboard.clear_screen())
gdb.write(divider(width, 'Output/messages', True))
gdb.write('\n')
gdb.flush()
def on_stop(self, _):
if self.is_running():
self.render(clear_screen=False)
def on_exit(self, _):
if not self.is_running():
return
# collect all the outputs
outputs = set()
outputs.add(self.output)
outputs.update(module.output for module in self.modules)
outputs.remove(None)
# reset the terminal status
for output in outputs:
try:
with open(output, 'w') as fs:
fs.write(Dashboard.reset_terminal())
except:
# skip cleanup for invalid outputs
pass
def enable(self):
if self.enabled:
return
self.enabled = True
# setup events
gdb.events.cont.connect(self.on_continue)
gdb.events.stop.connect(self.on_stop)
gdb.events.exited.connect(self.on_exit)
def disable(self):
if not self.enabled:
return
self.enabled = False
# setup events
gdb.events.cont.disconnect(self.on_continue)
gdb.events.stop.disconnect(self.on_stop)
gdb.events.exited.disconnect(self.on_exit)
def load_modules(self, modules):
self.modules = []
for module in modules:
info = Dashboard.ModuleInfo(self, module)
self.modules.append(info)
def redisplay(self, style_changed=False):
# manually redisplay the dashboard
if self.is_running() and not self.inhibited:
self.render(True, style_changed)
def inferior_pid(self):
return gdb.selected_inferior().pid
def is_running(self):
return self.inferior_pid() != 0
def render(self, clear_screen, style_changed=False):
# fetch module content and info
all_disabled = True
display_map = dict()
for module in self.modules:
# fall back to the global value
output = module.output or self.output
# add the instance or None if disabled
if module.enabled:
all_disabled = False
instance = module.instance
else:
instance = None
display_map.setdefault(output, []).append(instance)
# process each display info
for output, instances in display_map.items():
try:
buf = ''
# use GDB stream by default
fs = None
if output:
fs = open(output, 'w')
fd = fs.fileno()
fs.write(Dashboard.setup_terminal())
else:
fs = gdb
fd = 1 # stdout
# get the terminal size (default main terminal if either the
# output is not a file)
try:
width, height = Dashboard.get_term_size(fd)
except:
width, height = Dashboard.get_term_size()
# clear the "screen" if requested for the main terminal,
# auxiliary terminals are always cleared
if fs is not gdb or clear_screen:
buf += Dashboard.clear_screen()
# show message if all the modules in this output are disabled
if not any(instances):
# skip the main terminal
if fs is gdb:
continue
# write the error message
buf += divider(width, 'Warning', True)
buf += '\n'
if self.modules:
buf += 'No module to display (see `dashboard -layout`)'
else:
buf += 'No module loaded'
buf += '\n'
fs.write(buf)
continue
# process all the modules for that output
for n, instance in enumerate(instances, 1):
# skip disabled modules
if not instance:
continue
try:
# ask the module to generate the content
lines = instance.lines(width, height, style_changed)
except Exception as e:
# allow to continue on exceptions in modules
stacktrace = traceback.format_exc().strip()
lines = [ansi(stacktrace, R.style_error)]
# create the divider if needed
div = []
if not R.omit_divider or len(instances) > 1 or fs is gdb:
div = [divider(width, instance.label(), True, lines)]
# write the data
buf += '\n'.join(div + lines)
# write the newline for all but last unless main terminal
if n != len(instances) or fs is gdb:
buf += '\n'
# write the final newline and the terminator only if it is the
# main terminal to allow the prompt to display correctly (unless
# there are no modules to display)
if fs is gdb and not all_disabled:
buf += divider(width, primary=True)
buf += '\n'
fs.write(buf)
except Exception as e:
cause = traceback.format_exc().strip()
Dashboard.err('Cannot write the dashboard\n{}'.format(cause))
finally:
# don't close gdb stream
if fs and fs is not gdb:
fs.close()
# Utility methods --------------------------------------------------------------
@staticmethod
def start():
# save the instance for customization convenience
global dashboard
# initialize the dashboard
dashboard = Dashboard()
Dashboard.set_custom_prompt(dashboard)
# parse Python inits, load modules then parse GDB inits
dashboard.inhibited = True
Dashboard.parse_inits(True)
modules = Dashboard.get_modules()
dashboard.load_modules(modules)
Dashboard.parse_inits(False)
dashboard.inhibited = False
# GDB overrides
run('set pagination off')
# display if possible (program running and not explicitly disabled by
# some configuration file)
if dashboard.enabled:
dashboard.redisplay()
@staticmethod
def get_term_size(fd=1): # defaults to the main terminal
try:
if sys.platform == 'win32':
import curses
# XXX always neglects the fd parameter
height, width = curses.initscr().getmaxyx()
curses.endwin()
return int(width), int(height)
else:
import termios
import fcntl
# first 2 shorts (4 byte) of struct winsize
raw = fcntl.ioctl(fd, termios.TIOCGWINSZ, ' ' * 4)
height, width = struct.unpack('hh', raw)
return int(width), int(height)
except (ImportError, OSError):
# this happens when no curses library is found on windows or when
# the terminal is not properly configured
return 80, 24 # hardcoded fallback value
@staticmethod
def set_custom_prompt(dashboard):
def custom_prompt(_):
# render thread status indicator
if dashboard.is_running():
pid = dashboard.inferior_pid()
status = R.prompt_running.format(pid=pid)
else:
status = R.prompt_not_running
# build prompt
prompt = R.prompt.format(status=status)
prompt = gdb.prompt.substitute_prompt(prompt)
return prompt + ' ' # force trailing space
gdb.prompt_hook = custom_prompt
@staticmethod
def parse_inits(python):
# paths where the .gdbinit.d directory might be
search_paths = [
'/etc/gdb-dashboard',
'{}/gdb-dashboard'.format(os.getenv('XDG_CONFIG_HOME', '~/.config')),
'~/Library/Preferences/gdb-dashboard',
'~/.gdbinit.d'
]
# expand the tilde and walk the paths
inits_dirs = (os.walk(os.path.expanduser(path)) for path in search_paths)
# process all the init files in order
for root, dirs, files in itertools.chain.from_iterable(inits_dirs):
dirs.sort()
for init in sorted(files):
path = os.path.join(root, init)
_, ext = os.path.splitext(path)
# either load Python files or GDB
if python == (ext == '.py'):
gdb.execute('source ' + path)
@staticmethod
def get_modules():
# scan the scope for modules
modules = []
for name in globals():
obj = globals()[name]
try:
if issubclass(obj, Dashboard.Module):
modules.append(obj)
except TypeError:
continue
# sort modules alphabetically
modules.sort(key=lambda x: x.__name__)
return modules
@staticmethod
def create_command(name, invoke, doc, is_prefix, complete=None):
Class = type('', (gdb.Command,), {'invoke': invoke, '__doc__': doc})
Class(name, gdb.COMMAND_USER, complete or gdb.COMPLETE_NONE, is_prefix)
@staticmethod
def err(string):
print(ansi(string, R.style_error))
@staticmethod
def complete(word, candidates):
return filter(lambda candidate: candidate.startswith(word), candidates)
@staticmethod
def parse_arg(arg):
# encode unicode GDB command arguments as utf8 in Python 2.7
if type(arg) is not str:
arg = arg.encode('utf8')
return arg
@staticmethod
def clear_screen():
# ANSI: move the cursor to top-left corner and clear the screen
# (optionally also clear the scrollback buffer if supported by the
# terminal)
return '\x1b[H\x1b[J' + '\x1b[3J' if R.discard_scrollback else ''
@staticmethod
def setup_terminal():
# ANSI: enable alternative screen buffer and hide cursor
return '\x1b[?1049h\x1b[?25l'
@staticmethod
def reset_terminal():
# ANSI: disable alternative screen buffer and show cursor
return '\x1b[?1049l\x1b[?25h'
# Module descriptor ------------------------------------------------------------
class ModuleInfo:
def __init__(self, dashboard, module):
self.name = module.__name__.lower() # from class to module name
self.enabled = True
self.output = None # value from the dashboard by default
self.instance = module()
self.doc = self.instance.__doc__ or '(no documentation)'
self.prefix = 'dashboard {}'.format(self.name)
# add GDB commands
self.add_main_command(dashboard)
self.add_output_command(dashboard)
self.add_style_command(dashboard)
self.add_subcommands(dashboard)
def add_main_command(self, dashboard):
module = self
def invoke(self, arg, from_tty, info=self):
arg = Dashboard.parse_arg(arg)
if arg == '':
info.enabled ^= True
if dashboard.is_running():
dashboard.redisplay()
else:
status = 'enabled' if info.enabled else 'disabled'
print('{} module {}'.format(module.name, status))
else:
Dashboard.err('Wrong argument "{}"'.format(arg))
doc_brief = 'Configure the {} module, with no arguments toggles its visibility.'.format(self.name)
doc = '{}\n\n{}'.format(doc_brief, self.doc)
Dashboard.create_command(self.prefix, invoke, doc, True)
def add_output_command(self, dashboard):
Dashboard.OutputCommand(dashboard, self.prefix, self)
def add_style_command(self, dashboard):
Dashboard.StyleCommand(dashboard, self.prefix, self.instance, self.instance.attributes())
def add_subcommands(self, dashboard):
for name, command in self.instance.commands().items():
self.add_subcommand(dashboard, name, command)
def add_subcommand(self, dashboard, name, command):
action = command['action']
doc = command['doc']
complete = command.get('complete')
def invoke(self, arg, from_tty, info=self):
arg = Dashboard.parse_arg(arg)
if info.enabled:
try:
action(arg)
except Exception as e:
Dashboard.err(e)
return
# don't catch redisplay errors
dashboard.redisplay()
else:
Dashboard.err('Module disabled')
prefix = '{} {}'.format(self.prefix, name)
Dashboard.create_command(prefix, invoke, doc, False, complete)
# GDB commands -----------------------------------------------------------------
# handler for the `dashboard` command itself
def invoke(self, arg, from_tty):
arg = Dashboard.parse_arg(arg)
# show messages for checks in redisplay
if arg != '':
Dashboard.err('Wrong argument "{}"'.format(arg))
elif not self.is_running():
Dashboard.err('Is the target program running?')
else:
self.redisplay()
class ConfigurationCommand(gdb.Command):
'''Dump or save the dashboard configuration.
With an optional argument the configuration will be written to the specified
file.
This command allows to configure the dashboard live then make the changes
permanent, for example:
dashboard -configuration ~/.gdbinit.d/init
At startup the `~/.gdbinit.d/` directory tree is walked and files are evaluated
in alphabetical order but giving priority to Python files. This is where user
configuration files must be placed.'''
def __init__(self, dashboard):
gdb.Command.__init__(self, 'dashboard -configuration',
gdb.COMMAND_USER, gdb.COMPLETE_FILENAME)
self.dashboard = dashboard
def invoke(self, arg, from_tty):
arg = Dashboard.parse_arg(arg)
if arg:
with open(os.path.expanduser(arg), 'w') as fs:
fs.write('# auto generated by GDB dashboard\n\n')
self.dump(fs)
self.dump(gdb)
def dump(self, fs):
# dump layout
self.dump_layout(fs)
# dump styles
self.dump_style(fs, R)
for module in self.dashboard.modules:
self.dump_style(fs, module.instance, module.prefix)
# dump outputs
self.dump_output(fs, self.dashboard)
for module in self.dashboard.modules:
self.dump_output(fs, module, module.prefix)
def dump_layout(self, fs):
layout = ['dashboard -layout']
for module in self.dashboard.modules:
mark = '' if module.enabled else '!'
layout.append('{}{}'.format(mark, module.name))
fs.write(' '.join(layout))
fs.write('\n')
def dump_style(self, fs, obj, prefix='dashboard'):
attributes = getattr(obj, 'attributes', lambda: dict())()
for name, attribute in attributes.items():
real_name = attribute.get('name', name)
default = attribute.get('default')
value = getattr(obj, real_name)
if value != default:
fs.write('{} -style {} {!r}\n'.format(prefix, name, value))
def dump_output(self, fs, obj, prefix='dashboard'):
output = getattr(obj, 'output')
if output:
fs.write('{} -output {}\n'.format(prefix, output))
class OutputCommand(gdb.Command):
'''Set the output file/TTY for the whole dashboard or single modules.
The dashboard/module will be written to the specified file, which will be
created if it does not exist. If the specified file identifies a terminal then
its geometry will be used, otherwise it falls back to the geometry of the main
GDB terminal.
When invoked without argument on the dashboard, the output/messages and modules
which do not specify an output themselves will be printed on standard output
(default).
When invoked without argument on a module, it will be printed where the
dashboard will be printed.
An overview of all the outputs can be obtained with the `dashboard -layout`
command.'''
def __init__(self, dashboard, prefix=None, obj=None):
if not prefix:
prefix = 'dashboard'
if not obj:
obj = dashboard
prefix = prefix + ' -output'
gdb.Command.__init__(self, prefix, gdb.COMMAND_USER, gdb.COMPLETE_FILENAME)
self.dashboard = dashboard
self.obj = obj # None means the dashboard itself
def invoke(self, arg, from_tty):
arg = Dashboard.parse_arg(arg)
# reset the terminal status
if self.obj.output:
try:
with open(self.obj.output, 'w') as fs:
fs.write(Dashboard.reset_terminal())
except:
# just do nothing if the file is not writable
pass
# set or open the output file
if arg == '':
self.obj.output = None
else:
self.obj.output = arg
# redisplay the dashboard in the new output
self.dashboard.redisplay()
class EnabledCommand(gdb.Command):
'''Enable or disable the dashboard.
The current status is printed if no argument is present.'''
def __init__(self, dashboard):
gdb.Command.__init__(self, 'dashboard -enabled', gdb.COMMAND_USER)
self.dashboard = dashboard
def invoke(self, arg, from_tty):
arg = Dashboard.parse_arg(arg)
if arg == '':
status = 'enabled' if self.dashboard.enabled else 'disabled'
print('The dashboard is {}'.format(status))
elif arg == 'on':
self.dashboard.enable()
self.dashboard.redisplay()
elif arg == 'off':
self.dashboard.disable()
else:
msg = 'Wrong argument "{}"; expecting "on" or "off"'
Dashboard.err(msg.format(arg))
def complete(self, text, word):
return Dashboard.complete(word, ['on', 'off'])
class LayoutCommand(gdb.Command):
'''Set or show the dashboard layout.
Accepts a space-separated list of directive. Each directive is in the form
"[!]<module>". Modules in the list are placed in the dashboard in the same order
as they appear and those prefixed by "!" are disabled by default. Omitted
modules are hidden and placed at the bottom in alphabetical order.
Without arguments the current layout is shown where the first line uses the same
form expected by the input while the remaining depict the current status of
output files.
Passing `!` as a single argument resets the dashboard original layout.'''
def __init__(self, dashboard):
gdb.Command.__init__(self, 'dashboard -layout', gdb.COMMAND_USER)
self.dashboard = dashboard
def invoke(self, arg, from_tty):
arg = Dashboard.parse_arg(arg)
directives = str(arg).split()
if directives:
# apply the layout
if directives == ['!']:
self.reset()
else:
if not self.layout(directives):
return # in case of errors
# redisplay or otherwise notify
if from_tty:
if self.dashboard.is_running():
self.dashboard.redisplay()
else:
self.show()
else:
self.show()
def reset(self):
modules = self.dashboard.modules
modules.sort(key=lambda module: module.name)
for module in modules:
module.enabled = True
def show(self):
global_str = 'Dashboard'
default = '(default TTY)'
max_name_len = max(len(module.name) for module in self.dashboard.modules)
max_name_len = max(max_name_len, len(global_str))
fmt = '{{}}{{:{}s}}{{}}'.format(max_name_len + 2)
print((fmt + '\n').format(' ', global_str, self.dashboard.output or default))
for module in self.dashboard.modules:
mark = ' ' if module.enabled else '!'
style = R.style_high if module.enabled else R.style_low
line = fmt.format(mark, module.name, module.output or default)
print(ansi(line, style))
def layout(self, directives):
modules = self.dashboard.modules
# parse and check directives
parsed_directives = []
selected_modules = set()
for directive in directives:
enabled = (directive[0] != '!')
name = directive[not enabled:]
if name in selected_modules:
Dashboard.err('Module "{}" already set'.format(name))
return False
if next((False for module in modules if module.name == name), True):
Dashboard.err('Cannot find module "{}"'.format(name))
return False
parsed_directives.append((name, enabled))
selected_modules.add(name)
# reset visibility
for module in modules:
module.enabled = False
# move and enable the selected modules on top
last = 0
for name, enabled in parsed_directives:
todo = enumerate(modules[last:], start=last)
index = next(index for index, module in todo if name == module.name)
modules[index].enabled = enabled
modules.insert(last, modules.pop(index))
last += 1
return True
def complete(self, text, word):