static gboolean
typelib_attr_accessor(TreeState *state, XPTMethodDescriptor *meth,
gboolean getter, gboolean hidden, gboolean wantsJSContext)
{
uint8 methflags = 0;
uint8 pdflags = 0;
methflags |= getter ? XPT_MD_GETTER : XPT_MD_SETTER;
methflags |= hidden ? XPT_MD_HIDDEN : 0;
methflags |= wantsJSContext ? XPT_MD_CONTEXT : 0;
if (!XPT_FillMethodDescriptor(ARENA(state), meth, methflags,
ATTR_IDENT(state->tree).str, 1))
return FALSE;
if (getter) {
if (DIPPER_TYPE(ATTR_TYPE_DECL(state->tree))) {
pdflags |= (XPT_PD_RETVAL | XPT_PD_IN | XPT_PD_DIPPER);
} else {
pdflags |= (XPT_PD_RETVAL | XPT_PD_OUT);
}
} else {
pdflags |= XPT_PD_IN;
}
if (!fill_pd_from_type(state, meth->params, pdflags,
ATTR_TYPE_DECL(state->tree)))
return FALSE;
fill_pd_as_nsresult(meth->result);
NEXT_METH(state)++;
return TRUE;
}
static gboolean
write_attr_accessor(IDL_tree attr_tree, FILE * outfile,
gboolean getter, const char *className)
{
char *attrname = ATTR_IDENT(attr_tree).str;
fprintf(outfile, "function %cet%c%s(",
getter ? 'G' : 'S',
toupper(*attrname), attrname + 1);
/* Setters for string, wstring, nsid, domstring, utf8string,
* cstring and astring get const.
*/
if (!getter &&
(IDL_NODE_TYPE(ATTR_TYPE_DECL(attr_tree)) == IDLN_TYPE_STRING ||
IDL_NODE_TYPE(ATTR_TYPE_DECL(attr_tree)) == IDLN_TYPE_WIDE_STRING ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "nsid") ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "domstring") ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "utf8string") ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "cstring") ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "astring")))
{
fputs("const ", outfile);
}
fprintf(outfile, "%s",
(getter && !DIPPER_TYPE(ATTR_TYPE_DECL(attr_tree)))? "out " : "");
fprintf(outfile, "a%c%s", toupper(attrname[0]), attrname + 1);
if (!interface_write_type(ATTR_TYPE_DECL(attr_tree), getter, FALSE, FALSE, FALSE, NULL, outfile))
return FALSE;
fputc(')', outfile);
return TRUE;
}
/* If notype is true, just write the param name. */
static gboolean
write_param(IDL_tree param_tree, FILE *outfile)
{
IDL_tree param_type_spec = IDL_PARAM_DCL(param_tree).param_type_spec;
gboolean is_in = IDL_PARAM_DCL(param_tree).attr == IDL_PARAM_IN;
/* in string, wstring, nsid, domstring, utf8string, cstring and
* astring any explicitly marked [const] are const
*/
if (is_in &&
(IDL_NODE_TYPE(param_type_spec) == IDLN_TYPE_STRING ||
IDL_NODE_TYPE(param_type_spec) == IDLN_TYPE_WIDE_STRING ||
IDL_tree_property_get(IDL_PARAM_DCL(param_tree).simple_declarator,
"const") ||
IDL_tree_property_get(param_type_spec, "nsid") ||
IDL_tree_property_get(param_type_spec, "domstring") ||
IDL_tree_property_get(param_type_spec, "utf8string") ||
IDL_tree_property_get(param_type_spec, "cstring") ||
IDL_tree_property_get(param_type_spec, "astring"))) {
fputs("const ", outfile);
}
else if (IDL_PARAM_DCL(param_tree).attr == IDL_PARAM_OUT &&
IDL_tree_property_get(IDL_PARAM_DCL(param_tree).simple_declarator,
"shared")) {
fputs("const ", outfile);
}
if (!write_type(param_type_spec, !is_in, outfile))
return FALSE;
/* unless the type ended in a *, add a space */
if (!STARRED_TYPE(param_type_spec))
fputc(' ', outfile);
/* out and inout params get a bonus '*' (unless this is type that has a
* 'dipper' class that is passed in to receive 'out' data)
*/
if (IDL_PARAM_DCL(param_tree).attr != IDL_PARAM_IN &&
!DIPPER_TYPE(param_type_spec)) {
fputc('*', outfile);
}
/* arrays get a bonus * too */
/* XXX Should this be a leading '*' or a trailing "[]" ?*/
if (IDL_tree_property_get(IDL_PARAM_DCL(param_tree).simple_declarator,
"array"))
fputc('*', outfile);
fputs(IDL_IDENT(IDL_PARAM_DCL(param_tree).simple_declarator).str, outfile);
if (IDL_PARAM_DCL(param_tree).attr == IDL_PARAM_OUT) {
fputs(" NS_OUTPARAM", outfile);
} else if (IDL_PARAM_DCL(param_tree).attr == IDL_PARAM_INOUT) {
fputs(" NS_INOUTPARAM", outfile);
}
return TRUE;
}
static gboolean
fill_pd_from_param(TreeState *state, XPTParamDescriptor *pd, IDL_tree tree)
{
uint8 flags = 0;
gboolean is_dipper_type = DIPPER_TYPE(IDL_PARAM_DCL(tree).param_type_spec);
switch (IDL_PARAM_DCL(tree).attr) {
case IDL_PARAM_IN:
flags = XPT_PD_IN;
break;
case IDL_PARAM_OUT:
flags = XPT_PD_OUT;
break;
case IDL_PARAM_INOUT:
flags = XPT_PD_IN | XPT_PD_OUT;
break;
}
if (IDL_tree_property_get(IDL_PARAM_DCL(tree).simple_declarator,
"retval")) {
if (flags != XPT_PD_OUT) {
IDL_tree_error(tree, "can't have [retval] with in%s param "
"(only out)\n",
flags & XPT_PD_OUT ? "out" : "");
return FALSE;
}
flags |= XPT_PD_RETVAL;
}
if (is_dipper_type && (flags & XPT_PD_OUT)) {
flags &= ~XPT_PD_OUT;
flags |= XPT_PD_IN | XPT_PD_DIPPER;
}
if (IDL_tree_property_get(IDL_PARAM_DCL(tree).simple_declarator,
"shared")) {
if (flags & XPT_PD_IN) {
IDL_tree_error(tree, "can't have [shared] with in%s param "
"(only out)\n",
flags & XPT_PD_OUT ? "out" : "");
return FALSE;
}
flags |= XPT_PD_SHARED;
}
if (IDL_tree_property_get(IDL_PARAM_DCL(tree).simple_declarator,
"optional")) {
flags |= XPT_PD_OPTIONAL;
}
/* stick param where we can see it later */
state->tree = tree;
return fill_pd_from_type(state, pd, flags,
IDL_PARAM_DCL(tree).param_type_spec);
}
/*
* 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_attr_accessor(IDL_tree attr_tree, FILE * outfile,
gboolean getter, int mode, const char *className)
{
char *attrname = ATTR_IDENT(attr_tree).str;
const char *binaryname;
IDL_tree ident = IDL_LIST(IDL_ATTR_DCL(attr_tree).simple_declarations).data;
if (mode == AS_DECL) {
if (IDL_tree_property_get(ident, "deprecated"))
fputs("NS_DEPRECATED ", outfile);
if (is_method_scriptable(attr_tree, ident))
fputs("NS_SCRIPTABLE ", outfile);
fputs("NS_IMETHOD ", outfile);
} else if (mode == AS_IMPL) {
fprintf(outfile, "NS_IMETHODIMP %s::", className);
}
fprintf(outfile, "%cet",
getter ? 'G' : 'S');
binaryname = IDL_tree_property_get(ATTR_DECLS(attr_tree), "binaryname");
if (binaryname) {
fprintf(outfile, "%s(",
binaryname);
} else {
fprintf(outfile, "%c%s(",
toupper(*attrname),
attrname + 1);
}
if (mode == AS_DECL || mode == AS_IMPL) {
/* Setters for string, wstring, nsid, domstring, utf8string,
* cstring and astring get const.
*/
if (!getter &&
(IDL_NODE_TYPE(ATTR_TYPE_DECL(attr_tree)) == IDLN_TYPE_STRING ||
IDL_NODE_TYPE(ATTR_TYPE_DECL(attr_tree)) == IDLN_TYPE_WIDE_STRING ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "nsid") ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "domstring") ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "utf8string") ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "cstring") ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "astring")))
{
fputs("const ", outfile);
}
if (!write_type(ATTR_TYPE_DECL(attr_tree), getter, outfile))
return FALSE;
fprintf(outfile, "%s%s",
(STARRED_TYPE(attr_tree) ? "" : " "),
(getter && !DIPPER_TYPE(ATTR_TYPE_DECL(attr_tree)))? "*" : "");
}
fprintf(outfile, "a%c%s)", toupper(attrname[0]), attrname + 1);
return TRUE;
}
/*
* 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_attr_accessor(IDL_tree attr_tree, FILE * outfile,
gboolean getter, int mode, const char *className)
{
char *attrname = ATTR_IDENT(attr_tree).str;
if (mode == AS_DECL) {
fputs("NS_IMETHOD ", outfile);
} else if (mode == AS_IMPL) {
fprintf(outfile, "NS_IMETHODIMP %s::", className);
}
fprintf(outfile, "%cet%c%s(",
getter ? 'G' : 'S',
toupper(*attrname), attrname + 1);
if (mode == AS_DECL || mode == AS_IMPL) {
/* Setters for string, wstring, nsid, domstring, utf8string,
* cstring and astring get const.
*/
if (!getter &&
(IDL_NODE_TYPE(ATTR_TYPE_DECL(attr_tree)) == IDLN_TYPE_STRING ||
IDL_NODE_TYPE(ATTR_TYPE_DECL(attr_tree)) == IDLN_TYPE_WIDE_STRING ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "nsid") ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "domstring") ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "utf8string") ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "cstring") ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "astring")))
{
fputs("const ", outfile);
}
if (!write_type(ATTR_TYPE_DECL(attr_tree), getter, outfile))
return FALSE;
fprintf(outfile, "%s%s",
(STARRED_TYPE(attr_tree) ? "" : " "),
(getter && !DIPPER_TYPE(ATTR_TYPE_DECL(attr_tree)))? "*" : "");
}
fprintf(outfile, "a%c%s)", toupper(attrname[0]), attrname + 1);
return TRUE;
}
static gboolean
typelib_op_dcl(TreeState *state)
{
XPTInterfaceDescriptor *id = CURRENT(state);
XPTMethodDescriptor *meth;
struct _IDL_OP_DCL *op = &IDL_OP_DCL(state->tree);
IDL_tree iter;
uint16 num_args = 0;
uint8 op_flags = 0;
gboolean op_notxpcom = (IDL_tree_property_get(op->ident, "notxpcom")
!= NULL);
gboolean op_noscript = (IDL_tree_property_get(op->ident, "noscript")
!= NULL);
gboolean op_context = (IDL_tree_property_get(op->ident,
"implicit_jscontext") != NULL);
gboolean op_opt_argc = (IDL_tree_property_get(op->ident, "optional_argc")
!= NULL);
if (!verify_method_declaration(state->tree))
return FALSE;
if (!XPT_InterfaceDescriptorAddMethods(ARENA(state), id, 1))
return FALSE;
meth = &id->method_descriptors[NEXT_METH(state)];
for (iter = op->parameter_dcls; iter; iter = IDL_LIST(iter).next)
num_args++; /* count params */
if (op->op_type_spec && !op_notxpcom)
num_args++; /* fake param for _retval */
if (op_noscript)
op_flags |= XPT_MD_HIDDEN;
if (op_notxpcom)
op_flags |= XPT_MD_NOTXPCOM;
if (op_opt_argc)
op_flags |= XPT_MD_OPT_ARGC;
if (op_context)
op_flags |= XPT_MD_CONTEXT;
/* XXXshaver constructor? */
#ifdef DEBUG_shaver_method
fprintf(stdout, "DBG: adding method %s (nargs %d)\n",
IDL_IDENT(op->ident).str, num_args);
#endif
if (!XPT_FillMethodDescriptor(ARENA(state), meth, op_flags,
IDL_IDENT(op->ident).str,
(uint8) num_args))
return FALSE;
for (num_args = 0, iter = op->parameter_dcls; iter;
iter = IDL_LIST(iter).next, num_args++) {
XPTParamDescriptor *pd = &meth->params[num_args];
if (!fill_pd_from_param(state, pd, IDL_LIST(iter).data))
return FALSE;
}
/* stick retval param where we can see it later */
state->tree = op->op_type_spec;
/* XXX unless [notxpcom] */
if (!op_notxpcom) {
if (op->op_type_spec) {
uint8 pdflags = DIPPER_TYPE(op->op_type_spec) ?
(XPT_PD_RETVAL | XPT_PD_IN | XPT_PD_DIPPER) :
(XPT_PD_RETVAL | XPT_PD_OUT);
if (!fill_pd_from_type(state, &meth->params[num_args],
pdflags, op->op_type_spec))
return FALSE;
}
if (!fill_pd_as_nsresult(meth->result))
return FALSE;
} else {
#ifdef DEBUG_shaver_notxpcom
fprintf(stderr, "%s is notxpcom\n", IDL_IDENT(op->ident).str);
#endif
if (!fill_pd_from_type(state, meth->result, XPT_PD_RETVAL,
op->op_type_spec))
return FALSE;
}
NEXT_METH(state)++;
return TRUE;
}
