source: trunk/third/libIDL/tstidl.c @ 20748

/*
 *
 * 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;
}