/**

***     XMLLINT command response program.

***

***     See Copyright for the status of this software.

***

***     Author: Patrick Monnerat <pm@datasphere.ch>, DATASPHERE S.A.

**/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <qshell.h>

/* Variable-length string, with 16-bit length. */

typedef struct {

        short           len;

        char            string[5000];

}               vary2;

/* Variable-length string, with 32-bit length. */

typedef struct {

        int             len;

        char            string[5000];

}               vary4;

/* Multiple occurrence parameter list. */

#define paramlist(itemsize, itemtype)                                   \

        _Packed struct {                                                \

                short           len;                                    \

                union {                                                 \

                         char           _pad[itemsize];                 \

                        itemtype        param;                          \

                }               item[1];                                \

        }

/* Arguments from CL command. */

typedef struct {

        char *          pgm;            /* Program name. */

        vary2 *         stmf;           /* XML file name or URL. */

        vary2 *         dtd;            /* DTD location or public identifier. */

        char *          dtdvalid;       /* *DTDURL or *DTDFPI. */

        vary2 *         schema;         /* Schema file name or URL. */

        vary2 *         schemakind;     /* --schema/--relaxng/--schematron. */

        vary2 *         outstmf;        /* Output stream file name. */

        vary2 *         xpath;          /* XPath filter. */

        vary2 *         pattern;        /* Reader filter pattern. */

        paramlist(5000 + 2, vary2) * path; /* Path for resources. */

        vary2 *         pretty;         /* Pretty-print style. */

        unsigned long * maxmem;         /* Maximum dynamic memory. */

        vary2 *         encoding;       /* Output encoding. */

        paramlist(20 + 2, vary2) * options; /* Other options. */

}               arguments;

/* Definition of QSHELL program. */

extern void     qshell(vary4 * cmd);

#pragma linkage(qshell, OS)

#pragma map(qshell, "QSHELL/QZSHQSHC")

static void

vary4nappend(vary4 * dst, const char * src, size_t len)

{

        if (len > sizeof(dst->string) - dst->len)

                len = sizeof(dst->string) - dst->len;

        if (len) {

                memcpy(dst->string + dst->len, src, len);

                dst->len += len;

                }

}

static void

vary4append(vary4 * dst, const char * src)

{

        vary4nappend(dst, src, strlen(src));

}

static void

vary4arg(vary4 * dst, const char * arg)

{

        vary4nappend(dst, " ", 1);

        vary4append(dst, arg);

}

static void

vary4varg(vary4 * dst, vary2 * arg)

{

        vary4nappend(dst, " ", 1);

        vary4nappend(dst, arg->string, arg->len);

}

static void

vary4vescape(vary4 * dst, vary2 * arg)

{

        int i;

        for (i = 0; i < arg->len; i++)

                if (arg->string[i] == '\'')

                        vary4nappend(dst, "'\"'\"'", 5);

                else

                        vary4nappend(dst, arg->string + i, 1);

}

static void

vary4vargquote(vary4 * dst, vary2 * arg)

{

        vary4nappend(dst, " '", 2);

        vary4vescape(dst, arg);

        vary4nappend(dst, "'", 1);

}

int

main(int argsc, arguments * args)

{

        vary4 cmd;

        int i;

        char textbuf[20];

        char * lang;

        /* find length of library name. */

        for (i = 0; i < 10 && args->pgm[i] && args->pgm[i] != '/'; i++)

                ;

        /* Store program name in command buffer. */

        cmd.len = 0;

        vary4append(&cmd, "/QSYS.LIB/");

        vary4nappend(&cmd, args->pgm, i);

        vary4append(&cmd, ".LIB/XMLLINT.PGM");

        /* Map command arguments to standard xmllint argument vector. */

        if (args->dtd && args->dtd->len) {

                if (args->dtdvalid && args->dtdvalid[4] == 'F')

                        vary4arg(&cmd, "--dtdvalidfpi");

                else

                        vary4arg(&cmd, "--dtdvalid");

                vary4vargquote(&cmd, args->dtd);

                }

        if (args->schema && args->schema->len) {

                vary4varg(&cmd, args->schemakind);

                vary4vargquote(&cmd, args->schema);

                }

        if (args->outstmf && args->outstmf->len) {

                vary4arg(&cmd, "--output");

                vary4vargquote(&cmd, args->outstmf);

                if (args->encoding && args->encoding->len) {

                        vary4arg(&cmd, "--encoding");

                        vary4vargquote(&cmd, args->encoding);

                        }

                }

        if (args->xpath && args->xpath->len) {

                vary4arg(&cmd, "--xpath");

                vary4vargquote(&cmd, args->xpath);

                }

        if (args->pattern && args->pattern->len) {

                vary4arg(&cmd, "--pattern");

                vary4vargquote(&cmd, args->pattern);

                }

        if (args->path && args->path->len) {

                vary4arg(&cmd, "--path '");

                vary4vescape(&cmd, &args->path->item[0].param);

                for (i = 1; i < args->path->len; i++) {

                        vary4nappend(&cmd, ":", 1);

                        vary4vescape(&cmd, &args->path->item[i].param);

                        }

                vary4nappend(&cmd, "'", 1);

                }

        if (args->pretty && args->pretty->len &&

            args->pretty->string[0] != '0') {

                vary4arg(&cmd, "--pretty");

                vary4varg(&cmd, args->pretty);

                }

        if (args->maxmem && *args->maxmem) {

                snprintf(textbuf, sizeof textbuf, "%lu", *args->maxmem);

                vary4arg(&cmd, "--maxmem");

                vary4arg(&cmd, textbuf);

                }

        for (i = 0; i < args->options->len; i++)

                vary4varg(&cmd, &args->options->item[i].param);

        vary4vargquote(&cmd, args->stmf);

        /* Execute the shell command. */

        qshell(&cmd);

        /* Terminate. */

        exit(0);

}