/*
* 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;
}
void
orbit_cbe_unflatten_args (IDL_tree tree, FILE *of, const char *name)
{
IDL_tree l;
int i = 0;
for (l = IDL_OP_DCL(tree).parameter_dcls; l;
l = IDL_LIST(l).next) {
IDL_tree decl = IDL_LIST (l).data;
IDL_tree tspec = orbit_cbe_get_typespec (decl);
IDL_ParamRole r = 0;
char *unflatten;
switch(IDL_PARAM_DCL(decl).attr) {
case IDL_PARAM_IN: r = DATA_IN; break;
case IDL_PARAM_INOUT: r = DATA_INOUT; break;
case IDL_PARAM_OUT: r = DATA_OUT; break;
default:
g_error("Unknown IDL_PARAM type");
}
unflatten = orbit_cbe_unflatten_ref (r, tspec);
fprintf (of, "%s%s[%d], ", unflatten, name, i++);
g_free (unflatten);
}
}
static gboolean
find_arg_with_name(TreeState *state, const char *name, int16 *argnum)
{
int16 count;
IDL_tree params;
XPT_ASSERT(state);
XPT_ASSERT(name);
XPT_ASSERT(argnum);
params = IDL_OP_DCL(IDL_NODE_UP(IDL_NODE_UP(state->tree))).parameter_dcls;
for (count = 0;
params != NULL && IDL_LIST(params).data != NULL;
params = IDL_LIST(params).next, count++)
{
const char *cur_name = IDL_IDENT(
IDL_PARAM_DCL(IDL_LIST(params).data).simple_declarator).str;
if (!strcmp(cur_name, name)) {
/* XXX ought to verify that this is the right type here */
/* XXX for iid_is this must be an iid */
/* XXX for size_is and length_is this must be a uint32 */
*argnum = count;
return TRUE;
}
}
return FALSE;
}
static
void VoyagerWriteParamsForParentCall(IDL_tree curif, InheritedOutputInfo2 *ioi)
{
IDL_tree curitem;
char* overridenMethodName;
if(curif == ioi->realif)
return;
overridenMethodName=ioi->chrOverridenMethodName;
for(curitem = IDL_INTERFACE(curif).body; curitem; curitem = IDL_LIST(curitem).next) {
IDL_tree curop = IDL_LIST(curitem).data;
switch(IDL_NODE_TYPE(curop)) {
case IDLN_OP_DCL:
{
/* Check if the current method (introduced by some parent) is the one to be
overriden. */
if(!strcmp(overridenMethodName, IDL_IDENT(IDL_OP_DCL(curop).ident).str)){
IDL_tree sub;
for (sub = IDL_OP_DCL (curop).parameter_dcls; sub; sub = IDL_LIST (sub).next) {
IDL_tree parm = IDL_LIST (sub).data;
fprintf (ioi->of, "%s, ", IDL_IDENT (IDL_PARAM_DCL (parm).simple_declarator).str);
}
}
break;
}
default:
break;
}
}
}
IDL_tree
MateCORBA_imodule_get_typespec (IDL_tree tree)
{
IDL_tree retval = NULL;
if (!tree)
return NULL;
switch (IDL_NODE_TYPE (tree)) {
case IDLN_TYPE_INTEGER:
case IDLN_TYPE_FLOAT:
case IDLN_TYPE_FIXED:
case IDLN_TYPE_CHAR:
case IDLN_TYPE_WIDE_CHAR:
case IDLN_TYPE_STRING:
case IDLN_TYPE_WIDE_STRING:
case IDLN_TYPE_BOOLEAN:
case IDLN_TYPE_OCTET:
case IDLN_TYPE_ANY:
case IDLN_TYPE_OBJECT:
case IDLN_TYPE_ENUM:
case IDLN_TYPE_SEQUENCE:
case IDLN_TYPE_ARRAY:
case IDLN_TYPE_STRUCT:
case IDLN_TYPE_UNION:
case IDLN_EXCEPT_DCL:
case IDLN_FORWARD_DCL:
case IDLN_INTERFACE:
case IDLN_NATIVE:
case IDLN_TYPE_TYPECODE:
retval = tree;
break;
case IDLN_TYPE_DCL:
retval = MateCORBA_imodule_get_typespec (
IDL_TYPE_DCL (tree).type_spec);
break;
case IDLN_PARAM_DCL:
retval = MateCORBA_imodule_get_typespec (
IDL_PARAM_DCL (tree).param_type_spec);
break;
case IDLN_MEMBER:
retval = MateCORBA_imodule_get_typespec (
IDL_MEMBER (tree).type_spec);
break;
case IDLN_LIST:
case IDLN_IDENT:
retval = MateCORBA_imodule_get_typespec (
IDL_get_parent_node (tree, IDLN_ANY, NULL));
break;
default:
g_error ("Cannot get typespec for %s",
IDL_tree_type_names [IDL_NODE_TYPE (tree)]);
break;
}
return retval;
}
/*
This helper just writes the typespec of a parameter to a method without any
'const' qualifier.
*/
void
orbit_cbe_voyager_write_param_typespec(FILE *of, IDL_tree tree) {
IDL_tree ts = NULL /* Quiet gcc */;
IDL_ParamRole role = 0 /* Quiet gcc */;
char *str;
switch ( IDL_NODE_TYPE(tree) ) {
case IDLN_PARAM_DCL: /* one of the parameters */
ts = IDL_PARAM_DCL(tree).param_type_spec;
role = oidl_attr_to_paramrole(IDL_PARAM_DCL(tree).attr);
break;
default:
g_assert_not_reached();
}
str = orbit_cbe_voyager_write_param_typespec_str (ts, role);
fprintf (of, str);
g_free (str);
}
void
orbit_cbe_write_param_typespec(FILE *of, IDL_tree tree) {
IDL_tree ts = NULL /* Quiet gcc */;
IDL_ParamRole role = 0 /* Quiet gcc */;
switch ( IDL_NODE_TYPE(tree) ) {
case IDLN_OP_DCL: /* means return value of method */
ts = IDL_OP_DCL(tree).op_type_spec;
role = DATA_RETURN;
break;
case IDLN_PARAM_DCL: /* one of the parameters */
ts = IDL_PARAM_DCL(tree).param_type_spec;
role = oidl_attr_to_paramrole(IDL_PARAM_DCL(tree).attr);
break;
default:
g_assert_not_reached();
}
orbit_cbe_write_param_typespec_raw(of, ts, role);
}
/*
This function is called for each parent to check if the current parent introduced the
overriden method. If yes, the parameter info is taken from this parent and put into the
file.
*/
static
void VoyagerDoWriteParamsForOverridenMethod(IDL_tree curif, InheritedOutputInfo2 *ioi)
{
IDL_tree curitem;
char* overridenMethodName;
if(curif == ioi->realif)
return;
overridenMethodName=ioi->chrOverridenMethodName;
for(curitem = IDL_INTERFACE(curif).body; curitem; curitem = IDL_LIST(curitem).next) {
IDL_tree curop = IDL_LIST(curitem).data;
switch(IDL_NODE_TYPE(curop)) {
case IDLN_OP_DCL:
{
/* Check if the current method (introduced by some parent) is the one to be
overriden. */
if(!strcmp(overridenMethodName, IDL_IDENT(IDL_OP_DCL(curop).ident).str)){
IDL_tree sub;
g_assert (IDL_NODE_TYPE(curop) == IDLN_OP_DCL);
/* return typespec */
orbit_cbe_write_param_typespec (ioi->of, curop);
/* The methodname */
fprintf (ioi->of, " %s%s_%s", "NOMLINK impl_",
ioi->chrClassName, overridenMethodName);
fprintf (ioi->of, "(%s* nomSelf, ", ioi->chrClassName);
/* Write the params including the typespec */
for (sub = IDL_OP_DCL (curop).parameter_dcls; sub; sub = IDL_LIST (sub).next) {
IDL_tree parm = IDL_LIST (sub).data;
orbit_cbe_write_param_typespec (ioi->of, parm);
fprintf (ioi->of, " %s, ", IDL_IDENT (IDL_PARAM_DCL (parm).simple_declarator).str);
}
if (IDL_OP_DCL (curop).context_expr)
fprintf (ioi->of, "CORBA_Context _ctx, ");
fprintf (ioi->of, "CORBA_Environment *ev)");
}
break;
}
default:
break;
}
}
}
/* 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);
return TRUE;
}
static gboolean
xpcom_to_java_param(TreeState *state)
{
IDL_tree param = state->tree;
/*
* Put in type of parameter
*/
if (!xpcom_to_java_type(state, IDL_PARAM_DCL(param).param_type_spec)) {
return FALSE;
}
/*
* If the parameter is out or inout, make it a Java array of the
* appropriate type
*/
if (IDL_PARAM_DCL(param).attr != IDL_PARAM_IN) {
fputs("[]", state->file);
}
/*
* If the parameter is an array make it a Java array
*/
if (IDL_tree_property_get(IDL_PARAM_DCL(param).simple_declarator, "array"))
fputs("[]", state->file);
/*
* Put in name of parameter
*/
fputc(' ', state->file);
fputs(subscriptIdentifier(state,
IDL_IDENT(IDL_PARAM_DCL(param).simple_declarator).str),
state->file);
return TRUE;
}
void
orte_idl_check_oneway_op (IDL_tree op)
{
g_assert (IDL_NODE_TYPE(op) == IDLN_OP_DCL);
if (IDL_OP_DCL (op).f_oneway) {
IDL_tree sub;
for (sub = IDL_OP_DCL (op).parameter_dcls; sub; sub = IDL_LIST (sub).next) {
IDL_tree param = IDL_LIST (sub).data;
if (IDL_PARAM_DCL (param).attr == IDL_PARAM_OUT ||
IDL_PARAM_DCL (param).attr == IDL_PARAM_INOUT) {
g_warning ("Out or Inout parameter in declaration of oneway '%s'",
IDL_IDENT(IDL_OP_DCL(op).ident).str);
break;
}
}
if (IDL_OP_DCL (op).op_type_spec)
g_warning ("Return value in declaration of oneway '%s'",
IDL_IDENT(IDL_OP_DCL(op).ident).str);
}
}
static IDL_tree /* IDL_PARAM_DCL */
find_named_parameter(IDL_tree method_tree, const char *param_name)
{
IDL_tree iter;
for (iter = IDL_OP_DCL(method_tree).parameter_dcls; iter;
iter = IDL_LIST(iter).next)
{
IDL_tree param = IDL_LIST(iter).data;
IDL_tree simple_decl = IDL_PARAM_DCL(param).simple_declarator;
const char *current_name = IDL_IDENT(simple_decl).str;
if (strcmp(current_name, param_name) == 0)
return param;
}
return NULL;
}
IDL_tree
orte_cbe_get_typespec(IDL_tree node)
{
if(node == NULL)
return NULL;
switch(IDL_NODE_TYPE(node)) {
case IDLN_TYPE_INTEGER:
case IDLN_TYPE_FLOAT:
case IDLN_TYPE_FIXED:
case IDLN_TYPE_CHAR:
case IDLN_TYPE_WIDE_CHAR:
case IDLN_TYPE_STRING:
case IDLN_TYPE_WIDE_STRING:
case IDLN_TYPE_BOOLEAN:
case IDLN_TYPE_OCTET:
case IDLN_TYPE_ANY:
case IDLN_TYPE_OBJECT:
case IDLN_TYPE_ENUM:
case IDLN_TYPE_SEQUENCE:
case IDLN_TYPE_ARRAY:
case IDLN_TYPE_STRUCT:
case IDLN_TYPE_UNION:
case IDLN_EXCEPT_DCL:
case IDLN_FORWARD_DCL:
case IDLN_INTERFACE:
case IDLN_NATIVE:
case IDLN_TYPE_TYPECODE:
return node;
break;
case IDLN_TYPE_DCL:
return orte_cbe_get_typespec(IDL_TYPE_DCL(node).type_spec);
break;
case IDLN_PARAM_DCL:
return orte_cbe_get_typespec(IDL_PARAM_DCL(node).param_type_spec);
break;
case IDLN_MEMBER:
return orte_cbe_get_typespec(IDL_MEMBER(node).type_spec);
break;
case IDLN_LIST:
case IDLN_IDENT:
return orte_cbe_get_typespec(IDL_get_parent_node(node, IDLN_ANY, NULL));
break;
default:
g_error("Unhandled node type %s!", IDL_tree_type_names[IDL_NODE_TYPE(node)]);
return NULL;
}
}
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);
}
/* return value is for success or failure */
static gboolean
get_size_and_length(TreeState *state, IDL_tree type,
int16 *size_is_argnum, int16 *length_is_argnum,
gboolean *has_size_is, gboolean *has_length_is)
{
*has_size_is = FALSE;
*has_length_is = FALSE;
if (IDL_NODE_TYPE(state->tree) == IDLN_PARAM_DCL) {
IDL_tree sd = IDL_PARAM_DCL(state->tree).simple_declarator;
const char *size_is;
const char *length_is;
/* only if size_is is found does any of this matter */
size_is = IDL_tree_property_get(sd, "size_is");
if (!size_is)
return TRUE;
if (!find_arg_with_name(state, size_is, size_is_argnum)) {
IDL_tree_error(state->tree, "can't find matching argument for "
"[size_is(%s)]\n", size_is);
return FALSE;
}
*has_size_is = TRUE;
/* length_is is optional */
length_is = IDL_tree_property_get(sd, "length_is");
if (length_is) {
*has_length_is = TRUE;
if (!find_arg_with_name(state, length_is, length_is_argnum)) {
IDL_tree_error(state->tree, "can't find matching argument for "
"[length_is(%s)]\n", length_is);
return FALSE;
}
}
}
return TRUE;
}
/* Find all the interfaces referenced in the tree (uses add_interface_maybe) */
static gboolean
find_interfaces(IDL_tree_func_data *tfd, gpointer user_data)
{
IDL_tree node = NULL;
switch (IDL_NODE_TYPE(tfd->tree)) {
case IDLN_ATTR_DCL:
node = IDL_ATTR_DCL(tfd->tree).param_type_spec;
break;
case IDLN_OP_DCL:
IDL_tree_walk_in_order(IDL_OP_DCL(tfd->tree).parameter_dcls, find_interfaces,
user_data);
node = IDL_OP_DCL(tfd->tree).op_type_spec;
break;
case IDLN_PARAM_DCL:
node = IDL_PARAM_DCL(tfd->tree).param_type_spec;
break;
case IDLN_INTERFACE:
node = IDL_INTERFACE(tfd->tree).inheritance_spec;
if (node)
xpidl_list_foreach(node, add_interface_maybe, user_data);
node = IDL_INTERFACE(tfd->tree).ident;
break;
case IDLN_FORWARD_DCL:
node = IDL_FORWARD_DCL(tfd->tree).ident;
break;
default:
node = NULL;
}
if (node && IDL_NODE_TYPE(node) == IDLN_IDENT) {
IDL_tree_func_data new_tfd;
new_tfd.tree = node;
add_interface_maybe(&new_tfd, user_data);
}
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);
}
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;
}
void
orbit_cbe_op_write_proto (FILE *of,
IDL_tree op,
const char *nom_prefix,
gboolean for_epv)
{
IDL_tree sub;
char *id;
char * id2;
char * ptr;
g_assert (IDL_NODE_TYPE(op) == IDLN_OP_DCL);
orbit_cbe_write_param_typespec (of, op);
id = IDL_ns_ident_to_qstring (
IDL_IDENT_TO_NS (IDL_INTERFACE (
IDL_get_parent_node (op, IDLN_INTERFACE, NULL)).ident), "_", 0);
#ifdef USE_LIBIDL_CODE
if (for_epv)
fprintf (of, " (*%s%s)", nom_prefix ? nom_prefix : "",
IDL_IDENT(IDL_OP_DCL(op).ident).str);
else
fprintf (of, " %s%s_%s", nom_prefix ? nom_prefix : "",
id, IDL_IDENT(IDL_OP_DCL(op).ident).str);
#else
id2=g_strdup(IDL_IDENT (IDL_OP_DCL (op).ident).str);
if((ptr=strstr(id2, NOM_OVERRIDE_STRING))!=NULL)
*ptr='\0';
if (for_epv)
fprintf (of, " (*%s%s)", nom_prefix ? nom_prefix : "",
IDL_IDENT(IDL_OP_DCL(op).ident).str);
else
fprintf (of, " %s%s_%s", nom_prefix ? nom_prefix : "",
id, id2);
g_free(id2);
#endif
fprintf (of, "(");
if (for_epv)
fprintf (of, "PortableServer_Servant _servant, ");
else
#ifdef USE_LIBIDL_CODE
fprintf (of, "%s _obj, ", id);
#else
fprintf (of, "%s* nomSelf, ", id);
#endif
g_free (id);
for (sub = IDL_OP_DCL (op).parameter_dcls; sub; sub = IDL_LIST (sub).next) {
IDL_tree parm = IDL_LIST (sub).data;
orbit_cbe_write_param_typespec (of, parm);
fprintf (of, " %s, ", IDL_IDENT (IDL_PARAM_DCL (parm).simple_declarator).str);
}
if (IDL_OP_DCL (op).context_expr)
fprintf (of, "CORBA_Context _ctx, ");
fprintf (of, "CORBA_Environment *ev)");
}
/**
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;
}
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));
}
}
/*
* 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;
IDL_tree iter;
if (mode == AS_DECL) {
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::%c%s(", className, toupper(*name), name + 1);
} 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
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
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 void
cc_output_iargs (FILE *of, const char *method, IDL_tree tree)
{
IDL_tree sub;
int arg_count = 0;
/* Build a list of IArgs */
for (sub = IDL_OP_DCL (tree).parameter_dcls; sub;
sub = IDL_LIST (sub).next) {
IDL_tree parm;
char *tc;
if (!arg_count)
fprintf (of, "static ORBit_IArg %s__arginfo [] = {\n", method);
parm = IDL_LIST(sub).data;
fprintf (of, "\t{ ");
/* TypeCode tc */
tc = orbit_cbe_get_typecode_name (
IDL_PARAM_DCL (parm).param_type_spec);
if (!tc) {
g_warning ("Can't get typecode");
tc = g_strdup ("NULL /* no typecode */");
}
fprintf (of, "%s, ", tc);
/* IArgFlag flags */
switch (IDL_PARAM_DCL (parm).attr) {
case IDL_PARAM_IN:
fprintf (of, " ORBit_I_ARG_IN ");
break;
case IDL_PARAM_OUT:
fprintf (of, " ORBit_I_ARG_OUT ");
break;
case IDL_PARAM_INOUT:
fprintf (of, " ORBit_I_ARG_INOUT ");
break;
}
if (orbit_cbe_type_is_fixed_length (
IDL_PARAM_DCL (parm).param_type_spec))
fprintf (of, "| ORBit_I_COMMON_FIXED_SIZE");
else if (IDL_PARAM_DCL(parm).attr == IDL_PARAM_OUT) {
IDL_tree ts = orbit_cbe_get_typespec (
IDL_PARAM_DCL (parm).param_type_spec);
switch(IDL_NODE_TYPE (ts)) {
case IDLN_TYPE_STRUCT:
case IDLN_TYPE_UNION:
case IDLN_TYPE_ARRAY:
/* fprintf (of, "| ORBIT_I_ARG_FIXED");*/
break;
default:
break;
};
}
fprintf (of, ", ");
/* string name */
fprintf (of, "\"%s\"", IDL_IDENT (IDL_PARAM_DCL (
IDL_LIST (sub).data).simple_declarator).str);
fprintf (of, " }%s\n", IDL_LIST (sub).next ? "," : "");
g_free (tc);
arg_count++;
}
if (arg_count)
fprintf (of, "};\n");
}
static gboolean coder_service_on_function(Coder* thiz, struct _IDL_OP_DCL f)
{
int i = 0;
TypeInfo type = {0};
const char* param_name = NULL;
struct _IDL_LIST iter = {0};
char lower_func_name[STR_LENGTH+1] = {0};
PrivInfo* priv = (PrivInfo*)thiz->priv;
char req_coder_name[STR_LENGTH+1];
const char* func_name = IDL_IDENT(f.ident).str;
GString* params_list = g_string_sized_new(1024);
GString* params_in = g_string_sized_new(1024);
GString* params_out = g_string_sized_new(1024);
GString* params_call = g_string_sized_new(1024);
GString* params_decls = g_string_sized_new(1024);
GString* params_free = g_string_sized_new(1024);
coder_name_to_lower(func_name, lower_func_name);
coder_get_type_info(f.op_type_spec, 0, &type);
if(f.parameter_dcls != NULL)
{
for (i = 0, iter = IDL_LIST(f.parameter_dcls); iter.data != NULL; iter = IDL_LIST(iter.next))
{
int attr = IDL_PARAM_DCL(iter.data).attr;
param_name = IDL_IDENT(IDL_PARAM_DCL(iter.data).simple_declarator).str;
coder_get_type_info(IDL_PARAM_DCL(iter.data).param_type_spec, attr, &type);
g_string_append_printf(params_list, ", %s %s", type.name, param_name);
g_string_append_printf(params_decls, "\t%s %s = {0};\n", type.name, param_name);
g_string_append_printf(params_call, ", %s%s", attr == IDL_PARAM_OUT ? "&" : "", param_name);
if(attr == IDL_PARAM_OUT)
{
if(strcmp(type.org_name, "int") == 0)
{
g_string_append_printf(params_out, "\t\t\tfbus_parcel_write_int(req_resp, %s);\n", param_name);
}
else if(strcmp(type.org_name, "String") == 0)
{
g_string_append_printf(params_out, "\t\t\tfbus_parcel_write_string(req_resp, %s);\n", param_name);
g_string_append_printf(params_free, "\t\t\tFTK_FREE(%s);\n", param_name);
}
else
{
g_string_append_printf(params_out, "\t\t\tfbus_parcel_write_data(req_resp, &%s, sizeof(%s));\n",
param_name, param_name);
}
}
if(attr == IDL_PARAM_IN)
{
if(strcmp(type.org_name, "int") == 0)
{
g_string_append_printf(params_in, "\t%s = fbus_parcel_get_int(req_resp);\n", param_name);
}
else if(strcmp(type.org_name, "String") == 0)
{
g_string_append_printf(params_in, "\t%s = fbus_parcel_get_string(req_resp);\n", param_name);
}
else
{
g_string_append_printf(params_in, "\t%s = (%s)fbus_parcel_get_data(req_resp, sizeof(%s));\n",
param_name, type.name, param_name);
}
}
if(iter.next == NULL)
{
break;
}
}
}
coder_name_to_lower(func_name, lower_func_name);
snprintf(req_coder_name, sizeof(req_coder_name)-1, "%s_%s", priv->interface_lower, lower_func_name);
coder_to_upper(req_coder_name);
g_string_append_printf(priv->func_dispatch, "\t\tcase %s:\n", req_coder_name);
g_string_append_printf(priv->func_dispatch, "\t\t{\n");
g_string_append_printf(priv->func_dispatch, "\t\t\t%s_marshal_%s(thiz, req_resp);\n",
priv->interface_lower, lower_func_name);
g_string_append_printf(priv->func_dispatch, "\t\t\tbreak;\n");
g_string_append_printf(priv->func_dispatch, "\t\t}\n");
g_string_append_printf(priv->func_empty, "static Ret %s_marshal_%s(FBusService* thiz, FBusParcel* req_resp)\n{\n",
priv->interface_lower, lower_func_name);
g_string_append_printf(priv->func_empty, "%s\n", params_decls->str);
g_string_append_printf(priv->func_empty, "\tRet ret = RET_FAIL;\n");
g_string_append_printf(priv->func_empty, "\tDECL_PRIV(thiz, priv);\n");
g_string_append_printf(priv->func_empty,
" return_val_if_fail(priv != NULL && priv->impl != NULL && req_resp != NULL, RET_FAIL);\n\n");
g_string_append_printf(priv->func_empty, "%s\n", params_in->str);
g_string_append_printf(priv->func_empty, "\tif((ret = %s_%s(priv->impl%s)) == RET_OK)\n",
priv->interface_lower, lower_func_name, params_call->str);
g_string_append_printf(priv->func_empty, "\t{\n");
g_string_append_printf(priv->func_empty, "\t\tfbus_parcel_reset(req_resp);\n");
g_string_append_printf(priv->func_empty, "\t\tfbus_parcel_write_int(req_resp, ret);\n");
if(params_out->str != NULL && strlen(params_out->str) > 0)
{
g_string_append_printf(priv->func_empty, "\t\tif(ret == RET_OK)\n");
g_string_append_printf(priv->func_empty, "\t\t{\n");
g_string_append_printf(priv->func_empty, "%s", params_out->str);
g_string_append_printf(priv->func_empty, "%s", params_free->str);
g_string_append_printf(priv->func_empty, "\t\t}\n");
}
g_string_append_printf(priv->func_empty, "\t}\n\n");
g_string_append_printf(priv->func_empty, "\treturn ret;\n");
g_string_append_printf(priv->func_empty, "}\n\n");
g_string_append_printf(priv->func_create, " thiz->%s = %s_marshal_%s;\n",
lower_func_name, priv->interface_lower, lower_func_name);
g_string_free(params_list, 1);
g_string_free(params_in, 1);
g_string_free(params_out, 1);
g_string_free(params_call, 1);
g_string_free(params_decls, 1);
g_string_free(params_free, 1);
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 void
cs_output_stub (IDL_tree tree,
OIDL_C_Info *ci,
int *idx)
{
FILE *of = ci->fh;
char *iface_id;
char *opname;
gboolean has_retval, has_args;
g_return_if_fail (idx != NULL);
iface_id = IDL_ns_ident_to_qstring (
IDL_IDENT_TO_NS (IDL_INTERFACE (
IDL_get_parent_node (tree, IDLN_INTERFACE, NULL)
).ident), "_", 0);
opname = IDL_ns_ident_to_qstring (IDL_IDENT_TO_NS (IDL_OP_DCL (tree).ident), "_", 0);
has_retval = IDL_OP_DCL (tree).op_type_spec != NULL;
has_args = IDL_OP_DCL (tree).parameter_dcls != NULL;
#ifdef USE_LIBIDL_CODE
orbit_cbe_op_write_proto (of, tree, "", FALSE);
fprintf (of, "{\n");
if (has_retval) {
orbit_cbe_write_param_typespec (of, tree);
fprintf (of, " " ORBIT_RETVAL_VAR_NAME ";\n");
}
fprintf (ci->fh, "POA_%s__epv *%s;\n", iface_id, ORBIT_EPV_VAR_NAME);
fprintf (ci->fh, "gpointer _ORBIT_servant;\n");
/* in-proc part */
fprintf (ci->fh, "if ((%s = ORBit_c_stub_invoke\n", ORBIT_EPV_VAR_NAME);
fprintf (ci->fh, " (_obj, %s__classid, &_ORBIT_servant,\n", iface_id);
fprintf (ci->fh, " G_STRUCT_OFFSET (POA_%s__epv, %s)))) {\n",
iface_id, IDL_IDENT (IDL_OP_DCL (tree).ident).str);
fprintf (ci->fh, "if (ORBit_small_flags & ORBIT_SMALL_FAST_LOCALS && \n");
fprintf (ci->fh, " ORBIT_STUB_IsBypass (_obj, %s__classid) && \n", iface_id);
fprintf (ci->fh, " (%s = (POA_%s__epv*) ORBIT_STUB_GetEpv (_obj, %s__classid))->%s) {\n",
ORBIT_EPV_VAR_NAME, iface_id, iface_id, IDL_IDENT (IDL_OP_DCL (tree).ident).str);
fprintf (ci->fh, "ORBIT_STUB_PreCall (_obj);\n");
fprintf (ci->fh, "%s%s->%s (_ORBIT_servant, ",
IDL_OP_DCL (tree).op_type_spec? ORBIT_RETVAL_VAR_NAME " = ":"",
ORBIT_EPV_VAR_NAME,
IDL_IDENT (IDL_OP_DCL (tree).ident).str);
for (node = IDL_OP_DCL (tree).parameter_dcls; node; node = IDL_LIST (node).next)
fprintf (ci->fh, "%s, ",
IDL_IDENT (IDL_PARAM_DCL (IDL_LIST (node).data).simple_declarator).str);
if (IDL_OP_DCL (tree).context_expr)
fprintf (ci->fh, "_ctx, ");
fprintf (ci->fh, "ev);\n");
fprintf (ci->fh, "ORBit_stub_post_invoke (_obj, %s);\n", ORBIT_EPV_VAR_NAME);
fprintf (of, " } else { /* remote marshal */\n");
/* remote invocation part */
if (has_args)
orbit_cbe_flatten_args (tree, of, "_args");
fprintf (of, "ORBit_c_stub_invoke (_obj, "
"&%s__iinterface.methods, %d, ", iface_id, *idx);
if (has_retval)
fprintf (of, "&_ORBIT_retval, ");
else
fprintf (of, "NULL, ");
if (has_args)
fprintf (of, "_args, ");
else
fprintf (of, "NULL, ");
if (IDL_OP_DCL (tree).context_expr)
fprintf (ci->fh, "_ctx, ");
else
fprintf (ci->fh, "NULL, ");
fprintf (of, "ev, ");
fprintf (of, "%s__classid, G_STRUCT_OFFSET (POA_%s__epv, %s),\n",
iface_id, iface_id, IDL_IDENT (IDL_OP_DCL (tree).ident).str);
fprintf (of, "(ORBitSmallSkeleton) _ORBIT_skel_small_%s);\n\n", opname);
if (has_retval)
fprintf (of, "return " ORBIT_RETVAL_VAR_NAME ";\n");
fprintf (of, "}\n");
#else
/*** This is Voyager stuff... ***/
if(strstr(opname, NOM_INSTANCEVAR_STRING)==NULL &&
strstr(opname, NOM_OVERRIDE_STRING)==NULL)
{
/* Skip specially marked methods containing "__INSTANCEVAR__ */
fprintf (of, "NOM_Scope ");
orbit_cbe_op_write_proto (of, tree, "NOMLINK impl_", FALSE);
fprintf (of, "\n{\n");
fprintf (of, "/* %sData* nomThis=%sGetData(nomSelf); */\n",
iface_id, iface_id);
if (has_retval) {
fprintf (of, " ");
orbit_cbe_write_param_typespec (of, tree);
fprintf (of, " " ORBIT_RETVAL_VAR_NAME ";\n\n");
fprintf (of, " return " ORBIT_RETVAL_VAR_NAME ";\n");
}
else
fprintf (of, "\n"); /* Beautyfication... */
fprintf (of, "}\n\n");
}
if(strstr(opname, NOM_OVERRIDE_STRING)!=NULL)
{
/* There's an overriden method here */
fprintf (of, "\n/* %s, %s line %d */\n", __FILE__, __FUNCTION__, __LINE__);
fprintf (of, "NOM_Scope ");
VoyagerWriteParamsForOverridenMethod (of, tree, "", FALSE);
fprintf (of, "\n{\n");
fprintf (of, "/* %sData* nomThis=%sGetData(nomSelf); */\n",
iface_id, iface_id);
if (has_retval) {
fprintf (of, " ");
orbit_cbe_write_param_typespec (of, tree);
fprintf (of, " " ORBIT_RETVAL_VAR_NAME ";\n\n");
fprintf (of, " return " ORBIT_RETVAL_VAR_NAME ";\n");
}
else
fprintf (of, "\n"); /* Beautyfication... */
fprintf (of, "#if 0\n");
if (has_retval)
fprintf (of, " return ");
VoyagerWriteProtoForParentCall (of, tree, "", FALSE);
fprintf (of, "#endif\n");
#if 0
/* Inherited */
tmptree = IDL_get_parent_node(tree, IDLN_INTERFACE, NULL);;
if(IDL_INTERFACE(tmptree).inheritance_spec) {
char * ptr=opname;
char * str;
printf("!!!! %s\n", opname);
InheritedOutputInfo ioi;
ioi.of = ci->fh;
ioi.realif = tmptree;
// str= IDL_ns_ident_to_qstring( IDL_IDENT_TO_NS (IDL_INTERFACE(tree).ident), "_", 0);
if((ptr=strchr(opname, '_'))!=NULL)
ptr++;
str=g_strdup(ptr);
if((ptr=strchr(str, '_'))!=NULL)
*ptr='\0';
ioi.chrOverridenMethodName=str;
IDL_tree_traverse_parents(IDL_INTERFACE(tmptree).inheritance_spec, (GFunc)VoyagerOutputOverridenMethodTemplate, &ioi);
if(NULL!=ptr)
*ptr='_';
}
#endif
fprintf (of, "}\n\n");
}
#endif
g_free (iface_id);
(*idx)++;
}
