lib/libdss/cxopen.c

/***********************************************************************
*                                                                      *
*               This software is part of the ast package               *
*          Copyright (c) 2002-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
/*
 * C expression library open/close and global initialization
 *
 * Glenn Fowler
 * AT&T Research
 */

#include "cxlib.h"

#include <ccode.h>

typedef struct Type_s
{
    Cxtype_t**  state;
    Cxtype_t    type;
} Type_t;

static Cxstate_t    state;
static Cxtable_t    table;

static const char   name_buffer[] = "buffer";
static const char   name_number[] = "number";
static const char   name_pointer[] = "pointer";
static const char   name_reference[] = "reference";
static const char   name_string[] = "string";
static const char   name_type[] = "type_t";
static const char   name_void[] = "void";

static void*
match_string_comp(Cx_t* cx, Cxtype_t* st, Cxtype_t* pt, Cxvalue_t* pv, Cxdisc_t* disc)
{
    regex_t*    re;

    if (!cxisstring(pt))
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, 2, "%s: match requires %s pattern", st->name, st->name);
        return 0;
    }
    if (!(re = newof(0, regex_t, 1, 0)))
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
        return 0;
    }
    re->re_disc = &cx->redisc;
    if (regcomp(re, pv->string.data, REG_AUGMENTED|REG_DISCIPLINE))
    {
        free(re);
        return 0;
    }
    return re;
}

static int
match_string_exec(Cx_t* cx, void* data, Cxtype_t* st, Cxvalue_t* sv, Cxdisc_t* disc)
{
    int i;

    if ((i = regnexec((regex_t*)data, sv->string.data, sv->string.size, 0, NiL, 0)) && i != REG_NOMATCH)
        i = -1;
    return i == 0;
}

static int
match_string_free(Cx_t* cx, void* data, Cxdisc_t* disc)
{
    if (data)
    {
        regfree((regex_t*)data);
        free(data);
    }
    return 0;
}

static Cxmatch_t    match_string =
{
    "regex",
    "Matches on this type treat the pattern as a regex(3) pattern string.",
    CXH,
    match_string_comp,
    match_string_exec,
    match_string_free
};

/*
 * default void externalf
 */

static ssize_t
void_external(Cx_t* cx, Cxtype_t* type, const char* details, Cxformat_t* format, Cxvalue_t* value, char* buf, size_t size, Cxdisc_t* disc)
{
    ssize_t i;

    if (!format)
        return 0;
    if (format->width > size)
        return format->width;
    for (i = 0; i < format->width; i++)
        buf[i] = 0;
    return i;
}

/*
 * default void internalf
 */

static ssize_t
void_internal(Cx_t* cx, Cxtype_t* type, const char* details, Cxformat_t* format, Cxoperand_t* ret, const char* buf, size_t size, Vmalloc_t* vm, Cxdisc_t* disc)
{
    ret->value.number = 0;
    return format ? format->width : 0;
}

/*
 * default number externalf
 */

static ssize_t
number_external(Cx_t* cx, Cxtype_t* type, const char* details, Cxformat_t* format, Cxvalue_t* value, char* buf, size_t size, Cxdisc_t* disc)
{
    ssize_t n;
    char*   f;
    char    fmt[16];

    if (CXDETAILS(details, format, type, 0))
        n = sfsprintf(buf, size, details, (intmax_t)value->number);
    else if (value->number == (intmax_t)value->number || (format->flags & CX_INTEGER))
    {
        f = fmt;
        *f++ = '%';
        if (format)
        {
            if (format->width)
            {
                if (format->fill > 0)
                    *f++ = format->fill;
                f += sfsprintf(f, sizeof(fmt) - (f - fmt), "%d", format->width);
            }
            *f++ = 'l';
            *f++ = 'l';
            *f++ = (format->flags & CX_UNSIGNED) ? 'u' : 'd';
        }
        else
        {
            *f++ = 'l';
            *f++ = 'l';
            *f++ = 'd';
        }
        *f = 0;
        n = sfsprintf(buf, size, fmt, (intmax_t)value->number);
    }
    else if (format->width)
    {
        int w;

        w = format->width - ((value->number < 0) ? 2 : 1);
        n = sfsprintf(buf, size, "%#.*I*g", w, sizeof(value->number), value->number);
        if (n != w)
        {
            w += w - n;
            n = sfsprintf(buf, size, "%#.*I*g", w, sizeof(value->number), value->number);
        }
    }
    else
        n = sfsprintf(buf, size, "%1.15I*g", sizeof(value->number), value->number);
    if (n < 0)
        return -1;
    if (n > size)
        return size ? 2 * size : 32;
    return n;
}

/*
 * default number internalf
 */

static ssize_t
number_internal(Cx_t* cx, Cxtype_t* type, const char* details, Cxformat_t* format, Cxoperand_t* ret, const char* buf, size_t size, Vmalloc_t* vm, Cxdisc_t* disc)
{
    Cxunsigned_t    m;
    char*       e;

    if (size == 0)
    {
        ret->value.number = 0;
        return 0;
    }
    if (format && (format->flags & CX_UNSIGNED))
        ret->value.number = (Cxinteger_t)strntoull(buf, size, &e, format->base);
    else if (format && format->base)
        ret->value.number = strntoll(buf, size, &e, format->base);
    else
        ret->value.number = strntod(buf, size, &e);
    if (e != ((char*)buf + size) && *buf)
    {
        if (format && format->map && !cxstr2num(cx, format, buf, size, &m))
        {
            ret->value.number = (Cxinteger_t)m;
            return size;
        }
        if (disc->errorf && !(cx->flags & CX_QUIET))
            (*disc->errorf)(cx, disc, 1, "%s: invalid number [(buf+size)=%p e=%p%s base=%d size=%d]", fmtquote(buf, NiL, NiL, size, 0), (char*)buf+size, e, (format && (format->flags & CX_UNSIGNED)) ? " unsigned" : "", format ? format->base : 0, size);
    }
    return e - (char*)buf;
}

/*
 * default string externalf
 */

static ssize_t
string_external(Cx_t* cx, Cxtype_t* type, const char* details, register Cxformat_t* format, register Cxvalue_t* value, char* buf, size_t size, Cxdisc_t* disc)
{
    if (format && format->width)
    {
        if (format->width > size)
            return format->width;
        if (format->width <= value->string.size)
            memcpy(buf, value->string.data, format->width);
        else
        {
            memcpy(buf, value->string.data, value->string.size);
            memset(buf + value->string.size, format->fill >= 0 ? format->fill : 0, format->width - value->string.size);
        }
        return format->width;
    }
    else
    {
        if (value->string.size > size)
            return value->string.size;
        memcpy(buf, value->string.data, value->string.size);
        return value->string.size;
    }
}

/*
 * default string internalf
 */

static ssize_t
string_internal(Cx_t* cx, Cxtype_t* type, const char* details, Cxformat_t* format, Cxoperand_t* ret, const char* buf, size_t size, Vmalloc_t* vm, Cxdisc_t* disc)
{
    char*   s;

    ret->value.string.data = (char*)buf;
    if ((!format || !(format->flags & CX_NUL) && format->fill <= 0) && (s = memchr(buf, 0, size)))
        size = s - (char*)buf;
    return ret->value.string.size = size;
}

/*
 * default buffer externalf -- mime base64 encode
 */

static ssize_t
buffer_external(Cx_t* cx, Cxtype_t* type, const char* details, Cxformat_t* format, Cxvalue_t* value, char* buf, size_t size, Cxdisc_t* disc)
{
    register unsigned char* t;
    register unsigned char* f;
    register unsigned char* e;
    register int        v;
    int         z;

    static const char   hex[] = "0123456789abcdefg";

    switch (details ? *details : 0)
    {
    case 0:
    case 'b':
    case 'm':
        return base64encode(value->buffer.data, value->buffer.size, NiL, buf, size, NiL);
    case 'h':
    case 'x':
        z = value->buffer.size;
        f = (unsigned char*)value->buffer.data;
        e = f + z;
        z *= 2;
        if (size < z)
            return z;
        t = (unsigned char*)buf;
        while (f < e)
        {
            v = *f++;
            *t++ = hex[v >> 4];
            *t++ = hex[v & 0xf];
        }
        return z;
    }
    if (cx->disc->errorf)
        (*cx->disc->errorf)(cx, cx->disc, ERROR_SYSTEM|2, "%s: unknown buffer representation details", details);
    return -1;
}

/*
 * default buffer internalf -- mime base64 decode
 */

static ssize_t
buffer_internal(Cx_t* cx, Cxtype_t* type, const char* details, Cxformat_t* format, Cxoperand_t* ret, const char* buf, size_t size, Vmalloc_t* vm, Cxdisc_t* disc)
{
    void*   t;
    size_t  n;
    ssize_t r;

    n = (size * 3) / 4 + 1;
    if (!vm)
        vm = Vmregion;
    if (!(t = vmnewof(vm, 0, unsigned char, n, 0)))
    {
        if (disc->errorf)
            (*disc->errorf)(cx, disc, ERROR_SYSTEM|2, "out of space");
        return -1;
    }
    if ((r = base64decode(buf, size, NiL, t, n, NiL)) > n)
        vmfree(vm, t);
    else
    {
        ret->value.buffer.data = t;
        ret->value.buffer.size = r;
    }
    return r;
}

/*
 * type externalf
 */

static ssize_t
type_external(Cx_t* cx, Cxtype_t* type, const char* details, register Cxformat_t* format, register Cxvalue_t* value, char* buf, size_t size, Cxdisc_t* disc)
{
    size_t  n;

    type = (Cxtype_t*)value->pointer;
    if ((n = strlen(type->name)) <= size)
        memcpy(buf, type->name, n);
    return n;
}

/*
 * default string internalf
 */

static ssize_t
type_internal(Cx_t* cx, Cxtype_t* type, const char* details, Cxformat_t* format, Cxoperand_t* ret, const char* buf, size_t size, Vmalloc_t* vm, Cxdisc_t* disc)
{
    return -1;
}

#define BT(r,n,s,d,e,i,m)   {s,{n,d,CXH,0,0,e,i,r,0,0,0,{0},m},},

/*
 * NOTE: void must be first
 */

static Type_t types[] =
{
BT(CX_void, &name_void[0],     &state.type_void,    "No value. May be used for padding.", void_external, void_internal, 0)
BT(CX_number,   &name_number[0],   &state.type_number,  "An integral or floating point number.", number_external, number_internal, 0)
BT(CX_string,   &name_string[0],   &state.type_string,  "A string. The format details string specifies quoting and C style character escape processing: \bquote\b[=\achar\a] quotes string with \achar\a (\b\"\b) as the begin and end quote; \bendquote\b=\achar\a changes the \bquote\b end to \achar\a; \bshell\b[=\abeg\a] quotes using shell conventions and \abeg\a (\b$'\b) as the quote begin; \bopt\b performs \bquote\b and \bshell\b quoting only when necessary; \bescape\b assumes that escape processing has already been performed; \bwide\b does not escape characters with the bit 8 set; \bexpand\b=\amask\a expands escaped characters according to \amask\a which may be a \b,\b or \b|\b separated list of \ball\b: expand all escaped chars, \bchar\b expands 7 bit character escapes, \bline\b expands \b\\r\b and \b\\n\b escapes, \bwide\b expands wide character escapes, \bnocr\b eliminates \b\\r\b, and \bnonl\b eliminates \b\\n\b.", string_external, string_internal, &match_string)
BT(CX_reference,&name_reference[0],&state.type_reference,"A referenced type.", 0,0,0)
BT(CX_buffer,   &name_buffer[0],   &state.type_buffer,  "A separately allocated sized buffer. The external representation is a newline separated base64 mime encoding.", buffer_external, buffer_internal, 0)
BT(CX_type, &name_type[0],   &state.type_type_t,    "A type.", type_external, type_internal, 0)
BT(CX_pointer,  &name_pointer[0],  0,           "A generic pointer.", 0,0,0)
};

#define CX_buffer_t ((Cxtype_t*)&name_buffer[0])
#define CX_number_t ((Cxtype_t*)&name_number[0])
#define CX_pointer_t    ((Cxtype_t*)&name_pointer[0])
#define CX_reference_t  ((Cxtype_t*)&name_reference[0])
#define CX_string_t ((Cxtype_t*)&name_string[0])
#define CX_type_t   ((Cxtype_t*)&name_type[0])
#define CX_void_t   ((Cxtype_t*)&name_void[0])

static int
op_call_V(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    return (*pc->data.variable->function)(cx, pc->data.variable, r, b + (pc->pp + 1), -pc->pp, data, disc);
}

static int
op_nop_V(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    return 0;
}

static int
op_end_V(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    /*
     * NOTE: this special case error return breaks out of the
     *       cxeval() execute() inner loop and is not recorded
     *   as an error
     */

    return -1;
}

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

static int
op_sc_V(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    if ((pc->op == CX_SC0) == (b->value.number == 0))
    {
        cx->jump = (int)pc->data.number;
        return 1;
    }
    return 0;
}

static int
op_const_V(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value = pc->data;
    return 0;
}

static int
op_tst_V(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    if (cx->disc->errorf)
        (*cx->disc->errorf)(cx, cx->disc, 2, "CX_TST not implemented yet");
    return -1;
}

static int
op_add_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = a->value.number + b->value.number;
    return 0;
}

static int
op_sub_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = a->value.number - b->value.number;
    return 0;
}

static int
op_mpy_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = a->value.number * b->value.number;
    return 0;
}

static int
op_div_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    if (b->value.number == 0.0)
    {
        if (cx->disc->errorf)
            (*cx->disc->errorf)(cx, cx->disc, 2, "divide by 0");
        return -1;
    }
    r->value.number = a->value.number / b->value.number;
    return 0;
}

static int
op_mod_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    if (b->value.number < 1.0)
    {
        if (cx->disc->errorf)
            (*cx->disc->errorf)(cx, cx->disc, 2, "modulus by number < 1.0");
        return -1;
    }
    r->value.number = a->value.number / b->value.number;
    r->value.number = (Cxnumber_t)(((Cxinteger_t)a->value.number) % ((Cxinteger_t)b->value.number));
    return 0;
}

static int
op_and_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = (Cxnumber_t)(((Cxinteger_t)a->value.number) & ((Cxinteger_t)b->value.number));
    return 0;
}

static int
op_or_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = (Cxnumber_t)(((Cxinteger_t)a->value.number) | ((Cxinteger_t)b->value.number));
    return 0;
}

static int
op_xor_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = (Cxnumber_t)(((Cxinteger_t)a->value.number) ^ ((Cxinteger_t)b->value.number));
    return 0;
}

static int
op_andand_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = a->value.number > 0 && b->value.number > 0;
    return 0;
}

static int
op_oror_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = a->value.number > 0 || b->value.number > 0;
    return 0;
}

static int
op_lsh_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = (Cxnumber_t)(((Cxinteger_t)a->value.number) << ((int)b->value.number));
    return 0;
}

static int
op_rsh_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = (Cxnumber_t)(((Cxinteger_t)a->value.number) >> ((int)b->value.number));
    return 0;
}

static int
op_inv_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = (Cxnumber_t)(~((Cxinteger_t)a->value.number));
    return 0;
}

static int
op_log_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = b->value.number > 0.0;
    return 0;
}

static int
op_not_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = b->value.number == 0.0;
    return 0;
}

static int
op_uplus_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = b->value.number;
    return 0;
}

static int
op_uminus_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = -b->value.number;
    return 0;
}

static int
op_lt_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = a->value.number < b->value.number;
    return 0;
}

static int
op_le_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = a->value.number <= b->value.number;
    return 0;
}

static int
op_eq_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = a->value.number == b->value.number;
    return 0;
}

static int
op_ne_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = a->value.number != b->value.number;
    return 0;
}

static int
op_ge_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = a->value.number >= b->value.number;
    return 0;
}

static int
op_gt_N(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = a->value.number > b->value.number;
    return 0;
}

static int
op_log_S(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = b->value.string.size > 0 && b->value.string.data[0] != 0;
    return 0;
}

static int
op_lt_S(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    int c;

    r->value.number = (c = strncmp(a->value.string.data, b->value.string.data, CXMIN(a->value.string.size, b->value.string.size))) < 0 || c == 0 && a->value.string.size < b->value.string.size;
    return 0;
}

static int
op_le_S(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    int c;

    r->value.number = (c = strncmp(a->value.string.data, b->value.string.data, CXMIN(a->value.string.size, b->value.string.size))) < 0 || c == 0 && a->value.string.size == b->value.string.size;
    return 0;
}

static int
op_eq_S(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = a->value.string.size == b->value.string.size && strncmp(a->value.string.data, b->value.string.data, a->value.string.size) == 0;
    return 0;
}

static int
op_ne_S(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = a->value.string.size != b->value.string.size || strncmp(a->value.string.data, b->value.string.data, a->value.string.size) != 0;
    return 0;
}

static int
op_ge_S(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    int c;

    r->value.number = (c = strncmp(a->value.string.data, b->value.string.data, CXMIN(a->value.string.size, b->value.string.size))) > 0 || c == 0 && a->value.string.size > b->value.string.size;
    return 0;
}

static int
op_gt_S(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    int c;

    r->value.number = (c = strncmp(a->value.string.data, b->value.string.data, CXMIN(a->value.string.size, b->value.string.size))) > 0 || c == 0 && a->value.string.size > b->value.string.size;
    return 0;
}

static int
op_not_S(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = *b->value.string.data == 0;
    return 0;
}

static int
op_lt_B(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    int c;

    r->value.number = (c = memcmp(a->value.buffer.data, b->value.buffer.data, CXMIN(a->value.buffer.size, b->value.buffer.size))) < 0 || c == 0 && a->value.buffer.size < b->value.buffer.size;
    return 0;
}

static int
op_le_B(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    int c;

    r->value.number = (c = memcmp(a->value.buffer.data, b->value.buffer.data, CXMIN(a->value.buffer.size, b->value.buffer.size))) < 0 || c == 0 && a->value.buffer.size == b->value.buffer.size;
    return 0;
}

static int
op_eq_B(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = a->value.buffer.size == b->value.buffer.size && memcmp(a->value.buffer.data, b->value.buffer.data, a->value.buffer.size) == 0;
    return 0;
}

static int
op_ne_B(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = a->value.buffer.size != b->value.buffer.size || memcmp(a->value.buffer.data, b->value.buffer.data, a->value.buffer.size) != 0;
    return 0;
}

static int
op_ge_B(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    int c;

    r->value.number = (c = memcmp(a->value.buffer.data, b->value.buffer.data, CXMIN(a->value.buffer.size, b->value.buffer.size))) > 0 || c == 0 && a->value.buffer.size > b->value.buffer.size;
    return 0;
}

static int
op_gt_B(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    int c;

    r->value.number = (c = memcmp(a->value.buffer.data, b->value.buffer.data, CXMIN(a->value.buffer.size, b->value.buffer.size))) > 0 || c == 0 && a->value.buffer.size > b->value.buffer.size;
    return 0;
}

static int
op_not_B(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = b->value.buffer.size == 0;
    return 0;
}

static int
op_eq_T(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = a->value.type == b->value.type;
    return 0;
}

static int
op_ne_T(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    r->value.number = a->type != b->type;
    return 0;
}

static int
op_cast_SN(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    char*   e;

    r->value.number = strtod(b->value.string.data, &e);
    if (*e && cx->disc->errorf)
        (*cx->disc->errorf)(cx, cx->disc, 2, "%s: invalid number", b->value.string.data);
    return 0;
}

static int
op_match(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    int i;

    if ((i = (*a->type->match->execf)(cx, pc->data.pointer, a->type, &a->value, disc)) < 0)
        return i;
    r->value.number = i == 1;
    return 0;
}

static int
op_nomatch(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
    int i;

    if ((i = (*a->type->match->execf)(cx, pc->data.pointer, a->type, &a->value, disc)) < 0)
        return i;
    r->value.number = i == 0;
    return 0;
}

static int
re_match(Cx_t* cx, Cxexpr_t* expr, Cxinstruction_t* x, Cxinstruction_t* a, Cxinstruction_t* b, void* data, Cxdisc_t* disc)
{
    if (!(x->data.pointer = (*a->type->match->compf)(cx, a->type, b->type, &b->data, disc)))
        return -1;
    if (a->type->match->freef && cxatfree(cx, expr, a->type->match->freef, x->data.pointer))
    {
        (*a->type->match->freef)(cx, x->data.pointer, disc);
        return -1;
    }
    b->type = state.type_void;
    x->callout = x->op == CX_MATCH ? op_match : op_nomatch;
    return 0;
}

static Cxcallout_t callouts[] =
{

CXC(CX_CALL,    CX_void_t,  CX_void_t,  op_call_V,  0)
CXC(CX_NOP, CX_void_t,  CX_void_t,  op_nop_V,   0)
CXC(CX_POP, CX_void_t,  CX_void_t,  op_nop_V,   0)
CXC(CX_REF, CX_reference_t, CX_void_t,  op_const_V, 0)
CXC(CX_REF, CX_string_t,    CX_void_t,  op_ref_V,   0)
CXC(CX_SC0, CX_number_t,    CX_void_t,  op_sc_V,    0)
CXC(CX_SC1, CX_number_t,    CX_void_t,  op_sc_V,    0)
CXC(CX_TST, CX_void_t,  CX_void_t,  op_tst_V,   0)
CXC(CX_END, CX_void_t,  CX_void_t,  op_end_V,   0)

CXC(CX_NUM, CX_number_t,    CX_void_t,  op_const_V, 0)
CXC(CX_STR, CX_string_t,    CX_void_t,  op_const_V, 0)
CXC(CX_NUM, CX_type_t,  CX_void_t,  op_const_V, 0)

CXC(CX_ADD, CX_number_t,    CX_number_t,    op_add_N,   0)
CXC(CX_SUB, CX_number_t,    CX_number_t,    op_sub_N,   0)
CXC(CX_MPY, CX_number_t,    CX_number_t,    op_mpy_N,   0)
CXC(CX_DIV, CX_number_t,    CX_number_t,    op_div_N,   0)
CXC(CX_MOD, CX_number_t,    CX_number_t,    op_mod_N,   0)
CXC(CX_AND, CX_number_t,    CX_number_t,    op_and_N,   0)
CXC(CX_OR,  CX_number_t,    CX_number_t,    op_or_N,    0)
CXC(CX_XOR, CX_number_t,    CX_number_t,    op_xor_N,   0)

CXC(CX_ANDAND,  CX_number_t,    CX_number_t,    op_andand_N,    0)
CXC(CX_OROR,    CX_number_t,    CX_number_t,    op_oror_N,  0)

CXC(CX_LSH, CX_number_t,    CX_number_t,    op_lsh_N,   0)
CXC(CX_RSH, CX_number_t,    CX_number_t,    op_rsh_N,   0)

CXC(CX_INV, CX_number_t,    CX_void_t,  op_inv_N,   0)
CXC(CX_LOG, CX_number_t,    CX_void_t,  op_log_N,   0)
CXC(CX_NOT, CX_number_t,    CX_void_t,  op_not_N,   0)
CXC(CX_UPLUS,   CX_number_t,    CX_void_t,  op_uplus_N, 0)
CXC(CX_UMINUS,  CX_number_t,    CX_void_t,  op_uminus_N,    0)

CXC(CX_LT,  CX_number_t,    CX_number_t,    op_lt_N,    0)
CXC(CX_LE,  CX_number_t,    CX_number_t,    op_le_N,    0)
CXC(CX_EQ,  CX_number_t,    CX_number_t,    op_eq_N,    0)
CXC(CX_NE,  CX_number_t,    CX_number_t,    op_ne_N,    0)
CXC(CX_GE,  CX_number_t,    CX_number_t,    op_ge_N,    0)
CXC(CX_GT,  CX_number_t,    CX_number_t,    op_gt_N,    0)

CXC(CX_LOG, CX_string_t,    CX_void_t,  op_log_S,   0)

CXC(CX_LT,  CX_string_t,    CX_string_t,    op_lt_S,    0)
CXC(CX_LE,  CX_string_t,    CX_string_t,    op_le_S,    0)
CXC(CX_EQ,  CX_string_t,    CX_string_t,    op_eq_S,    0)
CXC(CX_NE,  CX_string_t,    CX_string_t,    op_ne_S,    0)
CXC(CX_GE,  CX_string_t,    CX_string_t,    op_ge_S,    0)
CXC(CX_GT,  CX_string_t,    CX_string_t,    op_gt_S,    0)

CXC(CX_NOT, CX_string_t,    CX_void_t,  op_not_S,   0)

CXC(CX_LT,  CX_buffer_t,    CX_buffer_t,    op_lt_B,    0)
CXC(CX_LE,  CX_buffer_t,    CX_buffer_t,    op_le_B,    0)
CXC(CX_EQ,  CX_buffer_t,    CX_buffer_t,    op_eq_B,    0)
CXC(CX_NE,  CX_buffer_t,    CX_buffer_t,    op_ne_B,    0)
CXC(CX_GE,  CX_buffer_t,    CX_buffer_t,    op_ge_B,    0)
CXC(CX_GT,  CX_buffer_t,    CX_buffer_t,    op_gt_B,    0)

CXC(CX_NOT, CX_buffer_t,    CX_void_t,  op_not_B,   0)

CXC(CX_EQ,  CX_type_t,  CX_type_t,  op_eq_T,    0)
CXC(CX_NE,  CX_type_t,  CX_type_t,  op_ne_T,    0)

CXC(CX_CAST,    CX_string_t,    CX_number_t,    op_cast_SN, 0)

};

size_t
cxsizeof(Cx_t* cx, Cxvariable_t* var, Cxtype_t* type, Cxvalue_t* value)
{
    size_t      size;

    if (var->array)
        size = var->array->size;
    else
        do
        {
            if (size = type->size)
                break;
            switch (type->representation)
            {
            case CX_buffer:
                if (size = value->buffer.size)
                {
                    if (value->buffer.elements)
                        size = value->buffer.elements;
                    else if (type->element)
                        size /= type->element;
                }
                break;
            case CX_number:
            case CX_pointer:
                size = 8;
                break;
            case CX_string:
                size = value->string.size;
                break;
            default:
                continue;
            }
            break;
        } while (type = type->base);
    return size;
}

static int
cx_edit_B(Cx_t* cx, Cxvariable_t* var, Cxoperand_t* ret, Cxoperand_t* arg, int n, void* data, Cxdisc_t* disc)
{
    Cxedit_t*   edit;

    if (!(edit = cxedit(cx, arg[0].value.string.data, disc)))
        return -1;
    ret->value = arg[1].value;
    return cxsub(cx, edit, ret);
}

static int
cx_sizeof_B(Cx_t* cx, Cxvariable_t* var, Cxoperand_t* ret, Cxoperand_t* arg, int n, void* data, Cxdisc_t* disc)
{
    ret->value.number = cxsizeof(cx, var, arg->type, &arg->value);
    return 0;
}

static int
cx_typeof_B(Cx_t* cx, Cxvariable_t* var, Cxoperand_t* ret, Cxoperand_t* arg, int n, void* data, Cxdisc_t* disc)
{
    ret->value.type = arg->type;
    return 0;
}

static Cxvariable_t builtins[] =
{
CXF("edit",     "string",   cx_edit_B,  "string,string",
            "Returns the result of applying the ed(1) style substitute expression"
            " in the first argument to the second argument.")
CXF("sizeof",       "number",   cx_sizeof_B,    "*",
            "Returns the size of the \avariable\a argument;"
            " the size of an array variable is the number of elements,"
            " otherwise the size is in bytes.")
CXF("typeof",       "type_t",   cx_typeof_B,    "*",
            "Returns the type of the \avariable\a argument"
            " for comparison with other types.")
};

/*
 * open a cx session
 */

Cx_t*
cxopen(Cxflags_t flags, Cxflags_t test, Cxdisc_t* disc)
{
    register Cx_t*      cx;
    register Vmalloc_t* vm;
    register Vmalloc_t* em;
    register Vmalloc_t* rm;

    if (!(vm = vmopen(Vmdcheap, Vmbest, 0)) || !(em = vmopen(Vmdcheap, Vmlast, 0)) || !(rm = vmopen(Vmdcheap, Vmlast, 0)))
    {
        if (vm)
        {
            vmclose(vm);
            if (em)
                vmclose(em);
        }
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
        return 0;
    }
    if (!(cx = vmnewof(vm, 0, Cx_t, 1, 0)) || !(cx->cvtbuf = vmnewof(vm, 0, char, cx->cvtsiz = 64, 0)))
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
        goto bad;
    }
    cx->state = cxstate(disc);
    cx->table = &table;
    cx->id = CX_ID;
    cx->vm = vm;
    cx->em = em;
    cx->rm = rm;
    cx->disc = disc;
    cx->flags = flags;
    cx->test = test;
    cx->redisc.re_version = REG_VERSION;
    cx->redisc.re_flags = REG_NOFREE;
    cx->redisc.re_errorf = (regerror_t)disc->errorf;
    if (!(cx->buf = sfstropen()) || !(cx->tp = sfstropen()))
    {
        cxclose(cx);
        return 0;
    }
    cx->scoped = 1;
    if (!(flags & CX_SCOPE))
    {
        cx->op = sfstdout;
        if (!(cx->fields = dtnew(cx->vm, &state.listdisc, Dtqueue)) || !(cx->buf = sfstropen()) || !(cx->tp = sfstropen()))
        {
            cxclose(cx);
            return 0;
        }
        cx->callouts = state.callouts;
        cx->constraints = state.constraints;
        cx->edits = state.edits;
        cx->maps = state.maps;
        cx->queries = state.queries;
        cx->recodes = state.recodes;
        cx->types = state.types;
        cx->variables = state.variables;
    }
    cx->ctype = state.ctype;
    return cx;
 bad:
    vmclose(vm);
    vmclose(em);
    vmclose(rm);
    return 0;
}

/*
 * scope control
 */

Cx_t*
cxscope(Cx_t* top, Cx_t* bot, Cxflags_t flags, Cxflags_t test, Cxdisc_t* disc)
{
    if (!top)
    {
        if (!(top = cxopen(CX_SCOPE|flags, test, disc)))
            return 0;
        top->op = sfstdout;
    }
    if (top->scoped != 1)
    {
        if (top->disc->errorf)
            (*top->disc->errorf)(NiL, top->disc, 2, "cannot change active scope");
        return 0;
    }
    if (bot)
    {
        /*
         * scope top on bot
         */

        if (top->scope)
        {
            if (top->disc->errorf)
                (*top->disc->errorf)(NiL, top->disc, 2, "already scoped");
            return 0;
        }
        if (top->view & CX_VIEW_callouts)
            dtview(top->callouts, bot->callouts);
        else
            top->callouts = bot->callouts;
        if (top->view & CX_VIEW_constraints)
            dtview(top->constraints, bot->constraints);
        else
            top->constraints = bot->constraints;
        if (top->view & CX_VIEW_edits)
            dtview(top->edits, bot->edits);
        else
            top->edits = bot->edits;
        if (top->view & CX_VIEW_fields)
            dtview(top->fields, bot->fields);
        else
            top->fields = bot->fields;
        if (top->view & CX_VIEW_maps)
            dtview(top->maps, bot->maps);
        else
            top->maps = bot->maps;
        if (top->view & CX_VIEW_queries)
            dtview(top->queries, bot->queries);
        else
            top->queries = bot->queries;
        if (top->view & CX_VIEW_recodes)
            dtview(top->recodes, bot->recodes);
        else
            top->recodes = bot->recodes;
        if (top->view & CX_VIEW_types)
            dtview(top->types, bot->types);
        else
            top->types = bot->types;
        if (top->view & CX_VIEW_variables)
            dtview(top->variables, bot->variables);
        else
            top->variables = bot->variables;
        bot->scoped++;
        top->scope = bot;
        bot = top;
    }
    else if (bot = top->scope)
    {
        /*
         * pop the scope
         */

        if (top->view & CX_VIEW_callouts)
            dtview(top->callouts, NiL);
        if (top->view & CX_VIEW_constraints)
            dtview(top->constraints, NiL);
        if (top->view & CX_VIEW_edits)
            dtview(top->edits, NiL);
        if (top->view & CX_VIEW_fields)
            dtview(top->fields, NiL);
        if (top->view & CX_VIEW_maps)
            dtview(top->maps, NiL);
        if (top->view & CX_VIEW_queries)
            dtview(top->queries, NiL);
        if (top->view & CX_VIEW_recodes)
            dtview(top->recodes, NiL);
        if (top->view & CX_VIEW_types)
            dtview(top->types, NiL);
        if (top->view & CX_VIEW_variables)
            dtview(top->variables, NiL);
        top->scope = 0;
        bot->scoped--;
    }
    else
        bot = top;
    return bot;
}

/*
 * close a cx session
 */

int
cxclose(register Cx_t* cx)
{
    if (!cx)
        return -1;
    if (cx->scope)
        cxscope(cx, NiL, 0, 0, cx->disc);
    if (--cx->scoped <= 0)
    {
        if (cx->view & CX_VIEW_callouts)
            dtclose(cx->callouts);
        if (cx->view & CX_VIEW_constraints)
            dtclose(cx->constraints);
        if (cx->view & CX_VIEW_edits)
            dtclose(cx->edits);
        if (cx->view & CX_VIEW_maps)
            dtclose(cx->maps);
        if (cx->view & CX_VIEW_queries)
            dtclose(cx->queries);
        if (cx->view & CX_VIEW_recodes)
            dtclose(cx->recodes);
        if (cx->view & CX_VIEW_types)
            dtclose(cx->types);
        if (cx->view & CX_VIEW_fields)
            dtclose(cx->fields);
        if (cx->view & CX_VIEW_variables)
            dtclose(cx->variables);
        if (cx->scope)
            cx->scope->scoped--;
        if (cx->buf)
            sfclose(cx->buf);
        if (cx->tp)
            sfclose(cx->tp);
        if (cx->em)
            vmclose(cx->em);
        if (cx->rm)
            vmclose(cx->rm);
        if (cx->vm)
            vmclose(cx->vm);
    }
    return 0;
}

/*
 * add a type
 */

int
cxaddtype(Cx_t* cx, register Cxtype_t* type, Cxdisc_t* disc)
{
    char*       base;
    Cxvariable_t*   v;
    Cxvariable_t*   member;
    Dt_t*       dict;
    Cxtype_t*   copy;
    Cxrecode_t* re;
    int     i;

    if (cx)
    {
        disc = cx->disc;
        if (cx->view & CX_VIEW_types)
            dict = cx->types;
        else if (!(dict = dtnew(cx->vm, &state.namedisc, Dtoset)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
            return -1;
        }
        else
        {
            dtview(dict, cx->types);
            cx->types = dict;
            cx->view |= CX_VIEW_types;
        }
        if (!(copy = vmnewof(cx->vm, 0, Cxtype_t, 1, 0)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
            return -1;
        }
        *copy = *type;
        type = copy;
    }
    else
        dict = state.types;
    if (dtsearch(dict, type))
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, 2, "%s: type already defined", type->name);
        return -1;
    }
    dtinsert(dict, type);
    if (!(type->header.flags & CX_NORMALIZED))
    {
        type->header.flags |= CX_NORMALIZED;
        if ((base = (char*)type->base) && !(type->base = cxtype(cx, base, disc)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, 2, "%s: unknown base type", base);
            return -1;
        }
        if ((base = (char*)type->fundamental) && !(type->fundamental = cxtype(cx, base, disc)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, 2, "%s: unknown fundamental type", base);
            return -1;
        }
        if (type->member)
        {
            if (!type->member->getf)
            {
                if (disc->errorf)
                    (*disc->errorf)(NiL, disc, 2, "%s: no member get function", type->name);
                return -1;
            }
            if (!(member = (Cxvariable_t*)type->member->members))
            {
                if (disc->errorf)
                    (*disc->errorf)(NiL, disc, 2, "%s: no member table", type->name);
                return -1;
            }
            if (type->header.flags & CX_REFERENCED)
                type->member->members = cx ? cx->variables : state.variables;
            else if (!(type->member->members = cx ? dtnew(cx->vm, &state.namedisc, Dtoset) : dtopen(&state.namedisc, Dtoset)))
            {
                if (disc->errorf)
                    (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
                return -1;
            }
            else
                for (i = 0; member->name; member++)
                {
                    v = member;
                    if (!(v->header.flags & CX_NORMALIZED))
                    {
                        v->header.flags |= CX_NORMALIZED;
                        if ((base = (char*)v->type) && !(v->type = cxtype(cx, base, disc)))
                        {
                            if (disc->errorf)
                                (*disc->errorf)(NiL, disc, 2, "%s: unknown type", base);
                            return -1;
                        }
                        v->member = type;
                    }
                    v->header.index = i++;
                    dtinsert(type->member->members, v);
                }
        }
        if (type->generic)
            for (i = 0; base = (char*)type->generic[i]; i++)
                if (!(type->generic[i] = cxtype(cx, base, disc)))
                {
                    if (disc->errorf)
                        (*disc->errorf)(NiL, disc, 2, "%s: unknown type", base);
                    return -1;
                }
    }
    if (!(type->header.flags & CX_INITIALIZED))
    {
        type->header.flags |= CX_INITIALIZED;
        if (type->fundamental)
        {
            if (type->base)
                type->representation = type->base->representation;
        }
        else if (!type->base)
            type->fundamental = type;
        else
        {
            type->fundamental = type->base->fundamental;
            type->representation = type->base->representation;
        }
        if (type->match)
        {
            if (!(re = newof(0, Cxrecode_t, 1, 0)))
            {
                if (disc->errorf)
                    (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
                return -1;
            }
            re->header.flags = CX_NORMALIZED;
            re->op.code = CX_MATCH;
            re->op.type1 = type;
            re->op.type2 = state.type_void;
            re->recode = re_match;
            if (cxaddrecode(cx, re, disc))
                return -1;
        }
        if (type->initf && !(type->data = (*type->initf)(type, disc)))
            return -1;
    }
    return 0;
}

/*
 * return type given name
 */

Cxtype_t*
cxtype(Cx_t* cx, const char* name, Cxdisc_t* disc)
{
    register char*  s;
    register char*  lib;
    Cxtype_t*   t;
    size_t      n;

    if ((s = strchr(name, ':')) && *++s == ':')
    {
        n = s - (char*)name;
        lib = fmtbuf(n);
        memcpy(lib, name, --n);
        lib[n] = 0;
        name = (const char*)s + 1;
    }
    else
        lib = (char*)name;
    if (!(t = (Cxtype_t*)dtmatch(cx ? cx->types : state.types, name)) && disc->loadf && (*disc->loadf)(lib, disc))
        t = (Cxtype_t*)dtmatch(cx ? cx->types : state.types, name);
    return t;
}

/*
 * add an op callout
 */

int
cxaddcallout(Cx_t* cx, register Cxcallout_t* callout, Cxdisc_t* disc)
{
    char*       name;
    Dt_t*       dict;
    Cxcallout_t*    copy;

    if (cx)
    {
        disc = cx->disc;
        if (cx->view & CX_VIEW_callouts)
            dict = cx->callouts;
        else if (!(dict = dtnew(cx->vm, &state.codedisc, Dtoset)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
            return -1;
        }
        else
        {
            dtview(dict, cx->callouts);
            cx->callouts = dict;
            cx->view |= CX_VIEW_callouts;
        }
        if (!(copy = vmnewof(cx->vm, 0, Cxcallout_t, 1, 0)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
            return -1;
        }
        *copy = *callout;
        callout = copy;
    }
    else if (callout->op.code == CX_GET || callout->op.code == CX_SET || callout->op.code == CX_DEL || callout->op.code == CX_RET)
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, 2, "%s: callout must be local", cxcodename(callout->op.code));
        return -1;
    }
    else
        dict = state.callouts;
    if (!(callout->header.flags & CX_NORMALIZED))
    {
        callout->header.flags |= CX_NORMALIZED;
        if (!(name = (char*)callout->op.type1))
            callout->op.type1 = state.type_void;
        else if (!(callout->op.type1 = cxtype(cx, name, disc)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, 2, "%s: unknown type", name);
            return -1;
        }
        if (!(name = (char*)callout->op.type2))
            callout->op.type2 = state.type_void;
        else if (!(callout->op.type2 = cxtype(cx, name, disc)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, 2, "%s: unknown type", name);
            return -1;
        }
    }
    if (!(copy = (Cxcallout_t*)dtinsert(dict, callout)) || copy->callout != callout->callout)
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, 2, "callout initialization error");
        return -1;
    }
    return 0;
}

/*
 * return callout given <code,type1,type2>
 */

Cxcallout_f
cxcallout(Cx_t* cx, int code, Cxtype_t* type1, Cxtype_t* type2, Cxdisc_t* disc)
{
    Cxcallout_t*    callout;
    Cxop_t      op;

    memset(&op, 0, sizeof(op));
    op.code = code;
    if (!(op.type1 = type1))
        op.type1 = state.type_void;
    if (!(op.type2 = type2))
        op.type2 = state.type_void;
    while (!(callout = (Cxcallout_t*)dtmatch(cx ? cx->callouts : state.callouts, &op)))
    {
        if (op.code == CX_NOMATCH)
            op.code = CX_MATCH;
        else if (op.type2 == state.type_void)
            return 0;
        else
            op.type2 = state.type_void;
    }
    return callout->callout;
}

/*
 * add a query
 */

int
cxaddquery(Cx_t* cx, Cxquery_t* query, Cxdisc_t* disc)
{
    Dt_t*       dict;
    Cxquery_t*  copy;

    if (cx)
    {
        disc = cx->disc;
        if (cx->view & CX_VIEW_queries)
            dict = cx->queries;
        else if (!(dict = dtnew(cx->vm, &state.namedisc, Dtoset)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
            return -1;
        }
        else
        {
            dtview(dict, cx->queries);
            cx->queries = dict;
            cx->view |= CX_VIEW_queries;
        }
        if (!(copy = vmnewof(cx->vm, 0, Cxquery_t, 1, 0)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
            return -1;
        }
        *copy = *query;
        query = copy;
    }
    else
        dict = state.queries;
    if (dtsearch(dict, query))
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, 2, "%s: query already defined", query->name);
        return -1;
    }
    dtinsert(dict, query);
    return 0;
}

/*
 * return query given name
 */

Cxquery_t*
cxquery(Cx_t* cx, const char* name, Cxdisc_t* disc)
{
    register char*  s;
    register char*  lib;
    Cxquery_t*  q;
    size_t      n;

    if ((s = strchr(name, ':')) && *++s == ':')
    {
        n = s - (char*)name;
        lib = fmtbuf(n);
        memcpy(lib, name, --n);
        lib[n] = 0;
        name = (const char*)s + 1;
    }
    else
        lib = (char*)name;
    if (!(q = (Cxquery_t*)dtmatch(cx ? cx->queries : state.queries, name)) && disc->loadf && (*disc->loadf)(lib, disc))
        q = (Cxquery_t*)dtmatch(cx ? cx->queries : state.queries, name);
    return q;
}

/*
 * return function given name
 */

Cxvariable_t*
cxfunction(Cx_t* cx, const char* name, Cxdisc_t* disc)
{
    register char*  s;
    register char*  p;
    Cxvariable_t*   f;
    Cxlib_t*    lib;
    int     i;

    if (!cx)
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, 2, "%s: function must be local", name);
        return 0;
    }
    if (f = (Cxvariable_t*)dtmatch(cx->variables, name))
    {
        if (f->function)
            return f;
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, 2, "%s: not a function", name);
        return 0;
    }
    if (!(s = strchr(name, ':')) || *++s != ':')
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, 2, "%s: function must be local", name);
        return 0;
    }
    i = s - (char*)name;
    p = fmtbuf(i);
    memcpy(p, name, --i);
    p[i] = 0;
    if (!disc->loadf || !(lib = (*disc->loadf)(p, disc)))
        return 0;
    if (lib->functions)
        for (i = 0; lib->functions[i].name; i++)
            if (cxaddvariable(cx, &lib->functions[i], disc))
                return 0;
    if (f = (Cxvariable_t*)dtmatch(cx->variables, name))
    {
        if (f->function)
            return f;
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, 2, "%s: not a function", name);
    }
    else
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, 2, "%s: undefined function", name);
        return 0;
    }
    return 0;
}

/*
 * add a map
 */

int
cxaddmap(Cx_t* cx, Cxmap_t* map, Cxdisc_t* disc)
{
    Dt_t*       dict;
    Cxmap_t*    copy;

    if (cx)
    {
        disc = cx->disc;
        if (cx->view & CX_VIEW_maps)
            dict = cx->maps;
        if (!(dict = dtnew(cx->vm, &state.namedisc, Dtoset)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
            return -1;
        }
        else
        {
            dtview(dict, cx->maps);
            cx->maps = dict;
            cx->view |= CX_VIEW_maps;
        }
        if (!(copy = vmnewof(cx->vm, 0, Cxmap_t, 1, 0)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
            return -1;
        }
        *copy = *map;
        map = copy;
    }
    else
        dict = state.maps;
    if (dtsearch(dict, map))
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, 2, "%s: map already defined", map->name);
        return -1;
    }
    if (cxinitmap(map, disc))
        return -1;
    dtinsert(dict, map);
    return 0;
}

/*
 * return map given name
 */

Cxmap_t*
cxmap(Cx_t* cx, const char* name, Cxdisc_t* disc)
{
    return (Cxmap_t*)dtmatch(cx ? cx->maps : state.maps, name);
}

/*
 * add an op recode
 */

int
cxaddrecode(Cx_t* cx, register Cxrecode_t* recode, Cxdisc_t* disc)
{
    Cxrecode_t* o;
    char*       name;
    Dt_t*       dict;
    Cxrecode_t* copy;

    if (cx)
    {
        disc = cx->disc;
        if (cx->view & CX_VIEW_recodes)
            dict = cx->recodes;
        else if (!(dict = dtnew(cx->vm, &state.codedisc, Dtoset)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
            return -1;
        }
        else
        {
            dtview(dict, cx->recodes);
            cx->recodes = dict;
            cx->view |= CX_VIEW_recodes;
        }
        if (!(copy = vmnewof(cx->vm, 0, Cxrecode_t, 1, 0)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
            return -1;
        }
        *copy = *recode;
        recode = copy;
    }
    else if (recode->op.code == CX_GET || recode->op.code == CX_SET || recode->op.code == CX_DEL || recode->op.code == CX_RET)
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, 2, "%s: recode must be local", cxcodename(recode->op.code));
        return -1;
    }
    else
        dict = state.recodes;
    if (!(recode->header.flags & CX_NORMALIZED))
    {
        recode->header.flags |= CX_NORMALIZED;
        if ((name = (char*)recode->op.type1) && !(recode->op.type1 = cxtype(cx, name, disc)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, 2, "%s: unknown type", name);
            return -1;
        }
        if ((name = (char*)recode->op.type2) && !(recode->op.type2 = cxtype(cx, name, disc)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, 2, "%s: unknown type", name);
            return -1;
        }
    }
    if (!(o = (Cxrecode_t*)dtsearch(dict, recode)) || o != recode && dtdelete(dict, o))
        dtinsert(dict, recode);
    return 0;
}

/*
 * return recode given <code,type1,type2>
 */

Cxrecode_f
cxrecode(Cx_t* cx, int code, Cxtype_t* type1, Cxtype_t* type2, Cxdisc_t* disc)
{
    Cxrecode_t* recode;
    Cxop_t      op;

    switch (code)
    {
    case CX_NOMATCH:
        code = CX_MATCH;
        /*FALLTHROUGH*/
    case CX_MATCH:
        type2 = 0;
        break;
    }
    memset(&op, 0, sizeof(op));
    op.code = code;
    if (!(op.type1 = type1))
        op.type1 = state.type_void;
    if (!(op.type2 = type2))
        op.type2 = state.type_void;
    return (recode = (Cxrecode_t*)dtmatch(cx ? cx->recodes : state.recodes, &op)) ? recode->recode : (Cxrecode_f)0;
}

/*
 * add an edit
 */

int
cxaddedit(Cx_t* cx, register Cxedit_t* edit, Cxdisc_t* disc)
{
    Dt_t*       dict;
    Cxedit_t*   copy;

    if (cx)
    {
        disc = cx->disc;
        if (cx->view & CX_VIEW_edits)
            dict = cx->edits;
        else if (!(dict = dtnew(cx->vm, &state.namedisc, Dtoset)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
            return -1;
        }
        else
        {
            dtview(dict, cx->edits);
            cx->edits = dict;
            cx->view |= CX_VIEW_edits;
        }
        if (!(copy = vmnewof(cx->vm, 0, Cxedit_t, 1, 0)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
            return -1;
        }
        *copy = *edit;
        edit = copy;
    }
    else
        dict = state.edits;
    if (dtsearch(dict, edit))
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, 2, "%s: edit already defined", edit->name);
        return -1;
    }
    dtinsert(dict, edit);
    if (!(edit->header.flags & CX_INITIALIZED))
    {
        edit->header.flags |= CX_INITIALIZED;
        if (edit->initf && !(edit->data = (*edit->initf)(edit, disc)))
            return -1;
    }
    return 0;
}

/*
 * return edit given name
 * optional substitute expression instantiated
 */

Cxedit_t*
cxedit(Cx_t* cx, const char* data, Cxdisc_t* disc)
{
    Cxedit_t*   e;
    Cxedit_t*   o;
    char*       s;

    e = (Cxedit_t*)dtmatch(cx ? cx->edits : state.edits, data);
    if (isalpha(*data))
    {
        if (!e)
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, 2, "%s: edit not defined", data);
            return 0;
        }
        o = e;
        if (!(e = cx ? vmnewof(cx->vm, 0, Cxedit_t, 1, 0) : newof(0, Cxedit_t, 1, 0)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
            return 0;
        }
        e->name = o->name;
        e->description = o->description;
        e->initf = o->initf;
        e->num2strf = o->num2strf;
        e->str2numf = o->str2numf;
    }
    else if (e)
        return e;
    else
    {
        if (!(e = cx ? vmnewof(cx->vm, 0, Cxedit_t, 1, strlen(data) + 1) : newof(0, Cxedit_t, 1, strlen(data) + 1)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
            return 0;
        }
        e->redisc.re_version = REG_VERSION;
        e->redisc.re_errorf = (regerror_t)disc->errorf;
        if (cx)
        {
            e->redisc.re_flags = REG_NOFREE;
            e->redisc.re_resizef = (regresize_t)vmgetmem;
            e->redisc.re_resizehandle = cx->vm;
        }
        e->re.re_disc = &e->redisc;
        s = (char*)data;
        if (regcomp(&e->re, s, REG_DELIMITED|REG_LENIENT|REG_NULL))
            return 0;
        s += e->re.re_npat;
        if (regsubcomp(&e->re, s, NiL, 0, 0))
            return 0;
        s += e->re.re_npat;
        e->re.re_npat = s - (char*)data;
        if (*s && disc->errorf)
            (*disc->errorf)(NiL, disc, 1, "invalid character after substitution: %s", s);
        strcpy((char*)(e->name = (const char*)(e + 1)), data);
        if (cx && cxaddedit(cx, e, disc))
            return 0;
    }
    return e;
}

/*
 * add a constraint
 */

int
cxaddconstraint(Cx_t* cx, register Cxconstraint_t* constraint, Cxdisc_t* disc)
{
    Dt_t*       dict;
    Cxconstraint_t* copy;

    if (cx)
    {
        disc = cx->disc;
        if (cx->view & CX_VIEW_constraints)
            dict = cx->constraints;
        else if (!(dict = dtnew(cx->vm, &state.namedisc, Dtoset)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
            return -1;
        }
        else
        {
            dtview(dict, cx->constraints);
            cx->constraints = dict;
            cx->view |= CX_VIEW_constraints;
        }
        if (!(copy = vmnewof(cx->vm, 0, Cxconstraint_t, 1, 0)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
            return -1;
        }
        *copy = *constraint;
        constraint = copy;
    }
    else
        dict = state.constraints;
    if (dtsearch(dict, constraint))
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, 2, "%s: constraint already defined", constraint->name);
        return -1;
    }
    if (!(constraint->header.flags & CX_INITIALIZED))
    {
        constraint->header.flags |= CX_INITIALIZED;
        if (constraint->initf && !(constraint->data = (*constraint->initf)(constraint, disc)))
            return -1;
    }
    dtinsert(dict, constraint);
    return 0;
}

/*
 * return constraint given name
 */

Cxconstraint_t*
cxconstraint(Cx_t* cx, const char* name, Cxdisc_t* disc)
{
    return (Cxconstraint_t*)dtmatch(cx ? cx->constraints : state.constraints, name);
}

/*
 * mark type CX_REFERENCED
 */

static void
referenced(register Cxtype_t* type)
{
    register Cxvariable_t*  mp;

    if (!(type->header.flags & CX_REFERENCED))
    {
        type->header.flags |= CX_REFERENCED;
        if (type->base)
            referenced(type->base);
        if (type->member)
            for (mp = (Cxvariable_t*)dtfirst(type->member->members); mp; mp = (Cxvariable_t*)dtnext(type->member->members, mp))
                referenced(mp->type);
    }
}

/*
 * add a variable
 */

int
cxaddvariable(register Cx_t* cx, register Cxvariable_t* variable, Cxdisc_t* disc)
{
    Dt_t*   dict;
    Cx_t*   sx;
    char*   name;

    if (cx)
    {
        disc = cx->disc;
        if (cx->view & CX_VIEW_variables)
            dict = cx->variables;
        else if (!(dict = dtnew(cx->vm, &state.namedisc, Dtoset)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
            return -1;
        }
        else
        {
            dtview(dict, cx->variables);
            cx->variables = dict;
            cx->view |= CX_VIEW_variables;
        }
    }
    else
        dict = state.variables;
    if (!variable)
        return 0;
    if (dtsearch(dict, variable))
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, 2, "%s: variable already defined", variable->name);
        return -1;
    }
    if (!(variable->header.flags & CX_NORMALIZED))
    {
        variable->header.flags |= CX_NORMALIZED;
        if ((name = (char*)variable->type) && !(variable->type = cxtype(cx, name, disc)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, 2, "%s: %s: unknown type", variable->name, name);
            return -1;
        }
    }
    dtinsert(dict, variable);
    if (cx)
    {
        if (sx = cx->scope)
        {
            variable->header.index = sx->index++;
            cx->index = sx->index;
        }
        else
            variable->header.index = cx->index++;
    }
    if (!(variable->header.flags & CX_INITIALIZED))
    {
        variable->header.flags |= CX_INITIALIZED;
        referenced(variable->type);
        if (cx)
            dtinsert(cx->fields, variable);
    }
    return 0;
}

/*
 * return variable given name
 */

Cxvariable_t*
cxvariable(Cx_t* cx, const char* name, register Cxtype_t* m, Cxdisc_t* disc)
{
    register char*  s;
    register char*  t;
    Cxvariable_t*   v;
    Dt_t*       dict;
    Cxreference_t*  ref;
    Cxreference_t*  head;
    Cxreference_t*  tail;

    if (!cx)
    {
        if (disc->errorf)
            (*disc->errorf)(NiL, disc, 2, "%s: variable must be local", name);
        return 0;
    }
    disc = cx->disc;
    if (!m || !m->member)
    {
        if (!(v = (Cxvariable_t*)dtmatch(cx->variables, name)))
        {
            if (!(t = strchr(name, '.')))
            {
                if (disc->errorf)
                    (*disc->errorf)(NiL, disc, 2, "%s: undefined variable", name);
                return 0;
            }

            /*
             * cxparse() never gets here
             */

            strcpy(s = fmtbuf(strlen(name) + 1), name);
            t = s + (t - (char*)name);
            m = 0;
            dict = cx->variables;
            head = 0;
            for (;;)
            {
                if (t)
                    *t++ = 0;
                v = (Cxvariable_t*)dtmatch(dict, *s ? s : ".");
                if (!v)
                {
                    if (disc->errorf)
                    {
                        if (m)
                            (*disc->errorf)(NiL, disc, 2, "%s: not a member of %s", s, m->name);

                        else
                            (*disc->errorf)(NiL, disc, 2, "%s: undefined variable", s);
                    }
                    return 0;
                }
                if (!(ref = newof(0, Cxreference_t, 1, 0)))
                {
                    if (disc->errorf)
                        (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
                    return 0;
                }
                ref->variable = v;
                if (m)
                    ref->member = m->member;
                if (head)
                    tail->next = ref;
                else
                    head = ref;
                tail = ref;
                if (!(s = t))
                    break;
                if ((!(m = v->type) || !m->member || !(dict = m->member->members)) &&
                    (!(m = v->type->base) || !m->member || !(dict = m->member->members)))
                {
                    if (disc->errorf)
                        (*disc->errorf)(NiL, disc, 2, "%s: struct or union variable expected",  v->name);
                    return 0;
                }
                t = strchr(t, '.');
            }
            if (!(v = newof(0, Cxvariable_t, 1, strlen(name) + 1)))
            {
                if (disc->errorf)
                    (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
                return 0;
            }
            strcpy((char*)(v->name = (const char*)(v + 1)), name);
            v->reference = head;
            v->type = tail->variable->type;
            dtinsert(cx->variables, v);
        }
    }
    else if (!(v = (Cxvariable_t*)dtmatch(m->member->members, name)))
    {
        if (disc->errorf)
            (*disc->errorf)(cx, disc, 2, "%s: not a member of %s", name, m->name);
        return 0;
    }
    return v;
}

/*
 * cast var value to type
 * if var==0 or data==0 then the value is already in ret
 */

int
cxcast(Cx_t* cx, Cxoperand_t* ret, Cxvariable_t* var, Cxtype_t* type, void* data, const char* format)
{
    Cxinstruction_t x;
    Cxoperand_t val;
    Cxreference_t*  ref;
    Cxtype_t*   from;
    unsigned char*  map;
    char*       s;
    ssize_t     n;
    Cxunsigned_t    m;
    int     c;
    Cxoperand_t a;
    Cxoperand_t b;

    x.callout = 0;
    if (x.data.variable = var)
    {
        from = var->type;
        if (!type)
            type = from;
        if (data)
        {
            if (!cx->getf && !(cx->getf = cxcallout(cx, CX_GET, 0, 0, cx->disc)))
            {
                if (cx->disc->errorf)
                    (*cx->disc->errorf)(NiL, cx->disc, 3, "%s: cx CX_GET callout must be defined", var->name);
                return -1;
            }
            a.type = state.type_string;
            a.refs = 0;
            a.value.string.size = (a.value.string.data = (char*)format) ? strlen(format) : 0;
            ret->type = var->type;
            ret->value.number = 0;
            if (ref = var->reference)
            {
                b.type = var->type;
                b.refs = 0;
                b.value.number = 0;
                x.data.variable = ref->variable;
                x.type = ret->type = ref->variable->type;
                if (var->name != var->type->name && (*cx->getf)(cx, &x, ret, &a, &b, data, cx->disc))
                    return -1;
                while (ref = ref->next)
                {
                    b.type = x.data.variable->type;
                    x.data.variable = ref->variable;
                    ret->type = x.data.variable->type;
                    if ((*ref->member->getf)(cx, &x, ret, &a, &b, data, cx->disc))
                        return -1;
                }
            }
            else if ((*cx->getf)(cx, &x, ret, &a, NiL, data, cx->disc))
                return -1;
            if (type == state.type_void)
                return 0;
            from = ret->type;
        }
    }
    else
        from = 0;
    if (var && var->format.map && var->format.map->part && var->format.map->part->edit)
        cxsuball(cx, var->format.map->part, ret);
    if ((var && (c = var->format.code) || (c = type->format.code)) &&
        c != CC_NATIVE &&
        (CCCONVERT(c) || !(type->format.flags & CX_BINARY) && (c = CCOP(c, CC_NATIVE))) &&
        (map = ccmap(CCIN(c), CCOUT(c))))
    {
        if (ret->value.string.size > cx->ccsiz)
        {
            n = roundof(ret->value.string.size + 1, 32);
            if (!(cx->ccbuf = vmoldof(cx->vm, cx->ccbuf, char, n, 0)))
            {
                if (cx->disc->errorf)
                    (*cx->disc->errorf)(NiL, cx->disc, ERROR_SYSTEM|2, "out of space");
                return -1;
            }
            cx->ccsiz = n;
        }
        ret->value.string.data = (char*)ccmapcpy(map, cx->ccbuf, ret->value.string.data, ret->value.string.size);
    }
    if (ret->type->representation != type->representation)
    {
        val = *ret;
        if (cxisstring(type))
        {
            if (!var || !cxisnumber(from) || !var->format.map || format || cxnum2str(cx, &var->format, (Cxinteger_t)ret->value.number, &s))
            {
                if (ret->type->externalf)
                {
                    while ((n = (*ret->type->externalf)(cx, ret->type, format, var ? &var->format : (Cxformat_t*)0, &ret->value, cx->cvtbuf, cx->cvtsiz, cx->disc)) > cx->cvtsiz)
                    {
                        n = roundof(n + 1, 32);
                        if (!(cx->cvtbuf = vmoldof(cx->vm, cx->cvtbuf, char, n, 0)))
                        {
                            if (cx->disc->errorf)
                                (*cx->disc->errorf)(NiL, cx->disc, ERROR_SYSTEM|2, "out of space");
                            return -1;
                        }
                        cx->cvtsiz = n;
                    }
                    if (n < 0)
                        return -1;
                    ret->value.string.data = cx->cvtbuf;
                    ret->value.string.size = n;
                }
                else if (!cxisnumber(ret->type))
                    goto bad;
                else
                    ret->value.string.size = strlen(ret->value.string.data = sfprints("%Lg", val.value.number));
            }
            else
                ret->value.string.size = strlen(ret->value.string.data = s);
        }
        else if (cxisnumber(type) && var && cxisstring(from) && var->format.map && !cxstr2num(cx, &var->format, val.value.string.data, val.value.string.size, &m))
            ret->value.number = (Cxinteger_t)m;
#if 0
        else if (ret->type->representation != type->representation)
            goto bad;
#endif
        else if (!type->internalf || (*type->internalf)(cx, type, format, var ? &var->format : (Cxformat_t*)0, ret, val.value.string.data, val.value.string.size, cx->em, cx->disc) < 0)
            goto bad;
        ret->type = type;
    }
    return 0;
 bad:
    if ((x.callout = cxcallout(cx, CX_CAST, ret->type, type, cx->disc)) && !(*x.callout)(cx, &x, ret, NiL, &val, NiL, cx->disc))
        return 0;
    if (cx->disc->errorf)
        (*cx->disc->errorf)(cx, cx->disc, 2, "cannot cast %s to %s", ret->type->name, type->name);
    return -1;
}

/*
 * initialize the global state
 */

static void
initialize(Cxdisc_t* disc)
{
    register int        i;

    static const char   cx_alpha[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_$";
    static const char   cx_digit[] = "0123456789";
    static const char   cx_float[] = "_.#";
    static const char   cx_space[] = " \f\n\t\r\v";

    if (!state.initialized++)
    {
        table.opcode['+'] = CX_ADD;
        table.opcode['&'] = CX_AND;
        table.opcode['/'] = CX_DIV;
        table.opcode['>'] = CX_GT;
        table.opcode['~'] = CX_INV;
        table.opcode['<'] = CX_LT;
        table.opcode['%'] = CX_MOD;
        table.opcode['*'] = CX_MPY;
        table.opcode['!'] = CX_NOT;
        table.opcode['|'] = CX_OR;
        table.opcode['='] = CX_SET;
        table.opcode['-'] = CX_SUB;
        table.opcode['^'] = CX_XOR;

        table.comparison[CX_LOG] =
        table.comparison[CX_LT] =
        table.comparison[CX_LE] =
        table.comparison[CX_EQ] =
        table.comparison[CX_NE] =
        table.comparison[CX_MATCH] =
        table.comparison[CX_NOMATCH] =
        table.comparison[CX_GE] =
        table.comparison[CX_GT] =   1;

        table.logical[CX_ANDAND] =
        table.logical[CX_OROR] =
        table.logical[CX_NOT] =     1;

        table.precedence[CX_INV] =
        table.precedence[CX_NOT] =
        table.precedence[CX_UMINUS] =
        table.precedence[CX_UPLUS] =    15;
        table.precedence[CX_DIV] =
        table.precedence[CX_MOD] =
        table.precedence[CX_MPY] =  14;
        table.precedence[CX_ADD] =
        table.precedence[CX_SUB] =  13;
        table.precedence[CX_LSH] =
        table.precedence[CX_RSH] =  12;
        table.precedence[CX_GE] =
        table.precedence[CX_GT] =
        table.precedence[CX_LE] =
        table.precedence[CX_LT] =   11;
        table.precedence[CX_EQ] =
        table.precedence[CX_NE] =
        table.precedence[CX_MATCH] =
        table.precedence[CX_NOMATCH] =  10;
        table.precedence[CX_AND] =  9;
        table.precedence[CX_XOR] =  8;
        table.precedence[CX_AND] =
        table.precedence[CX_OR] =   7;
        table.precedence[CX_ANDAND] =   6;
        table.precedence[CX_OROR] = 5;
        table.precedence[CX_TST] =  4;
        table.precedence[CX_SET] =  3;
        table.precedence[CX_PAREN] =    2;
        table.precedence[CX_CALL] = 1;

        state.codedisc.key = offsetof(Cxcodeheader_t, op);
        state.codedisc.size = sizeof(Cxop_t);
        state.codedisc.link = offsetof(Cxcodeheader_t, header.link);
        state.listdisc.key = offsetof(Cxlistheader_t, name);
        state.listdisc.size = -1;
        state.listdisc.link = offsetof(Cxlistheader_t, header.list);
        state.namedisc.key = offsetof(Cxnameheader_t, name);
        state.namedisc.size = -1;
        state.namedisc.link = offsetof(Cxnameheader_t, header.link);

        if (!(state.libraries = dtopen(&state.namedisc, Dtqueue)) ||
            !(state.methods = dtopen(&state.namedisc, Dtoset)) ||
            !(state.types = dtopen(&state.namedisc, Dtoset)) ||
            !(state.callouts = dtopen(&state.codedisc, Dtoset)) ||
            !(state.recodes = dtopen(&state.codedisc, Dtoset)) ||
            !(state.maps = dtopen(&state.namedisc, Dtoset)) ||
            !(state.queries = dtopen(&state.namedisc, Dtoset)) ||
            !(state.constraints = dtopen(&state.namedisc, Dtoset)) ||
            !(state.edits = dtopen(&state.namedisc, Dtoset)) ||
            !(state.variables = dtopen(&state.namedisc, Dtoset)))
        {
            if (disc->errorf)
                (*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
            goto panic;
        }

        for (i = 0; i < elementsof(types); i++)
        {
            if (cxaddtype(NiL, &types[i].type, disc))
                goto panic;
            if (types[i].state)
                *types[i].state = cxtype(NiL, types[i].type.name, disc);
        }
        for (i = 0; i < elementsof(callouts); i++)
            if (cxaddcallout(NiL, &callouts[i], disc))
                goto panic;
        for (i = 0; i < elementsof(builtins); i++)
            if (cxaddvariable(NiL, &builtins[i], disc))
                goto panic;

        for (i = 0; i < (sizeof(cx_alpha) - 1); i++)
            state.ctype[cx_alpha[i]] |= CX_CTYPE_ALPHA;
        for (i = 0; i < (sizeof(cx_digit) - 1); i++)
            state.ctype[cx_digit[i]] |= CX_CTYPE_DIGIT;
        for (i = 0; i < (sizeof(cx_float) - 1); i++)
            state.ctype[cx_float[i]] |= CX_CTYPE_FLOAT;
        for (i = 0; i < (sizeof(cx_space) - 1); i++)
            state.ctype[cx_space[i]] |= CX_CTYPE_SPACE;
    }
    return;
 panic:
    error(ERROR_PANIC, "%s library initialization error", CX_ID);
}

/*
 * return initialized global state pointer
 */

Cxstate_t*
cxstate(Cxdisc_t* disc)
{
    if (!state.initialized)
        initialize(disc);
    return &state;
}

/*
 * return the input location (path,record,offset) or the empty string
 */

char*
cxlocation(Cx_t* cx, void* data)
{
    char*   s;

    return cx->disc->locationf && (s = (*cx->disc->locationf)(cx, data, cx->disc)) ? s : "";
}

/*
 * for when only a 0-terminated string will do
 * copy n bytes of s to cvt buffer and 0-terminate it
 * pointer to cvt buf returned
 * data ok until the next cvtbuf() call
 */

char*
cxcvt(register Cx_t* cx, const char* s, size_t n)
{
    if (cx->cvtsiz <= n || !cx->cvtbuf)
    {
        cx->cvtsiz = roundof(n + 1, 32);
        if (!(cx->cvtbuf = vmoldof(cx->vm, cx->cvtbuf, char, cx->cvtsiz, 0)))
        {
            if (cx->disc->errorf)
                (*cx->disc->errorf)(NiL, cx->disc, ERROR_SYSTEM|2, "out of space");
            return (char*)s;
        }
    }
    memcpy(cx->cvtbuf, s, n);
    cx->cvtbuf[n] = 0;
    return cx->cvtbuf;
}