static void
parse_set(struct vcc *tl)
{
const struct var *vp;
const struct arith *ap;
enum var_type fmt;
vcc_NextToken(tl);
ExpectErr(tl, ID);
vp = vcc_FindVar(tl, tl->t, 1, "cannot be set");
ERRCHK(tl);
assert(vp != NULL);
Fb(tl, 1, "%s", vp->lname);
vcc_NextToken(tl);
fmt = vp->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, 0, "%s %c ", vp->rname, *tl->t->b);
vcc_NextToken(tl);
fmt = ap->want;
break;
}
if (ap->type == VOID)
SkipToken(tl, ap->oper);
if (fmt == STRING) {
vcc_Expr(tl, STRING_LIST);
} else {
vcc_Expr(tl, fmt);
}
Fb(tl, 1, ");\n");
}
/*--------------------------------------------------------------------
*/
void
vcc_Eval_Var(struct vcc *tl, struct expr **e, const struct symbol *sym)
{
const struct var *vp;
assert(sym->kind == SYM_VAR);
vcc_AddUses(tl, tl->t, sym->r_methods, "Not available");
vp = vcc_FindVar(tl, tl->t, 0, "cannot be read");
ERRCHK(tl);
assert(vp != NULL);
*e = vcc_mk_expr(vp->fmt, "%s", vp->rname);
vcc_NextToken(tl);
}
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
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);
}
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 vcc *tl)
{
const struct var *vp;
/* XXX: Wrong, should use VCC_Expr(HEADER) */
vcc_NextToken(tl);
ExpectErr(tl, ID);
vp = vcc_FindVar(tl, tl->t, 1, "cannot be unset");
ERRCHK(tl);
assert(vp != NULL);
if (vp->fmt != HEADER) {
VSB_printf(tl->sb,
"Only HTTP header variables can be unset.\n");
vcc_ErrWhere(tl, tl->t);
return;
}
ERRCHK(tl);
Fb(tl, 1, "%svrt_magic_string_unset);\n", vp->lname);
vcc_NextToken(tl);
}
static void
parse_unset(struct vcc *tl)
{
const struct symbol *sym;
/* XXX: Wrong, should use VCC_Expr(HEADER) */
vcc_NextToken(tl);
ExpectErr(tl, ID);
sym = vcc_FindVar(tl, tl->t, 1, "cannot be unset");
ERRCHK(tl);
assert(sym != NULL);
if (sym->fmt != HEADER && !vcc_IdIs(tl->t, "bereq.body")) {
VSB_printf(tl->sb,
"Only bereq.body and HTTP header variables can"
" be unset.\n");
vcc_ErrWhere(tl, tl->t);
return;
}
ERRCHK(tl);
Fb(tl, 1, "%svrt_magic_string_unset);\n", sym->lname);
vcc_NextToken(tl);
}
static void
parse_error(struct tokenlist *tl)
{
struct var *vp;
vcc_NextToken(tl);
if (tl->t->tok == VAR) {
vp = vcc_FindVar(tl, tl->t, vcc_vars);
ERRCHK(tl);
assert(vp != NULL);
if (vp->fmt == INT) {
Fb(tl, 1, "VRT_error(sp, %s", vp->rname);
vcc_NextToken(tl);
} else {
Fb(tl, 1, "VRT_error(sp, 0");
}
} else if (tl->t->tok == CNUM) {
Fb(tl, 1, "VRT_error(sp, %u", vcc_UintVal(tl));
} else
Fb(tl, 1, "VRT_error(sp, 0");
if (tl->t->tok == CSTR) {
Fb(tl, 0, ", %.*s", PF(tl->t));
vcc_NextToken(tl);
} else if (tl->t->tok == VAR) {
Fb(tl, 0, ", ");
if (!vcc_StringVal(tl)) {
ERRCHK(tl);
vcc_ExpectedStringval(tl);
return;
}
} else {
Fb(tl, 0, ", (const char *)0");
}
Fb(tl, 0, ");\n");
Fb(tl, 1, "VRT_done(sp, VCL_RET_ERROR);\n");
}
static void
parse_set(struct tokenlist *tl)
{
struct var *vp;
struct token *at, *vt;
vcc_NextToken(tl);
ExpectErr(tl, VAR);
vt = tl->t;
vp = vcc_FindVar(tl, tl->t, vcc_vars);
ERRCHK(tl);
assert(vp != NULL);
check_writebit(tl, vp);
ERRCHK(tl);
Fb(tl, 1, "%s", vp->lname);
vcc_NextToken(tl);
switch (vp->fmt) {
case INT:
case SIZE:
case TIME:
case RTIME:
case FLOAT:
if (tl->t->tok != '=')
Fb(tl, 0, "%s %c ", vp->rname, *tl->t->b);
at = tl->t;
vcc_NextToken(tl);
switch (at->tok) {
case T_MUL:
case T_DIV:
Fb(tl, 0, "%g", vcc_DoubleVal(tl));
break;
case T_INCR:
case T_DECR:
case '=':
vcc_VarVal(tl, vp, vt);
ERRCHK(tl);
break;
default:
vsb_printf(tl->sb, "Invalid assignment operator.\n");
vcc_ErrWhere(tl, at);
return;
}
Fb(tl, 0, ");\n");
break;
#if 0 /* XXX: enable if we find a legit use */
case IP:
if (tl->t->tok != '=') {
illegal_assignment(tl, "IP numbers");
return;
}
vcc_NextToken(tl);
u = vcc_vcc_IpVal(tl);
Fb(tl, 0, "= %uU; /* %u.%u.%u.%u */\n",
u,
(u >> 24) & 0xff,
(u >> 16) & 0xff,
(u >> 8) & 0xff,
u & 0xff);
break;
#endif
case BACKEND:
if (tl->t->tok != '=') {
illegal_assignment(tl, "backend");
return;
}
vcc_NextToken(tl);
vcc_ExpectCid(tl);
ERRCHK(tl);
vcc_AddRef(tl, tl->t, R_BACKEND);
Fb(tl, 0, "VGCDIR(_%.*s)", PF(tl->t));
vcc_NextToken(tl);
Fb(tl, 0, ");\n");
break;
case HASH:
SkipToken(tl, T_INCR);
if (!vcc_StringVal(tl)) {
ERRCHK(tl);
vcc_ExpectedStringval(tl);
return;
}
Fb(tl, 0, ");\n");
/*
* We count the number of operations on the req.hash
* variable, so that varnishd can preallocate the worst case
* number of slots for composing the hash string.
*/
break;
case STRING:
if (tl->t->tok != '=') {
illegal_assignment(tl, "strings");
return;
}
vcc_NextToken(tl);
if (!vcc_StringVal(tl)) {
ERRCHK(tl);
vcc_ExpectedStringval(tl);
return;
}
do
Fb(tl, 0, ", ");
while (vcc_StringVal(tl));
if (tl->t->tok != ';') {
ERRCHK(tl);
vsb_printf(tl->sb,
"Expected variable, string or semicolon\n");
vcc_ErrWhere(tl, tl->t);
return;
}
Fb(tl, 0, "vrt_magic_string_end);\n");
break;
case BOOL:
if (tl->t->tok != '=') {
illegal_assignment(tl, "boolean");
return;
}
vcc_NextToken(tl);
ExpectErr(tl, ID);
if (vcc_IdIs(tl->t, "true")) {
Fb(tl, 0, " 1);\n", vp->lname);
} else if (vcc_IdIs(tl->t, "false")) {
Fb(tl, 0, " 0);\n", vp->lname);
} else {
vsb_printf(tl->sb,
"Expected true or false\n");
vcc_ErrWhere(tl, tl->t);
return;
}
vcc_NextToken(tl);
break;
default:
vsb_printf(tl->sb,
"Assignments not possible for type of '%s'\n", vp->name);
vcc_ErrWhere(tl, tl->t);
return;
}
}