/*

 *

 * Some crude tests for libIDL.

 *

 * Usage: tstidl <filename> [flags]

 *

 * if given, flags is read as (output_flags << 24) | parse_flags

 *

 * gcc `libIDL-config --cflags --libs` tstidl.c -o tstidl

 *

 */

#ifdef G_LOG_DOMAIN

#  undef G_LOG_DOMAIN

#endif

#define G_LOG_DOMAIN		"tstidl"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <libIDL/IDL.h>

#define IDLFP_IDENT_VISITED	(1UL << 0)

typedef struct {

	IDL_tree tree;

	IDL_ns ns;

} WalkData;

static gboolean

print_repo_id (IDL_tree_func_data *tfd, WalkData *data)

{

	char *repo_id = NULL;

	IDL_tree p;

	p = tfd->tree;

	if (IDL_NODE_TYPE (p) == IDLN_INTERFACE) {

		repo_id = IDL_IDENT_REPO_ID (IDL_INTERFACE (p).ident);

	} else if (IDL_NODE_TYPE (p) == IDLN_IDENT &&

		 IDL_NODE_UP (p) != NULL &&

		 IDL_NODE_UP (IDL_NODE_UP (p)) != NULL &&

		 IDL_NODE_TYPE (IDL_NODE_UP (IDL_NODE_UP (p))) == IDLN_ATTR_DCL)

		repo_id = IDL_IDENT_REPO_ID (p);

	if (repo_id)

		printf ("%s\n", repo_id);

	return TRUE;

}

static gboolean

print_xpidl_exts (IDL_tree_func_data *tfd, WalkData *data)

{

	IDL_tree p;

	p = tfd->tree;

	if (IDL_NODE_TYPE (p) == IDLN_IDENT &&

	    IDL_NODE_TYPE (IDL_NODE_UP (p)) == IDLN_INTERFACE) {

		const char *val;

		val = IDL_tree_property_get (p, "IID");

		if (val) printf ("\tinterface `%s' XPIDL IID:\"%s\"\n",

				 IDL_IDENT (IDL_INTERFACE (IDL_NODE_UP (p)).ident).str,

				 val);

	}

	if (IDL_NODE_TYPE (p) == IDLN_NATIVE &&

	    IDL_NATIVE (p).user_type)

		g_message ("XPIDL native type: \"%s\"", IDL_NATIVE (p).user_type);

	if (IDL_NODE_TYPE (p) == IDLN_CODEFRAG) {

		GSList *slist = IDL_CODEFRAG (p).lines;

		g_message ("XPIDL code fragment desc.: \"%s\"", IDL_CODEFRAG (p).desc);

		for (; slist; slist = slist->next)

			g_message ("XPIDL code fragment line.: \"%s\"", (char *) slist->data);

	}

	return TRUE;

}

static gboolean

print_ident_comments (IDL_tree_func_data *tfd, WalkData *data)

{

	GSList *list;

	IDL_tree p;

	p = tfd->tree;

	if (IDL_NODE_TYPE (p) == IDLN_IDENT) {

		if (!(p->flags & IDLFP_IDENT_VISITED)) {

			printf ("Identifier: %s\n", IDL_IDENT (p).str);

			for (list = IDL_IDENT (p).comments; list;

			     list = g_slist_next (list)) {

				char *comment = list->data;

				printf ("%s\n", comment);

			}

			p->flags |= IDLFP_IDENT_VISITED;

		}

	}

	return TRUE;

}

static gboolean

print_const_dcls (IDL_tree_func_data *tfd, WalkData *data)

{

	IDL_tree p;

	p = tfd->tree;

	if (IDL_NODE_TYPE (p) == IDLN_CONST_DCL) {

		GString *s;

		s = IDL_tree_to_IDL_string (p, NULL, IDLF_OUTPUT_NO_NEWLINES);

		puts (s->str);

		g_string_free (s, TRUE);

		return FALSE;

	}

	return TRUE;

}

/* Example input method... simply reads in from some file and passes it along as

 * is--warning, no actual C preprocessing performed here!  Standard C preprocessor

 * indicators should also be passed to libIDL, including # <line> "filename" (double

 * quotes expected), etcetera (do not confuse this with passing #defines to libIDL, this

 * should not be done). */

/* #define TEST_INPUT_CB */

#ifdef G_OS_WIN32

#  ifndef TEST_INPUT_CB

#    define TEST_INPUT_CB

#  endif

#endif

#ifdef TEST_INPUT_CB

typedef struct {

	FILE *in;

} InputData;

static int

my_input_cb (IDL_input_reason reason, union IDL_input_data *cb_data, gpointer user_data)

{

	InputData *my_data = user_data;

	int rv;

	static int linecount;

	switch (reason) {

	case IDL_INPUT_REASON_INIT:

		g_message ("my_input_cb: filename: %s", cb_data->init.filename);

		my_data->in = fopen (cb_data->init.filename, "r");

		/* If failed, should know that it is implied to libIDL that errno is set

		 * appropriately by a C library function or otherwise. Return 0 upon

		 * success. */

		linecount = 1;

		IDL_file_set (cb_data->init.filename, 1);

		return my_data->in ? 0 : -1;

	case IDL_INPUT_REASON_FILL:

		/* Fill the buffer here... return number of bytes read (maximum of

		   cb_data->fill.max_size), 0 for EOF, negative value upon error. */

		rv = fread (cb_data->fill.buffer, 1, cb_data->fill.max_size, my_data->in);

		IDL_queue_new_ident_comment ("Queue some comment...");

		g_message ("my_input_cb: fill, max size %d, got %d",

			   cb_data->fill.max_size, rv);

		if (rv == 0 && ferror (my_data->in))

			return -1;

		IDL_file_set (NULL, ++linecount);

		return rv;

	case IDL_INPUT_REASON_ABORT:

	case IDL_INPUT_REASON_FINISH:

		/* Called after parsing to indicate success or failure */

		g_message ("my_input_cb: abort or finish");

		fclose (my_data->in);

		break;

	}

	return 0;

}

#endif

int

main (int argc, char *argv[])

{

	int rv;

	IDL_tree tree;

	IDL_ns ns;

	char *fn;

	WalkData data;

	unsigned long parse_flags = 0;

#ifndef G_PLATFORM_WIN32

	{ extern int __IDL_debug;

	__IDL_debug = argc >= 4 ? TRUE : FALSE; }

#endif

	IDL_check_cast_enable (TRUE);

	g_message ("libIDL version %s", IDL_get_libver_string ());

	if (argc < 2) {

		fprintf (stderr, "usage: tstidl <filename> [parse flags, hex]\n");

		exit (1);

	}

	fn = argv[1];

	if (argc >= 3)

		sscanf (argv[2], "%lx", &parse_flags);

#ifdef TEST_INPUT_CB

	{ InputData input_cb_data;

	g_message ("IDL_parse_filename_with_input");

	rv = IDL_parse_filename_with_input (

		fn, my_input_cb, &input_cb_data,

		NULL, &tree, &ns, parse_flags,

		IDL_WARNING1);

	}

#else

	g_message ("IDL_parse_filename");

	rv = IDL_parse_filename (

		fn, NULL, NULL, &tree, &ns,

		parse_flags, IDL_WARNING1);

#endif

	if (rv == IDL_ERROR) {

		g_message ("IDL_ERROR");

		exit (1);	

	} else if (rv < 0) {

		perror (fn);

		exit (1);

	}

	/* rv == IDL_SUCCESS */

	data.tree = tree;

	data.ns = ns;

	g_print ("--------------------------------------\n");

	g_message ("Repository IDs");

	g_print ("--------------------------------------\n");

	IDL_tree_walk_in_order (tree, (IDL_tree_func) print_repo_id, &data);

	g_print ("\n--------------------------------------\n");

	g_message ("XPIDL extensions");

	g_print ("--------------------------------------\n");

	IDL_tree_walk_in_order (tree, (IDL_tree_func) print_xpidl_exts, &data);

	g_print ("\n--------------------------------------\n");

	g_message ("Constant Declarations");

	g_print ("--------------------------------------\n");

	IDL_tree_walk_in_order (tree, (IDL_tree_func) print_const_dcls, &data);

	g_print ("\n--------------------------------------\n");

	g_message ("Identifiers");

	g_print ("--------------------------------------\n");

	IDL_tree_walk_in_order (tree, (IDL_tree_func) print_ident_comments, &data);

	g_print ("\n--------------------------------------\n");

	g_message ("IDL_tree_to_IDL");

	g_print ("--------------------------------------\n");

	IDL_tree_to_IDL (tree, ns, stdout, parse_flags >> 24);

	IDL_ns_free (ns);

	IDL_tree_free (tree);

	return 0;

}