dsslib/xml/xml.c

/***********************************************************************
*                                                                      *
*               This software is part of the ast package               *
*          Copyright (c) 2010-2012 AT&T Intellectual Property          *
*                      and is licensed under the                       *
*                 Eclipse Public License, Version 1.0                  *
*                    by AT&T Intellectual Property                     *
*                                                                      *
*                A copy of the License is available at                 *
*          http://www.eclipse.org/org/documents/epl-v10.html           *
*         (with md5 checksum b35adb5213ca9657e911e9befb180842)         *
*                                                                      *
*              Information and Software Systems Research               *
*                            AT&T Research                             *
*                           Florham Park NJ                            *
*                                                                      *
*                 Glenn Fowler <gsf@research.att.com>                  *
*                                                                      *
***********************************************************************/
#pragma prototyped
/*
 * xml method
 *
 * Glenn Fowler
 * AT&T Research
 */

static const char usage[] =
"[+DESCRIPTION?The \bdss\b xml method reads XML data in two formats: "
    "pure XML (\aname=value\a attributes within tags ignored) and JSON. In "
    "general XML data provides field names but not type information, so by "
    "default all fields are treated as strings. Only fields specified in the "
    "\bdss\b(1) \aexpression\a are parsed from the data. Fields are named "
    "using \b.\b'd notation, where each prefix name represents XML tag "
    "nesting. For XML data, if all records have the same XML tag prefix then "
    "that prefix may be omitted, except that all field names must have at "
    "least one prefix component. For example, \busers.user.name\b and "
    "\buser.name\b are valid, but \bname\b is not.]"
"[+?The xml method schema is an XML document that specifies the type of "
    "one or more fields, and any libraries required to support those types.]"
"[T:test?Enable implementation-specific tests and tracing.]#[mask]"
"[+TAGS?The supported tags are:]{"
;

#include <dsslib.h>
#include <ctype.h>

struct Field_s; typedef struct Field_s Field_t;
struct File_s; typedef struct File_s File_t;
struct Value_s; typedef struct Value_s Value_t;
struct Library_s; typedef struct Library_s Library_t;
struct Xml_s; typedef struct Xml_s Xml_t;

struct Library_s            /* library list         */
{
    Library_t*  next;       /* next in list         */
    char        name[1];    /* library name         */
};

struct Value_s              /* value in current record  */
{
    uintmax_t   record;     /* record number for value  */
    size_t      offset;     /* File_t.value offset      */
    size_t      size;       /* string value size        */
    int     number;     /* value is a number        */
    Cxinternal_f    internalf;  /* convert to internal value    */
};

struct File_s               /* file read state      */
{
    uintmax_t   record;     /* current record number    */
    unsigned char*  buf;        /* input buffer         */
    unsigned char*  rec;        /* input record position    */
    unsigned char*  cur;        /* input buffer position    */
    unsigned char*  end;        /* input buffer end     */
    char*       name;       /* current .'d name     */
    char*       root;       /* root path            */
    char*       value;      /* current record tag values    */
    int     image;      /* keep current record image    */
    int     level;      /* part[] index         */
    int     maxlevel;   /* max part[] index     */
    int     maxname;    /* max .'d name length      */
    int     prefix;     /* implied .'d prefix       */
    int     save;       /* real char at *f->end     */
    size_t      maxvalue;   /* size of value        */
    unsigned char*  prv;        /* previous buffer chunk    */
    size_t      prvsize;    /* max previous buffer size */
    size_t      prvlen;     /* current previous buffer size */
    char*       part[1];    /* .'d part stack       */
};

struct Field_s              /* current proto schema field   */
{
    Field_t*    next;       /* next in list         */
    char*       name;       /* qualified field name     */
    char*       type;       /* field type name      */
    Cxformat_t  format;     /* field output format      */
};

struct Xml_s                /* Dssmeth_t.data       */
{
    Dsstagdisc_t    dsstagdisc;
    Dssmeth_t   meth;
    Dssmeth_t*  basemeth;
    Library_t*  libraries;
    Library_t*  lastlibrary;
    Field_t*    fields;
    Field_t*    lastfield;
    Cxflags_t   test;
    char*       root;
    int     image;
    int     maxname;
    int     maxlevel;
    int     prefix;
};

static const char   null[1];

static char     xml_beg_tag[UCHAR_MAX+1];
static char     xml_end_tag[UCHAR_MAX+1];
static char     xml_end_att[UCHAR_MAX+1];

static char     json_beg_tag[UCHAR_MAX+1];
static char     json_end_val[UCHAR_MAX+1];

extern Dsslib_t     dss_lib_xml;

/*
 * xml var create/lookup
 * type==0 for prefix components
 */

static Cxvariable_t*
xmlvar(Cx_t* cx, char* name, const char* type, Cxdisc_t* disc)
{
    Xml_t*      xml = (Xml_t*)DSS(cx)->meth->data;
    Cxvariable_t*   var;
    Value_t*    val;
    char*       s;
    int     n;
    int     i;

    if (*name == '.')
        var = cxvariable(cx, name, NiL, disc);
    else if (!(var = dtmatch(cx->variables, name)))
    {
        n = strlen(name) + 1;
        if (!(var = vmnewof(cx->vm, 0, Cxvariable_t, 1, sizeof(Value_t) + n)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
            return 0;
        }
        var->data = val = (Value_t*)(var + 1);
        strcpy((char*)(var->name = (const char*)(var + 1) + sizeof(Value_t)), name);
        var->type = (Cxtype_t*)(type ? type : "number");
        if (cxaddvariable(cx, var, disc))
            return 0;
        if ((val->number = cxisnumber(var->type)) && !(val->internalf = var->type->internalf) && var->type->base)
            val->internalf = var->type->base->internalf;
        if (type)
        {
            if (xml->maxname < ++n)
                xml->maxname = n;
            n = 0;
            for (s = name; *s; s++)
                if (*s == '.')
                {
                    *s = 0;
                    i = !xmlvar(cx, name, NiL, disc);
                    *s = '.';
                    if (i)
                        return 0;
                    n++;
                }
            if (xml->maxlevel < n)
                xml->maxlevel = n;
            if (n && !xml->root && (s = strchr(var->name, '.')))
            {
                if (xml->root = vmnewof(cx->vm, 0, char, s - var->name, 1))
                    memcpy(xml->root, var->name, s - var->name);
                else
                {
                    if (disc->errorf)
                        (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
                    return 0;
                }
            }
        }
    }
    return var;
}

/*
 * xml identf
 */

static int
xmlident(Dssfile_t* file, void* buf, size_t n, Dssdisc_t* disc)
{
    static const char   magic[] = "<?xml";

    return (n > (sizeof(magic) - 1) && !memcmp(buf, magic, sizeof(magic) - 1));
}

/*
 * refill the input buffer and return the next char, -1 on error
 */

static int
refill(Dssfile_t* file, register File_t* f, int c, Dssdisc_t* disc)
{
    size_t  n;

    if (f->cur >= f->end)
    {
        if (f->rec)
        {
            if ((n = f->cur - f->rec + f->prvlen) > f->prvsize)
            {
                f->prvsize = roundof(f->prvsize + n, 1024);
                if (!(f->prv = vmnewof(file->vm, f->prv, unsigned char, f->prvsize, 0)))
                {
                    if (disc->errorf)
                        (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
                    return -1;
                }
            }
            if (n > 1)
                memcpy(f->prv + f->prvlen, f->rec, n - 1);
            f->prv[n-1] = f->save;
            f->prvlen += n;
        }
        if (!(f->buf = (unsigned char*)sfreserve(file->io, SF_UNBOUND, 0)))
            return -1;
        if (f->rec)
            f->rec = f->buf;
        f->cur = f->buf;
        c = f->save;
        f->end = f->buf + sfvalue(file->io) - 1;
        f->save = *f->end;
        *f->end = 0;
    }
    return c;
}

#define REFILL(f,c,r)   do { if ((c = refill(file, f, c, disc)) < 0) r; } while (0)

#define RESIZE() \
    do \
    { \
        o = vp - f->value; \
        f->maxvalue += 1024; \
        if (!(f->value = vmnewof(file->vm, f->value, char, f->maxvalue, 0))) \
        { \
            if (disc->errorf) \
                (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space"); \
            return -1; \
        } \
        vb = f->value; \
        vp = vb + o; \
        ve = vb + f->maxvalue - 1; \
    } while (0)

/*
 * xml readf -- consume 1 xml record and retain field values of interest
 */

static int
xmlread(Dssfile_t* file, Dssrecord_t* record, Dssdisc_t* disc)
{
    register File_t*    f = file->data;
    register char*      np;
    register char*      ne;
    register char*      vp;
    register char*      ve;
    register int        c;
    char*           vb;
    Cxvariable_t*       v;
    ssize_t         o;
    int         q;

    f->record++;
    f->rec = 0;
    f->prvlen = 0;
    vp = vb = f->value;
    ve = f->value + f->maxvalue - 1;
    ne = f->name + f->maxname;
    np = f->level >= f->maxlevel ? ne : f->level ? f->part[f->level] : f->name;
    for (;;)
    {
        /* find the next tag */

        for (;;)
        {
            while (!xml_beg_tag[*f->cur++]);
            if (*(f->cur - 1))
                break;
            REFILL(f, c, goto done);
            if (c == '<')
                break;
        }
    tag:
        if (!(c = *f->cur++))
            REFILL(f, c, -1);
        switch (c)
        {
        case '/':
            if (f->level)
                f->level--;
            if (f->level <= f->maxlevel)
                np = f->part[f->level];
            /*FALLTHROUGH*/
        case '?':
            for (;;)
            {
                while (!xml_end_tag[*f->cur++]);
                if (*(f->cur - 1))
                    break;
                REFILL(f, o, goto incomplete);
                if (o == '>')
                    break;
            }
            if (c == '/' && f->level == f->prefix)
            {
                record->data = f;
                file->count = f->record;
                return 1;
            }
            break;
        default:
            if (np <= ne && f->level > f->prefix)
            {
                *np = 0;
                if (v = dtmatch(file->dss->cx->variables, f->part[f->prefix] + 1))
                {
                    if (f->image && !f->rec)
                        f->rec = f->cur - 1;
                    ((Value_t*)v->data)->record = f->record;
                    ((Value_t*)v->data)->offset = vp - vb;
                    ((Value_t*)v->data)->size = 1;
                    if (vp >= ve)
                        RESIZE();
                    *vp++ = '1';
                    if (vp >= ve)
                        RESIZE();
                    *vp++ = 0;
                }
            }
            if (f->level <= f->maxlevel)
                f->part[f->level] = np;
            else
                np = ne + 1;
            f->level++;
            if (np < ne)
                *np++ = '.';
            if (np < ne)
                *np++ = c;
            q = 0;
            for (;;)
            {
                while (!xml_end_tag[c = *f->cur++])
                    if (np < ne)
                        *np++ = c;
                    else
                        q = c;
                if (c)
                    break;
                REFILL(f, c, goto incomplete);
                if (c == '>')
                    break;
                if (np < ne)
                    *np++ = c;
                else
                    q = c;
            }
            if (!q && *(np - 1) == '/' || q == '/')
            {
                /* null tag */

                if (f->level)
                    f->level--;
                if (f->level <= f->maxlevel)
                    np = f->part[f->level];
            }
            else
            {
                /* ignore tag name=value attributes -- why did they allow them */

                if (c == ' ')
                {
                    q = 0;
                    for (;;)
                    {
                        while (!xml_end_att[c = *f->cur++]);
                        if (!c)
                            REFILL(f, c, goto incomplete);
                        if (c == '"')
                            q = !q;
                        else if (!q && c == '>')
                            break;
                    }
                }
                if (np < ne && f->level > f->prefix)
                {
                    *np = 0;
                    if (v = dtmatch(file->dss->cx->variables, f->part[f->prefix] + 1))
                    {
                        if (f->image && !f->rec)
                            f->rec = f->cur - 1;
                        ((Value_t*)v->data)->record = f->record;
                        ((Value_t*)v->data)->offset = vp - vb;
                        for (;;)
                        {
                            while (!xml_beg_tag[c = *f->cur++])
                            {
                                if (vp >= ve)
                                    RESIZE();
                                *vp++ = c;
                            }
                            if (*(f->cur - 1))
                                break;
                            REFILL(f, c, goto incomplete);
                            if (c == '<')
                                break;
                            if (vp >= ve)
                                RESIZE();
                            *vp++ = c;
                        }
                        ((Value_t*)v->data)->size = vp - (vb + ((Value_t*)v->data)->offset);
                        if (vp >= ve)
                            RESIZE();
                        *vp++ = 0;
                        goto tag;
                    }
                }
            }
            break;
        }
    }
 done:
    if (f->level <= f->prefix)
        return 0;
 incomplete:
    if (disc->errorf)
        (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "%s: record %I*u incomplete", file->path, sizeof(f->record), f->record);
    return -1;
}

/*
 * xml writef -- output current record
 */

static int
xmlwrite(Dssfile_t* file, Dssrecord_t* record, Dssdisc_t* disc)
{
    register File_t*    r = (File_t*)record->data;
    size_t          n;

    sfprintf(file->io, "<%s", r->root);
    if (r->prvlen && sfwrite(file->io, r->prv, r->prvlen) != r->prvlen)
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "%s: write error", file->path);
        return -1;
    }
    if ((n = r->cur - r->rec) && sfwrite(file->io, r->rec, n) != n)
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "%s: write error", file->path);
        return -1;
    }
    sfputc(file->io, '\n');
    return 0;
}

/*
 * xml fopenf
 */

static int
xmlfopen(Dssfile_t* file, Dssdisc_t* disc)
{
    register Xml_t*     xml = (Xml_t*)file->dss->meth->data;
    register unsigned char* s;
    register unsigned char* t;
    register int        n;
    File_t*         f;
    int         c;
    int         m;
    int         x;
    unsigned char*      buf;
    unsigned char*      end;

    if (file->flags & DSS_FILE_WRITE)
        buf = 0;
    else if (buf = (unsigned char*)sfreserve(file->io, SF_UNBOUND, 0))
    {
        end = buf + sfvalue(file->io) - 1;
        if (xml->prefix < 0)
        {
            xml->image = !!(file->dss->flags & DSS_WRITE);
            if (file->format->readf == xmlread)
            {
                if (!xml->root)
                {
                    if (disc->errorf)
                        (*disc->errorf)(NiL, disc, 2, "%s variable names must be qualified by at least the immediate containing tag", file->format->name);
                    return -1;
                }
                x = *end;
                *end = 0;
                s = buf;
                n = 0;
                m = -1;
                for (;;)
                {
                    while (!xml_beg_tag[*s++]);
                    if (*(s - 1))
                    {
                        t = s;
                        while (!xml_end_tag[*s++]);
                        if (*t == '/')
                        {
                            if (m > 0)
                            {
                                m--;
                                n -= s - t - 2;
                            }
                        }
                        else if (*t != '?')
                        {
                            m++;
                            n += (c = s - t - 1);
                            if (!memcmp(xml->root, t, c) && !*(xml->root + c))
                                break;
                        }
                    }
                    else if (s >= end)
                        break;
                }
                *end = x;
                xml->prefix = m;
                xml->maxlevel += m;
                xml->maxname += n;
            }
            else
            {
                xml->prefix = 0;
                xml->maxname += 1024; /*XXX*/
            }
        }
    }
    if (!(f = vmnewof(file->vm, 0, File_t, 1, (xml->maxlevel + 1) * sizeof(char*) + xml->maxname + 1)))
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
        return -1;
    }
    file->data = f;
    f->name = (char*)(f + 1) + (xml->maxlevel + 1) * sizeof(char*);
    if (!(file->flags & DSS_FILE_WRITE))
    {
        if (buf)
        {
            f->cur = f->buf = buf;
            f->end = end;
            f->save = *end;
            *end = 0;
        }
        else
            f->buf = f->cur = f->end = (unsigned char*)null;
        f->image = xml->image;
        f->prefix = xml->prefix;
        f->maxlevel = xml->maxlevel;
        f->maxname = xml->maxname;
        f->maxvalue = 1024;
        f->root = xml->root;
        if (!(f->value = vmnewof(file->vm, 0, char, f->maxvalue, 0)))
        {
            vmfree(file->vm, f);
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
            return -1;
        }
    }
    return 0;
}

/*
 * xml fclosef
 */

static int
xmlfclose(Dssfile_t* file, Dssdisc_t* disc)
{
    if (!file || !file->data)
        return -1;
    return 0;
}

static Dssformat_t xml_format =
{
    "xml",
    "xml format (2010-05-19)",
    CXH,
    xmlident,
    xmlfopen,
    xmlread,
    xmlwrite,
    0,
    xmlfclose,
    0,
    0,
    0
};

/*
 * json identf
 */

static int
jsonident(Dssfile_t* file, void* buf, size_t n, Dssdisc_t* disc)
{
    register char*      s;
    register char*      e;
    register const char*    m;

    static const char   magic[] = "{\"";

    s = buf;
    e = s + n;
    for (m = magic; s < e; s++)
        if (isspace(*s))
            ;
        else if (*s != *m)
            return 0;
        else if (!*++m)
            return 1;
    return 0;
}

/*
 * json readf
 */

static int
jsonread(register Dssfile_t* file, register Dssrecord_t* record, Dssdisc_t* disc)
{
    register File_t*    f = file->data;
    register char*      np;
    register char*      ne;
    register char*      vp;
    register char*      ve;
    register int        c;
    char*           vb;
    Cxvariable_t*       v;
    size_t          o;
    int         a;
    int         e;
    int         q;
    int         n;

    f->record++;
    error(-1, "AHA jsonread file=%p record.file=%p", file, record->file);
    f->rec = 0;
    f->prvlen = 0;
    vp = vb = f->value;
    ve = f->value + f->maxvalue - 1;
    ne = f->name + f->maxname;
    np = f->level > f->maxlevel ? ne : f->level ? f->part[f->level] : f->name;
    for (;;)
    {
    beg:
        do
        {
            while (!json_beg_tag[c = *f->cur++]);
            if (!c)
                REFILL(f, c, goto done);
            if (c == '}')
            {
                if (!f->level)
                {
                    record->data = f;
                    file->count = f->record;
                    return 1;
                }
                if (--f->level <= f->maxlevel)
                    np = f->part[f->level];
            }
        } while (c != '{' && c != ',');
        if (f->image && !f->rec)
            f->rec = f->cur - 1;
    tag:
        do
        {
            while (json_end_val[c = *f->cur++] == 1);
            if (!c)
                REFILL(f, c, goto incomplete);
        } while (json_end_val[c] == 1);
        if (f->level <= f->maxlevel)
            f->part[f->level] = np;
        else
            np = ne + 1;
        f->level++;
        if (np < ne)
            *np++ = '.';
        if (!(q = c == '"') && np < ne)
            *np++ = c;
        for (;;)
        {
            while (!json_end_val[c = *f->cur++])
                if (np < ne)
                    *np++ = c;
            if (!c)
                REFILL(f, c, goto incomplete);
            if (c == '"')
            {
                q = !q;
                continue;
            }
            else if (c == '\\')
            {
                if (!(c = *f->cur++))
                    REFILL(f, c, goto incomplete);
            }
            else if (!q)
            {
                if (c == '}')
                {
                    if (!f->level)
                    {
                        record->data = f;
                        file->count = f->record;
                        return 1;
                    }
                    if (--f->level <= f->maxlevel)
                        np = f->part[f->level];
                    break;
                }
                else if (c == ':')
                {
                    do
                    {
                        while (json_end_val[c = *f->cur++] == 1);
                        if (!c)
                            REFILL(f, c, goto incomplete);
                    } while (json_end_val[c] == 1);
                    if (c == '{')
                    {
                        if (np <= ne)
                        {
                            *np = 0;
                            if (v = dtmatch(file->dss->cx->variables, f->part[f->prefix] + 1))
                            {
                                ((Value_t*)v->data)->record = f->record;
                                ((Value_t*)v->data)->offset = vp - vb;
                                if (vp >= ve)
                                    RESIZE();
                                *vp++ = '1';
                                ((Value_t*)v->data)->size = 1;
                                if (vp >= ve)
                                    RESIZE();
                                *vp++ = 0;
                            }
                        }
                        goto tag;
                    }
                    a = 0;
                    q = 0;
                    if (np < ne && f->level > f->prefix)
                    {
                        *np = 0;
                        if (v = dtmatch(file->dss->cx->variables, f->part[f->prefix] + 1))
                        {
                            ((Value_t*)v->data)->record = f->record;
                            ((Value_t*)v->data)->offset = vp - vb;
                            e = c == 'n';
                            for (;;)
                            {
                                if (c == '"')
                                {
                                    q = !q;
                                    goto ignore;
                                }
                                else if (c == '\\')
                                {
                                    if (!(c = *f->cur++))
                                        REFILL(f, c, goto incomplete);
                                    if (c != '\\' && c != '"' && c != ',' && c != '}')
                                    {
                                        if (vp >= ve)
                                            RESIZE();
                                        *vp++ = '\\';
                                    }
                                }
                                else if (!q)
                                {
                                    if (c == '[')
                                    {
                                        a++;
                                        goto ignore;
                                    }
                                    else if (c == ']')
                                    {
                                        if (a)
                                            a--;
                                        goto ignore;
                                    }
                                    else if (json_end_val[c] == 1)
                                        goto ignore;
                                    else if (a)
                                        /*array*/;
                                    else if (c == '}')
                                    {
                                        if (!f->level)
                                        {
                                            record->data = f;
                                            file->count = f->record;
                                            return 1;
                                        }
                                        if (--f->level <= f->maxlevel)
                                            np = f->part[f->level];
                                        break;
                                    }
                                    else if (c == ',')
                                        break;
                                }
                                if (vp >= ve)
                                    RESIZE();
                                *vp++ = c;
                            ignore:
                                while (!json_end_val[c = *f->cur++])
                                {
                                    if (vp >= ve)
                                        RESIZE();
                                    *vp++ = c;
                                }
                                if (!c)
                                    REFILL(f, c, goto incomplete);
                            }
                            if (e)
                                vp = vb + ((Value_t*)v->data)->offset;
                            ((Value_t*)v->data)->size = vp - (vb + ((Value_t*)v->data)->offset);
                            *vp++ = 0;
                            if (!f->level)
                            {
                                record->data = f;
                                file->count = f->record;
                                return 1;
                            }
                            if (--f->level <= f->maxlevel)
                                np = f->part[f->level];
                            if (c == ',')
                                goto tag;
                            goto beg;
                        }
                    }
                    n = 1;
                    for (;;)
                    {
                        if (c == '"')
                            q = !q;
                        else if (c == '\\')
                        {
                            if (!(c = *f->cur++))
                                REFILL(f, c, goto incomplete);
                        }
                        else if (!q)
                        {
                            if (c == '[')
                                a++;
                            else if (c == ']')
                            {
                                if (a)
                                    a--;
                            }
                            else if (a)
                                /*array*/;
                            else if (c == '{')
                                n++;
                            else if (c == '}' && !--n)
                            {
                                if (!f->level)
                                {
                                    record->data = f;
                                    file->count = f->record;
                                    return 1;
                                }
                                if (--f->level <= f->maxlevel)
                                    np = f->part[f->level];
                                break;
                            }
                            else if (c == ',' && n == 1)
                                break;
                        }
                        while (!json_end_val[c = *f->cur++]);
                        if (!c)
                            REFILL(f, c, goto done);
                    }
                    if (!f->level)
                    {
                        record->data = f;
                        file->count = f->record;
                        return 1;
                    }
                    if (--f->level <= f->maxlevel)
                        np = f->part[f->level];
                    if (c == ',')
                        goto tag;
                    goto beg;
                }
                else if (json_end_val[c] == 1)
                    continue;
            }
            if (np < ne)
                *np++ = c;
        }
    }
 done:
    if (!f->level)
        return 0;
 incomplete:
    if (disc->errorf)
        (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "%s: record %I*u incomplete", file->path, sizeof(f->record), f->record);
    return -1;
}

/*
 * xml writef -- output current record
 */

static int
jsonwrite(Dssfile_t* file, Dssrecord_t* record, Dssdisc_t* disc)
{
    register File_t*    r = (File_t*)record->data;
    size_t          n;

    if (r->prvlen && sfwrite(file->io, r->prv, r->prvlen) != r->prvlen)
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "%s: write error", file->path);
        return -1;
    }
    if ((n = r->cur - r->rec) && sfwrite(file->io, r->rec, n) != n)
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "%s: write error", file->path);
        return -1;
    }
    sfputc(file->io, '\n');
    return 0;
}

static Dssformat_t json_format =
{
    "json",
    "json format (2010-05-19)",
    CXH,
    jsonident,
    xmlfopen,
    jsonread,
    jsonwrite,
    0,
    xmlfclose,
    0,
    0,
    0
};

static int
op_get(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    File_t*     f = (File_t*)DSSDATA(data);
    Value_t*    v = (Value_t*)pc->data.variable->data;
    char*       s;

    if (v)
    {
        if (v->record == f->record)
            s = f->value + v->offset;
        else
        {
            s = (char*)null;
            v->size = 0;
        }
        if (!v->internalf)
        {
            r->value.string.data = s;
            r->value.string.size = v->size;
        }
        else if ((*v->internalf)(cx, pc->data.variable->type, NiL, &pc->data.variable->format, r, s, v->size, cx->rm, disc) < 0)
            return -1;
    }
    return 0;
}

static int
op_ref(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    return (r->value.variable = xmlvar(cx, b->value.string.data, "string", disc)) ? 0 : -1;
}

static Cxcallout_t local_callouts[] =
{
CXC(CX_GET, "void", "void", op_get, 0)
CXC(CX_REF, "string", "void", op_ref, 0)
};

static int
xml_field_name_dat(Tag_t* tag, Tagframe_t* fp, const char* data, Tagdisc_t* disc)
{
    register Xml_t*     xml = (Xml_t*)disc;

    if (!(xml->lastfield->name = strdup(data)))
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
        return -1;
    }
    return 0;
}

static int
xml_field_type_dat(Tag_t* tag, Tagframe_t* fp, const char* data, Tagdisc_t* disc)
{
    register Xml_t*     xml = (Xml_t*)disc;
    char*           s;

    memset(&xml->lastfield->format, 0, sizeof(xml->lastfield->format));
    (void)cxattr(NiL, data, &s, &xml->lastfield->format, NiL);
    if (!*s)
        s = "number";
    if (!(xml->lastfield->type = strdup(s)))
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
        return -1;
    }
    if (xml->lastfield->format.flags & CX_FLOAT)
        xml->lastfield->format.flags &= ~(CX_STRING|CX_BUFFER|CX_UNSIGNED|CX_INTEGER);
    else if (xml->lastfield->format.flags & CX_UNSIGNED)
    {
        xml->lastfield->format.flags &= ~(CX_STRING|CX_BUFFER);
        xml->lastfield->format.flags |= CX_UNSIGNED|CX_INTEGER;
    }
    else if (!(xml->lastfield->format.flags & (CX_STRING|CX_BUFFER|CX_INTEGER)))
    {
        if (streq(s, "string"))
            xml->lastfield->format.flags |= CX_STRING;
        else if (streq(s, "buffer"))
            xml->lastfield->format.flags |= CX_BUFFER;
    }
    return 0;
}

static Tags_t   tags_xml_field[] =
{
    "NAME",     "Field name.",
            0,0,xml_field_name_dat,0,
    "TYPE",     "Field type. The intrinsic types are number and"
            " string. Other types are defined in optional"
            " method and schema libraries.",
            0,0,xml_field_type_dat,0,
    0
};

static int
xml_name_dat(Tag_t* tag, Tagframe_t* fp, const char* data, Tagdisc_t* disc)
{
    register Xml_t* xml = (Xml_t*)disc;

    if (!(xml->meth.name = strdup(data)))
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
        return -1;
    }
    return 0;
}

static int
xml_description_dat(Tag_t* tag, Tagframe_t* fp, const char* data, Tagdisc_t* disc)
{
    register Xml_t* xml = (Xml_t*)disc;

    if (!(xml->meth.description = strdup(data)))
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
        return -1;
    }
    return 0;
}

static int
xml_library_dat(Tag_t* tag, Tagframe_t* fp, const char* data, Tagdisc_t* disc)
{
    register Xml_t*     xml = (Xml_t*)disc;
    register Library_t* p;

    if (!(p = newof(0, Library_t, 1, strlen(data))))
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
        return -1;
    }
    strcpy(p->name, data);
    if (!xml->lastlibrary)
        xml->libraries = xml->lastlibrary = p;
    else
        xml->lastlibrary = xml->lastlibrary->next = p;
    return 0;
}

static Tags_t*
xml_field_beg(Tag_t* tag, Tagframe_t* fp, const char* name, Tagdisc_t* disc)
{
    register Xml_t*     xml = (Xml_t*)disc;
    Field_t*        f;

    if (name)
    {
        if (!(f = newof(0, Field_t, 1, 0)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
            return 0;
        }
        if (!xml->lastfield)
            xml->fields = f;
        else
            xml->lastfield->next = f;
        xml->lastfield = f;
    }
    return &tags_xml_field[0];
}

static int
xml_field_end(Tag_t* tag, Tagframe_t* fp, Tagdisc_t* disc)
{
    register Xml_t*     xml = (Xml_t*)disc;

    if (xml->lastfield && (!xml->lastfield->name || !xml->lastfield->type))
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, 2, "field name and type must be specified");
        return -1;
    }
    return 0;
}

static Tags_t   tags_xml[] =
{
    "NAME",     "Schema name.",
            0,0,xml_name_dat,0,
    "DESCRIPTION",  "Schema description.",
            0,0,xml_description_dat,0,
    "LIBRARY",  "Required type/map library name;"
            " more than one library may be specified.",
            0,0,xml_library_dat,0,
    "FIELD",    "Field info.",
            0,xml_field_beg,0,xml_field_end,
    0
};

static Tags_t*
xml_beg(Tag_t* tag, Tagframe_t* fp, const char* name, Tagdisc_t* disc)
{
    return &tags_xml[0];
}

static Tags_t   tags[] =
{
    "METHOD",   "Method name; must be xml.",
            0,0,0,0,
    "XML",      "xml method schema.",
            0,xml_beg,0,0,
    0
};

/*
 * methf
 */

static Dssmeth_t*
xmlmeth(const char* name, const char* options, const char* schema, Dssdisc_t* disc, Dssmeth_t* meth)
{
    register Xml_t*     xml;
    Tag_t*          tag;
    Sfio_t*         sp;
    Library_t*      p;
    char*           s;
    char            path[PATH_MAX];

    if (!(xml = newof(0, Xml_t, 1, 0)))
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
        return 0;
    }
    xml->basemeth = meth;
    xml->meth = *meth;
    meth = &xml->meth;
    meth->data = xml;
    taginit(&xml->dsstagdisc.tagdisc, disc->errorf);
    xml->dsstagdisc.tagdisc.id = DSS_ID;
    xml->dsstagdisc.disc = disc;
    xml->dsstagdisc.meth = meth;
    sp = 0;
    if (options)
    {
        if (!(sp = sfstropen()))
            goto drop;
        sfprintf(sp, "%s", usage);
        if (tagusage(tags, sp, &xml->dsstagdisc.tagdisc))
            goto drop;
        sfprintf(sp, "}\n");
        if (dssoptlib(meth->cx->buf, &dss_lib_xml, sfstruse(sp), disc))
            goto drop;
        sfclose(sp);
        sp = 0;
        s = sfstruse(meth->cx->buf);
        for (;;)
        {
            switch (optstr(options, s))
            {
            case 'T':
                xml->test = opt_info.num;
                continue;
            case '?':
                if (disc->errorf)
                    (*disc->errorf)(NiL, disc, ERROR_USAGE|4, "%s", opt_info.arg);
                goto drop;
            case ':':
                if (disc->errorf)
                    (*disc->errorf)(NiL, disc, 2, "%s", opt_info.arg);
                goto drop;
            }
            break;
        }
    }
    if (schema && *schema)
    {
        if (!(sp = dssfind(schema, NiL, DSS_VERBOSE, path, sizeof(path), disc)))
            return 0;
        if (!(tag = tagopen(sp, path, 1, &tags[0], &xml->dsstagdisc.tagdisc)) || tagclose(tag))
            goto drop;
        sfclose(sp);
        sp = 0;
    }
    dtinsert(meth->formats, &xml_format);
    dtinsert(meth->formats, &json_format);
    for (p = xml->libraries; p; p = p->next)
        if (!dssload(p->name, disc))
            return 0;
    return meth;
 drop:
    free(xml);
    if (sp)
        sfclose(sp);
    return 0;
}

/*
 * openf
 */

static int
xmlopen(Dss_t* dss, Dssdisc_t* disc)
{
    Xml_t*      xml = (Xml_t*)dss->meth->data;
    Field_t*    f;
    Field_t*    g;
    Cxvariable_t*   v;
    int     i;

    if (xml)
    {
        dss->cx->ctype['.'] |= CX_CTYPE_ALPHA;
        for (i = 0; i < elementsof(local_callouts); i++)
            if (cxaddcallout(dss->cx, &local_callouts[i], disc))
                return -1;

        xml_beg_tag[0] = 1;
        xml_beg_tag['<'] = 1;

        xml_end_tag[0] = 1;
        xml_end_tag['>'] = 1;
        xml_end_tag[' '] = 1;

        xml_end_att[0] = 1;
        xml_end_att['"'] = 1;
        xml_end_att['>'] = 1;

        json_beg_tag[0] = 2;
        json_beg_tag[','] = 2;
        json_beg_tag['{'] = 2;
        json_beg_tag['}'] = 2;

        json_end_val[0] = 2;
        json_end_val['\\'] = 2;
        json_end_val['"'] = 2;
        json_end_val[':'] = 2;
        json_end_val[','] = 2;
        json_end_val['{'] = 2;
        json_end_val['}'] = 2;
        json_end_val['['] = 2;
        json_end_val[']'] = 2;
        json_end_val[' '] = 1;
        json_end_val['\n'] = 1;
        json_end_val['\r'] = 1;
        json_end_val['\t'] = 1;
        json_end_val['\v'] = 1;

        xml->prefix = -1;
        for (f = xml->fields; f; f = g)
        {
            g = f->next;
            if (!(v = xmlvar(dss->cx, f->name, f->type, disc)))
                return -1;
            v->format = f->format;
            free(f->name);
            free(f->type);
            free(f);
        }
    }
    return 0;
}

static Dssmeth_t method =
{
    "xml",
    "xml and json method",
    CXH,
    xmlmeth,
    xmlopen,
    0,
    0
};

Dsslib_t dss_lib_xml =
{
    "xml",
    "xml method"
    "[-1ls5Pp0?\n@(#)$Id: dss xml method (AT&T Research) 2010-04-22 $\n]"
    USAGE_LICENSE,
    CXH,
    0,
    &method,
};