source: trunk/ORBit2-2.14.0/src/idl-compiler/orbit-idl-utils.c

Last change on this file was 92, checked in by cinc, 19 years ago

Orbit2 modified for use with NOM
File size: 22.1 KB
Line 
1#include "config.h"
2#include "orbit-idl2.h"
3#include <string.h>
4
5void
6orbit_idl_check_oneway_op (IDL_tree op)
7{
8 g_assert (IDL_NODE_TYPE(op) == IDLN_OP_DCL);
9
10 if (IDL_OP_DCL (op).f_oneway) {
11 IDL_tree sub;
12
13 for (sub = IDL_OP_DCL (op).parameter_dcls; sub; sub = IDL_LIST (sub).next) {
14 IDL_tree param = IDL_LIST (sub).data;
15
16 if (IDL_PARAM_DCL (param).attr == IDL_PARAM_OUT ||
17 IDL_PARAM_DCL (param).attr == IDL_PARAM_INOUT) {
18 g_warning ("Out or Inout parameter in declaration of oneway '%s'",
19 IDL_IDENT(IDL_OP_DCL(op).ident).str);
20 break;
21 }
22 }
23
24 if (IDL_OP_DCL (op).op_type_spec)
25 g_warning ("Return value in declaration of oneway '%s'",
26 IDL_IDENT(IDL_OP_DCL(op).ident).str);
27 }
28}
29
30void
31orbit_idl_attr_fake_ops(IDL_tree attr, IDL_ns ns)
32{
33 IDL_tree attr_name, ident, curnode, op1, op2, intf;
34 GString *attrname;
35 OIDL_Attr_Info *setme;
36
37 g_assert(attr && IDL_NODE_TYPE(attr) == IDLN_ATTR_DCL);
38
39 attrname = g_string_new(NULL);
40
41 for(curnode = IDL_ATTR_DCL(attr).simple_declarations; curnode; curnode = IDL_LIST(curnode).next) {
42 op1 = op2 = NULL;
43
44 attr_name = IDL_LIST(curnode).data;
45
46 g_string_printf(attrname, "_get_%s",
47 IDL_IDENT(attr_name).str);
48 ident = IDL_ident_new(g_strdup(attrname->str));
49 IDL_IDENT_TO_NS(ident) = IDL_IDENT_TO_NS(attr_name);
50 op1 = IDL_op_dcl_new(0, IDL_ATTR_DCL(attr).param_type_spec, ident, NULL, NULL, NULL);
51 IDL_NODE_UP(op1) = IDL_NODE_UP(attr);
52 intf = IDL_NODE_UP (IDL_NODE_UP (op1));
53 IDL_NS(ns).current = IDL_IDENT_TO_NS (IDL_INTERFACE (intf).ident);
54 IDL_ns_place_new(ns, ident);
55
56 if(!IDL_ATTR_DCL(attr).f_readonly) {
57 g_string_printf(attrname, "_set_%s",
58 IDL_IDENT(attr_name).str);
59 ident = IDL_ident_new(g_strdup(attrname->str));
60 IDL_IDENT_TO_NS(ident) = IDL_IDENT_TO_NS(attr_name);
61 op2 = IDL_op_dcl_new(0, NULL, ident, NULL, NULL, NULL);
62 IDL_NODE_UP(op2) = IDL_NODE_UP(attr);
63 intf = IDL_NODE_UP (IDL_NODE_UP (op2));
64 IDL_NS(ns).current = IDL_IDENT_TO_NS (IDL_INTERFACE (intf).ident);
65 IDL_ns_place_new(ns, ident);
66 IDL_OP_DCL(op2).parameter_dcls = IDL_list_new(
67 IDL_param_dcl_new(IDL_PARAM_IN,
68 IDL_ATTR_DCL(attr).param_type_spec,
69 IDL_ident_new(g_strdup("value"))));
70 }
71
72 setme = g_new0(OIDL_Attr_Info, 1);
73 setme->op1 = op1;
74 setme->op2 = op2;
75 attr_name->data = setme;
76 }
77
78 g_string_free(attrname, TRUE);
79}
80
81#define INDENT_INCREMENT_1 2
82#define INDENT_INCREMENT_2 4
83
84static void do_indent(int level) {
85 int i;
86 for(i = 0; i < level; i++) g_print(" ");
87}
88
89static const char * const nodenames[] = {
90 "DATUM",
91 "LOOP",
92 "SWITCH",
93 "CASE",
94 "COMPLEX",
95 "CONST",
96 "SET",
97 NULL
98};
99
100void
101orbit_idl_print_node(IDL_tree node, int indent_level)
102{
103 IDL_tree curnode;
104 char *s;
105
106 do_indent(indent_level);
107
108 if(node == NULL) {
109 g_print("(null)\n");
110 return;
111 }
112
113 g_print("[%d] ", IDL_NODE_REFS(node));
114
115 switch(IDL_NODE_TYPE(node)) {
116
117 case IDLN_NONE:
118 g_print("NONE\n");
119 break;
120
121 case IDLN_LIST:
122 g_print("LIST:\n");
123 for(curnode = node; curnode;
124 curnode = IDL_LIST(curnode).next) {
125 orbit_idl_print_node(IDL_LIST(curnode).data, indent_level + INDENT_INCREMENT_1);
126 }
127 break;
128
129 case IDLN_GENTREE:
130 break;
131
132 case IDLN_INTEGER:
133 g_print("INTEGER: %" IDL_LL "d\n", IDL_INTEGER(node).value);
134 break;
135
136 case IDLN_STRING:
137 g_print("STRING: %s\n", IDL_STRING(node).value);
138 break;
139
140 case IDLN_WIDE_STRING:
141 g_print("WIDE STRING: %ls\n", IDL_WIDE_STRING(node).value);
142 break;
143
144 case IDLN_CHAR:
145 g_print("CHAR: %s\n", IDL_CHAR(node).value);
146 break;
147
148 case IDLN_WIDE_CHAR:
149 g_print("WIDE CHAR: %ls\n", IDL_WIDE_CHAR(node).value);
150 break;
151
152 case IDLN_FIXED:
153 g_print("FIXED: %s\n", IDL_FIXED(node).value);
154 break;
155
156 case IDLN_FLOAT:
157 g_print("FLOAT: %f\n", IDL_FLOAT(node).value);
158 break;
159
160 case IDLN_BOOLEAN:
161 g_print("BOOLEAN: %s\n", (IDL_BOOLEAN(node).value)?"True":"False");
162 break;
163
164 case IDLN_IDENT:
165 s = IDL_ns_ident_to_qstring(IDL_IDENT_TO_NS(node), "_", 0);
166 g_print("IDENT: %s NSQ: %s RID: \"%s\"\n",
167 IDL_IDENT(node).str, s,
168 IDL_IDENT_REPO_ID(node) ? IDL_IDENT_REPO_ID(node) : "");
169 g_free(s);
170 break;
171
172 case IDLN_TYPE_DCL:
173 g_print("TYPE DCL:\n");
174 orbit_idl_print_node(IDL_TYPE_DCL(node).type_spec, indent_level + INDENT_INCREMENT_1);
175 do_indent(indent_level + INDENT_INCREMENT_1); g_print("decls:\n");
176 orbit_idl_print_node(IDL_TYPE_DCL(node).dcls, indent_level + INDENT_INCREMENT_2);
177 break;
178
179 case IDLN_CONST_DCL:
180 g_print("CONST DCL:\n");
181 orbit_idl_print_node(IDL_CONST_DCL(node).const_type, indent_level + INDENT_INCREMENT_1);
182 do_indent(indent_level + INDENT_INCREMENT_1); g_print("ident:\n");
183 orbit_idl_print_node(IDL_CONST_DCL(node).ident, indent_level + INDENT_INCREMENT_2);
184 do_indent(indent_level + INDENT_INCREMENT_1); g_print("const_exp:\n");
185 orbit_idl_print_node(IDL_CONST_DCL(node).const_exp, indent_level + INDENT_INCREMENT_2);
186 break;
187
188 case IDLN_EXCEPT_DCL:
189 g_print("EXCEPT DCL:\n");
190 orbit_idl_print_node(IDL_EXCEPT_DCL(node).ident, indent_level + INDENT_INCREMENT_1);
191 do_indent(indent_level + INDENT_INCREMENT_1); g_print("members:\n");
192 orbit_idl_print_node(IDL_EXCEPT_DCL(node).members, indent_level + INDENT_INCREMENT_2);
193 break;
194
195 case IDLN_ATTR_DCL:
196 g_print("ATTR_DCL (%s):\n", (IDL_ATTR_DCL(node).f_readonly)?"readonly":"rw");
197 orbit_idl_print_node(IDL_ATTR_DCL(node).param_type_spec, indent_level + INDENT_INCREMENT_1);
198 do_indent(indent_level + INDENT_INCREMENT_1); g_print("simple_declarations:\n");
199 orbit_idl_print_node(IDL_ATTR_DCL(node).simple_declarations, indent_level + INDENT_INCREMENT_2);
200 break;
201
202 case IDLN_OP_DCL:
203 g_print("OP DCL (%s):\n", (IDL_OP_DCL(node).f_oneway)?"oneway":"normal");
204 orbit_idl_print_node(IDL_OP_DCL(node).ident, indent_level + INDENT_INCREMENT_1);
205 do_indent(indent_level + INDENT_INCREMENT_1); g_print("op_type_spec:\n");
206 orbit_idl_print_node(IDL_OP_DCL(node).op_type_spec, indent_level + INDENT_INCREMENT_2);
207 do_indent(indent_level + INDENT_INCREMENT_1); g_print("parameter_dcls:\n");
208 orbit_idl_print_node(IDL_OP_DCL(node).parameter_dcls, indent_level + INDENT_INCREMENT_2);
209 do_indent(indent_level + INDENT_INCREMENT_1); g_print("raises_expr:\n");
210 orbit_idl_print_node(IDL_OP_DCL(node).raises_expr, indent_level + INDENT_INCREMENT_2);
211 do_indent(indent_level + INDENT_INCREMENT_1); g_print("context_expr:\n");
212 orbit_idl_print_node(IDL_OP_DCL(node).context_expr, indent_level + INDENT_INCREMENT_2);
213 break;
214
215 case IDLN_PARAM_DCL:
216 g_print("PARAM DCL: ");
217 switch(IDL_PARAM_DCL(node).attr) {
218 case IDL_PARAM_IN: g_print("(in)\n"); break;
219 case IDL_PARAM_OUT: g_print("(out)\n"); break;
220 case IDL_PARAM_INOUT: g_print("(inout)\n"); break;
221 }
222 orbit_idl_print_node(IDL_PARAM_DCL(node).param_type_spec, indent_level + INDENT_INCREMENT_1);
223 do_indent(indent_level + INDENT_INCREMENT_1); g_print("simple_declarator:\n");
224 orbit_idl_print_node(IDL_PARAM_DCL(node).simple_declarator, indent_level + INDENT_INCREMENT_2);
225 break;
226 case IDLN_FORWARD_DCL:
227 g_print("FORWARD DCL:\n");
228 orbit_idl_print_node(IDL_FORWARD_DCL(node).ident, indent_level + INDENT_INCREMENT_1);
229 break;
230 case IDLN_INTERFACE:
231 g_print("INTERFACE:\n");
232 orbit_idl_print_node(IDL_INTERFACE(node).ident, indent_level + INDENT_INCREMENT_1);
233 do_indent(indent_level + INDENT_INCREMENT_1); g_print("inheritance_spec:\n");
234 orbit_idl_print_node(IDL_INTERFACE(node).inheritance_spec, indent_level + INDENT_INCREMENT_2);
235 do_indent(indent_level + INDENT_INCREMENT_1); g_print("body:\n");
236 orbit_idl_print_node(IDL_INTERFACE(node).body, indent_level + INDENT_INCREMENT_2);
237 break;
238 case IDLN_MODULE:
239 g_print("MODULE:\n");
240 orbit_idl_print_node(IDL_MODULE(node).ident, indent_level + INDENT_INCREMENT_1);
241 do_indent(indent_level + INDENT_INCREMENT_1); g_print("definition_list:\n");
242 orbit_idl_print_node(IDL_MODULE(node).definition_list, indent_level + INDENT_INCREMENT_2);
243 break;
244
245 case IDLN_TYPE_INTEGER:
246 if(!IDL_TYPE_INTEGER(node).f_signed) g_print("TYPE unsigned ");
247 switch(IDL_TYPE_INTEGER(node).f_type) {
248 case IDL_INTEGER_TYPE_SHORT: g_print("short\n"); break;
249 case IDL_INTEGER_TYPE_LONG: g_print("long\n"); break;
250 case IDL_INTEGER_TYPE_LONGLONG: g_print("long long\n"); break;
251 }
252 break;
253 case IDLN_TYPE_FLOAT:
254 switch(IDL_TYPE_FLOAT(node).f_type) {
255 case IDL_FLOAT_TYPE_FLOAT: g_print("TYPE float\n"); break;
256 case IDL_FLOAT_TYPE_DOUBLE: g_print("TYPE double\n"); break;
257 case IDL_FLOAT_TYPE_LONGDOUBLE: g_print("TYPE long double\n"); break;
258 }
259 break;
260 case IDLN_TYPE_FIXED:
261 g_print("TYPE fixed:\n");
262 orbit_idl_print_node(IDL_TYPE_FIXED(node).positive_int_const, indent_level + INDENT_INCREMENT_1);
263 orbit_idl_print_node(IDL_TYPE_FIXED(node).integer_lit, indent_level + INDENT_INCREMENT_1);
264 break;
265 case IDLN_TYPE_STRING:
266 g_print("TYPE string:\n");
267 orbit_idl_print_node(IDL_TYPE_STRING(node).positive_int_const, indent_level + INDENT_INCREMENT_1);
268 break;
269 case IDLN_TYPE_WIDE_STRING:
270 g_print("TYPE wide string:\n");
271 orbit_idl_print_node(IDL_TYPE_WIDE_STRING(node).positive_int_const, indent_level + INDENT_INCREMENT_1);
272 break;
273 case IDLN_TYPE_ENUM:
274 g_print("TYPE enum:\n");
275 orbit_idl_print_node(IDL_TYPE_ENUM(node).ident, indent_level + INDENT_INCREMENT_1);
276 do_indent(indent_level + INDENT_INCREMENT_1); g_print("enumerator_list:\n");
277 orbit_idl_print_node(IDL_TYPE_ENUM(node).enumerator_list, indent_level + INDENT_INCREMENT_2);
278 break;
279 case IDLN_TYPE_ARRAY:
280 g_print("TYPE array:\n");
281 orbit_idl_print_node(IDL_TYPE_ARRAY(node).ident, indent_level + INDENT_INCREMENT_1);
282 do_indent(indent_level + INDENT_INCREMENT_1); g_print("size_list:\n");
283 orbit_idl_print_node(IDL_TYPE_ARRAY(node).size_list, indent_level + INDENT_INCREMENT_2);
284 break;
285 case IDLN_TYPE_SEQUENCE:
286 g_print("TYPE sequence:\n");
287 orbit_idl_print_node(IDL_TYPE_SEQUENCE(node).simple_type_spec, indent_level + INDENT_INCREMENT_1);
288 do_indent(indent_level + INDENT_INCREMENT_1); g_print("positive_int_const:\n");
289 orbit_idl_print_node(IDL_TYPE_SEQUENCE(node).positive_int_const, indent_level + INDENT_INCREMENT_2);
290 break;
291 case IDLN_TYPE_STRUCT:
292 g_print("TYPE struct:\n");
293 orbit_idl_print_node(IDL_TYPE_STRUCT(node).ident, indent_level + INDENT_INCREMENT_1);
294 do_indent(indent_level + INDENT_INCREMENT_1); g_print("member_list:\n");
295 orbit_idl_print_node(IDL_TYPE_STRUCT(node).member_list, indent_level + INDENT_INCREMENT_2);
296 break;
297 case IDLN_TYPE_UNION:
298 g_print("TYPE union:\n");
299 orbit_idl_print_node(IDL_TYPE_UNION(node).ident, indent_level + INDENT_INCREMENT_1);
300 do_indent(indent_level + INDENT_INCREMENT_1); g_print("switch_type_spec:\n");
301 orbit_idl_print_node(IDL_TYPE_UNION(node).switch_type_spec, indent_level + INDENT_INCREMENT_2);
302 do_indent(indent_level + INDENT_INCREMENT_1); g_print("switch_body:\n");
303 orbit_idl_print_node(IDL_TYPE_UNION(node).switch_body, indent_level + INDENT_INCREMENT_2);
304 break;
305 case IDLN_MEMBER:
306 g_print("MEMBER:\n");
307 orbit_idl_print_node(IDL_MEMBER(node).type_spec, indent_level + INDENT_INCREMENT_1);
308 do_indent(indent_level + INDENT_INCREMENT_1); g_print("dcls:\n");
309 orbit_idl_print_node(IDL_MEMBER(node).dcls, indent_level + INDENT_INCREMENT_2);
310 break;
311 case IDLN_CASE_STMT:
312 g_print("CASE_STMT:\n");
313 orbit_idl_print_node(IDL_CASE_STMT(node).labels, indent_level + INDENT_INCREMENT_1);
314 do_indent(indent_level + INDENT_INCREMENT_1); g_print("element_spec:\n");
315 orbit_idl_print_node(IDL_CASE_STMT(node).element_spec, indent_level + INDENT_INCREMENT_2);
316 break;
317 case IDLN_BINOP:
318 g_print("BINOP ");
319 switch(IDL_BINOP(node).op) {
320 case IDL_BINOP_OR: g_print("or:\n"); break;
321 case IDL_BINOP_XOR: g_print("xor:\n"); break;
322 case IDL_BINOP_AND: g_print("and:\n"); break;
323 case IDL_BINOP_SHR: g_print("shr:\n"); break;
324 case IDL_BINOP_SHL: g_print("shl:\n"); break;
325 case IDL_BINOP_ADD: g_print("add:\n"); break;
326 case IDL_BINOP_SUB: g_print("sub:\n"); break;
327 case IDL_BINOP_MULT: g_print("mult:\n"); break;
328 case IDL_BINOP_DIV: g_print("div:\n"); break;
329 case IDL_BINOP_MOD: g_print("mod:\n"); break;
330 }
331 do_indent(indent_level + INDENT_INCREMENT_1); g_print("left:\n");
332 orbit_idl_print_node(IDL_BINOP(node).left, indent_level + INDENT_INCREMENT_2);
333 do_indent(indent_level + INDENT_INCREMENT_1); g_print("right:\n");
334 orbit_idl_print_node(IDL_BINOP(node).right, indent_level + INDENT_INCREMENT_2);
335 break;
336 case IDLN_UNARYOP:
337 g_print("UNARYOP ");
338 switch(IDL_UNARYOP(node).op) {
339 case IDL_UNARYOP_PLUS: g_print("plus:\n"); break;
340 case IDL_UNARYOP_MINUS: g_print("minus:\n"); break;
341 case IDL_UNARYOP_COMPLEMENT: g_print("complement:\n"); break;
342 }
343 orbit_idl_print_node(IDL_UNARYOP(node).operand, indent_level + INDENT_INCREMENT_1);
344 break;
345 case IDLN_TYPE_CHAR:
346 g_print("TYPE char\n");
347 break;
348 case IDLN_TYPE_WIDE_CHAR:
349 g_print("TYPE wide char\n");
350 break;
351 case IDLN_TYPE_BOOLEAN:
352 g_print("TYPE boolean\n");
353 break;
354 case IDLN_TYPE_OCTET:
355 g_print("TYPE octet\n");
356 break;
357 case IDLN_TYPE_OBJECT:
358 g_print("TYPE object\n");
359 break;
360 case IDLN_TYPE_ANY:
361 g_print("TYPE any\n");
362 break;
363 case IDLN_TYPE_TYPECODE:
364 g_print("TYPE TypeCode\n");
365 break;
366 case IDLN_CODEFRAG:
367 g_print("CODEFRAG\n");
368 break;
369 default:
370 g_print("unhandled %d\n", IDL_NODE_TYPE(node));
371 }
372}
373
374static void
375IDL_tree_traverse_helper(IDL_tree p, GFunc f,
376 gconstpointer func_data,
377 GHashTable *visited_nodes,
378 gboolean include_self)
379{
380 IDL_tree curitem;
381
382 if (g_hash_table_lookup (visited_nodes, p))
383 return;
384
385 g_hash_table_insert (visited_nodes, p, ((gpointer)1));
386
387 for (curitem = IDL_INTERFACE (p).inheritance_spec; curitem;
388 curitem = IDL_LIST (curitem).next) {
389 IDL_tree_traverse_helper (IDL_get_parent_node
390 (IDL_LIST (curitem).data, IDLN_INTERFACE, NULL), f, func_data, visited_nodes, TRUE);
391 }
392
393 if (include_self)
394 f(p, (gpointer)func_data);
395}
396
397void
398IDL_tree_traverse_parents_full (IDL_tree p,
399 GFunc f,
400 gconstpointer func_data,
401 gboolean include_self)
402{
403 GHashTable *visited_nodes = g_hash_table_new (NULL, g_direct_equal);
404
405 if (!(p && f))
406 return;
407
408 if (IDL_NODE_TYPE(p) != IDLN_INTERFACE)
409 p = IDL_get_parent_node (p, IDLN_INTERFACE, NULL);
410
411 if (!p)
412 return;
413
414 IDL_tree_traverse_helper (p, f, func_data, visited_nodes, include_self);
415
416 g_hash_table_destroy (visited_nodes);
417}
418
419void
420IDL_tree_traverse_parents (IDL_tree p,
421 GFunc f,
422 gconstpointer func_data)
423{
424 IDL_tree_traverse_parents_full (p, f, func_data, TRUE);
425}
426
427/* For use by below function */
428static const int * const
429orbit_cbe_get_typeoffsets_table (void)
430{
431 static int typeoffsets[IDLN_LAST];
432 static gboolean initialized = FALSE;
433
434 if (!initialized) {
435 int i;
436
437 for (i = 0; i < IDLN_LAST; ++i)
438 typeoffsets[i] = -1;
439
440 typeoffsets[IDLN_FORWARD_DCL] = 8; /* (same as objref) */
441 typeoffsets[IDLN_TYPE_INTEGER] = 0;
442 typeoffsets[IDLN_TYPE_FLOAT] = 0;
443 typeoffsets[IDLN_TYPE_FIXED] = 3;
444 typeoffsets[IDLN_TYPE_CHAR] = 5;
445 typeoffsets[IDLN_TYPE_WIDE_CHAR] = 6;
446 typeoffsets[IDLN_TYPE_STRING] = 12;
447 typeoffsets[IDLN_TYPE_WIDE_STRING] = 13;
448 typeoffsets[IDLN_TYPE_BOOLEAN] = 4;
449 typeoffsets[IDLN_TYPE_OCTET] = 7;
450 typeoffsets[IDLN_TYPE_ANY] = 16;
451 typeoffsets[IDLN_TYPE_OBJECT] = 9;
452 typeoffsets[IDLN_TYPE_TYPECODE] = 9;
453 typeoffsets[IDLN_TYPE_ENUM] = 8;
454 typeoffsets[IDLN_TYPE_SEQUENCE] = 14;
455 typeoffsets[IDLN_TYPE_ARRAY] = 15;
456 typeoffsets[IDLN_TYPE_STRUCT] = 10;
457 typeoffsets[IDLN_TYPE_UNION] = 11;
458 typeoffsets[IDLN_NATIVE] = 15; /* no pointers ever, same as fixed array */
459 typeoffsets[IDLN_INTERFACE] = 9; /* (same as objref) */
460
461 initialized = TRUE;
462 }
463
464 return typeoffsets;
465}
466
467
468/**
469 This is a rather hairy function. Its purpose is to output the
470 required number of *'s that indicate the amount of indirection
471 for input, output, & input-output parameters, and return
472 values. We do this by having a table of the number of *'s for
473 each type and purpose (nptrrefs_required), taken from 19.20
474 of the CORBA 2.2 spec, and then having a table that translates
475 from the IDLN_* enums into an index into nptrrefs_required (typeoffsets)
476**/
477gint
478oidl_param_info(IDL_tree in_param, IDL_ParamRole role, gboolean *isSlice)
479{
480 IDL_tree param;
481 const int * const typeoffsets = orbit_cbe_get_typeoffsets_table ();
482 const int nptrrefs_required[][4] = {
483 {0,1,1,0} /* float */,
484 {0,1,1,0} /* double */,
485 {0,1,1,0} /* long double */,
486 {1,1,1,0} /* fixed_d_s 3 */,
487 {0,1,1,0} /* boolean */,
488 {0,1,1,0} /* char */,
489 {0,1,1,0} /* wchar */,
490 {0,1,1,0} /* octet */,
491 {0,1,1,0} /* enum */,
492 {0,1,1,0} /* objref */,
493 {1,1,1,0} /* fixed struct 10 */,
494 {1,1,1,0} /* fixed union */,
495 {0,1,1,0} /* string */,
496 {0,1,1,0} /* wstring */,
497 {1,1,2,1} /* sequence */,
498 {0,0,0,0} /* fixed array */,
499 {1,1,2,1} /* any 16 */
500 };
501 int retval = 0;
502 int typeidx;
503
504 *isSlice = FALSE;
505
506 if(!in_param)
507 return 0; /* void */
508
509 /* Now, how do we use this table? :) */
510 param = orbit_cbe_get_typespec (in_param);
511
512 g_assert (param);
513
514 switch (IDL_NODE_TYPE (param)) {
515 case IDLN_TYPE_STRUCT:
516 case IDLN_TYPE_UNION:
517 if (((role == DATA_RETURN) || (role == DATA_OUT)) &&
518 !orbit_cbe_type_is_fixed_length(param))
519 retval++;
520 break;
521
522 case IDLN_TYPE_ARRAY:
523 if ( role == DATA_RETURN ) {
524 *isSlice = TRUE;
525 retval = 1;
526
527 } else if (role == DATA_OUT &&
528 !orbit_cbe_type_is_fixed_length (param)) {
529 *isSlice = TRUE;
530 retval = 2;
531 }
532 break;
533
534 case IDLN_NATIVE:
535 if ( IDL_NATIVE (param).user_type
536 && strcmp (IDL_NATIVE (param).user_type,
537 "IDL_variable_length_struct") == 0 )
538 return role == DATA_OUT ? 2 : 1;
539 break;
540
541 case IDLN_EXCEPT_DCL:
542 fprintf (stderr, "Error: exception declared at '%s:%d' cannot be "
543 "used as a method parameter\n", in_param->_file,
544 in_param->_line);
545 exit (1);
546 break;
547 default:
548 break;
549 }
550
551 /* ERROR ! */
552 typeidx = typeoffsets [IDL_NODE_TYPE (param)];
553 g_assert (typeidx >= 0);
554
555 switch (role) {
556 case DATA_IN:
557 role = 0;
558 break;
559 case DATA_INOUT:
560 role = 1;
561 break;
562 case DATA_OUT:
563 role = 2;
564 break;
565 case DATA_RETURN:
566 role = 3;
567 break;
568 default:
569 g_assert_not_reached ();
570 break;
571 }
572
573 retval += nptrrefs_required [typeidx] [role];
574
575 return retval;
576}
577
578/**
579 Fixed-length-ness is a property that CORBA defines, and it is
580 a property of each type, not each kind. Furthermore, it doesnt
581 depend on the language mapping. Generally, the GIOP coding
582 a fixed length variable will be a known length (determined by the TC),
583 regardless of the data within the variable.
584
585 With the C mapping, fixed --> nothing to free in this node
586 Note that in the C mapping, everything is a struct and is
587 fixed length in that sense. Thus variable length types show
588 up in C as pointers.
589
590 Recursive types introduced by sequences are not a problem for this
591 func, because sequences are not fixed length, and terminate
592 the recursion.
593**/
594
595gboolean
596orbit_cbe_type_is_fixed_length(IDL_tree ts)
597{
598 gboolean is_fixed = TRUE;
599 IDL_tree curitem;
600
601 ts = orbit_cbe_get_typespec(ts);
602 switch(IDL_NODE_TYPE(ts)) {
603 case IDLN_TYPE_FLOAT:
604 case IDLN_TYPE_INTEGER:
605 case IDLN_TYPE_ENUM:
606 case IDLN_TYPE_CHAR:
607 case IDLN_TYPE_WIDE_CHAR:
608 case IDLN_TYPE_OCTET:
609 case IDLN_TYPE_BOOLEAN:
610 return TRUE;
611 break;
612 case IDLN_TYPE_SEQUENCE:
613 case IDLN_TYPE_STRING:
614 case IDLN_TYPE_WIDE_STRING:
615 case IDLN_TYPE_OBJECT:
616 case IDLN_FORWARD_DCL:
617 case IDLN_INTERFACE:
618 case IDLN_TYPE_ANY:
619 case IDLN_NATIVE:
620 case IDLN_TYPE_TYPECODE:
621 return FALSE;
622 break;
623 case IDLN_TYPE_UNION:
624 for(curitem = IDL_TYPE_UNION(ts).switch_body; curitem;
625 curitem = IDL_LIST(curitem).next) {
626 is_fixed &= orbit_cbe_type_is_fixed_length(IDL_LIST(IDL_CASE_STMT(IDL_LIST(curitem).data).element_spec).data);
627 }
628 return is_fixed;
629 break;
630 case IDLN_EXCEPT_DCL:
631 case IDLN_TYPE_STRUCT:
632 for(curitem = IDL_TYPE_STRUCT(ts).member_list; curitem;
633 curitem = IDL_LIST(curitem).next) {
634 is_fixed &= orbit_cbe_type_is_fixed_length(IDL_LIST(curitem).data);
635 }
636 return is_fixed;
637 break;
638 case IDLN_TYPE_ARRAY:
639 return orbit_cbe_type_is_fixed_length(IDL_TYPE_DCL(IDL_get_parent_node(ts, IDLN_TYPE_DCL, NULL)).type_spec);
640 break;
641 case IDLN_TYPE_DCL:
642 return orbit_cbe_type_is_fixed_length(IDL_TYPE_DCL(ts).type_spec);
643 break;
644 case IDLN_IDENT:
645 case IDLN_LIST:
646 return orbit_cbe_type_is_fixed_length(IDL_NODE_UP(ts));
647 break;
648 case IDLN_MEMBER:
649 return orbit_cbe_type_is_fixed_length(IDL_MEMBER(ts).type_spec);
650 break;
651 default:
652 g_warning("I'm not sure if type %s is fixed-length", IDL_tree_type_names[IDL_NODE_TYPE(ts)]);
653 return FALSE;
654 }
655}
656
657IDL_tree
658orbit_cbe_get_typespec(IDL_tree node)
659{
660 if(node == NULL)
661 return NULL;
662
663 switch(IDL_NODE_TYPE(node)) {
664 case IDLN_TYPE_INTEGER:
665 case IDLN_TYPE_FLOAT:
666 case IDLN_TYPE_FIXED:
667 case IDLN_TYPE_CHAR:
668 case IDLN_TYPE_WIDE_CHAR:
669 case IDLN_TYPE_STRING:
670 case IDLN_TYPE_WIDE_STRING:
671 case IDLN_TYPE_BOOLEAN:
672 case IDLN_TYPE_OCTET:
673 case IDLN_TYPE_ANY:
674 case IDLN_TYPE_OBJECT:
675 case IDLN_TYPE_ENUM:
676 case IDLN_TYPE_SEQUENCE:
677 case IDLN_TYPE_ARRAY:
678 case IDLN_TYPE_STRUCT:
679 case IDLN_TYPE_UNION:
680 case IDLN_EXCEPT_DCL:
681 case IDLN_FORWARD_DCL:
682 case IDLN_INTERFACE:
683 case IDLN_NATIVE:
684 case IDLN_TYPE_TYPECODE:
685 return node;
686 break;
687 case IDLN_TYPE_DCL:
688 return orbit_cbe_get_typespec(IDL_TYPE_DCL(node).type_spec);
689 break;
690 case IDLN_PARAM_DCL:
691 return orbit_cbe_get_typespec(IDL_PARAM_DCL(node).param_type_spec);
692 break;
693 case IDLN_MEMBER:
694 return orbit_cbe_get_typespec(IDL_MEMBER(node).type_spec);
695 break;
696 case IDLN_LIST:
697 case IDLN_IDENT:
698 return orbit_cbe_get_typespec(IDL_get_parent_node(node, IDLN_ANY, NULL));
699 break;
700 default:
701 g_error("Unhandled node type %s!", IDL_tree_type_names[IDL_NODE_TYPE(node)]);
702 return NULL;
703 }
704}
705
706IDL_ParamRole
707oidl_attr_to_paramrole(enum IDL_param_attr attr)
708{
709 switch(attr) {
710 case IDL_PARAM_IN:
711 return DATA_IN;
712 case IDL_PARAM_OUT:
713 return DATA_OUT;
714 case IDL_PARAM_INOUT:
715 return DATA_INOUT;
716 default:
717 g_warning("Unknown IDL_param_attr %d", attr);
718 return -1;
719 }
720}
Note: See TracBrowser for help on using the repository browser.