Advanced
Mailing List Archive

Mailing List Archive

  1. Home >
  2. Varnish>
  3. Commits
[master] 6c5d9ae0b Split the monolithic VCL symbol table
dridi.boukelmoune at gmail
Jul 2, 2020, 5:49 AM
Post #1 of 1 (58 views)
Permalink
commit 6c5d9ae0b4c0ebc2422286af048dd2e10aba1ab4
Author: Dridi Boukelmoune <dridi.boukelmoune@gmail.com>
Date: Fri Jun 5 07:44:19 2020 +0200

Split the monolithic VCL symbol table

This introduces two namespaces MAIN and TYPE to allow top-level symbol
collisions for type methods.

For example, `backend` is a reserved keyword but `backend.resolve` is a
type method. It is impossible to declare such a method symbol because it
would require its parent `backend` symbol to be a type symbol.

There would be a conflict between two `backend` symbols of different
kinds. The same would apply if the BLOB type had methods and vmod_blob
was imported.

At this point only the MAIN namespace is used but the split enables the
symbolization of types and type methods down the line.

diff --git a/lib/libvcc/Makefile.am b/lib/libvcc/Makefile.am
index 628e321e6..bf352e019 100644
--- a/lib/libvcc/Makefile.am
+++ b/lib/libvcc/Makefile.am
@@ -13,6 +13,7 @@ libvcc_a_CFLAGS = \

libvcc_a_SOURCES = \
vcc_compile.h \
+ vcc_namespace.h \
vcc_token_defs.h \
vcc_acl.c \
vcc_action.c \
diff --git a/lib/libvcc/generate.py b/lib/libvcc/generate.py
index 749eebd38..c0f4a4543 100755
--- a/lib/libvcc/generate.py
+++ b/lib/libvcc/generate.py
@@ -184,7 +184,7 @@ class vardef(object):
ctyp = vcltypes[self.typ]

# fo.write("\t{ \"%s\", %s,\n" % (nm, self.typ))
- fo.write("\tsym = VCC_MkSym(tl, \"%s\", " % self.nam)
+ fo.write("\tsym = VCC_MkSym(tl, \"%s\", SYM_MAIN," % self.nam)
if self.typ == "HEADER":
fo.write(" SYM_NONE, %d, %d);\n" % (self.vlo, self.vhi))
fo.write("\tAN(sym);\n")
diff --git a/lib/libvcc/vcc_action.c b/lib/libvcc/vcc_action.c
index 40ad52060..1ed104af5 100644
--- a/lib/libvcc/vcc_action.c
+++ b/lib/libvcc/vcc_action.c
@@ -49,7 +49,7 @@ vcc_act_call(struct vcc *tl, struct token *t, struct symbol *sym)
(void)t;
ExpectErr(tl, ID);
t0 = tl->t;
- sym = VCC_SymbolGet(tl, SYM_SUB, SYMTAB_CREATE, XREF_REF);
+ sym = VCC_SymbolGet(tl, SYM_MAIN, SYM_SUB, SYMTAB_CREATE, XREF_REF);
if (sym != NULL) {
vcc_AddCall(tl, t0, sym);
VCC_GlobalSymbol(sym, SUB, "VGC_function");
@@ -124,7 +124,7 @@ vcc_act_set(struct vcc *tl, struct token *t, struct symbol *sym)
(void)t;
ExpectErr(tl, ID);
t = tl->t;
- sym = VCC_SymbolGet(tl, SYM_VAR, SYMTAB_EXISTING, XREF_NONE);
+ sym = VCC_SymbolGet(tl, SYM_MAIN, SYM_VAR, SYMTAB_EXISTING, XREF_NONE);
ERRCHK(tl);
AN(sym);
vcc_AddUses(tl, t, tl->t, sym, XREF_WRITE);
@@ -162,7 +162,7 @@ vcc_act_unset(struct vcc *tl, struct token *t, struct symbol *sym)
/* XXX: Wrong, should use VCC_Expr(HEADER) */
ExpectErr(tl, ID);
t = tl->t;
- sym = VCC_SymbolGet(tl, SYM_VAR, SYMTAB_EXISTING, XREF_NONE);
+ sym = VCC_SymbolGet(tl, SYM_MAIN, SYM_VAR, SYMTAB_EXISTING, XREF_NONE);
ERRCHK(tl);
AN(sym);
if (sym->u_methods == 0) {
@@ -281,7 +281,7 @@ vcc_act_return_vcl(struct vcc *tl)

SkipToken(tl, '(');
ExpectErr(tl, ID);
- sym = VCC_SymbolGet(tl, SYM_VCL, SYMTAB_EXISTING, XREF_NONE);
+ sym = VCC_SymbolGet(tl, SYM_MAIN, SYM_VCL, SYMTAB_EXISTING, XREF_NONE);
ERRCHK(tl);
AN(sym);
if (sym->eval_priv == NULL) {
@@ -402,7 +402,8 @@ vcc_act_synthetic(struct vcc *tl, struct token *t, struct symbol *sym)
#define ACT(name, func, mask) \
do { \
const char pp[] = #name; \
- sym = VCC_MkSym(tl, pp, SYM_ACTION, VCL_LOW, VCL_HIGH); \
+ sym = VCC_MkSym(tl, pp, SYM_MAIN, SYM_ACTION, VCL_LOW, \
+ VCL_HIGH); \
AN(sym); \
sym->action = func; \
sym->action_mask = (mask); \
diff --git a/lib/libvcc/vcc_backend.c b/lib/libvcc/vcc_backend.c
index 217b2366a..f6a268800 100644
--- a/lib/libvcc/vcc_backend.c
+++ b/lib/libvcc/vcc_backend.c
@@ -444,7 +444,7 @@ vcc_ParseHostDef(struct vcc *tl, const struct token *t_be, const char *vgcname)
vcc_NextToken(tl);
(void)vcc_default_probe(tl);
} else {
- pb = VCC_SymbolGet(tl, SYM_PROBE,
+ pb = VCC_SymbolGet(tl, SYM_MAIN, SYM_PROBE,
SYMTAB_EXISTING, XREF_REF);
ERRCHK(tl);
AN(pb);
diff --git a/lib/libvcc/vcc_compile.c b/lib/libvcc/vcc_compile.c
index 78b08d04d..d726a80eb 100644
--- a/lib/libvcc/vcc_compile.c
+++ b/lib/libvcc/vcc_compile.c
@@ -839,7 +839,7 @@ VCC_New(void)

for (i = 1; i < VCL_MET_MAX; i++) {
sym = VCC_MkSym(tl, method_tab[i].name,
- SYM_SUB, VCL_LOW, VCL_HIGH);
+ SYM_MAIN, SYM_SUB, VCL_LOW, VCL_HIGH);
p = vcc_NewProc(tl, sym);
p->method = &method_tab[i];
VSB_printf(p->cname, "VGC_function_%s", p->method->name);
@@ -906,7 +906,7 @@ vcc_predef_vcl(struct vcc *vcc, const char *name)
{
struct symbol *sym;

- sym = VCC_MkSym(vcc, name, SYM_VCL, VCL_LOW, VCL_HIGH);
+ sym = VCC_MkSym(vcc, name, SYM_MAIN, SYM_VCL, VCL_LOW, VCL_HIGH);
AN(sym);
sym->type = VCL;
sym->r_methods = VCL_MET_RECV;
diff --git a/lib/libvcc/vcc_compile.h b/lib/libvcc/vcc_compile.h
index c63335f2f..d91bd00b4 100644
--- a/lib/libvcc/vcc_compile.h
+++ b/lib/libvcc/vcc_compile.h
@@ -132,6 +132,7 @@ struct type {
#include "tbl/vcc_types.h"

/*---------------------------------------------------------------------*/
+
typedef const struct kind *vcc_kind_t;

struct kind {
@@ -146,6 +147,19 @@ struct kind {

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

+typedef const struct vcc_namespace *const vcc_ns_t;
+
+#define VCC_NAMESPACE(U, l) extern vcc_ns_t SYM_##U;
+#include "vcc_namespace.h"
+
+enum vcc_namespace_e {
+#define VCC_NAMESPACE(U, l) VCC_NAMESPACE_##U,
+#include "vcc_namespace.h"
+ VCC_NAMESPACE__MAX
+};
+
+/*---------------------------------------------------------------------*/
+
typedef void sym_expr_t(struct vcc *tl, struct expr **,
struct token *, struct symbol *sym, vcc_type_t);
typedef void sym_wildcard_t(struct vcc *, struct symbol *, struct symbol *);
@@ -241,7 +255,7 @@ struct vcc {
#define MGT_VCC(t, n, cc) t n;
#include <tbl/mgt_vcc.h>

- struct symtab *syms;
+ struct symtab *syms[VCC_NAMESPACE__MAX];

struct inifinhead inifin;
unsigned ninifin;
@@ -369,7 +383,8 @@ void vcc_stevedore(struct vcc *vcc, const char *stv_name);

/* vcc_symb.c */
void VCC_PrintCName(struct vsb *vsb, const char *b, const char *e);
-struct symbol *VCC_MkSym(struct vcc *tl, const char *b, vcc_kind_t, int, int);
+struct symbol *VCC_MkSym(struct vcc *tl, const char *b, vcc_ns_t, vcc_kind_t,
+ int, int);

struct symxref { const char *name; };
extern const struct symxref XREF_NONE[1];
@@ -382,11 +397,11 @@ extern const struct symmode SYMTAB_CREATE[1];
extern const struct symmode SYMTAB_EXISTING[1];
extern const struct symmode SYMTAB_PARTIAL[1];

-struct symbol *VCC_SymbolGet(struct vcc *, vcc_kind_t,
+struct symbol *VCC_SymbolGet(struct vcc *, vcc_ns_t, vcc_kind_t,
const struct symmode *, const struct symxref *);

typedef void symwalk_f(struct vcc *tl, const struct symbol *s);
-void VCC_WalkSymbols(struct vcc *tl, symwalk_f *func, vcc_kind_t);
+void VCC_WalkSymbols(struct vcc *tl, symwalk_f *func, vcc_ns_t, vcc_kind_t);

/* vcc_token.c */
void vcc_Coord(const struct vcc *tl, struct vsb *vsb,
diff --git a/lib/libvcc/vcc_expr.c b/lib/libvcc/vcc_expr.c
index 91c9917a0..862dd6686 100644
--- a/lib/libvcc/vcc_expr.c
+++ b/lib/libvcc/vcc_expr.c
@@ -697,7 +697,8 @@ vcc_expr5(struct vcc *tl, struct expr **e, vcc_type_t fmt)
switch (tl->t->tok) {
case ID:
t = tl->t;
- sym = VCC_SymbolGet(tl, SYM_NONE, SYMTAB_PARTIAL, XREF_REF);
+ sym = VCC_SymbolGet(tl, SYM_MAIN, SYM_NONE, SYMTAB_PARTIAL,
+ XREF_REF);
ERRCHK(tl);
AN(sym);
if (sym->kind == SYM_FUNC && sym->type == VOID) {
@@ -1070,7 +1071,7 @@ cmp_acl(struct vcc *tl, struct expr **e, const struct cmps *cp)

vcc_NextToken(tl);
vcc_ExpectVid(tl, "ACL");
- sym = VCC_SymbolGet(tl, SYM_ACL, SYMTAB_CREATE, XREF_REF);
+ sym = VCC_SymbolGet(tl, SYM_MAIN, SYM_ACL, SYMTAB_CREATE, XREF_REF);
ERRCHK(tl);
AN(sym);
VCC_GlobalSymbol(sym, ACL, ACL_SYMBOL_PREFIX);
@@ -1483,31 +1484,31 @@ vcc_Expr_Init(struct vcc *tl)
{
struct symbol *sym;

- sym = VCC_MkSym(tl, "regsub", SYM_FUNC, VCL_LOW, VCL_HIGH);
+ sym = VCC_MkSym(tl, "regsub", SYM_MAIN, SYM_FUNC, VCL_LOW, VCL_HIGH);
AN(sym);
sym->type = STRING;
sym->eval = vcc_Eval_Regsub;
sym->eval_priv = NULL;

- sym = VCC_MkSym(tl, "regsuball", SYM_FUNC, VCL_LOW, VCL_HIGH);
+ sym = VCC_MkSym(tl, "regsuball", SYM_MAIN, SYM_FUNC, VCL_LOW, VCL_HIGH);
AN(sym);
sym->type = STRING;
sym->eval = vcc_Eval_Regsub;
sym->eval_priv = sym;

- sym = VCC_MkSym(tl, "true", SYM_FUNC, VCL_LOW, VCL_HIGH);
+ sym = VCC_MkSym(tl, "true", SYM_MAIN, SYM_FUNC, VCL_LOW, VCL_HIGH);
AN(sym);
sym->type = BOOL;
sym->eval = vcc_Eval_BoolConst;
sym->eval_priv = sym;

- sym = VCC_MkSym(tl, "false", SYM_FUNC, VCL_LOW, VCL_HIGH);
+ sym = VCC_MkSym(tl, "false", SYM_MAIN, SYM_FUNC, VCL_LOW, VCL_HIGH);
AN(sym);
sym->type = BOOL;
sym->eval = vcc_Eval_BoolConst;
sym->eval_priv = NULL;

- sym = VCC_MkSym(tl, "default", SYM_FUNC, VCL_LOW, VCL_HIGH);
+ sym = VCC_MkSym(tl, "default", SYM_MAIN, SYM_FUNC, VCL_LOW, VCL_HIGH);
AN(sym);
sym->type = BACKEND; // ... can also (sometimes) deliver PROBE
sym->eval = vcc_Eval_Default;
diff --git a/lib/libvcc/vcc_namespace.h b/lib/libvcc/vcc_namespace.h
new file mode 100644
index 000000000..ee9ba2333
--- /dev/null
+++ b/lib/libvcc/vcc_namespace.h
@@ -0,0 +1,38 @@
+/*-
+ * Copyright (c) 2020 Varnish Software AS
+ * All rights reserved.
+ *
+ * Author: Dridi Boukelmoune <dridi.boukelmoune@gmail.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.
+ *
+ */
+
+/*lint -save -e525 -e539 */
+
+VCC_NAMESPACE(MAIN, main)
+VCC_NAMESPACE(TYPE, type)
+#undef VCC_NAMESPACE
+
+/*lint -restore */
diff --git a/lib/libvcc/vcc_parse.c b/lib/libvcc/vcc_parse.c
index f5dc8c364..ec7b5e614 100644
--- a/lib/libvcc/vcc_parse.c
+++ b/lib/libvcc/vcc_parse.c
@@ -182,8 +182,8 @@ vcc_Compound(struct vcc *tl)
tl->err = 1;
return;
case ID:
- sym = VCC_SymbolGet(tl, SYM_NONE, SYMTAB_NOERR,
- XREF_NONE);
+ sym = VCC_SymbolGet(tl, SYM_MAIN, SYM_NONE,
+ SYMTAB_NOERR, XREF_NONE);
if (sym == NULL) {
VSB_printf(tl->sb, "Symbol not found.\n");
vcc_ErrWhere(tl, tl->t);
@@ -228,7 +228,7 @@ vcc_ParseFunction(struct vcc *tl)
ERRCHK(tl);

t = tl->t;
- sym = VCC_SymbolGet(tl, SYM_SUB, SYMTAB_CREATE, XREF_DEF);
+ sym = VCC_SymbolGet(tl, SYM_MAIN, SYM_SUB, SYMTAB_CREATE, XREF_DEF);
ERRCHK(tl);
AN(sym);
p = sym->proc;
@@ -432,5 +432,6 @@ vcc_Parse_Init(struct vcc *tl)
struct toplev *tp;

for (tp = toplev; tp->name != NULL; tp++)
- AN(VCC_MkSym(tl, tp->name, SYM_RESERVED, tp->vcllo, tp->vclhi));
+ AN(VCC_MkSym(tl, tp->name, SYM_MAIN, SYM_RESERVED,
+ tp->vcllo, tp->vclhi));
}
diff --git a/lib/libvcc/vcc_storage.c b/lib/libvcc/vcc_storage.c
index a0b160f37..bb08bc3d3 100644
--- a/lib/libvcc/vcc_storage.c
+++ b/lib/libvcc/vcc_storage.c
@@ -70,7 +70,7 @@ vcc_stevedore(struct vcc *vcc, const char *stv_name)

CHECK_OBJ_NOTNULL(vcc, VCC_MAGIC);
bprintf(buf, "storage.%s", stv_name);
- sym = VCC_MkSym(vcc, buf, SYM_VAR, VCL_LOW, VCL_41);
+ sym = VCC_MkSym(vcc, buf, SYM_MAIN, SYM_VAR, VCL_LOW, VCL_41);
AN(sym);
sym->type = STEVEDORE;
sym->eval = vcc_Eval_Var;
diff --git a/lib/libvcc/vcc_symb.c b/lib/libvcc/vcc_symb.c
index 6784ef48b..93983c098 100644
--- a/lib/libvcc/vcc_symb.c
+++ b/lib/libvcc/vcc_symb.c
@@ -40,8 +40,28 @@
#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 {
@@ -235,7 +255,7 @@ const struct symmode SYMTAB_EXISTING[1] = {{"Symbol not found"}};
const struct symmode SYMTAB_PARTIAL[1] = {{"Symbol not found"}};

struct symbol *
-VCC_SymbolGet(struct vcc *tl, vcc_kind_t kind,
+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;
@@ -243,6 +263,8 @@ VCC_SymbolGet(struct vcc *tl, vcc_kind_t kind,
struct token *t0, *tn, *tn1, *tn2 = NULL;

AN(tl);
+ CHECK_OBJ_NOTNULL(ns, VCC_NAMESPACE_MAGIC);
+ CHECK_OBJ_NOTNULL(kind, KIND_MAGIC);
AN(e);
AN(x);
AN(x->name);
@@ -256,7 +278,7 @@ VCC_SymbolGet(struct vcc *tl, vcc_kind_t kind,
return (NULL);
}

- st = tl->syms;
+ st = tl->syms[ns->id];
t0 = tl->t;
tn = tl->t;
while (1) {
@@ -343,19 +365,21 @@ VCC_SymbolGet(struct vcc *tl, vcc_kind_t kind,
}

struct symbol *
-VCC_MkSym(struct vcc *tl, const char *b, vcc_kind_t kind, int vlo, int vhi)
+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;

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

- if (tl->syms == NULL)
- tl->syms = vcc_symtab_new("");
- st = vcc_symtab_str(tl->syms, b, NULL);
+ if (tl->syms[ns->id] == NULL)
+ tl->syms[ns->id] = vcc_symtab_new("");
+ st = vcc_symtab_str(tl->syms[ns->id], b, NULL);
AN(st);
sym = vcc_sym_in_tab(tl, st, kind, vlo, vhi);
AZ(sym);
@@ -386,10 +410,11 @@ vcc_walksymbols(struct vcc *tl, const struct symtab *root,
}

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

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

void
@@ -434,7 +459,7 @@ VCC_HandleSymbol(struct vcc *tl, vcc_type_t fmt, const char *pfx)
assert(kind != SYM_NONE);

t = tl->t;
- sym = VCC_SymbolGet(tl, SYM_NONE, SYMTAB_NOERR, XREF_NONE);
+ 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",
@@ -459,7 +484,8 @@ VCC_HandleSymbol(struct vcc *tl, vcc_type_t fmt, const char *pfx)
return (sym);
}
if (sym == NULL)
- sym = VCC_SymbolGet(tl, kind, SYMTAB_CREATE, XREF_NONE);
+ sym = VCC_SymbolGet(tl, SYM_MAIN, kind, SYMTAB_CREATE,
+ XREF_NONE);
if (sym == NULL)
return (NULL);
AN(sym);
diff --git a/lib/libvcc/vcc_vmod.c b/lib/libvcc/vcc_vmod.c
index fb41197a3..fbe422435 100644
--- a/lib/libvcc/vcc_vmod.c
+++ b/lib/libvcc/vcc_vmod.c
@@ -252,7 +252,8 @@ vcc_VmodSymbols(struct vcc *tl, struct symbol *msym)
VSB_clear(buf);
VSB_printf(buf, "%s.%s", msym->name, vv2->value);
AZ(VSB_finish(buf));
- fsym = VCC_MkSym(tl, VSB_data(buf), kind, VCL_LOW, VCL_HIGH);
+ fsym = VCC_MkSym(tl, VSB_data(buf), SYM_MAIN, kind,
+ VCL_LOW, VCL_HIGH);
AN(fsym);

if (kind == SYM_FUNC) {
@@ -296,7 +297,7 @@ vcc_ParseImport(struct vcc *tl)
}
tmod = tl->t;

- msym = VCC_SymbolGet(tl, SYM_VMOD, SYMTAB_CREATE, XREF_NONE);
+ msym = VCC_SymbolGet(tl, SYM_MAIN, SYM_VMOD, SYMTAB_CREATE, XREF_NONE);
ERRCHK(tl);
AN(msym);

@@ -454,7 +455,8 @@ vcc_Act_New(struct vcc *tl, struct token *t, struct symbol *sym)

SkipToken(tl, '=');
ExpectErr(tl, ID);
- osym = VCC_SymbolGet(tl, SYM_OBJECT, SYMTAB_EXISTING, XREF_NONE);
+ osym = VCC_SymbolGet(tl, SYM_MAIN, SYM_OBJECT, SYMTAB_EXISTING,
+ XREF_NONE);
ERRCHK(tl);
AN(osym);
CAST_OBJ_NOTNULL(vv, osym->eval_priv, VJSN_VAL_MAGIC);
diff --git a/lib/libvcc/vcc_xref.c b/lib/libvcc/vcc_xref.c
index 483805f3d..b0228ec26 100644
--- a/lib/libvcc/vcc_xref.c
+++ b/lib/libvcc/vcc_xref.c
@@ -95,7 +95,7 @@ int
vcc_CheckReferences(struct vcc *tl)
{

- VCC_WalkSymbols(tl, vcc_checkref, SYM_NONE);
+ VCC_WalkSymbols(tl, vcc_checkref, SYM_MAIN, SYM_NONE);
return (tl->err);
}

@@ -248,7 +248,7 @@ int
vcc_CheckAction(struct vcc *tl)
{

- VCC_WalkSymbols(tl, vcc_checkaction, SYM_SUB);
+ VCC_WalkSymbols(tl, vcc_checkaction, SYM_MAIN, SYM_SUB);
return (tl->err);
}

@@ -352,7 +352,7 @@ int
vcc_CheckUses(struct vcc *tl)
{

- VCC_WalkSymbols(tl, vcc_checkuses, SYM_SUB);
+ VCC_WalkSymbols(tl, vcc_checkuses, SYM_MAIN, SYM_SUB);
return (tl->err);
}

@@ -388,7 +388,7 @@ void
VCC_InstanceInfo(struct vcc *tl)
{
Fc(tl, 0, "\nconst struct vpi_ii VGC_instance_info[] = {\n");
- VCC_WalkSymbols(tl, vcc_instance_info, SYM_INSTANCE);
+ VCC_WalkSymbols(tl, vcc_instance_info, SYM_MAIN, SYM_INSTANCE);
Fc(tl, 0, "\t{ .p = NULL, .name = \"\" }\n");
Fc(tl, 0, "};\n");
}
@@ -414,8 +414,8 @@ VCC_XrefTable(struct vcc *tl)
{

Fc(tl, 0, "\n/*\n * Symbol Table\n *\n");
- VCC_WalkSymbols(tl, vcc_xreftable_len, SYM_NONE);
- VCC_WalkSymbols(tl, vcc_xreftable, SYM_NONE);
+ VCC_WalkSymbols(tl, vcc_xreftable_len, SYM_MAIN, SYM_NONE);
+ VCC_WalkSymbols(tl, vcc_xreftable, SYM_MAIN, SYM_NONE);
Fc(tl, 0, "*/\n\n");
}

_______________________________________________
varnish-commit mailing list
varnish-commit@varnish-cache.org
https://www.varnish-cache.org/lists/mailman/listinfo/varnish-commit

©2024 GT.net. A Gossamer Threads company.
5th Floor, 455 Granville St., Vancouver, BC V6C 1T1, Canada | Legal