forb-idl/forb-idl-utils.c

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