1 # Copyright 2014-2017 Free Software Foundation, Inc.
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.
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.
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/>.
16 # This file is part of the GDB testsuite. It test the xmethods support
17 # in the Python extension language.
22 from gdb.xmethod import XMethod
23 from gdb.xmethod import XMethodMatcher, XMethodWorker
24 from gdb.xmethod import SimpleXMethodMatcher
27 def A_plus_A(obj, opr):
28 print('From Python <A_plus_A>:')
29 return obj['a'] + opr['a']
33 print('From Python <plus_plus_A>:')
38 print('From Python <A_geta>:')
42 def A_getarrayind(obj, index):
43 print('From Python <A_getarrayind>:')
44 return obj['array'][index]
46 def A_indexoper(obj, index):
47 return obj['array'][index].reference_value()
49 def B_indexoper(obj, index):
50 return obj['array'][index].const_value().reference_value()
53 type_A = gdb.parse_and_eval('(dop::A *) 0').type.target()
54 type_B = gdb.parse_and_eval('(dop::B *) 0').type.target()
55 type_int = gdb.parse_and_eval('(int *) 0').type.target()
58 # The E class matcher and worker test two things:
59 # 1. xmethod returning None.
60 # 2. Matcher returning a list of workers.
62 class E_method_char_worker(XMethodWorker):
66 def get_arg_types(self):
67 return gdb.lookup_type('char')
69 def get_result_type(self, obj, arg):
70 return gdb.lookup_type('void')
72 def __call__(self, obj, arg):
73 print('From Python <E_method_char>')
77 class E_method_int_worker(XMethodWorker):
81 def get_arg_types(self):
82 return gdb.lookup_type('int')
84 # Note: get_result_type method elided on purpose
86 def __call__(self, obj, arg):
87 print('From Python <E_method_int>')
91 class E_method_matcher(XMethodMatcher):
93 XMethodMatcher.__init__(self, 'E_methods')
94 self.methods = [XMethod('method_int'), XMethod('method_char')]
96 def match(self, class_type, method_name):
97 class_tag = class_type.unqualified().tag
98 if not re.match('^dop::E$', class_tag):
100 if not re.match('^method$', method_name):
103 if self.methods[0].enabled:
104 workers.append(E_method_int_worker())
105 if self.methods[1].enabled:
106 workers.append(E_method_char_worker())
110 # The G class method matcher and worker illustrate how to write
111 # xmethod matchers and workers for template classes and template
114 class G_size_diff_worker(XMethodWorker):
115 def __init__(self, class_template_type, method_template_type):
116 self._class_template_type = class_template_type
117 self._method_template_type = method_template_type
119 def get_arg_types(self):
122 def __call__(self, obj):
123 print('From Python G<>::size_diff()')
124 return (self._method_template_type.sizeof -
125 self._class_template_type.sizeof)
128 class G_size_mul_worker(XMethodWorker):
129 def __init__(self, class_template_type, method_template_val):
130 self._class_template_type = class_template_type
131 self._method_template_val = method_template_val
133 def get_arg_types(self):
136 def __call__(self, obj):
137 print('From Python G<>::size_mul()')
138 return self._class_template_type.sizeof * self._method_template_val
141 class G_mul_worker(XMethodWorker):
142 def __init__(self, class_template_type, method_template_type):
143 self._class_template_type = class_template_type
144 self._method_template_type = method_template_type
146 def get_arg_types(self):
147 return self._method_template_type
149 def __call__(self, obj, arg):
150 print('From Python G<>::mul()')
151 return obj['t'] * arg
154 class G_methods_matcher(XMethodMatcher):
156 XMethodMatcher.__init__(self, 'G_methods')
157 self.methods = [XMethod('size_diff'),
161 def _is_enabled(self, name):
162 for method in self.methods:
163 if method.name == name and method.enabled:
166 def match(self, class_type, method_name):
167 class_tag = class_type.unqualified().tag
168 if not re.match('^dop::G<[ ]*[_a-zA-Z][ _a-zA-Z0-9]*>$',
171 t_name = class_tag[7:-1]
173 t_type = gdb.lookup_type(t_name)
176 if re.match('^size_diff<[ ]*[_a-zA-Z][ _a-zA-Z0-9]*>$', method_name):
177 if not self._is_enabled('size_diff'):
179 t1_name = method_name[10:-1]
181 t1_type = gdb.lookup_type(t1_name)
182 return G_size_diff_worker(t_type, t1_type)
185 if re.match('^size_mul<[ ]*[0-9]+[ ]*>$', method_name):
186 if not self._is_enabled('size_mul'):
188 m_val = int(method_name[9:-1])
189 return G_size_mul_worker(t_type, m_val)
190 if re.match('^mul<[ ]*[_a-zA-Z][ _a-zA-Z0-9]*>$', method_name):
191 if not self._is_enabled('mul'):
193 t1_name = method_name[4:-1]
195 t1_type = gdb.lookup_type(t1_name)
196 return G_mul_worker(t_type, t1_type)
202 SimpleXMethodMatcher('A_plus_A',
206 # This is a replacement, hence match the arg type
208 type_A.const().reference()),
209 SimpleXMethodMatcher('plus_plus_A',
213 SimpleXMethodMatcher('A_geta',
217 SimpleXMethodMatcher('A_getarrayind',
222 SimpleXMethodMatcher('A_indexoper',
227 SimpleXMethodMatcher('B_indexoper',
234 for matcher in global_dm_list:
235 gdb.xmethod.register_xmethod_matcher(gdb, matcher)
236 gdb.xmethod.register_xmethod_matcher(gdb.current_progspace(),
238 gdb.xmethod.register_xmethod_matcher(gdb.current_progspace(),