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 "vqueue.h"
44
#include "vre.h"
45
#include "vsb.h"
46
47
#include "vapi/vsl.h"
48
49
#include "vsl_api.h"
50
#include "vxp.h"
51
52
static void vxp_expr_or(struct vxp *vxp, struct vex **pvex);
53
54
static struct vex *
55 8600
vex_alloc(const struct vxp *vxp)
56
{
57
        struct vex *vex;
58
59 8600
        ALLOC_OBJ(vex, VEX_MAGIC);
60 8600
        AN(vex);
61 8600
        vex->options = vxp->vex_options;
62 8600
        return (vex);
63
}
64
65
static void
66 7720
vxp_expr_lhs(struct vxp *vxp, struct vex_lhs **plhs)
67
{
68
        char *p;
69
        int i;
70
71 7720
        AN(plhs);
72 7720
        AZ(*plhs);
73 7720
        ALLOC_OBJ(*plhs, VEX_LHS_MAGIC);
74 7720
        AN(*plhs);
75 7720
        (*plhs)->tags = vbit_new(SLT__MAX);
76 7720
        (*plhs)->level = -1;
77
78 7720
        if (vxp->t->tok == '{') {
79
                /* Transaction level limits */
80 280
                vxp_NextToken(vxp);
81 280
                if (vxp->t->tok != VAL) {
82 80
                        VSB_printf(vxp->sb, "Expected integer got '%.*s' ",
83 40
                            PF(vxp->t));
84 40
                        vxp_ErrWhere(vxp, vxp->t, -1);
85 40
                        return;
86
                }
87 240
                (*plhs)->level = (int)strtol(vxp->t->dec, &p, 0);
88 240
                if ((*plhs)->level < 0) {
89 40
                        VSB_cat(vxp->sb, "Expected positive integer ");
90 40
                        vxp_ErrWhere(vxp, vxp->t, -1);
91 40
                        return;
92
                }
93 200
                if (*p == '-') {
94 40
                        (*plhs)->level_pm = -1;
95 40
                        p++;
96 200
                } else if (*p == '+') {
97 40
                        (*plhs)->level_pm = 1;
98 40
                        p++;
99 40
                }
100 200
                if (*p) {
101 40
                        VSB_cat(vxp->sb, "Syntax error in level limit ");
102 40
                        vxp_ErrWhere(vxp, vxp->t, -1);
103 40
                        return;
104
                }
105 160
                vxp_NextToken(vxp);
106 160
                ExpectErr(vxp, '}');
107 160
                vxp_NextToken(vxp);
108 160
        }
109
110 7760
        while (1) {
111
                /* The tags this expression applies to */
112 7760
                if (vxp->t->tok == VXID) {
113 1160
                        (*plhs)->vxid++;
114 1160
                        i = 0;
115 7760
                } else if (vxp->t->tok != VAL) {
116 80
                        VSB_printf(vxp->sb, "Expected VSL tag name got '%.*s' ",
117 40
                            PF(vxp->t));
118 40
                        vxp_ErrWhere(vxp, vxp->t, -1);
119 40
                        return;
120
                } else {
121 6560
                        (*plhs)->taglist++;
122 13120
                        i = VSL_Glob2Tags(vxp->t->dec, -1, vsl_vbm_bitset,
123 6560
                            (*plhs)->tags);
124
                }
125 7720
                if (i == -1) {
126 80
                        VSB_cat(vxp->sb, "Tag name matches zero tags ");
127 80
                        vxp_ErrWhere(vxp, vxp->t, -1);
128 80
                        return;
129
                }
130 7640
                if (i == -2) {
131 40
                        VSB_cat(vxp->sb, "Tag name is ambiguous ");
132 40
                        vxp_ErrWhere(vxp, vxp->t, -1);
133 40
                        return;
134
                }
135 7600
                if (i == -3) {
136 40
                        VSB_cat(vxp->sb, "Syntax error in tag name ");
137 40
                        vxp_ErrWhere(vxp, vxp->t, -1);
138 40
                        return;
139
                }
140 7560
                assert(i > 0 || vxp->t->tok == VXID);
141 7560
                vxp_NextToken(vxp);
142 7560
                if (vxp->t->tok != ',')
143 7400
                        break;
144 160
                vxp_NextToken(vxp);
145
        }
146
147 7400
        if (vxp->t->tok == ':') {
148
                /* Record prefix */
149 840
                vxp_NextToken(vxp);
150 840
                if (vxp->t->tok != VAL) {
151 80
                        VSB_printf(vxp->sb, "Expected string got '%.*s' ",
152 40
                            PF(vxp->t));
153 40
                        vxp_ErrWhere(vxp, vxp->t, -1);
154 40
                        return;
155
                }
156 800
                AN(vxp->t->dec);
157 800
                (*plhs)->prefix = strdup(vxp->t->dec);
158 800
                AN((*plhs)->prefix);
159 800
                (*plhs)->prefixlen = strlen((*plhs)->prefix);
160 800
                vxp_NextToken(vxp);
161 800
        }
162
163 7360
        if (vxp->t->tok == '[') {
164
                /* LHS field [] */
165 480
                vxp_NextToken(vxp);
166 480
                if (vxp->t->tok != VAL) {
167 80
                        VSB_printf(vxp->sb, "Expected integer got '%.*s' ",
168 40
                            PF(vxp->t));
169 40
                        vxp_ErrWhere(vxp, vxp->t, -1);
170 40
                        return;
171
                }
172 440
                (*plhs)->field = (int)strtol(vxp->t->dec, &p, 0);
173 440
                if (*p || (*plhs)->field <= 0) {
174 40
                        VSB_cat(vxp->sb, "Expected positive integer ");
175 40
                        vxp_ErrWhere(vxp, vxp->t, -1);
176 40
                        return;
177
                }
178 400
                vxp_NextToken(vxp);
179 400
                ExpectErr(vxp, ']');
180 400
                vxp_NextToken(vxp);
181 400
        }
182
183 7280
        if ((*plhs)->vxid == 0)
184 6160
                return;
185
186 2120
        if ((*plhs)->vxid > 1 || (*plhs)->level >= 0 ||
187 1040
            (*plhs)->field > 0 || (*plhs)->prefixlen > 0 ||
188 1000
            (*plhs)->taglist > 0) {
189 160
                VSB_cat(vxp->sb, "Unexpected taglist selection for vxid ");
190 160
                vxp_ErrWhere(vxp, vxp->t, -1);
191 160
        }
192 7720
}
193
194
static void
195 3040
vxp_expr_num(struct vxp *vxp, struct vex_rhs **prhs, unsigned vxid)
196
{
197
        char *endptr;
198
199 3040
        AN(prhs);
200 3040
        AZ(*prhs);
201 3040
        if (vxp->t->tok != VAL) {
202 40
                VSB_printf(vxp->sb, "Expected number got '%.*s' ", PF(vxp->t));
203 40
                vxp_ErrWhere(vxp, vxp->t, -1);
204 40
                return;
205
        }
206 3000
        AN(vxp->t->dec);
207 3000
        ALLOC_OBJ(*prhs, VEX_RHS_MAGIC);
208 3000
        AN(*prhs);
209 3000
        endptr = NULL;
210 3000
        if (strchr(vxp->t->dec, '.')) {
211 480
                (*prhs)->type = VEX_FLOAT;
212 480
                (*prhs)->val_float = strtod(vxp->t->dec, &endptr);
213 480
        } else {
214 2520
                (*prhs)->type = VEX_INT;
215 2520
                (*prhs)->val_int = strtoll(vxp->t->dec, &endptr, 0);
216
        }
217 3000
        while (isspace(*endptr))
218 0
                endptr++;
219 3000
        if (*endptr != '\0') {
220 160
                VSB_printf(vxp->sb, "%s parse error ",
221 80
                    (*prhs)->type == VEX_FLOAT ? "Floating point" : "Integer");
222 80
                vxp_ErrWhere(vxp, vxp->t, -1);
223 80
                return;
224
        }
225 2920
        if (vxid && (*prhs)->type != VEX_INT) {
226 80
                VSB_printf(vxp->sb, "Expected integer got '%.*s' ",
227 40
                    PF(vxp->t));
228 40
                vxp_ErrWhere(vxp, vxp->t, 0);
229 40
                return;
230
        }
231 2880
        vxp_NextToken(vxp);
232 3040
}
233
234
static void
235 520
vxp_expr_str(struct vxp *vxp, struct vex_rhs **prhs)
236
{
237
238 520
        AN(prhs);
239 520
        AZ(*prhs);
240 520
        if (vxp->t->tok != VAL) {
241 40
                VSB_printf(vxp->sb, "Expected string got '%.*s' ", PF(vxp->t));
242 40
                vxp_ErrWhere(vxp, vxp->t, -1);
243 40
                return;
244
        }
245 480
        AN(vxp->t->dec);
246 480
        ALLOC_OBJ(*prhs, VEX_RHS_MAGIC);
247 480
        AN(*prhs);
248 480
        (*prhs)->type = VEX_STRING;
249 480
        (*prhs)->val_string = strdup(vxp->t->dec);
250 480
        AN((*prhs)->val_string);
251 480
        (*prhs)->val_stringlen = strlen((*prhs)->val_string);
252 480
        vxp_NextToken(vxp);
253 520
}
254
255
static void
256 2120
vxp_expr_regex(struct vxp *vxp, struct vex_rhs **prhs)
257
{
258
        int err, erroff;
259
260
        /* XXX: Caseless option */
261
262 2120
        AN(prhs);
263 2120
        AZ(*prhs);
264 2120
        if (vxp->t->tok != VAL) {
265 80
                VSB_printf(vxp->sb, "Expected regular expression got '%.*s' ",
266 40
                    PF(vxp->t));
267 40
                vxp_ErrWhere(vxp, vxp->t, -1);
268 40
                return;
269
        }
270 2080
        AN(vxp->t->dec);
271 2080
        ALLOC_OBJ(*prhs, VEX_RHS_MAGIC);
272 2080
        AN(*prhs);
273 2080
        (*prhs)->type = VEX_REGEX;
274 2080
        (*prhs)->val_string = strdup(vxp->t->dec);
275 2080
        (*prhs)->val_regex = VRE_compile(vxp->t->dec, vxp->vre_options,
276
            &err, &erroff, 1);
277 2080
        if ((*prhs)->val_regex == NULL) {
278 40
                VSB_cat(vxp->sb, "Regular expression error: ");
279 40
                AZ(VRE_error(vxp->sb, err));
280 40
                VSB_putc(vxp->sb, ' ');
281 40
                vxp_ErrWhere(vxp, vxp->t, erroff);
282 40
                return;
283
        }
284 2040
        vxp_NextToken(vxp);
285 2120
}
286
287
static void
288 960
vxp_vxid_cmp(struct vxp *vxp)
289
{
290
291 960
        switch (vxp->t->tok) {
292
        /* Valid operators */
293
        case T_EQ:              /* == */
294
        case '<':               /* < */
295
        case '>':               /* > */
296
        case T_GEQ:             /* >= */
297
        case T_LEQ:             /* <= */
298
        case T_NEQ:             /* != */
299 800
                break;
300
301
        /* Error */
302
        default:
303 320
                VSB_printf(vxp->sb, "Expected vxid operator got '%.*s' ",
304 160
                    PF(vxp->t));
305 160
                vxp_ErrWhere(vxp, vxp->t, -1);
306 160
        }
307 960
}
308
309
/*
310
 * SYNTAX:
311
 *   expr_cmp:
312
 *     lhs
313
 *     lhs <operator> num|str|regex
314
 */
315
316
static void
317 7720
vxp_expr_cmp(struct vxp *vxp, struct vex **pvex)
318
{
319
320 7720
        AN(pvex);
321 7720
        AZ(*pvex);
322 7720
        *pvex = vex_alloc(vxp);
323 7720
        AN(*pvex);
324 7720
        vxp_expr_lhs(vxp, &(*pvex)->lhs);
325 7720
        ERRCHK(vxp);
326
327 7120
        if ((*pvex)->lhs->vxid) {
328 960
                vxp_vxid_cmp(vxp);
329 960
                ERRCHK(vxp);
330 800
        }
331
332
        /* Test operator */
333 6960
        switch (vxp->t->tok) {
334
335
        /* Single lhs expressions don't take any more tokens */
336
        case EOI:
337
        case T_AND:
338
        case T_OR:
339
        case ')':
340 1240
                (*pvex)->tok = T_TRUE;
341 1240
                return;
342
343
        /* Valid operators */
344
        case T_EQ:              /* == */
345
        case '<':               /* < */
346
        case '>':               /* > */
347
        case T_GEQ:             /* >= */
348
        case T_LEQ:             /* <= */
349
        case T_NEQ:             /* != */
350
        case T_SEQ:             /* eq */
351
        case T_SNEQ:            /* ne */
352
        case '~':               /* ~ */
353
        case T_NOMATCH:         /* !~ */
354 5680
                (*pvex)->tok = vxp->t->tok;
355 5680
                break;
356
357
        /* Error */
358
        default:
359 80
                VSB_printf(vxp->sb, "Expected operator got '%.*s' ",
360 40
                    PF(vxp->t));
361 40
                vxp_ErrWhere(vxp, vxp->t, -1);
362 40
                return;
363
        }
364 5680
        vxp_NextToken(vxp);
365 5680
        ERRCHK(vxp);
366
367
        /* Value */
368 5680
        switch ((*pvex)->tok) {
369
        case '\0':
370 0
                WRONG("Missing token");
371 0
                break;
372
        case T_EQ:              /* == */
373
        case '<':               /* < */
374
        case '>':               /* > */
375
        case T_GEQ:             /* >= */
376
        case T_LEQ:             /* <= */
377
        case T_NEQ:             /* != */
378 3040
                vxp_expr_num(vxp, &(*pvex)->rhs, (*pvex)->lhs->vxid);
379 3040
                break;
380
        case T_SEQ:             /* eq */
381
        case T_SNEQ:            /* ne */
382 520
                vxp_expr_str(vxp, &(*pvex)->rhs);
383 520
                break;
384
        case '~':               /* ~ */
385
        case T_NOMATCH:         /* !~ */
386 2120
                vxp_expr_regex(vxp, &(*pvex)->rhs);
387 2120
                break;
388
        default:
389 0
                INCOMPL();
390 0
        }
391 7720
}
392
393
/*
394
 * SYNTAX:
395
 *   expr_group:
396
 *     '(' expr_or ')'
397
 *     expr_not
398
 */
399
400
static void
401 7920
vxp_expr_group(struct vxp *vxp, struct vex **pvex)
402
{
403
404 7920
        AN(pvex);
405 7920
        AZ(*pvex);
406
407 7920
        if (vxp->t->tok == '(') {
408 200
                SkipToken(vxp, '(');
409 200
                vxp_expr_or(vxp, pvex);
410 200
                ERRCHK(vxp);
411 200
                SkipToken(vxp, ')');
412 200
                return;
413
        }
414
415 7720
        vxp_expr_cmp(vxp, pvex);
416 7920
}
417
418
/*
419
 * SYNTAX:
420
 *   expr_not:
421
 *     'not' expr_group
422
 *     expr_group
423
 */
424
425
static void
426 7920
vxp_expr_not(struct vxp *vxp, struct vex **pvex)
427
{
428
429 7920
        AN(pvex);
430 7920
        AZ(*pvex);
431
432 7920
        if (vxp->t->tok == T_NOT) {
433 40
                *pvex = vex_alloc(vxp);
434 40
                AN(*pvex);
435 40
                (*pvex)->tok = vxp->t->tok;
436 40
                vxp_NextToken(vxp);
437 40
                vxp_expr_group(vxp, &(*pvex)->a);
438 40
                return;
439
        }
440
441 7880
        vxp_expr_group(vxp, pvex);
442 7920
}
443
444
/*
445
 * SYNTAX:
446
 *   expr_and:
447
 *     expr_not { 'and' expr_not }*
448
 */
449
450
static void
451 7600
vxp_expr_and(struct vxp *vxp, struct vex **pvex)
452
{
453
        struct vex *a;
454
455 7600
        AN(pvex);
456 7600
        AZ(*pvex);
457 7600
        vxp_expr_not(vxp, pvex);
458 7600
        ERRCHK(vxp);
459 6840
        while (vxp->t->tok == T_AND) {
460 320
                a = *pvex;
461 320
                *pvex = vex_alloc(vxp);
462 320
                AN(*pvex);
463 320
                (*pvex)->tok = vxp->t->tok;
464 320
                (*pvex)->a = a;
465 320
                vxp_NextToken(vxp);
466 320
                ERRCHK(vxp);
467 320
                vxp_expr_not(vxp, &(*pvex)->b);
468 320
                ERRCHK(vxp);
469
        }
470 7600
}
471
472
/*
473
 * SYNTAX:
474
 *   expr_or:
475
 *     expr_and { 'or' expr_and }*
476
 */
477
478
static void
479 7320
vxp_expr_or(struct vxp *vxp, struct vex **pvex)
480
{
481
        struct vex *a;
482
483 7320
        AN(pvex);
484 7320
        AZ(*pvex);
485 7320
        vxp_expr_and(vxp, pvex);
486 7320
        ERRCHK(vxp);
487 6520
        while (vxp->t->tok == T_OR) {
488 280
                a = *pvex;
489 280
                *pvex = vex_alloc(vxp);
490 280
                AN(*pvex);
491 280
                (*pvex)->tok = vxp->t->tok;
492 280
                (*pvex)->a = a;
493 280
                vxp_NextToken(vxp);
494 280
                ERRCHK(vxp);
495 280
                vxp_expr_and(vxp, &(*pvex)->b);
496 280
                ERRCHK(vxp);
497
        }
498 7320
}
499
500
/*
501
 * SYNTAX:
502
 *   expr:
503
 *     expr_or EOI { 'or' expr_or EOI }?
504
 */
505
506
static void
507 7360
vxp_expr(struct vxp *vxp, struct vex **pvex)
508
{
509 7360
        struct vex *a = NULL, *or;
510
511 7360
        if (*pvex == NULL) {
512 7120
                vxp_expr_or(vxp, pvex);
513 7120
                ERRCHK(vxp);
514 6040
                ExpectErr(vxp, EOI);
515 6040
                return;
516
        }
517
518 240
        vxp_expr(vxp, &a);
519 240
        ERRCHK(vxp);
520
521 240
        or = vex_alloc(vxp);
522 240
        AN(or);
523 240
        or->tok = T_OR;
524 240
        or->b = *pvex;
525 240
        or->a = a;
526 240
        *pvex = or;
527 7360
}
528
529
/*
530
 * Build a struct vex tree from the token list in vxp
531
 */
532
533
struct vex *
534 6960
vxp_Parse(struct vxp *vxp)
535
{
536 6960
        struct vex *vex = NULL;
537
538 6960
        AZ(vxp->err);
539 6960
        vxp->t = VTAILQ_FIRST(&vxp->tokens);
540
541 13000
        while (vxp->t != NULL) {
542
                /* Ignore empty queries */
543 8360
                while (vxp->t != NULL && vxp->t->tok == EOI)
544 960
                        vxp->t = VTAILQ_NEXT(vxp->t, list);
545
546 7400
                if (vxp->t == NULL)
547 280
                        break;
548
549 7120
                vxp_expr(vxp, &vex);
550
551 7120
                if (vxp->err) {
552 1080
                        if (vex)
553 1080
                                vex_Free(&vex);
554 1080
                        AZ(vex);
555 1080
                        return (NULL);
556
                }
557
558 6040
                vxp->t = VTAILQ_NEXT(vxp->t, list);
559
        }
560
561 5880
        return (vex);
562 6960
}
563
564
/*
565
 * Free a struct vex tree
566
 */
567
568
void
569 8600
vex_Free(struct vex **pvex)
570
{
571
        struct vex *vex;
572
        struct vex_lhs *lhs;
573
        struct vex_rhs *rhs;
574
575 8600
        TAKE_OBJ_NOTNULL(vex, pvex, VEX_MAGIC);
576
577 8600
        if (vex->lhs) {
578 7720
                CAST_OBJ_NOTNULL(lhs, vex->lhs, VEX_LHS_MAGIC);
579 7720
                if (lhs->tags)
580 7720
                        vbit_destroy(lhs->tags);
581 7720
                if (lhs->prefix)
582 800
                        free(lhs->prefix);
583 7720
                FREE_OBJ(lhs);
584 7720
        }
585 8600
        if (vex->rhs) {
586 5560
                CAST_OBJ_NOTNULL(rhs, vex->rhs, VEX_RHS_MAGIC);
587 5560
                if (rhs->val_string)
588 2560
                        free(rhs->val_string);
589 5560
                if (rhs->val_regex)
590 2040
                        VRE_free(&rhs->val_regex);
591 5560
                FREE_OBJ(rhs);
592 5560
        }
593 8600
        if (vex->a) {
594 880
                vex_Free(&vex->a);
595 880
                AZ(vex->a);
596 880
        }
597 8600
        if (vex->b) {
598 840
                vex_Free(&vex->b);
599 840
                AZ(vex->b);
600 840
        }
601 8600
        FREE_OBJ(vex);
602 8600
}
603
604
#ifdef VXP_DEBUG
605
606
static void
607 120
vex_print_rhs(const struct vex_rhs *rhs)
608
{
609
610 120
        CHECK_OBJ_NOTNULL(rhs, VEX_RHS_MAGIC);
611 120
        fprintf(stderr, "rhs=");
612 120
        switch (rhs->type) {
613
        case VEX_INT:
614 80
                fprintf(stderr, "INT(%jd)", (intmax_t)rhs->val_int);
615 80
                break;
616
        case VEX_FLOAT:
617 0
                fprintf(stderr, "FLOAT(%f)", rhs->val_float);
618 0
                break;
619
        case VEX_STRING:
620 0
                AN(rhs->val_string);
621 0
                fprintf(stderr, "STRING(%s)", rhs->val_string);
622 0
                break;
623
        case VEX_REGEX:
624 40
                AN(rhs->val_string);
625 40
                AN(rhs->val_regex);
626 40
                fprintf(stderr, "REGEX(%s)", rhs->val_string);
627 40
                break;
628
        default:
629 0
                WRONG("rhs type");
630 0
                break;
631
        }
632 120
}
633
634
static void
635 160
vex_print_tags(const struct vbitmap *vbm)
636
{
637
        int i;
638 160
        int first = 1;
639
640 41120
        for (i = 0; i < SLT__MAX; i++) {
641 40960
                if (VSL_tags[i] == NULL)
642 26080
                        continue;
643 14880
                if (!vbit_test(vbm, i))
644 14560
                        continue;
645 320
                if (first)
646 160
                        first = 0;
647
                else
648 160
                        fprintf(stderr, ",");
649 320
                fprintf(stderr, "%s", VSL_tags[i]);
650 320
        }
651 160
}
652
653
static void
654 240
vex_print(const struct vex *vex, int indent)
655
{
656 240
        CHECK_OBJ_NOTNULL(vex, VEX_MAGIC);
657
658 240
        fprintf(stderr, "%*s%s", indent, "", vxp_tnames[vex->tok]);
659 240
        if (vex->lhs != NULL) {
660 160
                CHECK_OBJ(vex->lhs, VEX_LHS_MAGIC);
661 160
                AN(vex->lhs->tags);
662 160
                fprintf(stderr, " lhs=");
663 160
                if (vex->lhs->level >= 0)
664 0
                        fprintf(stderr, "{%d%s}", vex->lhs->level,
665 0
                            vex->lhs->level_pm < 0 ? "-" :
666 0
                            vex->lhs->level_pm > 0 ? "+" : "");
667 160
                fprintf(stderr, "(");
668 160
                vex_print_tags(vex->lhs->tags);
669 160
                fprintf(stderr, ")");
670 160
                if (vex->lhs->prefix) {
671 80
                        assert(vex->lhs->prefixlen == strlen(vex->lhs->prefix));
672 80
                        fprintf(stderr, ":%s", vex->lhs->prefix);
673 80
                }
674 160
                if (vex->lhs->field > 0)
675 40
                        fprintf(stderr, "[%d]", vex->lhs->field);
676 160
        }
677 240
        if (vex->rhs != NULL) {
678 120
                fprintf(stderr, " ");
679 120
                vex_print_rhs(vex->rhs);
680 120
        }
681 240
        fprintf(stderr, "\n");
682 240
        if (vex->a != NULL)
683 80
                vex_print(vex->a, indent + 2);
684 240
        if (vex->b != NULL)
685 80
                vex_print(vex->b, indent + 2);
686 240
}
687
688
void
689 80
vex_PrintTree(const struct vex *vex)
690
{
691
692 80
        CHECK_OBJ_NOTNULL(vex, VEX_MAGIC);
693 80
        fprintf(stderr, "VEX tree:\n");
694 80
        vex_print(vex, 2);
695 80
}
696
697
#endif /* VXP_DEBUG */