cmd/jcl/cpy2dss.c

/***********************************************************************
*                                                                      *
*               This software is part of the ast package               *
*          Copyright (c) 2003-2011 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

/*
 * convert copybook to dss flat schema
 */

static const char usage[] =
"[-?\n@(#)$Id: cpy2dss (AT&T Research) 2007-02-20 $\n]"
USAGE_LICENSE
"[+NAME?cpy2dss - convert copybook to dss flat schema]"
"[+DESCRIPTION?\bcpy2dss\b converts each copybook \afile\a operand to a"
"   \bdss\b flat schema file on the standard output. If no \afile\a"
"   operands are specified then the standard input is read.]"
"[+?Duplicate structure and field names are disambiguated by appending"
"   \b_\b\acount\a to the names, where \acount\a > 1. \bRENAMES\b"
"   and level 88 fields are ignored.]"
"[b:bytemask?Output a single line where each character represents the"
"   type of the corresponding byte in the physical representation of"
"   a copybook record, where \b0\b means \bPIC\b and \an\a means"
"   \bCOMP-\b\an\a.]"
"[c:codeset?Set the \bstring\b codeset name.]:[codeset:=ebcdic-m]"
"[C:comp?Convert COMP-\afrom\a to COMP-\ato\a.]:[from::to]"
"[d:delimiter?Set the \b--text\b field delimiter character. XML"
"   &\aname\a; and #\adecimal\a; forms are accepted.]:[delimiter:=|]"
"[D:terminator?Set the \b--text\b record terminator character. XML"
"   &\aname\a; and #\adecimal\a; forms are"
"   accepted.]:[terminator:=&newline;]"
"[e:escape?Set the \b--text\b field escape character. XML"
"   &\aname\a; and #\adecimal\a; forms are accepted.]:[delimiter:=\boff\b]"
"[k:keep?Keep original names. Otherwise non-identifier characters are"
"   converted to \b_\b.]"
"[l:little-endian|le?Little-endian binary integer encoding.]"
"[o:offsets?Output the name, offset, size, number of elements and type"
"   of each member, one per line, on the standard output. Scalar"
"   fields have 0 elements.]"
"[q:quote?Set the \b--text\b field quote begin character. If"
"   \b--end-quote\b is not specified then it is the same as"
"   \b--quote\b. XML &\aname\a; and #\adecimal\a; forms are"
"   accepted.]:[quote:=\"]"
"[Q:end-quote?Set the \b--text\b field quote end character. If"
"   \b--quote\b is not specified then it is the same as"
"   \b--end-quote\b. XML &\aname\a; and #\adecimal\a; forms are"
"   accepted.]:[quote:=\"]"
"[r:reclen|record-length?Sets the physical record format to be fixed"
"   with a record length of \areclen\a bytes.]#[reclen]"
"[s!:sized-struct?Check for embedded size/data structures.]"
"[t:text?Generate a field-delimited newline-terminated text schema"
"   using the local codeset.]"
"[T:regress?Massage output for regression testing.]"
"[v:variable?If \b--notext\b is on then records are variable length,"
"   delimited by the \b--terminator\b character. If \b--text\b is"
"   on then the size field \b--sized\b structures is omitted from"
"   the output.]"
"\n"
"\n[ file ... ]\n"
"\n"
;

#include <ast.h>
#include <ctype.h>
#include <ccode.h>
#include <dt.h>
#include <ls.h>
#include <tm.h>
#include <error.h>

#define CPY_VERSION 20030220L

#define cpyinit(d,e)    (memset(d,0,sizeof(Cpydisc_t)),(d)->version=CPY_VERSION,(d)->errorf=(Error_f)(e))

#define CPY_binary  (1<<0)
#define CPY_number  (1<<1)
#define CPY_pointer (1<<2)
#define CPY_signed  (1<<3)
#define CPY_string  (1<<4)
#define CPY_sync    (1<<5)

#define CPY_XML     0
#define CPY_BYTEMASK    1
#define CPY_OFFSETS 2

#define CPY_ALIGN(w)    (((w)<=2)?2:4)

struct Cpyfield_s; typedef struct Cpyfield_s Cpyfield_t;

struct Cpyfield_s
{
    Dtlink_t    link;
    Cpyfield_t* parent;
    Cpyfield_t* members;
    Cpyfield_t* next;
    Cpyfield_t* sized;
    Cpyfield_t* redefines;
    char*       dimension;
    unsigned long   offset;
    int     comp;
    int     dup;
    int     level;
    int     fixedpoint;
    int     mindimension;
    int     maxdimension;
    int     structure;
    int     width;
    int     total;
    unsigned int    flags;
    char        name[8];
};

typedef struct Cpydisc_s
{
    uint32_t    version;
    Error_f     errorf;
} Cpydisc_t;

typedef struct Cpy_s
{
    const char* id;
    Cpydisc_t*  disc;
    Cpyfield_t* first;
    Cpyfield_t* last;
    Sfio_t*     ip;
    char*       cp;
    char*       ofile;
    int     item;
    int     oline;
    int     size;
    Vmalloc_t*  vm;
    Dt_t*       dt;
} Cpy_t;

static struct State_s
{
    char*       codeset;
    char*       delimiter;
    char*       endian;
    char*       escape;
    char*       quotebegin;
    char*       quoteend;
    char*       terminator;

    size_t      fixed;

    int     keep;
    int     output;
    int     regress;
    int     sized;
    int     text;
    int     variable;

    int     comp[10];
} state;

static char     empty[] = "\n";

Cpy_t*
cpyopen(const char* path, Sfio_t* ip, Cpydisc_t* disc)
{
    register Cpy_t* cpy;
    Vmalloc_t*  vm;

    static Dtdisc_t dictdisc;

    dictdisc.key = offsetof(Cpyfield_t, name);
    dictdisc.size = 0;
    dictdisc.link = offsetof(Cpyfield_t, link);
    if (!(vm = vmopen(Vmdcheap, Vmlast, 0)) || !(cpy = vmnewof(vm, 0, Cpy_t, 1, 0)) || !(cpy->dt = dtnew(vm, &dictdisc, Dtset)))
    {
        if (vm)
            vmclose(vm);
        if (disc->errorf)
            (*disc->errorf)(cpy, disc, ERROR_SYSTEM|2, "out of space");
        return 0;
    }
    cpy->id = "cpy";
    cpy->vm = vm;
    cpy->disc = disc;
    cpy->ip = ip;
    cpy->cp = empty;
    cpy->ofile = error_info.file;
    error_info.file = (char*)path;
    cpy->oline = error_info.line;
    error_info.line = 0;
    return cpy;
}

int
cpyclose(Cpy_t* cpy)
{
    error_info.file = cpy->ofile;
    error_info.line = cpy->oline;
    vmclose(cpy->vm);
    return 0;
}

char*
cpylex(register Cpy_t* cpy)
{
    register char*  s;
    register int    q;

    if (cpy->item)
    {
        cpy->item = 0;
        cpy->size = 0;
        return "";
    }
    for (;;)
    {
        switch (*cpy->cp)
        {
        case '*':
        case '\n':
            do
            {
                if (!(cpy->cp = sfgetr(cpy->ip, '\n', 0)))
                {
                    cpy->cp = empty;
                    return 0;
                }
                error_info.line++;
            } while ((q = sfvalue(cpy->ip)) < 7);
            if (q > 72)
                cpy->cp[72] = '\n';
            cpy->cp += 6;
            continue;
        case ' ':
        case '\t':
        case '\r':
            cpy->cp++;
            continue;
        }
        break;
    }
    s = cpy->cp;
    q = 0;
    for (;;)
    {
        switch (*cpy->cp++)
        {
        case '\n':
            *(cpy->cp - 1) = 0;
            cpy->size = cpy->cp - s - 1;
            cpy->cp = empty;
            return s;
        case ' ':
        case '\t':
        case '\r':
            if (!q)
                break;
            continue;
        case '\'':
            q = !q;
            continue;
        case '.':
            if (!q)
            {
                if (cpy->cp > s + 1)
                {
                    if (isdigit(*cpy->cp) && (isdigit(*(cpy->cp - 2)) || *(cpy->cp - 2) == ')'))
                        continue;
                    cpy->item = 1;
                }
                *cpy->cp = '\n';
                break;
            }
            continue;
        case '-':
            if ((cpy->cp - 1) == s && isdigit(*cpy->cp))
                continue;
            /*FALLTHROUGH*/
        case ':':
        case '&':
            if (!q && !state.keep)
                *(cpy->cp - 1) = '_';
            continue;
        default:
            continue;
        }
        break;
    }
    *(cpy->cp - 1) = 0;
    cpy->size = cpy->cp - s - 1;
    return s;
}

Cpyfield_t*
cpyfield(register Cpy_t* cpy)
{
    register char*      s;
    register Cpyfield_t*    f;
    Cpyfield_t*     p;
    size_t          n;
    char*           e;
    int         fixedpoint;
    int         level;
    int         width;

    do
    {
        if (!(s = cpylex(cpy)))
            return 0;
    } while (!strncasecmp(s, "SKIP", 4));
    level = (int)strtol(s, &e, 10);
    if (*e)
    {
        if (cpy->disc->errorf)
            (*cpy->disc->errorf)(cpy, cpy->disc, 2, "%s: syntax error: level number expected", s);
        return 0;
    }
    if (!(s = cpylex(cpy)) || !*s)
        return 0;
    if (!(f = vmnewof(cpy->vm, 0, Cpyfield_t, 1, cpy->size)))
    {
        if (cpy->disc->errorf)
            (*cpy->disc->errorf)(cpy, cpy->disc, ERROR_SYSTEM|2, "out of space");
        return 0;
    }
    if (cpy->first)
        cpy->last->next = f;
    else
        cpy->first = f;
    cpy->last = f;
    f->level = level;
    e = s;
    while ((p = (Cpyfield_t*)dtmatch(cpy->dt, e)) && p->dup)
    {
        p->dup++;
        e = sfprints("%s_%d", s, p->dup);
    }
    strcpy(f->name, e);
    if (!p)
        dtinsert(cpy->dt, f);
    f->dup = 1;
    f->structure = 1;
    while ((s = cpylex(cpy)) && *s)
    {
    again:
        if (!strcasecmp(s, "BINARY"))
        {
            f->structure = 0;
            f->flags |= CPY_binary;
        }
        else if (!strncasecmp(s, "COMP", 4))
        {
            f->structure = 0;
            s += !strncasecmp(s, "COMPUTATIONAL", 13) ? 13 : 4;
            if (*s++ != '_')
                f->comp = 1;
            else
            {
                f->comp = (int)strtol(s, &e, 10);
                if (*e || f->comp <= 0 || f->comp > 9)
                {
                    if (cpy->disc->errorf)
                        (*cpy->disc->errorf)(cpy, cpy->disc, 2, "%s: syntax error: COMP number in range 1..9 expected", s);
                    continue;
                }
            }
            f->comp = state.comp[f->comp];
        }
        else if (!strcasecmp(s, "DEPENDING"))
        {
            if (!(s = cpylex(cpy)) || !*s)
                break;
            if (strcasecmp(s, "ON"))
            {
                if (cpy->disc->errorf)
                    (*cpy->disc->errorf)(cpy, cpy->disc, 2, "%s: syntax error: ON expected", s);
                continue;
            }
            if (!(s = cpylex(cpy)) || !*s)
                break;
            if (!(p = (Cpyfield_t*)dtmatch(cpy->dt, s)))
            {
                if (!(p = vmnewof(cpy->vm, 0, Cpyfield_t, 1, cpy->size)))
                {
                    if (cpy->disc->errorf)
                        (*cpy->disc->errorf)(cpy, cpy->disc, ERROR_SYSTEM|2, "out of space");
                    return 0;
                }
                dtinsert(cpy->dt, p);
            }
            else if (p->dup > 1)
            {
                s = sfprints("%s_%d", p->name, p->dup);
                if (!(p = (Cpyfield_t*)dtmatch(cpy->dt, s)))
                {
                    if (cpy->disc->errorf)
                        (*cpy->disc->errorf)(cpy, cpy->disc, 2, "%s: internal error: dup not found", s);
                    return 0;
                }
            }
            f->dimension = p->name;
        }
        else if (!strcasecmp(s, "INDEXED"))
        {
            if (!(s = cpylex(cpy)) || !*s)
                break;
            if (strcasecmp(s, "BY"))
            {
                if (cpy->disc->errorf)
                    (*cpy->disc->errorf)(cpy, cpy->disc, 2, "%s: syntax error: BY expected", s);
                continue;
            }
            if (!(s = cpylex(cpy)) || !*s)
                break;
        }
        else if (!strcasecmp(s, "IS"))
            /*ignore*/;
        else if (!strcasecmp(s, "OCCURS"))
        {
            if (!(s = cpylex(cpy)) || !*s)
                break;
            f->mindimension = (int)strtol(s, &e, 10);
            if (*e)
            {
                if (cpy->disc->errorf)
                    (*cpy->disc->errorf)(cpy, cpy->disc, 2, "%s: syntax error: minimum OCCURS number expected", s);
                continue;
            }
            if (!(s = cpylex(cpy)) || !*s)
                break;
            if (!strcasecmp(s, "TO"))
            {
                if (!(s = cpylex(cpy)) || !*s)
                    break;
                f->maxdimension = (int)strtol(s, &e, 10);
                if (*e)
                {
                    if (cpy->disc->errorf)
                        (*cpy->disc->errorf)(cpy, cpy->disc, 2, "%s: syntax error: maximum OCCURS number expected", s);
                    continue;
                }
                if (!(s = cpylex(cpy)) || !*s)
                    break;
            }
            else
                f->maxdimension = f->mindimension;
            if (strcasecmp(s, "TIMES"))
                goto again;
        }
        else if (!strncasecmp(s, "PACKED", 6))
        {
            f->structure = 0;
            f->comp = 3;
        }
        else if (!strncasecmp(s, "PIC", 3))
        {
            f->structure = 0;
            if (!(s = cpylex(cpy)) || !*s)
                break;
            fixedpoint = width = 0;
            for (;;)
            {
                switch (*s++)
                {
                case 0:
                    break;
                case 'S':
                case 's':
                case '-':
                    f->flags |= CPY_signed;
                    continue;
                case 'V':
                case 'v':
                case '.':
                    fixedpoint = 1;
                    continue;
                case '9':
                    f->flags |= CPY_number;
                    width++;
                    continue;
                case 'X':
                case 'x':
                    f->flags |= CPY_string;
                    width++;
                    continue;
                case '(':
                    width = 0;
                    n = (int)strtol(s, &e, 10);
                    if (*e == ')')
                        e++;
                    s = e;
                    f->width += n;
                    if (fixedpoint)
                    {
                        fixedpoint = 0;
                        f->fixedpoint = n;
                    }
                    continue;
                default:
                    if (cpy->disc->errorf)
                        (*cpy->disc->errorf)(cpy, cpy->disc, 2, "%s: unknown PIC", s - 1);
                    break;
                }
                break;
            }
            if (width)
            {
                f->width += width;
                if (fixedpoint)
                    f->fixedpoint = width;
            }
        }
        else if (!strcasecmp(s, "POINTER"))
        {
            f->structure = 0;
            f->flags |= CPY_pointer;
            f->width = 4;
            s += 7;
            f->comp = state.comp[5];
        }
        else if (!strcasecmp(s, "REDEFINES"))
        {
            if (!(s = cpylex(cpy)) || !*s)
            {
                if (cpy->disc->errorf)
                    (*cpy->disc->errorf)(cpy, cpy->disc, 2, "redefined member name expected");
                return 0;
            }
            e = s;
            while ((p = (Cpyfield_t*)dtmatch(cpy->dt, e)) && p->dup > 1)
                e = sfprints("%s_%d", s, p->dup);
            if (!(f->redefines = p))
            {
                if (cpy->disc->errorf)
                    (*cpy->disc->errorf)(cpy, cpy->disc, 2, "%s: unknown member", s);
                return 0;
            }
        }
        else if (!strncasecmp(s, "SYNC", 4))
            f->flags |= CPY_sync;
        else if (!strcasecmp(s, "USAGE"))
            f->structure = 0;
        else if (!strncasecmp(s, "VALUE", 5))
        {
            f->structure = 0;
            while ((s = cpylex(cpy)) && *s);
            break;
        }
        else if (cpy->disc->errorf)
            (*cpy->disc->errorf)(cpy, cpy->disc, 1, "%s: unknown attribute", s);
    }
    return f;
}

static int
compwidth(Cpyfield_t* field, int width)
{
    switch (field->comp)
    {
    case 0:
        if (field->fixedpoint)
            width++;
        if (field->flags & CPY_signed)
            width++;
        break;
    case 1:
    case 5:
        if (width <= 2)
            width = 1;
        else if (width <= 4)
            width = 2;
        else if (width <= 9)
            width = 4;
        else
            width = 8;
        break;
    case 3:
        width = (width + 2) / 2;
        break;
    }
    return width;
}

static char*
typename(Cpyfield_t* field)
{
    char*   type;

    if (field->flags & CPY_pointer)
        type = "unsigned char*";
    else if (field->flags & CPY_binary)
        type = state.endian;
    else
        switch (field->comp)
        {
        case 1:
            type = "be_t";
            break;
        case 2:
            type = "ibm_t";
            break;
        case 3:
            type = "bcd_t";
            break;
        case 5:
            type = "le_t";
            break;
        default:
            type = 0;
            break;
        }
    return type;
}

#define INDENT(n)       (&indent[sizeof(indent)-(n)-1])

int
cpy2dss(const char* path, Sfio_t* ip, Sfio_t* op, Cpydisc_t* disc, time_t stamp)
{
    Cpy_t*      cpy;
    Cpyfield_t* field;
    Cpyfield_t* next;
    Cpyfield_t* parent;
    Cpyfield_t* member;
    char*       delimiter;
    char*       type;
    unsigned long   offset;
    long        n;
    int     c;
    int     i;
    int     j;
    int     lev;
    int     skip;
    int     structure;
    int     width;
    int     levels[256];
    char        indent[elementsof(levels) + 2];

    if (!(cpy = cpyopen(path, ip, disc)))
        return -1;
    memset(indent, ' ', sizeof(indent) - 1);
    indent[sizeof(indent) - 1] = 0;
    if (field = cpyfield(cpy))
    {
        parent = field;
        member = 0;
        offset = field->width;
        i = state.sized && !state.text && state.fixed;
        while (next = cpyfield(cpy))
            if (i)
            {
                width = next->width;
                if (next->flags & CPY_number)
                    width = compwidth(next, width);
                offset += width;
                if (!member && (i = strlen(parent->name)) && !memcmp(parent->name, next->name, i) && strmatch(next->name + i, "?(_)(siz|SIZ|LEN|len)*"))
                    member = next;
                parent = next;
            }
        if (i && offset > state.fixed)
        {
            if (!member || !(member = member->next))
                error(1, "accumulated field sizes %lu exceeds fixed record size %lu", offset, state.fixed);
            else
            {
                if ((n = member->width - (offset - state.fixed)) > 0)
                {
                    error(1, "%s: maximum variable field size shortened from %d to %ld to comply with fixed record size %u", member->name, member->width, n, state.fixed);
                    member->width = n;
                }
            }
        }
        levels[lev = 0] = 0;
        switch (state.output)
        {
        case CPY_OFFSETS:
            offset = 0;
            break;
        case CPY_XML:
            sfprintf(sfstdout, "<METHOD>flat</>\n");
            sfprintf(sfstdout, "<FLAT>\n");
            sfprintf(op, "%s<NAME>%s</>\n", INDENT(lev + 1), field->name);
            if (state.regress)
            {
                stamp = 0x42d9e64b;
                if (path && (delimiter = strrchr(path, '/')))
                    path = (const char*)delimiter + 1;
            }
            sfprintf(op, "%s<DESCRIPTION>converted by %s from copybook %s</>\n", INDENT(lev + 1), error_info.id, path ? path : "standard input");
            sfprintf(op, "%s<IDENT>@(#)$Id: %s (AT&T Research) %s $</>\n", INDENT(lev + 1), field->name, fmttime("%Y-%m-%d", stamp));
            sfprintf(sfstdout, "%s<LIBRARY>num_t</>\n", INDENT(lev + 1));
            if (state.fixed)
            {
                sfprintf(sfstdout, "%s<RECORD>\n", INDENT(lev + 1));
                sfprintf(sfstdout, "%s<FIXED>%I*u</>\n", INDENT(lev + 2), sizeof(state.fixed), state.fixed);
                sfprintf(sfstdout, "%s</>\n", INDENT(lev + 1));
            }
            if (state.text && (state.escape || state.quotebegin))
            {
                sfprintf(sfstdout, "%s<PHYSICAL>\n", INDENT(lev + 1));
                if (state.escape)
                    sfprintf(sfstdout, "%s<ESCAPE>%s</>\n", INDENT(lev + 2), state.escape);
                if (state.quotebegin)
                {
                    if (state.quoteend)
                    {
                        sfprintf(sfstdout, "%s<QUOTEBEGIN>%s</>\n", INDENT(lev + 2), state.quotebegin);
                        sfprintf(sfstdout, "%s<QUOTEEND>%s</>\n", INDENT(lev + 2), state.quoteend);
                    }
                    else
                        sfprintf(sfstdout, "%s<QUOTE>%s</>\n", INDENT(lev + 2), state.quotebegin);
                    sfprintf(sfstdout, "%s<QUOTEALL>1</>\n", INDENT(lev + 2));
                }
                sfprintf(sfstdout, "%s</>\n", INDENT(lev + 1));
            }
            break;
        }
        parent = 0;
        skip = 0;
        structure = 1;
        if (next = field->next)
            levels[++lev] = next->level;
        while (field = next)
        {
            delimiter = (next = field->next) ? state.delimiter : state.terminator;
            if (field->level == 88)
                continue;
            if (!structure)
            {
                if (state.output == CPY_XML && !skip)
                    sfprintf(op, "%s</>\n", INDENT(lev));
                for (i = lev; i > 0 && field->level != levels[i]; i--);
                if (i > 0)
                    while (lev > i)
                    {
                        lev--;
                        switch (state.output)
                        {
                        case CPY_OFFSETS:
                            parent->total = offset - parent->offset;
                            if (parent->maxdimension)
                            {
                                offset += parent->total * (parent->maxdimension - 1);
                                parent->total *= parent->maxdimension;
                            }
                            if (parent->redefines && parent->redefines->total > parent->total)
                            {
                                offset += parent->redefines->total - parent->total;
                                parent->total = parent->redefines->total;
                            }
                            break;
                        case CPY_XML:
                            sfprintf(op, "%s</>\n", INDENT(lev));
                            break;
                        }
                        parent = parent->parent;
                    }
            }
            skip = 0;
            field->parent = parent;
            if (structure = field->structure)
            {
                if (!next)
                {
                    if (disc->errorf)
                        (*disc->errorf)(cpy, disc, 2, "%s: empty struct", field->name);
                    cpyclose(cpy);
                    return -1;
                }
                parent = field;
                if ((lev + 1) >= elementsof(levels))
                {
                    if (disc->errorf)
                        (*disc->errorf)(cpy, disc, 2, "%s: nesting too deep", field->name);
                    cpyclose(cpy);
                    return -1;
                }
                levels[lev + 1] = next->level;
            }
            if (state.output == CPY_XML)
            {
                if (state.sized && state.text && state.variable && field->parent && (field->flags & CPY_number))
                {
                    i = strlen(field->parent->name);
                    if (!memcmp(field->parent->name, field->name, i) && strmatch(field->name + i, "?(_)(siz|SIZ|LEN|len)*"))
                    {
                        skip = 1;
                        continue;
                    }
                }
                sfprintf(op, "%s<FIELD>\n", INDENT(lev));
                sfprintf(op, "%s<NAME>%s</>\n", INDENT(lev + 1), field->name);
                if (field->redefines)
                {
                    sfprintf(op, "%s<UNION>%s</>\n", INDENT(lev + 1), field->redefines->name);
                    structure = 1;
                }
                if (field->dimension || field->maxdimension)
                {
                    sfprintf(op, "%s<ARRAY>\n", INDENT(lev + 1));
                    if (field->dimension)
                        sfprintf(op, "%s<SIZE>%s</>\n", INDENT(lev + 2), field->dimension);
                    if (field->maxdimension)
                        sfprintf(op, "%s<SIZE>%d</>\n", INDENT(lev + 2), field->maxdimension);
                    sfprintf(op, "%s</>\n", INDENT(lev + 1));
                }
                if (field->flags & CPY_string)
                {
                    sfprintf(op, "%s<TYPE>string</>\n", INDENT(lev + 1));
                    sfprintf(op, "%s<PHYSICAL>\n", INDENT(lev + 1));
                    sfprintf(op, "%s<CODESET>%s</>\n", INDENT(lev + 2), state.codeset);
                }
                else if (field->flags & (CPY_number|CPY_pointer))
                {
                    sfprintf(op, "%s<TYPE>", INDENT(lev + 1));
                    if (!(field->flags & CPY_signed))
                        sfprintf(op, "unsigned ");
                    sfprintf(op, "number</>\n");
                    sfprintf(op, "%s<PHYSICAL>\n", INDENT(lev + 1));
                    if (state.text)
                        sfprintf(op, "%s<CODESET>%s</>\n", INDENT(lev + 2), state.codeset);
                    else if (field->flags & CPY_binary)
                        sfprintf(op, "%s<TYPE>%s</>\n", INDENT(lev + 2), state.endian);
                    else
                    {
                        field->width = compwidth(field, field->width);
                        if (type = typename(field))
                            sfprintf(op, "%s<TYPE>%s</>\n", INDENT(lev + 2), type);
                        else
                        {
                            sfprintf(op, "%s<CODESET>%s</>\n", INDENT(lev + 2), state.codeset);
                            sfprintf(op, "%s<FILL>0</>\n", INDENT(lev + 2));
                        }
                    }
                    if (field->fixedpoint)
                        sfprintf(op, "%s<FIXEDPOINT>%d</>\n", INDENT(lev + 2), field->fixedpoint);
                    if (field->flags & CPY_sync)
                        sfprintf(op, "%s<ALIGN>%d</>\n", INDENT(lev + 2), CPY_ALIGN(field->width));
                }
                if (field->flags & (CPY_string|CPY_number|CPY_pointer))
                {
                    if (!state.text)
                        sfprintf(op, "%s<WIDTH>%d</>\n", INDENT(lev + 2), field->width);
                    if (state.sized && field->parent)
                    {
                        if (field->flags & CPY_number)
                        {
                            i = strlen(field->parent->name);
                            if (!memcmp(field->parent->name, field->name, i) && strmatch(field->name + i, "?(_)(siz|SIZ|LEN|len)*"))
                                field->parent->sized = field;
                        }
                        else if (field->parent->sized)
                        {
                            sfprintf(op, "%s<WIDTH>%s</>\n", INDENT(lev + 2), field->parent->sized->name);
                            field->parent->sized = 0;
                        }
                    }
                    if (state.text || state.variable && delimiter == state.terminator)
                        sfprintf(op, "%s<DELIMITER>%s</>\n", INDENT(lev + 2), delimiter);
                    sfprintf(op, "%s</>\n", INDENT(lev + 1));
                }
            }
            else
            {
                if (field->redefines)
                    offset = field->redefines->offset;
                c = '0';
                if (field->flags & CPY_number)
                {
                    c += field->comp;
                    field->width = compwidth(field, field->width);
                }
                width = field->width;
                if (field->flags & CPY_sync)
                {
                    i = CPY_ALIGN(width);
                    if (j = offset & (i - 1))
                        offset += i - j;
                }
                if (field->maxdimension)
                    width *= field->maxdimension;
                if (state.output == CPY_BYTEMASK)
                    for (i = 0; i < width; i++)
                        sfputc(op, c);
                else
                {
                    field->offset = offset;
                    offset += width;
                    if (field->structure)
                    {
                        type = "struct";
                        for (member = field->next; member && member->level > field->level; member = member->next)
                            width += member->width * (member->maxdimension ? member->maxdimension : 1);
                        if (field->maxdimension)
                            width *= field->maxdimension;
                    }
                    else if (field->flags & CPY_pointer)
                        type = "pointer";
                    else if (field->flags & CPY_string)
                        type = "string";
                    else if (field->flags & CPY_number)
                    {
                        if (state.text || !(type = typename(field)))
                            type = (field->flags & CPY_signed) ? "number" : "unsigned";
                    }
                    sfprintf(sfstdout, "%s\t%lu\t%u", field->name, field->offset, width);
                    if (field->dimension)
                        sfprintf(sfstdout, "\t%s", field->dimension);
                    else
                        sfprintf(sfstdout, "\t%d", field->maxdimension);
                    sfprintf(sfstdout, "\t%s\n", type);
                }
            }
            lev += structure;
        }
        switch (state.output)
        {
        case CPY_OFFSETS:
            while (levels[lev] > 0 && parent)
            {
                lev--;
                parent->total = offset - parent->offset;
                if (parent->maxdimension)
                {
                    offset += parent->total * (parent->maxdimension - 1);
                    parent->total *= parent->maxdimension;
                }
                if (parent->redefines && parent->redefines->total > parent->total)
                {
                    offset += parent->redefines->total - parent->total;
                    parent->total = parent->redefines->total;
                }
                parent = parent->parent;
            }
            sfprintf(sfstdout, "%s\t%lu\t%u\t%u\tstruct\n", ".", offset, 0, 0);
            break;
        case CPY_XML:
            while (levels[lev] > 0)
            {
                sfprintf(op, "%s</>\n", INDENT(lev));
                lev--;
            }
            sfprintf(op, "</>\n");
            break;
        }
    }
    if (state.output == CPY_BYTEMASK)
        sfputc(op, '\n');
    lev = sfsync(op);
    if (cpyclose(cpy))
        lev = -1;
    return lev;
}

int
main(int argc, char** argv)
{
    char*       file;
    Sfio_t*     ip;
    char*       e;
    int     i;
    int     j;
    Cpydisc_t   disc;
    struct stat st;

    error_info.id = "cpy2dss";
    state.codeset = "ebcdic-m";
    state.delimiter = "|";
    state.endian = "be_t";
    state.output = CPY_XML;
    state.quotebegin = "\"";
    state.sized = 1;
    state.terminator = "&newline;";
    for (i = 0; i < elementsof(state.comp); i++)
        state.comp[i] = i;
    cpyinit(&disc, errorf);
    for (;;)
    {
        switch (optget(argv, usage))
        {
        case 'b':
            state.output = CPY_BYTEMASK;
            continue;
        case 'c':
            state.codeset = opt_info.arg;
            continue;
        case 'C':
            i = strtol(opt_info.arg, &e, 0);
            j = *e ? strtol(e + 1, &e, 0) : 0;
            if (i <= 0 || i > 9 || j <= 0 || j > 9 || *e)
                error(2, "%s: COMP from:to expected in range 1..9", opt_info.arg);
            state.comp[i] = j;
            continue;
        case 'd':
            state.delimiter = opt_info.arg;
            continue;
        case 'D':
            state.terminator = opt_info.arg;
            continue;
        case 'e':
            state.escape = opt_info.arg;
            continue;
        case 'k':
            state.keep = opt_info.num;
            continue;
        case 'l':
            state.endian = "le_t";
            continue;
        case 'o':
            state.output = CPY_OFFSETS;
            continue;
        case 'r':
            state.fixed = opt_info.num;
            continue;
        case 's':
            state.sized = opt_info.num;
            continue;
        case 't':
            state.text = 1;
            state.codeset = ccmapname(CC_NATIVE);
            continue;
        case 'T':
            state.regress = opt_info.num;
            continue;
        case 'v':
            state.variable = opt_info.num;
            continue;
        case '?':
            error(ERROR_USAGE|4, "%s", opt_info.arg);
            break;
        case ':':
            error(2, "%s", opt_info.arg);
            break;
        }
        break;
    }
    argv += opt_info.index;
    if (error_info.errors)
        error(ERROR_USAGE|4, "%s", optusage(NiL));
    if (!state.quotebegin)
        state.quotebegin = state.quoteend;
    else if (!state.quoteend)
        state.quoteend = state.quotebegin;
    if (state.quotebegin && state.quoteend && streq(state.quotebegin, state.quoteend))
        state.quoteend = 0;
    if (!*argv)
        cpy2dss(NiL, sfstdin, sfstdout, &disc, time(NiL));
    else
        while (file = *argv++)
        {
            if (!stat(file, &st) && (ip = sfopen(NiL, file, "r")))
            {
                cpy2dss(file, ip, sfstdout, &disc, st.st_mtime);
                sfclose(ip);
            }
            else
                error(ERROR_SYSTEM|2, "%s: cannot read", file);
        }
    return error_info.errors != 0;
}