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 <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h> /* for MUSL */

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

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

#include "vxp.h"

static void
vxp_ErrToken(const struct vxp *vxp, const struct token *t)
{

        if (t->tok == EOI)
                VSB_cat(vxp->sb, "end of input");
        else
                VSB_printf(vxp->sb, "'%.*s'", PF(t));
}

static void
vxp_Pos(const struct vxp *vxp, struct vsb *vsb, const struct token *t,
    int tokoff)
{
        unsigned pos;

        AN(vxp);
        AN(vsb);
        AN(t);
        assert(t->b >= vxp->b);
        pos = (unsigned)(t->b - vxp->b);
        if (tokoff > 0)
                pos += tokoff;
        VSB_printf(vsb, "(Pos %u)", pos + 1);
}

static void
vxp_quote(const struct vxp *vxp, const char *b, const char *e, int tokoff)
{
        const char *p;
        char c;

        assert(b <= e);
        assert(b >= vxp->b);
        assert(e <= vxp->e);
        for (p = vxp->b; p < vxp->e; p++) {
                if (isspace(*p))
                        VSB_putc(vxp->sb, ' ');
                else
                        VSB_putc(vxp->sb, *p);
        }
        VSB_putc(vxp->sb, '\n');
        for (p = vxp->b; p < vxp->e; p++) {
                if (p >= b && p < e) {
                        if (p - b == tokoff)
                                c = '^';
                        else
                                c = '#';
                } else
                        c = '-';
                VSB_putc(vxp->sb, c);
        }
        VSB_putc(vxp->sb, '\n');
}

void
vxp_ErrWhere(struct vxp *vxp, const struct token *t, int tokoff)
{

        AN(vxp);
        AN(t);
        vxp_Pos(vxp, vxp->sb, t, tokoff);
        VSB_putc(vxp->sb, '\n');
        vxp_quote(vxp, t->b, t->e, tokoff);
        VSB_putc(vxp->sb, '\n');
        vxp->err = 1;
}

void
vxp_NextToken(struct vxp *vxp)
{

        AN(vxp->t);
        vxp->t = VTAILQ_NEXT(vxp->t, list);
        if (vxp->t == NULL) {
                VSB_cat(vxp->sb,
                    "Ran out of input, something is missing or"
                    " maybe unbalanced parenthesis\n");
                vxp->err = 1;
        }
}

void
vxp__Expect(struct vxp *vxp, unsigned tok)
{

        if (vxp->t->tok == tok)
                return;
        VSB_printf(vxp->sb, "Expected %s got ", vxp_tnames[tok]);
        vxp_ErrToken(vxp, vxp->t);
        VSB_putc(vxp->sb, ' ');
        vxp_ErrWhere(vxp, vxp->t, -1);
}

static void
vxp_DoFree(struct vxp *vxp, void *p)
{
        struct membit *mb;

        mb = calloc(1, sizeof *mb);
        AN(mb);
        mb->ptr = p;
        VTAILQ_INSERT_TAIL(&vxp->membits, mb, list);
}

void *
vxp_Alloc(struct vxp *vxp, unsigned len)
{
        void *p;

        p = calloc(1, len);
        AN(p);
        vxp_DoFree(vxp, p);
        return (p);
}

static struct vxp *
vxp_New(struct vsb *sb)
{
        struct vxp *vxp;

        AN(sb);

        ALLOC_OBJ(vxp, VXP_MAGIC);
        AN(vxp);
        VTAILQ_INIT(&vxp->membits);
        VTAILQ_INIT(&vxp->tokens);
        vxp->sb = sb;

        return (vxp);
}

static void
vxp_Delete(struct vxp **pvxp)
{
        struct vxp *vxp;
        struct membit *mb;

        TAKE_OBJ_NOTNULL(vxp, pvxp, VXP_MAGIC);

        while (!VTAILQ_EMPTY(&vxp->membits)) {
                mb = VTAILQ_FIRST(&vxp->membits);
                VTAILQ_REMOVE(&vxp->membits, mb, list);
                free(mb->ptr);
                free(mb);
        }

        FREE_OBJ(vxp);
}

struct vex *
vex_New(const char *query, struct vsb *sb, unsigned options)
{
        struct vxp *vxp;
        struct vex *vex;

        AN(query);
        AN(sb);
        vxp = vxp_New(sb);
        vxp->b = query;
        vxp->e = query + strlen(query);
        vxp->vex_options = options;
        if (options & VEX_OPT_CASELESS)
                vxp->vre_options |= VRE_CASELESS;

        vxp_Lexer(vxp);

#ifdef VXP_DEBUG
        vxp_PrintTokens(vxp);
#endif

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

        vex = vxp_Parse(vxp);

#ifdef VXP_DEBUG
        if (vex != NULL)
                vex_PrintTree(vex);
#endif

        vxp_Delete(&vxp);
        AZ(vxp);

        return (vex);
}

		varnish-cache/lib/libvarnishapi/vxp.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 <stdint.h>
36		#include <stdlib.h>
37		#include <string.h>
38		#include <unistd.h> /* for MUSL */
39
40		#include "vdef.h"
41		#include "vas.h"
42		#include "miniobj.h"
43
44		#include "vqueue.h"
45		#include "vre.h"
46		#include "vsb.h"
47
48		#include "vxp.h"
49
50		static void
51	0	vxp_ErrToken(const struct vxp vxp, const struct token t)
52		{
53
54	0	if (t->tok == EOI)
55	0	VSB_cat(vxp->sb, "end of input");
56		else
57	0	VSB_printf(vxp->sb, "'%.*s'", PF(t));
58	0	}
59
60		static void
61	31	vxp_Pos(const struct vxp vxp, struct vsb vsb, const struct token *t,
62		int tokoff)
63		{
64		unsigned pos;
65
66	31	AN(vxp);
67	31	AN(vsb);
68	31	AN(t);
69	31	assert(t->b >= vxp->b);
70	31	pos = (unsigned)(t->b - vxp->b);
71	31	if (tokoff > 0)
72	5	pos += tokoff;
73	31	VSB_printf(vsb, "(Pos %u)", pos + 1);
74	31	}
75
76		static void
77	31	vxp_quote(const struct vxp vxp, const char b, const char *e, int tokoff)
78		{
79		const char *p;
80		char c;
81
82	31	assert(b <= e);
83	31	assert(b >= vxp->b);
84	31	assert(e <= vxp->e);
85	501	for (p = vxp->b; p < vxp->e; p++) {
86	470	if (isspace(*p))
87	66	VSB_putc(vxp->sb, ' ');
88		else
89	404	VSB_putc(vxp->sb, *p);
90	470	}
91	31	VSB_putc(vxp->sb, '\n');
92	501	for (p = vxp->b; p < vxp->e; p++) {
93	470	if (p >= b && p < e) {
94	101	if (p - b == tokoff)
95	2	c = '^';
96		else
97	99	c = '#';
98	101	} else
99	369	c = '-';
100	470	VSB_putc(vxp->sb, c);
101	470	}
102	31	VSB_putc(vxp->sb, '\n');
103	31	}
104
105		void
106	31	vxp_ErrWhere(struct vxp vxp, const struct token t, int tokoff)
107		{
108
109	31	AN(vxp);
110	31	AN(t);
111	31	vxp_Pos(vxp, vxp->sb, t, tokoff);
112	31	VSB_putc(vxp->sb, '\n');
113	31	vxp_quote(vxp, t->b, t->e, tokoff);
114	31	VSB_putc(vxp->sb, '\n');
115	31	vxp->err = 1;
116	31	}
117
118		void
119	604	vxp_NextToken(struct vxp *vxp)
120		{
121
122	604	AN(vxp->t);
123	604	vxp->t = VTAILQ_NEXT(vxp->t, list);
124	604	if (vxp->t == NULL) {
125	0	VSB_cat(vxp->sb,
126		"Ran out of input, something is missing or"
127		" maybe unbalanced parenthesis\n");
128	0	vxp->err = 1;
129	0	}
130	604	}
131
132		void
133	181	vxp__Expect(struct vxp *vxp, unsigned tok)
134		{
135
136	181	if (vxp->t->tok == tok)
137	181	return;
138	0	VSB_printf(vxp->sb, "Expected %s got ", vxp_tnames[tok]);
139	0	vxp_ErrToken(vxp, vxp->t);
140	0	VSB_putc(vxp->sb, ' ');
141	0	vxp_ErrWhere(vxp, vxp->t, -1);
142	181	}
143
144		static void
145	1247	vxp_DoFree(struct vxp vxp, void p)
146		{
147		struct membit *mb;
148
149	1247	mb = calloc(1, sizeof *mb);
150	1247	AN(mb);
151	1247	mb->ptr = p;
152	1247	VTAILQ_INSERT_TAIL(&vxp->membits, mb, list);
153	1247	}
154
155		void *
156	1247	vxp_Alloc(struct vxp *vxp, unsigned len)
157		{
158		void *p;
159
160	1247	p = calloc(1, len);
161	1247	AN(p);
162	1247	vxp_DoFree(vxp, p);
163	1247	return (p);
164		}
165
166		static struct vxp *
167	184	vxp_New(struct vsb *sb)
168		{
169		struct vxp *vxp;
170
171	184	AN(sb);
172
173	184	ALLOC_OBJ(vxp, VXP_MAGIC);
174	184	AN(vxp);
175	184	VTAILQ_INIT(&vxp->membits);
176	184	VTAILQ_INIT(&vxp->tokens);
177	184	vxp->sb = sb;
178
179	184	return (vxp);
180		}
181
182		static void
183	184	vxp_Delete(struct vxp **pvxp)
184		{
185		struct vxp *vxp;
186		struct membit *mb;
187
188	184	TAKE_OBJ_NOTNULL(vxp, pvxp, VXP_MAGIC);
189
190	1431	while (!VTAILQ_EMPTY(&vxp->membits)) {
191	1247	mb = VTAILQ_FIRST(&vxp->membits);
192	1247	VTAILQ_REMOVE(&vxp->membits, mb, list);
193	1247	free(mb->ptr);
194	1247	free(mb);
195		}
196
197	184	FREE_OBJ(vxp);
198	184	}
199
200		struct vex *
201	184	vex_New(const char query, struct vsb sb, unsigned options)
202		{
203		struct vxp *vxp;
204		struct vex *vex;
205
206	184	AN(query);
207	184	AN(sb);
208	184	vxp = vxp_New(sb);
209	184	vxp->b = query;
210	184	vxp->e = query + strlen(query);
211	184	vxp->vex_options = options;
212	184	if (options & VEX_OPT_CASELESS)
213	0	vxp->vre_options \|= VRE_CASELESS;
214
215	184	vxp_Lexer(vxp);
216
217		#ifdef VXP_DEBUG
218	3	vxp_PrintTokens(vxp);
219		#endif
220
221	184	if (vxp->err) {
222	4	vxp_Delete(&vxp);
223	4	AZ(vxp);
224	4	return (NULL);
225		}
226
227	180	vex = vxp_Parse(vxp);
228
229		#ifdef VXP_DEBUG
230	3	if (vex != NULL)
231	2	vex_PrintTree(vex);
232		#endif
233
234	180	vxp_Delete(&vxp);
235	180	AZ(vxp);
236
237	180	return (vex);
238	184	}