Mercurial > pidgin.yaz
annotate libgaim/dbus-analyze-functions.py @ 14694:8538993dbb00
[gaim-migrate @ 17446]
Patch #1571853 from Richard Nelson (wabz):
"This patch removes the contact and all buddies when
removing a contact, rather than just removing it from
the blist (and having all the buddies show up next time
gaim-text is opened)"
committer: Tailor Script <tailor@pidgin.im>
author | Sadrul Habib Chowdhury <imadil@gmail.com> |
---|---|
date | Sun, 08 Oct 2006 04:21:20 +0000 |
parents | 74b69a11830c |
children |
rev | line source |
---|---|
14192 | 1 import re |
2 import string | |
3 import sys | |
4 | |
5 | |
6 # types translated into "int" | |
7 simpletypes = ["int", "gint", "guint", "gboolean"] | |
8 | |
9 # List "excluded" contains functions that shouldn't be exported via | |
10 # DBus. If you remove a function from this list, please make sure | |
11 # that it does not break "make" with the configure option | |
12 # "--enable-dbus" turned on. | |
13 | |
14 excluded = [\ | |
15 # I don't remember why this function is excluded; something to do | |
16 # with the fact that it takes a (const) GList as a parameter. | |
17 "gaim_presence_add_list", | |
18 | |
19 # These functions are excluded because they involve value of the | |
20 # type GaimConvPlacementFunc, which is a pointer to a function and | |
21 # (currently?) can't be translated into a DBus type. Normally, | |
22 # functions with untranslatable types are skipped, but this script | |
23 # assumes that all non-pointer type names beginning with "Gaim" | |
24 # are enums, which is not true in this case. | |
25 "gaim_conv_placement_add_fnc", | |
26 "gaim_conv_placement_get_fnc", | |
27 "gaim_conv_placement_get_current_func", | |
28 "gaim_conv_placement_set_current_func", | |
29 | |
30 # This is excluded because this script treats GaimLogReadFlags* | |
31 # as pointer to a struct, instead of a pointer to an enum. This | |
32 # causes a compilation error. Someone should fix this script. | |
33 "gaim_log_read", | |
34 ] | |
35 | |
36 # This is a list of functions that return a GList* whose elements are | |
37 # string, not pointers to objects. Don't put any functions here, it | |
38 # won't work. | |
39 stringlists = [] | |
40 | |
41 pointer = "#pointer#" | |
42 myexception = "My Exception" | |
43 | |
44 def ctopascal(name): | |
45 newname = "" | |
46 for word in name.split("_"): | |
47 newname += word.capitalize() | |
48 return newname | |
49 | |
50 class Parameter: | |
51 def __init__(self, type, name): | |
52 self.name = name | |
53 self.type = type | |
54 | |
55 def fromtokens(tokens, parameternumber = -1): | |
56 if len(tokens) == 0: | |
57 raise myexception | |
58 if (len(tokens) == 1) or (tokens[-1] == pointer): | |
59 if parameternumber >= 0: | |
60 return Parameter(tokens, "param%i" % parameternumber) | |
61 else: | |
62 raise myexception | |
63 else: | |
64 return Parameter(tokens[:-1], tokens[-1]) | |
65 | |
66 fromtokens = staticmethod(fromtokens) | |
67 | |
68 class Binding: | |
69 def __init__(self, functiontext, paramtexts): | |
70 self.function = Parameter.fromtokens(functiontext.split()) | |
71 | |
72 if self.function.name in excluded: | |
73 raise myexception | |
74 | |
75 self.params = [] | |
76 for i in range(len(paramtexts)): | |
77 self.params.append(Parameter.fromtokens(paramtexts[i].split(), i)) | |
78 | |
79 self.call = "%s(%s)" % (self.function.name, | |
80 ", ".join([param.name for param in self.params])) | |
81 | |
82 | |
83 def process(self): | |
84 for param in self.params: | |
85 self.processinput(param.type, param.name) | |
86 | |
87 self.processoutput(self.function.type, "RESULT") | |
88 self.flush() | |
89 | |
90 | |
91 def processinput(self, type, name): | |
92 const = False | |
93 if type[0] == "const": | |
94 type = type[1:] | |
95 const = True | |
96 | |
97 if len(type) == 1: | |
98 # simple types (int, gboolean, etc.) and enums | |
99 if (type[0] in simpletypes) or (type[0].startswith("Gaim")): | |
100 return self.inputsimple(type, name) | |
101 | |
102 # pointers ... | |
103 if (len(type) == 2) and (type[1] == pointer): | |
104 # strings | |
105 if type[0] == "char": | |
106 if const: | |
107 return self.inputstring(type, name) | |
108 else: | |
109 raise myexception | |
110 | |
111 elif type[0] == "GHashTable": | |
112 return self.inputhash(type, name) | |
113 | |
114 # known object types are transformed to integer handles | |
14352
9c884b84afb9
[gaim-migrate @ 17058]
Sadrul Habib Chowdhury <imadil@gmail.com>
parents:
14192
diff
changeset
|
115 elif type[0].startswith("Gaim") or type[0] == "xmlnode": |
14192 | 116 return self.inputgaimstructure(type, name) |
117 | |
118 # unknown pointers are always replaced with NULL | |
119 else: | |
120 return self.inputpointer(type, name) | |
121 return | |
122 | |
123 raise myexception | |
124 | |
125 | |
126 def processoutput(self, type, name): | |
127 # the "void" type is simple ... | |
128 if type == ["void"]: | |
129 return self.outputvoid(type, name) | |
130 | |
131 const = False | |
132 if type[0] == "const": | |
133 type = type[1:] | |
134 const = True | |
135 | |
136 # a string | |
137 if type == ["char", pointer]: | |
138 return self.outputstring(type, name, const) | |
139 | |
140 # simple types (ints, booleans, enums, ...) | |
141 if (len(type) == 1) and \ | |
142 ((type[0] in simpletypes) or (type[0].startswith("Gaim"))): | |
143 return self.outputsimple(type, name) | |
144 | |
145 # pointers ... | |
146 if (len(type) == 2) and (type[1] == pointer): | |
147 | |
148 # handles | |
149 if type[0].startswith("Gaim"): | |
150 return self.outputgaimstructure(type, name) | |
151 | |
152 if type[0] in ["GList", "GSList"]: | |
153 return self.outputlist(type, name) | |
154 | |
155 raise myexception | |
156 | |
157 | |
158 class ClientBinding (Binding): | |
159 def __init__(self, functiontext, paramtexts, knowntypes, headersonly): | |
160 Binding.__init__(self, functiontext, paramtexts) | |
161 self.knowntypes = knowntypes | |
162 self.headersonly = headersonly | |
163 self.paramshdr = [] | |
164 self.decls = [] | |
165 self.inputparams = [] | |
166 self.outputparams = [] | |
167 self.returncode = [] | |
168 | |
169 def flush(self): | |
170 print "%s %s(%s)" % (self.functiontype, self.function.name, | |
171 ", ".join(self.paramshdr)), | |
172 | |
173 if self.headersonly: | |
174 print ";" | |
175 return | |
176 | |
177 print "{" | |
178 | |
179 for decl in self.decls: | |
180 print decl | |
181 | |
182 print 'dbus_g_proxy_call(gaim_proxy, "%s", NULL,' % ctopascal(self.function.name) | |
183 | |
184 for type_name in self.inputparams: | |
185 print "\t%s, %s, " % type_name, | |
186 print "G_TYPE_INVALID," | |
187 | |
188 for type_name in self.outputparams: | |
189 print "\t%s, &%s, " % type_name, | |
190 print "G_TYPE_INVALID);" | |
191 | |
192 for code in self.returncode: | |
193 print code | |
194 | |
195 print "}\n" | |
196 | |
197 | |
198 def definegaimstructure(self, type): | |
199 if (self.headersonly) and (type[0] not in self.knowntypes): | |
200 print "struct _%s;" % type[0] | |
201 print "typedef struct _%s %s;" % (type[0], type[0]) | |
202 self.knowntypes.append(type[0]) | |
203 | |
204 def inputsimple(self, type, name): | |
205 self.paramshdr.append("%s %s" % (type[0], name)) | |
206 self.inputparams.append(("G_TYPE_INT", name)) | |
207 | |
208 def inputstring(self, type, name): | |
209 self.paramshdr.append("const char *%s" % name) | |
210 self.inputparams.append(("G_TYPE_STRING", name)) | |
211 | |
212 def inputgaimstructure(self, type, name): | |
213 self.paramshdr.append("const %s *%s" % (type[0], name)) | |
214 self.inputparams.append(("G_TYPE_INT", "GPOINTER_TO_INT(%s)" % name)) | |
215 self.definegaimstructure(type) | |
216 | |
217 def inputpointer(self, type, name): | |
218 name += "_NULL" | |
219 self.paramshdr.append("const %s *%s" % (type[0], name)) | |
220 self.inputparams.append(("G_TYPE_INT", "0")) | |
221 | |
222 def inputhash(self, type, name): | |
223 self.paramshdr.append("const GHashTable *%s" % name) | |
224 self.inputparams.append(('dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_STRING)', name)) | |
225 | |
226 def outputvoid(self, type, name): | |
227 self.functiontype = "void" | |
228 | |
229 def outputstring(self, type, name, const): | |
230 self.functiontype = "char*" | |
231 self.decls.append("char *%s = NULL;" % name) | |
232 self.outputparams.append(("G_TYPE_STRING", name)) | |
233 # self.returncode.append("NULLIFY(%s);" % name) | |
234 self.returncode.append("return %s;" % name); | |
235 | |
236 def outputsimple(self, type, name): | |
237 self.functiontype = type[0] | |
238 self.decls.append("%s %s = 0;" % (type[0], name)) | |
239 self.outputparams.append(("G_TYPE_INT", name)) | |
240 self.returncode.append("return %s;" % name); | |
241 | |
242 # we could add "const" to the return type but this would probably | |
243 # be a nuisance | |
244 def outputgaimstructure(self, type, name): | |
245 name = name + "_ID" | |
246 self.functiontype = "%s*" % type[0] | |
247 self.decls.append("int %s = 0;" % name) | |
248 self.outputparams.append(("G_TYPE_INT", "%s" % name)) | |
249 self.returncode.append("return (%s*) GINT_TO_POINTER(%s);" % (type[0], name)); | |
250 self.definegaimstructure(type) | |
251 | |
252 def outputlist(self, type, name): | |
253 self.functiontype = "%s*" % type[0] | |
254 self.decls.append("GArray *%s;" % name) | |
255 self.outputparams.append(('dbus_g_type_get_collection("GArray", G_TYPE_INT)', name)) | |
256 self.returncode.append("return garray_int_to_%s(%s);" % | |
257 (type[0].lower(), name)); | |
258 | |
259 | |
260 class ServerBinding (Binding): | |
261 def __init__(self, functiontext, paramtexts): | |
262 Binding.__init__(self, functiontext, paramtexts) | |
263 self.dparams = "" | |
264 self.cparams = [] | |
265 self.cdecls = [] | |
266 self.ccode = [] | |
267 self.cparamsout = [] | |
268 self.ccodeout = [] | |
269 self.argfunc = "dbus_message_get_args" | |
270 | |
271 def flush(self): | |
272 print "static DBusMessage*" | |
273 print "%s_DBUS(DBusMessage *message_DBUS, DBusError *error_DBUS) {" % \ | |
274 self.function.name | |
275 | |
276 print "\tDBusMessage *reply_DBUS;" | |
277 | |
278 for decl in self.cdecls: | |
279 print decl | |
280 | |
281 print "\t%s(message_DBUS, error_DBUS, " % self.argfunc, | |
282 for param in self.cparams: | |
283 print "DBUS_TYPE_%s, &%s," % param, | |
284 print "DBUS_TYPE_INVALID);" | |
285 | |
286 print "\tCHECK_ERROR(error_DBUS);" | |
287 | |
288 for code in self.ccode: | |
289 print code | |
290 | |
291 print "\treply_DBUS = dbus_message_new_method_return (message_DBUS);" | |
292 | |
293 print "\tdbus_message_append_args(reply_DBUS, ", | |
294 for param in self.cparamsout: | |
295 if type(param) is str: | |
296 print "%s, " % param | |
297 else: | |
298 print "DBUS_TYPE_%s, &%s, " % param, | |
299 print "DBUS_TYPE_INVALID);" | |
300 | |
301 for code in self.ccodeout: | |
302 print code | |
303 | |
304 print "\treturn reply_DBUS;\n}\n" | |
305 | |
306 | |
307 def addstring(self, *items): | |
308 for item in items: | |
309 self.dparams += item + r"\0" | |
310 | |
311 def addintype(self, type, name): | |
312 self.addstring("in", type, name) | |
313 | |
314 def addouttype(self, type, name): | |
315 self.addstring("out", type, name) | |
316 | |
317 | |
318 # input parameters | |
319 | |
320 def inputsimple(self, type, name): | |
321 self.cdecls.append("\tdbus_int32_t %s;" % name) | |
322 self.cparams.append(("INT32", name)) | |
323 self.addintype("i", name) | |
324 | |
325 def inputstring(self, type, name): | |
326 self.cdecls.append("\tconst char *%s;" % name) | |
327 self.cparams.append(("STRING", name)) | |
328 self.ccode .append("\tNULLIFY(%s);" % name) | |
329 self.addintype("s", name) | |
330 | |
331 def inputhash(self, type, name): | |
332 self.argfunc = "gaim_dbus_message_get_args" | |
333 self.cdecls.append("\tDBusMessageIter %s_ITER;" % name) | |
334 self.cdecls.append("\tGHashTable *%s;" % name) | |
335 self.cparams.append(("ARRAY", "%s_ITER" % name)) | |
336 self.ccode.append("\t%s = gaim_dbus_iter_hash_table(&%s_ITER, error_DBUS);" \ | |
337 % (name, name)) | |
338 self.ccode.append("\tCHECK_ERROR(error_DBUS);") | |
339 self.ccodeout.append("\tg_hash_table_destroy(%s);" % name) | |
340 self.addintype("a{ss}", name) | |
341 | |
342 def inputgaimstructure(self, type, name): | |
343 self.cdecls.append("\tdbus_int32_t %s_ID;" % name) | |
344 self.cdecls.append("\t%s *%s;" % (type[0], name)) | |
345 self.cparams.append(("INT32", name + "_ID")) | |
346 self.ccode.append("\tGAIM_DBUS_ID_TO_POINTER(%s, %s_ID, %s, error_DBUS);" % \ | |
347 (name, name, type[0])) | |
348 self.addintype("i", name) | |
349 | |
350 def inputpointer(self, type, name): | |
351 self.cdecls.append("\tdbus_int32_t %s_NULL;" % name) | |
352 self.cdecls .append("\t%s *%s;" % (type[0], name)) | |
353 self.cparams.append(("INT32", name + "_NULL")) | |
354 self.ccode .append("\t%s = NULL;" % name) | |
355 self.addintype("i", name) | |
356 | |
357 # output parameters | |
358 | |
359 def outputvoid(self, type, name): | |
360 self.ccode.append("\t%s;" % self.call) # just call the function | |
361 | |
362 def outputstring(self, type, name, const): | |
363 self.cdecls.append("\tconst char *%s;" % name) | |
364 self.ccode.append("\t%s = null_to_empty(%s);" % (name, self.call)) | |
365 self.cparamsout.append(("STRING", name)) | |
366 self.addouttype("s", name) | |
367 if not const: | |
368 self.ccodeout.append("\tg_free(%s);" % name) | |
369 | |
370 def outputsimple(self, type, name): | |
371 self.cdecls.append("\tdbus_int32_t %s;" % name) | |
372 self.ccode.append("\t%s = %s;" % (name, self.call)) | |
373 self.cparamsout.append(("INT32", name)) | |
374 self.addouttype("i", name) | |
375 | |
376 def outputgaimstructure(self, type, name): | |
377 self.cdecls.append("\tdbus_int32_t %s;" % name) | |
378 self.ccode .append("\tGAIM_DBUS_POINTER_TO_ID(%s, %s, error_DBUS);" % (name, self.call)) | |
379 self.cparamsout.append(("INT32", name)) | |
380 self.addouttype("i", name) | |
381 | |
382 # GList*, GSList*, assume that list is a list of objects | |
383 | |
384 # fixme: at the moment, we do NOT free the memory occupied by | |
385 # the list, we should free it if the list has NOT been declared const | |
386 | |
387 # fixme: we assume that this is a list of objects, not a list | |
388 # of strings | |
389 | |
390 def outputlist(self, type, name): | |
391 self.cdecls.append("\tdbus_int32_t %s_LEN;" % name) | |
392 self.ccodeout.append("\tg_free(%s);" % name) | |
393 | |
394 if self.function.name in stringlists: | |
395 self.cdecls.append("\tchar **%s;" % name) | |
396 self.ccode.append("\t%s = gaim_%s_to_array(%s, FALSE, &%s_LEN);" % \ | |
397 (name, type[0], self.call, name)) | |
398 self.cparamsout.append("\tDBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &%s, %s_LEN" \ | |
399 % (name, name)) | |
400 self.addouttype("as", name) | |
401 else: | |
402 self.cdecls.append("\tdbus_int32_t *%s;" % name) | |
403 self.ccode.append("\t%s = gaim_dbusify_%s(%s, FALSE, &%s_LEN);" % \ | |
404 (name, type[0], self.call, name)) | |
405 self.cparamsout.append("\tDBUS_TYPE_ARRAY, DBUS_TYPE_INT32, &%s, %s_LEN" \ | |
406 % (name, name)) | |
407 self.addouttype("ai", name) | |
408 | |
409 | |
410 class BindingSet: | |
411 regexp = r"^(\w[^()]*)\(([^()]*)\)\s*;\s*$"; | |
412 | |
413 def __init__(self, inputfile, fprefix): | |
414 self.inputiter = iter(inputfile) | |
415 self.functionregexp = \ | |
416 re.compile("^%s(\w[^()]*)\(([^()]*)\)\s*;\s*$" % fprefix) | |
417 | |
418 | |
419 | |
420 def process(self): | |
421 print "/* Generated by %s. Do not edit! */" % sys.argv[0] | |
422 | |
423 for line in self.inputiter: | |
424 words = line.split() | |
425 if len(words) == 0: # empty line | |
426 continue | |
427 if line[0] == "#": # preprocessor directive | |
428 continue | |
429 if words[0] in ["typedef", "struct", "enum", "static"]: | |
430 continue | |
431 | |
432 # accumulate lines until the parentheses are balance or an | |
433 # empty line has been encountered | |
434 myline = line.strip() | |
435 while myline.count("(") > myline.count(")"): | |
436 newline = self.inputiter.next().strip() | |
437 if len(newline) == 0: | |
438 break | |
439 myline += " " + newline | |
440 | |
441 # is this a function declaration? | |
442 thematch = self.functionregexp.match( | |
443 myline.replace("*", " " + pointer + " ")) | |
444 | |
445 if thematch is None: | |
446 continue | |
447 | |
448 functiontext = thematch.group(1) | |
449 paramstext = thematch.group(2).strip() | |
450 | |
451 if (paramstext == "void") or (paramstext == ""): | |
452 paramtexts = [] | |
453 else: | |
454 paramtexts = paramstext.split(",") | |
455 | |
456 try: | |
457 self.processfunction(functiontext, paramtexts) | |
458 except myexception: | |
459 sys.stderr.write(myline + "\n") | |
460 except: | |
461 sys.stderr.write(myline + "\n") | |
462 raise | |
463 | |
464 self.flush() | |
465 | |
466 class ServerBindingSet (BindingSet): | |
467 def __init__(self, inputfile, fprefix): | |
468 BindingSet.__init__(self, inputfile, fprefix) | |
469 self.functions = [] | |
470 | |
471 | |
472 def processfunction(self, functiontext, paramtexts): | |
473 binding = ServerBinding(functiontext, paramtexts) | |
474 binding.process() | |
475 self.functions.append((binding.function.name, binding.dparams)) | |
476 | |
477 def flush(self): | |
478 print "static GaimDBusBinding bindings_DBUS[] = { " | |
479 for function, params in self.functions: | |
480 print '{"%s", "%s", %s_DBUS},' % \ | |
481 (ctopascal(function), params, function) | |
482 | |
483 print "{NULL, NULL, NULL}" | |
484 print "};" | |
485 | |
486 print "#define GAIM_DBUS_REGISTER_BINDINGS(handle) gaim_dbus_register_bindings(handle, bindings_DBUS)" | |
487 | |
488 class ClientBindingSet (BindingSet): | |
489 def __init__(self, inputfile, fprefix, headersonly): | |
490 BindingSet.__init__(self, inputfile, fprefix) | |
491 self.functions = [] | |
492 self.knowntypes = [] | |
493 self.headersonly = headersonly | |
494 | |
495 def processfunction(self, functiontext, paramtexts): | |
496 binding = ClientBinding(functiontext, paramtexts, self.knowntypes, self.headersonly) | |
497 binding.process() | |
498 | |
499 def flush(self): | |
500 pass | |
501 | |
502 # Main program | |
503 | |
504 options = {} | |
505 | |
506 for arg in sys.argv[1:]: | |
507 if arg[0:2] == "--": | |
508 mylist = arg[2:].split("=",1) | |
509 command = mylist[0] | |
510 if len(mylist) > 1: | |
511 options[command] = mylist[1] | |
512 else: | |
513 options[command] = None | |
514 | |
515 if "export-only" in options: | |
516 fprefix = "DBUS_EXPORT\s+" | |
517 else: | |
518 fprefix = "" | |
519 | |
520 sys.stderr.write("%s: Functions not exported:\n" % sys.argv[0]) | |
521 | |
522 if "client" in options: | |
523 bindings = ClientBindingSet(sys.stdin, fprefix, | |
524 options.has_key("headers")) | |
525 else: | |
526 bindings = ServerBindingSet(sys.stdin, fprefix) | |
527 bindings.process() | |
528 | |
529 | |
530 | |
531 |