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;
}
}
