gboolean verify_const_declaration(IDL_tree const_tree) { struct _IDL_CONST_DCL *dcl = &IDL_CONST_DCL(const_tree); const char *name = IDL_IDENT(dcl->ident).str; IDL_tree real_type; /* const -> list -> interface */ if (!IDL_NODE_UP(IDL_NODE_UP(const_tree)) || IDL_NODE_TYPE(IDL_NODE_UP(IDL_NODE_UP(const_tree))) != IDLN_INTERFACE) { IDL_tree_error(const_tree, "const declaration \'%s\' outside interface", name); return FALSE; } /* Could be a typedef; try to map it to the real type. */ real_type = find_underlying_type(dcl->const_type); real_type = real_type ? real_type : dcl->const_type; if (IDL_NODE_TYPE(real_type) == IDLN_TYPE_INTEGER && (IDL_TYPE_INTEGER(real_type).f_type == IDL_INTEGER_TYPE_SHORT || IDL_TYPE_INTEGER(real_type).f_type == IDL_INTEGER_TYPE_LONG)) { if (!IDL_TYPE_INTEGER(real_type).f_signed && IDL_INTEGER(dcl->const_exp).value < 0) { #ifndef G_HAVE_GINT64 /* * For platforms without longlong support turned on we can get * confused by the high bit of the long value and think that it * represents a negative value in an unsigned declaration. * In that case we don't know if it is the programmer who is * confused or the compiler. So we issue a warning instead of * an error. */ if (IDL_TYPE_INTEGER(real_type).f_type == IDL_INTEGER_TYPE_LONG) { XPIDL_WARNING((const_tree, IDL_WARNING1, "unsigned const declaration \'%s\' " "initialized with (possibly) negative constant", name)); return TRUE; } #endif IDL_tree_error(const_tree, "unsigned const declaration \'%s\' initialized with " "negative constant", name); return FALSE; } } else { IDL_tree_error(const_tree, "const declaration \'%s\' must be of type short or long", name); return FALSE; } return TRUE; }
static gboolean typelib_const_dcl(TreeState *state) { struct _IDL_CONST_DCL *dcl = &IDL_CONST_DCL(state->tree); const char *name = IDL_IDENT(dcl->ident).str; gboolean is_long; gboolean sign; IDL_tree real_type; XPTInterfaceDescriptor *id; XPTConstDescriptor *cd; IDL_longlong_t value; if (!verify_const_declaration(state->tree)) return FALSE; /* Could be a typedef; try to map it to the real type. */ real_type = find_underlying_type(dcl->const_type); real_type = real_type ? real_type : dcl->const_type; is_long = (IDL_TYPE_INTEGER(real_type).f_type == IDL_INTEGER_TYPE_LONG); id = CURRENT(state); if (!XPT_InterfaceDescriptorAddConsts(ARENA(state), id, 1)) return FALSE; cd = &id->const_descriptors[NEXT_CONST(state)]; cd->name = IDL_IDENT(dcl->ident).str; #ifdef DEBUG_shaver_const fprintf(stderr, "DBG: adding const %s\n", cd->name); #endif if (!fill_td_from_type(state, &cd->type, dcl->const_type)) return FALSE; value = IDL_INTEGER(dcl->const_exp).value; sign = IDL_TYPE_INTEGER(dcl->const_type).f_signed; if (is_long) { if (sign) cd->value.i32 = value; else cd->value.ui32 = value; } else { if (sign) cd->value.i16 = value; else cd->value.ui16 = value; } NEXT_CONST(state)++; return TRUE; }
static gboolean do_const_dcl(TreeState *state) { struct _IDL_CONST_DCL *dcl = &IDL_CONST_DCL(state->tree); const char *name = IDL_IDENT(dcl->ident).str; gboolean is_signed; GSList *doc_comments = IDL_IDENT(dcl->ident).comments; IDL_tree real_type; const char *const_format; if (!verify_const_declaration(state->tree)) return FALSE; if (doc_comments != NULL) { write_indent(state->file); printlist(state->file, doc_comments); } /* Could be a typedef; try to map it to the real type. */ real_type = find_underlying_type(dcl->const_type); real_type = real_type ? real_type : dcl->const_type; is_signed = IDL_TYPE_INTEGER(real_type).f_signed; const_format = is_signed ? "%" IDL_LL "d" : "%" IDL_LL "uU"; write_indent(state->file); fprintf(state->file, "enum { %s = ", name); fprintf(state->file, const_format, IDL_INTEGER(dcl->const_exp).value); fprintf(state->file, " };\n\n"); return TRUE; }
bool is_signed(IDL_tree typ) { assert(is_integral_type(typ)); return IDL_NODE_TYPE(typ) == IDLN_TYPE_CHAR || IDL_NODE_TYPE(typ) == IDLN_TYPE_WIDE_CHAR || (IDL_NODE_TYPE(typ) == IDLN_TYPE_INTEGER && IDL_TYPE_INTEGER(typ).f_signed); }
/* returns a LLVM representation corresponding to the C translation of the * given IDL type. */ LLVMTypeRef llvm_value_type(struct llvm_ctx *ctx, IDL_tree type) { if(type == NULL) return LLVMVoidTypeInContext(ctx->ctx); switch(IDL_NODE_TYPE(type)) { case IDLN_TYPE_INTEGER: { static short bitlens[] = { [IDL_INTEGER_TYPE_SHORT] = 16, [IDL_INTEGER_TYPE_LONG] = 32, [IDL_INTEGER_TYPE_LONGLONG] = 64, }; int t = IDL_TYPE_INTEGER(type).f_type; assert(t < G_N_ELEMENTS(bitlens)); return LLVMIntTypeInContext(ctx->ctx, bitlens[t]); } case IDLN_NATIVE: { /* each of these is the size of a single word, which is all LLVM * wants to know. */ if(IS_WORD_TYPE(type) || IS_FPAGE_TYPE(type) || IS_TIME_TYPE(type)) { return ctx->wordt; } else { fprintf(stderr, "%s: native type `%s' not supported\n", __FUNCTION__, NATIVE_NAME(type)); abort(); } break; } case IDLN_TYPE_FLOAT: switch(IDL_TYPE_FLOAT(type).f_type) { case IDL_FLOAT_TYPE_FLOAT: return LLVMFloatTypeInContext(ctx->ctx); case IDL_FLOAT_TYPE_DOUBLE: return LLVMDoubleTypeInContext(ctx->ctx); case IDL_FLOAT_TYPE_LONGDOUBLE: return LLVMFP128TypeInContext(ctx->ctx); } g_assert_not_reached(); case IDLN_TYPE_BOOLEAN: case IDLN_TYPE_OCTET: case IDLN_TYPE_CHAR: return LLVMInt8TypeInContext(ctx->ctx); case IDLN_TYPE_WIDE_CHAR: return ctx->i32t; case IDLN_TYPE_ENUM: return LLVMInt16TypeInContext(ctx->ctx); default: NOTDEFINED(type); } }
static CORBA_TypeCode orbit_idl_tree_type_to_typecode_integer(IDL_tree type) { enum IDL_integer_type integer_type = IDL_TYPE_INTEGER(type).f_type; switch (integer_type) { case IDL_INTEGER_TYPE_SHORT: return TC_CORBA_short; case IDL_INTEGER_TYPE_LONG: return TC_CORBA_long; default: /* php_error(E_WARNING, "unsupported integer type %i", integer_type);*/ return NULL; } }
static gboolean write_type(IDL_tree type_tree, gboolean is_out, FILE *outfile) { if (!type_tree) { fputs("void", outfile); return TRUE; } switch (IDL_NODE_TYPE(type_tree)) { case IDLN_TYPE_INTEGER: { gboolean sign = IDL_TYPE_INTEGER(type_tree).f_signed; switch (IDL_TYPE_INTEGER(type_tree).f_type) { case IDL_INTEGER_TYPE_SHORT: fputs(sign ? "PRInt16" : "PRUint16", outfile); break; case IDL_INTEGER_TYPE_LONG: fputs(sign ? "PRInt32" : "PRUint32", outfile); break; case IDL_INTEGER_TYPE_LONGLONG: fputs(sign ? "PRInt64" : "PRUint64", outfile); break; default: g_error("Unknown integer type %d\n", IDL_TYPE_INTEGER(type_tree).f_type); return FALSE; } break; } case IDLN_TYPE_CHAR: fputs("char", outfile); break; case IDLN_TYPE_WIDE_CHAR: fputs("PRUnichar", outfile); /* wchar_t? */ break; case IDLN_TYPE_WIDE_STRING: fputs("PRUnichar *", outfile); break; case IDLN_TYPE_STRING: fputs("char *", outfile); break; case IDLN_TYPE_BOOLEAN: fputs("PRBool", outfile); break; case IDLN_TYPE_OCTET: fputs("PRUint8", outfile); break; case IDLN_TYPE_FLOAT: switch (IDL_TYPE_FLOAT(type_tree).f_type) { case IDL_FLOAT_TYPE_FLOAT: fputs("float", outfile); break; case IDL_FLOAT_TYPE_DOUBLE: fputs("double", outfile); break; /* XXX 'long double' just ignored, or what? */ default: fprintf(outfile, "unknown_type_%d", IDL_NODE_TYPE(type_tree)); break; } break; case IDLN_IDENT: if (UP_IS_NATIVE(type_tree)) { if (IDL_tree_property_get(type_tree, "domstring") || IDL_tree_property_get(type_tree, "astring")) { fputs("nsAString", outfile); } else if (IDL_tree_property_get(type_tree, "utf8string")) { fputs("nsACString", outfile); } else if (IDL_tree_property_get(type_tree, "cstring")) { fputs("nsACString", outfile); } else { fputs(IDL_NATIVE(IDL_NODE_UP(type_tree)).user_type, outfile); } if (IDL_tree_property_get(type_tree, "ptr")) { fputs(" *", outfile); } else if (IDL_tree_property_get(type_tree, "ref")) { fputs(" &", outfile); } } else { fputs(IDL_IDENT(type_tree).str, outfile); } if (UP_IS_AGGREGATE(type_tree)) fputs(" *", outfile); break; default: fprintf(outfile, "unknown_type_%d", IDL_NODE_TYPE(type_tree)); break; } return TRUE; }
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; }
/* * Check that parameters referred to by attributes such as size_is exist and * refer to parameters of the appropriate type. */ static gboolean check_param_attribute(IDL_tree method_tree, IDL_tree param, ParamAttrType whattocheck) { const char *method_name = IDL_IDENT(IDL_OP_DCL(method_tree).ident).str; const char *referred_name = NULL; IDL_tree param_type = IDL_PARAM_DCL(param).param_type_spec; IDL_tree simple_decl = IDL_PARAM_DCL(param).simple_declarator; const char *param_name = IDL_IDENT(simple_decl).str; const char *attr_name; const char *needed_type; if (whattocheck == IID_IS) { attr_name = "iid_is"; needed_type = "IID"; } else if (whattocheck == LENGTH_IS) { attr_name = "length_is"; needed_type = "unsigned long (or PRUint32)"; } else if (whattocheck == SIZE_IS) { attr_name = "size_is"; needed_type = "unsigned long (or PRUint32)"; } else { XPT_ASSERT("asked to check an unknown attribute type!"); return TRUE; } referred_name = IDL_tree_property_get(simple_decl, attr_name); if (referred_name != NULL) { IDL_tree referred_param = find_named_parameter(method_tree, referred_name); IDL_tree referred_param_type; if (referred_param == NULL) { IDL_tree_error(method_tree, "attribute [%s(%s)] refers to missing " "parameter \"%s\"", attr_name, referred_name, referred_name); return FALSE; } if (referred_param == param) { IDL_tree_error(method_tree, "attribute [%s(%s)] refers to it's own parameter", attr_name, referred_name); return FALSE; } referred_param_type = IDL_PARAM_DCL(referred_param).param_type_spec; if (whattocheck == IID_IS) { /* require IID type */ if (IDL_tree_property_get(referred_param_type, "nsid") == NULL) { IDL_tree_error(method_tree, "target \"%s\" of [%s(%s)] attribute " "must be of %s type", referred_name, attr_name, referred_name, needed_type); return FALSE; } } else if (whattocheck == LENGTH_IS || whattocheck == SIZE_IS) { /* require PRUint32 type */ IDL_tree real_type; /* Could be a typedef; try to map it to the real type. */ real_type = find_underlying_type(referred_param_type); real_type = real_type ? real_type : referred_param_type; if (IDL_NODE_TYPE(real_type) != IDLN_TYPE_INTEGER || IDL_TYPE_INTEGER(real_type).f_signed != FALSE || IDL_TYPE_INTEGER(real_type).f_type != IDL_INTEGER_TYPE_LONG) { IDL_tree_error(method_tree, "target \"%s\" of [%s(%s)] attribute " "must be of %s type", referred_name, attr_name, referred_name, needed_type); return FALSE; } } } return TRUE; }
/** 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; }
static void orbit_output_tcstruct_kind (FILE *fh, IDL_tree node, int array_gen_ctr) { switch (IDL_NODE_TYPE (node)) { case IDLN_TYPE_ARRAY: if (array_gen_ctr) fprintf (fh, "CORBA_tk_array"); else fprintf (fh, "CORBA_tk_alias"); break; case IDLN_IDENT: fprintf (fh, "CORBA_tk_alias"); break; case IDLN_TYPE_STRUCT: fprintf (fh, "CORBA_tk_struct"); break; case IDLN_TYPE_UNION: fprintf (fh, "CORBA_tk_union"); break; case IDLN_TYPE_ENUM: fprintf (fh, "CORBA_tk_enum"); break; case IDLN_TYPE_OBJECT: case IDLN_INTERFACE: case IDLN_FORWARD_DCL: fprintf (fh, "CORBA_tk_objref"); break; case IDLN_EXCEPT_DCL: fprintf (fh, "CORBA_tk_except"); break; case IDLN_TYPE_INTEGER: fprintf (fh, "CORBA_tk_"); if (!IDL_TYPE_INTEGER (node).f_signed) fprintf (fh, "u"); switch (IDL_TYPE_INTEGER (node).f_type) { case IDL_INTEGER_TYPE_SHORT: fprintf (fh, "short"); break; case IDL_INTEGER_TYPE_LONG: fprintf (fh, "long"); break; case IDL_INTEGER_TYPE_LONGLONG: fprintf (fh, "longlong"); break; } break; case IDLN_TYPE_FLOAT: fprintf (fh, "CORBA_tk_"); switch (IDL_TYPE_FLOAT (node).f_type) { case IDL_FLOAT_TYPE_FLOAT: fprintf (fh, "float"); break; case IDL_FLOAT_TYPE_DOUBLE: fprintf (fh, "double"); break; case IDL_FLOAT_TYPE_LONGDOUBLE: fprintf (fh, "longdouble"); break; } break; case IDLN_TYPE_BOOLEAN: fprintf (fh, "CORBA_tk_boolean"); break; case IDLN_TYPE_OCTET: fprintf (fh, "CORBA_tk_octet"); break; case IDLN_TYPE_STRING: fprintf (fh, "CORBA_tk_string"); break; case IDLN_TYPE_WIDE_STRING: fprintf (fh, "CORBA_tk_wstring"); break; case IDLN_TYPE_CHAR: fprintf (fh, "CORBA_tk_char"); break; case IDLN_TYPE_WIDE_CHAR: fprintf (fh, "CORBA_tk_wchar"); break; case IDLN_TYPE_ANY: fprintf (fh, "CORBA_tk_any"); break; case IDLN_TYPE_SEQUENCE: fprintf (fh, "CORBA_tk_sequence"); break; default: g_message ("Type %s has no tk constant!", IDL_tree_type_names[IDL_NODE_TYPE (node)]); } }
static gboolean constant_declaration(TreeState *state) { /* * The C++ header XPIDL module only allows for shorts and longs (ints) * to be constants, so we will follow the same convention */ struct _IDL_CONST_DCL *declaration = &IDL_CONST_DCL(state->tree); const char *name = IDL_IDENT(declaration->ident).str; IDL_tree real_type; gboolean success; gboolean isshort = FALSE; if (!verify_const_declaration(state->tree)) return FALSE; /* Could be a typedef; try to map it to the real type. */ real_type = find_underlying_type(declaration->const_type); real_type = real_type ? real_type : declaration->const_type; /* * Consts must be in an interface */ if (!IDL_NODE_UP(IDL_NODE_UP(state->tree)) || IDL_NODE_TYPE(IDL_NODE_UP(IDL_NODE_UP(state->tree))) != IDLN_INTERFACE) { XPIDL_WARNING((state->tree, IDL_WARNING1, "A constant \"%s\" was declared outside an interface." " It was ignored.", name)); return TRUE; } /* * Make sure this is a numeric short or long constant. */ success = (IDLN_TYPE_INTEGER == IDL_NODE_TYPE(real_type)); if (success) { /* * We aren't successful yet, we know it's an integer, but what *kind* * of integer? */ switch(IDL_TYPE_INTEGER(real_type).f_type) { case IDL_INTEGER_TYPE_SHORT: /* * We're OK */ isshort = TRUE; break; case IDL_INTEGER_TYPE_LONG: /* * We're OK */ break; default: /* * Whoops, it's some other kind of number */ success = FALSE; } } else { IDL_tree_error(state->tree, "const declaration \'%s\' must be of type short or long", name); return FALSE; } /* if (doc_comments != NULL) { fputs(" ", state->file); printlist(state->file, doc_comments); } */ if (success) { /* Since Java does not have any concept of 'unsigned short', we need * to check that the value is in the proper range. If not, promote * it to an 'int'. */ int value = (int) IDL_INTEGER(declaration->const_exp).value; if (isshort && (value < -32768 || value > 32767)) isshort = FALSE; fputc('\n', state->file); xpidl_write_comment(state, 4); /* write_comment(state); */ fprintf(state->file, " public static final %s %s = %d;\n", (isshort ? "short" : "int"), subscriptIdentifier(state, (char*) name), (int) IDL_INTEGER(declaration->const_exp).value); } else { XPIDL_WARNING((state->tree, IDL_WARNING1, "A constant \"%s\" was not of type short or long." " It was ignored.", name)); } return TRUE; }
static gboolean xpcom_to_java_type(TreeState *state, IDL_tree type) { IDL_tree real_type; IDL_tree up; if (!type) { fputs("Object", state->file); return TRUE; } /* Could be a typedef; try to map it to the real type */ real_type = find_underlying_type(type); type = real_type ? real_type : type; switch(IDL_NODE_TYPE(type)) { case IDLN_TYPE_INTEGER: { switch(IDL_TYPE_INTEGER(type).f_type) { case IDL_INTEGER_TYPE_SHORT: fputs("short", state->file); break; case IDL_INTEGER_TYPE_LONG: fputs("int", state->file); break; case IDL_INTEGER_TYPE_LONGLONG: fputs("long", state->file); break; default: g_error(" Unknown integer type: %d\n", IDL_TYPE_INTEGER(type).f_type); return FALSE; } break; } case IDLN_TYPE_CHAR: case IDLN_TYPE_WIDE_CHAR: fputs("char", state->file); break; case IDLN_TYPE_WIDE_STRING: case IDLN_TYPE_STRING: fputs("String", state->file); break; case IDLN_TYPE_BOOLEAN: fputs("boolean", state->file); break; case IDLN_TYPE_OCTET: fputs("byte", state->file); break; case IDLN_TYPE_FLOAT: switch(IDL_TYPE_FLOAT(type).f_type) { case IDL_FLOAT_TYPE_FLOAT: fputs("float", state->file); break; case IDL_FLOAT_TYPE_DOUBLE: fputs("double", state->file); break; default: g_error(" Unknown floating point typ: %d\n", IDL_NODE_TYPE(type)); break; } break; case IDLN_IDENT: if (!(up = IDL_NODE_UP(type))) { IDL_tree_error(state->tree, "ERROR: orphan ident %s in param list\n", IDL_IDENT(state->tree).str); return FALSE; } switch (IDL_NODE_TYPE(up)) { case IDLN_FORWARD_DCL: case IDLN_INTERFACE: { char *className; const char *iid_is; handle_iid_is: /* might get here via the goto, so re-check type */ if (IDL_NODE_TYPE(up) == IDLN_INTERFACE) className = IDL_IDENT(IDL_INTERFACE(up).ident).str; else if (IDL_NODE_TYPE(up) == IDLN_FORWARD_DCL) className = IDL_IDENT(IDL_FORWARD_DCL(up).ident).str; else className = IDL_IDENT(IDL_NATIVE(up).ident).str; iid_is = NULL; if (IDL_NODE_TYPE(state->tree) == IDLN_PARAM_DCL) { iid_is = IDL_tree_property_get(IDL_PARAM_DCL(state->tree).simple_declarator, "iid_is"); } if (iid_is) { fputs("nsISupports", state->file); } else { /* XXX How do we want to handle this? If it's an IDLN_INTERFACE, * then we can just output the name of the class, since the IDL * files exist for those classes. However, if it's an * IDLN_FORWARD_DCL, some of those interfaces are not defined in * IDL files, so we get an error when trying to compile the java * files. So, for now, we just output them as the base iface * (nsISupports). */ if (IDL_NODE_TYPE(up) == IDLN_FORWARD_DCL) fputs("nsISupports", state->file); else fprintf(state->file, "%s", className); } break; } case IDLN_NATIVE: { char *ident; /* jband - adding goto for iid_is when type is native */ if (IDL_NODE_TYPE(state->tree) == IDLN_PARAM_DCL && IDL_tree_property_get(IDL_PARAM_DCL(state->tree).simple_declarator, "iid_is")) { goto handle_iid_is; /* fputs("nsISupports", state->file); */ break; } ident = IDL_IDENT(type).str; if (IDL_tree_property_get(type, "nsid")) { fputs("String", state->file); } else if (IDL_tree_property_get(type, "domstring")) { fputs("String", state->file); } else if (IDL_tree_property_get(type, "astring")) { fputs("String", state->file); } else if (IDL_tree_property_get(type, "utf8string")) { fputs("String", state->file); } else if (IDL_tree_property_get(type, "cstring")) { fputs("String", state->file); } else { const char* user_type = IDL_NATIVE(IDL_NODE_UP(type)).user_type; IDL_tree real_type = g_hash_table_lookup(TYPEDEFS(state), user_type); if (real_type) { return xpcom_to_java_type(state, real_type); } else { if (strcmp(user_type, "PRInt8") == 0 || strcmp(user_type, "PRUint8") == 0) { fputs("byte", state->file); } else if (strcmp(user_type, "PRInt16") == 0 || strcmp(user_type, "PRUint16") == 0) { fputs("short", state->file); } else if (strcmp(user_type, "PRInt32") == 0 || strcmp(user_type, "PRUint32") == 0 || strcmp(user_type, "int") == 0) { fputs("int", state->file); } else if (strcmp(user_type, "PRInt64") == 0 || strcmp(user_type, "PRUint64") == 0) { fputs("long", state->file); } else if (strcmp(user_type, "PRBool") == 0) { fputs("boolean", state->file); } else if (strncmp(user_type, "char", 4) == 0 || strncmp(user_type, "const char", 10) == 0 || strncmp(user_type, "unsigned char", 13) == 0) { if (IDL_tree_property_get(type, "ptr")) { fputs("byte[]", state->file); } else { fputs("char", state->file); } } else if (strcmp(user_type, "nsIID") == 0) { fputs("String", state->file); } else if (strcmp(user_type, "nsString") == 0 || strcmp(user_type, "nsAString") == 0 || strcmp(user_type, "nsACString") == 0) { fputs("String", state->file); } else { fputs("int", state->file); } } } break; } default: if (IDL_NODE_TYPE(IDL_NODE_UP(up)) == IDLN_TYPE_DCL) { /* restart with the underlying type */ IDL_tree new_type; new_type = IDL_TYPE_DCL(IDL_NODE_UP(up)).type_spec; if (new_type) { gboolean rc = xpcom_to_java_type(state, new_type); return rc; } else { /* do what we would do in recursion if !type */ fputs("Object", state->file); return TRUE; } } IDL_tree_error(state->tree, "can't handle %s ident in param list\n", "that type of" ); return FALSE; } break; default: IDL_tree_error(state->tree, "can't handle %s in param list\n", #ifdef DEBUG_shaver /* XXX is this safe to use on Win now? */ IDL_NODE_TYPE_NAME(IDL_NODE_UP(type)) #else "that type" #endif ); return FALSE; } return TRUE; }
static gboolean xpcom_to_java_type (TreeState *state) { IDL_tree real_type; if (!state->tree) { fputs("Object", FILENAME(state)); return TRUE; } /* Could be a typedef; try to map it to the real type */ real_type = find_underlying_type(state->tree); state->tree = real_type ? real_type : state->tree; switch(IDL_NODE_TYPE(state->tree)) { case IDLN_TYPE_INTEGER: { switch(IDL_TYPE_INTEGER(state->tree).f_type) { case IDL_INTEGER_TYPE_SHORT: fputs("short", FILENAME(state)); break; case IDL_INTEGER_TYPE_LONG: fputs("int", FILENAME(state)); break; case IDL_INTEGER_TYPE_LONGLONG: fputs("long", FILENAME(state)); break; default: g_error(" Unknown integer type: %d\n", IDL_TYPE_INTEGER(state->tree).f_type); return FALSE; } break; } case IDLN_TYPE_CHAR: case IDLN_TYPE_WIDE_CHAR: fputs("char", FILENAME(state)); break; case IDLN_TYPE_WIDE_STRING: case IDLN_TYPE_STRING: fputs("String", FILENAME(state)); break; case IDLN_TYPE_BOOLEAN: fputs("boolean", FILENAME(state)); break; case IDLN_TYPE_OCTET: fputs("byte", FILENAME(state)); break; case IDLN_TYPE_FLOAT: switch(IDL_TYPE_FLOAT(state->tree).f_type) { case IDL_FLOAT_TYPE_FLOAT: fputs("float", FILENAME(state)); break; case IDL_FLOAT_TYPE_DOUBLE: fputs("double", FILENAME(state)); break; default: g_error(" Unknown floating point typ: %d\n", IDL_NODE_TYPE(state->tree)); break; } break; case IDLN_IDENT: if (IDL_NODE_UP(state->tree) && IDL_NODE_TYPE(IDL_NODE_UP(state->tree)) == IDLN_NATIVE) { const char *user_type = IDL_NATIVE(IDL_NODE_UP(state->tree)).user_type; const char *ident_str = IDL_IDENT(IDL_NATIVE(IDL_NODE_UP(state->tree)).ident).str; if (strcmp(user_type, "void") == 0) { /*it should not happend for scriptable methods*/ fputs("Object", FILENAME(state)); } /* XXX: s.b test for "id" attribute */ /* XXX: special class for nsIDs */ else if (strcmp(user_type, "nsID") == 0) { fputs("ID", FILENAME(state)); } else if (strcmp(user_type, "nsIID") == 0) { fputs("IID", FILENAME(state)); } else if (strcmp(user_type, "nsCID") == 0) { fputs("CID", FILENAME(state)); } else { /* XXX: special class for opaque types */ /*it should not happend for scriptable methods*/ fputs("OpaqueValue", FILENAME(state)); } } else { const char *ident_str = IDL_IDENT(state->tree).str; /* XXX: big kludge; s.b. way to match to typedefs */ if (strcmp(ident_str, "PRInt8") == 0 || strcmp(ident_str, "PRUint8") == 0) { fputs("byte", FILENAME(state)); } else if (strcmp(ident_str, "PRInt16") == 0 || strcmp(ident_str, "PRUint16") == 0) { fputs("short", FILENAME(state)); } else if (strcmp(ident_str, "PRInt32") == 0 || strcmp(ident_str, "PRUint32") == 0) { fputs("int", FILENAME(state)); } else if (strcmp(ident_str, "PRInt64") == 0 || strcmp(ident_str, "PRUint64") == 0) { fputs("long", FILENAME(state)); } else if (strcmp(ident_str, "PRBool") == 0) { fputs("boolean", FILENAME(state)); } else if (strcmp(ident_str, "nsrefcnt") == 0) { fputs("int", FILENAME(state)); } else { IDL_tree real_type = g_hash_table_lookup(TYPEDEFS(state), ident_str); if (real_type) { IDL_tree orig_tree = state->tree; state->tree = real_type; xpcom_to_java_type(state); state->tree = orig_tree; } else { fputs(subscriptIdentifier(state, (char*) ident_str), FILENAME(state)); } } } break; case IDLN_TYPE_ENUM: case IDLN_TYPE_OBJECT: default: g_error(" Unknown type: %d\n", IDL_TYPE_FLOAT(state->tree).f_type); break; } return TRUE; }
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)); } }
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 gboolean fill_td_from_type(TreeState *state, XPTTypeDescriptor *td, IDL_tree type) { IDL_tree up; int16 size_is_argnum; int16 length_is_argnum; gboolean has_size_is; gboolean has_length_is; gboolean is_array = FALSE; if (type) { /* deal with array */ if (IDL_NODE_TYPE(state->tree) == IDLN_PARAM_DCL) { IDL_tree sd = IDL_PARAM_DCL(state->tree).simple_declarator; if (IDL_tree_property_get(sd, "array")) { is_array = TRUE; /* size_is is required! */ if (!get_size_and_length(state, type, &size_is_argnum, &length_is_argnum, &has_size_is, &has_length_is)) { /* error was reported by helper function */ return FALSE; } if (!has_size_is) { IDL_tree_error(state->tree, "[array] requires [size_is()]\n"); return FALSE; } td->prefix.flags = TD_ARRAY | XPT_TDP_POINTER; td->argnum = size_is_argnum; if (has_length_is) td->argnum2 = length_is_argnum; else td->argnum2 = size_is_argnum; /* * XXX - NOTE - this will be broken for multidimensional * arrays because of the realloc XPT_InterfaceDescriptorAddTypes * uses. The underlying 'td' can change as we recurse in to get * additional dimensions. Luckily, we don't yet support more * than on dimension in the arrays */ /* setup the additional_type */ if (!XPT_InterfaceDescriptorAddTypes(ARENA(state), CURRENT(state), 1)) { g_error("out of memory\n"); return FALSE; } td->type.additional_type = NEXT_TYPE(state); td = &CURRENT(state)->additional_types[NEXT_TYPE(state)]; NEXT_TYPE(state)++ ; } } handle_typedef: switch (IDL_NODE_TYPE(type)) { case IDLN_TYPE_INTEGER: { gboolean sign = IDL_TYPE_INTEGER(type).f_signed; switch(IDL_TYPE_INTEGER(type).f_type) { case IDL_INTEGER_TYPE_SHORT: td->prefix.flags = sign ? TD_INT16 : TD_UINT16; break; case IDL_INTEGER_TYPE_LONG: td->prefix.flags = sign ? TD_INT32 : TD_UINT32; break; case IDL_INTEGER_TYPE_LONGLONG: td->prefix.flags = sign ? TD_INT64 : TD_UINT64; break; } break; } case IDLN_TYPE_CHAR: td->prefix.flags = TD_CHAR; break; case IDLN_TYPE_WIDE_CHAR: td->prefix.flags = TD_WCHAR; break; case IDLN_TYPE_STRING: if (is_array) { td->prefix.flags = TD_PSTRING | XPT_TDP_POINTER; } else { if (!get_size_and_length(state, type, &size_is_argnum, &length_is_argnum, &has_size_is, &has_length_is)) { /* error was reported by helper function */ return FALSE; } if (has_size_is) { td->prefix.flags = TD_PSTRING_SIZE_IS | XPT_TDP_POINTER; td->argnum = size_is_argnum; if (has_length_is) td->argnum2 = length_is_argnum; else td->argnum2 = size_is_argnum; } else { td->prefix.flags = TD_PSTRING | XPT_TDP_POINTER; } } break; case IDLN_TYPE_WIDE_STRING: if (is_array) { td->prefix.flags = TD_PWSTRING | XPT_TDP_POINTER; } else { if (!get_size_and_length(state, type, &size_is_argnum, &length_is_argnum, &has_size_is, &has_length_is)) { /* error was reported by helper function */ return FALSE; } if (has_size_is) { td->prefix.flags = TD_PWSTRING_SIZE_IS | XPT_TDP_POINTER; td->argnum = size_is_argnum; if (has_length_is) td->argnum2 = length_is_argnum; else td->argnum2 = size_is_argnum; } else { td->prefix.flags = TD_PWSTRING | XPT_TDP_POINTER; } } break; case IDLN_TYPE_BOOLEAN: td->prefix.flags = TD_BOOL; break; case IDLN_TYPE_OCTET: td->prefix.flags = TD_UINT8; break; case IDLN_TYPE_FLOAT: switch (IDL_TYPE_FLOAT (type).f_type) { case IDL_FLOAT_TYPE_FLOAT: td->prefix.flags = TD_FLOAT; break; case IDL_FLOAT_TYPE_DOUBLE: td->prefix.flags = TD_DOUBLE; break; /* XXX 'long double' just ignored, or what? */ default: break; } break; case IDLN_IDENT: if (!(up = IDL_NODE_UP(type))) { IDL_tree_error(state->tree, "ERROR: orphan ident %s in param list\n", IDL_IDENT(type).str); return FALSE; } switch (IDL_NODE_TYPE(up)) { /* This whole section is abominably ugly */ case IDLN_FORWARD_DCL: case IDLN_INTERFACE: { XPTInterfaceDirectoryEntry *ide, *ides; uint16 num_ifaces; char *className; const char *iid_is; handle_iid_is: ides = HEADER(state)->interface_directory; num_ifaces = HEADER(state)->num_interfaces; /* might get here via the goto, so re-check type */ if (IDL_NODE_TYPE(up) == IDLN_INTERFACE) className = IDL_IDENT(IDL_INTERFACE(up).ident).str; else if (IDL_NODE_TYPE(up) == IDLN_FORWARD_DCL) className = IDL_IDENT(IDL_FORWARD_DCL(up).ident).str; else className = IDL_IDENT(IDL_NATIVE(up).ident).str; iid_is = NULL; if (IDL_NODE_TYPE(state->tree) == IDLN_PARAM_DCL) { iid_is = IDL_tree_property_get(IDL_PARAM_DCL(state->tree).simple_declarator, "iid_is"); } if (iid_is) { int16 argnum; if (!find_arg_with_name(state, iid_is, &argnum)) { IDL_tree_error(state->tree, "can't find matching argument for " "[iid_is(%s)]\n", iid_is); return FALSE; } td->prefix.flags = TD_INTERFACE_IS_TYPE | XPT_TDP_POINTER; td->argnum = argnum; } else { td->prefix.flags = TD_INTERFACE_TYPE | XPT_TDP_POINTER; ide = FindInterfaceByName(ides, num_ifaces, className); if (!ide || ide < ides || ide > ides + num_ifaces) { IDL_tree_error(state->tree, "unknown iface %s in param\n", className); return FALSE; } td->type.iface = ide - ides + 1; #ifdef DEBUG_shaver_index fprintf(stderr, "DBG: index %d for %s\n", td->type.iface, className); #endif } break; } case IDLN_NATIVE: { char *ident; /* jband - adding goto for iid_is when type is native */ if (IDL_NODE_TYPE(state->tree) == IDLN_PARAM_DCL && IDL_tree_property_get(IDL_PARAM_DCL(state->tree).simple_declarator, "iid_is")) goto handle_iid_is; ident = IDL_IDENT(type).str; if (IDL_tree_property_get(type, "nsid")) { td->prefix.flags = TD_PNSIID; if (IDL_tree_property_get(type, "ref")) td->prefix.flags |= XPT_TDP_POINTER | XPT_TDP_REFERENCE; else if (IDL_tree_property_get(type,"ptr")) td->prefix.flags |= XPT_TDP_POINTER; } else if (IDL_tree_property_get(type, "domstring")) { td->prefix.flags = TD_DOMSTRING | XPT_TDP_POINTER; if (IDL_tree_property_get(type, "ref")) td->prefix.flags |= XPT_TDP_REFERENCE; } else if (IDL_tree_property_get(type, "astring")) { td->prefix.flags = TD_ASTRING | XPT_TDP_POINTER; if (IDL_tree_property_get(type, "ref")) td->prefix.flags |= XPT_TDP_REFERENCE; } else if (IDL_tree_property_get(type, "utf8string")) { td->prefix.flags = TD_UTF8STRING | XPT_TDP_POINTER; if (IDL_tree_property_get(type, "ref")) td->prefix.flags |= XPT_TDP_REFERENCE; } else if (IDL_tree_property_get(type, "cstring")) { td->prefix.flags = TD_CSTRING | XPT_TDP_POINTER; if (IDL_tree_property_get(type, "ref")) td->prefix.flags |= XPT_TDP_REFERENCE; } else if (IDL_tree_property_get(type, "jsval")) { td->prefix.flags = TD_JSVAL; if (IDL_tree_property_get(type, "ptr")) td->prefix.flags |= XPT_TDP_POINTER; } else { td->prefix.flags = TD_VOID | XPT_TDP_POINTER; } break; } default: if (IDL_NODE_TYPE(IDL_NODE_UP(up)) == IDLN_TYPE_DCL) { /* restart with the underlying type */ IDL_tree new_type; new_type = IDL_TYPE_DCL(IDL_NODE_UP(up)).type_spec; #ifdef DEBUG_shaver_misc fprintf(stderr, "following %s typedef to %s\n", IDL_IDENT(type).str, IDL_NODE_TYPE_NAME(new_type)); #endif /* * Do a nice messy goto rather than recursion so that * we can avoid screwing up the *array* information. */ /* return fill_td_from_type(state, td, new_type); */ if (new_type) { type = new_type; goto handle_typedef; } else { /* do what we would do in recursion if !type */ td->prefix.flags = TD_VOID; return TRUE; } } IDL_tree_error(state->tree, "can't handle %s ident in param list\n", #ifdef DEBUG_shaver /* XXX is this safe to use on Win now? */ IDL_NODE_TYPE_NAME(IDL_NODE_UP(type)) #else "that type of" #endif ); #ifdef DEBUG_shaver XPT_ASSERT(0); #endif return FALSE; } break; default: IDL_tree_error(state->tree, "can't handle %s in param list\n", #ifdef DEBUG_shaver /* XXX is this safe to use on Win now? */ IDL_NODE_TYPE_NAME(IDL_NODE_UP(type)) #else "that type" #endif ); return FALSE; } } else { td->prefix.flags = TD_VOID; } return TRUE; }
/** 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); }