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; }
static void orbit_output_tcstruct_subtypes (FILE *fh, IDL_tree node, int subtypes_id) { switch (IDL_NODE_TYPE (node)) { case IDLN_EXCEPT_DCL: case IDLN_TYPE_STRUCT: if (IDL_TYPE_STRUCT (node).member_list) fprintf (fh, "(CORBA_TypeCode *)anon_subtypes_array%d", subtypes_id); else fprintf (fh, "NULL"); break; case IDLN_TYPE_UNION: if (IDL_TYPE_UNION (node).switch_body) fprintf (fh, "(CORBA_TypeCode *)anon_subtypes_array%d", subtypes_id); else fprintf (fh, "NULL"); break; case IDLN_TYPE_SEQUENCE: case IDLN_TYPE_ARRAY: case IDLN_IDENT: fprintf (fh, "(CORBA_TypeCode *)anon_subtypes_array%d", subtypes_id); 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 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; } }
/* TODO: cache outputs by the struct type's repo id, like in * packed_format_of() */ LLVMTypeRef llvm_struct_type( struct llvm_ctx *ctx, char ***names_p, IDL_tree type) { assert(IDL_NODE_TYPE(type) == IDLN_TYPE_STRUCT); GArray *types = g_array_new(FALSE, FALSE, sizeof(T)); GPtrArray *names = names_p != NULL ? g_ptr_array_new() : NULL; struct member_item *members = expand_member_list( IDL_TYPE_STRUCT(type).member_list); for(int i=0; members[i].type != NULL; i++) { IDL_tree mtype = members[i].type; T mt = llvm_rigid_type(ctx, mtype); if(members[i].dim == 0) { g_array_append_val(types, mt); } else { T ary = LLVMArrayType(mt, members[i].dim); g_array_append_val(types, ary); } if(names_p != NULL) { g_ptr_array_add(names, g_strdup(members[i].name)); } } g_free(members); if(names_p != NULL) { char **namev = g_new(char *, names->len + 1); for(int i=0; i<names->len; i++) namev[i] = names->pdata[i]; namev[names->len] = NULL; g_ptr_array_free(names, TRUE); (*names_p) = namev; }
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); }
/* * create a CORBA_TypeCode for a struct */ static CORBA_TypeCode orbit_idl_tree_type_to_typecode_struct(IDL_tree type) { CORBA_TypeCode type_code = NULL; CORBA_StructMemberSeq * p_members = NULL; #if 0 if (IDL_TYPE_STRUCT(type).member_list == NULL) { printf("no struct members\n"); goto error; } #endif p_members = orbit_create_member_sequence(IDL_TYPE_STRUCT(type).member_list); if (p_members == NULL) goto error; type_code = CORBA_ORB_create_struct_tc( orbit_get_orb(), IDL_IDENT(IDL_TYPE_STRUCT(type).ident).repo_id, IDL_IDENT(IDL_TYPE_STRUCT(type).ident).str, p_members, orbit_get_environment()); if (type_code == NULL) goto error; goto exit; error: satellite_release_typecode(type_code); exit: CORBA_free(p_members); return type_code; }
void decode_packed_struct( struct llvm_ctx *ctx, LLVMValueRef *dst_p, IDL_tree ctyp, LLVMValueRef first_mr, LLVMValueRef bit_offset) { if(*dst_p == NULL) { /* TODO: fold this allocation with struct fields from other decoders, * if invoked from a dispatcher. somehow. (v2?) */ T s_type = llvm_struct_type(ctx, NULL, ctyp); const char *s_name = IDL_IDENT(IDL_TYPE_STRUCT(ctyp).ident).str; *dst_p = build_local_storage(ctx, s_type, NULL, s_name); } const struct packed_format *fmt = packed_format_of(ctyp); assert(fmt != NULL); if(is_short_fmt(fmt)) { decode_packed_struct_inline(ctx, *dst_p, ctyp, first_mr, bit_offset); } else { decode_packed_struct_fncall(ctx, *dst_p, ctyp, first_mr, bit_offset); } }
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; }
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 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; }
/** 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; }
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; } }
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; } }
const struct packed_format *packed_format_of(IDL_tree stype) { static bool first = true; if(first) { first = false; strmap_init(&packed_cache); } const char *s_id = sdecl_name(stype); struct packed_format *ret = strmap_get(&packed_cache, s_id); if(ret != NULL) return ret; struct member_item *items = expand_member_list( IDL_TYPE_STRUCT(stype).member_list); int num_items = 0; while(items[num_items].type != NULL) num_items++; qsort(items, num_items, sizeof(struct member_item), &item_by_bitsize_cmp); /* packing of small (sub-word) items */ GList *items_by_size[BITS_PER_WORD - 1]; for(int i=0; i < (BITS_PER_WORD - 1); i++) { items_by_size[i] = NULL; } int num_small = 0; for(int i=0; i<num_items; i++) { struct member_item *item = &items[i]; /* TODO: produce N items for arrays where bits_each < BITS_PER_WORD, so * that smaller items can be packed after e.g. an array member that * leaves 11 bits unused in each word. */ int bits = MEMBER_BITS(item); if(bits >= BITS_PER_WORD) break; items_by_size[bits] = g_list_prepend(items_by_size[bits], item); num_small++; } for(int i=0; i < (BITS_PER_WORD - 1); i++) { items_by_size[i] = g_list_reverse(items_by_size[i]); } GPtrArray *packed = g_ptr_array_new(); int num_words = pack_items(packed, items_by_size, num_small, NULL, 0, 64); if(num_words > 63) { warn_once("structure `%s' can't be bit-packed\n", s_id); return NULL; } assert(num_words < 64); for(int i=0; i < (BITS_PER_WORD - 1); i++) { g_list_free(items_by_size[i]); } #if 0 printf("%s: packed %d/%d small items into %d words from `%s'\n", __func__, (int)packed->len, num_small, num_words, s_id); #endif /* packing of word-length, and longer, items */ for(int i=0; i<num_items; i++) { struct member_item *item = &items[i]; int nbits = MEMBER_BITS(item); if(nbits < BITS_PER_WORD) continue; g_ptr_array_add(packed, new_packed_item(num_words, 0, nbits, item)); int words = (nbits + BITS_PER_WORD - 1) / BITS_PER_WORD; #if 0 printf("%s: packing item `%s' of %d words (%d bits) as-is\n", __func__, item->name, words, nbits); #endif num_words += words; } #if 0 printf("%s: packed %d items into %d words from `%s'\n", __func__, items->len, num_words, s_id); for(int i=0; i<packed->len; i++) { const struct packed_item *pi = packed->pdata[i]; printf("... `%s' -> word %d, bit %d\n", pi->name, pi->word, pi->bit); } #endif assert(packed->len == num_items); g_free(items); items = NULL; ret = g_malloc(sizeof(struct packed_format) + sizeof(struct packed_item *) * packed->len); ret->num_words = num_words; ret->num_items = packed->len; memcpy(ret->items, &g_ptr_array_index(packed, 0), packed->len * sizeof(void *)); g_ptr_array_free(packed, TRUE); ret->num_bits = 0; for(int i=0; i<ret->num_items; i++) { ret->num_bits += ret->items[i]->len; } bool ok = strmap_add(&packed_cache, s_id, ret); assert(ok || errno != EEXIST); return ret; }
static const char *sdecl_name(IDL_tree sdecl) { return IDL_IDENT(IDL_TYPE_STRUCT(sdecl).ident).repo_id; }
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; }
LLVMValueRef get_struct_fn( struct llvm_ctx *ctx, IDL_tree ctyp, bool for_encode) { const char *s_id = IDL_IDENT(IDL_TYPE_STRUCT(ctyp).ident).repo_id; char *lookup_name = talloc_asprintf(ctx, "%c%s", for_encode ? 'e' : 'd', s_id); LLVMValueRef fn = strmap_get(&ctx->struct_decoder_fns, lookup_name); if(fn != NULL) { talloc_free(lookup_name); return fn; } const struct packed_format *fmt = packed_format_of(ctyp); assert(fmt != NULL); /* only sane for packable structs */ int namelen = strlen(s_id); char flatname[namelen + 1]; /* FIXME: make this proper, i.e. use a name mangler that works */ for(int i=0; i < namelen; i++) { flatname[i] = isalnum(s_id[i]) ? s_id[i] : '_'; } flatname[namelen] = '\0'; T types[3], rettyp = LLVMVoidTypeInContext(ctx->ctx); types[0] = LLVMPointerType(llvm_rigid_type(ctx, ctyp), 0); int nparms; if(!for_encode) { /* decoder */ types[1] = ctx->i32t; types[2] = ctx->i32t; nparms = fmt->num_bits < BITS_PER_WORD ? 3 : 2; } else if(fmt->num_bits < BITS_PER_WORD) { /* subword encoder */ rettyp = ctx->wordt; types[1] = ctx->wordt; types[2] = ctx->i32t; nparms = 3; } else { /* non-subword encoder */ types[1] = ctx->i32t; nparms = 2; } T fntype = LLVMFunctionType(rettyp, types, nparms, 0); char *fnname = g_strdup_printf("__muidl_idl_%scode__%s", for_encode ? "en" : "de", flatname); fn = LLVMAddFunction(ctx->module, fnname, fntype); LLVMSetLinkage(fn, LLVMExternalLinkage); V params[nparms]; assert(LLVMCountParams(fn) == nparms); LLVMGetParams(fn, params); LLVMAddAttribute(params[0], LLVMNoAliasAttribute); LLVMAddAttribute(params[0], LLVMNoCaptureAttribute); for(int i=0; i<nparms; i++) { LLVMAddAttribute(params[i], LLVMInRegAttribute); } g_free(fnname); bool ok = strmap_add(&ctx->struct_decoder_fns, lookup_name, fn); assert(ok || errno != EEXIST); return fn; }
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; } }
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)); } }
/** 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); }