GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2011 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 */

#include "config.h"

#include <math.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>

#include "vcc_compile.h"
#include "vjsn.h"

struct expr {
        unsigned        magic;
#define EXPR_MAGIC      0x38c794ab
        vcc_type_t      fmt;
        struct vsb      *vsb;
        uint8_t         constant;
#define EXPR_VAR        (1<<0)
#define EXPR_CONST      (1<<1)
#define EXPR_STR_CONST  (1<<2)          // Last string elem is "..."
        struct token    *t1, *t2;
        struct symbol   *instance;
        int             nstr;
};

/*--------------------------------------------------------------------
 * Facility for carrying expressions around and do text-processing on
 * them.
 */

static inline int
vcc_isconst(const struct expr *e)
{
        AN(e->constant);
        return (e->constant & EXPR_CONST);
}

static inline int
vcc_islit(const struct expr *e)
{
        AN(e->constant);
        return (e->constant & EXPR_STR_CONST);
}

static const char *
vcc_utype(vcc_type_t t)
{
        if (t == STRINGS || t->stringform)
                t = STRING;
        return (t->name);
}

static vcc_type_t
vcc_stringstype(vcc_type_t t)
{
        return (t->stringform ? STRINGS : t);
}


static void vcc_expr0(struct vcc *tl, struct expr **e, vcc_type_t fmt);
static void vcc_expr_cor(struct vcc *tl, struct expr **e, vcc_type_t fmt);
static void vcc_expr_typecheck(struct vcc *tl, struct expr **e, vcc_type_t fmt,
    struct token *t1);

static struct expr *
vcc_new_expr(vcc_type_t fmt)
{
        struct expr *e;

        ALLOC_OBJ(e, EXPR_MAGIC);
        AN(e);
        e->vsb = VSB_new_auto();
        e->fmt = fmt;
        e->constant = EXPR_VAR;
        return (e);
}

static struct expr * v_printflike_(2, 3)
vcc_mk_expr(vcc_type_t fmt, const char *str, ...)
{
        va_list ap;
        struct expr *e;

        e = vcc_new_expr(fmt);
        va_start(ap, str);
        VSB_vprintf(e->vsb, str, ap);
        va_end(ap);
        AZ(VSB_finish(e->vsb));
        return (e);
}

static void
vcc_delete_expr(struct expr *e)
{
        if (e == NULL)
                return;
        CHECK_OBJ(e, EXPR_MAGIC);
        VSB_destroy(&e->vsb);
        FREE_OBJ(e);
}

/*--------------------------------------------------------------------
 * We want to get the indentation right in the emitted C code so we have
 * to represent it symbolically until we are ready to render.
 *
 * Many of the operations have very schematic output syntaxes, so we
 * use the same facility to simplify the text-processing of emitting
 * a given operation on two subexpressions.
 *
 * We use '\v' as the magic escape character.
 *      \v1  insert subexpression 1
 *      \v2  insert subexpression 2
 *      \vS  insert subexpression 1(STRINGS) as STRING
 *      \vs  insert subexpression 2(STRINGS) as STRING
 *      \vT  insert subexpression 1(STRINGS) as STRANDS
 *      \vt  insert subexpression 2(STRINGS) as STRANDS
 *      \v+  increase indentation
 *      \v-  decrease indentation
 *      anything else is literal
 *
 * When editing, we check if any of the subexpressions contain a newline
 * and issue it as an indented block of so.
 *
 * XXX: check line lengths in edit, should pass indent in for this
 */

static void
vcc_strands_edit(const struct expr *e1, const struct expr *e2)
{

        assert(e2->fmt == STRANDS || e2->fmt == STRINGS);

        if (e2->fmt == STRANDS)
                VSB_cat(e1->vsb, VSB_data(e2->vsb));
        else if (e2->nstr == 0)
                VSB_printf(e1->vsb, "vrt_null_strands");
        else if (e2->nstr == 1)
                VSB_printf(e1->vsb, "TOSTRAND(%s)", VSB_data(e2->vsb));
        else {
                VSB_printf(e1->vsb, "TOSTRANDS(%d,\v+\n%s\v-)",
                   e2->nstr, VSB_data(e2->vsb));
        }
}

static struct expr *
vcc_expr_edit(struct vcc *tl, vcc_type_t fmt, const char *p, struct expr *e1,
    struct expr *e2)
{
        struct expr *e, *e3;
        int nl = 1;

        (void) tl;

        AN(e1);
        e = vcc_new_expr(fmt);
        while (*p != '\0') {
                if (*p != '\v') {
                        if (*p != '\n' || !nl)
                                VSB_putc(e->vsb, *p);
                        nl = (*p == '\n');
                        p++;
                        continue;
                }
                assert(*p == '\v');
                switch (*++p) {
                case '+': VSB_cat(e->vsb, "\v+"); nl = 0; break;
                case '-': VSB_cat(e->vsb, "\v-"); nl = 0; break;
                case 'S':
                case 's':
                        e3 = (*p == 'S' ? e1 : e2);
                        AN(e3);
                        assert(e1->fmt == STRINGS);
                        if (e3->nstr > 1) {
                                VSB_cat(e->vsb,
                                    "\nVRT_STRANDS_string(ctx,\v+\n");
                                vcc_strands_edit(e, e3);
                                VSB_cat(e->vsb,
                                    "\v-\n)\n");
                        } else {
                                VSB_cat(e->vsb, VSB_data(e3->vsb));
                        }
                        break;
                case 'T':
                case 't':
                        e3 = (*p == 'T' ? e1 : e2);
                        AN(e3);
                        vcc_strands_edit(e, e3);
                        break;
                case '1':
                        VSB_cat(e->vsb, VSB_data(e1->vsb));
                        break;
                case '2':
                        AN(e2);
                        VSB_cat(e->vsb, VSB_data(e2->vsb));
                        break;
                default:
                        WRONG("Illegal edit in VCC expression");
                }
                p++;
        }
        AZ(VSB_finish(e->vsb));
        e->t1 = e1->t1;
        e->t2 = e1->t2;
        if (e2 != NULL)
                e->t2 = e2->t2;
        vcc_delete_expr(e1);
        vcc_delete_expr(e2);
        return (e);
}

/*--------------------------------------------------------------------
 * Expand finished expression into C-source code
 */

static void
vcc_expr_fmt(struct vsb *d, int ind, const struct expr *e1)
{
        char *p;
        int i;

        if (!e1->fmt->noindent) {
                for (i = 0; i < ind; i++)
                        VSB_putc(d, ' ');
        }
        p = VSB_data(e1->vsb);
        while (*p != '\0') {
                if (*p == '\n') {
                        VSB_putc(d, '\n');
                        if (*++p == '\0')
                                break;
                        for (i = 0; i < ind; i++)
                                VSB_putc(d, ' ');
                } else if (*p != '\v') {
                        VSB_putc(d, *p++);
                } else {
                        switch (*++p) {
                        case '+': ind += INDENT; break;
                        case '-': ind -= INDENT; break;
                        default:  WRONG("Illegal format in VCC expression");
                        }
                        p++;
                }
        }
}

/*--------------------------------------------------------------------
 */

static void
vcc_expr_tobool(struct vcc *tl, struct expr **e)
{

        if ((*e)->fmt == BOOL)
                return;
        if ((*e)->fmt == BACKEND || (*e)->fmt == INT)
                *e = vcc_expr_edit(tl, BOOL, "(\v1 != 0)", *e, NULL);
        else if ((*e)->fmt == DURATION)
                *e = vcc_expr_edit(tl, BOOL, "(\v1 > 0)", *e, NULL);
        else if ((*e)->fmt == STRINGS)
                *e = vcc_expr_edit(tl, BOOL, "VRT_Strands2Bool(\vT)", *e, NULL);
        /*
         * We do not provide automatic folding from REAL to BOOL
         * because comparing to zero is seldom an exact science
         * and we want to force people to explicitly get it right.
         */
}

/*--------------------------------------------------------------------
 */

static void
vcc_expr_tostring(struct vcc *tl, struct expr **e)
{
        const char *p;
        uint8_t constant = EXPR_VAR;

        CHECK_OBJ_NOTNULL(*e, EXPR_MAGIC);
        assert((*e)->fmt != STRINGS);

        p = (*e)->fmt->tostring;
        if (p != NULL) {
                AN(*p);
                *e = vcc_expr_edit(tl, STRINGS, p, *e, NULL);
                (*e)->constant = constant;
                (*e)->nstr = 1;
        } else {
                VSB_printf(tl->sb,
                    "Cannot convert %s to STRING.\n",
                    vcc_utype((*e)->fmt));
                vcc_ErrWhere2(tl, (*e)->t1, tl->t);
        }
}

/*--------------------------------------------------------------------
 */

void v_matchproto_(sym_expr_t)
vcc_Eval_Handle(struct vcc *tl, struct expr **e, struct token *t,
    struct symbol *sym, vcc_type_t type)
{

        (void)t;
        (void)tl;
        AN(sym->rname);
        AZ(type->stringform);

        if (sym->type->tostring == NULL &&
            sym->type != STRING && type == STRINGS) {
                *e = vcc_mk_expr(STRINGS, "\"%s\"", sym->name);
                (*e)->nstr = 1;
                (*e)->constant |= EXPR_CONST | EXPR_STR_CONST;
        } else {
                *e = vcc_mk_expr(sym->type, "%s", sym->rname);
                (*e)->constant = EXPR_VAR;
                (*e)->nstr = 1;
                if ((*e)->fmt == STRING)
                        (*e)->fmt = STRINGS;
        }
}

void v_matchproto_(sym_expr_t)
vcc_Eval_Sub(struct vcc *tl, struct expr **e, struct token *t,
    struct symbol *sym, vcc_type_t type)
{

        (void)t;
        (void)tl;
        AN(sym->rname);
        AZ(type->stringform);

        assert (sym->type == SUB);

        if (type == SUB) {
                *e = vcc_mk_expr(sym->type, "%s", sym->rname);
                (*e)->constant = EXPR_CONST;
                return;
        }

        VSB_printf(tl->sb, "Symbol '%s' can only be used as a %s expression\n",
            sym->name, sym->type->name);
        vcc_ErrWhere(tl, tl->t);
}

/*--------------------------------------------------------------------
 */

void v_matchproto_(sym_expr_t)
vcc_Eval_Var(struct vcc *tl, struct expr **e, struct token *t,
    struct symbol *sym, vcc_type_t type)
{

        (void)type;
        vcc_AddUses(tl, t, NULL, sym, XREF_READ);
        ERRCHK(tl);
        *e = vcc_mk_expr(sym->type, "%s", sym->rname);
        (*e)->constant = EXPR_VAR;
        (*e)->nstr = 1;
        if ((*e)->fmt == STRING)
                (*e)->fmt = STRINGS;
}

void v_matchproto_(sym_expr_t)
vcc_Eval_ProtectedHeader(struct vcc *tl, struct expr **e, struct token *t,
    struct symbol *sym, vcc_type_t type)
{

        AN(sym);
        AZ(sym->lorev);

        vcc_Header_Fh(tl, sym);
        sym->eval = vcc_Eval_Var;
        vcc_Eval_Var(tl, e, t, sym, type);
}

/*--------------------------------------------------------------------
 */

static struct expr *
vcc_priv_arg(struct vcc *tl, const char *p, struct symbol *sym)
{
        char buf[64];
        struct inifin *ifp;
        const char *f = NULL;

        AN(sym);
        AN(sym->vmod_name);

        if (!strcmp(p, "PRIV_VCL"))
                return (vcc_mk_expr(VOID, "&vmod_priv_%s", sym->vmod_name));

        if (!strcmp(p, "PRIV_CALL")) {
                bprintf(buf, "vmod_priv_%u", tl->unique++);
                ifp = New_IniFin(tl);
                Fh(tl, 0, "static struct vmod_priv %s;\n", buf);
                VSB_printf(ifp->fin, "\tVRT_priv_fini(ctx, &%s);", buf);
                return (vcc_mk_expr(VOID, "&%s", buf));
        }

        if (!strcmp(p, "PRIV_TASK"))
                f = "task";
        else if (!strcmp(p, "PRIV_TOP")) {
                f = "top";
                sym->r_methods &= VCL_MET_TASK_C;
        } else {
                WRONG("Wrong PRIV_ type");
        }
        AN(f);

        return (vcc_mk_expr(VOID, "VRT_priv_%s(ctx, &VGC_vmod_%s)",
            f, sym->vmod_name));
}

struct func_arg {
        vcc_type_t              type;
        const struct vjsn_val   *enums;
        const char              *cname;
        const char              *name;
        const char              *val;
        struct expr             *result;
        int                     avail;
        int                     optional;
        VTAILQ_ENTRY(func_arg)  list;
};

static struct expr *
vcc_do_enum(struct vcc *tl, const char *cfunc, int len, const char *ptr)
{
        const char *r;

        (void)tl;
        r = strchr(cfunc, '.');
        AN(r);
        return (vcc_mk_expr(VOID, "*%.*s.enum_%.*s",
            (int)(r - cfunc), cfunc, len, ptr));
}

static void
vcc_do_arg(struct vcc *tl, const char *cfunc, struct func_arg *fa)
{
        struct expr *e2;
        struct vjsn_val *vv;

        if (fa->type == ENUM) {
                ExpectErr(tl, ID);
                ERRCHK(tl);
                VTAILQ_FOREACH(vv, &fa->enums->children, list)
                        if (vcc_IdIs(tl->t, vv->value))
                                break;
                if (vv == NULL) {
                        VSB_cat(tl->sb, "Wrong enum value.");
                        VSB_cat(tl->sb, "  Expected one of:\n");
                        VTAILQ_FOREACH(vv, &fa->enums->children, list)
                                VSB_printf(tl->sb, "\t%s\n", vv->value);
                        vcc_ErrWhere(tl, tl->t);
                        return;
                }
                fa->result = vcc_do_enum(tl, cfunc, PF(tl->t));
                SkipToken(tl, ID);
        } else {
                if (fa->type == SUB)
                        tl->subref++;
                vcc_expr0(tl, &e2, fa->type);
                ERRCHK(tl);
                assert(e2->fmt == fa->type);
                fa->result = e2;
        }
        fa->avail = 1;
}

static void
vcc_func(struct vcc *tl, struct expr **e, const void *priv,
    const char *extra, struct symbol *sym)
{
        vcc_type_t rfmt;
        const char *cfunc;
        struct expr *e1;
        struct func_arg *fa, *fa2;
        VTAILQ_HEAD(,func_arg) head;
        struct token *tf, *t1;
        const struct vjsn_val *vv, *vvp;
        const char *sa, *extra_sep;
        char ssa[64];
        int n;

        CAST_OBJ_NOTNULL(vv, priv, VJSN_VAL_MAGIC);
        assert(vjsn_is_array(vv));
        vv = VTAILQ_FIRST(&vv->children);
        rfmt = VCC_Type(VTAILQ_FIRST(&vv->children)->value);
        AN(rfmt);
        vv = VTAILQ_NEXT(vv, list);
        cfunc = vv->value;
        vv = VTAILQ_NEXT(vv, list);
        sa = vv->value;
        if (*sa == '\0') {
                sa = NULL;
        }
        vv = VTAILQ_NEXT(vv, list);
        if (sym->kind == SYM_METHOD) {
                if (*e == NULL) {
                        VSB_cat(tl->sb, "Syntax error.");
                        tl->err = 1;
                        return;
                }
                vcc_NextToken(tl);
                AZ(extra);
                AN((*e)->instance);
                extra = (*e)->instance->rname;
        }
        tf = VTAILQ_PREV(tl->t, tokenhead, list);
        SkipToken(tl, '(');
        if (extra == NULL) {
                extra = "";
                extra_sep = "";
        } else {
                AN(*extra);
                extra_sep = ", ";
        }
        VTAILQ_INIT(&head);
        for (;vv != NULL; vv = VTAILQ_NEXT(vv, list)) {
                assert(vjsn_is_array(vv));
                fa = calloc(1, sizeof *fa);
                AN(fa);
                VTAILQ_INSERT_TAIL(&head, fa, list);

                vvp = VTAILQ_FIRST(&vv->children);
                if (!memcmp(vvp->value, "PRIV_", 5)) {
                        fa->result = vcc_priv_arg(tl, vvp->value, sym);
                        vvp = VTAILQ_NEXT(vvp, list);
                        if (vvp != NULL)
                                fa->name = vvp->value;
                        continue;
                }
                fa->type = VCC_Type(vvp->value);
                AN(fa->type);
                vvp = VTAILQ_NEXT(vvp, list);
                if (vvp != NULL) {
                        fa->name = vvp->value;
                        vvp = VTAILQ_NEXT(vvp, list);
                        if (vvp != NULL) {
                                fa->val = vvp->value;
                                vvp = VTAILQ_NEXT(vvp, list);
                                if (vvp != NULL) {
                                        fa->enums = vvp;
                                        vvp = VTAILQ_NEXT(vvp, list);
                                }
                        }
                }
                if (sa != NULL && vvp != NULL && vjsn_is_true(vvp)) {
                        fa->optional = 1;
                        vvp = VTAILQ_NEXT(vvp, list);
                }
                AZ(vvp);
        }

        VTAILQ_FOREACH(fa, &head, list) {
                if (tl->t->tok == ')')
                        break;
                if (fa->result != NULL)
                        continue;
                if (tl->t->tok == ID) {
                        t1 = VTAILQ_NEXT(tl->t, list);
                        if (t1->tok == '=')
                                break;
                }
                vcc_do_arg(tl, cfunc, fa);
                if (tl->err)
                        VSB_printf(tl->sb, "Expected argument: %s %s\n\n",
                            fa->type->name,
                            fa->name ? fa->name : "(unnamed argument)");
                ERRCHK(tl);
                if (tl->t->tok == ')')
                        break;
                SkipToken(tl, ',');
        }
        while (tl->t->tok == ID) {
                VTAILQ_FOREACH(fa, &head, list) {
                        if (fa->name == NULL)
                                continue;
                        if (vcc_IdIs(tl->t, fa->name))
                                break;
                }
                if (fa == NULL) {
                        VSB_printf(tl->sb, "Unknown argument '%.*s'\n",
                            PF(tl->t));
                        vcc_ErrWhere(tl, tl->t);
                        return;
                }
                if (fa->result != NULL) {
                        AN(fa->name);
                        VSB_printf(tl->sb, "Argument '%s' already used\n",
                            fa->name);
                        vcc_ErrWhere(tl, tl->t);
                        return;
                }
                vcc_NextToken(tl);
                SkipToken(tl, '=');
                vcc_do_arg(tl, cfunc, fa);
                ERRCHK(tl);
                if (tl->t->tok == ')')
                        break;
                SkipToken(tl, ',');
        }

        if (sa != NULL)
                e1 = vcc_mk_expr(rfmt, "%s(ctx%s%s,\v+\n&(%s)\v+ {\n",
                    cfunc, extra_sep, extra, sa);
        else
                e1 = vcc_mk_expr(rfmt, "%s(ctx%s%s\v+",
                    cfunc, extra_sep, extra);
        n = 0;
        VTAILQ_FOREACH_SAFE(fa, &head, list, fa2) {
                n++;
                if (fa->optional) {
                        AN(fa->name);
                        bprintf(ssa, "\v1.valid_%s = %d,\n",
                            fa->name, fa->avail);
                        e1 = vcc_expr_edit(tl, e1->fmt, ssa, e1, NULL);
                }
                if (fa->result == NULL && fa->type == ENUM && fa->val != NULL)
                        fa->result = vcc_do_enum(tl, cfunc, strlen(fa->val), fa->val);
                if (fa->result == NULL && fa->val != NULL)
                        fa->result = vcc_mk_expr(fa->type, "%s", fa->val);
                if (fa->result != NULL && sa != NULL) {
                        if (fa->name)
                                bprintf(ssa, "\v1.%s = \v2,\n", fa->name);
                        else
                                bprintf(ssa, "\v1.arg%d = \v2,\n", n);
                        e1 = vcc_expr_edit(tl, e1->fmt, ssa, e1, fa->result);
                } else if (fa->result != NULL) {
                        e1 = vcc_expr_edit(tl, e1->fmt, "\v1,\n\v2",
                            e1, fa->result);
                } else if (!fa->optional) {
                        if (fa->name)
                                VSB_printf(tl->sb, "Argument '%s' missing\n",
                                    fa->name);
                        else
                                VSB_printf(tl->sb, "Argument %d missing\n", n);
                        vcc_ErrWhere(tl, tl->t);
                }
                free(fa);
        }
        if (sa != NULL) {
                *e = vcc_expr_edit(tl, e1->fmt, "\v1\v-\n}\v-\n)", e1, NULL);
        } else {
                *e = vcc_expr_edit(tl, e1->fmt, "\v1\v-\n)", e1, NULL);
        }
        SkipToken(tl, ')');
        vcc_AddUses(tl, tf, NULL, sym, XREF_READ);
}


/*--------------------------------------------------------------------
 */

void
vcc_Eval_Func(struct vcc *tl, const struct vjsn_val *spec,
    const char *extra, struct symbol *sym)
{
        struct expr *e = NULL;

        vcc_func(tl, &e, spec, extra, sym);
        if (tl->err)
                VSB_cat(tl->sb, "While compiling function call:\n");
        ERRCHK(tl);
        vcc_expr_fmt(tl->fb, tl->indent, e);
        VSB_cat(tl->fb, ";\n");
        vcc_delete_expr(e);
}

/*--------------------------------------------------------------------
 */

void v_matchproto_(sym_expr_t)
vcc_Eval_SymFunc(struct vcc *tl, struct expr **e, struct token *t,
    struct symbol *sym, vcc_type_t fmt)
{

        (void)t;
        (void)fmt;
        assert(sym->kind == SYM_FUNC || sym->kind == SYM_METHOD);
        AN(sym->eval_priv);

        vcc_func(tl, e, sym->eval_priv, sym->extra, sym);
        ERRCHK(tl);
        if ((*e)->fmt == STRING) {
                (*e)->fmt = STRINGS;
                (*e)->nstr = 1;
        }
}

/*--------------------------------------------------------------------
 */

static void
vcc_number(struct vcc *tl, struct expr **e, vcc_type_t fmt, const char *sign)
{
        VCL_INT vi;
        struct expr *e1;
        struct token *t;

        assert(fmt != VOID);
        if (fmt == BYTES) {
                vcc_ByteVal(tl, &vi);
                ERRCHK(tl);
                e1 = vcc_mk_expr(BYTES, "%ju", (intmax_t)vi);
        } else {
                t = tl->t;
                vcc_NextToken(tl);
                if (tl->t->tok == ID) {
                        e1 = vcc_mk_expr(DURATION, "%s%.3f * %g",
                            sign, t->num, vcc_DurationUnit(tl));
                        ERRCHK(tl);
                } else if (fmt == REAL || t->tok == FNUM) {
                        e1 = vcc_mk_expr(REAL, "%s%.3f", sign, t->num);
                } else {
                        e1 = vcc_mk_expr(INT, "%s%.0f", sign, t->num);
                }
        }
        e1->constant = EXPR_CONST;
        *e = e1;
}

/*--------------------------------------------------------------------
 * SYNTAX:
 *    Expr5:
 *      '(' ExprCor ')'
 *      symbol
 *      CNUM
 *      FNUM
 *      CSTR
 *      CBLOB
 */

static void
vcc_expr5(struct vcc *tl, struct expr **e, vcc_type_t fmt)
{
        struct expr *e1, *e2;
        const char *ip, *sign;
        struct token *t, *t1;
        struct symbol *sym;

        sign = "";
        *e = NULL;
        if (tl->t->tok == '(') {
                SkipToken(tl, '(');
                vcc_expr_cor(tl, &e2, fmt);
                ERRCHK(tl);
                SkipToken(tl, ')');
                if (e2->fmt == STRINGS)
                        *e = e2;
                else
                        *e = vcc_expr_edit(tl, e2->fmt, "(\v1)", e2, NULL);
                return;
        }
        switch (tl->t->tok) {
        case ID:
                t = tl->t;
                t1 = vcc_PeekToken(tl);
                AN(t1);
                sym = VCC_SymbolGet(tl, SYM_MAIN, SYM_NONE,
                    SYMTAB_PARTIAL_NOERR, XREF_REF);
                if (sym == NULL && fmt->global_pfx != NULL && t1->tok != '.') {
                        sym = VCC_SymbolGet(tl, SYM_MAIN, SYM_NONE,
                            SYMTAB_CREATE, XREF_REF);
                        ERRCHK(tl);
                        AN(sym);
                        VCC_GlobalSymbol(sym, fmt);
                }
                ERRCHK(tl);
                if (sym == NULL)
                        AZ(VCC_SymbolGet(tl, SYM_MAIN, SYM_NONE,
                            SYMTAB_PARTIAL, XREF_REF));
                ERRCHK(tl);
                AN(sym);
                if (sym->kind == SYM_INSTANCE) {
                        AZ(*e);
                        *e = vcc_new_expr(sym->type);
                        (*e)->instance = sym;
                        return;
                }
                if (sym->kind == SYM_FUNC && sym->type == VOID) {
                        VSB_cat(tl->sb, "Function returns VOID:\n");
                        vcc_ErrWhere(tl, tl->t);
                        return;
                }
                if (sym->eval != NULL) {
                        AN(sym->eval);
                        AZ(*e);
                        sym->eval(tl, e, t, sym, fmt);
                        if (tl->err) {
                                VSB_cat(tl->sb,
                                    "While compiling function call:\n\n");
                                vcc_ErrWhere2(tl, t, tl->t);
                        }
                        ERRCHK(tl);
                        /* Unless asked for a HEADER, fold to string here */
                        if (*e && fmt != HEADER && (*e)->fmt == HEADER) {
                                vcc_expr_tostring(tl, e);
                                ERRCHK(tl);
                        }
                        return;
                }
                VSB_printf(tl->sb,
                    "Symbol '%.*s' type (%s) cannot be used in expression.\n",
                    PF(t), sym->kind->name);
                vcc_ErrWhere(tl, t);
                if (sym->def_b != NULL) {
                        VSB_cat(tl->sb, "That symbol was defined here:\n");
                        vcc_ErrWhere(tl, sym->def_b);
                }
                return;
        case CSTR:
                assert(fmt != VOID);
                if (fmt == IP) {
                        if (*tl->t->dec == '/') {
                                /*
                                 * On some platforms (e.g. FreeBSD),
                                 * getaddrinfo(3) may resolve a path to a
                                 * sockaddr_un if it happens to exist and
                                 * is a socket. So don't let that happen.
                                 */
                                VSB_cat(tl->sb,
                                    "Cannot convert to an IP address: ");
                                vcc_ErrToken(tl, tl->t);
                                vcc_ErrWhere(tl, tl->t);
                                return;
                        }
                        Resolve_Sockaddr(tl, tl->t->dec, "80",
                            &ip, NULL, &ip, NULL, NULL, 1,
                            tl->t, "IP constant");
                        ERRCHK(tl);
                        e1 = vcc_mk_expr(IP, "%s", ip);
                        ERRCHK(tl);
                } else if (fmt == REGEX) {
                        e1 = vcc_new_expr(REGEX);
                        vcc_regexp(tl, e1->vsb);
                        AZ(VSB_finish(e1->vsb));
                } else {
                        e1 = vcc_new_expr(STRINGS);
                        EncToken(e1->vsb, tl->t);
                        AZ(VSB_finish(e1->vsb));
                        e1->constant |= EXPR_STR_CONST;
                        e1->nstr = 1;
                }
                e1->t1 = tl->t;
                e1->constant |= EXPR_CONST;
                vcc_NextToken(tl);
                *e = e1;
                return;
        case '-':
                if (fmt != INT &&
                    fmt != REAL &&
                    fmt != DURATION &&
                    fmt != STRINGS)
                        break;
                vcc_NextToken(tl);
                if (tl->t->tok != FNUM && tl->t->tok != CNUM) {
                        vcc_expr_cor(tl, &e1, fmt);
                        ERRCHK(tl);
                        *e = vcc_expr_edit(tl, e1->fmt, "-(\v1)", e1, NULL);
                        return;
                }
                sign = "-";
                /* FALLTHROUGH */
        case FNUM:
        case CNUM:
                vcc_number(tl, e, fmt, sign);
                return;
        case CBLOB:
                e1 = vcc_new_expr(BLOB);
                VSB_printf(e1->vsb, "%s", tl->t->dec);
                AZ(VSB_finish(e1->vsb));
                e1->constant |= EXPR_STR_CONST;
                e1->t1 = tl->t;
                vcc_NextToken(tl);
                *e = e1;
                return;
        default:
                break;
        }
        VSB_cat(tl->sb, "Unknown token ");
        vcc_ErrToken(tl, tl->t);
        VSB_printf(tl->sb, " when looking for %s\n\n", vcc_utype(fmt));
        vcc_ErrWhere(tl, tl->t);
}

/*--------------------------------------------------------------------
 * SYNTAX:
 *    Expr4:
 *      Expr5 [ '.' (type_attribute | type_method()) ]*
 */

void
vcc_Eval_TypeMethod(struct vcc *tl, struct expr **e, struct token *t,
    struct symbol *sym, vcc_type_t fmt)
{
        const char *impl;

        (void)t;
        impl = VCC_Type_EvalMethod(tl, sym);
        ERRCHK(tl);
        AN(impl);
        *e = vcc_expr_edit(tl, fmt, impl, *e, NULL);
}

static void
vcc_expr4(struct vcc *tl, struct expr **e, vcc_type_t fmt)
{
        struct symbol *sym;

        *e = NULL;
        vcc_expr5(tl, e, fmt);
        ERRCHK(tl);
        AN(*e);
        while (tl->t->tok == '.') {
                vcc_NextToken(tl);
                ExpectErr(tl, ID);

                sym = VCC_TypeSymbol(tl, SYM_METHOD, (*e)->fmt);
                if (sym == NULL) {
                        VSB_cat(tl->sb, "Unknown property ");
                        vcc_ErrToken(tl, tl->t);
                        VSB_printf(tl->sb, " for type %s\n", (*e)->fmt->name);
                        vcc_ErrWhere(tl, tl->t);
                        return;
                }

                AN(sym->eval);
                sym->eval(tl, e, tl->t, sym, sym->type);
                ERRCHK(tl);
                if ((*e)->fmt == STRING) {
                        (*e)->fmt = STRINGS;
                        (*e)->nstr = 1;
                }
        }
}

/*--------------------------------------------------------------------
 * SYNTAX:
 *    ExprMul:
 *      Expr4 { {'*'|'/'|'%'} Expr4 } *
 */

static void
vcc_expr_mul(struct vcc *tl, struct expr **e, vcc_type_t fmt)
{
        struct expr *e2;
        vcc_type_t f2;
        struct token *tk;
        char buf[24];

        *e = NULL;
        vcc_expr4(tl, e, fmt);
        ERRCHK(tl);
        AN(*e);

        while (tl->t->tok == '*' || tl->t->tok == '/' || tl->t->tok == '%') {
                if (tl->t->tok == '%' && ((*e)->fmt != INT)) {
                        VSB_cat(tl->sb, "Operator % only possible on INT.\n");
                        vcc_ErrWhere(tl, tl->t);
                        return;
                }
                f2 = (*e)->fmt->multype;
                if (f2 == NULL) {
                        VSB_printf(tl->sb,
                            "Operator %.*s not possible on type %s.\n",
                            PF(tl->t), vcc_utype((*e)->fmt));
                        vcc_ErrWhere(tl, tl->t);
                        return;
                }
                tk = tl->t;
                vcc_NextToken(tl);
                vcc_expr4(tl, &e2, f2);
                ERRCHK(tl);
                if (e2->fmt != INT && e2->fmt != f2) {
                        VSB_printf(tl->sb, "%s %.*s %s not possible.\n",
                            vcc_utype((*e)->fmt), PF(tk), vcc_utype(e2->fmt));
                        vcc_ErrWhere(tl, tk);
                        return;
                }
                bprintf(buf, "(\v1%c\v2)", tk->tok);
                *e = vcc_expr_edit(tl, (*e)->fmt, buf, *e, e2);
        }
}

/*--------------------------------------------------------------------
 * SYNTAX:
 *    ExprAdd:
 *      ExprMul { {'+'|'-'} ExprMul } *
 */

static const struct adds {
        unsigned        op;
        vcc_type_t      a;
        vcc_type_t      b;
        vcc_type_t      fmt;
} vcc_adds[] = {
        { '+', BYTES,           BYTES,          BYTES },
        { '-', BYTES,           BYTES,          BYTES },
        { '+', DURATION,        DURATION,       DURATION },
        { '-', DURATION,        DURATION,       DURATION },
        { '+', INT,             INT,            INT },
        { '-', INT,             INT,            INT },
        { '+', INT,             REAL,           REAL },
        { '-', INT,             REAL,           REAL },
        { '+', REAL,            INT,            REAL },
        { '-', REAL,            INT,            REAL },
        { '+', REAL,            REAL,           REAL },
        { '-', REAL,            REAL,           REAL },
        { '-', TIME,            TIME,           DURATION },
        { '+', TIME,            DURATION,       TIME },
        { '-', TIME,            DURATION,       TIME },

        { EOI, VOID,            VOID,           VOID }
};

static void
vcc_expr_add(struct vcc *tl, struct expr **e, vcc_type_t fmt)
{
        const struct adds *ap;
        struct expr  *e2;
        struct token *tk;
        int lit, n;

        *e = NULL;
        vcc_expr_mul(tl, e, fmt);
        ERRCHK(tl);

        while (tl->t->tok == '+' || tl->t->tok == '-') {
                tk = tl->t;
                for (ap = vcc_adds; ap->op != EOI; ap++)
                        if (tk->tok == ap->op && (*e)->fmt == ap->a)
                                break;
                vcc_NextToken(tl);
                if (ap->op == EOI && fmt == STRINGS)
                        vcc_expr_mul(tl, &e2, STRINGS);
                else
                        vcc_expr_mul(tl, &e2, (*e)->fmt);
                ERRCHK(tl);

                for (ap = vcc_adds; ap->op != EOI; ap++)
                        if (tk->tok == ap->op && (*e)->fmt == ap->a &&
                            e2->fmt == ap->b)
                                break;

                if (ap->op == '+') {
                        *e = vcc_expr_edit(tl, ap->fmt, "(\v1 + \v2)", *e, e2);
                } else if (ap->op == '-') {
                        *e = vcc_expr_edit(tl, ap->fmt, "(\v1 - \v2)", *e, e2);
                } else if (tk->tok == '+' &&
                    ((*e)->fmt == STRINGS || fmt == STRINGS)) {
                        if ((*e)->fmt != STRINGS)
                                vcc_expr_tostring(tl, e);
                        if (e2->fmt != STRINGS)
                                vcc_expr_tostring(tl, &e2);
                        if (vcc_islit(*e) && vcc_isconst(e2)) {
                                lit = vcc_islit(e2);
                                *e = vcc_expr_edit(tl, STRINGS,
                                    "\v1\n\v2", *e, e2);
                                (*e)->constant = EXPR_CONST;
                                (*e)->nstr = 1;
                                if (lit)
                                        (*e)->constant |= EXPR_STR_CONST;
                        } else {
                                n = (*e)->nstr + e2->nstr;
                                *e = vcc_expr_edit(tl, STRINGS,
                                    "\v1,\n\v2", *e, e2);
                                (*e)->constant = EXPR_VAR;
                                (*e)->nstr = n;
                        }
                } else {
                        VSB_printf(tl->sb, "%s %.*s %s not possible.\n",
                            vcc_utype((*e)->fmt), PF(tk), vcc_utype(e2->fmt));
                        vcc_ErrWhere2(tl, tk, tl->t);
                        return;
                }
        }
}

/*--------------------------------------------------------------------
 * SYNTAX:
 *    ExprCmp:
 *      ExprAdd
 *      ExprAdd Relation ExprAdd
 *      ExprAdd(STRING) '~' CString
 *      ExprAdd(STRING) '!~' CString
 *      ExprAdd(IP) '==' ExprAdd(IP)
 *      ExprAdd(IP) '!=' ExprAdd(IP)
 *      ExprAdd(IP) '~' ACL
 *      ExprAdd(IP) '!~' ACL
 */

struct cmps;

typedef void cmp_f(struct vcc *, struct expr **, const struct cmps *);

struct cmps {
        vcc_type_t              fmt;
        unsigned                token;
        cmp_f                   *func;
        const char              *emit;
};

static void v_matchproto_(cmp_f)
cmp_simple(struct vcc *tl, struct expr **e, const struct cmps *cp)
{
        struct expr *e2;
        struct token *tk;

        tk = tl->t;
        vcc_NextToken(tl);
        vcc_expr_add(tl, &e2, (*e)->fmt);
        ERRCHK(tl);

        if (e2->fmt != (*e)->fmt) {
                VSB_printf(tl->sb,
                    "Comparison of different types: %s '%.*s' %s\n",
                    vcc_utype((*e)->fmt), PF(tk), vcc_utype(e2->fmt));
                vcc_ErrWhere(tl, tk);
        } else
                *e = vcc_expr_edit(tl, BOOL, cp->emit, *e, e2);
}

static void v_matchproto_(cmp_f)
cmp_regexp(struct vcc *tl, struct expr **e, const struct cmps *cp)
{
        struct token *t1;
        struct expr *e2;
        char buf[128];

        *e = vcc_expr_edit(tl, STRING, "\vS", *e, NULL);
        vcc_NextToken(tl);
        t1 = tl->t;
        vcc_expr4(tl, &e2, REGEX);
        ERRCHK(tl);
        vcc_expr_typecheck(tl, &e2, REGEX, t1);
        ERRCHK(tl);
        bprintf(buf, "%sVRT_re_match(ctx, \v1, \v2)", cp->emit);
        *e = vcc_expr_edit(tl, BOOL, buf, *e, e2);
}

static void v_matchproto_(cmp_f)
cmp_acl(struct vcc *tl, struct expr **e, const struct cmps *cp)
{
        struct token *t1;
        struct expr *e2;
        char buf[256];

        vcc_NextToken(tl);
        t1 = tl->t;
        vcc_expr4(tl, &e2, ACL);
        ERRCHK(tl);
        vcc_expr_typecheck(tl, &e2, ACL, t1);
        ERRCHK(tl);
        bprintf(buf, "%sVRT_acl_match(ctx, \v1, \v2)", cp->emit);
        *e = vcc_expr_edit(tl, BOOL, buf, e2, *e);
}

static void v_matchproto_(cmp_f)
cmp_string(struct vcc *tl, struct expr **e, const struct cmps *cp)
{
        struct expr *e2;
        struct token *tk;
        char buf[128];

        tk = tl->t;
        vcc_NextToken(tl);
        vcc_expr_add(tl, &e2, STRINGS);
        ERRCHK(tl);
        if (vcc_stringstype(e2->fmt) != STRINGS) {
                VSB_printf(tl->sb,
                    "Comparison of different types: %s '%.*s' %s\n",
                    vcc_utype((*e)->fmt), PF(tk), vcc_utype(e2->fmt));
                vcc_ErrWhere(tl, tk);
        } else if ((*e)->nstr == 1 && e2->nstr == 1) {
                bprintf(buf, "(%s VRT_strcmp(\v1, \v2))", cp->emit);
                *e = vcc_expr_edit(tl, BOOL, buf, *e, e2);
        } else {
                bprintf(buf, "(%s VRT_CompareStrands(\vT, \vt))", cp->emit);
                *e = vcc_expr_edit(tl, BOOL, buf, *e, e2);
        }
}

#define IDENT_REL(typ)                                                  \
        {typ,           T_EQ,           cmp_simple, "(\v1 == \v2)" },   \
        {typ,           T_NEQ,          cmp_simple, "(\v1 != \v2)" }

#define NUM_REL(typ)                                                    \
        IDENT_REL(typ),                                                 \
        {typ,           T_LEQ,          cmp_simple, "(\v1 <= \v2)" },   \
        {typ,           T_GEQ,          cmp_simple, "(\v1 >= \v2)" },   \
        {typ,           '<',            cmp_simple, "(\v1 < \v2)" },    \
        {typ,           '>',            cmp_simple, "(\v1 > \v2)" }

static const struct cmps vcc_cmps[] = {
        NUM_REL(INT),
        NUM_REL(DURATION),
        NUM_REL(BYTES),
        NUM_REL(REAL),
        NUM_REL(TIME),
        IDENT_REL(BACKEND),
        IDENT_REL(ACL),
        IDENT_REL(PROBE),
        IDENT_REL(STEVEDORE),
        IDENT_REL(SUB),
        IDENT_REL(INSTANCE),

        {BOOL,          T_EQ,           cmp_simple, "((!(\v1)) == (!(\v2)))" },
        {BOOL,          T_NEQ,          cmp_simple, "((!(\v1)) != (!(\v2)))" },
        {IP,            T_EQ,           cmp_simple, "!VRT_ipcmp(ctx, \v1, \v2)" },
        {IP,            T_NEQ,          cmp_simple, "VRT_ipcmp(ctx, \v1, \v2)" },

        {IP,            '~',            cmp_acl, "" },
        {IP,            T_NOMATCH,      cmp_acl, "!" },

        {STRINGS,       T_EQ,           cmp_string, "0 =="},
        {STRINGS,       T_NEQ,          cmp_string, "0 !="},
        {STRINGS,       '<',            cmp_string, "0 > "},
        {STRINGS,       '>',            cmp_string, "0 < "},
        {STRINGS,       T_LEQ,          cmp_string, "0 >="},
        {STRINGS,       T_GEQ,          cmp_string, "0 <="},

        {STRINGS,       '~',            cmp_regexp, "" },
        {STRINGS,       T_NOMATCH,      cmp_regexp, "!" },

        {VOID,          0,              NULL, NULL}
};

#undef IDENT_REL
#undef NUM_REL

static void
vcc_expr_cmp(struct vcc *tl, struct expr **e, vcc_type_t fmt)
{
        const struct cmps *cp;
        struct token *tk;

        *e = NULL;
        vcc_expr_add(tl, e, fmt);
        ERRCHK(tl);
        tk = tl->t;

        for (cp = vcc_cmps; cp->fmt != VOID; cp++) {
                if (tl->t->tok != cp->token)
                        continue;
                if (vcc_stringstype((*e)->fmt) != cp->fmt)
                        continue;
                AN(cp->func);
                cp->func(tl, e, cp);
                return;
        }

        switch (tk->tok) {
        case T_EQ:
        case T_NEQ:
        case '<':
        case T_LEQ:
        case '>':
        case T_GEQ:
        case '~':
        case T_NOMATCH:
                VSB_printf(tl->sb, "Operator %.*s not possible on %s\n",
                    PF(tl->t), vcc_utype((*e)->fmt));
                vcc_ErrWhere(tl, tl->t);
                return;
        default:
                break;
        }
}

/*--------------------------------------------------------------------
 * SYNTAX:
 *    ExprNot:
 *      '!' ExprCmp
 */

static void
vcc_expr_not(struct vcc *tl, struct expr **e, vcc_type_t fmt)
{
        struct token *tk;

        *e = NULL;
        tk = tl->t;
        if (tl->t->tok == '!')
                vcc_NextToken(tl);
        vcc_expr_cmp(tl, e, fmt);
        ERRCHK(tl);
        if (tk->tok != '!')
                return;
        vcc_expr_tobool(tl, e);
        ERRCHK(tl);
        if ((*e)->fmt != BOOL) {
                VSB_cat(tl->sb, "'!' must be followed by BOOL, found ");
                VSB_printf(tl->sb, "%s.\n", vcc_utype((*e)->fmt));
                vcc_ErrWhere2(tl, tk, tl->t);
        } else {
                *e = vcc_expr_edit(tl, BOOL, "!(\v1)", *e, NULL);
        }
}

/*--------------------------------------------------------------------
 * CAND and COR are identical save for a few details, but they are
 * stacked so handling them in the same function is not simpler.
 * Instead have them both call this helper function to do everything.
 */

typedef void upfunc(struct vcc *tl, struct expr **e, vcc_type_t fmt);

static void
vcc_expr_bin_bool(struct vcc *tl, struct expr **e, vcc_type_t fmt,
    unsigned ourtok, upfunc *up, const char *tokstr)
{
        struct expr *e2;
        struct token *tk;
        char buf[32];

        *e = NULL;
        tk = tl->t;
        up(tl, e, fmt);
        ERRCHK(tl);
        if (tl->t->tok != ourtok)
                return;
        vcc_expr_tobool(tl, e);
        ERRCHK(tl);
        if ((*e)->fmt != BOOL) {
                VSB_printf(tl->sb,
                    "'%s' must be preceded by BOOL,"
                    " found %s.\n", tokstr, vcc_utype((*e)->fmt));
                vcc_ErrWhere2(tl, tk, tl->t);
                return;
        }
        *e = vcc_expr_edit(tl, BOOL, "(\v+\n\v1", *e, NULL);
        while (tl->t->tok == ourtok) {
                vcc_NextToken(tl);
                tk = tl->t;
                up(tl, &e2, fmt);
                ERRCHK(tl);
                vcc_expr_tobool(tl, &e2);
                ERRCHK(tl);
                if (e2->fmt != BOOL) {
                        VSB_printf(tl->sb,
                            "'%s' must be followed by BOOL,"
                            " found %s.\n", tokstr, vcc_utype(e2->fmt));
                        vcc_ErrWhere2(tl, tk, tl->t);
                        vcc_delete_expr(e2);
                        return;
                }
                bprintf(buf, "\v1\v-\n%s\v+\n\v2", tokstr);
                *e = vcc_expr_edit(tl, BOOL, buf, *e, e2);
        }
        *e = vcc_expr_edit(tl, BOOL, "\v1\v-\n)", *e, NULL);
}

/*--------------------------------------------------------------------
 * SYNTAX:
 *    ExprCand:
 *      ExprNot { '&&' ExprNot } *
 */

static void
vcc_expr_cand(struct vcc *tl, struct expr **e, vcc_type_t fmt)
{

        vcc_expr_bin_bool(tl, e, fmt, T_CAND, vcc_expr_not, "&&");
}

/*--------------------------------------------------------------------
 * SYNTAX:
 *    ExprCOR:
 *      ExprCand { '||' ExprCand } *
 */

static void
vcc_expr_cor(struct vcc *tl, struct expr **e, vcc_type_t fmt)
{

        vcc_expr_bin_bool(tl, e, fmt, T_COR, vcc_expr_cand, "||");
}

/*--------------------------------------------------------------------
 * This function is the entry-point for getting an expression with
 * a particular type, ready for inclusion in the VGC.
 */

static void
vcc_expr0(struct vcc *tl, struct expr **e, vcc_type_t fmt)
{
        struct token *t1;

        assert(fmt != VOID);
        assert(fmt != STRINGS);
        *e = NULL;
        t1 = tl->t;
        if (fmt->stringform)
                vcc_expr_cor(tl, e, STRINGS);
        else
                vcc_expr_cor(tl, e, fmt);
        ERRCHK(tl);

        if ((*e)->fmt == fmt)
                return;

        if ((*e)->fmt != STRINGS && fmt->stringform)
                vcc_expr_tostring(tl, e);

        if ((*e)->fmt->stringform) {
                VSB_printf(tl->sb, "Cannot convert type %s(%s) to %s(%s)\n",
                    vcc_utype((*e)->fmt), (*e)->fmt->name,
                    vcc_utype(fmt), fmt->name);
                vcc_ErrWhere2(tl, t1, tl->t);
                return;
        }

        if (fmt == BODY && !(*e)->fmt->bodyform)
                vcc_expr_tostring(tl, e);

        if (fmt == BODY && (*e)->fmt->bodyform) {
                if ((*e)->fmt == STRINGS)
                        *e = vcc_expr_edit(tl, BODY, "STRING, 0, \vT", *e, NULL);
                else if ((*e)->fmt == BLOB)
                        *e = vcc_expr_edit(tl, BODY, "BLOB, 0, \v1", *e, NULL);
                else
                        WRONG("Unhandled bodyform");
        }

        if ((*e)->fmt == STRINGS && fmt->stringform) {
                if (fmt == STRING)
                        *e = vcc_expr_edit(tl, STRING, "\vS", *e, NULL);
                else if (fmt == STRANDS)
                        *e = vcc_expr_edit(tl, STRANDS, "\vT", (*e), NULL);
                else
                        WRONG("Unhandled stringform");
        }

        if (fmt == BOOL) {
                vcc_expr_tobool(tl, e);
                ERRCHK(tl);
        }

        vcc_expr_typecheck(tl, e, fmt, t1);
}

static void
vcc_expr_typecheck(struct vcc *tl, struct expr **e, vcc_type_t fmt,
    struct token *t1)
{

        assert(fmt != VOID);
        assert(fmt != STRINGS);

        if (fmt != (*e)->fmt)  {
                VSB_printf(tl->sb, "Expression has type %s, expected %s\n",
                    vcc_utype((*e)->fmt), vcc_utype(fmt));
                vcc_ErrWhere2(tl, t1, tl->t);
        }
}

/*--------------------------------------------------------------------
 * This function parses and emits the C-code to evaluate an expression
 *
 * We know up front what kind of type we want the expression to be,
 * and this function is the backstop if that doesn't succeed.
 */

void
vcc_Expr(struct vcc *tl, vcc_type_t fmt)
{
        struct expr *e = NULL;

        assert(fmt != VOID);
        assert(fmt != STRINGS);
        vcc_expr0(tl, &e, fmt);
        ERRCHK(tl);
        assert(e->fmt == fmt);

        vcc_expr_fmt(tl->fb, tl->indent, e);
        VSB_cat(tl->fb, "\n");
        vcc_delete_expr(e);
}

/*--------------------------------------------------------------------
 */

void v_matchproto_(sym_act_f)
vcc_Act_Call(struct vcc *tl, struct token *t, struct symbol *sym)
{

        struct expr *e;

        e = NULL;
        vcc_func(tl, &e, sym->eval_priv, sym->extra, sym);
        if (!tl->err) {
                vcc_expr_fmt(tl->fb, tl->indent, e);
                SkipToken(tl, ';');
                VSB_cat(tl->fb, ";\n");
        } else if (t != tl->t) {
                VSB_cat(tl->sb, "While compiling function call:\n\n");
                vcc_ErrWhere2(tl, t, tl->t);
        }
        vcc_delete_expr(e);
}

void v_matchproto_(sym_act_f)
vcc_Act_Obj(struct vcc *tl, struct token *t, struct symbol *sym)
{

        struct expr *e = NULL;

        assert(sym->kind == SYM_INSTANCE);
        ExpectErr(tl, '.');
        tl->t = t;
        vcc_expr4(tl, &e, sym->type);
        ERRCHK(tl);
        vcc_expr_fmt(tl->fb, tl->indent, e);
        vcc_delete_expr(e);
        SkipToken(tl, ';');
        VSB_cat(tl->fb, ";\n");
}

/*--------------------------------------------------------------------
 */

static void v_matchproto_(sym_expr_t)
vcc_Eval_Regsub(struct vcc *tl, struct expr **e, struct token *t,
    struct symbol *sym, vcc_type_t fmt)
{
        struct expr *e2, *e3;
        int all = sym->eval_priv == NULL ? 0 : 1;
        char buf[128];

        (void)t;
        (void)fmt;
        SkipToken(tl, '(');
        vcc_expr0(tl, &e2, STRING);
        ERRCHK(tl);
        SkipToken(tl, ',');
        vcc_expr0(tl, &e3, REGEX);
        ERRCHK(tl);

        bprintf(buf, "VRT_regsub(ctx, %d,\v+\n\v1,\n\v2", all);
        *e = vcc_expr_edit(tl, STRING, buf, e2, e3);
        SkipToken(tl, ',');
        vcc_expr0(tl, &e2, STRING);
        ERRCHK(tl);
        *e = vcc_expr_edit(tl, STRINGS, "\v1,\n\v2)\v-", *e, e2);
        (*e)->nstr = 1;
        SkipToken(tl, ')');
}

/*--------------------------------------------------------------------
 */

static void v_matchproto_(sym_expr_t)
vcc_Eval_BoolConst(struct vcc *tl, struct expr **e, struct token *t,
    struct symbol *sym, vcc_type_t fmt)
{

        (void)t;
        (void)tl;
        (void)fmt;
        *e = vcc_mk_expr(BOOL, "(0==%d)", sym->eval_priv == NULL ? 1 : 0);
        (*e)->constant = EXPR_CONST;
}

/*--------------------------------------------------------------------
 */

static void v_matchproto_(sym_expr_t)
vcc_Eval_Default(struct vcc *tl, struct expr **e, struct token *t,
    struct symbol *sym, vcc_type_t fmt)
{
        (void)e;
        (void)fmt;
        (void)sym;
        (void)t;

        if (fmt->default_sym == NULL) {
                VSB_cat(tl->sb, "Symbol 'default' is a reserved word.\n");
                vcc_ErrWhere(tl, t);
                return;
        }

        *e = vcc_mk_expr(fmt, "%s", fmt->default_sym->rname);
}

/*--------------------------------------------------------------------
 */

void
vcc_Expr_Init(struct vcc *tl)
{
        struct symbol *sym;

        sym = VCC_MkSym(tl, "regsub", SYM_MAIN, SYM_FUNC, VCL_LOW, VCL_HIGH);
        AN(sym);
        sym->type = STRING;
        sym->eval = vcc_Eval_Regsub;
        sym->eval_priv = NULL;

        sym = VCC_MkSym(tl, "regsuball", SYM_MAIN, SYM_FUNC, VCL_LOW, VCL_HIGH);
        AN(sym);
        sym->type = STRING;
        sym->eval = vcc_Eval_Regsub;
        sym->eval_priv = sym;

        sym = VCC_MkSym(tl, "true", SYM_MAIN, SYM_FUNC, VCL_LOW, VCL_HIGH);
        AN(sym);
        sym->type = BOOL;
        sym->eval = vcc_Eval_BoolConst;
        sym->eval_priv = sym;

        sym = VCC_MkSym(tl, "false", SYM_MAIN, SYM_FUNC, VCL_LOW, VCL_HIGH);
        AN(sym);
        sym->type = BOOL;
        sym->eval = vcc_Eval_BoolConst;
        sym->eval_priv = NULL;

        sym = VCC_MkSym(tl, "default", SYM_MAIN, SYM_FUNC, VCL_LOW, VCL_HIGH);
        AN(sym);
        sym->type = DEFAULT;
        sym->eval = vcc_Eval_Default;
}

		varnish-cache/lib/libvcc/vcc_expr.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2011 Varnish Software AS
3		* All rights reserved.
4		*
5		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6		*
7		* SPDX-License-Identifier: BSD-2-Clause
8		*
9		* Redistribution and use in source and binary forms, with or without
10		* modification, are permitted provided that the following conditions
11		* are met:
12		* 1. Redistributions of source code must retain the above copyright
13		* notice, this list of conditions and the following disclaimer.
14		* 2. Redistributions in binary form must reproduce the above copyright
15		* notice, this list of conditions and the following disclaimer in the
16		* documentation and/or other materials provided with the distribution.
17		*
18		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28		* SUCH DAMAGE.
29		*
30		*/
31
32		#include "config.h"
33
34		#include <math.h>
35		#include <stdarg.h>
36		#include <stdlib.h>
37		#include <string.h>
38
39		#include "vcc_compile.h"
40		#include "vjsn.h"
41
42		struct expr {
43		unsigned magic;
44		#define EXPR_MAGIC 0x38c794ab
45		vcc_type_t fmt;
46		struct vsb *vsb;
47		uint8_t constant;
48		#define EXPR_VAR (1<<0)
49		#define EXPR_CONST (1<<1)
50		#define EXPR_STR_CONST (1<<2) // Last string elem is "..."
51		struct token t1, t2;
52		struct symbol *instance;
53		int nstr;
54		};
55
56		/*--------------------------------------------------------------------
57		* Facility for carrying expressions around and do text-processing on
58		* them.
59		*/
60
61		static inline int
62	226880	vcc_isconst(const struct expr *e)
63		{
64	226880	AN(e->constant);
65	226880	return (e->constant & EXPR_CONST);
66		}
67
68		static inline int
69	2674760	vcc_islit(const struct expr *e)
70		{
71	2674760	AN(e->constant);
72	2674760	return (e->constant & EXPR_STR_CONST);
73		}
74
75		static const char *
76	2680	vcc_utype(vcc_type_t t)
77		{
78	2680	if (t == STRINGS \|\| t->stringform)
79	720	t = STRING;
80	2680	return (t->name);
81		}
82
83		static vcc_type_t
84	24722480	vcc_stringstype(vcc_type_t t)
85		{
86	24722480	return (t->stringform ? STRINGS : t);
87		}
88
89
90		static void vcc_expr0(struct vcc tl, struct expr *e, vcc_type_t fmt);
91		static void vcc_expr_cor(struct vcc tl, struct expr *e, vcc_type_t fmt);
92		static void vcc_expr_typecheck(struct vcc tl, struct expr *e, vcc_type_t fmt,
93		struct token *t1);
94
95		static struct expr *
96	23486200	vcc_new_expr(vcc_type_t fmt)
97		{
98		struct expr *e;
99
100	23486200	ALLOC_OBJ(e, EXPR_MAGIC);
101	23486200	AN(e);
102	23486200	e->vsb = VSB_new_auto();
103	23486200	e->fmt = fmt;
104	23486200	e->constant = EXPR_VAR;
105	23486200	return (e);
106		}
107
108		static struct expr * v_printflike_(2, 3)
109	6231200	vcc_mk_expr(vcc_type_t fmt, const char *str, ...)
110		{
111		va_list ap;
112		struct expr *e;
113
114	6231200	e = vcc_new_expr(fmt);
115	6231200	va_start(ap, str);
116	6231200	VSB_vprintf(e->vsb, str, ap);
117	6231200	va_end(ap);
118	6231200	AZ(VSB_finish(e->vsb));
119	6231200	return (e);
120		}
121
122		static void
123	29934720	vcc_delete_expr(struct expr *e)
124		{
125	29934720	if (e == NULL)
126	6482680	return;
127	23452040	CHECK_OBJ(e, EXPR_MAGIC);
128	23452040	VSB_destroy(&e->vsb);
129	23452040	FREE_OBJ(e);
130	29934720	}
131
132		/*--------------------------------------------------------------------
133		* We want to get the indentation right in the emitted C code so we have
134		* to represent it symbolically until we are ready to render.
135		*
136		* Many of the operations have very schematic output syntaxes, so we
137		* use the same facility to simplify the text-processing of emitting
138		* a given operation on two subexpressions.
139		*
140		* We use '\v' as the magic escape character.
141		* \v1 insert subexpression 1
142		* \v2 insert subexpression 2
143		* \vS insert subexpression 1(STRINGS) as STRING
144		* \vs insert subexpression 2(STRINGS) as STRING
145		* \vT insert subexpression 1(STRINGS) as STRANDS
146		* \vt insert subexpression 2(STRINGS) as STRANDS
147		* \v+ increase indentation
148		* \v- decrease indentation
149		* anything else is literal
150		*
151		* When editing, we check if any of the subexpressions contain a newline
152		* and issue it as an indented block of so.
153		*
154		* XXX: check line lengths in edit, should pass indent in for this
155		*/
156
157		static void
158	1994200	vcc_strands_edit(const struct expr e1, const struct expr e2)
159		{
160
161	1994200	assert(e2->fmt == STRANDS \|\| e2->fmt == STRINGS);
162
163	1994200	if (e2->fmt == STRANDS)
164	160	VSB_cat(e1->vsb, VSB_data(e2->vsb));
165	1994040	else if (e2->nstr == 0)
166	0	VSB_printf(e1->vsb, "vrt_null_strands");
167	1994040	else if (e2->nstr == 1)
168	1764360	VSB_printf(e1->vsb, "TOSTRAND(%s)", VSB_data(e2->vsb));
169		else {
170	459360	VSB_printf(e1->vsb, "TOSTRANDS(%d,\v+\n%s\v-)",
171	229680	e2->nstr, VSB_data(e2->vsb));
172		}
173	1994200	}
174
175		static struct expr *
176	13157480	vcc_expr_edit(struct vcc tl, vcc_type_t fmt, const char p, struct expr *e1,
177		struct expr *e2)
178		{
179		struct expr e, e3;
180	13157480	int nl = 1;
181
182	13157480	(void) tl;
183
184	13157480	AN(e1);
185	13157480	e = vcc_new_expr(fmt);
186	154789240	while (*p != '\0') {
187	141631760	if (*p != '\v') {
188	117467120	if (*p != '\n' \|\| !nl)
189	117465200	VSB_putc(e->vsb, *p);
190	117467120	nl = (*p == '\n');
191	117467120	p++;
192	117467120	continue;
193		}
194	24164640	assert(*p == '\v');
195	24164640	switch (*++p) {
196	2103640	case '+': VSB_cat(e->vsb, "\v+"); nl = 0; break;
197	2228520	case '-': VSB_cat(e->vsb, "\v-"); nl = 0; break;
198		case 'S':
199		case 's':
200	476080	e3 = (*p == 'S' ? e1 : e2);
201	476080	AN(e3);
202	476080	assert(e1->fmt == STRINGS);
203	476080	if (e3->nstr > 1) {
204	1040	VSB_cat(e->vsb,
205		"\nVRT_STRANDS_string(ctx,\v+\n");
206	1040	vcc_strands_edit(e, e3);
207	1040	VSB_cat(e->vsb,
208		"\v-\n)\n");
209	1040	} else {
210	475040	VSB_cat(e->vsb, VSB_data(e3->vsb));
211		}
212	476080	break;
213		case 'T':
214		case 't':
215	1993160	e3 = (*p == 'T' ? e1 : e2);
216	1993160	AN(e3);
217	1993160	vcc_strands_edit(e, e3);
218	1993160	break;
219		case '1':
220	10689480	VSB_cat(e->vsb, VSB_data(e1->vsb));
221	10689480	break;
222		case '2':
223	6673760	AN(e2);
224	6673760	VSB_cat(e->vsb, VSB_data(e2->vsb));
225	6673760	break;
226		default:
227	0	WRONG("Illegal edit in VCC expression");
228	0	}
229	24164640	p++;
230		}
231	13157480	AZ(VSB_finish(e->vsb));
232	13157480	e->t1 = e1->t1;
233	13157480	e->t2 = e1->t2;
234	13157480	if (e2 != NULL)
235	6675000	e->t2 = e2->t2;
236	13157480	vcc_delete_expr(e1);
237	13157480	vcc_delete_expr(e2);
238	13157480	return (e);
239		}
240
241		/*--------------------------------------------------------------------
242		* Expand finished expression into C-source code
243		*/
244
245		static void
246	3619480	vcc_expr_fmt(struct vsb d, int ind, const struct expr e1)
247		{
248		char *p;
249		int i;
250
251	3619480	if (!e1->fmt->noindent) {
252	32201920	for (i = 0; i < ind; i++)
253	28804400	VSB_putc(d, ' ');
254	3397520	}
255	3619480	p = VSB_data(e1->vsb);
256	354230086	while (*p != '\0') {
257	350610766	if (*p == '\n') {
258	10646320	VSB_putc(d, '\n');
259	10646320	if (*++p == '\0')
260	160	break;
261	114068880	for (i = 0; i < ind; i++)
262	103422720	VSB_putc(d, ' ');
263	350610606	} else if (*p != '\v') {
264	335046606	VSB_putc(d, *p++);
265	335046606	} else {
266	4917840	switch (*++p) {
267	2458920	case '+': ind += INDENT; break;
268	2458920	case '-': ind -= INDENT; break;
269	0	default: WRONG("Illegal format in VCC expression");
270	0	}
271	4917840	p++;
272		}
273		}
274	3619480	}
275
276		/*--------------------------------------------------------------------
277		*/
278
279		static void
280	2772040	vcc_expr_tobool(struct vcc tl, struct expr *e)
281		{
282
283	2772040	if ((*e)->fmt == BOOL)
284	2104120	return;
285	667920	if ((e)->fmt == BACKEND \|\| (e)->fmt == INT)
286	400	e = vcc_expr_edit(tl, BOOL, "(\v1 != 0)", e, NULL);
287	667520	else if ((*e)->fmt == DURATION)
288	80	e = vcc_expr_edit(tl, BOOL, "(\v1 > 0)", e, NULL);
289	667440	else if ((*e)->fmt == STRINGS)
290	667200	e = vcc_expr_edit(tl, BOOL, "VRT_Strands2Bool(\vT)", e, NULL);
291		/*
292		* We do not provide automatic folding from REAL to BOOL
293		* because comparing to zero is seldom an exact science
294		* and we want to force people to explicitly get it right.
295		*/
296	2772040	}
297
298		/*--------------------------------------------------------------------
299		*/
300
301		static void
302	2168120	vcc_expr_tostring(struct vcc tl, struct expr *e)
303		{
304		const char *p;
305	2168120	uint8_t constant = EXPR_VAR;
306
307	2168120	CHECK_OBJ_NOTNULL(*e, EXPR_MAGIC);
308	2168120	assert((*e)->fmt != STRINGS);
309
310	2168120	p = (*e)->fmt->tostring;
311	2168120	if (p != NULL) {
312	2168080	AN(*p);
313	2168080	e = vcc_expr_edit(tl, STRINGS, p, e, NULL);
314	2168080	(*e)->constant = constant;
315	2168080	(*e)->nstr = 1;
316	2168080	} else {
317	80	VSB_printf(tl->sb,
318		"Cannot convert %s to STRING.\n",
319	40	vcc_utype((*e)->fmt));
320	40	vcc_ErrWhere2(tl, (*e)->t1, tl->t);
321		}
322	2168120	}
323
324		/*--------------------------------------------------------------------
325		*/
326
327		void v_matchproto_(sym_expr_t)
328	16400	vcc_Eval_Handle(struct vcc tl, struct expr e, struct token t,
329		struct symbol *sym, vcc_type_t type)
330		{
331
332	16400	(void)t;
333	16400	(void)tl;
334	16400	AN(sym->rname);
335	16400	AZ(type->stringform);
336
337	16600	if (sym->type->tostring == NULL &&
338	200	sym->type != STRING && type == STRINGS) {
339	0	*e = vcc_mk_expr(STRINGS, "\"%s\"", sym->name);
340	0	(*e)->nstr = 1;
341	0	(*e)->constant \|= EXPR_CONST \| EXPR_STR_CONST;
342	0	} else {
343	16400	*e = vcc_mk_expr(sym->type, "%s", sym->rname);
344	16400	(*e)->constant = EXPR_VAR;
345	16400	(*e)->nstr = 1;
346	16400	if ((*e)->fmt == STRING)
347	0	(*e)->fmt = STRINGS;
348		}
349	16400	}
350
351		void v_matchproto_(sym_expr_t)
352	920	vcc_Eval_Sub(struct vcc tl, struct expr e, struct token t,
353		struct symbol *sym, vcc_type_t type)
354		{
355
356	920	(void)t;
357	920	(void)tl;
358	920	AN(sym->rname);
359	920	AZ(type->stringform);
360
361	920	assert (sym->type == SUB);
362
363	920	if (type == SUB) {
364	800	*e = vcc_mk_expr(sym->type, "%s", sym->rname);
365	800	(*e)->constant = EXPR_CONST;
366	800	return;
367		}
368
369	240	VSB_printf(tl->sb, "Symbol '%s' can only be used as a %s expression\n",
370	120	sym->name, sym->type->name);
371	120	vcc_ErrWhere(tl, tl->t);
372	920	}
373
374		/*--------------------------------------------------------------------
375		*/
376
377		void v_matchproto_(sym_expr_t)
378	4947960	vcc_Eval_Var(struct vcc tl, struct expr e, struct token t,
379		struct symbol *sym, vcc_type_t type)
380		{
381
382	4947960	(void)type;
383	4947960	vcc_AddUses(tl, t, NULL, sym, XREF_READ);
384	4947960	ERRCHK(tl);
385	4947960	*e = vcc_mk_expr(sym->type, "%s", sym->rname);
386	4947960	(*e)->constant = EXPR_VAR;
387	4947960	(*e)->nstr = 1;
388	4947960	if ((*e)->fmt == STRING)
389	2232200	(*e)->fmt = STRINGS;
390	4947960	}
391
392		void v_matchproto_(sym_expr_t)
393	400	vcc_Eval_ProtectedHeader(struct vcc tl, struct expr e, struct token t,
394		struct symbol *sym, vcc_type_t type)
395		{
396
397	400	AN(sym);
398	400	AZ(sym->lorev);
399
400	400	vcc_Header_Fh(tl, sym);
401	400	sym->eval = vcc_Eval_Var;
402	400	vcc_Eval_Var(tl, e, t, sym, type);
403	400	}
404
405		/*--------------------------------------------------------------------
406		*/
407
408		static struct expr *
409	6880	vcc_priv_arg(struct vcc tl, const char p, struct symbol *sym)
410		{
411		char buf[64];
412		struct inifin *ifp;
413	6880	const char *f = NULL;
414
415	6880	AN(sym);
416	6880	AN(sym->vmod_name);
417
418	6880	if (!strcmp(p, "PRIV_VCL"))
419	600	return (vcc_mk_expr(VOID, "&vmod_priv_%s", sym->vmod_name));
420
421	6280	if (!strcmp(p, "PRIV_CALL")) {
422	880	bprintf(buf, "vmod_priv_%u", tl->unique++);
423	880	ifp = New_IniFin(tl);
424	880	Fh(tl, 0, "static struct vmod_priv %s;\n", buf);
425	880	VSB_printf(ifp->fin, "\tVRT_priv_fini(ctx, &%s);", buf);
426	880	return (vcc_mk_expr(VOID, "&%s", buf));
427		}
428
429	5400	if (!strcmp(p, "PRIV_TASK"))
430	5080	f = "task";
431	320	else if (!strcmp(p, "PRIV_TOP")) {
432	320	f = "top";
433	320	sym->r_methods &= VCL_MET_TASK_C;
434	320	} else {
435	0	WRONG("Wrong PRIV_ type");
436		}
437	5400	AN(f);
438
439	5400	return (vcc_mk_expr(VOID, "VRT_priv_%s(ctx, &VGC_vmod_%s)",
440	5400	f, sym->vmod_name));
441	6880	}
442
443		struct func_arg {
444		vcc_type_t type;
445		const struct vjsn_val *enums;
446		const char *cname;
447		const char *name;
448		const char *val;
449		struct expr *result;
450		int avail;
451		int optional;
452		VTAILQ_ENTRY(func_arg) list;
453		};
454
455		static struct expr *
456	72680	vcc_do_enum(struct vcc tl, const char cfunc, int len, const char *ptr)
457		{
458		const char *r;
459
460	72680	(void)tl;
461	72680	r = strchr(cfunc, '.');
462	72680	AN(r);
463	72680	return (vcc_mk_expr(VOID, "%.s.enum_%.*s",
464	72680	(int)(r - cfunc), cfunc, len, ptr));
465		}
466
467		static void
468	158320	vcc_do_arg(struct vcc tl, const char cfunc, struct func_arg *fa)
469		{
470		struct expr *e2;
471		struct vjsn_val *vv;
472
473	158320	if (fa->type == ENUM) {
474	53400	ExpectErr(tl, ID);
475	53400	ERRCHK(tl);
476	182720	VTAILQ_FOREACH(vv, &fa->enums->children, list)
477	182640	if (vcc_IdIs(tl->t, vv->value))
478	53320	break;
479	53400	if (vv == NULL) {
480	80	VSB_cat(tl->sb, "Wrong enum value.");
481	80	VSB_cat(tl->sb, " Expected one of:\n");
482	400	VTAILQ_FOREACH(vv, &fa->enums->children, list)
483	320	VSB_printf(tl->sb, "\t%s\n", vv->value);
484	80	vcc_ErrWhere(tl, tl->t);
485	80	return;
486		}
487	53320	fa->result = vcc_do_enum(tl, cfunc, PF(tl->t));
488	53320	SkipToken(tl, ID);
489	53320	} else {
490	104920	if (fa->type == SUB)
491	800	tl->subref++;
492	104920	vcc_expr0(tl, &e2, fa->type);
493	104920	ERRCHK(tl);
494	104600	assert(e2->fmt == fa->type);
495	104600	fa->result = e2;
496		}
497	157920	fa->avail = 1;
498	158320	}
499