static gboolean do_typedef(TreeState *state) { IDL_tree type = IDL_TYPE_DCL(state->tree).type_spec; IDL_tree dcls = IDL_TYPE_DCL(state->tree).dcls; IDL_tree complex; GSList *doc_comments; if (IDL_NODE_TYPE(type) == IDLN_TYPE_SEQUENCE) { XPIDL_WARNING((state->tree, IDL_WARNING1, "sequences not supported, ignored")); } else { if (IDL_NODE_TYPE(complex = IDL_LIST(dcls).data) == IDLN_TYPE_ARRAY) { IDL_tree dim = IDL_TYPE_ARRAY(complex).size_list; doc_comments = IDL_IDENT(IDL_TYPE_ARRAY(complex).ident).comments; if (doc_comments != NULL) printlist(state->file, doc_comments); fputs("typedef ", state->file); if (!write_type(type, FALSE, state->file)) return FALSE; fputs(" ", state->file); fprintf(state->file, "%s", IDL_IDENT(IDL_TYPE_ARRAY(complex).ident).str); do { fputc('[', state->file); if (IDL_LIST(dim).data) { fprintf(state->file, "%ld", (long)IDL_INTEGER(IDL_LIST(dim).data).value); } fputc(']', state->file); } while ((dim = IDL_LIST(dim).next) != NULL); } else { doc_comments = IDL_IDENT(IDL_LIST(dcls).data).comments; if (doc_comments != NULL) printlist(state->file, doc_comments); fputs("typedef ", state->file); if (!write_type(type, FALSE, state->file)) return FALSE; fputs(" ", state->file); fputs(IDL_IDENT(IDL_LIST(dcls).data).str, state->file); } fputs(";\n\n", state->file); } return TRUE; }
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; }
static gboolean type_declaration(TreeState *state) { /* * Unlike C, Java has no type declaration directive. * Instead, we record the mapping, and look up the actual type * when needed. */ IDL_tree type = IDL_TYPE_DCL(state->tree).type_spec; IDL_tree dcls = IDL_TYPE_DCL(state->tree).dcls; /* XXX: check for illegal types */ g_hash_table_insert(TYPEDEFS(state), IDL_IDENT(IDL_LIST(dcls).data).str, type); return TRUE; }
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; } }
/* * Find the underlying type of an identifier typedef. * * All the needed tree-walking seems pretty shaky; isn't there something in * libIDL to automate this? */ IDL_tree /* IDL_TYPE_DCL */ find_underlying_type(IDL_tree typedef_ident) { IDL_tree up; if (typedef_ident == NULL || IDL_NODE_TYPE(typedef_ident) != IDLN_IDENT) return NULL; up = IDL_NODE_UP(typedef_ident); if (up == NULL || IDL_NODE_TYPE(up) != IDLN_LIST) return NULL; up = IDL_NODE_UP(up); if (up == NULL || IDL_NODE_TYPE(up) != IDLN_TYPE_DCL) return NULL; return IDL_TYPE_DCL(up).type_spec; }
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)); } }
gboolean orte_cbe_type_is_fixed_length(IDL_tree ts) { gboolean is_fixed = TRUE; IDL_tree curitem; ts = orte_cbe_get_typespec(ts); switch(IDL_NODE_TYPE(ts)) { case IDLN_TYPE_FLOAT: case IDLN_TYPE_INTEGER: case IDLN_TYPE_ENUM: case IDLN_TYPE_CHAR: case IDLN_TYPE_WIDE_CHAR: case IDLN_TYPE_OCTET: case IDLN_TYPE_BOOLEAN: return TRUE; break; case IDLN_TYPE_SEQUENCE: case IDLN_TYPE_STRING: case IDLN_TYPE_WIDE_STRING: case IDLN_TYPE_OBJECT: case IDLN_FORWARD_DCL: case IDLN_INTERFACE: case IDLN_TYPE_ANY: case IDLN_NATIVE: case IDLN_TYPE_TYPECODE: return FALSE; break; case IDLN_TYPE_UNION: for(curitem = IDL_TYPE_UNION(ts).switch_body; curitem; curitem = IDL_LIST(curitem).next) { is_fixed &= orte_cbe_type_is_fixed_length(IDL_LIST(IDL_CASE_STMT(IDL_LIST(curitem).data).element_spec).data); } return is_fixed; break; case IDLN_EXCEPT_DCL: case IDLN_TYPE_STRUCT: for(curitem = IDL_TYPE_STRUCT(ts).member_list; curitem; curitem = IDL_LIST(curitem).next) { is_fixed &= orte_cbe_type_is_fixed_length(IDL_LIST(curitem).data); } return is_fixed; break; case IDLN_TYPE_ARRAY: return orte_cbe_type_is_fixed_length(IDL_TYPE_DCL(IDL_get_parent_node(ts, IDLN_TYPE_DCL, NULL)).type_spec); break; case IDLN_TYPE_DCL: return orte_cbe_type_is_fixed_length(IDL_TYPE_DCL(ts).type_spec); break; case IDLN_IDENT: case IDLN_LIST: return orte_cbe_type_is_fixed_length(IDL_NODE_UP(ts)); break; case IDLN_MEMBER: return orte_cbe_type_is_fixed_length(IDL_MEMBER(ts).type_spec); break; default: g_warning("I'm not sure if type %s is fixed-length", IDL_tree_type_names[IDL_NODE_TYPE(ts)]); return FALSE; } }
gboolean MateCORBA_imodule_type_is_fixed_length (IDL_tree tree) { gboolean is_fixed = TRUE; IDL_tree iter; IDL_tree typespec; typespec = MateCORBA_imodule_get_typespec (tree); switch (IDL_NODE_TYPE (typespec)) { case IDLN_TYPE_FLOAT: case IDLN_TYPE_INTEGER: case IDLN_TYPE_ENUM: case IDLN_TYPE_CHAR: case IDLN_TYPE_WIDE_CHAR: case IDLN_TYPE_OCTET: case IDLN_TYPE_BOOLEAN: is_fixed = TRUE; break; case IDLN_TYPE_SEQUENCE: case IDLN_TYPE_STRING: case IDLN_TYPE_WIDE_STRING: case IDLN_TYPE_OBJECT: case IDLN_FORWARD_DCL: case IDLN_INTERFACE: case IDLN_TYPE_ANY: case IDLN_NATIVE: case IDLN_TYPE_TYPECODE: is_fixed = FALSE; break; case IDLN_TYPE_UNION: for (iter = IDL_TYPE_UNION (typespec).switch_body; iter; iter = IDL_LIST (iter).next) is_fixed &= MateCORBA_imodule_type_is_fixed_length ( IDL_LIST (IDL_CASE_STMT ( IDL_LIST (iter).data).element_spec).data); break; case IDLN_EXCEPT_DCL: case IDLN_TYPE_STRUCT: for (iter = IDL_TYPE_STRUCT (typespec).member_list; iter; iter = IDL_LIST (iter).next) is_fixed &= MateCORBA_imodule_type_is_fixed_length (IDL_LIST (iter).data); break; case IDLN_TYPE_ARRAY: is_fixed = MateCORBA_imodule_type_is_fixed_length ( IDL_TYPE_DCL (IDL_get_parent_node ( typespec, IDLN_TYPE_DCL, NULL)).type_spec); break; case IDLN_TYPE_DCL: is_fixed = MateCORBA_imodule_type_is_fixed_length ( IDL_TYPE_DCL (typespec).type_spec); break; case IDLN_IDENT: case IDLN_LIST: is_fixed = MateCORBA_imodule_type_is_fixed_length (IDL_NODE_UP (typespec)); break; case IDLN_MEMBER: is_fixed = MateCORBA_imodule_type_is_fixed_length (IDL_MEMBER (typespec).type_spec); break; default: g_error ("Cannot determine if type %s is fixed-length", IDL_tree_type_names [IDL_NODE_TYPE (typespec)]); break; } return is_fixed; }
CORBA_TypeCode MateCORBA_imodule_get_typecode (GHashTable *typecodes, IDL_tree tree) { CORBA_Environment env; CORBA_TypeCode retval = CORBA_OBJECT_NIL; if (!tree) return CORBA_OBJECT_NIL; CORBA_exception_init (&env); switch (IDL_NODE_TYPE (tree)) { case IDLN_MEMBER: retval = MateCORBA_imodule_get_typecode ( typecodes, IDL_MEMBER (tree).type_spec); break; case IDLN_TYPE_ANY: retval = (CORBA_TypeCode) CORBA_Object_duplicate ( (CORBA_Object) TC_CORBA_any, NULL); break; case IDLN_TYPE_FLOAT: switch (IDL_TYPE_FLOAT (tree).f_type) { case IDL_FLOAT_TYPE_FLOAT: retval = TC_CORBA_float; break; case IDL_FLOAT_TYPE_DOUBLE: retval = TC_CORBA_double; break; case IDL_FLOAT_TYPE_LONGDOUBLE: retval = TC_CORBA_long_double; break; } break; case IDLN_TYPE_FIXED: retval = CORBA_ORB_create_fixed_tc (NULL, IDL_INTEGER (IDL_TYPE_FIXED (tree).positive_int_const).value, IDL_INTEGER (IDL_TYPE_FIXED (tree).integer_lit).value, &env); break; case IDLN_TYPE_INTEGER: if (!IDL_TYPE_INTEGER (tree).f_signed) switch (IDL_TYPE_INTEGER (tree).f_type) { case IDL_INTEGER_TYPE_SHORT: retval = TC_CORBA_unsigned_short; break; case IDL_INTEGER_TYPE_LONGLONG: retval = TC_CORBA_unsigned_long_long; break; case IDL_INTEGER_TYPE_LONG: retval = TC_CORBA_unsigned_long; break; default: g_assert_not_reached (); } else switch (IDL_TYPE_INTEGER (tree).f_type) { case IDL_INTEGER_TYPE_SHORT: retval = TC_CORBA_short; break; case IDL_INTEGER_TYPE_LONGLONG: retval = TC_CORBA_long_long; break; case IDL_INTEGER_TYPE_LONG: retval = TC_CORBA_long; break; default: g_assert_not_reached (); } break; case IDLN_TYPE_STRING: retval = (CORBA_TypeCode) CORBA_Object_duplicate ( (CORBA_Object) TC_CORBA_string, NULL); break; case IDLN_TYPE_WIDE_STRING: retval = (CORBA_TypeCode) CORBA_Object_duplicate ( (CORBA_Object) TC_CORBA_wstring, NULL); break; case IDLN_TYPE_OCTET: retval = (CORBA_TypeCode) CORBA_Object_duplicate ( (CORBA_Object) TC_CORBA_octet, NULL); break; case IDLN_TYPE_CHAR: retval = (CORBA_TypeCode) CORBA_Object_duplicate ( (CORBA_Object) TC_CORBA_char, NULL); break; case IDLN_TYPE_WIDE_CHAR: retval = (CORBA_TypeCode) CORBA_Object_duplicate ( (CORBA_Object) TC_CORBA_wchar, NULL); break; case IDLN_TYPE_BOOLEAN: retval = (CORBA_TypeCode) CORBA_Object_duplicate ( (CORBA_Object) TC_CORBA_boolean, NULL); break; case IDLN_TYPE_STRUCT: retval = MateCORBA_imodule_lookup_typecode ( typecodes, IDL_IDENT (IDL_TYPE_STRUCT (tree).ident).repo_id); if (!retval) { CORBA_StructMemberSeq *members; members = MateCORBA_imodule_get_struct_members ( typecodes, tree, &env); retval = CORBA_ORB_create_struct_tc (NULL, IDL_IDENT (IDL_TYPE_STRUCT (tree).ident).repo_id, IDL_IDENT (IDL_TYPE_STRUCT (tree).ident).str, members, &env); MateCORBA_imodule_register_typecode ( typecodes, IDL_IDENT (IDL_TYPE_STRUCT (tree).ident).repo_id, retval); CORBA_free (members); } break; case IDLN_EXCEPT_DCL: retval = MateCORBA_imodule_lookup_typecode ( typecodes, IDL_IDENT (IDL_EXCEPT_DCL (tree).ident).repo_id); if (!retval) { CORBA_StructMemberSeq *members; members = MateCORBA_imodule_get_struct_members ( typecodes, tree, &env); retval = CORBA_ORB_create_exception_tc (NULL, IDL_IDENT (IDL_EXCEPT_DCL (tree).ident).repo_id, IDL_IDENT (IDL_EXCEPT_DCL (tree).ident).str, members, &env); MateCORBA_imodule_register_typecode ( typecodes, IDL_IDENT (IDL_EXCEPT_DCL (tree).ident).repo_id, retval); CORBA_free (members); } break; case IDLN_TYPE_ARRAY: { CORBA_TypeCode subtc; IDL_tree sizer; IDL_tree type_dcl; sizer = IDL_list_nth (IDL_TYPE_ARRAY (tree).size_list, IDL_list_length (IDL_TYPE_ARRAY (tree).size_list) - 1); g_assert (IDL_NODE_TYPE (IDL_LIST (sizer).data) == IDLN_INTEGER); type_dcl = IDL_NODE_UP (IDL_NODE_UP (tree)); g_assert (IDL_NODE_TYPE (type_dcl) == IDLN_TYPE_DCL); subtc = MateCORBA_imodule_get_typecode ( typecodes, IDL_TYPE_DCL (type_dcl).type_spec), retval = CORBA_ORB_create_array_tc (NULL, IDL_INTEGER (IDL_LIST (sizer).data).value, subtc, &env); retval->c_align = subtc->c_align; CORBA_Object_release ((CORBA_Object) subtc, NULL); for (sizer = IDL_LIST (sizer).prev; sizer; sizer = IDL_LIST (sizer).prev) { subtc = retval; retval = CORBA_ORB_create_array_tc (NULL, IDL_INTEGER (IDL_LIST (sizer).data).value, subtc, &env); retval->c_align = subtc->c_align; CORBA_Object_release ((CORBA_Object) subtc, NULL); } subtc = retval; retval = MateCORBA_imodule_create_alias_typecode ( typecodes, IDL_TYPE_ARRAY (tree).ident, subtc); CORBA_Object_release ((CORBA_Object) subtc, NULL); } break; case IDLN_TYPE_UNION: retval = MateCORBA_imodule_lookup_typecode ( typecodes, IDL_IDENT (IDL_TYPE_UNION (tree).ident).repo_id); if (!retval) { CORBA_UnionMemberSeq *members; CORBA_TypeCode switchtc; switchtc = MateCORBA_imodule_get_typecode ( typecodes, IDL_TYPE_UNION (tree).switch_type_spec); members = MateCORBA_imodule_get_union_members ( typecodes, tree, switchtc, &env); retval = CORBA_ORB_create_union_tc (NULL, IDL_IDENT (IDL_TYPE_UNION (tree).ident).repo_id, IDL_IDENT (IDL_TYPE_UNION (tree).ident).str, switchtc, members, &env); CORBA_Object_release ((CORBA_Object) switchtc, NULL); MateCORBA_imodule_register_typecode ( typecodes, IDL_IDENT (IDL_TYPE_UNION (tree).ident).repo_id, retval); CORBA_free (members); } break; case IDLN_TYPE_ENUM: retval = MateCORBA_imodule_lookup_typecode ( typecodes, IDL_IDENT (IDL_TYPE_ENUM (tree).ident).repo_id); if (!retval) { CORBA_EnumMemberSeq *members; members = MateCORBA_imodule_get_enum_members (tree, &env); retval = CORBA_ORB_create_enum_tc (NULL, IDL_IDENT (IDL_TYPE_ENUM (tree).ident).repo_id, IDL_IDENT (IDL_TYPE_ENUM (tree).ident).str, members, &env); MateCORBA_imodule_register_typecode ( typecodes, IDL_IDENT (IDL_TYPE_ENUM (tree).ident).repo_id, retval); CORBA_free (members); } break; case IDLN_IDENT: retval = MateCORBA_imodule_lookup_typecode ( typecodes, IDL_IDENT (tree).repo_id); g_assert (retval != NULL); break; case IDLN_TYPE_SEQUENCE: { CORBA_TypeCode subtc; int bound = 0; if (IDL_TYPE_SEQUENCE (tree).positive_int_const) bound = IDL_INTEGER (IDL_TYPE_SEQUENCE (tree).positive_int_const).value; subtc = MateCORBA_imodule_get_typecode ( typecodes, IDL_TYPE_SEQUENCE (tree).simple_type_spec), retval = CORBA_ORB_create_sequence_tc (NULL, bound, subtc, &env); CORBA_Object_release ((CORBA_Object) subtc, NULL); /* * FIXME: and what about recursive sequences? */ } break; case IDLN_FORWARD_DCL: case IDLN_INTERFACE: retval = MateCORBA_imodule_lookup_typecode ( typecodes, IDL_IDENT (IDL_TYPE_ENUM (tree).ident).repo_id); if (!retval) { retval = CORBA_ORB_create_interface_tc (NULL, IDL_IDENT (IDL_TYPE_ENUM (tree).ident).repo_id, IDL_IDENT (IDL_TYPE_ENUM (tree).ident).str, &env); MateCORBA_imodule_register_typecode ( typecodes, IDL_IDENT (IDL_TYPE_ENUM (tree).ident).repo_id, retval); } break; case IDLN_TYPE_OBJECT: retval = (CORBA_TypeCode) CORBA_Object_duplicate ( (CORBA_Object) TC_CORBA_Object, NULL); break; case IDLN_TYPE_TYPECODE: retval = (CORBA_TypeCode) CORBA_Object_duplicate ( (CORBA_Object) TC_CORBA_TypeCode, NULL); break; default: g_error ("We were asked to get a typecode for a %s", IDL_tree_type_names [IDL_NODE_TYPE (tree)]); break; } if (retval && retval->c_align == 0) retval->c_align = MateCORBA_imodule_find_c_align (tree); if (env._major != CORBA_NO_EXCEPTION) g_warning ("MateCORBA_imodule_get_typecode: exception %s", env._id); CORBA_exception_free (&env); return retval; }
static int MateCORBA_imodule_find_c_align (IDL_tree node) { int c_align = 1; node = MateCORBA_imodule_get_typespec (node); switch (IDL_NODE_TYPE (node)) { case IDLN_TYPE_INTEGER: switch (IDL_TYPE_INTEGER (node).f_type) { case IDL_INTEGER_TYPE_SHORT: c_align = MATECORBA_ALIGNOF_CORBA_SHORT; break; case IDL_INTEGER_TYPE_LONG: c_align = MATECORBA_ALIGNOF_CORBA_LONG; break; case IDL_INTEGER_TYPE_LONGLONG: c_align = MATECORBA_ALIGNOF_CORBA_LONG_LONG; break; } break; case IDLN_TYPE_FLOAT: switch (IDL_TYPE_FLOAT (node).f_type) { case IDL_FLOAT_TYPE_FLOAT: c_align = MATECORBA_ALIGNOF_CORBA_FLOAT; break; case IDL_FLOAT_TYPE_DOUBLE: c_align = MATECORBA_ALIGNOF_CORBA_DOUBLE; break; case IDL_FLOAT_TYPE_LONGDOUBLE: c_align = MATECORBA_ALIGNOF_CORBA_LONG_DOUBLE; break; } break; case IDLN_TYPE_ENUM: c_align = MATECORBA_ALIGNOF_CORBA_LONG; break; case IDLN_TYPE_CHAR: /* drop through */ case IDLN_TYPE_BOOLEAN: case IDLN_TYPE_OCTET: c_align = MATECORBA_ALIGNOF_CORBA_CHAR; break; case IDLN_TYPE_WIDE_CHAR: c_align = MATECORBA_ALIGNOF_CORBA_SHORT; break; case IDLN_TYPE_UNION: { IDL_tree l = IDL_TYPE_UNION (node).switch_body; c_align = MATECORBA_ALIGNOF_CORBA_STRUCT; for (; l; l = IDL_LIST (l).next) { IDL_tree subtype = IDL_MEMBER (IDL_CASE_STMT ( IDL_LIST (l).data).element_spec).type_spec; c_align = MAX (c_align, MateCORBA_imodule_find_c_align (subtype)); } } break; case IDLN_EXCEPT_DCL: /* drop through */ case IDLN_TYPE_STRUCT: { IDL_tree l = IDL_TYPE_STRUCT (node).member_list; for (; l; l = IDL_LIST (l).next) { IDL_tree member = IDL_MEMBER (IDL_LIST (l).data).type_spec; c_align = MAX (c_align, MateCORBA_imodule_find_c_align (member)); } } break; case IDLN_TYPE_STRING: /* drop through */ case IDLN_TYPE_WIDE_STRING: case IDLN_TYPE_OBJECT: case IDLN_TYPE_TYPECODE: case IDLN_FORWARD_DCL: case IDLN_INTERFACE: c_align = MATECORBA_ALIGNOF_CORBA_POINTER; break; case IDLN_TYPE_ARRAY: { IDL_tree subtype; subtype = IDL_TYPE_DCL ( IDL_get_parent_node ( node, IDLN_TYPE_DCL, NULL)).type_spec; c_align = MateCORBA_imodule_find_c_align (subtype); } break; case IDLN_TYPE_SEQUENCE: c_align = MAX (MAX (MATECORBA_ALIGNOF_CORBA_STRUCT, MATECORBA_ALIGNOF_CORBA_LONG), MATECORBA_ALIGNOF_CORBA_POINTER); break; case IDLN_TYPE_ANY: c_align = MAX (MATECORBA_ALIGNOF_CORBA_STRUCT, MATECORBA_ALIGNOF_CORBA_POINTER); break; default: g_error ("Can't find alignment %s\n", IDL_tree_type_names [IDL_NODE_TYPE (node)]); break; } return c_align; }
/* * get a CORBA_TypeCode from a IDL_tree node type */ CORBA_TypeCode orbit_idl_tree_type_to_typecode(IDL_tree type) { CORBA_TypeCode type_code = NULL; if (type == NULL) { /* not good! */ return FALSE; } switch (IDL_NODE_TYPE(type)) { case IDLN_EXCEPT_DCL: type_code = orbit_idl_tree_type_to_typecode_exception(type); break; case IDLN_IDENT: type_code = orbit_idl_tree_type_to_typecode_ident(type); break; case IDLN_INTERFACE: /*type_code = TC_CORBA_Object; */ type_code = orbit_idl_tree_type_to_typecode_interface(type); break; case IDLN_TYPE_BOOLEAN: type_code = TC_CORBA_boolean; break; case IDLN_TYPE_DCL: type_code = orbit_idl_tree_type_to_typecode(IDL_TYPE_DCL(type).type_spec); break; case IDLN_TYPE_ENUM: type_code = orbit_idl_tree_type_to_typecode_enum(type); break; case IDLN_TYPE_FLOAT: type_code = orbit_idl_tree_type_to_typecode_float(type); break; case IDLN_TYPE_INTEGER: type_code = orbit_idl_tree_type_to_typecode_integer(type); break; case IDLN_TYPE_SEQUENCE: type_code = orbit_idl_tree_type_to_typecode_sequence(type); break; case IDLN_TYPE_STRING: /*type_code = TC_CORBA_string; */ type_code = orbit_idl_tree_type_to_typecode_string(type); break; case IDLN_TYPE_STRUCT: type_code = orbit_idl_tree_type_to_typecode_struct(type); break; /* TODO: handle more types */ default: /* printf("orbit_idl_tree_type_to_typecode can't handle type %s\n", IDL_NODE_TYPE_NAME(type));*/ } return type_code; }
static void cbe_tc_generate (OIDL_C_Info *ci, CBETCGenInfo *tci) { CBETCGenInfo subtci; IDL_tree curitem; char *ctmp; int union_default_index = -1, subnames_id = random_id++, subtypes_id = random_id++, sublabels_id = random_id++; if (strncmp (tci->structname, "anon", 4)) { fprintf (ci->fh, "#if "); orbit_cbe_id_cond_hack (ci->fh, "TC_IMPL", tci->structname, ci->c_base_name); fprintf (ci->fh, " && !defined(TC_DEF_%s)\n", tci->structname); fprintf (ci->fh, "#define TC_DEF_%s 1\n", tci->structname); } if (IDL_NODE_TYPE (tci->ts) == IDLN_TYPE_DCL) { subtci = *tci; curitem = IDL_TYPE_DCL (tci->ts).type_spec; subtci.substructname = ctmp = orbit_generate_tcstruct_name (curitem); /* * The only type not already defined elsewhere * that can be in the left half of a TypeCode. */ if (IDL_NODE_TYPE (curitem) == IDLN_TYPE_SEQUENCE) { subtci.structname = ctmp; subtci.ts = curitem; cbe_tc_generate (ci, &subtci); } for (curitem = IDL_TYPE_DCL (tci->ts).dcls; curitem; curitem = IDL_LIST (curitem).next) { subtci.ts = IDL_LIST (curitem).data; if (IDL_NODE_TYPE (subtci.ts) == IDLN_TYPE_ARRAY) subtci.structname = orbit_generate_tcstruct_name ( IDL_TYPE_ARRAY (subtci.ts).ident); else subtci.structname = orbit_generate_tcstruct_name (subtci.ts); cbe_tc_generate (ci, &subtci); g_free (subtci.structname); } g_free (ctmp); return; } /* Do magic here - nesting of typecodes for arrays */ if (IDL_NODE_TYPE (tci->ts) == IDLN_TYPE_ARRAY && (IDL_list_length (IDL_TYPE_ARRAY (tci->ts).size_list) > tci->array_gen_ctr)) { curitem = IDL_list_nth (IDL_TYPE_ARRAY (tci->ts).size_list, tci->array_gen_ctr - 1); subtci = *tci; subtci.structname = ctmp = orbit_generate_tcstruct_name (curitem); subtci.array_gen_ctr++; cbe_tc_generate (ci, &subtci); tci->substructname = ctmp; /* FIXME: memory leak */ } orbit_output_tcstruct_anon_subnames_array (ci->fh, tci->ts, subnames_id); orbit_output_tcstruct_anon_subtypes_array (ci->fh, tci->ts, subtypes_id, tci->substructname); union_default_index = orbit_output_tcstruct_anon_sublabels_array ( ci->fh, tci->ts, sublabels_id); if (!strncmp (tci->structname, "anon", 4)) fprintf (ci->fh, "static "); else { fprintf (ci->fh, "#ifdef ORBIT_IDL_C_IMODULE_%s\n", ci->c_base_name); fprintf (ci->fh, "static\n"); fprintf (ci->fh, "#endif\n"); } fprintf (ci->fh, "ORBIT2_MAYBE_CONST struct CORBA_TypeCode_struct %s_struct = {\n", tci->structname); orbit_output_tcstruct_parent (ci->fh); fprintf (ci->fh, ",\n"); orbit_output_tcstruct_kind (ci->fh, tci->ts, tci->array_gen_ctr); fprintf (ci->fh, ",\n"); /* flags */ fprintf (ci->fh, "0,\n"); /* c_length */ fprintf (ci->fh, "0,\n"); orbit_output_tcstruct_c_align (ci->fh, tci->ts); fprintf (ci->fh, ",\n"); orbit_output_tcstruct_length (ci->fh, tci->ts, tci->array_gen_ctr); fprintf (ci->fh, ",\n"); orbit_output_tcstruct_sub_parts (ci->fh, tci->ts); fprintf (ci->fh, ",\n"); orbit_output_tcstruct_subtypes (ci->fh, tci->ts, subtypes_id); fprintf (ci->fh, ",\n"); orbit_output_tcstruct_discriminator (ci->fh, tci->ts); fprintf (ci->fh, ",\n"); orbit_output_tcstruct_name (ci->fh, tci->ts, tci->array_gen_ctr); fprintf (ci->fh, ",\n"); orbit_output_tcstruct_repo_id (ci->fh, tci->ts, tci->array_gen_ctr); fprintf (ci->fh, ",\n"); orbit_output_tcstruct_subnames (ci->fh, tci->ts, subnames_id); fprintf (ci->fh, ",\n"); orbit_output_tcstruct_sublabels (ci->fh, tci->ts, sublabels_id); fprintf (ci->fh, ",\n"); orbit_output_tcstruct_default_index (ci->fh, union_default_index); fprintf (ci->fh, ",\n"); orbit_output_tcstruct_recurse_depth (ci->fh); fprintf (ci->fh, ",\n"); orbit_output_tcstruct_digits_scale (ci->fh, tci->ts); fprintf (ci->fh, "\n};\n"); if (strncmp (tci->structname, "anon", 4)) fprintf (ci->fh, "#endif\n"); }
static GSList * orbit_find_c_align (GSList *max, IDL_tree node) { node = orbit_cbe_get_typespec (node); switch (IDL_NODE_TYPE (node)) { case IDLN_TYPE_INTEGER: switch (IDL_TYPE_INTEGER (node).f_type) { case IDL_INTEGER_TYPE_SHORT: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_SHORT"); break; case IDL_INTEGER_TYPE_LONG: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_LONG"); break; case IDL_INTEGER_TYPE_LONGLONG: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_LONG_LONG"); break; } break; case IDLN_TYPE_FLOAT: switch (IDL_TYPE_FLOAT (node).f_type) { case IDL_FLOAT_TYPE_FLOAT: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_FLOAT"); break; case IDL_FLOAT_TYPE_DOUBLE: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_DOUBLE"); break; case IDL_FLOAT_TYPE_LONGDOUBLE: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_LONG_DOUBLE"); break; } break; case IDLN_TYPE_ENUM: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_LONG"); break; case IDLN_TYPE_CHAR: /* drop through */ case IDLN_TYPE_BOOLEAN: case IDLN_TYPE_OCTET: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_CHAR"); break; case IDLN_TYPE_WIDE_CHAR: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_SHORT"); break; case IDLN_TYPE_UNION: { IDL_tree l = IDL_TYPE_UNION (node).switch_body; orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_STRUCT"); for (; l; l = IDL_LIST (l).next) { IDL_tree subtype = IDL_MEMBER (IDL_CASE_STMT ( IDL_LIST (l).data).element_spec).type_spec; max = orbit_find_c_align (max, subtype); } break; } case IDLN_EXCEPT_DCL: /* drop through */ case IDLN_TYPE_STRUCT: { IDL_tree l = IDL_TYPE_STRUCT (node).member_list; for (; l; l = IDL_LIST (l).next) { IDL_tree member = IDL_MEMBER (IDL_LIST (l).data).type_spec; max = orbit_find_c_align (max, member); } break; } case IDLN_TYPE_STRING: /* drop through */ case IDLN_TYPE_WIDE_STRING: case IDLN_TYPE_OBJECT: case IDLN_TYPE_TYPECODE: case IDLN_FORWARD_DCL: case IDLN_INTERFACE: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_POINTER"); break; case IDLN_TYPE_ARRAY: { IDL_tree subtype = IDL_TYPE_DCL ( IDL_get_parent_node (node, IDLN_TYPE_DCL, NULL)).type_spec; max = orbit_find_c_align (max, subtype); break; } case IDLN_TYPE_SEQUENCE: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_STRUCT"); orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_LONG"); orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_POINTER"); break; case IDLN_TYPE_ANY: orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_STRUCT"); orbit_add_align (&max, "ORBIT_ALIGNOF_CORBA_POINTER"); break; default: g_error ("Can't find alignment %s\n", IDL_tree_type_names[IDL_NODE_TYPE (node)]); break; } return max; }
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; }