gdb/testsuite/gdb.python/py-prettyprint.py

   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
  19 import re
  20 import gdb
  21
  22
  23 def _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.
  32 def _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.
  43 class 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.
  52 class 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.
  75 class 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.
  90 exception_flag = False
  91
  92
  93 # Test a printer where to_string is None
  94 class NoStringContainerPrinter(object):
  95     def __init__(self, val):
  96         self.val = val
  97
  98     def to_string(self):
  99         return None
 100
 101     def children(self):
 102         return _iterator_except(self.val["elements"], self.val["len"])
 103
 104
 105 # See ToStringReturnsValueWrapper.
 106 class ToStringReturnsValueInner:
 107     def __init__(self, val):
 108         self.val = val
 109
 110     def to_string(self):
 111         return "Inner to_string {}".format(int(self.val["val"]))
 112
 113
 114 # Test a printer that returns a gdb.Value in its to_string.  That gdb.Value
 115 # also has its own pretty-printer.
 116 class ToStringReturnsValueWrapper:
 117     def __init__(self, val):
 118         self.val = val
 119
 120     def to_string(self):
 121         return self.val["inner"]
 122
 123
 124 class pp_s(object):
 125     def __init__(self, val):
 126         self.val = val
 127
 128     def to_string(self):
 129         a = self.val["a"]
 130         b = self.val["b"]
 131         if a.address != b:
 132             raise Exception("&a(%s) != b(%s)" % (str(a.address), str(b)))
 133         return " a=<" + str(self.val["a"]) + "> b=<" + str(self.val["b"]) + ">"
 134
 135
 136 class pp_ss(object):
 137     def __init__(self, val):
 138         self.val = val
 139
 140     def to_string(self):
 141         return "a=<" + str(self.val["a"]) + "> b=<" + str(self.val["b"]) + ">"
 142
 143
 144 class pp_sss(object):
 145     def __init__(self, val):
 146         self.val = val
 147
 148     def to_string(self):
 149         return "a=<" + str(self.val["a"]) + "> b=<" + str(self.val["b"]) + ">"
 150
 151
 152 class pp_multiple_virtual(object):
 153     def __init__(self, val):
 154         self.val = val
 155
 156     def to_string(self):
 157         return "pp value variable is: " + str(self.val["value"])
 158
 159
 160 class pp_vbase1(object):
 161     def __init__(self, val):
 162         self.val = val
 163
 164     def to_string(self):
 165         return "pp class name: " + self.val.type.tag
 166
 167
 168 class pp_nullstr(object):
 169     def __init__(self, val):
 170         self.val = val
 171
 172     def to_string(self):
 173         return self.val["s"].string(gdb.target_charset())
 174
 175
 176 class pp_ns(object):
 177     "Print a std::basic_string of some kind"
 178
 179     def __init__(self, val):
 180         self.val = val
 181
 182     def to_string(self):
 183         len = self.val["length"]
 184         return self.val["null_str"].string(gdb.target_charset(), length=len)
 185
 186     def display_hint(self):
 187         return "string"
 188
 189
 190 pp_ls_encoding = None
 191
 192
 193 class pp_ls(object):
 194     "Print a std::basic_string of some kind"
 195
 196     def __init__(self, val):
 197         self.val = val
 198
 199     def to_string(self):
 200         length = self.val["len"]
 201         if pp_ls_encoding is not None:
 202             if length >= 0:
 203                 return self.val["lazy_str"].lazy_string(
 204                     encoding=pp_ls_encoding, length=length
 205                 )
 206             else:
 207                 return self.val["lazy_str"].lazy_string(encoding=pp_ls_encoding)
 208         else:
 209             if length >= 0:
 210                 return self.val["lazy_str"].lazy_string(length=length)
 211             else:
 212                 return self.val["lazy_str"].lazy_string()
 213
 214     def display_hint(self):
 215         return "string"
 216
 217
 218 class pp_hint_error(object):
 219     "Throw error from display_hint"
 220
 221     def __init__(self, val):
 222         self.val = val
 223
 224     def to_string(self):
 225         return "hint_error_val"
 226
 227     def display_hint(self):
 228         raise Exception("hint failed")
 229
 230
 231 class pp_children_as_list(object):
 232     "Throw error from display_hint"
 233
 234     def __init__(self, val):
 235         self.val = val
 236
 237     def to_string(self):
 238         return "children_as_list_val"
 239
 240     def children(self):
 241         return [("one", 1)]
 242
 243
 244 class pp_outer(object):
 245     "Print struct outer"
 246
 247     def __init__(self, val):
 248         self.val = val
 249
 250     def to_string(self):
 251         return "x = %s" % self.val["x"]
 252
 253     def children(self):
 254         yield "s", self.val["s"]
 255         yield "x", self.val["x"]
 256
 257
 258 class MemoryErrorString(object):
 259     "Raise an error"
 260
 261     def __init__(self, val):
 262         self.val = val
 263
 264     def to_string(self):
 265         raise gdb.MemoryError("Cannot access memory.")
 266
 267     def display_hint(self):
 268         return "string"
 269
 270
 271 class pp_eval_type(object):
 272     def __init__(self, val):
 273         self.val = val
 274
 275     def to_string(self):
 276         gdb.execute("bt", to_string=True)
 277         return (
 278             "eval=<"
 279             + str(gdb.parse_and_eval("eval_func (123456789, 2, 3, 4, 5, 6, 7, 8)"))
 280             + ">"
 281         )
 282
 283
 284 class pp_int_typedef(object):
 285     def __init__(self, val):
 286         self.val = val
 287
 288     def to_string(self):
 289         return "type=%s, val=%s" % (self.val.type, int(self.val))
 290
 291
 292 class pp_int_typedef3(object):
 293     "A printer without a to_string method"
 294
 295     def __init__(self, val):
 296         self.val = val
 297
 298     def children(self):
 299         yield "s", 27
 300
 301
 302 def lookup_function(val):
 303     "Look-up and return a pretty-printer that can print val."
 304
 305     # Get the type.
 306     type = val.type
 307
 308     # If it points to a reference, get the reference.
 309     if type.code == gdb.TYPE_CODE_REF:
 310         type = type.target()
 311
 312     # Get the unqualified type, stripped of typedefs.
 313     type = type.unqualified().strip_typedefs()
 314
 315     # Get the type name.
 316     typename = type.tag
 317
 318     if typename is None:
 319         return None
 320
 321     # Iterate over local dictionary of types to determine
 322     # if a printer is registered for that type.  Return an
 323     # instantiation of the printer if found.
 324     for function in pretty_printers_dict:
 325         if function.match(typename):
 326             return pretty_printers_dict[function](val)
 327
 328     # Cannot find a pretty printer.  Return None.
 329
 330     return None
 331
 332
 333 def disable_lookup_function():
 334     lookup_function.enabled = False
 335
 336
 337 def enable_lookup_function():
 338     lookup_function.enabled = True
 339
 340
 341 # Lookup a printer for VAL in the typedefs dict.
 342 def lookup_typedefs_function(val):
 343     "Look-up and return a pretty-printer that can print val (typedefs)."
 344
 345     # Get the type.
 346     type = val.type
 347
 348     if type is None or type.name is None or type.code != gdb.TYPE_CODE_TYPEDEF:
 349         return None
 350
 351     # Iterate over local dictionary of typedef types to determine if a
 352     # printer is registered for that type.  Return an instantiation of
 353     # the printer if found.
 354     for function in typedefs_pretty_printers_dict:
 355         if function.match(type.name):
 356             return typedefs_pretty_printers_dict[function](val)
 357
 358     # Cannot find a pretty printer.
 359     return None
 360
 361
 362 def register_pretty_printers():
 363     pretty_printers_dict[re.compile("^struct s$")] = pp_s
 364     pretty_printers_dict[re.compile("^s$")] = pp_s
 365     pretty_printers_dict[re.compile("^S$")] = pp_s
 366
 367     pretty_printers_dict[re.compile("^struct ss$")] = pp_ss
 368     pretty_printers_dict[re.compile("^ss$")] = pp_ss
 369     pretty_printers_dict[re.compile("^const S &$")] = pp_s
 370     pretty_printers_dict[re.compile("^SSS$")] = pp_sss
 371
 372     pretty_printers_dict[re.compile("^VirtualTest$")] = pp_multiple_virtual
 373     pretty_printers_dict[re.compile("^Vbase1$")] = pp_vbase1
 374
 375     pretty_printers_dict[re.compile("^struct nullstr$")] = pp_nullstr
 376     pretty_printers_dict[re.compile("^nullstr$")] = pp_nullstr
 377
 378     # Note that we purposely omit the typedef names here.
 379     # Printer lookup is based on canonical name.
 380     # However, we do need both tagged and untagged variants, to handle
 381     # both the C and C++ cases.
 382     pretty_printers_dict[re.compile("^struct string_repr$")] = string_print
 383     pretty_printers_dict[re.compile("^struct container$")] = ContainerPrinter
 384     pretty_printers_dict[re.compile("^struct justchildren$")] = NoStringContainerPrinter
 385     pretty_printers_dict[re.compile("^string_repr$")] = string_print
 386     pretty_printers_dict[re.compile("^container$")] = ContainerPrinter
 387     pretty_printers_dict[re.compile("^justchildren$")] = NoStringContainerPrinter
 388
 389     pretty_printers_dict[
 390         re.compile("^struct to_string_returns_value_inner$")
 391     ] = ToStringReturnsValueInner
 392     pretty_printers_dict[
 393         re.compile("^to_string_returns_value_inner$")
 394     ] = ToStringReturnsValueInner
 395     pretty_printers_dict[
 396         re.compile("^struct to_string_returns_value_wrapper$")
 397     ] = ToStringReturnsValueWrapper
 398     pretty_printers_dict[
 399         re.compile("^to_string_returns_value_wrapper$")
 400     ] = ToStringReturnsValueWrapper
 401
 402     pretty_printers_dict[re.compile("^struct ns$")] = pp_ns
 403     pretty_printers_dict[re.compile("^ns$")] = pp_ns
 404
 405     pretty_printers_dict[re.compile("^struct lazystring$")] = pp_ls
 406     pretty_printers_dict[re.compile("^lazystring$")] = pp_ls
 407
 408     pretty_printers_dict[re.compile("^struct outerstruct$")] = pp_outer
 409     pretty_printers_dict[re.compile("^outerstruct$")] = pp_outer
 410
 411     pretty_printers_dict[re.compile("^struct hint_error$")] = pp_hint_error
 412     pretty_printers_dict[re.compile("^hint_error$")] = pp_hint_error
 413
 414     pretty_printers_dict[re.compile("^struct children_as_list$")] = pp_children_as_list
 415     pretty_printers_dict[re.compile("^children_as_list$")] = pp_children_as_list
 416
 417     pretty_printers_dict[re.compile("^memory_error$")] = MemoryErrorString
 418
 419     pretty_printers_dict[re.compile("^eval_type_s$")] = pp_eval_type
 420
 421     typedefs_pretty_printers_dict[re.compile("^int_type$")] = pp_int_typedef
 422     typedefs_pretty_printers_dict[re.compile("^int_type2$")] = pp_int_typedef
 423     typedefs_pretty_printers_dict[re.compile("^int_type3$")] = pp_int_typedef3
 424
 425
 426 # Dict for struct types with typedefs fully stripped.
 427 pretty_printers_dict = {}
 428 # Dict for typedef types.
 429 typedefs_pretty_printers_dict = {}
 430
 431 register_pretty_printers()
 432 gdb.pretty_printers.append(lookup_function)
 433 gdb.pretty_printers.append(lookup_typedefs_function)