const char *
vtc_logfull(void)
{
vsb_finish(vtclog_full);
AZ(vsb_overflowed(vtclog_full));
return (vsb_data(vtclog_full));
}
//lint -e{818}
void
vtc_log(struct vtclog *vl, unsigned lvl, const char *fmt, ...)
{
CHECK_OBJ_NOTNULL(vl, VTCLOG_MAGIC);
AZ(pthread_mutex_lock(&vl->mtx));
assert(lvl < NLEAD);
vsb_clear(vl->vsb);
vsb_printf(vl->vsb, "%s %-4s ", lead[lvl], vl->id);
va_list ap;
va_start(ap, fmt);
(void)vsb_vprintf(vl->vsb, fmt, ap);
va_end(ap);
vsb_putc(vl->vsb, '\n');
vsb_finish(vl->vsb);
AZ(vsb_overflowed(vl->vsb));
vtc_log_emit(vl, lvl);
vsb_clear(vl->vsb);
AZ(pthread_mutex_unlock(&vl->mtx));
if (lvl == 0) {
vtc_error = 1;
if (pthread_self() != vtc_thread)
pthread_exit(NULL);
}
}
static struct expr *
vcc_expr_edit(enum var_type fmt, const char *p, struct expr *e1,
struct expr *e2)
{
struct expr *e;
int nl = 1;
e = vcc_new_expr();
while (*p != '\0') {
if (*p == '\n') {
if (!nl)
vsb_putc(e->vsb, *p);
nl = 1;
p++;
continue;
}
nl = 0;
if (*p != '\v') {
vsb_putc(e->vsb, *p);
p++;
continue;
}
assert(*p == '\v');
p++;
switch(*p) {
case '+': vsb_cat(e->vsb, "\v+"); break;
case '-': vsb_cat(e->vsb, "\v-"); break;
case '1':
case '2':
if (*p == '1')
vsb_cat(e->vsb, vsb_data(e1->vsb));
else {
AN(e2);
vsb_cat(e->vsb, vsb_data(e2->vsb));
}
break;
default:
assert(__LINE__ == 0);
}
p++;
}
AZ(vsb_finish(e->vsb));
if (e1 != NULL)
e->t1 = e1->t1;
else if (e2 != NULL)
e->t1 = e2->t1;
if (e2 != NULL)
e->t2 = e2->t1;
else if (e1 != NULL)
e->t1 = e1->t1;
if ((e1 == NULL || e1->constant) && (e2 == NULL || e2->constant))
e->constant = 1;
vcc_delete_expr(e1);
vcc_delete_expr(e2);
e->fmt = fmt;
return (e);
}
static void
http_write(const struct http *hp, int lvl, const char *pfx)
{
int l;
vsb_finish(hp->vsb);
AZ(vsb_overflowed(hp->vsb));
vtc_dump(hp->vl, lvl, pfx, vsb_data(hp->vsb));
l = write(hp->fd, vsb_data(hp->vsb), vsb_len(hp->vsb));
if (l != vsb_len(hp->vsb))
vtc_log(hp->vl, 0, "Write failed: %s", strerror(errno));
}
static struct expr *
vcc_mk_expr(enum var_type fmt, const char *str, ...)
{
va_list ap;
struct expr *e;
e = vcc_new_expr();
e->fmt = fmt;
va_start(ap, str);
vsb_vprintf(e->vsb, str, ap);
va_end(ap);
AZ(vsb_finish(e->vsb));
return (e);
}
//lint -e{818}
void
vtc_dump(struct vtclog *vl, unsigned lvl, const char *pfx, const char *str)
{
int nl = 1;
CHECK_OBJ_NOTNULL(vl, VTCLOG_MAGIC);
assert(lvl < NLEAD);
AZ(pthread_mutex_lock(&vl->mtx));
vsb_clear(vl->vsb);
if (pfx == NULL)
pfx = "";
if (str == NULL)
vsb_printf(vl->vsb, "%s %-4s %s(null)\n",
lead[lvl], vl->id, pfx);
else
for(; *str != '\0'; str++) {
if (nl) {
vsb_printf(vl->vsb, "%s %-4s %s| ",
lead[lvl], vl->id, pfx);
nl = 0;
}
if (*str == '\r')
vsb_printf(vl->vsb, "\\r");
else if (*str == '\t')
vsb_printf(vl->vsb, "\\t");
else if (*str == '\n') {
vsb_printf(vl->vsb, "\\n\n");
nl = 1;
} else if (*str < 0x20 || *str > 0x7e)
vsb_printf(vl->vsb, "\\x%02x", *str);
else
vsb_printf(vl->vsb, "%c", *str);
}
if (!nl)
vsb_printf(vl->vsb, "\n");
vsb_finish(vl->vsb);
AZ(vsb_overflowed(vl->vsb));
vtc_log_emit(vl, lvl);
vsb_clear(vl->vsb);
AZ(pthread_mutex_unlock(&vl->mtx));
if (lvl == 0) {
vtc_error = 1;
if (pthread_self() != vtc_thread)
pthread_exit(NULL);
}
}
static void
vcc_expr4(struct vcc *tl, struct expr **e, enum var_type fmt)
{
struct expr *e1, *e2;
const struct symbol *sym;
double d;
*e = NULL;
if (tl->t->tok == '(') {
SkipToken(tl, '(');
vcc_expr0(tl, &e2, fmt);
ERRCHK(tl);
SkipToken(tl, ')');
*e = vcc_expr_edit(e2->fmt, "(\v1)", e2, NULL);
return;
}
switch(tl->t->tok) {
case ID:
/*
* XXX: what if var and func/proc had same name ?
* XXX: look for SYM_VAR first for consistency ?
*/
sym = VCC_FindSymbol(tl, tl->t, SYM_NONE);
if (sym == NULL || sym->eval == NULL) {
vsb_printf(tl->sb, "Symbol not found: ");
vcc_ErrToken(tl, tl->t);
vsb_printf(tl->sb, " (expected type %s):\n",
vcc_Type(fmt));
vcc_ErrWhere(tl, tl->t);
return;
}
AN(sym);
switch(sym->kind) {
case SYM_VAR:
case SYM_FUNC:
case SYM_BACKEND:
AN(sym->eval);
AZ(*e);
sym->eval(tl, e, sym);
return;
default:
break;
}
vsb_printf(tl->sb,
"Symbol type (%s) can not be used in expression.\n",
VCC_SymKind(tl, sym));
vcc_ErrWhere(tl, tl->t);
return;
case CSTR:
assert(fmt != VOID);
e1 = vcc_new_expr();
EncToken(e1->vsb, tl->t);
e1->fmt = STRING;
e1->t1 = tl->t;
e1->constant = 1;
vcc_NextToken(tl);
AZ(vsb_finish(e1->vsb));
*e = e1;
break;
case CNUM:
/*
* XXX: %g may not have enough decimals by default
* XXX: but %a is ugly, isn't it ?
*/
assert(fmt != VOID);
if (fmt == DURATION) {
vcc_RTimeVal(tl, &d);
ERRCHK(tl);
e1 = vcc_mk_expr(DURATION, "%g", d);
} else if (fmt == BYTES) {
vcc_ByteVal(tl, &d);
ERRCHK(tl);
e1 = vcc_mk_expr(BYTES, "%.1f", d);
ERRCHK(tl);
} else if (fmt == REAL) {
e1 = vcc_mk_expr(REAL, "%g", vcc_DoubleVal(tl));
ERRCHK(tl);
} else {
e1 = vcc_mk_expr(INT, "%.*s", PF(tl->t));
vcc_NextToken(tl);
}
e1->constant = 1;
*e = e1;
break;
default:
vsb_printf(tl->sb, "Unknown token ");
vcc_ErrToken(tl, tl->t);
vsb_printf(tl->sb, " when looking for %s\n\n", vcc_Type(fmt));
vcc_ErrWhere(tl, tl->t);
break;
}
}
