static void
vcc_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 void
vcc_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 void
parse_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 void
vcc_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;
}
void
vcc_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;
}
}
}
void
vcc_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 void
vcc_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 void
parse_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 double
vcc_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);
}
void
vcc_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));
}
void
vcc_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 void
parse_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);
}
void
vcc_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 void
check_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 int
vcc_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);
}
void
vcc__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);
}
void
vcc_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 void
parse_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 void
vcc_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;
}
void
vcc_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 void
vcc_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 void
parse_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 void
vcc_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 void
parse_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 void
vcc_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 void
parse_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 void
parse_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);
}
