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);
}
