void
orbit_cbe_unflatten_args (IDL_tree tree, FILE *of, const char *name)
{
IDL_tree l;
int i = 0;
for (l = IDL_OP_DCL(tree).parameter_dcls; l;
l = IDL_LIST(l).next) {
IDL_tree decl = IDL_LIST (l).data;
IDL_tree tspec = orbit_cbe_get_typespec (decl);
IDL_ParamRole r = 0;
char *unflatten;
switch(IDL_PARAM_DCL(decl).attr) {
case IDL_PARAM_IN: r = DATA_IN; break;
case IDL_PARAM_INOUT: r = DATA_INOUT; break;
case IDL_PARAM_OUT: r = DATA_OUT; break;
default:
g_error("Unknown IDL_PARAM type");
}
unflatten = orbit_cbe_unflatten_ref (r, tspec);
fprintf (of, "%s%s[%d], ", unflatten, name, i++);
g_free (unflatten);
}
}
void
orbit_cbe_flatten_args (IDL_tree tree, FILE *of, const char *name)
{
int i = 0;
IDL_tree l;
for (l = IDL_OP_DCL(tree).parameter_dcls; l;
l = IDL_LIST(l).next)
i++;
fprintf (of, "gpointer %s[%d];\n", name, i);
i = 0;
for (l = IDL_OP_DCL(tree).parameter_dcls; l;
l = IDL_LIST(l).next) {
IDL_tree decl = IDL_LIST (l).data;
IDL_tree tspec = orbit_cbe_get_typespec (decl);
IDL_ParamRole r = 0;
switch(IDL_PARAM_DCL(decl).attr) {
case IDL_PARAM_IN: r = DATA_IN; break;
case IDL_PARAM_INOUT: r = DATA_INOUT; break;
case IDL_PARAM_OUT: r = DATA_OUT; break;
default:
g_error("Unknown IDL_PARAM type");
}
fprintf (of, "%s[%d] = %s%s;\n",
name, i,
orbit_cbe_flatten_ref (r, tspec),
IDL_IDENT (IDL_PARAM_DCL (decl).simple_declarator).str);
i++;
}
}
static void
cc_typecode_prep_sequence (IDL_tree tree,
OIDL_C_Info *ci)
{
IDL_tree seq_type;
IDL_tree fake_seq_type = NULL;
char *type_str;
char *seq_type_str;
seq_type = orbit_cbe_get_typespec (IDL_TYPE_SEQUENCE (tree).simple_type_spec);
if (IDL_NODE_TYPE (seq_type) != IDLN_INTERFACE)
seq_type_str = orbit_cbe_get_typespec_str (seq_type);
else {
seq_type_str = g_strdup ("CORBA_Object");
fake_seq_type = IDL_type_object_new ();
}
type_str = orbit_cbe_get_typespec_str (IDL_TYPE_SEQUENCE (tree).simple_type_spec);
if (strcmp (type_str, seq_type_str)) {
IDL_tree fake_seq;
fake_seq = IDL_type_sequence_new (
fake_seq_type ? fake_seq_type : seq_type,
NULL);
IDL_NODE_UP (fake_seq) = IDL_NODE_UP (tree);
cc_output_typecodes (fake_seq, ci);
IDL_TYPE_SEQUENCE (fake_seq).simple_type_spec = NULL;
IDL_tree_free (fake_seq);
}
if (fake_seq_type)
IDL_tree_free (fake_seq_type);
g_free (type_str);
g_free (seq_type_str);
}
/*
This is almost the same like orbit_cbe_write_param_typespec_str(). We only omit the
'const' qualifier because we only need the parameter type.
*/
static char *
orbit_cbe_voyager_write_param_typespec_str(IDL_tree ts, IDL_ParamRole role)
{
int i, n;
gboolean isSlice;
char *name;
GString *str = g_string_sized_new (23);
IDL_tree typedef_spec;
char *typedef_name;
n = oidl_param_info (ts, role, &isSlice);
name = orbit_cbe_get_typespec_str (ts);
if ( role == DATA_IN ) {
/* We want to check if this is a typedef for CORBA_string so we can do special handling
* in that case.
*/
typedef_spec = orbit_cbe_get_typespec (ts);
typedef_name = orbit_cbe_get_typespec_str (typedef_spec);
g_string_printf (str, "%s",
!strcmp (typedef_name, "CORBA_string") ?
"CORBA_char *" : name);
g_free (typedef_name);
} else
g_string_printf (str, "%s", name);
g_free (name);
if ( isSlice )
g_string_append (str, "_slice");
for (i = 0; i < n; i++)
g_string_append_c (str, '*');
return g_string_free (str, FALSE);
}
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;
}
}
static void
cc_output_iargs (FILE *of, const char *method, IDL_tree tree)
{
IDL_tree sub;
int arg_count = 0;
/* Build a list of IArgs */
for (sub = IDL_OP_DCL (tree).parameter_dcls; sub;
sub = IDL_LIST (sub).next) {
IDL_tree parm;
char *tc;
if (!arg_count)
fprintf (of, "static ORBit_IArg %s__arginfo [] = {\n", method);
parm = IDL_LIST(sub).data;
fprintf (of, "\t{ ");
/* TypeCode tc */
tc = orbit_cbe_get_typecode_name (
IDL_PARAM_DCL (parm).param_type_spec);
if (!tc) {
g_warning ("Can't get typecode");
tc = g_strdup ("NULL /* no typecode */");
}
fprintf (of, "%s, ", tc);
/* IArgFlag flags */
switch (IDL_PARAM_DCL (parm).attr) {
case IDL_PARAM_IN:
fprintf (of, " ORBit_I_ARG_IN ");
break;
case IDL_PARAM_OUT:
fprintf (of, " ORBit_I_ARG_OUT ");
break;
case IDL_PARAM_INOUT:
fprintf (of, " ORBit_I_ARG_INOUT ");
break;
}
if (orbit_cbe_type_is_fixed_length (
IDL_PARAM_DCL (parm).param_type_spec))
fprintf (of, "| ORBit_I_COMMON_FIXED_SIZE");
else if (IDL_PARAM_DCL(parm).attr == IDL_PARAM_OUT) {
IDL_tree ts = orbit_cbe_get_typespec (
IDL_PARAM_DCL (parm).param_type_spec);
switch(IDL_NODE_TYPE (ts)) {
case IDLN_TYPE_STRUCT:
case IDLN_TYPE_UNION:
case IDLN_TYPE_ARRAY:
/* fprintf (of, "| ORBIT_I_ARG_FIXED");*/
break;
default:
break;
};
}
fprintf (of, ", ");
/* string name */
fprintf (of, "\"%s\"", IDL_IDENT (IDL_PARAM_DCL (
IDL_LIST (sub).data).simple_declarator).str);
fprintf (of, " }%s\n", IDL_LIST (sub).next ? "," : "");
g_free (tc);
arg_count++;
}
if (arg_count)
fprintf (of, "};\n");
}
