Refactor a VCC error message

bin/varnishtest/tests/a00000.vtc

 # the first token in a varnishtest file must be "varnishtest",
- 	# but whitespace and comments are fine
+    # but whitespace (SP)
+	# and (TAB) and comments are fine
 
 varnishtest "basic default HTTP transactions"
 

bin/varnishtest/tests/d00006.vtc

@@ -22,7 +22,7 @@ server s4 {
 	txresp -body "4444"
 } -start
 
-varnish v1 -errvcl {Names of VCL objects cannot contain '-'} {
+varnish v1 -errvcl {Name of VCL object, 'rr1-xx', contains illegal character '-'} {
 	import directors;
 	backend b1 { .host = "127.0.0.1"; .port = "8080";}
 	sub vcl_init {

bin/varnishtest/tests/v00020.vtc

@@ -257,7 +257,7 @@ varnish v1 -vcl {
 	}
 }
 
-varnish v1 -errvcl {Names of VCL sub's cannot contain '-'} {
+varnish v1 -errvcl {Name of function, 'foo-bar', contains illegal character '-'} {
 	backend b { .host = "127.0.0.1"; }
 	sub foo-bar {
 	}
@@ -291,7 +291,7 @@ varnish v1 -errvcl {'beresp.status': Not available in method 'vcl_recv'.} {
 	}
 }
 
-varnish v1 -errvcl {Names of VCL acl's cannot contain '-'} {
+varnish v1 -errvcl {Name of ACL, 'foo-bar', contains illegal character '-'} {
 	backend b { .host = "127.0.0.1"; }
 	acl foo-bar {
 	}

bin/varnishtest/tests/v00047.vtc

 varnishtest "Changing Last Modified in vcl_deliver"
- 
+
 server s1 {
 	rxreq
 	txresp -hdr "Last-Modified: Wed, 27 Apr 2016 14:00:00 GMT"
 } -start
- 
+
 varnish v1 -vcl+backend {
 	sub vcl_deliver {
 		if (req.http.deliver == "modify") {
@@ -12,7 +12,7 @@ varnish v1 -vcl+backend {
 		}
 	}
 } -start
- 
+
 client c1 {
 	txreq
 	rxresp

lib/libvcc/vcc_acl.c

@@ -479,13 +479,8 @@ vcc_ParseAcl(struct vcc *tl)
 	vcc_NextToken(tl);
 	VTAILQ_INIT(&tl->acl);
 
-	ExpectErr(tl, ID);
-	if (!vcc_isCid(tl->t)) {
-		VSB_printf(tl->sb,
-		    "Names of VCL acl's cannot contain '-'\n");
-		vcc_ErrWhere(tl, tl->t);
-		return;
-	}
+	vcc_ExpectCid(tl, "ACL");
+	ERRCHK(tl);
 	an = tl->t;
 	vcc_NextToken(tl);
 

lib/libvcc/vcc_action.c

@@ -156,12 +156,8 @@ parse_new(struct vcc *tl)
 
 	vcc_NextToken(tl);
 	ExpectErr(tl, ID);
-	if (!vcc_isCid(tl->t)) {
-		VSB_printf(tl->sb,
-		    "Names of VCL objects cannot contain '-'\n");
-		vcc_ErrWhere(tl, tl->t);
-		return;
-	}
+	vcc_ExpectCid(tl, "VCL object");
+	ERRCHK(tl);
 	sy1 = VCC_FindSymbol(tl, tl->t, SYM_NONE);
 	if (sy1 != NULL) {
 		VSB_printf(tl->sb, "Object name '%.*s' already used.\n",

lib/libvcc/vcc_backend.c

@@ -251,9 +251,9 @@ vcc_ParseProbe(struct vcc *tl)
 	struct token *t_probe;
 	char *p;
 
-	vcc_NextToken(tl);		/* ID: probe */
+	vcc_NextToken(tl);			/* ID: probe */
 
-	vcc_ExpectCid(tl);		/* ID: name */
+	vcc_ExpectCid(tl, "backend probe");	/* ID: name */
 	ERRCHK(tl);
 	t_probe = tl->t;
 	vcc_NextToken(tl);
@@ -462,7 +462,7 @@ vcc_ParseBackend(struct vcc *tl)
 	t_first = tl->t;
 	vcc_NextToken(tl);		/* ID: backend */
 
-	vcc_ExpectCid(tl);		/* ID: name */
+	vcc_ExpectCid(tl, "backend");	/* ID: name */
 	ERRCHK(tl);
 
 	if (tl->t->e - tl->t->b > MAX_BACKEND_NAME) {

lib/libvcc/vcc_compile.h

@@ -54,7 +54,6 @@ struct sockaddr_storage;
 #define isident1(c) (isalpha(c))
 #define isident(c) (isalpha(c) || isdigit(c) || (c) == '_' || (c) == '-')
 #define isvar(c) (isident(c) || (c) == '.')
-int vcc_isCid(const struct token *t);
 unsigned vcl_fixed_token(const char *p, const char **q);
 extern const char * const vcl_tnames[256];
 void vcl_output_lang_h(struct vsb *sb);
@@ -333,7 +332,7 @@ void vcc_ErrWhere2(struct vcc *, const struct token *, const struct token *);
 
 void vcc__Expect(struct vcc *tl, unsigned tok, unsigned line);
 int vcc_IdIs(const struct token *t, const char *p);
-void vcc_ExpectCid(struct vcc *tl);
+void vcc_ExpectCid(struct vcc *tl, const char *what);
 void vcc_Lexer(struct vcc *tl, struct source *sp);
 void vcc_NextToken(struct vcc *tl);
 void vcc__ErrInternal(struct vcc *tl, const char *func,

lib/libvcc/vcc_expr.c

@@ -509,7 +509,7 @@ vcc_Eval_Handle(struct vcc *tl, struct expr **e, const struct symbol *sym,
 		*e = vcc_mk_expr(STRING, "\"%s\"", sym->name);
 		vcc_AddRef(tl, tl->t, sym->kind);
 	} else {
-		vcc_ExpectCid(tl);
+		vcc_ExpectCid(tl, "handle");
 		vcc_AddRef(tl, tl->t, sym->kind);
 		*e = vcc_mk_expr(sym->fmt, "%s", sym->rname);
 		(*e)->constant = EXPR_VAR;	/* XXX ? */
@@ -1196,7 +1196,7 @@ vcc_expr_cmp(struct vcc *tl, struct expr **e, enum var_type fmt)
 	    (tl->t->tok == '~' || tl->t->tok == T_NOMATCH)) {
 		not = tl->t->tok == '~' ? "" : "!";
 		vcc_NextToken(tl);
-		vcc_ExpectCid(tl);
+		vcc_ExpectCid(tl, "ACL");
 		vcc_AddRef(tl, tl->t, SYM_ACL);
 		bprintf(buf, "%smatch_acl_named_%.*s(ctx, \v1)",
 		    not, PF(tl->t));

lib/libvcc/vcc_parse.c

@@ -211,13 +211,8 @@ vcc_ParseFunction(struct vcc *tl)
 	int m, i;
 
 	vcc_NextToken(tl);
-	ExpectErr(tl, ID);
-	if (!vcc_isCid(tl->t)) {
-		VSB_printf(tl->sb,
-		    "Names of VCL sub's cannot contain '-'\n");
-		vcc_ErrWhere(tl, tl->t);
-		return;
-	}
+	vcc_ExpectCid(tl, "function");
+	ERRCHK(tl);
 
 	m = IsMethod(tl->t);
 	if (m == -2) {

lib/libvcc/vcc_token.c

@@ -293,32 +293,23 @@ vcc_IdIs(const struct token *t, const char *p)
  * Check that we have a C-identifier
  */
 
-int
-vcc_isCid(const struct token *t)
-{
-	const char *q;
-
-	assert(t->tok == ID);
-	for (q = t->b; q < t->e; q++) {
-		if (!isalnum(*q) && *q != '_')
-			return (0);
-	}
-	return (1);
-}
-
 void
-vcc_ExpectCid(struct vcc *tl)
+vcc_ExpectCid(struct vcc *tl, const char *what)
 {
+	const char *q;
 
 	ExpectErr(tl, ID);
 	ERRCHK(tl);
-	if (vcc_isCid(tl->t))
-		return;
-	VSB_printf(tl->sb, "Identifier ");
-	vcc_ErrToken(tl, tl->t);
-	VSB_printf(tl->sb,
-	    " contains illegal characters, use [0-9a-zA-Z_] only.\n");
-	vcc_ErrWhere(tl, tl->t);
+	for (q = tl->t->b; q < tl->t->e; q++) {
+		if (!isalnum(*q) && *q != '_') {
+			VSB_printf(tl->sb, "Name of %s, ", what);
+			vcc_ErrToken(tl, tl->t);
+			VSB_printf(tl->sb,
+			    ", contains illegal character '%c'\n", *q);
+			vcc_ErrWhere(tl, tl->t);
+			return;
+		}
+	}
 }
 
 /*--------------------------------------------------------------------