static CORBA_UnionMemberSeq * MateCORBA_imodule_get_union_members (GHashTable *typecodes, IDL_tree tree, CORBA_TypeCode switchtc, CORBA_Environment *ev) { CORBA_UnionMemberSeq *members; IDL_tree l; int num_members = 0; int i; g_return_val_if_fail (IDL_NODE_TYPE (tree) == IDLN_TYPE_UNION, NULL); for (l = IDL_TYPE_UNION (tree).switch_body; l; l = IDL_LIST (l).next) num_members += IDL_list_length (IDL_CASE_STMT (IDL_LIST (l).data).labels); members = CORBA_UnionMemberSeq__alloc (); members->_length = members->_maximum = num_members; members->_buffer = CORBA_UnionMemberSeq_allocbuf (members->_length); members->_release = CORBA_TRUE; for (i = 0, l = IDL_TYPE_UNION (tree).switch_body; l; l = IDL_LIST (l).next) { CORBA_TypeCode subtc; IDL_tree member, label, dcl; member = IDL_CASE_STMT (IDL_LIST (l).data).element_spec; g_assert (IDL_NODE_TYPE (member) == IDLN_MEMBER); subtc = MateCORBA_imodule_get_typecode ( typecodes, IDL_MEMBER (member).type_spec); dcl = IDL_LIST (IDL_MEMBER (member).dcls).data; for (label = IDL_CASE_STMT (IDL_LIST (l).data).labels; label; label = IDL_LIST (label).next, i++) { CORBA_UnionMember *umember = &members->_buffer [i]; MateCORBA_imodule_setup_label_any ( switchtc, IDL_LIST (label).data, &umember->label); umember->label._release = CORBA_TRUE; umember->name = CORBA_string_dup (IDL_IDENT (dcl).str); umember->type = (CORBA_TypeCode) CORBA_Object_duplicate ((CORBA_Object) subtc, ev); umember->type_def = CORBA_OBJECT_NIL; /* Not used? */ } CORBA_Object_release ((CORBA_Object) subtc, ev); } g_assert (i == num_members); return members; }
static void orbit_output_tcstruct_sub_parts (FILE *fh, IDL_tree node) { int length = 0; switch (IDL_NODE_TYPE (node)) { case IDLN_TYPE_STRUCT: case IDLN_EXCEPT_DCL: { IDL_tree l; for (l = IDL_TYPE_STRUCT (node).member_list; l; l = IDL_LIST (l).next) { IDL_tree member; member = IDL_LIST (l).data; g_assert (IDL_NODE_TYPE (member) == IDLN_MEMBER); length += IDL_list_length (IDL_MEMBER (member).dcls); } } break; case IDLN_TYPE_UNION: { IDL_tree l; for (l = IDL_TYPE_UNION (node).switch_body; l; l = IDL_LIST (l).next) { IDL_tree case_stmt; case_stmt = IDL_LIST (l).data; g_assert (IDL_NODE_TYPE (case_stmt) == IDLN_CASE_STMT); length += IDL_list_length (IDL_CASE_STMT (case_stmt).labels); } } break; case IDLN_TYPE_ENUM: length = IDL_list_length (IDL_TYPE_ENUM (node).enumerator_list); break; case IDLN_IDENT: case IDLN_TYPE_SEQUENCE: case IDLN_TYPE_ARRAY: length = 1; break; default: length = 0; break; } fprintf (fh, "%d\n", length); }
static int orbit_output_tcstruct_anon_sublabels_array (FILE *fh, IDL_tree node, int sublabels_id) { IDL_tree l, label; int index = 0; int default_index = -1; if (IDL_NODE_TYPE (node) != IDLN_TYPE_UNION || !IDL_TYPE_UNION (node).switch_body) return default_index; fprintf (fh, "static ORBIT2_MAYBE_CONST CORBA_long anon_sublabels_array%d[] = {", sublabels_id); for (l = IDL_TYPE_UNION (node).switch_body; l; l = IDL_LIST (l).next) for (label = IDL_CASE_STMT (IDL_LIST (l).data).labels; label; label = IDL_LIST (label).next, index++) { if (IDL_LIST (label).data) { fprintf (fh, "(CORBA_long) "); orbit_cbe_write_const (fh, IDL_LIST (label).data); } else { /* default case */ fprintf (fh, "-1"); default_index = index; } if (IDL_LIST (label).next || IDL_LIST (l).next) fprintf (fh, ", "); } fprintf (fh, "};\n"); return default_index; }
void orte_idl_print_node(IDL_tree node, int indent_level) { IDL_tree curnode; char *s; do_indent(indent_level); if(node == NULL) { g_print("(null)\n"); return; } g_print("[%d] ", IDL_NODE_REFS(node)); switch(IDL_NODE_TYPE(node)) { case IDLN_NONE: g_print("NONE\n"); break; case IDLN_LIST: g_print("LIST:\n"); for(curnode = node; curnode; curnode = IDL_LIST(curnode).next) { orte_idl_print_node(IDL_LIST(curnode).data, indent_level + INDENT_INCREMENT_1); } break; case IDLN_GENTREE: break; case IDLN_INTEGER: g_print("INTEGER: %" IDL_LL "d\n", IDL_INTEGER(node).value); break; case IDLN_STRING: g_print("STRING: %s\n", IDL_STRING(node).value); break; case IDLN_WIDE_STRING: g_print("WIDE STRING: %ls\n", IDL_WIDE_STRING(node).value); break; case IDLN_CHAR: g_print("CHAR: %s\n", IDL_CHAR(node).value); break; case IDLN_WIDE_CHAR: g_print("WIDE CHAR: %ls\n", IDL_WIDE_CHAR(node).value); break; case IDLN_FIXED: g_print("FIXED: %s\n", IDL_FIXED(node).value); break; case IDLN_FLOAT: g_print("FLOAT: %f\n", IDL_FLOAT(node).value); break; case IDLN_BOOLEAN: g_print("BOOLEAN: %s\n", (IDL_BOOLEAN(node).value)?"True":"False"); break; case IDLN_IDENT: s = IDL_ns_ident_to_qstring(IDL_IDENT_TO_NS(node), "_", 0); g_print("IDENT: %s NSQ: %s RID: \"%s\"\n", IDL_IDENT(node).str, s, IDL_IDENT_REPO_ID(node) ? IDL_IDENT_REPO_ID(node) : ""); g_free(s); break; case IDLN_TYPE_DCL: g_print("TYPE DCL:\n"); orte_idl_print_node(IDL_TYPE_DCL(node).type_spec, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("decls:\n"); orte_idl_print_node(IDL_TYPE_DCL(node).dcls, indent_level + INDENT_INCREMENT_2); break; case IDLN_CONST_DCL: g_print("CONST DCL:\n"); orte_idl_print_node(IDL_CONST_DCL(node).const_type, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("ident:\n"); orte_idl_print_node(IDL_CONST_DCL(node).ident, indent_level + INDENT_INCREMENT_2); do_indent(indent_level + INDENT_INCREMENT_1); g_print("const_exp:\n"); orte_idl_print_node(IDL_CONST_DCL(node).const_exp, indent_level + INDENT_INCREMENT_2); break; case IDLN_EXCEPT_DCL: g_print("EXCEPT DCL:\n"); orte_idl_print_node(IDL_EXCEPT_DCL(node).ident, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("members:\n"); orte_idl_print_node(IDL_EXCEPT_DCL(node).members, indent_level + INDENT_INCREMENT_2); break; case IDLN_ATTR_DCL: g_print("ATTR_DCL (%s):\n", (IDL_ATTR_DCL(node).f_readonly)?"readonly":"rw"); orte_idl_print_node(IDL_ATTR_DCL(node).param_type_spec, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("simple_declarations:\n"); orte_idl_print_node(IDL_ATTR_DCL(node).simple_declarations, indent_level + INDENT_INCREMENT_2); break; case IDLN_OP_DCL: g_print("OP DCL (%s):\n", (IDL_OP_DCL(node).f_oneway)?"oneway":"normal"); orte_idl_print_node(IDL_OP_DCL(node).ident, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("op_type_spec:\n"); orte_idl_print_node(IDL_OP_DCL(node).op_type_spec, indent_level + INDENT_INCREMENT_2); do_indent(indent_level + INDENT_INCREMENT_1); g_print("parameter_dcls:\n"); orte_idl_print_node(IDL_OP_DCL(node).parameter_dcls, indent_level + INDENT_INCREMENT_2); do_indent(indent_level + INDENT_INCREMENT_1); g_print("raises_expr:\n"); orte_idl_print_node(IDL_OP_DCL(node).raises_expr, indent_level + INDENT_INCREMENT_2); do_indent(indent_level + INDENT_INCREMENT_1); g_print("context_expr:\n"); orte_idl_print_node(IDL_OP_DCL(node).context_expr, indent_level + INDENT_INCREMENT_2); break; case IDLN_PARAM_DCL: g_print("PARAM DCL: "); switch(IDL_PARAM_DCL(node).attr) { case IDL_PARAM_IN: g_print("(in)\n"); break; case IDL_PARAM_OUT: g_print("(out)\n"); break; case IDL_PARAM_INOUT: g_print("(inout)\n"); break; } orte_idl_print_node(IDL_PARAM_DCL(node).param_type_spec, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("simple_declarator:\n"); orte_idl_print_node(IDL_PARAM_DCL(node).simple_declarator, indent_level + INDENT_INCREMENT_2); break; case IDLN_FORWARD_DCL: g_print("FORWARD DCL:\n"); orte_idl_print_node(IDL_FORWARD_DCL(node).ident, indent_level + INDENT_INCREMENT_1); break; case IDLN_INTERFACE: g_print("INTERFACE:\n"); orte_idl_print_node(IDL_INTERFACE(node).ident, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("inheritance_spec:\n"); orte_idl_print_node(IDL_INTERFACE(node).inheritance_spec, indent_level + INDENT_INCREMENT_2); do_indent(indent_level + INDENT_INCREMENT_1); g_print("body:\n"); orte_idl_print_node(IDL_INTERFACE(node).body, indent_level + INDENT_INCREMENT_2); break; case IDLN_MODULE: g_print("MODULE:\n"); orte_idl_print_node(IDL_MODULE(node).ident, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("definition_list:\n"); orte_idl_print_node(IDL_MODULE(node).definition_list, indent_level + INDENT_INCREMENT_2); break; case IDLN_TYPE_INTEGER: if(!IDL_TYPE_INTEGER(node).f_signed) g_print("TYPE unsigned "); switch(IDL_TYPE_INTEGER(node).f_type) { case IDL_INTEGER_TYPE_SHORT: g_print("short\n"); break; case IDL_INTEGER_TYPE_LONG: g_print("long\n"); break; case IDL_INTEGER_TYPE_LONGLONG: g_print("long long\n"); break; } break; case IDLN_TYPE_FLOAT: switch(IDL_TYPE_FLOAT(node).f_type) { case IDL_FLOAT_TYPE_FLOAT: g_print("TYPE float\n"); break; case IDL_FLOAT_TYPE_DOUBLE: g_print("TYPE double\n"); break; case IDL_FLOAT_TYPE_LONGDOUBLE: g_print("TYPE long double\n"); break; } break; case IDLN_TYPE_FIXED: g_print("TYPE fixed:\n"); orte_idl_print_node(IDL_TYPE_FIXED(node).positive_int_const, indent_level + INDENT_INCREMENT_1); orte_idl_print_node(IDL_TYPE_FIXED(node).integer_lit, indent_level + INDENT_INCREMENT_1); break; case IDLN_TYPE_STRING: g_print("TYPE string:\n"); orte_idl_print_node(IDL_TYPE_STRING(node).positive_int_const, indent_level + INDENT_INCREMENT_1); break; case IDLN_TYPE_WIDE_STRING: g_print("TYPE wide string:\n"); orte_idl_print_node(IDL_TYPE_WIDE_STRING(node).positive_int_const, indent_level + INDENT_INCREMENT_1); break; case IDLN_TYPE_ENUM: g_print("TYPE enum:\n"); orte_idl_print_node(IDL_TYPE_ENUM(node).ident, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("enumerator_list:\n"); orte_idl_print_node(IDL_TYPE_ENUM(node).enumerator_list, indent_level + INDENT_INCREMENT_2); break; case IDLN_TYPE_ARRAY: g_print("TYPE array:\n"); orte_idl_print_node(IDL_TYPE_ARRAY(node).ident, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("size_list:\n"); orte_idl_print_node(IDL_TYPE_ARRAY(node).size_list, indent_level + INDENT_INCREMENT_2); break; case IDLN_TYPE_SEQUENCE: g_print("TYPE sequence:\n"); orte_idl_print_node(IDL_TYPE_SEQUENCE(node).simple_type_spec, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("positive_int_const:\n"); orte_idl_print_node(IDL_TYPE_SEQUENCE(node).positive_int_const, indent_level + INDENT_INCREMENT_2); break; case IDLN_TYPE_STRUCT: g_print("TYPE struct:\n"); orte_idl_print_node(IDL_TYPE_STRUCT(node).ident, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("member_list:\n"); orte_idl_print_node(IDL_TYPE_STRUCT(node).member_list, indent_level + INDENT_INCREMENT_2); break; case IDLN_TYPE_UNION: g_print("TYPE union:\n"); orte_idl_print_node(IDL_TYPE_UNION(node).ident, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("switch_type_spec:\n"); orte_idl_print_node(IDL_TYPE_UNION(node).switch_type_spec, indent_level + INDENT_INCREMENT_2); do_indent(indent_level + INDENT_INCREMENT_1); g_print("switch_body:\n"); orte_idl_print_node(IDL_TYPE_UNION(node).switch_body, indent_level + INDENT_INCREMENT_2); break; case IDLN_MEMBER: g_print("MEMBER:\n"); orte_idl_print_node(IDL_MEMBER(node).type_spec, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("dcls:\n"); orte_idl_print_node(IDL_MEMBER(node).dcls, indent_level + INDENT_INCREMENT_2); break; case IDLN_CASE_STMT: g_print("CASE_STMT:\n"); orte_idl_print_node(IDL_CASE_STMT(node).labels, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("element_spec:\n"); orte_idl_print_node(IDL_CASE_STMT(node).element_spec, indent_level + INDENT_INCREMENT_2); break; case IDLN_BINOP: g_print("BINOP "); switch(IDL_BINOP(node).op) { case IDL_BINOP_OR: g_print("or:\n"); break; case IDL_BINOP_XOR: g_print("xor:\n"); break; case IDL_BINOP_AND: g_print("and:\n"); break; case IDL_BINOP_SHR: g_print("shr:\n"); break; case IDL_BINOP_SHL: g_print("shl:\n"); break; case IDL_BINOP_ADD: g_print("add:\n"); break; case IDL_BINOP_SUB: g_print("sub:\n"); break; case IDL_BINOP_MULT: g_print("mult:\n"); break; case IDL_BINOP_DIV: g_print("div:\n"); break; case IDL_BINOP_MOD: g_print("mod:\n"); break; } do_indent(indent_level + INDENT_INCREMENT_1); g_print("left:\n"); orte_idl_print_node(IDL_BINOP(node).left, indent_level + INDENT_INCREMENT_2); do_indent(indent_level + INDENT_INCREMENT_1); g_print("right:\n"); orte_idl_print_node(IDL_BINOP(node).right, indent_level + INDENT_INCREMENT_2); break; case IDLN_UNARYOP: g_print("UNARYOP "); switch(IDL_UNARYOP(node).op) { case IDL_UNARYOP_PLUS: g_print("plus:\n"); break; case IDL_UNARYOP_MINUS: g_print("minus:\n"); break; case IDL_UNARYOP_COMPLEMENT: g_print("complement:\n"); break; } orte_idl_print_node(IDL_UNARYOP(node).operand, indent_level + INDENT_INCREMENT_1); break; case IDLN_TYPE_CHAR: g_print("TYPE char\n"); break; case IDLN_TYPE_WIDE_CHAR: g_print("TYPE wide char\n"); break; case IDLN_TYPE_BOOLEAN: g_print("TYPE boolean\n"); break; case IDLN_TYPE_OCTET: g_print("TYPE octet\n"); break; case IDLN_TYPE_OBJECT: g_print("TYPE object\n"); break; case IDLN_TYPE_ANY: g_print("TYPE any\n"); break; case IDLN_TYPE_TYPECODE: g_print("TYPE TypeCode\n"); break; case IDLN_CODEFRAG: g_print("CODEFRAG\n"); break; default: g_print("unhandled %d\n", IDL_NODE_TYPE(node)); } }
gboolean orte_cbe_type_is_fixed_length(IDL_tree ts) { gboolean is_fixed = TRUE; IDL_tree curitem; ts = orte_cbe_get_typespec(ts); switch(IDL_NODE_TYPE(ts)) { case IDLN_TYPE_FLOAT: case IDLN_TYPE_INTEGER: case IDLN_TYPE_ENUM: case IDLN_TYPE_CHAR: case IDLN_TYPE_WIDE_CHAR: case IDLN_TYPE_OCTET: case IDLN_TYPE_BOOLEAN: return TRUE; break; case IDLN_TYPE_SEQUENCE: case IDLN_TYPE_STRING: case IDLN_TYPE_WIDE_STRING: case IDLN_TYPE_OBJECT: case IDLN_FORWARD_DCL: case IDLN_INTERFACE: case IDLN_TYPE_ANY: case IDLN_NATIVE: case IDLN_TYPE_TYPECODE: return FALSE; break; case IDLN_TYPE_UNION: for(curitem = IDL_TYPE_UNION(ts).switch_body; curitem; curitem = IDL_LIST(curitem).next) { is_fixed &= orte_cbe_type_is_fixed_length(IDL_LIST(IDL_CASE_STMT(IDL_LIST(curitem).data).element_spec).data); } return is_fixed; break; case IDLN_EXCEPT_DCL: case IDLN_TYPE_STRUCT: for(curitem = IDL_TYPE_STRUCT(ts).member_list; curitem; curitem = IDL_LIST(curitem).next) { is_fixed &= orte_cbe_type_is_fixed_length(IDL_LIST(curitem).data); } return is_fixed; break; case IDLN_TYPE_ARRAY: return orte_cbe_type_is_fixed_length(IDL_TYPE_DCL(IDL_get_parent_node(ts, IDLN_TYPE_DCL, NULL)).type_spec); break; case IDLN_TYPE_DCL: return orte_cbe_type_is_fixed_length(IDL_TYPE_DCL(ts).type_spec); break; case IDLN_IDENT: case IDLN_LIST: return orte_cbe_type_is_fixed_length(IDL_NODE_UP(ts)); break; case IDLN_MEMBER: return orte_cbe_type_is_fixed_length(IDL_MEMBER(ts).type_spec); break; default: g_warning("I'm not sure if type %s is fixed-length", IDL_tree_type_names[IDL_NODE_TYPE(ts)]); return FALSE; } }
gboolean MateCORBA_imodule_type_is_fixed_length (IDL_tree tree) { gboolean is_fixed = TRUE; IDL_tree iter; IDL_tree typespec; typespec = MateCORBA_imodule_get_typespec (tree); switch (IDL_NODE_TYPE (typespec)) { case IDLN_TYPE_FLOAT: case IDLN_TYPE_INTEGER: case IDLN_TYPE_ENUM: case IDLN_TYPE_CHAR: case IDLN_TYPE_WIDE_CHAR: case IDLN_TYPE_OCTET: case IDLN_TYPE_BOOLEAN: is_fixed = TRUE; break; case IDLN_TYPE_SEQUENCE: case IDLN_TYPE_STRING: case IDLN_TYPE_WIDE_STRING: case IDLN_TYPE_OBJECT: case IDLN_FORWARD_DCL: case IDLN_INTERFACE: case IDLN_TYPE_ANY: case IDLN_NATIVE: case IDLN_TYPE_TYPECODE: is_fixed = FALSE; break; case IDLN_TYPE_UNION: for (iter = IDL_TYPE_UNION (typespec).switch_body; iter; iter = IDL_LIST (iter).next) is_fixed &= MateCORBA_imodule_type_is_fixed_length ( IDL_LIST (IDL_CASE_STMT ( IDL_LIST (iter).data).element_spec).data); break; case IDLN_EXCEPT_DCL: case IDLN_TYPE_STRUCT: for (iter = IDL_TYPE_STRUCT (typespec).member_list; iter; iter = IDL_LIST (iter).next) is_fixed &= MateCORBA_imodule_type_is_fixed_length (IDL_LIST (iter).data); break; case IDLN_TYPE_ARRAY: is_fixed = MateCORBA_imodule_type_is_fixed_length ( IDL_TYPE_DCL (IDL_get_parent_node ( typespec, IDLN_TYPE_DCL, NULL)).type_spec); break; case IDLN_TYPE_DCL: is_fixed = MateCORBA_imodule_type_is_fixed_length ( IDL_TYPE_DCL (typespec).type_spec); break; case IDLN_IDENT: case IDLN_LIST: is_fixed = MateCORBA_imodule_type_is_fixed_length (IDL_NODE_UP (typespec)); break; case IDLN_MEMBER: is_fixed = MateCORBA_imodule_type_is_fixed_length (IDL_MEMBER (typespec).type_spec); break; default: g_error ("Cannot determine if type %s is fixed-length", IDL_tree_type_names [IDL_NODE_TYPE (typespec)]); break; } return is_fixed; }
static int MateCORBA_imodule_find_c_align (IDL_tree node) { int c_align = 1; node = MateCORBA_imodule_get_typespec (node); switch (IDL_NODE_TYPE (node)) { case IDLN_TYPE_INTEGER: switch (IDL_TYPE_INTEGER (node).f_type) { case IDL_INTEGER_TYPE_SHORT: c_align = MATECORBA_ALIGNOF_CORBA_SHORT; break; case IDL_INTEGER_TYPE_LONG: c_align = MATECORBA_ALIGNOF_CORBA_LONG; break; case IDL_INTEGER_TYPE_LONGLONG: c_align = MATECORBA_ALIGNOF_CORBA_LONG_LONG; break; } break; case IDLN_TYPE_FLOAT: switch (IDL_TYPE_FLOAT (node).f_type) { case IDL_FLOAT_TYPE_FLOAT: c_align = MATECORBA_ALIGNOF_CORBA_FLOAT; break; case IDL_FLOAT_TYPE_DOUBLE: c_align = MATECORBA_ALIGNOF_CORBA_DOUBLE; break; case IDL_FLOAT_TYPE_LONGDOUBLE: c_align = MATECORBA_ALIGNOF_CORBA_LONG_DOUBLE; break; } break; case IDLN_TYPE_ENUM: c_align = MATECORBA_ALIGNOF_CORBA_LONG; break; case IDLN_TYPE_CHAR: /* drop through */ case IDLN_TYPE_BOOLEAN: case IDLN_TYPE_OCTET: c_align = MATECORBA_ALIGNOF_CORBA_CHAR; break; case IDLN_TYPE_WIDE_CHAR: c_align = MATECORBA_ALIGNOF_CORBA_SHORT; break; case IDLN_TYPE_UNION: { IDL_tree l = IDL_TYPE_UNION (node).switch_body; c_align = MATECORBA_ALIGNOF_CORBA_STRUCT; for (; l; l = IDL_LIST (l).next) { IDL_tree subtype = IDL_MEMBER (IDL_CASE_STMT ( IDL_LIST (l).data).element_spec).type_spec; c_align = MAX (c_align, MateCORBA_imodule_find_c_align (subtype)); } } break; case IDLN_EXCEPT_DCL: /* drop through */ case IDLN_TYPE_STRUCT: { IDL_tree l = IDL_TYPE_STRUCT (node).member_list; for (; l; l = IDL_LIST (l).next) { IDL_tree member = IDL_MEMBER (IDL_LIST (l).data).type_spec; c_align = MAX (c_align, MateCORBA_imodule_find_c_align (member)); } } break; case IDLN_TYPE_STRING: /* drop through */ case IDLN_TYPE_WIDE_STRING: case IDLN_TYPE_OBJECT: case IDLN_TYPE_TYPECODE: case IDLN_FORWARD_DCL: case IDLN_INTERFACE: c_align = MATECORBA_ALIGNOF_CORBA_POINTER; break; case IDLN_TYPE_ARRAY: { IDL_tree subtype; subtype = IDL_TYPE_DCL ( IDL_get_parent_node ( node, IDLN_TYPE_DCL, NULL)).type_spec; c_align = MateCORBA_imodule_find_c_align (subtype); } break; case IDLN_TYPE_SEQUENCE: c_align = MAX (MAX (MATECORBA_ALIGNOF_CORBA_STRUCT, MATECORBA_ALIGNOF_CORBA_LONG), MATECORBA_ALIGNOF_CORBA_POINTER); break; case IDLN_TYPE_ANY: c_align = MAX (MATECORBA_ALIGNOF_CORBA_STRUCT, MATECORBA_ALIGNOF_CORBA_POINTER); break; default: g_error ("Can't find alignment %s\n", IDL_tree_type_names [IDL_NODE_TYPE (node)]); break; } return c_align; }
static void orbit_output_tcstruct_anon_subnames_array (FILE *fh, IDL_tree node, int subnames_id) { IDL_tree l; switch (IDL_NODE_TYPE (node)) { case IDLN_TYPE_ENUM: if (!IDL_TYPE_ENUM (node).enumerator_list) break; fprintf (fh, "static const char *anon_subnames_array%d[] = {", subnames_id); for (l = IDL_TYPE_ENUM (node).enumerator_list; l; l = IDL_LIST (l).next) { g_assert (IDL_NODE_TYPE (IDL_LIST (l).data) == IDLN_IDENT); fprintf (fh, "\"%s\"", IDL_IDENT (IDL_LIST (l).data).str ); if (IDL_LIST (l).next) fprintf (fh, ", "); } fprintf (fh, "};\n"); break; case IDLN_EXCEPT_DCL: case IDLN_TYPE_STRUCT: if (!IDL_TYPE_STRUCT (node).member_list) break; fprintf (fh, "static const char *anon_subnames_array%d[] = {", subnames_id); for (l = IDL_TYPE_STRUCT (node).member_list; l; l = IDL_LIST (l).next) { IDL_tree dcl; g_assert (IDL_NODE_TYPE (IDL_LIST (l).data) == IDLN_MEMBER); for (dcl = IDL_MEMBER (IDL_LIST (l).data).dcls; dcl; dcl = IDL_LIST (dcl).next) { IDL_tree p = IDL_LIST (dcl).data; g_assert (IDL_NODE_TYPE (p) == IDLN_IDENT || IDL_NODE_TYPE (p) == IDLN_TYPE_ARRAY); if (IDL_NODE_TYPE (p) == IDLN_IDENT) fprintf (fh, "\"%s\"", IDL_IDENT (p).str); else /* IDLN_TYPE_ARRAY */ fprintf (fh, "\"%s\"", IDL_IDENT (IDL_TYPE_ARRAY (p).ident).str); if (IDL_LIST (dcl).next || IDL_LIST (l).next) fprintf (fh, ", "); } } fprintf (fh, "};\n"); break; case IDLN_TYPE_UNION: if (!IDL_TYPE_UNION (node).switch_body) break; fprintf (fh, "static const char * anon_subnames_array%d[] = {", subnames_id); for (l = IDL_TYPE_UNION (node).switch_body; l; l = IDL_LIST (l).next) { IDL_tree dcl, label; const char *subname; g_assert (IDL_NODE_TYPE (IDL_LIST (l).data) == IDLN_CASE_STMT); dcl = IDL_LIST (IDL_MEMBER ( IDL_CASE_STMT (IDL_LIST (l).data).element_spec).dcls).data; g_assert (IDL_NODE_TYPE (dcl) == IDLN_IDENT || IDL_NODE_TYPE (dcl) == IDLN_TYPE_ARRAY); if (IDL_NODE_TYPE (dcl) == IDLN_IDENT) subname = IDL_IDENT (dcl).str; else /* IDLN_TYPE_ARRAY */ subname = IDL_IDENT (IDL_TYPE_ARRAY (dcl).ident).str; /* output the name once for each label */ for (label = IDL_CASE_STMT (IDL_LIST (l).data).labels; label != NULL; label = IDL_LIST (label).next) { fprintf (fh, "\"%s\"", subname); if (IDL_LIST (label).next) fprintf (fh, ", "); } if (IDL_LIST (l).next) fprintf (fh, ", "); } fprintf (fh, "};\n"); break; default: break; } }
static GSList * orbit_find_c_align (GSList *max, IDL_tree node) { node = orbit_cbe_get_typespec (node); switch (IDL_NODE_TYPE (node)) { case IDLN_TYPE_INTEGER: switch (IDL_TYPE_INTEGER (node).f_type) { case IDL_INTEGER_TYPE_SHORT: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_SHORT"); break; case IDL_INTEGER_TYPE_LONG: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_LONG"); break; case IDL_INTEGER_TYPE_LONGLONG: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_LONG_LONG"); break; } break; case IDLN_TYPE_FLOAT: switch (IDL_TYPE_FLOAT (node).f_type) { case IDL_FLOAT_TYPE_FLOAT: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_FLOAT"); break; case IDL_FLOAT_TYPE_DOUBLE: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_DOUBLE"); break; case IDL_FLOAT_TYPE_LONGDOUBLE: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_LONG_DOUBLE"); break; } break; case IDLN_TYPE_ENUM: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_LONG"); break; case IDLN_TYPE_CHAR: /* drop through */ case IDLN_TYPE_BOOLEAN: case IDLN_TYPE_OCTET: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_CHAR"); break; case IDLN_TYPE_WIDE_CHAR: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_SHORT"); break; case IDLN_TYPE_UNION: { IDL_tree l = IDL_TYPE_UNION (node).switch_body; orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_STRUCT"); for (; l; l = IDL_LIST (l).next) { IDL_tree subtype = IDL_MEMBER (IDL_CASE_STMT ( IDL_LIST (l).data).element_spec).type_spec; max = orbit_find_c_align (max, subtype); } break; } case IDLN_EXCEPT_DCL: /* drop through */ case IDLN_TYPE_STRUCT: { IDL_tree l = IDL_TYPE_STRUCT (node).member_list; for (; l; l = IDL_LIST (l).next) { IDL_tree member = IDL_MEMBER (IDL_LIST (l).data).type_spec; max = orbit_find_c_align (max, member); } break; } case IDLN_TYPE_STRING: /* drop through */ case IDLN_TYPE_WIDE_STRING: case IDLN_TYPE_OBJECT: case IDLN_TYPE_TYPECODE: case IDLN_FORWARD_DCL: case IDLN_INTERFACE: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_POINTER"); break; case IDLN_TYPE_ARRAY: { IDL_tree subtype = IDL_TYPE_DCL ( IDL_get_parent_node (node, IDLN_TYPE_DCL, NULL)).type_spec; max = orbit_find_c_align (max, subtype); break; } case IDLN_TYPE_SEQUENCE: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_STRUCT"); orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_LONG"); orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_POINTER"); break; case IDLN_TYPE_ANY: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_STRUCT"); orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_POINTER"); break; default: g_error ("Can't find alignment %s\n", IDL_tree_type_names[IDL_NODE_TYPE (node)]); break; } return max; }
static void orbit_output_tcstruct_anon_subtypes_array (FILE *fh, IDL_tree node, int subtypes_id, char *substructname) { IDL_tree l; switch (IDL_NODE_TYPE (node)) { case IDLN_EXCEPT_DCL: case IDLN_TYPE_STRUCT: if (!IDL_TYPE_STRUCT (node).member_list) break; fprintf (fh, "static ORBIT2_MAYBE_CONST CORBA_TypeCode anon_subtypes_array%d[] = {", subtypes_id); for (l = IDL_TYPE_STRUCT (node).member_list; l; l = IDL_LIST (l).next) { IDL_tree dcl; char *tmpstr; dcl = IDL_MEMBER (IDL_LIST (l).data).type_spec; switch (IDL_NODE_TYPE (dcl)) { case IDLN_IDENT: case IDLN_INTERFACE: case IDLN_TYPE_OBJECT: case IDLN_FORWARD_DCL: dcl = orbit_cbe_get_typespec (dcl); if (IDL_NODE_DECLSPEC (dcl) & IDLF_DECLSPEC_PIDL && (IDL_NODE_TYPE (dcl) == IDLN_INTERFACE || IDL_NODE_TYPE (dcl) == IDLN_FORWARD_DCL)) tmpstr = g_strdup ("Object"); else tmpstr = orbit_cbe_get_typespec_str ( IDL_MEMBER (IDL_LIST (l).data).type_spec); break; default: tmpstr = orbit_cbe_get_typespec_str ( IDL_MEMBER (IDL_LIST (l).data).type_spec); break; } g_assert (IDL_NODE_TYPE (IDL_LIST (l).data) == IDLN_MEMBER); for (dcl = IDL_MEMBER (IDL_LIST (l).data).dcls; dcl; dcl = IDL_LIST (dcl).next) { fprintf (fh, "(CORBA_TypeCode)&TC_%s_struct", tmpstr); if (IDL_LIST (dcl).next || IDL_LIST (l).next) fprintf (fh, ", "); } g_free (tmpstr); } fprintf (fh, "};\n"); break; case IDLN_TYPE_UNION: if (!IDL_TYPE_UNION (node).switch_body) break; fprintf (fh, "static ORBIT2_MAYBE_CONST CORBA_TypeCode anon_subtypes_array%d[] = {", subtypes_id); for (l = IDL_TYPE_UNION (node).switch_body; l; l = IDL_LIST (l).next) { IDL_tree label, dcl; char *tmpstr; g_assert (IDL_NODE_TYPE (IDL_LIST (l).data) == IDLN_CASE_STMT); dcl = IDL_MEMBER (IDL_CASE_STMT (IDL_LIST (l).data).element_spec).type_spec; switch (IDL_NODE_TYPE (orbit_cbe_get_typespec (dcl))) { case IDLN_INTERFACE: case IDLN_FORWARD_DCL: if (IDL_NODE_DECLSPEC (dcl) & IDLF_DECLSPEC_PIDL) tmpstr = g_strdup ( "Object"); else tmpstr = orbit_cbe_get_typespec_str (dcl); break; default: tmpstr = orbit_cbe_get_typespec_str (dcl); break; } for (label = IDL_CASE_STMT (IDL_LIST (l).data).labels; label; label = IDL_LIST (label).next) { fprintf (fh, "(CORBA_TypeCode)&TC_%s_struct", tmpstr); if (IDL_LIST (label).next || IDL_LIST (l).next) fprintf (fh, ", "); } g_free (tmpstr); } fprintf (fh, "};\n"); break; case IDLN_TYPE_SEQUENCE: { IDL_tree seqts; char *tmpstr; seqts = orbit_cbe_get_typespec (IDL_TYPE_SEQUENCE (node).simple_type_spec); fprintf (fh, "static ORBIT2_MAYBE_CONST CORBA_TypeCode anon_subtypes_array%d[] = ", subtypes_id); switch (IDL_NODE_TYPE (seqts)) { case IDLN_INTERFACE: case IDLN_FORWARD_DCL: if (IDL_NODE_DECLSPEC (seqts) && IDLF_DECLSPEC_PIDL) tmpstr = g_strdup ("Object"); else tmpstr = orbit_cbe_get_typespec_str ( IDL_TYPE_SEQUENCE (node).simple_type_spec); break; default: tmpstr = orbit_cbe_get_typespec_str ( IDL_TYPE_SEQUENCE (node).simple_type_spec); break; } fprintf (fh, "{(CORBA_TypeCode)&TC_%s_struct};\n", tmpstr); g_free (tmpstr); } break; case IDLN_TYPE_ARRAY: case IDLN_IDENT: fprintf (fh, "static ORBIT2_MAYBE_CONST CORBA_TypeCode anon_subtypes_array%d[] = ", subtypes_id); fprintf (fh, "{(CORBA_TypeCode)&%s_struct};\n", substructname); break; default: break; } }