More symbol table cleanup.

bin/varnishtest/tests/r01510.vtc

 varnishtest "Duplicate object names"
 
-varnish v1 -errvcl {Object name 'first' already used.} {
+varnish v1 -errvcl {Instance 'first' redefined.} {
 	import debug;
 	sub vcl_init {
 		new first = debug.obj("FOO");
@@ -8,7 +8,7 @@ varnish v1 -errvcl {Object name 'first' already used.} {
 	}
 }
 
-varnish v1 -errvcl {Object name 'first' already used.} {
+varnish v1 -errvcl {Name 'first' already used.} {
 	import debug;
 
 	backend first { .host = "${bad_ip}"; .port = "9080"; }

bin/varnishtest/tests/r01569.vtc

 varnishtest "symbol lookup order issue"
 
-varnish v1 -vcl {
+varnish v1 -errvcl {Name 'debug' already used.} {
 	vcl 4.0;
 	import debug;
 

bin/varnishtest/tests/v00034.vtc

@@ -7,19 +7,19 @@ server s1 {
 
 varnish v1 -vcl+backend { } -start
 
-varnish v1 -errvcl {Function c1 redefined} {
+varnish v1 -errvcl {Function 'c1' redefined} {
 	backend foo { .host = "127.0.0.1"; }
 	sub c1 { }
 	sub c1 { }
 	sub vcl_recv { call c1; }
 }
 
-varnish v1 -errvcl {Backend s1 redefined} {
+varnish v1 -errvcl {Backend 's1' redefined} {
 	backend s1 { .host = "127.0.0.1"; }
 	backend s1 { .host = "127.0.0.1"; }
 }
 
-varnish v1 -errvcl {Probe p1 redefined} {
+varnish v1 -errvcl {Probe 'p1' redefined} {
 	probe p1 { }
 	probe p1 { }
 	backend s1 { .host = "127.0.0.1"; .probe = p1;}

lib/libvcc/vcc_action.c

@@ -158,27 +158,12 @@ parse_new(struct vcc *tl)
 	ExpectErr(tl, ID);
 	vcc_ExpectCid(tl, "VCL object");
 	ERRCHK(tl);
-	sy1 = VCC_SymbolTok(tl, NULL, tl->t, SYM_NONE, 0);
-	if (sy1 != NULL) {
-		VSB_printf(tl->sb, "Object name '%.*s' already used.\n",
-		    PF(tl->t));
-
-		if (sy1->def_b) {
-			VSB_printf(tl->sb, "First usage:\n");
-			AN(sy1->def_b);
-			if (sy1->def_e != NULL)
-				vcc_ErrWhere2(tl, sy1->def_b, sy1->def_e);
-			else
-				vcc_ErrWhere(tl, sy1->def_b);
-			VSB_printf(tl->sb, "Redefinition:\n");
-			vcc_ErrWhere(tl, tl->t);
-		}
-		return;
-	}
+	sy1 = VCC_HandleSymbol(tl, tl->t, INSTANCE, "XXX");
+	ERRCHK(tl);
+
+	/* We allow implicit use of VMOD objects:  Pretend it's ref'ed */
+	sy1->nref++;
 
-	sy1 = VCC_SymbolTok(tl, NULL, tl->t, SYM_INSTANCE, 1);
-	XXXAN(sy1);
-	sy1->def_b = tl->t;
 	vcc_NextToken(tl);
 
 	ExpectErr(tl, '=');

lib/libvcc/vcc_compile.c

@@ -905,11 +905,13 @@ void
 VCP_Stevedore(struct vcp *vcp, const char *stv_name)
 {
 	struct symbol *sym;
+	char stv[1024];
 
 	CHECK_OBJ_NOTNULL(vcp, VCP_MAGIC);
 	ALLOC_OBJ(sym, SYMBOL_MAGIC);
 	AN(sym);
-	REPLACE(sym->name, stv_name);		/* XXX storage.* ? */
+	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);

lib/libvcc/vcc_parse.c

@@ -240,7 +240,7 @@ vcc_ParseFunction(struct vcc *tl)
 		i = vcc_AddDef(tl, tl->t, SYM_SUB);
 		if (i > 1) {
 			VSB_printf(tl->sb,
-			    "Function %.*s redefined\n", PF(tl->t));
+			    "Function '%.*s' redefined\n", PF(tl->t));
 			vcc_ErrWhere(tl, tl->t);
 			return;
 		}

lib/libvcc/vcc_symb.c

@@ -42,11 +42,12 @@ enum symkind
 VCC_HandleKind(enum var_type fmt)
 {
 	switch(fmt) {
-	case ACL:       return(SYM_ACL);
-	case BACKEND:   return(SYM_BACKEND);
-	case PROBE:     return(SYM_PROBE);
-	case STEVEDORE: return(SYM_STEVEDORE);
-	default:        return(SYM_NONE);
+	case ACL:	return(SYM_ACL);
+	case BACKEND:	return(SYM_BACKEND);
+	case PROBE:	return(SYM_PROBE);
+	case STEVEDORE:	return(SYM_STEVEDORE);
+	case INSTANCE:	return(SYM_INSTANCE);
+	default:	return(SYM_NONE);
 	}
 }
 
@@ -223,26 +224,43 @@ VCC_HandleSymbol(struct vcc *tl, const struct token *tk, enum var_type fmt,
 {
 	struct symbol *sym;
 	enum symkind kind;
-	va_list ap;
 	const char *p;
+	va_list ap;
 
 	kind = VCC_HandleKind(fmt);
 	assert(kind != SYM_NONE);
 
-	sym = VCC_SymbolTok(tl, NULL, tk, kind, 1);
-	if (sym->def_b == NULL)
-		sym->def_b = tk;
-	AN(sym);
-	if (sym->ndef > 0) {
+	sym = VCC_SymbolTok(tl, NULL, tk, SYM_NONE, 0);
+	if (sym != NULL && sym->def_b != NULL && kind == sym->kind) {
 		p = VCC_SymKind(tl, sym);
-		VSB_printf(tl->sb, "%c%s %.*s redefined\n",
-		    toupper(*p), p+1, PF(tk));
+		VSB_printf(tl->sb, "%c%s '%.*s' redefined.\n",
+		    toupper(*p), p + 1, PF(tk));
+		vcc_ErrWhere(tl, tk);
+		VSB_printf(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 used.\n", PF(tk));
+		vcc_ErrWhere(tl, tk);
+		VSB_printf(tl->sb, "First definition:\n");
+		AN(sym->def_b);
+		vcc_ErrWhere(tl, sym->def_b);
+		return (sym);
+	} else if (sym != NULL) {
+		VSB_printf(tl->sb,
+		    "Name %.*s is a reserved name.\n", PF(tk));
 		vcc_ErrWhere(tl, tk);
 		return (sym);
 	}
+	sym = VCC_SymbolTok(tl, NULL, tk, kind, 1);
+	AN(sym);
+	AZ(sym->ndef);
 	va_start(ap, str);
 	vcc_global(tl, sym, fmt, str, ap);
 	va_end(ap);
 	sym->ndef = 1;
+	if (sym->def_b == NULL)
+		sym->def_b = tk;
 	return (sym);
 }