?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Support explicit constructors for boolean, integer, and floating types
[vala-lang.git] / codegen / valadbusservermodule.vala
blob64de305af741ad56cbdadc77d2556930ce3cbc8d
1 /* valadbusservermodule.vala
2 *
3 * Copyright (C) 2007-2009 Jürg Billeter
4 * Copyright (C) 2008 Philip Van Hoof
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 *
20 * Author:
21 * Jürg Billeter <j@bitron.ch>
22 * Philip Van Hoof <pvanhoof@gnome.org>
23 */
24
25 using GLib;
26
27 /**
28 * The link between a dynamic method and generated code.
29 */
30 internal class Vala.DBusServerModule : DBusClientModule {
31 public DBusServerModule (CCodeGenerator codegen, CCodeModule? next) {
32 base (codegen, next);
33 }
34
35 bool is_dbus_visible (CodeNode node) {
36 var dbus_attribute = node.get_attribute ("DBus");
37 if (dbus_attribute != null
38 && dbus_attribute.has_argument ("visible")
39 && !dbus_attribute.get_bool ("visible")) {
40 return false;
41 }
42
43 return true;
44 }
45
46 string dbus_result_name (Method m) {
47 var dbus_attribute = m.get_attribute ("DBus");
48 if (dbus_attribute != null
49 && dbus_attribute.has_argument ("result")) {
50 var result_name = dbus_attribute.get_string ("result");
51 if (result_name != null && result_name != "") {
52 return result_name;
53 }
54 }
55
56 return "result";
57 }
58
59 void send_reply (CCodeBlock block) {
60 var ccall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_connection_send"));
61 ccall.add_argument (new CCodeIdentifier ("connection"));
62 ccall.add_argument (new CCodeIdentifier ("reply"));
63 ccall.add_argument (new CCodeConstant ("NULL"));
64 block.add_statement (new CCodeExpressionStatement (ccall));
65 ccall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_unref"));
66 ccall.add_argument (new CCodeIdentifier ("reply"));
67 block.add_statement (new CCodeExpressionStatement (ccall));
68 }
69
70 void handle_reply (CCodeBlock block) {
71 var handled = new CCodeBlock ();
72 send_reply (handled);
73 handled.add_statement (new CCodeReturnStatement (new CCodeIdentifier ("DBUS_HANDLER_RESULT_HANDLED")));
74
75 var not_handled = new CCodeBlock ();
76 not_handled.add_statement (new CCodeReturnStatement (new CCodeIdentifier ("DBUS_HANDLER_RESULT_NOT_YET_HANDLED")));
77
78 block.add_statement (new CCodeIfStatement (new CCodeIdentifier ("reply"), handled, not_handled));
79 }
80
81 string generate_dbus_wrapper (Method m, ObjectTypeSymbol sym) {
82 string wrapper_name = "_dbus_%s".printf (m.get_cname ());
83
84 // declaration
85
86 CCodeDeclaration cdecl;
87
88 var function = new CCodeFunction (wrapper_name, "DBusHandlerResult");
89 function.modifiers = CCodeModifiers.STATIC;
90 function.add_parameter (new CCodeFormalParameter ("self", sym.get_cname () + "*"));
91 function.add_parameter (new CCodeFormalParameter ("connection", "DBusConnection*"));
92 function.add_parameter (new CCodeFormalParameter ("message", "DBusMessage*"));
93 var block = new CCodeBlock ();
94
95 CCodeFunction ready_function = null;
96 CCodeBlock ready_block = null;
97 if (m.coroutine) {
98 // GAsyncResult
99 source_declarations.add_include ("gio/gio.h");
100
101 ready_function = new CCodeFunction (wrapper_name + "_ready", "void");
102 ready_function.modifiers = CCodeModifiers.STATIC;
103 ready_function.add_parameter (new CCodeFormalParameter ("source_object", "GObject *"));
104 ready_function.add_parameter (new CCodeFormalParameter ("_res_", "GAsyncResult *"));
105 ready_function.add_parameter (new CCodeFormalParameter ("_user_data_", "gpointer *"));
106 ready_block = new CCodeBlock ();
107
108 cdecl = new CCodeDeclaration ("DBusConnection *");
109 cdecl.add_declarator (new CCodeVariableDeclarator ("connection", new CCodeIdentifier ("_user_data_[0]")));
110 ready_block.add_statement (cdecl);
111 cdecl = new CCodeDeclaration ("DBusMessage *");
112 cdecl.add_declarator (new CCodeVariableDeclarator ("message", new CCodeIdentifier ("_user_data_[1]")));
113 ready_block.add_statement (cdecl);
114 }
115
116 var in_prefragment = new CCodeFragment ();
117 var in_postfragment = new CCodeFragment ();
118 var out_prefragment = in_prefragment;
119 var out_postfragment = in_postfragment;
120
121 cdecl = new CCodeDeclaration ("DBusMessageIter");
122 cdecl.add_declarator (new CCodeVariableDeclarator ("iter"));
123 block.add_statement (cdecl);
124 if (m.coroutine) {
125 out_prefragment = new CCodeFragment ();
126 out_postfragment = new CCodeFragment ();
127 ready_block.add_statement (cdecl);
128 }
129
130 cdecl = new CCodeDeclaration ("GError*");
131 cdecl.add_declarator (new CCodeVariableDeclarator ("error", new CCodeConstant ("NULL")));
132 if (m.coroutine) {
133 ready_block.add_statement (cdecl);
134 } else {
135 block.add_statement (cdecl);
136 }
137
138 block.add_statement (in_prefragment);
139 if (m.coroutine) {
140 ready_block.add_statement (out_prefragment);
141 }
142
143 var message_signature = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_get_signature"));
144 message_signature.add_argument (new CCodeIdentifier ("message"));
145 var signature_check = new CCodeFunctionCall (new CCodeIdentifier ("strcmp"));
146 signature_check.add_argument (message_signature);
147 var signature_error_block = new CCodeBlock ();
148 signature_error_block.add_statement (new CCodeReturnStatement (new CCodeIdentifier ("DBUS_HANDLER_RESULT_NOT_YET_HANDLED")));
149 in_prefragment.append (new CCodeIfStatement (signature_check, signature_error_block));
150
151 var iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_init"));
152 iter_call.add_argument (new CCodeIdentifier ("message"));
153 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("iter")));
154 in_prefragment.append (new CCodeExpressionStatement (iter_call));
155
156 cdecl = new CCodeDeclaration ("DBusMessage*");
157 cdecl.add_declarator (new CCodeVariableDeclarator ("reply"));
158 out_postfragment.append (cdecl);
159
160 var msgcall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_new_method_return"));
161 msgcall.add_argument (new CCodeIdentifier ("message"));
162 out_postfragment.append (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("reply"), msgcall)));
163
164 iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_init_append"));
165 iter_call.add_argument (new CCodeIdentifier ("reply"));
166 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("iter")));
167 out_postfragment.append (new CCodeExpressionStatement (iter_call));
168
169 var ccall = new CCodeFunctionCall (new CCodeIdentifier (m.get_cname ()));
170
171 CCodeFunctionCall finish_ccall = null;
172 if (m.coroutine) {
173 finish_ccall = new CCodeFunctionCall (new CCodeIdentifier (m.get_finish_cname ()));
174 finish_ccall.add_argument (new CCodeIdentifier ("source_object"));
175 finish_ccall.add_argument (new CCodeIdentifier ("_res_"));
176 }
177
178 ccall.add_argument (new CCodeIdentifier ("self"));
179
180 // expected type signature for input parameters
181 string type_signature = "";
182
183 foreach (FormalParameter param in m.get_parameters ()) {
184 var owned_type = param.parameter_type.copy ();
185 owned_type.value_owned = true;
186
187 cdecl = new CCodeDeclaration (owned_type.get_cname ());
188 cdecl.add_declarator (new CCodeVariableDeclarator.zero (param.name, default_value_for_type (param.parameter_type, true)));
189 if (param.direction == ParameterDirection.IN) {
190 in_prefragment.append (cdecl);
191 } else {
192 out_prefragment.append (cdecl);
193 }
194 if (type_signature == ""
195 && param.direction == ParameterDirection.IN
196 && param.parameter_type.data_type != null
197 && param.parameter_type.data_type.get_full_name () == "DBus.BusName") {
198 // first parameter is a string parameter called 'sender'
199 // pass bus name of sender
200 var get_sender = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_get_sender"));
201 get_sender.add_argument (new CCodeIdentifier ("message"));
202 ccall.add_argument (get_sender);
203 continue;
204 }
205
206 if (get_type_signature (param.parameter_type) == null) {
207 Report.error (param.parameter_type.source_reference, "D-Bus serialization of type `%s' is not supported".printf (param.parameter_type.to_string ()));
208 continue;
209 }
210
211 if (!m.coroutine || param.direction == ParameterDirection.IN) {
212 var st = param.parameter_type.data_type as Struct;
213 if (param.direction != ParameterDirection.IN
214 || (st != null && !st.is_simple_type ())) {
215 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (param.name)));
216 } else {
217 ccall.add_argument (new CCodeIdentifier (param.name));
218 }
219 } else {
220 finish_ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (param.name)));
221 }
222
223 if (param.parameter_type is ArrayType) {
224 var array_type = (ArrayType) param.parameter_type;
225
226 for (int dim = 1; dim <= array_type.rank; dim++) {
227 string length_cname = get_array_length_cname (param.name, dim);
228
229 cdecl = new CCodeDeclaration ("int");
230 cdecl.add_declarator (new CCodeVariableDeclarator (length_cname, new CCodeConstant ("0")));
231 if (!m.coroutine || param.direction == ParameterDirection.IN) {
232 if (param.direction != ParameterDirection.IN) {
233 out_prefragment.append (cdecl);
234 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (length_cname)));
235 } else {
236 in_prefragment.append (cdecl);
237 ccall.add_argument (new CCodeIdentifier (length_cname));
238 }
239 } else {
240 out_prefragment.append (cdecl);
241 finish_ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (length_cname)));
242 }
243 }
244 }
245
246 if (param.direction == ParameterDirection.IN) {
247 type_signature += get_type_signature (param.parameter_type);
248
249 var target = new CCodeIdentifier (param.name);
250 var expr = read_expression (in_prefragment, param.parameter_type, new CCodeIdentifier ("iter"), target);
251 in_prefragment.append (new CCodeExpressionStatement (new CCodeAssignment (target, expr)));
252 } else {
253 write_expression (out_postfragment, param.parameter_type, new CCodeIdentifier ("iter"), new CCodeIdentifier (param.name));
254 }
255
256 if (requires_destroy (owned_type)) {
257 // keep local alive (symbol_reference is weak)
258 var local = new LocalVariable (owned_type, param.name);
259 var ma = new MemberAccess.simple (param.name);
260 ma.symbol_reference = local;
261 var stmt = new CCodeExpressionStatement (get_unref_expression (new CCodeIdentifier (param.name), owned_type, ma));
262 if (param.direction == ParameterDirection.IN) {
263 in_postfragment.append (stmt);
264 } else {
265 out_postfragment.append (stmt);
266 }
267 }
268 }
269
270 signature_check.add_argument (new CCodeConstant ("\"%s\"".printf (type_signature)));
271
272 if (!(m.return_type is VoidType)) {
273 if (get_type_signature (m.return_type) == null) {
274 Report.error (m.return_type.source_reference, "D-Bus serialization of type `%s' is not supported".printf (m.return_type.to_string ()));
275 } else if (m.return_type.is_real_non_null_struct_type ()) {
276 cdecl = new CCodeDeclaration (m.return_type.get_cname ());
277 cdecl.add_declarator (new CCodeVariableDeclarator.zero ("result", default_value_for_type (m.return_type, true)));
278 out_prefragment.append (cdecl);
279
280 if (!m.coroutine) {
281 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("result")));
282 } else {
283 finish_ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("result")));
284 }
285
286 write_expression (out_postfragment, m.return_type, new CCodeIdentifier ("iter"), new CCodeIdentifier ("result"));
287
288 if (requires_destroy (m.return_type)) {
289 // keep local alive (symbol_reference is weak)
290 // space before `result' is work around to not trigger
291 // variable renaming, we really mean C identifier `result' here
292 var local = new LocalVariable (m.return_type, " result");
293 var ma = new MemberAccess.simple ("result");
294 ma.symbol_reference = local;
295 out_postfragment.append (new CCodeExpressionStatement (get_unref_expression (new CCodeIdentifier ("result"), m.return_type, ma)));
296 }
297
298 block.add_statement (new CCodeExpressionStatement (ccall));
299 if (m.coroutine) {
300 ready_block.add_statement (new CCodeExpressionStatement (finish_ccall));
301 }
302 } else {
303 cdecl = new CCodeDeclaration (m.return_type.get_cname ());
304 cdecl.add_declarator (new CCodeVariableDeclarator ("result"));
305 out_prefragment.append (cdecl);
306 if (!m.coroutine) {
307 block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("result"), ccall)));
308 } else {
309 block.add_statement (new CCodeExpressionStatement (ccall));
310 ready_block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("result"), finish_ccall)));
311 }
312
313 if (m.return_type is ArrayType) {
314 var array_type = (ArrayType) m.return_type;
315
316 for (int dim = 1; dim <= array_type.rank; dim++) {
317 string length_cname = get_array_length_cname ("result", dim);
318
319 cdecl = new CCodeDeclaration ("int");
320 cdecl.add_declarator (new CCodeVariableDeclarator (length_cname, new CCodeConstant ("0")));
321 out_prefragment.append (cdecl);
322 if (!m.coroutine) {
323 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (length_cname)));
324 } else {
325 finish_ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (length_cname)));
326 }
327 }
328 }
329
330 write_expression (out_postfragment, m.return_type, new CCodeIdentifier ("iter"), new CCodeIdentifier ("result"));
331
332 if (requires_destroy (m.return_type)) {
333 // keep local alive (symbol_reference is weak)
334 // space before `result' is work around to not trigger
335 // variable renaming, we really mean C identifier `result' here
336 var local = new LocalVariable (m.return_type, " result");
337 var ma = new MemberAccess.simple ("result");
338 ma.symbol_reference = local;
339 out_postfragment.append (new CCodeExpressionStatement (get_unref_expression (new CCodeIdentifier ("result"), m.return_type, ma)));
340 }
341 }
342 } else {
343 block.add_statement (new CCodeExpressionStatement (ccall));
344 if (m.coroutine) {
345 ready_block.add_statement (new CCodeExpressionStatement (finish_ccall));
346 }
347 }
348
349 if (m.coroutine) {
350 ccall.add_argument (new CCodeIdentifier (wrapper_name + "_ready"));
351
352 var new_call = new CCodeFunctionCall (new CCodeIdentifier ("g_new0"));
353 new_call.add_argument (new CCodeIdentifier ("gpointer"));
354 new_call.add_argument (new CCodeConstant ("2"));
355 cdecl = new CCodeDeclaration ("gpointer *");
356 cdecl.add_declarator (new CCodeVariableDeclarator ("_user_data_", new_call));
357 in_prefragment.append (cdecl);
358
359 var ref_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_connection_ref"));
360 ref_call.add_argument (new CCodeIdentifier ("connection"));
361 in_prefragment.append (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("_user_data_[0]"), ref_call)));
362 ref_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_ref"));
363 ref_call.add_argument (new CCodeIdentifier ("message"));
364 in_prefragment.append (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("_user_data_[1]"), ref_call)));
365
366 ccall.add_argument (new CCodeIdentifier ("_user_data_"));
367 }
368
369 if (m.get_error_types ().size > 0) {
370 if (m.coroutine) {
371 finish_ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("error")));
372 } else {
373 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("error")));
374 }
375
376 var error_block = new CCodeBlock ();
377
378 generate_server_error_cases (error_block, m.get_error_types (), new CCodeIdentifier ("error"), new CCodeIdentifier ("message"), new CCodeIdentifier ("reply"));
379
380 send_reply (error_block);
381
382 if (m.coroutine) {
383 error_block.add_statement (new CCodeReturnStatement ());
384 ready_block.add_statement (new CCodeIfStatement (new CCodeIdentifier ("error"), error_block));
385 } else {
386 error_block.add_statement (new CCodeReturnStatement (new CCodeIdentifier ("DBUS_HANDLER_RESULT_HANDLED")));
387 block.add_statement (new CCodeIfStatement (new CCodeIdentifier ("error"), error_block));
388 }
389 }
390
391 block.add_statement (in_postfragment);
392
393 if (!m.coroutine) {
394 handle_reply (block);
395 } else {
396 block.add_statement (new CCodeReturnStatement (new CCodeIdentifier ("DBUS_HANDLER_RESULT_HANDLED")));
397
398 ready_block.add_statement (out_postfragment);
399
400 send_reply (ready_block);
401
402 var unref_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_connection_unref"));
403 unref_call.add_argument (new CCodeIdentifier ("connection"));
404 ready_block.add_statement (new CCodeExpressionStatement (unref_call));
405 unref_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_unref"));
406 unref_call.add_argument (new CCodeIdentifier ("message"));
407 ready_block.add_statement (new CCodeExpressionStatement (unref_call));
408 var free_call = new CCodeFunctionCall (new CCodeIdentifier ("g_free"));
409 free_call.add_argument (new CCodeIdentifier ("_user_data_"));
410 ready_block.add_statement (new CCodeExpressionStatement (free_call));
411 }
412
413 source_declarations.add_type_member_declaration (function.copy ());
414
415 function.block = block;
416 source_type_member_definition.append (function);
417
418 if (m.coroutine) {
419 source_declarations.add_type_member_declaration (ready_function.copy ());
420
421 ready_function.block = ready_block;
422 source_type_member_definition.append (ready_function);
423 }
424
425 return wrapper_name;
426 }
427
428 void generate_server_error_cases (CCodeBlock error_block, List<DataType> error_types, CCodeExpression error, CCodeExpression message, CCodeExpression reply) {
429 CCodeStatement if_else_if = null;
430 CCodeIfStatement last_statement = null;
431
432 foreach (DataType error_type in error_types) {
433 var edomain = ((ErrorType) error_type).error_domain;
434
435 var edomain_dbus_name = get_dbus_name (edomain);
436 if (edomain_dbus_name == null) {
437 Report.error (edomain.source_reference, "Errordomain must have a DBus.name annotation to be serialized over DBus");
438 }
439
440 var true_block = new CCodeBlock ();
441 true_block.suppress_newline = true;
442
443 var cswitch = new CCodeSwitchStatement (new CCodeMemberAccess.pointer (error, "code"));
444 foreach (ErrorCode ecode in edomain.get_codes ()) {
445 cswitch.add_statement (new CCodeCaseStatement (new CCodeIdentifier (ecode.get_cname ())));
446
447 var ecode_dbus_name = get_dbus_name (ecode);
448 if (ecode_dbus_name == null) {
449 ecode_dbus_name = Symbol.lower_case_to_camel_case (ecode.name.down ());
450 }
451
452 string dbus_name = "%s.%s".printf (edomain_dbus_name, ecode_dbus_name);
453
454 var msgcall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_new_error"));
455 msgcall.add_argument (message);
456 msgcall.add_argument (new CCodeConstant ("\"%s\"".printf (dbus_name)));
457 msgcall.add_argument (new CCodeMemberAccess.pointer (error, "message"));
458 cswitch.add_statement (new CCodeExpressionStatement (new CCodeAssignment (reply, msgcall)));
459
460 cswitch.add_statement (new CCodeBreakStatement ());
461 }
462 true_block.add_statement (cswitch);
463
464 var equal_test = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, new CCodeMemberAccess.pointer (error, "domain"), new CCodeIdentifier (edomain.get_upper_case_cname ()));
465 var stmt = new CCodeIfStatement (equal_test, true_block);
466
467 if (last_statement != null) {
468 last_statement.false_statement = stmt;
469 } else {
470 if_else_if = stmt;
471 }
472 last_statement = stmt;
473 }
474 error_block.add_statement (if_else_if);
475 }
476
477 string generate_dbus_signal_wrapper (Signal sig, ObjectTypeSymbol sym, string dbus_iface_name) {
478 string wrapper_name = "_dbus_%s_%s".printf (sym.get_lower_case_cname (), sig.get_cname ());
479
480 // declaration
481
482 CCodeDeclaration cdecl;
483
484 var function = new CCodeFunction (wrapper_name, "void");
485 function.modifiers = CCodeModifiers.STATIC;
486
487 function.add_parameter (new CCodeFormalParameter ("_sender", "GObject*"));
488
489 foreach (var param in sig.get_parameters ()) {
490 // ensure ccodenode of parameter is set
491 generate_parameter (param, source_declarations, new HashMap<int,CCodeFormalParameter> (), null);
492
493 function.add_parameter ((CCodeFormalParameter) get_ccodenode (param));
494 if (param.parameter_type is ArrayType) {
495 var array_type = (ArrayType) param.parameter_type;
496 for (int dim = 1; dim <= array_type.rank; dim++) {
497 function.add_parameter (new CCodeFormalParameter (head.get_array_length_cname (param.name, dim), "int"));
498 }
499 }
500 }
501
502 function.add_parameter (new CCodeFormalParameter ("_connection", "DBusConnection*"));
503
504 var block = new CCodeBlock ();
505 var prefragment = new CCodeFragment ();
506
507 var path = new CCodeFunctionCall (new CCodeIdentifier ("g_object_get_data"));
508 path.add_argument (new CCodeIdentifier ("_sender"));
509 path.add_argument (new CCodeConstant ("\"dbus_object_path\""));
510
511 cdecl = new CCodeDeclaration ("const char *");
512 cdecl.add_declarator (new CCodeVariableDeclarator ("_path", path));
513 block.add_statement (cdecl);
514
515 cdecl = new CCodeDeclaration ("DBusMessage");
516 cdecl.add_declarator (new CCodeVariableDeclarator ("*_message"));
517 block.add_statement (cdecl);
518
519 cdecl = new CCodeDeclaration ("DBusMessageIter");
520 cdecl.add_declarator (new CCodeVariableDeclarator ("_iter"));
521 block.add_statement (cdecl);
522
523 block.add_statement (prefragment);
524
525 var msgcall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_new_signal"));
526 msgcall.add_argument (new CCodeIdentifier ("_path"));
527 msgcall.add_argument (new CCodeConstant ("\"%s\"".printf (dbus_iface_name)));
528 msgcall.add_argument (new CCodeConstant ("\"%s\"".printf (get_dbus_name_for_member (sig))));
529 prefragment.append (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("_message"), msgcall)));
530
531 var iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_init_append"));
532 iter_call.add_argument (new CCodeIdentifier ("_message"));
533 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_iter")));
534 prefragment.append (new CCodeExpressionStatement (iter_call));
535
536 foreach (FormalParameter param in sig.get_parameters ()) {
537 CCodeExpression expr = new CCodeIdentifier (param.name);
538 if (param.parameter_type.is_real_struct_type ()) {
539 expr = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, expr);
540 }
541 write_expression (prefragment, param.parameter_type, new CCodeIdentifier ("_iter"), expr);
542 }
543
544 var ccall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_connection_send"));
545 ccall.add_argument (new CCodeIdentifier ("_connection"));
546 ccall.add_argument (new CCodeIdentifier ("_message"));
547 ccall.add_argument (new CCodeConstant ("NULL"));
548 block.add_statement (new CCodeExpressionStatement (ccall));
549
550 var message_unref = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_unref"));
551 message_unref.add_argument (new CCodeIdentifier ("_message"));
552 block.add_statement (new CCodeExpressionStatement (message_unref));
553
554 source_declarations.add_type_member_declaration (function.copy ());
555 function.block = block;
556 source_type_member_definition.append (function);
557
558 return wrapper_name;
559 }
560
561 void generate_register_function (ObjectType object_type) {
562 var sym = object_type.type_symbol;
563
564 var cfunc = new CCodeFunction (sym.get_lower_case_cprefix () + "dbus_register_object", "void");
565 cfunc.add_parameter (new CCodeFormalParameter ("connection", "DBusConnection*"));
566 cfunc.add_parameter (new CCodeFormalParameter ("path", "const char*"));
567 cfunc.add_parameter (new CCodeFormalParameter ("object", "void*"));
568
569 if (!sym.is_private_symbol ()) {
570 dbus_glib_h_needed_in_header = true;
571 } else {
572 dbus_glib_h_needed = true;
573
574 cfunc.modifiers |= CCodeModifiers.STATIC;
575 }
576
577 source_declarations.add_type_member_declaration (cfunc.copy ());
578
579 var block = new CCodeBlock ();
580 cfunc.block = block;
581
582 var get_path = new CCodeFunctionCall (new CCodeIdentifier ("g_object_get_data"));
583 get_path.add_argument (new CCodeIdentifier ("object"));
584 get_path.add_argument (new CCodeConstant ("\"dbus_object_path\""));
585 var register_check = new CCodeUnaryExpression (CCodeUnaryOperator.LOGICAL_NEGATION, get_path);
586
587 var register_block = new CCodeBlock ();
588
589 var path_dup = new CCodeFunctionCall (new CCodeIdentifier ("g_strdup"));
590 path_dup.add_argument (new CCodeIdentifier ("path"));
591
592 var set_path = new CCodeFunctionCall (new CCodeIdentifier ("g_object_set_data"));
593 set_path.add_argument (new CCodeIdentifier ("object"));
594 set_path.add_argument (new CCodeConstant ("\"dbus_object_path\""));
595 set_path.add_argument (path_dup);
596 register_block.add_statement (new CCodeExpressionStatement (set_path));
597
598 var cregister = new CCodeFunctionCall (new CCodeIdentifier ("dbus_connection_register_object_path"));
599 cregister.add_argument (new CCodeIdentifier ("connection"));
600 cregister.add_argument (new CCodeIdentifier ("path"));
601 cregister.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_path_vtable (object_type)));
602 cregister.add_argument (new CCodeIdentifier ("object"));
603 register_block.add_statement (new CCodeExpressionStatement (cregister));
604
605 var weak_unregister = new CCodeFunctionCall (new CCodeIdentifier ("g_object_weak_ref"));
606 weak_unregister.add_argument (new CCodeIdentifier ("object"));
607 weak_unregister.add_argument (new CCodeIdentifier ("_vala_dbus_unregister_object"));
608 weak_unregister.add_argument (new CCodeIdentifier ("connection"));
609 register_block.add_statement (new CCodeExpressionStatement (weak_unregister));
610
611 block.add_statement (new CCodeIfStatement (register_check, register_block));
612
613 handle_signals (object_type.type_symbol, block);
614
615 var cl = sym as Class;
616 if (cl != null) {
617 foreach (DataType base_type in cl.get_base_types ()) {
618 var base_obj_type = base_type as ObjectType;
619 if (type_implements_dbus_interface (base_obj_type.type_symbol)) {
620 var base_register = new CCodeFunctionCall (new CCodeIdentifier (base_obj_type.type_symbol.get_lower_case_cprefix () + "dbus_register_object"));
621 base_register.add_argument (new CCodeIdentifier ("connection"));
622 base_register.add_argument (new CCodeIdentifier ("path"));
623 base_register.add_argument (new CCodeIdentifier ("object"));
624 block.add_statement (new CCodeExpressionStatement (base_register));
625 }
626 }
627 }
628
629 source_type_member_definition.append (cfunc);
630 }
631
632 void generate_unregister_function (ObjectType object_type) {
633 var sym = object_type.type_symbol;
634
635 var cfunc = new CCodeFunction ("_" + sym.get_lower_case_cprefix () + "dbus_unregister", "void");
636 cfunc.add_parameter (new CCodeFormalParameter ("connection", "DBusConnection*"));
637 cfunc.add_parameter (new CCodeFormalParameter ("_user_data_", "void*"));
638
639 source_declarations.add_type_member_declaration (cfunc.copy ());
640
641 var block = new CCodeBlock ();
642 cfunc.block = block;
643
644 source_type_member_definition.append (cfunc);
645 }
646
647 void handle_method (string dbus_iface_name, string dbus_method_name, string handler_name, CCodeBlock block, ref CCodeIfStatement clastif) {
648 var ccheck = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_is_method_call"));
649 ccheck.add_argument (new CCodeIdentifier ("message"));
650 ccheck.add_argument (new CCodeConstant ("\"%s\"".printf (dbus_iface_name)));
651 ccheck.add_argument (new CCodeConstant ("\"%s\"".printf (dbus_method_name)));
652
653 var callblock = new CCodeBlock ();
654
655 var ccall = new CCodeFunctionCall (new CCodeIdentifier (handler_name));
656 ccall.add_argument (new CCodeIdentifier ("object"));
657 ccall.add_argument (new CCodeIdentifier ("connection"));
658 ccall.add_argument (new CCodeIdentifier ("message"));
659
660 callblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("result"), ccall)));
661
662 var cif = new CCodeIfStatement (ccheck, callblock);
663 if (clastif == null) {
664 block.add_statement (cif);
665 } else {
666 clastif.false_statement = cif;
667 }
668
669 clastif = cif;
670 }
671
672 void handle_methods (ObjectTypeSymbol sym, string dbus_iface_name, CCodeBlock block, ref CCodeIfStatement clastif) {
673 foreach (Method m in sym.get_methods ()) {
674 if (m is CreationMethod || m.binding != MemberBinding.INSTANCE
675 || m.overrides || m.access != SymbolAccessibility.PUBLIC) {
676 continue;
677 }
678 if (!is_dbus_visible (m)) {
679 continue;
680 }
681
682 handle_method (dbus_iface_name, get_dbus_name_for_member (m), generate_dbus_wrapper (m, sym), block, ref clastif);
683 }
684 }
685
686 string generate_dbus_property_get_wrapper (ObjectTypeSymbol sym, string dbus_iface_name) {
687 string wrapper_name = "_dbus_%s_property_get".printf (sym.get_lower_case_cname ());
688
689 CCodeDeclaration cdecl;
690
691 var function = new CCodeFunction (wrapper_name, "DBusHandlerResult");
692 function.modifiers = CCodeModifiers.STATIC;
693
694 function.add_parameter (new CCodeFormalParameter ("self", sym.get_cname () + "*"));
695 function.add_parameter (new CCodeFormalParameter ("connection", "DBusConnection*"));
696 function.add_parameter (new CCodeFormalParameter ("message", "DBusMessage*"));
697
698 var block = new CCodeBlock ();
699 var prefragment = new CCodeFragment ();
700
701 cdecl = new CCodeDeclaration ("DBusMessage*");
702 cdecl.add_declarator (new CCodeVariableDeclarator ("reply"));
703 block.add_statement (cdecl);
704
705 cdecl = new CCodeDeclaration ("DBusMessageIter");
706 cdecl.add_declarator (new CCodeVariableDeclarator ("iter"));
707 cdecl.add_declarator (new CCodeVariableDeclarator ("reply_iter"));
708 cdecl.add_declarator (new CCodeVariableDeclarator ("subiter"));
709 block.add_statement (cdecl);
710
711 var message_signature = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_get_signature"));
712 message_signature.add_argument (new CCodeIdentifier ("message"));
713 var signature_check = new CCodeFunctionCall (new CCodeIdentifier ("strcmp"));
714 signature_check.add_argument (message_signature);
715 signature_check.add_argument (new CCodeConstant ("\"ss\""));
716 var signature_error_block = new CCodeBlock ();
717 signature_error_block.add_statement (new CCodeReturnStatement (new CCodeIdentifier ("DBUS_HANDLER_RESULT_NOT_YET_HANDLED")));
718 block.add_statement (new CCodeIfStatement (signature_check, signature_error_block));
719
720 var iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_init"));
721 iter_call.add_argument (new CCodeIdentifier ("message"));
722 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("iter")));
723 block.add_statement (new CCodeExpressionStatement (iter_call));
724
725 var msgcall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_new_method_return"));
726 msgcall.add_argument (new CCodeIdentifier ("message"));
727 block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("reply"), msgcall)));
728
729 iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_init_append"));
730 iter_call.add_argument (new CCodeIdentifier ("reply"));
731 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("reply_iter")));
732 block.add_statement (new CCodeExpressionStatement (iter_call));
733
734 block.add_statement (prefragment);
735
736 cdecl = new CCodeDeclaration ("char*");
737 cdecl.add_declarator (new CCodeVariableDeclarator ("interface_name"));
738 prefragment.append (cdecl);
739 var target = new CCodeIdentifier ("interface_name");
740 var expr = read_expression (prefragment, string_type, new CCodeIdentifier ("iter"), target);
741 prefragment.append (new CCodeExpressionStatement (new CCodeAssignment (target, expr)));
742
743 cdecl = new CCodeDeclaration ("char*");
744 cdecl.add_declarator (new CCodeVariableDeclarator ("property_name"));
745 prefragment.append (cdecl);
746 target = new CCodeIdentifier ("property_name");
747 expr = read_expression (prefragment, string_type, new CCodeIdentifier ("iter"), target);
748 prefragment.append (new CCodeExpressionStatement (new CCodeAssignment (target, expr)));
749
750 CCodeIfStatement clastif = null;
751
752 foreach (Property prop in sym.get_properties ()) {
753 if (prop.binding != MemberBinding.INSTANCE
754 || prop.overrides || prop.access != SymbolAccessibility.PUBLIC) {
755 continue;
756 }
757 if (!is_dbus_visible (prop)) {
758 continue;
759 }
760 if (prop.get_accessor == null) {
761 continue;
762 }
763
764 var prop_block = new CCodeBlock ();
765 var postfragment = new CCodeFragment ();
766 prop_block.add_statement (postfragment);
767
768 var ccmp = new CCodeFunctionCall (new CCodeIdentifier ("strcmp"));
769 ccmp.add_argument (new CCodeIdentifier ("interface_name"));
770 ccmp.add_argument (new CCodeConstant ("\"%s\"".printf (dbus_iface_name)));
771 var ccheck1 = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, ccmp, new CCodeConstant ("0"));
772
773 ccmp = new CCodeFunctionCall (new CCodeIdentifier ("strcmp"));
774 ccmp.add_argument (new CCodeIdentifier ("property_name"));
775 ccmp.add_argument (new CCodeConstant ("\"%s\"".printf (get_dbus_name_for_member (prop))));
776 var ccheck2 = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, ccmp, new CCodeConstant ("0"));
777
778 var ccheck = new CCodeBinaryExpression (CCodeBinaryOperator.AND, ccheck1, ccheck2);
779
780 iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_open_container"));
781 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("reply_iter")));
782 iter_call.add_argument (new CCodeIdentifier ("DBUS_TYPE_VARIANT"));
783 iter_call.add_argument (new CCodeConstant ("\"%s\"".printf (get_type_signature (prop.property_type))));
784 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("subiter")));
785 postfragment.append (new CCodeExpressionStatement (iter_call));
786
787 var ccall = new CCodeFunctionCall (new CCodeIdentifier (prop.get_accessor.get_cname ()));
788 ccall.add_argument (new CCodeIdentifier ("self"));
789
790 cdecl = new CCodeDeclaration (prop.property_type.get_cname ());
791 cdecl.add_declarator (new CCodeVariableDeclarator ("result"));
792 postfragment.append (cdecl);
793
794 if (prop.property_type.is_real_non_null_struct_type ()) {
795 // structs are returned via out parameter
796 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("result")));
797
798 postfragment.append (new CCodeExpressionStatement (ccall));
799 } else {
800 postfragment.append (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("result"), ccall)));
801
802 var array_type = prop.property_type as ArrayType;
803 if (array_type != null) {
804 for (int dim = 1; dim <= array_type.rank; dim++) {
805 string length_cname = get_array_length_cname ("result", dim);
806
807 cdecl = new CCodeDeclaration ("int");
808 cdecl.add_declarator (new CCodeVariableDeclarator (length_cname));
809 postfragment.append (cdecl);
810
811 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (length_cname)));
812 }
813 }
814 }
815
816 write_expression (postfragment, prop.property_type, new CCodeIdentifier ("subiter"), new CCodeIdentifier ("result"));
817
818 if (requires_destroy (prop.get_accessor.value_type)) {
819 // keep local alive (symbol_reference is weak)
820 // space before `result' is work around to not trigger
821 // variable renaming, we really mean C identifier `result' here
822 var local = new LocalVariable (prop.get_accessor.value_type, " result");
823 var ma = new MemberAccess.simple ("result");
824 ma.symbol_reference = local;
825 postfragment.append (new CCodeExpressionStatement (get_unref_expression (new CCodeIdentifier ("result"), prop.get_accessor.value_type, ma)));
826 }
827
828 iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_close_container"));
829 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("reply_iter")));
830 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("subiter")));
831 postfragment.append (new CCodeExpressionStatement (iter_call));
832
833 var cif = new CCodeIfStatement (ccheck, prop_block);
834 if (clastif == null) {
835 block.add_statement (cif);
836 } else {
837 clastif.false_statement = cif;
838 }
839
840 clastif = cif;
841 }
842
843 // free interface_name and property_name
844 var free_call = new CCodeFunctionCall (new CCodeIdentifier ("g_free"));
845 free_call.add_argument (new CCodeIdentifier ("interface_name"));
846 block.add_statement (new CCodeExpressionStatement (free_call));
847
848 free_call = new CCodeFunctionCall (new CCodeIdentifier ("g_free"));
849 free_call.add_argument (new CCodeIdentifier ("property_name"));
850 block.add_statement (new CCodeExpressionStatement (free_call));
851
852 if (clastif == null) {
853 block = new CCodeBlock ();
854 block.add_statement (new CCodeReturnStatement (new CCodeConstant ("NULL")));
855 } else {
856 var else_block = new CCodeBlock ();
857 var unref_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_unref"));
858 unref_call.add_argument (new CCodeIdentifier ("reply"));
859 else_block.add_statement (new CCodeExpressionStatement (unref_call));
860 else_block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("reply"), new CCodeConstant ("NULL"))));
861 clastif.false_statement = else_block;
862
863 handle_reply (block);
864 }
865
866 source_declarations.add_type_member_declaration (function.copy ());
867
868 function.block = block;
869 source_type_member_definition.append (function);
870
871 return wrapper_name;
872 }
873
874 string generate_dbus_property_get_all_wrapper (ObjectTypeSymbol sym, string dbus_iface_name) {
875 string wrapper_name = "_dbus_%s_property_get_all".printf (sym.get_lower_case_cname ());
876
877 bool has_readable_properties = false;
878 foreach (Property prop in sym.get_properties ()) {
879 if (prop.binding != MemberBinding.INSTANCE
880 || prop.overrides || prop.access != SymbolAccessibility.PUBLIC) {
881 continue;
882 }
883 if (!is_dbus_visible (prop)) {
884 continue;
885 }
886 if (prop.get_accessor != null) {
887 has_readable_properties = true;
888 }
889 }
890
891 CCodeDeclaration cdecl;
892
893 var function = new CCodeFunction (wrapper_name, "DBusHandlerResult");
894 function.modifiers = CCodeModifiers.STATIC;
895
896 function.add_parameter (new CCodeFormalParameter ("self", sym.get_cname () + "*"));
897 function.add_parameter (new CCodeFormalParameter ("connection", "DBusConnection*"));
898 function.add_parameter (new CCodeFormalParameter ("message", "DBusMessage*"));
899
900 var block = new CCodeBlock ();
901 var prefragment = new CCodeFragment ();
902
903 cdecl = new CCodeDeclaration ("DBusMessage*");
904 cdecl.add_declarator (new CCodeVariableDeclarator ("reply"));
905 block.add_statement (cdecl);
906
907 cdecl = new CCodeDeclaration ("DBusMessageIter");
908 cdecl.add_declarator (new CCodeVariableDeclarator ("iter"));
909 cdecl.add_declarator (new CCodeVariableDeclarator ("reply_iter"));
910 cdecl.add_declarator (new CCodeVariableDeclarator ("subiter"));
911 if (has_readable_properties) {
912 cdecl.add_declarator (new CCodeVariableDeclarator ("entry_iter"));
913 cdecl.add_declarator (new CCodeVariableDeclarator ("value_iter"));
914 }
915 block.add_statement (cdecl);
916
917 var message_signature = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_get_signature"));
918 message_signature.add_argument (new CCodeIdentifier ("message"));
919 var signature_check = new CCodeFunctionCall (new CCodeIdentifier ("strcmp"));
920 signature_check.add_argument (message_signature);
921 signature_check.add_argument (new CCodeConstant ("\"s\""));
922 var signature_error_block = new CCodeBlock ();
923 signature_error_block.add_statement (new CCodeReturnStatement (new CCodeIdentifier ("DBUS_HANDLER_RESULT_NOT_YET_HANDLED")));
924 block.add_statement (new CCodeIfStatement (signature_check, signature_error_block));
925
926 var iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_init"));
927 iter_call.add_argument (new CCodeIdentifier ("message"));
928 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("iter")));
929 block.add_statement (new CCodeExpressionStatement (iter_call));
930
931 var msgcall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_new_method_return"));
932 msgcall.add_argument (new CCodeIdentifier ("message"));
933 block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("reply"), msgcall)));
934
935 iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_init_append"));
936 iter_call.add_argument (new CCodeIdentifier ("reply"));
937 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("reply_iter")));
938 block.add_statement (new CCodeExpressionStatement (iter_call));
939
940 block.add_statement (prefragment);
941
942 cdecl = new CCodeDeclaration ("char*");
943 cdecl.add_declarator (new CCodeVariableDeclarator ("interface_name"));
944 prefragment.append (cdecl);
945 var target = new CCodeIdentifier ("interface_name");
946 var expr = read_expression (prefragment, string_type, new CCodeIdentifier ("iter"), target);
947 prefragment.append (new CCodeExpressionStatement (new CCodeAssignment (target, expr)));
948
949 if (has_readable_properties) {
950 cdecl = new CCodeDeclaration ("const char*");
951 cdecl.add_declarator (new CCodeVariableDeclarator ("property_name"));
952 prefragment.append (cdecl);
953 }
954
955 var prop_block = new CCodeBlock ();
956
957 iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_open_container"));
958 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("reply_iter")));
959 iter_call.add_argument (new CCodeIdentifier ("DBUS_TYPE_ARRAY"));
960 iter_call.add_argument (new CCodeConstant ("\"{sv}\""));
961 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("subiter")));
962 prop_block.add_statement (new CCodeExpressionStatement (iter_call));
963
964 foreach (Property prop in sym.get_properties ()) {
965 if (prop.binding != MemberBinding.INSTANCE
966 || prop.overrides || prop.access != SymbolAccessibility.PUBLIC) {
967 continue;
968 }
969 if (!is_dbus_visible (prop)) {
970 continue;
971 }
972 if (prop.get_accessor == null) {
973 continue;
974 }
975
976 var inner_block = new CCodeBlock ();
977 prop_block.add_statement (inner_block);
978 var postfragment = new CCodeFragment ();
979 inner_block.add_statement (postfragment);
980
981 iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_open_container"));
982 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("subiter")));
983 iter_call.add_argument (new CCodeIdentifier ("DBUS_TYPE_DICT_ENTRY"));
984 iter_call.add_argument (new CCodeConstant ("NULL"));
985 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("entry_iter")));
986 postfragment.append (new CCodeExpressionStatement (iter_call));
987
988 postfragment.append (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("property_name"), new CCodeConstant ("\"%s\"".printf (get_dbus_name_for_member (prop))))));
989
990 iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_append_basic"));
991 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("entry_iter")));
992 iter_call.add_argument (new CCodeIdentifier ("DBUS_TYPE_STRING"));
993 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("property_name")));
994 postfragment.append (new CCodeExpressionStatement (iter_call));
995
996 iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_open_container"));
997 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("entry_iter")));
998 iter_call.add_argument (new CCodeIdentifier ("DBUS_TYPE_VARIANT"));
999 iter_call.add_argument (new CCodeConstant ("\"%s\"".printf (get_type_signature (prop.property_type))));
1000 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("value_iter")));
1001 postfragment.append (new CCodeExpressionStatement (iter_call));
1002
1003 var ccall = new CCodeFunctionCall (new CCodeIdentifier (prop.get_accessor.get_cname ()));
1004 ccall.add_argument (new CCodeIdentifier ("self"));
1005
1006 cdecl = new CCodeDeclaration (prop.property_type.get_cname ());
1007 cdecl.add_declarator (new CCodeVariableDeclarator ("result"));
1008 postfragment.append (cdecl);
1009
1010 if (prop.property_type.is_real_non_null_struct_type ()) {
1011 // structs are returned via out parameter
1012 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("result")));
1013
1014 postfragment.append (new CCodeExpressionStatement (ccall));
1015 } else {
1016 postfragment.append (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("result"), ccall)));
1017
1018 var array_type = prop.property_type as ArrayType;
1019 if (array_type != null) {
1020 for (int dim = 1; dim <= array_type.rank; dim++) {
1021 string length_cname = get_array_length_cname ("result", dim);
1022
1023 cdecl = new CCodeDeclaration ("int");
1024 cdecl.add_declarator (new CCodeVariableDeclarator (length_cname));
1025 postfragment.append (cdecl);
1026
1027 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (length_cname)));
1028 }
1029 }
1030 }
1031
1032 write_expression (postfragment, prop.property_type, new CCodeIdentifier ("value_iter"), new CCodeIdentifier ("result"));
1033
1034 if (requires_destroy (prop.get_accessor.value_type)) {
1035 // keep local alive (symbol_reference is weak)
1036 // space before `result' is work around to not trigger
1037 // variable renaming, we really mean C identifier `result' here
1038 var local = new LocalVariable (prop.get_accessor.value_type, " result");
1039 var ma = new MemberAccess.simple ("result");
1040 ma.symbol_reference = local;
1041 postfragment.append (new CCodeExpressionStatement (get_unref_expression (new CCodeIdentifier ("result"), prop.get_accessor.value_type, ma)));
1042 }
1043
1044 iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_close_container"));
1045 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("entry_iter")));
1046 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("value_iter")));
1047 postfragment.append (new CCodeExpressionStatement (iter_call));
1048
1049 iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_close_container"));
1050 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("subiter")));
1051 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("entry_iter")));
1052 postfragment.append (new CCodeExpressionStatement (iter_call));
1053 }
1054
1055 iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_close_container"));
1056 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("reply_iter")));
1057 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("subiter")));
1058 prop_block.add_statement (new CCodeExpressionStatement (iter_call));
1059
1060 var ccmp = new CCodeFunctionCall (new CCodeIdentifier ("strcmp"));
1061 ccmp.add_argument (new CCodeIdentifier ("interface_name"));
1062 ccmp.add_argument (new CCodeConstant ("\"%s\"".printf (dbus_iface_name)));
1063 var ccheck = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, ccmp, new CCodeConstant ("0"));
1064
1065 var else_block = new CCodeBlock ();
1066 var unref_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_unref"));
1067 unref_call.add_argument (new CCodeIdentifier ("reply"));
1068 else_block.add_statement (new CCodeExpressionStatement (unref_call));
1069 else_block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("reply"), new CCodeConstant ("NULL"))));
1070
1071 block.add_statement (new CCodeIfStatement (ccheck, prop_block, else_block));
1072
1073 // free interface_name
1074 var free_call = new CCodeFunctionCall (new CCodeIdentifier ("g_free"));
1075 free_call.add_argument (new CCodeIdentifier ("interface_name"));
1076 block.add_statement (new CCodeExpressionStatement (free_call));
1077
1078 handle_reply (block);
1079
1080 source_declarations.add_type_member_declaration (function.copy ());
1081
1082 function.block = block;
1083 source_type_member_definition.append (function);
1084
1085 return wrapper_name;
1086 }
1087
1088 string generate_dbus_property_set_wrapper (ObjectTypeSymbol sym, string dbus_iface_name) {
1089 string wrapper_name = "_dbus_%s_property_set".printf (sym.get_lower_case_cname ());
1090
1091 var function = new CCodeFunction (wrapper_name, "DBusHandlerResult");
1092 function.modifiers = CCodeModifiers.STATIC;
1093
1094 function.add_parameter (new CCodeFormalParameter ("self", sym.get_cname () + "*"));
1095 function.add_parameter (new CCodeFormalParameter ("connection", "DBusConnection*"));
1096 function.add_parameter (new CCodeFormalParameter ("message", "DBusMessage*"));
1097
1098 var block = new CCodeBlock ();
1099 var prefragment = new CCodeFragment ();
1100
1101 var cdecl = new CCodeDeclaration ("DBusMessage*");
1102 cdecl.add_declarator (new CCodeVariableDeclarator ("reply"));
1103 block.add_statement (cdecl);
1104
1105 cdecl = new CCodeDeclaration ("DBusMessageIter");
1106 cdecl.add_declarator (new CCodeVariableDeclarator ("iter"));
1107 cdecl.add_declarator (new CCodeVariableDeclarator ("subiter"));
1108 block.add_statement (cdecl);
1109
1110 var message_signature = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_get_signature"));
1111 message_signature.add_argument (new CCodeIdentifier ("message"));
1112 var signature_check = new CCodeFunctionCall (new CCodeIdentifier ("strcmp"));
1113 signature_check.add_argument (message_signature);
1114 signature_check.add_argument (new CCodeConstant ("\"ssv\""));
1115 var signature_error_block = new CCodeBlock ();
1116 signature_error_block.add_statement (new CCodeReturnStatement (new CCodeIdentifier ("DBUS_HANDLER_RESULT_NOT_YET_HANDLED")));
1117 block.add_statement (new CCodeIfStatement (signature_check, signature_error_block));
1118
1119 var iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_init"));
1120 iter_call.add_argument (new CCodeIdentifier ("message"));
1121 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("iter")));
1122 block.add_statement (new CCodeExpressionStatement (iter_call));
1123
1124 var msgcall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_new_method_return"));
1125 msgcall.add_argument (new CCodeIdentifier ("message"));
1126 block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("reply"), msgcall)));
1127
1128 block.add_statement (prefragment);
1129
1130 cdecl = new CCodeDeclaration ("char*");
1131 cdecl.add_declarator (new CCodeVariableDeclarator ("interface_name"));
1132 prefragment.append (cdecl);
1133 var target = new CCodeIdentifier ("interface_name");
1134 var expr = read_expression (prefragment, string_type, new CCodeIdentifier ("iter"), target);
1135 prefragment.append (new CCodeExpressionStatement (new CCodeAssignment (target, expr)));
1136
1137 cdecl = new CCodeDeclaration ("char*");
1138 cdecl.add_declarator (new CCodeVariableDeclarator ("property_name"));
1139 prefragment.append (cdecl);
1140 target = new CCodeIdentifier ("property_name");
1141 expr = read_expression (prefragment, string_type, new CCodeIdentifier ("iter"), target);
1142 prefragment.append (new CCodeExpressionStatement (new CCodeAssignment (target, expr)));
1143
1144 iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_recurse"));
1145 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("iter")));
1146 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("subiter")));
1147 prefragment.append (new CCodeExpressionStatement (iter_call));
1148
1149 CCodeIfStatement clastif = null;
1150
1151 foreach (Property prop in sym.get_properties ()) {
1152 if (prop.binding != MemberBinding.INSTANCE
1153 || prop.overrides || prop.access != SymbolAccessibility.PUBLIC) {
1154 continue;
1155 }
1156 if (!is_dbus_visible (prop)) {
1157 continue;
1158 }
1159 if (prop.set_accessor == null) {
1160 continue;
1161 }
1162
1163 var prop_block = new CCodeBlock ();
1164 prefragment = new CCodeFragment ();
1165 prop_block.add_statement (prefragment);
1166
1167 var ccmp = new CCodeFunctionCall (new CCodeIdentifier ("strcmp"));
1168 ccmp.add_argument (new CCodeIdentifier ("interface_name"));
1169 ccmp.add_argument (new CCodeConstant ("\"%s\"".printf (dbus_iface_name)));
1170 var ccheck1 = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, ccmp, new CCodeConstant ("0"));
1171
1172 ccmp = new CCodeFunctionCall (new CCodeIdentifier ("strcmp"));
1173 ccmp.add_argument (new CCodeIdentifier ("property_name"));
1174 ccmp.add_argument (new CCodeConstant ("\"%s\"".printf (get_dbus_name_for_member (prop))));
1175 var ccheck2 = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, ccmp, new CCodeConstant ("0"));
1176
1177 var ccheck = new CCodeBinaryExpression (CCodeBinaryOperator.AND, ccheck1, ccheck2);
1178
1179 var owned_type = prop.property_type.copy ();
1180 owned_type.value_owned = true;
1181
1182 cdecl = new CCodeDeclaration (owned_type.get_cname ());
1183 cdecl.add_declarator (new CCodeVariableDeclarator ("value"));
1184 prefragment.append (cdecl);
1185
1186 target = new CCodeIdentifier ("value");
1187 expr = read_expression (prefragment, prop.property_type, new CCodeIdentifier ("subiter"), target);
1188 prefragment.append (new CCodeExpressionStatement (new CCodeAssignment (target, expr)));
1189
1190 var ccall = new CCodeFunctionCall (new CCodeIdentifier (prop.set_accessor.get_cname ()));
1191 ccall.add_argument (new CCodeIdentifier ("self"));
1192
1193 if (prop.property_type.is_real_non_null_struct_type ()) {
1194 // structs are passed by reference
1195 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("value")));
1196 } else {
1197 ccall.add_argument (new CCodeIdentifier ("value"));
1198
1199 var array_type = prop.property_type as ArrayType;
1200 if (array_type != null) {
1201 for (int dim = 1; dim <= array_type.rank; dim++) {
1202 cdecl = new CCodeDeclaration ("int");
1203 cdecl.add_declarator (new CCodeVariableDeclarator (head.get_array_length_cname ("value", dim)));
1204 prefragment.append (cdecl);
1205
1206 ccall.add_argument (new CCodeIdentifier (head.get_array_length_cname ("value", dim)));
1207 }
1208 }
1209 }
1210
1211 prop_block.add_statement (new CCodeExpressionStatement (ccall));
1212
1213 if (requires_destroy (owned_type)) {
1214 // keep local alive (symbol_reference is weak)
1215 var local = new LocalVariable (owned_type, "value");
1216 var ma = new MemberAccess.simple ("value");
1217 ma.symbol_reference = local;
1218 prop_block.add_statement (new CCodeExpressionStatement (get_unref_expression (new CCodeIdentifier ("value"), owned_type, ma)));
1219 }
1220
1221 var cif = new CCodeIfStatement (ccheck, prop_block);
1222 if (clastif == null) {
1223 block.add_statement (cif);
1224 } else {
1225 clastif.false_statement = cif;
1226 }
1227
1228 clastif = cif;
1229 }
1230
1231 // free interface_name and property_name
1232 var free_call = new CCodeFunctionCall (new CCodeIdentifier ("g_free"));
1233 free_call.add_argument (new CCodeIdentifier ("interface_name"));
1234 block.add_statement (new CCodeExpressionStatement (free_call));
1235
1236 free_call = new CCodeFunctionCall (new CCodeIdentifier ("g_free"));
1237 free_call.add_argument (new CCodeIdentifier ("property_name"));
1238 block.add_statement (new CCodeExpressionStatement (free_call));
1239
1240 if (clastif == null) {
1241 block = new CCodeBlock ();
1242 block.add_statement (new CCodeReturnStatement (new CCodeConstant ("NULL")));
1243 } else {
1244 var else_block = new CCodeBlock ();
1245 var unref_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_unref"));
1246 unref_call.add_argument (new CCodeIdentifier ("reply"));
1247 else_block.add_statement (new CCodeExpressionStatement (unref_call));
1248 else_block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("reply"), new CCodeIdentifier ("NULL"))));
1249 clastif.false_statement = else_block;
1250
1251 handle_reply (block);
1252 }
1253
1254 source_declarations.add_type_member_declaration (function.copy ());
1255
1256 function.block = block;
1257 source_type_member_definition.append (function);
1258
1259 return wrapper_name;
1260 }
1261
1262 string get_dbus_type_introspection (ObjectTypeSymbol sym) {
1263 string result = "";
1264
1265 var cl = sym as Class;
1266 if (cl != null) {
1267 foreach (DataType base_type in cl.get_base_types ()) {
1268 var base_obj_type = base_type as ObjectType;
1269 result += get_dbus_type_introspection (base_obj_type.type_symbol);
1270 }
1271 }
1272
1273 string dbus_iface_name = get_dbus_name (sym);
1274 if (dbus_iface_name == null) {
1275 return result;
1276 }
1277
1278 result += "<interface name=\"%s\">\n".printf (dbus_iface_name);
1279
1280 foreach (var m in sym.get_methods ()) {
1281 if (m is CreationMethod || m.binding != MemberBinding.INSTANCE
1282 || m.overrides || m.access != SymbolAccessibility.PUBLIC) {
1283 continue;
1284 }
1285 if (!is_dbus_visible (m)) {
1286 continue;
1287 }
1288
1289 result += " <method name=\"%s\">\n".printf (get_dbus_name_for_member (m));
1290
1291 foreach (var param in m.get_parameters ()) {
1292 if (param.parameter_type.data_type != null
1293 && param.parameter_type.data_type.get_full_name () == "DBus.BusName") {
1294 // skip sender parameter
1295 // (implicit in D-Bus)
1296 continue;
1297 }
1298
1299 string direction = param.direction == ParameterDirection.IN ? "in" : "out";
1300 result += " <arg name=\"%s\" type=\"%s\" direction=\"%s\"/>\n".printf (param.name, get_type_signature (param.parameter_type), direction);
1301 }
1302 if (!(m.return_type is VoidType)) {
1303 result += " <arg name=\"%s\" type=\"%s\" direction=\"out\"/>\n".printf (dbus_result_name (m), get_type_signature (m.return_type));
1304 }
1305
1306 result += " </method>\n";
1307 }
1308
1309 foreach (var prop in sym.get_properties ()) {
1310 if (prop.binding != MemberBinding.INSTANCE
1311 || prop.overrides || prop.access != SymbolAccessibility.PUBLIC) {
1312 continue;
1313 }
1314 if (!is_dbus_visible (prop)) {
1315 continue;
1316 }
1317
1318 string access = (prop.get_accessor != null ? "read" : "") + (prop.set_accessor != null ? "write" : "");
1319 result += " <property name=\"%s\" type=\"%s\" access=\"%s\"/>\n".printf (get_dbus_name_for_member (prop), get_type_signature (prop.property_type), access);
1320 }
1321
1322 foreach (var sig in sym.get_signals ()) {
1323 if (sig.access != SymbolAccessibility.PUBLIC) {
1324 continue;
1325 }
1326 if (!is_dbus_visible (sig)) {
1327 continue;
1328 }
1329
1330 result += " <signal name=\"%s\">\n".printf (get_dbus_name_for_member (sig));
1331
1332 foreach (var param in sig.get_parameters ()) {
1333 result += " <arg name=\"%s\" type=\"%s\"/>\n".printf (param.name, get_type_signature (param.parameter_type));
1334 }
1335
1336 result += " </signal>\n";
1337 }
1338
1339 result += "</interface>\n";
1340
1341 return result;
1342 }
1343
1344 string generate_dbus_introspect (ObjectTypeSymbol sym) {
1345 string wrapper_name = "_dbus_%s_introspect".printf (sym.get_lower_case_cname ());
1346
1347 var function = new CCodeFunction (wrapper_name, "DBusHandlerResult");
1348 function.modifiers = CCodeModifiers.STATIC;
1349
1350 function.add_parameter (new CCodeFormalParameter ("self", sym.get_cname () + "*"));
1351 function.add_parameter (new CCodeFormalParameter ("connection", "DBusConnection*"));
1352 function.add_parameter (new CCodeFormalParameter ("message", "DBusMessage*"));
1353
1354 var block = new CCodeBlock ();
1355
1356 var cdecl = new CCodeDeclaration ("DBusMessage*");
1357 cdecl.add_declarator (new CCodeVariableDeclarator ("reply"));
1358 block.add_statement (cdecl);
1359
1360 cdecl = new CCodeDeclaration ("DBusMessageIter");
1361 cdecl.add_declarator (new CCodeVariableDeclarator ("iter"));
1362 block.add_statement (cdecl);
1363
1364 var msgcall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_new_method_return"));
1365 msgcall.add_argument (new CCodeIdentifier ("message"));
1366 block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("reply"), msgcall)));
1367
1368 var iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_init_append"));
1369 iter_call.add_argument (new CCodeIdentifier ("reply"));
1370 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("iter")));
1371 block.add_statement (new CCodeExpressionStatement (iter_call));
1372
1373 cdecl = new CCodeDeclaration ("GString*");
1374 cdecl.add_declarator (new CCodeVariableDeclarator ("xml_data"));
1375 block.add_statement (cdecl);
1376
1377 cdecl = new CCodeDeclaration ("char**");
1378 cdecl.add_declarator (new CCodeVariableDeclarator ("children"));
1379 block.add_statement (cdecl);
1380
1381 cdecl = new CCodeDeclaration ("int");
1382 cdecl.add_declarator (new CCodeVariableDeclarator ("i"));
1383 block.add_statement (cdecl);
1384
1385 string xml_data = "<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\" \"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n";
1386 var str_call = new CCodeFunctionCall (new CCodeIdentifier ("g_string_new"));
1387 str_call.add_argument (new CCodeConstant ("\"%s\"".printf (xml_data.escape (""))));
1388 block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("xml_data"), str_call)));
1389
1390 xml_data = "<node>\n";
1391 xml_data +=
1392 """<interface name="org.freedesktop.DBus.Introspectable">
1393 <method name="Introspect">
1394 <arg name="data" direction="out" type="s"/>
1395 </method>
1396 </interface>
1397 <interface name="org.freedesktop.DBus.Properties">
1398 <method name="Get">
1399 <arg name="interface" direction="in" type="s"/>
1400 <arg name="propname" direction="in" type="s"/>
1401 <arg name="value" direction="out" type="v"/>
1402 </method>
1403 <method name="Set">
1404 <arg name="interface" direction="in" type="s"/>
1405 <arg name="propname" direction="in" type="s"/>
1406 <arg name="value" direction="in" type="v"/>
1407 </method>
1408 <method name="GetAll">
1409 <arg name="interface" direction="in" type="s"/>
1410 <arg name="props" direction="out" type="a{sv}"/>
1411 </method>
1412 </interface>
1413 """;
1414 xml_data += get_dbus_type_introspection (sym);
1415 str_call = new CCodeFunctionCall (new CCodeIdentifier ("g_string_append"));
1416 str_call.add_argument (new CCodeIdentifier ("xml_data"));
1417 str_call.add_argument (new CCodeConstant ("\"%s\"".printf (xml_data.escape (""))));
1418 block.add_statement (new CCodeExpressionStatement (str_call));
1419
1420 var get_path = new CCodeFunctionCall (new CCodeIdentifier ("g_object_get_data"));
1421 get_path.add_argument (new CCodeCastExpression (new CCodeIdentifier ("self"), "GObject *"));
1422 get_path.add_argument (new CCodeConstant ("\"dbus_object_path\""));
1423
1424 var list_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_connection_list_registered"));
1425 list_call.add_argument (new CCodeIdentifier ("connection"));
1426 list_call.add_argument (get_path);
1427 list_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("children")));
1428 block.add_statement (new CCodeExpressionStatement (list_call));
1429
1430 // add child nodes
1431 var child_block = new CCodeBlock ();
1432 str_call = new CCodeFunctionCall (new CCodeIdentifier ("g_string_append_printf"));
1433 str_call.add_argument (new CCodeIdentifier ("xml_data"));
1434 str_call.add_argument (new CCodeConstant ("\"%s\"".printf ("<node name=\"%s\"/>\n".escape (""))));
1435 str_call.add_argument (new CCodeElementAccess (new CCodeIdentifier ("children"), new CCodeIdentifier ("i")));
1436 child_block.add_statement (new CCodeExpressionStatement (str_call));
1437 var cfor = new CCodeForStatement (new CCodeElementAccess (new CCodeIdentifier ("children"), new CCodeIdentifier ("i")), child_block);
1438 cfor.add_initializer (new CCodeAssignment (new CCodeIdentifier ("i"), new CCodeConstant ("0")));
1439 cfor.add_iterator (new CCodeUnaryExpression (CCodeUnaryOperator.POSTFIX_INCREMENT, new CCodeIdentifier ("i")));
1440 block.add_statement (cfor);
1441
1442 var list_free_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_free_string_array"));
1443 list_free_call.add_argument (new CCodeIdentifier ("children"));
1444 block.add_statement (new CCodeExpressionStatement (list_free_call));
1445
1446 xml_data = "</node>\n";
1447 str_call = new CCodeFunctionCall (new CCodeIdentifier ("g_string_append"));
1448 str_call.add_argument (new CCodeIdentifier ("xml_data"));
1449 str_call.add_argument (new CCodeConstant ("\"%s\"".printf (xml_data.escape (""))));
1450 block.add_statement (new CCodeExpressionStatement (str_call));
1451
1452 iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_append_basic"));
1453 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("iter")));
1454 iter_call.add_argument (new CCodeIdentifier ("DBUS_TYPE_STRING"));
1455 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeMemberAccess.pointer (new CCodeIdentifier ("xml_data"), "str")));
1456 block.add_statement (new CCodeExpressionStatement (iter_call));
1457
1458 str_call = new CCodeFunctionCall (new CCodeIdentifier ("g_string_free"));
1459 str_call.add_argument (new CCodeIdentifier ("xml_data"));
1460 str_call.add_argument (new CCodeConstant ("TRUE"));
1461 block.add_statement (new CCodeExpressionStatement (str_call));
1462
1463 handle_reply (block);
1464
1465 source_declarations.add_type_member_declaration (function.copy ());
1466
1467 function.block = block;
1468 source_type_member_definition.append (function);
1469
1470 return wrapper_name;
1471 }
1472
1473 void handle_signals (ObjectTypeSymbol sym, CCodeBlock block) {
1474 string dbus_iface_name = get_dbus_name (sym);
1475 if (dbus_iface_name == null) {
1476 return;
1477 }
1478
1479 foreach (Signal sig in sym.get_signals ()) {
1480 if (sig.access != SymbolAccessibility.PUBLIC) {
1481 continue;
1482 }
1483 if (!is_dbus_visible (sig)) {
1484 continue;
1485 }
1486
1487 var connect = new CCodeFunctionCall (new CCodeIdentifier ("g_signal_connect"));
1488 connect.add_argument (new CCodeIdentifier ("object"));
1489 connect.add_argument (sig.get_canonical_cconstant (null));
1490 connect.add_argument (new CCodeCastExpression (new CCodeIdentifier (generate_dbus_signal_wrapper (sig, sym, dbus_iface_name)), "GCallback"));
1491 connect.add_argument (new CCodeIdentifier ("connection"));
1492 block.add_statement (new CCodeExpressionStatement (connect));
1493 }
1494 }
1495
1496 void generate_message_function (ObjectType object_type) {
1497 var sym = object_type.type_symbol;
1498
1499 dbus_glib_h_needed = true;
1500
1501 var cfunc = new CCodeFunction (sym.get_lower_case_cprefix () + "dbus_message", "DBusHandlerResult");
1502 cfunc.add_parameter (new CCodeFormalParameter ("connection", "DBusConnection*"));
1503 cfunc.add_parameter (new CCodeFormalParameter ("message", "DBusMessage*"));
1504 cfunc.add_parameter (new CCodeFormalParameter ("object", "void*"));
1505
1506 if (sym.is_private_symbol ()) {
1507 cfunc.modifiers |= CCodeModifiers.STATIC;
1508 }
1509
1510 source_declarations.add_type_member_declaration (cfunc.copy ());
1511
1512 var block = new CCodeBlock ();
1513 cfunc.block = block;
1514
1515 var cdecl = new CCodeDeclaration ("DBusHandlerResult");
1516 cdecl.add_declarator (new CCodeVariableDeclarator ("result", new CCodeConstant ("DBUS_HANDLER_RESULT_NOT_YET_HANDLED")));
1517 block.add_statement (cdecl);
1518
1519 CCodeIfStatement clastif = null;
1520
1521 handle_method ("org.freedesktop.DBus.Introspectable", "Introspect", generate_dbus_introspect (sym), block, ref clastif);
1522
1523 string dbus_iface_name = get_dbus_name (sym);
1524 if (dbus_iface_name != null) {
1525 bool need_property_get = false;
1526 bool need_property_set = false;
1527 foreach (Property prop in sym.get_properties ()) {
1528 if (prop.binding != MemberBinding.INSTANCE
1529 || prop.overrides || prop.access != SymbolAccessibility.PUBLIC) {
1530 continue;
1531 }
1532 if (!is_dbus_visible (prop)) {
1533 continue;
1534 }
1535 if (prop.get_accessor != null) {
1536 need_property_get = true;
1537 }
1538 if (prop.set_accessor != null) {
1539 need_property_set = true;
1540 }
1541 }
1542
1543 if (need_property_get) {
1544 handle_method ("org.freedesktop.DBus.Properties", "Get", generate_dbus_property_get_wrapper (sym, dbus_iface_name), block, ref clastif);
1545 }
1546 if (need_property_set) {
1547 handle_method ("org.freedesktop.DBus.Properties", "Set", generate_dbus_property_set_wrapper (sym, dbus_iface_name), block, ref clastif);
1548 }
1549 handle_method ("org.freedesktop.DBus.Properties", "GetAll", generate_dbus_property_get_all_wrapper (sym, dbus_iface_name), block, ref clastif);
1550
1551 handle_methods (sym, dbus_iface_name, block, ref clastif);
1552 }
1553
1554 var resultblock = new CCodeBlock ();
1555 resultblock.add_statement (new CCodeReturnStatement (new CCodeIdentifier ("result")));
1556 var cif = new CCodeIfStatement (new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, new CCodeIdentifier ("result"), new CCodeIdentifier ("DBUS_HANDLER_RESULT_HANDLED")), resultblock);
1557 block.add_statement (cif);
1558 clastif = cif;
1559
1560 var cl = sym as Class;
1561 if (cl != null) {
1562 foreach (DataType base_type in cl.get_base_types ()) {
1563 var base_obj_type = base_type as ObjectType;
1564 if (type_implements_dbus_interface (base_obj_type.type_symbol)) {
1565 var base_call = new CCodeFunctionCall (new CCodeIdentifier (base_obj_type.type_symbol.get_lower_case_cprefix () + "dbus_message"));
1566 base_call.add_argument (new CCodeIdentifier ("connection"));
1567 base_call.add_argument (new CCodeIdentifier ("message"));
1568 base_call.add_argument (new CCodeIdentifier ("object"));
1569
1570 var ccheck = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, base_call, new CCodeIdentifier ("DBUS_HANDLER_RESULT_HANDLED"));
1571
1572 var base_block = new CCodeBlock ();
1573 base_block.add_statement (new CCodeReturnStatement (new CCodeIdentifier ("DBUS_HANDLER_RESULT_HANDLED")));
1574
1575 cif = new CCodeIfStatement (ccheck, base_block);
1576 clastif.false_statement = cif;
1577
1578 clastif = cif;
1579 }
1580 }
1581 }
1582
1583 var retblock = new CCodeBlock ();
1584 retblock.add_statement (new CCodeReturnStatement (new CCodeIdentifier ("DBUS_HANDLER_RESULT_NOT_YET_HANDLED")));
1585 clastif.false_statement = retblock;
1586
1587 source_type_member_definition.append (cfunc);
1588 }
1589
1590 CCodeExpression get_vtable (ObjectType object_type) {
1591 var sym = object_type.type_symbol;
1592
1593 var vtable = new CCodeInitializerList ();
1594 vtable.append (new CCodeIdentifier (sym.get_lower_case_cprefix () + "dbus_register_object"));
1595
1596 generate_register_function (object_type);
1597
1598 var cdecl = new CCodeDeclaration ("const _DBusObjectVTable");
1599 cdecl.add_declarator (new CCodeVariableDeclarator ("_" + sym.get_lower_case_cprefix () + "dbus_vtable", vtable));
1600 cdecl.modifiers = CCodeModifiers.STATIC;
1601 source_declarations.add_constant_declaration (cdecl);
1602
1603 return new CCodeIdentifier ("_" + sym.get_lower_case_cprefix () + "dbus_vtable");
1604 }
1605
1606 CCodeExpression get_path_vtable (ObjectType object_type) {
1607 var sym = object_type.type_symbol;
1608
1609 var vtable = new CCodeInitializerList ();
1610 vtable.append (new CCodeIdentifier ("_" + sym.get_lower_case_cprefix () + "dbus_unregister"));
1611 vtable.append (new CCodeIdentifier (sym.get_lower_case_cprefix () + "dbus_message"));
1612
1613 generate_unregister_function (object_type);
1614 generate_message_function (object_type);
1615
1616 var cdecl = new CCodeDeclaration ("const DBusObjectPathVTable");
1617 cdecl.add_declarator (new CCodeVariableDeclarator ("_" + sym.get_lower_case_cprefix () + "dbus_path_vtable", vtable));
1618 cdecl.modifiers = CCodeModifiers.STATIC;
1619 source_declarations.add_constant_declaration (cdecl);
1620
1621 return new CCodeIdentifier ("_" + sym.get_lower_case_cprefix () + "dbus_path_vtable");
1622 }
1623
1624 public override void visit_method_call (MethodCall expr) {
1625 var mtype = expr.call.value_type as MethodType;
1626 if (mtype == null || (mtype.method_symbol.get_cname () != "dbus_connection_register_g_object" &&
1627 mtype.method_symbol.get_cname () != "dbus_g_connection_register_g_object")) {
1628 base.visit_method_call (expr);
1629 return;
1630 }
1631
1632 dbus_glib_h_needed = true;
1633
1634 expr.accept_children (codegen);
1635
1636 var ma = (MemberAccess) expr.call;
1637
1638 var raw_conn = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_connection_get_connection"));
1639 raw_conn.add_argument ((CCodeExpression) ma.inner.ccodenode);
1640
1641 var args_it = expr.get_argument_list ().iterator ();
1642 args_it.next ();
1643 var path_arg = args_it.get ();
1644 args_it.next ();
1645 var obj_arg = args_it.get ();
1646
1647 var cregister = new CCodeFunctionCall (new CCodeIdentifier ("_vala_dbus_register_object"));
1648 if (mtype.method_symbol.get_cname () == "dbus_g_connection_register_g_object") {
1649 cregister.add_argument (raw_conn);
1650 } else {
1651 cregister.add_argument ((CCodeExpression) ma.inner.ccodenode);
1652 }
1653 cregister.add_argument ((CCodeExpression) path_arg.ccodenode);
1654 cregister.add_argument ((CCodeExpression) obj_arg.ccodenode);
1655 expr.ccodenode = cregister;
1656 }
1657
1658 bool type_implements_dbus_interface (ObjectTypeSymbol sym) {
1659 var dbus = sym.get_attribute ("DBus");
1660 if (dbus != null) {
1661 return true;
1662 }
1663
1664 var cl = sym as Class;
1665 if (cl != null) {
1666 foreach (DataType base_type in cl.get_base_types ()) {
1667 var base_obj_type = base_type as ObjectType;
1668 if (type_implements_dbus_interface (base_obj_type.type_symbol)) {
1669 return true;
1670 }
1671 }
1672 }
1673
1674 return false;
1675 }
1676
1677 public override CCodeFragment register_dbus_info (ObjectTypeSymbol sym) {
1678 CCodeFragment fragment = new CCodeFragment ();
1679
1680 if (!type_implements_dbus_interface (sym)) {
1681 return fragment;
1682 }
1683
1684 var quark = new CCodeFunctionCall (new CCodeIdentifier ("g_quark_from_static_string"));
1685 quark.add_argument (new CCodeConstant ("\"DBusObjectVTable\""));
1686
1687 var set_qdata = new CCodeFunctionCall (new CCodeIdentifier ("g_type_set_qdata"));
1688 set_qdata.add_argument (new CCodeIdentifier (sym.get_upper_case_cname ("TYPE_")));
1689 set_qdata.add_argument (quark);
1690 set_qdata.add_argument (new CCodeCastExpression (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_vtable (new ObjectType (sym))), "void*"));
1691
1692 fragment.append (new CCodeExpressionStatement (set_qdata));
1693
1694 return fragment;
1695 }
1696 }
vala-lang from freesmartphone.org