?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mx-1.0: Remove abstract for several Draggable and Droppable methods
[vala-lang.git] / codegen / valadbusclientmodule.vala
blob1e22c0646e065cfe98f0aff460115a066f647fd4
1 /* valadbusclientmodule.vala
2 *
3 * Copyright (C) 2007-2010 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 public class Vala.DBusClientModule : DBusModule {
31 int dynamic_property_id;
32
33 string get_dynamic_dbus_name (string vala_name) {
34 // TODO switch default to no transformation as soon as we have static D-Bus client support
35 // keep transformation by default for static D-Bus client and server support
36 if (context.dbus_transformation) {
37 return Symbol.lower_case_to_camel_case (vala_name);
38 } else {
39 return vala_name;
40 }
41 }
42
43 public CCodeConstant get_dbus_timeout (Symbol symbol) {
44 int timeout = -1;
45
46 var dbus = symbol.get_attribute ("DBus");
47 if (dbus != null && dbus.has_argument ("timeout")) {
48 timeout = dbus.get_integer ("timeout");
49 } else if (symbol.parent_symbol != null) {
50 return get_dbus_timeout (symbol.parent_symbol);
51 }
52
53 return new CCodeConstant (timeout.to_string ());
54 }
55
56 public static bool is_dbus_no_reply (CodeNode node) {
57 var dbus_attribute = node.get_attribute ("DBus");
58 if (dbus_attribute != null
59 && dbus_attribute.has_argument ("no_reply")
60 && dbus_attribute.get_bool ("no_reply")) {
61 return true;
62 }
63
64 return false;
65 }
66
67 bool has_dbus_error (List<DataType> error_types) {
68 foreach (DataType error_type in error_types) {
69 if (((ErrorType) error_type).error_domain.get_full_name () == "DBus.Error") {
70 return true;
71 }
72 }
73 return false;
74 }
75
76 public override void generate_dynamic_method_wrapper (DynamicMethod method) {
77 var dynamic_method = (DynamicMethod) method;
78
79 var func = new CCodeFunction (method.get_cname ());
80 func.modifiers = CCodeModifiers.STATIC;
81
82 var cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
83
84 generate_cparameters (method, cfile, cparam_map, func);
85
86 var block = new CCodeBlock ();
87 if (dynamic_method.dynamic_type.data_type == dbus_object_type) {
88 generate_dbus_method_wrapper (method, block);
89 } else {
90 Report.error (method.source_reference, "dynamic methods are not supported for `%s'".printf (dynamic_method.dynamic_type.to_string ()));
91 }
92
93 // append to C source file
94 cfile.add_function_declaration (func);
95
96 func.block = block;
97 cfile.add_function (func);
98 }
99
100 void generate_dbus_method_wrapper (Method method, CCodeBlock block) {
101 var dynamic_method = (DynamicMethod) method;
102
103 var expr = dynamic_method.invocation;
104
105 var ccall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_proxy_begin_call"));
106
107 ccall.add_argument (new CCodeIdentifier ("self"));
108
109 bool found_out = false;
110 Expression callback = null;
111 int callback_index = -1;
112 int arg_index = 1;
113 foreach (Expression arg in expr.get_argument_list ()) {
114 if (arg.symbol_reference is Method) {
115 // callback
116 if (callback != null) {
117 Report.error (expr.source_reference, "only one reply callback may be specified in invocation of DBus method");
118 expr.error = true;
119 return;
120 } else if (found_out) {
121 Report.error (expr.source_reference, "out argument and reply callback conflict in invocation of DBus method");
122 expr.error = true;
123 return;
124 }
125 callback = arg;
126 callback_index = arg_index;
127 } else if (arg is UnaryExpression && ((UnaryExpression) arg).operator == UnaryOperator.OUT) {
128 // out arg
129 if (callback != null) {
130 Report.error (expr.source_reference, "out argument and reply callback conflict in invocation of DBus method");
131 expr.error = true;
132 return;
133 }
134 found_out = true;
135 } else {
136 // in arg
137 if (callback != null || found_out) {
138 Report.error (expr.source_reference, "in argument must not follow out argument or reply callback in invocation of DBus method");
139 expr.error = true;
140 return;
141 }
142 }
143 arg_index++;
144 }
145
146 ccall.add_argument (new CCodeConstant ("\"%s\"".printf (get_dynamic_dbus_name (method.name))));
147
148 if (callback != null) {
149 var reply_method = (Method) callback.symbol_reference;
150
151 var cb_fun = new CCodeFunction ("_%s_cb".printf (reply_method.get_cname ()), "void");
152 cb_fun.modifiers = CCodeModifiers.STATIC;
153 cb_fun.add_parameter (new CCodeParameter ("proxy", "DBusGProxy*"));
154 cb_fun.add_parameter (new CCodeParameter ("call", "DBusGProxyCall*"));
155 cb_fun.add_parameter (new CCodeParameter ("user_data", "void*"));
156 cb_fun.block = new CCodeBlock ();
157 var cerrdecl = new CCodeDeclaration ("GError*");
158 cerrdecl.add_declarator (new CCodeVariableDeclarator ("error", new CCodeConstant ("NULL")));
159 cb_fun.block.add_statement (cerrdecl);
160 var cend_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_proxy_end_call"));
161 cend_call.add_argument (new CCodeIdentifier ("proxy"));
162 cend_call.add_argument (new CCodeIdentifier ("call"));
163 cend_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("error")));
164 var creply_call = new CCodeFunctionCall (get_cvalue (callback));
165 if (reply_method.binding != MemberBinding.STATIC) {
166 creply_call.add_argument (new CCodeIdentifier ("user_data"));
167 }
168 int param_count = reply_method.get_parameters ().size;
169 int i = 0;
170 foreach (Parameter param in reply_method.get_parameters ()) {
171 if ((++i) == param_count) {
172 if (!(param.variable_type is ErrorType)) {
173 Report.error (null, "DBus reply callbacks must end with GLib.Error argument");
174 return;
175 }
176
177 break;
178 }
179 if (param.variable_type is ArrayType && ((ArrayType) param.variable_type).element_type.data_type != string_type.data_type) {
180 var array_type = (ArrayType) param.variable_type;
181 CCodeDeclaration cdecl;
182 if (dbus_use_ptr_array (array_type)) {
183 cdecl = new CCodeDeclaration ("GPtrArray*");
184 } else {
185 cdecl = new CCodeDeclaration ("GArray*");
186 }
187 cdecl.add_declarator (new CCodeVariableDeclarator (param.name));
188 cb_fun.block.add_statement (cdecl);
189 cend_call.add_argument (get_dbus_g_type (array_type));
190 cend_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (param.name)));
191 creply_call.add_argument (new CCodeCastExpression (new CCodeMemberAccess.pointer (new CCodeIdentifier (param.name), dbus_use_ptr_array (array_type) ? "pdata" : "data"), array_type.get_cname ()));
192 creply_call.add_argument (new CCodeMemberAccess.pointer (new CCodeIdentifier (param.name), "len"));
193 } else {
194 var cdecl = new CCodeDeclaration (param.variable_type.get_cname ());
195 cdecl.add_declarator (new CCodeVariableDeclarator (param.name));
196 cb_fun.block.add_statement (cdecl);
197 cend_call.add_argument (get_dbus_g_type (param.variable_type));
198 cend_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (param.name)));
199 creply_call.add_argument (new CCodeIdentifier (param.name));
200
201 if (param.variable_type is ArrayType && ((ArrayType) param.variable_type).element_type.data_type == string_type.data_type) {
202 var cstrvlen = new CCodeFunctionCall (new CCodeIdentifier ("g_strv_length"));
203 cstrvlen.add_argument (new CCodeIdentifier (param.name));
204 creply_call.add_argument (cstrvlen);
205 }
206
207 }
208 }
209 cend_call.add_argument (new CCodeIdentifier ("G_TYPE_INVALID"));
210 cb_fun.block.add_statement (new CCodeExpressionStatement (cend_call));
211 creply_call.add_argument (new CCodeIdentifier ("error"));
212 cb_fun.block.add_statement (new CCodeExpressionStatement (creply_call));
213
214 CCodeExpression target = new CCodeConstant ("param%d_target".printf (callback_index));
215 var ma = (MemberAccess) callback;
216 if (reply_method.binding != MemberBinding.STATIC && ma.inner.value_type.data_type != null && ma.inner.value_type.data_type.is_reference_counting ()) {
217 // unref user_data after creply_call
218 var unref_call = new CCodeFunctionCall (get_destroy_func_expression (ma.inner.value_type));
219 unref_call.add_argument (new CCodeIdentifier ("user_data"));
220 cb_fun.block.add_statement (new CCodeExpressionStatement (unref_call));
221
222 // ref target for ccall
223 var ref_call = new CCodeFunctionCall (get_dup_func_expression (ma.inner.value_type, callback.source_reference));
224 ref_call.add_argument (target);
225 target = ref_call;
226 }
227
228 if (!cfile.add_declaration (cb_fun.name)) {
229 // avoid duplicate function definition
230 cfile.add_function (cb_fun);
231 }
232
233 ccall.add_argument (new CCodeIdentifier (cb_fun.name));
234 ccall.add_argument (target);
235 ccall.add_argument (new CCodeConstant ("NULL"));
236 } else {
237 ccall.call = new CCodeIdentifier ("dbus_g_proxy_call");
238
239 ccall.add_argument (new CCodeIdentifier ("error"));
240 }
241
242 foreach (Parameter param in method.get_parameters ()) {
243 if (param.variable_type is MethodType
244 || param.variable_type is DelegateType) {
245 // callback parameter
246 break;
247 }
248
249 if (param.direction != ParameterDirection.IN) {
250 continue;
251 }
252
253 var array_type = param.variable_type as ArrayType;
254 if (array_type != null) {
255 // array parameter
256 if (array_type.element_type.data_type != string_type.data_type) {
257 // non-string arrays (use GArray)
258 ccall.add_argument (get_dbus_g_type (array_type));
259
260 var sizeof_call = new CCodeFunctionCall (new CCodeIdentifier ("sizeof"));
261 sizeof_call.add_argument (new CCodeIdentifier (array_type.element_type.get_cname ()));
262
263 CCodeDeclaration cdecl;
264 CCodeFunctionCall array_construct;
265 if (dbus_use_ptr_array (array_type)) {
266 cdecl = new CCodeDeclaration ("GPtrArray*");
267
268 array_construct = new CCodeFunctionCall (new CCodeIdentifier ("g_ptr_array_sized_new"));
269 array_construct.add_argument (new CCodeIdentifier (get_parameter_array_length_cname (param, 1)));
270 } else {
271 cdecl = new CCodeDeclaration ("GArray*");
272
273 array_construct = new CCodeFunctionCall (new CCodeIdentifier ("g_array_new"));
274 array_construct.add_argument (new CCodeConstant ("TRUE"));
275 array_construct.add_argument (new CCodeConstant ("TRUE"));
276 array_construct.add_argument (sizeof_call);
277 }
278
279 cdecl.add_declarator (new CCodeVariableDeclarator ("dbus_%s".printf (param.name), array_construct));
280 block.add_statement (cdecl);
281
282 if (dbus_use_ptr_array (array_type)) {
283 cfile.add_include ("string.h");
284
285 var memcpy_call = new CCodeFunctionCall (new CCodeIdentifier ("memcpy"));
286 memcpy_call.add_argument (new CCodeMemberAccess.pointer (new CCodeIdentifier ("dbus_%s".printf (param.name)), "pdata"));
287 memcpy_call.add_argument (new CCodeIdentifier (param.name));
288 memcpy_call.add_argument (new CCodeBinaryExpression (CCodeBinaryOperator.MUL, new CCodeIdentifier (get_parameter_array_length_cname (param, 1)), sizeof_call));
289 block.add_statement (new CCodeExpressionStatement (memcpy_call));
290
291 var len_assignment = new CCodeAssignment (new CCodeMemberAccess.pointer (new CCodeIdentifier ("dbus_%s".printf (param.name)), "len"), new CCodeIdentifier (get_parameter_array_length_cname (param, 1)));
292 block.add_statement (new CCodeExpressionStatement (len_assignment));
293 } else {
294 var cappend_call = new CCodeFunctionCall (new CCodeIdentifier ("g_array_append_vals"));
295 cappend_call.add_argument (new CCodeIdentifier ("dbus_%s".printf (param.name)));
296 cappend_call.add_argument (new CCodeIdentifier (param.name));
297 cappend_call.add_argument (new CCodeIdentifier (get_parameter_array_length_cname (param, 1)));
298 block.add_statement (new CCodeExpressionStatement (cappend_call));
299 }
300
301 ccall.add_argument (new CCodeIdentifier ("dbus_%s".printf (param.name)));
302 } else {
303 // string arrays
304 ccall.add_argument (new CCodeIdentifier ("G_TYPE_STRV"));
305 ccall.add_argument (new CCodeIdentifier (param.name));
306 }
307 } else if (get_type_signature (param.variable_type).has_prefix ("(")) {
308 // struct parameter
309 var st = (Struct) param.variable_type.data_type;
310
311 var array_construct = new CCodeFunctionCall (new CCodeIdentifier ("g_value_array_new"));
312 array_construct.add_argument (new CCodeConstant ("0"));
313
314 var cdecl = new CCodeDeclaration ("GValueArray*");
315 cdecl.add_declarator (new CCodeVariableDeclarator ("dbus_%s".printf (param.name), array_construct));
316 block.add_statement (cdecl);
317
318 foreach (Field f in st.get_fields ()) {
319 if (f.binding != MemberBinding.INSTANCE) {
320 continue;
321 }
322
323 string val_name = "val_%s_%s".printf (param.name, f.name);
324
325 // 0-initialize struct with struct initializer { 0 }
326 var cvalinit = new CCodeInitializerList ();
327 cvalinit.append (new CCodeConstant ("0"));
328
329 var cval_decl = new CCodeDeclaration ("GValue");
330 cval_decl.add_declarator (new CCodeVariableDeclarator.zero (val_name, cvalinit));
331 block.add_statement (cval_decl);
332
333 var val_ptr = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (val_name));
334
335 var cinit_call = new CCodeFunctionCall (new CCodeIdentifier ("g_value_init"));
336 cinit_call.add_argument (val_ptr);
337 cinit_call.add_argument (new CCodeIdentifier (f.variable_type.data_type.get_type_id ()));
338 block.add_statement (new CCodeExpressionStatement (cinit_call));
339
340 var cset_call = new CCodeFunctionCall (new CCodeIdentifier (f.variable_type.data_type.get_set_value_function ()));
341 cset_call.add_argument (val_ptr);
342 cset_call.add_argument (new CCodeMemberAccess.pointer (new CCodeIdentifier (param.name), f.name));
343 block.add_statement (new CCodeExpressionStatement (cset_call));
344
345 var cappend_call = new CCodeFunctionCall (new CCodeIdentifier ("g_value_array_append"));
346 cappend_call.add_argument (new CCodeIdentifier ("dbus_%s".printf (param.name)));
347 cappend_call.add_argument (val_ptr);
348 block.add_statement (new CCodeExpressionStatement (cappend_call));
349 }
350
351 ccall.add_argument (get_dbus_g_type (param.variable_type));
352 ccall.add_argument (new CCodeIdentifier ("dbus_%s".printf (param.name)));
353 } else {
354 ccall.add_argument (get_dbus_g_type (param.variable_type));
355 ccall.add_argument (new CCodeIdentifier (param.name));
356 }
357 }
358
359 ccall.add_argument (new CCodeIdentifier ("G_TYPE_INVALID"));
360
361 var out_marshalling_fragment = new CCodeFragment ();
362
363 foreach (Parameter param in method.get_parameters ()) {
364 if (param.variable_type is MethodType) {
365 // callback parameter
366 break;
367 }
368
369 if (param.direction != ParameterDirection.OUT) {
370 continue;
371 }
372
373 if (get_type_signature (param.variable_type).has_prefix ("(")) {
374 // struct output parameter
375 var st = (Struct) param.variable_type.data_type;
376
377 var cdecl = new CCodeDeclaration ("GValueArray*");
378 cdecl.add_declarator (new CCodeVariableDeclarator ("dbus_%s".printf (param.name)));
379 block.add_statement (cdecl);
380
381 int i = 0;
382 foreach (Field f in st.get_fields ()) {
383 if (f.binding != MemberBinding.INSTANCE) {
384 continue;
385 }
386
387 var cget_call = new CCodeFunctionCall (new CCodeIdentifier (f.variable_type.data_type.get_get_value_function ()));
388 cget_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeElementAccess (new CCodeMemberAccess.pointer (new CCodeIdentifier ("dbus_%s".printf (param.name)), "values"), new CCodeConstant (i.to_string ()))));
389
390 var converted_value = cget_call;
391
392 if (requires_copy (f.variable_type)) {
393 var dupexpr = get_dup_func_expression (f.variable_type, expr.source_reference);
394 converted_value = new CCodeFunctionCall (dupexpr);
395 converted_value.add_argument (cget_call);
396 }
397
398 var assign = new CCodeAssignment (new CCodeMemberAccess.pointer (new CCodeIdentifier (param.name), f.name), converted_value);
399 out_marshalling_fragment.append (new CCodeExpressionStatement (assign));
400
401 i++;
402 }
403
404 ccall.add_argument (get_dbus_g_type (param.variable_type));
405 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("dbus_%s".printf (param.name))));
406 } else {
407 ccall.add_argument (get_dbus_g_type (param.variable_type));
408 ccall.add_argument (new CCodeIdentifier (param.name));
409 }
410 }
411
412 if (!(method.return_type is VoidType)) {
413 // synchronous D-Bus method call with reply
414 ccall.add_argument (get_dbus_g_type (method.return_type));
415
416 var array_type = method.return_type as ArrayType;
417 if (array_type != null && array_type.element_type.data_type != string_type.data_type) {
418 // non-string arrays (use GArray)
419 CCodeDeclaration cdecl;
420 if (dbus_use_ptr_array (array_type)) {
421 cdecl = new CCodeDeclaration ("GPtrArray*");
422 } else {
423 cdecl = new CCodeDeclaration ("GArray*");
424 }
425 cdecl.add_declarator (new CCodeVariableDeclarator ("result"));
426 block.add_statement (cdecl);
427
428 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("result")));
429 ccall.add_argument (new CCodeIdentifier ("G_TYPE_INVALID"));
430
431 block.add_statement (new CCodeExpressionStatement (ccall));
432
433 // don't access result when error occured
434 var creturnblock = new CCodeBlock ();
435 creturnblock.add_statement (new CCodeReturnStatement (default_value_for_type (method.return_type, false)));
436 var cerrorif = new CCodeIfStatement (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("error")), creturnblock);
437 block.add_statement (cerrorif);
438
439 block.add_statement (out_marshalling_fragment);
440
441 // *result_length1 = result->len;
442 var garray_length = new CCodeMemberAccess.pointer (new CCodeIdentifier ("result"), "len");
443 var result_length = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("result_length1"));
444 var assign = new CCodeAssignment (result_length, garray_length);
445 block.add_statement (new CCodeExpressionStatement (assign));
446
447 // return result->data;
448 block.add_statement (new CCodeReturnStatement (new CCodeCastExpression (new CCodeMemberAccess.pointer (new CCodeIdentifier ("result"), dbus_use_ptr_array (array_type) ? "pdata" : "data"), method.return_type.get_cname ())));
449 } else if (method.return_type.is_real_non_null_struct_type ()) {
450 // structs are returned via out parameter
451 var st = (Struct) method.return_type.data_type;
452
453 if (st.get_full_name () == "GLib.Value") {
454 ccall.add_argument (new CCodeIdentifier ("result"));
455 ccall.add_argument (new CCodeIdentifier ("G_TYPE_INVALID"));
456
457 block.add_statement (new CCodeExpressionStatement (ccall));
458 } else {
459 var cdecl = new CCodeDeclaration ("GValueArray*");
460 cdecl.add_declarator (new CCodeVariableDeclarator ("dbus_result"));
461 block.add_statement (cdecl);
462
463 int i = 0;
464 foreach (Field f in st.get_fields ()) {
465 if (f.binding != MemberBinding.INSTANCE) {
466 continue;
467 }
468
469 var cget_call = new CCodeFunctionCall (new CCodeIdentifier (f.variable_type.data_type.get_get_value_function ()));
470 cget_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeElementAccess (new CCodeMemberAccess.pointer (new CCodeIdentifier ("dbus_result"), "values"), new CCodeConstant (i.to_string ()))));
471
472 var converted_value = cget_call;
473
474 if (requires_copy (f.variable_type)) {
475 var dupexpr = get_dup_func_expression (f.variable_type, expr.source_reference);
476 converted_value = new CCodeFunctionCall (dupexpr);
477 converted_value.add_argument (cget_call);
478 }
479
480 var assign = new CCodeAssignment (new CCodeMemberAccess.pointer (new CCodeIdentifier ("result"), f.name), converted_value);
481 out_marshalling_fragment.append (new CCodeExpressionStatement (assign));
482
483 i++;
484 }
485
486 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("dbus_result")));
487 ccall.add_argument (new CCodeIdentifier ("G_TYPE_INVALID"));
488
489 block.add_statement (new CCodeExpressionStatement (ccall));
490 }
491
492 // don't access result when error occured
493 var creturnblock = new CCodeBlock ();
494 creturnblock.add_statement (new CCodeReturnStatement ());
495 var cerrorif = new CCodeIfStatement (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("error")), creturnblock);
496 block.add_statement (cerrorif);
497
498 block.add_statement (out_marshalling_fragment);
499 } else {
500 // string arrays or other datatypes
501 var cdecl = new CCodeDeclaration (method.return_type.get_cname ());
502 cdecl.add_declarator (new CCodeVariableDeclarator ("result"));
503 block.add_statement (cdecl);
504
505 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("result")));
506 ccall.add_argument (new CCodeIdentifier ("G_TYPE_INVALID"));
507
508 block.add_statement (new CCodeExpressionStatement (ccall));
509
510 // don't access result when error occured
511 var creturnblock = new CCodeBlock ();
512 creturnblock.add_statement (new CCodeReturnStatement (default_value_for_type (method.return_type, false)));
513 var cerrorif = new CCodeIfStatement (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("error")), creturnblock);
514 block.add_statement (cerrorif);
515
516 block.add_statement (out_marshalling_fragment);
517
518 if (array_type != null) {
519 // special case string array
520
521 // *result_length1 = g_strv_length (result);
522 var cstrvlen = new CCodeFunctionCall (new CCodeIdentifier ("g_strv_length"));
523 cstrvlen.add_argument (new CCodeIdentifier ("result"));
524 var result_length = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("result_length1"));
525 var assign = new CCodeAssignment (result_length, cstrvlen);
526 block.add_statement (new CCodeExpressionStatement (assign));
527 }
528
529 block.add_statement (new CCodeReturnStatement (new CCodeIdentifier ("result")));
530 }
531 } else {
532 ccall.add_argument (new CCodeIdentifier ("G_TYPE_INVALID"));
533
534 block.add_statement (new CCodeExpressionStatement (ccall));
535
536 // don't access result when error occured
537 var creturnblock = new CCodeBlock ();
538 creturnblock.add_statement (new CCodeReturnStatement ());
539 var cerrorif = new CCodeIfStatement (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("error")), creturnblock);
540 block.add_statement (cerrorif);
541
542 block.add_statement (out_marshalling_fragment);
543 }
544 }
545
546 public override CCodeExpression get_dbus_g_type (DataType data_type) {
547 if (data_type is ArrayType) {
548 var array_type = data_type as ArrayType;
549 if (array_type.element_type.data_type == string_type.data_type) {
550 return new CCodeIdentifier ("G_TYPE_STRV");
551 }
552
553 var carray_type = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_type_get_collection"));
554 if (dbus_use_ptr_array (array_type)) {
555 carray_type.add_argument (new CCodeConstant ("\"GPtrArray\""));
556 } else {
557 carray_type.add_argument (new CCodeConstant ("\"GArray\""));
558 }
559 carray_type.add_argument (get_dbus_g_type (array_type.element_type));
560 return carray_type;
561 } else if (data_type.data_type is Enum) {
562 var en = (Enum) data_type.data_type;
563 if (en.is_flags) {
564 return new CCodeIdentifier ("G_TYPE_UINT");
565 } else {
566 return new CCodeIdentifier ("G_TYPE_INT");
567 }
568 } else if (data_type.data_type == null) {
569 critical ("Internal error during DBus type generation with: %s", data_type.to_string ());
570 return new CCodeIdentifier ("G_TYPE_NONE");
571 } else if (data_type.data_type.get_full_name () == "GLib.HashTable") {
572 var cmap_type = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_type_get_map"));
573 var type_args = data_type.get_type_arguments ();
574
575 cmap_type.add_argument (new CCodeConstant ("\"GHashTable\""));
576 foreach (DataType type_arg in type_args) {
577 cmap_type.add_argument (get_dbus_g_type (type_arg));
578 }
579
580 return cmap_type;
581 } else if (get_type_signature (data_type).has_prefix ("(")) {
582 // struct parameter
583 var st = (Struct) data_type.data_type;
584
585 var type_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_type_get_struct"));
586 type_call.add_argument (new CCodeConstant ("\"GValueArray\""));
587
588 foreach (Field f in st.get_fields ()) {
589 if (f.binding != MemberBinding.INSTANCE) {
590 continue;
591 }
592
593 type_call.add_argument (get_dbus_g_type (f.variable_type));
594 }
595
596 type_call.add_argument (new CCodeConstant ("G_TYPE_INVALID"));
597
598 return type_call;
599 } else {
600 return new CCodeIdentifier (data_type.data_type.get_type_id ());
601 }
602 }
603
604 public bool dbus_use_ptr_array (ArrayType array_type) {
605 if (array_type.element_type.data_type == string_type.data_type) {
606 // use char**
607 return false;
608 } else if (array_type.element_type.data_type == bool_type.data_type
609 || array_type.element_type.data_type == char_type.data_type
610 || array_type.element_type.data_type == uchar_type.data_type
611 || array_type.element_type.data_type == int_type.data_type
612 || array_type.element_type.data_type == uint_type.data_type
613 || array_type.element_type.data_type == long_type.data_type
614 || array_type.element_type.data_type == ulong_type.data_type
615 || array_type.element_type.data_type == int8_type.data_type
616 || array_type.element_type.data_type == uint8_type.data_type
617 || array_type.element_type.data_type == int32_type.data_type
618 || array_type.element_type.data_type == uint32_type.data_type
619 || array_type.element_type.data_type == int64_type.data_type
620 || array_type.element_type.data_type == uint64_type.data_type
621 || array_type.element_type.data_type == double_type.data_type) {
622 // use GArray
623 return false;
624 } else {
625 // use GPtrArray
626 return true;
627 }
628 }
629
630 public override string get_dynamic_property_getter_cname (DynamicProperty prop) {
631 if (prop.dynamic_type.data_type != dbus_object_type) {
632 return base.get_dynamic_property_getter_cname (prop);
633 }
634
635 string getter_cname = "_dynamic_get_%s%d".printf (prop.name, dynamic_property_id++);
636
637 if (get_type_signature (prop.property_type) == null) {
638 Report.error (prop.property_type.source_reference, "D-Bus serialization of type `%s' is not supported".printf (prop.property_type.to_string ()));
639 return getter_cname;
640 }
641
642 var func = new CCodeFunction (getter_cname, prop.property_type.get_cname ());
643 func.modifiers |= CCodeModifiers.STATIC | CCodeModifiers.INLINE;
644
645 func.add_parameter (new CCodeParameter ("obj", prop.dynamic_type.get_cname ()));
646
647 var block = new CCodeBlock ();
648 generate_dbus_property_getter_wrapper (prop, block);
649
650 // append to C source file
651 cfile.add_function_declaration (func);
652
653 func.block = block;
654 cfile.add_function (func);
655
656 return getter_cname;
657 }
658
659 public override string get_dynamic_property_setter_cname (DynamicProperty prop) {
660 if (prop.dynamic_type.data_type != dbus_object_type) {
661 return base.get_dynamic_property_setter_cname (prop);
662 }
663
664 string setter_cname = "_dynamic_set_%s%d".printf (prop.name, dynamic_property_id++);
665
666 if (get_type_signature (prop.property_type) == null) {
667 Report.error (prop.property_type.source_reference, "D-Bus serialization of type `%s' is not supported".printf (prop.property_type.to_string ()));
668 return setter_cname;
669 }
670
671 var func = new CCodeFunction (setter_cname, "void");
672 func.modifiers |= CCodeModifiers.STATIC | CCodeModifiers.INLINE;
673
674 func.add_parameter (new CCodeParameter ("obj", prop.dynamic_type.get_cname ()));
675 func.add_parameter (new CCodeParameter ("value", prop.property_type.get_cname ()));
676
677 var block = new CCodeBlock ();
678 generate_dbus_property_setter_wrapper (prop, block);
679
680 // append to C source file
681 cfile.add_function_declaration (func);
682
683 func.block = block;
684 cfile.add_function (func);
685
686 return setter_cname;
687 }
688
689 void create_dbus_property_proxy (DynamicProperty node, CCodeBlock block) {
690 var prop_proxy_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_proxy_new_from_proxy"));
691 prop_proxy_call.add_argument (new CCodeIdentifier ("obj"));
692 prop_proxy_call.add_argument (new CCodeConstant ("DBUS_INTERFACE_PROPERTIES"));
693 prop_proxy_call.add_argument (new CCodeConstant ("NULL"));
694
695 var prop_proxy_decl = new CCodeDeclaration ("DBusGProxy*");
696 prop_proxy_decl.add_declarator (new CCodeVariableDeclarator ("property_proxy", prop_proxy_call));
697 block.add_statement (prop_proxy_decl);
698 }
699
700 void generate_dbus_property_getter_wrapper (DynamicProperty node, CCodeBlock block) {
701 create_dbus_property_proxy (node, block);
702
703 // initialize GValue
704 var cvalinit = new CCodeInitializerList ();
705 cvalinit.append (new CCodeConstant ("0"));
706
707 var cval_decl = new CCodeDeclaration ("GValue");
708 cval_decl.add_declarator (new CCodeVariableDeclarator.zero ("gvalue", cvalinit));
709 block.add_statement (cval_decl);
710
711 var val_ptr = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("gvalue"));
712
713 // call Get method on property proxy
714 var cdecl = new CCodeDeclaration (node.property_type.get_cname ());
715 cdecl.add_declarator (new CCodeVariableDeclarator ("result"));
716 block.add_statement (cdecl);
717
718 var ccall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_proxy_call"));
719 ccall.add_argument (new CCodeIdentifier ("property_proxy"));
720 ccall.add_argument (new CCodeConstant ("\"Get\""));
721 ccall.add_argument (new CCodeConstant ("NULL"));
722
723 ccall.add_argument (new CCodeIdentifier ("G_TYPE_STRING"));
724 var get_iface = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_proxy_get_interface"));
725 get_iface.add_argument (new CCodeIdentifier ("obj"));
726 ccall.add_argument (get_iface);
727
728 ccall.add_argument (new CCodeIdentifier ("G_TYPE_STRING"));
729 ccall.add_argument (new CCodeConstant ("\"%s\"".printf (get_dynamic_dbus_name (node.name))));
730
731 ccall.add_argument (new CCodeIdentifier ("G_TYPE_INVALID"));
732
733 ccall.add_argument (new CCodeIdentifier ("G_TYPE_VALUE"));
734 ccall.add_argument (val_ptr);
735
736 ccall.add_argument (new CCodeIdentifier ("G_TYPE_INVALID"));
737
738 block.add_statement (new CCodeExpressionStatement (ccall));
739
740 // unref property proxy
741 var prop_proxy_unref = new CCodeFunctionCall (new CCodeIdentifier ("g_object_unref"));
742 prop_proxy_unref.add_argument (new CCodeIdentifier ("property_proxy"));
743 block.add_statement (new CCodeExpressionStatement (prop_proxy_unref));
744
745 // assign value to result variable
746 var cget_call = new CCodeFunctionCall (new CCodeIdentifier (node.property_type.data_type.get_get_value_function ()));
747 cget_call.add_argument (val_ptr);
748 var assign = new CCodeAssignment (new CCodeIdentifier ("result"), cget_call);
749 block.add_statement (new CCodeExpressionStatement (assign));
750
751 // return result
752 block.add_statement (new CCodeReturnStatement (new CCodeIdentifier ("result")));
753 }
754
755 void generate_dbus_property_setter_wrapper (DynamicProperty node, CCodeBlock block) {
756 create_dbus_property_proxy (node, block);
757
758 // initialize GValue
759 var cvalinit = new CCodeInitializerList ();
760 cvalinit.append (new CCodeConstant ("0"));
761
762 var cval_decl = new CCodeDeclaration ("GValue");
763 cval_decl.add_declarator (new CCodeVariableDeclarator.zero ("gvalue", cvalinit));
764 block.add_statement (cval_decl);
765
766 var val_ptr = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("gvalue"));
767
768 var cinit_call = new CCodeFunctionCall (new CCodeIdentifier ("g_value_init"));
769 cinit_call.add_argument (val_ptr);
770 cinit_call.add_argument (new CCodeIdentifier (node.property_type.data_type.get_type_id ()));
771 block.add_statement (new CCodeExpressionStatement (cinit_call));
772
773 var cset_call = new CCodeFunctionCall (new CCodeIdentifier (node.property_type.data_type.get_set_value_function ()));
774 cset_call.add_argument (val_ptr);
775 cset_call.add_argument (new CCodeIdentifier ("value"));
776 block.add_statement (new CCodeExpressionStatement (cset_call));
777
778 // call Set method on property proxy
779 var ccall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_proxy_call"));
780 ccall.add_argument (new CCodeIdentifier ("property_proxy"));
781 ccall.add_argument (new CCodeConstant ("\"Set\""));
782 ccall.add_argument (new CCodeConstant ("NULL"));
783
784 ccall.add_argument (new CCodeIdentifier ("G_TYPE_STRING"));
785 var get_iface = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_proxy_get_interface"));
786 get_iface.add_argument (new CCodeIdentifier ("obj"));
787 ccall.add_argument (get_iface);
788
789 ccall.add_argument (new CCodeIdentifier ("G_TYPE_STRING"));
790 ccall.add_argument (new CCodeConstant ("\"%s\"".printf (get_dynamic_dbus_name (node.name))));
791
792 ccall.add_argument (new CCodeIdentifier ("G_TYPE_VALUE"));
793 ccall.add_argument (val_ptr);
794
795 ccall.add_argument (new CCodeIdentifier ("G_TYPE_INVALID"));
796
797 ccall.add_argument (new CCodeIdentifier ("G_TYPE_INVALID"));
798
799 block.add_statement (new CCodeExpressionStatement (ccall));
800
801 // unref property proxy
802 var prop_proxy_unref = new CCodeFunctionCall (new CCodeIdentifier ("g_object_unref"));
803 prop_proxy_unref.add_argument (new CCodeIdentifier ("property_proxy"));
804 block.add_statement (new CCodeExpressionStatement (prop_proxy_unref));
805 }
806
807 public override string get_dynamic_signal_connect_wrapper_name (DynamicSignal sig) {
808 if (sig.dynamic_type.data_type != dbus_object_type) {
809 return base.get_dynamic_signal_connect_wrapper_name (sig);
810 }
811
812 string connect_wrapper_name = "_%sconnect".printf (get_dynamic_signal_cname (sig));
813 var func = new CCodeFunction (connect_wrapper_name, "void");
814 func.add_parameter (new CCodeParameter ("obj", "gpointer"));
815 func.add_parameter (new CCodeParameter ("signal_name", "const char *"));
816 func.add_parameter (new CCodeParameter ("handler", "GCallback"));
817 func.add_parameter (new CCodeParameter ("data", "gpointer"));
818 var block = new CCodeBlock ();
819 generate_dbus_connect_wrapper (sig, block);
820
821 // append to C source file
822 cfile.add_function_declaration (func);
823
824 func.block = block;
825 cfile.add_function (func);
826
827 return connect_wrapper_name;
828 }
829
830 public override string get_dynamic_signal_disconnect_wrapper_name (DynamicSignal sig) {
831 if (sig.dynamic_type.data_type != dbus_object_type) {
832 return base.get_dynamic_signal_disconnect_wrapper_name (sig);
833 }
834
835 string disconnect_wrapper_name = "_%sdisconnect".printf (get_dynamic_signal_cname (sig));
836 var func = new CCodeFunction (disconnect_wrapper_name, "void");
837 func.add_parameter (new CCodeParameter ("obj", "gpointer"));
838 func.add_parameter (new CCodeParameter ("signal_name", "const char *"));
839 func.add_parameter (new CCodeParameter ("handler", "GCallback"));
840 func.add_parameter (new CCodeParameter ("data", "gpointer"));
841 var block = new CCodeBlock ();
842 generate_dbus_disconnect_wrapper (sig, block);
843
844 // append to C source file
845 cfile.add_function_declaration (func);
846
847 func.block = block;
848 cfile.add_function (func);
849
850 return disconnect_wrapper_name;
851 }
852
853 void generate_dbus_connect_wrapper (DynamicSignal sig, CCodeBlock block) {
854 var m = (Method) sig.handler.symbol_reference;
855
856 sig.accept (this);
857
858 // FIXME should only be done once per marshaller
859 var register_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_object_register_marshaller"));
860 generate_marshaller (sig.get_parameters (), sig.return_type, true);
861 register_call.add_argument (new CCodeIdentifier (get_marshaller_function (sig.get_parameters (), sig.return_type, null, true)));
862 register_call.add_argument (new CCodeIdentifier ("G_TYPE_NONE"));
863
864 var add_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_proxy_add_signal"));
865 add_call.add_argument (new CCodeIdentifier ("obj"));
866 add_call.add_argument (new CCodeConstant ("\"%s\"".printf (get_dynamic_dbus_name (sig.name))));
867
868 bool first = true;
869 foreach (Parameter param in m.get_parameters ()) {
870 if (first) {
871 // skip sender parameter
872 first = false;
873 continue;
874 }
875
876 register_call.add_argument (get_dbus_g_type (param.variable_type));
877 add_call.add_argument (get_dbus_g_type (param.variable_type));
878 }
879 register_call.add_argument (new CCodeIdentifier ("G_TYPE_INVALID"));
880 add_call.add_argument (new CCodeIdentifier ("G_TYPE_INVALID"));
881
882 block.add_statement (new CCodeExpressionStatement (register_call));
883 block.add_statement (new CCodeExpressionStatement (add_call));
884
885 var call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_proxy_connect_signal"));
886 call.add_argument (new CCodeIdentifier ("obj"));
887 call.add_argument (new CCodeConstant ("\"%s\"".printf (get_dynamic_dbus_name (sig.name))));
888 call.add_argument (new CCodeIdentifier ("handler"));
889 call.add_argument (new CCodeIdentifier ("data"));
890 call.add_argument (new CCodeConstant ("NULL"));
891 block.add_statement (new CCodeExpressionStatement (call));
892 }
893
894 void generate_dbus_disconnect_wrapper (DynamicSignal sig, CCodeBlock block) {
895 var call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_proxy_disconnect_signal"));
896 call.add_argument (new CCodeIdentifier ("obj"));
897 call.add_argument (new CCodeConstant ("\"%s\"".printf (get_dynamic_dbus_name (sig.name))));
898 call.add_argument (new CCodeIdentifier ("handler"));
899 call.add_argument (new CCodeIdentifier ("data"));
900 block.add_statement (new CCodeExpressionStatement (call));
901 }
902
903 public override void visit_cast_expression (CastExpression expr) {
904 // handles casting DBus.Object instances to DBus interfaces
905
906 var type = expr.type_reference as ObjectType;
907 var call = expr.inner as MethodCall;
908 if (type == null || !(type.type_symbol is Interface)
909 || type.type_symbol.get_attribute ("DBus") == null || call == null) {
910 base.visit_cast_expression (expr);
911 return;
912 }
913
914 var mtype = call.call.value_type as MethodType;
915 if (mtype == null || mtype.method_symbol.get_cname () != "dbus_g_proxy_new_for_name") {
916 base.visit_cast_expression (expr);
917 return;
918 }
919
920 var args = call.get_argument_list ();
921 Expression connection = ((MemberAccess) call.call).inner;
922 Expression bus_name = args.get (0);
923 Expression object_path = args.get (1);
924
925 var ccall = new CCodeFunctionCall (new CCodeIdentifier (type.type_symbol.get_lower_case_cprefix () + "dbus_proxy_new"));
926 connection.emit (this);
927 ccall.add_argument (get_cvalue (connection));
928 bus_name.emit (this);
929 ccall.add_argument (get_cvalue (bus_name));
930 object_path.emit (this);
931 ccall.add_argument (get_cvalue (object_path));
932 set_cvalue (expr, ccall);
933 }
934
935 void generate_proxy_interface_init (Interface main_iface, Interface iface) {
936 // also generate proxy for prerequisites
937 foreach (var prereq in iface.get_prerequisites ()) {
938 if (prereq.data_type is Interface) {
939 generate_proxy_interface_init (main_iface, (Interface) prereq.data_type);
940 }
941 }
942
943 string lower_cname = main_iface.get_lower_case_cprefix () + "dbus_proxy";
944
945 var proxy_iface_init = new CCodeFunction (lower_cname + "_" + iface.get_lower_case_cprefix () + "_interface_init", "void");
946 proxy_iface_init.add_parameter (new CCodeParameter ("iface", iface.get_cname () + "Iface*"));
947
948 var iface_block = new CCodeBlock ();
949
950 foreach (Method m in iface.get_methods ()) {
951 var vfunc_entry = new CCodeMemberAccess.pointer (new CCodeIdentifier ("iface"), m.vfunc_name);
952 if (is_dbus_no_reply (m)) {
953 if (m.coroutine) {
954 Report.error (m.source_reference, "No-reply DBus methods must not be async");
955 }
956 iface_block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (vfunc_entry, new CCodeIdentifier (generate_noreply_dbus_proxy_method (main_iface, iface, m)))));
957 } else if (!m.coroutine) {
958 iface_block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (vfunc_entry, new CCodeIdentifier (generate_dbus_proxy_method (main_iface, iface, m)))));
959 } else {
960 iface_block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (vfunc_entry, new CCodeIdentifier (generate_async_dbus_proxy_method (main_iface, iface, m)))));
961 vfunc_entry = new CCodeMemberAccess.pointer (new CCodeIdentifier ("iface"), m.get_finish_vfunc_name ());
962 iface_block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (vfunc_entry, new CCodeIdentifier (generate_finish_dbus_proxy_method (main_iface, iface, m)))));
963 }
964 }
965
966 foreach (Property prop in iface.get_properties ()) {
967 if (prop.get_accessor != null) {
968 var vfunc_entry = new CCodeMemberAccess.pointer (new CCodeIdentifier ("iface"), "get_" + prop.name);
969 iface_block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (vfunc_entry, new CCodeIdentifier (generate_dbus_proxy_property_get (main_iface, iface, prop)))));
970 }
971 if (prop.set_accessor != null) {
972 var vfunc_entry = new CCodeMemberAccess.pointer (new CCodeIdentifier ("iface"), "set_" + prop.name);
973 iface_block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (vfunc_entry, new CCodeIdentifier (generate_dbus_proxy_property_set (main_iface, iface, prop)))));
974 }
975 }
976
977 proxy_iface_init.modifiers = CCodeModifiers.STATIC;
978 cfile.add_function_declaration (proxy_iface_init);
979 proxy_iface_init.block = iface_block;
980 cfile.add_function (proxy_iface_init);
981 }
982
983 string implement_interface (CCodeFunctionCall define_type, Interface main_iface, Interface iface) {
984 string result = "";
985
986 // also implement prerequisites
987 foreach (var prereq in iface.get_prerequisites ()) {
988 if (prereq.data_type is Interface) {
989 result += implement_interface (define_type, main_iface, (Interface) prereq.data_type);
990 }
991 }
992
993 result += "G_IMPLEMENT_INTERFACE (%s, %sdbus_proxy_%s_interface_init) ".printf (
994 iface.get_upper_case_cname ("TYPE_"),
995 main_iface.get_lower_case_cprefix (),
996 iface.get_lower_case_cprefix ());
997 return result;
998 }
999
1000 void implement_property (CCodeBlock block, Interface main_iface, Interface iface) {
1001 // also implement prerequisites
1002 foreach (var prereq in iface.get_prerequisites ()) {
1003 if (prereq.data_type is Interface) {
1004 implement_property (block, main_iface, (Interface) prereq.data_type);
1005 }
1006 }
1007
1008 var gobject_class = new CCodeFunctionCall (new CCodeIdentifier ("G_OBJECT_CLASS"));
1009 gobject_class.add_argument (new CCodeIdentifier ("klass"));
1010
1011 foreach (Property prop in iface.get_properties ()) {
1012 if (!prop.is_abstract) {
1013 continue;
1014 }
1015
1016 if (!is_gobject_property (prop)) {
1017 continue;
1018 }
1019
1020 string prop_ev = "%s_dbus_proxy_%s".printf (main_iface.get_lower_case_cname (null), Symbol.camel_case_to_lower_case (prop.name)).up ();
1021
1022 var cinst = new CCodeFunctionCall (new CCodeIdentifier ("g_object_class_override_property"));
1023 cinst.add_argument (gobject_class);
1024 cinst.add_argument (new CCodeConstant (prop_ev));
1025 cinst.add_argument (prop.get_canonical_cconstant ());
1026 block.add_statement (new CCodeExpressionStatement (cinst));
1027
1028 prop_enum.add_value (new CCodeEnumValue (prop_ev));
1029 }
1030 }
1031
1032 public override void generate_interface_declaration (Interface iface, CCodeFile decl_space) {
1033 base.generate_interface_declaration (iface, decl_space);
1034
1035 string dbus_iface_name = get_dbus_name (iface);
1036 if (dbus_iface_name == null) {
1037 return;
1038 }
1039
1040 string lower_cname = iface.get_lower_case_cprefix () + "dbus_proxy";
1041
1042 if (add_symbol_declaration (decl_space, iface, lower_cname + "_new")) {
1043 return;
1044 }
1045
1046 decl_space.add_include ("dbus/dbus-glib.h");
1047
1048 // declare proxy_new function
1049 var proxy_new = new CCodeFunction (lower_cname + "_new", iface.get_cname () + "*");
1050 proxy_new.add_parameter (new CCodeParameter ("connection", "DBusGConnection*"));
1051 proxy_new.add_parameter (new CCodeParameter ("name", "const char*"));
1052 proxy_new.add_parameter (new CCodeParameter ("path", "const char*"));
1053
1054 decl_space.add_function_declaration (proxy_new);
1055 }
1056
1057 public override void visit_interface (Interface iface) {
1058 base.visit_interface (iface);
1059
1060 string dbus_iface_name = get_dbus_name (iface);
1061 if (dbus_iface_name == null) {
1062 return;
1063 }
1064
1065 // strcmp
1066 cfile.add_include ("string.h");
1067
1068 // create proxy class
1069 string cname = iface.get_cname () + "DBusProxy";
1070 string lower_cname = iface.get_lower_case_cprefix () + "dbus_proxy";
1071
1072 add_dbus_helpers ();
1073
1074 cfile.add_type_declaration (new CCodeTypeDefinition ("struct _%s".printf (cname), new CCodeVariableDeclarator (cname)));
1075 cfile.add_type_declaration (new CCodeTypeDefinition ("DBusGProxyClass", new CCodeVariableDeclarator (cname + "Class")));
1076
1077 var instance_struct = new CCodeStruct ("_%s".printf (cname));
1078 instance_struct.add_field ("DBusGProxy", "parent_instance");
1079 instance_struct.add_field ("gboolean", "disposed");
1080
1081 cfile.add_type_definition (instance_struct);
1082
1083 var type_fun = new CCodeFunction(lower_cname + "_get_type", "GType");
1084 type_fun.attributes = "G_GNUC_CONST";
1085 cfile.add_function_declaration (type_fun);
1086
1087 var define_type = new CCodeFunctionCall (new CCodeIdentifier ("G_DEFINE_TYPE_EXTENDED"));
1088 define_type.add_argument (new CCodeIdentifier (cname));
1089 define_type.add_argument (new CCodeIdentifier (lower_cname));
1090 define_type.add_argument (new CCodeIdentifier ("DBUS_TYPE_G_PROXY"));
1091 define_type.add_argument (new CCodeConstant ("0"));
1092 define_type.add_argument (new CCodeIdentifier (implement_interface (define_type, iface, iface)));
1093
1094 cfile.add_type_member_definition (new CCodeExpressionStatement (define_type));
1095
1096 // generate proxy_new function
1097 var proxy_new = new CCodeFunction (lower_cname + "_new", iface.get_cname () + "*");
1098 proxy_new.add_parameter (new CCodeParameter ("connection", "DBusGConnection*"));
1099 proxy_new.add_parameter (new CCodeParameter ("name", "const char*"));
1100 proxy_new.add_parameter (new CCodeParameter ("path", "const char*"));
1101
1102 var new_block = new CCodeBlock ();
1103
1104 // create proxy object
1105 var new_call = new CCodeFunctionCall (new CCodeIdentifier ("g_object_new"));
1106 new_call.add_argument (new CCodeFunctionCall (new CCodeIdentifier (lower_cname + "_get_type")));
1107 new_call.add_argument (new CCodeConstant ("\"connection\""));
1108 new_call.add_argument (new CCodeIdentifier ("connection"));
1109 new_call.add_argument (new CCodeConstant ("\"name\""));
1110 new_call.add_argument (new CCodeIdentifier ("name"));
1111 new_call.add_argument (new CCodeConstant ("\"path\""));
1112 new_call.add_argument (new CCodeIdentifier ("path"));
1113 new_call.add_argument (new CCodeConstant ("\"interface\""));
1114 new_call.add_argument (new CCodeConstant ("\"%s\"".printf (dbus_iface_name)));
1115 new_call.add_argument (new CCodeConstant ("NULL"));
1116
1117 var cdecl = new CCodeDeclaration (iface.get_cname () + "*");
1118 cdecl.add_declarator (new CCodeVariableDeclarator ("self", new_call));
1119 new_block.add_statement (cdecl);
1120 new_block.add_statement (new CCodeReturnStatement (new CCodeIdentifier ("self")));
1121
1122 proxy_new.block = new_block;
1123 cfile.add_function (proxy_new);
1124
1125 // dbus proxy construct
1126 var proxy_construct = new CCodeFunction (lower_cname + "_construct", "GObject*");
1127 proxy_construct.add_parameter (new CCodeParameter ("gtype", "GType"));
1128 proxy_construct.add_parameter (new CCodeParameter ("n_properties", "guint"));
1129 proxy_construct.add_parameter (new CCodeParameter ("properties", "GObjectConstructParam*"));
1130 proxy_construct.modifiers = CCodeModifiers.STATIC;
1131 proxy_construct.block = new CCodeBlock ();
1132
1133 // chain up
1134 var parent_class = new CCodeFunctionCall (new CCodeIdentifier ("G_OBJECT_CLASS"));
1135 parent_class.add_argument (new CCodeIdentifier (lower_cname + "_parent_class"));
1136 var chainup = new CCodeFunctionCall (new CCodeMemberAccess.pointer (parent_class, "constructor"));
1137 chainup.add_argument (new CCodeIdentifier ("gtype"));
1138 chainup.add_argument (new CCodeIdentifier ("n_properties"));
1139 chainup.add_argument (new CCodeIdentifier ("properties"));
1140
1141 cdecl = new CCodeDeclaration ("GObject*");
1142 cdecl.add_declarator (new CCodeVariableDeclarator ("self", chainup));
1143 proxy_construct.block.add_statement (cdecl);
1144
1145 cdecl = new CCodeDeclaration ("DBusGConnection");
1146 cdecl.add_declarator (new CCodeVariableDeclarator ("*connection"));
1147 proxy_construct.block.add_statement (cdecl);
1148
1149 var gconnection = new CCodeFunctionCall (new CCodeIdentifier ("g_object_get"));
1150 gconnection.add_argument (new CCodeIdentifier ("self"));
1151 gconnection.add_argument (new CCodeConstant ("\"connection\""));
1152 gconnection.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("connection")));
1153 gconnection.add_argument (new CCodeConstant ("NULL"));
1154 proxy_construct.block.add_statement (new CCodeExpressionStatement (gconnection));
1155
1156 cdecl = new CCodeDeclaration ("char*");
1157 cdecl.add_declarator (new CCodeVariableDeclarator ("path"));
1158 proxy_construct.block.add_statement (cdecl);
1159
1160 var path = new CCodeFunctionCall (new CCodeIdentifier ("g_object_get"));
1161 path.add_argument (new CCodeIdentifier ("self"));
1162 path.add_argument (new CCodeConstant ("\"path\""));
1163 path.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("path")));
1164 path.add_argument (new CCodeConstant ("NULL"));
1165 proxy_construct.block.add_statement (new CCodeExpressionStatement (path));
1166
1167 var raw_connection = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_connection_get_connection"));
1168 raw_connection.add_argument (new CCodeIdentifier ("connection"));
1169
1170 // add filter to handle signals from the remote object
1171 var filter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_connection_add_filter"));
1172 filter_call.add_argument (raw_connection);
1173 filter_call.add_argument (new CCodeIdentifier (lower_cname + "_filter"));
1174 filter_call.add_argument (new CCodeIdentifier ("self"));
1175 filter_call.add_argument (new CCodeConstant ("NULL"));
1176 proxy_construct.block.add_statement (new CCodeExpressionStatement (filter_call));
1177
1178 var filter_printf = new CCodeFunctionCall (new CCodeIdentifier ("g_strdup_printf"));
1179 filter_printf.add_argument (new CCodeConstant ("\"type='signal',path='%s'\""));
1180 filter_printf.add_argument (new CCodeIdentifier ("path"));
1181
1182 cdecl = new CCodeDeclaration ("char*");
1183 cdecl.add_declarator (new CCodeVariableDeclarator ("filter", filter_printf));
1184 proxy_construct.block.add_statement (cdecl);
1185
1186 // ensure we receive signals from the remote object
1187 var match_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_bus_add_match"));
1188 match_call.add_argument (raw_connection);
1189 match_call.add_argument (new CCodeIdentifier ("filter"));
1190 match_call.add_argument (new CCodeConstant ("NULL"));
1191 proxy_construct.block.add_statement (new CCodeExpressionStatement (match_call));
1192
1193 var connection_free = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_connection_unref"));
1194 connection_free.add_argument (new CCodeIdentifier ("connection"));
1195 proxy_construct.block.add_statement (new CCodeExpressionStatement (connection_free));
1196
1197 var path_free = new CCodeFunctionCall (new CCodeIdentifier ("g_free"));
1198 path_free.add_argument (new CCodeIdentifier ("path"));
1199 proxy_construct.block.add_statement (new CCodeExpressionStatement (path_free));
1200
1201 var filter_free = new CCodeFunctionCall (new CCodeIdentifier ("g_free"));
1202 filter_free.add_argument (new CCodeIdentifier ("filter"));
1203 proxy_construct.block.add_statement (new CCodeExpressionStatement (filter_free));
1204
1205 proxy_construct.block.add_statement (new CCodeReturnStatement (new CCodeIdentifier ("self")));
1206
1207 cfile.add_function (proxy_construct);
1208
1209 // dbus proxy filter function
1210 generate_proxy_filter_function (iface);
1211
1212 // dbus proxy dispose
1213 var proxy_dispose = new CCodeFunction (lower_cname + "_dispose", "void");
1214 proxy_dispose.add_parameter (new CCodeParameter ("self", "GObject*"));
1215 proxy_dispose.modifiers = CCodeModifiers.STATIC;
1216 proxy_dispose.block = new CCodeBlock ();
1217
1218 cdecl = new CCodeDeclaration ("DBusGConnection");
1219 cdecl.add_declarator (new CCodeVariableDeclarator ("*connection"));
1220 proxy_dispose.block.add_statement (cdecl);
1221
1222 // return if proxy is already disposed
1223 var dispose_return_block = new CCodeBlock ();
1224 dispose_return_block.add_statement (new CCodeReturnStatement ());
1225 proxy_dispose.block.add_statement (new CCodeIfStatement (new CCodeMemberAccess.pointer (new CCodeCastExpression (new CCodeIdentifier ("self"), cname + "*"), "disposed"), dispose_return_block));
1226
1227 // mark proxy as disposed
1228 proxy_dispose.block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess.pointer (new CCodeCastExpression (new CCodeIdentifier ("self"), cname + "*"), "disposed"), new CCodeConstant ("TRUE"))));
1229
1230 gconnection = new CCodeFunctionCall (new CCodeIdentifier ("g_object_get"));
1231 gconnection.add_argument (new CCodeIdentifier ("self"));
1232 gconnection.add_argument (new CCodeConstant ("\"connection\""));
1233 gconnection.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("connection")));
1234 gconnection.add_argument (new CCodeConstant ("NULL"));
1235 proxy_dispose.block.add_statement (new CCodeExpressionStatement (gconnection));
1236
1237 // remove filter
1238 filter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_connection_remove_filter"));
1239 filter_call.add_argument (raw_connection);
1240 filter_call.add_argument (new CCodeIdentifier (lower_cname + "_filter"));
1241 filter_call.add_argument (new CCodeIdentifier ("self"));
1242 proxy_dispose.block.add_statement (new CCodeExpressionStatement (filter_call));
1243
1244 // chain up
1245 parent_class = new CCodeFunctionCall (new CCodeIdentifier ("G_OBJECT_CLASS"));
1246 parent_class.add_argument (new CCodeIdentifier (lower_cname + "_parent_class"));
1247 chainup = new CCodeFunctionCall (new CCodeMemberAccess.pointer (parent_class, "dispose"));
1248 chainup.add_argument (new CCodeIdentifier ("self"));
1249 proxy_dispose.block.add_statement (new CCodeExpressionStatement (chainup));
1250
1251 cfile.add_function (proxy_dispose);
1252
1253 var proxy_class_init = new CCodeFunction (lower_cname + "_class_init", "void");
1254 proxy_class_init.add_parameter (new CCodeParameter ("klass", cname + "Class*"));
1255 proxy_class_init.modifiers = CCodeModifiers.STATIC;
1256 proxy_class_init.block = new CCodeBlock ();
1257 var gobject_class = new CCodeFunctionCall (new CCodeIdentifier ("G_OBJECT_CLASS"));
1258 gobject_class.add_argument (new CCodeIdentifier ("klass"));
1259 proxy_class_init.block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess.pointer (gobject_class, "constructor"), new CCodeIdentifier (lower_cname + "_construct"))));
1260 proxy_class_init.block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess.pointer (gobject_class, "dispose"), new CCodeIdentifier (lower_cname + "_dispose"))));
1261 proxy_class_init.block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess.pointer (gobject_class, "get_property"), new CCodeIdentifier ("_vala_%s_get_property".printf (lower_cname)))));
1262 proxy_class_init.block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess.pointer (gobject_class, "set_property"), new CCodeIdentifier ("_vala_%s_set_property".printf (lower_cname)))));
1263 cfile.add_function (proxy_class_init);
1264
1265 prop_enum = new CCodeEnum ();
1266 prop_enum.add_value (new CCodeEnumValue ("%s_DUMMY_PROPERTY".printf (lower_cname.up ())));
1267
1268 implement_property (proxy_class_init.block, iface, iface);
1269
1270 cfile.add_type_member_declaration (prop_enum);
1271
1272 var proxy_instance_init = new CCodeFunction (lower_cname + "_init", "void");
1273 proxy_instance_init.add_parameter (new CCodeParameter ("self", cname + "*"));
1274 proxy_instance_init.modifiers = CCodeModifiers.STATIC;
1275 proxy_instance_init.block = new CCodeBlock ();
1276 cfile.add_function (proxy_instance_init);
1277
1278 generate_proxy_interface_init (iface, iface);
1279
1280 // dbus proxy get/set_property stubs
1281 // TODO add actual implementation
1282 var get_prop = new CCodeFunction ("_vala_%s_get_property".printf (lower_cname), "void");
1283 get_prop.modifiers = CCodeModifiers.STATIC;
1284 get_prop.add_parameter (new CCodeParameter ("object", "GObject *"));
1285 get_prop.add_parameter (new CCodeParameter ("property_id", "guint"));
1286 get_prop.add_parameter (new CCodeParameter ("value", "GValue *"));
1287 get_prop.add_parameter (new CCodeParameter ("pspec", "GParamSpec *"));
1288 cfile.add_function_declaration (get_prop);
1289 get_prop.block = new CCodeBlock ();
1290 cfile.add_function (get_prop);
1291
1292 var set_prop = new CCodeFunction ("_vala_%s_set_property".printf (lower_cname), "void");
1293 set_prop.modifiers = CCodeModifiers.STATIC;
1294 set_prop.add_parameter (new CCodeParameter ("object", "GObject *"));
1295 set_prop.add_parameter (new CCodeParameter ("property_id", "guint"));
1296 set_prop.add_parameter (new CCodeParameter ("value", "const GValue *"));
1297 set_prop.add_parameter (new CCodeParameter ("pspec", "GParamSpec *"));
1298 cfile.add_function_declaration (set_prop);
1299 set_prop.block = new CCodeBlock ();
1300 cfile.add_function (set_prop);
1301 }
1302
1303 public override TypeRegisterFunction create_interface_register_function (Interface iface) {
1304 string dbus_iface_name = get_dbus_name (iface);
1305 if (dbus_iface_name == null) {
1306 return new InterfaceRegisterFunction (iface, context);
1307 }
1308
1309 return new DBusInterfaceRegisterFunction (iface, context);
1310 }
1311
1312 string generate_get_all_function (Method m) {
1313 string get_all_func = "_dbus_g_proxy_get_all";
1314
1315 if (!add_wrapper (get_all_func)) {
1316 // wrapper already defined
1317 return get_all_func;
1318 }
1319
1320 var function = new CCodeFunction (get_all_func, "GHashTable*");
1321 function.modifiers = CCodeModifiers.STATIC;
1322
1323 function.add_parameter (new CCodeParameter ("self", "DBusGProxy*"));
1324 function.add_parameter (new CCodeParameter ("interface_name", "const gchar*"));
1325 function.add_parameter (new CCodeParameter ("error", "GError**"));
1326
1327 var block = new CCodeBlock ();
1328 var prefragment = new CCodeFragment ();
1329 var postfragment = new CCodeFragment ();
1330
1331 var cdecl = new CCodeDeclaration ("DBusError");
1332 cdecl.add_declarator (new CCodeVariableDeclarator ("_dbus_error"));
1333 block.add_statement (cdecl);
1334
1335 var dbus_error = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_dbus_error"));
1336
1337 cdecl = new CCodeDeclaration ("DBusGConnection");
1338 cdecl.add_declarator (new CCodeVariableDeclarator ("*_connection"));
1339 block.add_statement (cdecl);
1340
1341 cdecl = new CCodeDeclaration ("DBusMessage");
1342 cdecl.add_declarator (new CCodeVariableDeclarator ("*_message"));
1343 cdecl.add_declarator (new CCodeVariableDeclarator ("*_reply"));
1344 block.add_statement (cdecl);
1345
1346 cdecl = new CCodeDeclaration ("DBusMessageIter");
1347 cdecl.add_declarator (new CCodeVariableDeclarator ("_iter"));
1348 block.add_statement (cdecl);
1349
1350 block.add_statement (prefragment);
1351
1352 generate_marshalling (m, "org.freedesktop.DBus.Properties", prefragment, postfragment);
1353
1354 var gconnection = new CCodeFunctionCall (new CCodeIdentifier ("g_object_get"));
1355 gconnection.add_argument (new CCodeIdentifier ("self"));
1356 gconnection.add_argument (new CCodeConstant ("\"connection\""));
1357 gconnection.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_connection")));
1358 gconnection.add_argument (new CCodeConstant ("NULL"));
1359 block.add_statement (new CCodeExpressionStatement (gconnection));
1360
1361 var dbus_error_init = new CCodeFunctionCall (new CCodeIdentifier ("dbus_error_init"));
1362 dbus_error_init.add_argument (dbus_error);
1363 block.add_statement (new CCodeExpressionStatement (dbus_error_init));
1364
1365 var connection = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_connection_get_connection"));
1366 connection.add_argument (new CCodeIdentifier ("_connection"));
1367
1368 var ccall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_connection_send_with_reply_and_block"));
1369 ccall.add_argument (connection);
1370 ccall.add_argument (new CCodeIdentifier ("_message"));
1371 ccall.add_argument (get_dbus_timeout (m));
1372 ccall.add_argument (dbus_error);
1373 block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("_reply"), ccall)));
1374
1375 var conn_unref = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_connection_unref"));
1376 conn_unref.add_argument (new CCodeIdentifier ("_connection"));
1377 block.add_statement (new CCodeExpressionStatement (conn_unref));
1378
1379 var message_unref = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_unref"));
1380 message_unref.add_argument (new CCodeIdentifier ("_message"));
1381 block.add_statement (new CCodeExpressionStatement (message_unref));
1382
1383 check_error_reply (m, block);
1384 check_reply_signature (m, block);
1385
1386 block.add_statement (postfragment);
1387
1388 var reply_unref = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_unref"));
1389 reply_unref.add_argument (new CCodeIdentifier ("_reply"));
1390 block.add_statement (new CCodeExpressionStatement (reply_unref));
1391
1392 block.add_statement (new CCodeReturnStatement (new CCodeIdentifier ("_result")));
1393
1394 cfile.add_function_declaration (function);
1395
1396 function.block = block;
1397 cfile.add_function (function);
1398
1399 return get_all_func;
1400 }
1401
1402 public override void visit_method_call (MethodCall expr) {
1403 var mtype = expr.call.value_type as MethodType;
1404 bool proxy_new_from_type = (mtype != null && mtype.method_symbol.get_cname () == "dbus_g_proxy_new_from_type");
1405 bool proxy_get_all = (mtype != null && mtype.method_symbol.get_cname () == "dbus_g_proxy_get_all");
1406 if (!proxy_new_from_type && !proxy_get_all) {
1407 base.visit_method_call (expr);
1408 return;
1409 }
1410
1411 if (proxy_get_all) {
1412 var ma = expr.call as MemberAccess;
1413 var instance = ma.inner;
1414 instance.emit (this);
1415
1416 var args = expr.get_argument_list ();
1417 Expression interface_name = args.get (0);
1418 interface_name.emit (this);
1419
1420 var ccall = new CCodeFunctionCall (new CCodeIdentifier (generate_get_all_function (mtype.method_symbol)));
1421 ccall.add_argument (get_cvalue (instance));
1422 ccall.add_argument (get_cvalue (interface_name));
1423
1424 current_method_inner_error = true;
1425 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression ("_inner_error_")));
1426
1427 set_cvalue (expr, ccall);
1428 return;
1429 }
1430
1431 var args = expr.get_argument_list ();
1432 Expression connection = ((MemberAccess) expr.call).inner;
1433 Expression bus_name = args.get (0);
1434 Expression object_path = args.get (1);
1435 Expression interface_name = args.get (2);
1436 Expression type = args.get (3);
1437
1438 var quark_call = new CCodeFunctionCall (new CCodeIdentifier ("g_quark_from_string"));
1439 quark_call.add_argument (new CCodeConstant ("\"ValaDBusInterfaceProxyType\""));
1440
1441 var qdata_call = new CCodeFunctionCall (new CCodeIdentifier ("g_type_get_qdata"));
1442 type.emit (this);
1443 qdata_call.add_argument (get_cvalue (type));
1444 qdata_call.add_argument (quark_call);
1445
1446 var get_type_call = new CCodeFunctionCall (new CCodeCastExpression (qdata_call, "GType (*)(void)"));
1447
1448 var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_object_new"));
1449 ccall.add_argument (get_type_call);
1450 ccall.add_argument (new CCodeConstant ("\"connection\""));
1451 connection.emit (this);
1452 ccall.add_argument (get_cvalue (connection));
1453 ccall.add_argument (new CCodeConstant ("\"name\""));
1454 bus_name.emit (this);
1455 ccall.add_argument (get_cvalue (bus_name));
1456 ccall.add_argument (new CCodeConstant ("\"path\""));
1457 object_path.emit (this);
1458 ccall.add_argument (get_cvalue (object_path));
1459 ccall.add_argument (new CCodeConstant ("\"interface\""));
1460 interface_name.emit (this);
1461 ccall.add_argument (get_cvalue (interface_name));
1462 ccall.add_argument (new CCodeConstant ("NULL"));
1463 set_cvalue (expr, ccall);
1464 }
1465
1466 void generate_proxy_filter_function (Interface iface) {
1467 string lower_cname = iface.get_lower_case_cprefix () + "dbus_proxy";
1468
1469 var proxy_filter = new CCodeFunction (lower_cname + "_filter", "DBusHandlerResult");
1470 proxy_filter.add_parameter (new CCodeParameter ("connection", "DBusConnection*"));
1471 proxy_filter.add_parameter (new CCodeParameter ("message", "DBusMessage*"));
1472 proxy_filter.add_parameter (new CCodeParameter ("user_data", "void*"));
1473
1474 var filter_block = new CCodeBlock ();
1475
1476 // only handle signals concering the object path
1477 var path = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_proxy_get_path"));
1478 path.add_argument (new CCodeIdentifier ("user_data"));
1479
1480 var ccheck = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_has_path"));
1481 ccheck.add_argument (new CCodeIdentifier ("message"));
1482 ccheck.add_argument (path);
1483
1484 var object_filter_block = new CCodeBlock ();
1485 filter_block.add_statement (new CCodeIfStatement (ccheck, object_filter_block));
1486
1487 handle_signals (iface, object_filter_block);
1488
1489 filter_block.add_statement (new CCodeReturnStatement (new CCodeIdentifier ("DBUS_HANDLER_RESULT_NOT_YET_HANDLED")));
1490
1491 cfile.add_function_declaration (proxy_filter);
1492 proxy_filter.block = filter_block;
1493 cfile.add_function (proxy_filter);
1494 }
1495
1496 string generate_dbus_signal_handler (Signal sig, ObjectTypeSymbol sym) {
1497 string wrapper_name = "_dbus_handle_%s_%s".printf (sym.get_lower_case_cname (), sig.get_cname ());
1498
1499 // declaration
1500
1501 CCodeDeclaration cdecl;
1502
1503 var function = new CCodeFunction (wrapper_name, "void");
1504 function.modifiers = CCodeModifiers.STATIC;
1505
1506 function.add_parameter (new CCodeParameter ("self", sym.get_cname () + "*"));
1507 function.add_parameter (new CCodeParameter ("connection", "DBusConnection*"));
1508 function.add_parameter (new CCodeParameter ("message", "DBusMessage*"));
1509
1510 var block = new CCodeBlock ();
1511 var prefragment = new CCodeFragment ();
1512 var postfragment = new CCodeFragment ();
1513
1514 cdecl = new CCodeDeclaration ("DBusMessageIter");
1515 cdecl.add_declarator (new CCodeVariableDeclarator ("iter"));
1516 block.add_statement (cdecl);
1517
1518 block.add_statement (prefragment);
1519
1520 var message_signature = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_get_signature"));
1521 message_signature.add_argument (new CCodeIdentifier ("message"));
1522 var signature_check = new CCodeFunctionCall (new CCodeIdentifier ("strcmp"));
1523 signature_check.add_argument (message_signature);
1524 var signature_error_block = new CCodeBlock ();
1525 signature_error_block.add_statement (new CCodeReturnStatement ());
1526 prefragment.append (new CCodeIfStatement (signature_check, signature_error_block));
1527
1528 var iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_init"));
1529 iter_call.add_argument (new CCodeIdentifier ("message"));
1530 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("iter")));
1531 prefragment.append (new CCodeExpressionStatement (iter_call));
1532
1533 var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_signal_emit_by_name"));
1534 ccall.add_argument (new CCodeIdentifier ("self"));
1535 ccall.add_argument (sig.get_canonical_cconstant ());
1536
1537 // expected type signature for input parameters
1538 string type_signature = "";
1539
1540 foreach (Parameter param in sig.get_parameters ()) {
1541 var owned_type = param.variable_type.copy ();
1542 owned_type.value_owned = true;
1543
1544 cdecl = new CCodeDeclaration (owned_type.get_cname ());
1545 cdecl.add_declarator (new CCodeVariableDeclarator.zero (param.name, default_value_for_type (param.variable_type, true)));
1546 prefragment.append (cdecl);
1547
1548 if (get_type_signature (param.variable_type) == null) {
1549 Report.error (param.variable_type.source_reference, "D-Bus serialization of type `%s' is not supported".printf (param.variable_type.to_string ()));
1550 continue;
1551 }
1552
1553 var st = param.variable_type.data_type as Struct;
1554 if (st != null && !st.is_simple_type ()) {
1555 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (param.name)));
1556 } else {
1557 ccall.add_argument (new CCodeIdentifier (param.name));
1558 }
1559
1560 if (param.variable_type is ArrayType) {
1561 var array_type = (ArrayType) param.variable_type;
1562
1563 for (int dim = 1; dim <= array_type.rank; dim++) {
1564 string length_cname = get_parameter_array_length_cname (param, dim);
1565
1566 cdecl = new CCodeDeclaration ("int");
1567 cdecl.add_declarator (new CCodeVariableDeclarator (length_cname, new CCodeConstant ("0")));
1568 prefragment.append (cdecl);
1569 ccall.add_argument (new CCodeIdentifier (length_cname));
1570 }
1571 }
1572
1573 type_signature += get_type_signature (param.variable_type);
1574
1575 var target = new CCodeIdentifier (param.name);
1576 var expr = read_expression (prefragment, param.variable_type, new CCodeIdentifier ("iter"), target);
1577 prefragment.append (new CCodeExpressionStatement (new CCodeAssignment (target, expr)));
1578
1579 if (requires_destroy (owned_type)) {
1580 // keep local alive (symbol_reference is weak)
1581 var local = new LocalVariable (owned_type, param.name);
1582 var ma = new MemberAccess.simple (param.name);
1583 ma.symbol_reference = local;
1584 ma.value_type = owned_type.copy ();
1585 visit_member_access (ma);
1586 var stmt = new CCodeExpressionStatement (get_unref_expression (new CCodeIdentifier (param.name), owned_type, ma));
1587 postfragment.append (stmt);
1588 }
1589 }
1590
1591 signature_check.add_argument (new CCodeConstant ("\"%s\"".printf (type_signature)));
1592
1593 block.add_statement (new CCodeExpressionStatement (ccall));
1594
1595 block.add_statement (postfragment);
1596
1597 cdecl = new CCodeDeclaration ("DBusMessage*");
1598 cdecl.add_declarator (new CCodeVariableDeclarator ("reply"));
1599 block.add_statement (cdecl);
1600
1601 cfile.add_function_declaration (function);
1602
1603 function.block = block;
1604 cfile.add_function (function);
1605
1606 return wrapper_name;
1607 }
1608
1609 void handle_signal (string dbus_iface_name, string dbus_signal_name, string handler_name, CCodeBlock block, ref CCodeIfStatement clastif) {
1610 var ccheck = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_is_signal"));
1611 ccheck.add_argument (new CCodeIdentifier ("message"));
1612 ccheck.add_argument (new CCodeConstant ("\"%s\"".printf (dbus_iface_name)));
1613 ccheck.add_argument (new CCodeConstant ("\"%s\"".printf (dbus_signal_name)));
1614
1615 var callblock = new CCodeBlock ();
1616
1617 var ccall = new CCodeFunctionCall (new CCodeIdentifier (handler_name));
1618 ccall.add_argument (new CCodeIdentifier ("user_data"));
1619 ccall.add_argument (new CCodeIdentifier ("connection"));
1620 ccall.add_argument (new CCodeIdentifier ("message"));
1621
1622 callblock.add_statement (new CCodeExpressionStatement (ccall));
1623
1624 var cif = new CCodeIfStatement (ccheck, callblock);
1625 if (clastif == null) {
1626 block.add_statement (cif);
1627 } else {
1628 clastif.false_statement = cif;
1629 }
1630
1631 clastif = cif;
1632 }
1633
1634 void handle_signals (Interface iface, CCodeBlock block) {
1635 string dbus_iface_name = get_dbus_name (iface);
1636
1637 CCodeIfStatement clastif = null;
1638 foreach (Signal sig in iface.get_signals ()) {
1639 if (sig.access != SymbolAccessibility.PUBLIC) {
1640 continue;
1641 }
1642
1643 handle_signal (dbus_iface_name, get_dbus_name_for_member (sig), generate_dbus_signal_handler (sig, iface), block, ref clastif);
1644 }
1645 }
1646
1647 void generate_marshalling (Method m, string dbus_iface_name, CCodeFragment prefragment, CCodeFragment postfragment) {
1648 CCodeDeclaration cdecl;
1649
1650 var no_reply = is_dbus_no_reply (m);
1651
1652 var destination = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_proxy_get_bus_name"));
1653 destination.add_argument (new CCodeCastExpression (new CCodeIdentifier ("self"), "DBusGProxy*"));
1654 var path = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_proxy_get_path"));
1655 path.add_argument (new CCodeCastExpression (new CCodeIdentifier ("self"), "DBusGProxy*"));
1656
1657 var msgcall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_new_method_call"));
1658 msgcall.add_argument (destination);
1659 msgcall.add_argument (path);
1660 msgcall.add_argument (new CCodeConstant ("\"%s\"".printf (dbus_iface_name)));
1661 msgcall.add_argument (new CCodeConstant ("\"%s\"".printf (get_dbus_name_for_member (m))));
1662 prefragment.append (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("_message"), msgcall)));
1663
1664 if (no_reply) {
1665 var noreplycall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_set_no_reply"));
1666 noreplycall.add_argument (new CCodeIdentifier ("_message"));
1667 noreplycall.add_argument (new CCodeConstant ("TRUE"));
1668 prefragment.append (new CCodeExpressionStatement (noreplycall));
1669 }
1670
1671 var iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_init_append"));
1672 iter_call.add_argument (new CCodeIdentifier ("_message"));
1673 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_iter")));
1674 prefragment.append (new CCodeExpressionStatement (iter_call));
1675
1676 if (!no_reply) {
1677 iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_init"));
1678 iter_call.add_argument (new CCodeIdentifier ("_reply"));
1679 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_iter")));
1680 postfragment.append (new CCodeExpressionStatement (iter_call));
1681 }
1682
1683 foreach (Parameter param in m.get_parameters ()) {
1684 if (param.direction == ParameterDirection.IN) {
1685 if (param.variable_type.data_type != null
1686 && param.variable_type.data_type.get_full_name () == "DBus.BusName") {
1687 // ignore BusName sender parameters
1688 continue;
1689 }
1690 CCodeExpression expr = new CCodeIdentifier (param.name);
1691 if (param.variable_type.is_real_struct_type ()) {
1692 expr = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, expr);
1693 }
1694 write_expression (prefragment, param.variable_type, new CCodeIdentifier ("_iter"), expr);
1695 } else {
1696 if (no_reply) {
1697 Report.error (param.source_reference, "No-reply DBus methods must not have out parameters");
1698 break;
1699 }
1700 cdecl = new CCodeDeclaration (param.variable_type.get_cname ());
1701 cdecl.add_declarator (new CCodeVariableDeclarator ("_" + param.name));
1702 postfragment.append (cdecl);
1703
1704 var array_type = param.variable_type as ArrayType;
1705
1706 if (array_type != null) {
1707 for (int dim = 1; dim <= array_type.rank; dim++) {
1708 cdecl = new CCodeDeclaration ("int");
1709 cdecl.add_declarator (new CCodeVariableDeclarator ("_%s_length%d".printf (param.name, dim), new CCodeConstant ("0")));
1710 postfragment.append (cdecl);
1711 }
1712 }
1713
1714 var target = new CCodeIdentifier ("_" + param.name);
1715 var expr = read_expression (postfragment, param.variable_type, new CCodeIdentifier ("_iter"), target);
1716 postfragment.append (new CCodeExpressionStatement (new CCodeAssignment (target, expr)));
1717
1718 // TODO check that parameter is not NULL (out parameters are optional)
1719 // free value if parameter is NULL
1720 postfragment.append (new CCodeExpressionStatement (new CCodeAssignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier (param.name)), target)));
1721
1722
1723 if (array_type != null) {
1724 for (int dim = 1; dim <= array_type.rank; dim++) {
1725 // TODO check that parameter is not NULL (out parameters are optional)
1726 postfragment.append (new CCodeExpressionStatement (new CCodeAssignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("%s_length%d".printf (param.name, dim))), new CCodeIdentifier ("_%s_length%d".printf (param.name, dim)))));
1727 }
1728 }
1729 }
1730 }
1731
1732 if (!(m.return_type is VoidType)) {
1733 if (no_reply) {
1734 Report.error (m.return_type.source_reference, "No-reply DBus methods must return void");
1735 }
1736 if (m.return_type.is_real_non_null_struct_type ()) {
1737 var target = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("result"));
1738 var expr = read_expression (postfragment, m.return_type, new CCodeIdentifier ("_iter"), target);
1739 postfragment.append (new CCodeExpressionStatement (new CCodeAssignment (target, expr)));
1740 } else {
1741 cdecl = new CCodeDeclaration (m.return_type.get_cname ());
1742 cdecl.add_declarator (new CCodeVariableDeclarator ("_result"));
1743 postfragment.append (cdecl);
1744
1745 var array_type = m.return_type as ArrayType;
1746
1747 if (array_type != null) {
1748 for (int dim = 1; dim <= array_type.rank; dim++) {
1749 cdecl = new CCodeDeclaration ("int");
1750 cdecl.add_declarator (new CCodeVariableDeclarator ("_result_length%d".printf (dim), new CCodeConstant ("0")));
1751 postfragment.append (cdecl);
1752 }
1753 }
1754
1755 var target = new CCodeIdentifier ("_result");
1756 var expr = read_expression (postfragment, m.return_type, new CCodeIdentifier ("_iter"), target);
1757 postfragment.append (new CCodeExpressionStatement (new CCodeAssignment (target, expr)));
1758
1759 if (array_type != null) {
1760 for (int dim = 1; dim <= array_type.rank; dim++) {
1761 // TODO check that parameter is not NULL (out parameters are optional)
1762 postfragment.append (new CCodeExpressionStatement (new CCodeAssignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("result_length%d".printf (dim))), new CCodeIdentifier ("_result_length%d".printf (dim)))));
1763 }
1764 }
1765 }
1766 }
1767 }
1768
1769 void check_error_reply (Method m, CCodeBlock block) {
1770 var error_types = m.get_error_types ();
1771 if (!has_dbus_error (error_types)) {
1772 Report.error (m.source_reference, "D-Bus methods must throw DBus.Error");
1773 return;
1774 }
1775 if (is_dbus_no_reply (m)) {
1776 // no-reply messages throw no error
1777 return;
1778 }
1779
1780 var dbus_error = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_dbus_error"));
1781
1782 var error_block = new CCodeBlock ();
1783
1784 var cdecl = new CCodeDeclaration ("GQuark");
1785 cdecl.add_declarator (new CCodeVariableDeclarator.zero ("_edomain", new CCodeConstant ("0")));
1786 error_block.add_statement (cdecl);
1787
1788 cdecl = new CCodeDeclaration ("gint");
1789 cdecl.add_declarator (new CCodeVariableDeclarator.zero ("_ecode", new CCodeConstant ("0")));
1790 error_block.add_statement (cdecl);
1791
1792 generate_client_error_cases (error_block, error_types, new CCodeMemberAccess (new CCodeIdentifier ("_dbus_error"), "name"), new CCodeIdentifier ("_edomain"), new CCodeIdentifier ("_ecode"));
1793
1794 var g_set_error = new CCodeFunctionCall (new CCodeIdentifier ("g_set_error"));
1795 g_set_error.add_argument (new CCodeIdentifier ("error"));
1796 g_set_error.add_argument (new CCodeIdentifier ("_edomain"));
1797 g_set_error.add_argument (new CCodeIdentifier ("_ecode"));
1798 g_set_error.add_argument (new CCodeConstant ("\"%s\""));
1799 g_set_error.add_argument (new CCodeMemberAccess (new CCodeIdentifier ("_dbus_error"), "message"));
1800 error_block.add_statement (new CCodeExpressionStatement (g_set_error));
1801
1802 var dbus_error_free = new CCodeFunctionCall (new CCodeIdentifier ("dbus_error_free"));
1803 dbus_error_free.add_argument (dbus_error);
1804 error_block.add_statement (new CCodeExpressionStatement (dbus_error_free));
1805
1806 if (m.return_type is VoidType || m.return_type.is_real_non_null_struct_type ()) {
1807 error_block.add_statement (new CCodeReturnStatement ());
1808 } else {
1809 error_block.add_statement (new CCodeReturnStatement (default_value_for_type (m.return_type, false)));
1810 }
1811
1812 var dbus_error_is_set = new CCodeFunctionCall (new CCodeIdentifier ("dbus_error_is_set"));
1813 dbus_error_is_set.add_argument (dbus_error);
1814 block.add_statement (new CCodeIfStatement (dbus_error_is_set, error_block));
1815 }
1816
1817 string generate_dbus_proxy_method (Interface main_iface, Interface iface, Method m) {
1818 string proxy_name = "%sdbus_proxy_%s".printf (main_iface.get_lower_case_cprefix (), m.name);
1819
1820 string dbus_iface_name = get_dbus_name (iface);
1821
1822 CCodeDeclaration cdecl;
1823
1824 var function = new CCodeFunction (proxy_name);
1825 function.modifiers = CCodeModifiers.STATIC;
1826
1827 var cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
1828
1829 generate_cparameters (m, cfile, cparam_map, function);
1830
1831 var block = new CCodeBlock ();
1832 var prefragment = new CCodeFragment ();
1833 var postfragment = new CCodeFragment ();
1834
1835 // throw error and return if proxy is disposed
1836 var dispose_return_block = new CCodeBlock ();
1837 if (m.get_error_types ().size > 0) {
1838 var set_error_call = new CCodeFunctionCall (new CCodeIdentifier ("g_set_error"));
1839 set_error_call.add_argument (new CCodeIdentifier ("error"));
1840 set_error_call.add_argument (new CCodeIdentifier ("DBUS_GERROR"));
1841 set_error_call.add_argument (new CCodeIdentifier ("DBUS_GERROR_DISCONNECTED"));
1842 set_error_call.add_argument (new CCodeConstant ("\"%s\""));
1843 set_error_call.add_argument (new CCodeConstant ("\"Connection is closed\""));
1844 dispose_return_block.add_statement (new CCodeExpressionStatement (set_error_call));
1845 }
1846 if (m.return_type is VoidType || m.return_type.is_real_non_null_struct_type ()) {
1847 dispose_return_block.add_statement (new CCodeReturnStatement ());
1848 } else {
1849 dispose_return_block.add_statement (new CCodeReturnStatement (default_value_for_type (m.return_type, false)));
1850 }
1851 block.add_statement (new CCodeIfStatement (new CCodeMemberAccess.pointer (new CCodeCastExpression (new CCodeIdentifier ("self"), iface.get_cname () + "DBusProxy*"), "disposed"), dispose_return_block));
1852
1853 cdecl = new CCodeDeclaration ("DBusError");
1854 cdecl.add_declarator (new CCodeVariableDeclarator ("_dbus_error"));
1855 block.add_statement (cdecl);
1856
1857 var dbus_error = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_dbus_error"));
1858
1859 cdecl = new CCodeDeclaration ("DBusGConnection");
1860 cdecl.add_declarator (new CCodeVariableDeclarator ("*_connection"));
1861 block.add_statement (cdecl);
1862
1863 cdecl = new CCodeDeclaration ("DBusMessage");
1864 cdecl.add_declarator (new CCodeVariableDeclarator ("*_message"));
1865 cdecl.add_declarator (new CCodeVariableDeclarator ("*_reply"));
1866 block.add_statement (cdecl);
1867
1868 cdecl = new CCodeDeclaration ("DBusMessageIter");
1869 cdecl.add_declarator (new CCodeVariableDeclarator ("_iter"));
1870 block.add_statement (cdecl);
1871
1872 block.add_statement (prefragment);
1873
1874 generate_marshalling (m, dbus_iface_name, prefragment, postfragment);
1875
1876 var gconnection = new CCodeFunctionCall (new CCodeIdentifier ("g_object_get"));
1877 gconnection.add_argument (new CCodeIdentifier ("self"));
1878 gconnection.add_argument (new CCodeConstant ("\"connection\""));
1879 gconnection.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_connection")));
1880 gconnection.add_argument (new CCodeConstant ("NULL"));
1881 block.add_statement (new CCodeExpressionStatement (gconnection));
1882
1883 var dbus_error_init = new CCodeFunctionCall (new CCodeIdentifier ("dbus_error_init"));
1884 dbus_error_init.add_argument (dbus_error);
1885 block.add_statement (new CCodeExpressionStatement (dbus_error_init));
1886
1887 var connection = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_connection_get_connection"));
1888 connection.add_argument (new CCodeIdentifier ("_connection"));
1889
1890 var ccall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_connection_send_with_reply_and_block"));
1891 ccall.add_argument (connection);
1892 ccall.add_argument (new CCodeIdentifier ("_message"));
1893 ccall.add_argument (get_dbus_timeout (m));
1894 ccall.add_argument (dbus_error);
1895 block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("_reply"), ccall)));
1896
1897 var conn_unref = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_connection_unref"));
1898 conn_unref.add_argument (new CCodeIdentifier ("_connection"));
1899 block.add_statement (new CCodeExpressionStatement (conn_unref));
1900
1901 var message_unref = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_unref"));
1902 message_unref.add_argument (new CCodeIdentifier ("_message"));
1903 block.add_statement (new CCodeExpressionStatement (message_unref));
1904
1905 check_error_reply (m, block);
1906 check_reply_signature (m, block);
1907
1908 block.add_statement (postfragment);
1909
1910 var reply_unref = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_unref"));
1911 reply_unref.add_argument (new CCodeIdentifier ("_reply"));
1912 block.add_statement (new CCodeExpressionStatement (reply_unref));
1913
1914 if (!(m.return_type is VoidType || m.return_type.is_real_non_null_struct_type ())) {
1915 block.add_statement (new CCodeReturnStatement (new CCodeIdentifier ("_result")));
1916 }
1917
1918 cfile.add_function_declaration (function);
1919 function.block = block;
1920 cfile.add_function (function);
1921
1922 return proxy_name;
1923 }
1924
1925 string generate_noreply_dbus_proxy_method (Interface main_iface, Interface iface, Method m) {
1926 string proxy_name = "%sdbus_proxy_%s".printf (main_iface.get_lower_case_cprefix (), m.name);
1927
1928 string dbus_iface_name = get_dbus_name (iface);
1929
1930 CCodeDeclaration cdecl;
1931
1932 var function = new CCodeFunction (proxy_name);
1933 function.modifiers = CCodeModifiers.STATIC;
1934
1935 var cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
1936
1937 generate_cparameters (m, cfile, cparam_map, function);
1938
1939 var block = new CCodeBlock ();
1940 var prefragment = new CCodeFragment ();
1941 var postfragment = new CCodeFragment ();
1942
1943 // throw error and return if proxy is disposed
1944 var dispose_return_block = new CCodeBlock ();
1945 if (m.get_error_types ().size > 0) {
1946 var set_error_call = new CCodeFunctionCall (new CCodeIdentifier ("g_set_error"));
1947 set_error_call.add_argument (new CCodeIdentifier ("error"));
1948 set_error_call.add_argument (new CCodeIdentifier ("DBUS_GERROR"));
1949 set_error_call.add_argument (new CCodeIdentifier ("DBUS_GERROR_DISCONNECTED"));
1950 set_error_call.add_argument (new CCodeConstant ("\"%s\""));
1951 set_error_call.add_argument (new CCodeConstant ("\"Connection is closed\""));
1952 dispose_return_block.add_statement (new CCodeExpressionStatement (set_error_call));
1953 dispose_return_block.add_statement (new CCodeReturnStatement ());
1954 }
1955 block.add_statement (new CCodeIfStatement (new CCodeMemberAccess.pointer (new CCodeCastExpression (new CCodeIdentifier ("self"), iface.get_cname () + "DBusProxy*"), "disposed"), dispose_return_block));
1956
1957 cdecl = new CCodeDeclaration ("DBusGConnection");
1958 cdecl.add_declarator (new CCodeVariableDeclarator ("*_connection"));
1959 block.add_statement (cdecl);
1960
1961 cdecl = new CCodeDeclaration ("DBusMessage");
1962 cdecl.add_declarator (new CCodeVariableDeclarator ("*_message"));
1963 block.add_statement (cdecl);
1964
1965 cdecl = new CCodeDeclaration ("DBusMessageIter");
1966 cdecl.add_declarator (new CCodeVariableDeclarator ("_iter"));
1967 block.add_statement (cdecl);
1968
1969 block.add_statement (prefragment);
1970
1971 generate_marshalling (m, dbus_iface_name, prefragment, postfragment);
1972
1973 var gconnection = new CCodeFunctionCall (new CCodeIdentifier ("g_object_get"));
1974 gconnection.add_argument (new CCodeIdentifier ("self"));
1975 gconnection.add_argument (new CCodeConstant ("\"connection\""));
1976 gconnection.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_connection")));
1977 gconnection.add_argument (new CCodeConstant ("NULL"));
1978 block.add_statement (new CCodeExpressionStatement (gconnection));
1979
1980 var connection = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_connection_get_connection"));
1981 connection.add_argument (new CCodeIdentifier ("_connection"));
1982
1983 var oom_return_block = new CCodeBlock ();
1984 if (m.get_error_types ().size > 0) {
1985 var set_error_call = new CCodeFunctionCall (new CCodeIdentifier ("g_set_error"));
1986 set_error_call.add_argument (new CCodeIdentifier ("error"));
1987 set_error_call.add_argument (new CCodeIdentifier ("DBUS_GERROR"));
1988 set_error_call.add_argument (new CCodeIdentifier ("DBUS_GERROR_NO_MEMORY"));
1989 set_error_call.add_argument (new CCodeConstant ("\"%s\""));
1990 set_error_call.add_argument (new CCodeConstant ("\"Out of memory\""));
1991 oom_return_block.add_statement (new CCodeExpressionStatement (set_error_call));
1992 oom_return_block.add_statement (new CCodeReturnStatement ());
1993 }
1994
1995 var ccall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_connection_send"));
1996 ccall.add_argument (connection);
1997 ccall.add_argument (new CCodeIdentifier ("_message"));
1998 ccall.add_argument (new CCodeConstant ("NULL"));
1999 block.add_statement (new CCodeIfStatement (new CCodeUnaryExpression (CCodeUnaryOperator.LOGICAL_NEGATION, ccall), oom_return_block));
2000
2001 var conn_unref = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_connection_unref"));
2002 conn_unref.add_argument (new CCodeIdentifier ("_connection"));
2003 block.add_statement (new CCodeExpressionStatement (conn_unref));
2004
2005 var message_unref = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_unref"));
2006 message_unref.add_argument (new CCodeIdentifier ("_message"));
2007 block.add_statement (new CCodeExpressionStatement (message_unref));
2008
2009 check_error_reply (m, block);
2010
2011 block.add_statement (postfragment);
2012
2013 cfile.add_function_declaration (function);
2014 function.block = block;
2015 cfile.add_function (function);
2016
2017 return proxy_name;
2018 }
2019
2020 void generate_client_error_cases (CCodeBlock error_block, List<DataType> error_types, CCodeExpression dbus_error_name, CCodeExpression result_edomain, CCodeExpression result_ecode) {
2021 CCodeStatement if_else_if = null;
2022 CCodeIfStatement last_statement = null;
2023
2024 foreach (DataType error_type in error_types) {
2025 var edomain = ((ErrorType) error_type).error_domain;
2026
2027 if (edomain == null) {
2028 Report.error (error_type.source_reference, "Generic errors cannot be serialized over DBus");
2029 continue;
2030 }
2031
2032 var edomain_dbus_name = get_dbus_name (edomain);
2033 if (edomain_dbus_name == null) {
2034 Report.error (edomain.source_reference, "Errordomain must have a DBus.name annotation to be serialized over DBus");
2035 }
2036
2037 var true_block = new CCodeBlock ();
2038 true_block.suppress_newline = true;
2039
2040 string temp_name = "_tmp%d_".printf (next_temp_var_id++);
2041
2042 var cdecl = new CCodeDeclaration ("const char*");
2043 cdecl.add_declarator (new CCodeVariableDeclarator (temp_name));
2044 true_block.add_statement (cdecl);
2045
2046 true_block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (result_edomain, new CCodeIdentifier (edomain.get_upper_case_cname ()))));
2047
2048 true_block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier (temp_name), new CCodeBinaryExpression (CCodeBinaryOperator.PLUS, dbus_error_name, new CCodeConstant ("%ld".printf (edomain_dbus_name.length + 1))))));
2049
2050 CCodeStatement inner_if_else_if = null;
2051 CCodeIfStatement inner_last_statement = null;
2052 foreach (ErrorCode ecode in edomain.get_codes ()) {
2053 var inner_true_block = new CCodeBlock ();
2054 inner_true_block.suppress_newline = true;
2055 inner_true_block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (result_ecode, new CCodeIdentifier (ecode.get_cname ()))));
2056
2057 var ecode_dbus_name = get_dbus_name (ecode);
2058 if (ecode_dbus_name == null) {
2059 ecode_dbus_name = Symbol.lower_case_to_camel_case (ecode.name.down ());
2060 }
2061
2062 var string_comparison = new CCodeFunctionCall (new CCodeIdentifier ("strcmp"));
2063 string_comparison.add_argument (new CCodeIdentifier (temp_name));
2064 string_comparison.add_argument (new CCodeConstant ("\"%s\"".printf (ecode_dbus_name)));
2065 var stmt = new CCodeIfStatement (new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, string_comparison, new CCodeConstant ("0")), inner_true_block);
2066
2067 if (inner_last_statement != null) {
2068 inner_last_statement.false_statement = stmt;
2069 } else {
2070 inner_if_else_if = stmt;
2071 }
2072 inner_last_statement = stmt;
2073 }
2074 true_block.add_statement (inner_if_else_if);
2075
2076 var string_comparison = new CCodeFunctionCall (new CCodeIdentifier ("strstr"));
2077 string_comparison.add_argument (dbus_error_name);
2078 string_comparison.add_argument (new CCodeConstant ("\"%s\"".printf (edomain_dbus_name)));
2079 var stmt = new CCodeIfStatement (new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, string_comparison, dbus_error_name), true_block);
2080
2081 if (last_statement != null) {
2082 last_statement.false_statement = stmt;
2083 } else {
2084 if_else_if = stmt;
2085 }
2086 last_statement = stmt;
2087 }
2088 error_block.add_statement (if_else_if);
2089 }
2090
2091 string generate_async_dbus_proxy_method (Interface main_iface, Interface iface, Method m) {
2092 string proxy_name = "%sdbus_proxy_%s_async".printf (main_iface.get_lower_case_cprefix (), m.name);
2093
2094 string dbus_iface_name = get_dbus_name (iface);
2095
2096 CCodeDeclaration cdecl;
2097
2098
2099 // generate data struct
2100
2101 string dataname = "%sDBusProxy%sData".printf (iface.get_cname (), Symbol.lower_case_to_camel_case (m.name));
2102 var datastruct = new CCodeStruct ("_" + dataname);
2103
2104 datastruct.add_field ("GAsyncReadyCallback", "_callback_");
2105 datastruct.add_field ("gpointer", "_user_data_");
2106 datastruct.add_field ("DBusPendingCall*", "pending");
2107
2108 cfile.add_type_definition (datastruct);
2109 cfile.add_type_declaration (new CCodeTypeDefinition ("struct _" + dataname, new CCodeVariableDeclarator (dataname)));
2110
2111
2112 // generate async function
2113
2114 var function = new CCodeFunction (proxy_name, "void");
2115 function.modifiers = CCodeModifiers.STATIC;
2116
2117 var cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
2118
2119 cparam_map.set (get_param_pos (-1), new CCodeParameter ("_callback_", "GAsyncReadyCallback"));
2120 cparam_map.set (get_param_pos (-0.9), new CCodeParameter ("_user_data_", "gpointer"));
2121
2122 generate_cparameters (m, cfile, cparam_map, function, null, null, null, 1);
2123
2124 var block = new CCodeBlock ();
2125 var prefragment = new CCodeFragment ();
2126 var postfragment = new CCodeFragment ();
2127
2128 cdecl = new CCodeDeclaration ("DBusGConnection");
2129 cdecl.add_declarator (new CCodeVariableDeclarator ("*_connection"));
2130 block.add_statement (cdecl);
2131
2132 cdecl = new CCodeDeclaration ("DBusMessage");
2133 cdecl.add_declarator (new CCodeVariableDeclarator ("*_message"));
2134 block.add_statement (cdecl);
2135
2136 cdecl = new CCodeDeclaration ("DBusPendingCall");
2137 cdecl.add_declarator (new CCodeVariableDeclarator ("*_pending"));
2138 block.add_statement (cdecl);
2139
2140 cdecl = new CCodeDeclaration ("DBusMessageIter");
2141 cdecl.add_declarator (new CCodeVariableDeclarator ("_iter"));
2142 block.add_statement (cdecl);
2143
2144 block.add_statement (prefragment);
2145
2146 generate_marshalling (m, dbus_iface_name, prefragment, postfragment);
2147
2148 var gconnection = new CCodeFunctionCall (new CCodeIdentifier ("g_object_get"));
2149 gconnection.add_argument (new CCodeIdentifier ("self"));
2150 gconnection.add_argument (new CCodeConstant ("\"connection\""));
2151 gconnection.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_connection")));
2152 gconnection.add_argument (new CCodeConstant ("NULL"));
2153 block.add_statement (new CCodeExpressionStatement (gconnection));
2154
2155 var connection = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_connection_get_connection"));
2156 connection.add_argument (new CCodeIdentifier ("_connection"));
2157
2158 var ccall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_connection_send_with_reply"));
2159 ccall.add_argument (connection);
2160 ccall.add_argument (new CCodeIdentifier ("_message"));
2161 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_pending")));
2162 ccall.add_argument (get_dbus_timeout (m));
2163 block.add_statement (new CCodeExpressionStatement (ccall));
2164
2165 var conn_unref = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_connection_unref"));
2166 conn_unref.add_argument (new CCodeIdentifier ("_connection"));
2167 block.add_statement (new CCodeExpressionStatement (conn_unref));
2168
2169 var message_unref = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_unref"));
2170 message_unref.add_argument (new CCodeIdentifier ("_message"));
2171 block.add_statement (new CCodeExpressionStatement (message_unref));
2172
2173 var dataalloc = new CCodeFunctionCall (new CCodeIdentifier ("g_slice_new0"));
2174 dataalloc.add_argument (new CCodeIdentifier (dataname));
2175
2176 var datadecl = new CCodeDeclaration (dataname + "*");
2177 datadecl.add_declarator (new CCodeVariableDeclarator ("_data_"));
2178 block.add_statement (datadecl);
2179 block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("_data_"), dataalloc)));
2180
2181 block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess.pointer (new CCodeIdentifier ("_data_"), "_callback_"), new CCodeIdentifier ("_callback_"))));
2182 block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess.pointer (new CCodeIdentifier ("_data_"), "_user_data_"), new CCodeIdentifier ("_user_data_"))));
2183 block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess.pointer (new CCodeIdentifier ("_data_"), "pending"), new CCodeIdentifier ("_pending"))));
2184
2185 var pending = new CCodeFunctionCall (new CCodeIdentifier ("dbus_pending_call_set_notify"));
2186 pending.add_argument (new CCodeIdentifier ("_pending"));
2187 pending.add_argument (new CCodeIdentifier ("%sdbus_proxy_%s_ready".printf (iface.get_lower_case_cprefix (), m.name)));
2188 pending.add_argument (new CCodeIdentifier ("_data_"));
2189 pending.add_argument (new CCodeConstant ("NULL"));
2190 block.add_statement (new CCodeExpressionStatement (pending));
2191
2192 cfile.add_function_declaration (function);
2193 function.block = block;
2194 cfile.add_function (function);
2195
2196
2197 // generate ready function
2198
2199 function = new CCodeFunction ("%sdbus_proxy_%s_ready".printf (iface.get_lower_case_cprefix (), m.name), "void");
2200 function.modifiers = CCodeModifiers.STATIC;
2201
2202 function.add_parameter (new CCodeParameter ("pending", "DBusPendingCall*"));
2203 function.add_parameter (new CCodeParameter ("user_data", "void*"));
2204
2205 block = new CCodeBlock ();
2206
2207 datadecl = new CCodeDeclaration (dataname + "*");
2208 datadecl.add_declarator (new CCodeVariableDeclarator ("_data_"));
2209 block.add_statement (datadecl);
2210 block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("_data_"), new CCodeIdentifier ("user_data"))));
2211
2212 // complete async call by invoking callback
2213 var obj_decl = new CCodeDeclaration ("GObject *");
2214 obj_decl.add_declarator (new CCodeVariableDeclarator ("_obj_"));
2215 block.add_statement (obj_decl);
2216
2217 var object_creation = new CCodeFunctionCall (new CCodeIdentifier ("g_object_newv"));
2218 object_creation.add_argument (new CCodeConstant ("G_TYPE_OBJECT"));
2219 object_creation.add_argument (new CCodeConstant ("0"));
2220 object_creation.add_argument (new CCodeConstant ("NULL"));
2221 block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("_obj_"), object_creation)));
2222
2223 var async_result_decl = new CCodeDeclaration ("GSimpleAsyncResult *");
2224 async_result_decl.add_declarator (new CCodeVariableDeclarator ("_res_"));
2225 block.add_statement (async_result_decl);
2226
2227 var async_result_creation = new CCodeFunctionCall (new CCodeIdentifier ("g_simple_async_result_new"));
2228 async_result_creation.add_argument (new CCodeIdentifier ("_obj_"));
2229 async_result_creation.add_argument (new CCodeMemberAccess.pointer (new CCodeIdentifier ("_data_"), "_callback_"));
2230 async_result_creation.add_argument (new CCodeMemberAccess.pointer (new CCodeIdentifier ("_data_"), "_user_data_"));
2231 async_result_creation.add_argument (new CCodeIdentifier ("_data_"));
2232 block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("_res_"), async_result_creation)));
2233
2234 var completecall = new CCodeFunctionCall (new CCodeIdentifier ("g_simple_async_result_complete"));
2235 completecall.add_argument (new CCodeIdentifier ("_res_"));
2236 block.add_statement (new CCodeExpressionStatement (completecall));
2237
2238 var obj_free = new CCodeFunctionCall (new CCodeIdentifier ("g_object_unref"));
2239 obj_free.add_argument (new CCodeIdentifier ("_obj_"));
2240 block.add_statement (new CCodeExpressionStatement (obj_free));
2241
2242 var async_result_free = new CCodeFunctionCall (new CCodeIdentifier ("g_object_unref"));
2243 async_result_free.add_argument (new CCodeIdentifier ("_res_"));
2244 block.add_statement (new CCodeExpressionStatement (async_result_free));
2245
2246 var datafree = new CCodeFunctionCall (new CCodeIdentifier ("g_slice_free"));
2247 datafree.add_argument (new CCodeIdentifier (dataname));
2248 datafree.add_argument (new CCodeIdentifier ("_data_"));
2249 block.add_statement (new CCodeExpressionStatement (datafree));
2250
2251 var pendingfree = new CCodeFunctionCall (new CCodeIdentifier ("dbus_pending_call_unref"));
2252 pendingfree.add_argument (new CCodeIdentifier ("pending"));
2253 block.add_statement (new CCodeExpressionStatement (pendingfree));
2254
2255 cfile.add_function_declaration (function);
2256 function.block = block;
2257 cfile.add_function (function);
2258
2259
2260 return proxy_name;
2261 }
2262
2263 CCodeConstant get_reply_signature (Method m) {
2264 // expected type signature for output parameters
2265 string type_signature = "";
2266
2267 foreach (Parameter param in m.get_parameters ()) {
2268 if (param.direction == ParameterDirection.OUT) {
2269 type_signature += get_type_signature (param.variable_type);
2270 }
2271 }
2272
2273 if (!(m.return_type is VoidType)) {
2274 type_signature += get_type_signature (m.return_type);
2275 }
2276
2277 return (new CCodeConstant ("\"%s\"".printf (type_signature)));
2278 }
2279
2280 void check_reply_signature (Method m, CCodeBlock block) {
2281 var reply_unref = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_unref"));
2282 reply_unref.add_argument (new CCodeIdentifier ("_reply"));
2283
2284 var message_signature = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_get_signature"));
2285 message_signature.add_argument (new CCodeIdentifier ("_reply"));
2286
2287 var signature_check = new CCodeFunctionCall (new CCodeIdentifier ("strcmp"));
2288 signature_check.add_argument (message_signature);
2289 signature_check.add_argument (get_reply_signature (m));
2290
2291 var signature_error_block = new CCodeBlock ();
2292 var set_error_call = new CCodeFunctionCall (new CCodeIdentifier ("g_set_error"));
2293 set_error_call.add_argument (new CCodeIdentifier ("error"));
2294 set_error_call.add_argument (new CCodeIdentifier ("DBUS_GERROR"));
2295 set_error_call.add_argument (new CCodeIdentifier ("DBUS_GERROR_INVALID_SIGNATURE"));
2296 set_error_call.add_argument (new CCodeConstant ("\"Invalid signature, expected \\\"%s\\\", got \\\"%s\\\"\""));
2297 set_error_call.add_argument (get_reply_signature (m));
2298 set_error_call.add_argument (message_signature);
2299 signature_error_block.add_statement (new CCodeExpressionStatement (set_error_call));
2300 signature_error_block.add_statement (new CCodeExpressionStatement (reply_unref));
2301 signature_error_block.add_statement (new CCodeReturnStatement (default_value_for_type (m.return_type, false)));
2302
2303 block.add_statement (new CCodeIfStatement (signature_check, signature_error_block));
2304 }
2305
2306 string generate_finish_dbus_proxy_method (Interface main_iface, Interface iface, Method m) {
2307 string proxy_name = "%sdbus_proxy_%s_finish".printf (main_iface.get_lower_case_cprefix (), m.name);
2308
2309 string dbus_iface_name = get_dbus_name (iface);
2310
2311 CCodeDeclaration cdecl;
2312
2313 var function = new CCodeFunction (proxy_name);
2314 function.modifiers = CCodeModifiers.STATIC;
2315
2316 var cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
2317
2318 cparam_map.set (get_param_pos (0.1), new CCodeParameter ("_res_", "GAsyncResult*"));
2319
2320 generate_cparameters (m, cfile, cparam_map, function, null, null, null, 2);
2321
2322 var block = new CCodeBlock ();
2323 var prefragment = new CCodeFragment ();
2324 var postfragment = new CCodeFragment ();
2325
2326 string dataname = "%sDBusProxy%sData".printf (iface.get_cname (), Symbol.lower_case_to_camel_case (m.name));
2327 cdecl = new CCodeDeclaration (dataname + "*");
2328 cdecl.add_declarator (new CCodeVariableDeclarator ("_data_"));
2329 block.add_statement (cdecl);
2330
2331 cdecl = new CCodeDeclaration ("DBusError");
2332 cdecl.add_declarator (new CCodeVariableDeclarator ("_dbus_error"));
2333 block.add_statement (cdecl);
2334
2335 var dbus_error = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_dbus_error"));
2336
2337 cdecl = new CCodeDeclaration ("DBusMessage");
2338 cdecl.add_declarator (new CCodeVariableDeclarator ("*_reply"));
2339 block.add_statement (cdecl);
2340
2341 cdecl = new CCodeDeclaration ("DBusMessageIter");
2342 cdecl.add_declarator (new CCodeVariableDeclarator ("_iter"));
2343 block.add_statement (cdecl);
2344
2345 var get_source_tag = new CCodeFunctionCall (new CCodeIdentifier ("g_simple_async_result_get_source_tag"));
2346 get_source_tag.add_argument (new CCodeCastExpression (new CCodeIdentifier ("_res_"), "GSimpleAsyncResult *"));
2347 block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("_data_"), get_source_tag)));
2348
2349 var dbus_error_init = new CCodeFunctionCall (new CCodeIdentifier ("dbus_error_init"));
2350 dbus_error_init.add_argument (dbus_error);
2351 block.add_statement (new CCodeExpressionStatement (dbus_error_init));
2352
2353 var ccall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_pending_call_steal_reply"));
2354 ccall.add_argument (new CCodeMemberAccess.pointer (new CCodeIdentifier ("_data_"), "pending"));
2355 block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("_reply"), ccall)));
2356
2357 var set_error_from_message = new CCodeFunctionCall (new CCodeIdentifier ("dbus_set_error_from_message"));
2358 set_error_from_message.add_argument (dbus_error);
2359 set_error_from_message.add_argument (new CCodeIdentifier ("_reply"));
2360 block.add_statement (new CCodeExpressionStatement (set_error_from_message));
2361
2362 check_error_reply (m, block);
2363 check_reply_signature (m, block);
2364
2365 generate_marshalling (m, dbus_iface_name, prefragment, postfragment);
2366
2367 block.add_statement (postfragment);
2368
2369 var reply_unref = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_unref"));
2370 reply_unref.add_argument (new CCodeIdentifier ("_reply"));
2371 block.add_statement (new CCodeExpressionStatement (reply_unref));
2372
2373 if (!(m.return_type is VoidType || m.return_type.is_real_non_null_struct_type ())) {
2374 block.add_statement (new CCodeReturnStatement (new CCodeIdentifier ("_result")));
2375 }
2376
2377 cfile.add_function_declaration (function);
2378 function.block = block;
2379 cfile.add_function (function);
2380
2381 return proxy_name;
2382 }
2383
2384 void check_property_error_reply (PropertyAccessor acc, CCodeBlock block) {
2385 var dbus_error = new CCodeIdentifier ("_dbus_error");
2386 var dbus_error_ptr = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, dbus_error);
2387
2388 var error_block = new CCodeBlock ();
2389
2390 var ccritical = new CCodeFunctionCall (new CCodeIdentifier ("g_critical"));
2391 ccritical.add_argument (new CCodeConstant ("\"file %s: line %d: uncaught error: %s (%s)\""));
2392 ccritical.add_argument (new CCodeConstant ("__FILE__"));
2393 ccritical.add_argument (new CCodeConstant ("__LINE__"));
2394 ccritical.add_argument (new CCodeMemberAccess (dbus_error, "message"));
2395 ccritical.add_argument (new CCodeMemberAccess (dbus_error, "name"));
2396
2397 error_block.add_statement (new CCodeExpressionStatement (ccritical));
2398
2399 var dbus_error_free = new CCodeFunctionCall (new CCodeIdentifier ("dbus_error_free"));
2400 dbus_error_free.add_argument (dbus_error_ptr);
2401 error_block.add_statement (new CCodeExpressionStatement (dbus_error_free));
2402
2403 if (acc.readable && !acc.value_type.is_real_non_null_struct_type ()) {
2404 error_block.add_statement (new CCodeReturnStatement (default_value_for_type (acc.value_type, false)));
2405 } else {
2406 error_block.add_statement (new CCodeReturnStatement ());
2407 }
2408
2409 var dbus_error_is_set = new CCodeFunctionCall (new CCodeIdentifier ("dbus_error_is_set"));
2410 dbus_error_is_set.add_argument (dbus_error_ptr);
2411 block.add_statement (new CCodeIfStatement (dbus_error_is_set, error_block));
2412 }
2413
2414 CCodeConstant get_property_reply_signature (PropertyAccessor acc) {
2415 if (acc.readable) {
2416 return new CCodeConstant ("\"v\"");
2417 } else {
2418 return new CCodeConstant ("\"\"");
2419 }
2420 }
2421
2422 CCodeConstant get_property_inner_signature (PropertyAccessor acc) {
2423 return new CCodeConstant ("\"%s\"".printf (get_type_signature (acc.value_type)));
2424 }
2425
2426 void check_property_reply_signature (PropertyAccessor acc, CCodeBlock block) {
2427 var reply_unref = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_unref"));
2428 reply_unref.add_argument (new CCodeIdentifier ("_reply"));
2429
2430 var message_signature = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_get_signature"));
2431 message_signature.add_argument (new CCodeIdentifier ("_reply"));
2432
2433 var signature_check = new CCodeFunctionCall (new CCodeIdentifier ("strcmp"));
2434 signature_check.add_argument (message_signature);
2435 signature_check.add_argument (get_property_reply_signature (acc));
2436
2437 var signature_error_block = new CCodeBlock ();
2438
2439 var ccritical = new CCodeFunctionCall (new CCodeIdentifier ("g_critical"));
2440 ccritical.add_argument (new CCodeConstant ("\"file %s: line %d: Invalid signature, expected \\\"%s\\\", got \\\"%s\\\"\""));
2441 ccritical.add_argument (new CCodeConstant ("__FILE__"));
2442 ccritical.add_argument (new CCodeConstant ("__LINE__"));
2443 ccritical.add_argument (get_property_reply_signature (acc));
2444 ccritical.add_argument (message_signature);
2445
2446 signature_error_block.add_statement (new CCodeExpressionStatement (ccritical));
2447 signature_error_block.add_statement (new CCodeExpressionStatement (reply_unref));
2448
2449 if (acc.readable && !acc.value_type.is_real_non_null_struct_type ()) {
2450 signature_error_block.add_statement (new CCodeReturnStatement (default_value_for_type (acc.value_type, false)));
2451 } else {
2452 signature_error_block.add_statement (new CCodeReturnStatement ());
2453 }
2454
2455 block.add_statement (new CCodeIfStatement (signature_check, signature_error_block));
2456 }
2457
2458 void check_property_inner_signature (PropertyAccessor acc, CCodeFragment fragment) {
2459 var reply_unref = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_unref"));
2460 reply_unref.add_argument (new CCodeIdentifier ("_reply"));
2461
2462 var iter_signature = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_get_signature"));
2463 iter_signature.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_subiter")));
2464
2465 var signature_check = new CCodeFunctionCall (new CCodeIdentifier ("strcmp"));
2466 signature_check.add_argument (iter_signature);
2467 signature_check.add_argument (get_property_inner_signature (acc));
2468
2469 var signature_error_block = new CCodeBlock ();
2470
2471 var ccritical = new CCodeFunctionCall (new CCodeIdentifier ("g_critical"));
2472 ccritical.add_argument (new CCodeConstant ("\"file %s: line %d: Invalid signature, expected \\\"%s\\\", got \\\"%s\\\"\""));
2473 ccritical.add_argument (new CCodeConstant ("__FILE__"));
2474 ccritical.add_argument (new CCodeConstant ("__LINE__"));
2475 ccritical.add_argument (get_property_inner_signature (acc));
2476 ccritical.add_argument (iter_signature);
2477
2478 signature_error_block.add_statement (new CCodeExpressionStatement (ccritical));
2479 signature_error_block.add_statement (new CCodeExpressionStatement (reply_unref));
2480
2481 if (!acc.value_type.is_real_non_null_struct_type ()) {
2482 signature_error_block.add_statement (new CCodeReturnStatement (default_value_for_type (acc.value_type, false)));
2483 } else {
2484 signature_error_block.add_statement (new CCodeReturnStatement ());
2485 }
2486
2487 fragment.append (new CCodeIfStatement (signature_check, signature_error_block));
2488 }
2489
2490 string generate_dbus_proxy_property_get (Interface main_iface, Interface iface, Property prop) {
2491 string proxy_name = "%sdbus_proxy_get_%s".printf (main_iface.get_lower_case_cprefix (), prop.name);
2492
2493 string dbus_iface_name = get_dbus_name (iface);
2494
2495 var owned_type = prop.get_accessor.value_type.copy ();
2496 owned_type.value_owned = true;
2497 if (owned_type.is_disposable () && !prop.get_accessor.value_type.value_owned) {
2498 Report.error (prop.get_accessor.value_type.source_reference, "Properties used in D-Bus clients require owned get accessor");
2499 }
2500
2501 var array_type = prop.get_accessor.value_type as ArrayType;
2502
2503 CCodeDeclaration cdecl;
2504
2505 var function = new CCodeFunction (proxy_name);
2506 function.modifiers = CCodeModifiers.STATIC;
2507
2508 function.add_parameter (new CCodeParameter ("self", "%s*".printf (iface.get_cname ())));
2509
2510 if (prop.property_type.is_real_non_null_struct_type ()) {
2511 function.add_parameter (new CCodeParameter ("result", "%s*".printf (prop.get_accessor.value_type.get_cname ())));
2512 } else {
2513 if (array_type != null) {
2514 for (int dim = 1; dim <= array_type.rank; dim++) {
2515 function.add_parameter (new CCodeParameter ("result_length%d".printf (dim), "int*"));
2516 }
2517 }
2518
2519 function.return_type = prop.get_accessor.value_type.get_cname ();
2520 }
2521
2522 var block = new CCodeBlock ();
2523 var prefragment = new CCodeFragment ();
2524 var postfragment = new CCodeFragment ();
2525
2526 var dispose_return_block = new CCodeBlock ();
2527 if (prop.property_type.is_real_non_null_struct_type ()) {
2528 dispose_return_block.add_statement (new CCodeReturnStatement ());
2529 } else {
2530 dispose_return_block.add_statement (new CCodeReturnStatement (default_value_for_type (prop.property_type, false)));
2531 }
2532 block.add_statement (new CCodeIfStatement (new CCodeMemberAccess.pointer (new CCodeCastExpression (new CCodeIdentifier ("self"), iface.get_cname () + "DBusProxy*"), "disposed"), dispose_return_block));
2533
2534 cdecl = new CCodeDeclaration ("DBusError");
2535 cdecl.add_declarator (new CCodeVariableDeclarator ("_dbus_error"));
2536 block.add_statement (cdecl);
2537
2538 var dbus_error = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_dbus_error"));
2539
2540 cdecl = new CCodeDeclaration ("DBusGConnection");
2541 cdecl.add_declarator (new CCodeVariableDeclarator ("*_connection"));
2542 block.add_statement (cdecl);
2543
2544 cdecl = new CCodeDeclaration ("DBusMessage");
2545 cdecl.add_declarator (new CCodeVariableDeclarator ("*_message"));
2546 cdecl.add_declarator (new CCodeVariableDeclarator ("*_reply"));
2547 block.add_statement (cdecl);
2548
2549 cdecl = new CCodeDeclaration ("DBusMessageIter");
2550 cdecl.add_declarator (new CCodeVariableDeclarator ("_iter"));
2551 cdecl.add_declarator (new CCodeVariableDeclarator ("_subiter"));
2552 block.add_statement (cdecl);
2553
2554 block.add_statement (prefragment);
2555
2556 var destination = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_proxy_get_bus_name"));
2557 destination.add_argument (new CCodeCastExpression (new CCodeIdentifier ("self"), "DBusGProxy*"));
2558 var path = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_proxy_get_path"));
2559 path.add_argument (new CCodeCastExpression (new CCodeIdentifier ("self"), "DBusGProxy*"));
2560
2561 var msgcall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_new_method_call"));
2562 msgcall.add_argument (destination);
2563 msgcall.add_argument (path);
2564 msgcall.add_argument (new CCodeConstant ("\"org.freedesktop.DBus.Properties\""));
2565 msgcall.add_argument (new CCodeConstant ("\"Get\""));
2566 prefragment.append (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("_message"), msgcall)));
2567
2568 var iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_init_append"));
2569 iter_call.add_argument (new CCodeIdentifier ("_message"));
2570 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_iter")));
2571 prefragment.append (new CCodeExpressionStatement (iter_call));
2572
2573 iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_init"));
2574 iter_call.add_argument (new CCodeIdentifier ("_reply"));
2575 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_iter")));
2576 postfragment.append (new CCodeExpressionStatement (iter_call));
2577
2578 // interface name
2579 write_expression (prefragment, string_type, new CCodeIdentifier ("_iter"), new CCodeConstant ("\"%s\"".printf (dbus_iface_name)));
2580 // property name
2581 write_expression (prefragment, string_type, new CCodeIdentifier ("_iter"), new CCodeConstant ("\"%s\"".printf (get_dbus_name_for_member (prop))));
2582
2583 iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_recurse"));
2584 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_iter")));
2585 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_subiter")));
2586 postfragment.append (new CCodeExpressionStatement (iter_call));
2587
2588 check_property_inner_signature (prop.get_accessor, postfragment);
2589
2590 if (prop.property_type.is_real_non_null_struct_type ()) {
2591 var target = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("result"));
2592 var expr = read_expression (postfragment, prop.get_accessor.value_type, new CCodeIdentifier ("_subiter"), target);
2593 postfragment.append (new CCodeExpressionStatement (new CCodeAssignment (target, expr)));
2594 } else {
2595 cdecl = new CCodeDeclaration (prop.get_accessor.value_type.get_cname ());
2596 cdecl.add_declarator (new CCodeVariableDeclarator ("_result"));
2597 postfragment.append (cdecl);
2598
2599 if (array_type != null) {
2600 for (int dim = 1; dim <= array_type.rank; dim++) {
2601 cdecl = new CCodeDeclaration ("int");
2602 cdecl.add_declarator (new CCodeVariableDeclarator ("_result_length%d".printf (dim), new CCodeConstant ("0")));
2603 postfragment.append (cdecl);
2604 }
2605 }
2606
2607 var target = new CCodeIdentifier ("_result");
2608 var expr = read_expression (postfragment, prop.get_accessor.value_type, new CCodeIdentifier ("_subiter"), target);
2609 postfragment.append (new CCodeExpressionStatement (new CCodeAssignment (target, expr)));
2610
2611 if (array_type != null) {
2612 for (int dim = 1; dim <= array_type.rank; dim++) {
2613 // TODO check that parameter is not NULL (out parameters are optional)
2614 postfragment.append (new CCodeExpressionStatement (new CCodeAssignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("result_length%d".printf (dim))), new CCodeIdentifier ("_result_length%d".printf (dim)))));
2615 }
2616 }
2617 }
2618
2619 var gconnection = new CCodeFunctionCall (new CCodeIdentifier ("g_object_get"));
2620 gconnection.add_argument (new CCodeIdentifier ("self"));
2621 gconnection.add_argument (new CCodeConstant ("\"connection\""));
2622 gconnection.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_connection")));
2623 gconnection.add_argument (new CCodeConstant ("NULL"));
2624 block.add_statement (new CCodeExpressionStatement (gconnection));
2625
2626 var dbus_error_init = new CCodeFunctionCall (new CCodeIdentifier ("dbus_error_init"));
2627 dbus_error_init.add_argument (dbus_error);
2628 block.add_statement (new CCodeExpressionStatement (dbus_error_init));
2629
2630 var connection = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_connection_get_connection"));
2631 connection.add_argument (new CCodeIdentifier ("_connection"));
2632
2633 var ccall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_connection_send_with_reply_and_block"));
2634 ccall.add_argument (connection);
2635 ccall.add_argument (new CCodeIdentifier ("_message"));
2636 ccall.add_argument (get_dbus_timeout (prop));
2637 ccall.add_argument (dbus_error);
2638 block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("_reply"), ccall)));
2639
2640 var conn_unref = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_connection_unref"));
2641 conn_unref.add_argument (new CCodeIdentifier ("_connection"));
2642 block.add_statement (new CCodeExpressionStatement (conn_unref));
2643
2644 var message_unref = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_unref"));
2645 message_unref.add_argument (new CCodeIdentifier ("_message"));
2646 block.add_statement (new CCodeExpressionStatement (message_unref));
2647
2648 check_property_error_reply (prop.get_accessor, block);
2649 check_property_reply_signature (prop.get_accessor, block);
2650
2651 block.add_statement (postfragment);
2652
2653 var reply_unref = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_unref"));
2654 reply_unref.add_argument (new CCodeIdentifier ("_reply"));
2655 block.add_statement (new CCodeExpressionStatement (reply_unref));
2656
2657 if (prop.property_type.is_real_non_null_struct_type ()) {
2658 block.add_statement (new CCodeReturnStatement ());
2659 } else {
2660 block.add_statement (new CCodeReturnStatement (new CCodeIdentifier ("_result")));
2661 }
2662
2663 cfile.add_function_declaration (function);
2664 function.block = block;
2665 cfile.add_function (function);
2666
2667 return proxy_name;
2668 }
2669
2670 string generate_dbus_proxy_property_set (Interface main_iface, Interface iface, Property prop) {
2671 string proxy_name = "%sdbus_proxy_set_%s".printf (main_iface.get_lower_case_cprefix (), prop.name);
2672
2673 string dbus_iface_name = get_dbus_name (iface);
2674
2675 var array_type = prop.set_accessor.value_type as ArrayType;
2676
2677 CCodeDeclaration cdecl;
2678
2679 var function = new CCodeFunction (proxy_name);
2680 function.modifiers = CCodeModifiers.STATIC;
2681
2682 function.add_parameter (new CCodeParameter ("self", "%s*".printf (iface.get_cname ())));
2683
2684 if (prop.property_type.is_real_non_null_struct_type ()) {
2685 function.add_parameter (new CCodeParameter ("value", "%s*".printf (prop.set_accessor.value_type.get_cname ())));
2686 } else {
2687 function.add_parameter (new CCodeParameter ("value", prop.set_accessor.value_type.get_cname ()));
2688
2689 if (array_type != null) {
2690 for (int dim = 1; dim <= array_type.rank; dim++) {
2691 function.add_parameter (new CCodeParameter ("value_length%d".printf (dim), "int"));
2692 }
2693 }
2694 }
2695
2696 var block = new CCodeBlock ();
2697 var prefragment = new CCodeFragment ();
2698 var postfragment = new CCodeFragment ();
2699
2700 var dispose_return_block = new CCodeBlock ();
2701 dispose_return_block.add_statement (new CCodeReturnStatement ());
2702 block.add_statement (new CCodeIfStatement (new CCodeMemberAccess.pointer (new CCodeCastExpression (new CCodeIdentifier ("self"), iface.get_cname () + "DBusProxy*"), "disposed"), dispose_return_block));
2703
2704 cdecl = new CCodeDeclaration ("DBusError");
2705 cdecl.add_declarator (new CCodeVariableDeclarator ("_dbus_error"));
2706 block.add_statement (cdecl);
2707
2708 var dbus_error = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_dbus_error"));
2709
2710 cdecl = new CCodeDeclaration ("DBusGConnection");
2711 cdecl.add_declarator (new CCodeVariableDeclarator ("*_connection"));
2712 block.add_statement (cdecl);
2713
2714 cdecl = new CCodeDeclaration ("DBusMessage");
2715 cdecl.add_declarator (new CCodeVariableDeclarator ("*_message"));
2716 cdecl.add_declarator (new CCodeVariableDeclarator ("*_reply"));
2717 block.add_statement (cdecl);
2718
2719 cdecl = new CCodeDeclaration ("DBusMessageIter");
2720 cdecl.add_declarator (new CCodeVariableDeclarator ("_iter"));
2721 cdecl.add_declarator (new CCodeVariableDeclarator ("_subiter"));
2722 block.add_statement (cdecl);
2723
2724 block.add_statement (prefragment);
2725
2726 var destination = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_proxy_get_bus_name"));
2727 destination.add_argument (new CCodeCastExpression (new CCodeIdentifier ("self"), "DBusGProxy*"));
2728 var path = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_proxy_get_path"));
2729 path.add_argument (new CCodeCastExpression (new CCodeIdentifier ("self"), "DBusGProxy*"));
2730
2731 var msgcall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_new_method_call"));
2732 msgcall.add_argument (destination);
2733 msgcall.add_argument (path);
2734 msgcall.add_argument (new CCodeConstant ("\"org.freedesktop.DBus.Properties\""));
2735 msgcall.add_argument (new CCodeConstant ("\"Set\""));
2736 prefragment.append (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("_message"), msgcall)));
2737
2738 var iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_init_append"));
2739 iter_call.add_argument (new CCodeIdentifier ("_message"));
2740 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_iter")));
2741 prefragment.append (new CCodeExpressionStatement (iter_call));
2742
2743 iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_init"));
2744 iter_call.add_argument (new CCodeIdentifier ("_reply"));
2745 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_iter")));
2746 postfragment.append (new CCodeExpressionStatement (iter_call));
2747
2748 // interface name
2749 write_expression (prefragment, string_type, new CCodeIdentifier ("_iter"), new CCodeConstant ("\"%s\"".printf (dbus_iface_name)));
2750 // property name
2751 write_expression (prefragment, string_type, new CCodeIdentifier ("_iter"), new CCodeConstant ("\"%s\"".printf (get_dbus_name_for_member (prop))));
2752
2753 // property value (as variant)
2754 iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_open_container"));
2755 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_iter")));
2756 iter_call.add_argument (new CCodeIdentifier ("DBUS_TYPE_VARIANT"));
2757 iter_call.add_argument (new CCodeConstant ("\"%s\"".printf (get_type_signature (prop.property_type))));
2758 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_subiter")));
2759 prefragment.append (new CCodeExpressionStatement (iter_call));
2760
2761 if (prop.property_type.is_real_non_null_struct_type ()) {
2762 write_expression (prefragment, prop.set_accessor.value_type, new CCodeIdentifier ("_subiter"), new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("value")));
2763 } else {
2764 write_expression (prefragment, prop.set_accessor.value_type, new CCodeIdentifier ("_subiter"), new CCodeIdentifier ("value"));
2765 }
2766
2767 iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_close_container"));
2768 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_iter")));
2769 iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_subiter")));
2770 prefragment.append (new CCodeExpressionStatement (iter_call));
2771
2772 var gconnection = new CCodeFunctionCall (new CCodeIdentifier ("g_object_get"));
2773 gconnection.add_argument (new CCodeIdentifier ("self"));
2774 gconnection.add_argument (new CCodeConstant ("\"connection\""));
2775 gconnection.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_connection")));
2776 gconnection.add_argument (new CCodeConstant ("NULL"));
2777 block.add_statement (new CCodeExpressionStatement (gconnection));
2778
2779 var dbus_error_init = new CCodeFunctionCall (new CCodeIdentifier ("dbus_error_init"));
2780 dbus_error_init.add_argument (dbus_error);
2781 block.add_statement (new CCodeExpressionStatement (dbus_error_init));
2782
2783 var connection = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_connection_get_connection"));
2784 connection.add_argument (new CCodeIdentifier ("_connection"));
2785
2786 var ccall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_connection_send_with_reply_and_block"));
2787 ccall.add_argument (connection);
2788 ccall.add_argument (new CCodeIdentifier ("_message"));
2789 ccall.add_argument (get_dbus_timeout (prop));
2790 ccall.add_argument (dbus_error);
2791 block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("_reply"), ccall)));
2792
2793 var conn_unref = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_connection_unref"));
2794 conn_unref.add_argument (new CCodeIdentifier ("_connection"));
2795 block.add_statement (new CCodeExpressionStatement (conn_unref));
2796
2797 var message_unref = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_unref"));
2798 message_unref.add_argument (new CCodeIdentifier ("_message"));
2799 block.add_statement (new CCodeExpressionStatement (message_unref));
2800
2801 check_property_error_reply (prop.set_accessor, block);
2802 check_property_reply_signature (prop.set_accessor, block);
2803
2804 block.add_statement (postfragment);
2805
2806 var reply_unref = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_unref"));
2807 reply_unref.add_argument (new CCodeIdentifier ("_reply"));
2808 block.add_statement (new CCodeExpressionStatement (reply_unref));
2809
2810 cfile.add_function_declaration (function);
2811 function.block = block;
2812 cfile.add_function (function);
2813
2814 return proxy_name;
2815 }
2816 }
vala-lang from freesmartphone.org