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