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 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 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 CORBA_StructMemberSeq *
MateCORBA_imodule_get_struct_members (GHashTable *typecodes,
IDL_tree tree,
CORBA_Environment *ev)
{
CORBA_StructMemberSeq *members;
IDL_tree l;
int num_members = 0;
int i;
g_return_val_if_fail (IDL_NODE_TYPE (tree) == IDLN_TYPE_STRUCT ||
IDL_NODE_TYPE (tree) == IDLN_EXCEPT_DCL, NULL);
for (l = IDL_TYPE_STRUCT (tree).member_list; l; l = IDL_LIST (l).next)
num_members += IDL_list_length (IDL_MEMBER (IDL_LIST (l).data).dcls);
members = CORBA_StructMemberSeq__alloc ();
members->_length = members->_maximum = num_members;
members->_buffer = CORBA_StructMemberSeq_allocbuf (members->_length);
members->_release = CORBA_TRUE;
for (i = 0, l = IDL_TYPE_STRUCT (tree).member_list; l; l = IDL_LIST (l).next) {
CORBA_TypeCode subtc;
IDL_tree dcl;
subtc = MateCORBA_imodule_get_typecode (
typecodes, IDL_MEMBER (IDL_LIST (l).data).type_spec);
for (dcl = IDL_MEMBER (IDL_LIST (l).data).dcls; dcl;
dcl = IDL_LIST (dcl).next, i++) {
CORBA_StructMember *member = &members->_buffer [i];
CORBA_string name;
if (IDL_NODE_TYPE (dcl) == IDLN_IDENT)
name = IDL_IDENT (dcl).str;
else /* IDLN_TYPE_ARRAY */
name = IDL_IDENT (IDL_TYPE_ARRAY (dcl).ident).str;
member->name = CORBA_string_dup (name);
member->type = (CORBA_TypeCode)
CORBA_Object_duplicate ((CORBA_Object) subtc, ev);
member->type_def = CORBA_OBJECT_NIL; /* Not used? */
}
CORBA_Object_release ((CORBA_Object) subtc, ev);
}
g_assert (i == num_members);
return members;
}
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
cbe_tc_generate (OIDL_C_Info *ci,
CBETCGenInfo *tci)
{
CBETCGenInfo subtci;
IDL_tree curitem;
char *ctmp;
int union_default_index = -1,
subnames_id = random_id++,
subtypes_id = random_id++,
sublabels_id = random_id++;
if (strncmp (tci->structname, "anon", 4)) {
fprintf (ci->fh, "#if ");
orbit_cbe_id_cond_hack (ci->fh, "TC_IMPL",
tci->structname, ci->c_base_name);
fprintf (ci->fh, " && !defined(TC_DEF_%s)\n", tci->structname);
fprintf (ci->fh, "#define TC_DEF_%s 1\n", tci->structname);
}
if (IDL_NODE_TYPE (tci->ts) == IDLN_TYPE_DCL) {
subtci = *tci;
curitem = IDL_TYPE_DCL (tci->ts).type_spec;
subtci.substructname = ctmp = orbit_generate_tcstruct_name (curitem);
/*
* The only type not already defined elsewhere
* that can be in the left half of a TypeCode.
*/
if (IDL_NODE_TYPE (curitem) == IDLN_TYPE_SEQUENCE) {
subtci.structname = ctmp;
subtci.ts = curitem;
cbe_tc_generate (ci, &subtci);
}
for (curitem = IDL_TYPE_DCL (tci->ts).dcls; curitem;
curitem = IDL_LIST (curitem).next) {
subtci.ts = IDL_LIST (curitem).data;
if (IDL_NODE_TYPE (subtci.ts) == IDLN_TYPE_ARRAY)
subtci.structname = orbit_generate_tcstruct_name (
IDL_TYPE_ARRAY (subtci.ts).ident);
else
subtci.structname = orbit_generate_tcstruct_name (subtci.ts);
cbe_tc_generate (ci, &subtci);
g_free (subtci.structname);
}
g_free (ctmp);
return;
}
/* Do magic here - nesting of typecodes for arrays */
if (IDL_NODE_TYPE (tci->ts) == IDLN_TYPE_ARRAY &&
(IDL_list_length (IDL_TYPE_ARRAY (tci->ts).size_list) > tci->array_gen_ctr)) {
curitem = IDL_list_nth (IDL_TYPE_ARRAY (tci->ts).size_list,
tci->array_gen_ctr - 1);
subtci = *tci;
subtci.structname = ctmp = orbit_generate_tcstruct_name (curitem);
subtci.array_gen_ctr++;
cbe_tc_generate (ci, &subtci);
tci->substructname = ctmp; /* FIXME: memory leak */
}
orbit_output_tcstruct_anon_subnames_array (ci->fh, tci->ts, subnames_id);
orbit_output_tcstruct_anon_subtypes_array (ci->fh, tci->ts, subtypes_id,
tci->substructname);
union_default_index = orbit_output_tcstruct_anon_sublabels_array (
ci->fh, tci->ts, sublabels_id);
if (!strncmp (tci->structname, "anon", 4))
fprintf (ci->fh, "static ");
else {
fprintf (ci->fh, "#ifdef ORBIT_IDL_C_IMODULE_%s\n",
ci->c_base_name);
fprintf (ci->fh, "static\n");
fprintf (ci->fh, "#endif\n");
}
fprintf (ci->fh, "ORBIT2_MAYBE_CONST struct CORBA_TypeCode_struct %s_struct = {\n",
tci->structname);
orbit_output_tcstruct_parent (ci->fh);
fprintf (ci->fh, ",\n");
orbit_output_tcstruct_kind (ci->fh, tci->ts, tci->array_gen_ctr);
fprintf (ci->fh, ",\n");
/* flags */
fprintf (ci->fh, "0,\n");
/* c_length */
fprintf (ci->fh, "0,\n");
orbit_output_tcstruct_c_align (ci->fh, tci->ts);
fprintf (ci->fh, ",\n");
orbit_output_tcstruct_length (ci->fh, tci->ts, tci->array_gen_ctr);
fprintf (ci->fh, ",\n");
orbit_output_tcstruct_sub_parts (ci->fh, tci->ts);
fprintf (ci->fh, ",\n");
orbit_output_tcstruct_subtypes (ci->fh, tci->ts, subtypes_id);
fprintf (ci->fh, ",\n");
orbit_output_tcstruct_discriminator (ci->fh, tci->ts);
fprintf (ci->fh, ",\n");
orbit_output_tcstruct_name (ci->fh, tci->ts, tci->array_gen_ctr);
fprintf (ci->fh, ",\n");
orbit_output_tcstruct_repo_id (ci->fh, tci->ts, tci->array_gen_ctr);
fprintf (ci->fh, ",\n");
orbit_output_tcstruct_subnames (ci->fh, tci->ts, subnames_id);
fprintf (ci->fh, ",\n");
orbit_output_tcstruct_sublabels (ci->fh, tci->ts, sublabels_id);
fprintf (ci->fh, ",\n");
orbit_output_tcstruct_default_index (ci->fh, union_default_index);
fprintf (ci->fh, ",\n");
orbit_output_tcstruct_recurse_depth (ci->fh);
fprintf (ci->fh, ",\n");
orbit_output_tcstruct_digits_scale (ci->fh, tci->ts);
fprintf (ci->fh, "\n};\n");
if (strncmp (tci->structname, "anon", 4))
fprintf (ci->fh, "#endif\n");
}
static void
cc_output_method (FILE *of, IDL_tree tree, const char *id)
{
int arg_count;
int except_count;
int context_count;
const char *method;
char *fullname;
fullname = g_strconcat (id, "_", IDL_IDENT (
IDL_OP_DCL (tree).ident).str, NULL);
arg_count = IDL_list_length (IDL_OP_DCL (tree).parameter_dcls);
except_count = IDL_list_length (IDL_OP_DCL (tree).raises_expr);
context_count = IDL_list_length (IDL_OP_DCL (tree).context_expr);
fprintf (of, "\t{\n");
/* IArgs arguments */
if (arg_count)
fprintf (of, "\t\t{ %d, %d, %s__arginfo, FALSE },\n",
arg_count, arg_count, fullname);
else
fprintf (of, "\t\t{ 0, 0, NULL, FALSE },\n");
/* IContexts contexts */
if (context_count)
fprintf (of, "\t\t{ %d, %d, %s__contextinfo, FALSE },\n",
context_count, context_count, fullname);
else
fprintf (of, "\t\t{ 0, 0, NULL, FALSE },\n");
/* ITypes exceptions */
if (IDL_OP_DCL (tree).raises_expr)
fprintf (of, "\t\t{ %d, %d, %s__exceptinfo, FALSE },\n",
except_count, except_count, fullname);
else
fprintf (of, "\t\t{ 0, 0, NULL, FALSE },\n");
/* TypeCode ret */
if (IDL_OP_DCL (tree).op_type_spec) {
char *type_id;
type_id = orbit_cbe_get_typespec_str (
IDL_OP_DCL (tree).op_type_spec);
fprintf (of, "\t\tTC_%s, ", type_id);
g_free (type_id);
} else
fprintf (of, "TC_void, ");
/* string name, long name_len */
method = IDL_IDENT (IDL_OP_DCL (tree).ident).str;
fprintf (of, "\"%s\", %d,\n", method, strlen (method));
/* IMethodFlags flags */
fprintf (of, "\t\t0");
if (IDL_OP_DCL(tree).f_oneway)
fprintf (of, " | ORBit_I_METHOD_1_WAY");
/* FIXME: re-scan for no_out */
/* if (no_out)
fprintf (of, " | ORBit_I_METHOD_NO_OUT");*/
if (IDL_OP_DCL (tree).op_type_spec &&
orbit_cbe_type_is_fixed_length (
IDL_OP_DCL (tree).op_type_spec))
fprintf (of, "| ORBit_I_COMMON_FIXED_SIZE");
if (IDL_OP_DCL(tree).context_expr)
fprintf (of, "| ORBit_I_METHOD_HAS_CONTEXT");
fprintf (of, "\n}\n");
g_free (fullname);
}
