/* * Common method verification code, called by *op_dcl in the various backends. */ gboolean verify_method_declaration(IDL_tree method_tree) { struct _IDL_OP_DCL *op = &IDL_OP_DCL(method_tree); IDL_tree iface; IDL_tree iter; gboolean notxpcom; gboolean scriptable_interface; gboolean scriptable_method; gboolean seen_retval = FALSE; const char *method_name = IDL_IDENT(IDL_OP_DCL(method_tree).ident).str; /* We don't support attributes named IID, conflicts with static GetIID * member. The conflict is due to certain compilers (VC++) choosing a * different vtable order, placing GetIID at the beginning regardless * of it's placement */ if (strcmp(method_name, "GetIID") == 0) { IDL_tree_error(method_tree, "Methods named GetIID not supported, causes vtable " "ordering problems"); return FALSE; } if (op->f_varargs) { /* We don't currently support varargs. */ IDL_tree_error(method_tree, "varargs are not currently supported"); return FALSE; } /* * Verify that we've been called on an interface, and decide if the * interface was marked [scriptable]. */ if (IDL_NODE_UP(method_tree) && IDL_NODE_UP(IDL_NODE_UP(method_tree)) && IDL_NODE_TYPE(iface = IDL_NODE_UP(IDL_NODE_UP(method_tree))) == IDLN_INTERFACE) { scriptable_interface = (IDL_tree_property_get(IDL_INTERFACE(iface).ident, "scriptable") != NULL); } else { IDL_tree_error(method_tree, "verify_method_declaration called on a non-interface?"); return FALSE; } /* * Require that any method in an interface marked as [scriptable], that * *isn't* scriptable because it refers to some native type, be marked * [noscript] or [notxpcom]. * * Also check that iid_is points to nsid, and length_is, size_is points * to unsigned long. */ notxpcom = IDL_tree_property_get(op->ident, "notxpcom") != NULL; scriptable_method = scriptable_interface && !notxpcom && IDL_tree_property_get(op->ident, "noscript") == NULL; /* Loop through the parameters and check. */ for (iter = op->parameter_dcls; iter; iter = IDL_LIST(iter).next) { IDL_tree param = IDL_LIST(iter).data; 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; /* * Reject this method if it should be scriptable and some parameter is * native that isn't marked with either nsid, domstring, utf8string, * cstring, astring or iid_is. */ if (scriptable_method && UP_IS_NATIVE(param_type) && IDL_tree_property_get(param_type, "nsid") == NULL && IDL_tree_property_get(simple_decl, "iid_is") == NULL && IDL_tree_property_get(param_type, "domstring") == NULL && IDL_tree_property_get(param_type, "utf8string") == NULL && IDL_tree_property_get(param_type, "cstring") == NULL && IDL_tree_property_get(param_type, "astring") == NULL) { IDL_tree_error(method_tree, "methods in [scriptable] interfaces that are " "non-scriptable because they refer to native " "types (parameter \"%s\") must be marked " "[noscript]", param_name); return FALSE; } /* * nsid's parameters that aren't ptr's or ref's are not currently * supported in xpcom or non-xpcom (marked with [notxpcom]) methods * as input parameters */ if (!(notxpcom && IDL_PARAM_DCL(param).attr != IDL_PARAM_IN) && IDL_tree_property_get(param_type, "nsid") != NULL && IDL_tree_property_get(param_type, "ptr") == NULL && IDL_tree_property_get(param_type, "ref") == NULL) { IDL_tree_error(method_tree, "Feature currently not supported: " "parameter \"%s\" is of type nsid and " "must be marked either [ptr] or [ref] " "or method \"%s\" must be marked [notxpcom] " "and must not be an input parameter", param_name, method_name); return FALSE; } /* * Sanity checks on return values. */ if (IDL_tree_property_get(simple_decl, "retval") != NULL) { if (IDL_LIST(iter).next != NULL) { IDL_tree_error(method_tree, "only the last parameter can be marked [retval]"); return FALSE; } if (op->op_type_spec) { IDL_tree_error(method_tree, "can't have [retval] with non-void return type"); return FALSE; } /* In case XPConnect relaxes the retval-is-last restriction. */ if (seen_retval) { IDL_tree_error(method_tree, "can't have more than one [retval] parameter"); return FALSE; } seen_retval = TRUE; } /* * Confirm that [shared] attributes are only used with string, wstring, * or native (but not nsid, domstring, utf8string, cstring or astring) * and can't be used with [array]. */ if (IDL_tree_property_get(simple_decl, "shared") != NULL) { IDL_tree real_type; real_type = find_underlying_type(param_type); real_type = real_type ? real_type : param_type; if (IDL_tree_property_get(simple_decl, "array") != NULL) { IDL_tree_error(method_tree, "[shared] parameter \"%s\" cannot " "be of array type", param_name); return FALSE; } if (!(IDL_NODE_TYPE(real_type) == IDLN_TYPE_STRING || IDL_NODE_TYPE(real_type) == IDLN_TYPE_WIDE_STRING || (UP_IS_NATIVE(real_type) && !IDL_tree_property_get(real_type, "nsid") && !IDL_tree_property_get(real_type, "domstring") && !IDL_tree_property_get(real_type, "utf8string") && !IDL_tree_property_get(real_type, "cstring") && !IDL_tree_property_get(real_type, "astring")))) { IDL_tree_error(method_tree, "[shared] parameter \"%s\" must be of type " "string, wstring or native", param_name); return FALSE; } } /* * inout is not allowed with "domstring", "UTF8String", "CString" * and "AString" types */ if (IDL_PARAM_DCL(param).attr == IDL_PARAM_INOUT && UP_IS_NATIVE(param_type) && (IDL_tree_property_get(param_type, "domstring") != NULL || IDL_tree_property_get(param_type, "utf8string") != NULL || IDL_tree_property_get(param_type, "cstring") != NULL || IDL_tree_property_get(param_type, "astring") != NULL )) { IDL_tree_error(method_tree, "[domstring], [utf8string], [cstring], [astring] " "types cannot be used as inout parameters"); return FALSE; } /* * arrays of domstring, utf8string, cstring, astring types not allowed */ if (IDL_tree_property_get(simple_decl, "array") != NULL && UP_IS_NATIVE(param_type) && (IDL_tree_property_get(param_type, "domstring") != NULL || IDL_tree_property_get(param_type, "utf8string") != NULL || IDL_tree_property_get(param_type, "cstring") != NULL || IDL_tree_property_get(param_type, "astring") != NULL)) { IDL_tree_error(method_tree, "[domstring], [utf8string], [cstring], [astring] " "types cannot be used in array parameters"); return FALSE; } if (!check_param_attribute(method_tree, param, IID_IS) || !check_param_attribute(method_tree, param, LENGTH_IS) || !check_param_attribute(method_tree, param, SIZE_IS)) return FALSE; /* * Run additional error checks on the parameter type if targetting an * older version of XPConnect. */ if (!verify_type_fits_version(param_type, method_tree)) return FALSE; } /* XXX q: can return type be nsid? */ /* Native return type? */ if (scriptable_method && op->op_type_spec != NULL && UP_IS_NATIVE(op->op_type_spec) && IDL_tree_property_get(op->op_type_spec, "nsid") == NULL && IDL_tree_property_get(op->op_type_spec, "domstring") == NULL && IDL_tree_property_get(op->op_type_spec, "utf8string") == NULL && IDL_tree_property_get(op->op_type_spec, "cstring") == NULL && IDL_tree_property_get(op->op_type_spec, "astring") == NULL) { IDL_tree_error(method_tree, "methods in [scriptable] interfaces that are " "non-scriptable because they return native " "types must be marked [noscript]"); return FALSE; } /* * nsid's parameters that aren't ptr's or ref's are not currently * supported in xpcom */ if (!notxpcom && op->op_type_spec != NULL && IDL_tree_property_get(op->op_type_spec, "nsid") != NULL && IDL_tree_property_get(op->op_type_spec, "ptr") == NULL && IDL_tree_property_get(op->op_type_spec, "ref") == NULL) { IDL_tree_error(method_tree, "Feature currently not supported: " "return value is of type nsid and " "must be marked either [ptr] or [ref], " "or else method \"%s\" must be marked [notxpcom] ", method_name); return FALSE; } /* * Run additional error checks on the return type if targetting an * older version of XPConnect. */ if (op->op_type_spec != NULL && !verify_type_fits_version(op->op_type_spec, method_tree)) { return FALSE; } return TRUE; }
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 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; }
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; }
/* * 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; }
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; }