static CORBA_EnumMemberSeq *
MateCORBA_imodule_get_enum_members (IDL_tree tree,
CORBA_Environment *ev)
{
CORBA_EnumMemberSeq *members;
IDL_tree l;
int num_members = 0;
int i;
g_return_val_if_fail (IDL_NODE_TYPE (tree) == IDLN_TYPE_ENUM, NULL);
num_members = IDL_list_length (IDL_TYPE_ENUM (tree).enumerator_list);
members = CORBA_EnumMemberSeq__alloc ();
members->_length = members->_maximum = num_members;
members->_buffer = CORBA_EnumMemberSeq_allocbuf (members->_length);
members->_release = CORBA_TRUE;
for (i = 0, l = IDL_TYPE_ENUM (tree).enumerator_list; l; i++, l = IDL_LIST (l).next)
members->_buffer [i] = CORBA_string_dup (IDL_IDENT (IDL_LIST (l).data).str);
g_assert (i == num_members);
return members;
}
static void
orbit_output_tcstruct_subnames (FILE *fh, IDL_tree node, int subnames_id)
{
switch (IDL_NODE_TYPE (node)) {
case IDLN_TYPE_ENUM:
if (IDL_TYPE_ENUM (node).enumerator_list)
fprintf (fh, "(char **)anon_subnames_array%d", subnames_id);
else
fprintf (fh, "NULL");
break;
case IDLN_TYPE_UNION:
if (IDL_TYPE_UNION (node).switch_body)
fprintf (fh, "(char **)anon_subnames_array%d", subnames_id);
else
fprintf (fh, "NULL");
break;
case IDLN_TYPE_STRUCT:
case IDLN_EXCEPT_DCL:
if (IDL_TYPE_STRUCT (node).member_list)
fprintf (fh, "(char **)anon_subnames_array%d", subnames_id);
else
fprintf (fh, "NULL");
break;
default:
fprintf (fh, "NULL");
break;
}
}
static void
orbit_output_tcstruct_repo_id (FILE *fh, IDL_tree node, int array_gen_ctr)
{
switch (IDL_NODE_TYPE (node)) {
case IDLN_TYPE_STRUCT:
fprintf (fh, "(char *)\"%s\"", IDL_IDENT (IDL_TYPE_STRUCT (node).ident).repo_id);
break;
case IDLN_TYPE_UNION:
fprintf (fh, "(char *)\"%s\"", IDL_IDENT (IDL_TYPE_UNION (node).ident).repo_id);
break;
case IDLN_TYPE_ENUM:
fprintf (fh, "(char *)\"%s\"", IDL_IDENT (IDL_TYPE_ENUM (node).ident).repo_id);
break;
case IDLN_INTERFACE:
case IDLN_FORWARD_DCL:
fprintf (fh, "(char *)\"%s\"", IDL_IDENT (IDL_INTERFACE (node).ident).repo_id);
break;
case IDLN_EXCEPT_DCL:
fprintf (fh, "(char *)\"%s\"", IDL_IDENT (IDL_EXCEPT_DCL (node).ident).repo_id);
break;
case IDLN_IDENT:
fprintf (fh, "(char *)\"%s\"", IDL_IDENT (node).repo_id);
break;
case IDLN_TYPE_ARRAY:
if (!array_gen_ctr)
fprintf (fh, "(char *)\"%s\"", IDL_IDENT (IDL_TYPE_ARRAY (node).ident).repo_id);
else
fprintf (fh, "NULL");
break;
default:
fprintf (fh, "NULL");
break;
}
}
static gboolean
typelib_enum(TreeState *state)
{
XPIDL_WARNING((state->tree, IDL_WARNING1,
"enums not supported, enum \'%s\' ignored",
IDL_IDENT(IDL_TYPE_ENUM(state->tree).ident).str));
return TRUE;
}
static CORBA_TypeCode orbit_idl_tree_type_to_typecode_enum(IDL_tree type)
{
CORBA_TypeCode type_code;
CORBA_EnumMemberSeq * p_members = NULL;
p_members = CORBA_EnumMemberSeq__alloc();
p_members->_maximum = p_members->_length = 1;
p_members->_buffer = CORBA_sequence_CORBA_Identifier_allocbuf(p_members->_length);
p_members->_buffer[0] = "dummy";
/*
* TODO: initialize p_members with members...
* look at orbit_idl_tree_type_to_typecode_struct
*/
type_code = CORBA_ORB_create_enum_tc(
orbit_get_orb(),
IDL_IDENT(IDL_TYPE_ENUM(type).ident).repo_id,
IDL_IDENT(IDL_TYPE_ENUM(type).ident).str,
p_members,
orbit_get_environment());
if (orbit_error_test("CORBA_ORB_create_enum_tc"))
{
goto error;
}
if (type_code == NULL)
{
/* printf("unable to create enum typecode for type %s\n",
IDL_IDENT(IDL_TYPE_ENUM(type).ident).str);*/
}
goto exit;
error:
type_code = NULL;
exit:
CORBA_free(p_members);
return type_code;
}
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);
}
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));
}
}
CORBA_TypeCode
MateCORBA_imodule_get_typecode (GHashTable *typecodes,
IDL_tree tree)
{
CORBA_Environment env;
CORBA_TypeCode retval = CORBA_OBJECT_NIL;
if (!tree)
return CORBA_OBJECT_NIL;
CORBA_exception_init (&env);
switch (IDL_NODE_TYPE (tree)) {
case IDLN_MEMBER:
retval = MateCORBA_imodule_get_typecode (
typecodes, IDL_MEMBER (tree).type_spec);
break;
case IDLN_TYPE_ANY:
retval = (CORBA_TypeCode)
CORBA_Object_duplicate (
(CORBA_Object) TC_CORBA_any, NULL);
break;
case IDLN_TYPE_FLOAT:
switch (IDL_TYPE_FLOAT (tree).f_type) {
case IDL_FLOAT_TYPE_FLOAT:
retval = TC_CORBA_float;
break;
case IDL_FLOAT_TYPE_DOUBLE:
retval = TC_CORBA_double;
break;
case IDL_FLOAT_TYPE_LONGDOUBLE:
retval = TC_CORBA_long_double;
break;
}
break;
case IDLN_TYPE_FIXED:
retval = CORBA_ORB_create_fixed_tc (NULL,
IDL_INTEGER (IDL_TYPE_FIXED (tree).positive_int_const).value,
IDL_INTEGER (IDL_TYPE_FIXED (tree).integer_lit).value, &env);
break;
case IDLN_TYPE_INTEGER:
if (!IDL_TYPE_INTEGER (tree).f_signed)
switch (IDL_TYPE_INTEGER (tree).f_type) {
case IDL_INTEGER_TYPE_SHORT:
retval = TC_CORBA_unsigned_short;
break;
case IDL_INTEGER_TYPE_LONGLONG:
retval = TC_CORBA_unsigned_long_long;
break;
case IDL_INTEGER_TYPE_LONG:
retval = TC_CORBA_unsigned_long;
break;
default:
g_assert_not_reached ();
}
else
switch (IDL_TYPE_INTEGER (tree).f_type) {
case IDL_INTEGER_TYPE_SHORT:
retval = TC_CORBA_short;
break;
case IDL_INTEGER_TYPE_LONGLONG:
retval = TC_CORBA_long_long;
break;
case IDL_INTEGER_TYPE_LONG:
retval = TC_CORBA_long;
break;
default:
g_assert_not_reached ();
}
break;
case IDLN_TYPE_STRING:
retval = (CORBA_TypeCode)
CORBA_Object_duplicate (
(CORBA_Object) TC_CORBA_string, NULL);
break;
case IDLN_TYPE_WIDE_STRING:
retval = (CORBA_TypeCode)
CORBA_Object_duplicate (
(CORBA_Object) TC_CORBA_wstring, NULL);
break;
case IDLN_TYPE_OCTET:
retval = (CORBA_TypeCode)
CORBA_Object_duplicate (
(CORBA_Object) TC_CORBA_octet, NULL);
break;
case IDLN_TYPE_CHAR:
retval = (CORBA_TypeCode)
CORBA_Object_duplicate (
(CORBA_Object) TC_CORBA_char, NULL);
break;
case IDLN_TYPE_WIDE_CHAR:
retval = (CORBA_TypeCode)
CORBA_Object_duplicate (
(CORBA_Object) TC_CORBA_wchar, NULL);
break;
case IDLN_TYPE_BOOLEAN:
retval = (CORBA_TypeCode)
CORBA_Object_duplicate (
(CORBA_Object) TC_CORBA_boolean, NULL);
break;
case IDLN_TYPE_STRUCT:
retval = MateCORBA_imodule_lookup_typecode (
typecodes,
IDL_IDENT (IDL_TYPE_STRUCT (tree).ident).repo_id);
if (!retval) {
CORBA_StructMemberSeq *members;
members = MateCORBA_imodule_get_struct_members (
typecodes, tree, &env);
retval = CORBA_ORB_create_struct_tc (NULL,
IDL_IDENT (IDL_TYPE_STRUCT (tree).ident).repo_id,
IDL_IDENT (IDL_TYPE_STRUCT (tree).ident).str,
members, &env);
MateCORBA_imodule_register_typecode (
typecodes,
IDL_IDENT (IDL_TYPE_STRUCT (tree).ident).repo_id, retval);
CORBA_free (members);
}
break;
case IDLN_EXCEPT_DCL:
retval = MateCORBA_imodule_lookup_typecode (
typecodes,
IDL_IDENT (IDL_EXCEPT_DCL (tree).ident).repo_id);
if (!retval) {
CORBA_StructMemberSeq *members;
members = MateCORBA_imodule_get_struct_members (
typecodes, tree, &env);
retval = CORBA_ORB_create_exception_tc (NULL,
IDL_IDENT (IDL_EXCEPT_DCL (tree).ident).repo_id,
IDL_IDENT (IDL_EXCEPT_DCL (tree).ident).str,
members, &env);
MateCORBA_imodule_register_typecode (
typecodes,
IDL_IDENT (IDL_EXCEPT_DCL (tree).ident).repo_id, retval);
CORBA_free (members);
}
break;
case IDLN_TYPE_ARRAY: {
CORBA_TypeCode subtc;
IDL_tree sizer;
IDL_tree type_dcl;
sizer = IDL_list_nth (IDL_TYPE_ARRAY (tree).size_list,
IDL_list_length (IDL_TYPE_ARRAY (tree).size_list) - 1);
g_assert (IDL_NODE_TYPE (IDL_LIST (sizer).data) == IDLN_INTEGER);
type_dcl = IDL_NODE_UP (IDL_NODE_UP (tree));
g_assert (IDL_NODE_TYPE (type_dcl) == IDLN_TYPE_DCL);
subtc = MateCORBA_imodule_get_typecode (
typecodes, IDL_TYPE_DCL (type_dcl).type_spec),
retval = CORBA_ORB_create_array_tc (NULL,
IDL_INTEGER (IDL_LIST (sizer).data).value,
subtc, &env);
retval->c_align = subtc->c_align;
CORBA_Object_release ((CORBA_Object) subtc, NULL);
for (sizer = IDL_LIST (sizer).prev; sizer; sizer = IDL_LIST (sizer).prev) {
subtc = retval;
retval = CORBA_ORB_create_array_tc (NULL,
IDL_INTEGER (IDL_LIST (sizer).data).value,
subtc, &env);
retval->c_align = subtc->c_align;
CORBA_Object_release ((CORBA_Object) subtc, NULL);
}
subtc = retval;
retval = MateCORBA_imodule_create_alias_typecode (
typecodes, IDL_TYPE_ARRAY (tree).ident, subtc);
CORBA_Object_release ((CORBA_Object) subtc, NULL);
}
break;
case IDLN_TYPE_UNION:
retval = MateCORBA_imodule_lookup_typecode (
typecodes,
IDL_IDENT (IDL_TYPE_UNION (tree).ident).repo_id);
if (!retval) {
CORBA_UnionMemberSeq *members;
CORBA_TypeCode switchtc;
switchtc = MateCORBA_imodule_get_typecode (
typecodes, IDL_TYPE_UNION (tree).switch_type_spec);
members = MateCORBA_imodule_get_union_members (
typecodes, tree, switchtc, &env);
retval = CORBA_ORB_create_union_tc (NULL,
IDL_IDENT (IDL_TYPE_UNION (tree).ident).repo_id,
IDL_IDENT (IDL_TYPE_UNION (tree).ident).str,
switchtc, members, &env);
CORBA_Object_release ((CORBA_Object) switchtc, NULL);
MateCORBA_imodule_register_typecode (
typecodes,
IDL_IDENT (IDL_TYPE_UNION (tree).ident).repo_id, retval);
CORBA_free (members);
}
break;
case IDLN_TYPE_ENUM:
retval = MateCORBA_imodule_lookup_typecode (
typecodes,
IDL_IDENT (IDL_TYPE_ENUM (tree).ident).repo_id);
if (!retval) {
CORBA_EnumMemberSeq *members;
members = MateCORBA_imodule_get_enum_members (tree, &env);
retval = CORBA_ORB_create_enum_tc (NULL,
IDL_IDENT (IDL_TYPE_ENUM (tree).ident).repo_id,
IDL_IDENT (IDL_TYPE_ENUM (tree).ident).str,
members, &env);
MateCORBA_imodule_register_typecode (
typecodes,
IDL_IDENT (IDL_TYPE_ENUM (tree).ident).repo_id, retval);
CORBA_free (members);
}
break;
case IDLN_IDENT:
retval = MateCORBA_imodule_lookup_typecode (
typecodes, IDL_IDENT (tree).repo_id);
g_assert (retval != NULL);
break;
case IDLN_TYPE_SEQUENCE: {
CORBA_TypeCode subtc;
int bound = 0;
if (IDL_TYPE_SEQUENCE (tree).positive_int_const)
bound = IDL_INTEGER (IDL_TYPE_SEQUENCE (tree).positive_int_const).value;
subtc = MateCORBA_imodule_get_typecode (
typecodes, IDL_TYPE_SEQUENCE (tree).simple_type_spec),
retval = CORBA_ORB_create_sequence_tc (NULL,
bound, subtc, &env);
CORBA_Object_release ((CORBA_Object) subtc, NULL);
/*
* FIXME: and what about recursive sequences?
*/
}
break;
case IDLN_FORWARD_DCL:
case IDLN_INTERFACE:
retval = MateCORBA_imodule_lookup_typecode (
typecodes,
IDL_IDENT (IDL_TYPE_ENUM (tree).ident).repo_id);
if (!retval) {
retval = CORBA_ORB_create_interface_tc (NULL,
IDL_IDENT (IDL_TYPE_ENUM (tree).ident).repo_id,
IDL_IDENT (IDL_TYPE_ENUM (tree).ident).str,
&env);
MateCORBA_imodule_register_typecode (
typecodes,
IDL_IDENT (IDL_TYPE_ENUM (tree).ident).repo_id, retval);
}
break;
case IDLN_TYPE_OBJECT:
retval = (CORBA_TypeCode)
CORBA_Object_duplicate (
(CORBA_Object) TC_CORBA_Object, NULL);
break;
case IDLN_TYPE_TYPECODE:
retval = (CORBA_TypeCode)
CORBA_Object_duplicate (
(CORBA_Object) TC_CORBA_TypeCode, NULL);
break;
default:
g_error ("We were asked to get a typecode for a %s",
IDL_tree_type_names [IDL_NODE_TYPE (tree)]);
break;
}
if (retval && retval->c_align == 0)
retval->c_align = MateCORBA_imodule_find_c_align (tree);
if (env._major != CORBA_NO_EXCEPTION)
g_warning ("MateCORBA_imodule_get_typecode: exception %s", env._id);
CORBA_exception_free (&env);
return retval;
}
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;
}
}
/**
Gets the "type" of {tree} as known in C.
The return value was alloc'd via g_malloc, and must be g_free'd.
**/
gulong
orbit_cbe_get_typespec_size(IDL_tree tree)
{
gulong retval=0;
if(!tree) {
return 0;
}
switch(IDL_NODE_TYPE(tree)) {
#if 0
case IDLN_MEMBER:
return orbit_cbe_get_typespec_str(IDL_MEMBER(tree).type_spec);
break;
case IDLN_TYPE_ANY:
retval = sizeof(CORBA_any);
break;
#endif
case IDLN_TYPE_FLOAT:
switch(IDL_TYPE_FLOAT(tree).f_type) {
case IDL_FLOAT_TYPE_FLOAT:
retval = sizeof(CORBA_float);
break;
case IDL_FLOAT_TYPE_DOUBLE:
retval = sizeof(CORBA_double);
break;
case IDL_FLOAT_TYPE_LONGDOUBLE:
retval = sizeof(CORBA_long_double);
break;
}
break;
#if 0
case IDLN_TYPE_FIXED:
return g_strdup_printf( "CORBA_fixed_%" IDL_LL "d_%" IDL_LL "d",
IDL_INTEGER(IDL_TYPE_FIXED(tree).positive_int_const).value,
IDL_INTEGER(IDL_TYPE_FIXED(tree).integer_lit).value);
break;
#endif
case IDLN_TYPE_INTEGER:
if(!IDL_TYPE_INTEGER(tree).f_signed)
{
/* unsigned types */
switch(IDL_TYPE_INTEGER(tree).f_type)
{
case IDL_INTEGER_TYPE_SHORT:
retval=sizeof(CORBA_unsigned_short);
break;
case IDL_INTEGER_TYPE_LONGLONG:
retval=sizeof(CORBA_unsigned_long_long);
break;
case IDL_INTEGER_TYPE_LONG:
retval=sizeof(CORBA_unsigned_long);
break;
}
}
else{
switch(IDL_TYPE_INTEGER(tree).f_type)
{
/* signed types */
case IDL_INTEGER_TYPE_SHORT:
retval=sizeof(CORBA_short);
break;
case IDL_INTEGER_TYPE_LONGLONG:
retval=sizeof(CORBA_long_long);
break;
case IDL_INTEGER_TYPE_LONG:
retval=sizeof(CORBA_long);
break;
}
}
break;
case IDLN_TYPE_OCTET:
retval = sizeof(CORBA_octet);
break;
case IDLN_TYPE_STRING:
retval = sizeof(CORBA_string); /* this is non-standard! */
break;
case IDLN_TYPE_BOOLEAN:
retval = sizeof(CORBA_boolean);
break;
case IDLN_TYPE_CHAR:
retval = sizeof(CORBA_char);
break;
case IDLN_TYPE_OBJECT:
retval = sizeof(CORBA_Object);
break;
case IDLN_NATIVE:
retval = sizeof(gpointer);
break;
#if 0
case IDLN_TYPE_WIDE_STRING:
retval = "CORBA_wstring"; /* this is non-standard! */
break;
case IDLN_TYPE_WIDE_CHAR:
retval = "CORBA_wchar";
break;
case IDLN_TYPE_STRUCT:
return orbit_cbe_get_typespec_str(IDL_TYPE_STRUCT(tree).ident);
case IDLN_EXCEPT_DCL:
return orbit_cbe_get_typespec_str(IDL_EXCEPT_DCL(tree).ident);
case IDLN_TYPE_ARRAY:
return orbit_cbe_get_typespec_str(IDL_TYPE_ARRAY(tree).ident);
case IDLN_TYPE_UNION:
return orbit_cbe_get_typespec_str(IDL_TYPE_UNION(tree).ident);
case IDLN_TYPE_ENUM:
return orbit_cbe_get_typespec_str(IDL_TYPE_ENUM(tree).ident);
case IDLN_IDENT:
return IDL_ns_ident_to_qstring(IDL_IDENT_TO_NS(tree), "_", 0);
case IDLN_PARAM_DCL:
return orbit_cbe_get_typespec_str(IDL_PARAM_DCL(tree).param_type_spec);
case IDLN_TYPE_SEQUENCE:
{
IDL_tree subtype = IDL_TYPE_SEQUENCE(tree).simple_type_spec;
char *ctmp, *base;
ctmp = orbit_cbe_get_typespec_str(subtype);
/* We should have built-in alias to make this next line not needed */
base = orbit_cbe_type_is_builtin(subtype)
? ctmp + strlen("CORBA_") : ctmp;
retval = g_strdup_printf( "CORBA_sequence_%s", base);
g_free(ctmp);
return retval;
}
break;
case IDLN_FORWARD_DCL:
case IDLN_INTERFACE:
return orbit_cbe_get_typespec_str(IDL_INTERFACE(tree).ident);
case IDLN_TYPE_TYPECODE:
retval = "CORBA_TypeCode";
break;
#endif
default:
// retval=sizeof(gpointer);
// g_error("We were asked to get a typesize for a %s (%s, %s line %d)",
// IDL_tree_type_names[IDL_NODE_TYPE(tree)], __FILE__, __FUNCTION__, __LINE__);
g_print("We were asked to get a typesize for a %s -> %s (%s line %d)\n",
IDL_tree_type_names[IDL_NODE_TYPE(tree)], IDL_ns_ident_to_qstring(IDL_IDENT_TO_NS(tree), "_", 0),
__FUNCTION__, __LINE__);
g_print("HACK: Returning sizeof(gpointer) now...\n", IDL_ns_ident_to_qstring(IDL_IDENT_TO_NS(tree), "_", 0));
retval=sizeof(gpointer);
break;
}
return retval;
}
/**
Gets the "type" of {tree} as known in C.
The return value was alloc'd via g_malloc, and must be g_free'd.
**/
char *
orbit_cbe_get_typespec_str(IDL_tree tree)
{
char *retval = NULL;
GString *tmpstr = NULL;
if(!tree) {
return g_strdup("void");
}
switch(IDL_NODE_TYPE(tree)) {
case IDLN_MEMBER:
return orbit_cbe_get_typespec_str(IDL_MEMBER(tree).type_spec);
break;
case IDLN_TYPE_ANY:
retval = "CORBA_any";
break;
case IDLN_TYPE_FLOAT:
switch(IDL_TYPE_FLOAT(tree).f_type) {
case IDL_FLOAT_TYPE_FLOAT:
retval = "CORBA_float";
break;
case IDL_FLOAT_TYPE_DOUBLE:
retval = "CORBA_double";
break;
case IDL_FLOAT_TYPE_LONGDOUBLE:
retval = "CORBA_long_double";
break;
}
break;
case IDLN_TYPE_FIXED:
return g_strdup_printf( "CORBA_fixed_%" IDL_LL "d_%" IDL_LL "d",
IDL_INTEGER(IDL_TYPE_FIXED(tree).positive_int_const).value,
IDL_INTEGER(IDL_TYPE_FIXED(tree).integer_lit).value);
break;
case IDLN_TYPE_INTEGER:
tmpstr = g_string_new(NULL);
g_string_append(tmpstr, "CORBA_");
if(!IDL_TYPE_INTEGER(tree).f_signed)
g_string_append(tmpstr, "unsigned_");
switch(IDL_TYPE_INTEGER(tree).f_type) {
case IDL_INTEGER_TYPE_SHORT:
g_string_append(tmpstr, "short");
break;
case IDL_INTEGER_TYPE_LONGLONG:
g_string_append(tmpstr, "long_");
/* FALLTHROUGH */
case IDL_INTEGER_TYPE_LONG:
g_string_append(tmpstr, "long");
break;
}
break;
case IDLN_TYPE_STRING:
retval = "CORBA_string"; /* this is non-standard! */
break;
case IDLN_TYPE_OCTET:
retval = "CORBA_octet";
break;
case IDLN_TYPE_WIDE_STRING:
retval = "CORBA_wstring"; /* this is non-standard! */
break;
case IDLN_TYPE_CHAR:
retval = "CORBA_char";
break;
case IDLN_TYPE_WIDE_CHAR:
retval = "CORBA_wchar";
break;
case IDLN_TYPE_BOOLEAN:
retval = "CORBA_boolean";
break;
case IDLN_TYPE_STRUCT:
return orbit_cbe_get_typespec_str(IDL_TYPE_STRUCT(tree).ident);
case IDLN_EXCEPT_DCL:
return orbit_cbe_get_typespec_str(IDL_EXCEPT_DCL(tree).ident);
case IDLN_TYPE_ARRAY:
return orbit_cbe_get_typespec_str(IDL_TYPE_ARRAY(tree).ident);
case IDLN_TYPE_UNION:
return orbit_cbe_get_typespec_str(IDL_TYPE_UNION(tree).ident);
case IDLN_TYPE_ENUM:
return orbit_cbe_get_typespec_str(IDL_TYPE_ENUM(tree).ident);
case IDLN_IDENT:
return IDL_ns_ident_to_qstring(IDL_IDENT_TO_NS(tree), "_", 0);
case IDLN_PARAM_DCL:
return orbit_cbe_get_typespec_str(IDL_PARAM_DCL(tree).param_type_spec);
case IDLN_TYPE_SEQUENCE:
{
IDL_tree subtype = IDL_TYPE_SEQUENCE(tree).simple_type_spec;
char *ctmp, *base;
ctmp = orbit_cbe_get_typespec_str(subtype);
/* We should have built-in alias to make this next line not needed */
base = orbit_cbe_type_is_builtin(subtype)
? ctmp + strlen("CORBA_") : ctmp;
retval = g_strdup_printf( "CORBA_sequence_%s", base);
g_free(ctmp);
return retval;
}
break;
case IDLN_NATIVE:
retval = "gpointer";
break;
case IDLN_FORWARD_DCL:
case IDLN_INTERFACE:
return orbit_cbe_get_typespec_str(IDL_INTERFACE(tree).ident);
case IDLN_TYPE_OBJECT:
retval = "CORBA_Object";
break;
case IDLN_TYPE_TYPECODE:
retval = "CORBA_TypeCode";
break;
default:
g_error("We were asked to get a typename for a %s",
IDL_tree_type_names[IDL_NODE_TYPE(tree)]);
break;
}
if (retval)
return g_strdup (retval);
else
return g_string_free (tmpstr, FALSE);
}
