1# Copyright (C) 2008-2023 Free Software Foundation, Inc.
2
3# This program is free software; you can redistribute it and/or modify
4# it under the terms of the GNU General Public License as published by
5# the Free Software Foundation; either version 3 of the License, or
6# (at your option) any later version.
7#
8# This program is distributed in the hope that it will be useful,
9# but WITHOUT ANY WARRANTY; without even the implied warranty of
10# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11# GNU General Public License for more details.
12#
13# You should have received a copy of the GNU General Public License
14# along with this program.  If not, see <http://www.gnu.org/licenses/>.
15
16# This file is part of the GDB testsuite.  It tests python pretty
17# printers.
18
19import re
20import gdb
21
22
23def _iterator(pointer, len):
24    start = pointer
25    end = pointer + len
26    while pointer != end:
27        yield ("[%d]" % int(pointer - start), pointer.dereference())
28        pointer += 1
29
30
31# Same as _iterator but can be told to raise an exception.
32def _iterator_except(pointer, len):
33    start = pointer
34    end = pointer + len
35    while pointer != end:
36        if exception_flag:
37            raise gdb.MemoryError("hi bob")
38        yield ("[%d]" % int(pointer - start), pointer.dereference())
39        pointer += 1
40
41
42# Test returning a Value from a printer.
43class string_print(object):
44    def __init__(self, val):
45        self.val = val
46
47    def to_string(self):
48        return self.val["whybother"]["contents"]
49
50
51# Test a class-based printer.
52class ContainerPrinter(object):
53    def __init__(self, val):
54        self.val = val
55
56    def to_string(self):
57        return "container %s with %d elements" % (self.val["name"], self.val["len"])
58
59    def children(self):
60        return _iterator(self.val["elements"], self.val["len"])
61
62    def display_hint(self):
63        if self.val["is_map_p"] and self.val["is_array_p"]:
64            raise Exception("invalid object state found in display_hint")
65
66        if self.val["is_map_p"]:
67            return "map"
68        elif self.val["is_array_p"]:
69            return "array"
70        else:
71            return None
72
73
74# Treats a container as array.
75class ArrayPrinter(object):
76    def __init__(self, val):
77        self.val = val
78
79    def to_string(self):
80        return "array %s with %d elements" % (self.val["name"], self.val["len"])
81
82    def children(self):
83        return _iterator(self.val["elements"], self.val["len"])
84
85    def display_hint(self):
86        return "array"
87
88
89# Flag to make NoStringContainerPrinter throw an exception.
90exception_flag = False
91
92# Test a printer where to_string is None
93class NoStringContainerPrinter(object):
94    def __init__(self, val):
95        self.val = val
96
97    def to_string(self):
98        return None
99
100    def children(self):
101        return _iterator_except(self.val["elements"], self.val["len"])
102
103
104# See ToStringReturnsValueWrapper.
105class ToStringReturnsValueInner:
106    def __init__(self, val):
107        self.val = val
108
109    def to_string(self):
110        return "Inner to_string {}".format(int(self.val["val"]))
111
112
113# Test a printer that returns a gdb.Value in its to_string.  That gdb.Value
114# also has its own pretty-printer.
115class ToStringReturnsValueWrapper:
116    def __init__(self, val):
117        self.val = val
118
119    def to_string(self):
120        return self.val["inner"]
121
122
123class pp_s(object):
124    def __init__(self, val):
125        self.val = val
126
127    def to_string(self):
128        a = self.val["a"]
129        b = self.val["b"]
130        if a.address != b:
131            raise Exception("&a(%s) != b(%s)" % (str(a.address), str(b)))
132        return " a=<" + str(self.val["a"]) + "> b=<" + str(self.val["b"]) + ">"
133
134
135class pp_ss(object):
136    def __init__(self, val):
137        self.val = val
138
139    def to_string(self):
140        return "a=<" + str(self.val["a"]) + "> b=<" + str(self.val["b"]) + ">"
141
142
143class pp_sss(object):
144    def __init__(self, val):
145        self.val = val
146
147    def to_string(self):
148        return "a=<" + str(self.val["a"]) + "> b=<" + str(self.val["b"]) + ">"
149
150
151class pp_multiple_virtual(object):
152    def __init__(self, val):
153        self.val = val
154
155    def to_string(self):
156        return "pp value variable is: " + str(self.val["value"])
157
158
159class pp_vbase1(object):
160    def __init__(self, val):
161        self.val = val
162
163    def to_string(self):
164        return "pp class name: " + self.val.type.tag
165
166
167class pp_nullstr(object):
168    def __init__(self, val):
169        self.val = val
170
171    def to_string(self):
172        return self.val["s"].string(gdb.target_charset())
173
174
175class pp_ns(object):
176    "Print a std::basic_string of some kind"
177
178    def __init__(self, val):
179        self.val = val
180
181    def to_string(self):
182        len = self.val["length"]
183        return self.val["null_str"].string(gdb.target_charset(), length=len)
184
185    def display_hint(self):
186        return "string"
187
188
189pp_ls_encoding = None
190
191
192class pp_ls(object):
193    "Print a std::basic_string of some kind"
194
195    def __init__(self, val):
196        self.val = val
197
198    def to_string(self):
199        length = self.val["len"]
200        if pp_ls_encoding is not None:
201            if length >= 0:
202                return self.val["lazy_str"].lazy_string(
203                    encoding=pp_ls_encoding, length=length
204                )
205            else:
206                return self.val["lazy_str"].lazy_string(encoding=pp_ls_encoding)
207        else:
208            if length >= 0:
209                return self.val["lazy_str"].lazy_string(length=length)
210            else:
211                return self.val["lazy_str"].lazy_string()
212
213    def display_hint(self):
214        return "string"
215
216
217class pp_hint_error(object):
218    "Throw error from display_hint"
219
220    def __init__(self, val):
221        self.val = val
222
223    def to_string(self):
224        return "hint_error_val"
225
226    def display_hint(self):
227        raise Exception("hint failed")
228
229
230class pp_children_as_list(object):
231    "Throw error from display_hint"
232
233    def __init__(self, val):
234        self.val = val
235
236    def to_string(self):
237        return "children_as_list_val"
238
239    def children(self):
240        return [("one", 1)]
241
242
243class pp_outer(object):
244    "Print struct outer"
245
246    def __init__(self, val):
247        self.val = val
248
249    def to_string(self):
250        return "x = %s" % self.val["x"]
251
252    def children(self):
253        yield "s", self.val["s"]
254        yield "x", self.val["x"]
255
256
257class MemoryErrorString(object):
258    "Raise an error"
259
260    def __init__(self, val):
261        self.val = val
262
263    def to_string(self):
264        raise gdb.MemoryError("Cannot access memory.")
265
266    def display_hint(self):
267        return "string"
268
269
270class pp_eval_type(object):
271    def __init__(self, val):
272        self.val = val
273
274    def to_string(self):
275        gdb.execute("bt", to_string=True)
276        return (
277            "eval=<"
278            + str(gdb.parse_and_eval("eval_func (123456789, 2, 3, 4, 5, 6, 7, 8)"))
279            + ">"
280        )
281
282
283class pp_int_typedef(object):
284    def __init__(self, val):
285        self.val = val
286
287    def to_string(self):
288        return "type=%s, val=%s" % (self.val.type, int(self.val))
289
290
291class pp_int_typedef3(object):
292    "A printer without a to_string method"
293
294    def __init__(self, val):
295        self.val = val
296
297    def children(self):
298        yield "s", 27
299
300
301def lookup_function(val):
302    "Look-up and return a pretty-printer that can print val."
303
304    # Get the type.
305    type = val.type
306
307    # If it points to a reference, get the reference.
308    if type.code == gdb.TYPE_CODE_REF:
309        type = type.target()
310
311    # Get the unqualified type, stripped of typedefs.
312    type = type.unqualified().strip_typedefs()
313
314    # Get the type name.
315    typename = type.tag
316
317    if typename is None:
318        return None
319
320    # Iterate over local dictionary of types to determine
321    # if a printer is registered for that type.  Return an
322    # instantiation of the printer if found.
323    for function in pretty_printers_dict:
324        if function.match(typename):
325            return pretty_printers_dict[function](val)
326
327    # Cannot find a pretty printer.  Return None.
328
329    return None
330
331
332def disable_lookup_function():
333    lookup_function.enabled = False
334
335
336def enable_lookup_function():
337    lookup_function.enabled = True
338
339
340# Lookup a printer for VAL in the typedefs dict.
341def lookup_typedefs_function(val):
342    "Look-up and return a pretty-printer that can print val (typedefs)."
343
344    # Get the type.
345    type = val.type
346
347    if type is None or type.name is None or type.code != gdb.TYPE_CODE_TYPEDEF:
348        return None
349
350    # Iterate over local dictionary of typedef types to determine if a
351    # printer is registered for that type.  Return an instantiation of
352    # the printer if found.
353    for function in typedefs_pretty_printers_dict:
354        if function.match(type.name):
355            return typedefs_pretty_printers_dict[function](val)
356
357    # Cannot find a pretty printer.
358    return None
359
360
361def register_pretty_printers():
362    pretty_printers_dict[re.compile("^struct s$")] = pp_s
363    pretty_printers_dict[re.compile("^s$")] = pp_s
364    pretty_printers_dict[re.compile("^S$")] = pp_s
365
366    pretty_printers_dict[re.compile("^struct ss$")] = pp_ss
367    pretty_printers_dict[re.compile("^ss$")] = pp_ss
368    pretty_printers_dict[re.compile("^const S &$")] = pp_s
369    pretty_printers_dict[re.compile("^SSS$")] = pp_sss
370
371    pretty_printers_dict[re.compile("^VirtualTest$")] = pp_multiple_virtual
372    pretty_printers_dict[re.compile("^Vbase1$")] = pp_vbase1
373
374    pretty_printers_dict[re.compile("^struct nullstr$")] = pp_nullstr
375    pretty_printers_dict[re.compile("^nullstr$")] = pp_nullstr
376
377    # Note that we purposely omit the typedef names here.
378    # Printer lookup is based on canonical name.
379    # However, we do need both tagged and untagged variants, to handle
380    # both the C and C++ cases.
381    pretty_printers_dict[re.compile("^struct string_repr$")] = string_print
382    pretty_printers_dict[re.compile("^struct container$")] = ContainerPrinter
383    pretty_printers_dict[re.compile("^struct justchildren$")] = NoStringContainerPrinter
384    pretty_printers_dict[re.compile("^string_repr$")] = string_print
385    pretty_printers_dict[re.compile("^container$")] = ContainerPrinter
386    pretty_printers_dict[re.compile("^justchildren$")] = NoStringContainerPrinter
387
388    pretty_printers_dict[
389        re.compile("^struct to_string_returns_value_inner$")
390    ] = ToStringReturnsValueInner
391    pretty_printers_dict[
392        re.compile("^to_string_returns_value_inner$")
393    ] = ToStringReturnsValueInner
394    pretty_printers_dict[
395        re.compile("^struct to_string_returns_value_wrapper$")
396    ] = ToStringReturnsValueWrapper
397    pretty_printers_dict[
398        re.compile("^to_string_returns_value_wrapper$")
399    ] = ToStringReturnsValueWrapper
400
401    pretty_printers_dict[re.compile("^struct ns$")] = pp_ns
402    pretty_printers_dict[re.compile("^ns$")] = pp_ns
403
404    pretty_printers_dict[re.compile("^struct lazystring$")] = pp_ls
405    pretty_printers_dict[re.compile("^lazystring$")] = pp_ls
406
407    pretty_printers_dict[re.compile("^struct outerstruct$")] = pp_outer
408    pretty_printers_dict[re.compile("^outerstruct$")] = pp_outer
409
410    pretty_printers_dict[re.compile("^struct hint_error$")] = pp_hint_error
411    pretty_printers_dict[re.compile("^hint_error$")] = pp_hint_error
412
413    pretty_printers_dict[re.compile("^struct children_as_list$")] = pp_children_as_list
414    pretty_printers_dict[re.compile("^children_as_list$")] = pp_children_as_list
415
416    pretty_printers_dict[re.compile("^memory_error$")] = MemoryErrorString
417
418    pretty_printers_dict[re.compile("^eval_type_s$")] = pp_eval_type
419
420    typedefs_pretty_printers_dict[re.compile("^int_type$")] = pp_int_typedef
421    typedefs_pretty_printers_dict[re.compile("^int_type2$")] = pp_int_typedef
422    typedefs_pretty_printers_dict[re.compile("^int_type3$")] = pp_int_typedef3
423
424
425# Dict for struct types with typedefs fully stripped.
426pretty_printers_dict = {}
427# Dict for typedef types.
428typedefs_pretty_printers_dict = {}
429
430register_pretty_printers()
431gdb.pretty_printers.append(lookup_function)
432gdb.pretty_printers.append(lookup_typedefs_function)
433