[master] 632d519 VCC have not lived in the MGT process for a long time, GC the OCD-level memory-management stuff, and drop the two-stage setup.

Poul-Henning Kamp phk at FreeBSD.org
Tue Jun 7 10:21:06 CEST 2016


commit 632d519b9fdc268a0323b4a3abb0e93c83d834a5
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Tue Jun 7 08:19:10 2016 +0000

    VCC have not lived in the MGT process for a long time, GC the
    OCD-level memory-management stuff, and drop the two-stage setup.

diff --git a/bin/varnishd/mgt/mgt_vcc.c b/bin/varnishd/mgt/mgt_vcc.c
index 62b12e8..79bb4be 100644
--- a/bin/varnishd/mgt/mgt_vcc.c
+++ b/bin/varnishd/mgt/mgt_vcc.c
@@ -83,10 +83,10 @@ static void __match_proto__(vsub_func_f)
 run_vcc(void *priv)
 {
 	char *csrc;
-	struct vsb *sb;
+	struct vsb *sb = NULL;
 	struct vcc_priv *vp;
 	int fd, i, l;
-	struct vcp *vcp;
+	struct vcc *vcc;
 	struct stevedore *stv;
 
 	VJ_subproc(JAIL_SUBPROC_VCC);
@@ -94,20 +94,18 @@ run_vcc(void *priv)
 
 	AZ(chdir(vp->dir));
 
-	sb = VSB_new_auto();
-	XXXAN(sb);
-	vcp = VCP_New();
-	AN(vcp);
-	VCP_Builtin_VCL(vcp, builtin_vcl);
-	VCP_VCL_path(vcp, mgt_vcl_path);
-	VCP_VMOD_path(vcp, mgt_vmod_path);
-	VCP_Err_Unref(vcp, mgt_vcc_err_unref);
-	VCP_Allow_InlineC(vcp, mgt_vcc_allow_inline_c);
-	VCP_Unsafe_Path(vcp, mgt_vcc_unsafe_path);
+	vcc = VCC_New();
+	AN(vcc);
+	VCC_Builtin_VCL(vcc, builtin_vcl);
+	VCC_VCL_path(vcc, mgt_vcl_path);
+	VCC_VMOD_path(vcc, mgt_vmod_path);
+	VCC_Err_Unref(vcc, mgt_vcc_err_unref);
+	VCC_Allow_InlineC(vcc, mgt_vcc_allow_inline_c);
+	VCC_Unsafe_Path(vcc, mgt_vcc_unsafe_path);
 	VTAILQ_FOREACH(stv, &stv_stevedores, list)
-		VCP_Stevedore(vcp, stv->ident);
-	VCP_Stevedore(vcp, stv_transient->ident);
-	csrc = VCC_Compile(vcp, sb, vp->vclsrc, vp->vclsrcfile);
+		VCC_Stevedore(vcc, stv->ident);
+	VCC_Stevedore(vcc, stv_transient->ident);
+	csrc = VCC_Compile(vcc, &sb, vp->vclsrc, vp->vclsrcfile);
 	AZ(VSB_finish(sb));
 	if (VSB_len(sb))
 		printf("%s", VSB_data(sb));
diff --git a/include/libvcc.h b/include/libvcc.h
index 1ae4b8a..2b69bd8 100644
--- a/include/libvcc.h
+++ b/include/libvcc.h
@@ -28,16 +28,16 @@
  *
  */
 
-struct vcp;
+struct vcc;
 
-struct vcp *VCP_New(void);
-void VCP_Allow_InlineC(struct vcp *, unsigned);
-void VCP_Builtin_VCL(struct vcp *, const char *);
-void VCP_Err_Unref(struct vcp *, unsigned);
-void VCP_Stevedore(struct vcp *, const char *);
-void VCP_Unsafe_Path(struct vcp *, unsigned);
-void VCP_VCL_path(struct vcp *, const char *);
-void VCP_VMOD_path(struct vcp *, const char *);
+struct vcc *VCC_New(void);
+void VCC_Allow_InlineC(struct vcc *, unsigned);
+void VCC_Builtin_VCL(struct vcc *, const char *);
+void VCC_Err_Unref(struct vcc *, unsigned);
+void VCC_Stevedore(struct vcc *, const char *);
+void VCC_Unsafe_Path(struct vcc *, unsigned);
+void VCC_VCL_path(struct vcc *, const char *);
+void VCC_VMOD_path(struct vcc *, const char *);
 
-char *VCC_Compile(const struct vcp *, struct vsb *,
+char *VCC_Compile(struct vcc *, struct vsb **,
     const char *vclsrc, const char *vclsrcfile);
diff --git a/lib/libvcc/vcc_acl.c b/lib/libvcc/vcc_acl.c
index 18d967d..7c7ec97 100644
--- a/lib/libvcc/vcc_acl.c
+++ b/lib/libvcc/vcc_acl.c
@@ -364,7 +364,7 @@ vcc_acl_emit(struct vcc *tl, const char *acln, int anon)
 	Fh(tl, 0, "\t\tVRT_acl_log(ctx, \"NO_FAM %s\");\n", acln);
 	Fh(tl, 0, "\t\treturn(0);\n");
 	Fh(tl, 0, "\t}\n\n");
-	if (!tl->param->err_unref && !anon) {
+	if (!tl->err_unref && !anon) {
 		ifp = New_IniFin(tl);
 		VSB_printf(ifp->ini,
 			"\tif (0) match_acl_named_%s(0, 0);\n", acln);
diff --git a/lib/libvcc/vcc_compile.c b/lib/libvcc/vcc_compile.c
index 8653b30..6254794 100644
--- a/lib/libvcc/vcc_compile.c
+++ b/lib/libvcc/vcc_compile.c
@@ -74,26 +74,14 @@ struct method method_tab[] = {
 
 /*--------------------------------------------------------------------*/
 
-static void
-TlDoFree(struct vcc *tl, void *p)
-{
-	struct membit *mb;
-
-	mb = calloc(sizeof *mb, 1);
-	assert(mb != NULL);
-	mb->ptr = p;
-	VTAILQ_INSERT_TAIL(&tl->membits, mb, list);
-}
-
-
-void *
+void * __match_proto__(TlAlloc)
 TlAlloc(struct vcc *tl, unsigned len)
 {
 	void *p;
 
+	(void)tl;
 	p = calloc(len, 1);
 	assert(p != NULL);
-	TlDoFree(tl, p);
 	return (p);
 }
 
@@ -453,31 +441,21 @@ vcc_new_source(const char *b, const char *e, const char *name)
 	return (sp);
 }
 
-static void
-vcc_destroy_source(struct source *sp)
-{
-
-	if (sp->freeit != NULL)
-		free(sp->freeit);
-	free(sp->name);
-	free(sp);
-}
-
 /*--------------------------------------------------------------------*/
 
 static struct source *
-vcc_file_source(const struct vcp * const vcp, struct vsb *sb, const char *fn)
+vcc_file_source(struct vcc *tl, const char *fn)
 {
 	char *f, *fnp;
 	struct source *sp;
 
-	if (!vcp->unsafe_path && strchr(fn, '/') != NULL) {
-		VSB_printf(sb, "VCL filename '%s' is unsafe.\n", fn);
+	if (!tl->unsafe_path && strchr(fn, '/') != NULL) {
+		VSB_printf(tl->sb, "VCL filename '%s' is unsafe.\n", fn);
 		return (NULL);
 	}
 	f = NULL;
-	if (VFIL_searchpath(vcp->vcl_path, NULL, &f, fn, &fnp) || f == NULL) {
-		VSB_printf(sb, "Cannot read file '%s' (%s)\n",
+	if (VFIL_searchpath(tl->vcl_path, NULL, &f, fn, &fnp) || f == NULL) {
+		VSB_printf(tl->sb, "Cannot read file '%s' (%s)\n",
 		    fnp != NULL ? fnp : fn, strerror(errno));
 		free(fnp);
 		return (NULL);
@@ -540,10 +518,10 @@ vcc_resolve_includes(struct vcc *tl)
 			VSB_bcat(vsb, t1->src->name, p - t1->src->name);
 			VSB_cat(vsb, t1->dec + 1);
 			AZ(VSB_finish(vsb));
-			sp = vcc_file_source(tl->param, tl->sb, VSB_data(vsb));
+			sp = vcc_file_source(tl, VSB_data(vsb));
 			VSB_destroy(&vsb);
 		} else {
-			sp = vcc_file_source(tl->param, tl->sb, t1->dec);
+			sp = vcc_file_source(tl, t1->dec);
 		}
 		if (sp == NULL) {
 			vcc_ErrWhere(tl, t1);
@@ -563,103 +541,22 @@ vcc_resolve_includes(struct vcc *tl)
 	}
 }
 
-/*--------------------------------------------------------------------*/
-
-static struct vcc *
-vcc_NewVcc(const struct vcp *vcp)
-{
-	struct vcc *tl;
-	int i;
-
-	CHECK_OBJ_NOTNULL(vcp, VCP_MAGIC);
-	ALLOC_OBJ(tl, VCC_MAGIC);
-	AN(tl);
-	tl->param = vcp;
-	VTAILQ_INIT(&tl->inifin);
-	VTAILQ_INIT(&tl->membits);
-	VTAILQ_INIT(&tl->tokens);
-	VTAILQ_INIT(&tl->sources);
-
-	tl->nsources = 0;
-
-	/* General C code */
-	tl->fc = VSB_new_auto();
-	assert(tl->fc != NULL);
-
-	/* Forward decls (.h like) */
-	tl->fh = VSB_new_auto();
-	assert(tl->fh != NULL);
-
-	/* body code of methods */
-	for (i = 0; i < VCL_MET_MAX; i++) {
-		tl->fm[i] = VSB_new_auto();
-		assert(tl->fm[i] != NULL);
-	}
-	return (tl);
-}
-
-/*--------------------------------------------------------------------*/
-
-static char *
-vcc_DestroyTokenList(struct vcc *tl, char *ret)
-{
-	struct membit *mb;
-	struct source *sp;
-	int i;
-
-	while (!VTAILQ_EMPTY(&tl->membits)) {
-		mb = VTAILQ_FIRST(&tl->membits);
-		VTAILQ_REMOVE(&tl->membits, mb, list);
-		free(mb->ptr);
-		free(mb);
-	}
-	while (!VTAILQ_EMPTY(&tl->sources)) {
-		sp = VTAILQ_FIRST(&tl->sources);
-		VTAILQ_REMOVE(&tl->sources, sp, list);
-		vcc_destroy_source(sp);
-	}
-
-	VSB_destroy(&tl->fh);
-	VSB_destroy(&tl->fc);
-	for (i = 0; i < VCL_MET_MAX; i++)
-		VSB_destroy(&tl->fm[i]);
-
-	free(tl);
-	return (ret);
-}
-
 /*--------------------------------------------------------------------
  * Compile the VCL code from the given source and return the C-source
  */
 
 static char *
-vcc_CompileSource(const struct vcp * const vcp, struct vsb *sb,
-    struct source *sp)
+vcc_CompileSource(struct vcc *tl, struct source *sp)
 {
-	struct vcc *tl;
-	struct symbol *sym, *sym2;
+	struct symbol *sym;
 	const struct var *v;
 	struct vsb *vsb;
 
 	char *of;
 	int i;
 
-	tl = vcc_NewVcc(vcp);
-	tl->sb = sb;
-
 	vcc_Expr_Init(tl);
 
-	VTAILQ_FOREACH(sym, &vcp->symbols, list) {
-		sym2 = VCC_Symbol(tl, NULL, sym->name, NULL, sym->kind, 1);
-		sym2->fmt = sym->fmt;
-		sym2->eval = sym->eval;
-		sym2->eval_priv = sym->eval_priv;
-		sym2->rname = sym->rname;
-		sym2->r_methods = sym->r_methods;
-		sym2->ndef = 1;
-		sym2->nref = 1;
-	}
-
 	for (v = vcc_vars; v->name != NULL; v++) {
 		if (v->fmt == HEADER) {
 			sym = VCC_Symbol(tl, NULL, v->name, NULL,
@@ -689,32 +586,32 @@ vcc_CompileSource(const struct vcp * const vcp, struct vsb *sb,
 	sp->idx = tl->nsources++;
 	vcc_Lexer(tl, sp);
 	if (tl->err)
-		return (vcc_DestroyTokenList(tl, NULL));
+		return (NULL);
 
 	/* Register and lex the builtin VCL */
-	sp = vcc_new_source(tl->param->builtin_vcl, NULL, "Builtin");
+	sp = vcc_new_source(tl->builtin_vcl, NULL, "Builtin");
 	assert(sp != NULL);
 	VTAILQ_INSERT_TAIL(&tl->sources, sp, list);
 	sp->idx = tl->nsources++;
 	vcc_Lexer(tl, sp);
 	if (tl->err)
-		return (vcc_DestroyTokenList(tl, NULL));
+		return (NULL);
 
 	/* Add "END OF INPUT" token */
 	vcc_AddToken(tl, EOI, sp->e, sp->e);
 	if (tl->err)
-		return (vcc_DestroyTokenList(tl, NULL));
+		return (NULL);
 
 	/* Expand and lex any includes in the token string */
 	vcc_resolve_includes(tl);
 	if (tl->err)
-		return (vcc_DestroyTokenList(tl, NULL));
+		return (NULL);
 
 	/* Parse the token string */
 	tl->t = VTAILQ_FIRST(&tl->tokens);
 	vcc_Parse(tl);
 	if (tl->err)
-		return (vcc_DestroyTokenList(tl, NULL));
+		return (NULL);
 
 	/* Check if we have any backends at all */
 	if (tl->default_director == NULL) {
@@ -722,7 +619,7 @@ vcc_CompileSource(const struct vcp * const vcp, struct vsb *sb,
 		    "No backends or directors found in VCL program, "
 		    "at least one is necessary.\n");
 		tl->err = 1;
-		return (vcc_DestroyTokenList(tl, NULL));
+		return (NULL);
 	}
 
 	/* Configure the default director */
@@ -730,15 +627,15 @@ vcc_CompileSource(const struct vcp * const vcp, struct vsb *sb,
 
 	/* Check for orphans */
 	if (vcc_CheckReferences(tl))
-		return (vcc_DestroyTokenList(tl, NULL));
+		return (NULL);
 
 	/* Check that all action returns are legal */
 	if (vcc_CheckAction(tl) || tl->err)
-		return (vcc_DestroyTokenList(tl, NULL));
+		return (NULL);
 
 	/* Check that all variable uses are legal */
 	if (vcc_CheckUses(tl) || tl->err)
-		return (vcc_DestroyTokenList(tl, NULL));
+		return (NULL);
 
 	/* Emit method functions */
 	Fh(tl, 1, "\n");
@@ -793,7 +690,7 @@ vcc_CompileSource(const struct vcp * const vcp, struct vsb *sb,
 	VSB_destroy(&vsb);
 
 	/* done */
-	return (vcc_DestroyTokenList(tl, of));
+	return (of);
 }
 
 /*--------------------------------------------------------------------
@@ -802,22 +699,23 @@ vcc_CompileSource(const struct vcp * const vcp, struct vsb *sb,
  */
 
 char *
-VCC_Compile(const struct vcp *vcp, struct vsb *sb,
+VCC_Compile(struct vcc *tl, struct vsb **sb,
     const char *vclsrc, const char *vclsrcfile)
 {
 	struct source *sp;
-	char *r;
-	CHECK_OBJ_NOTNULL(vcp, VCP_MAGIC);
+	char *r = NULL;
+
+	CHECK_OBJ_NOTNULL(tl, VCC_MAGIC);
 	AN(sb);
 	AN(vclsrcfile);
 
 	if (vclsrc != NULL)
 		sp = vcc_new_source(vclsrc, NULL, vclsrcfile);
 	else
-		sp = vcc_file_source(vcp, sb, vclsrcfile);
-	if (sp == NULL)
-		return (NULL);
-	r = vcc_CompileSource(vcp, sb, sp);
+		sp = vcc_file_source(tl, vclsrcfile);
+	if (sp != NULL)
+		r = vcc_CompileSource(tl, sp);
+	*sb = tl->sb;
 	return (r);
 }
 
@@ -825,16 +723,36 @@ VCC_Compile(const struct vcp *vcp, struct vsb *sb,
  * Allocate a compiler instance
  */
 
-struct vcp *
-VCP_New(void)
+struct vcc *
+VCC_New(void)
 {
-	struct vcp *vcp;
+	struct vcc *tl;
+	int i;
+
+	ALLOC_OBJ(tl, VCC_MAGIC);
+	AN(tl);
+	VTAILQ_INIT(&tl->inifin);
+	VTAILQ_INIT(&tl->tokens);
+	VTAILQ_INIT(&tl->sources);
 
-	ALLOC_OBJ(vcp, VCP_MAGIC);
-	AN(vcp);
-	VTAILQ_INIT(&vcp->symbols);
+	tl->nsources = 0;
 
-	return (vcp);
+	/* General C code */
+	tl->fc = VSB_new_auto();
+	assert(tl->fc != NULL);
+
+	/* Forward decls (.h like) */
+	tl->fh = VSB_new_auto();
+	assert(tl->fh != NULL);
+
+	/* body code of methods */
+	for (i = 0; i < VCL_MET_MAX; i++) {
+		tl->fm[i] = VSB_new_auto();
+		assert(tl->fm[i] != NULL);
+	}
+	tl->sb = VSB_new_auto();
+	AN(tl->sb);
+	return (tl);
 }
 
 /*--------------------------------------------------------------------
@@ -842,11 +760,11 @@ VCP_New(void)
  */
 
 void
-VCP_Builtin_VCL(struct vcp *vcp, const char *str)
+VCC_Builtin_VCL(struct vcc *vcc, const char *str)
 {
 
-	CHECK_OBJ_NOTNULL(vcp, VCP_MAGIC);
-	REPLACE(vcp->builtin_vcl, str);
+	CHECK_OBJ_NOTNULL(vcc, VCC_MAGIC);
+	REPLACE(vcc->builtin_vcl, str);
 }
 
 /*--------------------------------------------------------------------
@@ -854,11 +772,11 @@ VCP_Builtin_VCL(struct vcp *vcp, const char *str)
  */
 
 void
-VCP_VCL_path(struct vcp *vcp, const char *str)
+VCC_VCL_path(struct vcc *vcc, const char *str)
 {
 
-	CHECK_OBJ_NOTNULL(vcp, VCP_MAGIC);
-	VFIL_setpath(&vcp->vcl_path, str);
+	CHECK_OBJ_NOTNULL(vcc, VCC_MAGIC);
+	VFIL_setpath(&vcc->vcl_path, str);
 }
 
 /*--------------------------------------------------------------------
@@ -866,11 +784,11 @@ VCP_VCL_path(struct vcp *vcp, const char *str)
  */
 
 void
-VCP_VMOD_path(struct vcp *vcp, const char *str)
+VCC_VMOD_path(struct vcc *vcc, const char *str)
 {
 
-	CHECK_OBJ_NOTNULL(vcp, VCP_MAGIC);
-	VFIL_setpath(&vcp->vmod_path, str);
+	CHECK_OBJ_NOTNULL(vcc, VCC_MAGIC);
+	VFIL_setpath(&vcc->vmod_path, str);
 }
 
 /*--------------------------------------------------------------------
@@ -878,42 +796,47 @@ VCP_VMOD_path(struct vcp *vcp, const char *str)
  */
 
 void
-VCP_Err_Unref(struct vcp *vcp, unsigned u)
+VCC_Err_Unref(struct vcc *vcc, unsigned u)
 {
 
-	CHECK_OBJ_NOTNULL(vcp, VCP_MAGIC);
-	vcp->err_unref = u;
+	CHECK_OBJ_NOTNULL(vcc, VCC_MAGIC);
+	vcc->err_unref = u;
 }
 
 void
-VCP_Allow_InlineC(struct vcp *vcp, unsigned u)
+VCC_Allow_InlineC(struct vcc *vcc, unsigned u)
 {
 
-	CHECK_OBJ_NOTNULL(vcp, VCP_MAGIC);
-	vcp->allow_inline_c = u;
+	CHECK_OBJ_NOTNULL(vcc, VCC_MAGIC);
+	vcc->allow_inline_c = u;
 }
 
 void
-VCP_Unsafe_Path(struct vcp *vcp, unsigned u)
+VCC_Unsafe_Path(struct vcc *vcc, unsigned u)
 {
 
-	CHECK_OBJ_NOTNULL(vcp, VCP_MAGIC);
-	vcp->unsafe_path = u;
+	CHECK_OBJ_NOTNULL(vcc, VCC_MAGIC);
+	vcc->unsafe_path = u;
 }
 
 void
-VCP_Stevedore(struct vcp *vcp, const char *stv_name)
+VCC_Stevedore(struct vcc *vcc, const char *stv_name)
 {
+#if 0
 	struct symbol *sym;
 	char stv[1024];
 
-	CHECK_OBJ_NOTNULL(vcp, VCP_MAGIC);
+	CHECK_OBJ_NOTNULL(vcc, VCC_MAGIC);
 	ALLOC_OBJ(sym, SYMBOL_MAGIC);
 	AN(sym);
 	bprintf(stv, "stv.%s", stv_name);
 	REPLACE(sym->name, stv);		/* XXX storage.* ? */
 	sym->kind = SYM_STEVEDORE;
 	VCC_GlobalSymbol(sym, STEVEDORE, "VRT_stevedore(\"%s\")", stv_name);
-	VTAILQ_INSERT_TAIL(&vcp->symbols, sym, list);
+	VTAILQ_INSERT_TAIL(&vcc->symbols, sym, list);
+#else
+	(void)vcc;
+	(void)stv_name;
+#endif
 }
 
diff --git a/lib/libvcc/vcc_compile.h b/lib/libvcc/vcc_compile.h
index 556eacf..9999230 100644
--- a/lib/libvcc/vcc_compile.h
+++ b/lib/libvcc/vcc_compile.h
@@ -74,11 +74,6 @@ enum var_type {
 #undef VCC_TYPE
 };
 
-struct membit {
-	VTAILQ_ENTRY(membit)	list;
-	void			*ptr;
-};
-
 struct source {
 	VTAILQ_ENTRY(source)	list;
 	char			*name;
@@ -160,9 +155,10 @@ struct inifin {
 
 VTAILQ_HEAD(inifinhead, inifin);
 
-struct vcp {
+struct vcc {
 	unsigned		magic;
-#define VCP_MAGIC		0xd90acfbc
+#define VCC_MAGIC		0x24ad719d
+	float			syntax;
 
 	char			*builtin_vcl;
 	struct vfil_path	*vcl_path;
@@ -171,17 +167,6 @@ struct vcp {
 	unsigned		allow_inline_c;
 	unsigned		unsafe_path;
 
-	VTAILQ_HEAD(,symbol)	symbols;
-};
-
-struct vcc {
-	unsigned		magic;
-#define VCC_MAGIC		0x24ad719d
-	float			syntax;
-
-	/* Parameter/Template section */
-	const struct vcp	*param;
-
 	struct symbol		*symbols;
 
 	struct inifinhead	inifin;
@@ -190,7 +175,6 @@ struct vcc {
 	/* Instance section */
 	struct tokenhead	tokens;
 	VTAILQ_HEAD(, source)	sources;
-	VTAILQ_HEAD(, membit)	membits;
 	unsigned		nsources;
 	struct source		*src;
 	struct token		*t;
diff --git a/lib/libvcc/vcc_parse.c b/lib/libvcc/vcc_parse.c
index bcb9586..aa242f8 100644
--- a/lib/libvcc/vcc_parse.c
+++ b/lib/libvcc/vcc_parse.c
@@ -160,7 +160,7 @@ vcc_Compound(struct vcc *tl)
 			Fb(tl, 1, "}\n");
 			return;
 		case CSRC:
-			if (tl->param->allow_inline_c) {
+			if (tl->allow_inline_c) {
 				Fb(tl, 1, "%.*s\n",
 				    (int) (tl->t->e - (tl->t->b + 2)),
 				    tl->t->b + 1);
@@ -352,7 +352,7 @@ vcc_Parse(struct vcc *tl)
 		ERRCHK(tl);
 		switch (tl->t->tok) {
 		case CSRC:
-			if (tl->param->allow_inline_c) {
+			if (tl->allow_inline_c) {
 				Fc(tl, 0, "%.*s\n",
 				    (int) (tl->t->e - (tl->t->b + 4)),
 				    tl->t->b + 2);
diff --git a/lib/libvcc/vcc_vmod.c b/lib/libvcc/vcc_vmod.c
index 77eefee..9f6f59e 100644
--- a/lib/libvcc/vcc_vmod.c
+++ b/lib/libvcc/vcc_vmod.c
@@ -110,7 +110,7 @@ vcc_ParseImport(struct vcc *tl)
 			return;
 		}
 		vcc_NextToken(tl);
-		if (!tl->param->unsafe_path && strchr(tl->t->dec, '/')) {
+		if (!tl->unsafe_path && strchr(tl->t->dec, '/')) {
 			VSB_printf(tl->sb,
 			    "'import ... from path ...' is unsafe.\nAt:");
 			vcc_ErrToken(tl, tl->t);
@@ -130,7 +130,7 @@ vcc_ParseImport(struct vcc *tl)
 
 	SkipToken(tl, ';');
 
-	if (VFIL_searchpath(tl->param->vmod_path,
+	if (VFIL_searchpath(tl->vmod_path,
 	    vcc_path_dlopen, &hdl, fn, &fnpx)) {
 		VSB_printf(tl->sb, "Could not load VMOD %.*s\n", PF(mod));
 		VSB_printf(tl->sb, "\tFile name: %s\n",
diff --git a/lib/libvcc/vcc_xref.c b/lib/libvcc/vcc_xref.c
index 989a87d..e8feac2 100644
--- a/lib/libvcc/vcc_xref.c
+++ b/lib/libvcc/vcc_xref.c
@@ -110,7 +110,7 @@ vcc_checkref(struct vcc *tl, const struct symbol *sym)
 		VSB_printf(tl->sb, "Unused %s %.*s, defined:\n",
 		    VCC_SymKind(tl, sym), PF(sym->def_b));
 		vcc_ErrWhere(tl, sym->def_b);
-		if (!tl->param->err_unref) {
+		if (!tl->err_unref) {
 			VSB_printf(tl->sb, "(That was just a warning)\n");
 			tl->err = 0;
 		}
@@ -291,7 +291,7 @@ vcc_checkaction2(struct vcc *tl, const struct symbol *sym)
 		return;
 	VSB_printf(tl->sb, "Function unused\n");
 	vcc_ErrWhere(tl, p->name);
-	if (!tl->param->err_unref) {
+	if (!tl->err_unref) {
 		VSB_printf(tl->sb, "(That was just a warning)\n");
 		tl->err = 0;
 	}



More information about the varnish-commit mailing list