/* * A forward declaration, usually an interface. */ static gboolean forward_dcl(TreeState *state) { IDL_tree iface = state->tree; const char *className = IDL_IDENT(IDL_FORWARD_DCL(iface).ident).str; if (!className) return FALSE; fprintf(state->file, "class %s; /* forward declaration */\n\n", className); return TRUE; }
static gboolean forward_declaration(TreeState *state) { /* * Java doesn't need forward declarations unless the declared * class resides in a different package. */ #if 0 IDL_tree iface = state->tree; const char *className = IDL_IDENT(IDL_FORWARD_DCL(iface).ident).str; const char *pkgName = "org.mozilla.xpcom"; if (!className) return FALSE; /* XXX: Get package name and compare */ fprintf(FILENAME(state), "import %s.%s;\n", pkgName, className); #endif 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; }
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 orte_idl_print_node(IDL_tree node, int indent_level) { IDL_tree curnode; char *s; do_indent(indent_level); if(node == NULL) { g_print("(null)\n"); return; } g_print("[%d] ", IDL_NODE_REFS(node)); switch(IDL_NODE_TYPE(node)) { case IDLN_NONE: g_print("NONE\n"); break; case IDLN_LIST: g_print("LIST:\n"); for(curnode = node; curnode; curnode = IDL_LIST(curnode).next) { orte_idl_print_node(IDL_LIST(curnode).data, indent_level + INDENT_INCREMENT_1); } break; case IDLN_GENTREE: break; case IDLN_INTEGER: g_print("INTEGER: %" IDL_LL "d\n", IDL_INTEGER(node).value); break; case IDLN_STRING: g_print("STRING: %s\n", IDL_STRING(node).value); break; case IDLN_WIDE_STRING: g_print("WIDE STRING: %ls\n", IDL_WIDE_STRING(node).value); break; case IDLN_CHAR: g_print("CHAR: %s\n", IDL_CHAR(node).value); break; case IDLN_WIDE_CHAR: g_print("WIDE CHAR: %ls\n", IDL_WIDE_CHAR(node).value); break; case IDLN_FIXED: g_print("FIXED: %s\n", IDL_FIXED(node).value); break; case IDLN_FLOAT: g_print("FLOAT: %f\n", IDL_FLOAT(node).value); break; case IDLN_BOOLEAN: g_print("BOOLEAN: %s\n", (IDL_BOOLEAN(node).value)?"True":"False"); break; case IDLN_IDENT: s = IDL_ns_ident_to_qstring(IDL_IDENT_TO_NS(node), "_", 0); g_print("IDENT: %s NSQ: %s RID: \"%s\"\n", IDL_IDENT(node).str, s, IDL_IDENT_REPO_ID(node) ? IDL_IDENT_REPO_ID(node) : ""); g_free(s); break; case IDLN_TYPE_DCL: g_print("TYPE DCL:\n"); orte_idl_print_node(IDL_TYPE_DCL(node).type_spec, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("decls:\n"); orte_idl_print_node(IDL_TYPE_DCL(node).dcls, indent_level + INDENT_INCREMENT_2); break; case IDLN_CONST_DCL: g_print("CONST DCL:\n"); orte_idl_print_node(IDL_CONST_DCL(node).const_type, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("ident:\n"); orte_idl_print_node(IDL_CONST_DCL(node).ident, indent_level + INDENT_INCREMENT_2); do_indent(indent_level + INDENT_INCREMENT_1); g_print("const_exp:\n"); orte_idl_print_node(IDL_CONST_DCL(node).const_exp, indent_level + INDENT_INCREMENT_2); break; case IDLN_EXCEPT_DCL: g_print("EXCEPT DCL:\n"); orte_idl_print_node(IDL_EXCEPT_DCL(node).ident, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("members:\n"); orte_idl_print_node(IDL_EXCEPT_DCL(node).members, indent_level + INDENT_INCREMENT_2); break; case IDLN_ATTR_DCL: g_print("ATTR_DCL (%s):\n", (IDL_ATTR_DCL(node).f_readonly)?"readonly":"rw"); orte_idl_print_node(IDL_ATTR_DCL(node).param_type_spec, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("simple_declarations:\n"); orte_idl_print_node(IDL_ATTR_DCL(node).simple_declarations, indent_level + INDENT_INCREMENT_2); break; case IDLN_OP_DCL: g_print("OP DCL (%s):\n", (IDL_OP_DCL(node).f_oneway)?"oneway":"normal"); orte_idl_print_node(IDL_OP_DCL(node).ident, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("op_type_spec:\n"); orte_idl_print_node(IDL_OP_DCL(node).op_type_spec, indent_level + INDENT_INCREMENT_2); do_indent(indent_level + INDENT_INCREMENT_1); g_print("parameter_dcls:\n"); orte_idl_print_node(IDL_OP_DCL(node).parameter_dcls, indent_level + INDENT_INCREMENT_2); do_indent(indent_level + INDENT_INCREMENT_1); g_print("raises_expr:\n"); orte_idl_print_node(IDL_OP_DCL(node).raises_expr, indent_level + INDENT_INCREMENT_2); do_indent(indent_level + INDENT_INCREMENT_1); g_print("context_expr:\n"); orte_idl_print_node(IDL_OP_DCL(node).context_expr, indent_level + INDENT_INCREMENT_2); break; case IDLN_PARAM_DCL: g_print("PARAM DCL: "); switch(IDL_PARAM_DCL(node).attr) { case IDL_PARAM_IN: g_print("(in)\n"); break; case IDL_PARAM_OUT: g_print("(out)\n"); break; case IDL_PARAM_INOUT: g_print("(inout)\n"); break; } orte_idl_print_node(IDL_PARAM_DCL(node).param_type_spec, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("simple_declarator:\n"); orte_idl_print_node(IDL_PARAM_DCL(node).simple_declarator, indent_level + INDENT_INCREMENT_2); break; case IDLN_FORWARD_DCL: g_print("FORWARD DCL:\n"); orte_idl_print_node(IDL_FORWARD_DCL(node).ident, indent_level + INDENT_INCREMENT_1); break; case IDLN_INTERFACE: g_print("INTERFACE:\n"); orte_idl_print_node(IDL_INTERFACE(node).ident, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("inheritance_spec:\n"); orte_idl_print_node(IDL_INTERFACE(node).inheritance_spec, indent_level + INDENT_INCREMENT_2); do_indent(indent_level + INDENT_INCREMENT_1); g_print("body:\n"); orte_idl_print_node(IDL_INTERFACE(node).body, indent_level + INDENT_INCREMENT_2); break; case IDLN_MODULE: g_print("MODULE:\n"); orte_idl_print_node(IDL_MODULE(node).ident, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("definition_list:\n"); orte_idl_print_node(IDL_MODULE(node).definition_list, indent_level + INDENT_INCREMENT_2); break; case IDLN_TYPE_INTEGER: if(!IDL_TYPE_INTEGER(node).f_signed) g_print("TYPE unsigned "); switch(IDL_TYPE_INTEGER(node).f_type) { case IDL_INTEGER_TYPE_SHORT: g_print("short\n"); break; case IDL_INTEGER_TYPE_LONG: g_print("long\n"); break; case IDL_INTEGER_TYPE_LONGLONG: g_print("long long\n"); break; } break; case IDLN_TYPE_FLOAT: switch(IDL_TYPE_FLOAT(node).f_type) { case IDL_FLOAT_TYPE_FLOAT: g_print("TYPE float\n"); break; case IDL_FLOAT_TYPE_DOUBLE: g_print("TYPE double\n"); break; case IDL_FLOAT_TYPE_LONGDOUBLE: g_print("TYPE long double\n"); break; } break; case IDLN_TYPE_FIXED: g_print("TYPE fixed:\n"); orte_idl_print_node(IDL_TYPE_FIXED(node).positive_int_const, indent_level + INDENT_INCREMENT_1); orte_idl_print_node(IDL_TYPE_FIXED(node).integer_lit, indent_level + INDENT_INCREMENT_1); break; case IDLN_TYPE_STRING: g_print("TYPE string:\n"); orte_idl_print_node(IDL_TYPE_STRING(node).positive_int_const, indent_level + INDENT_INCREMENT_1); break; case IDLN_TYPE_WIDE_STRING: g_print("TYPE wide string:\n"); orte_idl_print_node(IDL_TYPE_WIDE_STRING(node).positive_int_const, indent_level + INDENT_INCREMENT_1); break; case IDLN_TYPE_ENUM: g_print("TYPE enum:\n"); orte_idl_print_node(IDL_TYPE_ENUM(node).ident, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("enumerator_list:\n"); orte_idl_print_node(IDL_TYPE_ENUM(node).enumerator_list, indent_level + INDENT_INCREMENT_2); break; case IDLN_TYPE_ARRAY: g_print("TYPE array:\n"); orte_idl_print_node(IDL_TYPE_ARRAY(node).ident, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("size_list:\n"); orte_idl_print_node(IDL_TYPE_ARRAY(node).size_list, indent_level + INDENT_INCREMENT_2); break; case IDLN_TYPE_SEQUENCE: g_print("TYPE sequence:\n"); orte_idl_print_node(IDL_TYPE_SEQUENCE(node).simple_type_spec, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("positive_int_const:\n"); orte_idl_print_node(IDL_TYPE_SEQUENCE(node).positive_int_const, indent_level + INDENT_INCREMENT_2); break; case IDLN_TYPE_STRUCT: g_print("TYPE struct:\n"); orte_idl_print_node(IDL_TYPE_STRUCT(node).ident, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("member_list:\n"); orte_idl_print_node(IDL_TYPE_STRUCT(node).member_list, indent_level + INDENT_INCREMENT_2); break; case IDLN_TYPE_UNION: g_print("TYPE union:\n"); orte_idl_print_node(IDL_TYPE_UNION(node).ident, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("switch_type_spec:\n"); orte_idl_print_node(IDL_TYPE_UNION(node).switch_type_spec, indent_level + INDENT_INCREMENT_2); do_indent(indent_level + INDENT_INCREMENT_1); g_print("switch_body:\n"); orte_idl_print_node(IDL_TYPE_UNION(node).switch_body, indent_level + INDENT_INCREMENT_2); break; case IDLN_MEMBER: g_print("MEMBER:\n"); orte_idl_print_node(IDL_MEMBER(node).type_spec, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("dcls:\n"); orte_idl_print_node(IDL_MEMBER(node).dcls, indent_level + INDENT_INCREMENT_2); break; case IDLN_CASE_STMT: g_print("CASE_STMT:\n"); orte_idl_print_node(IDL_CASE_STMT(node).labels, indent_level + INDENT_INCREMENT_1); do_indent(indent_level + INDENT_INCREMENT_1); g_print("element_spec:\n"); orte_idl_print_node(IDL_CASE_STMT(node).element_spec, indent_level + INDENT_INCREMENT_2); break; case IDLN_BINOP: g_print("BINOP "); switch(IDL_BINOP(node).op) { case IDL_BINOP_OR: g_print("or:\n"); break; case IDL_BINOP_XOR: g_print("xor:\n"); break; case IDL_BINOP_AND: g_print("and:\n"); break; case IDL_BINOP_SHR: g_print("shr:\n"); break; case IDL_BINOP_SHL: g_print("shl:\n"); break; case IDL_BINOP_ADD: g_print("add:\n"); break; case IDL_BINOP_SUB: g_print("sub:\n"); break; case IDL_BINOP_MULT: g_print("mult:\n"); break; case IDL_BINOP_DIV: g_print("div:\n"); break; case IDL_BINOP_MOD: g_print("mod:\n"); break; } do_indent(indent_level + INDENT_INCREMENT_1); g_print("left:\n"); orte_idl_print_node(IDL_BINOP(node).left, indent_level + INDENT_INCREMENT_2); do_indent(indent_level + INDENT_INCREMENT_1); g_print("right:\n"); orte_idl_print_node(IDL_BINOP(node).right, indent_level + INDENT_INCREMENT_2); break; case IDLN_UNARYOP: g_print("UNARYOP "); switch(IDL_UNARYOP(node).op) { case IDL_UNARYOP_PLUS: g_print("plus:\n"); break; case IDL_UNARYOP_MINUS: g_print("minus:\n"); break; case IDL_UNARYOP_COMPLEMENT: g_print("complement:\n"); break; } orte_idl_print_node(IDL_UNARYOP(node).operand, indent_level + INDENT_INCREMENT_1); break; case IDLN_TYPE_CHAR: g_print("TYPE char\n"); break; case IDLN_TYPE_WIDE_CHAR: g_print("TYPE wide char\n"); break; case IDLN_TYPE_BOOLEAN: g_print("TYPE boolean\n"); break; case IDLN_TYPE_OCTET: g_print("TYPE octet\n"); break; case IDLN_TYPE_OBJECT: g_print("TYPE object\n"); break; case IDLN_TYPE_ANY: g_print("TYPE any\n"); break; case IDLN_TYPE_TYPECODE: g_print("TYPE TypeCode\n"); break; case IDLN_CODEFRAG: g_print("CODEFRAG\n"); break; default: g_print("unhandled %d\n", IDL_NODE_TYPE(node)); } }
static 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; }