GCOV - Varnish Cache


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

#include "config.h"

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

#include "vcc_compile.h"

#include "venc.h"
#include "vct.h"

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

void
vcc_ErrToken(const struct vcc *tl, const struct token *t)
{

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

void
vcc__ErrInternal(struct vcc *tl, const char *func, unsigned line)
{

        VSB_printf(tl->sb, "VCL compiler internal error at %s():%u\n",
            func, line);
        tl->err = 1;
}

/*--------------------------------------------------------------------
 * Find start of source-line of token
 */

static void
vcc_iline(const struct token *t, const char **ll, int tail)
{
        const char *p, *b, *x;

        b = t->src->b;
        if (ll != NULL)
                *ll = b;
        x = tail ? t->e - 1 : t->b;
        for (p = b; p < x; p++) {
                if (*p == '\n') {
                        if (ll != NULL)
                                *ll = p + 1;
                }
        }
}

/*--------------------------------------------------------------------
 * Find and print src+line+pos of this token
 */

static void
vcc_icoord(struct vsb *vsb, const struct token *t, int tail)
{
        unsigned lin, pos;
        const char *p, *b, *x;

        lin = 1;
        pos = 0;
        b = t->src->b;
        x = tail ? t->e - 1 : t->b;
        for (p = b; p < x; p++) {
                if (*p == '\n') {
                        lin++;
                        pos = 0;
                } else if (*p == '\t') {
                        pos &= ~7;
                        pos += 8;
                } else
                        pos++;
        }
        VSB_cat(vsb, "(");
        if (tail < 2)
                VSB_printf(vsb, "'%s' Line %u ", t->src->name, lin);
        VSB_printf(vsb, "Pos %u)", pos + 1);
}

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

void
vcc_Coord(const struct vcc *tl, struct vsb *vsb, const struct token *t)
{

        if (t == NULL)
                t = tl->t;
        vcc_icoord(vsb, t, 0);
}

/*--------------------------------------------------------------------
 * Output one line of source code, starting at 'l' and ending at the
 * first NL or 'le'.
 */

static void
vcc_quoteline(const struct vcc *tl, const char *l, const char *le)
{
        const char *p;
        unsigned x, y;

        x = y = 0;
        for (p = l; p < le && *p != '\n'; p++) {
                if (*p == '\t') {
                        y &= ~7;
                        y += 8;
                        while (x < y) {
                                VSB_putc(tl->sb, ' ');
                                x++;
                        }
                } else {
                        x++;
                        y++;
                        VSB_putc(tl->sb, *p);
                }
        }
        VSB_putc(tl->sb, '\n');
}

/*--------------------------------------------------------------------
 * Output a marker line for a sourceline starting at 'l' and ending at
 * the first NL or 'le'.  Characters between 'b' and 'e' are marked.
 */

static void
vcc_markline(const struct vcc *tl, const char *l, const char *le,
    const char *b, const char *e)
{
        const char *p;
        unsigned x, y;
        char c;

        x = y = 0;
        for (p = l; p < le && *p != '\n'; p++) {
                if (p >= b && p < e)
                        c = '#';
                else
                        c = '-';

                if (*p == '\t') {
                        y &= ~7;
                        y += 8;
                } else
                        y++;
                while (x < y) {
                        VSB_putc(tl->sb, c);
                        x++;
                }
        }
        VSB_putc(tl->sb, '\n');
}

void
vcc_Warn(struct vcc *tl)
{

        AN(tl);
        AN(tl->err);
        VSB_cat(tl->sb, "(That was just a warning)\n");
        tl->err = 0;
}

/*--------------------------------------------------------------------*/
/* XXX: should take first+last token */

void
vcc_ErrWhere2(struct vcc *tl, const struct token *t, const struct token *t2)
{
        const char  *l1, *l2, *l3;

        if (t == NULL) {
                vcc_ErrWhere(tl, t2);
                return;
        }
        vcc_iline(t, &l1, 0);
        t2 = VTAILQ_PREV(t2, tokenhead, list);
        vcc_iline(t2, &l2, 1);


        if (l1 == l2) {
                vcc_icoord(tl->sb, t, 0);
                VSB_cat(tl->sb, " -- ");
                vcc_icoord(tl->sb, t2, 2);
                VSB_putc(tl->sb, '\n');
                /* Two tokens on same line */
                vcc_quoteline(tl, l1, t->src->e);
                vcc_markline(tl, l1, t->src->e, t->b, t2->e);
        } else {
                /* Two tokens different lines */
                l3 = strchr(l1, '\n');
                AN(l3);
                /* XXX: t had better be before t2 */
                vcc_icoord(tl->sb, t, 0);
                if (l3 + 1 == l2) {
                        VSB_cat(tl->sb, " -- ");
                        vcc_icoord(tl->sb, t2, 1);
                }
                VSB_putc(tl->sb, '\n');
                vcc_quoteline(tl, l1, t->src->e);
                vcc_markline(tl, l1, t->src->e, t->b, t2->e);
                if (l3 + 1 != l2) {
                        VSB_cat(tl->sb, "[...]\n");
                        vcc_icoord(tl->sb, t2, 1);
                        VSB_putc(tl->sb, '\n');
                }
                vcc_quoteline(tl, l2, t->src->e);
                vcc_markline(tl, l2, t->src->e, t->b, t2->e);
        }
        VSB_putc(tl->sb, '\n');
        tl->err = 1;
}

void
vcc_ErrWhere(struct vcc *tl, const struct token *t)
{
        const char  *l1;

        vcc_iline(t, &l1, 0);
        vcc_icoord(tl->sb, t, 0);
        VSB_putc(tl->sb, '\n');
        vcc_quoteline(tl, l1, t->src->e);
        vcc_markline(tl, l1, t->src->e, t->b, t->e);
        VSB_putc(tl->sb, '\n');
        tl->err = 1;
}

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

struct token *
vcc_PeekTokenFrom(const struct vcc *tl, const struct token *t)
{
        struct token *t2;

        CHECK_OBJ_NOTNULL(tl, VCC_MAGIC);
        AN(t);
        assert(t->tok != EOI);
        t2 = VTAILQ_NEXT(t, list);
        AN(t2);
        return (t2);
}

struct token *
vcc_PeekToken(const struct vcc *tl)
{

        CHECK_OBJ_NOTNULL(tl, VCC_MAGIC);
        return (vcc_PeekTokenFrom(tl, tl->t));
}

void
vcc_NextToken(struct vcc *tl)
{

        CHECK_OBJ_NOTNULL(tl, VCC_MAGIC);
        tl->t = vcc_PeekTokenFrom(tl, tl->t);
}

void
vcc__Expect(struct vcc *tl, unsigned tok, unsigned line)
{
        if (tl->t->tok == tok)
                return;
        VSB_printf(tl->sb, "Expected %s got ", vcl_tnames[tok]);
        vcc_ErrToken(tl, tl->t);
        VSB_printf(tl->sb, "\n(program line %u), at\n", line);
        vcc_ErrWhere(tl, tl->t);
}

/*--------------------------------------------------------------------
 * Compare ID token to string, return true of match
 */

int
vcc_IdIs(const struct token *t, const char *p)
{
        const char *q;

        assert(t->tok == ID);
        for (q = t->b; q < t->e && *p != '\0'; p++, q++)
                if (*q != *p)
                        return (0);
        if (q != t->e || *p != '\0')
                return (0);
        return (1);
}

/*--------------------------------------------------------------------
 * Check that we have a Varnish identifier
 */

void
vcc_PrintTokens(const struct vcc *tl,
    const struct token *tb, const struct token *te)
{

        CHECK_OBJ_NOTNULL(tl, VCC_MAGIC);
        AN(tb);
        AN(te);
        while (tb != te) {
                VSB_printf(tl->sb, "%.*s", PF(tb));
                tb = vcc_PeekTokenFrom(tl, tb);
                AN(tb);
        }
}

void
vcc_ExpectVid(struct vcc *tl, const char *what)
{
        const char *bad = NULL;
        struct token *t2;

        ExpectErr(tl, ID);
        ERRCHK(tl);

        t2 = vcc_PeekToken(tl);
        AN(t2);
        while (t2->tok == '.') {
                bad = ".";
                t2 = vcc_PeekTokenFrom(tl, t2);
                AN(t2);
                if (t2->tok != ID)
                        break;
                t2 = vcc_PeekTokenFrom(tl, t2);
                AN(t2);
        }
        if (bad == NULL)
                bad = VCT_invalid_name(tl->t->b, tl->t->e);
        if (bad != NULL) {
                VSB_printf(tl->sb, "Name of %s, '", what);
                vcc_PrintTokens(tl, tl->t, t2);
                VSB_printf(tl->sb,
                    "', contains illegal character '%c'\n", *bad);
                vcc_ErrWhere2(tl, tl->t, t2);
                return;
        }
}

/*--------------------------------------------------------------------
 * Decode a string
 */

static void
vcc_decstr(struct vcc *tl, unsigned sep)
{
        char *q;
        unsigned int l;

        assert(tl->t->tok == CSTR);
        l = pdiff(tl->t->b + sep, tl->t->e - sep);
        tl->t->dec = TlAlloc(tl, l + 1);
        AN(tl->t->dec);
        q = tl->t->dec;
        memcpy(q, tl->t->b + sep, l);
        q[l] = '\0';
}

/*--------------------------------------------------------------------
 * Add a token to the token list.
 */

static void
vcc_addtoken(struct vcc *tl, unsigned tok,
    struct source *sp, const char *b, const char *e)
{
        struct token *t;

        t = TlAlloc(tl, sizeof *t);
        assert(t != NULL);
        t->tok = tok;
        t->b = b;
        t->e = e;
        t->src = sp;
        VTAILQ_INSERT_TAIL(&sp->src_tokens, t, src_list);
        tl->t = t;
}

/*--------------------------------------------------------------------
 * Find a delimited token
 */

static const struct delim_def {
        const char      *name;
        const char      *b;
        const char      *e;
        unsigned        len;    /* NB: must be the same for both delimiters */
        unsigned        crlf;
        unsigned        tok;
} delim_defs[] = {
#define DELIM_DEF(nm, l, r, c, t)               \
        { nm, l, r, sizeof (l) - 1, c, t }
        DELIM_DEF("long-string", "\"\"\"", "\"\"\"", 1, CSTR),  /* """...""" */
        DELIM_DEF("long-string", "{\"", "\"}", 1, CSTR),        /*  {"..."}  */
        DELIM_DEF("string", "\"", "\"", 0, CSTR),               /*   "..."   */
        DELIM_DEF("inline C source", "C{", "}C", 1, CSRC),      /*  C{...}C  */
#undef DELIM_DEF
        { NULL }
};

static unsigned
vcc_delim_token(struct vcc *tl, struct source *sp, const char *p,
    const char **qp)
{
        const struct delim_def *dd;
        const char *q, *r;

        for (dd = delim_defs; dd->name != NULL; dd++)
                if (!strncmp(p, dd->b, dd->len))
                        break;

        if (dd->name == NULL)
                return (0);

        q = strstr(p + dd->len, dd->e);
        if (q != NULL && !dd->crlf) {
                r = strpbrk(p + dd->len, "\r\n");
                if (r != NULL && r < q)
                        q = NULL;
        }

        if (q == NULL) {
                vcc_addtoken(tl, EOI, sp, p, p + dd->len);
                VSB_printf(tl->sb, "Unterminated %s, starting at\n", dd->name);
                vcc_ErrWhere(tl, tl->t);
                return (0);
        }

        assert(q < sp->e);
        vcc_addtoken(tl, dd->tok, sp, p, q + dd->len);
        if (dd->tok == CSTR)
                vcc_decstr(tl, dd->len);
        *qp = q + dd->len;
        return (1);
}

/*--------------------------------------------------------------------
 * Lex a number, either CNUM or FNUM.
 * We enforce the RFC8941 restrictions on number of digits here.
 */

static int
vcc_lex_number_token_valid(struct vcc *tl)
{
        if (*tl->t->e == 'e' || *tl->t->e == 'E') {
                VSB_printf(tl->sb, "Unexpected character '%c'.\n", *tl->t->e);
                tl->t->e++;
                vcc_ErrWhere(tl, tl->t);
                return (0);
        }
        return (1);
}

static const char *
vcc_lex_number(struct vcc *tl, struct source *sp, const char *p)
{
        const char *q, *r;
        char *s;

        for (q = p; q < sp->e; q++)
                if (!vct_isdigit(*q))
                        break;
        if (*q != '.') {
                vcc_addtoken(tl, CNUM, sp, p, q);
                if (q - p > 15) {
                        VSB_cat(tl->sb, "Too many digits for integer.\n");
                        vcc_ErrWhere(tl, tl->t);
                        return (NULL);
                }
                if (! vcc_lex_number_token_valid(tl))
                        return (NULL);
                tl->t->num = strtod(p, &s);
                assert(s == tl->t->e);
                return (q);
        }
        r = ++q;
        for (; r < sp->e; r++)
                if (!vct_isdigit(*r))
                        break;
        vcc_addtoken(tl, FNUM, sp, p, r);
        if (q - p > 13 || r - q > 3) {
                VSB_cat(tl->sb, "Too many digits for real.\n");
                vcc_ErrWhere(tl, tl->t);
                return (NULL);
        }
        if (! vcc_lex_number_token_valid(tl))
                return (NULL);
        tl->t->num = strtod(p, &s);
        assert(s == tl->t->e);
        return (r);
}

/*--------------------------------------------------------------------
 * Lexical analysis and token generation
 */

void
vcc_Lexer(struct vcc *tl, struct source *sp)
{
        const char *p, *q, *r;
        unsigned u;
        struct vsb *vsb;
        char namebuf[40];

        for (p = sp->b; p < sp->e; ) {

                /* Skip any whitespace */
                if (vct_isspace(*p)) {
                        p++;
                        continue;
                }

                /* Skip '#.*\n' comments */
                if (*p == '#') {
                        while (p < sp->e && *p != '\n')
                                p++;
                        continue;
                }

                /* Skip C-style comments */
                if (*p == '/' && p[1] == '*') {
                        for (q = p + 2; q < sp->e; q++) {
                                if (*q == '/' && q[1] == '*') {
                                        VSB_cat(tl->sb,
                                            "/* ... */ comment contains /*\n");
                                        vcc_addtoken(tl, EOI, sp, p, p + 2);
                                        vcc_ErrWhere(tl, tl->t);
                                        vcc_addtoken(tl, EOI, sp, q, q + 2);
                                        vcc_ErrWhere(tl, tl->t);
                                        return;
                                }
                                if (*q == '*' && q[1] == '/') {
                                        p = q + 2;
                                        break;
                                }
                        }
                        if (q < sp->e)
                                continue;
                        vcc_addtoken(tl, EOI, sp, p, p + 2);
                        VSB_cat(tl->sb,
                            "Unterminated /* ... */ comment, starting at\n");
                        vcc_ErrWhere(tl, tl->t);
                        return;
                }

                /* Skip C++-style comments */
                if (*p == '/' && p[1] == '/') {
                        while (p < sp->e && *p != '\n')
                                p++;
                        continue;
                }

                /* Recognize BLOB (= SF-binary) */
                if (*p == ':') {
                        vsb = VSB_new_auto();
                        AN(vsb);
                        q = sp->e;
                        q -= (q - (p + 1)) % 4;
                        assert(q > p);
                        r = VENC_Decode_Base64(vsb, p + 1, q);
                        if (r == NULL) {
                                vcc_addtoken(tl, CBLOB, sp, p, q + 1);
                                VSB_cat(tl->sb,
                                    "Missing colon at end of BLOB:\n");
                                vcc_ErrWhere(tl, tl->t);
                                VSB_destroy(&vsb);
                                return;
                        }
                        vcc_addtoken(tl, CBLOB, sp, p, r + 1);
                        if (*r == ':' && ((r - p) % 4) != 1) {
                                VSB_cat(tl->sb,
                                    "BLOB must have n*4 base64 characters\n");
                                vcc_ErrWhere(tl, tl->t);
                                VSB_destroy(&vsb);
                                return;
                        }
                        if (*r == '=') {
                                VSB_cat(tl->sb,
                                    "Wrong padding ('=') in BLOB:\n");
                                vcc_ErrWhere(tl, tl->t);
                                VSB_destroy(&vsb);
                                return;
                        }
                        if (*r != ':') {
                                VSB_cat(tl->sb, "Illegal BLOB character:\n");
                                vcc_ErrWhere(tl, tl->t);
                                VSB_destroy(&vsb);
                                return;
                        }
                        r++;
                        AZ(VSB_finish(vsb));

                        bprintf(namebuf, "blob_%u", tl->unique++);
                        Fh(tl, 0,
                            "\nstatic const unsigned char %s_data[%zd] = {\n",
                            namebuf, VSB_len(vsb));
                        for (u = 0; u < VSB_len(vsb); u++) {
                                Fh(tl, 0, "\t0x%02x,", VSB_data(vsb)[u] & 0xff);
                                if ((u & 7) == 7)
                                        Fh(tl, 0, "\n");
                        }
                        if ((u & 7) != 7)
                                Fh(tl, 0, "\n");
                        Fh(tl, 0, "};\n");
                        Fh(tl, 0,
                            "\nstatic const struct vrt_blob %s[1] = {{\n",
                            namebuf);
                        Fh(tl, 0, "\t.magic =\tVRT_BLOB_MAGIC,\n");
                        Fh(tl, 0, "\t.len =\t%zd,\n", VSB_len(vsb));
                        Fh(tl, 0, "\t.blob =\t%s_data,\n", namebuf);
                        Fh(tl, 0, "}};\n");
                        REPLACE(tl->t->dec, namebuf);
                        VSB_destroy(&vsb);
                        p = r;
                        continue;
                }

                /* Match delimited tokens */
                if (vcc_delim_token(tl, sp, p, &q) != 0) {
                        p = q;
                        continue;
                }
                ERRCHK(tl);

                /* Match for the fixed tokens (see generate.py) */
                u = vcl_fixed_token(p, &q);
                if (u != 0) {
                        vcc_addtoken(tl, u, sp, p, q);
                        p = q;
                        continue;
                }

                /* Match Identifiers */
                if (vct_isident1(*p)) {
                        for (q = p; q < sp->e; q++)
                                if (!vct_isident(*q))
                                        break;
                        vcc_addtoken(tl, ID, sp, p, q);
                        p = q;
                        continue;
                }

                /* Match numbers { [0-9]+ } */
                if (vct_isdigit(*p)) {
                        p = vcc_lex_number(tl, sp, p);
                        if (p == NULL)
                                return;
                        continue;
                }
                vcc_addtoken(tl, EOI, sp, p, p + 1);
                VSB_cat(tl->sb, "Syntax error at\n");
                vcc_ErrWhere(tl, tl->t);
                return;
        }
        vcc_addtoken(tl, EOI, sp, sp->e, sp->e);
}

		varnish-cache/lib/libvcc/vcc_token.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2011 Varnish Software AS
3		* All rights reserved.
4		*
5		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6		*
7		* SPDX-License-Identifier: BSD-2-Clause
8		*
9		* Redistribution and use in source and binary forms, with or without
10		* modification, are permitted provided that the following conditions
11		* are met:
12		* 1. Redistributions of source code must retain the above copyright
13		* notice, this list of conditions and the following disclaimer.
14		* 2. Redistributions in binary form must reproduce the above copyright
15		* notice, this list of conditions and the following disclaimer in the
16		* documentation and/or other materials provided with the distribution.
17		*
18		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28		* SUCH DAMAGE.
29		*/
30
31		#include "config.h"
32
33		#include <stdlib.h>
34		#include <string.h>
35
36		#include "vcc_compile.h"
37
38		#include "venc.h"
39		#include "vct.h"
40
41		/--------------------------------------------------------------------/
42
43		void
44	264	vcc_ErrToken(const struct vcc tl, const struct token t)
45		{
46
47	264	if (t->tok == EOI)
48	0	VSB_cat(tl->sb, "end of input");
49	264	else if (t->tok == CSRC)
50	0	VSB_cat(tl->sb, "C{ ... }C");
51		else
52	264	VSB_printf(tl->sb, "'%.*s'", PF(t));
53	264	}
54
55		void
56	0	vcc__ErrInternal(struct vcc tl, const char func, unsigned line)
57		{
58
59	0	VSB_printf(tl->sb, "VCL compiler internal error at %s():%u\n",
60	0	func, line);
61	0	tl->err = 1;
62	0	}
63
64		/*--------------------------------------------------------------------
65		* Find start of source-line of token
66		*/
67
68		static void
69	5495	vcc_iline(const struct token t, const char *ll, int tail)
70		{
71		const char p, b, *x;
72
73	5495	b = t->src->b;
74	5495	if (ll != NULL)
75	5495	*ll = b;
76	5495	x = tail ? t->e - 1 : t->b;
77	2405009	for (p = b; p < x; p++) {
78	2399514	if (*p == '\n') {
79	67460	if (ll != NULL)
80	67460	*ll = p + 1;
81	67460	}
82	2399514	}
83	5495	}
84
85		/*--------------------------------------------------------------------
86		* Find and print src+line+pos of this token
87		*/
88
89		static void
90	964069	vcc_icoord(struct vsb vsb, const struct token t, int tail)
91		{
92		unsigned lin, pos;
93		const char p, b, *x;
94
95	964069	lin = 1;
96	964069	pos = 0;
97	964069	b = t->src->b;
98	964069	x = tail ? t->e - 1 : t->b;
99	4052432254	for (p = b; p < x; p++) {
100	4051468185	if (*p == '\n') {
101	168677569	lin++;
102	168677569	pos = 0;
103	4051468185	} else if (*p == '\t') {
104	81284515	pos &= ~7;
105	81284515	pos += 8;
106	81284515	} else
107	3801506101	pos++;
108	4051468185	}
109	964069	VSB_cat(vsb, "(");
110	964069	if (tail < 2)
111	963069	VSB_printf(vsb, "'%s' Line %u ", t->src->name, lin);
112	964069	VSB_printf(vsb, "Pos %u)", pos + 1);
113	964069	}
114
115		/--------------------------------------------------------------------/
116
117		void
118	958574	vcc_Coord(const struct vcc tl, struct vsb vsb, const struct token *t)
119		{
120
121	958574	if (t == NULL)
122	958574	t = tl->t;
123	958574	vcc_icoord(vsb, t, 0);
124	958574	}
125
126		/*--------------------------------------------------------------------
127		* Output one line of source code, starting at 'l' and ending at the
128		* first NL or 'le'.
129		*/
130
131		static void
132	4495	vcc_quoteline(const struct vcc tl, const char l, const char *le)
133		{
134		const char *p;
135		unsigned x, y;
136
137	4495	x = y = 0;
138	149041	for (p = l; p < le && *p != '\n'; p++) {
139	144546	if (*p == '\t') {
140	6070	y &= ~7;
141	6070	y += 8;
142	54630	while (x < y) {
143	48560	VSB_putc(tl->sb, ' ');
144	48560	x++;
145		}
146	6070	} else {
147	138476	x++;
148	138476	y++;
149	138476	VSB_putc(tl->sb, *p);
150		}
151	144546	}
152	4495	VSB_putc(tl->sb, '\n');
153	4495	}
154
155		/*--------------------------------------------------------------------
156		* Output a marker line for a sourceline starting at 'l' and ending at
157		* the first NL or 'le'. Characters between 'b' and 'e' are marked.
158		*/
159
160		static void
161	4495	vcc_markline(const struct vcc tl, const char l, const char *le,
162		const char b, const char e)
163		{
164		const char *p;
165		unsigned x, y;
166		char c;
167
168	4495	x = y = 0;
169	149041	for (p = l; p < le && *p != '\n'; p++) {
170	144546	if (p >= b && p < e)
171	35380	c = '#';
172		else
173	109166	c = '-';
174
175	144546	if (*p == '\t') {
176	6070	y &= ~7;
177	6070	y += 8;
178	6070	} else
179	138476	y++;
180	331582	while (x < y) {
181	187036	VSB_putc(tl->sb, c);
182	187036	x++;
183		}
184	144546	}
185	4495	VSB_putc(tl->sb, '\n');
186	4495	}
187
188		void
189	1232	vcc_Warn(struct vcc *tl)
190		{
191
192	1232	AN(tl);
193	1232	AN(tl->err);
194	1232	VSB_cat(tl->sb, "(That was just a warning)\n");
195	1232	tl->err = 0;
196	1232	}
197
198		/--------------------------------------------------------------------/
199		/* XXX: should take first+last token */
200
201		void
202	1016	vcc_ErrWhere2(struct vcc tl, const struct token t, const struct token *t2)
203		{
204		const char l1, l2, *l3;
205
206	1016	if (t == NULL) {
207	8	vcc_ErrWhere(tl, t2);
208	8	return;
209		}
210	1008	vcc_iline(t, &l1, 0);
211	1008	t2 = VTAILQ_PREV(t2, tokenhead, list);
212	1008	vcc_iline(t2, &l2, 1);
213
214
215	1008	if (l1 == l2) {
216	1000	vcc_icoord(tl->sb, t, 0);
217	1000	VSB_cat(tl->sb, " -- ");
218	1000	vcc_icoord(tl->sb, t2, 2);
219	1000	VSB_putc(tl->sb, '\n');
220		/* Two tokens on same line */
221	1000	vcc_quoteline(tl, l1, t->src->e);
222	1000	vcc_markline(tl, l1, t->src->e, t->b, t2->e);
223	1000	} else {
224		/* Two tokens different lines */
225	8	l3 = strchr(l1, '\n');
226	8	AN(l3);
227		/* XXX: t had better be before t2 */
228	8	vcc_icoord(tl->sb, t, 0);
229	8	if (l3 + 1 == l2) {
230	0	VSB_cat(tl->sb, " -- ");
231	0	vcc_icoord(tl->sb, t2, 1);
232	0	}
233	8	VSB_putc(tl->sb, '\n');
234	8	vcc_quoteline(tl, l1, t->src->e);
235	8	vcc_markline(tl, l1, t->src->e, t->b, t2->e);
236	8	if (l3 + 1 != l2) {
237	8	VSB_cat(tl->sb, "[...]\n");
238	8	vcc_icoord(tl->sb, t2, 1);
239	8	VSB_putc(tl->sb, '\n');
240	8	}
241	8	vcc_quoteline(tl, l2, t->src->e);
242	8	vcc_markline(tl, l2, t->src->e, t->b, t2->e);
243		}
244	1008	VSB_putc(tl->sb, '\n');
245	1008	tl->err = 1;
246	1016	}
247
248		void
249	3479	vcc_ErrWhere(struct vcc tl, const struct token t)
250		{
251		const char *l1;
252
253	3479	vcc_iline(t, &l1, 0);
254	3479	vcc_icoord(tl->sb, t, 0);
255	3479	VSB_putc(tl->sb, '\n');
256	3479	vcc_quoteline(tl, l1, t->src->e);
257	3479	vcc_markline(tl, l1, t->src->e, t->b, t->e);
258	3479	VSB_putc(tl->sb, '\n');
259	3479	tl->err = 1;
260	3479	}
261
262		/--------------------------------------------------------------------/
263
264		struct token *
265	31139989	vcc_PeekTokenFrom(const struct vcc tl, const struct token t)
266		{
267		struct token *t2;
268
269	31139989	CHECK_OBJ_NOTNULL(tl, VCC_MAGIC);
270	31139989	AN(t);
271	31139989	assert(t->tok != EOI);
272	31139989	t2 = VTAILQ_NEXT(t, list);
273	31139989	AN(t2);
274	31139989	return (t2);
275		}
276
277		struct token *
278	2214824	vcc_PeekToken(const struct vcc *tl)
279		{
280
281	2214824	CHECK_OBJ_NOTNULL(tl, VCC_MAGIC);
282	2214824	return (vcc_PeekTokenFrom(tl, tl->t));
283		}
284
285		void
286	11884136	vcc_NextToken(struct vcc *tl)
287		{
288
289	11884136	CHECK_OBJ_NOTNULL(tl, VCC_MAGIC);
290	11884136	tl->t = vcc_PeekTokenFrom(tl, tl->t);
291	11884136	}
292
293		void
294	8359033	vcc__Expect(struct vcc *tl, unsigned tok, unsigned line)
295		{
296	8359033	if (tl->t->tok == tok)
297	8358921	return;
298	112	VSB_printf(tl->sb, "Expected %s got ", vcl_tnames[tok]);
299	112	vcc_ErrToken(tl, tl->t);
300	112	VSB_printf(tl->sb, "\n(program line %u), at\n", line);
301	112	vcc_ErrWhere(tl, tl->t);
302	8359033	}
303
304		/*--------------------------------------------------------------------
305		* Compare ID token to string, return true of match
306		*/
307
308		int
309	22465731	vcc_IdIs(const struct token t, const char p)
310		{
311		const char *q;
312
313	22465731	assert(t->tok == ID);
314	29974216	for (q = t->b; q < t->e && *p != '\0'; p++, q++)
315	28247514	if (q != p)
316	20739029	return (0);
317	1726702	if (q != t->e \|\| *p != '\0')
318	1680	return (0);
319	1725022	return (1);
320	22465731	}
321
322		/*--------------------------------------------------------------------
323		* Check that we have a Varnish identifier
324		*/
325
326		void
327	256	vcc_PrintTokens(const struct vcc *tl,
328		const struct token tb, const struct token te)
329		{
330
331	256	CHECK_OBJ_NOTNULL(tl, VCC_MAGIC);
332	256	AN(tb);
333	256	AN(te);
334	864	while (tb != te) {
335	608	VSB_printf(tl->sb, "%.*s", PF(tb));
336	608	tb = vcc_PeekTokenFrom(tl, tb);
337	608	AN(tb);
338		}
339	256	}
340
341		void
342	974389	vcc_ExpectVid(struct vcc tl, const char what)
343		{
344	974389	const char *bad = NULL;
345		struct token *t2;
346
347	974389	ExpectErr(tl, ID);
348	974381	ERRCHK(tl);
349
350	974381	t2 = vcc_PeekToken(tl);
351	974381	AN(t2);
352	974405	while (t2->tok == '.') {
353	24	bad = ".";
354	24	t2 = vcc_PeekTokenFrom(tl, t2);
355	24	AN(t2);
356	24	if (t2->tok != ID)
357	0	break;
358	24	t2 = vcc_PeekTokenFrom(tl, t2);
359	24	AN(t2);
360		}
361	974381	if (bad == NULL)
362	974357	bad = VCT_invalid_name(tl->t->b, tl->t->e);
363	974381	if (bad != NULL) {
364	24	VSB_printf(tl->sb, "Name of %s, '", what);
365	24	vcc_PrintTokens(tl, tl->t, t2);
366	48	VSB_printf(tl->sb,
367	24	"', contains illegal character '%c'\n", *bad);
368	24	vcc_ErrWhere2(tl, tl->t, t2);
369	24	return;
370		}
371	974389	}
372
373		/*--------------------------------------------------------------------
374		* Decode a string
375		*/
376
377		static void
378	1003561	vcc_decstr(struct vcc *tl, unsigned sep)
379		{
380		char *q;
381		unsigned int l;
382
383	1003561	assert(tl->t->tok == CSTR);
384	1003561	l = pdiff(tl->t->b + sep, tl->t->e - sep);
385	1003561	tl->t->dec = TlAlloc(tl, l + 1);
386	1003561	AN(tl->t->dec);
387	1003561	q = tl->t->dec;
388	1003561	memcpy(q, tl->t->b + sep, l);
389	1003561	q[l] = '\0';
390	1003561	}
391
392		/*--------------------------------------------------------------------
393		* Add a token to the token list.
394		*/
395
396		static void
397	22404998	vcc_addtoken(struct vcc *tl, unsigned tok,
398		struct source sp, const char b, const char *e)
399		{
400		struct token *t;
401
402	22404998	t = TlAlloc(tl, sizeof *t);
403	22404998	assert(t != NULL);
404	22404998	t->tok = tok;
405	22404998	t->b = b;
406	22404998	t->e = e;
407	22404998	t->src = sp;
408	22404998	VTAILQ_INSERT_TAIL(&sp->src_tokens, t, src_list);
409	22404998	tl->t = t;
410	22404998	}
411
412		/*--------------------------------------------------------------------
413		* Find a delimited token
414		*/
415
416		static const struct delim_def {
417		const char *name;
418		const char *b;
419		const char *e;
420		unsigned len; /* NB: must be the same for both delimiters */
421		unsigned crlf;
422		unsigned tok;
423		} delim_defs[] = {
424		#define DELIM_DEF(nm, l, r, c, t) \
425		{ nm, l, r, sizeof (l) - 1, c, t }
426		DELIM_DEF("long-string", "\"\"\"", "\"\"\"", 1, CSTR), /* """...""" */
427		DELIM_DEF("long-string", "{\"", "\"}", 1, CSTR), /* {"..."} */
428		DELIM_DEF("string", "\"", "\"", 0, CSTR), /* "..." */
429		DELIM_DEF("inline C source", "C{", "}C", 1, CSRC), /* C{...}C */
430		#undef DELIM_DEF
431		{ NULL }
432		};
433
434		static unsigned
435	22367617	vcc_delim_token(struct vcc tl, struct source sp, const char *p,
436		const char **qp)
437		{
438		const struct delim_def *dd;
439		const char q, r;
440
441	109583479	for (dd = delim_defs; dd->name != NULL; dd++)
442	88219647	if (!strncmp(p, dd->b, dd->len))
443	1003785	break;
444
445	22367617	if (dd->name == NULL)
446	21363832	return (0);
447
448	1003785	q = strstr(p + dd->len, dd->e);
449	1003785	if (q != NULL && !dd->crlf) {
450	756381	r = strpbrk(p + dd->len, "\r\n");
451	756381	if (r != NULL && r < q)
452	0	q = NULL;
453	756381	}
454
455	1003785	if (q == NULL) {
456	32	vcc_addtoken(tl, EOI, sp, p, p + dd->len);
457	32	VSB_printf(tl->sb, "Unterminated %s, starting at\n", dd->name);
458	32	vcc_ErrWhere(tl, tl->t);
459	32	return (0);
460		}
461
462	1003753	assert(q < sp->e);
463	1003753	vcc_addtoken(tl, dd->tok, sp, p, q + dd->len);
464	1003753	if (dd->tok == CSTR)
465	1003561	vcc_decstr(tl, dd->len);
466	1003753	*qp = q + dd->len;
467	1003753	return (1);
468	22367617	}
469
470		/*--------------------------------------------------------------------
471		* Lex a number, either CNUM or FNUM.
472		* We enforce the RFC8941 restrictions on number of digits here.
473		*/
474
475		static int
476	321135	vcc_lex_number_token_valid(struct vcc *tl)
477		{
478	321135	if (tl->t->e == 'e' \|\| tl->t->e == 'E') {
479	16	VSB_printf(tl->sb, "Unexpected character '%c'.\n", *tl->t->e);
480	16	tl->t->e++;
481	16	vcc_ErrWhere(tl, tl->t);
482	16	return (0);
483		}
484	321119	return (1);
485	321135	}
486
487		static const char *
488	321167	vcc_lex_number(struct vcc tl, struct source sp, const char *p)
489		{
490		const char q, r;
491		char *s;
492
493	1098786	for (q = p; q < sp->e; q++)
494	1098786	if (!vct_isdigit(*q))
495	321167	break;
496	321167	if (*q != '.') {
497	282882	vcc_addtoken(tl, CNUM, sp, p, q);
498	282882	if (q - p > 15) {
499	8	VSB_cat(tl->sb, "Too many digits for integer.\n");