GCOV - Varnish Cache


/*-
 * Copyright (c) 2010 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.
 */
/*lint -save -esym(759, SYMTAB_NOERR) -esym(765, SYMTAB_NOERR)*/

#include "config.h"

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

#include "vcc_compile.h"

#include "vct.h"

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

#define VCC_KIND(U,l) const struct kind SYM_##U[1] = {{ KIND_MAGIC, #l}};
#include "tbl/symbol_kind.h"

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

struct vcc_namespace {
        unsigned                magic;
#define VCC_NAMESPACE_MAGIC     0x27b842f4
        const char              *name;
        enum vcc_namespace_e    id;
};

#define VCC_NAMESPACE(U, l)                             \
        static const struct vcc_namespace sym_##l = {   \
                VCC_NAMESPACE_MAGIC,                    \
                #l,                                     \
                VCC_NAMESPACE_##U                       \
        };                                              \
        vcc_ns_t SYM_##U = &sym_##l;
#include "vcc_namespace.h"

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

struct symtab {
        unsigned                        magic;
#define SYMTAB_MAGIC                    0x084d9c8a
        unsigned                        nlen;
        const char                      *name;
        const struct symtab             *parent;
        VTAILQ_ENTRY(symtab)            list;
        VTAILQ_HEAD(,symtab)            children;
        VTAILQ_HEAD(,symbol)            symbols;
};

vcc_kind_t
VCC_HandleKind(vcc_type_t fmt)
{
        if (fmt == ACL)         return (SYM_ACL);
        if (fmt == BACKEND)     return (SYM_BACKEND);
        if (fmt == PROBE)       return (SYM_PROBE);
        if (fmt == STEVEDORE)   return (SYM_STEVEDORE);
        if (fmt == SUB)         return (SYM_SUB);
        if (fmt == INSTANCE)    return (SYM_INSTANCE);
        AZ(fmt->global_pfx);
        return (SYM_NONE);
}

void
VCC_PrintCName(struct vsb *vsb, const char *b, const char *e)
{

        AN(vsb);
        AN(b);

        if (e == NULL)
                e = strchr(b, '\0');
        assert(b < e);

        for (; b < e; b++)
                if (vct_isalnum(*b))
                        VSB_putc(vsb, *b);
                else
                        VSB_printf(vsb, "_%02x_", *b);
}

static void
vcc_symtabname(struct vsb *vsb, const struct symtab *st)
{
        if (st->parent != NULL && st->parent->parent != NULL) {
                vcc_symtabname(vsb, st->parent);
                VSB_putc(vsb, '.');
        }
        VSB_cat(vsb, st->name);
}

void
VCC_SymName(struct vsb *vsb, const struct symbol *sym)
{
        AN(vsb);
        CHECK_OBJ_NOTNULL(sym, SYMBOL_MAGIC);
        CHECK_OBJ_NOTNULL(sym->symtab, SYMTAB_MAGIC);
        vcc_symtabname(vsb, sym->symtab);
}

static struct symtab *
vcc_symtab_new(const char *name)
{
        struct symtab *st;

        ALLOC_OBJ(st, SYMTAB_MAGIC);
        AN(st);
        st->name = name;
        st->nlen = vstrlen(st->name);
        VTAILQ_INIT(&st->children);
        VTAILQ_INIT(&st->symbols);
        return (st);
}

static struct symtab *
vcc_symtab_str(struct symtab *st, const char *b, const char *e, unsigned tok)
{
        struct symtab *st2, *st3;
        size_t l;
        int i;
        const char *q;

        assert(tok == ID || tok == CSTR);
        if (e == NULL)
                e = strchr(b, '\0');
        q = e;

        while (b < e) {
                if (tok == ID) {
                        for (q = b; q < e && *q != '.'; q++)
                                continue;
                }
                l = pdiff(b, q);
                VTAILQ_FOREACH(st2, &st->children, list) {
                        i = strncasecmp(st2->name, b, l);
                        if (i < 0)
                                continue;
                        if (i == 0 && l == st2->nlen)
                                break;
                        st3 = vcc_symtab_new(vcc_Dup_be(b, q));
                        st3->parent = st;
                        VTAILQ_INSERT_BEFORE(st2, st3, list);
                        st2 = st3;
                        break;
                }
                if (st2 == NULL) {
                        st2 = vcc_symtab_new(vcc_Dup_be(b, q));
                        st2->parent = st;
                        VTAILQ_INSERT_TAIL(&st->children, st2, list);
                }
                st = st2;
                b = q + 1;
        }
        return (st);
}

static struct symbol *
vcc_new_symbol(struct vcc *tl, struct symtab *st,
    vcc_kind_t kind, int vlo, int vhi)
{
        struct symbol *sym;

        sym = TlAlloc(tl, sizeof *sym);
        INIT_OBJ(sym, SYMBOL_MAGIC);
        AN(sym);
        sym->name = st->name;
        sym->symtab = st;
        sym->kind = kind;
        sym->type = VOID;
        sym->lorev = vlo;
        sym->hirev = vhi;
        VTAILQ_INSERT_TAIL(&st->symbols, sym, list);
        return (sym);
}

static struct symbol *
vcc_sym_in_tab(struct vcc *tl, struct symtab *st,
    vcc_kind_t kind, int vlo, int vhi)
{
        const struct symtab *pst;
        struct symbol *sym, *psym;

        VTAILQ_FOREACH(sym, &st->symbols, list) {
                if (sym->lorev > vhi || sym->hirev < vlo)
                        continue;
                if (kind == SYM_NONE && kind == sym->kind &&
                    sym->wildcard == NULL)
                        continue;
                if (tl->syntax < VCL_41 && vstrcmp(sym->name, "default") &&
                     kind != SYM_NONE && kind != sym->kind &&
                     sym->wildcard == NULL)
                        continue;
                return (sym);
        }
        pst = st->parent;
        if (pst == NULL)
                return (sym);
        psym = VTAILQ_FIRST(&pst->symbols);
        if (psym == NULL)
                return (sym);
        if (psym->wildcard == NULL)
                return (sym);

        sym = vcc_new_symbol(tl, st, kind, vlo, vhi);
        psym->wildcard(tl, psym, sym);
        if (tl->err)
                return (NULL);
        return (sym);
}


const struct symxref XREF_NONE[1] = {{"xref_none"}};
const struct symxref XREF_DEF[1] = {{"xref_def"}};
const struct symxref XREF_REF[1] = {{"xref_ref"}};

const struct symmode SYMTAB_NOERR[1] = {{
        .name = "sym_noerror",
        .noerr = 1
}};

const struct symmode SYMTAB_CREATE[1] = {{
        .name = "sym_create"
}};

const struct symmode SYMTAB_EXISTING[1] = {{
        .name = "Symbol not found"
}};

const struct symmode SYMTAB_PARTIAL[1] = {{
        .name = "Symbol not found",
        .partial = 1
}};

const struct symmode SYMTAB_PARTIAL_NOERR[1] = {{
        .name = "Symbol not found",
        .partial = 1,
        .noerr = 1
}};

struct symbol *
VCC_SymbolGet(struct vcc *tl, vcc_ns_t ns, vcc_kind_t kind,
    const struct symmode *e, const struct symxref *x)
{
        struct symtab *st, *st2 = NULL;
        struct symbol *sym = NULL, *sym2 = NULL;
        struct token *t0, *tn, *tn1, *tn2 = NULL;

        AN(tl);
        CHECK_OBJ_NOTNULL(ns, VCC_NAMESPACE_MAGIC);
        AN(ns->name);
        CHECK_OBJ_NOTNULL(kind, KIND_MAGIC);
        AN(e);
        AN(x);
        AN(x->name);
        if (tl->syntax >= VCL_41 && e == SYMTAB_CREATE && kind != SYM_SUB &&
            vcc_Has_vcl_prefix(tl->t->b)) {
                VSB_cat(tl->sb, "Symbols named 'vcl_*' are reserved.\nAt:");
                vcc_ErrWhere(tl, tl->t);
                return (NULL);
        }

        st = tl->syms[ns->id];
        t0 = tl->t;
        tn = tl->t;
        assert(tn->tok == ID);
        while (1) {
                assert(tn->tok == ID || tn->tok == CSTR);
                if (tn->tok == CSTR && tl->syntax < VCL_41) {
                        VSB_cat(tl->sb,
                            "Quoted headers are available for VCL >= 4.1.\n"
                            "At:");
                        vcc_ErrWhere(tl, tn);
                        return (NULL);
                }
                if (tn->tok == CSTR && !vstrcmp(tn->dec, "")) {
                        VSB_cat(tl->sb,
                            "Illegal empty header name.\n"
                            "At: ");
                        vcc_ErrWhere(tl, tn);
                        return (NULL);
                }
                if (tn->tok == ID)
                        st = vcc_symtab_str(st, tn->b, tn->e, tn->tok);
                else
                        st = vcc_symtab_str(st, tn->dec, NULL, tn->tok);
                sym2 = vcc_sym_in_tab(tl, st, kind, tl->syntax, tl->syntax);
                if (sym2 != NULL) {
                        sym = sym2;
                        st2 = st;
                        tn2 = tn;
                }
                tn1 = vcc_PeekTokenFrom(tl, tn);
                if (tn1->tok != '.')
                        break;
                tn1 = vcc_PeekTokenFrom(tl, tn1);
                if (tn1->tok == CSTR && (sym == NULL || sym->wildcard == NULL))
                        break;
                if (tn1->tok != CSTR && tn1->tok != ID)
                        break;
                tn = tn1;
        }
        if (sym != NULL && sym->kind == SYM_ALIAS) {
                assert(ns == SYM_MAIN);
                st = vcc_symtab_str(tl->syms[ns->id], sym->eval_priv, NULL, ID);
                AN(st);
                st2 = st;
                sym = vcc_sym_in_tab(tl, st, SYM_NONE, sym->lorev, sym->hirev);
                AN(sym);
        }
        if (sym != NULL && sym->kind == SYM_VMOD && e->partial)
                e = SYMTAB_EXISTING;
        if (sym != NULL && e->partial) {
                st = st2;
                tn = tn2;
        } else if (st != st2) {
                sym = NULL;
        }
        if (tl->err || (sym == NULL && e->noerr))
                return (sym);
        AN(st);
        AN(tn);
        if (sym == NULL && e == SYMTAB_CREATE)
                sym = vcc_new_symbol(tl, st, kind, tl->syntax, tl->syntax);
        tl->t = vcc_PeekTokenFrom(tl, tn);
        if (tl->err)
                return (NULL);
        if (sym == NULL) {
                VSB_printf(tl->sb, "%s: '", e->name);
                vcc_PrintTokens(tl, t0, tl->t);
                VSB_cat(tl->sb, "'");
                sym = vcc_sym_in_tab(tl, st, kind, VCL_LOW, VCL_HIGH);
                if (sym != NULL && sym->kind != SYM_OBJECT &&
                    sym->kind != SYM_INSTANCE) { /* XXX: too specific */
                        VSB_cat(tl->sb, " (Only available when");
                        if (sym->lorev >= VCL_LOW)
                                VSB_printf(tl->sb, " %.1f <=", .1 * sym->lorev);
                        VSB_cat(tl->sb, " VCL syntax");
                        if (sym->hirev <= VCL_HIGH)
                                VSB_printf(tl->sb, " <= %.1f", .1 * sym->hirev);
                        VSB_cat(tl->sb, ")");
                }
                VSB_cat(tl->sb, "\nAt: ");
                vcc_ErrWhere2(tl, t0, tl->t);
                return (NULL);
        }
        if (kind != SYM_NONE && kind != sym->kind && sym->type != DEFAULT) {
                VSB_cat(tl->sb, "Symbol '");
                vcc_PrintTokens(tl, t0, tl->t);
                VSB_printf(tl->sb, "' has wrong type (%s), expected %s:",
                    sym->kind->name, kind->name);
                VSB_cat(tl->sb, "\nAt: ");
                vcc_ErrWhere2(tl, t0, tl->t);
                if (sym->def_b != NULL) {
                        VSB_cat(tl->sb, "Symbol was defined here: ");
                        vcc_ErrWhere(tl, sym->def_b);
                } else if (sym->ref_b != NULL) {
                        VSB_cat(tl->sb, "Symbol was declared here: ");
                        vcc_ErrWhere(tl, sym->ref_b);
                } else {
                        VSB_cat(tl->sb, "Symbol was builtin\n");
                }
                return (NULL);
        }
        if (x == XREF_DEF) {
                if (sym->def_b == NULL)
                        sym->def_b = t0;
                sym->ndef++;
        } else if (x == XREF_REF) {
                if (sym->ref_b == NULL)
                        sym->ref_b = t0;
                sym->nref++;
        } else {
                assert (x == XREF_NONE);
        }
        return (sym);
}

static struct symbol *
vcc_TypeSymbol(struct vcc *tl, vcc_ns_t ns, vcc_kind_t kind, vcc_type_t type)
{
        struct token t[1], *t0;
        struct symbol *sym;
        struct vsb *buf;

        buf = VSB_new_auto();
        AN(buf);
        VSB_printf(buf, "%s.%.*s", type->name, PF(tl->t));
        AZ(VSB_finish(buf));

        /* NB: we create a fake token but errors are handled by the caller. */
        vmemcpy(t, tl->t, sizeof *t);
        t->b = VSB_data(buf);
        t->e = t->b + VSB_len(buf);

        t0 = tl->t;
        tl->t = t;
        sym = VCC_SymbolGet(tl, ns, kind, SYMTAB_NOERR, XREF_NONE);
        tl->t = t0;
        VSB_destroy(&buf);

        return (sym);
}

struct symbol *
VCC_TypeSymbol(struct vcc *tl, vcc_kind_t kind, vcc_type_t type)
{

        if (strchr(type->name, '.') == NULL)
                return (vcc_TypeSymbol(tl, SYM_TYPE, kind, type));

        /* NB: type imported from a VMOD */
        return (vcc_TypeSymbol(tl, SYM_MAIN, kind, type));
}

struct symbol *
VCC_MkSym(struct vcc *tl, const char *b, vcc_ns_t ns, vcc_kind_t kind,
    int vlo, int vhi)
{
        struct symtab *st;
        struct symbol *sym;
        const struct symbol *parent;

        AN(tl);
        AN(b);
        CHECK_OBJ_NOTNULL(ns, VCC_NAMESPACE_MAGIC);
        CHECK_OBJ_NOTNULL(kind, KIND_MAGIC);
        assert(vlo <= vhi);

        if (tl->syms[ns->id] == NULL)
                tl->syms[ns->id] = vcc_symtab_new("");
        st = vcc_symtab_str(tl->syms[ns->id], b, NULL, ID);
        AN(st);
        sym = vcc_sym_in_tab(tl, st, kind, vlo, vhi);
        if (sym != NULL) {
                assert(sym->kind == SYM_VAR);
                parent = sym->eval_priv;
                AN(parent);
                AN(parent->wildcard);
                assert(sym->type == parent->type);
                return (sym);
        }
        AZ(sym);
        sym = vcc_new_symbol(tl, st, kind, vlo, vhi);
        AN(sym);
        sym->noref = 1;
        return (sym);
}

struct symbol *
VCC_MkSymAlias(struct vcc *tl, const char *alias, const char *name)
{
        struct symbol *sym_alias, *sym;
        struct symtab *st;

        AN(tl);
        AN(alias);
        AN(name);

        st = vcc_symtab_str(tl->syms[SYM_MAIN->id], name, NULL, ID);
        AN(st);
        sym = vcc_sym_in_tab(tl, st, SYM_NONE, VCL_LOW, VCL_HIGH);
        AN(sym);
        assert(sym->kind != SYM_ALIAS);
        sym_alias = VCC_MkSym(tl, alias, SYM_MAIN, SYM_ALIAS, sym->lorev,
            sym->hirev);
        AN(sym_alias);
        sym_alias->eval_priv = strdup(name);
        AN(sym_alias->eval_priv);
        return (sym);
}

static void
vcc_walksymbols(struct vcc *tl, const struct symtab *root,
    symwalk_f *func, vcc_kind_t kind)
{
        struct symbol *sym;
        struct symtab *st1, *st2 = NULL;

        VTAILQ_FOREACH(sym, &root->symbols, list) {
                if (kind == SYM_NONE || kind == sym->kind)
                        func(tl, sym);
                ERRCHK(tl);
        }
        VTAILQ_FOREACH(st1, &root->children, list) {
                if (st2 != NULL)
                        assert(strcasecmp(st1->name, st2->name) >= 0);
                st2 = st1;
                vcc_walksymbols(tl, st1, func, kind);
                ERRCHK(tl);
        }
}

void
VCC_WalkSymbols(struct vcc *tl, symwalk_f *func, vcc_ns_t ns, vcc_kind_t kind)
{

        CHECK_OBJ_NOTNULL(ns, VCC_NAMESPACE_MAGIC);
        vcc_walksymbols(tl, tl->syms[ns->id], func, kind);
}

void
VCC_GlobalSymbol(struct symbol *sym, vcc_type_t type)
{
        vcc_kind_t kind;
        struct vsb *vsb;

        CHECK_OBJ_NOTNULL(sym, SYMBOL_MAGIC);
        AN(type);
        AN(type->global_pfx);

        kind = VCC_HandleKind(type);

        if (sym->lname != NULL) {
                AN(sym->rname);
                assert(sym->type == type);
                assert(sym->kind == kind);
                return;
        }

        vsb = VSB_new_auto();
        AN(vsb);
        VSB_printf(vsb, "%s_", type->global_pfx);
        VCC_PrintCName(vsb, sym->name, NULL);
        AZ(VSB_finish(vsb));
        sym->lname = strdup(VSB_data(vsb));
        AN(sym->lname);
        if (type == SUB) {
                VSB_clear(vsb);
                VSB_printf(vsb, "sub_%s", sym->lname);
                AZ(VSB_finish(vsb));
        }
        sym->rname = strdup(VSB_data(vsb));
        AN(sym->rname);
        VSB_destroy(&vsb);

        sym->type = type;
        sym->kind = kind;
        if (sym->kind != SYM_NONE) {
                AZ(VCT_invalid_name(sym->rname, NULL));
                if (type == SUB)
                        sym->eval = vcc_Eval_Sub;
                else
                        sym->eval = vcc_Eval_Handle;
        } else {
                WRONG("Wrong kind of global symbol");
        }

#define VCL_MET_MAC(l,u,t,b)   sym->r_methods |= VCL_MET_##u;
#include "tbl/vcl_returns.h"
}

struct symbol *
VCC_HandleSymbol(struct vcc *tl, vcc_type_t fmt)
{
        struct symbol *sym;
        vcc_kind_t kind;
        struct token *t;
        const char *p;

        if (vcc_IdIs(tl->t, "default") && fmt->default_sym != NULL) {
                vcc_NextToken(tl);
                return (fmt->default_sym);
        }

        kind = VCC_HandleKind(fmt);
        assert(kind != SYM_NONE);

        t = tl->t;
        sym = VCC_SymbolGet(tl, SYM_MAIN, SYM_NONE, SYMTAB_NOERR, XREF_NONE);
        if (sym != NULL && sym->def_b != NULL && kind == sym->kind) {
                p = sym->kind->name;
                VSB_printf(tl->sb, "%c%s '%.*s' redefined.\n",
                    toupper(*p), p + 1, PF(t));
                vcc_ErrWhere(tl, t);
                VSB_cat(tl->sb, "First definition:\n");
                AN(sym->def_b);
                vcc_ErrWhere(tl, sym->def_b);
                return (sym);
        } else if (sym != NULL && sym->def_b != NULL) {
                VSB_printf(tl->sb, "Name '%.*s' already defined.\n", PF(t));
                vcc_ErrWhere(tl, t);
                VSB_cat(tl->sb, "First definition:\n");
                AN(sym->def_b);
                vcc_ErrWhere(tl, sym->def_b);
                return (sym);
        } else if (sym != NULL && sym->kind != kind) {
                VSB_printf(tl->sb,
                    "Name %.*s must have type '%s'.\n",
                    PF(t), sym->kind->name);
                vcc_ErrWhere(tl, t);
                return (sym);
        }
        if (sym == NULL)
                sym = VCC_SymbolGet(tl, SYM_MAIN, kind, SYMTAB_CREATE,
                    XREF_NONE);
        if (sym == NULL)
                return (NULL);
        AN(sym);
        AZ(sym->ndef);
        VCC_GlobalSymbol(sym, fmt);
        sym->ndef = 1;
        if (sym->def_b == NULL)
                sym->def_b = t;
        return (sym);
}
/*lint -restore */

		vinyl-cache/lib/libvcc/vcc_symb.c
0		/*-
1		* Copyright (c) 2010 Varnish Software AS
2		* All rights reserved.
3		*
4		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
5		*
6		* SPDX-License-Identifier: BSD-2-Clause
7		*
8		* Redistribution and use in source and binary forms, with or without
9		* modification, are permitted provided that the following conditions
10		* are met:
11		* 1. Redistributions of source code must retain the above copyright
12		* notice, this list of conditions and the following disclaimer.
13		* 2. Redistributions in binary form must reproduce the above copyright
14		* notice, this list of conditions and the following disclaimer in the
15		* documentation and/or other materials provided with the distribution.
16		*
17		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27		* SUCH DAMAGE.
28		*/
29		/lint -save -esym(759, SYMTAB_NOERR) -esym(765, SYMTAB_NOERR)/
30
31		#include "config.h"
32
33		#include <ctype.h>
34		#include <stdlib.h>
35		#include <string.h>
36
37		#include "vcc_compile.h"
38
39		#include "vct.h"
40
41		/--------------------------------------------------------------------/
42
43		#define VCC_KIND(U,l) const struct kind SYM_##U[1] = {{ KIND_MAGIC, #l}};
44		#include "tbl/symbol_kind.h"
45
46		/--------------------------------------------------------------------/
47
48		struct vcc_namespace {
49		unsigned magic;
50		#define VCC_NAMESPACE_MAGIC 0x27b842f4
51		const char *name;
52		enum vcc_namespace_e id;
53		};
54
55		#define VCC_NAMESPACE(U, l) \
56		static const struct vcc_namespace sym_##l = { \
57		VCC_NAMESPACE_MAGIC, \
58		#l, \
59		VCC_NAMESPACE_##U \
60		}; \
61		vcc_ns_t SYM_##U = &sym_##l;
62		#include "vcc_namespace.h"
63
64		/--------------------------------------------------------------------/
65
66		struct symtab {
67		unsigned magic;
68		#define SYMTAB_MAGIC 0x084d9c8a
69		unsigned nlen;
70		const char *name;
71		const struct symtab *parent;
72		VTAILQ_ENTRY(symtab) list;
73		VTAILQ_HEAD(,symtab) children;
74		VTAILQ_HEAD(,symbol) symbols;
75		};
76
77		vcc_kind_t
78	4767099	VCC_HandleKind(vcc_type_t fmt)
79		{
80	4767099	if (fmt == ACL) return (SYM_ACL);
81	4764894	if (fmt == BACKEND) return (SYM_BACKEND);
82	4694840	if (fmt == PROBE) return (SYM_PROBE);
83	4694105	if (fmt == STEVEDORE) return (SYM_STEVEDORE);
84	4694105	if (fmt == SUB) return (SYM_SUB);
85	8610	if (fmt == INSTANCE) return (SYM_INSTANCE);
86	0	AZ(fmt->global_pfx);
87	0	return (SYM_NONE);
88	4767099	}
89
90		void
91	3474136	VCC_PrintCName(struct vsb vsb, const char b, const char *e)
92		{
93
94	3474136	AN(vsb);
95	3474136	AN(b);
96
97	3474136	if (e == NULL)
98	3474136	e = strchr(b, '\0');
99	3474136	assert(b < e);
100
101	55486634	for (; b < e; b++)
102	104024996	if (vct_isalnum(*b))
103	46782832	VSB_putc(vsb, *b);
104		else
105	5229666	VSB_printf(vsb, "_%02x_", *b);
106	3474136	}
107
108		static void
109	14978250	vcc_symtabname(struct vsb vsb, const struct symtab st)
110		{
111	14978250	if (st->parent != NULL && st->parent->parent != NULL) {
112	6680667	vcc_symtabname(vsb, st->parent);
113	6680667	VSB_putc(vsb, '.');
114	6680667	}
115	14978250	VSB_cat(vsb, st->name);
116	14978250	}
117
118		void
119	8297583	VCC_SymName(struct vsb vsb, const struct symbol sym)
120		{
121	8297583	AN(vsb);
122	8297583	CHECK_OBJ_NOTNULL(sym, SYMBOL_MAGIC);
123	8297583	CHECK_OBJ_NOTNULL(sym->symtab, SYMTAB_MAGIC);
124	8297583	vcc_symtabname(vsb, sym->symtab);
125	8297583	}
126
127		static struct symtab *
128	18785876	vcc_symtab_new(const char *name)
129		{
130		struct symtab *st;
131
132	18785876	ALLOC_OBJ(st, SYMTAB_MAGIC);
133	18785876	AN(st);
134	18785876	st->name = name;
135	18785876	st->nlen = vstrlen(st->name);
136	18785876	VTAILQ_INIT(&st->children);
137	18785876	VTAILQ_INIT(&st->symbols);
138	18785876	return (st);
139		}
140
141		static struct symtab *
142	40291415	vcc_symtab_str(struct symtab st, const char b, const char *e, unsigned tok)
143		{
144		struct symtab st2, st3;
145		size_t l;
146		int i;
147		const char *q;
148
149	40291415	assert(tok == ID \|\| tok == CSTR);
150	40291415	if (e == NULL)
151	15196242	e = strchr(b, '\0');
152	40291415	q = e;
153
154	93720654	while (b < e) {
155	53429239	if (tok == ID) {
156	460606155	for (q = b; q < e && *q != '.'; q++)
157	407177546	continue;
158	53428609	}
159	53429239	l = pdiff(b, q);
160	936444312	VTAILQ_FOREACH(st2, &st->children, list) {
161	923807275	i = strncasecmp(st2->name, b, l);
162	923807275	if (i < 0)
163	883015073	continue;
164	40792202	if (i == 0 && l == st2->nlen)
165	34780174	break;
166	6012028	st3 = vcc_symtab_new(vcc_Dup_be(b, q));
167	6012028	st3->parent = st;
168	6012028	VTAILQ_INSERT_BEFORE(st2, st3, list);
169	6012028	st2 = st3;
170	6012028	break;
171		}
172	53429239	if (st2 == NULL) {
173	12637037	st2 = vcc_symtab_new(vcc_Dup_be(b, q));
174	12637037	st2->parent = st;
175	12637037	VTAILQ_INSERT_TAIL(&st->children, st2, list);
176	12637037	}
177	53429239	st = st2;
178	53429239	b = q + 1;
179		}
180	40291415	return (st);
181		}
182
183		static struct symbol *
184	18132374	vcc_new_symbol(struct vcc tl, struct symtab st,
185		vcc_kind_t kind, int vlo, int vhi)
186		{
187		struct symbol *sym;
188
189	18132374	sym = TlAlloc(tl, sizeof *sym);
190	18132374	INIT_OBJ(sym, SYMBOL_MAGIC);
191	18132374	AN(sym);
192	18132374	sym->name = st->name;
193	18132374	sym->symtab = st;
194	18132374	sym->kind = kind;
195	18132374	sym->type = VOID;
196	18132374	sym->lorev = vlo;
197	18132374	sym->hirev = vhi;
198	18132374	VTAILQ_INSERT_TAIL(&st->symbols, sym, list);
199	18132374	return (sym);
200		}
201
202		static struct symbol *
203	40291961	vcc_sym_in_tab(struct vcc tl, struct symtab st,
204		vcc_kind_t kind, int vlo, int vhi)
205		{
206		const struct symtab *pst;
207		struct symbol sym, psym;
208
209	40622241	VTAILQ_FOREACH(sym, &st->symbols, list) {
210	20270686	if (sym->lorev > vhi \|\| sym->hirev < vlo)
211	330112	continue;
212	19940574	if (kind == SYM_NONE && kind == sym->kind &&
213	969744	sym->wildcard == NULL)
214	0	continue;
215	20222722	if (tl->syntax < VCL_41 && vstrcmp(sym->name, "default") &&
216	11381796	kind != SYM_NONE && kind != sym->kind &&
217	282148	sym->wildcard == NULL)
218	168	continue;
219	19940406	return (sym);
220		}
221	20351555	pst = st->parent;
222	20351555	if (pst == NULL)
223	0	return (sym);
224	20351555	psym = VTAILQ_FIRST(&pst->symbols);
225	20351555	if (psym == NULL)
226	11849460	return (sym);
227	8502095	if (psym->wildcard == NULL)
228	6899953	return (sym);
229
230	1602142	sym = vcc_new_symbol(tl, st, kind, vlo, vhi);
231	1602142	psym->wildcard(tl, psym, sym);
232	1602142	if (tl->err)
233	42	return (NULL);
234	1602100	return (sym);
235	40291961	}
236
237
238		const struct symxref XREF_NONE[1] = {{"xref_none"}};
239		const struct symxref XREF_DEF[1] = {{"xref_def"}};
240		const struct symxref XREF_REF[1] = {{"xref_ref"}};
241
242		const struct symmode SYMTAB_NOERR[1] = {{
243		.name = "sym_noerror",
244		.noerr = 1
245		}};
246
247		const struct symmode SYMTAB_CREATE[1] = {{
248		.name = "sym_create"
249		}};
250
251		const struct symmode SYMTAB_EXISTING[1] = {{
252		.name = "Symbol not found"
253		}};
254
255		const struct symmode SYMTAB_PARTIAL[1] = {{
256		.name = "Symbol not found",
257		.partial = 1
258		}};
259
260		const struct symmode SYMTAB_PARTIAL_NOERR[1] = {{
261		.name = "Symbol not found",
262		.partial = 1,
263		.noerr = 1
264		}};
265
266		struct symbol *
267	18981453	VCC_SymbolGet(struct vcc *tl, vcc_ns_t ns, vcc_kind_t kind,
268		const struct symmode e, const struct symxref x)
269		{
270	18981453	struct symtab st, st2 = NULL;
271	18981453	struct symbol sym = NULL, sym2 = NULL;
272	18981453	struct token t0, tn, tn1, tn2 = NULL;
273
274	18981453	AN(tl);
275	18981453	CHECK_OBJ_NOTNULL(ns, VCC_NAMESPACE_MAGIC);
276	18981453	AN(ns->name);
277	18981453	CHECK_OBJ_NOTNULL(kind, KIND_MAGIC);
278	18981453	AN(e);
279	18981453	AN(x);
280	18981453	AN(x->name);
281	18981453	if (tl->syntax >= VCL_41 && e == SYMTAB_CREATE && kind != SYM_SUB &&
282	52877	vcc_Has_vcl_prefix(tl->t->b)) {
283	42	VSB_cat(tl->sb, "Symbols named 'vcl_*' are reserved.\nAt:");
284	42	vcc_ErrWhere(tl, tl->t);
285	42	return (NULL);
286		}
287
288	18981411	st = tl->syms[ns->id];
289	18981411	t0 = tl->t;
290	18981411	tn = tl->t;
291	18981411	assert(tn->tok == ID);
292	25095866	while (1) {
293	25095866	assert(tn->tok == ID \|\| tn->tok == CSTR);
294	25095866	if (tn->tok == CSTR && tl->syntax < VCL_41) {
295	21	VSB_cat(tl->sb,
296		"Quoted headers are available for VCL >= 4.1.\n"
297		"At:");
298	21	vcc_ErrWhere(tl, tn);
299	21	return (NULL);
300		}
301	25095845	if (tn->tok == CSTR && !vstrcmp(tn->dec, "")) {
302	42	VSB_cat(tl->sb,
303		"Illegal empty header name.\n"
304		"At: ");
305	42	vcc_ErrWhere(tl, tn);
306	42	return (NULL);
307		}
308	25095803	if (tn->tok == ID)
309	25095173	st = vcc_symtab_str(st, tn->b, tn->e, tn->tok);
310		else
311	630	st = vcc_symtab_str(st, tn->dec, NULL, tn->tok);
312	25095803	sym2 = vcc_sym_in_tab(tl, st, kind, tl->syntax, tl->syntax);
313	25095803	if (sym2 != NULL) {
314	20992406	sym = sym2;
315	20992406	st2 = st;
316	20992406	tn2 = tn;
317	20992406	}
318	25095803	tn1 = vcc_PeekTokenFrom(tl, tn);
319	25095803	if (tn1->tok != '.')
320	18981306	break;
321	6114497	tn1 = vcc_PeekTokenFrom(tl, tn1);
322	6114497	if (tn1->tok == CSTR && (sym == NULL \|\| sym->wildcard == NULL))
323	21	break;
324	6114476	if (tn1->tok != CSTR && tn1->tok != ID)
325	21	break;
326	6114455	tn = tn1;
327		}
328	18981348	if (sym != NULL && sym->kind == SYM_ALIAS) {
329	21	assert(ns == SYM_MAIN);
330	21	st = vcc_symtab_str(tl->syms[ns->id], sym->eval_priv, NULL, ID);
331	21	AN(st);
332	21	st2 = st;
333	21	sym = vcc_sym_in_tab(tl, st, SYM_NONE, sym->lorev, sym->hirev);
334	21	AN(sym);
335	21	}
336	18981348	if (sym != NULL && sym->kind == SYM_VMOD && e->partial)
337	21	e = SYMTAB_EXISTING;
338	18981348	if (sym != NULL && e->partial) {
339	10136982	st = st2;
340	10136982	tn = tn2;
341	18981348	} else if (st != st2) {
342	3756735	sym = NULL;
343	3756735	}
344	18981348	if (tl->err \|\| (sym == NULL && e->noerr))
345	1871658	return (sym);
346	17109690	AN(st);
347	17109690	AN(tn);
348	17109690	if (sym == NULL && e == SYMTAB_CREATE)
349	1884531	sym = vcc_new_symbol(tl, st, kind, tl->syntax, tl->syntax);
350	17109690	tl->t = vcc_PeekTokenFrom(tl, tn);
351	17109690	if (tl->err)
352	0	return (NULL);
353	17109690	if (sym == NULL) {
354	546	VSB_printf(tl->sb, "%s: '", e->name);
355	546	vcc_PrintTokens(tl, t0, tl->t);
356	546	VSB_cat(tl->sb, "'");
357	546	sym = vcc_sym_in_tab(tl, st, kind, VCL_LOW, VCL_HIGH);
358	546	if (sym != NULL && sym->kind != SYM_OBJECT &&
359	189	sym->kind != SYM_INSTANCE) { /* XXX: too specific */
360	189	VSB_cat(tl->sb, " (Only available when");
361	189	if (sym->lorev >= VCL_LOW)
362	168	VSB_printf(tl->sb, " %.1f <=", .1 * sym->lorev);
363	189	VSB_cat(tl->sb, " VCL syntax");
364	189	if (sym->hirev <= VCL_HIGH)
365	21	VSB_printf(tl->sb, " <= %.1f", .1 * sym->hirev);
366	189	VSB_cat(tl->sb, ")");
367	189	}
368	546	VSB_cat(tl->sb, "\nAt: ");
369	546	vcc_ErrWhere2(tl, t0, tl->t);
370	546	return (NULL);
371		}
372	17109144	if (kind != SYM_NONE && kind != sym->kind && sym->type != DEFAULT) {
373	63	VSB_cat(tl->sb, "Symbol '");
374	63	vcc_PrintTokens(tl, t0, tl->t);
375	126	VSB_printf(tl->sb, "' has wrong type (%s), expected %s:",
376	63	sym->kind->name, kind->name);
377	63	VSB_cat(tl->sb, "\nAt: ");
378	63	vcc_ErrWhere2(tl, t0, tl->t);
379	63	if (sym->def_b != NULL) {
380	42	VSB_cat(tl->sb, "Symbol was defined here: ");
381	42	vcc_ErrWhere(tl, sym->def_b);
382	63	} else if (sym->ref_b != NULL) {
383	21	VSB_cat(tl->sb, "Symbol was declared here: ");
384	21	vcc_ErrWhere(tl, sym->ref_b);
385	21	} else {
386	0	VSB_cat(tl->sb, "Symbol was builtin\n");
387		}
388	63	return (NULL);
389		}
390	17109081	if (x == XREF_DEF) {
391	2813451	if (sym->def_b == NULL)
392	2779053	sym->def_b = t0;
393	2813451	sym->ndef++;
394	17109081	} else if (x == XREF_REF) {
395	5726946	if (sym->ref_b == NULL)
396	3700561	sym->ref_b = t0;
397	5726946	sym->nref++;
398	5726946	} else {
399	8568684	assert (x == XREF_NONE);
400		}
401	17109081	return (sym);
402	18981453	}
403
404		static struct symbol *
405	79778	vcc_TypeSymbol(struct vcc *tl, vcc_ns_t ns, vcc_kind_t kind, vcc_type_t type)
406		{
407		struct token t[1], *t0;
408		struct symbol *sym;
409		struct vsb *buf;
410
411	79778	buf = VSB_new_auto();
412	79778	AN(buf);
413	79778	VSB_printf(buf, "%s.%.*s", type->name, PF(tl->t));
414	79778	AZ(VSB_finish(buf));
415
416		/* NB: we create a fake token but errors are handled by the caller. */
417	79778	vmemcpy(t, tl->t, sizeof *t);
418	79778	t->b = VSB_data(buf);
419	79778	t->e = t->b + VSB_len(buf);
420
421	79778	t0 = tl->t;
422	79778	tl->t = t;
423	79778	sym = VCC_SymbolGet(tl, ns, kind, SYMTAB_NOERR, XREF_NONE);
424	79778	tl->t = t0;
425	79778	VSB_destroy(&buf);
426
427	79778	return (sym);
428		}
429
430		struct symbol *
431	79778	VCC_TypeSymbol(struct vcc *tl, vcc_kind_t kind, vcc_type_t type)
432		{
433
434	79778	if (strchr(type->name, '.') == NULL)
435	63566	return (vcc_TypeSymbol(tl, SYM_TYPE, kind, type));
436
437		/* NB: type imported from a VMOD */
438	16212	return (vcc_TypeSymbol(tl, SYM_MAIN, kind, type));
439	79778	}
440
441		struct symbol *
442	15192861	VCC_MkSym(struct vcc tl, const char b, vcc_ns_t ns, vcc_kind_t kind,
443		int vlo, int vhi)
444		{
445		struct symtab *st;
446		struct symbol *sym;
447		const struct symbol *parent;
448
449	15192861	AN(tl);
450	15192861	AN(b);
451	15192861	CHECK_OBJ_NOTNULL(ns, VCC_NAMESPACE_MAGIC);
452	15192861	CHECK_OBJ_NOTNULL(kind, KIND_MAGIC);
453	15192861	assert(vlo <= vhi);
454
455	15192861	if (tl->syms[ns->id] == NULL)
456	136811	tl->syms[ns->id] = vcc_symtab_new("");
457	15192861	st = vcc_symtab_str(tl->syms[ns->id], b, NULL, ID);
458	15192861	AN(st);
459	15192861	sym = vcc_sym_in_tab(tl, st, kind, vlo, vhi);
460	15192861	if (sym != NULL) {
461	547160	assert(sym->kind == SYM_VAR);
462	547160	parent = sym->eval_priv;
463	547160	AN(parent);
464	547160	AN(parent->wildcard);
465	547160	assert(sym->type == parent->type);
466	547160	return (sym);
467		}
468	14645701	AZ(sym);
469	14645701	sym = vcc_new_symbol(tl, st, kind, vlo, vhi);
470	14645701	AN(sym);
471	14645701	sym->noref = 1;
472	14645701	return (sym);
473	15192861	}
474
475		struct symbol *
476	2730	VCC_MkSymAlias(struct vcc tl, const char alias, const char *name)
477		{
478		struct symbol sym_alias, sym;
479		struct symtab *st;
480
481	2730	AN(tl);
482	2730	AN(alias);
483	2730	AN(name);
484
485	2730	st = vcc_symtab_str(tl->syms[SYM_MAIN->id], name, NULL, ID);
486	2730	AN(st);
487	2730	sym = vcc_sym_in_tab(tl, st, SYM_NONE, VCL_LOW, VCL_HIGH);
488	2730	AN(sym);
489	2730	assert(sym->kind != SYM_ALIAS);
490	5460	sym_alias = VCC_MkSym(tl, alias, SYM_MAIN, SYM_ALIAS, sym->lorev,
491	2730	sym->hirev);
492	2730	AN(sym_alias);
493	2730	sym_alias->eval_priv = strdup(name);
494	2730	AN(sym_alias->eval_priv);
495	2730	return (sym);
496		}
497
498		static void
499	98759347	vcc_walksymbols(struct vcc tl, const struct symtab root,