GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2015 Varnish Software AS
 * All rights reserved.
 *
 * Author: Martin Blix Grydeland <martin@varnish-software.com>
 *
 * 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 <ctype.h>
#include <math.h>
#include <stdio.h>

#include "vdef.h"
#include "vas.h"
#include "miniobj.h"

#include "vbm.h"
#include "vnum.h"
#include "vqueue.h"
#include "vre.h"
#include "vsb.h"

#include "vapi/vsl.h"

#include "vsl_api.h"
#include "vxp.h"

static void vxp_expr_or(struct vxp *vxp, struct vex **pvex);

static struct vex *
vex_alloc(const struct vxp *vxp)
{
        struct vex *vex;

        ALLOC_OBJ(vex, VEX_MAGIC);
        AN(vex);
        vex->options = vxp->vex_options;
        return (vex);
}

static void
vxp_expr_lhs(struct vxp *vxp, struct vex_lhs **plhs)
{
        char *p;
        int i;

        AN(plhs);
        AZ(*plhs);
        ALLOC_OBJ(*plhs, VEX_LHS_MAGIC);
        AN(*plhs);
        (*plhs)->tags = vbit_new(SLT__MAX);
        (*plhs)->level = -1;

        if (vxp->t->tok == '{') {
                /* Transaction level limits */
                vxp_NextToken(vxp);
                if (vxp->t->tok != VAL) {
                        VSB_printf(vxp->sb, "Expected integer got '%.*s' ",
                            PF(vxp->t));
                        vxp_ErrWhere(vxp, vxp->t, -1);
                        return;
                }
                (*plhs)->level = (int)strtol(vxp->t->dec, &p, 0);
                if ((*plhs)->level < 0) {
                        VSB_cat(vxp->sb, "Expected positive integer ");
                        vxp_ErrWhere(vxp, vxp->t, -1);
                        return;
                }
                if (*p == '-') {
                        (*plhs)->level_pm = -1;
                        p++;
                } else if (*p == '+') {
                        (*plhs)->level_pm = 1;
                        p++;
                }
                if (*p) {
                        VSB_cat(vxp->sb, "Syntax error in level limit ");
                        vxp_ErrWhere(vxp, vxp->t, -1);
                        return;
                }
                vxp_NextToken(vxp);
                ExpectErr(vxp, '}');
                vxp_NextToken(vxp);
        }

        while (1) {
                /* The tags this expression applies to */
                if (vxp->t->tok == VXID) {
                        (*plhs)->vxid++;
                        i = 0;
                } else if (vxp->t->tok != VAL) {
                        VSB_printf(vxp->sb, "Expected VSL tag name got '%.*s' ",
                            PF(vxp->t));
                        vxp_ErrWhere(vxp, vxp->t, -1);
                        return;
                } else {
                        (*plhs)->taglist++;
                        i = VSL_Glob2Tags(vxp->t->dec, -1, vsl_vbm_bitset,
                            (*plhs)->tags);
                }
                if (i == -1) {
                        VSB_cat(vxp->sb, "Tag name matches zero tags ");
                        vxp_ErrWhere(vxp, vxp->t, -1);
                        return;
                }
                if (i == -2) {
                        VSB_cat(vxp->sb, "Tag name is ambiguous ");
                        vxp_ErrWhere(vxp, vxp->t, -1);
                        return;
                }
                if (i == -3) {
                        VSB_cat(vxp->sb, "Syntax error in tag name ");
                        vxp_ErrWhere(vxp, vxp->t, -1);
                        return;
                }
                assert(i > 0 || vxp->t->tok == VXID);
                vxp_NextToken(vxp);
                if (vxp->t->tok != ',')
                        break;
                vxp_NextToken(vxp);
        }

        if (vxp->t->tok == ':') {
                /* Record prefix */
                vxp_NextToken(vxp);
                if (vxp->t->tok != VAL) {
                        VSB_printf(vxp->sb, "Expected string got '%.*s' ",
                            PF(vxp->t));
                        vxp_ErrWhere(vxp, vxp->t, -1);
                        return;
                }
                AN(vxp->t->dec);
                (*plhs)->prefix = strdup(vxp->t->dec);
                AN((*plhs)->prefix);
                (*plhs)->prefixlen = strlen((*plhs)->prefix);
                vxp_NextToken(vxp);
        }

        if (vxp->t->tok == '[') {
                /* LHS field [] */
                vxp_NextToken(vxp);
                if (vxp->t->tok != VAL) {
                        VSB_printf(vxp->sb, "Expected integer got '%.*s' ",
                            PF(vxp->t));
                        vxp_ErrWhere(vxp, vxp->t, -1);
                        return;
                }
                (*plhs)->field = (int)strtol(vxp->t->dec, &p, 0);
                if (*p || (*plhs)->field <= 0) {
                        VSB_cat(vxp->sb, "Expected positive integer ");
                        vxp_ErrWhere(vxp, vxp->t, -1);
                        return;
                }
                vxp_NextToken(vxp);
                ExpectErr(vxp, ']');
                vxp_NextToken(vxp);
        }

        if ((*plhs)->vxid == 0)
                return;

        if ((*plhs)->vxid > 1 || (*plhs)->level >= 0 ||
            (*plhs)->field > 0 || (*plhs)->prefixlen > 0 ||
            (*plhs)->taglist > 0) {
                VSB_cat(vxp->sb, "Unexpected taglist selection for vxid ");
                vxp_ErrWhere(vxp, vxp->t, -1);
        }
}

static void
vxp_expr_num(struct vxp *vxp, struct vex_rhs **prhs, unsigned vxid)
{
        char *endptr;

        AN(prhs);
        AZ(*prhs);
        if (vxp->t->tok != VAL) {
                VSB_printf(vxp->sb, "Expected number got '%.*s' ", PF(vxp->t));
                vxp_ErrWhere(vxp, vxp->t, -1);
                return;
        }
        AN(vxp->t->dec);
        ALLOC_OBJ(*prhs, VEX_RHS_MAGIC);
        AN(*prhs);
        if (strchr(vxp->t->dec, '.')) {
                (*prhs)->type = VEX_FLOAT;
                (*prhs)->val_float = VNUM(vxp->t->dec);
                if (isnan((*prhs)->val_float)) {
                        VSB_cat(vxp->sb, "Floating point parse error ");
                        vxp_ErrWhere(vxp, vxp->t, -1);
                        return;
                }
        } else {
                (*prhs)->type = VEX_INT;
                (*prhs)->val_int = strtoll(vxp->t->dec, &endptr, 0);
                while (isspace(*endptr))
                        endptr++;
                if (*endptr != '\0') {
                        VSB_cat(vxp->sb, "Integer parse error ");
                        vxp_ErrWhere(vxp, vxp->t, -1);
                        return;
                }
        }
        if (vxid && (*prhs)->type != VEX_INT) {
                VSB_printf(vxp->sb, "Expected integer got '%.*s' ",
                    PF(vxp->t));
                vxp_ErrWhere(vxp, vxp->t, 0);
                return;
        }
        vxp_NextToken(vxp);
}

static void
vxp_expr_str(struct vxp *vxp, struct vex_rhs **prhs)
{

        AN(prhs);
        AZ(*prhs);
        if (vxp->t->tok != VAL) {
                VSB_printf(vxp->sb, "Expected string got '%.*s' ", PF(vxp->t));
                vxp_ErrWhere(vxp, vxp->t, -1);
                return;
        }
        AN(vxp->t->dec);
        ALLOC_OBJ(*prhs, VEX_RHS_MAGIC);
        AN(*prhs);
        (*prhs)->type = VEX_STRING;
        (*prhs)->val_string = strdup(vxp->t->dec);
        AN((*prhs)->val_string);
        (*prhs)->val_stringlen = strlen((*prhs)->val_string);
        vxp_NextToken(vxp);
}

static void
vxp_expr_regex(struct vxp *vxp, struct vex_rhs **prhs)
{
        int err, erroff;

        /* XXX: Caseless option */

        AN(prhs);
        AZ(*prhs);
        if (vxp->t->tok != VAL) {
                VSB_printf(vxp->sb, "Expected regular expression got '%.*s' ",
                    PF(vxp->t));
                vxp_ErrWhere(vxp, vxp->t, -1);
                return;
        }
        AN(vxp->t->dec);
        ALLOC_OBJ(*prhs, VEX_RHS_MAGIC);
        AN(*prhs);
        (*prhs)->type = VEX_REGEX;
        (*prhs)->val_string = strdup(vxp->t->dec);
        (*prhs)->val_regex = VRE_compile(vxp->t->dec, vxp->vre_options,
            &err, &erroff, 1);
        if ((*prhs)->val_regex == NULL) {
                VSB_cat(vxp->sb, "Regular expression error: ");
                AZ(VRE_error(vxp->sb, err));
                VSB_putc(vxp->sb, ' ');
                vxp_ErrWhere(vxp, vxp->t, erroff);
                return;
        }
        vxp_NextToken(vxp);
}

static void
vxp_vxid_cmp(struct vxp *vxp)
{

        switch (vxp->t->tok) {
        /* Valid operators */
        case T_EQ:              /* == */
        case '<':               /* < */
        case '>':               /* > */
        case T_GEQ:             /* >= */
        case T_LEQ:             /* <= */
        case T_NEQ:             /* != */
                break;

        /* Error */
        default:
                VSB_printf(vxp->sb, "Expected vxid operator got '%.*s' ",
                    PF(vxp->t));
                vxp_ErrWhere(vxp, vxp->t, -1);
        }
}

/*
 * SYNTAX:
 *   expr_cmp:
 *     lhs
 *     lhs <operator> num|str|regex
 */

static void
vxp_expr_cmp(struct vxp *vxp, struct vex **pvex)
{

        AN(pvex);
        AZ(*pvex);
        *pvex = vex_alloc(vxp);
        AN(*pvex);
        vxp_expr_lhs(vxp, &(*pvex)->lhs);
        ERRCHK(vxp);

        if ((*pvex)->lhs->vxid) {
                vxp_vxid_cmp(vxp);
                ERRCHK(vxp);
        }

        /* Test operator */
        switch (vxp->t->tok) {

        /* Single lhs expressions don't take any more tokens */
        case EOI:
        case T_AND:
        case T_OR:
        case ')':
                (*pvex)->tok = T_TRUE;
                return;

        /* Valid operators */
        case T_EQ:              /* == */
        case '<':               /* < */
        case '>':               /* > */
        case T_GEQ:             /* >= */
        case T_LEQ:             /* <= */
        case T_NEQ:             /* != */
        case T_SEQ:             /* eq */
        case T_SNEQ:            /* ne */
        case '~':               /* ~ */
        case T_NOMATCH:         /* !~ */
                (*pvex)->tok = vxp->t->tok;
                break;

        /* Error */
        default:
                VSB_printf(vxp->sb, "Expected operator got '%.*s' ",
                    PF(vxp->t));
                vxp_ErrWhere(vxp, vxp->t, -1);
                return;
        }
        vxp_NextToken(vxp);
        ERRCHK(vxp);

        /* Value */
        switch ((*pvex)->tok) {
        case '\0':
                WRONG("Missing token");
                break;
        case T_EQ:              /* == */
        case '<':               /* < */
        case '>':               /* > */
        case T_GEQ:             /* >= */
        case T_LEQ:             /* <= */
        case T_NEQ:             /* != */
                vxp_expr_num(vxp, &(*pvex)->rhs, (*pvex)->lhs->vxid);
                break;
        case T_SEQ:             /* eq */
        case T_SNEQ:            /* ne */
                vxp_expr_str(vxp, &(*pvex)->rhs);
                break;
        case '~':               /* ~ */
        case T_NOMATCH:         /* !~ */
                vxp_expr_regex(vxp, &(*pvex)->rhs);
                break;
        default:
                INCOMPL();
        }
}

/*
 * SYNTAX:
 *   expr_group:
 *     '(' expr_or ')'
 *     expr_not
 */

static void
vxp_expr_group(struct vxp *vxp, struct vex **pvex)
{

        AN(pvex);
        AZ(*pvex);

        if (vxp->t->tok == '(') {
                SkipToken(vxp, '(');
                vxp_expr_or(vxp, pvex);
                ERRCHK(vxp);
                SkipToken(vxp, ')');
                return;
        }

        vxp_expr_cmp(vxp, pvex);
}

/*
 * SYNTAX:
 *   expr_not:
 *     'not' expr_group
 *     expr_group
 */

static void
vxp_expr_not(struct vxp *vxp, struct vex **pvex)
{

        AN(pvex);
        AZ(*pvex);

        if (vxp->t->tok == T_NOT) {
                *pvex = vex_alloc(vxp);
                AN(*pvex);
                (*pvex)->tok = vxp->t->tok;
                vxp_NextToken(vxp);
                vxp_expr_group(vxp, &(*pvex)->a);
                return;
        }

        vxp_expr_group(vxp, pvex);
}

/*
 * SYNTAX:
 *   expr_and:
 *     expr_not { 'and' expr_not }*
 */

static void
vxp_expr_and(struct vxp *vxp, struct vex **pvex)
{
        struct vex *a;

        AN(pvex);
        AZ(*pvex);
        vxp_expr_not(vxp, pvex);
        ERRCHK(vxp);
        while (vxp->t->tok == T_AND) {
                a = *pvex;
                *pvex = vex_alloc(vxp);
                AN(*pvex);
                (*pvex)->tok = vxp->t->tok;
                (*pvex)->a = a;
                vxp_NextToken(vxp);
                ERRCHK(vxp);
                vxp_expr_not(vxp, &(*pvex)->b);
                ERRCHK(vxp);
        }
}

/*
 * SYNTAX:
 *   expr_or:
 *     expr_and { 'or' expr_and }*
 */

static void
vxp_expr_or(struct vxp *vxp, struct vex **pvex)
{
        struct vex *a;

        AN(pvex);
        AZ(*pvex);
        vxp_expr_and(vxp, pvex);
        ERRCHK(vxp);
        while (vxp->t->tok == T_OR) {
                a = *pvex;
                *pvex = vex_alloc(vxp);
                AN(*pvex);
                (*pvex)->tok = vxp->t->tok;
                (*pvex)->a = a;
                vxp_NextToken(vxp);
                ERRCHK(vxp);
                vxp_expr_and(vxp, &(*pvex)->b);
                ERRCHK(vxp);
        }
}

/*
 * SYNTAX:
 *   expr:
 *     expr_or EOI { 'or' expr_or EOI }?
 */

static void
vxp_expr(struct vxp *vxp, struct vex **pvex)
{
        struct vex *a = NULL, *or;

        if (*pvex == NULL) {
                vxp_expr_or(vxp, pvex);
                ERRCHK(vxp);
                ExpectErr(vxp, EOI);
                return;
        }

        vxp_expr(vxp, &a);
        ERRCHK(vxp);

        or = vex_alloc(vxp);
        AN(or);
        or->tok = T_OR;
        or->b = *pvex;
        or->a = a;
        *pvex = or;
}

/*
 * Build a struct vex tree from the token list in vxp
 */

struct vex *
vxp_Parse(struct vxp *vxp)
{
        struct vex *vex = NULL;

        AZ(vxp->err);
        vxp->t = VTAILQ_FIRST(&vxp->tokens);

        while (vxp->t != NULL) {
                /* Ignore empty queries */
                while (vxp->t != NULL && vxp->t->tok == EOI)
                        vxp->t = VTAILQ_NEXT(vxp->t, list);

                if (vxp->t == NULL)
                        break;

                vxp_expr(vxp, &vex);

                if (vxp->err) {
                        if (vex)
                                vex_Free(&vex);
                        AZ(vex);
                        return (NULL);
                }

                vxp->t = VTAILQ_NEXT(vxp->t, list);
        }

        return (vex);
}

/*
 * Free a struct vex tree
 */

void
vex_Free(struct vex **pvex)
{
        struct vex *vex;
        struct vex_lhs *lhs;
        struct vex_rhs *rhs;

        TAKE_OBJ_NOTNULL(vex, pvex, VEX_MAGIC);

        if (vex->lhs) {
                CAST_OBJ_NOTNULL(lhs, vex->lhs, VEX_LHS_MAGIC);
                if (lhs->tags)
                        vbit_destroy(lhs->tags);
                if (lhs->prefix)
                        free(lhs->prefix);
                FREE_OBJ(lhs);
        }
        if (vex->rhs) {
                CAST_OBJ_NOTNULL(rhs, vex->rhs, VEX_RHS_MAGIC);
                if (rhs->val_string)
                        free(rhs->val_string);
                if (rhs->val_regex)
                        VRE_free(&rhs->val_regex);
                FREE_OBJ(rhs);
        }
        if (vex->a) {
                vex_Free(&vex->a);
                AZ(vex->a);
        }
        if (vex->b) {
                vex_Free(&vex->b);
                AZ(vex->b);
        }
        FREE_OBJ(vex);
}

#ifdef VXP_DEBUG

static void
vex_print_rhs(const struct vex_rhs *rhs)
{

        CHECK_OBJ_NOTNULL(rhs, VEX_RHS_MAGIC);
        fprintf(stderr, "rhs=");
        switch (rhs->type) {
        case VEX_INT:
                fprintf(stderr, "INT(%jd)", (intmax_t)rhs->val_int);
                break;
        case VEX_FLOAT:
                fprintf(stderr, "FLOAT(%f)", rhs->val_float);
                break;
        case VEX_STRING:
                AN(rhs->val_string);
                fprintf(stderr, "STRING(%s)", rhs->val_string);
                break;
        case VEX_REGEX:
                AN(rhs->val_string);
                AN(rhs->val_regex);
                fprintf(stderr, "REGEX(%s)", rhs->val_string);
                break;
        default:
                WRONG("rhs type");
                break;
        }
}

static void
vex_print_tags(const struct vbitmap *vbm)
{
        int i;
        int first = 1;

        for (i = 0; i < SLT__MAX; i++) {
                if (VSL_tags[i] == NULL)
                        continue;
                if (!vbit_test(vbm, i))
                        continue;
                if (first)
                        first = 0;
                else
                        fprintf(stderr, ",");
                fprintf(stderr, "%s", VSL_tags[i]);
        }
}

static void
vex_print(const struct vex *vex, int indent)
{
        CHECK_OBJ_NOTNULL(vex, VEX_MAGIC);

        fprintf(stderr, "%*s%s", indent, "", vxp_tnames[vex->tok]);
        if (vex->lhs != NULL) {
                CHECK_OBJ(vex->lhs, VEX_LHS_MAGIC);
                AN(vex->lhs->tags);
                fprintf(stderr, " lhs=");
                if (vex->lhs->level >= 0)
                        fprintf(stderr, "{%d%s}", vex->lhs->level,
                            vex->lhs->level_pm < 0 ? "-" :
                            vex->lhs->level_pm > 0 ? "+" : "");
                fprintf(stderr, "(");
                vex_print_tags(vex->lhs->tags);
                fprintf(stderr, ")");
                if (vex->lhs->prefix) {
                        assert(vex->lhs->prefixlen == strlen(vex->lhs->prefix));
                        fprintf(stderr, ":%s", vex->lhs->prefix);
                }
                if (vex->lhs->field > 0)
                        fprintf(stderr, "[%d]", vex->lhs->field);
        }
        if (vex->rhs != NULL) {
                fprintf(stderr, " ");
                vex_print_rhs(vex->rhs);
        }
        fprintf(stderr, "\n");
        if (vex->a != NULL)
                vex_print(vex->a, indent + 2);
        if (vex->b != NULL)
                vex_print(vex->b, indent + 2);
}

void
vex_PrintTree(const struct vex *vex)
{

        CHECK_OBJ_NOTNULL(vex, VEX_MAGIC);
        fprintf(stderr, "VEX tree:\n");
        vex_print(vex, 2);
}

#endif /* VXP_DEBUG */

		varnish-cache/lib/libvarnishapi/vxp_parse.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2015 Varnish Software AS
3		* All rights reserved.
4		*
5		* Author: Martin Blix Grydeland <martin@varnish-software.com>
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 <ctype.h>
35		#include <math.h>
36		#include <stdio.h>
37
38		#include "vdef.h"
39		#include "vas.h"
40		#include "miniobj.h"
41
42		#include "vbm.h"
43		#include "vnum.h"
44		#include "vqueue.h"
45		#include "vre.h"
46		#include "vsb.h"
47
48		#include "vapi/vsl.h"
49
50		#include "vsl_api.h"
51		#include "vxp.h"
52
53		static void vxp_expr_or(struct vxp vxp, struct vex *pvex);
54
55		static struct vex *
56	8360	vex_alloc(const struct vxp *vxp)
57		{
58		struct vex *vex;
59
60	8360	ALLOC_OBJ(vex, VEX_MAGIC);
61	8360	AN(vex);
62	8360	vex->options = vxp->vex_options;
63	8360	return (vex);
64		}
65
66		static void
67	7480	vxp_expr_lhs(struct vxp vxp, struct vex_lhs *plhs)
68		{
69		char *p;
70		int i;
71
72	7480	AN(plhs);
73	7480	AZ(*plhs);
74	7480	ALLOC_OBJ(*plhs, VEX_LHS_MAGIC);
75	7480	AN(*plhs);
76	7480	(*plhs)->tags = vbit_new(SLT__MAX);
77	7480	(*plhs)->level = -1;
78
79	7480	if (vxp->t->tok == '{') {
80		/* Transaction level limits */
81	280	vxp_NextToken(vxp);
82	280	if (vxp->t->tok != VAL) {
83	80	VSB_printf(vxp->sb, "Expected integer got '%.*s' ",
84	40	PF(vxp->t));
85	40	vxp_ErrWhere(vxp, vxp->t, -1);
86	40	return;
87		}
88	240	(*plhs)->level = (int)strtol(vxp->t->dec, &p, 0);
89	240	if ((*plhs)->level < 0) {
90	40	VSB_cat(vxp->sb, "Expected positive integer ");
91	40	vxp_ErrWhere(vxp, vxp->t, -1);
92	40	return;
93		}
94	200	if (*p == '-') {
95	40	(*plhs)->level_pm = -1;
96	40	p++;
97	200	} else if (*p == '+') {
98	40	(*plhs)->level_pm = 1;
99	40	p++;
100	40	}
101	200	if (*p) {
102	40	VSB_cat(vxp->sb, "Syntax error in level limit ");
103	40	vxp_ErrWhere(vxp, vxp->t, -1);
104	40	return;
105		}
106	160	vxp_NextToken(vxp);
107	160	ExpectErr(vxp, '}');
108	160	vxp_NextToken(vxp);
109	160	}
110
111	7480	while (1) {
112		/* The tags this expression applies to */
113	7480	if (vxp->t->tok == VXID) {
114	1080	(*plhs)->vxid++;
115	1080	i = 0;
116	7480	} else if (vxp->t->tok != VAL) {
117	80	VSB_printf(vxp->sb, "Expected VSL tag name got '%.*s' ",
118	40	PF(vxp->t));
119	40	vxp_ErrWhere(vxp, vxp->t, -1);
120	40	return;
121		} else {
122	6360	(*plhs)->taglist++;
123	12720	i = VSL_Glob2Tags(vxp->t->dec, -1, vsl_vbm_bitset,
124	6360	(*plhs)->tags);
125		}
126	7440	if (i == -1) {
127	80	VSB_cat(vxp->sb, "Tag name matches zero tags ");
128	80	vxp_ErrWhere(vxp, vxp->t, -1);
129	80	return;
130		}
131	7360	if (i == -2) {
132	40	VSB_cat(vxp->sb, "Tag name is ambiguous ");
133	40	vxp_ErrWhere(vxp, vxp->t, -1);
134	40	return;
135		}
136	7320	if (i == -3) {
137	40	VSB_cat(vxp->sb, "Syntax error in tag name ");
138	40	vxp_ErrWhere(vxp, vxp->t, -1);
139	40	return;
140		}
141	7280	assert(i > 0 \|\| vxp->t->tok == VXID);
142	7280	vxp_NextToken(vxp);
143	7280	if (vxp->t->tok != ',')
144	7160	break;
145	120	vxp_NextToken(vxp);
146		}
147
148	7160	if (vxp->t->tok == ':') {
149		/* Record prefix */
150	800	vxp_NextToken(vxp);
151	800	if (vxp->t->tok != VAL) {
152	80	VSB_printf(vxp->sb, "Expected string got '%.*s' ",
153	40	PF(vxp->t));
154	40	vxp_ErrWhere(vxp, vxp->t, -1);
155	40	return;
156		}
157	760	AN(vxp->t->dec);
158	760	(*plhs)->prefix = strdup(vxp->t->dec);
159	760	AN((*plhs)->prefix);
160	760	(plhs)->prefixlen = strlen((plhs)->prefix);
161	760	vxp_NextToken(vxp);
162	760	}
163
164	7120	if (vxp->t->tok == '[') {
165		/* LHS field [] */
166	480	vxp_NextToken(vxp);
167	480	if (vxp->t->tok != VAL) {
168	80	VSB_printf(vxp->sb, "Expected integer got '%.*s' ",
169	40	PF(vxp->t));
170	40	vxp_ErrWhere(vxp, vxp->t, -1);
171	40	return;
172		}
173	440	(*plhs)->field = (int)strtol(vxp->t->dec, &p, 0);
174	440	if (p \|\| (plhs)->field <= 0) {
175	40	VSB_cat(vxp->sb, "Expected positive integer ");
176	40	vxp_ErrWhere(vxp, vxp->t, -1);
177	40	return;
178		}
179	400	vxp_NextToken(vxp);
180	400	ExpectErr(vxp, ']');
181	400	vxp_NextToken(vxp);
182	400	}
183
184	7040	if ((*plhs)->vxid == 0)
185	6000	return;
186
187	1960	if ((plhs)->vxid > 1 \|\| (plhs)->level >= 0 \|\|
188	960	(plhs)->field > 0 \|\| (plhs)->prefixlen > 0 \|\|
189	920	(*plhs)->taglist > 0) {
190	160	VSB_cat(vxp->sb, "Unexpected taglist selection for vxid ");
191	160	vxp_ErrWhere(vxp, vxp->t, -1);
192	160	}
193	7480	}
194
195		static void
196	2920	vxp_expr_num(struct vxp vxp, struct vex_rhs *prhs, unsigned vxid)
197		{
198		char *endptr;
199
200	2920	AN(prhs);
201	2920	AZ(*prhs);
202	2920	if (vxp->t->tok != VAL) {
203	40	VSB_printf(vxp->sb, "Expected number got '%.*s' ", PF(vxp->t));
204	40	vxp_ErrWhere(vxp, vxp->t, -1);
205	40	return;
206		}
207	2880	AN(vxp->t->dec);
208	2880	ALLOC_OBJ(*prhs, VEX_RHS_MAGIC);
209	2880	AN(*prhs);
210	2880	if (strchr(vxp->t->dec, '.')) {
211	440	(*prhs)->type = VEX_FLOAT;
212	440	(*prhs)->val_float = VNUM(vxp->t->dec);
213	440	if (isnan((*prhs)->val_float)) {
214	40	VSB_cat(vxp->sb, "Floating point parse error ");
215	40	vxp_ErrWhere(vxp, vxp->t, -1);
216	40	return;
217		}
218	400	} else {
219	2440	(*prhs)->type = VEX_INT;
220	2440	(*prhs)->val_int = strtoll(vxp->t->dec, &endptr, 0);
221	2440	while (isspace(*endptr))
222	0	endptr++;
223	2440	if (*endptr != '\0') {
224	40	VSB_cat(vxp->sb, "Integer parse error ");
225	40	vxp_ErrWhere(vxp, vxp->t, -1);
226	40	return;
227		}
228		}
229	2800	if (vxid && (*prhs)->type != VEX_INT) {
230	80	VSB_printf(vxp->sb, "Expected integer got '%.*s' ",
231	40	PF(vxp->t));
232	40	vxp_ErrWhere(vxp, vxp->t, 0);
233	40	return;
234		}
235	2760	vxp_NextToken(vxp);
236	2920	}
237
238		static void
239	520	vxp_expr_str(struct vxp vxp, struct vex_rhs *prhs)
240		{
241
242	520	AN(prhs);
243	520	AZ(*prhs);
244	520	if (vxp->t->tok != VAL) {
245	40	VSB_printf(vxp->sb, "Expected string got '%.*s' ", PF(vxp->t));
246	40	vxp_ErrWhere(vxp, vxp->t, -1);
247	40	return;
248		}
249	480	AN(vxp->t->dec);
250	480	ALLOC_OBJ(*prhs, VEX_RHS_MAGIC);
251	480	AN(*prhs);
252	480	(*prhs)->type = VEX_STRING;
253	480	(*prhs)->val_string = strdup(vxp->t->dec);
254	480	AN((*prhs)->val_string);
255	480	(prhs)->val_stringlen = strlen((prhs)->val_string);
256	480	vxp_NextToken(vxp);
257	520	}
258
259		static void
260	2120	vxp_expr_regex(struct vxp vxp, struct vex_rhs *prhs)
261		{
262		int err, erroff;
263
264		/* XXX: Caseless option */
265
266	2120	AN(prhs);
267	2120	AZ(*prhs);
268	2120	if (vxp->t->tok != VAL) {
269	80	VSB_printf(vxp->sb, "Expected regular expression got '%.*s' ",
270	40	PF(vxp->t));
271	40	vxp_ErrWhere(vxp, vxp->t, -1);
272	40	return;
273		}
274	2080	AN(vxp->t->dec);
275	2080	ALLOC_OBJ(*prhs, VEX_RHS_MAGIC);
276	2080	AN(*prhs);
277	2080	(*prhs)->type = VEX_REGEX;
278	2080	(*prhs)->val_string = strdup(vxp->t->dec);
279	2080	(*prhs)->val_regex = VRE_compile(vxp->t->dec, vxp->vre_options,
280		&err, &erroff, 1);
281	2080	if ((*prhs)->val_regex == NULL) {
282	40	VSB_cat(vxp->sb, "Regular expression error: ");
283	40	AZ(VRE_error(vxp->sb, err));
284	40	VSB_putc(vxp->sb, ' ');
285	40	vxp_ErrWhere(vxp, vxp->t, erroff);
286	40	return;
287		}
288	2040	vxp_NextToken(vxp);
289	2120	}
290
291		static void
292	880	vxp_vxid_cmp(struct vxp *vxp)
293		{
294
295	880	switch (vxp->t->tok) {
296		/* Valid operators */
297		case T_EQ: /* == */
298		case '<': /* < */
299		case '>': /* > */
300		case T_GEQ: /* >= */
301		case T_LEQ: /* <= */
302		case T_NEQ: /* != */
303	720	break;
304
305		/* Error */
306		default:
307	320	VSB_printf(vxp->sb, "Expected vxid operator got '%.*s' ",
308	160	PF(vxp->t));
309	160	vxp_ErrWhere(vxp, vxp->t, -1);
310	160	}
311	880	}
312
313		/*
314		* SYNTAX:
315		* expr_cmp:
316		* lhs
317		* lhs <operator> num\|str\|regex
318		*/
319
320		static void
321	7480	vxp_expr_cmp(struct vxp vxp, struct vex *pvex)
322		{
323
324	7480	AN(pvex);
325	7480	AZ(*pvex);
326	7480	*pvex = vex_alloc(vxp);
327	7480	AN(*pvex);
328	7480	vxp_expr_lhs(vxp, &(*pvex)->lhs);
329	7480	ERRCHK(vxp);
330
331	6880	if ((*pvex)->lhs->vxid) {
332	880	vxp_vxid_cmp(vxp);
333	880	ERRCHK(vxp);
334	720	}
335
336		/* Test operator */
337	6720	switch (vxp->t->tok) {
338
339		/* Single lhs expressions don't take any more tokens */
340		case EOI:
341		case T_AND:
342		case T_OR:
343		case ')':
344	1120	(*pvex)->tok = T_TRUE;
345	1120	return;
346
347		/* Valid operators */
348		case T_EQ: /* == */
349		case '<': /* < */
350		case '>': /* > */
351		case T_GEQ: /* >= */
352		case T_LEQ: /* <= */
353		case T_NEQ: /* != */
354		case T_SEQ: /* eq */
355		case T_SNEQ: /* ne */
356		case '~': /* ~ */
357		case T_NOMATCH: /* !~ */
358	5560	(*pvex)->tok = vxp->t->tok;
359	5560	break;
360
361		/* Error */
362		default:
363	80	VSB_printf(vxp->sb, "Expected operator got '%.*s' ",
364	40	PF(vxp->t));
365	40	vxp_ErrWhere(vxp, vxp->t, -1);
366	40	return;
367		}
368	5560	vxp_NextToken(vxp);
369	5560	ERRCHK(vxp);
370
371		/* Value */
372	5560	switch ((*pvex)->tok) {
373		case '\0':
374	0	WRONG("Missing token");
375	0	break;
376		case T_EQ: /* == */
377		case '<': /* < */
378		case '>': /* > */
379		case T_GEQ: /* >= */
380		case T_LEQ: /* <= */
381		case T_NEQ: /* != */
382	2920	vxp_expr_num(vxp, &(pvex)->rhs, (pvex)->lhs->vxid);
383	2920	break;
384		case T_SEQ: /* eq */
385		case T_SNEQ: /* ne */
386	520	vxp_expr_str(vxp, &(*pvex)->rhs);
387	520	break;
388		case '~': /* ~ */
389		case T_NOMATCH: /* !~ */
390	2120	vxp_expr_regex(vxp, &(*pvex)->rhs);
391	2120	break;
392		default:
393	0	INCOMPL();
394	0	}
395	7480	}
396
397		/*
398		* SYNTAX:
399		* expr_group:
400		* '(' expr_or ')'
401		* expr_not
402		*/
403
404		static void
405	7680	vxp_expr_group(struct vxp vxp, struct vex *pvex)
406		{
407
408	7680	AN(pvex);
409	7680	AZ(*pvex);
410
411	7680	if (vxp->t->tok == '(') {
412	200	SkipToken(vxp, '(');
413	200	vxp_expr_or(vxp, pvex);
414	200	ERRCHK(vxp);
415	200	SkipToken(vxp, ')');
416	200	return;
417		}
418
419	7480	vxp_expr_cmp(vxp, pvex);
420	7680	}
421
422		/*
423		* SYNTAX:
424		* expr_not:
425		* 'not' expr_group
426		* expr_group
427		*/
428
429		static void
430	7680	vxp_expr_not(struct vxp vxp, struct vex *pvex)
431		{
432
433	7680	AN(pvex);
434	7680	AZ(*pvex);
435
436	7680	if (vxp->t->tok == T_NOT) {
437	40	*pvex = vex_alloc(vxp);
438	40	AN(*pvex);
439	40	(*pvex)->tok = vxp->t->tok;
440	40	vxp_NextToken(vxp);
441	40	vxp_expr_group(vxp, &(*pvex)->a);
442	40	return;
443		}
444
445	7640	vxp_expr_group(vxp, pvex);
446	7680	}
447
448		/*
449		* SYNTAX:
450		* expr_and:
451		* expr_not { 'and' expr_not }*
452		*/
453
454		static void
455	7360	vxp_expr_and(struct vxp vxp, struct vex *pvex)
456		{
457		struct vex *a;
458
459	7360	AN(pvex);
460	7360	AZ(*pvex);
461	7360	vxp_expr_not(vxp, pvex);
462	7360	ERRCHK(vxp);
463	6600	while (vxp->t->tok == T_AND) {
464	320	a = *pvex;
465	320	*pvex = vex_alloc(vxp);
466	320	AN(*pvex);
467	320	(*pvex)->tok = vxp->t->tok;
468	320	(*pvex)->a = a;
469	320	vxp_NextToken(vxp);
470	320	ERRCHK(vxp);
471	320	vxp_expr_not(vxp, &(*pvex)->b);
472	320	ERRCHK(vxp);
473		}
474	7360	}
475
476		/*
477		* SYNTAX:
478		* expr_or:
479		* expr_and { 'or' expr_and }*
480		*/
481
482		static void
483	7080	vxp_expr_or(struct vxp vxp, struct vex *pvex)
484		{
485		struct vex *a;
486
487	7080	AN(pvex);
488	7080	AZ(*pvex);
489	7080	vxp_expr_and(vxp, pvex);
490	7080	ERRCHK(vxp);
491	6280	while (vxp->t->tok == T_OR) {
492	280	a = *pvex;
493	280	*pvex = vex_alloc(vxp);
494	280	AN(*pvex);
495	280	(*pvex)->tok = vxp->t->tok;
496	280	(*pvex)->a = a;
497	280	vxp_NextToken(vxp);
498	280	ERRCHK(vxp);
499	280	vxp_expr_and(vxp, &(*pvex)->b);