+const struct type_print_options type_print_raw_options =
+{
+ 1, /* raw */
+ 1, /* print_methods */
+ 1, /* print_typedefs */
+ NULL, /* local_typedefs */
+ NULL, /* global_table */
+ NULL /* global_printers */
+};
+
+/* The default flags for 'ptype' and 'whatis'. */
+
+static struct type_print_options default_ptype_flags =
+{
+ 0, /* raw */
+ 1, /* print_methods */
+ 1, /* print_typedefs */
+ NULL, /* local_typedefs */
+ NULL, /* global_table */
+ NULL /* global_printers */
+};
+
+\f
+
+/* A hash table holding typedef_field objects. This is more
+ complicated than an ordinary hash because it must also track the
+ lifetime of some -- but not all -- of the contained objects. */
+
+struct typedef_hash_table
+{
+ /* The actual hash table. */
+ htab_t table;
+
+ /* Storage for typedef_field objects that must be synthesized. */
+ struct obstack storage;
+};
+
+/* A hash function for a typedef_field. */
+
+static hashval_t
+hash_typedef_field (const void *p)
+{
+ const struct typedef_field *tf = p;
+ struct type *t = check_typedef (tf->type);
+
+ return htab_hash_string (TYPE_SAFE_NAME (t));
+}
+
+/* An equality function for a typedef field. */
+
+static int
+eq_typedef_field (const void *a, const void *b)
+{
+ const struct typedef_field *tfa = a;
+ const struct typedef_field *tfb = b;
+
+ return types_equal (tfa->type, tfb->type);
+}
+
+/* Add typedefs from T to the hash table TABLE. */
+
+void
+recursively_update_typedef_hash (struct typedef_hash_table *table,
+ struct type *t)
+{
+ int i;
+
+ if (table == NULL)
+ return;
+
+ for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (t); ++i)
+ {
+ struct typedef_field *tdef = &TYPE_TYPEDEF_FIELD (t, i);
+ void **slot;
+
+ slot = htab_find_slot (table->table, tdef, INSERT);
+ /* Only add a given typedef name once. Really this shouldn't
+ happen; but it is safe enough to do the updates breadth-first
+ and thus use the most specific typedef. */
+ if (*slot == NULL)
+ *slot = tdef;
+ }
+
+ /* Recurse into superclasses. */
+ for (i = 0; i < TYPE_N_BASECLASSES (t); ++i)
+ recursively_update_typedef_hash (table, TYPE_BASECLASS (t, i));
+}
+
+/* Add template parameters from T to the typedef hash TABLE. */
+
+void
+add_template_parameters (struct typedef_hash_table *table, struct type *t)
+{
+ int i;
+
+ if (table == NULL)
+ return;
+
+ for (i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (t); ++i)
+ {
+ struct typedef_field *tf;
+ void **slot;
+
+ /* We only want type-valued template parameters in the hash. */
+ if (SYMBOL_CLASS (TYPE_TEMPLATE_ARGUMENT (t, i)) != LOC_TYPEDEF)
+ continue;
+
+ tf = XOBNEW (&table->storage, struct typedef_field);
+ tf->name = SYMBOL_LINKAGE_NAME (TYPE_TEMPLATE_ARGUMENT (t, i));
+ tf->type = SYMBOL_TYPE (TYPE_TEMPLATE_ARGUMENT (t, i));
+
+ slot = htab_find_slot (table->table, tf, INSERT);
+ if (*slot == NULL)
+ *slot = tf;
+ }
+}
+
+/* Create a new typedef-lookup hash table. */
+
+struct typedef_hash_table *
+create_typedef_hash (void)
+{
+ struct typedef_hash_table *result;
+
+ result = XNEW (struct typedef_hash_table);
+ result->table = htab_create_alloc (10, hash_typedef_field, eq_typedef_field,
+ NULL, xcalloc, xfree);
+ obstack_init (&result->storage);
+
+ return result;
+}
+
+/* Free a typedef field table. */
+
+void
+free_typedef_hash (struct typedef_hash_table *table)
+{
+ if (table != NULL)
+ {
+ htab_delete (table->table);
+ obstack_free (&table->storage, NULL);
+ xfree (table);
+ }
+}
+
+/* A cleanup for freeing a typedef_hash_table. */
+
+static void
+do_free_typedef_hash (void *arg)
+{
+ free_typedef_hash (arg);
+}
+
+/* Return a new cleanup that frees TABLE. */
+
+struct cleanup *
+make_cleanup_free_typedef_hash (struct typedef_hash_table *table)
+{
+ return make_cleanup (do_free_typedef_hash, table);
+}
+
+/* Helper function for copy_typedef_hash. */
+
+static int
+copy_typedef_hash_element (void **slot, void *nt)
+{
+ htab_t new_table = nt;
+ void **new_slot;
+
+ new_slot = htab_find_slot (new_table, *slot, INSERT);
+ if (*new_slot == NULL)
+ *new_slot = *slot;
+
+ return 1;
+}
+
+/* Copy a typedef hash. */
+
+struct typedef_hash_table *
+copy_typedef_hash (struct typedef_hash_table *table)
+{
+ struct typedef_hash_table *result;
+
+ if (table == NULL)
+ return NULL;
+
+ result = create_typedef_hash ();
+ htab_traverse_noresize (table->table, copy_typedef_hash_element,
+ result->table);
+ return result;
+}
+
+/* A cleanup to free the global typedef hash. */
+
+static void
+do_free_global_table (void *arg)
+{
+ struct type_print_options *flags = arg;
+
+ free_typedef_hash (flags->global_typedefs);
+ free_ext_lang_type_printers (flags->global_printers);
+}
+
+/* Create the global typedef hash. */
+
+static struct cleanup *
+create_global_typedef_table (struct type_print_options *flags)
+{
+ gdb_assert (flags->global_typedefs == NULL && flags->global_printers == NULL);
+ flags->global_typedefs = create_typedef_hash ();
+ flags->global_printers = start_ext_lang_type_printers ();
+ return make_cleanup (do_free_global_table, flags);
+}
+
+/* Look up the type T in the global typedef hash. If it is found,
+ return the typedef name. If it is not found, apply the
+ type-printers, if any, given by start_script_type_printers and return the
+ result. A NULL return means that the name was not found. */
+
+static const char *
+find_global_typedef (const struct type_print_options *flags,
+ struct type *t)
+{
+ char *applied;
+ void **slot;
+ struct typedef_field tf, *new_tf;
+
+ if (flags->global_typedefs == NULL)
+ return NULL;
+
+ tf.name = NULL;
+ tf.type = t;
+
+ slot = htab_find_slot (flags->global_typedefs->table, &tf, INSERT);
+ if (*slot != NULL)
+ {
+ new_tf = *slot;
+ return new_tf->name;
+ }
+
+ /* Put an entry into the hash table now, in case
+ apply_ext_lang_type_printers recurses. */
+ new_tf = XOBNEW (&flags->global_typedefs->storage, struct typedef_field);
+ new_tf->name = NULL;
+ new_tf->type = t;
+
+ *slot = new_tf;
+
+ applied = apply_ext_lang_type_printers (flags->global_printers, t);
+
+ if (applied != NULL)
+ {
+ new_tf->name = obstack_copy0 (&flags->global_typedefs->storage, applied,
+ strlen (applied));
+ xfree (applied);
+ }
+
+ return new_tf->name;
+}
+
+/* Look up the type T in the typedef hash table in with FLAGS. If T
+ is in the table, return its short (class-relative) typedef name.
+ Otherwise return NULL. If the table is NULL, this always returns
+ NULL. */
+
+const char *
+find_typedef_in_hash (const struct type_print_options *flags, struct type *t)
+{
+ if (flags->local_typedefs != NULL)
+ {
+ struct typedef_field tf, *found;
+
+ tf.name = NULL;
+ tf.type = t;
+ found = htab_find (flags->local_typedefs->table, &tf);
+
+ if (found != NULL)
+ return found->name;
+ }
+
+ return find_global_typedef (flags, t);
+}
+
+\f