← Back to branch summary

~ubuntu-branches/ubuntu/vivid/vala/vivid

« back to all changes in this revision

Viewing changes to codegen/valadbusservermodule.vala

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge
  • Date: 2010-07-28 07:58:01 UTC
  • mfrom: (1.5.5 upstream) (7.3.14 experimental)
  • Revision ID: james.westby@ubuntu.com-20100728075801-18u9cg5hv5oety6m
Tags: 0.9.4-1
New upstream development release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
codegen/valadbusservermodule.vala
181
181
                string type_signature = "";
182
182
 
183
183
                foreach (FormalParameter param in m.get_parameters ()) {
184
 
                        var owned_type = param.parameter_type.copy ();
 
184
                        var owned_type = param.variable_type.copy ();
185
185
                        owned_type.value_owned = true;
186
186
 
187
187
                        cdecl = new CCodeDeclaration (owned_type.get_cname ());
188
 
                        cdecl.add_declarator (new CCodeVariableDeclarator.zero (param.name, default_value_for_type (param.parameter_type, true)));
 
188
                        cdecl.add_declarator (new CCodeVariableDeclarator.zero (param.name, default_value_for_type (param.variable_type, true)));
189
189
                        if (param.direction == ParameterDirection.IN) {
190
190
                                in_prefragment.append (cdecl);
191
191
                        } else {
193
193
                        }
194
194
                        if (type_signature == ""
195
195
                            && param.direction == ParameterDirection.IN
196
 
                            && param.parameter_type.data_type != null
197
 
                            && param.parameter_type.data_type.get_full_name () == "DBus.BusName") {
 
196
                            && param.variable_type.data_type != null
 
197
                            && param.variable_type.data_type.get_full_name () == "DBus.BusName") {
198
198
                                // first parameter is a string parameter called 'sender'
199
199
                                // pass bus name of sender
200
200
                                var get_sender = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_get_sender"));
203
203
                                continue;
204
204
                        }
205
205
 
206
 
                        if (get_type_signature (param.parameter_type) == null) {
207
 
                                Report.error (param.parameter_type.source_reference, "D-Bus serialization of type `%s' is not supported".printf (param.parameter_type.to_string ()));
 
206
                        if (get_type_signature (param.variable_type) == null) {
 
207
                                Report.error (param.variable_type.source_reference, "D-Bus serialization of type `%s' is not supported".printf (param.variable_type.to_string ()));
208
208
                                continue;
209
209
                        }
210
210
 
211
211
                        if (!m.coroutine || param.direction == ParameterDirection.IN) {
212
 
                                var st = param.parameter_type.data_type as Struct;
 
212
                                var st = param.variable_type.data_type as Struct;
213
213
                                if (param.direction != ParameterDirection.IN
214
214
                                    || (st != null && !st.is_simple_type ())) {
215
215
                                        ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (param.name)));
220
220
                                finish_ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (param.name)));
221
221
                        }
222
222
 
223
 
                        if (param.parameter_type is ArrayType) {
224
 
                                var array_type = (ArrayType) param.parameter_type;
 
223
                        if (param.variable_type is ArrayType) {
 
224
                                var array_type = (ArrayType) param.variable_type;
225
225
 
226
226
                                for (int dim = 1; dim <= array_type.rank; dim++) {
227
227
                                        string length_cname = get_array_length_cname (param.name, dim);
244
244
                        }
245
245
 
246
246
                        if (param.direction == ParameterDirection.IN) {
247
 
                                type_signature += get_type_signature (param.parameter_type);
 
247
                                type_signature += get_type_signature (param.variable_type);
248
248
 
249
249
                                var target = new CCodeIdentifier (param.name);
250
 
                                var expr = read_expression (in_prefragment, param.parameter_type, new CCodeIdentifier ("iter"), target);
 
250
                                var expr = read_expression (in_prefragment, param.variable_type, new CCodeIdentifier ("iter"), target);
251
251
                                in_prefragment.append (new CCodeExpressionStatement (new CCodeAssignment (target, expr)));
252
252
                        } else {
253
 
                                write_expression (out_postfragment, param.parameter_type, new CCodeIdentifier ("iter"), new CCodeIdentifier (param.name));
 
253
                                write_expression (out_postfragment, param.variable_type, new CCodeIdentifier ("iter"), new CCodeIdentifier (param.name));
254
254
                        }
255
255
 
256
256
                        if (requires_destroy (owned_type)) {
496
496
                        generate_parameter (param, source_declarations, new HashMap<int,CCodeFormalParameter> (), null);
497
497
 
498
498
                        function.add_parameter ((CCodeFormalParameter) get_ccodenode (param));
499
 
                        if (param.parameter_type is ArrayType) {
500
 
                                var array_type = (ArrayType) param.parameter_type;
 
499
                        if (param.variable_type is ArrayType) {
 
500
                                var array_type = (ArrayType) param.variable_type;
501
501
                                for (int dim = 1; dim <= array_type.rank; dim++) {
502
502
                                        function.add_parameter (new CCodeFormalParameter (head.get_array_length_cname (param.name, dim), "int"));
503
503
                                }
540
540
 
541
541
                foreach (FormalParameter param in sig.get_parameters ()) {
542
542
                        CCodeExpression expr = new CCodeIdentifier (param.name);
543
 
                        if (param.parameter_type.is_real_struct_type ()) {
 
543
                        if (param.variable_type.is_real_struct_type ()) {
544
544
                                expr = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, expr);
545
545
                        }
546
 
                        write_expression (prefragment, param.parameter_type, new CCodeIdentifier ("_iter"), expr);
 
546
                        write_expression (prefragment, param.variable_type, new CCodeIdentifier ("_iter"), expr);
547
547
                }
548
548
 
549
549
                var ccall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_connection_send"));
1295
1295
                        result += "  <method name=\"%s\">\n".printf (get_dbus_name_for_member (m));
1296
1296
 
1297
1297
                        foreach (var param in m.get_parameters ()) {
1298
 
                                if (param.parameter_type.data_type != null
1299
 
                                    && param.parameter_type.data_type.get_full_name () == "DBus.BusName") {
 
1298
                                if (param.variable_type.data_type != null
 
1299
                                    && param.variable_type.data_type.get_full_name () == "DBus.BusName") {
1300
1300
                                        // skip sender parameter
1301
1301
                                        // (implicit in D-Bus)
1302
1302
                                        continue;
1303
1303
                                }
1304
1304
 
1305
1305
                                string direction = param.direction == ParameterDirection.IN ? "in" : "out";
1306
 
                                result += "    <arg name=\"%s\" type=\"%s\" direction=\"%s\"/>\n".printf (param.name, get_type_signature (param.parameter_type), direction);
 
1306
                                result += "    <arg name=\"%s\" type=\"%s\" direction=\"%s\"/>\n".printf (param.name, get_type_signature (param.variable_type), direction);
1307
1307
                        }
1308
1308
                        if (!(m.return_type is VoidType)) {
1309
1309
                                result += "    <arg name=\"%s\" type=\"%s\" direction=\"out\"/>\n".printf (dbus_result_name (m), get_type_signature (m.return_type));
1336
1336
                        result += "  <signal name=\"%s\">\n".printf (get_dbus_name_for_member (sig));
1337
1337
 
1338
1338
                        foreach (var param in sig.get_parameters ()) {
1339
 
                                result += "    <arg name=\"%s\" type=\"%s\"/>\n".printf (param.name, get_type_signature (param.parameter_type));
 
1339
                                result += "    <arg name=\"%s\" type=\"%s\"/>\n".printf (param.name, get_type_signature (param.variable_type));
1340
1340
                        }
1341
1341
 
1342
1342
                        result += "  </signal>\n";