util.c

CORBA上的libIDL源代码

			case IDLN_INTERFACE:
				list_head = &IDL_INTERFACE (q).body;
				break;

			default:
				g_warning ("Unhandled node %s in load_inhibits",
					   IDL_NODE_TYPE_NAME (q));
				break;
			}
		}
		g_hash_table_insert (table, IDL_NODE_UP (p), list_head);

		return FALSE;
	}

	return TRUE;
}

void IDL_tree_remove_inhibits (IDL_tree *tree, IDL_ns ns)
{
	RemoveListNodeData data;
	GHashTable *table = g_hash_table_new (g_direct_hash, g_direct_equal);
	gint removed;

	g_return_if_fail (tree != NULL);
	g_return_if_fail (ns != NULL);

	IDL_tree_walk_in_order (*tree, (IDL_tree_func) load_inhibits, table);
	removed = g_hash_table_size (table);
	data.root = tree;
	data.removed_nodes = IDL_NS (ns).inhibits;
	g_hash_table_foreach (table, (GHFunc) remove_list_node, &data);
	g_hash_table_destroy (table);
	if (__IDL_flags & IDLF_VERBOSE)
		g_message ("Inhibited nodes removed: %d", removed);
}

/* Multi-Pass Empty Module Removal */
static int load_empty_modules (IDL_tree_func_data *tfd, GHashTable *table)
{
	IDL_tree p, q, *list_head;

	p = tfd->tree;

	if (IDL_NODE_TYPE (p) == IDLN_MODULE &&
	    IDL_MODULE (p).definition_list == NULL &&
	    IDL_NODE_UP (p) &&
	    IDL_NODE_TYPE (IDL_NODE_UP (p)) == IDLN_LIST &&
	    !g_hash_table_lookup_extended (table, IDL_NODE_UP (p), NULL, NULL)) {

		list_head = NULL;
		q = IDL_NODE_UP (IDL_NODE_UP (p));
		if (q) {
			assert (IDL_NODE_TYPE (q) == IDLN_MODULE);
			list_head = &IDL_MODULE (q).definition_list;
		}
		g_hash_table_insert (table, IDL_NODE_UP (p), list_head);
	}

	return TRUE;
}

void IDL_tree_remove_empty_modules (IDL_tree *p, IDL_ns ns)
{
	RemoveListNodeData data;
	gboolean done = FALSE;
	gint removed = 0;

	data.root = p;
	data.removed_nodes = NULL;

	while (!done) {
		GHashTable *table = g_hash_table_new (g_direct_hash, g_direct_equal);
		IDL_tree_walk_in_order (*p, (IDL_tree_func) load_empty_modules, table);
		removed += g_hash_table_size (table);
		done = g_hash_table_size (table) == 0;
		g_hash_table_foreach (table, (GHFunc) remove_list_node, &data);
		g_hash_table_destroy (table);
	}
	if (__IDL_flags & IDLF_VERBOSE)
		g_message ("Empty modules removed: %d", removed);
}

/*
 * IDL_tree to IDL backend
 */

#define DELIM_COMMA		", "
#define DELIM_ARRAY		"]["
#define DELIM_SPACE		" "

#define indent()		++data->ilev
#define unindent()		--data->ilev
#define doindent()		do {					\
	int i;								\
	if (!(data->flags & IDLF_OUTPUT_NO_NEWLINES))			\
		for (i = 0; i < data->ilev; ++i) {			\
			switch (data->mode) {				\
			case OUTPUT_FILE:				\
				fputc ('\t', data->u.o);		\
				break;					\
									\
			case OUTPUT_STRING:				\
				g_string_append_c (data->u.s, '\t');	\
				break;					\
									\
			default:					\
				break;					\
			}						\
		}							\
	else if (data->ilev > 0)					\
		dataf (data, DELIM_SPACE);				\
} while (0)
#define nl()			do {				\
	if (!(data->flags & IDLF_OUTPUT_NO_NEWLINES)) {		\
		switch (data->mode) {				\
		case OUTPUT_FILE:				\
			fputc ('\n', data->u.o);		\
			break;					\
								\
		case OUTPUT_STRING:				\
			g_string_append_c (data->u.s, '\n');	\
			break;					\
								\
		default:					\
			break;					\
		}						\
	}							\
} while (0)
#define save_flag(flagbit,val)	do {				\
	tfd->data = GUINT_TO_POINTER (				\
 		GPOINTER_TO_UINT (tfd->data) |			\
 		(data->flagbit ? (1U << flagbit##bit) : 0));	\
	data->flagbit = val;					\
} while (0)
#define restore_flag(flagbit)	do {			\
	data->flagbit = (GPOINTER_TO_UINT (		\
		tfd->data) >> flagbit##bit) & 1U;	\
} while (0)

typedef struct {
	IDL_ns ns;
	enum {
		OUTPUT_FILE,
		OUTPUT_STRING
	} mode;
	union {
		FILE *o;
		GString *s;
	} u;
	int ilev;
	unsigned long flags;

#define identsbit		0
	guint idents : 1;

#define literalsbit		1
	guint literals : 1;

#define inline_propsbit		2
	guint inline_props : 1;

#define su_defbit		3
	guint su_def : 1;
} IDL_output_data;

static void dataf (IDL_output_data *data, const char *fmt, ...)
G_GNUC_PRINTF (2, 3);

static void idataf (IDL_output_data *data, const char *fmt, ...)
G_GNUC_PRINTF (2, 3);

static void dataf (IDL_output_data *data, const char *fmt, ...)
{
	gchar *buffer;
	va_list args;

	va_start (args, fmt);
	switch (data->mode) {
	case OUTPUT_FILE:
		vfprintf (data->u.o, fmt, args);
		break;

	case OUTPUT_STRING:
		buffer = g_strdup_vprintf (fmt, args);
		g_string_append (data->u.s, buffer);
		g_free (buffer);
		break;

	default:
		break;
	}
	va_end (args);
}

static void idataf (IDL_output_data *data, const char *fmt, ...)
{
	gchar *buffer;
	va_list args;

	va_start (args, fmt);
	doindent ();
	switch (data->mode) {
	case OUTPUT_FILE:
		vfprintf (data->u.o, fmt, args);
		break;

	case OUTPUT_STRING:
		buffer = g_strdup_vprintf (fmt, args);
		g_string_append (data->u.s, buffer);
		g_free (buffer);
		break;

	default:
		break;
	}
	va_end (args);
}

static gboolean IDL_emit_node_pre_func (IDL_tree_func_data *tfd, IDL_output_data *data);
static gboolean IDL_emit_node_post_func (IDL_tree_func_data *tfd, IDL_output_data *data);

typedef struct {
	IDL_tree_func pre_func;
	IDL_tree_func post_func;
	IDL_tree_type type, type2;
	gboolean limit;
	IDL_output_data *data;
	const char *delim;
	gboolean hit;
} IDL_output_delim_data;

static gboolean IDL_output_delim_match (IDL_tree_func_data *tfd, IDL_output_delim_data *delim)
{
	return delim->type == IDLN_ANY ||
		IDL_NODE_TYPE (tfd->tree) == delim->type ||
		IDL_NODE_TYPE (tfd->tree) == delim->type2;
}

static gboolean IDL_output_delim_pre (IDL_tree_func_data *tfd, IDL_output_delim_data *delim)
{
	if (IDL_output_delim_match (tfd, delim)) {
		if (delim->hit)
			dataf (delim->data, delim->delim);
		else
			delim->hit = TRUE;
		return delim->pre_func
			? (*delim->pre_func) (tfd, delim->data)
			: TRUE;
	} else {
		if (!delim->limit)
			return delim->pre_func
				? (*delim->pre_func) (tfd, delim->data)
				: TRUE;
		else
			return TRUE;
	}
}

static gboolean IDL_output_delim_post (IDL_tree_func_data *tfd, IDL_output_delim_data *delim)
{
	if (delim->limit && !IDL_output_delim_match (tfd, delim))
		return TRUE;

	return delim->post_func
		? (*delim->post_func) (tfd, delim->data)
		: TRUE;
}

static void IDL_output_delim (IDL_tree p, IDL_tree_func_data *current,
			      IDL_output_data *data,
			      IDL_tree_func pre_func, IDL_tree_func post_func,
			      IDL_tree_type type, IDL_tree_type type2,
			      gboolean limit,
			      const char *str)
{
	IDL_output_delim_data delim;

	delim.pre_func = pre_func;
	delim.post_func = post_func;
	delim.type = type;
	delim.type2 = type2;
	delim.limit = limit;
	delim.data = data;
	delim.hit = FALSE;
	delim.delim = str;

	IDL_tree_walk (p, current,
		       (IDL_tree_func) IDL_output_delim_pre,
		       (IDL_tree_func) IDL_output_delim_post,
		       &delim);
}

typedef struct {
	IDL_output_data *data;
	gboolean hit;
} IDL_property_emit_data;

static void IDL_emit_IDL_property (const char *key, const char *value,
				   IDL_property_emit_data *emit_data)
{
	IDL_output_data *data = emit_data->data;

	if (!emit_data->hit)
		emit_data->hit = TRUE;
	else
		dataf (emit_data->data, DELIM_COMMA);
	if (!data->inline_props) {
		nl ();
		doindent ();
	}
	if (value && *value)
		dataf (emit_data->data, "%s%s(%s)",
		       key, DELIM_SPACE, value);
	else
		dataf (emit_data->data, "%s", key);
}

static gboolean IDL_emit_IDL_properties (IDL_tree p, IDL_output_data *data)
{
	IDL_property_emit_data emit_data;

	if (IDL_NODE_PROPERTIES (p) &&
	    data->flags & IDLF_OUTPUT_PROPERTIES &&
	    g_hash_table_size (IDL_NODE_PROPERTIES (p)) > 0) {
		emit_data.data = data;
		emit_data.hit = FALSE;
		if (!data->inline_props)
			idataf (data, "[" DELIM_SPACE);
		else
			dataf (data, "[");
		indent ();
		g_hash_table_foreach (IDL_NODE_PROPERTIES (p),
				      (GHFunc) IDL_emit_IDL_property,
				      &emit_data);
		unindent ();
		if (!data->inline_props) {
			nl ();
			doindent ();
		}
		dataf (data, "]");
		if (!data->inline_props)
			nl ();
		else
			dataf (data, DELIM_SPACE);
	}

	return TRUE;
}

static gboolean IDL_emit_IDL_sc (IDL_tree_func_data *tfd, IDL_output_data *data)
{
	dataf (data, ";"); nl ();

	return TRUE;
}

static gboolean IDL_emit_IDL_indent (IDL_tree_func_data *tfd, IDL_output_data *data)
{
	doindent ();

	return TRUE;
}

static gboolean IDL_emit_IDL_curly_brace_open (IDL_tree_func_data *tfd, IDL_output_data *data)
{
	dataf (data, "{"); nl (); indent ();

	return TRUE;
}

static gboolean IDL_emit_IDL_curly_brace_close (IDL_tree_func_data *tfd, IDL_output_data *data)
{
	unindent (); idataf (data, "}");

	return TRUE;
}

static gboolean IDL_emit_IDL_curly_brace_close_sc (IDL_tree_func_data *tfd, IDL_output_data *data)
{
	IDL_emit_IDL_curly_brace_close (tfd, data);
	IDL_emit_IDL_sc (tfd, data);

	return TRUE;
}

static gboolean IDL_emit_IDL_ident_real (IDL_tree_func_data *tfd, IDL_output_data *data)
{
	IDL_tree_func_data *up_path;
	IDL_tree up_real, scope;
	char *s;
	int levels;

	up_path = tfd;
	up_real = tfd->tree;
	while (up_path && up_real) {
		if (IDL_NODE_TYPE (up_path->tree) != IDL_NODE_TYPE (up_real))
			break;
		up_path = up_path->up;
		up_real = IDL_NODE_UP (up_real);
	}

	assert (IDL_NODE_TYPE (tfd->tree) == IDLN_IDENT);

	if (!up_real || data->flags & IDLF_OUTPUT_NO_QUALIFY_IDENTS)
		dataf (data, "%s", IDL_IDENT (tfd->tree).str);
	else {
		/* Determine minimal required levels of scoping */
		assert (up_path != NULL);
		scope = up_path->tree ? up_path->tree : up_real;
		levels = IDL_ns_scope_levels_from_here (data->ns, tfd->tree, scope);
		s = IDL_ns_ident_to_qstring (IDL_IDENT_TO_NS (tfd->tree), "::", levels);
		dataf (data, "%s", s);
		g_free (s);
	}

	return TRUE;
}

static gboolean IDL_emit_IDL_ident_pre (IDL_tree_func_data *tfd, IDL_output_data *data)
{
	if (data->idents)
		IDL_emit_IDL_ident_real (tfd, data);

	return TRUE;
}

static gboolean IDL_emit_IDL_ident_force_pre (IDL_tree_func_data *tfd, IDL_output_data *data)
{
	IDL_emit_IDL_ident_real (tfd, data);

	return TRUE;
}

static gboolean IDL_emit_IDL_ident (IDL_tree ident, IDL_tree_func_data *tfd, IDL_output_data *data)
{
	IDL_tree_walk (ident, tfd,
		       (IDL_tree_func) IDL_emit_IDL_ident_real, NULL,
		       data);

	return TRUE;
}

static gboolean IDL_emit_IDL_literal (IDL_tree p, IDL_output_data *data)
{
	switch (IDL_NODE_TYPE (p)) {
	case IDLN_FLOAT:
		dataf (data, "%f", IDL_FLOAT (p).value);
		break;

	case IDLN_INTEGER:
		/* FIXME: sign */
		dataf (data, "%" IDL_LL "d", IDL_INTEGER (p).value);
		break;

	case IDLN_FIXED:
		dataf (data, "%s", IDL_FIXED (p).value);
		break;

	case IDLN_CHAR:
		dataf (data, "'%s'", IDL_CHAR (p).value);
		break;

	case IDLN_WIDE_CHAR:
/*		dataf (data, "'%s'", IDL_WIDE_CHAR (p).value); */
		g_warning ("IDL_emit_IDL_literal: %s is currently unhandled",
			   "Wide character output");
		break;

	case IDLN_BOOLEAN:
		dataf (data, "%s", IDL_BOOLEAN (p).value ? "TRUE" : "FALSE");
		break;

	case IDLN_STRING:
		dataf (data, "\"%s\"", IDL_STRING (p).value);
		break;

	case IDLN_WIDE_STRING:
/*		dataf (data, "\"%s\"", IDL_STRING (p).value); */
		g_warning ("IDL_emit_IDL_literal: %s is currently unhandled",
			   "Wide string output");
		break;

	default:
		g_warning ("Unhandled literal: %s", IDL_NODE_TYPE_NAME (p));
		break;
	}

	return TRUE;
}

static gboolean IDL_emit_IDL_literal_pre (IDL_tree_func_data *tfd, IDL_output_data *data)
{
	if (data->literals)
		IDL_emit_IDL_literal (tfd->tree, data);

	return TRUE;
}

static gboolean IDL_emit_IDL_literal_force_pre (IDL_tree_func_data *tfd, IDL_output_data *data)
{
	IDL_emit_IDL_literal (tfd->tree, data);

	return TRUE;
}

static gboolean IDL_emit_IDL_type_pre (IDL_tree_func_data *tfd, IDL_output_data *data)
{
	IDL_tree p, q;

	p = tfd->tree;

	switch (IDL_NODE_TYPE (p)) {
	case IDLN_IDENT:
		IDL_emit_IDL_ident (p, tfd, data);
		break;

	case IDLN_TYPE_CHAR:
		dataf (data, "char");
		break;

	case IDLN_TYPE_WIDE_CHAR:
		dataf (data, "wchar");
		break;

	case IDLN_TYPE_BOOLEAN:
		dataf (data, "boolean");
		break;

	case IDLN_TYPE_OCTET:
		dataf (data, "octet");
		break;

	case IDLN_TYPE_ANY:
		dataf (data, "any");
		break;

	case IDLN_TYPE_OBJECT:
		dataf (data, "Object");
		break;

	case IDLN_TYPE_TYPECODE:
		dataf (data, "TypeCode");
		break;

	case IDLN_TYPE_FLOAT:
		switch (IDL_TYPE_FLOAT (p).f_type) {
		case IDL_FLOAT_TYPE_FLOAT: dataf (data, "float"); break;
		case IDL_FLOAT_TYPE_DOUBLE: dataf (data, "double"); break;
		case IDL_FLOAT_TYPE_LONGDOUBLE: dataf (data, "long" DELIM_SPACE "double"); break;
		}
		break;

	case IDLN_TYPE_FIXED:
		dataf (data, "fixed<");
		IDL_emit_IDL_literal (IDL_TYPE_FIXED (p).positive_int_const, data);
		dataf (data, DELIM_COMMA);
		IDL_emit_IDL_literal (IDL_TYPE_FIXED (p).integer_lit, data);
		dataf (data, ">");
		return FALSE;

	case IDLN_TYPE_INTEGER:
		if (!IDL_TYPE_INTEGER (p).f_signed)
			dataf (data, "unsigned" DELIM_SPACE);
		switch (IDL_TYPE_INTEGER (p).f_type) {
		case IDL_INTEGER_TYPE_SHORT: dataf (data, "short"); break;
		case IDL_INTEGER_TYPE_LONG: dataf (data, "long"); break;
		case IDL_INTEGER_TYPE_LONGLONG: dataf (data, "long" DELIM_SPACE "long"); break;
		}
		break;

	case IDLN_TYPE_STRING:
	case