/* * 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; }
static gboolean interface(TreeState *state) { IDL_tree iface = state->tree, iter, orig; char *className = IDL_IDENT(IDL_INTERFACE(iface).ident).str; char *classNameUpper = NULL; char *classNameImpl = NULL; char *cp; gboolean ok = TRUE; gboolean keepvtable; const char *iid; const char *name_space; struct nsID id; char iid_parsed[UUID_LENGTH]; GSList *doc_comments = IDL_IDENT(IDL_INTERFACE(iface).ident).comments; if (!verify_interface_declaration(iface)) return FALSE; #define FAIL do {ok = FALSE; goto out;} while(0) fprintf(state->file, "\n/* starting interface: %s */\n", className); name_space = IDL_tree_property_get(IDL_INTERFACE(iface).ident, "namespace"); if (name_space) { fprintf(state->file, "/* namespace: %s */\n", name_space); fprintf(state->file, "/* fully qualified name: %s.%s */\n", name_space,className); } iid = IDL_tree_property_get(IDL_INTERFACE(iface).ident, "uuid"); if (iid) { /* Redundant, but a better error than 'cannot parse.' */ if (strlen(iid) != 36) { IDL_tree_error(state->tree, "IID %s is the wrong length\n", iid); FAIL; } /* * Parse uuid and then output resulting nsID to string, to validate * uuid and normalize resulting .h files. */ if (!xpidl_parse_iid(&id, iid)) { IDL_tree_error(state->tree, "cannot parse IID %s\n", iid); FAIL; } if (!xpidl_sprint_iid(&id, iid_parsed)) { IDL_tree_error(state->tree, "error formatting IID %s\n", iid); FAIL; } /* #define NS_ISUPPORTS_IID_STR "00000000-0000-0000-c000-000000000046" */ fputs("#define ", state->file); write_classname_iid_define(state->file, className); fprintf(state->file, "_STR \"%s\"\n", iid_parsed); fputc('\n', state->file); /* #define NS_ISUPPORTS_IID { {0x00000000 .... 0x46 }} */ fprintf(state->file, "#define "); write_classname_iid_define(state->file, className); fprintf(state->file, " \\\n" " {0x%.8x, 0x%.4x, 0x%.4x, \\\n" " { 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, " "0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x }}\n", id.m0, id.m1, id.m2, id.m3[0], id.m3[1], id.m3[2], id.m3[3], id.m3[4], id.m3[5], id.m3[6], id.m3[7]); fputc('\n', state->file); } else { IDL_tree_error(state->tree, "interface %s lacks a uuid attribute\n", className); FAIL; } if (doc_comments != NULL) printlist(state->file, doc_comments); /* * NS_NO_VTABLE is defined in nsISupportsUtils.h, and defined on windows * to __declspec(novtable) on windows. This optimization is safe * whenever the constructor calls no virtual methods. Writing in IDL * almost guarantees this, except for the case when a %{C++ block occurs in * the interface. We detect that case, and emit a macro call that disables * the optimization. */ keepvtable = FALSE; for (iter = IDL_INTERFACE(state->tree).body; iter != NULL; iter = IDL_LIST(iter).next) { IDL_tree data = IDL_LIST(iter).data; if (IDL_NODE_TYPE(data) == IDLN_CODEFRAG) keepvtable = TRUE; } /* The interface declaration itself. */ fprintf(state->file, "class %s%s", (keepvtable ? "" : "NS_NO_VTABLE "), className); if ((iter = IDL_INTERFACE(iface).inheritance_spec)) { fputs(" : ", state->file); if (IDL_LIST(iter).next != NULL) { IDL_tree_error(iter, "multiple inheritance is not supported by xpidl"); FAIL; } fprintf(state->file, "public %s", IDL_IDENT(IDL_LIST(iter).data).str); } fputs(" {\n" " public: \n\n", state->file); if (iid) { fputs(" NS_DEFINE_STATIC_IID_ACCESSOR(", state->file); write_classname_iid_define(state->file, className); fputs(")\n\n", state->file); } orig = state->tree; /* It would be nice to remove this state-twiddling. */ state->tree = IDL_INTERFACE(iface).body; if (state->tree && !xpidl_process_node(state)) FAIL; fputs("};\n", state->file); fputc('\n', state->file); /* * #define NS_DECL_NSIFOO - create method prototypes that can be used in * class definitions that support this interface. * * Walk the tree explicitly to prototype a reworking of xpidl to get rid of * the callback mechanism. */ state->tree = orig; fputs("/* Use this macro when declaring classes that implement this " "interface. */\n", state->file); fputs("#define NS_DECL_", state->file); classNameUpper = xpidl_strdup(className); for (cp = classNameUpper; *cp != '\0'; cp++) *cp = toupper(*cp); fprintf(state->file, "%s \\\n", classNameUpper); if (IDL_INTERFACE(state->tree).body == NULL) { write_indent(state->file); fputs("/* no methods! */\n", state->file); } for (iter = IDL_INTERFACE(state->tree).body; iter != NULL; iter = IDL_LIST(iter).next) { IDL_tree data = IDL_LIST(iter).data; switch(IDL_NODE_TYPE(data)) { case IDLN_OP_DCL: write_indent(state->file); write_method_signature(data, state->file, AS_DECL, NULL); break; case IDLN_ATTR_DCL: write_indent(state->file); if (!write_attr_accessor(data, state->file, TRUE, AS_DECL, NULL)) FAIL; if (!IDL_ATTR_DCL(data).f_readonly) { fputs("; \\\n", state->file); /* Terminate the previous one. */ write_indent(state->file); if (!write_attr_accessor(data, state->file, FALSE, AS_DECL, NULL)) FAIL; /* '; \n' at end will clean up. */ } break; case IDLN_CONST_DCL: /* ignore it here; it doesn't contribute to the macro. */ continue; case IDLN_CODEFRAG: XPIDL_WARNING((iter, IDL_WARNING1, "%%{ .. %%} code fragment within interface " "ignored when generating NS_DECL_%s macro; " "if the code fragment contains method " "declarations, the macro probably isn't " "complete.", classNameUpper)); continue; default: IDL_tree_error(iter, "unexpected node type %d! " "Please file a bug against the xpidl component.", IDL_NODE_TYPE(data)); FAIL; } if (IDL_LIST(iter).next != NULL) { fprintf(state->file, "; \\\n"); } else { fprintf(state->file, "; \n"); } } fputc('\n', state->file); /* XXX abstract above and below into one function? */ /* * #define NS_FORWARD_NSIFOO - create forwarding methods that can delegate * behavior from in implementation to another object. As generated by * idlc. */ fprintf(state->file, "/* Use this macro to declare functions that forward the " "behavior of this interface to another object. */\n" "#define NS_FORWARD_%s(_to) \\\n", classNameUpper); if (IDL_INTERFACE(state->tree).body == NULL) { write_indent(state->file); fputs("/* no methods! */\n", state->file); } for (iter = IDL_INTERFACE(state->tree).body; iter != NULL; iter = IDL_LIST(iter).next) { IDL_tree data = IDL_LIST(iter).data; switch(IDL_NODE_TYPE(data)) { case IDLN_OP_DCL: write_indent(state->file); write_method_signature(data, state->file, AS_DECL, NULL); fputs(" { return _to ", state->file); write_method_signature(data, state->file, AS_CALL, NULL); break; case IDLN_ATTR_DCL: write_indent(state->file); if (!write_attr_accessor(data, state->file, TRUE, AS_DECL, NULL)) FAIL; fputs(" { return _to ", state->file); if (!write_attr_accessor(data, state->file, TRUE, AS_CALL, NULL)) FAIL; if (!IDL_ATTR_DCL(data).f_readonly) { fputs("; } \\\n", state->file); /* Terminate the previous one. */ write_indent(state->file); if (!write_attr_accessor(data, state->file, FALSE, AS_DECL, NULL)) FAIL; fputs(" { return _to ", state->file); if (!write_attr_accessor(data, state->file, FALSE, AS_CALL, NULL)) FAIL; /* '; } \n' at end will clean up. */ } break; case IDLN_CONST_DCL: case IDLN_CODEFRAG: continue; default: FAIL; } if (IDL_LIST(iter).next != NULL) { fprintf(state->file, "; } \\\n"); } else { fprintf(state->file, "; } \n"); } } fputc('\n', state->file); /* XXX abstract above and below into one function? */ /* * #define NS_FORWARD_SAFE_NSIFOO - create forwarding methods that can delegate * behavior from in implementation to another object. As generated by * idlc. */ fprintf(state->file, "/* Use this macro to declare functions that forward the " "behavior of this interface to another object in a safe way. */\n" "#define NS_FORWARD_SAFE_%s(_to) \\\n", classNameUpper); if (IDL_INTERFACE(state->tree).body == NULL) { write_indent(state->file); fputs("/* no methods! */\n", state->file); } for (iter = IDL_INTERFACE(state->tree).body; iter != NULL; iter = IDL_LIST(iter).next) { IDL_tree data = IDL_LIST(iter).data; switch(IDL_NODE_TYPE(data)) { case IDLN_OP_DCL: write_indent(state->file); write_method_signature(data, state->file, AS_DECL, NULL); fputs(" { return !_to ? NS_ERROR_NULL_POINTER : _to->", state->file); write_method_signature(data, state->file, AS_CALL, NULL); break; case IDLN_ATTR_DCL: write_indent(state->file); if (!write_attr_accessor(data, state->file, TRUE, AS_DECL, NULL)) FAIL; fputs(" { return !_to ? NS_ERROR_NULL_POINTER : _to->", state->file); if (!write_attr_accessor(data, state->file, TRUE, AS_CALL, NULL)) FAIL; if (!IDL_ATTR_DCL(data).f_readonly) { fputs("; } \\\n", state->file); /* Terminate the previous one. */ write_indent(state->file); if (!write_attr_accessor(data, state->file, FALSE, AS_DECL, NULL)) FAIL; fputs(" { return !_to ? NS_ERROR_NULL_POINTER : _to->", state->file); if (!write_attr_accessor(data, state->file, FALSE, AS_CALL, NULL)) FAIL; /* '; } \n' at end will clean up. */ } break; case IDLN_CONST_DCL: case IDLN_CODEFRAG: continue; default: FAIL; } if (IDL_LIST(iter).next != NULL) { fprintf(state->file, "; } \\\n"); } else { fprintf(state->file, "; } \n"); } } fputc('\n', state->file); /* * Build a sample implementation template. */ if (strlen(className) >= 3 && className[2] == 'I') { classNameImpl = xpidl_strdup(className); if (!classNameImpl) FAIL; memmove(&classNameImpl[2], &classNameImpl[3], strlen(classNameImpl) - 2); } else { classNameImpl = xpidl_strdup("_MYCLASS_"); if (!classNameImpl) FAIL; } fputs("#if 0\n" "/* Use the code below as a template for the " "implementation class for this interface. */\n" "\n" "/* Header file */" "\n", state->file); fprintf(state->file, "class %s : public %s\n", classNameImpl, className); fputs("{\n" "public:\n", state->file); write_indent(state->file); fputs("NS_DECL_ISUPPORTS\n", state->file); write_indent(state->file); fprintf(state->file, "NS_DECL_%s\n", classNameUpper); fputs("\n", state->file); write_indent(state->file); fprintf(state->file, "%s();\n", classNameImpl); fputs("\n" "private:\n", state->file); write_indent(state->file); fprintf(state->file, "~%s();\n", classNameImpl); fputs("\n" "protected:\n", state->file); write_indent(state->file); fputs("/* additional members */\n", state->file); fputs("};\n\n", state->file); fputs("/* Implementation file */\n", state->file); fprintf(state->file, "NS_IMPL_ISUPPORTS1(%s, %s)\n", classNameImpl, className); fputs("\n", state->file); fprintf(state->file, "%s::%s()\n", classNameImpl, classNameImpl); fputs("{\n", state->file); write_indent(state->file); fputs("/* member initializers and constructor code */\n", state->file); fputs("}\n\n", state->file); fprintf(state->file, "%s::~%s()\n", classNameImpl, classNameImpl); fputs("{\n", state->file); write_indent(state->file); fputs("/* destructor code */\n", state->file); fputs("}\n\n", state->file); for (iter = IDL_INTERFACE(state->tree).body; iter != NULL; iter = IDL_LIST(iter).next) { IDL_tree data = IDL_LIST(iter).data; switch(IDL_NODE_TYPE(data)) { case IDLN_OP_DCL: /* It would be nice to remove this state-twiddling. */ orig = state->tree; state->tree = data; xpidl_write_comment(state, 0); state->tree = orig; write_method_signature(data, state->file, AS_IMPL, classNameImpl); fputs("\n{\n", state->file); write_indent(state->file); write_indent(state->file); fputs("return NS_ERROR_NOT_IMPLEMENTED;\n" "}\n" "\n", state->file); break; case IDLN_ATTR_DCL: /* It would be nice to remove this state-twiddling. */ orig = state->tree; state->tree = data; xpidl_write_comment(state, 0); state->tree = orig; if (!write_attr_accessor(data, state->file, TRUE, AS_IMPL, classNameImpl)) FAIL; fputs("\n{\n", state->file); write_indent(state->file); write_indent(state->file); fputs("return NS_ERROR_NOT_IMPLEMENTED;\n" "}\n", state->file); if (!IDL_ATTR_DCL(data).f_readonly) { if (!write_attr_accessor(data, state->file, FALSE, AS_IMPL, classNameImpl)) FAIL; fputs("\n{\n", state->file); write_indent(state->file); write_indent(state->file); fputs("return NS_ERROR_NOT_IMPLEMENTED;\n" "}\n", state->file); } fputs("\n", state->file); break; case IDLN_CONST_DCL: case IDLN_CODEFRAG: continue; default: FAIL; } } fputs("/* End of implementation class template. */\n" "#endif\n" "\n", state->file); #undef FAIL out: if (classNameUpper) free(classNameUpper); if (classNameImpl) free(classNameImpl); return ok; }
/* * 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 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; }
gboolean verify_attribute_declaration(IDL_tree attr_tree) { IDL_tree iface; IDL_tree ident; IDL_tree attr_type; gboolean scriptable_interface; /* 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( IDL_IDENT( IDL_LIST(IDL_ATTR_DCL(attr_tree).simple_declarations).data).str, "IID") == 0) { IDL_tree_error(attr_tree, "Attributes named IID not supported, causes vtable " "ordering problems"); return FALSE; } /* * Verify that we've been called on an interface, and decide if the * interface was marked [scriptable]. */ if (IDL_NODE_UP(attr_tree) && IDL_NODE_UP(IDL_NODE_UP(attr_tree)) && IDL_NODE_TYPE(iface = IDL_NODE_UP(IDL_NODE_UP(attr_tree))) == IDLN_INTERFACE) { scriptable_interface = (IDL_tree_property_get(IDL_INTERFACE(iface).ident, "scriptable") != NULL); } else { IDL_tree_error(attr_tree, "verify_attribute_declaration called on a non-interface?"); return FALSE; } /* * Grab the first of the list of idents and hope that it'll * say scriptable or no. */ ident = IDL_LIST(IDL_ATTR_DCL(attr_tree).simple_declarations).data; /* * If the interface isn't scriptable, or the attribute is marked noscript, * there's no need to check. */ if (!scriptable_interface || IDL_tree_property_get(ident, "noscript") != NULL) return TRUE; /* * If it should be scriptable, check that the type is non-native. nsid, * domstring, utf8string, cstring, astring are exempted. */ attr_type = IDL_ATTR_DCL(attr_tree).param_type_spec; if (attr_type != NULL) { if (UP_IS_NATIVE(attr_type) && IDL_tree_property_get(attr_type, "nsid") == NULL && IDL_tree_property_get(attr_type, "domstring") == NULL && IDL_tree_property_get(attr_type, "utf8string") == NULL && IDL_tree_property_get(attr_type, "cstring") == NULL && IDL_tree_property_get(attr_type, "astring") == NULL) { IDL_tree_error(attr_tree, "attributes in [scriptable] interfaces that are " "non-scriptable because they refer to native " "types must be marked [noscript]\n"); return FALSE; } /* * We currently don't support properties of type nsid that aren't * pointers or references, unless they are marked [notxpcom} and * must be read-only */ if ((IDL_tree_property_get(ident, "notxpcom") == NULL || !(IDL_ATTR_DCL(attr_tree).f_readonly)) && IDL_tree_property_get(attr_type,"nsid") != NULL && IDL_tree_property_get(attr_type,"ptr") == NULL && IDL_tree_property_get(attr_type,"ref") == NULL) { IDL_tree_error(attr_tree, "Feature not currently supported: " "attributes with a type of nsid must be marked " "either [ptr] or [ref], or " "else must be marked [notxpcom] " "and must be read-only\n"); return FALSE; } /* * Run additional error checks on the attribute type if targetting an * older version of XPConnect. */ if (!verify_type_fits_version(attr_type, attr_tree)) return FALSE; } if (IDL_LIST(IDL_ATTR_DCL(attr_tree).simple_declarations).next != NULL) { IDL_tree_error(attr_tree, "multiple attributes in a single declaration is not supported\n"); return FALSE; } return TRUE; }
static gboolean attribute_declaration(TreeState *state) { gboolean read_only = IDL_ATTR_DCL(state->tree).f_readonly; char *attribute_name = ATTR_IDENT(state->tree).str; gboolean method_noscript = (IDL_tree_property_get(ATTR_PROPS(state->tree), "noscript") != NULL); gboolean method_notxpcom = (IDL_tree_property_get(ATTR_PROPS(state->tree), "notxpcom") != NULL); #if 0 /* * Disabled here because I can't verify this check against possible * users of the java xpidl backend. */ if (!verify_attribute_declaration(state->tree)) return FALSE; #endif /* Comment */ fputc('\n', state->file); xpidl_write_comment(state, 4); #if 1 /* * Write access permission ("public") */ fputs(" public ", state->file); #else if (method_notxpcom || method_noscript) return TRUE; /* * Write access permission ("public" unless nonscriptable) */ fputs(" ", state->file); if (!method_noscript) { fputs("public ", state->file); } #endif /* * Write the proper Java return value for the get operation */ if (!xpcom_to_java_type(state, ATTR_TYPE_DECL(state->tree))) { return FALSE; } /* * Write the name of the accessor ("get") method. */ fprintf(state->file, " get%c%s();\n", toupper(attribute_name[0]), attribute_name + 1); if (!read_only) { #if 1 fputs(" public ", state->file); #else /* Nonscriptable methods become package-protected */ fputs(" ", state->file); if (!method_noscript) { fputs("public ", state->file); } #endif /* * Write attribute access method name and return type */ fprintf(state->file, "void set%c%s(", toupper(attribute_name[0]), attribute_name+1); /* * Write the proper Java type for the set operation */ if (!xpcom_to_java_type(state, ATTR_TYPE_DECL(state->tree))) { return FALSE; } /* * Write the name of the formal parameter. */ fprintf(state->file, " a%c%s);\n", toupper(attribute_name[0]), attribute_name + 1); } return TRUE; }
/* * Shared between the interface class declaration and the NS_DECL_IFOO macro * provided to aid declaration of implementation classes. * mode... * AS_DECL writes 'NS_IMETHOD foo(string bar, long sil)' * AS_IMPL writes 'NS_IMETHODIMP className::foo(string bar, long sil)' * AS_CALL writes 'foo(bar, sil)' */ static gboolean write_method_signature(IDL_tree method_tree, FILE *outfile, int mode, const char *className) { struct _IDL_OP_DCL *op = &IDL_OP_DCL(method_tree); gboolean no_generated_args = TRUE; gboolean op_notxpcom = (IDL_tree_property_get(op->ident, "notxpcom") != NULL); const char *name; const char *binaryname; IDL_tree iter; if (mode == AS_DECL) { if (IDL_tree_property_get(op->ident, "deprecated")) fputs("NS_DEPRECATED ", outfile); if (is_method_scriptable(method_tree, op->ident)) fputs("NS_SCRIPTABLE ", outfile); if (op_notxpcom) { fputs("NS_IMETHOD_(", outfile); if (!write_type(op->op_type_spec, FALSE, outfile)) return FALSE; fputc(')', outfile); } else { fputs("NS_IMETHOD", outfile); } fputc(' ', outfile); } else if (mode == AS_IMPL) { if (op_notxpcom) { fputs("NS_IMETHODIMP_(", outfile); if (!write_type(op->op_type_spec, FALSE, outfile)) return FALSE; fputc(')', outfile); } else { fputs("NS_IMETHODIMP", outfile); } fputc(' ', outfile); } name = IDL_IDENT(op->ident).str; if (mode == AS_IMPL) { fprintf(outfile, "%s::", className); } binaryname = IDL_tree_property_get(op->ident, "binaryname"); if (binaryname) { fprintf(outfile, "%s(", binaryname); } else { fprintf(outfile, "%c%s(", toupper(*name), name + 1); } for (iter = op->parameter_dcls; iter; iter = IDL_LIST(iter).next) { if (mode == AS_DECL || mode == AS_IMPL) { if (!write_param(IDL_LIST(iter).data, outfile)) return FALSE; } else { fputs(IDL_IDENT(IDL_PARAM_DCL(IDL_LIST(iter).data) .simple_declarator).str, outfile); } if ((IDL_LIST(iter).next || (!op_notxpcom && op->op_type_spec) || op->f_varargs)) fputs(", ", outfile); no_generated_args = FALSE; } /* make IDL return value into trailing out argument */ if (op->op_type_spec && !op_notxpcom) { IDL_tree fake_param = IDL_param_dcl_new(IDL_PARAM_OUT, op->op_type_spec, IDL_ident_new("_retval")); if (!fake_param) return FALSE; if (mode == AS_DECL || mode == AS_IMPL) { if (!write_param(fake_param, outfile)) return FALSE; } else { fputs("_retval", outfile); } if (op->f_varargs) fputs(", ", outfile); no_generated_args = FALSE; } /* varargs go last */ if (op->f_varargs) { if (mode == AS_DECL || mode == AS_IMPL) { fputs("nsVarArgs *", outfile); } fputs("_varargs", outfile); no_generated_args = FALSE; } /* * If generated method has no arguments, output 'void' to avoid C legacy * behavior of disabling type checking. */ if (no_generated_args && mode == AS_DECL) { fputs("void", outfile); } fputc(')', outfile); return TRUE; }
static gboolean method_declaration(TreeState *state) { const char* array = NULL; struct _IDL_OP_DCL *method = &IDL_OP_DCL(state->tree); gboolean method_notxpcom = (IDL_tree_property_get(method->ident, "notxpcom") != NULL); gboolean method_noscript = (IDL_tree_property_get(method->ident, "noscript") != NULL); IDL_tree iterator = NULL; IDL_tree retval_param = NULL; char *method_name = g_strdup_printf("%c%s", tolower(IDL_IDENT(method->ident).str[0]), IDL_IDENT(method->ident).str + 1); if (!verify_method_declaration(state->tree)) return FALSE; fputc('\n', state->file); xpidl_write_comment(state, 4); #if 1 /* do not write non-xpcom methods */ if (method_notxpcom) { return TRUE; } /* * Write beginning of method declaration */ fputs(" public ", state->file); #else /* do not write nonscriptable methods */ if (method_notxpcom || method_noscript) { return TRUE; } /* * Write beginning of method declaration */ fputs(" ", state->file); if (!method_noscript) { /* Nonscriptable methods become package-protected */ fputs("public ", state->file); } #endif /* * Write return type * Unlike C++ headers, Java interfaces return the declared * return value; an exception indicates XPCOM method failure. */ if (method->op_type_spec) { state->tree = method->op_type_spec; if (!xpcom_to_java_type(state, method->op_type_spec)) { return FALSE; } } else { /* Check for retval attribute */ for (iterator = method->parameter_dcls; iterator != NULL; iterator = IDL_LIST(iterator).next) { IDL_tree original_tree = state->tree; state->tree = IDL_LIST(iterator).data; if (IDL_tree_property_get(IDL_PARAM_DCL(state->tree).simple_declarator, "retval")) { retval_param = iterator; array = IDL_tree_property_get(IDL_PARAM_DCL(state->tree).simple_declarator, "array"); /* * Put in type of parameter */ if (!xpcom_to_java_type(state, IDL_PARAM_DCL(state->tree).param_type_spec)) { return FALSE; } if (array) fputs("[]", state->file); } state->tree = original_tree; } if (retval_param == NULL) { fputs("void", state->file); } } /* * Write method name */ fprintf(state->file, " %s(", subscriptIdentifier(state, method_name)); /* * Write parameters */ for (iterator = method->parameter_dcls; iterator != NULL; iterator = IDL_LIST(iterator).next) { /* Skip "retval" */ if (iterator == retval_param) { continue; } if (iterator != method->parameter_dcls) { fputs(", ", state->file); } state->tree = IDL_LIST(iterator).data; if (!xpcom_to_java_param(state)) { return FALSE; } } fputs(")", state->file); /* XXX Disable this for now. How do we specify exceptions? if (method->raises_expr) { IDL_tree iter = method->raises_expr; IDL_tree dataNode = IDL_LIST(iter).data; fputs(" throws ", state->file); fputs(IDL_IDENT(dataNode).str, state->file); iter = IDL_LIST(iter).next; while (iter) { dataNode = IDL_LIST(iter).data; fprintf(state->file, ", %s", IDL_IDENT(dataNode).str); iter = IDL_LIST(iter).next; } } */ fputs(";\n", state->file); 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 interface_declaration(TreeState *state) { char outname[PATH_MAX]; char* p; IDL_tree interface = state->tree; IDL_tree iterator = NULL; char *interface_name = subscriptIdentifier(state, IDL_IDENT(IDL_INTERFACE(interface).ident).str); const char *iid = NULL; char iid_parsed[UUID_LENGTH]; if (!verify_interface_declaration(interface)) return FALSE; /* * Each interface decl is a single file */ p = strrchr(state->filename, '/'); if (p) { strncpy(outname, state->filename, p + 1 - state->filename); outname[p + 1 - state->filename] = '\0'; } strcat(outname, interface_name); strcat(outname, ".java"); state->file = fopen(outname, "w"); if (!state->file) { perror("error opening output file"); return FALSE; } fputs("/*\n * ************* DO NOT EDIT THIS FILE ***********\n", state->file); fprintf(state->file, " *\n * This file was automatically generated from %s.idl.\n", state->basename); fputs(" */\n\n", state->file); if (state->package) fprintf(state->file, "\npackage %s;\n\n", state->package); if (!state->package || strcmp(state->package, "org.mozilla.xpcom") != 0) fputs("import org.mozilla.xpcom.*;\n", state->file); fputs("\n", state->file); #ifndef LIBIDL_MAJOR_VERSION iid = IDL_tree_property_get(interface, "uuid"); #else iid = IDL_tree_property_get(IDL_INTERFACE(interface).ident, "uuid"); #endif if (iid) { struct nsID id; /* Redundant, but a better error than 'cannot parse.' */ if (strlen(iid) != 36) { IDL_tree_error(state->tree, "IID %s is the wrong length\n", iid); return FALSE; } /* * Parse uuid and then output resulting nsID to string, to validate * uuid and normalize resulting .h files. */ if (!xpidl_parse_iid(&id, iid)) { IDL_tree_error(state->tree, "cannot parse IID %s\n", iid); return FALSE; } if (!xpidl_sprint_iid(&id, iid_parsed)) { IDL_tree_error(state->tree, "error formatting IID %s\n", iid); return FALSE; } } else { IDL_tree_error(state->tree, "interface %s lacks a uuid attribute\n", interface_name); return FALSE; } /* * Write out JavaDoc comment */ fprintf(state->file, "\n/**\n * Interface %s\n", interface_name); if (iid != NULL) { fprintf(state->file, " *\n * IID: 0x%s\n */\n\n", iid_parsed); } else { fputs(" */\n\n", state->file); } /* * Write "public interface <foo>" */ fprintf(state->file, "public interface %s", interface_name); /* * Check for inheritence, and iterator over the inherited names, * if any. */ if ((iterator = IDL_INTERFACE(interface).inheritance_spec)) { fputs(" extends ", state->file); do { fprintf(state->file, "%s", IDL_IDENT(IDL_LIST(iterator).data).str); if (IDL_LIST(iterator).next) { fputs(", ", state->file); } } while ((iterator = IDL_LIST(iterator).next)); } fputs("\n{\n", state->file); /* * Write interface constants for IID */ if (iid) { /* public static final String NS_ISUPPORTS_IID = "00000000-0000-0000-c000-000000000046" */ fputs(" public static final String ", state->file); write_classname_iid_define(state->file, interface_name); fprintf(state->file, " =\n \"{%s}\";\n\n", iid_parsed); } /* * Advance the state of the tree, go on to process more */ state->tree = IDL_INTERFACE(interface).body; PRIVDATA(state)->bCountingMethods = FALSE; PRIVDATA(state)->numMethods = 0; if (state->tree && !xpidl_process_node(state)) { return FALSE; } fputs("\n}\n", state->file); fprintf(state->file, "\n/*\n * end\n */\n"); fclose(state->file); return TRUE; }
static gboolean interface_declaration(TreeState *state) { char *outname; IDL_tree interface = state->tree; IDL_tree iterator = NULL; char *interface_name = subscriptIdentifier(state, IDL_IDENT(IDL_INTERFACE(interface).ident).str); const char *iid = NULL; GSList *doc_comments = IDL_IDENT(IDL_INTERFACE(interface).ident).comments; char *prefix = IDL_GENTREE(IDL_NS(state->ns).current)._cur_prefix; /* * Each interface decl is a single file */ outname = g_strdup_printf("%s.%s", interface_name, "java"); FILENAME(state) = fopen(outname, "w"); if (!FILENAME(state)) { perror("error opening output file"); return FALSE; } fputs("/*\n * ************* DO NOT EDIT THIS FILE ***********\n", FILENAME(state)); fprintf(FILENAME(state), " *\n * This file was automatically generated from %s.idl.\n", state->basename); fputs(" */\n\n", FILENAME(state)); if (prefix) { if (strlen(prefix)) fprintf(FILENAME(state), "\npackage %s;\n\n", prefix); fputs("import org.mozilla.xpcom.*;\n\n", FILENAME(state)); } else { fputs("\npackage org.mozilla.xpcom;\n\n", FILENAME(state)); } /* * Write out JavaDoc comment */ fprintf(FILENAME(state), "\n/**\n * Interface %s\n", interface_name); #ifndef LIBIDL_MAJOR_VERSION iid = IDL_tree_property_get(interface, "uuid"); #else iid = IDL_tree_property_get(IDL_INTERFACE(interface).ident, "uuid"); #endif if (iid != NULL) { fprintf(FILENAME(state), " *\n * IID: 0x%s\n */\n\n", iid); } else { fputs(" */\n\n", FILENAME(state)); } if (doc_comments != NULL) printlist(FILENAME(state), doc_comments); /* * Write "public interface <foo>" */ fprintf(FILENAME(state), "public interface %s ", interface_name); /* * Check for inheritence, and iterator over the inherited names, * if any. */ if ((iterator = IDL_INTERFACE(interface).inheritance_spec)) { fputs("extends ", FILENAME(state)); do { fprintf(FILENAME(state), "%s", IDL_IDENT(IDL_LIST(iterator).data).str); if (IDL_LIST(iterator).next) { fputs(", ", FILENAME(state)); } } while ((iterator = IDL_LIST(iterator).next)); } fputs("\n{\n", FILENAME(state)); if (iid) { /* * Write interface constants for IID */ /* fputs(" public static final String ", FILENAME(state)); */ /* XXX s.b just "IID" ? */ /* if (!write_classname_iid_define(FILENAME(state), interface_name)) { */ /* return FALSE; */ /* } */ /* fprintf(FILENAME(state), "_STRING =\n \"%s\";\n\n", iid); */ /* fputs(" public static final nsID ", FILENAME(state)); */ /* XXX s.b just "IID" ? */ /* if (!write_classname_iid_define(FILENAME(state), interface_name)) { */ /* return FALSE; */ /* } */ /* fprintf(FILENAME(state), " =\n new nsID(\"%s\");\n\n", iid); */ fprintf(FILENAME(state), " public static final IID IID =\n new IID(\"%s\");\n\n", iid); } /* * Advance the state of the tree, go on to process more */ state->tree = IDL_INTERFACE(interface).body; if (state->tree && !xpidl_process_node(state)) { return FALSE; } fputs("\n}\n", FILENAME(state)); fprintf(FILENAME(state), "\n/*\n * end\n */\n"); fclose(FILENAME(state)); free(outname); return TRUE; }
/* * Shared between the interface class declaration and the NS_DECL_IFOO macro * provided to aid declaration of implementation classes. * mode... */ static gboolean write_method_signature(IDL_tree method_tree, FILE *outfile, const char *className) { struct _IDL_OP_DCL *op = &IDL_OP_DCL(method_tree); gboolean no_generated_args = TRUE; gboolean op_notxpcom = (IDL_tree_property_get(op->ident, "notxpcom") != NULL); const char *name; IDL_tree iter; if (op_notxpcom && !op->op_type_spec) fputs("procedure ", outfile); else fputs("function ", outfile); name = IDL_IDENT(op->ident).str; if( is_reserved(name) ) fputc('_', outfile); fprintf(outfile, "%c%s(", toupper(*name), name + 1); for (iter = op->parameter_dcls; iter; iter = IDL_LIST(iter).next) { if (!write_param(IDL_LIST(iter).data, outfile)) return FALSE; if ((IDL_LIST(iter).next || (!op_notxpcom && op->op_type_spec) || op->f_varargs)) fputs("; ", outfile); no_generated_args = FALSE; } /* make IDL return value into trailing out argument */ if (op->op_type_spec && !op_notxpcom) { IDL_tree fake_param = IDL_param_dcl_new(IDL_PARAM_OUT, op->op_type_spec, IDL_ident_new("_retval")); if (!fake_param) return FALSE; if (!write_param(fake_param, outfile)) return FALSE; if (op->f_varargs) fputs("; ", outfile); no_generated_args = FALSE; } /* varargs go last */ if (op->f_varargs) { fputs("_varargs : PVarArgs", outfile); no_generated_args = FALSE; } fputc(')', outfile); if (op_notxpcom) { if (!interface_write_type(op->op_type_spec, FALSE, FALSE, FALSE, FALSE, NULL, outfile)) return FALSE; } else { fputs(": nsresult", outfile); } fputs("; stdcall", outfile); return TRUE; }