kakoune

Fork of kakoune, an acceptable text editor
git clone git://git.laack.co/kakoune.git
Log | Files | Refs

kakoune.py (6100B)


      1 import gdb.printing
      2 
      3 class ArrayIterator:
      4     def __init__(self, data, count):
      5         self.data = data
      6         self.count = count
      7         self.index = 0
      8 
      9     def __iter__(self):
     10         return self
     11 
     12     def next(self):
     13         if self.index == self.count:
     14             raise StopIteration
     15 
     16         index = self.index
     17         self.index = self.index + 1
     18         return ('[%d]' % index, (self.data + index).dereference())
     19 
     20     def __next__(self):
     21         return self.next()
     22 
     23 
     24 class ArrayView:
     25     """Print a ArrayView"""
     26 
     27     def __init__(self, val):
     28         self.val = val
     29 
     30     def display_hint(self):
     31         return 'array'
     32 
     33     def children(self):
     34         return ArrayIterator(self.val['m_pointer'], self.val['m_size'])
     35 
     36     def to_string(self):
     37         type = self.val.type.template_argument(0).unqualified().strip_typedefs()
     38         return "ArrayView<%s>" % (type)
     39 
     40 
     41 class LineAndColumn:
     42     """Print a LineAndColumn"""
     43 
     44     def __init__(self, val):
     45         self.val = val
     46 
     47     def to_string(self):
     48         value_type = self.val.type.unqualified()
     49         return "%s(%s, %s)" % (value_type, self.val['line'],
     50                                self.val['column'])
     51 
     52 
     53 class BufferCoordAndTarget:
     54     """Print a BufferCoordAndTarget"""
     55 
     56     def __init__(self, val):
     57         self.val = val
     58 
     59     def to_string(self):
     60         value_type = self.val.type.unqualified()
     61         return "%s(%s, %s, %s)" % (value_type, self.val['line'],
     62                                    self.val['column'], self.val['target'])
     63 
     64 
     65 class BufferIterator:
     66     """ Print a BufferIterator"""
     67 
     68     def __init__(self, val):
     69         self.val = val
     70 
     71     def to_string(self):
     72         line = self.val['m_coord']['line']
     73         column = self.val['m_coord']['column']
     74         return "BufferIterator(%s, %s)" % (line, column)
     75 
     76 
     77 class String:
     78     """ Print a String"""
     79 
     80     def __init__(self, val):
     81         self.val = val
     82 
     83     def to_string(self):
     84         data_u = self.val["m_data"]["u"]
     85         long = data_u["l"]
     86         short = data_u["s"]
     87         if (long["mode"] & long["active_mask"]) != 0:
     88             ptr = long["ptr"]
     89             len = long["size"]
     90         else:
     91             ptr = short["string"]
     92             short_capacity = short
     93             len = short["capacity"] - short["remaining_size"]
     94         return "\"%s\"" % (ptr.string("utf-8", "ignore", len))
     95 
     96 
     97 class StringView:
     98     """ Print a StringView"""
     99 
    100     def __init__(self, val):
    101         self.val = val
    102 
    103     def to_string(self):
    104         len = self.val['m_length']['m_value']
    105         return "\"%s\"" % (self.val['m_data'].string("utf-8", "ignore", len))
    106 
    107 
    108 class StringDataPtr:
    109     """ Print a RefPtr<StringData>"""
    110 
    111     def __init__(self, val):
    112         self.val = val
    113 
    114     def to_string(self):
    115         ptr = self.val['m_ptr']
    116         str_type = gdb.lookup_type("char").pointer()
    117         len = ptr.dereference()['length']
    118         refcount = ptr.dereference()['refcount']
    119         content = (ptr + 1).cast(str_type).string("utf-8", "ignore", len)
    120         return "\"%s\" (ref:%d)" % (content.replace("\n", "\\n"), refcount)
    121 
    122 
    123 class RefPtr:
    124     """ Print a RefPtr"""
    125 
    126     def __init__(self, val):
    127         self.val = val
    128 
    129     def to_string(self):
    130         ptr = self.val['m_ptr']
    131         return "\"refptr %s\"" % (ptr)
    132 
    133 
    134 class Option:
    135     """ Print a Option"""
    136 
    137     def __init__(self, val):
    138         self.val = val
    139 
    140     def to_string(self):
    141         return self.val["m_value"]
    142 
    143 
    144 class CharCount:
    145     """Print a CharCount"""
    146 
    147     def __init__(self, val):
    148         self.val = val
    149 
    150     def to_string(self):
    151         return self.val["m_value"]
    152 
    153 
    154 class ColumnCount:
    155     """Print a ColumnCount"""
    156 
    157     def __init__(self, val):
    158         self.val = val
    159 
    160     def to_string(self):
    161         return self.val["m_value"]
    162 
    163 
    164 class ByteCount:
    165     """Print a ByteCount"""
    166 
    167     def __init__(self, val):
    168         self.val = val
    169 
    170     def to_string(self):
    171         return self.val["m_value"]
    172 
    173 
    174 class LineCount:
    175     """Print a LineCount"""
    176 
    177     def __init__(self, val):
    178         self.val = val
    179 
    180     def to_string(self):
    181         return self.val["m_value"]
    182 
    183 
    184 class Color:
    185     """Print a Color"""
    186 
    187     def __init__(self, val):
    188         self.val = val
    189 
    190     def to_string(self):
    191         named_color = gdb.lookup_type("Kakoune::Color::NamedColor")
    192         if self.val["color"] == named_color["Kakoune::Color::RGB"].enumval:
    193             return "%s #%02x%02x%02x" % (self.val["color"], self.val["r"],
    194                                          self.val["g"], self.val["b"])
    195         else:
    196             return self.val["color"]
    197 
    198 class Regex:
    199     """Print a Regex"""
    200 
    201     def __init__(self, val):
    202         self.val = val
    203 
    204     def to_string(self):
    205         return "regex%s" % (self.val["m_str"])
    206 
    207 
    208 def build_pretty_printer():
    209     pp = gdb.printing.RegexpCollectionPrettyPrinter("kakoune")
    210     pp.add_printer('ArrayView', '^Kakoune::(Const)?ArrayView<.*>$', ArrayView)
    211     pp.add_printer('LineAndColumn', '^Kakoune::(Buffer|Display)Coord$', LineAndColumn)
    212     pp.add_printer('BufferCoordAndTarget', '^Kakoune::BufferCoordAndTarget$', BufferCoordAndTarget)
    213     pp.add_printer('BufferIterator', '^Kakoune::BufferIterator$', BufferIterator)
    214     pp.add_printer('String', '^Kakoune::String$', String)
    215     pp.add_printer('StringView', '^Kakoune::(StringView|SharedString)$', StringView)
    216     pp.add_printer('StringDataPtr', '^Kakoune::StringDataPtr$', StringDataPtr)
    217     pp.add_printer('StringDataPtr', '^Kakoune::RefPtr<Kakoune::StringData,.*>$', StringDataPtr)
    218     pp.add_printer('RefPtr', '^Kakoune::RefPtr<.*>$',  RefPtr)
    219     pp.add_printer('Option', '^Kakoune::Option$', Option)
    220     pp.add_printer('LineCount', '^Kakoune::LineCount$', LineCount)
    221     pp.add_printer('CharCount', '^Kakoune::CharCount$', CharCount)
    222     pp.add_printer('ColumnCount', '^Kakoune::ColumnCount$', ColumnCount)
    223     pp.add_printer('ByteCount', '^Kakoune::ByteCount$', ByteCount)
    224     pp.add_printer('Color', '^Kakoune::Color$', Color)
    225     pp.add_printer('Regex', '^Kakoune::Regex$', Regex)
    226     return pp
    227 
    228 if __name__ == "__main__":
    229     print("Adding kakoune pretty printers")
    230     gdb.printing.register_pretty_printer(gdb.current_objfile(), build_pretty_printer())