自学教程：C++ vcc_ErrWhere函数代码示例

static voidvcc_ByteVal(struct vcc *tl, double *d){	double v, sc;	v = vcc_DoubleVal(tl);	ERRCHK(tl);	if (tl->t->tok != ID) {		VSB_printf(tl->sb, "Expected BYTES unit (B, KB, MB...) got ");		vcc_ErrToken(tl, tl->t);		VSB_printf(tl->sb, "/n");		vcc_ErrWhere(tl, tl->t);		return;	}	if (vcc_IdIs(tl->t, "B"))		sc = 1.;	else if (vcc_IdIs(tl->t, "KB"))		sc = 1024.;	else if (vcc_IdIs(tl->t, "MB"))		sc = 1024. * 1024.;	else if (vcc_IdIs(tl->t, "GB"))		sc = 1024. * 1024. * 1024.;	else if (vcc_IdIs(tl->t, "TB"))		sc = 1024. * 1024. * 1024. * 1024.;	else {		VSB_printf(tl->sb, "Unknown BYTES unit ");		vcc_ErrToken(tl, tl->t);		VSB_printf(tl->sb,		    ".  Legal are 'B', 'KB', 'MB', 'GB' and 'TB'/n");		vcc_ErrWhere(tl, tl->t);		return;	}	vcc_NextToken(tl);	*d = v * sc;}

static voidvcc_Compound(struct vcc *tl){	int i;	SkipToken(tl, '{');	Fb(tl, 1, "{/n");	tl->indent += INDENT;	C(tl, ";");	while (1) {		ERRCHK(tl);		switch (tl->t->tok) {		case '{':			vcc_Compound(tl);			break;		case '}':			vcc_NextToken(tl);			tl->indent -= INDENT;			Fb(tl, 1, "}/n");			return;		case CSRC:			if (tl->allow_inline_c) {				Fb(tl, 1, "%.*s/n",				    (int) (tl->t->e - (tl->t->b + 2)),				    tl->t->b + 1);				vcc_NextToken(tl);			} else {				VSB_printf(tl->sb,				    "Inline-C not allowed/n");				vcc_ErrWhere(tl, tl->t);			}			break;		case EOI:			VSB_printf(tl->sb,			    "End of input while in compound statement/n");			tl->err = 1;			return;		case ID:			if (vcc_IdIs(tl->t, "if")) {				vcc_IfStmt(tl);				break;			} else {				i = vcc_ParseAction(tl);				ERRCHK(tl);				if (i) {					SkipToken(tl, ';');					break;				}			}			/* FALLTHROUGH */		default:			/* We deliberately do not mention inline C */			VSB_printf(tl->sb,			    "Expected an action, 'if', '{' or '}'/n");			vcc_ErrWhere(tl, tl->t);			return;		}	}}

static voidparse_return(struct vcc *tl){	unsigned hand;	const char *h;	vcc_NextToken(tl);	ExpectErr(tl, '(');	vcc_NextToken(tl);	ExpectErr(tl, ID);	hand = VCL_RET_MAX;	h = NULL;#define VCL_RET_MAC(l, U, B)				/		if (vcc_IdIs(tl->t, #l)) {		/			hand = VCL_RET_ ## U;		/			h = #U;				/		}#include "tbl/vcl_returns.h"#undef VCL_RET_MAC	if (h == NULL) {		VSB_printf(tl->sb, "Expected return action name./n");		vcc_ErrWhere(tl, tl->t);		ERRCHK(tl);	}	assert(hand < VCL_RET_MAX);	vcc_ProcAction(tl->curproc, hand, tl->t);	vcc_NextToken(tl);	if (tl->t->tok == '(') {		if (hand == VCL_RET_SYNTH)			parse_return_synth(tl);		else if (hand == VCL_RET_VCL)			parse_return_vcl(tl);		else if (hand == VCL_RET_PASS)			parse_return_pass(tl);		else {			VSB_printf(tl->sb, "Arguments not allowed./n");			vcc_ErrWhere(tl, tl->t);		}	} else {		if (hand == VCL_RET_SYNTH || hand == VCL_RET_VCL) {			VSB_printf(tl->sb, "Missing argument./n");			vcc_ErrWhere(tl, tl->t);		}	}	ERRCHK(tl);	Fb(tl, 1, "VRT_handling(ctx, VCL_RET_%s);/n", h);	Fb(tl, 1, "return (1);/n");	ExpectErr(tl, ')');	vcc_NextToken(tl);}

static voidvcc_Redef(struct vcc *tl, const char *redef, struct token **t_did,    struct token *t_field){	if (*t_did != NULL) {		VSB_printf(tl->sb, "%s redefinition at:/n", redef);		vcc_ErrWhere(tl, t_field);		VSB_printf(tl->sb, "Previous definition:/n");		vcc_ErrWhere(tl, *t_did);		return;	}	*t_did = t_field;}

voidvcc_Parse(struct vcc *tl){	struct toplev *tp;	while (tl->t->tok != EOI) {		ERRCHK(tl);		switch (tl->t->tok) {		case CSRC:			if (tl->allow_inline_c) {				Fc(tl, 0, "%.*s/n",				    (int) (tl->t->e - (tl->t->b + 4)),				    tl->t->b + 2);				vcc_NextToken(tl);			} else {				VSB_printf(tl->sb,				    "Inline-C not allowed/n");				vcc_ErrWhere(tl, tl->t);			}			break;		case EOI:			break;		case ID:			for (tp = toplev; tp->name != NULL; tp++) {				if (!vcc_IdIs(tl->t, tp->name))					continue;				tp->func(tl);				break;			}			if (tp->name != NULL)				break;			/* FALLTHROUGH */		default:			/* We deliberately do not mention inline-C */			VSB_printf(tl->sb, "Expected one of/n/t");			for (tp = toplev; tp->name != NULL; tp++) {				if (tp[1].name == NULL)					VSB_printf(tl->sb, " or ");				VSB_printf(tl->sb, "'%s'", tp->name);				if (tp[1].name != NULL)					VSB_printf(tl->sb, ", ");			}			VSB_printf(tl->sb, "/nFound: ");			vcc_ErrToken(tl, tl->t);			VSB_printf(tl->sb, " at/n");			vcc_ErrWhere(tl, tl->t);			return;		}	}}

voidvcc_ParseBackend(struct vcc *tl){	struct token *t_first, *t_be;	struct symbol *sym;	const char *dn;	tl->ndirector++;	t_first = tl->t;	SkipToken(tl, ID);		/* ID: backend */	vcc_ExpectVid(tl, "backend");	/* ID: name */	ERRCHK(tl);	t_be = tl->t;	if (vcc_IdIs(tl->t, "default")) {		if (tl->first_director != NULL) {			tl->first_director->noref = 0;			tl->first_director = NULL;			tl->default_director = NULL;		}		if (tl->default_director != NULL) {			VSB_printf(tl->sb,			    "Only one default director possible./n");			vcc_ErrWhere(tl, t_first);			return;		}		vcc_NextToken(tl);		dn = "vgc_backend_default";		tl->default_director = dn;	} else {		sym = VCC_HandleSymbol(tl, BACKEND, "vgc_backend");		ERRCHK(tl);		dn = sym->rname;		if (tl->default_director == NULL) {			tl->first_director = sym;			tl->default_director = dn;			sym->noref = 1;		}	}	Fh(tl, 0, "/nstatic VCL_BACKEND %s;/n", dn);	vcc_ParseHostDef(tl, t_be, dn);	if (tl->err) {		VSB_printf(tl->sb,		    "/nIn %.*s specification starting at:/n", PF(t_first));		vcc_ErrWhere(tl, t_first);		return;	}}

static voidvcc_ProbeRedef(struct vcc *tl, struct token **t_did,    struct token *t_field){	/* .url and .request are mutually exclusive */	if (*t_did != NULL) {		VSB_printf(tl->sb, "Probe request redefinition at:/n");		vcc_ErrWhere(tl, t_field);		VSB_printf(tl->sb, "Previous definition:/n");		vcc_ErrWhere(tl, *t_did);		return;	}	*t_did = t_field;}

static voidparse_return(struct tokenlist *tl){	int retval = 0;	vcc_NextToken(tl);	ExpectErr(tl, '(');	vcc_NextToken(tl);	ExpectErr(tl, ID);#define VCL_RET_MAC(l, U)						/	do {								/		if (vcc_IdIs(tl->t, #l)) {				/			Fb(tl, 1, "VRT_done(sp, VCL_RET_" #U ");/n");	/			vcc_ProcAction(tl->curproc, VCL_RET_##U, tl->t);/			retval = 1;					/		}							/	} while (0);#include "vcl_returns.h"#undef VCL_RET_MAC	if (!retval) {		vsb_printf(tl->sb, "Expected return action name./n");		vcc_ErrWhere(tl, tl->t);		ERRCHK(tl);	}	vcc_NextToken(tl);	ExpectErr(tl, ')');	vcc_NextToken(tl);}

const char *vcc_regexp(struct vcc *tl){	char buf[BUFSIZ], *p;	vre_t *t;	const char *error;	int erroroffset;	struct inifin *ifp;	Expect(tl, CSTR);	if (tl->err)		return (NULL);	t = VRE_compile(tl->t->dec, 0, &error, &erroroffset);	if (t == NULL) {		VSB_printf(tl->sb,		    "Regexp compilation error:/n/n%s/n/n", error);		vcc_ErrWhere(tl, tl->t);		return (NULL);	}	VRE_free(&t);	bprintf(buf, "VGC_re_%u", tl->unique++);	p = TlAlloc(tl, strlen(buf) + 1);	strcpy(p, buf);	Fh(tl, 0, "static void *%s;/n", buf);	ifp = New_IniFin(tl);	VSB_printf(ifp->ini, "/tVRT_re_init(&%s, ",buf);	EncToken(ifp->ini, tl->t);	VSB_printf(ifp->ini, ");");	VSB_printf(ifp->fin, "/t/tVRT_re_fini(%s);", buf);	vcc_NextToken(tl);	return (p);}

static doublevcc_TimeUnit(struct vcc *tl){	double sc = 1.0;	assert(tl->t->tok == ID);	if (vcc_IdIs(tl->t, "ms"))		sc = 1e-3;	else if (vcc_IdIs(tl->t, "s"))		sc = 1.0;	else if (vcc_IdIs(tl->t, "m"))		sc = 60.0;	else if (vcc_IdIs(tl->t, "h"))		sc = 60.0 * 60.0;	else if (vcc_IdIs(tl->t, "d"))		sc = 60.0 * 60.0 * 24.0;	else if (vcc_IdIs(tl->t, "w"))		sc = 60.0 * 60.0 * 24.0 * 7.0;	else {		VSB_printf(tl->sb, "Unknown time unit ");		vcc_ErrToken(tl, tl->t);		VSB_printf(tl->sb, ".  Legal are 's', 'm', 'h' and 'd'/n");		vcc_ErrWhere(tl, tl->t);		return (1.0);	}	vcc_NextToken(tl);	return (sc);}

voidvcc_ParseLeastBusyDirector(struct tokenlist *tl, const struct token *t_policy,    const struct token *t_dir){	struct token *t_field, *t_be;	int nbh, nelem;	struct fld_spec *fs;	const char *first;	fs = vcc_FldSpec(tl, "!backend", NULL);	Fc(tl, 0, "/nstatic const struct vrt_dir_least_busy_entry "	    "vdrre_%.*s[] = {/n", PF(t_dir));	for (nelem = 0; tl->t->tok != '}'; nelem++) {	/* List of members */		first = "";		t_be = tl->t;		vcc_ResetFldSpec(fs);		nbh = -1;		ExpectErr(tl, '{');		vcc_NextToken(tl);		Fc(tl, 0, "/t{");		while (tl->t->tok != '}') {	/* Member fields */			vcc_IsField(tl, &t_field, fs);			ERRCHK(tl);			if (vcc_IdIs(t_field, "backend")) {				vcc_ParseBackendHost(tl, &nbh,				    t_dir, t_policy, nelem);				Fc(tl, 0, "%s .host = &bh_%d", first, nbh);				ERRCHK(tl);			} else {				ErrInternal(tl);			}			first = ", ";		}		vcc_FieldsOk(tl, fs);		if (tl->err) {			vsb_printf(tl->sb,			    "/nIn member host specification starting at:/n");			vcc_ErrWhere(tl, t_be);			return;		}		Fc(tl, 0, " },/n");		vcc_NextToken(tl);	}	Fc(tl, 0, "};/n");	Fc(tl, 0,	    "/nstatic const struct vrt_dir_least_busy vdrr_%.*s = {/n",	    PF(t_dir));	Fc(tl, 0, "/t.name = /"%.*s/",/n", PF(t_dir));	Fc(tl, 0, "/t.nmember = %d,/n", nelem);	Fc(tl, 0, "/t.members = vdrre_%.*s,/n", PF(t_dir));	Fc(tl, 0, "};/n");	Fi(tl, 0, "/tVRT_init_dir_least_busy("	    "cli, &VGC_backend_%.*s , &vdrr_%.*s);/n", PF(t_dir), PF(t_dir));	Ff(tl, 0, "/tVRT_fini_dir(cli, VGC_backend_%.*s);/n", PF(t_dir));}

voidvcc_ParseBackend(struct vcc *tl){	struct token *t_first, *t_be;	struct symbol *sym;	char vgcname[MAX_BACKEND_NAME + 20];	t_first = tl->t;	vcc_NextToken(tl);		/* ID: backend */	vcc_ExpectCid(tl);		/* ID: name */	ERRCHK(tl);	if (tl->t->e - tl->t->b > MAX_BACKEND_NAME) {		VSB_printf(tl->sb,		    "Name of %.*s too long (max %d, is %zu):/n",		    PF(t_first), MAX_BACKEND_NAME,		    (size_t)(tl->t->e - tl->t->b));		vcc_ErrWhere(tl, tl->t);		return;	}	t_be = tl->t;	vcc_NextToken(tl);	sprintf(vgcname, "vgc_backend_%.*s", PF(t_be));	Fh(tl, 0, "/nstatic struct director *%s;/n", vgcname);	sym = VCC_HandleSymbol(tl, t_be, BACKEND, "%s", vgcname);	ERRCHK(tl);	vcc_ParseHostDef(tl, t_be, vgcname);	ERRCHK(tl);	if (tl->err) {		VSB_printf(tl->sb,		    "/nIn %.*s specification starting at:/n", PF(t_first));		vcc_ErrWhere(tl, t_first);		return;	}	if (tl->default_director == NULL || vcc_IdIs(t_be, "default")) {		tl->default_director = sym->rname;		tl->t_default_director = t_be;	}}

static voidparse_new_syntax(struct tokenlist *tl){	vsb_printf(tl->sb, "Please change /"%.*s/" to /"return(%.*s)/"./n",	    PF(tl->t), PF(tl->t));	vcc_ErrWhere(tl, tl->t);}

voidvcc_ParseDirector(struct vcc *tl){	struct token *t_first;	int isfirst;	t_first = tl->t;	vcc_NextToken(tl);		/* ID: director | backend */	vcc_ExpectCid(tl);		/* ID: name */	ERRCHK(tl);	if (tl->t->e - tl->t->b > 64) {		VSB_printf(tl->sb,		    "Name of %.*s too long (max 64, is %zu):/n",		    PF(t_first), (size_t)(tl->t->e - tl->t->b));		vcc_ErrWhere(tl, tl->t);		return;	}	tl->t_dir = tl->t;	vcc_NextToken(tl);	isfirst = tl->ndirector;	if (vcc_IdIs(t_first, "backend")) {		vcc_ParseSimpleDirector(tl);	} else {		VSB_printf(tl->sb,		    "/ndirectors are now in VMOD.directors/n");		vcc_ErrWhere(tl, t_first);		return;	}	if (tl->err) {		VSB_printf(tl->sb,		    "/nIn %.*s specification starting at:/n", PF(t_first));		vcc_ErrWhere(tl, t_first);		return;	}	if (isfirst == 1 || vcc_IdIs(tl->t_dir, "default")) {		tl->defaultdir = tl->ndirector - 1;		tl->t_defaultdir = tl->t_dir;	}	tl->t_dir = NULL;}

static voidcheck_writebit(struct tokenlist *tl, const struct var *vp){	if (vp->access == V_RW || vp->access == V_WO)		return;	vsb_printf(tl->sb, "Variable %.*s cannot be modified./n", PF(tl->t));	vcc_ErrWhere(tl, tl->t);}

static intvcc_decstr(struct tokenlist *tl){	const char *p;	char *q;	unsigned char u;	assert(tl->t->tok == CSTR);	tl->t->dec = TlAlloc(tl, (tl->t->e - tl->t->b) - 1);	assert(tl->t->dec != NULL);	q = tl->t->dec;	for (p = tl->t->b + 1; p < tl->t->e - 1; ) {		if (*p != '%') {			*q++ = *p++;			continue;		}		if (p + 4 > tl->t->e) {			vcc_AddToken(tl, CSTR, p, tl->t->e);			vsb_printf(tl->sb,			    "Incomplete %%xx escape/n");			vcc_ErrWhere(tl, tl->t);			return(1);		}		if (!isxdigit(p[1]) || !isxdigit(p[2])) {			vcc_AddToken(tl, CSTR, p, p + 3);			vsb_printf(tl->sb,			    "Invalid hex char in %%xx escape/n");			vcc_ErrWhere(tl, tl->t);			return(1);		}		u = (vcc_xdig(p[1]) * 16 + vcc_xdig(p[2])) & 0xff;		if (!isgraph(u)) {			vcc_AddToken(tl, CSTR, p, p + 3);			vsb_printf(tl->sb,			    "Control character in %%xx escape/n");			vcc_ErrWhere(tl, tl->t);			return(1);		}		*q++ = u;		p += 3;	}	*q++ = '/0';	return (0);}

voidvcc__Expect(struct tokenlist *tl, unsigned tok, int line){	if (tl->t->tok == tok)		return;	vsb_printf(tl->sb, "Expected %s got ", vcl_tnames[tok]);	vcc_ErrToken(tl, tl->t);	vsb_printf(tl->sb, "/n(program line %u), at/n", line);	vcc_ErrWhere(tl, tl->t);}

voidvcc_ParseRoundRobinDirector(struct vcc *tl){	struct token *t_field, *t_be;	int nelem;	struct fld_spec *fs;	const char *first;	char *p;	fs = vcc_FldSpec(tl, "!backend", NULL);	Fc(tl, 0, "/nstatic const struct vrt_dir_round_robin_entry "	    "vdrre_%.*s[] = {/n", PF(tl->t_dir));	for (nelem = 0; tl->t->tok != '}'; nelem++) {	/* List of members */		first = "";		t_be = tl->t;		vcc_ResetFldSpec(fs);		SkipToken(tl, '{');		Fc(tl, 0, "/t{");		while (tl->t->tok != '}') {	/* Member fields */			vcc_IsField(tl, &t_field, fs);			ERRCHK(tl);			if (vcc_IdIs(t_field, "backend")) {				vcc_ParseBackendHost(tl, nelem, &p);				ERRCHK(tl);				AN(p);				Fc(tl, 0, "%s .host = VGC_backend_%s",				    first, p);			} else {				ErrInternal(tl);			}			first = ", ";		}		vcc_FieldsOk(tl, fs);		if (tl->err) {			VSB_printf(tl->sb,			    "/nIn member host specification starting at:/n");			vcc_ErrWhere(tl, t_be);			return;		}		Fc(tl, 0, " },/n");		vcc_NextToken(tl);	}	Fc(tl, 0, "};/n");	Fc(tl, 0,	    "/nstatic const struct vrt_dir_round_robin vgc_dir_priv_%.*s = {/n",	    PF(tl->t_dir));	Fc(tl, 0, "/t.name = /"%.*s/",/n", PF(tl->t_dir));	Fc(tl, 0, "/t.nmember = %d,/n", nelem);	Fc(tl, 0, "/t.members = vdrre_%.*s,/n", PF(tl->t_dir));	Fc(tl, 0, "};/n");}

const struct var *vcc_FindVar(struct vcc *tl, const struct token *t, int wr_access,    const char *use){	const struct var *v;	const struct symbol *sym;	AN(tl->vars);	sym = VCC_FindSymbol(tl, t, SYM_VAR);	if (sym != NULL) {		v = sym->var;		AN(v);		if (wr_access && v->w_methods == 0) {			VSB_printf(tl->sb, "Variable ");			vcc_ErrToken(tl, t);			VSB_printf(tl->sb, " is read only.");			VSB_cat(tl->sb, "/nAt: ");			vcc_ErrWhere(tl, t);			return (NULL);		} else if (wr_access) {			vcc_AddUses(tl, t, v->w_methods, use);		} else if (v->r_methods == 0) {			VSB_printf(tl->sb, "Variable ");			vcc_ErrToken(tl, t);			VSB_printf(tl->sb, " is write only.");			VSB_cat(tl->sb, "/nAt: ");			vcc_ErrWhere(tl, t);			return (NULL);		} else {			vcc_AddUses(tl, t, v->r_methods, use);		}		assert(v->fmt != HEADER);		return (v);	}	VSB_printf(tl->sb, "Unknown variable ");	vcc_ErrToken(tl, t);	VSB_cat(tl->sb, "/nAt: ");	vcc_ErrWhere(tl, t);	return (NULL);}

const char *vcc_default_probe(struct vcc *tl){	if (tl->default_probe != NULL)		return (tl->default_probe);	VSB_printf(tl->sb, "No default probe defined/n");	vcc_ErrToken(tl, tl->t);	VSB_printf(tl->sb, " at/n");	vcc_ErrWhere(tl, tl->t);	return ("");}

static voidparse_error(struct vcc *tl){	VSB_printf(tl->sb,	    "Syntax has changed, use:/n"	    "/treturn(error(999));/n"	    "or/n"	    "/treturn(error(999, /"Response text/"));/n");	vcc_ErrWhere(tl, tl->t);	return;}

static voidvcc_Function(struct vcc *tl){	int m, i;	vcc_NextToken(tl);	ExpectErr(tl, ID);	m = IsMethod(tl->t);	if (m != -1) {		assert(m < VCL_MET_MAX);		tl->fb = tl->fm[m];		if (tl->mprocs[m] == NULL) {			(void)vcc_AddDef(tl, tl->t, SYM_SUB);			vcc_AddRef(tl, tl->t, SYM_SUB);			tl->mprocs[m] = vcc_AddProc(tl, tl->t);		}		tl->curproc = tl->mprocs[m];		Fb(tl, 1, "  /* ... from ");		vcc_Coord(tl, tl->fb, NULL);		Fb(tl, 0, " *//n");	} else {		tl->fb = tl->fc;		i = vcc_AddDef(tl, tl->t, SYM_SUB);		if (i > 1) {			VSB_printf(tl->sb,			    "Function %.*s redefined/n", PF(tl->t));			vcc_ErrWhere(tl, tl->t);			return;		}		tl->curproc = vcc_AddProc(tl, tl->t);		Fh(tl, 0, "static int VGC_function_%.*s (struct sess *sp);/n",		    PF(tl->t));		Fc(tl, 1, "/nstatic int/n");		Fc(tl, 1, "VGC_function_%.*s (struct sess *sp)/n", PF(tl->t));	}	vcc_NextToken(tl);	tl->indent += INDENT;	Fb(tl, 1, "{/n");	L(tl, vcc_Compound(tl));	if (m == -1) {		/*		 * non-method subroutines must have an explicit non-action		 * return in case they just fall through the bottom.		 */		Fb(tl, 1, "  return(0);/n");	}	Fb(tl, 1, "}/n");	tl->indent -= INDENT;	tl->fb = NULL;	tl->curproc = NULL;}

voidvcc_ExpectCid(struct tokenlist *tl){	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);}

static voidvcc_DefBackend(struct vcc *tl, const struct token *nm){	struct symbol *sym;	sym = VCC_GetSymbolTok(tl, nm, SYM_BACKEND);	AN(sym);	if (sym->ndef > 0) {		VSB_printf(tl->sb, "Backend %.*s redefined/n", PF(nm));		vcc_ErrWhere(tl, nm);		return;	}	sym->fmt = BACKEND;	sym->eval = vcc_Eval_Backend;	sym->ndef++;}

static voidparse_set(struct vcc *tl){	const struct symbol *sym;	const struct arith *ap;	vcc_type_t fmt;	vcc_NextToken(tl);	ExpectErr(tl, ID);	sym = vcc_FindVar(tl, tl->t, 1, "cannot be set");	ERRCHK(tl);	assert(sym != NULL);	if (vcc_IdIs(tl->t, "bereq.body")) {		VSB_printf(tl->sb, "bereq.body cannot be set./n");		vcc_ErrWhere(tl, tl->t);		return;	}	Fb(tl, 1, "%s/n", sym->lname);	tl->indent += INDENT;	vcc_NextToken(tl);	fmt = sym->fmt;	for (ap = arith; ap->type != VOID; ap++) {		if (ap->type != fmt)			continue;		if (ap->oper != tl->t->tok)			continue;		if (ap->oper != '=')			Fb(tl, 1, "%s %c ", sym->rname, *tl->t->b);		vcc_NextToken(tl);		fmt = ap->want;		break;	}	if (ap->type == VOID)		SkipToken(tl, ap->oper);	if (fmt == HEADER) {		vcc_Expr(tl, STRING_LIST);	} else if (fmt == STRING) {		vcc_Expr(tl, STRING_LIST);	} else if (fmt == BODY) {		vcc_Expr(tl, STRING_LIST);	} else {		vcc_Expr(tl, fmt);	}	tl->indent -= INDENT;	Fb(tl, 1, ");/n");}

static voidvcc_IfStmt(struct vcc *tl){	SkipToken(tl, ID);	Fb(tl, 1, "if ");	vcc_Conditional(tl);	ERRCHK(tl);	L(tl, vcc_Compound(tl));	ERRCHK(tl);	while (tl->t->tok == ID) {		if (vcc_IdIs(tl->t, "else")) {			vcc_NextToken(tl);			if (tl->t->tok == '{') {				Fb(tl, 1, "else/n");				L(tl, vcc_Compound(tl));				ERRCHK(tl);				return;			}			if (tl->t->tok != ID || !vcc_IdIs(tl->t, "if")) {				VSB_printf(tl->sb,				    "'else' must be followed by 'if' or '{'/n");				vcc_ErrWhere(tl, tl->t);				return;			}			Fb(tl, 1, "else if ");			vcc_NextToken(tl);			vcc_Conditional(tl);			ERRCHK(tl);			L(tl, vcc_Compound(tl));			ERRCHK(tl);		} else if (vcc_IdIs(tl->t, "elseif") ||		     vcc_IdIs(tl->t, "elsif") ||		     vcc_IdIs(tl->t, "elif")) {			Fb(tl, 1, "else if ");			vcc_NextToken(tl);			vcc_Conditional(tl);			ERRCHK(tl);			L(tl, vcc_Compound(tl));			ERRCHK(tl);		} else {			break;		}	}	C(tl, ";");}

static voidparse_restart(struct tokenlist *tl){	struct token *t1;	t1 = VTAILQ_NEXT(tl->t, list);	if (t1->tok == ID && vcc_IdIs(t1, "rollback")) {		Fb(tl, 1, "VRT_Rollback(sp);/n");		vcc_NextToken(tl);	} else if (t1->tok != ';') {		vsb_printf(tl->sb, "Expected /"rollback/" or semicolon./n");		vcc_ErrWhere(tl, t1);		ERRCHK(tl);	}	Fb(tl, 1, "VRT_done(sp, VCL_RET_RESTART);/n");	vcc_ProcAction(tl->curproc, VCL_RET_RESTART, tl->t);	vcc_NextToken(tl);}

static voidvcc_ParseVcl(struct vcc *tl){	double ver;	struct token *tok;	assert(vcc_IdIs(tl->t, "vcl"));	vcc_NextToken(tl);	tok = tl->t;	ver = vcc_DoubleVal(tl);	ERRCHK(tl);	if (ver != 4.0) {		VSB_printf(tl->sb, "VCL version %.1f not supported./n", ver);		vcc_ErrWhere(tl, tok);		ERRCHK(tl);	}	ExpectErr(tl, ';');	vcc_NextToken(tl);}

static voidparse_unset(struct vcc *tl){	const struct var *vp;	vcc_NextToken(tl);	ExpectErr(tl, ID);	vp = vcc_FindVar(tl, tl->t, 1, "cannot be unset");	ERRCHK(tl);	assert(vp != NULL);	if (vp->fmt != STRING || vp->http == NULL) {		VSB_printf(tl->sb,		    "Only http header variables can be unset./n");		vcc_ErrWhere(tl, tl->t);		return;	}	ERRCHK(tl);	Fb(tl, 1, "%s0);/n", vp->lname);	vcc_NextToken(tl);}

static voidparse_unset(struct tokenlist *tl){	struct var *vp;	vcc_NextToken(tl);	ExpectErr(tl, VAR);	vp = vcc_FindVar(tl, tl->t, vcc_vars);	ERRCHK(tl);	assert(vp != NULL);	if (vp->fmt != STRING || vp->hdr == NULL) {		vsb_printf(tl->sb, "Only http header lines can be unset./n");		vcc_ErrWhere(tl, tl->t);		return;	}	check_writebit(tl, vp);	ERRCHK(tl);	Fb(tl, 1, "%s0);/n", vp->lname);	vcc_NextToken(tl);}